Suporte ao desenvolvimento de jogos!


    Módulo Input corrigido

    Compartilhe
    avatar
    Paulo Soreto
    Lenda
    Lenda

    Mensagens : 1953
    Créditos : 356

    Ficha do personagem
    Nível: 1
    Vida:
    30/30  (30/30)
    Energia:
    0/0  (0/0)

    Módulo Input corrigido

    Mensagem por Paulo Soreto em Qua Nov 29, 2017 2:29 pm

    O script original pode ser encontrado aqui. Ele apesar de possuir suporte a acentuação não tinha os caracteres correspondentes ainda, tudo que eu fiz foi mapear os acentos e corrigir um pequeno bug que impedia que se digitasse o caractere 'ç'.
    Código:
    #==============================================================================
    # ** 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' =>  ['À', 'Á', 'Â', 'Ã', 'Ä'],
        'E' =>  ['È', 'É', 'Ê',  0 , 'Ë'],
        'I' =>  ['Ì', 'Í', 'Î',  0 , 'Ï'],
        'O' =>  ['Ò', 'Ó', 'Ô', 'Õ', 'Ö'],
        'U' =>  ['Ù', 'Ú', 'Û',  0 , 'Ü'],
        'C' =>  [ 0 ,  0 ,  0 ,  0 ,  0 ],
        'N' =>  [ 0 ,  0 ,  0 , 'Ñ',  0 ],
        'Y' =>  [ 0 , 'Ý',  0 ,  0 , '?'],
        'a' =>  ['à', 'á', 'â', 'ã', 'ä'],
        'e' =>  ['è', 'é', 'ê',  0 , 'ë'],
        'i' =>  ['ì', 'í', 'ô',  0 , 'ï'],
        'o' =>  ['ò', 'ó', 'ô', 'õ', 'ö'],
        'u' =>  ['ù', 'ú', 'û', 'õ', 'ü'],
        'c' =>  [ 0 ,  0 ,  0 ,  0 ,  0 ],
        'n' =>  [ 0 ,  0 ,  0 , 'ñ',  0 ],
        'y' =>  [ 0 , 'ý',  0 ,  0 , '?'],
      }
      
      # 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.convert(c) 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 c != 'ç' && Accents.include?(c)
            if (nc = result[i+1]) != nil
              if PssbLetters.include?(nc)
                if (ac = AccentsCharsConv[nc][Accents.index(c)]) != 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

    # Game_Interpreter
    # def command_111 modification to work properly with my Input System
    #
    class Game_Interpreter
      #--------------------------------------------------------------------------
      # * Conditional Branch
      #--------------------------------------------------------------------------
      def command_111
        result = false
        case @params[0]
        when 0  # Switch
          result = ($game_switches[@params[1]] == (@params[2] == 0))
        when 1  # Variable
          value1 = $game_variables[@params[1]]
          if @params[2] == 0
                value2 = @params[3]
          else
                value2 = $game_variables[@params[3]]
          end
          case @params[4]
          when 0  # value1 is equal to value2
                result = (value1 == value2)
          when 1  # value1 is greater than or equal to value2
                result = (value1 >= value2)
          when 2  # value1 is less than or equal to value2
                result = (value1 <= value2)
          when 3  # value1 is greater than value2
                result = (value1 > value2)
          when 4  # value1 is less than value2
                result = (value1 < value2)
          when 5  # value1 is not equal to value2
                result = (value1 != value2)
          end
        when 2  # Self switch
          if @event_id > 0
                key = [@map_id, @event_id, @params[1]]
                result = ($game_self_switches[key] == (@params[2] == 0))
          end
        when 3  # Timer
          if $game_timer.working?
                if @params[2] == 0
                  result = ($game_timer.sec >= @params[1])
                else
                  result = ($game_timer.sec <= @params[1])
                end
          end
        when 4  # Actor
          actor = $game_actors[@params[1]]
          if actor
                case @params[2]
                when 0  # in party
                  result = ($game_party.members.include?(actor))
                when 1  # name
                  result = (actor.name == @params[3])
                when 2  # Class
                  result = (actor.class_id == @params[3])
                when 3  # Skills
                  result = (actor.skill_learn?($data_skills[@params[3]]))
                when 4  # Weapons
                  result = (actor.weapons.include?($data_weapons[@params[3]]))
                when 5  # Armors
                  result = (actor.armors.include?($data_armors[@params[3]]))
                when 6  # States
                  result = (actor.state?(@params[3]))
                end
          end
        when 5  # Enemy
          enemy = $game_troop.members[@params[1]]
          if enemy
                case @params[2]
                when 0  # appear
                  result = (enemy.alive?)
                when 1  # state
                  result = (enemy.state?(@params[3]))
                end
          end
        when 6  # Character
          character = get_character(@params[1])
          if character
                result = (character.direction == @params[2])
          end
        when 7  # Gold
          case @params[2]
          when 0  # Greater than or equal to
                result = ($game_party.gold >= @params[1])
          when 1  # Less than or equal to
                result = ($game_party.gold <= @params[1])
          when 2  # Less than
                result = ($game_party.gold < @params[1])
          end
        when 8  # Item
          result = $game_party.has_item?($data_items[@params[1]])
        when 9  # Weapon
          result = $game_party.has_item?($data_weapons[@params[1]], @params[2])
        when 10  # Armor
          result = $game_party.has_item?($data_armors[@params[1]], @params[2])
        when 11  # Button
          key = Input::EventsKeyCodes[@params[1]]
          result = Input.press?(key) if key
        when 12  # Script
          result = eval(@params[1])
        when 13  # Vehicle
          result = ($game_player.vehicle == $game_map.vehicles[@params[1]])
        end
        @branch[@indent] = result
        command_skip if !@branch[@indent]
      end
    end

    Imagem:
    avatar
    Valentine
    Administrador
    Administrador

    Medalhas :
    Mensagens : 4762
    Créditos : 1009

    Re: Módulo Input corrigido

    Mensagem por Valentine em Qua Nov 29, 2017 5:09 pm

    Boa, Soreto.

    Também pretendo usar esse Input.

    + 1 crédito.


    _________________

      Data/hora atual: Sex Fev 23, 2018 7:27 pm