[Ace] Свое управление

#============================================================================== # ** Input #------------------------------------------------------------------------------- # Created By Cidiomar R. Dias Junior # Originally posted at # # Terms of Use: Credit "Cidiomar R. Dias Junior" # # Maintained on Hime Works #------------------------------------------------------------------------------- # ** Description # # A module that handles input data from a gamepad or keyboard. # Managed by symbols rather than button numbers in RGSS3. #------------------------------------------------------------------------------- # ** Usage # # Scroll down to the configuration section. It is around line 185. # You can set up your key mappings there. Use the reference to get the names # of the keys. # #=============================================================================== module Input #=============================================================================== # Reference # # Use this to determine which keys are available for mapping #=============================================================================== #-------------------------------------------------------------------------- # * Keymap in symbols # To get a key from the keymap, you can use Input.key(sym) or Input:KEYMAP[sym] # Or if you want to use a symbol in a input function, just pass the symbol # as argument. #-------------------------------------------------------------------------- KEYMAP = { LBUTTON: 0x01, RBUTTON: 0x02, CANCEL: 0x03, MBUTTON: 0x04, XBUTTON1: 0x05, XBUTTON2: 0x06, BACK: 0x08, TAB: 0x09, CLEAR: 0x0c, RETURN: 0x0d, SHIFT: 0x10, CONTROL: 0x11, MENU: 0x12, PAUSE: 0x13, CAPITAL: 0x14, KANA: 0x15, KANA: 0x15, KANA: 0x15, JUNJA: 0x17, FINAL: 0x18, HANJA: 0x19, HANJA: 0x19, ESCAPE: 0x1b, CONVERT: 0x1c, NONCONVERT: 0x1d, ACCEPT: 0x1e, MODECHANGE: 0x1f, SPACE: 0x20, PRIOR: 0x21, NEXT: 0x22, END: 0x23, HOME: 0x24, LEFT: 0x25, UP: 0x26, RIGHT: 0x27, DOWN: 0x28, SELECT: 0x29, PRINT: 0x2a, EXECUTE: 0x2b, SNAPSHOT: 0x2c, INSERT: 0x2d, DELETE: 0x2e, HELP: 0x2f, N0: 0x30, KEY_1: 0x31, KEY_2: 0x32, KEY_3: 0x33, KEY_4: 0x34, KEY_5: 0x35, KEY_6: 0x36, KEY_7: 0x37, KEY_8: 0x38, KEY_9: 0x39, colon: 0x3a, semicolon: 0x3b, less: 0x3c, equal: 0x3d, greater: 0x3e, question: 0x3f, at: 0x40, LETTER_A: 0x41, LETTER_B: 0x42, LETTER_C: 0x43, LETTER_D: 0x44, LETTER_E: 0x45, LETTER_F: 0x46, LETTER_G: 0x47, LETTER_H: 0x48, LETTER_I: 0x49, LETTER_J: 0x4a, LETTER_K: 0x4b, LETTER_L: 0x4c, LETTER_M: 0x4d, LETTER_N: 0x4e, LETTER_O: 0x4f, LETTER_P: 0x50, LETTER_Q: 0x51, LETTER_R: 0x52, LETTER_S: 0x53, LETTER_T: 0x54, LETTER_U: 0x55, LETTER_V: 0x56, LETTER_W: 0x57, LETTER_X: 0x58, LETTER_Y: 0x59, LETTER_Z: 0x5a, LWIN: 0x5b, RWIN: 0x5c, APPS: 0x5d, asciicircum: 0x5e, SLEEP: 0x5f, NUMPAD0: 0x60, NUMPAD1: 0x61, NUMPAD2: 0x62, NUMPAD3: 0x63, NUMPAD4: 0x64, NUMPAD5: 0x65, NUMPAD6: 0x66, NUMPAD7: 0x67, NUMPAD8: 0x68, NUMPAD9: 0x69, MULTIPLY: 0x6a, ADD: 0x6b, SEPARATOR: 0x6c, SUBTRACT: 0x6d, DECIMAL: 0x6e, DIVIDE: 0x6f, F1: 0x70, F2: 0x71, F3: 0x72, F4: 0x73, F5: 0x74, F6: 0x75, F7: 0x76, F8: 0x77, F9: 0x78, F10: 0x79, F11: 0x7a, F12: 0x7b, F13: 0x7c, F14: 0x7d, F15: 0x7e, F16: 0x7f, F17: 0x80, F18: 0x81, F19: 0x82, F20: 0x83, F21: 0x84, F22: 0x85, F23: 0x86, F24: 0x87, NUMLOCK: 0x90, SCROLL: 0x91, LSHIFT: 0xa0, RSHIFT: 0xa1, LCONTROL: 0xa2, RCONTROL: 0xa3, LMENU: 0xa4, RMENU: 0xa5, BROWSER_BACK: 0xa6, BROWSER_FORWARD: 0xa7, BROWSER_REFRESH: 0xa8, BROWSER_STOP: 0xa9, BROWSER_SEARCH: 0xaa, BROWSER_FAVORITES: 0xab, BROWSER_HOME: 0xac, VOLUME_MUTE: 0xad, VOLUME_DOWN: 0xae, VOLUME_UP: 0xaf, MEDIA_NEXT_TRACK: 0xb0, MEDIA_PREV_TRACK: 0xb1, MEDIA_STOP: 0xb2, MEDIA_PLAY_PAUSE: 0xb3, LAUNCH_MAIL: 0xb4, LAUNCH_MEDIA_SELECT: 0xb5, LAUNCH_APP1: 0xb6, LAUNCH_APP2: 0xb7, cedilla: 0xb8, onesuperior: 0xb9, masculine: 0xba, guillemotright: 0xbb, onequarter: 0xbc, onehalf: 0xbd, threequarters: 0xbe, questiondown: 0xbf, Agrave: 0xc0, Aacute: 0xc1, Acircumflex: 0xc2, Atilde: 0xc3, Adiaeresis: 0xc4, Aring: 0xc5, AE: 0xc6, Ccedilla: 0xc7, Egrave: 0xc8, Eacute: 0xc9, Ecircumflex: 0xca, Ediaeresis: 0xcb, Igrave: 0xcc, Iacute: 0xcd, Icircumflex: 0xce, Idiaeresis: 0xcf, ETH: 0xd0, Ntilde: 0xd1, Ograve: 0xd2, Oacute: 0xd3, Ocircumflex: 0xd4, Otilde: 0xd5, Odiaeresis: 0xd6, multiply: 0xd7, Oslash: 0xd8, Ugrave: 0xd9, Uacute: 0xda, Ucircumflex: 0xdb, Udiaeresis: 0xdc, Yacute: 0xdd, THORN: 0xde, ssharp: 0xdf, agrave: 0xe0, aacute: 0xe1, acircumflex: 0xe2, atilde: 0xe3, adiaeresis: 0xe4, PROCESSKEY: 0xe5, ae: 0xe6, PACKET: 0xe7, egrave: 0xe8, eacute: 0xe9, ecircumflex: 0xea, ediaeresis: 0xeb, igrave: 0xec, iacute: 0xed, icircumflex: 0xee, idiaeresis: 0xef, eth: 0xf0, ntilde: 0xf1, ograve: 0xf2, oacute: 0xf3, ocircumflex: 0xf4, otilde: 0xf5, ATTN: 0xf6, CRSEL: 0xf7, EXSEL: 0xf8, EREOF: 0xf9, PLAY: 0xfa, ZOOM: 0xfb, NONAME: 0xfc, PA1: 0xfd, thorn: 0xfe, ydiaeresis: 0xff } #=============================================================================== # Configuration #=============================================================================== KEYMAP[:WIN] = [KEYMAP[:LWIN], KEYMAP[:RWIN]] #-------------------------------------------------------------------------- # * Default Keys, you can configure here instead of by pressing F1. #-------------------------------------------------------------------------- UP = [KEYMAP[:UP]] DOWN = [KEYMAP[:DOWN]] LEFT = [KEYMAP[:LEFT]] RIGHT = [KEYMAP[:RIGHT]] A = [KEYMAP[:SHIFT]] B = [KEYMAP[:ESCAPE], KEYMAP[:LETTER_X]] C = [KEYMAP[:RETURN], KEYMAP[:LETTER_Z]] X = [] Y = [] Z = [] L = [KEYMAP[:PRIOR]] R = [KEYMAP[:NEXT]] F5 = [KEYMAP[:F5]] F6 = [KEYMAP[:F6]] F7 = [KEYMAP[:F7]] F8 = [KEYMAP[:F8]] F9 = [KEYMAP[:F9]] SHIFT = [KEYMAP[:SHIFT]] CTRL = [KEYMAP[:CONTROL]] ALT = [KEYMAP[:MENU]] #=============================================================================== # Rest of script #=============================================================================== #-------------------------------------------------------------------------- # * Symbol version of default keys. #-------------------------------------------------------------------------- SYM_KEYS = { :UP => UP, :LEFT => LEFT, :DOWN => DOWN, :RIGHT => RIGHT, :A => A, :B => B, :C => C, :X => X, :Y => Y, :Z => Z, :L => L, :R => R, :F5 => F5, :F6 => F6, :F7 => F7, :F8 => F8, :F9 => F9, :SHIFT => SHIFT, :CTRL => CTRL, :ALT => ALT } #-------------------------------------------------------------------------- # * Key Codes Used in Events Conditional Branchs #-------------------------------------------------------------------------- EventsKeyCodes = { 2 => :DOWN, 4 => :LEFT, 6 => :RIGHT, 8 => :UP, 11 => :A, 12 => :B, 13 => :C, 14 => :X, 15 => :Y, 16 => :Z, 17 => :L, 18 => :R } #-------------------------------------------------------------------------- # * Internal APIs to handle keyboard functions #-------------------------------------------------------------------------- GetKeyboardState = Win32API.new("user32.dll", "GetKeyboardState", "I", "I") MapVirtualKeyEx = Win32API.new("user32.dll", "MapVirtualKeyEx", "IIL", "I") ToUnicodeEx = Win32API.new("user32.dll", "ToUnicodeEx", "LLPPILL", "L") #---------- @language_layout = Win32API.new("user32.dll", "GetKeyboardLayout", "L", "L").call(0) DOWN_STATE_MASK = (0x8 << 0x04) DEAD_KEY_MASK = (0x8 << 0x1C) #----- UNICODE_TO_UTF8 = Encoding::Converter.new(Encoding.list[2], Encoding.list[1]) #-------------------------------------------------------------------------- # * States of keys #-------------------------------------------------------------------------- @state = DL::CPtr.new(DL.malloc(256), 256) @triggered = Array.new(256, false) @pressed = Array.new(256, false) @released = Array.new(256, false) @repeated = Array.new(256, 0) #-------------------------------------------------------------------------- # * Singleton attrs of states #-------------------------------------------------------------------------- class << self attr_reader :triggered, :pressed, :released, :repeated, :state end #-------------------------------------------------------------------------- # * Get a key code by simbol #-------------------------------------------------------------------------- def self.key(sym) KEYMAP[sym] || 0 end #-------------------------------------------------------------------------- # * Updates input data. # As a general rule, this method is called once per frame. #-------------------------------------------------------------------------- def self.update GetKeyboardState.call(@state.to_i) 0.upto(255) do |key| if @state[key] & DOWN_STATE_MASK == DOWN_STATE_MASK @released[key] = false @pressed[key] = true if (@triggered[key] = !@pressed[key]) @repeated[key] < 17 ? @repeated[key] += 1 : @repeated[key] = 15 elsif !@released[key] and @pressed[key] @triggered[key] = false @pressed[key] = false @repeated[key] = 0 @released[key] = true else @released[key] = false end end end #-------------------------------------------------------------------------- # * Checks the status of the directional buttons, translates the data into # a specialized 4-direction input format, and returns the number pad # equivalent (2, 4, 6, 8). # # If no directional buttons are being pressed (or the equivalent), returns 0. #-------------------------------------------------------------------------- def self.dir4 return 2 if self.press?(DOWN) return 4 if self.press?(LEFT) return 6 if self.press?(RIGHT) return 8 if self.press?(UP) return 0 end #-------------------------------------------------------------------------- # * Checks the status of the directional buttons, translates the data into # a specialized 8-direction input format, and returns the number pad # equivalent (1, 2, 3, 4, 6, 7, 8, 9). # #If no directional buttons are being pressed (or the equivalent), returns 0. #-------------------------------------------------------------------------- def self.dir8 down = self.press?(DOWN) left = self.press?(LEFT) return 1 if down and left right = self.press?(RIGHT) return 3 if down and right up = self.press?(UP) return 7 if up and left return 9 if up and right return 2 if down return 4 if left return 6 if right return 8 if up return 0 end #-------------------------------------------------------------------------- # * Determines whether the button corresponding to the symbol sym is # currently being pressed. # # If the button is being pressed, returns TRUE. If not, returns FALSE. # # if Input.press?(:C) # do_something # end #-------------------------------------------------------------------------- def self.press?(keys) if keys.is_a?(Numeric) k = keys.to_i return (@pressed[k] and !@triggered[k]) elsif keys.is_a?(Array) return keys.any? {|key| self.press?(key) } elsif keys.is_a?(Symbol) if SYM_KEYS.key?(keys) return SYM_KEYS[keys].any? {|key| (@pressed[key] and !@triggered[key]) } elsif (KEYMAP.key?(keys)) k = KEYMAP[keys] return (@pressed[k] and !@triggered[k]) else return false end end end #-------------------------------------------------------------------------- # * Determines whether the button corresponding to the symbol sym is # currently being pressed again. # "Pressed again" is seen as time having passed between the button being # not pressed and being pressed. # # If the button is being pressed, returns TRUE. If not, returns FALSE. #-------------------------------------------------------------------------- def self.trigger?(keys) if keys.is_a?(Numeric) return @triggered[keys.to_i] elsif keys.is_a?(Array) return keys.any? {|key| @triggered[key]} elsif keys.is_a?(Symbol) if SYM_KEYS.key?(keys) return SYM_KEYS[keys].any? {|key| @triggered[key]} elsif KEYMAP.key?(keys) return @triggered[KEYMAP[keys]] else return false end end end #-------------------------------------------------------------------------- # * Determines whether the button corresponding to the symbol sym is # currently being pressed again. # Unlike trigger?, takes into account the repeated input of a button being # held down continuously. # # If the button is being pressed, returns TRUE. If not, returns FALSE. #-------------------------------------------------------------------------- def self.repeat?(keys) if keys.is_a?(Numeric) key = keys.to_i return @repeated[key] == 1 || @repeated[key] == 16 elsif keys.is_a?(Array) return keys.any? {|key| @repeated[key] == 1 || @repeated[key] == 16} elsif keys.is_a?(Symbol) if SYM_KEYS.key?(keys) return SYM_KEYS[keys].any? {|key| @repeated[key] == 1 || @repeated[key] == 16} elsif KEYMAP.key?(keys) return @repeated[KEYMAP[keys]] == 1 || @repeated[KEYMAP[keys]] == 16 else return false end end end #-------------------------------------------------------------------------- # * Determines whether the button corresponding to the symbol sym # was released. # # If the button was released, returns TRUE. If not, returns FALSE. #-------------------------------------------------------------------------- def self.release?(keys) if keys.is_a?(Numeric) return @released[keys.to_i] elsif keys.is_a?(Array) return keys.any? {|key| @released[key]} elsif keys.is_a?(Symbol) if SYM_KEYS.key?(keys) return SYM_KEYS[keys].any? {|key| @released[key]} elsif KEYMAP.key?(keys) return @released[KEYMAP[keys]] else return false end end end #-------------------------------------------------------------------------- # * Gets the character that correspond to vk using the keyboard layout #-------------------------------------------------------------------------- def self.get_character(vk) c = MapVirtualKeyEx.call(vk, 2, @language_layout) return "" if c < 32 && (c & DEAD_KEY_MASK != DEAD_KEY_MASK) result = "\0" * 2 length = ToUnicodeEx.call(vk, MapVirtualKeyEx.call(vk, 0, @language_layout), @state, result, 2, 0, @language_layout) return (length == 0 ? "" : result) end #-------------------------------------------------------------------------- # * Accents Table, to bo used in conversion from ASCII to UTF8 #-------------------------------------------------------------------------- AccentsCharsConv = { "A" => ["A", "A", "A", "A", "A"], "E" => ["E", "E", "E", 0, "E"], "I" => ["I", "I", "I", 0, "I"], "O" => ["O", "O", "O", "O", "O"], "U" => ["U", "U", "U", 0, "U"], "C" => [ 0 , "C", 0 , 0, 0 ], "N" => [ 0 , 0, 0 , "N", 0 ], "Y" => [ 0 , "Y", 0 , 0, "?"], "a" => ["a", "a", "a", "a", "a"], "e" => ["e", "e", "e", 0 , "e"], "i" => ["i", "i", "i", 0 , "i"], "o" => ["o", "o", "o", "o", "o"], "u" => ["u", "u", "u", 0 , "u"], "c" => [ 0 , "c", 0 , 0 , 0 ], "n" => [ 0 , 0 , 0 , "n", 0 ], "y" => [ 0 , "y", 0 , 0 , "y"], } # Letters that can have accent PssbLetters = "AEIOUCNYaeioucny" # Accents, in ASCII, configured at runtime to avoid encoding troubles Accents = [96.chr, 180.chr, 94.chr, 126.chr, 168.chr].join NonCompatChars = [180, 168] @last_accent = nil #-------------------------------------------------------------------------- # * Get inputed string transcoded to UTF8 #-------------------------------------------------------------------------- def self.UTF8String result = "" 31.upto(255) {|key| if self.repeat?(key) c = self.get_character(key) if (cc = c.unpack("C")[0]) and NonCompatChars.include?(cc) result += cc.chr else result += UNICODE_TO_UTF8.convertc if c != "" end end } return "" if result == "" if @last_accent result = @last_accent + result @last_accent = nil end f_result = "" jump = false for i in 0 ... result.length c = result[i] if jump jump = false next end if Accents.include?c if (nc = result[i+1]) != nil if PssbLetters.include?(nc) if (ac = AccentsCharsConv[nc][Accents.indexc]) != 0 f_result << ac jump = true else f_result << c f_result << nc jump = true end elsif Accents.include?(nc) f_result << c f_result << nc jump = true else f_result << c f_result << nc jump = true end else @last_accent = c end else f_result << c end end return f_result end end