Тема: WASD управление и 8-Way Direction Movement

Andrew, как в 1-ом скрипте для XP отключить движение в 8 направлениях?

Я могу сейчас этим заняться. Всё ровно делать нечего.

ReDS,

PHP код:

class Game_Player
  #--------------------------------------------------------------------------
  def update
    last_moving = moving?
    unless moving? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      if Keys.press?(Keys::W)
        move_up
      else 
        if Keys.press?(Keys::S)
          move_down
        else 
          if Keys.press?(Keys::D)
            move_right
          else 
            if Keys.press?(Keys::A)
              move_left
            end
          end
        end
      end
    end
    last_real_x = @real_x
    last_real_y = @real_y
    super
    if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
      $game_map.scroll_down(@real_y - last_real_y)
    end
    if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
      $game_map.scroll_left(last_real_x - @real_x)
    end
    if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
      $game_map.scroll_right(@real_x - last_real_x)
    end
    if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
      $game_map.scroll_up(last_real_y - @real_y)
    end
    unless moving?
      if last_moving
        result = check_event_trigger_here([1,2])
        if result == false
          unless $DEBUG and Input.press?(Input::CTRL)
            if @encounter_count > 0
              @encounter_count -= 1
            end
          end
        end
      end
      if Input.trigger?(Input::C)
        check_event_trigger_here([0])
        check_event_trigger_there([0,1,2])
      end
    end
  end
