615 lines
19 KiB
Ruby
615 lines
19 KiB
Ruby
unless defined?(Ruby310Compat)
|
||
begin
|
||
compat_candidates = []
|
||
begin
|
||
compat_candidates << File.expand_path('000_Ruby310_Compat.rb', File.dirname(__FILE__))
|
||
rescue StandardError
|
||
end
|
||
begin
|
||
cwd = Dir.pwd.to_s
|
||
compat_candidates << File.expand_path('Data/Scripts/000_Ruby310_Compat.rb', cwd) unless cwd.empty?
|
||
compat_candidates << File.expand_path('000_Ruby310_Compat.rb', cwd) unless cwd.empty?
|
||
rescue StandardError
|
||
end
|
||
compat_candidates.compact.uniq.each do |compat_path|
|
||
next unless File.file?(compat_path)
|
||
load compat_path
|
||
break if defined?(Ruby310Compat)
|
||
end
|
||
rescue StandardError
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# Gamepad Extender v1.1 (2/20/15)
|
||
# by Lone Wolf
|
||
#------------------------------------------------------------------------------
|
||
# This allows scripters to utilize the extra buttons on modern
|
||
# XInput-compatible gamepads. It requires DirectX 9.0 or later and
|
||
# an XInput compatible gamepad. Incompatible pads will default to
|
||
# using the standard Input module functionality.
|
||
#
|
||
# This is not a plug-and-play script.
|
||
# Some knowledge of RGSS is required for proper use.
|
||
#
|
||
# Instructions:
|
||
# 1) Paste in the Materials section
|
||
# 2) Replace button calls in (other) scripts to use gamepad buttons as needed
|
||
# (see Command Reference below)
|
||
# Optional:
|
||
# 2) Use the PadConfig section to specify button differences between
|
||
# Gamepad and Keyboard (for players without gamepads)
|
||
# 3) Replace direct button calls in your scripts (and the defaults) with
|
||
# PadConfig calls or these will do nothing
|
||
# (see Command Reference below)
|
||
#------------------------------------------------------------------------------
|
||
# Command Reference:
|
||
#------------------------------------------------------------------------------
|
||
# All calls to extended buttons on Pad 1 can be made through the Input module.
|
||
# When using multiple pads, send calls to WolfPad with pad number (0...3)
|
||
# as the final parameter. (i.e. WolfPad.press?(:A, 3) )
|
||
#
|
||
# The current list of mappable buttons is as follows:
|
||
#
|
||
# :A, :B, :X, :Y - XBOX 360 standard face buttons.
|
||
# :L1, :L2, :R1, :R2 - Four triggers (LB, LT, RB, RT)
|
||
# :SELECT, :START - Back and Start buttons
|
||
# :L3, :R3 - Clickable Analog buttons
|
||
#
|
||
# :UP, :DOWN,
|
||
# :LEFT, :RIGHT - D-Pad buttons
|
||
#
|
||
# :L_UP, :L_DOWN
|
||
# :L_LEFT, :L_RIGHT - Left stick directions
|
||
#
|
||
# :R_UP, :R_DOWN
|
||
# :R_LEFT, :R_RIGHT - Right stick directions
|
||
#
|
||
# NON-STANDARD MAPPINGS WILL DO NOTHING without a compatible gamepad.
|
||
# To that end, use calls to PadConfig to remap non-standard keys into
|
||
# the standard domain where possible.
|
||
#
|
||
# for example: Input.trigger?(PadConfig.page_down)
|
||
# will return :R1 if a gamepad is plugged in, but :R otherwise
|
||
#
|
||
# Analog values can be referenced with the following commands:
|
||
# left_stick
|
||
# right_stick
|
||
# left_trigger
|
||
# right_trigger
|
||
#
|
||
# Directional values of analog sticks can be referenced with these:
|
||
# lstick4
|
||
# lstick8
|
||
# rstick4
|
||
# rstick8
|
||
#
|
||
# Controller vibration can be accessed with these:
|
||
# vibrate(left_motor, right_motor, frame_duration)
|
||
# set_motors(left_motor, right_motor)
|
||
#
|
||
# All functions take an optional gamepad id (0-3) as their final parameter.
|
||
#
|
||
#------------------------------------------------------------------------------
|
||
# Terms of Use:
|
||
|
||
#------------------------------------------------------------------------------
|
||
# If you use it, give credit. With a few caveats:
|
||
#
|
||
# Can't call it alpha nay more, but I consider this script in-development.
|
||
# I make no guarantees of compatibility with other scripts.
|
||
#
|
||
# Contact me via PM is you plan on using this in a commercial game.
|
||
# I probably won't charge anything, but I will want to know it's out there.
|
||
#
|
||
# This script was posted at the official RPG Maker forums.
|
||
# Do modify or redistribute this script by itself, though you may
|
||
# include a configured version with your own script demos provided
|
||
# you inclide this header in its entirety.
|
||
#------------------------------------------------------------------------------
|
||
# Contact Info:
|
||
#------------------------------------------------------------------------------
|
||
# I can be reached via PM only at the RPG Maker Web forums.
|
||
# (http://forums.rpgmakerweb.com)
|
||
#
|
||
# PM'ing the user Lone Wolf at other RPG Maker sites may have...
|
||
# unpredicatable results. I made someone really happy the day I registered...
|
||
#------------------------------------------------------------------------------
|
||
# Credits:
|
||
# Lone Wolf (99% of the code)
|
||
# raulf17 (directional movement bug fix; now obsolete)
|
||
#------------------------------------------------------------------------------
|
||
# 翻訳したいんですか?いいんだが、まだ未完成です。
|
||
#==============================================================================
|
||
module PadConfig
|
||
# Basic configuration settings:
|
||
# static:
|
||
CONTROLLERS = 1 # can be any number from 1-4, higher values may cause errors
|
||
|
||
# can be redefined by other scripts and changed in-game:
|
||
def self.deadzone # Deadzone for axis input (%), may require adjusting
|
||
0.7
|
||
end
|
||
def self.move_with_stick # Use left-analog stick with dir4 and dir8
|
||
false
|
||
end
|
||
def self.enable_vibration # Enable force-feedback
|
||
false
|
||
end
|
||
|
||
# Use this section to write flexible button-mappings for your scripts.
|
||
# Add additional methods as needed.
|
||
# Format:
|
||
# WolfPad.plugged_in? ? (gamepad binding) : (fallback binding)
|
||
#def self.confirm
|
||
# WolfPad.plugged_in? ? :A : :C
|
||
#end
|
||
#def self.cancel
|
||
# WolfPad.plugged_in? ? :B : :B
|
||
#end
|
||
#def self.dash
|
||
# WolfPad.plugged_in? ? :X : :A
|
||
#end
|
||
#def self.menu
|
||
# WolfPad.plugged_in? ? :Y : :B
|
||
#end
|
||
#def self.page_up
|
||
# WolfPad.plugged_in? ? :L1 : :L
|
||
#end
|
||
#def self.page_down
|
||
# WolfPad.plugged_in? ? :R1 : :R
|
||
#end
|
||
#def self.debug
|
||
# WolfPad.plugged_in? ? :L2 : :CTRL
|
||
#end
|
||
#def self.debug2
|
||
# WolfPad.plugged_in? ? :R3 : :F9
|
||
#end
|
||
end
|
||
# Main module:
|
||
module WolfPad
|
||
def self.update
|
||
for pad_index in 0...PadConfig::CONTROLLERS
|
||
input = get_state(pad_index)
|
||
if @packet[pad_index] == input[0]
|
||
set_holds(pad_index)
|
||
next
|
||
end
|
||
@packet[pad_index] = input[0]
|
||
@buttons[pad_index] = (input[1] | 0x10000).to_s(2)
|
||
@triggers[pad_index] = [input[2], input[3]]
|
||
@lstick[pad_index] = [constrain_axis(input[4]), -constrain_axis(input[5])]
|
||
@rstick[pad_index] = [constrain_axis(input[6]), -constrain_axis(input[7])]
|
||
set_holds(pad_index)
|
||
end
|
||
update_vibration
|
||
# Extra readout functions go here.
|
||
#dircheck
|
||
end
|
||
|
||
def self.press_any_key?(pad_index = 0)
|
||
return false unless plugged_in?(pad_index)
|
||
|
||
# 任一 hold > 0 就算
|
||
26.times do |i|
|
||
return true if @holds[pad_index, i] > 0
|
||
end
|
||
false
|
||
end
|
||
|
||
def self.trigger_any_key?(pad_index = 0)
|
||
return false unless plugged_in?(pad_index)
|
||
|
||
# 任一 hold == 1(剛按下)
|
||
26.times do |i|
|
||
return true if @holds[pad_index, i] == 1
|
||
end
|
||
false
|
||
end
|
||
def self.test # Prints no. of detected controllers (debugging use only)
|
||
detected = 0
|
||
for i in 0...PadConfig::CONTROLLERS
|
||
self.update
|
||
detected += plugged_in?(i) ? 1 : 0
|
||
end
|
||
puts sprintf("%d XInput controller(s) in use.", detected)
|
||
end
|
||
def self.readout # prints a range from the holds table (debugging use only)
|
||
for i in 00...16
|
||
print sprintf(" %d", @holds[0, i])
|
||
print sprintf(" %d", @holds[1, i])
|
||
end
|
||
puts ";"
|
||
end
|
||
def self.dircheck
|
||
for i in 0...PadConfig::CONTROLLERS
|
||
print sprintf(" %d", key_holds(:UP, i))
|
||
print sprintf(" %d", key_holds(:LEFT, i))
|
||
print sprintf(" %d", key_holds(:DOWN, i))
|
||
print sprintf(" %d", key_holds(:RIGHT, i))
|
||
print " : "
|
||
end
|
||
puts ";"
|
||
end
|
||
# Basic vibration call.
|
||
# For simplicity, motor values should be floats from 0.0 to 1.0
|
||
def self.vibrate(left, right, duration, pad_index = 0)
|
||
return unless PadConfig.enable_vibration
|
||
set_motors(left, right, pad_index)
|
||
@vibrations[pad_index] = duration
|
||
end
|
||
# Counts down vibration event timers
|
||
def self.update_vibration
|
||
for pad in 0...PadConfig::CONTROLLERS
|
||
next if @vibrations[pad] == -1
|
||
@vibrations[pad] -= 1
|
||
if @vibrations[pad] == 0
|
||
@vibrations[pad] = -1
|
||
set_motors(0, 0, pad)
|
||
end
|
||
end
|
||
end
|
||
# Set left and right motor speeds. Vibration continues until stopped.
|
||
# Repeated calls with different values can create vibration effects.
|
||
# For simplicity, input values should be floats from 0.0 to 1.0
|
||
def self.set_motors(left, right, pad_index = 0)
|
||
return unless (PadConfig.enable_vibration) || (left == 0 && right == 0)
|
||
left_v = [left * 65535, 65535].min
|
||
right_v = [right * 65535, 65535].min
|
||
vibration = [left_v, right_v].pack("SS")
|
||
@set_state.call(pad_index, vibration)
|
||
end
|
||
def self.press?(button, pad_index = 0)
|
||
key_holds(button, pad_index) > 0
|
||
end
|
||
def self.trigger?(button, pad_index = 0)
|
||
key_holds(button, pad_index) == 1
|
||
end
|
||
def self.repeat?(button, p_i = 0)
|
||
return true if key_holds(button, p_i) == 1
|
||
return true if key_holds(button, p_i) > 30 && key_holds(button, p_i) % 5 == 0
|
||
end
|
||
# Returns left stick as a pair of floats [x, y] between -1.0 and 1.0
|
||
def self.left_stick(pad_index = 0)
|
||
@lstick[pad_index]
|
||
end
|
||
# Returns right stick as a pair of floats [x, y] between -1.0 and 1.0
|
||
def self.right_stick(pad_index = 0)
|
||
@rstick[pad_index]
|
||
end
|
||
# Returns left trigger as float between 0.0 to 1.0
|
||
def self.left_trigger(pad_index = 0)
|
||
@triggers[pad_index][0] / 255.0
|
||
end
|
||
# Returns right trigger as float between 0.0 to 1.0
|
||
def self.right_trigger(pad_index = 0)
|
||
@triggers[pad_index][1] / 255.0
|
||
end
|
||
def self.dir4(p_i = 0)
|
||
return lstick4(p_i) if PadConfig.move_with_stick
|
||
if press?(:UP, p_i)
|
||
8
|
||
elsif press?(:RIGHT, p_i)
|
||
6
|
||
elsif press?(:LEFT, p_i)
|
||
4
|
||
elsif press?(:DOWN, p_i)
|
||
2
|
||
else
|
||
0
|
||
end
|
||
end
|
||
def self.dir8(p_i = 0)
|
||
return lstick8(p_i) if PadConfig.move_with_stick
|
||
if press?(:UP, p_i) and press?(:LEFT, p_i)
|
||
7
|
||
elsif press?(:UP, p_i) and press?(:RIGHT, p_i)
|
||
9
|
||
elsif press?(:DOWN, p_i) and press?(:LEFT, p_i)
|
||
1
|
||
elsif press?(:DOWN, p_i) and press?(:RIGHT, p_i)
|
||
3
|
||
else
|
||
dir4(p_i)
|
||
end
|
||
end
|
||
# Left-stick direction
|
||
def self.lstick8(p_i = 0)
|
||
flags_to_dir8(key_holds(:L_RIGHT, p_i),key_holds(:L_LEFT, p_i),
|
||
key_holds(:L_DOWN, p_i),key_holds(:L_UP, p_i))
|
||
end
|
||
def self.lstick4(p_i = 0)
|
||
flags_to_dir4(key_holds(:L_RIGHT, p_i),key_holds(:L_LEFT, p_i),
|
||
key_holds(:L_DOWN, p_i),key_holds(:L_UP, p_i))
|
||
end
|
||
# Right-stick direction
|
||
def self.rstick8(p_i = 0)
|
||
flags_to_dir8(key_holds(:R_RIGHT, p_i),key_holds(:R_LEFT, p_i),
|
||
key_holds(:R_DOWN, p_i),key_holds(:R_UP, p_i))
|
||
end
|
||
def self.rstick4(p_i = 0)
|
||
flags_to_dir4(key_holds(:R_RIGHT, p_i),key_holds(:R_LEFT, p_i),
|
||
key_holds(:R_DOWN, p_i),key_holds(:R_UP, p_i))
|
||
end
|
||
def self.plugged_in?(pad_index = 0)
|
||
@packet[pad_index] && @packet[pad_index] > 0
|
||
end
|
||
def self.keyboard_key?(button)
|
||
!@keys.has_key?(button)
|
||
end
|
||
|
||
#Helper functions:
|
||
# convert signed half-word axis state to float
|
||
def self.constrain_axis(axis)
|
||
val = axis.to_f / 2**15
|
||
val.abs > PadConfig.deadzone ? val : 0
|
||
end
|
||
|
||
# derives a dir8 value from directional hold values
|
||
def self.flags_to_dir8(right, left, down, up)
|
||
x = right == left ? 0 : (right > left ? 1 : 2)
|
||
y = down == up ? 0 : (down > up ? 1 : 2)
|
||
table = [[0, 2, 8],
|
||
[ 6, 3, 9],
|
||
[ 4, 1, 7]]
|
||
return table[x][y]
|
||
end
|
||
# derives a dir4 value from directional hold values
|
||
def self.flags_to_dir4(right, left, down, up)
|
||
selection = [right, left, down, up].max
|
||
table = [0,0,down,0,left,0,right,0,up]
|
||
return table.index(selection)
|
||
end
|
||
|
||
# calculates the precise geometric angle from stick axis values [x,y]
|
||
def self.axis_to_angle(axis)
|
||
cy = -axis[1]
|
||
cx = -axis[0]
|
||
return -1 if cy == 0 && cx == 0
|
||
angle = Math.atan2(cx, cy) * 180 / Math::PI
|
||
angle = angle < 0 ? angle + 360 : angle
|
||
return angle
|
||
end
|
||
|
||
# Original angle-conversion handlers for analog sticks
|
||
# OBSOLETE: preserved for reference only
|
||
def self.axis_to_dir8(axis)
|
||
angle_to_dir8(axis_to_angle(axis))
|
||
end
|
||
def self.axis_to_dir4(axis)
|
||
angle_to_dir4(axis_to_angle(axis))
|
||
end
|
||
|
||
def self.angle_to_dir8(angle)
|
||
return 0 if angle == -1
|
||
d = 0
|
||
if angle < 22.5 || angle >= 337.5
|
||
d = 8
|
||
elsif angle < 67.5
|
||
d = 7
|
||
elsif angle < 112.5
|
||
d = 4
|
||
elsif angle < 157.5
|
||
d = 1
|
||
elsif angle < 202.5
|
||
d = 2
|
||
elsif angle < 247.5
|
||
d = 3
|
||
elsif angle < 292.5
|
||
d = 6
|
||
elsif angle < 337.5
|
||
d = 9
|
||
end
|
||
return d
|
||
end
|
||
def self.angle_to_dir4(angle)
|
||
return 0 if angle == -1
|
||
d = 0
|
||
if angle < 45 || angle >= 315
|
||
d = 8
|
||
elsif angle < 135
|
||
d = 4
|
||
elsif angle < 225
|
||
d = 2
|
||
elsif angle < 315
|
||
d = 6
|
||
end
|
||
return d
|
||
end
|
||
|
||
|
||
private # methods past here can't be called from outside
|
||
# This hash correlates RM's Input to XInput keys. Experienced Users only!
|
||
# The Input module will handle any keys not listed here (i.e. :CTRL) itself.
|
||
# Integers refer to specific gamepad button IDs.
|
||
#@keys = {
|
||
# #based on Xbox one pad
|
||
# :LETTER_S => 0, #Y
|
||
# :LETTER_A => 1, #X
|
||
# :LETTER_D => 2, #B
|
||
# :LETTER_F => 3, #A
|
||
# :SPACE => 6, #upper right trigger
|
||
# :CTRL => 7, #upper left trigger
|
||
# #:R3 => 8, #right thubstick button
|
||
# #:L3 => 9, #left thubstick button
|
||
# :B => 10, #Back <
|
||
# :C => 11, #start >
|
||
# :RIGHT => 12, #d-pad RIGHT
|
||
# :LEFT => 13, #d-pad LEFT
|
||
# :DOWN => 14, #d-pad DOWN
|
||
# :UP => 15, #d-pad UP
|
||
# :ALT => 16, #lower left trigger (press only) LT
|
||
# :SHIFT => 17, #lower right trigger (press only) RT
|
||
# :NUMPAD6 => 18, #left mushroom L_RIGHT
|
||
# :NUMPAD4 => 19, #left mushroom L_LEFT
|
||
# :NUMPAD2 => 20, #left mushroom L_DOWN
|
||
# :NUMPAD8 => 21, #left mushroom L_UP
|
||
# :LETTER_W => 22, #right mushroom R_RIGHT
|
||
# :LETTER_E => 23, #right mushroom R_LEFT
|
||
# :LETTER_Q => 24, #right mushroom R_DOWN
|
||
# :LETTER_R => 25 #right mushroom R_UP
|
||
#}
|
||
@keys_text=[ "Y", #0
|
||
"X", #1
|
||
"B", #2
|
||
"A", #3
|
||
"", #4
|
||
"", #5
|
||
"RB", #6
|
||
"LB", #7
|
||
"RSB", #8
|
||
"LSB", #9
|
||
"Back", #10
|
||
"Start", #11
|
||
"DP_R", #12
|
||
"DP_L", #13
|
||
"DP_D", #14
|
||
"DP_U", #15
|
||
"LT", #16
|
||
"RT", #17
|
||
"LS_R", #18
|
||
"LS_L", #19
|
||
"LS_D", #20
|
||
"LS_U", #21
|
||
"RS_R", #22
|
||
"RS_L", #23
|
||
"RS_D", #24
|
||
"RS_U" #25
|
||
]
|
||
@keys = {
|
||
#based on Xbox one pad
|
||
:S1 => 3, #A
|
||
:S2 => 2, #B
|
||
:S3 => 1, #X
|
||
:S4 => 0, #Y
|
||
:X_LINK => 2, #B
|
||
:Z_LINK => 3, #A
|
||
:S9 => 6, #upper right trigger
|
||
:CTRL => 7, #upper left trigger
|
||
:R3 => 8, #right thubstick button
|
||
:L3 => 9, #left thubstick button
|
||
:B => 10, #Back <
|
||
:C => 11, #start >
|
||
:RIGHT => 12, #d-pad RIGHT
|
||
:LEFT => 13, #d-pad LEFT
|
||
:DOWN => 14, #d-pad DOWN
|
||
:UP => 15, #d-pad UP
|
||
:ALT => 16, #lower left trigger (press only) LT
|
||
:SHIFT => 17, #lower right trigger (press only) RT
|
||
:D6 => 18, #left mushroom L_RIGHT
|
||
:D4 => 19, #left mushroom L_LEFT
|
||
:D2 => 20, #left mushroom L_DOWN
|
||
:D8 => 21, #left mushroom L_UP
|
||
:S6 => 22, #right mushroom R_RIGHT
|
||
:S7 => 23, #right mushroom R_LEFT
|
||
:S5 => 24, #right mushroom R_DOWN
|
||
:S8 => 25 #right mushroom R_UP
|
||
}
|
||
@keys.each do |ev|
|
||
tmpTar = DataManager.get_constant(tmpFolder="GamePad",tmpName=ev[0].to_s,tmpBuffer=3)
|
||
tmpKeyTar = eval(":#{ev[0].to_s}")
|
||
@keys[tmpKeyTar] = tmpTar
|
||
#p "#{ev[0]} => #{ev[1]} tar = #{tmpTar} result => #{@keys[tmpKeyTar]}"
|
||
end
|
||
#Win32API calls. Leave these alone.
|
||
# Calls to XInput9_1_0.dll now only occur if DirectX is missing
|
||
@set_state = Ruby310Compat.native_api("XINPUT1_3", "XInputSetState", "IP", "V") rescue
|
||
Ruby310Compat.native_api("XINPUT9_1_0", "XInputSetState", "IP", "V")
|
||
@get_state = Ruby310Compat.native_api("XINPUT1_3", "XInputGetState", "IP", "L") rescue
|
||
Ruby310Compat.native_api("XINPUT9_1_0", "XInputGetState", "IP", "L")
|
||
#Initializers
|
||
# Will store data for number of gamepads in use.
|
||
@packet = Array.new(PadConfig::CONTROLLERS)
|
||
@buttons = Array.new(PadConfig::CONTROLLERS)
|
||
@triggers = Array.new(PadConfig::CONTROLLERS)
|
||
@lstick = Array.new(PadConfig::CONTROLLERS)
|
||
@rstick = Array.new(PadConfig::CONTROLLERS)
|
||
# tracks how long buttons have been pressed
|
||
@holds = Table.new(PadConfig::CONTROLLERS, 26)
|
||
# stores vibration event timers
|
||
@vibrations = Array.new(PadConfig::CONTROLLERS, -1)
|
||
def self.key_holds(symbol, pad_index)
|
||
return 0 if keyboard_key?(symbol)
|
||
@holds[pad_index, @keys[symbol]]
|
||
end
|
||
def self.get_state(pad_index)
|
||
state = "\0" * 16
|
||
@get_state.call(pad_index, state)
|
||
return state.unpack("LSCCssss")
|
||
end
|
||
def self.set_holds(p_i)
|
||
for i in 1...17
|
||
@holds[p_i, i-1] = @buttons[p_i][i].to_i > 0 ? @holds[p_i, i-1] + 1 : 0
|
||
end
|
||
@holds[p_i, 16] = left_trigger(p_i) >= 0.5 ? @holds[p_i, 16]+1 : 0
|
||
@holds[p_i, 17] = right_trigger(p_i) >= 0.5 ? @holds[p_i, 17]+1 : 0
|
||
@holds[p_i, 18] = left_stick(p_i)[0] >= 0.5 ? @holds[p_i, 18]+1 : 0
|
||
@holds[p_i, 19] = left_stick(p_i)[0] <= -0.5 ? @holds[p_i, 19]+1 : 0
|
||
@holds[p_i, 20] = left_stick(p_i)[1] >= 0.5 ? @holds[p_i, 20]+1 : 0
|
||
@holds[p_i, 21] = left_stick(p_i)[1] <= -0.5 ? @holds[p_i, 21]+1 : 0
|
||
@holds[p_i, 22] = right_stick(p_i)[0] >= 0.5 ? @holds[p_i, 22]+1 : 0
|
||
@holds[p_i, 23] = right_stick(p_i)[0] <= -0.5 ? @holds[p_i, 23]+1 : 0
|
||
@holds[p_i, 24] = right_stick(p_i)[1] >= 0.5 ? @holds[p_i, 24]+1 : 0
|
||
@holds[p_i, 25] = right_stick(p_i)[1] <= -0.5 ? @holds[p_i, 25]+1 : 0
|
||
end
|
||
end
|
||
# Aliases to tie the above into VXAce's Input module
|
||
module Input
|
||
class <<self
|
||
alias :vxa_update :update
|
||
alias :vxa_press? :press?
|
||
alias :vxa_trigger? :trigger?
|
||
alias :vxa_repeat? :repeat?
|
||
alias :vxa_dir4 :dir4
|
||
alias :vxa_dir8 :dir8
|
||
end
|
||
def self.update
|
||
WolfPad.update
|
||
vxa_update
|
||
end
|
||
def self.press?(button)
|
||
if WolfPad.keyboard_key?(button)
|
||
vxa_press?(button)
|
||
elsif WolfPad.press?(button)
|
||
WolfPad.press?(button)
|
||
else
|
||
vxa_press?(button)
|
||
end
|
||
#return vxa_press?(button) if WolfPad.keyboard_key?(button)
|
||
#return WolfPad.press?(button) if WolfPad.plugged_in?
|
||
#return vxa_press?(button)
|
||
end
|
||
|
||
def self.trigger?(button)
|
||
if WolfPad.keyboard_key?(button)
|
||
vxa_trigger?(button)
|
||
elsif WolfPad.trigger?(button)
|
||
WolfPad.trigger?(button)
|
||
else
|
||
vxa_trigger?(button)
|
||
end
|
||
#return vxa_trigger?(button) if WolfPad.keyboard_key?(button)
|
||
#return WolfPad.trigger?(button) if WolfPad.plugged_in?
|
||
#return vxa_trigger?(button)
|
||
end
|
||
|
||
def self.repeat?(button)
|
||
if WolfPad.keyboard_key?(button)
|
||
vxa_repeat?(button)
|
||
elsif WolfPad.repeat?(button)
|
||
WolfPad.repeat?(button)
|
||
else
|
||
vxa_repeat?(button)
|
||
end
|
||
#return vxa_repeat?(button) if WolfPad.keyboard_key?(button)
|
||
#return WolfPad.repeat?(button) if WolfPad.plugged_in?
|
||
#return vxa_repeat?(button)
|
||
end
|
||
def self.dir4
|
||
[WolfPad.dir4,vxa_dir4].max
|
||
end
|
||
def self.dir8
|
||
[WolfPad.dir8,vxa_dir8].max
|
||
end
|
||
end
|