Multi–Player

Registry [ Selecionar ] [ - ]

#===============================================================================
# ** Registry                                                                   
#-------------------------------------------------------------------------------
# This class reads the windows registry.                                        
#===============================================================================

module Win32
  class Registry
    module Constants
      HKEY_CLASSES_ROOT = 0x80000000
      HKEY_CURRENT_USER = 0x80000001
      HKEY_LOCAL_MACHINE = 0x80000002
      HKEY_USERS = 0x80000003
      HKEY_PERFORMANCE_DATA = 0x80000004
      HKEY_PERFORMANCE_TEXT = 0x80000050
      HKEY_PERFORMANCE_NLSTEXT = 0x80000060
      HKEY_CURRENT_CONFIG = 0x80000005
      HKEY_DYN_DATA = 0x80000006
      REG_NONE = 0
      REG_SZ = 1
      REG_EXPAND_SZ = 2
      REG_BINARY = 3
      REG_DWORD = 4
      REG_DWORD_LITTLE_ENDIAN = 4
      REG_DWORD_BIG_ENDIAN = 5
      REG_LINK = 6
      REG_MULTI_SZ = 7
      REG_RESOURCE_LIST = 8
      REG_FULL_RESOURCE_DESCRIPTOR = 9
      REG_RESOURCE_REQUIREMENTS_LIST = 10
      REG_QWORD = 11
      REG_QWORD_LITTLE_ENDIAN = 11
      STANDARD_RIGHTS_READ = 0x00020000
      STANDARD_RIGHTS_WRITE = 0x00020000
      KEY_QUERY_VALUE = 0x0001
      KEY_SET_VALUE = 0x0002
      KEY_CREATE_SUB_KEY = 0x0004
      KEY_ENUMERATE_SUB_KEYS = 0x0008
      KEY_NOTIFY = 0x0010
      KEY_CREATE_LINK = 0x0020
      KEY_READ = STANDARD_RIGHTS_READ |
        KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY
      KEY_WRITE = STANDARD_RIGHTS_WRITE |
        KEY_SET_VALUE | KEY_CREATE_SUB_KEY
      KEY_EXECUTE = KEY_READ
      KEY_ALL_ACCESS = KEY_READ | KEY_WRITE | KEY_CREATE_LINK
      REG_OPTION_RESERVED = 0x0000
      REG_OPTION_NON_VOLATILE = 0x0000
      REG_OPTION_VOLATILE = 0x0001
      REG_OPTION_CREATE_LINK = 0x0002
      REG_OPTION_BACKUP_RESTORE = 0x0004
      REG_OPTION_OPEN_LINK = 0x0008
      REG_LEGAL_OPTION = REG_OPTION_RESERVED |
        REG_OPTION_NON_VOLATILE | REG_OPTION_CREATE_LINK |
        REG_OPTION_BACKUP_RESTORE | REG_OPTION_OPEN_LINK
      REG_CREATED_NEW_KEY = 1
      REG_OPENED_EXISTING_KEY = 2
      REG_WHOLE_HIVE_VOLATILE = 0x0001
      REG_REFRESH_HIVE = 0x0002
      REG_NO_LAZY_FLUSH = 0x0004
      REG_FORCE_RESTORE = 0x0008
      MAX_KEY_LENGTH = 514
      MAX_VALUE_LENGTH = 32768
    end
    include Constants
    include Enumerable
    class Error < ::StandardError
      FormatMessageA=Win32API.new('kernel32.dll','FormatMessageA','LPLLPLP','L')
      def initialize(code)
        @code = code
        msg = "\\0" * 1024
        len = FormatMessageA.call(0x1200, 0, code, 0, msg, 1024, 0)
        super msg[0, len].tr("\\r", '').chomp
      end
      attr_reader :code
    end
    class PredefinedKey < Registry
      def initialize(hkey, keyname)
        @hkey = hkey
        @parent = nil
        @keyname = keyname
        @disposition = REG_OPENED_EXISTING_KEY
      end
      def close
        raise Error.new(5)
      end
      def class
        Registry
      end
      Constants.constants.grep(/^HKEY_/) do |c|
        Registry.const_set c, new(Constants.const_get(c), c)
      end
    end
    module API
      [
        %w/RegOpenKeyExA    LPLLP        L/,
        %w/RegCreateKeyExA  LPLLLLPPP    L/,
        %w/RegEnumValueA    LLPPPPPP     L/,
        %w/RegEnumKeyExA    LLPPLLLP     L/,
        %w/RegQueryValueExA LPLPPP       L/,
        %w/RegSetValueExA   LPLLPL       L/,
        %w/RegFlushKey      L            L/,
        %w/RegCloseKey      L            L/,
        %w/RegQueryInfoKey  LPPPPPPPPPPP L/,
      ].each do |fn|
        const_set fn[0].intern, Win32API.new('advapi32.dll', *fn)
      end
      module_function
      def check(result)
        raise Error, result, caller(2) if result != 0
      end
      def packdw(dw)
        [dw].pack('V')
      end
      def unpackdw(dw)
        dw += [0].pack('V')
        dw.unpack('V')[0]
      end
      def packqw(qw)
        [ qw & 0xFFFFFFFF, qw >> 32 ].pack('VV')
      end
      def unpackqw(qw)
        qw = qw.unpack('VV')
        (qw[1] << 32) | qw[0]
      end
      def OpenKey(hkey, name, opt, desired)
        result = packdw(0)
        check RegOpenKeyExA.call(hkey, name, opt, desired, result)
        unpackdw(result)
      end
      def CreateKey(hkey, name, opt, desired)
        result = packdw(0)
        disp = packdw(0)
        check RegCreateKeyExA.call(hkey, name, 0, 0, opt, desired,
                                   0, result, disp)
        [ unpackdw(result), unpackdw(disp) ]
      end
      def EnumValue(hkey, index)
        name = ' ' * Constants::MAX_KEY_LENGTH
        size = packdw(Constants::MAX_KEY_LENGTH)
        check RegEnumValueA.call(hkey, index, name, size, 0, 0, 0, 0)
        name[0, unpackdw(size)]
      end
      def EnumKey(hkey, index)
        name = ' ' * Constants::MAX_KEY_LENGTH
        size = packdw(Constants::MAX_KEY_LENGTH)
        wtime = ' ' * 8
        check RegEnumKeyExA.call(hkey, index, name, size, 0, 0, 0, wtime)
        [ name[0, unpackdw(size)], unpackqw(wtime) ]
      end
      def QueryValue(hkey, name)
        type = packdw(0)
        size = packdw(0)
        check RegQueryValueExA.call(hkey, name, 0, type, 0, size)
        data = ' ' * unpackdw(size)
        check RegQueryValueExA.call(hkey, name, 0, type, data, size)
        [ unpackdw(type), data[0, unpackdw(size)] ]
      end
      def SetValue(hkey, name, type, data, size)
        check RegSetValueExA.call(hkey, name, 0, type, data, size)
      end
      def FlushKey(hkey)
        check RegFlushKey.call(hkey)
      end
      def CloseKey(hkey)
        check RegCloseKey.call(hkey)
      end
      def QueryInfoKey(hkey)
        subkeys = packdw(0)
        maxsubkeylen = packdw(0)
        values = packdw(0)
        maxvaluenamelen = packdw(0)
        maxvaluelen = packdw(0)
        secdescs = packdw(0)
        wtime = ' ' * 8
        check RegQueryInfoKey.call(hkey, 0, 0, 0, subkeys, maxsubkeylen, 0,
          values, maxvaluenamelen, maxvaluelen, secdescs, wtime)
        [ unpackdw(subkeys), unpackdw(maxsubkeylen), unpackdw(values),
          unpackdw(maxvaluenamelen), unpackdw(maxvaluelen),
          unpackdw(secdescs), unpackqw(wtime) ]
      end
    end
    def self.expand_environ(str)
      str.gsub(/%([^%]+)%/) { ENV[$1] || $& }
    end
    @@type2name = { }
    %w[
      REG_NONE REG_SZ REG_EXPAND_SZ REG_BINARY REG_DWORD
      REG_DWORD_BIG_ENDIAN REG_LINK REG_MULTI_SZ
      REG_RESOURCE_LIST REG_FULL_RESOURCE_DESCRIPTOR
      REG_RESOURCE_REQUIREMENTS_LIST REG_QWORD
    ].each do |type|
      @@type2name[Constants.const_get(type)] = type
    end
    def self.type2name(type)
      @@type2name[type] || type.to_s
    end
    def self.wtime2time(wtime)
      Time.at((wtime - 116444736000000000) / 10000000)
    end
    def self.time2wtime(time)
      time.to_i * 10000000 + 116444736000000000
    end
    private_class_method :new
    def self.open(hkey, subkey, desired = KEY_READ, opt = REG_OPTION_RESERVED)
      subkey = subkey.chomp('\\\\')
      newkey = API.OpenKey(hkey.hkey, subkey, opt, desired)
      obj = new(newkey, hkey, subkey, REG_OPENED_EXISTING_KEY)
      if block_given?
        begin
          yield obj
        ensure
          obj.close
        end
      else
        obj
      end
    end
    def self.create(hkey, subkey, desired = KEY_ALL_ACCESS, opt = 0x0000)
      newkey, disp = API.CreateKey(hkey.hkey, subkey, opt, desired)
      obj = new(newkey, hkey, subkey, disp)
      if block_given?
        begin
          yield obj
        ensure
          obj.close
        end
      else
        obj
      end
    end
    @@final = proc { |hkey| proc { API.CloseKey(hkey[0]) if hkey[0] } }
    def initialize(hkey, parent, keyname, disposition)
      @hkey = hkey
      @parent = parent
      @keyname = keyname
      @disposition = disposition
      @hkeyfinal = [ hkey ]
      ObjectSpace.define_finalizer self, @@final.call(@hkeyfinal)
    end
    attr_reader :hkey, :parent, :keyname, :disposition
    def created?
      @disposition == REG_CREATED_NEW_KEY
    end
    def open?
      !@hkey.nil?
    end
    def name
      parent = self
      name = @keyname
      while parent = parent.parent
        name = parent.keyname + '\\\\' + name
      end
      name
    end
    def inspect
      "\\#<Win32::Registry key=#{name.inspect}>"
    end
    def _dump(depth)
      raise TypeError, "can't dump Win32::Registry"
    end
    def open(subkey, desired = KEY_READ, opt = REG_OPTION_RESERVED, &blk)
      self.class.open(self, subkey, desired, opt, &blk)
    end
    def create(subkey, desired = KEY_ALL_ACCESS, opt = REG_OPTION_RESERVED, &blk)
      self.class.create(self, subkey, desired, opt, &blk)
    end
    def close
      API.CloseKey(@hkey)
      @hkey = @parent = @keyname = nil
      @hkeyfinal[0] = nil
    end
    def each_value
      index = 0
      while true
        begin
          subkey = API.EnumValue(@hkey, index)
        rescue Error
          break
        end
        begin
          type, data = read(subkey)
        rescue Error
          next
        end
        yield subkey, type, data
        index += 1
      end
      index
    end
    alias each each_value
    def each_key
      index = 0
      while true
        begin
          subkey, wtime = API.EnumKey(@hkey, index)
        rescue Error
          break
        end
        yield subkey, wtime
        index += 1
      end
      index
    end
    def keys
      keys_ary = []
      each_key { |key,| keys_ary << key }
      keys_ary
    end
    def read(name, *rtype)
      type, data = API.QueryValue(@hkey, name)
      unless rtype.empty? or rtype.include?(type)
        string = "Type mismatch (expect #{rtype.inspect} but #{type} present)"
        raise TypeError, string
      end
      case type
      when REG_SZ, REG_EXPAND_SZ
        [ type, data.chop ]
      when REG_MULTI_SZ
        [ type, data.split(/\\0/) ]
      when REG_BINARY
        [ type, data ]
      when REG_DWORD
        [ type, API.unpackdw(data) ]
      when REG_DWORD_BIG_ENDIAN
        [ type, data.unpack('N')[0] ]
      when REG_QWORD
        [ type, API.unpackqw(data) ]
      else
        raise TypeError, "Type #{type} is not supported."
      end
    end
    def [](name, *rtype)
      type, data = read(name, *rtype)
      case type
      when REG_SZ, REG_DWORD, REG_QWORD, REG_MULTI_SZ
        data
      when REG_EXPAND_SZ
        Registry.expand_environ(data)
      else
        raise TypeError, "Type #{type} is not supported."
      end
    end
    def read_s(name)
      read(name, REG_SZ)[1]
    end
    def read_s_expand(name)
      type, data = read(name, REG_SZ, REG_EXPAND_SZ)
      if type == REG_EXPAND_SZ
        Registry.expand_environ(data)
      else
        data
      end
    end
    def read_i(name)
      read(name, REG_DWORD, REG_DWORD_BIG_ENDIAN, REG_QWORD)[1]
    end
    def read_bin(name)
      read(name, REG_BINARY)[1]
    end
    def write(name, type, data)
      case type
      when REG_SZ, REG_EXPAND_SZ
        data = data.to_s + "\\0"
      when REG_MULTI_SZ
        data = data.to_a.join("\\0") + "\\0\\0"
      when REG_BINARY
        data = data.to_s
      when REG_DWORD
        data = API.packdw(data.to_i)
      when REG_DWORD_BIG_ENDIAN
        data = [data.to_i].pack('N')
      when REG_QWORD
        data = API.packqw(data.to_i)
      else
        raise TypeError, "Unsupported type #{type}"
      end
      API.SetValue(@hkey, name, type, data, data.length)
    end
    def []=(name, rtype, value = nil)
      if value
        write name, rtype, value
      else
        case value = rtype
        when Integer
          write name, REG_DWORD, value
        when String
          write name, REG_SZ, value
        when Array
          write name, REG_MULTI_SZ, value
        else
          raise TypeError, "Unexpected type #{value.class}"
        end
      end
      value
    end
    def write_s(name, value)
      write name, REG_SZ, value.to_s
    end
    def write_i(name, value)
      write name, REG_DWORD, value.to_i
    end
    def write_bin(name, value)
      write name, REG_BINARY, value.to_s
    end
    def flush
      API.FlushKey @hkey
    end
    def info
      API.QueryInfoKey(@hkey)
    end
    %w[
      num_keys max_key_length
      num_values max_value_name_length max_value_length
      descriptor_length wtime
    ].each_with_index do |s, i|
      eval <<-__END__
        def #{s}
          info[#{i}]
        end
      __END__
    end
  end
end

Keys [ Selecionar ] [ - ]

=begin -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
                         Aleworks Keys Module
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 Created by Aleworks
 Version: 1.00.USA
 Last Update: 12/12/2006 (dd/mm/yyyy)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 * This module has all the keys of the USA keyboard.
 * The USA keyboard is like this:

 ----------------------------------------------------------------------------
 - ESC   F1 F2 F3 F4  F5 F6 F7 F8  F9 F10 F11 F12 SNP  SCRL PAUSE           -
 -                                                                          -
 - ` 1  2  3  4  5  6  7  8  9  0  -  = BACKSPACE INS  HOME PGUP  N / * -   -
 - TAB Q  W  E  R  T  Y  U  I  O  P  [  ]  EN-TER DEL  END  PGDW  7 8 9 +   -
 - CAPS A  S  D  F  G  H  J  K  L  ;  '  E-N-T-ER                 4 5 6 +   -
 - SHIFT Z  X  C  V  B  N  M  ,  .  /  S-H-IFT  \\       UP        1 2 3 EN  -
 - CTRL WIN ALT S-P-A-C-E-B-A-R ALT WIN APPS CTRL LEFT DOWN RIGHT 0-- . TER -
 ----------------------------------------------------------------------------

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
                             *** Functions ***
 * Keys.name?(num)
  Return a string with the name of the key "num".
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=end

module Keys
#-----------------------------------------------------------------------------
  MOUSE_PRIMARY   = 1    # Mouse primary button (Normaly the left button)
  MOUSE_SECONDARY = 2    # Mouse secondary button (Normaly the right button)
  MOUSE_MIDDLE    = 4    # Mouse middle button
  MOUSE_4TH       = 5    # Mouse fourth button
  MOUSE_5TH       = 6    # Mouse fifth button
#-----------------------------------------------------------------------------
  BACKSPACE       = 8    # BACKSPACE key
  TAB             = 9    # TAB key
  RETURN          = 13   # ENTER key
  SHIFT           = 16   # SHIFT key
  CTLR            = 17   # CTLR key
  ALT             = 18   # ALT key
  CAPS_LOCK       = 20   # CAPS LOCK key
  ESCAPE          = 27   # ESC key
  SPACE           = 32   # SPACEBAR
  PGUP            = 33   # PAGE UP key
  PGDN            = 34   # PAGE DOWN key
  ENDS            = 35   # END key
  HOME            = 36   # HOME key
  LEFT            = 37   # LEFT ARROW key
  UP              = 38   # UP ARROW key
  RIGHT           = 39   # RIGHT ARROW key
  DOWN            = 40   # DOWN ARROW key
  SNAPSHOT        = 44   # PRINT SCREEN key
  INSERT          = 45   # INS key
  DELETE          = 46   # DEL key
#-----------------------------------------------------------------------------
  N0              = 48   # 0 key
  N1              = 49   # 1 key
  N2              = 50   # 2 key
  N3              = 51   # 3 key
  N4              = 52   # 4 key
  N5              = 53   # 5 key
  N6              = 54   # 6 key
  N7              = 55   # 7 key
  N8              = 56   # 8 key
  N9              = 57   # 9 key
#-----------------------------------------------------------------------------
  A               = 65   # A key
  B               = 66   # B key
  C               = 67   # C key
  D               = 68   # D key
  E               = 69   # E key
  F               = 70   # F key
  G               = 71   # G key
  H               = 72   # H key
  I               = 73   # I key
  J               = 74   # J key
  K               = 75   # K key
  L               = 76   # L key
  M               = 77   # M key
  N               = 78   # N key
  O               = 79   # O key
  P               = 80   # P key
  Q               = 81   # Q key
  R               = 82   # R key
  S               = 83   # S key
  T               = 84   # T key
  U               = 85   # U key
  V               = 86   # V key
  W               = 87   # W key
  X               = 88   # X key
  Y               = 89   # Y key
  Z               = 90   # Z key
#-----------------------------------------------------------------------------
  LWIN            = 91   # Left Windows key (Microsoft Natural keyboard) 
  RWIN            = 92   # Right Windows key (Natural keyboard)
  APPS            = 93   # Applications key (Natural keyboard)
#-----------------------------------------------------------------------------
  NUMPAD0         = 96   # Numeric keypad 0 key
  NUMPAD1         = 97   # Numeric keypad 1 key
  NUMPAD2         = 98   # Numeric keypad 2 key
  NUMPAD3         = 99   # Numeric keypad 3 key
  NUMPAD4         = 100  # Numeric keypad 4 key
  NUMPAD5         = 101  # Numeric keypad 5 key
  NUMPAD6         = 102  # Numeric keypad 6 key
  NUMPAD7         = 103  # Numeric keypad 7 key
  NUMPAD8         = 104  # Numeric keypad 8 key
  NUMPAD9         = 105  # Numeric keypad 9 key
  MULTIPLY        = 106  # Multiply key (*)
  ADD             = 107  # Add key (+)
  SUBTRACT        = 109  # Subtract key (-)
  DECIMAL         = 110  # . (Decimal from PAD)
  DIVIDE          = 111  # Divide key (/)
#-----------------------------------------------------------------------------
  F1              = 112  # F1 key
  F2              = 113  # F2 key
  F3              = 114  # F3 key
  F4              = 115  # F4 key
  F5              = 116  # F5 key
  F6              = 117  # F6 key
  F7              = 118  # F7 key
  F8              = 119  # F8 key
  F9              = 120  # F9 key
  F10             = 121  # F10 key
  F11             = 122  # F11 key
  F12             = 123  # F12 key
#-----------------------------------------------------------------------------
  NUM_LOCK        = 144  # NUM LOCK key
  SCROLL_LOCK     = 145  # SCROLL LOCK key
  LEFT_SHIFT      = 160  # Left SHIFT key
  RIGHT_SHIFT     = 161  # Right SHIFT key
  LEFT_CONTROL    = 162  # Left CONTROL key
  RIGHT_CONTROL   = 163  # Right CONTROL key
  LEFT_ALT        = 164  # Left ALT key
  RIGHT_ALT       = 165  # Right ALT key
#-----------------------------------------------------------------------------
  COLLON          = 186  # ; :
  EQUAL           = 187  # = +
  COMMA           = 188  # , <
  UNDERSCORE      = 189  # - _
  DOT             = 190  # . >
  BACKSLASH       = 191  # / ?
  KEY192          = 192  # ` ~  I dont know the name of this key
  LB              = 219  # [ {
  BACKSLASH2      = 220  # \\ |
  RB              = 221  # ] }
  QUOTE           = 222  # ' "
#-----------------------------------------------------------------------------
  def Keys.name?(num)
    return "MOUSE PRIMARY" if num==1
    return "MOUSE SECONDARY" if num==2
    return "MOUSE MIDDLE" if num==4
    return "MOUSE 4TH" if num==5
    return "MOUSE 5TH" if num==6
    return "BACKSPACE" if num==8
    return "TAB" if num==9
    return "RETURN" if num==13
    return "SHIFT" if num==16
    return "CTLR" if num==17
    return "ALT" if num==18
    return "CAPS LOCK" if num==20
    return "ESCAPE" if num==27
    return "SPACE" if num==32
    return "PGUP" if num==33
    return "PGDN" if num==34
    return "END" if num==35
    return "HOME" if num==36
    return "LEFT" if num==37
    return "UP" if num==38
    return "RIGHT" if num==39
    return "DOWN" if num==40
    return "SNAPSHOT" if num==44
    return "INSERT" if num==45
    return "DELETE" if num==46
    return "0" if num==48
    return "1" if num==49
    return "2" if num==50
    return "3" if num==51
    return "4" if num==52
    return "5" if num==53
    return "6" if num==54
    return "7" if num==55
    return "8" if num==56
    return "9" if num==57
    return "A" if num==65
    return "B" if num==66
    return "C" if num==67
    return "D" if num==68
    return "E" if num==69
    return "F" if num==70
    return "G" if num==71
    return "H" if num==72
    return "I" if num==73
    return "J" if num==74
    return "K" if num==75
    return "L" if num==76
    return "M" if num==77
    return "N" if num==78
    return "O" if num==79
    return "P" if num==80
    return "Q" if num==81
    return "R" if num==82
    return "S" if num==83
    return "T" if num==84
    return "U" if num==85
    return "V" if num==86
    return "W" if num==87
    return "X" if num==88
    return "Y" if num==89
    return "Z" if num==90
    return "LWIN" if num==91
    return "RWIN" if num==92
    return "APPS" if num==93
    return "0" if num==96
    return "1" if num==97
    return "2" if num==98
    return "3" if num==99
    return "4" if num==100
    return "5" if num==101
    return "6" if num==102
    return "7" if num==103
    return "8" if num==104
    return "9" if num==105
    return "*" if num==106
    return "+" if num==107
    return "-" if num==109
    return "." if num==110
    return "/" if num==111
    return "F1" if num==112
    return "F2" if num==113
    return "F3" if num==114
    return "F4" if num==115
    return "F5" if num==116
    return "F6" if num==117
    return "F7" if num==118
    return "F8" if num==119
    return "F9" if num==120
    return "F10" if num==121
    return "F11" if num==122
    return "F12" if num==123
    return "NUM LOCK" if num==144
    return "SCROLL LOCK" if num==145
    return "LEFT SHIFT" if num==160
    return "RIGHT SHIFT" if num==161
    return "LEFT CTRL" if num==162
    return "RIGHT CTRL" if num==163
    return "LEFT ALT" if num==164
    return "RIGHT ALT" if num==165
    return ";" if num==186
    return "=" if num==187
    return "," if num==188
    return "_" if num==189
    return "." if num==190
    return "/" if num==191
    return "`" if num==192
    return "[" if num==219
    return " \\\\ " if num==220
    return "]" if num==221
    return "'" if num==222
    return "??? - " + "#{num}"
  end
end

Input [ Selecionar ] [ - ]

=begin -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
                          Aleworks Input Module(AIM)                            
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 Created by Aleworks
 Version: 1.21
 Last Update: 29/01/2007 (dd/mm/yyyy)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
                           *** Introduction ***
 This script simulates the RGSS module "Input". It is not the original module,
 but it has all the original module functions and some new.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
                          *** Version History ***
-- Version 1.00 --
 * Input.reiterate?(num)
   Return true if the key 'num', has been triggered again in maximum
   20 frames(default) after the last trigger of the key.
 * Input.activated?(num)
   This command, checks if the key 'num' is on. Returns true if the key is on.
   (If num is 1 the key will be CAPS LOCK, if is 2 NUM LOCK, and if is
   3 SCROLL LOCK)
 * Input.press_all
   Return all the keys pressed.
 * Input.trigger_all
   Return all the keys triggered.
 * Input.repeat_all
   Return all the keys repeated.
 * Input.reiterate_all
   Return all the keys reiterated.
 * New Keys
   LOWER_LEFT,LOWER_RIGHT,UPPER_LEFT and UPPER_RIGHT
-- Version 1.10 --
 * Input.event(num)
   Creates a keyboard event. In other words, you can press keys with this command
 * Input.free_key(num)
   Frees a key, it will be not actived for a frame.
 * Input.free_all_keys
   Frees all keys.
-- Version 1.11 --
 * Changed the variables: @repeat_time, @reiterate_time, @reiterate and 
   @update_keys to global variables for easy editing.
-- Version 1.12 --
 * Compability with the event commands: Asing Key and Condition Branch
-- Version 1.20 --
 * Little lag reduction
 * Input.release?(num)
   Returns true if the key num has been released.
 * Input.release_all
   Returns the keys that has been released.
-- Version 1.21 --
 * Major bug fixed, when using arrays in Input.press?, Input.trigger?,
   Input.reiterate? and Input.release?
 * Removed $update_keys and $reiterate
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
                            *** How to use ***
 * For some commands (trigger?,repeat? and reiterate?) you need to update this
 module with "Input.update".
 * If you need to use keys that are from the keyboard or from the mouse, use the
 Keys module.
  -- Example --
     Input.press?(Keys::CTRL)
   It will return true if the key CONTROL is pressed.
  -- Example --
     Input.press?(17)
   It will return true if the key CONTROL is pressed. The Keys::CTRL is equal to
   the number "17", so you can use the two forms.(See Keys module for all the 
   list)

  You can see all the keys available in the Keys module.
  Remember that if you want to use keys from the keyboard or mouse you need to
  put the number of the keys in the @update_keys variable.
 * You can use Arrays in the commands.
  -- Example --
     Input.press?([Input::A, Input::B]) 
   It'll return true if buttons A or/and B is/are pressed.
  -- Example 2 --
     Input.press?([Keys::A, Keys::B, Keys::C])
   It'll return true if the letters A or/and B or/and C is/are pressed.
  -- Example 3 --
     Input.trigger?([[Keys::SHIFT, Keys::ESCAPE]])
   It'll return true if the keys SHIFT and ESCAPE are being pressed.
  -- Example 4 --
     Input.trigger?([[Keys::SHIFT, Keys::ESCAPE], [Keys::ALT, Keys::F1]])
   It'll return true if the keys SHIFT and ESCAPE or the keys ALT an F1 are
   being pressed.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=end

module Input
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Editable options **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  $repeat_time = 7 # Frames for repeat in Input.repeat? (30 frames = 1s aprox.)
  $reiterate_time = 20 # Frames for reiterate in Input.reiterate?
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Win32API class creation **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  GetKeyState = Win32API.new('user32', 'GetKeyState', 'i', 'i')
  GetAsyncKeyState = Win32API.new('user32', 'GetAsyncKeyState', 'i', 'i')
  Keybd_event = Win32API.new('user32', 'keybd_event', %w(l l l l), '')
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Internal variables definition **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  @trigger, @trigger2, @repeat, @repeat2 = [], [], [], []
  @repeat3, @reiterate, @reiterate2, @reiterate3 = [], [], [], []
  @release, @release2 = [], []
  for i in 0..255
    @trigger.push(false)
    @trigger2.push(false)
    @repeat.push(false)
    @repeat2.push(0)
    @reiterate.push(false)
    @reiterate2.push(0)
    @reiterate3.push(GetKeyState.call(i) & 0x01)
    @release.push(false)
    @release2.push(false)
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** convert_keys (internal definition) **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  # It reads the windows registry and returns the corresponding keys to the
  # F1 keys menu.
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  module_function
  def convert_keys(num)
    Win32::Registry::HKEY_CURRENT_USER.open('Software\\Enterbrain\\RGSS') do |reg|
      value = reg.read('ButtonAssign', 3)[1].scan(/./)
      value[0, 10] = nil
      value.compact!
      key = []
      key2 = []
      for i in 0..14
        value[i] = 11 if value[i] == "\\v"
        value[i] = 12 if value[i] == "\\f"
        value[i] = 13 if value[i] == "\\r"
        value[i] = 14 if value[i] == "\\16"
        value[i] = 15 if value[i] == "\\17"
        value[i] = 16 if value[i] == "\\20"
        value[i] = 17 if value[i] == "\\21"
        value[i] = 18 if value[i] == "\\22"
        key.push(i) if num == value[i]
      end
      for i in key
        key2.push(32) if i == 0
        key2.push(13) if i == 1
        key2.push(27) if i == 2
        key2.push(96) if i == 3
        key2.push(16) if i == 4
        key2.push(90) if i == 5
        key2.push(88) if i == 6
        key2.push(67) if i == 7
        key2.push(86) if i == 8
        key2.push(66) if i == 9
        key2.push(65) if i == 10
        key2.push(83) if i == 11
        key2.push(68) if i == 12
        key2.push(81) if i == 13
        key2.push(87) if i == 14
      end
      return key2
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Keys variables definition **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  LOWER_LEFT = 97
  LOWER_RIGHT = 99
  UPPER_LEFT = 103
  UPPER_RIGHT = 105
  DOWN = [98, 40]
  LEFT = [100, 37]
  RIGHT = [102, 39]
  UP = [104, 38]
  A = convert_keys(11)
  B = convert_keys(12)
  C = convert_keys(13)
  X = convert_keys(14)
  Y = convert_keys(15)
  Z = convert_keys(16)
  L = convert_keys(17)
  R = convert_keys(18)
  SHIFT = 16
  CTRL = 17
  ALT = 18
  F5 = 116
  F6 = 117
  F7 = 118
  F8 = 119
  F9 = 120
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Update **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.update
    for i in 0..255
      @repeat2[i] -=1 if @repeat2[i] > 0
      if !GetAsyncKeyState.call(i).between?(0, 1)
        if @trigger2[i]
          @trigger[i] = false
        else
          @trigger[i] = true
          @trigger2[i] = true
        end
        if @repeat2[i] <= 0
          @repeat[i] = true
          @repeat2[i] = $repeat_time
        else
          @repeat[i] = false
        end
        @release2[i] = true
      else
        @trigger[i] = false
        @trigger2[i] = false
        @repeat[i] = false
        if @release2[i]
          @release[i] = true
        else
          @release[i] = false
        end
        @release2[i] = false
      end
      @reiterate2[i] -= 1 if @reiterate2[i] > 0
      @reiterate[i] = false if @reiterate2[i] == 0
      if GetKeyState.call(i) & 0x01 == 1 and @reiterate3[i] == 0
        @reiterate[i] = true
        @reiterate2[i] = $reiterate_time
        @reiterate3[i] = 1
      elsif GetKeyState.call(i) & 0x01 == 0 and @reiterate3[i] == 1
        @reiterate[i] = true
        @reiterate2[i] = $reiterate_time
        @reiterate3[i] = 0
      end
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Press **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.press?(num)
    if num.is_a?(Array)
      for i in 0...num.size
        if num[i].is_a?(Array)
          returntrue = true
          for e in 0...num[i].size
            if num[i][e].is_a?(Array)
              returntrue2 = false
              for o in 0...num[i][e].size
                if !GetAsyncKeyState.call(num[i][e][o]).between?(0, 1)
                  returntrue2 = true
                end
              end
              returntrue = false if !returntrue2
            elsif GetAsyncKeyState.call(num[i][e]).between?(0, 1)
              returntrue = false
            end
          end
          return true if returntrue
        else
          return true if !GetAsyncKeyState.call(num[i]).between?(0, 1)
        end
      end
      return false
    else
      return !GetAsyncKeyState.call(num).between?(0, 1)
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Press all **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.press_all
    pressed = []
    for i in 0..255
      pressed.push(i) if Input.press?(i)
    end
    return pressed
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Trigger **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.trigger?(num)
    if num.is_a?(Array)
      for i in 0...num.size
        if num[i].is_a?(Array)
          returntrue = true
          for e in 0...num[i].size
            if num[i][e].is_a?(Array)
              returntrue2 = false
              for o in 0...num[i][e].size
                if @trigger[num[i][e][o]]
                  returntrue2 = true
                end
              end
              returntrue = false if !returntrue2
            elsif @trigger[num[i][e]]
              returntrue = false
            end
          end
          return true if returntrue
        else
          return true if @trigger[num[i]]
        end
      end
      return false
    else
      return @trigger[num]
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Trigger all **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.trigger_all
    triggered = []
    for i in 0..255
      triggered.push(i) if @trigger[i]
    end
    return triggered
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Repeat **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.repeat?(num)
    if num.is_a?(Array)
      for i in 0...num.size
        if num[i].is_a?(Array)
          returntrue = true
          for e in 0...num[i].size
            if num[i][e].is_a?(Array)
              returntrue2 = false
              for o in 0...num[i][e].size
                if @repeat[num[i][e][o]]
                  returntrue2 = true
                end
              end
              returntrue = false if !returntrue2
            elsif @repeat[num[i][e]]
              returntrue = false
            end
          end
          return true if returntrue
        else
          return true if @repeat[num[i]]
        end
      end
      return false
    else
      return @repeat[num]
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Repeat all **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.repeat_all
    repeated = []
    for i in 0..255
      repeated.push(i) if @repeat[i]
    end
    return repeated
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Reiterate **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.reiterate?(num)
    if num.is_a?(Array)
      for i in 0...num.size
        if num[i].is_a?(Array)
          returntrue = true
          for e in 0...num[i].size
            if num[i][e].is_a?(Array)
              returntrue2 = false
              for o in 0...num[i][e].size
                if @reiterate[num[i][e][o]]
                  returntrue2 = true
                end
              end
              returntrue = false if !returntrue2
            elsif @reiterate[num[i][e]]
              returntrue = false
            end
          end
          return true if returntrue
        else
          return true if @reiterate[num[i]]
        end
      end
      return false
    else
      return @reiterate[num]
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Reiterate all **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.reiterate_all
    reiterated = []
    for i in 0..255
      reiterated.push(i) if @reiterate[i]
    end
    return reiterated
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Release **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.release?(num)
    if num.is_a?(Array)
      for i in 0...num.size
        if num[i].is_a?(Array)
          returntrue = true
          for e in 0...num[i].size
            if num[i][e].is_a?(Array)
              returntrue2 = false
              for o in 0...num[i][e].size
                if @release[num[i][e][o]]
                  returntrue2 = true
                end
              end
              returntrue = false if !returntrue2
            elsif @release[num[i][e]]
              returntrue = false
            end
          end
          return true if returntrue
        else
          return true if @release[num[i]]
        end
      end
      return false
    else
      return @release[num]
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Release All **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.release_all
    release = []
    for i in 0..255
      release.push(i) if @release[i]
    end
    return release
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** 4 Directions **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.dir4
    return 2 if Input.press?(Input::DOWN)
    return 4 if Input.press?(Input::LEFT)
    return 6 if Input.press?(Input::RIGHT)
    return 8 if Input.press?(Input::UP)
    return 0
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** 8 Directions **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.dir8
    return 1 if Input.press?([[Input::DOWN, Input::LEFT]])
    return 3 if Input.press?([[Input::DOWN, Input::RIGHT]])
    return 7 if Input.press?([[Input::UP, Input::LEFT]])
    return 9 if Input.press?([[Input::UP, Input::RIGHT]])
    return 1 if Input.press?(Input::LOWER_LEFT)
    return 3 if Input.press?(Input::LOWER_RIGHT)
    return 7 if Input.press?(Input::UPPER_LEFT)
    return 9 if Input.press?(Input::UPPER_RIGHT)
    return 2 if Input.press?(Input::DOWN)
    return 4 if Input.press?(Input::LEFT)
    return 6 if Input.press?(Input::RIGHT)
    return 8 if Input.press?(Input::UP)
    return 0
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Activated **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.activated?(num)
    return GetKeyState.call(20) & 0x01 == 1 if num == 1 or num == 20
    return GetKeyState.call(144) & 0x01 == 1 if num == 2 or num == 144
    return GetKeyState.call(145) & 0x01 == 1 if num == 3 or num == 145
    return nil
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Key event **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.event(num)
    if num.is_a?(Array)
      for i in num
        Keybd_event.call(i,0,0,0)
      end
      for i in num
        Keybd_event.call(i,0,2,0)
      end
    else
      Keybd_event.call(num,0,0,0)
      Keybd_event.call(num,0,2,0)
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Free key **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.free_key(num)
    if num.is_a?(Array)
      for i in num
        Keybd_event.call(i,0,2,0)
      end
    else
      Keybd_event.call(num,0,2,0)
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  #  ** Free all keys **
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def Input.free_all_keys
    for i in 0..255
      Keybd_event.call(i,0,2,0)
    end
  end
end

#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#  *** Interpreter ***
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
class Interpreter
  def input_button
    n = 0
    n = 1 if Input.trigger?(Input::LOWER_LEFT)
    n = 3 if Input.trigger?(Input::LOWER_RIGHT)
    n = 7 if Input.trigger?(Input::UPPER_LEFT)
    n = 9 if Input.trigger?(Input::UPPER_RIGHT)
    n = 2 if Input.trigger?(Input::DOWN)
    n = 4 if Input.trigger?(Input::LEFT)
    n = 6 if Input.trigger?(Input::RIGHT)
    n = 8 if Input.trigger?(Input::UP)
    n = 11 if Input.trigger?(Input::A)
    n = 12 if Input.trigger?(Input::B)
    n = 13 if Input.trigger?(Input::C)
    n = 14 if Input.trigger?(Input::X)
    n = 15 if Input.trigger?(Input::Y)
    n = 16 if Input.trigger?(Input::Z)
    n = 17 if Input.trigger?(Input::L)
    n = 18 if Input.trigger?(Input::R)
    if n > 0
      $game_variables[@button_input_variable_id] = n
      $game_map.need_refresh = true
      @button_input_variable_id = 0
    end
  end
  #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  def command_111
    result = false
    case @parameters[0]
    when 0
      result = ($game_switches[@parameters[1]] == (@parameters[2] == 0))
    when 1
      value1 = $game_variables[@parameters[1]]
      if @parameters[2] == 0
        value2 = @parameters[3]
      else
        value2 = $game_variables[@parameters[3]]
      end
      case @parameters[4]
      when 0
        result = (value1 == value2)
      when 1
        result = (value1 >= value2)
      when 2
        result = (value1 <= value2)
      when 3
        result = (value1 > value2)
      when 4
        result = (value1 < value2)
      when 5
        result = (value1 != value2)
      end
    when 2
      if @event_id > 0
        key = [$game_map.map_id, @event_id, @parameters[1]]
        if @parameters[2] == 0
          result = ($game_self_switches[key] == true)
        else
          result = ($game_self_switches[key] != true)
        end
      end
    when 3
      if $game_system.timer_working
        sec = $game_system.timer / Graphics.frame_rate
        if @parameters[2] == 0
          result = (sec >= @parameters[1])
        else
          result = (sec <= @parameters[1])
        end
      end
    when 4
      actor = $game_actors[@parameters[1]]
      if actor != nil
        case @parameters[2]
        when 0
          result = ($game_party.actors.include?(actor))
        when 1
          result = (actor.name == @parameters[3])
        when 2
          result = (actor.skill_learn?(@parameters[3]))
        when 3
          result = (actor.weapon_id == @parameters[3])
        when 4
          result = (actor.armor1_id == @parameters[3] or
                    actor.armor2_id == @parameters[3] or
                    actor.armor3_id == @parameters[3] or
                    actor.armor4_id == @parameters[3])
        when 5
          result = (actor.state?(@parameters[3]))
        end
      end
    when 5
      enemy = $game_troop.enemies[@parameters[1]]
      if enemy != nil
        case @parameters[2]
        when 0
          result = (enemy.exist?)
        when 1
          result = (enemy.state?(@parameters[3]))
        end
      end
    when 6
      character = get_character(@parameters[1])
      if character != nil
        result = (character.direction == @parameters[2])
      end
    when 7
      if @parameters[2] == 0
        result = ($game_party.gold >= @parameters[1])
      else
        result = ($game_party.gold <= @parameters[1])
      end
    when 8
      result = ($game_party.item_number(@parameters[1]) > 0)
    when 9
      result = ($game_party.weapon_number(@parameters[1]) > 0)
    when 10
      result = ($game_party.armor_number(@parameters[1]) > 0)
    when 11
      n = Input::DOWN if @parameters[1] == 2
      n = Input::LEFT if @parameters[1] == 4
      n = Input::RIGHT if @parameters[1] == 6
      n = Input::UP if @parameters[1] == 8
      n = Input::A if @parameters[1] == 11
      n = Input::B if @parameters[1] == 12
      n = Input::C if @parameters[1] == 13
      n = Input::X if @parameters[1] == 14
      n = Input::Y if @parameters[1] == 15
      n = Input::Z if @parameters[1] == 16
      n = Input::L if @parameters[1] == 17
      n = Input::R if @parameters[1] == 18
      result = (Input.press?(n))
    when 12
      result = eval(@parameters[1])
    end
    @branch[@list[@index].indent] = result
    if @branch[@list[@index].indent] == true
      @branch.delete(@list[@index].indent)
      return true
    end
    return command_skip
  end
end

Second Player [ Selecionar ] [ - ]

#-------------------------------------------------------------------------------
# Multi-Player with Split Screen Script and SDK compatibility
# Version: 3.6
# By: Luis
# * Credit me, if you used it.
# * Please give your opinion and ideas in the RXMP forum. 
# Thanks to Aleworks for the Input Module.
#-------------------------------------------------------------------------------
=begin
  * Improvements:
    -Player 2 can move the selections windows
    -Alising of some parts of the code that was missing.
    -The player can select between a 1 player game or a 2 players game.
        
  * Next Versions:
    -ABS compatibility.
    -Menu for player 2.
    -More Interpreter Commands.
    -Message Window for player 2.
    -Players can be in diferents maps.
-Option to make appear the Names of Players.
-Change the separator line between vertical and horizontal(vgvgf idea)
-Option to make diferent parties.
    -Change the number of players in-game.

--How to Use------------------------------------------------------------------                 
                     
  * To force move the Second player use the following code in a move route
    script command:     
     $game_player2.move_down       # Move Down
     $game_player2.move_up         # Move Up
     $game_player2.move_right      # Move Right
     $game_player2.move_left       # Move Left
     $game_player2.move_random     # Random Move
     $game_player2.move_forward    # 1 step forward
     $game_player2.move_backward   # 1 step backward
     $game_player2.turn_180        # Turn 180°
     $game_player2.turn_right      # Turn Right
     $game_player2.turn_left       # Turn Left
     $game_player2.turn_up         # Turn Up
     $game_player2.turn_down       # Turn down
     $game_player2.jump(x, y)      # Jump
     ............................. #more commands at Game_Character 2
       
  * Interpreter Commands *Use it with a script event command or move route.
          
   command_356               # Player 2 transparent, to reverse, call it again.
   command_357(dis, dir, sp) # Scroll the second screen.  
   command_358(x, y)         # Set new position of Player 2 in the same map.
                                 
  
  * To check if the second player is touching a button check the Aleworks Input 
  Module.
  
---SDK Compatibility-----------------------------------------------------------  

  This script is compatible with the SDK thats mean you can remove the SDK.log
  and the SDK.state and it always work but it will have less compatibility 
  with others scripts, I CAN'T KNOW IF IS GOING TO WORK WITH SOME SCRIPTS.
  
  
---Credits---------------------------------------------------------------------

  Please credit if you use this script because, this script is very complicated,
  it was difficult, even for me, in this code i put my efford and only to see
  grow the RMXP community.
  The credits go to Luis and credit Aleworks for the Input Module.
    
  
=end

  #--Variables-------------------------------------------------------------
   
    # Variable used in-game to check when is a multiplayer game.
    $MULTI_PLAYER_GAME = false
    # X starting point of Player 2
    $PLAYER_2_STARTING_POINT_X = 7   
    # Y starting point of Player 2
    $PLAYER_2_STARTING_POINT_Y = 8  
    # Activate and desactive the speak with player 2
    $CAN_TALK_TO_PLAYER_2 = true
    # Message to be display when talking to player 2
    $PLAYER_2_TEXT = "Control me with the A,W,S,D keys"      
  

    
#--------------------------------------------------------------------------
# Game_Map edited to work with the muliplayer script by luis.  
#--------------------------------------------------------------------------  
 class Game_Map
  #--------------------------------------------------------------------------   
  attr_accessor :display2_x                # display x-coordinate * 128
  attr_accessor :display2_y                # display y-coordinate * 128
  #-------------------------------------------------------------------------- 
  # ** New variables fo the display of the second screen.
  #--------------------------------------------------------------------------
  alias multi_initialize initialize
  #--------------------------------------------------------------------------  
    def initialize
      @display2_x = 0
      @display2_y = 0
    end  
  #--------------------------------------------------------------------------  
  # ** Set up the varibles.
  #--------------------------------------------------------------------------
  alias luis_multiplayer_game_map_multi_setup :setup
  #--------------------------------------------------------------------------  
   def setup(map_id)
     luis_multiplayer_game_map_multi_setup(map_id)
     @display2_x = 0
     @display2_y = 0
     @scroll_direction_2 = 2
     @scroll_rest_2 = 0
     @scroll_speed_2 = 4
   end
  #--------------------------------------------------------------------------
  # * Scroll Down
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    @display_y = [@display_y + distance, (self.height - 15) * 128].min
  end  
  #--------------------------------------------------------------------------
  # * Scroll Left
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    @display_x = [@display_x - distance, 0].max
  end
  #--------------------------------------------------------------------------
  # * Scroll Right
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_right(distance)
   if $MULTI_PLAYER_GAME  
    @display_x = [@display_x + distance, (self.width - 10) * 128].min
  else 
    @display_x = [@display_x + distance, (self.width - 20) * 128].min
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Up
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    @display_y = [@display_y - distance, 0].max
  end 
  #--------------------------------------------------------------------------
  # * Scroll Down2 Works with the multiplayer script: by: luis
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_down2(distance2)
    @display2_y = [@display2_y + distance2, (self.height - 15) * 128].min
  end
  #--------------------------------------------------------------------------
  # * Scroll Left2 Works with the multiplayer script: by: luis
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_left2(distance2)
    @display2_x = [@display2_x - distance2, 0].max
  end
  #--------------------------------------------------------------------------
  # * Scroll Right2 Works with the multiplayer script: by: luis
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_right2(distance2)
    @display2_x = [@display2_x + distance2, (self.width - 10) * 128].min
  end
  #--------------------------------------------------------------------------
  # * Scroll Up2 Works with the multiplayer script: by: luis
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_up2(distance2)
    @display2_y = [@display2_y - distance2, 0].max
  end 
  #--------------------------------------------------------------------------
  # ** Start Scroll for Player 2 screen
  #--------------------------------------------------------------------------
  def start_scroll2(direction2, distance2, speed2)
    @scroll_direction_2 = direction2
    @scroll_rest_2 = distance2 * 128
    @scroll_speed_2 = speed2
  end
  #--------------------------------------------------------------------------
  # ** Determine if Scrolling2
  #--------------------------------------------------------------------------
  def scrolling2?
    return @scroll_rest_2 > 0
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias luis_multiplayer_game_map_update update
  def update
    # If scrolling 2
    if @scroll_rest_2 > 0
      # Change from scroll speed to distance in map coordinates
      distance2 = 2 ** @scroll_speed_2
      # Execute scrolling
      case @scroll_direction_2
      when 2  # Down
        scroll_down2(distance2)
      when 4  # Left
        scroll_left2(distance2)
      when 6  # Right
        scroll_right2(distance2)
      when 8  # Up
        scroll_up2(distance2)
      end
      # Subtract distance scrolled
      @scroll_rest_2 -= distance2
    end
    luis_multiplayer_game_map_update
   end
end 

#--------------------------------------------------------------------------
# Game_Character edited to work with the muliplayer script by luis.  
#--------------------------------------------------------------------------  
 class Game_Character   
  #--------------------------------------------------------------------------
  # * Fix the bug with player 1 can walk trought player 2
  #--------------------------------------------------------------------------
  alias luis_multiplayer_game_character_passable? :passable?
  def passable?(x, y, d)
    # Get new coordinates
    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
    if $MULTI_PLAYER_GAME
    # If player coordinates are consistent with move destination
    if $game_player2.x == new_x and $game_player2.y == new_y
      # If through is OFF
      unless $game_player2.through
        # If your own graphic is the character
        if @character_name != ""
          # impassable
          return false
        end
      end
    end
   end 
     luis_multiplayer_game_character_passable?(x, y, d)
  end
   #--------------------------------------------------------------------------
  # * Get Screen2 X-Coordinates
  #--------------------------------------------------------------------------
  def screen2_x
    # Get screen coordinates from real coordinates and map display position
    return (@real_x - $game_map.display2_x + 3) / 4 + 16
  end
  #--------------------------------------------------------------------------
  # * Get Screen2 Y-Coordinates
  #--------------------------------------------------------------------------
  def screen2_y
    # Get screen coordinates from real coordinates and map display position
    y = (@real_y - $game_map.display2_y + 3) / 4 + 32
    # Make y-coordinate smaller via jump count
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end
  #--------------------------------------------------------------------------
  # * Get Screen2 Z-Coordinates
  #     height : character height
  #--------------------------------------------------------------------------
  def screen2_z(height = 0)
    # If display flag on closest surface is ON
    if @always_on_top
      # 999, unconditional
      return 999
    end
    # Get screen coordinates from real coordinates and map display position
    z = (@real_y - $game_map.display2_y + 3) / 4 + 32
    # If tile
    if @tile_id > 0
      # Add tile priority * 32
      return z + $game_map.priorities[@tile_id] * 32
    # If character
    else
      # If height exceeds 32, then add 31
      return z + ((height > 32) ? 31 : 0)
    end
  end
end 
#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles the player. Its functions include event starting
#  determinants and map scrolling. Refer to "$game_player" for the one
#  instance of this class.
#==============================================================================

class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # * Invariables
  #--------------------------------------------------------------------------
   CENTER_X = (160 - 16) * 4   #2players Center screen x-coordinate * 4
   CENTER_Y = (240 - 16) * 4   #2players Center screen y-coordinate * 4
   FIXED_CENTER_X = (320 - 16) * 4   # Normal Center screen x-coordinate * 4
   FIXED_CENTER_Y = (240 - 16) * 4   # Normal Center screen y-coordinate * 4
  #--------------------------------------------------------------------------
  # * Set Map Display Position to Center of Screen
  #--------------------------------------------------------------------------
  def center(x, y)
   if $MULTI_PLAYER_GAME
    max_x = ($game_map.width - 10) * 128
    max_y = ($game_map.height - 15) * 128
    $game_map.display_x = [0, [x * 128 - CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * 128 - CENTER_Y, max_y].min].max
  else
    max_x = ($game_map.width - 20) * 128
    max_y = ($game_map.height - 15) * 128
    $game_map.display_x = [0, [x * 128 - FIXED_CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * 128 - FIXED_CENTER_Y, max_y].min].max
    end 
  end 
  #--------------------------------------------------------------------------
  # * Check the coordinates and position of player 2
  #--------------------------------------------------------------------------
  alias luis_multiplayer_check_event_trigger_there :check_event_trigger_there
  def check_event_trigger_there(triggers)
    new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    if $MULTI_PLAYER_GAME
    if $game_player2.x == new_x and $game_player2.y == new_y
        # If starting determinant is front event (other than jumping)
        if not $game_player2.jumping? 
          $game_player2.text
          result = true
        end
      end
     end 
      luis_multiplayer_check_event_trigger_there(triggers) 
   end 
   #---------------------------------------------------------------------------
   # * 
   #---------------------------------------------------------------------------
   def update
    # Remember whether or not moving in local variables
    last_moving = moving?
    # If moving, event running, move route forcing, and message window
    # display are all not occurring
    unless moving? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      # Move player in the direction the directional button is being pressed
      case Input.dir4
      when 2
        move_down
      when 4
        move_left
      when 6
        move_right
      when 8
        move_up
      end
    end
    last_real_x = @real_x
    last_real_y = @real_y
    super
   if $MULTI_PLAYER_GAME 
    # If character moves down and is positioned lower than the center
    # of the screen
    if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
      # Scroll map down
      $game_map.scroll_down(@real_y - last_real_y)
    end
    # If character moves left and is positioned more let on-screen than
    # center
    if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
      # Scroll map left
      $game_map.scroll_left(last_real_x - @real_x)
    end
    # If character moves right and is positioned more right on-screen than
    # center
    if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
      # Scroll map right
      $game_map.scroll_right(@real_x - last_real_x)
    end
    # If character moves up and is positioned higher than the center
    # of the screen
    if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
      # Scroll map up
      $game_map.scroll_up(last_real_y - @real_y)
    end
  else
    # If character moves down and is positioned lower than the center
    # of the screen
    if @real_y > last_real_y and @real_y - $game_map.display_y > FIXED_CENTER_Y
      # Scroll map down
      $game_map.scroll_down(@real_y - last_real_y)
    end
    # If character moves left and is positioned more let on-screen than
    # center
    if @real_x < last_real_x and @real_x - $game_map.display_x < FIXED_CENTER_X
      # Scroll map left
      $game_map.scroll_left(last_real_x - @real_x)
    end
    # If character moves right and is positioned more right on-screen than
    # center
    if @real_x > last_real_x and @real_x - $game_map.display_x > FIXED_CENTER_X
      # Scroll map right
      $game_map.scroll_right(@real_x - last_real_x)
    end
    # If character moves up and is positioned higher than the center
    # of the screen
    if @real_y < last_real_y and @real_y - $game_map.display_y < FIXED_CENTER_Y
      # Scroll map up
      $game_map.scroll_up(last_real_y - @real_y)
    end
   end 
    # If not moving
    unless moving?
      # If player was moving last time
      if last_moving
        # Event determinant is via touch of same position event
        result = check_event_trigger_here([1,2])
        # If event which started does not exist
        if result == false
          # Disregard if debug mode is ON and ctrl key was pressed
          unless $DEBUG and Input.press?(Input::CTRL)
            # Encounter countdown
            if @encounter_count > 0
              @encounter_count -= 1
            end
          end
        end
      end
      # If C button was pressed
      if Input.trigger?(Input::C)
        # Same position and front event determinant
        check_event_trigger_here([0])
        check_event_trigger_there([0,1,2])
      end
    end
   end
   end 
 

#==============================================================================
# ** Game_Player 2
#------------------------------------------------------------------------------
#  This class added a second player into the game, based on "$game_player"
#==============================================================================

class Game_Player2 < Game_Character
  #--------------------------------------------------------------------------
  # * Invariables
  #--------------------------------------------------------------------------
  CENTER2_X = (160 - 16) * 4   # Center screen x-coordinate * 4
  CENTER2_Y = (240 - 16) * 4   # Center screen y-coordinate * 4
  #--------------------------------------------------------------------------
  # * Passable Determinants
  #     x : x-coordinate
  #     y : y-coordinate
  #     d : direction (0,2,4,6,8)
  #         * 0 = Determines if all directions are impassable (for jumping)
  #--------------------------------------------------------------------------
  def passable?(x, y, d)
    # Get new coordinates
    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
    # If coordinates are outside of map
    unless $game_map.valid?(new_x, new_y)
      # Impassable
      return false
    end
    # If debug mode is ON and ctrl key was pressed
    if $DEBUG and Input.press?(Input::CTRL)
      # Passable
      return true
    end
    super
  end
  #--------------------------------------------------------------------------
  # * Calls the message window ** Note: to change the text see the variables.
  #--------------------------------------------------------------------------
  def text
   if $CAN_TALK_TO_PLAYER_2 
     # If other text has been set to message_text
     if $game_temp.message_text != nil
       # End
       return false
     end
     # Set message end waiting flag and callback
     @message_waiting = true
     $game_temp.message_proc = Proc.new { @message_waiting = false }
     # Set message text on first line
     $game_temp.message_text = $PLAYER_2_TEXT + "\\n"
     line_count = 1
     return true
   end 
  end  
  #--------------------------------------------------------------------------
  # * Set Map Display Position to Center of Screen
  #--------------------------------------------------------------------------
  def center(x, y)
    max_x = ($game_map.width - 10) * 128
    max_y = ($game_map.height - 15) * 128
    $game_map.display2_x = [0, [x - CENTER2_X, max_x].min].max
    $game_map.display2_y = [0, [y - CENTER2_Y, max_y].min].max
  end
  #--------------------------------------------------------------------------
  # * Move to Designated Position
  #     x : x-coordinate
  #     y : y-coordinate
  #--------------------------------------------------------------------------
  def moveto(x, y)
    super
    # Centering
    center(real_x, real_y)
    # Make encounter count
    make_encounter_count
  end
  #--------------------------------------------------------------------------
  # * Get Encounter Count
  #--------------------------------------------------------------------------
  def encounter_count
    return @encounter_count
  end
  #--------------------------------------------------------------------------
  # * Make Encounter Count
  #--------------------------------------------------------------------------
  def make_encounter_count
    # Image of two dice rolling
    if $game_map.map_id != 0
      n = $game_map.encounter_step
      @encounter_count = rand(n) + rand(n) + 1
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    # If party members = 0
    if $game_party.actors.size == 0
      # Clear character file name and hue
      @character_name = ""
      @character_hue = 0
      # End method
      return
    end
    # Get lead actor
    actor = $game_party.actors[1]
    # Set character file name and hue
    @character_name = actor.character_name
    @character_hue = actor.character_hue
    # Initialize opacity level and blending method
    @opacity = 255
    @blend_type = 0
  end
  #--------------------------------------------------------------------------
  # * Same Position Starting Determinant
  #--------------------------------------------------------------------------
  def check_event_trigger_here(triggers)
    result = false
    # If event is running
    if $game_system.map_interpreter.running?
      return result
    end
    # All event loops
    for event in $game_map.events.values
      # If event coordinates and triggers are consistent
      if event.x == @x and event.y == @y and triggers.include?(event.trigger)
        # If starting determinant is same position event (other than jumping)
        if not event.jumping? and event.over_trigger?
          event.start
          result = true
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Front Envent Starting Determinant
  #--------------------------------------------------------------------------
  def check_event_trigger_there(triggers)
    result = false
    # If event is running
    if $game_system.map_interpreter.running?
      return result
    end
    # Calculate front event coordinates
    new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    # All event loops
    for event in $game_map.events.values
      # If event coordinates and triggers are consistent
      if event.x == new_x and event.y == new_y and
         triggers.include?(event.trigger)
        # If starting determinant is front event (other than jumping)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    # If fitting event is not found
    if result == false
      # If front tile is a counter
      if $game_map.counter?(new_x, new_y)
        # Calculate 1 tile inside coordinates
        new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
        new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
        # All event loops
        for event in $game_map.events.values
          # If event coordinates and triggers are consistent
          if event.x == new_x and event.y == new_y and
             triggers.include?(event.trigger)
            # If starting determinant is front event (other than jumping)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Touch Event Starting Determinant
  #--------------------------------------------------------------------------
  def check_event_trigger_touch(x, y)
    result = false
    # If event is running
    if $game_system.map_interpreter.running?
      return result
    end
    # All event loops
    for event in $game_map.events.values
      # If event coordinates and triggers are consistent
      if event.x == x and event.y == y and [1,2].include?(event.trigger)
        # If starting determinant is front event (other than jumping)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Remember whether or not moving in local variables
    last_moving = moving?
    # If moving, event running, move route forcing, and message window
    # display are all not occurring
    unless moving? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      # Move player in the direction the directional button is being pressed
     if $DIRECTIONS_8
      if Input.press?(83)
        move_down
      elsif Input.press?(65)
        move_left
      elsif Input.press?(68)
        move_right
      elsif Input.press?(87) 
        move_up
      elsif Input.press?(65) and Input.press?(87)   
        move_upper_left
      elsif Input.press?(68) and Input.press?(87)  
        move_upper_right
      elsif Input.press?(68) and Input.press?(83)     
        move_lower_right
      elsif Input.press?(65) and Input.press?(83)    
        move_lower_left
      end
    else
      if Input.press?(83)
        move_down
      elsif Input.press?(65)
        move_left
      elsif Input.press?(68)
        move_right
      elsif Input.press?(87) 
        move_up 
      end
     end 
   end      
    # Remember coordinates in local variables
    last_real_x = @real_x
    last_real_y = @real_y
    super
    # If character moves down and is positioned lower than the center
    # of the screen
    if @real_y > last_real_y and @real_y - $game_map.display2_y > CENTER2_Y
      # Scroll map down
      $game_map.scroll_down2(@real_y - last_real_y)
    end
    # If character moves left and is positioned more let on-screen than
    # center
    if @real_x < last_real_x and @real_x - $game_map.display2_x < CENTER2_X
      # Scroll map left
      $game_map.scroll_left2(last_real_x - @real_x)
    end
    # If character moves right and is positioned more right on-screen than
    # center
    if @real_x > last_real_x and @real_x - $game_map.display2_x > CENTER2_X
      # Scroll map right
      $game_map.scroll_right2(@real_x - last_real_x)
    end
    # If character moves up and is positioned higher than the center
    # of the screen
    if @real_y < last_real_y and @real_y - $game_map.display2_y < CENTER2_Y
      # Scroll map up
      $game_map.scroll_up2(last_real_y - @real_y)
    end
    # If not moving
    unless moving?
      # If player was moving last time
      if last_moving
        # Event determinant is via touch of same position event
        result = check_event_trigger_here([1,2])
        # If event which started does not exist
        if result == false
          # Disregard if debug mode is ON and ctrl key was pressed
          unless $DEBUG and Input.trigger?(9)
            # Encounter countdown
            if @encounter_count > 0
              @encounter_count -= 1
            end
          end
        end
      end
      # If TAB button was pressed
      if Input.trigger?(9)
        # Same position and front event determinant
        check_event_trigger_here([0])
        check_event_trigger_there([0,1,2])
      end
    end
  end
end

#==============================================================================
# ** Sprite_Character2
#------------------------------------------------------------------------------
#  This sprite is used to display the character.It observes the Game_Character
#  class and automatically changes sprite conditions.
#==============================================================================

class Sprite_Character2 < RPG::Sprite
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :character                # character
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     viewport  : viewport
  #     character : character (Game_Character)
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil)
    super(viewport)
    @character = character
    update
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    # If tile ID, file name, or hue are different from current ones
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_hue != @character.character_hue
      # Remember tile ID, file name, and hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      # If tile ID value is valid
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      # If tile ID value is invalid
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    # Set visible situation
    self.visible = (not @character.transparent)
    # If graphic is character
    if @tile_id == 0
      # Set rectangular transfer
      sx = @character.pattern * @cw
      sy = (@character.direction - 2) / 2 * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    # Set sprite coordinates
    self.x = @character.screen2_x
    self.y = @character.screen2_y
    self.z = @character.screen2_z(@ch)
    # Set opacity level, blend method, and bush depth
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    # Animation
    if animation = true
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  This class brings together map screen sprites, tilemaps, etc.
#  It's used within the Scene_Map class.
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    # Make viewports
   if $MULTI_PLAYER_GAME
    @viewport1 = Viewport.new(0, 0, 319, 480)
    @viewport2 = Viewport.new(0, 0, 319, 480)
    @viewport3 = Viewport.new(0, 0, 319, 480)
  else
    @viewport1 = Viewport.new(0, 0, 640, 480)
    @viewport2 = Viewport.new(0, 0, 640, 480)
    @viewport3 = Viewport.new(0, 0, 640, 480)
  end  
    @viewport2.z = 200
    @viewport3.z = 5000
    # Make tilemap
    @tilemap = Tilemap.new(@viewport1)
    @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name)
    end
    @tilemap.map_data = $game_map.data
    @tilemap.priorities = $game_map.priorities
    # Make panorama plane
    @panorama = Plane.new(@viewport1)
    @panorama.z = -1000
    # Make fog plane
    @fog = Plane.new(@viewport1)
    @fog.z = 3000
    # Make character sprites
    @character_sprites = []
    for i in $game_map.events.keys.sort
      sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
      @character_sprites.push(sprite)
    end
    @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
    @character_sprites.push(Sprite_Character.new(@viewport1, $game_player2)) if $MULTI_PLAYER_GAME
    # Make weather
    @weather = RPG::Weather.new(@viewport1)
    # Make picture sprites
    @picture_sprites = []
    for i in 1..50
      @picture_sprites.push(Sprite_Picture.new(@viewport2,
        $game_screen.pictures[i]))
    end
    # Make timer sprite
    @timer_sprite = Sprite_Timer.new
    # Frame update
    update
  end
