fork/m-overlay

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

BkacjiosMore string format fixes09408fe

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