Files
AVA2/src/eter_net/PythonNetworkStreamPhaseGameRecv.cpp
T
shenleiandClaude Haiku 5.5 31c5b3dd9b Net: show damage numbers through the actor damage queue
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>
2026-10-13 21:50:50 +09:00

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;
}
}