end


#==============================================================================
# Spriteset_Map2
#------------------------------------------------------------------------------
# This class allows to see the second screen, that follows the second player
# based on the original "Spriteset_Map".
#==============================================================================

class Spriteset_Map2
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    # Make viewports
    @viewport1 = Viewport.new(325, 0, 319, 480)
    @viewport2 = Viewport.new(325, 0, 319, 480)
    @viewport3 = Viewport.new(325, 0, 319, 480)
    @viewport2.z = 200
    @viewport3.z = 5000
    # Make tilemap
    @tilemap = Tilemap.new(@viewport1)
    @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
    for i in 0..6
      autotile_name2 = $game_map.autotile_names[i]
      @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name2)
    end
    @tilemap.map_data = $game_map.data
    @tilemap.priorities = $game_map.priorities
    # Make panorama plane
    @panorama = Plane.new(@viewport1)
    @panorama.z = -1000
    # Make fog plane
    @fog = Plane.new(@viewport1)
    @fog.z = 3000
    # Make character sprites
    @character_sprites = []
    for i in $game_map.events.keys.sort
      sprite = Sprite_Character2.new(@viewport1, $game_map.events[i])
      @character_sprites.push(sprite)
    end
    @character_sprites.push(Sprite_Character2.new(@viewport1, $game_player))
    @character_sprites.push(Sprite_Character2.new(@viewport1, $game_player2))
    # Make weather
    @weather = RPG::Weather.new(@viewport1)
    # Make picture sprites
    @picture_sprites = []
    for i in 1..50
      @picture_sprites.push(Sprite_Picture.new(@viewport2,
        $game_screen.pictures[i]))
    end
    # Make timer sprite
    @timer_sprite = Sprite_Timer.new
    # Frame update
    update
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    # Dispose of tilemap
    @tilemap.tileset.dispose
    for i in 0..6
      @tilemap.autotiles[i].dispose
    end
    @tilemap.dispose
    # Dispose of panorama plane
    @panorama.dispose
    # Dispose of fog plane
    @fog.dispose
    # Dispose of character sprites
    for sprite in @character_sprites
      sprite.dispose
    end
    # Dispose of weather
    @weather.dispose
    # Dispose of picture sprites
    for sprite in @picture_sprites
      sprite.dispose
    end
    # Dispose of timer sprite
    @timer_sprite.dispose
    # Dispose of viewports
    @viewport1.dispose
    @viewport2.dispose
    @viewport3.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # If panorama is different from current one
    if @panorama_name != $game_map.panorama_name or
       @panorama_hue != $game_map.panorama_hue
      @panorama_name = $game_map.panorama_name
      @panorama_hue = $game_map.panorama_hue
      if @panorama.bitmap != nil
        @panorama.bitmap.dispose
        @panorama.bitmap = nil
      end
      if @panorama_name != ""
        @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue)
      end
      Graphics.frame_reset
    end
    # If fog is different than current fog
    if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue
      @fog_name = $game_map.fog_name
      @fog_hue = $game_map.fog_hue
      if @fog.bitmap != nil
        @fog.bitmap.dispose
        @fog.bitmap = nil
      end
      if @fog_name != ""
        @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue)
      end
      Graphics.frame_reset
    end
    # Update tilemap
    @tilemap.ox = $game_map.display2_x / 4
    @tilemap.oy = $game_map.display2_y / 4
    @tilemap.update
    # Update panorama plane
    @panorama.ox = $game_map.display2_x / 8
    @panorama.oy = $game_map.display2_y / 8
    # Update fog plane
    @fog.zoom_x = $game_map.fog_zoom / 100.0
    @fog.zoom_y = $game_map.fog_zoom / 100.0
    @fog.opacity = $game_map.fog_opacity
    @fog.blend_type = $game_map.fog_blend_type
    @fog.ox = $game_map.display2_x / 4 + $game_map.fog_ox
    @fog.oy = $game_map.display2_y / 4 + $game_map.fog_oy
    @fog.tone = $game_map.fog_tone
    # Update character sprites
    for sprite in @character_sprites
      sprite.update
    end
    # Update weather graphic
    @weather.type = $game_screen.weather_type
    @weather.max = $game_screen.weather_max
    @weather.ox = $game_map.display2_x / 4
    @weather.oy = $game_map.display2_y / 4
    @weather.update
    # Update picture sprites
    for sprite in @picture_sprites
      sprite.update
    end
    # Update timer sprite
    @timer_sprite.update
    # Set screen color tone and shake position
    @viewport1.tone = $game_screen.tone
    @viewport1.ox = $game_screen.shake
    # Set screen flash color
    @viewport3.color = $game_screen.flash_color
    # Update viewports
    @viewport1.update
    @viewport3.update
  end
