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 <