fork/m-overlay
git clone https://git.julia.blue/fork/m-overlay
7342549
v2.1.3
1local bit =require ( "bit" ) 2local ffi =require ( "ffi" ) 3local log =require ( "log" ) 4local cloneloader =require ( "memory.cloneloader" ) 5local process =require ( "memory." .. jit . os : lower ()) 6local notification =require ( "notification" ) 7 8require ( "extensions.string" ) 9require ( "extensions.table" ) 10 11local NULL =0x00000000 12 13local GAME_ID_ADDR =0x80000000 14local GAME_VER_ADDR =0x80000007 15local GAME_ID_LEN =0x06 16local GAME_NONE ="\0\0\0\0\0\0" 17 18local VC_ID_ADDR =0x80003180 19local VC_ID_LEN =0x04 20local VC_NONE ="\0\0\0\0" 21 22local memory ={ 23clones =require ( "games.clones" ), 24vcclones =require ( "games.vcclones" ), 25 26gameid =GAME_NONE , 27vcid =VC_NONE , 28process =process , 29permissions =process : hasPermissions (), 30 31hooked =false , 32initialized =false , 33ingame =false , 34 35map ={} , 36values ={} , 37 38hooks ={} , 39wildcard_hooks ={} , 40 41hook_queue ={} , 42} 43 44cloneloader . loadFile ( "clones.lua" , memory . clones ) 45 46setmetatable ( memory , { __index =memory . values } ) 47 48local bswap =bit . bswap 49local function bswap16 ( n ) 50return bit . bor ( bit . rshift ( n , 8 ), bit . lshift ( bit . band ( n , 0xFF ), 8 )) 51end 52 53function memory . readGameID () 54return memory . read ( GAME_ID_ADDR , GAME_ID_LEN ) 55end 56 57function memory . readVirtualConsoleID () 58return memory . read ( VC_ID_ADDR , VC_ID_LEN ) 59end 60 61function memory . readGameVersion () 62return memory . readUByte ( GAME_VER_ADDR ) 63end 64 65local typecache ={} 66 67local function cache ( typ , len ) 68-- This stops us from constantly calling ffi.new by recycling old variables 69len =len or 1 70if not typecache [ typ ] then 71-- Create new cache for this type 72typecache [ typ ] ={} 73elseif typecache [ typ ][ len ] then 74-- Set the cached value to all 0's so it can be reused safely 75ffi . fill ( typecache [ typ ][ len ], len ) 76-- Return the cached value 77return typecache [ typ ][ len ] 78end 79-- Create a new variable 80local cached =ffi . new ( string . format ( "%s[?]" , typ ), len ) 81-- Store it in the cache 82typecache [ typ ][ len ] =cached 83return cached 84end 85 86function memory . read ( addr , len ) 87local output =cache ( "uint8_t" , len ) 88local size =ffi . sizeof ( output ) 89process : read ( addr , output , size ) 90return ffi . string ( output , size ) 91end 92 93function memory . readByte ( addr ) 94if not process : hasProcess () then return 0 end 95local output =cache ( "int8_t" ) 96process : read ( addr , output , ffi . sizeof ( output )) 97return output [ 0 ] 98end 99 100function memory . writeByte ( addr , value ) 101if not process : hasProcess () then return end 102local input =cache ( "int8_t" ) 103return process : write ( addr , input , ffi . sizeof ( input )) 104end 105 106function memory . readBool ( addr ) 107if not process : hasProcess () then return false end 108return memory . readByte ( addr ) == 1 109end 110 111function memory . writeBool ( addr , value ) 112if not self : hasProcess () then return end 113self : writeByte ( addr , value == true and 1 or 0 ) 114end 115 116function memory . readUByte ( addr ) 117if not process : hasProcess () then return 0 end 118local output =cache ( "uint8_t" ) 119process : read ( addr , output , ffi . sizeof ( output )) 120return output [ 0 ] 121end 122 123function memory . writeUByte ( addr , value ) 124if not process : hasProcess () then return end 125local input =cache ( "uint8_t" ) 126return process : write ( addr , input , ffi . sizeof ( input )) 127end 128 129function memory . readShort ( addr ) 130if not process : hasProcess () then return 0 end 131local output =cache ( "int16_t" ) 132process : read ( addr , output , ffi . sizeof ( output )) 133return bswap16 ( output [ 0 ]) 134end 135 136function memory . writeShort ( addr , value ) 137if not process : hasProcess () then return end 138local input =cache ( "int16_t" ) 139return process : write ( addr , input , ffi . sizeof ( input )) 140end 141 142function memory . readUShort ( addr ) 143if not process : hasProcess () then return 0 end 144local output =cache ( "uint16_t" ) 145process : read ( addr , output , ffi . sizeof ( output )) 146return bswap16 ( output [ 0 ]) 147end 148 149function memory . writeUShort ( addr , value ) 150if not process : hasProcess () then return end 151local input =cache ( "uint16_t" ) 152return process : write ( addr , input , ffi . sizeof ( input )) 153end 154 155do 156local floatconversion =ffi . new ( "union { uint32_t i; float f; }" ) 157 158function memory . readFloat ( addr ) 159if not process : hasProcess () then return 0 end 160local output =cache ( "uint32_t" ) 161process : read ( addr , output , ffi . sizeof ( output )) 162floatconversion . i =bswap ( output [ 0 ]) 163return floatconversion . f , floatconversion . i 164end 165end 166 167function memory . writeFloat ( addr , value ) 168if not process : hasProcess () then return end 169local input =cache ( "float" ) 170return process : write ( addr , input , ffi . sizeof ( input )) 171end 172 173function memory . readInt ( addr ) 174if not process : hasProcess () then return 0 end 175local output =cache ( "int32_t" ) 176process : read ( addr , output , ffi . sizeof ( output )) 177return bswap ( output [ 0 ]) 178end 179 180function memory . writeInt ( addr , value ) 181if not process : hasProcess () then return end 182local input =cache ( "int32_t" ) 183return process : write ( addr , input , ffi . sizeof ( input )) 184end 185 186function memory . readUInt ( addr ) 187if not process : hasProcess () then return 0 end 188local output =cache ( "uint32_t" ) 189process : read ( addr , output , ffi . sizeof ( output )) 190return bswap ( output [ 0 ]) 191end 192 193function memory . writeUInt ( addr , value ) 194if not process : hasProcess () then return end 195local input =cache ( "uint32_t" ) 196return process : write ( addr , input , ffi . sizeof ( input )) 197end 198 199local char_replacement_map ={ 200[ 0x8149 ] ="!" , [ 0x8168 ] ="\"" , [ 0x8194 ] ="#" , [ 0x8190 ] ="$" , 201[ 0x8193 ] ="%" , [ 0x8195 ] ="&" , [ 0x8166 ] ="'" , [ 0x8169 ] ="(" , 202[ 0x816A ] =")" , [ 0x8196 ] ="*" , [ 0x817B ] ="+" , [ 0x8143 ] ="," , 203[ 0x817C ] ="-" , [ 0x8144 ] ="." , [ 0x815E ] ="/" , [ 0x8146 ] =":" , 204[ 0x8147 ] =";" , [ 0x8183 ] ="<" , [ 0x8181 ] ="=" , [ 0x8184 ] =">" , 205[ 0x8148 ] ="?" , [ 0x8197 ] ="@" , [ 0x816D ] ="[" , [ 0x815F ] ="\\" , 206[ 0x816E ] ="]" , [ 0x814F ] ="^" , [ 0x8151 ] ="_" , [ 0x814D ] ="`" , 207[ 0x816F ] ="{" , [ 0x8162 ] ="|" , [ 0x8170 ] ="}" , [ 0x8160 ] ="~" , 208} 209 210local function convertJisStr ( str ) 211local niceStr ="" 212local i =1 213while i <= # str do 214local c1 =string . sub ( str , i , i ) 215local b1 =string . byte ( c1 ) 216 217if bit . band ( b1 , 0x80 ) == 0x80 then 218local c2 =string . sub ( str , i + 1 , i + 1 ) 219local b2 =string . byte ( c2 ) 220 221local b16 =bit . bor ( bit . lshift ( b1 , 8 ), bit . lshift ( b2 , 0 )) 222 223if char_replacement_map [ b16 ] then 224niceStr =niceStr .. char_replacement_map [ b16 ] 225end 226 227i =i + 2 228else 229niceStr =niceStr .. c1 230i =i + 1 231end 232end 233return niceStr 234end 235 236local TYPES_READ ={ 237[ "bool" ] =memory . readBool , 238 239[ "sbyte" ] =memory . readByte , 240[ "byte" ] =memory . readUByte , 241[ "short" ] =memory . readShort , 242[ "int" ] =memory . readInt , 243 244[ "u8" ] =memory . readUByte , 245[ "s8" ] =memory . readByte , 246[ "u16" ] =memory . readUShort , 247[ "s16" ] =memory . readShort , 248[ "u32" ] =memory . readUInt , 249[ "s32" ] =memory . readInt , 250 251[ "float" ] =memory . readFloat , 252 253[ "data" ] =memory . read , 254[ "string" ] =function ( addr , len ) 255local value =memory . read ( addr , len ) 256return value : match ( "(.-)%z*" ) 257end , 258[ "string-jis" ] =function ( addr , len ) 259local value =memory . read ( addr , len ) 260return convertJisStr ( value : match ( "(.-)%z*" ) or value ) 261end , 262} 263 264-- Creates or updates a tree of values for easy indexing 265-- Example a path of "player.name" will become memory.players = { name = value } 266function memory . cacheValue ( table , path , value ) 267local last =table 268local last_key =nil 269 270local keys ={} 271for key in string . gmatch ( path , "[^%.]+" ) do 272keys [ # keys + 1 ] =tonumber ( key ) or key 273end 274 275for i , key in ipairs ( keys ) do 276if i < # keys then 277last [ key ] =last [ key ] or {} 278last =last [ key ] 279else 280if type ( last ) ~= "table" then 281return error (( "Failed to index a %s value (%q)" ): format ( type ( last ), keys [ i - 1 ])) 282end 283last [ key ] =value 284last_key =key 285end 286end 287 288-- Return the table that the value is being stored in, and the key name 289return last , last_key 290end 291 292local ADDRESS ={} 293ADDRESS . __index =ADDRESS 294 295function memory . newvalue ( addr , offset , struct , name ) 296assert ( type ( addr ) == "number" , "argument #1 'address' must be a number" ) 297assert ( TYPES_READ [ struct . type ] ~= nil , "unhandled type: " .. struct . type ) 298 299name =name or struct . name or addr 300 301local init =struct . init or NULL 302 303-- create/get a new value cache based off of the value name 304local tbl , key =memory . cacheValue ( memory . values , name , init ) 305 306log . trace ( "[MEMORY] VALUE CACHE %08X + %X %q" , addr , offset , name ) 307 308--local shoulddebug = name ~= "frame" and name:sub(1,10) ~= "controller" 309 310return setmetatable ( { 311name =name , 312 313address =addr , -- Where in memory this value is located 314offset =offset , -- How far past the address value we should get the value from 315 316type =struct . type , 317-- Assign the function we will be using to read from memory 318read =TYPES_READ [ struct . type ], 319len =struct . len , 320 321-- Setup the cache 322cache =tbl , 323cache_key =key , 324cache_value =init , 325 326debug =struct . debug , 327} , ADDRESS ) 328end 329 330function ADDRESS : update () 331if self . address == NULL then return end 332 333local address =self . address + self . offset 334 335-- value = converted value 336-- orig = Non-converted value (Only available for floats) 337local value , orig =self . read ( address , self . len ) 338 339-- Check if there has been a value change 340if self . cache_value ~= value then 341self . cache_value =value 342self . cache [ self . cache_key ] =self . cache_value 343 344if self . debug then 345if self . type == "string" or self . type == "string-jis" or self . type == "data" then 346log . debug ( "[MEMORY] [0x%08X = 0x%s] %s = %q" , address , string . tohex ( value ), self . name , value ) 347else 348local numValue =tonumber ( orig ) or tonumber ( value ) or ( value and 1 or 0 ) 349log . debug ( "[MEMORY] [0x%08X = 0x%08X] %s = %s" , address , numValue , self . name , value ) 350end 351end 352 353-- Queue up a hook event 354table . insert ( memory . hook_queue , { name =self . name , value =value } ) 355end 356end 357 358local POINTER ={} 359POINTER . __index =POINTER 360 361function memory . newpointer ( addr , offset , pointer , name ) 362local pstruct ={} 363 364name =name or pointer . name 365 366--log.debug("[MEMORY] POINTER CREATED %08X + %X %q", addr, offset, name or "nil") 367 368-- Loop through the pointers children 369for poffset , struct in pairs ( pointer . struct ) do 370local sname =name 371if sname and struct . name then 372sname =sname .. "." .. struct . name 373end 374if struct . type == "pointer" then 375pstruct [ poffset ] =memory . newpointer ( NULL , poffset , struct , sname ) 376else 377pstruct [ poffset ] =memory . newvalue ( NULL , poffset , struct , sname ) 378end 379end 380 381return setmetatable ( { 382parent =addr ~= NULL and pointer or nil , 383name =name , 384address =addr , 385offset =offset , 386location =NULL , 387struct =pstruct , 388debug =pointer . debug , 389} , POINTER ) 390end 391 392function POINTER : getAddress () 393return ( "0x%08X" ): format ( self . address + self . offset ) 394end 395 396function POINTER : getPointerPath () 397local parent =self 398while parent do 399local path =parent : getAddress () 400path =parent : getAddress () .. " -> " .. path 401parent =parent . parent 402end 403return path 404end 405 406do 407local cast =ffi . cast 408local GC_RAM_START =cast ( "uint32_t" , 0x80000000 ) 409local GC_RAM_END =cast ( "uint32_t" , 0x81800000 ) 410local WII_RAM_START =cast ( "uint32_t" , 0x90000000 ) 411local WII_RAM_END =cast ( "uint32_t" , 0x94000000 ) 412 413local function isValidPointer ( ptr ) 414ptr =cast ( "uint32_t" , ptr ) 415return ptr ~= NULL and (( ptr >= GC_RAM_START and ptr <= GC_RAM_END ) or ( ptr >= WII_RAM_START and ptr <= WII_RAM_END )) 416end 417 418function POINTER : update () 419local addr =self . address + self . offset 420local ploc =memory . readUInt ( addr ) 421local valid =isValidPointer ( ploc ) 422 423if self . location ~= ploc then 424self . location =ploc 425 426if self . debug then 427if valid then 428log . debug ( "[MEMORY] [0x%08X -> 0x%08X] %s -> 0x%08X" , addr , ploc , self . name , ploc ) 429else 430log . debug ( "[MEMORY] [0x%08X -> 0x0 (NULL)] %s -> 0x%08X" , addr , self . name , ploc ) 431end 432end 433end 434 435if valid then 436for offset , struct in pairs ( self . struct ) do 437-- Set the address space to be where the containing pointer is pointing to 438struct . address =ploc 439-- Update the value/pointer recursively 440struct : update () 441end 442end 443end 444end 445 446function memory . loadmap ( map ) 447for address , struct in pairs ( map ) do 448if struct . type == "pointer" then 449memory . map [ address ] =memory . newpointer ( address , NULL , struct ) 450else 451memory . map [ address ] =memory . newvalue ( address , NULL , struct ) 452end 453end 454end 455 456function memory . hasPermissions () 457return memory . permissions 458end 459 460function memory . isInGame () 461local gid =memory . gameid 462local vcid =memory . vcid 463return gid ~= GAME_NONE or vcid ~= VC_NONE 464end 465 466function memory . isMelee () 467local gid =memory . gameid 468local version =memory . version 469 470if not gid or not version then return false end 471 472-- Force the GAMEID and VERSION to be Melee 1.02, since Fizzi seems to be using the gameid address space for something.. 473if not memory . isSupportedGame ( gid , version ) and gid ~= GAME_NONE and PANEL_SETTINGS : IsSlippiNetplay () then 474gid ="GALE01" 475version =0x02 476end 477 478-- See if this GameID is a clone of another 479local clone =memory . clones [ gid ] and memory . clones [ gid ][ version ] or nil 480 481if clone then 482version =clone . version 483gid =clone . id 484end 485 486return gid == "GALE01" and version == 0x02 487end 488 489local timer =love . timer . getTime () 490 491function memory . isSupportedGame ( gid , version ) 492return love . filesystem . getInfo ( string . format ( "modules/games/%s-%d.lua" , gid , version )) ~= nil 493end 494 495function memory . loadGameScript ( path ) 496-- Try to load the game table 497local status , game =xpcall ( require , debug . traceback , ( "games.%s" ): format ( path )) 498 499if status then 500memory . game =game 501log . info ( "[DOLPHIN] Loaded game config: %s" , path ) 502notification . info (( "Game %q detected" ): format ( path )) 503if not game . translateCStick then 504game . translateCStick =game . translateJoyStick 505end 506memory . init ( game . memorymap ) 507else 508notification . error (( "Unsupported game %s" ): format ( path )) 509notification . error ( "Playing slippi netplay? Press 'escape' and enable Rollback/Netplay mode" ) 510log . error ( "[DOLPHIN] %s" , game ) -- game variable is an error string 511end 512end 513 514function memory . findGame () 515local gid =memory . readGameID () 516local version =memory . readGameVersion () 517local vcid =memory . readVirtualConsoleID () 518 519-- Force the GAMEID and VERSION to be Melee 1.02, since Fizzi seems to be using the gameid address space for something.. 520if not memory . isSupportedGame ( gid , version ) and gid ~= GAME_NONE and PANEL_SETTINGS : IsSlippiNetplay () then 521gid ="GALE01" 522version =0x02 523end 524 525-- When playing Slippi netplay.. the game ID can and will change.. 526-- This would normally break things, but if you enable Rollback/Netplay mode it will force the gameid to always be GALE01 v1.02 527local meleeMode =( memory . isMelee () and memory . gameid ~= gid ) 528 529if not memory . ingame and gid == GAME_NONE and vcid ~= VC_NONE then 530memory . reset () 531memory . ingame =true 532memory . vcid =vcid 533 534log . info ( "[DOLPHIN] Game: %s" , vcid ) 535love . updateTitle (( "M'Overlay - Dolphin hooked (%s)" ): format ( vcid )) 536 537-- Check for VC clones 538vcid =memory . vcclones [ vcid ] or vcid 539 540memory . loadGameScript ( vcid ) 541memory . runhook ( "OnGameOpen" , vcid ) 542elseif ( not memory . ingame or meleeMode ) and gid ~= GAME_NONE then 543memory . reset () 544memory . ingame =true 545memory . gameid =gid 546memory . version =version 547 548log . info ( "[DOLPHIN] Game: %s revision %i" , gid , version ) 549love . updateTitle (( "M'Overlay - Dolphin hooked (%s-%i)" ): format ( gid , version )) 550 551-- See if this GameID is a clone of another 552local clone =memory . clones [ gid ] and memory . clones [ gid ][ version ] or nil 553 554if clone then 555version =clone . version 556gid =clone . id 557end 558 559memory . loadGameScript (( "%s-%d" ): format ( gid , version )) 560memory . runhook ( "OnGameOpen" , gid , version ) 561elseif ( memory . ingame or meleeMode ) and ( gid == GAME_NONE and vcid == VC_NONE ) then 562memory . ingame =false 563memory . gameid =gid 564memory . vcid =vcid 565memory . version =version 566 567love . updateTitle ( "M'Overlay - Dolphin hooked" ) 568memory . runhook ( "OnGameClosed" ) 569memory . process : clearGamecubeRAMOffset () -- Clear the memory address space location (When a new game is opened, we recheck this) 570log . info ( "[DOLPHIN] Game closed.." ) 571end 572end 573 574function memory . update () 575if not memory . hasPermissions () then return end 576 577if not process : isProcessActive () and process : hasProcess () then 578process : close () 579love . updateTitle ( "M'Overlay - Waiting for Dolphin.." ) 580log . info ( "[DOLPHIN] Unhooked" ) 581memory . hooked =false 582end 583 584local t =love . timer . getTime () 585 586-- Only check for the dolphin process once per second to reduce CPU load 587if not process : hasProcess () or not process : hasGamecubeRAMOffset () then 588if timer <= t then 589timer =t + 0.5 590if process : findprocess () then 591log . info ( "[DOLPHIN] Hooked" ) 592love . updateTitle ( "M'Overlay - Dolphin hooked" ) 593memory . hooked =true 594elseif not process : hasGamecubeRAMOffset () and process : findGamecubeRAMOffset () then 595log . debug ( "[DOLPHIN] Watching ram address: 0x%X [%s]" , process : getGamecubeRAMOffset (), string . toSize ( process : getGamecubeRAMSize ())) 596end 597end 598else 599memory . updatememory () 600 601local frame =memory . frame or 0 602if frame == 0 or memory . game_frame ~= frame then 603memory . game_frame =frame 604memory . runhooks () 605end 606end 607end 608 609function memory . init ( map ) 610memory . initialized =true 611memory . loadmap ( map ) 612log . info ( "[MEMORY] Mapped game memory structure" ) 613end 614 615function memory . reset () 616memory . initialized =false 617memory . ingame =false 618memory . map ={} 619memory . values ={} 620memory . gameid =GAME_NONE 621memory . version =0 622memory . game =nil 623setmetatable ( memory , { __index =memory . values } ) 624end 625 626function memory . updatememory () 627memory . findGame () 628 629if memory . ingame then 630for addr , value in pairs ( memory . map ) do 631value : update () 632end 633end 634end 635 636local function hookPattern ( name ) 637-- Convert '*' into capture patterns 638if string . find ( name , "*" , 1 , true ) then 639return true , '^' .. name : escape (): gsub ( "%%%*" , "([^.]-)" ) .. '$' 640end 641return false , name 642end 643 644function memory . hook ( name , desc , callback ) 645local wildcard , name =hookPattern ( name ) 646if wildcard then 647memory . wildcard_hooks [ name ] =memory . wildcard_hooks [ name ] or {} 648memory . wildcard_hooks [ name ][ desc ] =callback 649else 650memory . hooks [ name ] =memory . hooks [ name ] or {} 651memory . hooks [ name ][ desc ] =callback 652end 653end 654 655function memory . unhook ( name , desc ) 656memory . hook ( name , desc , nil ) 657end 658 659function memory . runhooks () 660local pop 661while true do 662pop =table . remove ( memory . hook_queue , 1 ) 663if not pop then break end 664memory . runhook ( pop . name , pop . value ) 665end 666end 667 668do 669local args ={} 670local matches ={} 671 672function memory . runhook ( name , ... ) 673-- Normal hooks 674if memory . hooks [ name ] then 675for desc , callback in pairs ( memory . hooks [ name ]) do 676local succ , err 677if type ( desc ) == "table" then 678-- Assume a table is an object, so call it as so 679succ , err =xpcall ( callback , debug . traceback , desc , ... ) 680else 681succ , err =xpcall ( callback , debug . traceback , ... ) 682end 683if not succ then 684log . error ( "[MEMORY] hook error: %s (%s)" , desc , err ) 685end 686end 687end 688 689local varargs ={ ... } 690 691-- Allow for wildcard hooks 692for pattern , hooks in pairs ( memory . wildcard_hooks ) do 693if string . find ( name , pattern ) then 694args ={} 695matches ={ name : match ( pattern ) } 696 697for k , match in ipairs ( matches ) do 698table . insert ( args , tonumber ( match ) or match ) 699end 700for k , arg in ipairs ( varargs ) do 701table . insert ( args , arg ) 702end 703 704for desc , callback in pairs ( hooks ) do 705local succ , err 706if type ( desc ) == "table" then 707-- Assume a table is an object, so call it as so 708succ , err =xpcall ( callback , debug . traceback , desc , unpack ( args )) 709else 710succ , err =xpcall ( callback , debug . traceback , unpack ( args )) 711end 712if not succ then 713log . error ( "[MEMORY] wildcard hook error: %s (%s)" , desc , err ) 714end 715end 716end 717end 718end 719end 720 721return memory