end

#==============================================================================
# ** Window_Message
#------------------------------------------------------------------------------
#  This message window is used to display text.
#==============================================================================
class Window_Selectable < Window_Base
#------------------------------------------------------------------------------
# * Edit that makes possible player 2 to move the selection of the windows. 
#------------------------------------------------------------------------------
  def update
    super
    # If cursor is movable
    if self.active and @item_max > 0 and @index >= 0
      # If pressing down on the directional buttons
      if Input.repeat?(Input::DOWN) or Input.repeat?(83)
        # If column count is 1 and directional button was pressed down with no
        # repeat, or if cursor position is more to the front than
        # (item count - column count)
        if (@column_max == 1 and Input.trigger?(Input::DOWN) or Input.trigger?(83)) or
           @index < @item_max - @column_max
          # Move cursor down
          $game_system.se_play($data_system.cursor_se)
          @index = (@index + @column_max) % @item_max
        end
      end
      # If the up directional button was pressed
      if Input.repeat?(Input::UP) or Input.repeat?(87)
        # If column count is 1 and directional button was pressed up with no
        # repeat, or if cursor position is more to the back than column count
        if (@column_max == 1 and Input.trigger?(Input::UP) or Input.trigger?(87)) or
           @index >= @column_max
          # Move cursor up
          $game_system.se_play($data_system.cursor_se)
          @index = (@index - @column_max + @item_max) % @item_max
        end
      end
      # If the right directional button was pressed
      if Input.repeat?(Input::RIGHT) or Input.repeat?(68)
        # If column count is 2 or more, and cursor position is closer to front
        # than (item count -1)
        if @column_max >= 2 and @index < @item_max - 1
          # Move cursor right
          $game_system.se_play($data_system.cursor_se)
          @index += 1
        end
      end
      # If the left directional button was pressed
      if Input.repeat?(Input::LEFT) or Input.repeat?(65)
        # If column count is 2 or more, and cursor position is more back than 0
        if @column_max >= 2 and @index > 0
          # Move cursor left
          $game_system.se_play($data_system.cursor_se)
          @index -= 1
        end
      end
      # If R button was pressed
      if Input.repeat?(Input::R)
        # If bottom row being displayed is more to front than bottom data row
        if self.top_row + (self.page_row_max - 1) < (self.row_max - 1)
          # Move cursor 1 page back
          $game_system.se_play($data_system.cursor_se)
          @index = [@index + self.page_item_max, @item_max - 1].min
          self.top_row += self.page_row_max
        end
      end
      # If L button was pressed
      if Input.repeat?(Input::L)
        # If top row being displayed is more to back than 0
        if self.top_row > 0
          # Move cursor 1 page forward
          $game_system.se_play($data_system.cursor_se)
          @index = [@index - self.page_item_max, 0].max
          self.top_row -= self.page_row_max
        end
      end
    end
    # Update help text (update_help is defined by the subclasses)
    if self.active and @help_window != nil
      update_help
    end
    # Update cursor rectangle
    update_cursor_rect
  end
