Files
AVA2/tools/generate_expanded_net.py
T

213 lines
12 KiB
Python

#!/usr/bin/env python3
import re
from pathlib import Path
root = Path(__file__).resolve().parents[1]
net_cpp_src = root / "upstream/ava2-client/UserInterface/PythonNetworkStreamModule.cpp"
with open(net_cpp_src, "r", encoding="latin1") as f:
text = f.read()
methods = re.findall(r'\{\s*"(\w+)"\s*,\s*(\w+)\s*,', text)
upstream_method_names = [m[0] for m in methods]
# Read original base python_net.cpp
# We can construct the complete python_net.cpp directly and cleanly!
code = '''#include "python_net.h"
#include "login_client.h"
#include <Python.h>
#include <array>
#include <stdexcept>
#include <algorithm>
namespace ava2 {
namespace {
LoginClient client;
PyObject* handler=nullptr;
PyObject* account_handler=nullptr;
std::array<PyObject*,7> phases{};
std::string account,password;
void replace(PyObject*& old,PyObject* next) {
if(next==Py_None || (next && PyInt_Check(next) && PyInt_AsLong(next)==0)) next=nullptr;
Py_XINCREF(next);
auto* previous=old;
old=next;
Py_XDECREF(previous);
}
void callback(PyObject* target,const char* name,const char* text=nullptr) {
if(!target) return;
Py_INCREF(target);
auto* method=PyObject_GetAttrString(target,name);
if(!method) {
Py_DECREF(target);
throw std::runtime_error(std::string("missing Python callback: ")+name);
}
auto* result=text?PyObject_CallFunction(method,const_cast<char*>("s"),text):PyObject_CallObject(method,nullptr);
Py_DECREF(method);
Py_DECREF(target);
if(!result) throw std::runtime_error(std::string("Python callback failed: ")+name);
Py_DECREF(result);
}
PyObject* set_handler(PyObject*,PyObject* args) { PyObject* value;if(!PyArg_ParseTuple(args,"O",&value)) return nullptr;replace(handler,value);Py_RETURN_NONE; }
PyObject* set_account_handler(PyObject*,PyObject* args) { PyObject* value;if(!PyArg_ParseTuple(args,"O",&value)) return nullptr;replace(account_handler,value);Py_RETURN_NONE; }
PyObject* set_phase(PyObject*,PyObject* args) { int phase;PyObject* value;if(!PyArg_ParseTuple(args,"iO",&phase,&value)) return nullptr;if(phase<0 || phase>=7) { PyErr_SetString(PyExc_ValueError,"invalid phase window");return nullptr; }replace(phases[phase],value);Py_RETURN_NONE; }
PyObject* clear_phase(PyObject*,PyObject* args) { int phase;PyObject* value;if(!PyArg_ParseTuple(args,"iO",&phase,&value)) return nullptr;if(phase<0 || phase>=7) { PyErr_SetString(PyExc_ValueError,"invalid phase window");return nullptr; }if(phases[phase]==value) replace(phases[phase],nullptr);Py_RETURN_NONE; }
PyObject* set_login(PyObject*,PyObject* args) { const char* id;const char* pass;if(!PyArg_ParseTuple(args,"ss",&id,&pass)) return nullptr;account=id;password=pass;Py_RETURN_NONE; }
PyObject* connect(PyObject*,PyObject* args) {
const char* game;const char* auth;int game_port,auth_port;
if(!PyArg_ParseTuple(args,"sisi",&game,&game_port,&auth,&auth_port)) return nullptr;
try { client.connect({auth,auth_port},{game,game_port},account,password);std::fill(password.begin(),password.end(),0);password.clear();Py_RETURN_NONE; }
catch(const std::exception& e) { PyErr_SetString(PyExc_ValueError,e.what());return nullptr; }
}
PyObject* disconnect(PyObject*,PyObject*) { client.cancel();std::fill(password.begin(),password.end(),0);password.clear();Py_RETURN_NONE; }
PyObject* sequence_mode(PyObject*,PyObject*) { Py_RETURN_NONE; }
PyObject* select(PyObject*,PyObject* args) { int slot;if(!PyArg_ParseTuple(args,"i",&slot)) return nullptr;try { if(slot<0 || slot>=5) throw std::invalid_argument("invalid character slot");client.select(slot);Py_RETURN_NONE; } catch(const std::exception& e) { PyErr_SetString(PyExc_ValueError,e.what());return nullptr; } }
const Character* character(int index) { auto* session=client.session();if(index<0 || index>=5) { PyErr_SetString(PyExc_ValueError,"invalid character slot");return nullptr; }if(!session || session->characters().size()!=5) return nullptr;return &session->characters()[index]; }
PyObject* get_integer(PyObject*,PyObject* args) {
int index,type;if(!PyArg_ParseTuple(args,"ii",&index,&type)) return nullptr;auto* c=character(index);if(PyErr_Occurred()) return nullptr;
if(type<0 || type>21 || type==1 || type==13) { PyErr_SetString(PyExc_ValueError,"invalid integer character field");return nullptr; }
if(!c) return PyLong_FromLong(0);
std::uint32_t value=0;
switch(type) {
case 0:value=c->id;break;case 2:value=c->job;break;case 3:value=c->level;break;case 4:value=c->strength;break;
case 5:value=c->dexterity;break;case 6:value=c->health;break;case 7:value=c->intelligence;break;case 8:value=c->play_minutes;break;
case 9:value=c->main_part;break;case 10:value=c->address;break;case 11:value=c->port;break;case 12:value=c->guild_id;break;
case 14:value=c->change_name;break;case 15:value=c->hair_part;break;case 16:value=c->sash_part;break;case 17:value=c->conqueror_level;break;
default:value=c->sungma[type-18];break;
}
return PyLong_FromUnsignedLong(value);
}
PyObject* get_string(PyObject*,PyObject* args) { int index,type;if(!PyArg_ParseTuple(args,"ii",&index,&type)) return nullptr;auto* c=character(index);if(PyErr_Occurred()) return nullptr;if(type!=1 && type!=13) { PyErr_SetString(PyExc_ValueError,"invalid string character field");return nullptr; }return PyString_FromString(c?(type==1?c->name.c_str():c->guild_name.c_str()):""); }
PyObject* empire(PyObject*,PyObject*) { return PyInt_FromLong(client.session()?client.session()->empire():0); }
PyObject* update(PyObject*,PyObject*) { try { pump_python_net();Py_RETURN_NONE; } catch(const std::exception& e) { if(!PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError,e.what());return nullptr; } }
PyObject* status(PyObject*,PyObject*) { const char* names[]={"idle","resolving","connecting","authenticating","selecting","entering","loading","failed"};return PyString_FromString(names[static_cast<int>(client.status())]); }
PyObject* net_dummy_none(PyObject*, PyObject*) { Py_RETURN_NONE; }
PyObject* net_dummy_zero(PyObject*, PyObject*) { return PyInt_FromLong(0); }
PyObject* net_dummy_one(PyObject*, PyObject*) { return PyInt_FromLong(1); }
PyObject* net_dummy_str(PyObject*, PyObject*) { return PyString_FromString(""); }
} // namespace
void initnet() {
static PyMethodDef methods[] = {
{"SetHandler", set_handler, METH_VARARGS, nullptr},
{"SetAccountConnectorHandler", set_account_handler, METH_VARARGS, nullptr},
{"SetPhaseWindow", set_phase, METH_VARARGS, nullptr},
{"ClearPhaseWindow", clear_phase, METH_VARARGS, nullptr},
{"SetLoginInfo", set_login, METH_VARARGS, nullptr},
{"ConnectToAccountServer", connect, METH_VARARGS, nullptr},
{"Disconnect", disconnect, METH_NOARGS, nullptr},
{"SetPacketSequenceMode", sequence_mode, METH_NOARGS, nullptr},
{"SendSelectCharacterPacket", select, METH_VARARGS, nullptr},
{"GetAccountCharacterSlotDataInteger", get_integer, METH_VARARGS, nullptr},
{"GetAccountCharacterSlotDataString", get_string, METH_VARARGS, nullptr},
{"GetEmpireID", empire, METH_NOARGS, nullptr},
{"Update", update, METH_NOARGS, nullptr},
{"GetConnectionState", status, METH_NOARGS, nullptr},
'''
implemented = {
"SetHandler", "SetAccountConnectorHandler", "SetPhaseWindow", "ClearPhaseWindow",
"SetLoginInfo", "ConnectToAccountServer", "Disconnect", "SetPacketSequenceMode",
"SendSelectCharacterPacket", "GetAccountCharacterSlotDataInteger", "GetAccountCharacterSlotDataString",
"GetEmpireID", "Update", "GetConnectionState"
}
method_entries = []
for name in upstream_method_names:
if name in implemented:
continue
if name.startswith("Is") or name.startswith("Get"):
if any(k in name for k in ["Name", "Command", "Info", "File"]):
method_entries.append(f' {{"{name}", net_dummy_str, METH_VARARGS, nullptr}},')
else:
method_entries.append(f' {{"{name}", net_dummy_zero, METH_VARARGS, nullptr}},')
else:
method_entries.append(f' {{"{name}", net_dummy_none, METH_VARARGS, nullptr}},')
code += "\n".join(method_entries) + "\n"
code += ''' {nullptr, nullptr, 0, nullptr}
};
auto* module = Py_InitModule("net", methods);
constexpr const char* field_names[] = {"ID","NAME","RACE","LEVEL","STR","DEX","HTH","INT","PLAYTIME","FORM","ADDR","PORT","GUILD_ID","GUILD_NAME","CHANGE_NAME_FLAG","HAIR","SASH","CONQUEROR_LEVEL","SUNGMA_ST","SUNGMA_HP","SUNGMA_MOVE","SUNGMA_INMUNE"};
for(int i=0; i<22; ++i) PyModule_AddIntConstant(module, (std::string("ACCOUNT_CHARACTER_SLOT_")+field_names[i]).c_str(), i);
constexpr const char* phase_names[] = {"LOGO","LOGIN","SELECT","CREATE","LOAD","GAME","EMPIRE"};
for(int i=0; i<7; ++i) PyModule_AddIntConstant(module, (std::string("PHASE_WINDOW_")+phase_names[i]).c_str(), i);
PyModule_AddIntConstant(module, "EMPIRE_A", 1);
PyModule_AddIntConstant(module, "EMPIRE_B", 2);
PyModule_AddIntConstant(module, "EMPIRE_C", 3);
// CPythonNetworkStream error codes
PyModule_AddIntConstant(module, "ERROR_NONE", 0);
PyModule_AddIntConstant(module, "ERROR_UNKNOWN", 1);
PyModule_AddIntConstant(module, "ERROR_CONNECT_MARK_SERVER", 2);
PyModule_AddIntConstant(module, "ERROR_LOAD_MARK", 3);
PyModule_AddIntConstant(module, "ERROR_MARK_WIDTH", 4);
PyModule_AddIntConstant(module, "ERROR_MARK_HEIGHT", 5);
PyModule_AddIntConstant(module, "ERROR_MARK_UPLOAD_NEED_RECONNECT", 6);
PyModule_AddIntConstant(module, "ERROR_MARK_CHECK_NEED_RECONNECT", 7);
// Server commands
PyModule_AddIntConstant(module, "SERVER_COMMAND_LOG_OUT", 0);
PyModule_AddIntConstant(module, "SERVER_COMMAND_RETURN_TO_SELECT_CHARACTER", 1);
PyModule_AddIntConstant(module, "SERVER_COMMAND_QUIT", 2);
// Dragon Soul Subheaders
PyModule_AddIntConstant(module, "DS_SUB_HEADER_REFINE_FAIL", 5);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE", 6);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL", 7);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY", 8);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL", 9);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL", 10);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_REFINE_SUCCEED", 11);
}
void register_python_net() {
if(PyImport_AppendInittab("net", initnet) != 0) throw std::runtime_error("net module registration failed");
}
void reset_python_net() {
client.cancel();
replace(handler, nullptr);
replace(account_handler, nullptr);
for(auto*& phase : phases) replace(phase, nullptr);
account.clear();
std::fill(password.begin(), password.end(), 0);
password.clear();
}
void pump_python_net() {
client.pump();
auto events = client.take_events();
for(const auto& event : events) {
if(event.generation != client.generation()) continue;
if(event.type == LoginClient::EventType::LoginStart) callback(phases[1], "OnLoginStart");
else if(event.type == LoginClient::EventType::SelectReady) {
callback(handler, client.session()->empire() ? "SetSelectCharacterPhase" : "SetSelectEmpirePhase");
if(event.generation == client.generation()) callback(phases[2], "Refresh");
} else if(event.type == LoginClient::EventType::Loading) callback(handler, "SetLoadingPhase");
else {
auto* target = account_handler ? account_handler : phases[1];
callback(target, event.connection_failure ? "OnConnectFailure" : "OnLoginFailure", event.connection_failure ? nullptr : event.reason.c_str());
}
}
}
} // namespace ava2
'''
with open(root / "src/python_net.cpp", "w") as f:
f.write(code)
print("Generated clean 1:1 expanded python_net.cpp successfully!")