mirror of
https://github.com/pmret/papermario.git
synced 2024-11-08 20:12:30 +01:00
540 lines
18 KiB
Python
540 lines
18 KiB
Python
from pathlib import Path
|
|
import argparse
|
|
from struct import unpack_from
|
|
|
|
constants = {}
|
|
def get_constants():
|
|
global constants
|
|
valid_enums = { "ItemId", "PlayerAnim", "ActorID", "Event", "SoundId" }
|
|
for enum in valid_enums:
|
|
constants[enum] = {}
|
|
constants["NPC_SPRITE"] = {}
|
|
|
|
include_path = Path(Path(__file__).resolve().parent.parent / "include")
|
|
enums = Path(include_path / "enums.h").read_text()
|
|
|
|
for line in enums.splitlines():
|
|
this_enum = ""
|
|
for enum in valid_enums:
|
|
if f"#define {enum}_" in line:
|
|
this_enum = enum
|
|
break;
|
|
|
|
if this_enum:
|
|
name = line.split(" ",2)[1]
|
|
id_ = line.split("0x", 1)[1]
|
|
if " " in id_:
|
|
id_ = id_.split(" ",1)[0]
|
|
constants[this_enum][int(id_, 16)] = name
|
|
|
|
sprite_path = Path(Path(__file__).resolve().parent.parent / "ver" / "current" / "build" / "include" / "sprite" / "npc")
|
|
for file in sprite_path.iterdir():
|
|
fd = file.read_text()
|
|
for line in fd.splitlines():
|
|
if "#define _NPC_SPRITE_" in line:
|
|
enum = "NPC_SPRITE"
|
|
elif "#define _NPC_PALETTE_" in line:
|
|
enum = "NPC_PALETTE"
|
|
elif "#define _NPC_ANIM_" in line:
|
|
enum = "NPC_ANIM"
|
|
else:
|
|
continue
|
|
|
|
name = line.split(" ",2)[1]
|
|
id_ = line.split("0x", 1)[1]
|
|
if " " in id_:
|
|
id_ = id_.split(" ",1)[0]
|
|
name = name.split(f"_{enum}_", 1)[1]
|
|
if enum == "NPC_SPRITE":
|
|
saved_name = name
|
|
saved_id = id_
|
|
else:
|
|
name = name.rsplit(f"{saved_name}_")[1]
|
|
|
|
if enum == "NPC_SPRITE":
|
|
if int(id_, 16) not in constants["NPC_SPRITE"]:
|
|
constants[enum][int(id_, 16)] = {"name":"", "palettes":{}, "anims":{}}
|
|
constants[enum][int(id_, 16)]["name"] = name
|
|
elif enum == "NPC_PALETTE":
|
|
constants["NPC_SPRITE"][int(saved_id, 16)]["palettes"][int(id_, 16)] = name
|
|
elif enum == "NPC_ANIM":
|
|
constants["NPC_SPRITE"][int(saved_id, 16)]["anims"][int(id_, 16)] = name
|
|
return
|
|
|
|
STRUCTS = {}
|
|
|
|
def parse_var(line):
|
|
#print(f"Parsing {line}")
|
|
if "*/ " in line:
|
|
line = line.split("*/ ",1)[1]
|
|
line = line.split(";",1)[0].strip()
|
|
|
|
if "," in line or "(*" in line:
|
|
return (None, None, None, None)
|
|
elif "union " in line:
|
|
return ("union", None, None, None)
|
|
|
|
#print(f"Parsed {line}")
|
|
if " " in line:
|
|
if line.startswith("struct "):
|
|
struct, type_, name = line.split(" ")
|
|
else:
|
|
type_, name = line.split(" ")
|
|
else:
|
|
type_ = "function"
|
|
name = line.split("(", 1)[0]
|
|
count = 1
|
|
if "[" in name:
|
|
name, *count = name.split("[")
|
|
counts = 1
|
|
count.reverse()
|
|
for dim in count:
|
|
counts *= int(dim[:-1], 0)
|
|
count = counts
|
|
|
|
is_ptr = "*" in type_ or type_ == "UNK_PTR"
|
|
return (type_, name, count, is_ptr)
|
|
|
|
def parse_file(filename):
|
|
fd = filename.read_text().splitlines()
|
|
i = 0
|
|
while i < len(fd):
|
|
#supported = [f"typedef struct {x}" in fd[i] for x in SUPPORTED_STRUCTS]
|
|
#if any(supported):
|
|
if "typedef struct " in fd[i]:
|
|
#supported_name = [SUPPORTED_STRUCTS[i] for i,x in enumerate(supported) if x][0]
|
|
supported_name = fd[i].split("typedef struct ", 1)[1].split(" {", 1)[0]
|
|
if supported_name == "{":
|
|
supported_name = ""
|
|
#print(f"Parsing struct \"{supported_name}\"")
|
|
|
|
struct_to_add = []
|
|
i += 1
|
|
while ("} " + f"{supported_name.upper()}") not in fd[i].split(";",1)[0].upper():
|
|
type_, name, count, ptr = parse_var(fd[i])
|
|
|
|
if type_ == None:
|
|
i += 1
|
|
continue
|
|
|
|
union = []
|
|
if type_ == "union":
|
|
i += 1
|
|
while "}" not in fd[i]:
|
|
type_, name, count, ptr = parse_var(fd[i])
|
|
union.append({"type":type_, "name": name, "num":count, "ptr":ptr})
|
|
i += 1
|
|
name = fd[i].split("}", 1)[1].split(";", 1)[0]
|
|
|
|
#print(supported_name, type_, name, count)
|
|
struct_to_add.append({"type":type_, "name": name, "num":count, "ptr":ptr, "union":union})
|
|
|
|
i += 1
|
|
#print(f"Broke on line {fd[i]}")
|
|
#print()
|
|
if supported_name == "":
|
|
supported_name = fd[i].split("} ",1)[1].split(";",1)[0]
|
|
if "[" in supported_name:
|
|
supported_name = supported_name[:-2]
|
|
STRUCTS[supported_name] = struct_to_add
|
|
i += 1
|
|
|
|
def get_structs():
|
|
parse_file(Path(Path(__file__).parent.parent / "include" / "map.h"))
|
|
parse_file(Path(Path(__file__).parent.parent / "include" / "common_structs.h"))
|
|
|
|
def get_vals(fd, offset, var):
|
|
out = []
|
|
arr = []
|
|
for i in range(var["num"]):
|
|
if var["type"] in STRUCTS:
|
|
type_ = "struct"
|
|
data = []
|
|
for var2 in STRUCTS[var["type"]]:
|
|
out3, offset = get_vals(fd, offset, var2)
|
|
data.extend(out3)
|
|
#if var["num"] == 1:
|
|
# out.extend(out2)
|
|
#else:
|
|
#out.append(out2)
|
|
else:
|
|
type_ = "int"
|
|
if var["type"] == "s8" or var["type"] == "char":
|
|
if var["type"] == "char":
|
|
type_ = "hex"
|
|
data = unpack_from('>b', fd, offset)[0]
|
|
offset += 1
|
|
elif var["type"] == "u8":
|
|
data = unpack_from('>B', fd, offset)[0]
|
|
offset += 1
|
|
elif var["type"] == "s16" or var["type"] in ("ItemId"):
|
|
offset += offset % 2
|
|
data = unpack_from('>h', fd, offset)[0]
|
|
offset += 2
|
|
elif var["type"] == "u16":
|
|
offset += offset % 2
|
|
data = unpack_from('>H', fd, offset)[0]
|
|
offset += 2
|
|
elif var["type"] == "s32" or var["type"] in ("NpcId", "NpcAnimID", "MessageID"):
|
|
poff = offset
|
|
offset += offset % 4
|
|
data = unpack_from('>i', fd, offset)[0]
|
|
offset += 4
|
|
elif var["type"] == "u32":
|
|
offset += offset % 4
|
|
data = unpack_from('>I', fd, offset)[0]
|
|
offset += 4
|
|
elif var["type"] == "f32":
|
|
offset += offset % 4
|
|
data = unpack_from('>f', fd, offset)[0]
|
|
type_ = "float"
|
|
offset += 4
|
|
elif var["type"] == "X32":
|
|
offset += offset % 4
|
|
data = unpack_from('>f', fd, offset)[0]
|
|
type_ = "float"
|
|
if data < -1000.0 or data > 1000.0:
|
|
type_ = "int"
|
|
data = unpack_from('>i', fd, offset)[0]
|
|
offset += 4
|
|
elif var["ptr"]:
|
|
offset += offset % 4
|
|
data = unpack_from('>I', fd, offset)[0]
|
|
type_ = "ptr"
|
|
offset += 4
|
|
else:
|
|
print(f"Unknown data type \"{var['type']}\"")
|
|
exit()
|
|
if var["num"] == 1:
|
|
out.append({"name":var["name"], "type":type_, "data":data})
|
|
else:
|
|
arr.append({"name":var["name"], "type":type_, "data":data})
|
|
|
|
if var["num"] > 1:
|
|
out.append(arr)
|
|
return out, offset
|
|
|
|
def INDENT(depth):
|
|
return f" " * depth
|
|
|
|
def print_data(vals, indent, needs_name, is_array=False, is_struct=False):
|
|
out = []
|
|
for val in vals:
|
|
line = ""
|
|
if needs_name:
|
|
line = INDENT(indent)
|
|
#print(val)
|
|
# array
|
|
if type(val) is list:
|
|
line += f".{val[0]['name']} = " + "{ "
|
|
struct = type(val[0]["data"]) is list
|
|
line += ", ".join(print_data(val, indent + 1, needs_name=False, is_array=True, is_struct=struct))
|
|
if struct:
|
|
line += "\n" + INDENT(indent) + "},"
|
|
else:
|
|
line += " },"
|
|
else:
|
|
if needs_name:
|
|
line += f".{val['name']} = "
|
|
if type(val["data"]) is list:
|
|
if is_struct:
|
|
line += "\n"
|
|
line += INDENT(indent)
|
|
line += "{ "
|
|
for x,val2 in enumerate(val["data"]):
|
|
if x > 0:
|
|
line += ", "
|
|
#line += f".{val2['name']} = "
|
|
if val2["type"] == "float":
|
|
line += f"{val2['data']:.01f}f"
|
|
elif val2["type"] == "hex":
|
|
line += f"0x{val2['data']:X}"
|
|
elif val2["type"] == "ptr":
|
|
if val2["data"] == 0:
|
|
line += f"NULL"
|
|
else:
|
|
line += f"0x{val2['data']:08X}"
|
|
else:
|
|
line += f"{val2['data']}"
|
|
line += " }"
|
|
if not is_array:
|
|
line += ","
|
|
else:
|
|
|
|
if "flags" in val["name"].lower() or "animations" in val["name"].lower():
|
|
if val["name"] == "flags":
|
|
val["type"] = "ptr"
|
|
elif val["name"] == "dropFlags":
|
|
val["type"] = "hex"
|
|
val["data"] = abs(val["data"])
|
|
|
|
if val["type"] == "float":
|
|
line += f"{val['data']:.01f}f"
|
|
elif val["type"] == "hex":
|
|
line += f"0x{val['data']:X}"
|
|
elif val["type"] == "ptr":
|
|
if val["data"] == 0:
|
|
line += f"NULL"
|
|
else:
|
|
line += f"0x{val['data']:08X}"
|
|
else:
|
|
line += f"{val['data']}"
|
|
|
|
if not (is_array or is_struct):
|
|
line += ","
|
|
|
|
out.append(line)
|
|
|
|
return out
|
|
|
|
def output_type2(fd, offset, var):
|
|
vals = []
|
|
for var in STRUCTS[args.type]:
|
|
tmp, offset = get_vals(fd, offset, var)
|
|
vals.extend(tmp)
|
|
|
|
#print(vals)
|
|
#print()
|
|
out = [f"{args.type} = " + "{"]
|
|
out.extend(print_data(vals, 1, True))
|
|
out.append("};")
|
|
#print("END======")
|
|
#print("\n".join(out))
|
|
return "\n".join(out)
|
|
|
|
def check_list(vals, depth = 0):
|
|
for x,val in enumerate(vals):
|
|
if type(val) == list:
|
|
if check_list(val, depth + 1):
|
|
return True
|
|
elif val != 0:
|
|
return True
|
|
return False
|
|
|
|
def recurse_check_list(vals):
|
|
res = 0
|
|
for x,val in enumerate(vals):
|
|
if type(val) == list:
|
|
if check_list(val, 1):
|
|
return len(vals) - x
|
|
elif val != 0:
|
|
return len(vals) - x
|
|
return -1
|
|
|
|
def get_single_struct_vals(fd, i):
|
|
vals = []
|
|
if not fd[i].rstrip().endswith("},"):
|
|
# must be a sub-struct over multiple lines
|
|
old_i = i
|
|
i += 1
|
|
while not ("}," in fd[i] and "." in fd[i+1]):
|
|
temp = fd[i].split("{",1)[1].split("}",1)[0].split(", ")
|
|
a = []
|
|
for x in temp:
|
|
x = x.strip()
|
|
if x != "":
|
|
a.append(int(x, 0))
|
|
vals.append(a)
|
|
i += 1
|
|
else:
|
|
# single line
|
|
temp = fd[i].split("{",1)[1].split("}",1)[0].split(", ")
|
|
a = []
|
|
for x in temp:
|
|
x = x.strip()
|
|
if x != "":
|
|
a.append(int(x, 0))
|
|
vals.extend(a)
|
|
return vals, i
|
|
|
|
def cull_struct(fd, i):
|
|
out = []
|
|
vals = []
|
|
#print(f"Culling Starting at {fd[i]}")
|
|
if not fd[i].rstrip().endswith("},"):
|
|
# must be a sub-struct over multiple lines
|
|
old_i = i
|
|
vals, i = get_single_struct_vals(fd, i)
|
|
|
|
# reverse and cull entries of only zeros
|
|
x = recurse_check_list(vals[::-1])
|
|
#print(f"Found first index of empty values at idx {x}, vals: {vals}")
|
|
if x < 0:
|
|
#print(f"Ending at {fd[i]}")
|
|
return None, i
|
|
|
|
out.append(fd[old_i])
|
|
old_i += 1
|
|
for y in range(x):
|
|
out.append(fd[old_i])
|
|
old_i += 1
|
|
|
|
#print(f"Ending at {fd[i]}")
|
|
else:
|
|
prefix = fd[i].split("{",1)[0] + "{ "
|
|
suffix = " },"
|
|
|
|
vals, i = get_single_struct_vals(fd, i)
|
|
|
|
# reverse and cull entries of only zeros
|
|
x = recurse_check_list(vals[::-1])
|
|
#print(f"Found first index of empty values at idx {x}, vals: {vals}")
|
|
if x < 0:
|
|
#print(f"Ending at {fd[i]}")
|
|
return None, i
|
|
|
|
#out.append(prefix)
|
|
temp = ""
|
|
for z,y in enumerate(range(x)):
|
|
if z > 0:
|
|
prefix += ", "
|
|
prefix += f"{vals[y]}"
|
|
out.append(prefix + suffix)
|
|
#print(f"Ending at {fd[i]}")
|
|
return "\n".join(out), i
|
|
|
|
def MacroReplaceStaticNPC(fd):
|
|
replace_cull = { "unk_1C", "movement" }
|
|
fd = fd.splitlines()
|
|
out = []
|
|
i = 0
|
|
while i < len(fd):
|
|
if any(f".{x}" in fd[i] for x in replace_cull):
|
|
vals, i = cull_struct(fd, i)
|
|
if vals:
|
|
out.append(vals)
|
|
|
|
i += 1
|
|
continue
|
|
|
|
if ".itemDrops" in fd[i]:
|
|
vals, x = cull_struct(fd, i)
|
|
|
|
indent = len(fd[i].split(".",1)[0]) // 4
|
|
new_line = fd[i].split("{",1)[0] + "{\n"
|
|
|
|
if not vals:
|
|
i = x
|
|
i += 1
|
|
continue
|
|
|
|
vals += "\n},\n."
|
|
vals, _ = get_single_struct_vals(vals.splitlines(), 0)
|
|
|
|
added_item = False
|
|
for item in vals:
|
|
if item[0] == 0:
|
|
continue
|
|
|
|
added_item = True
|
|
item_name = constants["ItemId"][item[0]]
|
|
new_line += " " * (indent+1) + "{ " + item_name + f", {item[1]}, {item[2]}" + " },\n"
|
|
|
|
if added_item:
|
|
new_line += " " * indent + "},"
|
|
|
|
out.append(new_line)
|
|
i = x
|
|
|
|
elif ".animations" in fd[i]:
|
|
indent = len(fd[i].split(".",1)[0]) // 4
|
|
new_line = fd[i].split("{",1)[0] + "{\n"
|
|
|
|
vals, x = get_single_struct_vals(fd, i)
|
|
for val in vals:
|
|
sprite_id = (val & 0x00FF0000) >> 16
|
|
palette_id = (val & 0x0000FF00) >> 8
|
|
anim_id = (val & 0x000000FF) >> 0
|
|
sprite = constants["NPC_SPRITE"][sprite_id]["name"]
|
|
palette = constants["NPC_SPRITE"][sprite_id]["palettes"][palette_id]
|
|
anim = constants["NPC_SPRITE"][sprite_id]["anims"][anim_id]
|
|
new_line += " " * (indent+1) + f"NPC_ANIM({sprite}, {palette}, {anim}),\n"
|
|
new_line += " " * indent + "},"
|
|
out.append(new_line)
|
|
i = x
|
|
|
|
elif ".heartDrops" in fd[i] or ".flowerDrops" in fd[i]:
|
|
vals, x = get_single_struct_vals(fd, i)
|
|
|
|
new_line = fd[i].split("{",1)[0]
|
|
|
|
attempts = vals[0][2]
|
|
|
|
if ".heartDrops" in fd[i]:
|
|
if round(vals[0][1] / 327.67, 2) == 70 and round(vals[0][3] / 327.67, 2) == 50:
|
|
new_line += f"STANDARD_HEART_DROPS({attempts}),"
|
|
elif round(vals[0][1] / 327.67, 2) == 80 and round(vals[0][3] / 327.67, 2) == 50:
|
|
new_line += f"GENEROUS_HEART_DROPS({attempts}),"
|
|
elif round(vals[0][1] / 327.67, 2) == 80 and round(vals[0][3] / 327.67, 2) == 60:
|
|
new_line += f"GENEROUS_WHEN_LOW_HEART_DROPS({attempts}),"
|
|
else:
|
|
print(f"Unknown heart drop macro, values were {round(vals[0][1] / 327.67, 2)} and {round(vals[0][3] / 327.67, 2)}")
|
|
exit()
|
|
else:
|
|
if round(vals[0][1] / 327.67, 2) == 50 and round(vals[0][3] / 327.67, 2) == 40:
|
|
new_line += f"STANDARD_FLOWER_DROPS({attempts}),"
|
|
elif round(vals[0][1] / 327.67, 2) == 70 and round(vals[0][3] / 327.67, 2) == 50:
|
|
new_line += f"GENEROUS_WHEN_LOW_FLOWER_DROPS({attempts}),"
|
|
elif round(vals[0][1] / 327.67, 2) == 40 and round(vals[0][3] / 327.67, 2) == 40:
|
|
new_line += f"REDUCED_FLOWER_DROPS({attempts}),"
|
|
else:
|
|
print(f"Unknown heart drop macro, values were {round(vals[0][1] / 327.67, 2)} and {round(vals[0][3] / 327.67, 2)}")
|
|
exit()
|
|
|
|
out.append(new_line)
|
|
i = x
|
|
|
|
else:
|
|
out.append(fd[i])
|
|
i += 1
|
|
return "\n".join(out)
|
|
|
|
def MacroReplaceNpcSettings(fd):
|
|
replace_cull = { "unk_00", "unk_24" }
|
|
fd = fd.splitlines()
|
|
out = []
|
|
i = 0
|
|
while i < len(fd):
|
|
if any(f".{x}" in fd[i] for x in replace_cull):
|
|
vals, i = cull_struct(fd, i)
|
|
if vals:
|
|
out.append(vals)
|
|
else:
|
|
out.append(fd[i])
|
|
i += 1
|
|
return "\n".join(out)
|
|
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("file", type=str, help="File to decompile struct from")
|
|
parser.add_argument("offset", type=lambda x: int(x, 0), help="Offset to decompile struct from")
|
|
parser.add_argument("type", type=str, help="Struct type to decompile")
|
|
args = parser.parse_args()
|
|
|
|
get_constants()
|
|
get_structs()
|
|
|
|
if args.type not in STRUCTS:
|
|
print(f"Unknown struct type {args.type}")
|
|
exit()
|
|
|
|
'''
|
|
out = [f"{args.type} = " + "{\n"]
|
|
offset = args.offset
|
|
for var in STRUCTS[args.type]:
|
|
line, offset = output_type(fd, offset, var, 1)
|
|
out.append(line)
|
|
out.append("};")
|
|
'''
|
|
|
|
fd = Path(args.file).resolve().read_bytes()
|
|
out = output_type2(fd, args.offset, STRUCTS[args.type])
|
|
|
|
if args.type.lower() == "staticnpc":
|
|
print(MacroReplaceStaticNPC(out))
|
|
elif args.type.lower() == "npcaisettings":
|
|
print(out)
|
|
elif args.type.lower() == "npcsettings":
|
|
print(MacroReplaceNpcSettings(out))
|
|
else:
|
|
print(f"Add me type: {args.type}")
|