end  

#----------------------------------------------------------------------------
# ** Interpreter Edits **Check the comments to use this new methods.
#----------------------------------------------------------------------------
class Interpreter
  #--------------------------------------------------------------------------
  # * Get Character *** New method
  #     parameter : parameter
  #--------------------------------------------------------------------------
  def get_character(parameter)
    # Branch by parameter
   if $MULTI_PLAYER_GAME
    case parameter
    when -2 # player2
      return $game_player2
    when -1  # player
      return $game_player
    when 0  # this event
      events = $game_map.events
      return events == nil ? nil : events[@event_id]
    else  # specific event
      events = $game_map.events
      return events == nil ? nil : events[parameter]
     end 
   end
  end
  #--------------------------------------------------------------------------
  # * Change Player 2 Transparent Flag ** See notes at begining
  #--------------------------------------------------------------------------
  def command_356
   if $MULTI_PLAYER_GAME
    # Change player 2 transparent flag
    if $game_player2.transparent
      $game_player2.transparent = (false)
    else  
      $game_player2.transparent = (true)
    end  
    # Continue
    return true
  else
    print "Error: Player is not available"
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Second Map Screen
  #--------------------------------------------------------------------------
  def command_357(direction2, distance2, speed2)
    # If in battle
    if $game_temp.in_battle
      # Continue
      return true
    end
    # If already scrolling
    if $game_map.scrolling2?
      # End
      return false
    end
    # Start scroll
    $game_map.start_scroll2(direction2, distance2, speed2)
    # Continue
    return true
  end
  #--------------------------------------------------------------------------
  # ** Move the player 2 in the same map
  #--------------------------------------------------------------------------
  def command_358(x, y)
    if $MULTI_PLAYER_GAME
    $game_player2.moveto(x, y)
  else
    print "Error: Player is not available"
    end
  end  
  #--------------------------------------------------------------------------
  # ** Do Animation for Player 2
  #--------------------------------------------------------------------------
  def command_359(animation_id)
    if $MULTI_PLAYER_GAME
    # Get character
    character = get_character(-2)
    # If no character exists
    if character == nil
      # Continue
      return true
    end
    # Set animation ID
    character.animation_id = animation_id
    # Continue
    return true
  else
    print "Error: Player is not available"
   end
  end 
  #--------------------------------------------------------------------------
  # * Set Move Route for player 2 ** see How to
  #--------------------------------------------------------------------------
  def command_400(moves)
    # Get character
    character = get_character(-2)
    # If no character exists
    if character == nil
      # Continue
      return true
    end
    # Force move route
    character.force_move_route(moves)
    # Continue
    return true
  end
