Port CInstanceBase::AddDamageEffect/ProcessDamage: damage packets queue per actor and show one digit-effect burst per update, dodge/block show the miss effect. Add CEffectManager::SetEffectTextures and CFlyingManager::CreateIndexedFly for the indexed fly types, and reset the damage target on GC_PHASE loading. Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
1437 lines
67 KiB
C++
1437 lines
67 KiB
C++
// Port of the remaining AVA2 GamePhase() receive handlers from
|
|
// upstream/ava2-client/UserInterface/PythonNetworkStreamPhaseGame.cpp,
|
|
// PythonNetworkStreamPhaseGameItem.cpp, PythonNetworkStreamPhaseGameActor.cpp and
|
|
// PythonNetworkStreamPhaseHandShake.cpp (Locale_inc.h feature set: ELEMENT_TARGET,
|
|
// ENABLE_HIDE_COSTUME_SYSTEM, ENABLE_MULTI_REFINE_WORLDARD, ENABLE_MULTILANGUAGE_SYSTEM,
|
|
// ENABLE_CHANNEL_CHANGE, ENABLE_ANTI_EXP, ENABLE_SASH_SYSTEM, ENABLE_KINGDOMS_WAR,
|
|
// ENABLE_MINI_GAME_CATCH_KING, ENABLE_DEFENSAWESHIP; no LOCALE_SERVICE_GLOBAL, no XTrap).
|
|
// Wire reads, Python callbacks and player/party state are 1:1. Work that needs systems the
|
|
// port does not have yet (minimap/atlas marks, background target effects, fly targets,
|
|
// motion queues, guild symbols, hybrid-crypt packs, anticheat, sash/bank/chest-drop native
|
|
// stores) is consumed and listed in docs/WINDOWS-PARITY.md.
|
|
#include "PythonNetworkStream.h"
|
|
#include "shared/common/PythonUtils.h"
|
|
#include "python_app.h"
|
|
#include "quest_state.h"
|
|
#include "guild_state.h"
|
|
#include "battlepass_state.h"
|
|
#include "drop_item_state.h"
|
|
#include "dungeon_info_state.h"
|
|
#include "switchbot_state.h"
|
|
#include "messenger_state.h"
|
|
#include "cube_renewal_state.h"
|
|
#include "shop_search_state.h"
|
|
#include "offline_shop_state.h"
|
|
#include "python_gameplay_modules.h"
|
|
#include "python_native_modules.h"
|
|
#include "python_minimap.h"
|
|
#include "nonplayer_data.h"
|
|
#include "python_event_manager.h"
|
|
#include "item_sound.h"
|
|
#include "python_sash.h"
|
|
#include "python_manager_bank.h"
|
|
#include "NetworkActorManager.h"
|
|
#include "python_background.h"
|
|
#include <cstring>
|
|
#include <iostream>
|
|
|
|
namespace ava2 {
|
|
namespace {
|
|
|
|
void trace_error(const std::string& text) { std::cerr<<"[AVA2 TraceError] "<<text<<std::endl; }
|
|
|
|
// Bounded copy of a fixed-size char field (Windows hands the raw array to Py_BuildValue "s").
|
|
template<size_t N> std::string text(const char (&field)[N]) { return std::string(field,strnlen(field,N)); }
|
|
|
|
// CActorInstance type checks on the port's m_bType (0 enemy, 1 NPC, 2 stone, 3 warp,
|
|
// 4 door, 5 building, 6 PC).
|
|
bool is_enemy(const SNetworkActorData& d) { return d.m_bType==0; }
|
|
bool is_stone(const SNetworkActorData& d) { return d.m_bType==2; }
|
|
bool is_building(const SNetworkActorData& d) { return d.m_bType==5; }
|
|
bool is_pc(const SNetworkActorData& d) { return d.m_bType==6; }
|
|
bool is_dead(const SNetworkActorData& d) { return d.m_pActorInstance && d.m_pActorInstance->IsDead(); }
|
|
bool is_shop(const SNetworkActorData& d) { return d.m_dwRace>=30000 && d.m_dwRace<=30020; }
|
|
// CInstanceBase::IsWoodenDoor
|
|
bool is_wooden_door(const SNetworkActorData& d) {
|
|
return d.m_bType==4 && (d.m_dwRace==13000 || (d.m_dwRace>=30111 && d.m_dwRace<=30119));
|
|
}
|
|
// CInstanceBase::CanViewTargetHP (+ ENABLE_DEFENSAWESHIP IsHydraNPC)
|
|
bool can_view_target_hp(const SNetworkActorData& d) {
|
|
return is_stone(d) || is_wooden_door(d) || is_enemy(d) || is_pc(d) || d.m_dwRace==6801;
|
|
}
|
|
|
|
}
|
|
|
|
SNetworkActorData* PythonNetworkStream::MainInstance() {
|
|
return m_dwMainActorVID ? NetworkActorManager::Instance().GetActorData(m_dwMainActorVID) : nullptr;
|
|
}
|
|
|
|
void PythonNetworkStream::RefreshTargetBoardByVID(uint32_t vid) {
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RefreshTargetBoardByVID",Py_BuildValue("(i)",vid));
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvChangeSpeedPacket() {
|
|
TPacketGCChangeSpeed p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
return true; // SetWalkSpeed/SetRunSpeed are commented out in Windows.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvMotionPacket() {
|
|
TPacketGCMotion p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
return NetworkActorManager::Instance().GetActorData(p.vid)!=nullptr;
|
|
}
|
|
|
|
// AVA2 RecvItemShop routes data directly to Python, without a parallel native store.
|
|
bool PythonNetworkStream::RecvItemShop() {
|
|
TPacketGCItemShop p;if(!Read(sizeof(p),&p)||p.size<sizeof(p))return false;
|
|
size_t remaining=p.size-sizeof(p);
|
|
auto get=[&](size_t size,void* out) {if(size>remaining||!Read(size,out))return false;remaining-=size;return true;};
|
|
auto* game=m_phaseWindows[5];uint8_t sub;if(!get(1,&sub))return false;
|
|
auto log=[&](const TIShopLogData& r) {
|
|
PyCallClassMemberFunc(game,"ItemShopAppendLog",Py_BuildValue("(sissiiL)",text(r.buyDate).c_str(),r.buyTime,text(r.playerName).c_str(),text(r.ipAdress).c_str(),
|
|
int32_t(r.itemVnum),r.itemCount,static_cast<long long>(r.itemPrice)));
|
|
};
|
|
switch(sub) {
|
|
case ITEMSHOP_DRAGONCOIN: {
|
|
int64_t coin;uint8_t open;if(!get(8,&coin)||!get(1,&open))return false;
|
|
if(open) {TIShopLogData r;if(!get(sizeof(r),&r))return false;log(r);}
|
|
PyCallClassMemberFunc(game,"ItemShopSetDragonCoin",Py_BuildValue("(L)",static_cast<long long>(coin)));break;
|
|
}
|
|
case ITEMSHOP_LOG: {
|
|
int32_t count;if(!get(4,&count))return false;
|
|
PyCallClassMemberFunc(game,"ItemShopHideLoading",Py_BuildValue("()"));
|
|
PyCallClassMemberFunc(game,"ItemShopLogClear",Py_BuildValue("()"));
|
|
if(count<0 || size_t(count)>remaining/sizeof(TIShopLogData))return false;
|
|
// Original receives the complete array before invoking its first append callback.
|
|
std::vector<TIShopLogData> logs(size_t(count),TIShopLogData{});
|
|
if(count && !get(sizeof(TIShopLogData)*size_t(count),logs.data()))return false;
|
|
for(const auto& r:logs)log(r);
|
|
PyCallClassMemberFunc(game,"ItemShopPurchasesWindow",Py_BuildValue("()"));break;
|
|
}
|
|
case ITEMSHOP_UPDATE_ITEM: {
|
|
TIShopData r;if(!get(sizeof(r),&r))return false;
|
|
PyCallClassMemberFunc(game,"ItemShopUpdateItem",Py_BuildValue("(iiLiiiiLi)",int32_t(r.id),int32_t(r.itemVnum),static_cast<long long>(r.itemPrice),int(r.discount),r.offerTime,r.topSellingIndex,r.addedTime,static_cast<long long>(r.sellCount),r.maxSellCount));break;
|
|
}
|
|
case ITEMSHOP_LOAD: {
|
|
int64_t coin;int32_t updateTime;if(!get(8,&coin)||!get(4,&updateTime))return false;
|
|
PyCallClassMemberFunc(game,"ItemShopSetDragonCoin",Py_BuildValue("(L)",static_cast<long long>(coin)));
|
|
PyCallClassMemberFunc(game,"ItemShopHideLoading",Py_BuildValue("()"));
|
|
PyCallClassMemberFunc(game,"ItemShopClear",Py_BuildValue("(i)",updateTime));
|
|
int32_t count;if(!get(4,&count))return false;
|
|
if(count==9999) {PyCallClassMemberFunc(game,"ItemShopOpenMainPage",Py_BuildValue("()"));return true;}
|
|
if(count<0 || size_t(count)>remaining/2)return false;
|
|
for(int32_t j=0;j<count;++j) {
|
|
uint8_t category,subCount;if(!get(1,&category)||!get(1,&subCount))return false;
|
|
for(unsigned x=0;x<subCount;++x) {
|
|
uint8_t subCategory,itemCount;if(!get(1,&subCategory)||!get(1,&itemCount))return false;
|
|
for(unsigned k=0;k<itemCount;++k) {
|
|
TIShopData r;if(!get(sizeof(r),&r))return false;
|
|
PyCallClassMemberFunc(game,"ItemShopAppendItem",Py_BuildValue("(iiiiLiiiiLi)",int(category),int(subCategory),int32_t(r.id),int32_t(r.itemVnum),
|
|
static_cast<long long>(r.itemPrice),int(r.discount),r.offerTime,r.topSellingIndex,r.addedTime,static_cast<long long>(r.sellCount),r.maxSellCount));
|
|
}
|
|
}
|
|
PyCallClassMemberFunc(game,"ItemShopOpenMainPage",Py_BuildValue("()"));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return true; // Original BUY/RELOAD/LOG_ADD/unknown subheaders leave payload unconsumed.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvEventManager() {
|
|
TPacketGCEventManager p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
uint8_t subIndex;
|
|
if(!Read(1,&subIndex)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
if(subIndex==EVENT_MANAGER_LOAD) {
|
|
uint8_t dayCount;
|
|
if(!Read(1,&dayCount)) return false;
|
|
int32_t serverTime;
|
|
if(!Read(4,&serverTime)) return false;
|
|
PyCallClassMemberFunc(game,"ClearEventManager",Py_BuildValue("()"));
|
|
for(uint8_t j=0;j<dayCount;++j) {
|
|
uint8_t dayIndex,dayEventCount;
|
|
if(!Read(1,&dayIndex) || !Read(1,&dayEventCount)) return false;
|
|
if(dayEventCount>0) {
|
|
std::vector<TEventManagerData> events(dayEventCount);
|
|
if(!Read(dayEventCount*sizeof(TEventManagerData),events.data())) return false;
|
|
for(const auto& e:events)
|
|
PyCallClassMemberFunc(game,"AppendEvent",Py_BuildValue("(iiissiiiiiiiii)",int(dayIndex),int(e.eventID),int(e.eventIndex),
|
|
text(e.startRealTime).c_str(),text(e.endRealTime).c_str(),int(e.empireFlag),int(e.channelFlag),
|
|
int(e.value[0]),int(e.value[1]),int(e.value[2]),int(e.value[3]),
|
|
e.startTime-serverTime,e.endTime==0?0:e.endTime-serverTime,int(e.eventStatus)));
|
|
}
|
|
}
|
|
PyCallClassMemberFunc(game,"RefreshEventManager",Py_BuildValue("()"));
|
|
} else if(subIndex==EVENT_MANAGER_EVENT_STATUS) {
|
|
uint16_t eventID;uint8_t eventStatus;int32_t endTime;char endTimeText[25];int32_t serverTime;
|
|
if(!Read(2,&eventID) || !Read(1,&eventStatus) || !Read(4,&endTime) || !Read(sizeof(endTimeText),endTimeText) || !Read(4,&serverTime))
|
|
return false;
|
|
PyCallClassMemberFunc(game,"RefreshEventStatus",Py_BuildValue("(iiis)",int(eventID),int(eventStatus!=0),
|
|
endTime==0?0:endTime-serverTime,text(endTimeText).c_str()));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvDuelStartPacket() {
|
|
TPacketGCDuelStart p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
const uint32_t count=(uint32_t(p.wSize)-sizeof(p))/sizeof(uint32_t);
|
|
auto* main=MainInstance();
|
|
if(!main) {
|
|
trace_error("CPythonNetworkStream::RecvDuelStartPacket - MainCharacter is NULL");
|
|
return false;
|
|
}
|
|
auto& mgr=NetworkActorManager::Instance();
|
|
for(uint32_t i=0;i<count;++i) {
|
|
uint32_t dst=0;
|
|
Read(4,&dst);
|
|
mgr.InsertDUELKey(m_dwMainActorVID,dst);
|
|
}
|
|
main->m_duelMode=count==0?DUEL_CANNOTATTACK:DUEL_START;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"CloseTargetBoard",Py_BuildValue("()"));
|
|
mgr.RefreshAllPCTextTail();
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPVPPacket() {
|
|
TPacketGCPVP p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
auto& mgr=NetworkActorManager::Instance();
|
|
const auto isMain=[this](uint32_t vid){ return vid==m_dwMainActorVID; };
|
|
switch(p.bMode) {
|
|
case PVP_MODE_AGREE:
|
|
mgr.RemovePVPKey(p.dwVIDSrc,p.dwVIDDst);
|
|
if(isMain(p.dwVIDDst)) RememberChallengeInstance(p.dwVIDSrc);
|
|
if(isMain(p.dwVIDSrc)) RememberCantFightInstance(p.dwVIDDst);
|
|
break;
|
|
case PVP_MODE_REVENGE:
|
|
mgr.RemovePVPKey(p.dwVIDSrc,p.dwVIDDst);
|
|
if(isMain(p.dwVIDDst)) RememberRevengeInstance(p.dwVIDSrc);
|
|
if(isMain(p.dwVIDSrc)) RememberCantFightInstance(p.dwVIDDst);
|
|
break;
|
|
case PVP_MODE_FIGHT:
|
|
mgr.InsertPVPKey(p.dwVIDSrc,p.dwVIDDst);
|
|
ForgetInstance(p.dwVIDSrc);ForgetInstance(p.dwVIDDst);
|
|
break;
|
|
case PVP_MODE_NONE:
|
|
mgr.RemovePVPKey(p.dwVIDSrc,p.dwVIDDst);
|
|
ForgetInstance(p.dwVIDSrc);ForgetInstance(p.dwVIDDst);
|
|
break;
|
|
}
|
|
// CPythonCharacterManager::Insert/RemovePVPKey refresh both instances' text tails.
|
|
mgr.RefreshTextTail(p.dwVIDSrc);
|
|
mgr.RefreshTextTail(p.dwVIDDst);
|
|
RefreshTargetBoardByVID(p.dwVIDSrc);
|
|
RefreshTargetBoardByVID(p.dwVIDDst);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvCharacterPositionPacket() {
|
|
TPacketGCPosition p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
return true; // UpdatePosition is commented out in Windows.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvScriptPacket() {
|
|
TPacketGCScript p;
|
|
if(!Read(sizeof(p),&p)) { trace_error("RecvScriptPacket_RecvError");return false; }
|
|
if(p.size<sizeof(p)) { trace_error("RecvScriptPacket_SizeError");return false; }
|
|
const size_t size=p.size-sizeof(p);
|
|
std::string str(size+1,'\0');
|
|
if(!Read(size,str.data())) return false;
|
|
str[str.size()-1]='\0';
|
|
const int index=CPythonEventManager::Instance().RegisterEventSetFromString(str);
|
|
if(str.find('^')!=std::string::npos) {
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"GetQuestString",Py_BuildValue("(si)",str.c_str(),int(p.skin)));
|
|
return true;
|
|
}
|
|
if(index!=-1) {
|
|
CPythonEventManager::Instance().SetVisibleLineCount(index,30);
|
|
OnScriptEventStart(p.skin,index);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void PythonNetworkStream::OnScriptEventStart(int iSkin,int iIndex) {
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"OpenQuestWindow",Py_BuildValue("(ii)",iSkin,iIndex));
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvShopSearchSet() {
|
|
TPacketGCShopSearchItemSet p;uint16_t count;
|
|
if(!Read(sizeof(p),&p)||p.size<sizeof(p)+2||!Read(2,&count))return false;
|
|
const size_t bytes=size_t(count)*sizeof(TOfflineShopItemData);
|
|
if(p.size<sizeof(p)+2+bytes)return false;
|
|
std::vector<TOfflineShopItemData> items(count);
|
|
if(bytes && !Read(bytes,items.data()))return false;
|
|
auto& records=GetShopSearchItems();records.insert(records.end(),items.begin(),items.end());
|
|
m_refreshShopSearch=true;return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvCubeRenewalPacket() {
|
|
TPacketGCCubeRenewalReceive p;if(!Read(sizeof(p),&p))return false;
|
|
auto& cube=GetCubeRenewalState();
|
|
switch(p.subheader) {
|
|
case CUBE_RENEWAL_SUB_HEADER_OPEN_RECEIVE:
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_CUBE_RENEWAL_OPEN",Py_BuildValue("()"));break;
|
|
case CUBE_RENEWAL_SUB_HEADER_CLEAR_DATES_RECEIVE:cube.records.clear();break;
|
|
case CUBE_RENEWAL_SUB_HEADER_DATES_RECEIVE:cube.records.push_back(p.date_cube_renewal);break;
|
|
case CUBE_RENEWAL_SUB_HEADER_DATES_LOADING:cube.LoadingList();break;
|
|
default:break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvSwitchbotPacket() {
|
|
TPacketGCSwitchbot p;if(!Read(sizeof(p),&p)||p.size<int32_t(sizeof(p)))return false;
|
|
size_t size=size_t(p.size)-sizeof(p);auto& state=GetSwitchbotState();
|
|
if(p.subheader==SUBHEADER_GC_SWITCHBOT_UPDATE) {
|
|
if(size!=sizeof(TSwitchbotTable))return false;
|
|
TSwitchbotTable table;if(!Read(sizeof(table),&table))return false;state.table=table;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RefreshSwitchbotWindow",Py_BuildValue("()"));
|
|
} else if(p.subheader==SUBHEADER_GC_SWITCHBOT_UPDATE_ITEM) {
|
|
if(size!=sizeof(TSwitchbotUpdateItem))return false;
|
|
TSwitchbotUpdateItem update;if(!Read(sizeof(update),&update))return false;
|
|
// Windows ignores update.vnum: count/sockets/attributes amend the existing item.
|
|
if(update.slot<6) {
|
|
SetPlayerItemCount(11,update.slot,update.count);
|
|
auto item=GetPlayerItemData(11,update.slot);
|
|
std::copy_n(update.alSockets,ITEM_SOCKET_SLOT_MAX_NUM,item.alSockets);
|
|
std::copy_n(update.aAttr,ITEM_ATTRIBUTE_SLOT_MAX_NUM,item.aAttr);SetPlayerItemData(11,update.slot,item);
|
|
}
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RefreshSwitchbotItem",Py_BuildValue("(i)",int(update.slot)));
|
|
} else if(p.subheader==SUBHEADER_GC_SWITCHBOT_SEND_ATTRIBUTE_INFORMATION) {
|
|
state.attributes.clear();
|
|
while(size>=sizeof(TSwitchbotAttributeTable)) {
|
|
TSwitchbotAttributeTable entry;if(!Read(sizeof(entry),&entry))return false;
|
|
state.attributes[entry.attribute_set][uint8_t(entry.apply_num)]=entry.max_value;size-=sizeof(entry);
|
|
}
|
|
}
|
|
return true; // Original unknown subheaders/trailing attribute bytes remain in the stream.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvDungeonInfoPacket() {
|
|
TPacketGCDungeonInfoReceive p;if(!Read(sizeof(p),&p))return false;
|
|
auto& state=GetDungeonInfoState();
|
|
switch(p.bSubType) {
|
|
case DUNGEON_INFO_SUB_HEADER_OPEN_SEND:PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_TABLE_DUNGEON_INFO_OPEN",Py_BuildValue("()"));break;
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_CLEAR:state.Clear();break;
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_MISION_CLEAR:state.missions.clear();break;
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_SEND:state.info.push_back(p.dateinfo);break;
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_MISION_SEND:
|
|
state.missions.push_back(p.dateinfom);
|
|
// AVA2 has no break here: mission receipt clears ranking.
|
|
[[fallthrough]];
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_RANKING_CLEAR:state.ranking.clear();break;
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_RANKING_SEND:state.ranking.push_back(p.dateinfo_ranking);break;
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_RANKING_LOAD:PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_TABLE_DUNGEON_RANKING_LOAD",Py_BuildValue("()"));break;
|
|
case DUNGEON_INFO_SUB_HEADER_DATES_MISION_LOAD:PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_TABLE_DUNGEON_MISION_LOAD",Py_BuildValue("()"));break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvDropItemPacket() {
|
|
TPacketGCDropItemReceive p;if(!Read(sizeof(p),&p))return false;
|
|
auto& state=GetDropItemState();
|
|
switch(p.subheader) {
|
|
case DROP_ITEM_SUB_HEADER_OPEN_RECEIVE:PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_DROP_ITEM_OPEN",Py_BuildValue("()"));break;
|
|
case DROP_ITEM_SUB_HEADER_DATES_RECEIVE:state.records.push_back(p.info_drop);break;
|
|
case DROP_ITEM_SUB_HEADER_DATES_CLEAR_RECEIVE:state.Clear();break;
|
|
case DROP_ITEM_SUB_HEADER_DATES_LOADING:state.Loading();break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvBattlePassPacket() {
|
|
TPacketGCBattlePass p;if(!Read(sizeof(p),&p))return false;
|
|
auto& state=GetBattlePassState();
|
|
switch(p.subheader) {
|
|
case BATTLEPASS_SUB_HEADER_OPEN:PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_BATTLEPASS_OPEN",Py_BuildValue("()"));break;
|
|
case BATTLEPASS_SUB_HEADER_MP:PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_BATTLEPASS_MP",Py_BuildValue("()"));break;
|
|
case BATTLEPASS_SUB_HEADER_INFO_EXTRA:state.time=p.time;break;
|
|
case BATTLEPASS_SUB_HEADER_INFO:state.info.push_back(p.data);break;
|
|
case BATTLEPASS_SUB_HEADER_UPDATE:state.progress.push_back(p.data);break;
|
|
case BATTLEPASS_SUB_HEADER_LOADING:
|
|
case BATTLEPASS_SUB_HEADER_UPDATE_LOADING:state.Loading(p.subheader);break;
|
|
case BATTLEPASS_SUB_HEADER_CLEAR:
|
|
case BATTLEPASS_SUB_HEADER_UPDATE_CLEAR:state.Clear(p.subheader);break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// AVA2 RecvGuild: bounded Win32 reads; callback order and refresh coalescing
|
|
// follow PythonNetworkStreamPhaseGame.cpp. No added subheader for GC_ADD.
|
|
bool PythonNetworkStream::RecvGuild() {
|
|
TPacketGCGuild p;if(!Read(sizeof(p),&p)||p.size<sizeof(p))return false;
|
|
size_t remaining=p.size-sizeof(p);
|
|
auto get=[&](size_t size,void* out) {if(size>remaining||!Read(size,out))return false;remaining-=size;return true;};
|
|
auto& guild=GetGuildState();auto& messenger=GetMessengerState();auto* game=m_phaseWindows[5];
|
|
auto target=[&](const std::string& name) {PyCallClassMemberFunc(game,"RefreshTargetBoardByName",Py_BuildValue("(s)",name.c_str()));};
|
|
switch(p.subheader) {
|
|
case GUILD_SUBHEADER_GC_LOGIN:
|
|
case GUILD_SUBHEADER_GC_LOGOUT: {
|
|
uint32_t pid;if(!get(4,&pid))return false;
|
|
if(auto* member=guild.ByPID(pid);member && member->name!=GetMainCharacterName()) {
|
|
// Copy before invoking Python; the handler may mutate guild state.
|
|
const auto name=member->name;
|
|
if(p.subheader==GUILD_SUBHEADER_GC_LOGIN)messenger.LoginGuildMember(name);
|
|
else messenger.LogoutGuildMember(name);
|
|
}
|
|
break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_REMOVE: {
|
|
uint32_t pid;if(!get(4,&pid))return false;
|
|
auto* member=guild.ByPID(pid);const std::string name=member?member->name:"";
|
|
if(member && name==GetMainCharacterName()) {
|
|
guild.Destroy();PyCallClassMemberFunc(game,"DeleteGuild",Py_BuildValue("()"));
|
|
messenger.RemoveAllGuildMember();SetGuildID(0);
|
|
m_refreshMessenger=true;
|
|
PyCallClassMemberFunc(game,"RefreshTargetBoard",Py_BuildValue("()"));
|
|
m_refreshCharacter=true;
|
|
} else {
|
|
if(member)messenger.RemoveGuildMember(name);
|
|
guild.RemoveMember(pid);target(name);m_refreshGuildMember=true;
|
|
}
|
|
break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_LIST:
|
|
while(remaining) {
|
|
TPacketGCGuildSubMember m;if(!get(sizeof(m),&m))return false;
|
|
std::string name;
|
|
if(m.byNameFlag) {char raw[25];if(!get(sizeof(raw),raw))return false;name=text(raw);}
|
|
else if(auto* old=guild.ByPID(m.pid))name=old->name;
|
|
guild.RegisterMember({m.pid,name,m.byGrade,m.byJob,m.byLevel,m.byIsGeneral,m.dwOffer});
|
|
if(name!=GetMainCharacterName())messenger.AppendGuildMember(name);
|
|
target(name);
|
|
}
|
|
m_refreshGuildInfo=m_refreshGuildMember=m_refreshMessenger=m_refreshCharacter=true;
|
|
break;
|
|
case GUILD_SUBHEADER_GC_GRADE: {
|
|
uint8_t count;if(!get(1,&count))return false;
|
|
for(unsigned i=0;i<count;++i) {
|
|
uint8_t grade;TPacketGCGuildSubGrade data;
|
|
if(!get(1,&grade)||!get(sizeof(data),&data))return false;
|
|
guild.grades[grade]={data.auth_flag,text(data.grade_name)};
|
|
}
|
|
m_refreshGuildGrade=m_refreshGuildCombo=true;break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_GRADE_NAME: {
|
|
uint8_t grade;char name[9];if(!get(1,&grade)||!get(sizeof(name),name))return false;
|
|
if(auto it=guild.grades.find(grade);it!=guild.grades.end())it->second.name=text(name);
|
|
PyCallClassMemberFunc(game,"RefreshGuildGrade",Py_BuildValue("()"));
|
|
m_refreshGuildGrade=m_refreshGuildCombo=true;break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_GRADE_AUTH: {
|
|
uint8_t grade,auth;if(!get(1,&grade)||!get(1,&auth))return false;
|
|
if(auto it=guild.grades.find(grade);it!=guild.grades.end())it->second.authority=auth;
|
|
PyCallClassMemberFunc(game,"RefreshGuildGrade",Py_BuildValue("()"));m_refreshGuildGrade=true;break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_INFO: {
|
|
TPacketGCGuildInfo info;if(!get(sizeof(info),&info))return false;
|
|
guild.enabled=true;guild.info={info.guild_id,info.master_pid,info.level,info.exp,info.member_count,info.max_member_count,info.gold,std::string(info.name,strnlen(info.name,12)),info.hasLand};
|
|
m_refreshGuildInfo=true;break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_COMMENTS: {
|
|
uint8_t count;if(!get(1,&count))return false;guild.comments.clear();
|
|
for(unsigned i=0;i<count;++i) {
|
|
uint32_t id;char name[25],comment[51];if(!get(4,&id)||!get(sizeof(name),name)||!get(sizeof(comment),comment))return false;
|
|
auto value=text(comment);if(!value.empty())guild.comments.push_back({id,text(name),value});
|
|
}
|
|
m_refreshGuildBoard=true;break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_CHANGE_EXP: {
|
|
uint8_t level;uint32_t exp;if(!get(1,&level)||!get(4,&exp))return false;
|
|
guild.info.level=level;guild.info.exp=exp;m_refreshGuildInfo=true;break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE:
|
|
case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL: {
|
|
uint32_t pid;uint8_t value;if(!get(4,&pid)||!get(1,&value))return false;
|
|
if(auto* member=guild.ByPID(pid)) {
|
|
if(p.subheader==GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE)member->grade=value;
|
|
else member->general=value;
|
|
}
|
|
m_refreshGuildMember=true;break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_SKILL_INFO:
|
|
if(!get(1,&guild.skill.points)||!get(12,guild.skill.levels.data())||!get(2,&guild.skill.power)||!get(2,&guild.skill.maxPower))return false;
|
|
m_refreshGuildSkill=true;break;
|
|
case GUILD_SUBHEADER_GC_GUILD_INVITE: {
|
|
uint32_t id;char name[12];if(!get(4,&id)||!get(sizeof(name),name))return false;
|
|
PyCallClassMemberFunc(game,"RecvGuildInviteQuestion",Py_BuildValue("(is)",int32_t(id),text(name).c_str()));break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_WAR: {
|
|
TPacketGCGuildWar war;if(!get(sizeof(war),&war))return false;
|
|
switch(war.bWarState) {
|
|
case GUILD_WAR_SEND_DECLARE:PyCallClassMemberFunc(game,"BINARY_GuildWar_OnSendDeclare",Py_BuildValue("(i)",int32_t(war.dwGuildOpp)));break;
|
|
case GUILD_WAR_RECV_DECLARE:PyCallClassMemberFunc(game,"BINARY_GuildWar_OnRecvDeclare",Py_BuildValue("(ii)",int32_t(war.dwGuildOpp),int(war.bType)));break;
|
|
case GUILD_WAR_ON_WAR:PyCallClassMemberFunc(game,"BINARY_GuildWar_OnStart",Py_BuildValue("(ii)",int32_t(war.dwGuildSelf),int32_t(war.dwGuildOpp)));guild.StartWar(war.dwGuildOpp);break;
|
|
case GUILD_WAR_END:PyCallClassMemberFunc(game,"BINARY_GuildWar_OnEnd",Py_BuildValue("(ii)",int32_t(war.dwGuildSelf),int32_t(war.dwGuildOpp)));guild.EndWar(war.dwGuildOpp);break;
|
|
}
|
|
break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_GUILD_NAME:
|
|
if(remaining%16)return false;
|
|
while(remaining) {uint32_t id;char name[12];if(!get(4,&id)||!get(sizeof(name),name))return false;guild.names.insert({id,text(name)});}
|
|
break;
|
|
case GUILD_SUBHEADER_GC_GUILD_WAR_LIST:
|
|
case GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST:
|
|
if(remaining%8)return false;
|
|
while(remaining) {
|
|
uint32_t src,dst;if(!get(4,&src)||!get(4,&dst))return false;
|
|
auto& actors=NetworkActorManager::Instance();
|
|
if(p.subheader==GUILD_SUBHEADER_GC_GUILD_WAR_LIST)actors.InsertGVGKey(src,dst);
|
|
else actors.RemoveGVGKey(src,dst);
|
|
actors.ChangeGVG(src,dst);
|
|
}
|
|
break;
|
|
case GUILD_SUBHEADER_GC_WAR_POINT: {
|
|
TPacketGuildWarPoint point;if(!get(sizeof(point),&point))return false;
|
|
PyCallClassMemberFunc(game,"BINARY_GuildWar_OnRecvPoint",Py_BuildValue("(iii)",int32_t(point.dwGainGuildID),int32_t(point.dwOpponentGuildID),point.lPoint));break;
|
|
}
|
|
case GUILD_SUBHEADER_GC_MONEY_CHANGE:
|
|
if(!get(4,&guild.info.money))return false;m_refreshGuildInfo=true;break;
|
|
}
|
|
return true; // Unknown/ADD subheaders leave their bytes for Windows' dispatcher.
|
|
}
|
|
|
|
// AVA2 RecvMessenger: retain membership on logout and emit mobile after online state.
|
|
bool PythonNetworkStream::RecvMessenger() {
|
|
TPacketGCMessenger p;if(!Read(sizeof(p),&p)||p.size<sizeof(p))return false;
|
|
size_t remaining=p.size-sizeof(p);
|
|
auto get=[&](size_t count,void* dst) {
|
|
if(count>remaining || !Read(count,dst))return false;
|
|
remaining-=count;return true;
|
|
};
|
|
auto name=[&](uint8_t length,std::string& result) {
|
|
// The original writes to char[25] without bounds checks. Reject oversized names.
|
|
if(length>24)return false;
|
|
char bytes[25]{};if(!get(length,bytes))return false;
|
|
result=bytes;return true;
|
|
};
|
|
auto& messenger=GetMessengerState();
|
|
switch(p.subheader) {
|
|
case MESSENGER_SUBHEADER_GC_LIST:
|
|
while(remaining) {
|
|
TPacketGCMessengerListOnline entry;std::string key;
|
|
if(!get(sizeof(entry),&entry)||!name(entry.length,key))return false;
|
|
if(entry.connected&MESSENGER_CONNECTED_STATE_ONLINE)messenger.FriendLogin(key);
|
|
else messenger.FriendLogout(key);
|
|
if(entry.connected&MESSENGER_CONNECTED_STATE_MOBILE)messenger.SetMobile(key,1);
|
|
}
|
|
break;
|
|
case MESSENGER_SUBHEADER_GC_LOGIN:
|
|
case MESSENGER_SUBHEADER_GC_LOGOUT: {
|
|
uint8_t length;std::string key;if(!get(1,&length)||!name(length,key))return false;
|
|
if(p.subheader==MESSENGER_SUBHEADER_GC_LOGIN) {
|
|
messenger.FriendLogin(key);
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RefreshTargetBoardByName",Py_BuildValue("(s)",key.c_str()));
|
|
} else messenger.FriendLogout(key);
|
|
break;
|
|
}
|
|
case MESSENGER_SUBHEADER_GC_MOBILE: {
|
|
uint8_t state,length;std::string key;
|
|
if(!get(1,&state)||!get(1,&length)||!name(length,key))return false;
|
|
messenger.SetMobile(key,state);break;
|
|
}
|
|
// INVITE and unknown subheaders are ignored by Windows, without discarding payload.
|
|
default:break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// AVA2 RecvQuestInfoPacket: six-byte Win32 header and flag-ordered fields.
|
|
bool PythonNetworkStream::RecvQuestInfoPacket() {
|
|
uint8_t header,flags;uint16_t size,id;
|
|
if(!Read(1,&header)||!Read(2,&size)||!Read(2,&id)||!Read(1,&flags))return false;
|
|
|
|
unsigned type=2;
|
|
if(flags&QUEST_SEND_IS_BEGIN) {
|
|
uint8_t begin;if(!Read(1,&begin))return false;type=begin?1:3;
|
|
}
|
|
QuestRecord q;q.index=id;
|
|
char title[31]{},clockName[17]{},counterName[17]{},icon[25]{};
|
|
if((flags&QUEST_SEND_TITLE)&&!Read(sizeof(title),title))return false;
|
|
if((flags&QUEST_SEND_CLOCK_NAME)&&!Read(sizeof(clockName),clockName))return false;
|
|
if((flags&QUEST_SEND_CLOCK_VALUE)&&!Read(4,&q.clockValue))return false;
|
|
if((flags&QUEST_SEND_COUNTER_NAME)&&!Read(sizeof(counterName),counterName))return false;
|
|
if((flags&QUEST_SEND_COUNTER_VALUE)&&!Read(4,&q.counterValue))return false;
|
|
if((flags&QUEST_SEND_ICON_FILE)&&!Read(sizeof(icon),icon))return false;
|
|
title[30]=clockName[16]=counterName[16]=icon[24]='\0';
|
|
q.title=title;q.clockName=clockName;q.counterName=counterName;q.iconFile=icon;
|
|
if(type!=3 && q.title.find('^')!=std::string::npos) {
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"GetQuestLetterName",
|
|
Py_BuildValue("(iiissssii)",int(type),int(id),int(flags),title,clockName,counterName,icon,q.clockValue,q.counterValue));
|
|
} else GetQuestState().apply(type,q,flags,GetQuestTime());
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RefreshQuest",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvQuestConfirmPacket() {
|
|
TPacketGCQuestConfirm p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_OnQuestConfirm",Py_BuildValue("(sii)",text(p.msg).c_str(),p.timeout,int(p.requestPID)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvOfflineShopSignPacket() {
|
|
TPacketGCShopSign p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
auto* inst=NetworkActorManager::Instance().GetActorData(p.dwVID);
|
|
if(inst && is_shop(*inst)) {
|
|
const std::string sign=text(p.szSign);
|
|
if(sign.empty()) PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_OfflineShop_Disappear",Py_BuildValue("(i)",int(p.dwVID)));
|
|
else PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_OfflineShop_Appear",Py_BuildValue("(is)",int(p.dwVID),sign.c_str()));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvTargetInfoPacket() {
|
|
TPacketGCTargetInfo p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
auto* target=NetworkActorManager::Instance().GetActorData(p.dwVID);
|
|
PyObject* game=m_phaseWindows[5];
|
|
if(MainInstance() && target) {
|
|
if(!is_dead(*target)) {
|
|
if(is_enemy(*target) || is_stone(*target)) {
|
|
PyCallClassMemberFunc(game,"BINARY_AddTargetMonsterDropInfo",Py_BuildValue("(iii)",int(p.race),int(p.dwVnum),int(p.count)));
|
|
PyCallClassMemberFunc(game,"BINARY_RefreshTargetMonsterDropInfo",Py_BuildValue("(i)",int(p.race)));
|
|
} else PyCallClassMemberFunc(game,"CloseTargetBoard",Py_BuildValue("()"));
|
|
m_dwInstTargetVID=p.dwVID;
|
|
}
|
|
} else PyCallClassMemberFunc(game,"CloseTargetBoard",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvMountPacket() {
|
|
TPacketGCMount p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
return true; // Ride/Unride/SetRidingVehicleIndex are commented out in Windows.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvOwnerShipPacket() {
|
|
TPacketGCOwnership p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
NetworkActorManager::Instance().SetActorOwner(p.dwOwnerVID,p.dwVictimVID);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvTargetPacket() {
|
|
TPacketGCTarget p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
auto* main=MainInstance();
|
|
auto* target=NetworkActorManager::Instance().GetActorData(p.dwVID);
|
|
PyObject* game=m_phaseWindows[5];
|
|
if(main && target) {
|
|
if(!is_dead(*target)) {
|
|
if(is_building(*target))
|
|
PyCallClassMemberFunc(game,"CloseTargetBoardIfDifferent",Py_BuildValue("(ii)",int(p.dwVID),int(p.bHPPercent)));
|
|
else if(can_view_target_hp(*target)) {
|
|
PyCallClassMemberFunc(game,"SetHPTargetBoard",Py_BuildValue("(iii)",int(p.dwVID),int(p.bHPPercent),int(p.bElement)));
|
|
if(is_pc(*target))
|
|
PyCallClassMemberFunc(game,"SetHideCostumeTargetBoard",Py_BuildValue("(is)",int(p.dwVID),text(p.costume).c_str()));
|
|
} else PyCallClassMemberFunc(game,"CloseTargetBoard",Py_BuildValue("()"));
|
|
}
|
|
} else PyCallClassMemberFunc(game,"CloseTargetBoard",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvChestDrop() {
|
|
TPacketGCChestDrop p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
uint32_t chestVnum,chestCount;
|
|
if(!Read(4,&chestVnum) || !Read(4,&chestCount)) return false;
|
|
if(chestCount>0) {
|
|
ClearChestDropInfo(chestVnum);
|
|
for(uint32_t j=0;j<chestCount;++j) {
|
|
uint32_t vnum,count;
|
|
if(!Read(4,&vnum) || !Read(4,&count)) return false;
|
|
AddChestDropItem(chestVnum, vnum, count);
|
|
}
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"OpenChestDrop",Py_BuildValue("(i)",int(chestVnum)));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvKillLOG() {
|
|
TPacketGCKillLOG p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
SetKillLOG(p.kill_log);
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RefreshCharacter",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvFlyTargetingPacket(bool add) {
|
|
TPacketGCFlyTargeting p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
GlobalToLocalPosition(p.lX,p.lY);
|
|
// Windows logs the missing shooter only for AddFlyTargeting in release builds.
|
|
auto* shooter=NetworkActorManager::Instance().GetActorData(p.dwShooterVID);
|
|
if(!shooter || !shooter->m_pActorInstance) {
|
|
if(add) trace_error("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID["+std::to_string(p.dwShooterVID)+"] NOT EXIST");
|
|
return true;
|
|
}
|
|
ActorInstance& inst=*shooter->m_pActorInstance;
|
|
auto* target=p.dwTargetVID ? NetworkActorManager::Instance().GetActorData(p.dwTargetVID) : nullptr;
|
|
if(target && target->m_pActorInstance) {
|
|
if(add) inst.AddFlyTarget(p.dwTargetVID); else inst.SetFlyTarget(p.dwTargetVID);
|
|
} else {
|
|
// GetHeight(lX, lY) + 60.0f: "TEMPORARY HEIGHT" on Windows. Engine axes are (x, h, y).
|
|
const float h=CPythonBackground::Instance().GetHeight(float(p.lX),float(p.lY))+60.0f;
|
|
if(add) inst.AddFlyTarget(float(p.lX),h,float(p.lY)); else inst.SetFlyTarget(float(p.lX),h,float(p.lY));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvFlyTargetingPacket() {
|
|
return RecvFlyTargetingPacket(false);
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvAddFlyTargetingPacket() {
|
|
return RecvFlyTargetingPacket(true);
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPartyInvite() {
|
|
TPacketGCPartyInvite p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
auto* inst=NetworkActorManager::Instance().GetActorData(p.leader_pid);
|
|
if(!inst) {
|
|
trace_error(" CPythonNetworkStream::RecvPartyInvite - Failed to find leader instance ["+std::to_string(p.leader_pid)+"]\n");
|
|
return true;
|
|
}
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RecvPartyInviteQuestion",Py_BuildValue("(is)",int(p.leader_pid),inst->m_stName.c_str()));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPartyAdd() {
|
|
TPacketGCPartyAdd p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
const std::string name=text(p.name);
|
|
AppendPartyMember(p.pid,name);
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"AddPartyMember",Py_BuildValue("(is)",int(p.pid),name.c_str()));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPartyUpdate() {
|
|
TPacketGCPartyUpdate p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
uint8_t oldState;
|
|
if(!GetPartyMemberState(p.pid,&oldState)) return true;
|
|
UpdatePartyMemberInfo(p.pid,p.state,p.percent_hp);
|
|
for(uint8_t i=0;i<PARTY_AFFECT_SLOT_MAX_NUM;++i) UpdatePartyMemberAffect(p.pid,i,p.affects[i]);
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"UpdatePartyMemberInfo",Py_BuildValue("(i)",int(p.pid)));
|
|
uint32_t vid;
|
|
if(PartyMemberPIDToVID(p.pid,&vid) && oldState!=p.state) RefreshTargetBoardByVID(vid);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPartyRemove() {
|
|
TPacketGCPartyRemove p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"RemovePartyMember",Py_BuildValue("(i)",int(p.pid)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvRequestMakeGuild() {
|
|
TPacketGCBlank p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"AskGuildName",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPartyParameter() {
|
|
TPacketGCPartyParameter p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"ChangePartyParameter",Py_BuildValue("(i)",int(p.bDistributeMode)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvFishing() {
|
|
TPacketGCFishing p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
SNetworkActorData* inst=nullptr;
|
|
if(p.subheader!=FISHING_SUBHEADER_GC_FISH) {
|
|
inst=NetworkActorManager::Instance().GetActorData(p.info);
|
|
if(!inst) return true;
|
|
}
|
|
// Fishing motions/emoticons are not ported; m_isFishing mirrors IsFishing().
|
|
switch(p.subheader) {
|
|
case FISHING_SUBHEADER_GC_START: inst->m_isFishing=true;break;
|
|
case FISHING_SUBHEADER_GC_STOP: if(inst->m_isFishing) inst->m_isFishing=false;break;
|
|
case FISHING_SUBHEADER_GC_REACT: break;
|
|
case FISHING_SUBHEADER_GC_SUCCESS: inst->m_isFishing=false;break;
|
|
case FISHING_SUBHEADER_GC_FAIL:
|
|
inst->m_isFishing=false;
|
|
if(inst==MainInstance()) PyCallClassMemberFunc(game,"OnFishingFailure",Py_BuildValue("()"));
|
|
break;
|
|
case FISHING_SUBHEADER_GC_FISH: {
|
|
if(p.info==0) { PyCallClassMemberFunc(game,"OnFishingNotifyUnknown",Py_BuildValue("()"));return true; }
|
|
std::string name;int type=0;
|
|
if(!GetItemNameAndType(p.info,&name,&type)) return true;
|
|
auto* main=MainInstance();
|
|
if(!main) return true;
|
|
constexpr int ITEM_TYPE_FISH=12;
|
|
PyCallClassMemberFunc(game,main->m_isFishing?"OnFishingNotify":"OnFishingSuccess",Py_BuildValue("(is)",int(type==ITEM_TYPE_FISH),name.c_str()));
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPartyLink() {
|
|
TPacketGCPartyLink p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
LinkPartyMember(p.pid,p.vid);
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"LinkPartyMember",Py_BuildValue("(ii)",int(p.pid),int(p.vid)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPartyUnlink() {
|
|
TPacketGCPartyUnlink p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
UnlinkPartyMember(p.pid);
|
|
if(p.vid==m_dwMainActorVID) PyCallClassMemberFunc(m_phaseWindows[5],"UnlinkAllPartyMember",Py_BuildValue("()"));
|
|
else PyCallClassMemberFunc(m_phaseWindows[5],"UnlinkPartyMember",Py_BuildValue("(i)",int(p.pid)));
|
|
return true;
|
|
}
|
|
|
|
// ENABLE_MULTI_REFINE_WORLDARD variants of RecvRefineInformationPacket(New).
|
|
template<class Packet> void PythonNetworkStream::RefineInformation(const Packet& p,bool isNew) {
|
|
const TRefineTable& t=p.refine_table;
|
|
PyObject* game=m_phaseWindows[5];
|
|
switch(t.bSubType) {
|
|
case MULTIREFINE_CLEAR_INFO: PyCallClassMemberFunc(game,"BINARY_MULTI_REFINE_CLEAR_INFO",Py_BuildValue("()"));break;
|
|
case MULTIREFINE_ADD_INFO:
|
|
if(isNew) {
|
|
PyCallClassMemberFunc(game,"BINARY_MULTI_REFINE_ADD_INFO",Py_BuildValue("(iiiiiii)",t.index,int(p.pos),int(t.result_vnum),t.cost,t.prob,
|
|
int(t.special_storage),int(RefineType(p))));
|
|
for(int i=0;i<t.material_count;++i)
|
|
PyCallClassMemberFunc(game,"BINARY_MULTI_REFINE_ADD_MATERIAL",Py_BuildValue("(iii)",t.index,int(t.materials[i].vnum),int(t.materials[i].count)));
|
|
} else {
|
|
PyCallClassMemberFunc(game,"OpenRefineDialog",Py_BuildValue("(iiiiii)",t.index,int(p.pos),int(t.result_vnum),t.cost,t.prob,int(t.special_storage)));
|
|
for(int i=0;i<t.material_count;++i)
|
|
PyCallClassMemberFunc(game,"AppendMaterialToRefineDialog",Py_BuildValue("(iii)",t.index,int(t.materials[i].vnum),int(t.materials[i].count)));
|
|
}
|
|
break;
|
|
case MULTIREFINE_LOAD_INFO: PyCallClassMemberFunc(game,"BINARY_MULTI_REFINE_LOAD_INFO",Py_BuildValue("()"));break;
|
|
case MULTIREFINE_OPEN: PyCallClassMemberFunc(game,"BINARY_MULTI_REFINE_OPEN",Py_BuildValue("()"));break;
|
|
case MULTIREFINE_SEND_DATES_CLEAR: PyCallClassMemberFunc(game,"BINARY_MULTI_REFINE_DATES_CLEAR",Py_BuildValue("()"));break;
|
|
case MULTIREFINE_SEND_DATES: PyCallClassMemberFunc(game,"BINARY_MULTI_REFINE_SEND_DATES",Py_BuildValue("(i)",int(t.src_vnum)));break;
|
|
}
|
|
}
|
|
uint8_t PythonNetworkStream::RefineType(const TPacketGCRefineInformation&) { return 0; }
|
|
uint8_t PythonNetworkStream::RefineType(const TPacketGCRefineInformationNew& p) { return p.type; }
|
|
|
|
bool PythonNetworkStream::RecvRefineInformationPacket() {
|
|
TPacketGCRefineInformation p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
RefineInformation(p,false);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvRefineInformationPacketNew() {
|
|
TPacketGCRefineInformationNew p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
RefineInformation(p,true);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvViewEquipPacket() {
|
|
TPacketGCViewEquip p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
const int vid=int(p.vid);
|
|
PyCallClassMemberFunc(game,"OpenEquipmentDialog",Py_BuildValue("(i)",vid));
|
|
for(int i=0;i<int(WEAR_MAX_NUM);++i) {
|
|
const auto& set=p.equips[i];
|
|
PyCallClassMemberFunc(game,"SetEquipmentDialogItem",Py_BuildValue("(iiii)",vid,i,int(set.vnum),int(set.count)));
|
|
for(int j=0;j<int(ITEM_SOCKET_SLOT_MAX_NUM);++j)
|
|
PyCallClassMemberFunc(game,"SetEquipmentDialogSocket",Py_BuildValue("(iiii)",vid,i,j,int(set.alSockets[j])));
|
|
for(int k=0;k<int(ITEM_ATTRIBUTE_SLOT_MAX_NUM);++k)
|
|
PyCallClassMemberFunc(game,"SetEquipmentDialogAttr",Py_BuildValue("(iiiii)",vid,i,k,int(set.aAttr[k].bType),int(set.aAttr[k].sValue)));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvDungeon() {
|
|
TPacketGCDungeon p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
if(p.subheader==DUNGEON_SUBHEADER_GC_DESTINATION_POSITION) {
|
|
uint32_t x,y; // Win32 unsigned long
|
|
if(!Read(4,&x) || !Read(4,&y)) return false;
|
|
// CPythonPlayer::SetDungeonDestinationPosition: stored; the auto-walk that consumes
|
|
// it (CPythonPlayer::Update) is not ported.
|
|
m_dungeonDestination={int32_t(x),int32_t(y)};
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvWalkModePacket() {
|
|
TPacketGCWalkMode p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
if(auto* inst=NetworkActorManager::Instance().GetActorData(p.vid)) inst->m_walkMode=p.mode==0?0:1; // WALKMODE_RUN=0
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvChangeSkillGroupPacket() {
|
|
TPacketGCChangeSkillGroup p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
m_byMainActorSkillGroup=p.skill_group;
|
|
NEW_ClearSkillData(false);
|
|
m_refreshCharacter=true; // __RefreshCharacterWindow
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvNPCList() {
|
|
TPacketGCNPCPosition p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
CPythonMiniMap::Instance().ClearAtlasMarkInfo();
|
|
for(int i=0;i<p.count;++i) {
|
|
TNPCPosition pos;
|
|
if(!Read(sizeof(pos),&pos)) return false;
|
|
// CPythonNonPlayer::GetName leaves c_szName unset for an unknown vnum; empty here.
|
|
std::string name;
|
|
GetNonPlayerName(pos.name,name);
|
|
CPythonMiniMap::Instance().RegisterAtlasMark(pos.bType,pos.name,name.c_str(),pos.x,pos.y,pos.regenTime);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvChannelPacket() {
|
|
TPacketGCChannel p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"SetChannelIndex",Py_BuildValue("(i)",int(p.channel)));
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"SetAntiExp",Py_BuildValue("(i)",int(p.anti_exp)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvTargetUpdatePacket() {
|
|
TPacketGCTargetUpdate p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
CPythonMiniMap::Instance().UpdateTarget(p.lID,p.lX,p.lY);
|
|
return true; // background CreateTargetEffect(Shop) (bType 5): not ported.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvTargetDeletePacket() {
|
|
TPacketGCTargetDelete p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
CPythonMiniMap::Instance().DeleteTarget(p.lID);
|
|
return true; // background DeleteTargetEffect: not ported.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvTargetCreatePacket() {
|
|
TPacketGCTargetCreate p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
CPythonMiniMap::Instance().CreateTarget(p.lID,text(p.szTargetName).c_str());
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_OpenAtlasWindow",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvTargetCreatePacketNew() {
|
|
TPacketGCTargetCreateNew p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
// CREATE_TARGET_TYPE_LOCATION (1); WJ_COMBAT_ZONE is off. Background CreateTargetEffect: not ported.
|
|
if(p.byType==1)
|
|
CPythonMiniMap::Instance().CreateTarget(p.lID,text(p.szTargetName).c_str());
|
|
else
|
|
CPythonMiniMap::Instance().CreateTarget(p.lID,text(p.szTargetName).c_str(),p.dwVID);
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_OpenAtlasWindow",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvLandPacket() {
|
|
TPacketGCLandList p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
// CPythonBackground Clear/RegisterGuildArea (terrain overlay) and __DownloadSymbol are not ported.
|
|
CPythonMiniMap::Instance().ClearGuildArea();
|
|
for(int size=int(p.size)-int(sizeof(p));size>0;size-=int(sizeof(TLandPacketElement))) {
|
|
TLandPacketElement e;
|
|
if(!Read(sizeof(e),&e)) return false;
|
|
CPythonMiniMap::Instance().RegisterGuildArea(e.dwID,e.dwGuildID,e.x,e.y,e.width,e.height);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvLoverInfoPacket() {
|
|
TPacketGCLoverInfo p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_LoverInfo",Py_BuildValue("(si)",text(p.name).c_str(),int(p.love_point)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvLovePointUpdatePacket() {
|
|
TPacketGCLovePointUpdate p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_UpdateLovePoint",Py_BuildValue("(i)",int(p.love_point)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvDigMotionPacket() {
|
|
TPacketGCDigMotion p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
return true; // NEW_LookAtDestInstance + PushOnceMotion(NAME_DIG): motion queue not ported.
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvAccountBankPacket() {
|
|
TPacketGCBank p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
CPythonManagerBank::Instance().Append(p);
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_Account_Bank_Logs",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvHybridCryptPacket() {
|
|
TPacketGCHybridCryptKeys p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
if(p.iKeyStreamLen<0 || m_recvBuffer.size()<size_t(p.iKeyStreamLen)) return false;
|
|
// CEterPackManager::RetrieveHybridCryptPackKeys/SDB: packs are read decrypted, keys dropped.
|
|
m_recvBuffer.erase(m_recvBuffer.begin(),m_recvBuffer.begin()+p.iKeyStreamLen);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvHSCheckRequest() {
|
|
TPacketHSCheck p;
|
|
if(!Read(sizeof(p),&p)) { trace_error("HShield: Recv failed");return false; }
|
|
return false; // neither USE_AHNLAB_HACKSHIELD nor LOCALE_SERVICE_GLOBAL is defined
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvXTrapVerifyRequest() {
|
|
TPacketXTrapCSVerify p;
|
|
if(!Read(sizeof(p),&p)) { trace_error("XTrap: Recv failed");return false; }
|
|
// XTRAP_CLIENT_ENABLE is off, so XTrap_ValidateCheckStream leaves the reply data
|
|
// untouched (uninitialised on Windows); it is sent zeroed and without SendSequence.
|
|
TPacketXTrapCSVerify res{};
|
|
res.bHeader=HEADER_CG_XTRAP_ACK;
|
|
SendUnsequenced(&res,sizeof(res));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvSpecificEffect() {
|
|
TPacketGCSpecificEffect p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
auto& actors=NetworkActorManager::Instance();
|
|
if(actors.GetActorData(p.vid)) {
|
|
NetworkActorManager::RegisterEffect(NetworkActorManager::EFFECT_TEMP,"",std::string(p.effect_file,strnlen(p.effect_file,sizeof(p.effect_file))),false);
|
|
actors.AttachSpecialEffect(p.vid,NetworkActorManager::EFFECT_TEMP);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// PythonNetworkStreamPhaseGameItem.cpp RecvSpecialEffect. Effect indices are CInstanceBase::EFFECT_*.
|
|
bool PythonNetworkStream::RecvSpecialEffect() {
|
|
TPacketGCSpecialEffect p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
uint32_t effect=uint32_t(-1);
|
|
bool playPotionSound=false, attachEffect=true;
|
|
switch(p.type) {
|
|
case SE_HPUP_RED: effect=13;playPotionSound=true;break;
|
|
case SE_SPUP_BLUE: effect=14;playPotionSound=true;break;
|
|
case SE_SPEEDUP_GREEN: effect=15;playPotionSound=true;break;
|
|
case SE_DXUP_PURPLE: effect=16;playPotionSound=true;break;
|
|
case SE_CRITICAL: effect=17;break;
|
|
case SE_PENETRATE: effect=18;break;
|
|
case SE_BLOCK: effect=19;break;
|
|
case SE_DODGE: effect=20;break;
|
|
case SE_CHINA_FIREWORK: effect=21;attachEffect=false;break; // EFFECT_FIRECRACKER
|
|
case SE_SPIN_TOP: effect=22;attachEffect=false;break;
|
|
case SE_SUCCESS: effect=262;attachEffect=false;break;
|
|
case SE_FAIL: effect=263;break;
|
|
case SE_FR_SUCCESS: effect=264;attachEffect=false;break;
|
|
case SE_LEVELUP_ON_14_FOR_GERMANY: effect=265;attachEffect=false;break;
|
|
case SE_LEVELUP_UNDER_15_FOR_GERMANY: effect=266;attachEffect=false;break;
|
|
case SE_PERCENT_DAMAGE1: effect=267;break;
|
|
case SE_PERCENT_DAMAGE2: effect=268;break;
|
|
case SE_PERCENT_DAMAGE3: effect=269;break;
|
|
case SE_AUTO_HPUP: effect=270;break;
|
|
case SE_AUTO_SPUP: effect=271;break;
|
|
case SE_EQUIP_RAMADAN_RING: effect=272;break;
|
|
case SE_EQUIP_HALLOWEEN_CANDY: effect=273;break;
|
|
case SE_EQUIP_HAPPINESS_RING: effect=274;break;
|
|
case SE_EQUIP_LOVE_PENDANT: effect=275;break;
|
|
case SE_EFFECT_SASH_SUCCEDED: effect=277;break;
|
|
case SE_EFFECT_SASH_EQUIP: effect=278;break;
|
|
case SE_EFFECT_HEALER: effect=279;break;
|
|
// ENABLE_ZODIAC_MISSION: EFFECT_SKILL_DAMAGE_ZONE (14313) .. EFFECT_DEAPO_BOOM (14327) in order.
|
|
case SE_SKILL_DAMAGE_ZONE: case SE_SKILL_DAMAGE_ZONE_BUYUK: case SE_SKILL_DAMAGE_ZONE_ORTA:
|
|
case SE_SKILL_DAMAGE_ZONE_KUCUK: case SE_SKILL_SAFE_ZONE: case SE_SKILL_SAFE_ZONE_BUYUK:
|
|
case SE_SKILL_SAFE_ZONE_ORTA: case SE_SKILL_SAFE_ZONE_KUCUK: case SE_METEOR: case SE_BEAD_RAIN:
|
|
case SE_FALL_ROCK: case SE_ARROW_RAIN: case SE_HORSE_DROP: case SE_EGG_DROP: case SE_DEAPO_BOOM:
|
|
effect=14313+(p.type-SE_SKILL_DAMAGE_ZONE);break;
|
|
default:
|
|
trace_error(std::to_string(p.type)+" is not a special effect number. TPacketGCSpecialEffect");
|
|
break;
|
|
}
|
|
if(playPotionSound&&NetworkActorManager::Instance().IsMainActorVID(p.vid))
|
|
PlayUsePotionSound();
|
|
if(effect!=uint32_t(-1)) {
|
|
auto& actors=NetworkActorManager::Instance();
|
|
if(actors.GetActorData(p.vid)) {
|
|
if(attachEffect) actors.AttachSpecialEffect(p.vid,effect);
|
|
else actors.CreateSpecialEffect(p.vid,effect);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvDragonSoulRefine() {
|
|
TPacketGCDragonSoulRefine p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
switch(p.bSubType) {
|
|
case DS_SUB_HEADER_OPEN: PyCallClassMemberFunc(game,"BINARY_DragonSoulRefineWindow_Open",Py_BuildValue("()"));break;
|
|
case DS_SUB_HEADER_REFINE_FAIL:
|
|
case DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE:
|
|
case DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL:
|
|
case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY:
|
|
case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL:
|
|
case DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL:
|
|
PyCallClassMemberFunc(game,"BINARY_DragonSoulRefineWindow_RefineFail",Py_BuildValue("(iii)",int(p.bSubType),int(p.Pos.window_type),int(p.Pos.cell)));
|
|
break;
|
|
case DS_SUB_HEADER_REFINE_SUCCEED:
|
|
PyCallClassMemberFunc(game,"BINARY_DragonSoulRefineWindow_RefineSucceed",Py_BuildValue("(ii)",int(p.Pos.window_type),int(p.Pos.cell)));
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvUnk213() {
|
|
// @fixme007 reads `if (!Recv(sizeof(TPacketGCUnk213)), &kUnk213Packet)`: Recv(int)
|
|
// skips the packet and the comma expression is always true, so it always fails.
|
|
TPacketGCUnk213 p;
|
|
Read(sizeof(p),&p);
|
|
return false;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvCalendarSystem() {
|
|
TPacketGCCalendarReceive p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
switch(p.bSubType) {
|
|
case CALENDAR_RECEIVE_OPEN: PyCallClassMemberFunc(game,"BINARY_CALENDAR_OPEN",Py_BuildValue("(i)",int(p.dwCurrentTimeStamp)));break;
|
|
case CALENDAR_RECEIVE_LOAD_EVENTS:
|
|
PyCallClassMemberFunc(game,"BINARY_CALENDAR_LOAD_EVENTS",Py_BuildValue("(issssi)",int(p.bDay),text(p.szName).c_str(),text(p.szImage).c_str(),
|
|
text(p.szStartAt).c_str(),text(p.szEndAt).c_str(),int(p.dwDuration)));
|
|
break;
|
|
case CALENDAR_RECEIVE_CLEAR_EVENTS: PyCallClassMemberFunc(game,"BINARY_CALENDAR_CLEAR_EVENTS",Py_BuildValue("()"));break;
|
|
case CALENDAR_RECEIVE_LOADING_EVENTS: PyCallClassMemberFunc(game,"BINARY_CALENDAR_LOADING_EVENTS",Py_BuildValue("()"));break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvCalendarSystemADM() {
|
|
TPacketGCCalendarReceiveADM p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
switch(p.bSubType) {
|
|
case CALENDAR_RECEIVE_OPEN_ADM: PyCallClassMemberFunc(game,"BINARY_CALENDAR_OPEN_ADM",Py_BuildValue("()"));break;
|
|
case CALENDAR_RECEIVE_LOAD_EVENTS_ADM:
|
|
PyCallClassMemberFunc(game,"BINARY_CALENDAR_LOAD_EVENTS_ADM",Py_BuildValue("(iss)",p.index_event,text(p.event).c_str(),text(p.event_descript).c_str()));
|
|
break;
|
|
case CALENDAR_RECEIVE_CLEAR_EVENTS_ADM: PyCallClassMemberFunc(game,"BINARY_CALENDAR_CLEAR_EVENTS_ADM",Py_BuildValue("()"));break;
|
|
case CALENDAR_RECEIVE_LOADING_EVENTS_ADM: PyCallClassMemberFunc(game,"BINARY_CALENDAR_LOADING_EVENTS_ADM",Py_BuildValue("()"));break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvSashPacket() {
|
|
TPacketSash p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
const int window=p.bWindow;
|
|
switch(p.subheader) {
|
|
case SASH_SUBHEADER_GC_OPEN:
|
|
CPythonSash::Instance().Clear();
|
|
PyCallClassMemberFunc(game,"ActSash",Py_BuildValue("(ib)",1,window));
|
|
break;
|
|
case SASH_SUBHEADER_GC_CLOSE:
|
|
CPythonSash::Instance().Clear();
|
|
PyCallClassMemberFunc(game,"ActSash",Py_BuildValue("(ib)",2,window));
|
|
break;
|
|
case SASH_SUBHEADER_GC_ADDED:
|
|
CPythonSash::Instance().AddMaterial(p.dwPrice, p.bPos, p.tPos);
|
|
if(p.bPos==1) {
|
|
CPythonSash::Instance().AddResult(p.dwItemVnum, p.dwMinAbs, p.dwMaxAbs);
|
|
PyCallClassMemberFunc(game,"AlertSash",Py_BuildValue("(b)",window));
|
|
}
|
|
PyCallClassMemberFunc(game,"ActSash",Py_BuildValue("(ib)",3,window));
|
|
break;
|
|
case SASH_SUBHEADER_GC_REMOVED:
|
|
CPythonSash::Instance().RemoveMaterial(p.dwPrice, p.bPos);
|
|
if (p.bPos == 0)
|
|
CPythonSash::Instance().RemoveMaterial(p.dwPrice, 1);
|
|
PyCallClassMemberFunc(game,"ActSash",Py_BuildValue("(ib)",4,window));
|
|
break;
|
|
case SASH_SUBHEADER_CG_REFINED:
|
|
if (p.dwMaxAbs == 0)
|
|
CPythonSash::Instance().RemoveMaterial(p.dwPrice, 1);
|
|
else {
|
|
CPythonSash::Instance().RemoveMaterial(p.dwPrice, 0);
|
|
CPythonSash::Instance().RemoveMaterial(p.dwPrice, 1);
|
|
}
|
|
PyCallClassMemberFunc(game,"ActSash",Py_BuildValue("(ib)",5,window));
|
|
break;
|
|
default:
|
|
trace_error("CPythonNetworkStream::RecvSashPacket: unknown subheader "+std::to_string(p.subheader)+"\n.");
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvKingdomsWarPacket() {
|
|
TPacketKingdomWar p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
const auto act=[&](int mode){
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"ActKingdomsWar",Py_BuildValue("(iiiiiiii)",mode,p.iKills[0],p.iKills[1],p.iKills[2],
|
|
p.iLimitKills,p.iDeads,p.iLimitDeads,int(p.dwTimeRemained)));
|
|
};
|
|
switch(p.bSubHeader) {
|
|
case KINGDOMSWAR_SUBHEADER_GC_OPEN: act(1);break;
|
|
case KINGDOMSWAR_SUBHEADER_GC_REFRESH: act(p.iLimitDeads>0?3:2);break;
|
|
default:
|
|
trace_error("CPythonNetworkStream::RecvKingdomsWarPacket: unknown subheader "+std::to_string(p.bSubHeader)+"\n.");
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvSungmaAttrUpdatePacket() {
|
|
TPacketGCSungmaAttrUpdate p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_SungMaAttr",Py_BuildValue("(iiii)",int(p.bSTR),int(p.bHP),int(p.bMOVE),int(p.bINMUNE)));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvExchangeLog() {
|
|
TPacketGCExchangeLog p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
uint8_t subIndex;
|
|
if(!Read(1,&subIndex)) return false;
|
|
PyObject* game=m_phaseWindows[5];
|
|
if(subIndex==SUB_EXCHANGELOG_LOAD) {
|
|
char playerCode[19];uint8_t isNeedClean;uint16_t logCount;
|
|
if(!Read(sizeof(playerCode),playerCode) || !Read(1,&isNeedClean) || !Read(2,&logCount)) return false;
|
|
if(isNeedClean) PyCallClassMemberFunc(game,"ExchangeLogClear",Py_BuildValue("(s)",text(playerCode).c_str()));
|
|
for(uint32_t j=0;j<logCount;++j) {
|
|
uint32_t logID;TExchangeLog log;
|
|
if(!Read(4,&logID) || !Read(sizeof(log),&log)) return false;
|
|
PyCallClassMemberFunc(game,"ExchangeLogAppend",Py_BuildValue("(isLssLss)",int(logID),text(log.owner).c_str(),(long long)log.ownerGold,
|
|
text(log.ownerIP).c_str(),text(log.target).c_str(),(long long)log.targetGold,text(log.targetIP).c_str(),text(log.date).c_str()));
|
|
}
|
|
PyCallClassMemberFunc(game,"ExchangeLogRefresh",Py_BuildValue("(i)",0));
|
|
} else if(subIndex==SUB_EXCHANGELOG_LOAD_ITEM) {
|
|
uint16_t itemCount;uint32_t logID;
|
|
if(!Read(2,&itemCount) || !Read(4,&logID)) return false;
|
|
if(itemCount) {
|
|
std::vector<TExchangeLogItem> items(itemCount);
|
|
if(!Read(itemCount*sizeof(TExchangeLogItem),items.data())) return false;
|
|
for(const auto& item:items) {
|
|
PyObject* sockets=PyList_New(0);
|
|
for(int32_t socket:item.alSockets) { PyObject* v=PyInt_FromLong(socket);PyList_Append(sockets,v);Py_DECREF(v); }
|
|
PyObject* attrType=PyList_New(0);
|
|
PyObject* attrValue=PyList_New(0);
|
|
for(const auto& attr:item.aAttr) {
|
|
PyObject* t=PyInt_FromLong(attr.bType);PyList_Append(attrType,t);Py_DECREF(t);
|
|
PyObject* v=PyInt_FromLong(attr.sValue);PyList_Append(attrValue,v);Py_DECREF(v);
|
|
}
|
|
PyCallClassMemberFunc(game,"ExchangeLogItemAppend",Py_BuildValue("(iiiiOOOi)",int(logID),int(item.pos),int(item.vnum),int(item.count),
|
|
sockets,attrType,attrValue,int(item.isOwner)));
|
|
Py_DECREF(sockets);Py_DECREF(attrType);Py_DECREF(attrValue);
|
|
}
|
|
}
|
|
PyCallClassMemberFunc(game,"ExchangeLogRefresh",Py_BuildValue("(i)",int(logID)));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvMiniGameCatchKingPacket() {
|
|
TPacketGCMiniGameCatchKing p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
const int packetSize=int(p.wSize)-int(sizeof(p));
|
|
PyObject* game=m_phaseWindows[5];
|
|
const auto fail=[&](int code){
|
|
trace_error(" RecvMiniGamePacket Error 0x040"+std::to_string(p.bSubheader)+"BEBC"+std::to_string(code));
|
|
};
|
|
switch(p.bSubheader) {
|
|
case SUBHEADER_GC_CATCH_KING_EVENT_INFO: {
|
|
if(packetSize<=0) { fail(1);break; }
|
|
uint8_t isEnable;
|
|
if(!Read(1,&isEnable)) return false;
|
|
PyCallClassMemberFunc(game,"MiniGameCatchKingEvent",Py_BuildValue("(b)",int(isEnable)));
|
|
break;
|
|
}
|
|
case SUBHEADER_GC_CATCH_KING_START: {
|
|
if(packetSize<=0) { fail(2);break; }
|
|
uint32_t bigScore;
|
|
if(!Read(4,&bigScore)) return false;
|
|
PyCallClassMemberFunc(game,"MiniGameCatchKingEventStart",Py_BuildValue("(i)",int(bigScore)));
|
|
break;
|
|
}
|
|
case SUBHEADER_GC_CATCH_KING_SET_CARD: {
|
|
if(packetSize<=0) { fail(3);break; }
|
|
uint8_t card;
|
|
if(!Read(1,&card)) return false;
|
|
PyCallClassMemberFunc(game,"MiniGameCatchKingSetHandCard",Py_BuildValue("(i)",int(card)));
|
|
break;
|
|
}
|
|
case SUBHEADER_GC_CATCH_KING_RESULT_FIELD: {
|
|
if(packetSize<=0) { fail(4);break; }
|
|
TSubPacketGCCatchKingResult r;
|
|
if(!Read(sizeof(r),&r)) return false;
|
|
PyCallClassMemberFunc(game,"MiniGameCatchKingResultField",Py_BuildValue("(iiiibbbb)",int(r.dwPoints),int(r.bRowType),int(r.bCardPos),int(r.bCardValue),
|
|
int(r.bKeepFieldCard),int(r.bDestroyHandCard),int(r.bGetReward),int(r.bIsFiveNearBy)));
|
|
break;
|
|
}
|
|
case SUBHEADER_GC_CATCH_KING_SET_END_CARD: {
|
|
if(packetSize<=0) { fail(5);break; }
|
|
uint8_t card[2];
|
|
if(!Read(2,card)) return false;
|
|
PyCallClassMemberFunc(game,"MiniGameCatchKingSetEndCard",Py_BuildValue("(ii)",int(card[0]),int(card[1])));
|
|
break;
|
|
}
|
|
case SUBHEADER_GC_CATCH_KING_REWARD: {
|
|
if(packetSize<=0) { fail(6);break; }
|
|
uint8_t code;
|
|
if(!Read(1,&code)) return false;
|
|
PyCallClassMemberFunc(game,"MiniGameCatchKingReward",Py_BuildValue("(i)",int(code)));
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::Recv67AttrOpenPacket() {
|
|
TPacketGCBlank p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
PyCallClassMemberFunc(m_phaseWindows[5],"OpenAttr67AddDlg",Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvCheatBlacklist() {
|
|
TPacketGCCheatBlacklist p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
return true; // CAnticheatManager::ParseCheatBlacklist: anticheat is not ported.
|
|
}
|
|
|
|
// PythonNetworkStreamPhaseHandShake.cpp
|
|
bool PythonNetworkStream::RecvHandshakePacket() {
|
|
TPacketGCHandshake p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
m_changeServerTime=p.dwTime+uint32_t(p.lDelta);
|
|
m_changeClientTime=GetLocalMSec();
|
|
p.dwTime=p.dwTime+uint32_t(p.lDelta)+uint32_t(p.lDelta);
|
|
p.lDelta=0;
|
|
p.bHeader=HEADER_CG_TIME_SYNC;
|
|
Send(&p,sizeof(p)); // + SendSequence
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvHandshakeOKPacket() {
|
|
TPacketGCBlank p;
|
|
if(!Read(sizeof(p),&p)) return false;
|
|
// Bootstrap may already have completed the initial handshake. An OK without
|
|
// a native handshake must retain its synchronized clock, not use host uptime.
|
|
if(m_changeClientTime!=0) {
|
|
const uint32_t delta=GetLocalMSec()-m_changeClientTime;
|
|
SetServerMSec(m_changeServerTime+delta);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace ava2
|
|
|
|
namespace ava2 {
|
|
bool PythonNetworkStream::RecvOfflineShopPacket() {
|
|
TPacketGCShop header;if(!Read(sizeof(header),&header)||header.size<sizeof(header))return false;
|
|
size_t remaining=header.size-sizeof(header);
|
|
auto read=[&](void* data,size_t size) {if(size>remaining||!Read(size,data))return false;remaining-=size;return true;};
|
|
auto& state=GetOfflineShopState();
|
|
auto call=[&](const char* method,PyObject* args) {PyCallClassMemberFunc(m_phaseWindows[5],method,args);};
|
|
auto log=[&](const char* method,const TShopLog& entry) {
|
|
if(entry.price)call(method,Py_BuildValue("(ssiiL)",text(entry.name).c_str(),text(entry.date).c_str(),int32_t(entry.itemVnum),int32_t(entry.itemCount),static_cast<long long>(entry.price)));
|
|
};
|
|
// AVA2 reads these six scalar payloads directly; all other cases consume the declared payload first.
|
|
switch(header.subheader) {
|
|
case SHOP_SUBHEADER_GC_REFRESH_MONEY:
|
|
if(!read(&state.money,8))return false;break;
|
|
case SHOP_SUBHEADER_GC_CHECK_RESULT: {
|
|
uint8_t has;if(!read(&has,1))return false;state.hasShop=has==1;return true;
|
|
}
|
|
case SHOP_SUBHEADER_GC_REFRESH_DISPLAY_COUNT:
|
|
if(!read(&state.displayed,4))return false;break;
|
|
case SHOP_SUBHEADER_GC_REALWATCHER_COUNT:
|
|
if(!read(&state.watchers,4))return false;break;
|
|
case SHOP_SUBHEADER_GC_REFRESH_COUNT: {
|
|
uint32_t counts[2];if(!read(counts,8))return false;state.displayed=counts[0];state.watchers=counts[1];break;
|
|
}
|
|
case SHOP_SUBHEADER_GC_CHANGE_TITLE: {
|
|
char sign[46];if(!read(sign,sizeof(sign)))return false;state.sign=text(sign);break;
|
|
}
|
|
default: {
|
|
std::vector<uint8_t> payload(remaining);if(remaining&&!read(payload.data(),remaining))return false;
|
|
switch(header.subheader) {
|
|
case SHOP_SUBHEADER_GC_START: {
|
|
TPacketGCOfflineShopStart packet;if(payload.size()<sizeof(packet))return false;
|
|
std::memcpy(&packet,payload.data(),sizeof(packet));ClearShopState();
|
|
for(unsigned i=0;i<80;++i)state.SetItem(i,packet.items[i]);
|
|
state.displayed=packet.m_dwDisplayedCount;state.watchers=packet.m_dwRealWatcherCount;state.money=packet.price;
|
|
state.sign=text(packet.title);state.flag=packet.flag;state.type=packet.type;state.time=packet.time;
|
|
call("ClearOfflineShopLog",Py_BuildValue("()"));
|
|
for(int i=79;i>=0;--i)log("AppendShopLog",packet.log[i]);
|
|
call("StartOfflineShop",Py_BuildValue("(ii)",int32_t(packet.owner_vid),packet.IsOwner!=0));return true;
|
|
}
|
|
case SHOP_SUBHEADER_GC_END:
|
|
ClearShopState();call("ClearOfflineShopLog",Py_BuildValue("()"));call("EndOfflineShop",Py_BuildValue("()"));return true;
|
|
case SHOP_SUBHEADER_GC_UPDATE_ITEM: {
|
|
TPacketGCOfflineShopUpdateItem packet;if(payload.size()<sizeof(packet))return false;
|
|
std::memcpy(&packet,payload.data(),sizeof(packet));
|
|
state.displayed=packet.m_dwDisplayedCount;state.watchers=packet.m_dwRealWatcherCount;state.flag=packet.flag;
|
|
state.time=packet.time;state.sign=text(packet.title);state.type=packet.type;state.SetItem(packet.pos,packet.item);state.money=packet.price;
|
|
log("AppendShopLogFirst",packet.log);break;
|
|
}
|
|
case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY:call("OnShopError",Py_BuildValue("(s)","NOT_ENOUGH_MONEY"));return true;
|
|
case SHOP_SUBHEADER_GC_SOLD_OUT:call("OnShopError",Py_BuildValue("(s)","SOLDOUT"));return true;
|
|
case SHOP_SUBHEADER_GC_INVENTORY_FULL:call("OnShopError",Py_BuildValue("(s)","INVENTORY_FULL"));return true;
|
|
case SHOP_SUBHEADER_GC_INVALID_POS:call("OnShopError",Py_BuildValue("(s)","INVALID_POS"));return true;
|
|
case SHOP_SUBHEADER_GC_NOT_ENOUGH_LUCKY:call("OnShopError",Py_BuildValue("(s)","NOT_ENOUGH_LUCKY"));return true;
|
|
case SHOP_SUBHEADER_GC_OK:return true;
|
|
default:trace_error("RecvOfflineShopPacket: unknown subheader "+std::to_string(header.subheader));return true;
|
|
}
|
|
}
|
|
}
|
|
call("RefreshOfflineShop",Py_BuildValue("()"));return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvPingPacket() {
|
|
TPacketGCPing packet;
|
|
if (!Read(sizeof(packet), &packet)) return false;
|
|
TPacketCGPong pong;
|
|
pong.bHeader = HEADER_CG_PONG;
|
|
Send(&pong, sizeof(pong));
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvObserverAddPacket() {
|
|
TPacketGCObserverAdd packet;
|
|
if (!Read(sizeof(packet), &packet)) return false;
|
|
CPythonMiniMap::Instance().AddObserver(packet.vid, packet.x * 100.0f, packet.y * 100.0f);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvObserverRemovePacket() {
|
|
TPacketGCObserverAdd packet;
|
|
if (!Read(sizeof(packet), &packet)) return false;
|
|
CPythonMiniMap::Instance().RemoveObserver(packet.vid);
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::RecvObserverMovePacket() {
|
|
TPacketGCObserverMove packet;
|
|
if (!Read(sizeof(packet), &packet)) return false;
|
|
CPythonMiniMap::Instance().MoveObserver(packet.vid, packet.x * 100.0f, packet.y * 100.0f);
|
|
return true;
|
|
}
|
|
}
|
|
|