#!/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 #include #include #include namespace ava2 { namespace { LoginClient client; PyObject* handler=nullptr; PyObject* account_handler=nullptr; std::array 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("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(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!")