end
#--------------------------------------------------------------------------
# Scene_Map edited to work with the muliplayer script by luis.  
#--------------------------------------------------------------------------  
 class Scene_Map
#------------------------------------------------------------------------------  
# ** Main
#------------------------------------------------------------------------------ 
  alias luis_multiplayer_scene_map_main main
   def main
     @spriteset2 = Spriteset_Map2.new if $MULTI_PLAYER_GAME
     luis_multiplayer_scene_map_main
     @spriteset2.dispose if $MULTI_PLAYER_GAME
   end
 #------------------------------------------------------------------------------ 
 # ** Check if player 2 is activate.
 #------------------------------------------------------------------------------ 
  alias luis_multiplayer_scene_map_update update
   def update
     $game_player2.update if $MULTI_PLAYER_GAME 
     luis_multiplayer_scene_map_update
     @spriteset2.update if $MULTI_PLAYER_GAME
   end
 #------------------------------------------------------------------------------  
 # ** Call Battle
 #------------------------------------------------------------------------------ 
  alias luis_multiplayer_scene_map_call_battle call_battle
   def call_battle
     luis_multiplayer_scene_map_call_battle
     $game_player2.straighten if $MULTI_PLAYER_GAME  
   end 
 #------------------------------------------------------------------------------  
 # ** Call Shop
 #------------------------------------------------------------------------------ 
  alias luis_multiplayer_scene_map_call_shop call_shop
   def call_shop
     luis_multiplayer_scene_map_call_shop
     $game_player2.straighten if $MULTI_PLAYER_GAME
  end 
 #------------------------------------------------------------------------------ 
 # ** Call Name
 #------------------------------------------------------------------------------ 
  alias luis_multiplayer_scene_map_call_name call_name
   def call_name
     luis_multiplayer_scene_map_call_name
     $game_player2.straighten if $MULTI_PLAYER_GAME
   end 
 #------------------------------------------------------------------------------  
 # ** Scene_Save
 #------------------------------------------------------------------------------
  alias luis_multiplayer_scene_map_call_save call_save
   def call_save
     luis_multiplayer_scene_map_call_save
     $game_player2.straighten if $MULTI_PLAYER_GAME
   end  
 #------------------------------------------------------------------------------ 
 # ** Straight the player 2 when Debug is call.
 #------------------------------------------------------------------------------
  alias luis_multiplayer_scene_map_call_debug call_debug
   def call_debug
     luis_multiplayer_scene_map_call_debug
     $game_player2.straighten if $MULTI_PLAYER_GAME
   end
 #------------------------------------------------------------------------------ 
 # ** Transfer the player 2 to the new map.
 #------------------------------------------------------------------------------ 
  alias luis_multiplayer_scene_map_transfer_player transfer_player
   def transfer_player
    $game_temp.player_transferring = false
    # If move destination is different than current map
    if $game_map.map_id != $game_temp.player_new_map_id
      # Set up a new map
      $game_map.setup($game_temp.player_new_map_id)
    end
    # Check if player 2 is activate
    transfer_player_2 if $MULTI_PLAYER_GAME
    # Set up
    $game_player.moveto($game_temp.player_new_x, $game_temp.player_new_y)
    case $game_temp.player_new_direction
    when 2  
      $game_player.turn_down
    when 4  # left
      $game_player.turn_left
    when 6  # right
      $game_player.turn_right
    when 8  # up
      $game_player.turn_right
    end 
     # Straighten player position
    $game_player.straighten
    # Update map (run parallel process event)
    $game_map.update
    # Remake sprite set
    @spriteset.dispose
    @spriteset = Spriteset_Map.new
    # If processing transition
    if $game_temp.transition_processing
      # Clear transition processing flag
      $game_temp.transition_processing = false
      # Execute transition
      Graphics.transition(20)
    end
    # Run automatic change for BGM and BGS set on the map
    $game_map.autoplay
    # Frame reset
    Graphics.frame_reset
    # Update input information
    Input.update
  end
  #-----------------------------------------------------------------------------
  # * Transfer the second player.
  #-----------------------------------------------------------------------------
  def transfer_player_2  
    $game_player2.moveto($game_temp.player_new_x + 1, $game_temp.player_new_y)
    case $game_temp.player_new_direction
    when 2  
      $game_player2.turn_down
    when 4  # left
      $game_player2.turn_left
    when 6  # right
      $game_player2.turn_right
    when 8  # up
      $game_player2.turn_up
    end
    $game_map.update
    $game_player2.straighten
    $game_player2.center($game_player2.real_x,$game_player2.real_y)
    @spriteset2.dispose
    @spriteset2 = Spriteset_Map2.new
   end
 end
 
