fork/m-overlay
git clone https://git.julia.blue/fork/m-overlay
60fa5b3
master
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 ) 216if b1 then 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 233end 234return niceStr 235end 236 237-- Captures all characters up to any amount of NULL characters 238local STRING_PATTERN ="^(.-)%z-$" 239 240local TYPES_READ ={ 241[ "bool" ] =memory . readBool , 242 243[ "sbyte" ] =memory . readByte , 244[ "byte" ] =memory . readUByte , 245[ "short" ] =memory . readShort , 246[ "int" ] =memory . readInt , 247 248[ "u8" ] =memory . readUByte , 249[ "s8" ] =memory . readByte , 250[ "u16" ] =memory . readUShort , 251[ "s16" ] =memory . readShort , 252[ "u32" ] =memory . readUInt , 253[ "s32" ] =memory . readInt , 254 255[ "float" ] =memory . readFloat , 256 257[ "data" ] =memory . read , 258[ "string" ] =function ( addr , len ) 259local value =memory . read ( addr , len ) 260return value : match ( STRING_PATTERN ) 261end , 262[ "string-jis" ] =function ( addr , len ) 263local value =memory . read ( addr , len ) 264return convertJisStr ( value : match ( STRING_PATTERN ) or value ) 265end , 266} 267 268-- Creates or updates a tree of values for easy indexing 269-- Example a path of "player.name" will become memory.players = { name = value } 270function memory . cacheValue ( table , path , value ) 271local last =table 272local last_key =nil 273 274local keys ={} 275for key in string . gmatch ( path , "[^%.]+" ) do 276keys [ # keys + 1 ] =tonumber ( key ) or key 277end 278 279for i , key in ipairs ( keys ) do 280if i < # keys then 281last [ key ] =last [ key ] or {} 282last =last [ key ] 283else 284if type ( last ) ~= "table" then 285return error (( "Failed to index a %s value (%q)" ): format ( type ( last ), keys [ i - 1 ])) 286end 287last [ key ] =value 288last_key =key 289end 290end 291 292-- Return the table that the value is being stored in, and the key name 293return last , last_key 294end 295 296local ADDRESS ={} 297ADDRESS . __index =ADDRESS 298 299function memory . newvalue ( addr , offset , struct , name ) 300assert ( type ( addr ) == "number" , "argument #1 'address' must be a number" ) 301assert ( TYPES_READ [ struct . type ] ~= nil , "unhandled type: " .. struct . type ) 302 303name =name or struct . name or addr 304 305local init =struct . init or NULL 306 307-- create/get a new value cache based off of the value name 308local tbl , key =memory . cacheValue ( memory . values , name , init ) 309 310log . trace ( "[MEMORY] VALUE CACHE %08X + %X %q" , addr , offset , name ) 311 312--local shoulddebug = name ~= "frame" and name:sub(1,10) ~= "controller" 313 314return setmetatable ( { 315name =name , 316 317address =addr , -- Where in memory this value is located 318offset =offset , -- How far past the address value we should get the value from 319 320type =struct . type , 321-- Assign the function we will be using to read from memory 322read =TYPES_READ [ struct . type ], 323len =struct . len , 324 325-- Setup the cache 326cache =tbl , 327cache_key =key , 328cache_value =init , 329 330debug =struct . debug , 331} , ADDRESS ) 332end 333 334function ADDRESS : update () 335if self . address == NULL then return end 336 337local address =self . address + self . offset 338 339-- value = converted value 340-- orig = Non-converted value (Only available for floats) 341local value , orig =self . read ( address , self . len ) 342 343-- Check if there has been a value change 344if self . cache_value ~= value then 345self . cache_value =value 346self . cache [ self . cache_key ] =self . cache_value 347 348if self . debug then 349if self . type == "string" or self . type == "string-jis" or self . type == "data" then 350log . debug ( "[MEMORY] [0x%08X = 0x%s] %s = %q" , address , string . tohex ( value ), self . name , value ) 351else 352local numValue =tonumber ( orig ) or tonumber ( value ) or ( value and 1 or 0 ) 353log . debug ( "[MEMORY] [0x%08X = 0x%08X] %s = %s" , address , numValue , self . name , value ) 354end 355end 356 357-- Queue up a hook event 358table . insert ( memory . hook_queue , { name =self . name , value =value } ) 359end 360end 361 362local POINTER ={} 363POINTER . __index =POINTER 364 365function memory . newpointer ( addr , offset , pointer , name ) 366local pstruct ={} 367 368name =name or pointer . name 369 370--log.debug("[MEMORY] POINTER CREATED %08X + %X %q", addr, offset, name or "nil") 371 372-- Loop through the pointers children 373for poffset , struct in pairs ( pointer . struct ) do 374local sname =name 375if sname and struct . name then 376sname =sname .. "." .. struct . name 377end 378if struct . type == "pointer" then 379pstruct [ poffset ] =memory . newpointer ( NULL , poffset , struct , sname ) 380else 381pstruct [ poffset ] =memory . newvalue ( NULL , poffset , struct , sname ) 382end 383end 384 385return setmetatable ( { 386parent =addr ~= NULL and pointer or nil , 387name =name , 388address =addr , 389offset =offset , 390location =NULL , 391struct =pstruct , 392debug =pointer . debug , 393} , POINTER ) 394end 395 396function POINTER : getAddress () 397return ( "0x%08X" ): format ( self . address + self . offset ) 398end 399 400function POINTER : getPointerPath () 401local parent =self 402while parent do 403local path =parent : getAddress () 404path =parent : getAddress () .. " -> " .. path 405parent =parent . parent 406end 407return path 408end 409 410do 411local cast =ffi . cast 412local GC_RAM_START =cast ( "uint32_t" , 0x80000000 ) 413local GC_RAM_END =cast ( "uint32_t" , 0x81800000 ) 414local WII_RAM_START =cast ( "uint32_t" , 0x90000000 ) 415local WII_RAM_END =cast ( "uint32_t" , 0x94000000 ) 416 417local function isValidPointer ( ptr ) 418ptr =cast ( "uint32_t" , ptr ) 419return ptr ~= NULL and (( ptr >= GC_RAM_START and ptr <= GC_RAM_END ) or ( ptr >= WII_RAM_START and ptr <= WII_RAM_END )) 420end 421 422function POINTER : update () 423local addr =self . address + self . offset 424local ploc =memory . readUInt ( addr ) 425local valid =isValidPointer ( ploc ) 426 427if self . location ~= ploc then 428self . location =ploc 429 430if self . debug then 431if valid then 432log . debug ( "[MEMORY] [0x%08X -> 0x%08X] %s -> 0x%08X" , addr , ploc , self . name , ploc ) 433else 434log . debug ( "[MEMORY] [0x%08X -> 0x0 (NULL)] %s -> 0x%08X" , addr , self . name , ploc ) 435end 436end 437end 438 439if valid then 440for offset , struct in pairs ( self . struct ) do 441-- Set the address space to be where the containing pointer is pointing to 442struct . address =ploc 443-- Update the value/pointer recursively 444struct : update () 445end 446end 447end 448end 449 450function memory . loadmap ( map ) 451for address , struct in pairs ( map ) do 452if struct . type == "pointer" then 453memory . map [ address ] =memory . newpointer ( address , NULL , struct ) 454else 455memory . map [ address ] =memory . newvalue ( address , NULL , struct ) 456end 457end 458end 459 460function memory . hasPermissions () 461return memory . permissions 462end 463 464function memory . isInGame () 465local gid =memory . gameid 466local vcid =memory . vcid 467return gid ~= GAME_NONE or vcid ~= VC_NONE 468end 469 470function memory . isMelee () 471local gid =memory . gameid 472local version =memory . version 473 474if not gid or not version then return false end 475 476-- Force the GAMEID and VERSION to be Melee 1.02, since Fizzi seems to be using the gameid address space for something.. 477if not memory . isSupportedGame ( gid , version ) and gid ~= GAME_NONE and PANEL_SETTINGS : IsSlippiNetplay () then 478gid ="GALE01" 479version =0x02 480end 481 482-- See if this GameID is a clone of another 483local clone =memory . clones [ gid ] and memory . clones [ gid ][ version ] or nil 484 485if clone then 486version =clone . version 487gid =clone . id 488end 489 490return gid == "GALE01" and version == 0x02 491end 492 493local timer =love . timer . getTime () 494 495function memory . isSupportedGame ( gid , version ) 496return love . filesystem . getInfo ( string . format ( "modules/games/%s-%d.lua" , gid , version )) ~= nil 497end 498 499function memory . loadGameScript ( path ) 500-- Try to load the game table 501local status , game =xpcall ( require , debug . traceback , ( "games.%s" ): format ( path )) 502 503if status then 504memory . game =game 505log . info ( "[DOLPHIN] Loaded game config: %s" , path ) 506notification . info (( "Game %q detected" ): format ( path )) 507if not game . translateCStick then 508game . translateCStick =game . translateJoyStick 509end 510memory . init ( game . memorymap ) 511else 512notification . error (( "Unsupported game %s" ): format ( path )) 513notification . error ( "Playing slippi netplay? Press 'escape' and enable Rollback/Netplay mode" ) 514log . error ( "[DOLPHIN] %s" , game ) -- game variable is an error string 515end 516end 517 518function memory . findGame () 519local gid =memory . readGameID () 520local version =memory . readGameVersion () 521local vcid =memory . readVirtualConsoleID () 522 523-- Force the GAMEID and VERSION to be Melee 1.02, since Fizzi seems to be using the gameid address space for something.. 524if not memory . isSupportedGame ( gid , version ) and gid ~= GAME_NONE and PANEL_SETTINGS : IsSlippiNetplay () then 525gid ="GALE01" 526version =0x02 527end 528 529-- When playing Slippi netplay.. the game ID can and will change.. 530-- This would normally break things, but if you enable Rollback/Netplay mode it will force the gameid to always be GALE01 v1.02 531local meleeMode =( memory . isMelee () and memory . gameid ~= gid ) 532 533if not memory . ingame and gid == GAME_NONE and vcid ~= VC_NONE then 534memory . reset () 535memory . ingame =true 536memory . vcid =vcid 537 538log . info ( "[DOLPHIN] Game: %s" , vcid ) 539love . updateTitle (( "M'Overlay - Dolphin hooked (%s)" ): format ( vcid )) 540 541-- Check for VC clones 542vcid =memory . vcclones [ vcid ] or vcid 543 544memory . loadGameScript ( vcid ) 545memory . runhook ( "OnGameOpen" , vcid ) 546elseif ( not memory . ingame or meleeMode ) and gid ~= GAME_NONE then 547memory . reset () 548memory . ingame =true 549memory . gameid =gid 550memory . version =version 551 552log . info ( "[DOLPHIN] Game: %s revision %i" , gid , version ) 553love . updateTitle (( "M'Overlay - Dolphin hooked (%s-%i)" ): format ( gid , version )) 554 555-- See if this GameID is a clone of another 556local clone =memory . clones [ gid ] and memory . clones [ gid ][ version ] or nil 557 558if clone then 559version =clone . version 560gid =clone . id 561end 562 563memory . loadGameScript (( "%s-%d" ): format ( gid , version )) 564memory . runhook ( "OnGameOpen" , gid , version ) 565elseif ( memory . ingame or meleeMode ) and ( gid == GAME_NONE and vcid == VC_NONE ) then 566memory . ingame =false 567memory . gameid =gid 568memory . vcid =vcid 569memory . version =version 570 571love . updateTitle ( "M'Overlay - Dolphin hooked" ) 572memory . runhook ( "OnGameClosed" ) 573memory . process : clearGamecubeRAMOffset () -- Clear the memory address space location (When a new game is opened, we recheck this) 574log . info ( "[DOLPHIN] Game closed.." ) 575end 576end 577 578function memory . update () 579if not memory . hasPermissions () then return end 580 581if not process : isProcessActive () and process : hasProcess () then 582process : close () 583love . updateTitle ( "M'Overlay - Waiting for Dolphin.." ) 584log . info ( "[DOLPHIN] Unhooked" ) 585memory . hooked =false 586end 587 588local t =love . timer . getTime () 589 590-- Only check for the dolphin process once per second to reduce CPU load 591if not process : hasProcess () or not process : hasGamecubeRAMOffset () then 592if timer <= t then 593timer =t + 0.5 594if process : findprocess () then 595log . info ( "[DOLPHIN] Hooked" ) 596love . updateTitle ( "M'Overlay - Dolphin hooked" ) 597memory . hooked =true 598elseif not process : hasGamecubeRAMOffset () and process : findGamecubeRAMOffset () then 599log . debug ( "[DOLPHIN] Watching ram address: 0x%X [%s]" , process : getGamecubeRAMOffset (), string . toSize ( process : getGamecubeRAMSize ())) 600end 601end 602else 603memory . updatememory () 604 605local frame =memory . frame or 0 606if frame == 0 or memory . game_frame ~= frame then 607memory . game_frame =frame 608memory . runhooks () 609end 610end 611end 612 613function memory . init ( map ) 614memory . initialized =true 615memory . loadmap ( map ) 616log . info ( "[MEMORY] Mapped game memory structure" ) 617end 618 619function memory . reset () 620memory . initialized =false 621memory . ingame =false 622memory . map ={} 623memory . values ={} 624memory . gameid =GAME_NONE 625memory . version =0 626memory . game =nil 627setmetatable ( memory , { __index =memory . values } ) 628end 629 630function memory . updatememory () 631memory . findGame () 632 633if memory . ingame then 634for addr , value in pairs ( memory . map ) do 635value : update () 636end 637end 638end 639 640local function hookPattern ( name ) 641-- Convert '*' into capture patterns 642if string . find ( name , "*" , 1 , true ) then 643return true , '^' .. name : escape (): gsub ( "%%%*" , "([^.]-)" ) .. '$' 644end 645return false , name 646end 647 648function memory . hook ( name , desc , callback ) 649local wildcard , name =hookPattern ( name ) 650if wildcard then 651memory . wildcard_hooks [ name ] =memory . wildcard_hooks [ name ] or {} 652memory . wildcard_hooks [ name ][ desc ] =callback 653else 654memory . hooks [ name ] =memory . hooks [ name ] or {} 655memory . hooks [ name ][ desc ] =callback 656end 657end 658 659function memory . unhook ( name , desc ) 660memory . hook ( name , desc , nil ) 661end 662 663function memory . runhooks () 664local pop 665while true do 666pop =table . remove ( memory . hook_queue , 1 ) 667if not pop then break end 668memory . runhook ( pop . name , pop . value ) 669end 670end 671 672do 673local args ={} 674local matches ={} 675 676function memory . runhook ( name , ... ) 677-- Normal hooks 678if memory . hooks [ name ] then 679for desc , callback in pairs ( memory . hooks [ name ]) do 680local succ , err 681if type ( desc ) == "table" then 682-- Assume a table is an object, so call it as so 683succ , err =xpcall ( callback , debug . traceback , desc , ... ) 684else 685succ , err =xpcall ( callback , debug . traceback , ... ) 686end 687if not succ then 688log . error ( "[MEMORY] hook error: %s (%s)" , desc , err ) 689end 690end 691end 692 693local varargs ={ ... } 694 695-- Allow for wildcard hooks 696for pattern , hooks in pairs ( memory . wildcard_hooks ) do 697if string . find ( name , pattern ) then 698args ={} 699matches ={ name : match ( pattern ) } 700 701for k , match in ipairs ( matches ) do 702table . insert ( args , tonumber ( match ) or match ) 703end 704for k , arg in ipairs ( varargs ) do 705table . insert ( args , arg ) 706end 707 708for desc , callback in pairs ( hooks ) do 709local succ , err 710if type ( desc ) == "table" then 711-- Assume a table is an object, so call it as so 712succ , err =xpcall ( callback , debug . traceback , desc , unpack ( args )) 713else 714succ , err =xpcall ( callback , debug . traceback , unpack ( args )) 715end 716if not succ then 717log . error ( "[MEMORY] wildcard hook error: %s (%s)" , desc , err ) 718end 719end 720end 721end 722end 723end 724 725return memory