Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- def pbSameThread(wnd)
- return false if wnd==0
- processid=[0].pack('l')
- getCurrentThreadId=Win32API.new('kernel32','GetCurrentThreadId', '%w()','l')
- getWindowThreadProcessId=Win32API.new('user32','GetWindowThreadProcessId', '%w(l p)','l')
- threadid=getCurrentThreadId.call
- wndthreadid=getWindowThreadProcessId.call(wnd,processid)
- return (wndthreadid==threadid)
- end
- module Input
- DOWN = 2
- LEFT = 4
- RIGHT = 6
- UP = 8
- A = 11
- B = 12
- C = 13
- X = 14
- Y = 15
- Z = 16
- L = 17
- R = 18
- SHIFT = 21
- CTRL = 22
- ALT = 23
- F5 = 25
- F6 = 26
- F7 = 27
- F8 = 28
- F9 = 29
- LeftMouseKey = 1
- RightMouseKey = 2
- # GetAsyncKeyState or GetKeyState will work here
- @GetKeyState=Win32API.new("user32", "GetAsyncKeyState", "i", "i")
- @GetForegroundWindow=Win32API.new("user32", "GetForegroundWindow", "", "i")
- # Returns whether a key is being pressed
- @PadState=Win32API.new("xinput1_3.dll","XInputGetState","ip","l")
- Buttons=[64,128,32,16,256,512,1024,2048,1,16384,2,32768]
- Assign=[64,128,32,16,256,512,1024,2048,1,16384,2,32768]
- @counter=0
- @DeadZone=[]
- def self.getstate(key)
- return (@GetKeyState.call(key)&0x8000)>0
- end
- def self.PadState(key) #Basicamente, el nucleo de todo esto, all hail this method
- inputData= "\0" * 16
- @PadState.call(0,inputData)
- arr=inputData.unpack("ssnnssss")
- if @DeadZone.empty?
- @DeadZone.push(arr[4],arr[5],arr[6],arr[7])
- end
- if key==Assign[6] && (arr[4]==-32767||arr[6]==-32767)
- return true
- end
- if key==Assign[7] && (arr[6]==32767 || arr[4]==32767)
- return true
- end
- if key==Assign[4] && (arr[5]==32767 || arr[7]==32767)
- return true
- end
- if key==Assign[5] && (arr[5]==-32767 || arr[7]==-32767)
- return true
- end
- if key==Assign[3] && arr[3]>100
- return true
- end
- if arr[2]==key
- return true
- end
- return false
- end
- def self.State2(key)
- data=self.PadState(key)
- code=self.GetCode(key)
- if data==true && @padPState[code]==false
- @padPState[code]=true
- @padKeyState[code]+=1
- return true
- end
- if data==false
- @padPState[code]=false
- @padKeyState[code]=0
- return false
- end
- if data==true && @padPState[code]==true
- @padKeyState[code]+=1
- return false
- end
- return false
- end
- def self.State(key)
- data=self.PadState(key)
- code=self.GetCode(key)
- if data==true && @padPressState[code]==false
- @padPressState[code]=true
- @padKeyState[code]+=1
- return true
- end
- if data==false
- @padPressState[code]=false
- @padKeyState[code]=0
- return false
- end
- if data==true && @padPressState[code]==true
- @padKeyState[code]+=1
- return false
- end
- return false
- end
- def self.padVibrate(vibration1,vibration2)
- @SetState=Win32API.new("xinput1_3.dll","XInputSetState","ip","")
- @SetState.call(0,"#{vibration1},#{vibration2}")
- end
- def self.updateKeyState(i)
- gfw=pbSameThread(@GetForegroundWindow.call())
- if !@stateUpdated[i]
- newstate=self.getstate(i) && gfw
- @triggerstate[i]=(newstate&&@keystate[i]==0)
- @releasestate[i]=(!newstate&&@keystate[i]>0)
- @keystate[i]=newstate ? @keystate[i]+1 : 0
- @stateUpdated[i]=true
- end
- end
- def self.Update(i,identifier=0)
- gfw = pbSameThread(@GetForegroundWindow.call())
- if !@padStateUpdated[i]
- state=(self.PadState(Assign[i]) && gfw)
- @padTriggerState[i]=(state && @padKeyState[i]==0)
- @padKeyState[i]=(state ? @padKeyState[i]+1 : 0)
- @padReleaseState[i]=(!state && @padKeyState[i]>0)
- @padStateUpdated[i]=true
- end
- end
- def self.update
- if @keystate
- for i in 0...256
- # just noting that the state should be updated
- # instead of thunking to Win32 256 times
- @stateUpdated[i]=false
- if @keystate[i] > 0
- # If there is a repeat count, update anyway
- # (will normally apply only to a very few keys)
- updateKeyState(i)
- end
- if @counter>Assign.size
- @counter=0
- end
- @padStateUpdated[@counter]=false
- if @padKeyState
- if @padKeyState[@counter]>0
- self.Update(@counter)
- end
- end
- @counter+=1
- end
- else
- @stateUpdated=[]
- @keystate=[]
- @triggerstate=[]
- @releasestate=[]
- @padStateUpdated=[]
- @padKeyState=[]
- @padTriggerState=[]
- @padPressState=[]
- @padPState=[]
- @padReleaseState=[]
- for i in 0...256
- @stateUpdated[i]=true
- @keystate[i]=self.getstate(i) ? 1 : 0
- @triggerstate[i]=false
- @releasestate[i]=false
- if i<=Assign.size
- @padStateUpdated[i]=true
- @padKeyState[i]= self.PadState(i) ? 1 : 0
- @padTriggerState[i]=false
- @padPressState[i]=false
- @padReleaseState[i]=false
- @padPState[i]=false
- end
- end
- end
- end
- def self.buttonToKey(button)
- case button
- when Input::DOWN
- return [0x28] # Down
- when Input::LEFT
- return [0x25] # Left
- when Input::RIGHT
- return [0x27] # Right
- when Input::UP
- return [0x26] # Up
- when Input::A
- return [0x5A,0x10] # Z, Shift
- when Input::B
- return [0x58,0x1B] # X, ESC
- when Input::C
- return [0x43,0x0D,0x20] # C, ENTER, Space
- when Input::X
- return [0x41] # A
- when Input::Y
- return [0x53] # S
- when Input::Z
- return [0x44] # D
- when Input::L
- return [0x51,0x21] # Q, Page Up
- when Input::R
- return [0x57,0x22] # W, Page Down
- when Input::SHIFT
- return [0x10] # Shift
- when Input::CTRL
- return [0x11] # Ctrl
- when Input::ALT
- return [0x12] # Alt
- when Input::F5
- return [0x74] # F5
- when Input::F6
- return [0x75] # F6
- when Input::F7
- return [0x76] # F7
- when Input::F8
- return [0x77] # F8
- when Input::F9
- return [0x78] # F9
- else
- return []
- end
- end
- def self.PadCode(button) #Returns the key value
- case button
- when Input::UP; return [Assign[4]]
- when Input::DOWN; return [Assign[5]]
- when Input::LEFT; return [Assign[6]]
- when Input::RIGHT; return [Assign[7]]
- when Input::B; return [Assign[1]]
- when Input::C; return [Assign[2]]
- when Input::A; return [Assign[3]]
- when Input::L; return [Assign[8]]
- when Input::R; return [Assign[10]]
- end
- return []
- end
- def self.dir4
- button=0
- repeatcount=0
- if self.press?(Input::DOWN) && self.press?(Input::UP)
- return 0
- end
- if self.press?(Input::LEFT) && self.press?(Input::RIGHT)
- return 0
- end
- for b in [Input::DOWN,Input::LEFT,Input::RIGHT,Input::UP]
- rc=self.count(b)
- if rc>0
- if repeatcount==0 || rc<repeatcount
- button=b
- repeatcount=rc
- end
- end
- end
- return button
- end
- def self.dir8
- buttons=[]
- for b in [Input::DOWN,Input::LEFT,Input::RIGHT,Input::UP]
- rc=self.count(b)
- if rc>0
- buttons.push([b,rc])
- end
- end
- if buttons.length==0
- return 0
- elsif buttons.length==1
- return buttons[0][0]
- elsif buttons.length==2
- # since buttons sorted by button, no need to sort here
- if (buttons[0][0]==Input::DOWN && buttons[1][0]==Input::UP)
- return 0
- end
- if (buttons[0][0]==Input::LEFT && buttons[1][0]==Input::RIGHT)
- return 0
- end
- end
- buttons.sort!{|a,b| a[1]<=>b[1]}
- updown=0
- leftright=0
- for b in buttons
- if updown==0 && (b[0]==Input::UP || b[0]==Input::DOWN)
- updown=b[0]
- end
- if leftright==0 && (b[0]==Input::LEFT || b[0]==Input::RIGHT)
- leftright=b[0]
- end
- end
- if updown==Input::DOWN
- return 1 if leftright==Input::LEFT
- return 3 if leftright==Input::RIGHT
- return 2
- elsif updown==Input::UP
- return 7 if leftright==Input::LEFT
- return 9 if leftright==Input::RIGHT
- return 8
- else
- return 4 if leftright==Input::LEFT
- return 6 if leftright==Input::RIGHT
- return 0
- end
- end
- def self.count(button)
- for btn in self.buttonToKey(button)
- c=self.repeatcount(btn)
- return c if c>0
- end
- for btn in self.PadCode(button)
- c=self.padRepeatCount(btn)
- return c if c>0
- end
- return 0
- end
- def self.release?(button)
- rc=0
- for btn in self.buttonToKey(button)
- c=self.repeatcount(btn)
- return false if c>0
- rc+=1 if self.releaseex?(btn)
- end
- for btn in self.PadCode(button)
- c=self.padRepeatCount(btn)
- return false if c>0
- rc+=1 if self.padReleaseex?(btn)
- end
- return rc>0
- end
- def self.trigger?(button)
- trigger= self.buttonToKey(button).any? {|item| self.triggerex?(item) }
- pad = self.PadCode(button).any? {|item| self.padTriggerex?(item)}
- return trigger || pad
- end
- def self.repeat?(button)
- trigger= self.buttonToKey(button).any? {|item| self.repeatex?(item) }
- pad= self.PadCode(button).any? {|item| self.padRepeatex?(item)}
- return trigger || pad
- end
- def self.press?(button)
- return self.count(button)>0
- end
- def self.repeatex?(key)
- return false if !@keystate
- updateKeyState(key)
- return @keystate[key]==1 || (@keystate[key]>20 && (@keystate[key]&1)==0)
- end
- def self.padRepeatex?(key)
- return false if !@padKeyState
- code=GetCode(key)
- self.State2(key)
- return @padKeyState[code]==1 || (@padKeyState[code]>20 && (@padKeyState[code]&1)==0)
- end
- def self.releaseex?(key)
- return false if !@releasestate
- updateKeyState(key)
- return @releasestate[key]
- end
- def self.padReleasex?(key)
- return false if !@padReleaseState
- code=self.GetCode(key)
- self.Update(code)
- return @padReleaseState[code]
- end
- def self.triggerex?(key)
- return false if !@triggerstate
- updateKeyState(key)
- return @triggerstate[key]
- end
- def self.padTriggerex?(key)
- return false if !@padTriggerState
- code= self.GetCode(key)
- result=self.State(key)
- return result
- end
- def self.repeatcount(key)
- return 0 if !@keystate
- updateKeyState(key)
- return @keystate[key]
- end
- def self.padRepeatCount(key)
- return 0 if !@padKeyState
- code= self.GetCode(key)
- result=self.Update(code)
- return @padKeyState[code]
- end
- def self.pressex?(key)
- trigger= self.repeatcount(key)>0
- pad= self.repeatcount(key)>0
- return trigger || pad
- end
- def self.RunToogle
- Kernel.pbMessage(_INTL("wds"))
- $PokemonSystem.runstyle=1
- $PokemonGlobal.runtoogle=true
- end
- def self.GetCode(key)
- for i in 0..Assign.size
- if Assign[i]==key
- return i
- end
- end
- return 100
- end
- end
- # Requires Win32API
- module Mouse
- gsm = Win32API.new('user32', 'GetSystemMetrics', 'i', 'i')
- @GetCursorPos = Win32API.new('user32', 'GetCursorPos', 'p', 'i')
- @SetCapture = Win32API.new('user32', 'SetCapture', 'p', 'i')
- @ReleaseCapture = Win32API.new('user32', 'ReleaseCapture', '', 'i')
- module_function
- def getMouseGlobalPos
- pos = [0, 0].pack('ll')
- if @GetCursorPos.call(pos) != 0
- return pos.unpack('ll')
- else
- return nil
- end
- end
- def screen_to_client(x, y)
- return nil unless x and y
- screenToClient = Win32API.new('user32', 'ScreenToClient', %w(l p), 'i')
- pos = [x, y].pack('ll')
- if screenToClient.call(Win32API.pbFindRgssWindow, pos) != 0
- return pos.unpack('ll')
- else
- return nil
- end
- end
- def setCapture
- @SetCapture.call(Win32API.pbFindRgssWindow)
- end
- def releaseCapture
- @ReleaseCapture.call
- end
- # Returns the position of the mouse relative to the game window.
- def getMousePos(catch_anywhere = false)
- resizeFactor=($ResizeFactor) ? $ResizeFactor : 1
- x, y = screen_to_client(*getMouseGlobalPos)
- width, height = Win32API.client_size
- if catch_anywhere or (x >= 0 and y >= 0 and x < width and y < height)
- return (x/resizeFactor).to_i, (y/resizeFactor).to_i
- else
- return nil
- end
- end
- def del
- if @oldcursor == nil
- return
- else
- @SetClassLong.call(Win32API.pbFindRgssWindow,-12, @oldcursor)
- @oldcursor = nil
- end
- end
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement