fork/m-overlay

git clone https://git.julia.blue/fork/m-overlay

BkacjiosFinal small changes7342549

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