end
#≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
# ** Glitchfinder's Key Input Module              [RPG Maker XP] [RPG Maker VX]
#    Version 1.20
#------------------------------------------------------------------------------
#  This script helps scripters to use the full range of keys on any keyboard,
#  without being limited by the default Input Module.
#==============================================================================
# * Version History
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#   Version 1.00 ------------------------------------------------- (2010-03-18)
#     - Initial version
#     - Author: Glitchfinder
#    Version 1.10 ------------------------------------------------ (2010-08-20)
#      - Added the Keys.toggle? method
#      - Added the Keys.capslock? method
#      - Added the Keys.numlock? method
#      - Added the Keys.scroll? method
#      - Added the Keys.character_press method
#      - Added the Keys.character_trigger method
#      - Added the Keys.character_repeat method
#      - Added the Keys.get_character method
#      - Added the ANYKEY key constant
#      - Streamlined the script
#      - Patched various errors
#      - Author: Glitchfinder
#    Version 1.20 ------------------------------------------------ (2011-03-17)
#      - Added the Keys.array_press? method
#      - Added the Keys.array_trigger? method
#      - Added the Keys.array_repeat? method
#      - Added the Keys.array_release? method
#      - Added the Keys.array_toggle? method
#      - Modified the Keys.press? method for better error hendling
#      - Modified the Keys.trigger? method for better error hendling
#      - Modified the Keys.repeat? method for better error hendling
#      - Modified the Keys.release? method for better error hendling
#      - Modified the Keys.toggle? method for better error hendling
#      - Author: Glitchfinder
#==============================================================================
# * Instructions
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#  Place this script above Main, and below the default scripts. (I realize this
#  is obvious to most, but some people don't get it.)
#
#  This module is automatically updated by the default Input module, which
#  means that the only time you need to call the update method is in a scene
#  that does not update the default Input module.
#
#  This module does not break the functionality of the default Input module.
#
#  If you wish to read keys from a gamepad, you must still use the default
#  input module to do so.
#
#  To use this module, simply use one of the four methods (press?(key),
#  trigger?(key), repeat?(key), or release?(key)), where key is the index of
#  the key you want to check. Key may also be used as Keys::KEYNAME. For a list
#  of acceptable key names, look below the header.
#
#  There is a key named ANYKEY. This key can be used like any other key, with
#  the exception that, instead of corresponding to any one key, it reacts to
#  them all. If you use it, and any other key would cause the same method to
#  return true, then the ANYKEY will also return true.
#==============================================================================
# * Method List
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#  Keys.update
#    Updates keyboard input. Calls to this method are not necessary unless the
#    default Input module is not being updated.
#
#  Keys.press?(key)
#    Determines whether the button determined by key is currently being
#    pressed. If the button is being pressed, returns true. If not, returns
#    false.
#
#  Keys.trigger?(key)
#    Determines whether the button determined by key is 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.
#
#  Keys.repeat?(key)
#    Determines whether the button determined by key is being pressed again.
#    Unlike trigger?(), this takes into account the repeat input of a button
#    being held down continuously. If the button is being pressed, returns
#    true. If not, returns false.
#
#  Keys.release?(key)
#    Determines whether the button determined by key has just been released. If
#    the button has been released, returns true. If not, returns false.
#
#  Keys.toggle?(key)
#    Determines whether the button determined by key has been toggled. This
#    functions like Caps Lock, Number Lock, and Scroll Lock, only for all keys.
#
#  Keys.array_press?(keys)
#    Functions in the same manner as Keys.press?(), only it takes an array of
#    keys as input.
#
#  Keys.array_trigger?(keys)
#    Functions in the same manner as Keys.trigger?(), only it takes an array of
#    keys as input.
#
#  Keys.array_repeat?(keys)
#    Functions in the same manner as Keys.repeat?(), only it takes an array of
#    keys as input.
#
#  Keys.array_release?(keys)
#    Functions in the same manner as Keys.release?(), only it takes an array of
#    keys as input.
#
#  Keys.array_toggle?(keys)
#    Functions in the same manner as Keys.toggle?(), only it takes an array of
#    keys as input.
#
#  Keys.capslock?
#    Determines whether the caps lock key is toggled on. This will always
#    return true when the corresponding keyboard light is lit, and false when
#    it is not.
#
#  Keys.numlock?
#    Determines whether the number lock key is toggled on. This will always
#    return true when the corresponding keyboard light is lit, and false when
#    it is not.
#
#  Keys.scroll?
#    Determines whether the scroll lock key is toggled on. This will always
#    return true when the corresponding keyboard light is lit, and false when
#    it is not.
#
#  Keys.character_press
#    Returns the currently pressed key, if it would generate text input. If no
#    such key would register as pressed, it returns false.
#
#  Keys.character_trigger
#    Returns the currently triggered key, if it would generate text input. If
#    no such key would register as triggered, it returns false.
#
#  Keys.character_repeat
#    Returns the currently repeated key, if it would generate text input. If no
#    such key would register as repeated, it returns false.
#
#  Keys.get_character(key, scan_code)
#    Returns the character forresponding to the given key. If no character
#    is recognized by the system, it returns false instead. This method is
#    intended for internal use.
#==============================================================================
# * Known Issues
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#  This script has trouble with certain foreign language keyboards, where dead
#  keys are shift sensitive. Dead keys are used to insert diacritical marks
#  such as an accent. However, the correct character can be generated with
#  creative use of shift and caps lock.
#==============================================================================
# * Glitchfinder's Advice
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#  This script is meant for people with a medium or advanced level of scripting
#  knowledge and ability, or for those using scripts that require this module.
#==============================================================================
# * Contact
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#  Glitchfinder, the author of this script, may be contacted through his
#  website, found at http://www.glitchkey.com
#
#  You may also find Glitchfinder at http://www.hbgames.org
#==============================================================================
# * Usage
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#  This script may be used with the following terms and conditions:
#
#    1. This script is free to use in any noncommercial project. If you wish to
#       use this script in a commercial (paid) project, please contact
#       Glitchfinder at his website.
#    2. This script may only be hosted at the following domains:
#         http://www.glitchkey.com
#         http://www.hbgames.org
#    3. If you wish to host this script elsewhere, please contact Glitchfinder.
#    4. If you wish to translate this script, please contact Glitchfinder. He
#       will need the web address that you plan to host the script at, as well
#       as the language this script is being translated to.
#    5. This header must remain intact at all times.
#    6. Glitchfinder remains the sole owner of this code. He may modify or
#       revoke this license at any time, for any reason.
#    7. Any code derived from code within this script is owned by Glitchfinder,
#       and you must have his permission to publish, host, or distribute his
#       code.
#    8. This license applies to all code derived from the code within this
#       script.
#    9. If you use this script within your project, you must include visible
#       credit to Glitchfinder, within reason.
#≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
 
#==============================================================================
# ** Keys
#------------------------------------------------------------------------------
#  This module performs key input processing
#==============================================================================
 