#--------------------------------------------------------------------------
# Scene_Title edited to work with the muliplayer script by luis.  
#--------------------------------------------------------------------------  
 class Scene_Title          
#------------------------------------------------------------------------------  
# ** New Game. Make the player 2. 
#------------------------------------------------------------------------------ 
  alias luis_multiplayer_scene_title_command_new_game2 command_new_game2
    def command_new_game2
      $MULTI_PLAYER_GAME = true
      luis_multiplayer_scene_title_command_new_game2
      $game_player2 = Game_Player2.new
      $game_player2.moveto($PLAYER_2_STARTING_POINT_X, $PLAYER_2_STARTING_POINT_Y)
      $game_player2.center($game_player2.real_x,$game_player2.real_y)
      $game_player2.refresh
      $game_map.autoplay
      $game_map.update
  end  
 #------------------------------------------------------------------------------
 # ** Creates the game objects to be used in battle test.
 #------------------------------------------------------------------------------  
 alias luis_multiplayer_scene_title_battle_test battle_test
   def battle_test
      luis_multiplayer_scene_title_battle_test
      $game_player2 = Game_Player2.new if $MULTI_PLAYER_GAME
   end  
  end 
#--------------------------------------------------------------------------
# Scene_Save edited to work with the muliplayer script by luis.  
#--------------------------------------------------------------------------  
 class Scene_Save
 #------------------------------------------------------------------------------  
 alias luis_multiplayer_scene_save_write_save_data :write_save_data
   def write_save_data(file)
     if $MULTI_PLAYER_GAME 
    luis_multiplayer_scene_save_write_save_data(file) 
    Marshal.dump($game_player2, file)
    end
   end
  end   
#--------------------------------------------------------------------------
# Scene_Load edited to work with the muliplayer script by luis.  
#--------------------------------------------------------------------------  
 class Scene_Load  
 #------------------------------------------------------------------------------ 
 # ** Saves the position and stats of the player 2
 #------------------------------------------------------------------------------ 
 alias luis_multiplayer_scene_save_read_save_data :read_save_data
   def read_save_data(file)
     if $MULTI_PLAYER_GAME 
     luis_multiplayer_scene_save_read_save_data(file)
     $game_player2 = Marshal.load(file)
    end
  end
 end  
#------------------------------------------------------------------------------

Download

Visualizações: 111 Downloads: 20

Informações

Desenvolvimento: Luis

Categoria: Miscellaneous Systems

Classe: RGSS

Versão: 3.6

Tamanho: 979,97 kB

Ultima atualização: 05/03/09

Discuta

Você precisa estar logado para criar um tópico de discução em nosso Forum. Faça Login ou Registre-se por favor.

Envie para um amigo

Envie um e-mail indicando este script para um amigo seu!

E-mail enviado com sucesso!!

Falha no envio do e-mail!!!
Talvez algum campo ficou sem preenchimento!

Multi–Player

Download

Informações

Discuta

Envie para um amigo

Favoritos