Files
AVA2/tools/generate_evaluated_gameplay_modules.py
T

230 lines
9.2 KiB
Python

import re
import subprocess
from pathlib import Path
root = Path(__file__).resolve().parents[1]
upstream = root / "upstream/ava2-client"
modules_spec = [
("item", "initItem", "UserInterface/PythonItemModule.cpp"),
("player", "initPlayer", "UserInterface/PythonPlayerModule.cpp"),
("chrmgr", "initchrmgr", "UserInterface/PythonCharacterManagerModule.cpp"),
("chr", "initchr", "UserInterface/PythonCharacterModule.cpp"),
("chat", "initChat", "UserInterface/PythonChatModule.cpp"),
("snd", "initsnd", "UserInterface/PythonSoundManagerModule.cpp"),
("background", "initBackground", "UserInterface/PythonBackgroundModule.cpp"),
]
locale_text = (upstream / "UserInterface/Locale_inc.h").read_text(encoding="latin1")
def strip_comments(text):
text = re.sub(r'//.*', '', text)
text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
return text
# 1. Clean ItemData.h: stop BEFORE struct SItemTable_r / typedef struct SItemTable
itemdata_text = (upstream / "GameLib/ItemData.h").read_text(encoding="latin1")
table_pos = itemdata_text.find("TItemTable")
pre_typedef = itemdata_text.rfind("typedef", 0, table_pos)
itemdata_clean = itemdata_text[:pre_typedef] + "\n};\n"
itemdata_clean = "\n".join([l for l in itemdata_clean.splitlines() if not l.strip().startswith("#include")])
# 2. Clean GameType.h
gametype_text = (upstream / "UserInterface/GameType.h").read_text(encoding="latin1")
df_pos = gametype_text.find("// DEFAULT_FONT")
if df_pos == -1:
df_pos = gametype_text.find("DefaultFont")
if df_pos != -1:
gametype_text = gametype_text[:df_pos]
gametype_clean = "\n".join([l for l in gametype_text.splitlines() if not l.strip().startswith("#include")])
# 3. Clean Packet.h: extract ALL enums after stripping comments
packet_text = strip_comments((upstream / "UserInterface/Packet.h").read_text(encoding="latin1"))
packet_enums = re.findall(r'enum(\s+\w+)?\s*\{([^}]+)\};', packet_text)
seen_enums = set()
packet_enums_clean_list = []
for name, body in packet_enums:
if "MUSIC_NAME_MAX_LEN" in body:
if "MUSIC_NAME_MAX_LEN" in seen_enums:
continue
seen_enums.add("MUSIC_NAME_MAX_LEN")
packet_enums_clean_list.append(f"enum {name} {{{body}}};")
packet_enums_clean = "\n".join(packet_enums_clean_list)
# 4. Clean InstanceBase.h (extract ALL enums from InstanceBase.h after stripping comments)
ib_text = strip_comments((upstream / "UserInterface/InstanceBase.h").read_text(encoding="latin1"))
ib_enums = re.findall(r'enum(\s+\w+)?\s*\{([^}]+)\};', ib_text)
ib_enums_clean = "class CInstanceBase {\npublic:\n" + "\n".join(["enum " + e[0] + " {" + e[1] + "};" for e in ib_enums]) + "\n};\n"
def extract_class_enums(filepath, class_name):
txt = strip_comments((upstream / filepath).read_text(encoding="latin1"))
enums = re.findall(r'enum(\s+\w+)?\s*\{([^}]+)\};', txt)
return f"class {class_name} {{\npublic:\n" + "\n".join(["enum " + e[0] + " {" + e[1] + "};" for e in enums]) + "\n};\n"
pp_clean = extract_class_enums("UserInterface/PythonPlayer.h", "CPythonPlayer")
pi_clean = extract_class_enums("UserInterface/PythonItem.h", "CPythonItem")
rmd_clean = extract_class_enums("GameLib/RaceMotionData.h", "CRaceMotionData")
rd_clean = extract_class_enums("GameLib/RaceData.h", "CRaceData")
ai_clean = extract_class_enums("GameLib/ActorInstance.h", "CActorInstance")
chat_clean = extract_class_enums("UserInterface/PythonChat.h", "CPythonChat")
bg_clean = extract_class_enums("UserInterface/PythonBackground.h", "CPythonBackground")
mo_clean = extract_class_enums("GameLib/MapOutdoor.h", "CMapOutdoor")
sky_clean = extract_class_enums("EterLib/SkyBox.h", "CSkyObject")
pyplayer_cpp = (upstream / "UserInterface/PythonPlayerModule.cpp").read_text(encoding="latin1")
skill_consts = re.findall(r'extern const DWORD (c_iSkillIndex_\w+)\s*=\s*(\d+);', pyplayer_cpp)
skill_decl = "\n".join([f"const DWORD {name} = {val};" for name, val in skill_consts])
pyplayer_enums = re.findall(r'enum\s*\{([^}]+)\};', strip_comments(pyplayer_cpp))
pyplayer_module_enums = "\n".join(["enum {" + e + "};" for e in pyplayer_enums])
# Preprocess each module cpp to get exact methods and active constants
modules_data = {}
all_const_entries = []
for mod, init_fn, path in modules_spec:
raw_code = (upstream / path).read_text(encoding="latin1")
methods = re.findall(r'\{\s*"(\w+)"\s*,\s*(\w+)\s*,', raw_code)
method_names = [m[0] for m in methods]
lines = [l for l in raw_code.splitlines() if not l.strip().startswith("#include")]
res = subprocess.run([
"clang++", "-E",
"-include", str(upstream / "UserInterface/Locale_inc.h"),
"-x", "c++",
"-"
], input="\n".join(lines), capture_output=True, text=True)
if res.returncode != 0:
raise RuntimeError(f"Failed to preprocess {path}: {res.stderr}")
preprocessed_code = res.stdout
init_idx = preprocessed_code.find(f"void {init_fn}()")
body = preprocessed_code[init_idx:] if init_idx != -1 else ""
consts = re.findall(r'PyModule_AddIntConstant\s*\(\s*\w+,\s*\"(\w+)\"\s*,\s*([^)]+)\)', body)
modules_data[mod] = {
"init_fn": init_fn,
"methods": method_names,
"consts": consts,
}
for cname, cval in consts:
all_const_entries.append((mod, cname, cval.strip()))
print(f"Total active constants to evaluate: {len(all_const_entries)}")
eval_lines = []
for i, (mod, cname, cval) in enumerate(all_const_entries):
eval_lines.append(f' std::cout << "{mod}:{cname}:" << ({cval}) << std::endl;')
generator_source = f"""
#include <iostream>
#include <cstdint>
#include <string>
#include <cmath>
#include <vector>
#include <map>
typedef uint32_t DWORD;
typedef uint16_t WORD;
typedef uint8_t BYTE;
typedef int BOOL;
typedef long LONG;
typedef float FLOAT;
typedef unsigned int UINT;
#define CHARACTER_NAME_MAX_LEN 24
#define PLAYER_NAME_MAX_LEN 12
#define POINT_MAX_NUM 255
#define SKILL_MAX_NUM 255
{locale_text}
{itemdata_clean}
{gametype_clean}
{packet_enums_clean}
{ib_enums_clean}
{pp_clean}
{pi_clean}
{rmd_clean}
{rd_clean}
{ai_clean}
{chat_clean}
{bg_clean}
{mo_clean}
{sky_clean}
{skill_decl}
{pyplayer_module_enums}
int main() {{
{chr(10).join(eval_lines)}
return 0;
}}
"""
Path("/tmp/run_all_evals.cpp").write_text(generator_source)
res = subprocess.run(["clang++", "-std=c++17", "-Wno-everything", "/tmp/run_all_evals.cpp", "-o", "/tmp/run_all_evals"], capture_output=True, text=True)
if res.returncode != 0:
print("Compile error in run_all_evals:\n", res.stderr[:3000])
exit(1)
print("Evaluator binary compiled! Running...")
eval_out = subprocess.check_output(["/tmp/run_all_evals"]).decode().splitlines()
print(f"Evaluated {len(eval_out)} constants!")
evaluated_dict = {}
for line in eval_out:
parts = line.split(":", 2)
if len(parts) == 3:
evaluated_dict[(parts[0], parts[1])] = parts[2]
# Now generate python_gameplay_modules.h and python_gameplay_modules.cpp
h_out = ["#pragma once\n\nnamespace ava2 {\n"]
cpp_out = [
'#include "python_gameplay_modules.h"\n',
'#include <Python.h>\n',
'#include <string>\n',
'#include <vector>\n\n',
'namespace ava2 {\n',
'namespace {\n',
'PyObject* dummy_none(PyObject*, PyObject*) { Py_RETURN_NONE; }\n',
'PyObject* dummy_zero(PyObject*, PyObject*) { return PyInt_FromLong(0); }\n',
'PyObject* dummy_one(PyObject*, PyObject*) { return PyInt_FromLong(1); }\n',
'PyObject* dummy_str(PyObject*, PyObject*) { return PyString_FromString(""); }\n',
'PyObject* dummy_tuple2(PyObject*, PyObject*) { return Py_BuildValue("ii", 0, 0); }\n',
'PyObject* dummy_tuple3(PyObject*, PyObject*) { return Py_BuildValue("iii", 0, 0, 0); }\n',
'PyObject* dummy_tuple4(PyObject*, PyObject*) { return Py_BuildValue("iiii", 0, 0, 0, 0); }\n',
'} // namespace\n\n',
]
for mod, data in modules_data.items():
init_fn = data["init_fn"]
h_out.append(f"void {init_fn}();\n")
cpp_out.append(f"void {init_fn}() {{\n")
cpp_out.append(f" static PyMethodDef methods[] = {{\n")
for m in data["methods"]:
if m.startswith("Is") or m.startswith("Get"):
if any(k in m for k in ["Name", "String", "Text", "Title", "Path"]):
cpp_out.append(f' {{"{m}", dummy_str, METH_VARARGS, nullptr}},\n')
elif any(k in m for k in ["Position", "PixelPosition", "Coord"]):
cpp_out.append(f' {{"{m}", dummy_tuple3, METH_VARARGS, nullptr}},\n')
else:
cpp_out.append(f' {{"{m}", dummy_zero, METH_VARARGS, nullptr}},\n')
else:
cpp_out.append(f' {{"{m}", dummy_none, METH_VARARGS, nullptr}},\n')
cpp_out.append(f" {{nullptr, nullptr, 0, nullptr}}\n }};\n")
cpp_out.append(f' auto* module = Py_InitModule("{mod}", methods);\n\n')
for cname, _ in data["consts"]:
int_val = evaluated_dict.get((mod, cname), "0")
cpp_out.append(f' PyModule_AddIntConstant(module, "{cname}", {int_val});\n')
cpp_out.append("}\n\n")
h_out.append("} // namespace ava2\n")
cpp_out.append("} // namespace ava2\n")
(root / "src/python_gameplay_modules.h").write_text("".join(h_out))
(root / "src/python_gameplay_modules.cpp").write_text("".join(cpp_out))
print("Successfully generated src/python_gameplay_modules.h and src/python_gameplay_modules.cpp!")