// 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 #include namespace ava2 { namespace { void trace_error(const std::string& text) { std::cerr<<"[AVA2 TraceError] "< 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.sizeremaining||!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(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(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 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(r.itemPrice),int(r.discount),r.offerTime,r.topSellingIndex,r.addedTime,static_cast(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(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(r.itemPrice),int(r.discount),r.offerTime,r.topSellingIndex,r.addedTime,static_cast(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;j0) { std::vector 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;im_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 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=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.sizeremaining||!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;isecond.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;igrade=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.sizeremaining || !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;jm_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;im_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 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;im_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;i0;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()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 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.sizeremaining||!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(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 payload(remaining);if(remaining&&!read(payload.data(),remaining))return false; switch(header.subheader) { case SHOP_SUBHEADER_GC_START: { TPacketGCOfflineShopStart packet;if(payload.size()=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()