1499 lines
75 KiB
C++
1499 lines
75 KiB
C++
#include "python_net.h"
|
|
#include "python_app.h"
|
|
#include "guild_state.h"
|
|
#include "python_gameplay_modules.h"
|
|
#include "login_client.h"
|
|
#include "protocol.h"
|
|
#include "eter_net/PythonNetworkStream.h"
|
|
#include "eter_net/NetworkActorManager.h"
|
|
#include "shared/common/PythonUtils.h"
|
|
#include "python_runtime.h"
|
|
#include <Python.h>
|
|
#include <array>
|
|
#include <iostream>
|
|
#include <chrono>
|
|
#include <stdexcept>
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
|
|
namespace ava2 {
|
|
namespace {
|
|
|
|
LoginClient client;
|
|
PyObject* handler=nullptr;
|
|
PyObject* account_handler=nullptr;
|
|
std::array<PyObject*,7> phases{};
|
|
std::string account,password;
|
|
std::array<Character, 5> mock_characters{};
|
|
bool has_mock_characters = false;
|
|
std::uint8_t mock_empire = 0;
|
|
bool has_mock_empire = false;
|
|
|
|
|
|
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);
|
|
}
|
|
|
|
// PyCallClassMemberFunc (ScriptLib): a missing method is skipped, a Python
|
|
// exception is printed; neither aborts the network pump.
|
|
void callback(PyObject* target,const char* name,const char* text=nullptr) {
|
|
PyCallClassMemberFunc(target,name,text?Py_BuildValue("(s)",text):Py_BuildValue("()"));
|
|
}
|
|
|
|
PyObject* set_handler(PyObject*,PyObject* args) { PyObject* value;if(!PyArg_ParseTuple(args,"O",&value)) return nullptr;replace(handler,value);PythonNetworkStream::Instance().SetHandler(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; }// Release both native owners before installing a successor: old LoadingWindow
|
|
// __del__ calls SetPhaseWindow(LOAD, 0), which otherwise unregisters the new one.
|
|
if(value==Py_None || (value && PyInt_Check(value) && PyInt_AsLong(value)==0)) value=nullptr;
|
|
if(phases[phase]==value) Py_RETURN_NONE;
|
|
Py_XINCREF(value);
|
|
auto* previous=phases[phase]; phases[phase]=nullptr;
|
|
PythonNetworkStream::Instance().SetPhaseWindow(phase,nullptr);
|
|
Py_XDECREF(previous);
|
|
replace(phases[phase],value);
|
|
PythonNetworkStream::Instance().SetPhaseWindow(phase,value);
|
|
Py_XDECREF(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);PythonNetworkStream::Instance().ClearPhaseWindow(phase, value); }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);PythonNetworkStream::Instance().ResetConnection();has_mock_characters=has_mock_empire=false;mock_characters.fill({});mock_empire=0;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();PythonNetworkStream::Instance().ResetConnection();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;
|
|
if(slot<0 || slot>=5) { PyErr_SetString(PyExc_ValueError,"invalid character slot");return nullptr; }
|
|
if(has_mock_characters) Py_RETURN_NONE;
|
|
if(client.is_direct_enter()) {
|
|
// DirectEnter already executed the character selection on the map core
|
|
Py_RETURN_NONE;
|
|
}
|
|
try { client.select(slot);Py_RETURN_NONE; }
|
|
catch(const std::exception& e) { PyErr_SetString(PyExc_ValueError,e.what());return nullptr; }
|
|
}
|
|
|
|
PyObject* direct_enter(PyObject*,PyObject* args) {
|
|
int slot;
|
|
if(!PyArg_ParseTuple(args,"i",&slot)) return nullptr;
|
|
if(slot<0 || slot>=5) { PyErr_SetString(PyExc_ValueError,"invalid character slot");return nullptr; }
|
|
if(has_mock_characters) { PyErr_SetString(PyExc_RuntimeError,"DirectEnter unavailable for preview characters");return nullptr; }
|
|
try { client.direct_enter(static_cast<std::uint8_t>(slot));Py_RETURN_NONE; }
|
|
catch(const std::exception& e) { PyErr_SetString(PyExc_ValueError,e.what());return nullptr; }
|
|
}
|
|
|
|
const Character* character(int index) {
|
|
if(index<0 || index>=5) { PyErr_SetString(PyExc_ValueError,"invalid character slot");return nullptr; }
|
|
if(has_mock_characters) return &mock_characters[index];
|
|
auto* session=client.session();
|
|
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(has_mock_empire ? mock_empire : (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* is_connected(PyObject*,PyObject*) { return PyInt_FromLong(client.is_connected()); }
|
|
|
|
static PyObject* net_ElementsSpellClose(PyObject*, PyObject*) { return Py_BuildNone(); }
|
|
static PyObject* net_ElementsSpellAdd(PyObject*, PyObject*) { return Py_BuildNone(); }
|
|
static PyObject* net_ElementsSpellChange(PyObject*, PyObject*) { return Py_BuildNone(); }
|
|
static PyObject* net_SendCombatZoneRequestActionPacket(PyObject*, PyObject*) { return Py_BuildNone(); }
|
|
static PyObject* net_CombatZone_IsRunning(PyObject*, PyObject*) { return PyInt_FromLong(0); }
|
|
static PyObject* net_CombatZone_GetRankings(PyObject*, PyObject*) { return Py_BuildValue("iiii", 0, 0, 0, 0); }
|
|
static PyObject* net_CombatZone_GetDay(PyObject*, PyObject*) { return Py_BuildValue("iiii", 0, 0, 0, 0); }
|
|
static PyObject* net_CombatZone_GetDayActivate(PyObject*, PyObject*) { return PyInt_FromLong(0); }
|
|
|
|
// ── AVA2 PythonNetworkStreamModule.cpp wrappers (ScriptLib argument helpers, Py_BuildException -> None) ──
|
|
PyObject* netSendExchangeStartPacket(PyObject*, PyObject* poArgs) {
|
|
int vid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &vid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendExchangeStartPacket(vid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendExchangeElkAddPacket(PyObject*, PyObject* poArgs) {
|
|
long long elk;
|
|
if (!PyTuple_GetLongLong(poArgs, 0, &elk)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendExchangeElkAddPacket(elk);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendExchangeItemAddPacket(PyObject*, PyObject* poArgs) {
|
|
unsigned char window; unsigned short slot; int displayPos;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &window)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &slot)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 2, &displayPos)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendExchangeItemAddPacket(window, slot, static_cast<uint8_t>(displayPos));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendExchangeItemDelPacket(PyObject*, PyObject* poArgs) {
|
|
int pos;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &pos)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendExchangeItemDelPacket(static_cast<uint8_t>(pos));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendExchangeAcceptPacket(PyObject*, PyObject*) { PythonNetworkStream::Instance().SendExchangeAcceptPacket();return Py_BuildNone(); }
|
|
PyObject* netSendExchangeExitPacket(PyObject*, PyObject*) { PythonNetworkStream::Instance().SendExchangeExitPacket();return Py_BuildNone(); }
|
|
|
|
PyObject* netSendPrivateShopSearchInfo(PyObject*,PyObject* args) {
|
|
TPacketCGShopSearch p{};
|
|
if(!PyTuple_GetInteger(args,0,&p.ItemCat)||!PyTuple_GetInteger(args,1,&p.SubCat))return Py_BuildException();
|
|
uint8_t* pairs[]={p.avg,p.skill,p.abs,p.level,p.refine};
|
|
for(int i=0;i<10;++i)if(!PyTuple_GetInteger(args,i+2,&pairs[i/2][i%2]))return Py_BuildException();
|
|
if(!PyTuple_GetInteger(args,12,&p.enchant)||!PyTuple_GetInteger(args,13,&p.alchemy)||
|
|
!PyTuple_GetInteger(args,14,&p.sex)||!PyTuple_GetInteger(args,15,&p.character))return Py_BuildException();
|
|
long long lo,hi;char* input;
|
|
if(!PyTuple_GetLongLong(args,16,&lo)||!PyTuple_GetLongLong(args,17,&hi)||!PyTuple_GetString(args,18,&input))return Py_BuildException();
|
|
if(PyErr_Occurred())return nullptr;
|
|
const size_t length=std::strlen(input);
|
|
if(length>=sizeof(p.searchInput)) { PyErr_SetString(PyExc_ValueError,"Shop search text exceeds 49 bytes");return nullptr; }
|
|
std::memcpy(p.searchInput,input,length);p.price[0]=lo;p.price[1]=hi;
|
|
PythonNetworkStream::Instance().SendPrivateShopSearchInfo(p);Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* netSendMessengerAddByVIDPacket(PyObject*, PyObject* poArgs) {
|
|
int vid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &vid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendMessengerAddByVIDPacket(vid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendMessengerAddByNamePacket(PyObject*, PyObject* poArgs) {
|
|
char* name;
|
|
if (!PyTuple_GetString(poArgs, 0, &name)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendMessengerAddByNamePacket(name);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendMessengerRemovePacket(PyObject*, PyObject* poArgs) {
|
|
char* key; char* name;
|
|
if (!PyTuple_GetString(poArgs, 0, &key)) return Py_BuildException();
|
|
if (!PyTuple_GetString(poArgs, 1, &name)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendMessengerRemovePacket(key, name);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static inline bool party_member_vid_to_pid(uint32_t vid, uint32_t* pid) {
|
|
return PartyMemberVIDToPID(vid, pid);
|
|
}
|
|
|
|
PyObject* netSendPartyInvitePacket(PyObject*, PyObject* poArgs) {
|
|
int vid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &vid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendPartyInvitePacket(vid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendPartyInviteAnswerPacket(PyObject*, PyObject* poArgs) {
|
|
int vid, answer;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &vid)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &answer)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendPartyInviteAnswerPacket(vid, static_cast<uint8_t>(answer));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendPartyExitPacket(PyObject*, PyObject*) {
|
|
uint32_t pid;
|
|
if (party_member_vid_to_pid(PythonNetworkStream::Instance().GetMainActorVID(), &pid))
|
|
PythonNetworkStream::Instance().SendPartyRemovePacket(pid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendPartyRemovePacketPID(PyObject*, PyObject* poArgs) {
|
|
int pid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &pid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendPartyRemovePacket(pid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendPartyRemovePacketVID(PyObject*, PyObject* poArgs) {
|
|
int vid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &vid)) return Py_BuildException();
|
|
uint32_t pid;
|
|
if (party_member_vid_to_pid(vid, &pid)) PythonNetworkStream::Instance().SendPartyRemovePacket(pid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendPartySetStatePacket(PyObject*, PyObject* poArgs) {
|
|
int vid, state, flag;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &vid)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &state)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 2, &flag)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendPartySetStatePacket(vid, static_cast<uint8_t>(state), static_cast<uint8_t>(flag));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendPartyUseSkillPacket(PyObject*, PyObject* poArgs) {
|
|
int skillIndex, vid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &skillIndex)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &vid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendPartyUseSkillPacket(static_cast<uint8_t>(skillIndex), vid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendPartyParameterPacket(PyObject*, PyObject* poArgs) {
|
|
int mode;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &mode)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendPartyParameterPacket(static_cast<uint8_t>(mode));
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
PyObject* netSendSafeboxSaveMoneyPacket(PyObject*, PyObject* poArgs) {
|
|
int money;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &money)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendSafeBoxMoneyPacket(0, money); // SAFEBOX_MONEY_STATE_SAVE: disabled, sends nothing
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendSafeboxWithdrawMoneyPacket(PyObject*, PyObject* poArgs) {
|
|
int money;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &money)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendSafeBoxMoneyPacket(1, money); // SAFEBOX_MONEY_STATE_WITHDRAW: disabled, sends nothing
|
|
return Py_BuildNone();
|
|
}
|
|
// TItemPos() starts as {INVENTORY, WORD_MAX}; Windows' switch has no default for other arg counts,
|
|
// sending the ctor position and an uninitialized safebox slot (emitted as 0 here).
|
|
PyObject* netSendSafeboxCheckinPacket(PyObject*, PyObject* poArgs) {
|
|
unsigned char window = 1; unsigned short cell = 0xffff; int safeboxPos = 0;
|
|
switch (PyTuple_Size(poArgs)) {
|
|
case 2:
|
|
window = 1;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &cell)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &safeboxPos)) return Py_BuildException();
|
|
break;
|
|
case 3:
|
|
if (!PyTuple_GetInteger(poArgs, 0, &window)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &cell)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 2, &safeboxPos)) return Py_BuildException();
|
|
break;
|
|
}
|
|
PythonNetworkStream::Instance().SendSafeBoxCheckinPacket(window, cell, static_cast<uint8_t>(safeboxPos));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendSafeboxCheckoutPacket(PyObject*, PyObject* poArgs) {
|
|
int safeboxPos = 0; unsigned char window = 1; unsigned short cell = 0xffff;
|
|
switch (PyTuple_Size(poArgs)) {
|
|
case 2:
|
|
if (!PyTuple_GetInteger(poArgs, 0, &safeboxPos)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &cell)) return Py_BuildException();
|
|
break;
|
|
case 3:
|
|
if (!PyTuple_GetInteger(poArgs, 0, &safeboxPos)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &window)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 2, &cell)) return Py_BuildException();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
PythonNetworkStream::Instance().SendSafeBoxCheckoutPacket(static_cast<uint8_t>(safeboxPos), window, cell);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendSafeboxItemMovePacket(PyObject*, PyObject* poArgs) {
|
|
int source, target, count;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &source)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &target)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 2, &count)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendSafeBoxItemMovePacket(static_cast<uint8_t>(source), static_cast<uint8_t>(target), static_cast<uint32_t>(count));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendMallCheckoutPacket(PyObject*, PyObject* poArgs) {
|
|
int mallPos; unsigned char window = 1; unsigned short cell = 0xffff;
|
|
switch (PyTuple_Size(poArgs)) {
|
|
case 2:
|
|
if (!PyTuple_GetInteger(poArgs, 0, &mallPos)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &cell)) return Py_BuildException();
|
|
break;
|
|
case 3:
|
|
if (!PyTuple_GetInteger(poArgs, 0, &mallPos)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &window)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 2, &cell)) return Py_BuildException();
|
|
break;
|
|
default:
|
|
return Py_BuildException();
|
|
}
|
|
PythonNetworkStream::Instance().SendMallCheckoutPacket(static_cast<uint8_t>(mallPos), window, cell);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
PyObject* netSendAnswerMakeGuildPacket(PyObject*, PyObject* poArgs) {
|
|
char* name;
|
|
if (!PyTuple_GetString(poArgs, 0, &name)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendAnswerMakeGuildPacket(name);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendQuestInputStringPacket(PyObject*, PyObject* poArgs) {
|
|
char* text;
|
|
if (!PyTuple_GetString(poArgs, 0, &text)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendQuestInputStringPacket(text);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendQuestInputLongStringPacket(PyObject*, PyObject* poArgs) {
|
|
char* text;
|
|
if (!PyTuple_GetString(poArgs, 0, &text)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendQuestInputStringLongPacket(text);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendQuestConfirmPacket(PyObject*, PyObject* poArgs) {
|
|
int answer, pid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &answer)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &pid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendQuestConfirmPacket(static_cast<uint8_t>(answer), pid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendRequestRefineInfoPacket(PyObject*, PyObject* poArgs) {
|
|
int slot;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &slot)) return Py_BuildException();
|
|
// Windows: assert(!"... not used anymore"); nothing is sent.
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendSelectItemPacket(PyObject*, PyObject* poArgs) {
|
|
int itemPos;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &itemPos)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendSelectItemPacket(itemPos);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netTargetInfoLoad(PyObject*, PyObject* poArgs) {
|
|
unsigned int vid; // DWORD: Windows' "dwVID < 0" early return can never fire
|
|
if (!PyArg_ParseTuple(poArgs, "i", &vid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendTargetInfoLoadPacket(vid);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
PyObject* netGetGuildID(PyObject*,PyObject*) {return PyInt_FromLong(int32_t(PythonNetworkStream::Instance().GetGuildID()));}
|
|
|
|
PyObject* netSendGuildAddMemberPacket(PyObject*, PyObject* poArgs) {
|
|
int vid;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &vid)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildAddMemberPacket(vid);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildRemoveMemberPacket(PyObject*, PyObject* poArgs) {
|
|
char* key;
|
|
if (!PyTuple_GetString(poArgs, 0, &key)) return Py_BuildException();
|
|
if (auto* member=GetGuildState().ByName(key))
|
|
PythonNetworkStream::Instance().SendGuildRemoveMemberPacket(member->pid);
|
|
else
|
|
std::cerr << "netSendGuildRemoveMemberPacket(szKey=" << key << ") - Can't Find Guild Member\n";
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildChangeGradeNamePacket(PyObject*, PyObject* poArgs) {
|
|
int grade; char* name;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &grade)) return Py_BuildException();
|
|
if (!PyTuple_GetString(poArgs, 1, &name)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildChangeGradeNamePacket(static_cast<uint8_t>(grade), name);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildChangeGradeAuthorityPacket(PyObject*, PyObject* poArgs) {
|
|
int grade, authority;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &grade)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &authority)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildChangeGradeAuthorityPacket(static_cast<uint8_t>(grade), static_cast<uint8_t>(authority));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildOfferPacket(PyObject*, PyObject* poArgs) {
|
|
int experience;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &experience)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildOfferPacket(experience);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSnedGuildPostCommentPacket(PyObject*, PyObject* poArgs) {
|
|
char* comment;
|
|
if (!PyTuple_GetString(poArgs, 0, &comment)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildPostCommentPacket(comment);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSnedGuildDeleteCommentPacket(PyObject*, PyObject* poArgs) {
|
|
int index;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &index)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildDeleteCommentPacket(index);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildRefreshCommentsPacket(PyObject*, PyObject* poArgs) {
|
|
int highestIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &highestIndex)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildRefreshCommentsPacket(highestIndex);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildChangeMemberGradePacket(PyObject*, PyObject* poArgs) {
|
|
int pid, grade;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &pid)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &grade)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildChangeMemberGradePacket(pid, static_cast<uint8_t>(grade));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildUseSkillPacket(PyObject*, PyObject* poArgs) {
|
|
int skillID, targetVID;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &skillID)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &targetVID)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildUseSkillPacket(skillID, targetVID);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildChangeMemberGeneralPacket(PyObject*, PyObject* poArgs) {
|
|
int pid, flag;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &pid)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &flag)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildChangeMemberGeneralPacket(pid, static_cast<uint8_t>(flag));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildInviteAnswerPacket(PyObject*, PyObject* poArgs) {
|
|
int guildID, answer;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &guildID)) return Py_BuildException();
|
|
if (!PyTuple_GetInteger(poArgs, 1, &answer)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildInviteAnswerPacket(guildID, static_cast<uint8_t>(answer));
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildChargeGSPPacket(PyObject*, PyObject* poArgs) {
|
|
int gsp;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &gsp)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildChargeGSPPacket(gsp);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildDepositMoneyPacket(PyObject*, PyObject* poArgs) {
|
|
int money;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &money)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildDepositMoneyPacket(money);
|
|
return Py_BuildNone();
|
|
}
|
|
PyObject* netSendGuildWithdrawMoneyPacket(PyObject*, PyObject* poArgs) {
|
|
int money;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &money)) return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendGuildWithdrawMoneyPacket(money);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
PyObject* net_get_main_actor_vid(PyObject*, PyObject*) {
|
|
uint32_t vid = PythonNetworkStream::Instance().GetMainActorVID();
|
|
if (vid == 0 && has_mock_characters) vid = 1001;
|
|
return PyLong_FromUnsignedLong(vid);
|
|
}
|
|
|
|
PyObject* net_get_main_actor_race(PyObject*, PyObject*) {
|
|
return PyInt_FromLong(PythonNetworkStream::Instance().GetMainActorRace());
|
|
}
|
|
|
|
PyObject* net_get_main_actor_empire(PyObject*, PyObject*) {
|
|
return PyInt_FromLong(PythonNetworkStream::Instance().GetMainActorEmpire());
|
|
}
|
|
|
|
PyObject* net_get_main_actor_skill_group(PyObject*, PyObject*) {
|
|
return PyInt_FromLong(PythonNetworkStream::Instance().GetMainActorSkillGroup());
|
|
}
|
|
|
|
PyObject* net_get_field_music_name(PyObject*, PyObject*) {
|
|
return PyString_FromString(PythonNetworkStream::Instance().GetFieldMusicFileName().c_str());
|
|
}
|
|
|
|
PyObject* net_get_field_music_volume(PyObject*, PyObject*) {
|
|
return PyFloat_FromDouble(PythonNetworkStream::Instance().GetFieldMusicVolume());
|
|
}
|
|
|
|
PyObject* net_start_game(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().StartGame();
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* net_send_enter_game(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendEnterGamePacket();
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* net_send_chat(PyObject*, PyObject* args) {
|
|
char* text = nullptr;
|
|
int type = 0;
|
|
if (PyArg_ParseTuple(args, "s|i", &text, &type)) {
|
|
if (text) {
|
|
PythonNetworkStream::Instance().SendChatPacket(text, static_cast<uint8_t>(type));
|
|
}
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* net_send_whisper(PyObject*, PyObject* args) {
|
|
char* name = nullptr;
|
|
char* text = nullptr;
|
|
if (PyArg_ParseTuple(args, "ss", &name, &text)) {
|
|
if (name && text) {
|
|
PythonNetworkStream::Instance().SendWhisperPacket(name, text);
|
|
}
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* net_send_item_pickup(PyObject*, PyObject* args) {
|
|
int vid = 0;
|
|
if (PyArg_ParseTuple(args, "i", &vid)) {
|
|
PythonNetworkStream::Instance().SendItemPickUpPacket(static_cast<uint32_t>(vid));
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* net_send_item_drop(PyObject*, PyObject* args) {
|
|
int win=1,slot=0;
|
|
if(PyTuple_Size(args)==1) {if(!PyArg_ParseTuple(args,"i",&slot)) return nullptr;}
|
|
else if(!PyArg_ParseTuple(args,"ii",&win,&slot)) return nullptr;
|
|
try {PythonNetworkStream::Instance().SendItemDropPacket(uint8_t(win),uint16_t(slot),0);}
|
|
catch(const std::exception& e) {PyErr_SetString(PyExc_RuntimeError,e.what());return nullptr;}
|
|
Py_RETURN_NONE;
|
|
}
|
|
template<bool New> PyObject* net_send_gold_drop(PyObject*,PyObject* args) {
|
|
int gold;if(!PyArg_ParseTuple(args,"i",&gold)) return nullptr;
|
|
try {
|
|
if constexpr(New) PythonNetworkStream::Instance().SendItemDropPacketNew(0,0,uint32_t(gold),0);
|
|
else PythonNetworkStream::Instance().SendItemDropPacket(0,0,uint32_t(gold));
|
|
} catch(const std::exception& e) {PyErr_SetString(PyExc_RuntimeError,e.what());return nullptr;}
|
|
Py_RETURN_NONE;
|
|
}
|
|
PyObject* net_send_item_drop_new(PyObject*, PyObject* args) {
|
|
int win=1,slot=0,count=0;
|
|
if(PyTuple_Size(args)==2) {if(!PyArg_ParseTuple(args,"ii",&slot,&count)) return nullptr;}
|
|
else if(!PyArg_ParseTuple(args,"iii",&win,&slot,&count)) return nullptr;
|
|
try {PythonNetworkStream::Instance().SendItemDropPacketNew(uint8_t(win),uint16_t(slot),0,uint32_t(count));}
|
|
catch(const std::exception& e) {PyErr_SetString(PyExc_RuntimeError,e.what());return nullptr;}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* net_send_onclick(PyObject*, PyObject* args) {
|
|
int vid = 0;
|
|
if (PyArg_ParseTuple(args, "i", &vid)) {
|
|
PythonNetworkStream::Instance().SendOnClickPacket(static_cast<uint32_t>(vid));
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* net_warp(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendWarpPacket();
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
// CPythonNetworkStream::Send* on the select connection; Windows only traces a failed Send.
|
|
void send_select_packet(const char* what,wire::Bytes packet) {
|
|
try { client.send_select_packet(std::move(packet)); }
|
|
catch(const std::exception& e) { SDL_Log("%s - Error: %s",what,e.what()); }
|
|
}
|
|
|
|
PyObject* send_create_character(PyObject*, PyObject* args) {
|
|
int slot = 0, race = 0, shape = 0, con = 0, i_stat = 0, str = 0, dex = 0;
|
|
char* name = nullptr;
|
|
if (!PyArg_ParseTuple(args, "isiiiiii", &slot, &name, &race, &shape, &con, &i_stat, &str, &dex))
|
|
return nullptr;
|
|
if(!has_mock_characters) {
|
|
// netSendCreateCharacterPacket: (BYTE) index/job/shape and the four stats.
|
|
send_select_packet("Failed to SendCreateCharacterPacket",wire::create_character(std::uint8_t(slot),name,std::uint8_t(race),std::uint8_t(shape),
|
|
std::uint8_t(con),std::uint8_t(i_stat),std::uint8_t(str),std::uint8_t(dex)));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
if (slot >= 0 && slot < 5) {
|
|
Character chr;
|
|
chr.id = 1000 + slot;
|
|
chr.name = name ? name : "";
|
|
chr.job = race;
|
|
chr.level = 1;
|
|
chr.health = con;
|
|
chr.intelligence = i_stat;
|
|
chr.strength = str;
|
|
chr.dexterity = dex;
|
|
chr.play_minutes = 0;
|
|
set_mock_character(slot, chr);
|
|
}
|
|
|
|
if (phases[3]) { // PHASE_WINDOW_CREATE
|
|
PyObject* res = PyObject_CallMethod(phases[3], const_cast<char*>("OnCreateSuccess"), nullptr);
|
|
if (res) {
|
|
Py_DECREF(res);
|
|
} else {
|
|
PyErr_Clear();
|
|
}
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* send_destroy_character(PyObject*, PyObject* args) {
|
|
int slot = 0;
|
|
char* privateCode = nullptr;
|
|
if (!PyArg_ParseTuple(args, "is", &slot, &privateCode))
|
|
return nullptr;
|
|
if(!has_mock_characters) {
|
|
send_select_packet("SendDestroyCharacterPacket",wire::destroy_character(std::uint8_t(slot),privateCode));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
if (slot >= 0 && slot < 5) {
|
|
mock_characters[slot] = Character{};
|
|
}
|
|
|
|
if (phases[2]) { // PHASE_WINDOW_SELECT
|
|
PyObject* res = PyObject_CallMethod(phases[2], const_cast<char*>("OnDeleteSuccess"), const_cast<char*>("i"), slot);
|
|
if (res) {
|
|
Py_DECREF(res);
|
|
} else {
|
|
PyErr_Clear();
|
|
}
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
CharacterMoveState last_move_state{};
|
|
|
|
PyObject* send_character_move_packet(PyObject*, PyObject* args) {
|
|
int func = 0;
|
|
int arg = 0;
|
|
float rot = 0.0f;
|
|
int x = 0;
|
|
int y = 0;
|
|
unsigned int time = 0;
|
|
|
|
if (PyTuple_Size(args) >= 5) {
|
|
if (!PyArg_ParseTuple(args, "iifii|I", &func, &arg, &rot, &x, &y, &time)) {
|
|
PyErr_Clear();
|
|
int irot = 0;
|
|
if (!PyArg_ParseTuple(args, "iiiii|I", &func, &arg, &irot, &x, &y, &time)) {
|
|
return nullptr;
|
|
}
|
|
rot = static_cast<float>(irot);
|
|
}
|
|
} else if (PyTuple_Size(args) == 2) {
|
|
if (!PyArg_ParseTuple(args, "ii", &x, &y)) return nullptr;
|
|
func = 1;
|
|
}
|
|
|
|
uint8_t bRot = static_cast<uint8_t>(std::clamp(static_cast<int>(rot / 5.0f), 0, 255));
|
|
if (time == 0) {
|
|
time = static_cast<unsigned int>(std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
std::chrono::steady_clock::now().time_since_epoch()).count());
|
|
}
|
|
|
|
last_move_state.func = static_cast<uint8_t>(func);
|
|
last_move_state.arg = static_cast<uint8_t>(arg);
|
|
last_move_state.rot = bRot;
|
|
last_move_state.x = x;
|
|
last_move_state.y = y;
|
|
last_move_state.time = time;
|
|
last_move_state.valid = true;
|
|
|
|
auto wire_bytes = wire::character_move(last_move_state.func, last_move_state.arg, last_move_state.rot,
|
|
last_move_state.x, last_move_state.y, last_move_state.time);
|
|
(void)wire_bytes;
|
|
PythonNetworkStream::Instance().SendCharacterMovePacket(last_move_state.func, last_move_state.arg, last_move_state.rot,
|
|
last_move_state.x, last_move_state.y, last_move_state.time);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* send_character_position_packet(PyObject*, PyObject* args) {
|
|
int pos = 0;
|
|
if (PyArg_ParseTuple(args, "i", &pos)) {
|
|
last_move_state.arg = static_cast<uint8_t>(pos);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
ItemUsePacketCallback s_itemUseCallback = nullptr;
|
|
ItemMovePacketCallback s_itemMoveCallback = nullptr;
|
|
|
|
PyObject* shop_end(PyObject*,PyObject*) { PythonNetworkStream::Instance().SendShopPacket(0);Py_RETURN_NONE; }
|
|
PyObject* offline_shop_end(PyObject*,PyObject*) { PythonNetworkStream::Instance().SendOfflineShopPacket(false);Py_RETURN_NONE; }
|
|
PyObject* offline_shop_remove(PyObject*,PyObject* args) { int position=0;if(!PyArg_ParseTuple(args,"i",&position))return nullptr;PythonNetworkStream::Instance().SendOfflineShopManagement(5,static_cast<uint8_t>(position));Py_RETURN_NONE; }
|
|
PyObject* offline_shop_destroy(PyObject*,PyObject*) { PythonNetworkStream::Instance().SendOfflineShopManagement(6);Py_RETURN_NONE; }
|
|
PyObject* offline_shop_logs(PyObject*,PyObject*) { PythonNetworkStream::Instance().SendOfflineShopManagement(11);Py_RETURN_NONE; }
|
|
PyObject* offline_shop_slot(PyObject*,PyObject* args) { int position=0;if(!PyArg_ParseTuple(args,"i",&position))return nullptr;PythonNetworkStream::Instance().SendOfflineShopManagement(13,static_cast<uint8_t>(position));Py_RETURN_NONE; }
|
|
PyObject* offline_shop_get_items(PyObject*,PyObject*) { PythonNetworkStream::Instance().SendOfflineShopManagement(14);Py_RETURN_NONE; }
|
|
PyObject* offline_shop_add_time(PyObject*,PyObject*) { PythonNetworkStream::Instance().SendOfflineShopManagement(15);Py_RETURN_NONE; }
|
|
PyObject* offline_shop_open_vid(PyObject*,PyObject* args) { int owner=0;if(!PyArg_ParseTuple(args,"i",&owner))return nullptr;PythonNetworkStream::Instance().SendOfflineShopManagement(16,0,static_cast<uint32_t>(owner));Py_RETURN_NONE; }
|
|
PyObject* offline_shop_buy(PyObject*,PyObject* args) { int owner=0,position=0;if(!PyArg_ParseTuple(args,"ii",&owner,&position))return nullptr;PythonNetworkStream::Instance().SendOfflineShopPacket(true,static_cast<uint32_t>(owner),static_cast<uint8_t>(position));Py_RETURN_NONE; }
|
|
PyObject* shop_buy(PyObject*,PyObject* args) { int slot=0;if(!PyArg_ParseTuple(args,"i",&slot))return nullptr;PythonNetworkStream::Instance().SendShopPacket(1,0,static_cast<uint8_t>(slot));Py_RETURN_NONE; }
|
|
PyObject* shop_sell(PyObject*,PyObject* args) { int slot=0;if(!PyArg_ParseTuple(args,"i",&slot))return nullptr;PythonNetworkStream::Instance().SendShopPacket(2,0,static_cast<uint8_t>(slot));Py_RETURN_NONE; }
|
|
PyObject* shop_sell_new(PyObject*,PyObject* args) { int window=0,slot=0,count=0;if(!PyArg_ParseTuple(args,"iii",&window,&slot,&count))return nullptr;PythonNetworkStream::Instance().SendShopPacket(3,static_cast<uint8_t>(window),static_cast<uint8_t>(slot),static_cast<uint32_t>(count));Py_RETURN_NONE; }
|
|
PyObject* send_item_use_packet(PyObject*, PyObject* args) {
|
|
int window = 1;
|
|
int slot = 0;
|
|
if (!PyArg_ParseTuple(args, "ii", &window, &slot)) {
|
|
PyErr_Clear();
|
|
if (!PyArg_ParseTuple(args, "i", &slot)) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
}
|
|
PythonNetworkStream::Instance().SendItemUsePacket(static_cast<uint8_t>(window), static_cast<uint16_t>(slot));
|
|
if (s_itemUseCallback) {
|
|
s_itemUseCallback(window, slot);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PyObject* send_item_move_packet(PyObject*, PyObject* args) {
|
|
int srcWindow = 1, srcSlot = 0, dstWindow = 1, dstSlot = 0, count = 1;
|
|
if (!PyArg_ParseTuple(args, "iiiii", &srcWindow, &srcSlot, &dstWindow, &dstSlot, &count)) {
|
|
PyErr_Clear();
|
|
if (!PyArg_ParseTuple(args, "iii", &srcSlot, &dstSlot, &count)) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
}
|
|
PythonNetworkStream::Instance().SendItemMovePacket(static_cast<uint8_t>(srcWindow), static_cast<uint16_t>(srcSlot),
|
|
static_cast<uint8_t>(dstWindow), static_cast<uint16_t>(dstSlot),
|
|
static_cast<uint32_t>(count));
|
|
if (s_itemMoveCallback) {
|
|
s_itemMoveCallback(srcWindow, srcSlot, dstWindow, dstSlot, count);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void update_player_guild(uint32_t id,const std::string& name) {
|
|
if(has_mock_characters) {
|
|
for(auto& c:mock_characters)if(c.name==GetMainCharacterName()) {c.guild_id=id;c.guild_name=name;}
|
|
}
|
|
client.update_player_guild(GetMainCharacterName(),id,name);
|
|
}
|
|
|
|
const CharacterMoveState& get_last_character_move() {
|
|
return last_move_state;
|
|
}
|
|
|
|
void set_character_move(const CharacterMoveState& move) {
|
|
last_move_state = move;
|
|
}
|
|
|
|
void SetItemUsePacketCallback(ItemUsePacketCallback cb) {
|
|
s_itemUseCallback = cb;
|
|
}
|
|
|
|
void SetItemMovePacketCallback(ItemMovePacketCallback cb) {
|
|
s_itemMoveCallback = cb;
|
|
}
|
|
|
|
// AVA2 PythonNetworkStreamModule.cpp: server-command / chat-filter / emoticon wrappers.
|
|
std::vector<std::string> preserved_commands; // g_kList_strCommand
|
|
PyObject* server_command_parser=nullptr;
|
|
static PyObject* net_preserve_server_command(PyObject*, PyObject* args) { char* line;if(!PyTuple_GetString(args,0,&line)) return Py_BuildException();preserved_commands.push_back(line);return Py_BuildNone(); }
|
|
static PyObject* net_get_preserved_server_command(PyObject*, PyObject*) {
|
|
if(preserved_commands.empty()) return Py_BuildValue("s","");
|
|
std::string command=preserved_commands.front();preserved_commands.erase(preserved_commands.begin());
|
|
return Py_BuildValue("s",command.c_str());
|
|
}
|
|
static PyObject* net_set_server_command_parser_window(PyObject*, PyObject* args) {
|
|
PyObject* window;if(!PyTuple_GetObject(args,0,&window)) return Py_BuildException();
|
|
replace(server_command_parser,window);PythonNetworkStream::Instance().SetServerCommandParserWindow(server_command_parser);return Py_BuildNone();
|
|
}
|
|
// netLoadInsultList / netIsChatInsultIn / netIsInsultIn (AVA2 PythonNetworkStreamModule.cpp).
|
|
bool LoadInsultList(const std::string& path) {
|
|
std::string text;
|
|
try { text=ReadPackedText(path); } catch(const std::exception&) { return false; }
|
|
return PythonNetworkStream::Instance().LoadInsultList(text);
|
|
}
|
|
static PyObject* net_load_insult_list(PyObject*, PyObject* args) { char* path;if(!PyTuple_GetString(args,0,&path)) return Py_BuildException();return Py_BuildValue("i",LoadInsultList(path)); }
|
|
static PyObject* net_is_chat_insult_in(PyObject*, PyObject* args) { char* msg;if(!PyTuple_GetString(args,0,&msg)) return Py_BuildException();return Py_BuildValue("i",PythonNetworkStream::Instance().IsChatInsultIn(msg)); }
|
|
static PyObject* net_is_insult_in(PyObject*, PyObject* args) { char* msg;if(!PyTuple_GetString(args,0,&msg)) return Py_BuildException();return Py_BuildValue("i",PythonNetworkStream::Instance().IsInsultIn(msg)); }
|
|
static PyObject* net_enable_chat_insult_filter(PyObject*, PyObject* args) { int enable;if(!PyTuple_GetInteger(args,0,&enable)) return Py_BuildException();PythonNetworkStream::Instance().EnableChatInsultFilter(enable!=0);return Py_BuildNone(); }
|
|
static PyObject* net_set_empire_language_mode(PyObject*, PyObject* args) { int mode;if(!PyTuple_GetInteger(args,0,&mode)) return Py_BuildException();PythonNetworkStream::Instance().SetEmpireLanguageMode(mode!=0);return Py_BuildNone(); }
|
|
static PyObject* net_register_emoticon_string(PyObject*, PyObject* args) { char* text;if(!PyTuple_GetString(args,0,&text)) return Py_BuildException();PythonNetworkStream::Instance().RegisterEmoticonString(text);return Py_BuildNone(); }
|
|
static PyObject* net_send_emoticon(PyObject*, PyObject* args) { int emoticon;if(!PyTuple_GetInteger(args,0,&emoticon)) return Py_BuildException();PythonNetworkStream::Instance().SendEmoticon(unsigned(emoticon));return Py_BuildNone(); }
|
|
|
|
static PyObject* net_send_refine_packet(PyObject*, PyObject* args) {
|
|
int targetPos = 0, type = 0, specialStorage = 0, indexSelect = -1;
|
|
if (PyArg_ParseTuple(args, "iiii", &targetPos, &type, &specialStorage, &indexSelect)) {
|
|
PythonNetworkStream::Instance().SendRefinePacket((uint8_t)targetPos, (uint8_t)type, (uint8_t)specialStorage, indexSelect);
|
|
} else {
|
|
PyErr_Clear();
|
|
if (PyArg_ParseTuple(args, "iii", &targetPos, &type, &specialStorage)) {
|
|
PythonNetworkStream::Instance().SendRefinePacket((uint8_t)targetPos, (uint8_t)type, (uint8_t)specialStorage, -1);
|
|
} else {
|
|
PyErr_Clear();
|
|
if (PyArg_ParseTuple(args, "ii", &targetPos, &type)) {
|
|
PythonNetworkStream::Instance().SendRefinePacket((uint8_t)targetPos, (uint8_t)type, 0, -1);
|
|
}
|
|
}
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject* net_send_item_use_to_item_packet(PyObject*, PyObject* args) {
|
|
int srcCell = 0, dstCell = 0;
|
|
if (PyArg_ParseTuple(args, "ii", &srcCell, &dstCell)) {
|
|
PythonNetworkStream::Instance().SendItemUseToItemPacket((uint16_t)srcCell, (uint16_t)dstCell);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject* net_send_give_item_packet(PyObject*, PyObject* args) {
|
|
int targetVID = 0, window = 0, cell = 0, count = 0;
|
|
if (PyArg_ParseTuple(args, "iiii", &targetVID, &window, &cell, &count)) {
|
|
PythonNetworkStream::Instance().SendGiveItemPacket((uint32_t)targetVID, (uint8_t)window, (uint16_t)cell, (uint32_t)count);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject* net_send_script_answer_packet(PyObject*, PyObject* args) {
|
|
int answer = 0;
|
|
if (PyArg_ParseTuple(args, "i", &answer)) {
|
|
PythonNetworkStream::Instance().SendScriptAnswerPacket(answer);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject* net_send_script_button_packet(PyObject*, PyObject* args) {
|
|
int button = 0;
|
|
if (PyArg_ParseTuple(args, "i", &button)) {
|
|
PythonNetworkStream::Instance().SendScriptButtonPacket(button);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static std::string s_netServerInfo = "";
|
|
|
|
static PyObject* net_GetBettingGuildWarValue(PyObject*, PyObject* poArgs) {
|
|
char* szName = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szName))
|
|
return Py_BuildException();
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
static PyObject* net_SetServerInfo(PyObject*, PyObject* poArgs) {
|
|
char* szFileName = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
|
return Py_BuildException();
|
|
s_netServerInfo = szFileName ? szFileName : "";
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_GetServerInfo(PyObject*, PyObject*) {
|
|
return Py_BuildValue("s", s_netServerInfo.c_str());
|
|
}
|
|
|
|
static PyObject* net_IsTest(PyObject*, PyObject*) {
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
static PyObject* net_SetMarkServer(PyObject*, PyObject* poArgs) {
|
|
char* szAddr = nullptr;
|
|
int port = 0;
|
|
if (!PyTuple_GetString(poArgs, 0, &szAddr) || !PyTuple_GetInteger(poArgs, 1, &port))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_UploadMark(PyObject*, PyObject* poArgs) {
|
|
char* szFileName = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
|
return Py_BuildException();
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
static PyObject* net_UploadSymbol(PyObject*, PyObject* poArgs) {
|
|
char* szFileName = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
|
return Py_BuildException();
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
static PyObject* net_ToggleGameDebugInfo(PyObject*, PyObject*) {
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SetTCPRecvBufferSize(PyObject*, PyObject* poArgs) {
|
|
int bufSize = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &bufSize))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SetTCPSendBufferSize(PyObject*, PyObject* poArgs) {
|
|
int bufSize = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &bufSize))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SetUDPRecvBufferSize(PyObject*, PyObject* poArgs) {
|
|
int bufSize = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &bufSize))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_LogOutGame(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendChatPacket("/logout");
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_ExitGame(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendChatPacket("/phase_select");
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_ExitApplication(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendChatPacket("/quit");
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_ConnectTCP(PyObject*, PyObject* poArgs) {
|
|
char* szAddr = nullptr;
|
|
int port = 0;
|
|
if (!PyTuple_GetString(poArgs, 0, &szAddr) || !PyTuple_GetInteger(poArgs, 1, &port))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_ConnectUDP(PyObject*, PyObject* poArgs) {
|
|
char* c_szIP = nullptr;
|
|
int iPort = 0;
|
|
if (!PyTuple_GetString(poArgs, 0, &c_szIP) || !PyTuple_GetInteger(poArgs, 1, &iPort))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendLoginPacket(PyObject*, PyObject* poArgs) {
|
|
char* szName = nullptr;
|
|
char* szPwd = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szName) || !PyTuple_GetString(poArgs, 1, &szPwd))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendChinaMatrixCardPacket(PyObject*, PyObject* poArgs) {
|
|
char* szMatrixCardString = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szMatrixCardString))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendRunupMatrixCardPacket(PyObject*, PyObject* poArgs) {
|
|
char* szMatrixCardString = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szMatrixCardString))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendNEWCIBNPasspodAnswerPacket(PyObject*, PyObject* poArgs) {
|
|
char* szMatrixCardString = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szMatrixCardString))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendSelectEmpirePacket(PyObject*, PyObject* poArgs) {
|
|
int iEmpireIndex = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iEmpireIndex))
|
|
return Py_BuildException();
|
|
if(has_mock_characters) { set_mock_empire(std::uint8_t(iEmpireIndex));return Py_BuildNone(); }
|
|
// SendSelectEmpirePacket: the empire id is kept locally only after a successful Send.
|
|
try { client.send_select_packet(wire::select_empire(std::uint8_t(iEmpireIndex)));client.set_empire(std::uint8_t(iEmpireIndex)); }
|
|
catch(const std::exception& e) { SDL_Log("SendSelectEmpirePacket - Error: %s",e.what()); }
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendChangeNamePacket(PyObject*, PyObject* poArgs) {
|
|
int iIndex = 0;
|
|
char* szName = nullptr;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iIndex) || !PyTuple_GetString(poArgs, 1, &szName))
|
|
return Py_BuildException();
|
|
if(!has_mock_characters) send_select_packet("Failed to SendChangeNamePacket",wire::change_name(std::uint8_t(iIndex),szName));
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SetOfflinePhase(PyObject*, PyObject*) {
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendMobileMessagePacket(PyObject*, PyObject* poArgs) {
|
|
char* szName = nullptr;
|
|
char* szLine = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szName) || !PyTuple_GetString(poArgs, 1, &szLine))
|
|
return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendMobileMessagePacket(szName,szLine);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SetSkillGroupFake(PyObject*, PyObject* poArgs) {
|
|
int iIndex = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendGuildSymbol(PyObject*, PyObject* poArgs) {
|
|
char* szIP = nullptr;
|
|
int iPort = 0;
|
|
char* szFileName = nullptr;
|
|
int iGuildID = 0;
|
|
if (!PyTuple_GetString(poArgs, 0, &szIP) ||
|
|
!PyTuple_GetInteger(poArgs, 1, &iPort) ||
|
|
!PyTuple_GetString(poArgs, 2, &szFileName) ||
|
|
!PyTuple_GetInteger(poArgs, 3, &iGuildID))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_DisconnectUploader(PyObject*, PyObject*) {
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_RecvGuildSymbol(PyObject*, PyObject* poArgs) {
|
|
char* szIP = nullptr;
|
|
int iPort = 0;
|
|
int iGuildID = 0;
|
|
if (!PyTuple_GetString(poArgs, 0, &szIP) ||
|
|
!PyTuple_GetInteger(poArgs, 1, &iPort) ||
|
|
!PyTuple_GetInteger(poArgs, 2, &iGuildID))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendAddOfflineShopItem(PyObject*, PyObject* poArgs) {
|
|
int bDisplayPos = 0, bPos = 0, bWindowType = 0;
|
|
long long iPrice = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &bDisplayPos) ||
|
|
!PyTuple_GetInteger(poArgs, 1, &bPos) ||
|
|
!PyTuple_GetLongLong(poArgs, 2, &iPrice) ||
|
|
!PyTuple_GetInteger(poArgs, 3, &bWindowType))
|
|
return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendAddOfflineShopItem(TItemPos{uint8_t(bWindowType), uint16_t(bDisplayPos)}, uint8_t(bPos), iPrice);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendTakeOfflineMoney(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendTakeOfflineMoney();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendOfflineShopChangeTitle(PyObject*, PyObject* poArgs) {
|
|
char* title = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &title))
|
|
return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendOfflineShopChangeTitle(title ? title : "");
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendOfflineShopCheck(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendOfflineShopCheck();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendOfflineShopButton(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendOfflineShopButton();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_RegisterErrorLog(PyObject*, PyObject* poArgs) {
|
|
char* szLog = nullptr;
|
|
if (!PyTuple_GetString(poArgs, 0, &szLog))
|
|
return Py_BuildException();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_Send67AttrPacket(PyObject*, PyObject* poArgs) {
|
|
int iMaterialCount = 0, iSupportCount = 0, iSupportPos = 0, iItemPos = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iMaterialCount) ||
|
|
!PyTuple_GetInteger(poArgs, 1, &iSupportCount) ||
|
|
!PyTuple_GetInteger(poArgs, 2, &iSupportPos) ||
|
|
!PyTuple_GetInteger(poArgs, 3, &iItemPos))
|
|
return Py_BuildException();
|
|
PythonNetworkStream::Instance().Send67AttrPacket(iMaterialCount,iSupportCount,iSupportPos,iItemPos);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_Send67AttrClosePacket(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().Send67AttrClosePacket();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_CalendarOpen(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendCalendarPacket(0);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_CalendarClose(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendCalendarPacket(1);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_CalendarSend(PyObject*, PyObject* poArgs) {
|
|
int day = 0, index_event = 0;
|
|
char* hora_inicio = nullptr;
|
|
char* hora_final = nullptr;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &day) ||
|
|
!PyTuple_GetInteger(poArgs, 1, &index_event) ||
|
|
!PyTuple_GetString(poArgs, 2, &hora_inicio) ||
|
|
!PyTuple_GetString(poArgs, 3, &hora_final))
|
|
return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendCalendarPacket(2,day,index_event,hora_inicio,hora_final);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendMiniGameCatchKingStart(PyObject*, PyObject* poArgs) {
|
|
int ibetNumber = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &ibetNumber))
|
|
return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendCatchKingPacket(0,ibetNumber);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendMiniGameCatchKingDeckCardClick(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendCatchKingPacket(1);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendMiniGameCatchKingFieldCardClick(PyObject*, PyObject* poArgs) {
|
|
int icardNumber = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &icardNumber))
|
|
return Py_BuildException();
|
|
PythonNetworkStream::Instance().SendCatchKingPacket(2,icardNumber);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_SendMiniGameCatchKingReward(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().SendCatchKingPacket(3);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
static PyObject* net_OpenCatchKing(PyObject*, PyObject*) {
|
|
PythonNetworkStream::Instance().OpenCatchKing();
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
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},
|
|
{"GetBettingGuildWarValue", net_GetBettingGuildWarValue, METH_VARARGS, nullptr},
|
|
{"EnableChatInsultFilter", net_enable_chat_insult_filter, METH_VARARGS, nullptr},
|
|
{"SetServerInfo", net_SetServerInfo, METH_VARARGS, nullptr},
|
|
{"GetServerInfo", net_GetServerInfo, METH_VARARGS, nullptr},
|
|
{"PreserveServerCommand", net_preserve_server_command, METH_VARARGS, nullptr},
|
|
{"GetPreservedServerCommand", net_get_preserved_server_command, METH_VARARGS, nullptr},
|
|
{"StartGame", net_start_game, METH_VARARGS, nullptr},
|
|
{"Warp", net_warp, METH_VARARGS, nullptr},
|
|
{"IsTest", net_IsTest, METH_VARARGS, nullptr},
|
|
{"SetMarkServer", net_SetMarkServer, METH_VARARGS, nullptr},
|
|
{"IsChatInsultIn", net_is_chat_insult_in, METH_VARARGS, nullptr},
|
|
{"IsInsultIn", net_is_insult_in, METH_VARARGS, nullptr},
|
|
{"LoadInsultList", net_load_insult_list, METH_VARARGS, nullptr},
|
|
{"UploadMark", net_UploadMark, METH_VARARGS, nullptr},
|
|
{"UploadSymbol", net_UploadSymbol, METH_VARARGS, nullptr},
|
|
{"GetGuildID", netGetGuildID, METH_VARARGS, nullptr},
|
|
{"GetMainActorVID", net_get_main_actor_vid, METH_VARARGS, nullptr},
|
|
{"GetMainActorRace", net_get_main_actor_race, METH_VARARGS, nullptr},
|
|
{"GetMainActorEmpire", net_get_main_actor_empire, METH_VARARGS, nullptr},
|
|
{"GetMainActorSkillGroup", net_get_main_actor_skill_group, METH_VARARGS, nullptr},
|
|
{"SendTargetInfoLoad", netTargetInfoLoad, METH_VARARGS, nullptr},
|
|
{"GetFieldMusicFileName", net_get_field_music_name, METH_VARARGS, nullptr},
|
|
{"GetFieldMusicVolume", net_get_field_music_volume, METH_VARARGS, nullptr},
|
|
{"ToggleGameDebugInfo", net_ToggleGameDebugInfo, METH_VARARGS, nullptr},
|
|
{"SetServerCommandParserWindow", net_set_server_command_parser_window, METH_VARARGS, nullptr},
|
|
{"SetTCPRecvBufferSize", net_SetTCPRecvBufferSize, METH_VARARGS, nullptr},
|
|
{"SetTCPSendBufferSize", net_SetTCPSendBufferSize, METH_VARARGS, nullptr},
|
|
{"SetUDPRecvBufferSize", net_SetUDPRecvBufferSize, METH_VARARGS, nullptr},
|
|
{"DirectEnter", direct_enter, METH_VARARGS, nullptr},
|
|
{"LogOutGame", net_LogOutGame, METH_VARARGS, nullptr},
|
|
{"ExitGame", net_ExitGame, METH_VARARGS, nullptr},
|
|
{"ExitApplication", net_ExitApplication, METH_VARARGS, nullptr},
|
|
{"ConnectTCP", net_ConnectTCP, METH_VARARGS, nullptr},
|
|
{"ConnectUDP", net_ConnectUDP, METH_VARARGS, nullptr},
|
|
{"SendLoginPacket", net_SendLoginPacket, METH_VARARGS, nullptr},
|
|
{"SendChinaMatrixCardPacket", net_SendChinaMatrixCardPacket, METH_VARARGS, nullptr},
|
|
{"SendRunupMatrixCardPacket", net_SendRunupMatrixCardPacket, METH_VARARGS, nullptr},
|
|
{"SendNEWCIBNPasspodAnswerPacket", net_SendNEWCIBNPasspodAnswerPacket, METH_VARARGS, nullptr},
|
|
{"SendSelectEmpirePacket", net_SendSelectEmpirePacket, METH_VARARGS, nullptr},
|
|
{"SendChangeNamePacket", net_SendChangeNamePacket, METH_VARARGS, nullptr},
|
|
{"SendCreateCharacterPacket", send_create_character, METH_VARARGS, nullptr},
|
|
{"SendDestroyCharacterPacket", send_destroy_character, METH_VARARGS, nullptr},
|
|
{"SendEnterGamePacket", net_send_enter_game, METH_VARARGS, nullptr},
|
|
{"SendItemUsePacket", send_item_use_packet, METH_VARARGS, nullptr},
|
|
{"SendItemUseToItemPacket", net_send_item_use_to_item_packet, METH_VARARGS, nullptr},
|
|
{"SendItemDropPacket", net_send_item_drop, METH_VARARGS, nullptr},
|
|
{"SendItemDropPacketNew", net_send_item_drop_new, METH_VARARGS, nullptr},
|
|
{"SendElkDropPacket", net_send_gold_drop<false>, METH_VARARGS, nullptr},
|
|
{"SendGoldDropPacketNew", net_send_gold_drop<true>, METH_VARARGS, nullptr},
|
|
{"SendItemMovePacket", send_item_move_packet, METH_VARARGS, nullptr},
|
|
{"SendItemPickUpPacket", net_send_item_pickup, METH_VARARGS, nullptr},
|
|
{"SendGiveItemPacket", net_send_give_item_packet, METH_VARARGS, nullptr},
|
|
{"SetOfflinePhase", net_SetOfflinePhase, METH_VARARGS, nullptr},
|
|
{"IsConnect", is_connected, METH_VARARGS, nullptr},
|
|
{"SendChatPacket", net_send_chat, METH_VARARGS, nullptr},
|
|
{"SendEmoticon", net_send_emoticon, METH_VARARGS, nullptr},
|
|
{"SendWhisperPacket", net_send_whisper, METH_VARARGS, nullptr},
|
|
{"SendMobileMessagePacket", net_SendMobileMessagePacket, METH_VARARGS, nullptr},
|
|
{"SendCharacterPositionPacket", send_character_position_packet, METH_VARARGS, nullptr},
|
|
{"SendCharacterMovePacket", send_character_move_packet, METH_VARARGS, nullptr},
|
|
{"SendCharacterStatePacket", send_character_move_packet, METH_VARARGS, nullptr},
|
|
{"SendShopEndPacket", shop_end, METH_VARARGS, nullptr},
|
|
{"SendShopBuyPacket", shop_buy, METH_VARARGS, nullptr},
|
|
{"SendShopSellPacket", shop_sell, METH_VARARGS, nullptr},
|
|
{"SendShopSellPacketNew", shop_sell_new, METH_VARARGS, nullptr},
|
|
{"SendExchangeStartPacket", netSendExchangeStartPacket, METH_VARARGS, nullptr},
|
|
{"SendExchangeItemAddPacket", netSendExchangeItemAddPacket, METH_VARARGS, nullptr},
|
|
{"SendExchangeItemDelPacket", netSendExchangeItemDelPacket, METH_VARARGS, nullptr},
|
|
{"SendExchangeElkAddPacket", netSendExchangeElkAddPacket, METH_VARARGS, nullptr},
|
|
{"SendExchangeAcceptPacket", netSendExchangeAcceptPacket, METH_VARARGS, nullptr},
|
|
{"SendExchangeExitPacket", netSendExchangeExitPacket, METH_VARARGS, nullptr},
|
|
{"SendOnClickPacket", net_send_onclick, METH_VARARGS, nullptr},
|
|
{"RegisterEmoticonString", net_register_emoticon_string, METH_VARARGS, nullptr},
|
|
{"SendMessengerAddByVIDPacket", netSendMessengerAddByVIDPacket, METH_VARARGS, nullptr},
|
|
{"SendMessengerAddByNamePacket", netSendMessengerAddByNamePacket, METH_VARARGS, nullptr},
|
|
{"SendMessengerRemovePacket", netSendMessengerRemovePacket, METH_VARARGS, nullptr},
|
|
{"SendPartyInvitePacket", netSendPartyInvitePacket, METH_VARARGS, nullptr},
|
|
{"SendPartyInviteAnswerPacket", netSendPartyInviteAnswerPacket, METH_VARARGS, nullptr},
|
|
{"SendPartyExitPacket", netSendPartyExitPacket, METH_VARARGS, nullptr},
|
|
{"SendPartyRemovePacket", netSendPartyRemovePacketPID, METH_VARARGS, nullptr},
|
|
{"SendPartyRemovePacketPID", netSendPartyRemovePacketPID, METH_VARARGS, nullptr},
|
|
{"SendPartyRemovePacketVID", netSendPartyRemovePacketVID, METH_VARARGS, nullptr},
|
|
{"SendPartySetStatePacket", netSendPartySetStatePacket, METH_VARARGS, nullptr},
|
|
{"SendPartyUseSkillPacket", netSendPartyUseSkillPacket, METH_VARARGS, nullptr},
|
|
{"SendPartyParameterPacket", netSendPartyParameterPacket, METH_VARARGS, nullptr},
|
|
{"SendSafeboxSaveMoneyPacket", netSendSafeboxSaveMoneyPacket, METH_VARARGS, nullptr},
|
|
{"SendSafeboxWithdrawMoneyPacket", netSendSafeboxWithdrawMoneyPacket, METH_VARARGS, nullptr},
|
|
{"SendSafeboxCheckinPacket", netSendSafeboxCheckinPacket, METH_VARARGS, nullptr},
|
|
{"SendSafeboxCheckoutPacket", netSendSafeboxCheckoutPacket, METH_VARARGS, nullptr},
|
|
{"SendSafeboxItemMovePacket", netSendSafeboxItemMovePacket, METH_VARARGS, nullptr},
|
|
{"SendMallCheckoutPacket", netSendMallCheckoutPacket, METH_VARARGS, nullptr},
|
|
{"SendAnswerMakeGuildPacket", netSendAnswerMakeGuildPacket, METH_VARARGS, nullptr},
|
|
{"SendQuestInputStringPacket", netSendQuestInputStringPacket, METH_VARARGS, nullptr},
|
|
{"SendQuestInputLongStringPacket", netSendQuestInputLongStringPacket, METH_VARARGS, nullptr},
|
|
{"SendQuestConfirmPacket", netSendQuestConfirmPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildAddMemberPacket", netSendGuildAddMemberPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildRemoveMemberPacket", netSendGuildRemoveMemberPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildChangeGradeNamePacket", netSendGuildChangeGradeNamePacket, METH_VARARGS, nullptr},
|
|
{"SendGuildChangeGradeAuthorityPacket", netSendGuildChangeGradeAuthorityPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildOfferPacket", netSendGuildOfferPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildPostCommentPacket", netSnedGuildPostCommentPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildDeleteCommentPacket", netSnedGuildDeleteCommentPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildRefreshCommentsPacket", netSendGuildRefreshCommentsPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildChangeMemberGradePacket", netSendGuildChangeMemberGradePacket, METH_VARARGS, nullptr},
|
|
{"SendGuildUseSkillPacket", netSendGuildUseSkillPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildChangeMemberGeneralPacket", netSendGuildChangeMemberGeneralPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildInviteAnswerPacket", netSendGuildInviteAnswerPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildChargeGSPPacket", netSendGuildChargeGSPPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildDepositMoneyPacket", netSendGuildDepositMoneyPacket, METH_VARARGS, nullptr},
|
|
{"SendGuildWithdrawMoneyPacket", netSendGuildWithdrawMoneyPacket, METH_VARARGS, nullptr},
|
|
{"SendRequestRefineInfoPacket", netSendRequestRefineInfoPacket, METH_VARARGS, nullptr},
|
|
{"SendRefinePacket", net_send_refine_packet, METH_VARARGS, nullptr},
|
|
{"SendScriptAnswerPacket", net_send_script_answer_packet, METH_VARARGS, nullptr},
|
|
{"SendScriptButtonPacket", net_send_script_button_packet, METH_VARARGS, nullptr},
|
|
{"SendSelectItemPacket", netSendSelectItemPacket, METH_VARARGS, nullptr},
|
|
{"SetEmpireLanguageMode", net_set_empire_language_mode, METH_VARARGS, nullptr},
|
|
{"SetSkillGroupFake", net_SetSkillGroupFake, METH_VARARGS, nullptr},
|
|
{"SendGuildSymbol", net_SendGuildSymbol, METH_VARARGS, nullptr},
|
|
{"DisconnectUploader", net_DisconnectUploader, METH_VARARGS, nullptr},
|
|
{"RecvGuildSymbol", net_RecvGuildSymbol, METH_VARARGS, nullptr},
|
|
{"SendOfflineShopEndPacket", offline_shop_end, METH_VARARGS, nullptr},
|
|
{"SendOfflineShopBuyPacket", offline_shop_buy, METH_VARARGS, nullptr},
|
|
{"SendAddOfflineShopItem", net_SendAddOfflineShopItem, METH_VARARGS, nullptr},
|
|
{"SendRemoveOfflineShopItem", offline_shop_remove, METH_VARARGS, nullptr},
|
|
{"SendDestroyOfflineShop", offline_shop_destroy, METH_VARARGS, nullptr},
|
|
{"SendTakeOfflineMoney", net_SendTakeOfflineMoney, METH_VARARGS, nullptr},
|
|
{"SendOfflineShopChangeTitle", net_SendOfflineShopChangeTitle, METH_VARARGS, nullptr},
|
|
{"SendOfflineShopCheck", net_SendOfflineShopCheck, METH_VARARGS, nullptr},
|
|
{"SendOfflineShopButton", net_SendOfflineShopButton, METH_VARARGS, nullptr},
|
|
{"SendOfflineShopRemoveLogs", offline_shop_logs, METH_VARARGS, nullptr},
|
|
{"SendOpenShopSlot", offline_shop_slot, METH_VARARGS, nullptr},
|
|
{"SendGetBackItems", offline_shop_get_items, METH_VARARGS, nullptr},
|
|
{"SendAddTime", offline_shop_add_time, METH_VARARGS, nullptr},
|
|
{"SendOpenWithVID", offline_shop_open_vid, METH_VARARGS, nullptr},
|
|
{"RegisterErrorLog", net_RegisterErrorLog, METH_VARARGS, nullptr},
|
|
{"ElementsSpellClose", net_ElementsSpellClose, METH_VARARGS, nullptr},
|
|
{"ElementsSpellAdd", net_ElementsSpellAdd, METH_VARARGS, nullptr},
|
|
{"ElementsSpellChange", net_ElementsSpellChange, METH_VARARGS, nullptr},
|
|
{"Send67AttrPacket", net_Send67AttrPacket, METH_VARARGS, nullptr},
|
|
{"Send67AttrClosePacket", net_Send67AttrClosePacket, METH_VARARGS, nullptr},
|
|
{"CalendarOpen", net_CalendarOpen, METH_VARARGS, nullptr},
|
|
{"CalendarClose", net_CalendarClose, METH_VARARGS, nullptr},
|
|
{"CalendarSend", net_CalendarSend, METH_VARARGS, nullptr},
|
|
{"SendPrivateShopSearchInfo", netSendPrivateShopSearchInfo, METH_VARARGS, nullptr},
|
|
{"SendMiniGameCatchKingStart", net_SendMiniGameCatchKingStart, METH_VARARGS, nullptr},
|
|
{"SendMiniGameCatchKingDeckCardClick", net_SendMiniGameCatchKingDeckCardClick, METH_VARARGS, nullptr},
|
|
{"SendMiniGameCatchKingFieldCardClick", net_SendMiniGameCatchKingFieldCardClick, METH_VARARGS, nullptr},
|
|
{"SendMiniGameCatchKingReward", net_SendMiniGameCatchKingReward, METH_VARARGS, nullptr},
|
|
{"OpenCatchKing", net_OpenCatchKing, METH_VARARGS, nullptr},
|
|
{"SendCombatZoneRequestActionPacket", net_SendCombatZoneRequestActionPacket, METH_VARARGS, nullptr},
|
|
{"IsRunning", net_CombatZone_IsRunning, METH_VARARGS, nullptr},
|
|
{"GetRankings", net_CombatZone_GetRankings, METH_VARARGS, nullptr},
|
|
{"GetDay", net_CombatZone_GetDay, METH_VARARGS, nullptr},
|
|
{"GetDayActivate", net_CombatZone_GetDayActivate, METH_VARARGS, nullptr},
|
|
{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);
|
|
|
|
// Combat Zone
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_MAX_ROWS_RANKING", 11);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_EMPTY_DATA", 999);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_ACTION_OPEN_RANKING", 1);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_ACTION_CHANGE_PAGE_RANKING", 2);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_ACTION_PARTICIPATE", 3);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_ACTION_LEAVE", 4);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_ACTION_REQUEST_POTION", 5);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_TYPE_RANKING_WEEKLY", 1);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_TYPE_RANKING_ALL", 2);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_ICON_SLOT", 27125);
|
|
PyModule_AddIntConstant(module, "COMBAT_ZONE_ICON_SLOT_COUNT", 3);
|
|
}
|
|
|
|
void register_python_net() {
|
|
if(PyImport_AppendInittab("net", initnet) != 0) throw std::runtime_error("net module registration failed");
|
|
}
|
|
|
|
void reset_python_net() {
|
|
client.cancel();
|
|
PythonNetworkStream::Instance().SetHandler(nullptr);
|
|
for(int i=0;i<7;++i) PythonNetworkStream::Instance().SetPhaseWindow(i,nullptr);
|
|
PythonNetworkStream::Instance().ResetConnection();
|
|
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();
|
|
mock_characters.fill(Character{});
|
|
has_mock_characters = false;
|
|
mock_empire = 0;
|
|
has_mock_empire = false;
|
|
}
|
|
|
|
void set_mock_character(int slot, const Character& chr) {
|
|
if(slot >= 0 && slot < 5) {
|
|
mock_characters[slot] = chr;
|
|
has_mock_characters = true;
|
|
}
|
|
}
|
|
|
|
void set_mock_empire(std::uint8_t empire) {
|
|
mock_empire = empire;
|
|
has_mock_empire = true;
|
|
}
|
|
|
|
void pump_python_net() {
|
|
client.pump();
|
|
static uint64_t bootstrapClockGeneration=0;
|
|
uint32_t serverMS=0;
|
|
if(client.status()==LoginClient::Status::Loading && client.generation()!=bootstrapClockGeneration &&
|
|
client.session() && client.session()->server_milliseconds(serverMS)) {
|
|
SetServerMSec(serverMS);
|
|
bootstrapClockGeneration=client.generation();
|
|
SDL_Log("Game clock synchronized from login handshake: %u",serverMS);
|
|
}
|
|
auto events = client.take_events();
|
|
for(const auto& event : events) {
|
|
if(event.generation != client.generation()) continue;
|
|
if(event.type==LoginClient::EventType::Handshake) callback(phases[1],"OnHandShake");
|
|
else if(event.type==LoginClient::EventType::RemoteDisconnect) { PythonNetworkStream::Instance().ResetConnection();callback(handler,"SetLoginPhase"); }
|
|
else 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::SelectRefresh) callback(phases[2], "Refresh");
|
|
else if(event.type == LoginClient::EventType::SelectResult) {
|
|
// PHASE_WINDOW_SELECT=2, PHASE_WINDOW_CREATE=3 (PythonNetworkStreamPhaseSelect.cpp).
|
|
const auto& r=event.result;
|
|
switch(r.kind) {
|
|
case SelectResult::Kind::CreateSuccess: callback(phases[3],"OnCreateSuccess");break;
|
|
case SelectResult::Kind::CreateFailure:
|
|
PyCallClassMemberFunc(phases[3],"OnCreateFailure",Py_BuildValue("(i)",r.value));
|
|
PyCallClassMemberFunc(phases[2],"OnCreateFailure",Py_BuildValue("(i)",r.value));break;
|
|
case SelectResult::Kind::DeleteSuccess: PyCallClassMemberFunc(phases[2],"OnDeleteSuccess",Py_BuildValue("(i)",r.value));break;
|
|
case SelectResult::Kind::DeleteFailure: callback(phases[2],"OnDeleteFailure");break;
|
|
case SelectResult::Kind::ChangeName: PyCallClassMemberFunc(phases[2],"OnChangeName",Py_BuildValue("(is)",r.value,r.name.c_str()));break;
|
|
}
|
|
}
|
|
else if(event.type == LoginClient::EventType::DirectEnterReady) callback(handler, "SetLoadingPhase");
|
|
else if(event.type == LoginClient::EventType::Loading) {
|
|
PythonNetworkStream::Instance().SetPhase(PHASE_LOADING);
|
|
// SetSelectPhase under DirectEnter: ENABLE_NEW_LOADING picks SetNewLoadingPhase for a warp.
|
|
callback(handler,client.is_warp()?"SetNewLoadingPhase":"SetLoadingPhase");
|
|
}
|
|
else if(client.is_direct_enter() && event.connection_failure) {
|
|
// OnConnectFailure under DirectEnter: ClosePhase -> handler.SetLoginPhase.
|
|
client.cancel();PythonNetworkStream::Instance().ResetConnection();callback(handler,"SetLoginPhase");
|
|
}
|
|
else {
|
|
auto* target = account_handler ? account_handler : phases[1];
|
|
callback(target, event.connection_failure ? "OnConnectFailure" : "OnLoginFailure", event.connection_failure ? nullptr : event.reason.c_str());
|
|
}
|
|
}
|
|
auto& stream=PythonNetworkStream::Instance();
|
|
stream.PushRecvData(client.take_game_input(stream.RecvBufferSpace()));
|
|
stream.ProcessRecvData();
|
|
std::vector<uint8_t> selectLeftover;
|
|
if(stream.TakeSelectRequest(selectLeftover) && client.status()==LoginClient::Status::Loading) {
|
|
// RecvPhasePacket(PHASE_SELECT): SetSelectPhase. __LeaveGamePhase clears actors and items; the
|
|
// transport resumes select-phase parsing and raises SelectReady (SetSelectCharacterPhase).
|
|
stream.ResetConnection();stream.SetPhase(PHASE_SELECT);
|
|
try { client.return_to_select(selectLeftover); }
|
|
catch(const std::exception& e) { SDL_Log("Select phase failed: %s",e.what());client.cancel();callback(handler,"SetLoginPhase"); }
|
|
return;
|
|
}
|
|
uint32_t warpAddress=0;uint16_t warpPort=0;
|
|
if(stream.TakeWarpRequest(warpAddress,warpPort) && client.status()==LoginClient::Status::Loading) {
|
|
// RecvWarpPacket: __DirectEnterMode_Set(selected slot, true) + Connect. Leaving the game phase
|
|
// (__LeaveGamePhase) and SetLoadingPhase clear actors, items and the player before the new map.
|
|
try { client.warp(warpAddress,warpPort); }
|
|
catch(const std::exception& e) { SDL_Log("Warp failed: %s",e.what());client.cancel();stream.ResetConnection();callback(handler,"SetLoginPhase");return; }
|
|
stream.ResetConnection();
|
|
return;
|
|
}
|
|
if(client.status()==LoginClient::Status::Loading) {
|
|
for(auto& [packet,sequence]:stream.PopSendPacketsWithSequence()) client.send_game_packet(std::move(packet),sequence);
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace ava2
|