module Keys
  #--------------------------------------------------------------------------
  # * Miscellaneous Keys
  #--------------------------------------------------------------------------
  CANCEL              = 0x03 # Control-Break Processing
  BACKSPACE           = 0x08 # Backspace Key
  TAB                 = 0x09 # Tab Key
  CLEAR               = 0x0C # Clear Key
  RETURN              = 0x0D # Enter Key
  SHIFT               = 0x10 # Shift Key
  CONTROL             = 0x11 # Ctrl Key
  MENU                = 0x12 # Alt Key
  PAUSE               = 0x13 # Pause Key
  ESCAPE              = 0x1B # Esc Key
  CONVERT             = 0x1C # IME Convert Key
  NONCONVERT          = 0x1D # IME Nonconvert Key
  ACCEPT              = 0x1E # IME Accept Key
  SPACE               = 0x20 # Space Bar Key (Space, usually blank)
  PRIOR               = 0x21 # Page Up Key
  NEXT                = 0x22 # Page Down Key
  ENDS                = 0x23 # End Key
  HOME                = 0x24 # Home Key
  LEFT                = 0x25 # Left Arrow Key
  UP                  = 0x26 # Up Arrow Key
  RIGHT               = 0x27 # Right Arrow Key
  DOWN                = 0x28 # Down Arrow Key
  SELECT              = 0x29 # Select Key
  PRINT               = 0x2A # Print Key
  EXECUTE             = 0x2B # Execute Key
  SNAPSHOT            = 0x2C # Print Screen Key
  DELETE              = 0x2E # Delete Key
  HELP                = 0x2F # Help Key
  LSHIFT              = 0xA0 # Left Shift Key
  RSHIFT              = 0xA1 # Right Shift Key
  LCONTROL            = 0xA2 # Left Control Key (Ctrl)
  RCONTROL            = 0xA3 # Right Control Key (Ctrl)
  LMENU               = 0xA4 # Left Menu Key (Alt)
  RMENU               = 0xA5 # Right Menu Key (Alt)
  PACKET              = 0xE7 # Used to Pass Unicode Characters as Keystrokes
  #--------------------------------------------------------------------------
  # * Number Keys
  #--------------------------------------------------------------------------
  N0                  = 0x30 # 0 Key
  N1                  = 0x31 # 1 Key
  N2                  = 0x32 # 2 Key
  N3                  = 0x33 # 3 Key
  N4                  = 0x34 # 4 Key
  N5                  = 0x35 # 5 Key
  N6                  = 0x36 # 6 Key
  N7                  = 0x37 # 7 Key
  N8                  = 0x38 # 8 Key
  N9                  = 0x39 # 9 Key
  #--------------------------------------------------------------------------
  # * Letter Keys
  #--------------------------------------------------------------------------
  A                   = 0x41 # A Key
  B                   = 0x42 # B Key
  C                   = 0x43 # C Key
  D                   = 0x44 # D Key
  E                   = 0x45 # E Key
  F                   = 0x46 # F Key
  G                   = 0x47 # G Key
  H                   = 0x48 # H Key
  I                   = 0x49 # I Key
  J                   = 0x4A # J Key
  K                   = 0x4B # K Key
  L                   = 0x4C # L Key
  M                   = 0x4D # M Key
  N                   = 0x4E # N Key
  O                   = 0x4F # O Key
  P                   = 0x50 # P Key
  Q                   = 0x51 # Q Key
  R                   = 0x52 # R Key
  S                   = 0x53 # S Key
  T                   = 0x54 # T Key
  U                   = 0x55 # U Key
  V                   = 0x56 # V Key
  W                   = 0x57 # W Key
  X                   = 0x58 # X Key
  Y                   = 0x59 # Y Key
  Z                   = 0x5A # Z Key
  #--------------------------------------------------------------------------
  # * Windows Keys
  #--------------------------------------------------------------------------
  LWIN                = 0x5B # Left Windows Key (Natural keyboard)
  RWIN                = 0x5C # Right Windows Key (Natural Keyboard)
  APPS                = 0x5D # Applications Key (Natural keyboard)
  SLEEP               = 0x5F # Computer Sleep Key
  BROWSER_BACK        = 0xA6 # Browser Back Key
  BROWSER_FORWARD     = 0xA7 # Browser Forward Key
  BROWSER_REFRESH     = 0xA8 # Browser Refresh Key
  BROWSER_STOP        = 0xA9 # Browser Stop Key
  BROWSER_SEARCH      = 0xAA # Browser Search Key
  BROWSER_FAVORITES   = 0xAB # Browser Favorites Key
  BROWSER_HOME        = 0xAC # Browser Start and Home Key
  VOLUME_MUTE         = 0xAD # Volume Mute Key
  VOLUME_DOWN         = 0xAE # Volume Down Key
  VOLUME_UP           = 0xAF # Volume Up Key
  MEDIA_NEXT_TRACK    = 0xB0 # Next Track Key
  MEDIA_PREV_TRACK    = 0xB1 # Previous Track Key
  MEDIA_STOP          = 0xB2 # Stop Media Key
  MEDIA_PLAY_PAUSE    = 0xB3 # Play/Pause Media Key
  LAUNCH_MAIL         = 0xB4 # Start Mail Key
  LAUNCH_MEDIA_SELECT = 0xB5 # Select Media Key
  LAUNCH_APP1         = 0xB6 # Start Application 1 Key
  LAUNCH_APP2         = 0xB7 # Start Application 2 Key
  PROCESSKEY          = 0xE5 # IME Process Key
  ATTN                = 0xF6 # Attn Key
  CRSEL               = 0xF7 # CrSel Key
  EXSEL               = 0xF8 # ExSel Key
  EREOF               = 0xF9 # Erase EOF Key
  PLAY                = 0xFA # Play Key
  ZOOM                = 0xFB # Zoom Key
  PA1                 = 0xFD # PA1 Key
  #--------------------------------------------------------------------------
  # * Number Pad Keys
  #--------------------------------------------------------------------------
  NUMPAD0             = 0x60 # Numeric Keypad 0 Key
  NUMPAD1             = 0x61 # Numeric Keypad 1 Key
  NUMPAD2             = 0x62 # Numeric Keypad 2 Key
  NUMPAD3             = 0x63 # Numeric Keypad 3 Key
  NUMPAD4             = 0x64 # Numeric Keypad 4 Key
  NUMPAD5             = 0x65 # Numeric Keypad 5 Key
  NUMPAD6             = 0x66 # Numeric Keypad 6 Key
  NUMPAD7             = 0x67 # Numeric Keypad 7 Key
  NUMPAD8             = 0x68 # Numeric Keypad 8 Key
  NUMPAD9             = 0x69 # Numeric Keypad 9 Key
  MULTIPLY            = 0x6A # Multiply Key (*)
  ADD                 = 0x6B # Add Key (+)
  SEPARATOR           = 0x6C # Separator Key
  SUBTRACT            = 0x6D # Subtract Key (-)
  DECIMAL             = 0x6E # Decimal Key (.)
  DIVIDE              = 0x6F # Divide Key (/)
  #--------------------------------------------------------------------------
  # * Function Keys
  #--------------------------------------------------------------------------
  F1                  = 0x70 # F1 Key
  F2                  = 0x71 # F2 Key
  F3                  = 0x72 # F3 Key
  F4                  = 0x73 # F4 Key
  F5                  = 0x74 # F5 Key
  F6                  = 0x75 # F6 Key
  F7                  = 0x76 # F7 Key
  F8                  = 0x77 # F8 Key
  F9                  = 0x78 # F9 Key
  F10                 = 0x79 # F10 Key
  F11                 = 0x7A # F11 Key
  F12                 = 0x7B # F12 Key
  F13                 = 0x7C # F13 Key
  F14                 = 0x7D # F14 Key
  F15                 = 0x7E # F15 Key
  F16                 = 0x7F # F16 Key
  F17                 = 0x80 # F17 Key
  F18                 = 0x81 # F18 Key
  F19                 = 0x82 # F19 Key
  F20                 = 0x83 # F20 Key
  F21                 = 0x84 # F21 Key
  F22                 = 0x85 # F22 Key
  F23                 = 0x86 # F23 Key
  F24                 = 0x87 # F24 Key
  #--------------------------------------------------------------------------
  # * Toggle Keys
  #--------------------------------------------------------------------------
  CAPITAL             = 0x14 # Caps Lock Key
  KANA                = 0x15 # IME Kana Mode Key
  HANGUL              = 0x15 # IME Hangul Mode Key
  JUNJA               = 0x17 # IME Junja Mode Key
  FINAL               = 0x18 # IME Final Mode Key
  HANJA               = 0x19 # IME Hanja Mode Key
  KANJI               = 0x19 # IME Kanji Mode Key
  MODECHANGE          = 0x1F # IME Mode Change Request Key
  INSERT              = 0x2D # Insert Key
  NUMLOCK             = 0x90 # Num Lock Key
  SCROLL              = 0x91 # Scroll Lock Key
  #--------------------------------------------------------------------------
  # * OEM Keys (Vary by keyboard)
  #--------------------------------------------------------------------------
  OEM_1               = 0xBA # Misc Characters (; : in USA 101/102 Keyboards)
  OEM_PLUS            = 0xBB # + = Key
  OEM_COMMA           = 0xBC # , < Key
  OEM_MINUS           = 0xBD # - _ Key
  OEM_PERIOD          = 0xBE # . > Key
  OEM_2               = 0xBF # Misc Characters (/ ? in USA 101/102 Keyboards)
  OEM_3               = 0xC0 # Misc Characters (` ~ in USA 101/102 Keyboards)
  OEM_4               = 0xDB # Misc Characters ([ { in USA 101/102 Keyboards)
  OEM_5               = 0xDC # Misc Characters (\ | in USA 101/102 Keyboards)
  OEM_6               = 0xDD # Misc Characters (] } in USA 101/102 Keyboards)
  OEM_7               = 0xDE # Misc Characters (' " in USA 101/102 Keyboards)
  OEM_8               = 0xDF # Misc Characters (Varies by Keyboard)
  OEM_9               = 0xE1 # OEM Specific
  OEM_10              = 0x92 # OEM Specific
  OEM_11              = 0x93 # OEM Specific
  OEM_12              = 0x94 # OEM Specific
  OEM_13              = 0x95 # OEM Specific
  OEM_14              = 0x96 # OEM Specific
  OEM_15              = 0xE3 # OEM Specific
  OEM_16              = 0xE4 # OEM Specific
  OEM_17              = 0xE6 # OEM Specific
  OEM_18              = 0xE9 # OEM Specific
  OEM_19              = 0xEA # OEM Specific
  OEM_20              = 0xEB # OEM Specific
  OEM_21              = 0xEC # OEM Specific
  OEM_22              = 0xED # OEM Specific
  OEM_23              = 0xEE # OEM Specific
  OEM_24              = 0xEF # OEM Specific
  OEM_25              = 0xF1 # OEM Specific
  OEM_26              = 0xF2 # OEM Specific
  OEM_27              = 0xF3 # OEM Specific
  OEM_28              = 0xF4 # OEM Specific
  OEM_29              = 0xF5 # OEM Specific
  OEM_102             = 0xE2 # Angle Bracket or Backslash on RT-102 Keyboards
  OEM_CLEAR           = 0xFE # Clear Key
  #--------------------------------------------------------------------------
  # * Special Keys
  #--------------------------------------------------------------------------
  ANYKEY              = 0x100 # Any Key
  #--------------------------------------------------------------------------
  # * Declare Module Variables
  #--------------------------------------------------------------------------
  # Create strings for unpacking input
  @unpack_string = 'B' * 256
  @toggle_unpack_string = 'b' * 256
  # Generate blank input arrays
  @last_array = '0' * 256
  @press   = Array.new(256, false) # Key currently pressed
  @trigger = Array.new(256, false) # Key initially pressed
  @repeat  = Array.new(256, false) # Key being held
  @release = Array.new(256, false) # Key being released
  @toggle  = Array.new(256, false) # Key currently toggled
  # Generate blank counter array
  @repeat_counter = Array.new(256, 0)
  # Declare keyboard API
  @getKeyboardState = Win32API.new('user32.dll', 'GetKeyboardState', 'P', 'V')
  @getAsyncKeyState = Win32API.new('user32.dll', 'GetAsyncKeyState', 'I', 'I')
  @getKeyState = Win32API.new('user32.dll', 'GetKeyState', 'I', 'I')
  @getKeyboardLayoutName = Win32API.new('user32.dll', 'GetKeyboardLayoutName',
    'P', 'I')
  @loadKeyboardLayout = Win32API.new('user32.dll', 'LoadKeyboardLayout', 'PI',
    'I')
  @mapVirtualKeyEx = Win32API.new('user32.dll', 'MapVirtualKeyEx', 'III', 'I')
  @toUnicodeEx = Win32API.new('user32.dll', 'ToUnicodeEx', 'IIPPIII', 'I')
  # Call current keyboard state
  @getKeyboardState.call(@last_array)
  # Set previous keyboard state
  @last_array = @last_array.unpack(@unpack_string)
  # Set a blank keyboard state
  @keyboard_state = '0'*256
  # Save the null character as a value
  @null_character = ' '
  @null_character[0] = 000
  # Set array to input character list
  @input_characters = [A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S,
    T, U, V, W, X, Y, Z, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, OEM_MINUS,
    OEM_PLUS, OEM_COMMA, OEM_PERIOD, OEM_1, OEM_2, OEM_3, OEM_4, OEM_5, OEM_6,
    OEM_7, OEM_8, OEM_9, OEM_10, OEM_11, OEM_12, OEM_13, OEM_14, OEM_15,
    OEM_16, OEM_17, OEM_18, OEM_19, OEM_20, OEM_21, OEM_22, OEM_23, OEM_24,
    OEM_25, OEM_26, OEM_27, OEM_28, OEM_29, OEM_102, NUMPAD0, NUMPAD1, NUMPAD2,
    NUMPAD3, NUMPAD4, NUMPAD5, NUMPAD6, NUMPAD7, NUMPAD8, NUMPAD9, DECIMAL,
    MULTIPLY, ADD, SEPARATOR, SUBTRACT, DIVIDE, SPACE]
  # Create a keyboard layout buffer
  layout_name = '0' * 8
  # Get the keyboard name
  success = @getKeyboardLayoutName.call(layout_name)
  # Set the layout to US 101 if no name was obtained
  layout_name = '00000409' if success == 0
  # Save the keyboard layout
  @layout = @loadKeyboardLayout.call(layout_name, 0x00000001)
  # Create an empty array to store mapped virtual keys
  @mapped_keys = []
  # Iterate through the input character list
  for key in @input_characters
    # Insert the mapped virtual key into the array
    @mapped_keys.push(@mapVirtualKeyEx.call(key, 0, @layout))
  end
  # create blank input array
  @keyboard_state = '0'*256
  # Call current keyboard state
  @getKeyboardState.call(@keyboard_state)
  # Create an array to detect dead keys
  @dead_keys = []
  # Iterate through the input character array
  for key in 0...256
    # Find the key's current scan code
    scan_code = @mapVirtualKeyEx.call(key, 0, @layout)
    # Skip if there is no scan code for the current layout
    next if scan_code == 0
    # Create a character buffer
    buffer = '0' * 10
    # Test the key
    dead_key = @toUnicodeEx.call(key, scan_code, @keyboard_state, buffer, 5, 0,
      @layout)
    # if the key is a dead key
    if dead_key == -1
      # Add the key to the dead key array
      @dead_keys.push(key)
      # Create a character buffer
      buffer = '0' * 10
      # Clear the input queue
      dead_key = @toUnicodeEx.call(@input_characters[-1], @mapped_keys[-1],
        @keyboard_state, buffer, 5, 0, @layout)
    end
  end
  # Set the dead keys to off
  @dead_key_on = false
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def self.update
    # Clear input arrays
    @trigger = Array.new(256, false)
    @repeat = Array.new(256, false)
    @release = Array.new(256, false)
    # create blank input array
    @keyboard_state = '0' * 256
    # Call current keyboard state
    @getKeyboardState.call(@keyboard_state)
    # unpack toggle array
    toggle = @keyboard_state.unpack(@toggle_unpack_string)
    # Unpack key array
    array = @keyboard_state.unpack(@unpack_string)
    # Cycle through all keys
    for i in 0...array.size
      # Set the current key state
      @press[i] = (array[i].to_i != 0)
      # Set the current toggle unpack state
      @toggle[i] = (toggle[i].to_i != 0)
      # If the current key state does not match the previous state
      if array[i] != @last_array[i]
        # If the repeat counter is at 0
        if @repeat_counter[i] <= 0 && @press[i]
          # Set the key to repeat
          @repeat[i] = true
          # Set the repeat counter to 15 frames
          @repeat_counter[i] = 15
        end
        # If the key is not being pressed
        if !@press[i]
          # Set the key to released
          @release[i] = true
        # If the key is being pressed
        else
          # Set the key to triggered
          @trigger[i] = true
        end
      # If the key state is the same
      else
        # If the repeat counter is greater than 0 and the key is pressed
        if @repeat_counter[i] > 0 && @press[i]
          # Cycle the repeat counter down one frame
          @repeat_counter[i] -= 1
        # If the repeat counter is 0 or less and the key is pressed
        elsif @repeat_counter[i] <= 0 && @press[i]
          # Set the key to repeat
          @repeat[i] = true
          # Set the repeat counter to 15 frames
          @repeat_counter[i] = 3
        # If the repeat counter does not equal 0
        elsif @repeat_counter[i] != 0 && !@press[i]
          # Set the repeat counter to 0
          @repeat_counter[i] = 0
        end
      end
    end
    # Set the previous keyboard state
    @last_array = array
  end
  #--------------------------------------------------------------------------
  # * Get Key Pressed State
  #     key : key index
  #--------------------------------------------------------------------------
  def self.press?(key)
    # Return the array state if key is an array
    return array_press?(key) if (Array == key.class)
    # Return false if key is not a number
    return false if !(key.is_a?(Numeric))
    # Force key into the integer class
    key = key.to_i
    # Return false if the key does not exist or is not an integer
    return false if ((key < 0x01) || (key > 0x100) || !(key == key.to_i))
    # Return for any key
    return @press.include?(true) if key == 0x100
    # Return key pressed state
    return @press[key]
  end
  #--------------------------------------------------------------------------
  # * Get Key Triggered State
  #     key : key index
  #--------------------------------------------------------------------------
  def self.trigger?(key)
    # Return the array state if key is an array
    return array_trigger?(key) if (Array == key.class)
    # Return false if key is not a number
    return false if !(key.is_a?(Numeric))
    # Force key into the integer class
    key = key.to_i
    # Return false if the key does not exist or is not an integer
    return false if ((key < 0x01) || (key > 0x100) || !(key == key.to_i))
    # Return for any key
    return @trigger.include?(true) if key == 0x100
    # Return key triggered state
    return @trigger[key]
  end
  #--------------------------------------------------------------------------
  # * Get Key Repeated State
  #     key : key index
  #--------------------------------------------------------------------------
  def self.repeat?(key)
    # Return the array state if key is an array
    return array_repeat?(key) if (Array == key.class)
    # Return false if key is not a number
    return false if !(key.is_a?(Numeric))
    # Force key into the integer class
    key = key.to_i
    # Return false if the key does not exist or is not an integer
    return false if ((key < 0x01) || (key > 0x100) || !(key == key.to_i))
    # Return for any key
    return @repeat.include?(true) if key == 0x100
    # Return key repeated state
    return @repeat[key]
  end
  #--------------------------------------------------------------------------
  # * Get Key Released State
  #     key : key index
  #--------------------------------------------------------------------------
  def self.release?(key)
    # Return the array state if key is an array
    return array_release?(key) if (Array == key.class)
    # Return false if key is not a number
    return false if !(key.is_a?(Numeric))
    # Force key into the integer class
    key = key.to_i
    # Return false if the key does not exist or is not an integer
    return false if ((key < 0x01) || (key > 0x100) || !(key == key.to_i))
    # Return for any key
    return @release.include?(true) if key == 0x100
    # Return key released state
    return @release[key]
  end
  #--------------------------------------------------------------------------
  # * Get Key Toggled State
  #     key : key index
  #--------------------------------------------------------------------------
  def self.toggle?(key)
    # Return the array state if key is an array
    return array_toggle?(key) if (Array == key.class)
    # Return false if key is not a number
    return false if !(key.is_a?(Numeric))
    # Force key into the integer class
    key = key.to_i
    # Return false if the key does not exist or is not an integer
    return false if ((key < 0x01) || (key > 0x100) || !(key == key.to_i))
    # Return for any key
    return @toggle.include?(true) if key == 0x100
    # Return key toggled state
    return @toggle[key]
  end
  #--------------------------------------------------------------------------
  # * Get Key Pressed State (array)
  #     keys : array of key indices
  #--------------------------------------------------------------------------
  def self.array_press?(keys)
    # Return key state if the input is a number
    return press?(keys.to_i) if keys.is_a?(Numeric)
    # Return false if the input is not an array
    return false if (Array != keys.class)
    # Create a temporary array to store key states
    states = [false]
    # Iterate through the keys array
    for key in keys
      # Skip if key is not a number
      next if !(key.is_a?(Numeric))
      # Add the key state to the array
      states << press?(key.to_i)
    end
    # Return true if any of the keys were pressed
    return states.include?(true)
  end
  #--------------------------------------------------------------------------
  # * Get Key Triggered State (array)
  #     keys : array of key indices
  #--------------------------------------------------------------------------
  def self.array_trigger?(keys)
    # Return key state if the input is a number
    return trigger?(keys.to_i) if keys.is_a?(Numeric)
    # Return false if the input is not an array
    return false if (Array != keys.class)
    # Create a temporary array to store key states
    states = [false]
    # Iterate through the keys array
    for key in keys
      # Skip if key is not a number
      next if !(key.is_a?(Numeric))
      # Add the key state to the array
      states << trigger?(key.to_i)
    end
    # Return true if any of the keys were pressed
    return states.include?(true)
  end
  #--------------------------------------------------------------------------
  # * Get Key Repeated State (array)
  #     keys : array of key indices
  #--------------------------------------------------------------------------
  def self.array_repeat?(keys)
    # Return key state if the input is a number
    return repeat?(keys.to_i) if keys.is_a?(Numeric)
    # Return false if the input is not an array
    return false if (Array != keys.class)
    # Create a temporary array to store key states
    states = [false]
    # Iterate through the keys array
    for key in keys
      # Skip if key is not a number
      next if !(key.is_a?(Numeric))
      # Add the key state to the array
      states << repeat?(key.to_i)
    end
    # Return true if any of the keys were pressed
    return states.include?(true)
  end
  #--------------------------------------------------------------------------
  # * Get Key Released State (array)
  #     keys : array of key indices
  #--------------------------------------------------------------------------
  def self.array_release?(keys)
    # Return key state if the input is a number
    return release?(keys.to_i) if keys.is_a?(Numeric)
    # Return false if the input is not an array
    return false if (Array != keys.class)
    # Create a temporary array to store key states
    states = [false]
    # Iterate through the keys array
    for key in keys
      # Skip if key is not a number
      next if !(key.is_a?(Numeric))
      # Add the key state to the array
      states << release?(key.to_i)
    end
    # Return true if any of the keys were pressed
    return states.include?(true)
  end
  #--------------------------------------------------------------------------
  # * Get Key Toggled State (array)
  #     keys : array of key indices
  #--------------------------------------------------------------------------
  def self.array_toggle?(keys)
    # Return key state if the input is a number
    return toggle?(keys.to_i) if keys.is_a?(Numeric)
    # Return false if the input is not an array
    return false if (Array != keys.class)
    # Create a temporary array to store key states
    states = [false]
    # Iterate through the keys array
    for key in keys
      # Skip if key is not a number
      next if !(key.is_a?(Numeric))
      # Add the key state to the array
      states << toggle?(key.to_i)
    end
    # Return true if any of the keys were pressed
    return states.include?(true)
  end
  #--------------------------------------------------------------------------
  # * Get Caps Lock State
  #--------------------------------------------------------------------------
  def self.capslock?
    # Return the current toggle state of Caps Lock
    return @toggle[CAPITAL]
  end
  #--------------------------------------------------------------------------
  # * Get Number Lock State
  #--------------------------------------------------------------------------
  def self.numlock?
    # Return the current toggle state of Num Lock
    return @toggle[NUMLOCK]
  end
  #--------------------------------------------------------------------------
  # * Get Scroll Lock State
  #--------------------------------------------------------------------------
  def self.scroll?
    # Return the current toggle state of Scroll Lock
    return @toggle[SCROLL]
  end
  #--------------------------------------------------------------------------
  # * Return Current Key Character Pressed
  #--------------------------------------------------------------------------
  def self.character_press
    # Iterate through the list of input characters
    for i in 0...@input_characters.size
      # Set a temporary variable to the value of the current key
      key = @input_characters[i]
      # Skip if the character is not currently pressed
      next unless self.press?(key)
      # Get the current key's scan code
      scan_code = @mapped_keys[i]
      # Get the specified character
      character = get_character(key, scan_code)
      # Skip if there was no translation for the character
      next if !character || character == -1
      # Return the translated character
      return character
    end
    # Return false if no characters were returned
    return false
  end
  #--------------------------------------------------------------------------
  # * Return Current Key Character Triggered
  #--------------------------------------------------------------------------
  def self.character_trigger
    # Iterate through the list of input characters
    for i in 0...@input_characters.size
      # Set a temporary variable to the value of the current key
      key = @input_characters[i]
      # Skip if the character is not currently triggered
      next unless self.trigger?(key)
      # Get the current key's scan code
      scan_code = @mapped_keys[i]
      # Get the specified character
      character = get_character(key, scan_code)
      # Skip if there was no translation for the character
      next if !character || character == -1
      # Return the translated character
      return character
    end
    # Return false if no characters were returned
    return false
  end
  #--------------------------------------------------------------------------
  # * Return Current Key Character Repeated
  #--------------------------------------------------------------------------
  def self.character_repeat
    # Iterate through the list of input characters
    for i in 0...@input_characters.size
      # Set a temporary variable to the value of the current key
      key = @input_characters[i]
      # Skip if the character is not currently repeated
      next unless self.repeat?(key)
      # Get the current key's scan code
      scan_code = @mapped_keys[i]
      # Get the specified character
      character = get_character(key, scan_code)
      # Skip if there was no translation for the character
      next if !character || character == -1
      # Return the translated character
      return character
    end
    # Return false if no characters were returned
    return false
  end
  #--------------------------------------------------------------------------
  # * Get Character from Key
  #--------------------------------------------------------------------------
  def self.get_character(key, scan_code)
    # Create a character buffer
    buffer = '0' * 10
    # Translate the current key to Unicode
    success = @toUnicodeEx.call(key, scan_code, @keyboard_state, buffer, 5, 0,
      @layout)
    # Return false there was no translation for the character
    return false if success == 0
    # Iterate through the dead keys
    for dead_key in @dead_keys
      # If the dead key was pressed
      if @getAsyncKeyState.call(dead_key) != 0
        # Map the dead key scan code
        dead_scan =  @mapVirtualKeyEx.call(dead_key, 0, @layout)
        # Recreate a character buffer
        buffer = '0' * 10
        # Translate the current key to Unicode
        success = @toUnicodeEx.call(dead_key, dead_scan, @keyboard_state,
          buffer, 5, 0, @layout)
        # If it returns as a dead key
        if success == -1
          # Recreate a character buffer
          buffer = '0' * 10
          # Translate the current key to Unicode
          success = @toUnicodeEx.call(key, scan_code, @keyboard_state, buffer,
          5, 0, @layout)
        end
        # Return false there was no translation for the character
        return false if success == 0
      end
    end
    # Translate the characters to Ruby encoding
    characters = buffer.unpack('C*').pack('U*')
    # Create the return character
    array = []
    # Iterate through the character buffer
    for i in 0...(success * 2)
      # Add characters to the character array
      array.push(characters[i]) unless array.include?(characters[i])
    end
    # If a dead key was pressed
    if success == -1
      # Iterate through the character buffer
      for i in 0...2
        # Add characters to the character array
        array.push(characters[i]) unless array.include?(characters[i])
      end
    end
    # Delete null characters
    array.delete_if {|byte| byte == 0}
    # Create an empty string for the return character
    character = ' ' * array.size
    # Iterate through the character array
    for i in 0...array.size
      # Add the character to the string
      character[i] = array[i]
    end
    # Return the translated character
    return character
  end
end
 
#==============================================================================
# ** Input
#------------------------------------------------------------------------------
#  This module performs key input processing
#==============================================================================
 
module Input
  # Add class data
  class << self
    #------------------------------------------------------------------------
    # * Alias Methods
    #------------------------------------------------------------------------
    # If the update method has not been aliased
    unless method_defined?(:keyinputmodule_input_update)
      # Alias the update method
      alias keyinputmodule_input_update update
    end
    #-------------------------------------------------------------------------
    # * Frame Update
    #-------------------------------------------------------------------------
    def update
      # Call original method
      keyinputmodule_input_update
      # Update Keys module
      Keys.update
    end
  end
end 


Там чар не меняеться. Если двигаешся Верх-Вправо, то чар вверх.