#include "item_sound.h" #include "PythonNetworkStream.h" #include "python_net.h" #include "guild_state.h" #include "switchbot_state.h" #include "protocol.h" #include "shared/common/PythonUtils.h" #include "nonplayer_data.h" #include "python_app.h" #include "python_gameplay_modules.h" #include "python_chat.h" #include "python_native_modules.h" #include "PythonExchange.h" #include "PythonSafeBox.h" #include "eter_render/FloatingTextManager.h" #include "eter_render/TextTailManager.h" #include "eter_sound/SoundManager.h" #include "eter_effect/EffectManager.h" #include "eter_effect/FlyingManager.h" #include #include #include #include #include namespace ava2 { PythonNetworkStream& PythonNetworkStream::Instance() { static PythonNetworkStream s_stream; return s_stream; } PythonNetworkStream::PythonNetworkStream() { for (int i = 0; i < 7; ++i) { m_phaseWindows[i] = nullptr; } } PythonNetworkStream::~PythonNetworkStream() { if (Py_IsInitialized()) { if (m_poHandler) { Py_DECREF(m_poHandler); m_poHandler = nullptr; } for (int i = 0; i < 7; ++i) { if (m_phaseWindows[i]) { Py_DECREF(m_phaseWindows[i]); m_phaseWindows[i] = nullptr; } } } } void PythonNetworkStream::SetPhaseWindow(int phase, PyObject* poWindow) { if (phase >= 0 && phase < 7) { Py_XINCREF(poWindow); auto* previous=m_phaseWindows[phase]; m_phaseWindows[phase] = poWindow; Py_XDECREF(previous); } } void PythonNetworkStream::ClearPhaseWindow(int phase, PyObject* poWindow) { if (phase >= 0 && phase < 7) { if (m_phaseWindows[phase] == poWindow) { auto* previous=m_phaseWindows[phase]; m_phaseWindows[phase] = nullptr; Py_XDECREF(previous); } } } void PythonNetworkStream::SetHandler(PyObject* poHandler) { Py_XINCREF(poHandler); auto* previous=m_poHandler; m_poHandler = poHandler; Py_XDECREF(previous); } void PythonNetworkStream::SetPhase(EPhase phase) { m_phase = phase; } void PythonNetworkStream::StartGame() { m_startGameRequested=true; } void PythonNetworkStream::ResetConnection() { m_recvBuffer.clear();m_unportedPackets.clear();m_unknownPacketQuit=false;m_isObserverMode=m_bMobileFlag=false;std::memset(m_lastPacket,0,sizeof(m_lastPacket));ClearSendQueue();m_startGameRequested=m_refreshInventory=m_refreshStatus=m_refreshSkill=m_refreshCharacter=m_refreshShopSearch=m_stopGamePhase=false; m_refreshGuildInfo=m_refreshGuildBoard=m_refreshGuildMember=m_refreshGuildCombo=m_refreshGuildSkill=m_refreshGuildGrade=m_refreshMessenger=false; m_guildID=0; m_changeServerTime=m_changeClientTime=0;m_dungeonDestination={}; ResetPlayerState();NetworkActorManager::Instance().Clear(); m_pendingActorData={};m_strFieldMusicFileName.clear();m_fFieldMusicVolume=0.02f; m_phase=PHASE_OFFLINE;m_dwMainActorVID=0;m_wMainActorRace=0; m_byMainActorEmpire=m_byMainActorSkillGroup=0;m_strMainActorName.clear(); } std::vector> PythonNetworkStream::PopSendPackets() { auto packets=std::move(m_sendPackets);m_sendPackets.clear();m_sendSequence.clear();m_sendBuffer.clear();return packets; } std::vector,bool>> PythonNetworkStream::PopSendPacketsWithSequence() { std::vector,bool>> packets; for(size_t i=0;isecond); } void PythonNetworkStream::SetMainActorVID(uint32_t vid) { m_dwMainActorVID = vid; NetworkActorManager::Instance().SetMainActorVID(vid); } void PythonNetworkStream::PushRecvData(const uint8_t* data, size_t len) { if (data && len > 0) { if(len>128*1024 || m_recvBuffer.size()>128*1024-len) throw std::runtime_error("game receive buffer limit exceeded"); m_recvBuffer.insert(m_recvBuffer.end(), data, data + len); } } void PythonNetworkStream::PushRecvData(const std::vector& bytes) { if (!bytes.empty()) { if(bytes.size()>128*1024 || m_recvBuffer.size()>128*1024-bytes.size()) throw std::runtime_error("game receive buffer limit exceeded"); m_recvBuffer.insert(m_recvBuffer.end(), bytes.begin(), bytes.end()); } } bool PythonNetworkStream::Peek(size_t size, void* outBuf) { if (m_recvBuffer.size() < size) return false; std::memcpy(outBuf, m_recvBuffer.data(), size); return true; } bool PythonNetworkStream::Read(size_t size, void* outBuf) { if (m_recvBuffer.size() < size) return false; std::memcpy(outBuf, m_recvBuffer.data(), size); m_recvBuffer.erase(m_recvBuffer.begin(), m_recvBuffer.begin() + size); return true; } void PythonNetworkStream::Send(const void* data, size_t size) { if (data && size > 0) { if(size>65535 || m_sendBuffer.size()>128*1024-size) throw std::runtime_error("game send queue limit exceeded"); const uint8_t* bytes = static_cast(data); m_sendBuffer.insert(m_sendBuffer.end(), bytes, bytes + size); m_sendPackets.emplace_back(bytes,bytes+size); m_sendSequence.push_back(true); } } void PythonNetworkStream::SendUnsequenced(const void* data, size_t size) { const size_t count=m_sendPackets.size(); Send(data,size); if(m_sendPackets.size()>count) m_sendSequence.back()=false; } std::vector PythonNetworkStream::PopSendBytes() { std::vector result = std::move(m_sendBuffer); m_sendBuffer.clear();m_sendPackets.clear();m_sendSequence.clear(); return result; } namespace { void inventory_callback(PyObject*,const char*,PyObject*); // CMainPacketHeaderMap + GamePhase() case labels, generated from the Windows reference. struct GcPacketType { uint8_t header; uint32_t size; bool dynamic, mapped, gameHandled; }; constexpr GcPacketType kGcPacketTable[] = { #include "Ava2GcPacketTable.inc" }; const GcPacketType* gc_packet_type(uint8_t header) { for(const auto& type:kGcPacketTable) if(type.header==header) return &type; return nullptr; } void trace_error(const std::string& text) { std::cerr<<"[AVA2 TraceError] "<mapped) { trace_error("Unknown packet header: "+std::to_string(header)+", last: "+std::to_string(m_lastPacket[0])+" "+std::to_string(m_lastPacket[1])); m_recvBuffer.clear(); m_unknownPacketQuit=true; // Windows: PostQuitMessage(0) return false; } size_t need=type->size; if(type->dynamic) { if(m_recvBuffer.size()<3) return false; need=size_t(m_recvBuffer[1])|size_t(m_recvBuffer[2])<<8; } if(m_recvBuffer.size()gameHandled) { // Windows has a GamePhase handler that is not ported yet: consume exactly // this packet instead of stalling the stream. size_t size=type->dynamic?(size_t(m_recvBuffer[1])|size_t(m_recvBuffer[2])<<8):type->size; if(size==0) size=1; m_unportedPackets.push_back(header); m_recvBuffer.erase(m_recvBuffer.begin(),m_recvBuffer.begin()+std::min(size,m_recvBuffer.size())); } else { // RecvDefaultPacket trace_error("Unprocessed packet header "+std::to_string(header)+", state Game"); m_recvBuffer.clear(); } progress = true; if(m_stopGamePhase) { m_stopGamePhase=false;return progress; } } // GamePhase() refresh block order: Character, (Equipment), Inventory, (Exchange), Skill, ..., Status. if(m_refreshCharacter) { m_refreshCharacter=false;inventory_callback(m_phaseWindows[5],"RefreshCharacter",nullptr); } if(m_refreshInventory) { m_refreshInventory=false;inventory_callback(m_phaseWindows[5],"RefreshInventory",nullptr); } if(m_refreshSkill) {m_refreshSkill=false;inventory_callback(m_phaseWindows[5],"RefreshSkill",nullptr);} if(m_refreshStatus) { m_refreshStatus=false;inventory_callback(m_phaseWindows[5],"RefreshStatus",nullptr); } if(m_refreshMessenger) { m_refreshMessenger=false;inventory_callback(m_phaseWindows[5],"RefreshMessenger",nullptr); } if(m_refreshGuildInfo) { m_refreshGuildInfo=false;inventory_callback(m_phaseWindows[5],"RefreshGuildInfoPage",nullptr); } if(m_refreshGuildBoard) { m_refreshGuildBoard=false;inventory_callback(m_phaseWindows[5],"RefreshGuildBoardPage",nullptr); } if(m_refreshGuildMember) { m_refreshGuildMember=false;inventory_callback(m_phaseWindows[5],"RefreshGuildMemberPage",nullptr); } if(m_refreshGuildCombo) { m_refreshGuildCombo=false;inventory_callback(m_phaseWindows[5],"RefreshGuildMemberPageGradeComboBox",nullptr); } if(m_refreshGuildSkill) { m_refreshGuildSkill=false;inventory_callback(m_phaseWindows[5],"RefreshGuildSkillPage",nullptr); } if(m_refreshGuildGrade) { m_refreshGuildGrade=false;inventory_callback(m_phaseWindows[5],"RefreshGuildGradePage",nullptr); } if(m_refreshShopSearch) { m_refreshShopSearch=false;inventory_callback(m_phaseWindows[5],"RefreshShopSearch",nullptr); } return progress; } bool PythonNetworkStream::DispatchGamePhasePacket(uint8_t header,bool& ret) { m_dispatchUnported=false; ret=DispatchPortedGamePhasePacket(header); return !m_dispatchUnported; } bool PythonNetworkStream::DispatchPortedGamePhasePacket(uint8_t header) { switch (header) { case HEADER_GC_PING: return RecvPingPacket(); case HEADER_GC_PHASE: return RecvPhasePacket(); case HEADER_GC_SHOP: return RecvShopPacket(); case HEADER_GC_OFFLINE_SHOP: return RecvOfflineShopPacket(); case HEADER_GC_MAIN_CHARACTER: return RecvMainCharacter(); case HEADER_GC_MAIN_CHARACTER2_EMPIRE: return RecvMainCharacter2Empire(); case HEADER_GC_MAIN_CHARACTER3_BGM: return RecvMainCharacter3BGM(); case HEADER_GC_MAIN_CHARACTER4_BGM_VOL: return RecvMainCharacter4BGMVolume(); case HEADER_GC_TIME: return RecvTimePacket(); case HEADER_GC_AFFECT_ADD: return RecvAffectAddPacket(); case HEADER_GC_AFFECT_REMOVE: return RecvAffectRemovePacket(); case HEADER_GC_SKILL_LEVEL: return RecvSkillLevel(); case HEADER_GC_SKILL_LEVEL_NEW: return RecvSkillLevelNew(); case HEADER_GC_PLAYER_POINTS: return RecvPlayerPoints(); case HEADER_GC_CHARACTER_ADD: return RecvCharacterAppendPacket(); case HEADER_GC_CHARACTER_ADD2: return RecvCharacterAppendPacketNew(); case HEADER_GC_CHARACTER_UPDATE2: return RecvCharacterUpdatePacketNew(); case HEADER_GC_CHAR_ADDITIONAL_INFO: return RecvCharacterAdditionalInfo(); case HEADER_GC_CHARACTER_UPDATE: return RecvCharacterUpdatePacket(); case HEADER_GC_CHARACTER_DEL: return RecvCharacterDeletePacket(); case HEADER_GC_CHARACTER_MOVE: return RecvCharacterMovePacket(); case HEADER_GC_SYNC_POSITION: return RecvSyncPositionPacket(); case HEADER_GC_CHAT: return RecvChatPacket(); case HEADER_GC_WHISPER: return RecvWhisperPacket(); case HEADER_GC_DAMAGE_INFO: return RecvDamageInfoPacket(); case HEADER_GC_STUN: return RecvStunPacket(); case HEADER_GC_DEAD: return RecvDeadPacket(); case HEADER_GC_PLAYER_POINT_CHANGE: return RecvPointChange(); case HEADER_GC_ITEM_SET: return RecvItemSetPacket(); case HEADER_GC_ITEM_SET2: return RecvItemSetPacket2(); case HEADER_GC_ITEM_UPDATE: return RecvItemUpdatePacket(); case HEADER_GC_ITEM_USE: return RecvItemUsePacket(); case HEADER_GC_ITEM_GROUND_ADD: return RecvItemGroundAddPacket(); case HEADER_GC_ITEM_GROUND_DEL: return RecvItemGroundDelPacket(); case HEADER_GC_ITEM_OWNERSHIP: return RecvItemOwnership(); case HEADER_GC_QUICKSLOT_ADD: return RecvQuickSlotAddPacket(); case HEADER_GC_QUICKSLOT_DEL: return RecvQuickSlotDelPacket(); case HEADER_GC_QUICKSLOT_SWAP: return RecvQuickSlotMovePacket(); case HEADER_GC_CREATE_FLY: return RecvCreateFlyPacket(); case HEADER_GC_WARP: return RecvWarpPacket(); case HEADER_GC_OBSERVER_ADD: return RecvObserverAddPacket(); case HEADER_GC_OBSERVER_REMOVE: return RecvObserverRemovePacket(); case HEADER_GC_OBSERVER_MOVE: return RecvObserverMovePacket(); case HEADER_GC_EXCHANGE: return RecvExchangePacket(); case HEADER_GC_SAFEBOX_SET: return RecvSafeBoxSetPacket(); case HEADER_GC_SAFEBOX_DEL: return RecvSafeBoxDelPacket(); case HEADER_GC_SAFEBOX_WRONG_PASSWORD: return RecvSafeBoxWrongPasswordPacket(); case HEADER_GC_SAFEBOX_SIZE: return RecvSafeBoxSizePacket(); case HEADER_GC_SAFEBOX_MONEY_CHANGE: return RecvSafeBoxMoneyChangePacket(); case HEADER_GC_MALL_OPEN: return RecvMallOpenPacket(); case HEADER_GC_MALL_SET: return RecvMallSetPacket(); case HEADER_GC_MALL_DEL: return RecvMallDelPacket(); case HEADER_GC_CHANGE_SPEED: return RecvChangeSpeedPacket(); case HEADER_GC_MOTION: return RecvMotionPacket(); case HEADER_GC_ITEMSHOP: return RecvItemShop(); case HEADER_GC_EVENT_MANAGER: return RecvEventManager(); case HEADER_GC_DUEL_START: return RecvDuelStartPacket(); case HEADER_GC_PVP: return RecvPVPPacket(); case HEADER_GC_CHARACTER_POSITION: return RecvCharacterPositionPacket(); case HEADER_GC_SCRIPT: return RecvScriptPacket(); case HEADER_GC_SHOPSEARCH_SET: return RecvShopSearchSet(); case HEADER_GC_CUBE_RENEWAL: return RecvCubeRenewalPacket(); case HEADER_GC_SWITCHBOT: return RecvSwitchbotPacket(); case HEADER_GC_DUNGEON_INFO_SYSTEM: return RecvDungeonInfoPacket(); case HEADER_GC_DROP_ITEM_SYSTEM: return RecvDropItemPacket(); case HEADER_GC_BATTLEPASS: return RecvBattlePassPacket(); case HEADER_GC_GUILD: return RecvGuild(); case HEADER_GC_MESSENGER: return RecvMessenger(); case HEADER_GC_QUEST_INFO: return RecvQuestInfoPacket(); case HEADER_GC_QUEST_CONFIRM: return RecvQuestConfirmPacket(); case HEADER_GC_OFFLINE_SHOP_SIGN: return RecvOfflineShopSignPacket(); case HEADER_GC_TARGET_INFO: return RecvTargetInfoPacket(); case HEADER_GC_MOUNT: return RecvMountPacket(); case HEADER_GC_OWNERSHIP: return RecvOwnerShipPacket(); case HEADER_GC_TARGET: return RecvTargetPacket(); case HEADER_GC_CHESTDROP: return RecvChestDrop(); case HEADER_GC_KILL_LOG: return RecvKillLOG(); case HEADER_GC_ADD_FLY_TARGETING: return RecvFlyTargetingPacket(true); case HEADER_GC_FLY_TARGETING: return RecvFlyTargetingPacket(false); case HEADER_GC_PARTY_INVITE: return RecvPartyInvite(); case HEADER_GC_PARTY_ADD: return RecvPartyAdd(); case HEADER_GC_PARTY_UPDATE: return RecvPartyUpdate(); case HEADER_GC_PARTY_REMOVE: return RecvPartyRemove(); case HEADER_GC_REQUEST_MAKE_GUILD: return RecvRequestMakeGuild(); case HEADER_GC_PARTY_PARAMETER: return RecvPartyParameter(); case HEADER_GC_FISHING: return RecvFishing(); case HEADER_GC_PARTY_LINK: return RecvPartyLink(); case HEADER_GC_PARTY_UNLINK: return RecvPartyUnlink(); case HEADER_GC_REFINE_INFORMATION: return RecvRefineInformationPacket(); case HEADER_GC_REFINE_INFORMATION_NEW: return RecvRefineInformationPacketNew(); case HEADER_GC_VIEW_EQUIP: return RecvViewEquipPacket(); case HEADER_GC_DUNGEON: return RecvDungeon(); case HEADER_GC_WALK_MODE: return RecvWalkModePacket(); case HEADER_GC_CHANGE_SKILL_GROUP: return RecvChangeSkillGroupPacket(); case HEADER_GC_SEPCIAL_EFFECT: return RecvSpecialEffect(); case HEADER_GC_NPC_POSITION: return RecvNPCList(); case HEADER_GC_CHANNEL: return RecvChannelPacket(); case HEADER_GC_TARGET_UPDATE: return RecvTargetUpdatePacket(); case HEADER_GC_TARGET_DELETE: return RecvTargetDeletePacket(); case HEADER_GC_TARGET_CREATE_NEW: return RecvTargetCreatePacketNew(); case HEADER_GC_LAND_LIST: return RecvLandPacket(); case HEADER_GC_LOVER_INFO: return RecvLoverInfoPacket(); case HEADER_GC_LOVE_POINT_UPDATE: return RecvLovePointUpdatePacket(); case HEADER_GC_DIG_MOTION: return RecvDigMotionPacket(); case HEADER_GC_BANK: return RecvAccountBankPacket(); case HEADER_GC_HS_REQUEST: return RecvHSCheckRequest(); case HEADER_GC_XTRAP_CS1_REQUEST: return RecvXTrapVerifyRequest(); case HEADER_GC_SPECIFIC_EFFECT: return RecvSpecificEffect(); case HEADER_GC_DRAGON_SOUL_REFINE: return RecvDragonSoulRefine(); case HEADER_GC_UNK_213: return RecvUnk213(); case HEADER_GC_CALENDAR_SYSTEM: return RecvCalendarSystem(); case HEADER_GC_SASH: return RecvSashPacket(); case HEADER_GC_CALENDAR_SYSTEM_ADM: return RecvCalendarSystemADM(); case HEADER_GC_KINGDOMSWAR: return RecvKingdomsWarPacket(); case HEADER_GC_SUNGMA_ATTR_UPDATE: return RecvSungmaAttrUpdatePacket(); case HEADER_GC_EXCHANGE_LOG: return RecvExchangeLog(); case HEADER_GC_MINI_GAME_CATCH_KING: return RecvMiniGameCatchKingPacket(); case HEADER_GC_OPEN_67_ATTR: return Recv67AttrOpenPacket(); case HEADER_GC_CHEAT_BLACKLIST: return RecvCheatBlacklist(); // GamePhase() `return`s after these four: the rest of the buffer and the refresh // block wait for the next frame, and the handler result is ignored. case HEADER_GC_HANDSHAKE: RecvHandshakePacket();m_stopGamePhase=true;return true; case HEADER_GC_HANDSHAKE_OK: RecvHandshakeOKPacket();m_stopGamePhase=true;return true; case HEADER_GC_HYBRIDCRYPT_KEYS: case HEADER_GC_HYBRIDCRYPT_SDB: RecvHybridCryptPacket();m_stopGamePhase=true;return true; default: m_dispatchUnported=true; return false; } } bool PythonNetworkStream::RecvPhasePacket() { TPacketGCPhase p; if (!Read(sizeof(p), &p)) return false; SetPhase(static_cast(p.phase)); return true; } bool PythonNetworkStream::RecvMainCharacter() { TPacketGCMainCharacter p; if (!Read(sizeof(p), &p)) return false; SetMainActorVID(p.dwVID); m_wMainActorRace = p.wRaceNum; m_strMainActorName.assign(p.szName,strnlen(p.szName,sizeof(p.szName))); m_byMainActorSkillGroup = p.bySkillGroup; MainCharacterLoaded(p.lX,p.lY,p.lZ); return true; } bool PythonNetworkStream::RecvMainCharacter2Empire() { TPacketGCMainCharacter2Empire p; if (!Read(sizeof(p), &p)) return false; SetMainActorVID(p.dwVID); m_wMainActorRace = p.wRaceNum; m_strMainActorName.assign(p.szName,strnlen(p.szName,sizeof(p.szName))); m_byMainActorEmpire = p.byEmpire; m_byMainActorSkillGroup = p.bySkillGroup; MainCharacterLoaded(p.lX,p.lY,p.lZ); return true; } bool PythonNetworkStream::RecvMainCharacter3BGM() { TPacketGCMainCharacter3BGM p; if (!Read(sizeof(p), &p)) return false; SetMainActorVID(p.dwVID); m_wMainActorRace = p.wRaceNum; m_strMainActorName.assign(p.szUserName,strnlen(p.szUserName,sizeof(p.szUserName))); m_strFieldMusicFileName.assign(p.szBGMName,strnlen(p.szBGMName,sizeof(p.szBGMName))); m_byMainActorEmpire = p.byEmpire; m_byMainActorSkillGroup = p.bySkillGroup; MainCharacterLoaded(p.lX,p.lY,p.lZ); return true; } void PythonNetworkStream::MainCharacterLoaded(int32_t x,int32_t y,int32_t z) { WarpBackgroundMap(uint32_t(x),uint32_t(y)); int32_t localX=x,localY=y; GlobalToLocalPosition(localX,localY); SetMainCharacterName(m_strMainActorName);SetMainCharacterPosition(localX,localY,z); inventory_callback(m_phaseWindows[4],"LoadData",Py_BuildValue("ii",x,y)); std::vector version(67,0);version[0]=HEADER_CG_CLIENT_VERSION2; std::copy_n(m_clientFilename.data(),std::min(size_t(32),m_clientFilename.size()),version.data()+1); const std::string timestamp="1215955205"; std::copy(timestamp.begin(),timestamp.end(),version.begin()+34); Send(version.data(),version.size()); } bool PythonNetworkStream::RecvMainCharacter4BGMVolume() { TPacketGCMainCharacter4BGMVolume p; if(!Read(sizeof(p),&p)) return false; SetMainActorVID(p.dwVID);m_wMainActorRace=p.wRaceNum; m_strMainActorName.assign(p.szUserName,strnlen(p.szUserName,sizeof(p.szUserName))); m_strFieldMusicFileName.assign(p.szBGMName,strnlen(p.szBGMName,sizeof(p.szBGMName))); m_fFieldMusicVolume=p.fBGMVol;m_byMainActorEmpire=p.byEmpire;m_byMainActorSkillGroup=p.bySkillGroup; MainCharacterLoaded(p.lX,p.lY,p.lZ);return true; } bool PythonNetworkStream::RecvTimePacket() { TPacketGCTime p;if(!Read(sizeof(p),&p)) return false;SetServerTime(p.time);return true; } bool PythonNetworkStream::RecvPlayerPoints() { TPacketGCPoints p;if(!Read(sizeof(p),&p)) return false; for(int i=0;i<255;++i) SetPlayerStatusPoint(i,p.points[i]); m_refreshStatus=true;return true; } bool PythonNetworkStream::RecvAffectAddPacket() { TPacketGCAffectAdd p;if(!Read(sizeof(p),&p)) return false; const auto& elem=p.elem; if(elem.bPointIdxApplyOn==128) { // AVA2 POINT_ENERGY / POINT_ENERGY_END_TIME. uint32_t end=uint32_t(GetServerTimeStamp())+uint32_t(elem.lDuration); SetPlayerStatusPoint(129,std::bit_cast(end));m_refreshStatus=true; } inventory_callback(m_phaseWindows[5],"BINARY_NEW_AddAffect",Py_BuildValue("iiii",std::bit_cast(elem.dwType),int(elem.bPointIdxApplyOn),elem.lApplyValue,elem.lDuration)); return true; } bool PythonNetworkStream::RecvAffectRemovePacket() { TPacketGCAffectRemove p;if(!Read(sizeof(p),&p)) return false; inventory_callback(m_phaseWindows[5],"BINARY_NEW_RemoveAffect",Py_BuildValue("ii",std::bit_cast(p.dwType),int(p.bApplyOn)));return true; } bool PythonNetworkStream::RecvSkillLevel() { TPacketGCSkillLevel p;if(!Read(sizeof(p),&p)) return false; for(int i=0;i<255;++i) SetPlayerLegacySkillLevel(i,p.abSkillLevels[i]); m_refreshSkill=m_refreshStatus=true;return true; } bool PythonNetworkStream::RecvSkillLevelNew() { TPacketGCSkillLevelNew p;if(!Read(sizeof(p),&p)) return false; SetPlayerSkill(7,0);SetPlayerSkill(8,0); for(int i=0;i<255;++i) { if(p.skills[i].bLevel) { if((i>=221 && i<=228) || (i>=112 && i<=115)) SetPlayerSkill(7,i); if((i>=236 && i<=243) || (i>=116 && i<=119)) SetPlayerSkill(8,i); } SetPlayerSkillLevel(i,p.skills[i].bMasterType,p.skills[i].bLevel); } m_refreshSkill=m_refreshStatus=true;return true; } bool PythonNetworkStream::RecvCharacterAppendPacket() { TPacketGCCharacterAdd p; if (!Read(sizeof(p), &p)) return false; GlobalToLocalPosition(p.x,p.y); m_pendingActorData = SNetworkActorData{}; m_pendingActorData.m_dwVID = p.dwVID; m_pendingActorData.m_fRot = p.angle; m_pendingActorData.m_lCurX = p.x; m_pendingActorData.m_lCurY = p.y; m_pendingActorData.m_lCurZ = p.z; m_pendingActorData.m_bType = p.bType; m_pendingActorData.m_dwRace = p.wRaceNum; m_pendingActorData.m_dwMovSpd = static_cast(p.bMovingSpeed); m_pendingActorData.m_dwAtkSpd = p.bAttackSpeed; m_pendingActorData.m_dwStateFlags = p.bStateFlag; std::copy_n(p.dwAffectFlag, 2, m_pendingActorData.m_affectFlags); // For non-player entities that don't need AdditionalInfo, append immediately if (p.bType != 6 && p.bType != 1 && p.bType != 10) { // Windows: PC, NPC and pet require additional info GetNonPlayerName(p.wRaceNum,m_pendingActorData.m_stName); NetworkActorManager::Instance().AppendActor(m_pendingActorData); } return true; } bool PythonNetworkStream::RecvCharacterAppendPacketNew() { TPacketGCCharacterAdd2 p; if (!Read(sizeof(p), &p)) return false; if (p.wRaceNum==20025 || p.wRaceNum==20038 || p.wRaceNum==20039) return true; GlobalToLocalPosition(p.x,p.y); SNetworkActorData data{}; data.m_dwVID=p.dwVID; data.m_bType=p.bType; data.m_dwRace=p.wRaceNum; if(p.bType==1 && UseNonPlayerName(p.wRaceNum)) GetNonPlayerName(p.wRaceNum,data.m_stName); else data.m_stName.assign(p.name, strnlen(p.name,sizeof(p.name))); data.m_fRot=p.angle; data.m_lCurX=p.x; data.m_lCurY=p.y; data.m_lCurZ=p.z; data.m_dwArmor=p.awPart[CHR_EQUIPPART_ARMOR]; data.m_dwWeapon=p.awPart[CHR_EQUIPPART_WEAPON]; data.m_dwHair=p.awPart[CHR_EQUIPPART_HAIR]; data.m_dwSash=p.awPart[CHR_EQUIPPART_SASH]; data.m_dwArrowType=p.awPart[CHR_PART_ARROW_TYPE]; data.m_dwMovSpd=p.bMovingSpeed; data.m_dwAtkSpd=p.bAttackSpeed; data.m_dwStateFlags=p.bStateFlag; std::copy_n(p.dwAffectFlag,2,data.m_affectFlags); data.m_dwEmpireID=p.bEmpire; data.m_dwGuildID=p.dwGuild; data.m_sAlignment=p.sAlignment; data.m_byPKMode=p.bPKMode; data.m_dwMountVnum=p.dwMountVnum; NetworkActorManager::Instance().AppendActor(data); if(data.m_dwVID==m_dwMainActorVID)SetGuildID(data.m_dwGuildID); return true; } bool PythonNetworkStream::RecvCharacterAdditionalInfo() { TPacketGCCharacterAdditionalInfo p; if (!Read(sizeof(p), &p)) return false; SNetworkActorData actorData = m_pendingActorData; if (actorData.m_dwRace==20025 || actorData.m_dwRace==20038 || actorData.m_dwRace==20039) return true; if (actorData.m_dwVID != p.dwVID) { return true; // Windows ignores unmatched additional-info packets. } if(actorData.m_bType==1 && UseNonPlayerName(actorData.m_dwRace)) GetNonPlayerName(actorData.m_dwRace,actorData.m_stName); else actorData.m_stName.assign(p.name, strnlen(p.name, sizeof(p.name))); actorData.m_dwConquerorLevel = p.dwConquerorLevel; actorData.m_language = p.language; actorData.m_dwArrowType = p.awPart[CHR_PART_ARROW_TYPE]; std::copy_n(p.adwShining, CHR_SHINING_NUM, actorData.m_shining); actorData.m_dwArmor = p.awPart[CHR_EQUIPPART_ARMOR]; actorData.m_dwWeapon = p.awPart[CHR_EQUIPPART_WEAPON]; actorData.m_dwHair = p.awPart[CHR_EQUIPPART_HAIR]; actorData.m_dwSash = p.awPart[CHR_EQUIPPART_SASH]; actorData.m_dwEmpireID = p.bEmpire; actorData.m_dwGuildID = p.dwGuildID; actorData.m_dwLevel = p.dwLevel; actorData.m_sAlignment = p.sAlignment; actorData.m_byPKMode = p.bPKMode; actorData.m_dwMountVnum = p.dwMountVnum; NetworkActorManager::Instance().AppendActor(actorData); if(actorData.m_dwVID==m_dwMainActorVID)SetGuildID(actorData.m_dwGuildID); return true; } bool PythonNetworkStream::RecvCharacterUpdatePacket() { TPacketGCCharacterUpdate p; if (!Read(sizeof(p), &p)) return false; SNetworkUpdateActorData upd; upd.m_dwVID = p.dwVID; upd.m_dwSash = p.awPart[CHR_EQUIPPART_SASH]; upd.m_dwArrowType = p.awPart[CHR_PART_ARROW_TYPE]; upd.m_dwConquerorLevel = p.dwConquerorLevel; upd.m_dwStateFlags = p.bStateFlag; std::copy_n(p.dwAffectFlag, 2, upd.m_affectFlags); std::copy_n(p.adwShining, CHR_SHINING_NUM, upd.m_shining); upd.m_dwArmor = p.awPart[CHR_EQUIPPART_ARMOR]; upd.m_dwWeapon = p.awPart[CHR_EQUIPPART_WEAPON]; upd.m_dwHair = p.awPart[CHR_EQUIPPART_HAIR]; upd.m_dwGuildID = p.dwGuildID; upd.m_sAlignment = p.sAlignment; upd.m_byPKMode = p.bPKMode; upd.m_dwMountVnum = p.dwMountVnum; upd.m_dwMovSpd = static_cast(p.bMovingSpeed); upd.m_dwAtkSpd = p.bAttackSpeed; NetworkActorManager::Instance().UpdateActor(upd); if(upd.m_dwVID==m_dwMainActorVID)SetGuildID(upd.m_dwGuildID); return true; } bool PythonNetworkStream::RecvCharacterUpdatePacketNew() { TPacketGCCharacterUpdate2 p; if (!Read(sizeof(p), &p)) return false; SNetworkUpdateActorData upd; upd.m_dwVID = p.dwVID; upd.m_dwSash = p.awPart[CHR_EQUIPPART_SASH]; upd.m_dwArrowType = p.awPart[CHR_PART_ARROW_TYPE]; // Update2 provides no conqueror level. Windows leaves this member uninitialized; // preserve known state rather than propagate undefined data. if (auto* existing=NetworkActorManager::Instance().GetActorData(p.dwVID)) upd.m_dwConquerorLevel=existing->m_dwConquerorLevel; upd.m_dwStateFlags = p.bStateFlag; std::copy_n(p.dwAffectFlag, 2, upd.m_affectFlags); std::copy_n(p.adwShining, CHR_SHINING_NUM, upd.m_shining); upd.m_dwArmor = p.awPart[CHR_EQUIPPART_ARMOR]; upd.m_dwWeapon = p.awPart[CHR_EQUIPPART_WEAPON]; upd.m_dwHair = p.awPart[CHR_EQUIPPART_HAIR]; upd.m_dwGuildID = p.dwGuildID; upd.m_sAlignment = p.sAlignment; upd.m_byPKMode = p.bPKMode; upd.m_dwMountVnum = p.dwMountVnum; upd.m_dwMovSpd = static_cast(p.bMovingSpeed); upd.m_dwAtkSpd = p.bAttackSpeed; NetworkActorManager::Instance().UpdateActor(upd); if(upd.m_dwVID==m_dwMainActorVID)SetGuildID(upd.m_dwGuildID); return true; } bool PythonNetworkStream::RecvCharacterDeletePacket() { TPacketGCCharacterDelete p; if (!Read(sizeof(p), &p)) return false; NetworkActorManager::Instance().RemoveActor(p.dwVID); return true; } bool PythonNetworkStream::RecvCharacterMovePacket() { TPacketGCMove p; if (!Read(sizeof(p), &p)) return false; SNetworkMoveActorData mv; mv.m_dwVID = p.dwVID; mv.m_dwFunc = p.bFunc; mv.m_dwArg = p.bArg; mv.m_fRot = static_cast(p.bRot) * 5.0f; GlobalToLocalPosition(p.lX,p.lY); mv.m_lPosX = p.lX; mv.m_lPosY = p.lY; mv.m_dwTime = p.dwTime; mv.m_dwDuration = p.dwDuration; NetworkActorManager::Instance().MoveActor(mv); return true; } bool PythonNetworkStream::RecvSyncPositionPacket() { TPacketGCSyncPosition p; if (!Peek(sizeof(p), &p)) return false; if(p.wSize= CHAT_TYPE_MAX_NUM) return true; if (CHAT_TYPE_COMMAND == kChat.type) { ServerCommand(text); return true; } if (kChat.dwVID != 0) { auto& actors = NetworkActorManager::Instance(); const SNetworkActorData* chatter = actors.GetActorData(kChat.dwVID); if (!chatter) return true; std::string line; switch (kChat.type) { case CHAT_TYPE_TALKING: case CHAT_TYPE_PARTY: case CHAT_TYPE_GUILD: case CHAT_TYPE_SHOUT: case CHAT_TYPE_WHISPER: { const size_t colon = text.find(':'); // p = strchr(buf, ':') + 2 const size_t start = colon == std::string::npos ? 0 : std::min(colon + 2, text.size()); uint32_t dwEmoticon; if (ParseEmoticon(text.c_str() + start, &dwEmoticon)) { actors.SetEmoticon(kChat.dwVID, dwEmoticon); return true; } // __ConvertEmpireText needs lang%d.cvt, which Windows only loads for the YMIR // locale; AVA2 runs EUROPE, so the conversion is a no-op here. // p points into buf, so the filtered text also reaches AppendChat(buf). if (m_isEnableChatInsultFilter && chatter->m_bType != 1 && chatter->m_bType != 0) // !IsNPC && !IsEnemy FilterInsult(text.data() + start, strlen(text.c_str() + start)); line = text.substr(start); break; } default: line = text; break; } if (CHAT_TYPE_SHOUT != kChat.type) TextTailManager::Instance().RegisterChatTail(kChat.dwVID, line); if (chatter->m_bType == 6) // IsPC: CActorInstance::TYPE_PC CPythonChat::Instance().AppendChat(kChat.type, text.c_str()); } else { if (CHAT_TYPE_SHOUT == kChat.type) { const size_t colon = text.find(':'); if (colon != std::string::npos && m_isEnableChatInsultFilter) FilterInsult(text.data() + colon, strlen(text.c_str() + colon)); CPythonChat::Instance().AppendChat(kChat.type, text.c_str()); } else PyCallClassMemberFunc(m_phaseWindows[5], "GetLocaleString", Py_BuildValue("(is)", int(kChat.type), text.c_str())); } return true; } // CPythonNetworkStream::RecvWhisperPacket (ENABLE_MULTILANGUAGE_SYSTEM). bool PythonNetworkStream::RecvWhisperPacket() { TPacketGCWhisper whisperPacket; if (!Peek(sizeof(whisperPacket), &whisperPacket)) return false; if (whisperPacket.wSize < sizeof(whisperPacket)) throw std::runtime_error("invalid AVA2 dynamic packet length"); if (m_recvBuffer.size() < whisperPacket.wSize) return false; Read(sizeof(whisperPacket), &whisperPacket); std::string buf(whisperPacket.wSize - sizeof(whisperPacket), '\0'); if (!buf.empty()) Read(buf.size(), buf.data()); buf.resize(strnlen(buf.c_str(), buf.size())); char name[sizeof(whisperPacket.szNameFrom) + 1] {}; std::memcpy(name, whisperPacket.szNameFrom, sizeof(whisperPacket.szNameFrom)); if (m_whisperCallback) m_whisperCallback(whisperPacket.bType, name, buf); PyObject* gameWnd = m_phaseWindows[5]; if (WHISPER_TYPE_CHAT == whisperPacket.bType || WHISPER_TYPE_GM == whisperPacket.bType) { char line[256]; std::snprintf(line, sizeof(line), "%s : %s", name, buf.c_str()); PyCallClassMemberFunc(gameWnd, "OnRecvWhisper", Py_BuildValue("(issii)", int(whisperPacket.bType), name, line, int(whisperPacket.bLanguage), int(whisperPacket.bEmpire))); } else if (WHISPER_TYPE_SYSTEM == whisperPacket.bType || WHISPER_TYPE_ERROR == whisperPacket.bType) { PyCallClassMemberFunc(gameWnd, "OnRecvWhisperSystemMessage", Py_BuildValue("(iss)", int(whisperPacket.bType), name, buf.c_str())); } else { PyCallClassMemberFunc(gameWnd, "OnRecvWhisperError", Py_BuildValue("(iss)", int(whisperPacket.bType), name, buf.c_str())); } return true; } bool PythonNetworkStream::RecvDamageInfoPacket() { TPacketGCDamageInfo p; if (!Read(sizeof(p), &p)) return false; auto actor = NetworkActorManager::Instance().GetActorInstance(p.dwVID); float ax = 0.0f, ay = 0.0f, az = 0.0f; if (actor) { ax = actor->GetX(); ay = actor->GetY(); az = actor->GetZ(); actor->TakeDamage(p.damage); } // Spawn 3D floating damage number above target head bool isCritical = (p.flag & 1) != 0; FloatingTextManager::Instance().AddDamage(p.damage, ax, ay + 140.0f, az, isCritical, true); // Hit particle sparks EffectManager::Instance().CreateEffect("ymir work/pc/warrior/effect/gihyeol_spark.mse", ax, ay + 70.0f, az); // SFX SoundManager::Instance().PlaySound2D("sound/ui/punch.wav"); if (m_damageCallback) { m_damageCallback(p.dwVID, p.damage, p.flag); } return true; } bool PythonNetworkStream::RecvStunPacket() { TPacketGCStun p; if (!Read(sizeof(p), &p)) return false; auto actor=NetworkActorManager::Instance().GetActorInstance(p.vid); if(actor) { if(p.vid==m_dwMainActorVID) actor->Die(); else actor->Stun(); } return true; } bool PythonNetworkStream::RecvDeadPacket() { TPacketGCDead p; if (!Read(sizeof(p), &p)) return false; auto actor = NetworkActorManager::Instance().GetActorInstance(p.vid); if (actor) { auto* data = NetworkActorManager::Instance().GetActorData(p.vid); if (p.vid == m_dwMainActorVID && data && !data->m_duelMode) { PyObject* times = Py_BuildValue("(iii)", p.t_d[0], p.t_d[1], p.t_d[2]); PyObject* args = times ? PyTuple_Pack(1, times) : nullptr; Py_XDECREF(times); if (!args) throw std::runtime_error("AVA2 death callback argument allocation failed"); inventory_callback(m_phaseWindows[5], "OnGameOver", args); } if(data) data->m_isMoving=false; actor->Die(); } return true; } bool PythonNetworkStream::RecvPointChange() { TPacketGCPointChange p; if (!Read(sizeof(p), &p)) return false; if(m_dwMainActorVID && p.dwVID==m_dwMainActorVID) { SetPlayerStatusPoint(p.Type,p.value);m_refreshStatus=true; } return true; } namespace { template TItemData item_data(const Packet& p) { TItemData data{};data.vnum=p.vnum;data.count=p.count; std::copy_n(p.alSockets,ITEM_SOCKET_SLOT_MAX_NUM,data.alSockets); std::copy_n(p.aAttr,ITEM_ATTRIBUTE_SLOT_MAX_NUM,data.aAttr); std::copy_n(p.randomAttr,GLOVE_ATTR_MAX_NUM,data.randomAttr); std::copy_n(p.name,25,data.name);data.name[24]=0; return data; } void inventory_callback(PyObject* target,const char* name,PyObject* args) { PyCallClassMemberFunc(target,name,args); // ScriptLib semantics: skip missing, PyErr_Print on error } } bool PythonNetworkStream::RecvItemSetPacket() { TPacketGCItemSet p; if(!Read(sizeof(p),&p)) return false; SetPlayerItemData(p.Cell.window_type,p.Cell.cell,item_data(p)); if(p.Cell.window_type==11) inventory_callback(m_phaseWindows[5],"RefreshSwitchbotWindow",nullptr); else m_refreshInventory=true; return true; } bool PythonNetworkStream::RecvItemSetPacket2() { TPacketGCItemSet2 p; if(!Read(sizeof(p),&p)) return false; auto data=item_data(p);data.flags=p.flags;data.anti_flags=p.anti_flags; SetPlayerItemData(p.Cell.window_type,p.Cell.cell,data); if(p.Cell.window_type==11) { inventory_callback(m_phaseWindows[5],"RefreshSwitchbotWindow",nullptr);return true; } if(p.highlight) inventory_callback(m_phaseWindows[5],"BINARY_Highlight_Item",Py_BuildValue("ii",p.Cell.window_type,p.Cell.cell)); m_refreshInventory=true; return true; } bool PythonNetworkStream::RecvItemUpdatePacket() { TPacketGCItemUpdate p; if(!Read(sizeof(p),&p)) return false; auto data=GetPlayerItemData(p.Cell.window_type,p.Cell.cell);data.count=p.count; std::copy_n(p.alSockets,ITEM_SOCKET_SLOT_MAX_NUM,data.alSockets); std::copy_n(p.aAttr,ITEM_ATTRIBUTE_SLOT_MAX_NUM,data.aAttr); std::copy_n(p.randomAttr,GLOVE_ATTR_MAX_NUM,data.randomAttr); std::copy_n(p.name,25,data.name);data.name[24]=0; SetPlayerItemData(p.Cell.window_type,p.Cell.cell,data);m_refreshInventory=true; return true; } bool PythonNetworkStream::RecvItemUsePacket() { TPacketGCItemUse p; if (!Read(sizeof(p), &p)) return false; m_refreshInventory=true; return true; } bool PythonNetworkStream::RecvItemGroundAddPacket() { TPacketGCItemGroundAdd p; if (!Read(sizeof(p), &p)) return false; GlobalToLocalPosition(p.lX,p.lY); float wx = static_cast(p.lX); float wy = static_cast(p.lZ); float wz = static_cast(p.lY); TextTailManager::Instance().RegisterItemTextTail(p.dwVID, "Item " + std::to_string(p.dwVnum), wx, wy, wz); if (m_groundItemCallback) { m_groundItemCallback(p.dwVID, p.dwVnum, p.lX, p.lY, p.lZ, true); } return true; } bool PythonNetworkStream::RecvItemGroundDelPacket() { TPacketGCItemGroundDel p; if (!Read(sizeof(p), &p)) return false; TextTailManager::Instance().DeleteItemTextTail(p.vid); if (m_groundItemCallback) { m_groundItemCallback(p.vid, 0, 0, 0, 0, false); } return true; } bool PythonNetworkStream::RecvItemOwnership() { TPacketGCItemOwnership p; if (!Read(sizeof(p), &p)) return false; TextTailManager::Instance().SetItemTextTailOwner(p.dwVID, p.szName); return true; } bool PythonNetworkStream::RecvQuickSlotAddPacket() { TPacketGCQuickSlotAdd p; if (!Read(sizeof(p), &p)) return false; AddPlayerQuickSlot(p.pos,p.slot.Type,p.slot.Position);m_refreshInventory=true; return true; } bool PythonNetworkStream::RecvQuickSlotDelPacket() { TPacketGCQuickSlotDel p; if (!Read(sizeof(p), &p)) return false; DeletePlayerQuickSlot(p.pos);m_refreshInventory=true; return true; } bool PythonNetworkStream::RecvQuickSlotMovePacket() { TPacketGCQuickSlotSwap p; if (!Read(sizeof(p), &p)) return false; SwapPlayerQuickSlots(p.pos,p.change_pos);m_refreshInventory=true; return true; } bool PythonNetworkStream::RecvCreateFlyPacket() { TPacketGCCreateFly p; if (!Read(sizeof(p), &p)) return false; auto startActor = NetworkActorManager::Instance().GetActorInstance(p.dwStartVID); auto endActor = NetworkActorManager::Instance().GetActorInstance(p.dwEndVID); float startPos[3] = {0.0f, 100.0f, 0.0f}; float endPos[3] = {200.0f, 100.0f, 0.0f}; if (startActor) { startPos[0] = startActor->GetX(); startPos[1] = startActor->GetY() + 60.0f; startPos[2] = startActor->GetZ(); } if (endActor) { endPos[0] = endActor->GetX(); endPos[1] = endActor->GetY() + 60.0f; endPos[2] = endActor->GetZ(); } FlyingManager::Instance().CreateFlyingInstance(p.bType, startPos, endPos, [endVID = p.dwEndVID](const float* hitPos) { EffectManager::Instance().CreateEffect("ymir work/pc/warrior/effect/gihyeol_spark.mse", hitPos[0], hitPos[1], hitPos[2]); }); if (m_flyCallback) { m_flyCallback(p.bType, p.dwStartVID, p.dwEndVID); } return true; } bool PythonNetworkStream::RecvWarpPacket() { TPacketGCWarp p; if (!Read(sizeof(p), &p)) return false; return true; } // ── Outgoing Packet Builders ── namespace { bool main_actor_can_act(uint32_t vid) { auto actor=NetworkActorManager::Instance().GetActorInstance(vid); return actor && actor->CanAct(); } } bool PythonNetworkStream::SendPrivateShopSearchInfo(const TPacketCGShopSearch& p) { if(!main_actor_can_act(m_dwMainActorVID))return true; std::vector bytes{HEADER_CG_SHOP_SEARCH}; auto put=[&](uint64_t value,unsigned width) { for(unsigned i=0;i>(8*i))); }; put(uint32_t(p.ItemCat),4);put(uint32_t(p.SubCat),4); bytes.insert(bytes.end(),p.searchInput,p.searchInput+50); for(const auto* pair:{p.avg,p.skill,p.abs,p.level,p.refine})bytes.insert(bytes.end(),pair,pair+2); bytes.insert(bytes.end(),{p.sex,p.enchant,p.alchemy,p.character}); put(uint64_t(p.price[0]),8);put(uint64_t(p.price[1]),8); // Unlike normal gameplay transactions, Windows does not call SendSequence here. SendUnsequenced(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendSwitchbotPacket(bool start,uint8_t slot) { // Original has no main-actor action gate. Preserve slot6's declared37/actual7 quirk. std::vector bytes{HEADER_CG_SWITCHBOT,uint8_t(start?37:7),0,0,0,uint8_t(start?SUBHEADER_CG_SWITCHBOT_START:SUBHEADER_CG_SWITCHBOT_STOP),slot}; if(start && slot<6) { const auto& alternatives=GetSwitchbotState().table.alternatives[slot]; for(const auto& alt:alternatives)for(const auto& a:alt.attributes) { const uint16_t value=uint16_t(a.sValue);bytes.push_back(a.bType);bytes.push_back(uint8_t(value));bytes.push_back(uint8_t(value>>8)); } } Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendDungeonInfoPacket(uint8_t subheader,int32_t index) { if(!main_actor_can_act(m_dwMainActorVID))return true; // OPEN leaves index undefined in Windows; deterministic zero padding here. const uint32_t value=subheader==DUNGEON_INFO_SUB_HEADER_OPEN?0:uint32_t(index); const uint8_t bytes[]={HEADER_CG_DUNGEON_INFO_SYSTEM,subheader,uint8_t(value),uint8_t(value>>8),uint8_t(value>>16),uint8_t(value>>24)}; Send(bytes,sizeof(bytes));return true; // All four original senders use SendSequence. } bool PythonNetworkStream::SendDropItemPacket(bool search,int32_t vnum) { if(!main_actor_can_act(m_dwMainActorVID))return true; // Original OPEN leaves vnum undefined. Zero its padding deterministically. const uint32_t value=search?uint32_t(vnum):0; const uint8_t bytes[]={HEADER_CG_DROP_ITEM_SYSTEM,uint8_t(search?DROP_ITEM_SUB_HEADER_SEARCH:DROP_ITEM_SUB_HEADER_OPEN), uint8_t(value),uint8_t(value>>8),uint8_t(value>>16),uint8_t(value>>24)}; Send(bytes,sizeof(bytes));return true; // Both original senders use SendSequence. } bool PythonNetworkStream::SendBattlePassPacket(bool reward,int32_t index) { if(!main_actor_can_act(m_dwMainActorVID))return true; // Windows OPEN leaves index undefined; deterministic zero padding on the port. const uint32_t value=reward?uint32_t(index):0; const uint8_t bytes[]={HEADER_CG_BATTLEPASS,uint8_t(reward?BATTLEPASS_SUB_HEADER_REWARD:BATTLEPASS_SUB_HEADER_OPEN), uint8_t(value),uint8_t(value>>8),uint8_t(value>>16),uint8_t(value>>24)}; Send(bytes,sizeof(bytes));return true; // Original SendSequence() applies to both. } bool PythonNetworkStream::SendCubeRenewalPacket(bool close,uint32_t index,uint32_t count) { if(!main_actor_can_act(m_dwMainActorVID))return true; // Close leaves index/count undefined on Windows; deterministically zero them. std::array bytes{};bytes[0]=HEADER_CG_CUBE_RENEWAL; bytes[1]=close?CUBE_RENEWAL_SUB_HEADER_CLOSE:CUBE_RENEWAL_SUB_HEADER_MAKE_ITEM; if(!close)for(unsigned i=0;i<4;++i) { bytes[2+i]=uint8_t(index>>(i*8));bytes[6+i]=uint8_t(count>>(i*8)); } Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendQuickSlotAddPacket(uint8_t index,uint8_t type,uint8_t pos) { if(!main_actor_can_act(m_dwMainActorVID)) return true; const uint8_t bytes[]={HEADER_CG_QUICKSLOT_ADD,index,type,pos};Send(bytes,sizeof(bytes));return true; } bool PythonNetworkStream::SendQuickSlotDelPacket(uint8_t index) { if(!main_actor_can_act(m_dwMainActorVID)) return true; const uint8_t bytes[]={HEADER_CG_QUICKSLOT_DEL,index};Send(bytes,sizeof(bytes));return true; } bool PythonNetworkStream::SendQuickSlotMovePacket(uint8_t source,uint8_t target) { if(!main_actor_can_act(m_dwMainActorVID)) return true; const uint8_t bytes[]={HEADER_CG_QUICKSLOT_SWAP,source,target};Send(bytes,sizeof(bytes));return true; } bool PythonNetworkStream::SendEnterGamePacket() { auto bytes=wire::entergame(GetEnterGameLanguage());Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::RecvShopPacket() { uint8_t header[4];if(!Peek(4,header))return false; const size_t size=header[1]|(size_t(header[2])<<8); if(size<4)throw std::runtime_error("invalid AVA2 shop packet length"); if(m_recvBuffer.size() bytes(size);Peek(size,bytes.data()); if(sub==10&&(size<9||bytes[8]>3||size<9+size_t(bytes[8])*4953))throw std::runtime_error("invalid AVA2 shop tabs"); Read(size,bytes.data()); auto decode=[](const uint8_t* p) { auto read=[&](unsigned offset,unsigned width) { uint64_t value=0;for(unsigned i=0;i(read(4,8));item.count=read(12,4);item.displayPosition=p[16];item.buyVnum=read(17,4);item.buyCount=read(21,4); for(unsigned i=0;i<8;++i)item.sockets[i]=std::bit_cast(static_cast(read(25+4*i,4))); for(unsigned i=0;i<15;++i)item.attributes[i]={p[57+3*i],std::bit_cast(static_cast(read(58+3*i,2)))}; for(unsigned i=0;i<7;++i)item.gloveAttributes[i]={p[102+3*i],std::bit_cast(static_cast(read(103+3*i,2)))}; return item; }; if(sub==0||sub==10) { ClearShopState(); const uint32_t owner=uint32_t(bytes[4])|(uint32_t(bytes[5])<<8)|(uint32_t(bytes[6])<<16)|(uint32_t(bytes[7])<<24); if(sub==0)for(unsigned i=0;i<40;++i)SetShopItem(i,decode(bytes.data()+8+123*i)); else { SetShopTabCount(bytes[8]); for(unsigned tab=0;tab(p),strnlen(reinterpret_cast(p),32)),p[32]); for(unsigned i=0;i<40;++i)SetShopItem(tab*40+i,decode(p+33+123*i)); } } inventory_callback(m_phaseWindows[5],"StartShop",Py_BuildValue("(i)",std::bit_cast(owner))); } else if(sub==2) { SetShopItem(bytes[4],decode(bytes.data()+5));inventory_callback(m_phaseWindows[5],"RefreshShop",nullptr); } else if(sub==1)inventory_callback(m_phaseWindows[5],"EndShop",nullptr); else if(error)inventory_callback(m_phaseWindows[5],"OnShopError",Py_BuildValue("(s)",error)); else if(sub==3) { uint64_t value=0;for(unsigned i=0;i<8;++i)value|=uint64_t(bytes[4+i])<<(8*i); inventory_callback(m_phaseWindows[5],"SetShopSellingPrice",Py_BuildValue("(L)",std::bit_cast(value))); } return true; } bool PythonNetworkStream::SendShopPacket(uint8_t operation,uint8_t window,uint8_t slot,uint32_t count) { if(!main_actor_can_act(m_dwMainActorVID))return true; // Active OFFLINESHOP expands the common header to 58 bytes. Original // unused title/vid/pos bytes are uninitialized; emit deterministic zeros. std::vector bytes(58,0);bytes[0]=50;bytes[1]=operation; if(operation==1) { bytes.push_back(1);bytes.push_back(slot); } else if(operation==2)bytes.push_back(slot); else if(operation==3) { bytes.push_back(window);bytes.push_back(slot); for(unsigned i=0;i<4;++i)bytes.push_back(static_cast(count>>(8*i))); } Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendOfflineShopPacket(bool buy,uint32_t owner,uint8_t position) { if(!main_actor_can_act(m_dwMainActorVID))return true; std::array bytes{};bytes[0]=57;bytes[1]=buy?1:0; if(buy) { for(unsigned i=0;i<4;++i)bytes[53+i]=static_cast(owner>>(8*i)); bytes[57]=position; } Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendOfflineShopManagement(uint8_t operation,uint8_t position,uint32_t owner) { // Original management requests do not use the main-actor action gate. std::vector bytes(58,0);bytes[0]=57;bytes[1]=operation; if(operation==5||operation==13)bytes.push_back(position); if(operation==16)for(unsigned i=0;i<4;++i)bytes.push_back(static_cast(owner>>(8*i))); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendCharacterMovePacket(uint8_t func, uint8_t arg, uint8_t rot, int32_t x, int32_t y, uint32_t time) { TPacketCGMove p; p.bHeader = HEADER_CG_MOVE; p.bFunc = func; p.bArg = arg; p.bRot = rot; LocalToGlobalPosition(x,y); p.lX = x; p.lY = y; p.dwTime = time; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendAttackPacket(uint8_t type, uint32_t victimVID) { if(!main_actor_can_act(m_dwMainActorVID)) return true; TPacketCGAttack p; p.header = HEADER_CG_ATTACK; p.bType = type; p.dwVictimVID = victimVID; p.bCRCMagicCubeProc = 0; p.bCRCMagicCubeFile = 0; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendChatPacket(const std::string& input,uint8_t type) { if(m_phase!=PHASE_GAME) return false; if(input.empty() || input.size()>=512) return true; std::string text=input; if(text[0]=='/') { if(text.size()==1) { if(!m_strLastCommand.empty()) text=m_strLastCommand; } else m_strLastCommand=text; } // ClientCommand() always returns false in AVA2. auto bytes=wire::chat(text,type);Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendWhisperPacket(const std::string& name,const std::string& text) { auto bytes=wire::whisper(name,text);Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendItemUsePacket(uint8_t window, uint16_t cell) { if(!main_actor_can_act(m_dwMainActorVID)) return true; if(IsPlayerEquipmentItem(window,cell)) { const char* error=CPythonExchange::Instance().isTrading()?"CANNOT_EQUIP_EXCHANGE":IsShopOpen()?"CANNOT_EQUIP_SHOP":nullptr; if(error) {PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_AppendNotifyMessage",Py_BuildValue("(s)",error));return true;} if(auto actor=NetworkActorManager::Instance().GetActorInstance(m_dwMainActorVID);actor&&actor->IsAttacking())return true; } PlayItemUseSound(GetPlayerItemData(window,cell).vnum); TPacketCGItemUse p; p.header = HEADER_CG_ITEM_USE; p.Cell.window_type = window; p.Cell.cell = cell; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendItemMovePacket(uint8_t srcWindow, uint16_t srcCell, uint8_t dstWindow, uint16_t dstCell, uint32_t count) { if(!main_actor_can_act(m_dwMainActorVID)) return true; if(IsPlayerEquipmentItem(srcWindow,srcCell)) { const bool equipDestination=(dstWindow==1||dstWindow==2)&&dstCell>=180&&dstCell<216; const bool equipSource=(srcWindow==1||srcWindow==2)&&srcCell>=180&&srcCell<216; const char* error=CPythonExchange::Instance().isTrading()?"CANNOT_EQUIP_EXCHANGE":IsShopOpen()?"CANNOT_EQUIP_SHOP":nullptr; if(error&&(equipSource||equipDestination)) {PyCallClassMemberFunc(m_phaseWindows[5],"BINARY_AppendNotifyMessage",Py_BuildValue("(s)",error));return true;} if(auto actor=NetworkActorManager::Instance().GetActorInstance(m_dwMainActorVID);actor&&actor->IsAttacking())return true; } PlayItemDropSound(GetPlayerItemData(srcWindow,srcCell).vnum); TPacketCGItemMove p; p.header = HEADER_CG_ITEM_MOVE; p.Cell.window_type = srcWindow; p.Cell.cell = srcCell; p.CellTo.window_type = dstWindow; p.CellTo.cell = dstCell; p.count = count; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendItemPickUpPacket(uint32_t vid) { if(!main_actor_can_act(m_dwMainActorVID)) return true; TPacketCGItemPickUp p; p.header = HEADER_CG_ITEM_PICKUP; p.vid = vid; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendItemDropPacket(uint8_t window, uint16_t cell, uint32_t gold) { if(!main_actor_can_act(m_dwMainActorVID)) return true; TPacketCGItemDrop p; p.header = HEADER_CG_ITEM_DROP; p.Cell.window_type = window; p.Cell.cell = cell; p.elk = gold; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendItemDropPacketNew(uint8_t window,uint16_t cell,uint32_t gold,uint32_t count) { if(!main_actor_can_act(m_dwMainActorVID)) return true; TPacketCGItemDrop2 p{};p.header=HEADER_CG_ITEM_DROP2;p.Cell={window,cell};p.gold=gold;p.count=count; Send(&p,sizeof(p));return true; } bool PythonNetworkStream::SendOnClickPacket(uint32_t vid) { TPacketCGOnClick p; p.header = HEADER_CG_ON_CLICK; p.vid = vid; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendFlyTargetingPacket(uint32_t targetVID, int32_t x, int32_t y) { TPacketCGFlyTargeting p; p.bHeader = HEADER_CG_FLY_TARGETING; p.dwTargetVID = targetVID; p.x = x; p.y = y; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendWarpPacket() { TPacketCGWarp p; p.header = HEADER_CG_WARP; Send(&p, sizeof(p)); return true; } // ── Exchange Protocol Handlers ── bool PythonNetworkStream::RecvExchangePacket() { TPacketGCExchange p; if (!Read(sizeof(p), &p)) return false; switch (p.subheader) { case EXCHANGE_SUBHEADER_GC_START: { CPythonExchange::Instance().Clear(); CPythonExchange::Instance().Start(); CPythonExchange::Instance().SetSelfName(m_strMainActorName.c_str()); break; } case EXCHANGE_SUBHEADER_GC_ITEM_ADD: { uint32_t pos = p.arg2.cell; if (p.is_me) { CPythonExchange::Instance().SetItemToSelf(pos, static_cast(p.arg1), p.arg3); for (int i = 0; i < static_cast(ITEM_SOCKET_SLOT_MAX_NUM); ++i) { CPythonExchange::Instance().SetItemMetinSocketToSelf(pos, i, p.alValues[i]); } for (int i = 0; i < static_cast(ITEM_ATTRIBUTE_SLOT_MAX_NUM); ++i) { CPythonExchange::Instance().SetItemAttributeToSelf(pos, i, p.aAttr[i].bType, p.aAttr[i].sValue); } for (int i = 0; i < static_cast(GLOVE_ATTR_MAX_NUM); ++i) { CPythonExchange::Instance().SetItemRandomAttributeToSelf(pos, i, p.randomAttr[i].bType, p.randomAttr[i].sValue); } CPythonExchange::Instance().SetItemNewName(pos, p.name, true); } else { CPythonExchange::Instance().SetItemToTarget(pos, static_cast(p.arg1), p.arg3); for (int i = 0; i < static_cast(ITEM_SOCKET_SLOT_MAX_NUM); ++i) { CPythonExchange::Instance().SetItemMetinSocketToTarget(pos, i, p.alValues[i]); } for (int i = 0; i < static_cast(ITEM_ATTRIBUTE_SLOT_MAX_NUM); ++i) { CPythonExchange::Instance().SetItemAttributeToTarget(pos, i, p.aAttr[i].bType, p.aAttr[i].sValue); } for (int i = 0; i < static_cast(GLOVE_ATTR_MAX_NUM); ++i) { CPythonExchange::Instance().SetItemRandomAttributeToTarget(pos, i, p.randomAttr[i].bType, p.randomAttr[i].sValue); } CPythonExchange::Instance().SetItemNewName(pos, p.name, false); } break; } case EXCHANGE_SUBHEADER_GC_ITEM_DEL: { uint32_t pos = static_cast(p.arg1); if (p.is_me) { CPythonExchange::Instance().DelItemOfSelf(pos); } else { CPythonExchange::Instance().DelItemOfTarget(pos); } break; } case EXCHANGE_SUBHEADER_GC_ELK_ADD: { if (p.is_me) { CPythonExchange::Instance().SetElkToSelf(p.arg1); } else { CPythonExchange::Instance().SetElkToTarget(p.arg1); } break; } case EXCHANGE_SUBHEADER_GC_ACCEPT: { if (p.is_me) { CPythonExchange::Instance().SetAcceptToSelf(p.arg1 != 0 ? 1 : 0); } else { CPythonExchange::Instance().SetAcceptToTarget(p.arg1 != 0 ? 1 : 0); } break; } case EXCHANGE_SUBHEADER_GC_END: { CPythonExchange::Instance().End(); break; } default: break; } return true; } // AVA2 PythonNetworkStreamPhaseGame.cpp: every exchange sender is gated by __CanActMainInstance(). // Fields a sender leaves alone keep TItemPos's ctor value {INVENTORY, WORD_MAX}; the rest is emitted as zero. namespace { TPacketCGExchange exchange_packet(uint8_t subheader) { TPacketCGExchange p{}; p.header = HEADER_CG_EXCHANGE; p.subheader = subheader; p.Pos.window_type = 1; // INVENTORY p.Pos.cell = 0xffff; // WORD_MAX return p; } bool main_actor_can_act(uint32_t vid); } bool PythonNetworkStream::SendExchangeStartPacket(uint32_t vid) { if (!main_actor_can_act(m_dwMainActorVID)) return true; auto p = exchange_packet(EXCHANGE_SUBHEADER_CG_START); p.arg1 = vid; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendExchangeItemAddPacket(uint8_t window, uint16_t cell, uint8_t exchangePos) { if (!main_actor_can_act(m_dwMainActorVID)) return true; auto p = exchange_packet(EXCHANGE_SUBHEADER_CG_ITEM_ADD); p.Pos.window_type = window; p.Pos.cell = cell; p.arg2 = exchangePos; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendExchangeItemDelPacket(uint8_t) { // Windows: assert(!"Can't be called function"); return true; -- nothing is sent. return true; } bool PythonNetworkStream::SendExchangeElkAddPacket(int64_t elk) { if (!main_actor_can_act(m_dwMainActorVID)) return true; auto p = exchange_packet(EXCHANGE_SUBHEADER_CG_ELK_ADD); p.arg1 = elk; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendExchangeAcceptPacket() { if (!main_actor_can_act(m_dwMainActorVID)) return true; auto p = exchange_packet(EXCHANGE_SUBHEADER_CG_ACCEPT); Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendExchangeExitPacket() { if (!main_actor_can_act(m_dwMainActorVID)) return true; auto p = exchange_packet(EXCHANGE_SUBHEADER_CG_CANCEL); Send(&p, sizeof(p)); return true; } // ── SafeBox & Mall Handlers ── bool PythonNetworkStream::RecvSafeBoxSetPacket() { TPacketGCItemSet2 p; if (!Read(sizeof(p), &p)) return false; auto item=item_data(p);item.flags=p.flags;item.anti_flags=p.anti_flags; CPythonSafeBox::Instance().SetItemData(p.Cell.cell, item); return true; } bool PythonNetworkStream::RecvSafeBoxDelPacket() { TPacketGCItemDel p; if (!Read(sizeof(p), &p)) return false; CPythonSafeBox::Instance().DelItemData(p.pos); return true; } bool PythonNetworkStream::RecvSafeBoxWrongPasswordPacket() { TPacketGCSafeboxWrongPassword p; if (!Read(sizeof(p), &p)) return false; return true; } bool PythonNetworkStream::RecvSafeBoxSizePacket() { TPacketGCSafeboxSize p; if (!Read(sizeof(p), &p)) return false; CPythonSafeBox::Instance().OpenSafeBox(p.bSize); return true; } bool PythonNetworkStream::RecvSafeBoxMoneyChangePacket() { TPacketGCSafeboxMoneyChange p; if (!Read(sizeof(p), &p)) return false; CPythonSafeBox::Instance().SetMoney(p.dwMoney); return true; } bool PythonNetworkStream::RecvMallOpenPacket() { TPacketGCSafeboxSize p; if (!Read(sizeof(p), &p)) return false; CPythonSafeBox::Instance().OpenMall(p.bSize); return true; } bool PythonNetworkStream::RecvMallSetPacket() { TPacketGCItemSet2 p; if (!Read(sizeof(p), &p)) return false; auto item=item_data(p);item.flags=p.flags;item.anti_flags=p.anti_flags; CPythonSafeBox::Instance().SetMallItemData(p.Cell.cell, item); return true; } bool PythonNetworkStream::RecvMallDelPacket() { TPacketGCItemDel p; if (!Read(sizeof(p), &p)) return false; CPythonSafeBox::Instance().DelMallItemData(p.pos); return true; } bool PythonNetworkStream::SendSafeBoxCheckinPacket(uint8_t window, uint16_t cell, uint8_t safeboxPos) { PlayItemDropSound(GetPlayerItemData(window,cell).vnum); TPacketCGSafeboxCheckin p{}; p.header = HEADER_CG_SAFEBOX_CHECKIN; p.bSafeBoxPos = safeboxPos; p.ItemPos.window_type = window; p.ItemPos.cell = cell; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendSafeBoxCheckoutPacket(uint8_t safeboxPos, uint8_t window, uint16_t cell) { uint32_t vnum;if(CPythonSafeBox::Instance().GetSlotItemID(safeboxPos,&vnum))PlayItemDropSound(vnum); TPacketCGSafeboxCheckout p{}; p.header = HEADER_CG_SAFEBOX_CHECKOUT; p.bSafeBoxPos = safeboxPos; p.ItemPos.window_type = window; p.ItemPos.cell = cell; Send(&p, sizeof(p)); return true; } bool PythonNetworkStream::SendSafeBoxItemMovePacket(uint8_t srcPos, uint8_t dstPos, uint32_t count) { uint32_t vnum;if(CPythonSafeBox::Instance().GetSlotItemID(srcPos,&vnum))PlayItemDropSound(vnum); // Windows sends TPacketCGItemMove {header, pos, change_pos, DWORD num} under HEADER_CG_SAFEBOX_ITEM_MOVE. std::vector bytes{HEADER_CG_SAFEBOX_ITEM_MOVE,1,srcPos,0,1,dstPos,0}; for(int shift=0;shift<32;shift+=8) bytes.push_back(static_cast(count>>shift)); Send(bytes.data(), bytes.size()); return true; } bool PythonNetworkStream::SendSafeBoxMoneyPacket(uint8_t, uint32_t) { // AVA2 Windows explicitly disables this operation. Header 78 is PARTY_PARAMETER. return false; } bool PythonNetworkStream::SendMallCheckoutPacket(uint8_t safeboxPos, uint8_t window, uint16_t cell) { uint32_t vnum;if(CPythonSafeBox::Instance().GetSlotMallItemID(safeboxPos,&vnum))PlayItemDropSound(vnum); TPacketCGSafeboxCheckout p{}; p.header = HEADER_CG_MALL_CHECKOUT; p.bSafeBoxPos = safeboxPos; p.ItemPos.window_type = window; p.ItemPos.cell = cell; Send(&p, sizeof(p)); return true; } namespace { void append16(std::vector& bytes,uint16_t value) { bytes.push_back(value);bytes.push_back(value>>8); } void append32(std::vector& bytes,uint32_t value) { for(int shift=0;shift<32;shift+=8) bytes.push_back(value>>shift); } } namespace { // strncpy(dst,src,n) into a zeroed fixed char field; bytes Windows leaves uninitialized are emitted as zero. void append_text(std::vector& bytes,const char* text,size_t field,size_t copy) { const size_t start=bytes.size();bytes.resize(start+field,0); for(size_t i=0;i(text[i]); } std::vector guild_packet(uint8_t subheader) { return {HEADER_CG_GUILD,subheader}; } } // ── Script / quest (AVA2 PythonNetworkStreamPhaseGame.cpp) ── bool PythonNetworkStream::SendAnswerMakeGuildPacket(const char* name) { std::vector bytes{HEADER_CG_ANSWER_MAKE_GUILD};append_text(bytes,name,GUILD_NAME_MAX_LEN+1,GUILD_NAME_MAX_LEN); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendQuestInputStringPacket(const char* text) { std::vector bytes{HEADER_CG_QUEST_INPUT_STRING};append_text(bytes,text,QUEST_INPUT_STRING_MAX_NUM+1,QUEST_INPUT_STRING_MAX_NUM); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendQuestInputStringLongPacket(const char* text) { std::vector bytes{HEADER_CG_QUEST_INPUT_LONG_STRING};append_text(bytes,text,QUEST_INPUT_STRING_LONG_MAX_NUM,QUEST_INPUT_STRING_LONG_MAX_NUM); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendQuestConfirmPacket(uint8_t answer,uint32_t pid) { std::vector bytes{HEADER_CG_QUEST_CONFIRM,answer};append32(bytes,pid); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendSelectItemPacket(uint32_t itemPos) { std::vector bytes{HEADER_CG_SCRIPT_SELECT_ITEM};append32(bytes,itemPos); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendTargetInfoLoadPacket(uint32_t vid) { std::vector bytes{HEADER_CG_TARGET_INFO_LOAD};append32(bytes,vid); Send(bytes.data(),bytes.size());return true; } // ── Messenger ── bool PythonNetworkStream::SendMessengerAddByVIDPacket(uint32_t vid) { std::vector bytes{HEADER_CG_MESSENGER,MESSENGER_SUBHEADER_CG_ADD_BY_VID};append32(bytes,vid); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendMessengerAddByNamePacket(const char* name) { std::vector bytes{HEADER_CG_MESSENGER,MESSENGER_SUBHEADER_CG_ADD_BY_NAME};append_text(bytes,name,CHARACTER_NAME_MAX_LEN,CHARACTER_NAME_MAX_LEN-1); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendMessengerRemovePacket(const char* key,const char* name) { std::vector bytes{HEADER_CG_MESSENGER,MESSENGER_SUBHEADER_CG_REMOVE};append_text(bytes,key,CHARACTER_NAME_MAX_LEN,CHARACTER_NAME_MAX_LEN-1); Send(bytes.data(),bytes.size()); // __RefreshTargetBoardByName: PyCallClassMemberFunc skips a phase window without the method. if(auto* game=m_phaseWindows[5]; game && PyObject_HasAttrString(game,"RefreshTargetBoardByName")) inventory_callback(game,"RefreshTargetBoardByName",Py_BuildValue("(s)",name)); return true; } // ── Party ── bool PythonNetworkStream::SendPartyInvitePacket(uint32_t vid) { std::vector bytes{HEADER_CG_PARTY_INVITE};append32(bytes,vid); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendPartyInviteAnswerPacket(uint32_t leaderPID,uint8_t answer) { std::vector bytes{HEADER_CG_PARTY_INVITE_ANSWER};append32(bytes,leaderPID);bytes.push_back(answer); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendPartyRemovePacket(uint32_t pid) { if(m_phase!=PHASE_GAME) return false; std::vector bytes{HEADER_CG_PARTY_REMOVE};append32(bytes,pid); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendPartySetStatePacket(uint32_t vid,uint8_t state,uint8_t flag) { std::vector bytes{HEADER_CG_PARTY_SET_STATE};append32(bytes,vid);bytes.push_back(state);bytes.push_back(flag); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendPartyUseSkillPacket(uint8_t skillIndex,uint32_t vid) { std::vector bytes{HEADER_CG_PARTY_USE_SKILL,skillIndex};append32(bytes,vid); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendPartyParameterPacket(uint8_t distributeMode) { const uint8_t bytes[]={HEADER_CG_PARTY_PARAMETER,distributeMode}; Send(bytes,sizeof(bytes));return true; } // ── Guild: TPacketCGGuild {header, subheader} followed by the raw payload ── bool PythonNetworkStream::SendGuildAddMemberPacket(uint32_t vid) { auto bytes=guild_packet(GUILD_SUBHEADER_CG_ADD_MEMBER);append32(bytes,vid); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGuildRemoveMemberPacket(uint32_t pid) { auto bytes=guild_packet(GUILD_SUBHEADER_CG_REMOVE_MEMBER);append32(bytes,pid); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGuildChangeGradeNamePacket(uint8_t grade,const char* name) { auto bytes=guild_packet(GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME);bytes.push_back(grade); append_text(bytes,name,GUILD_GRADE_NAME_MAX_LEN+1,GUILD_GRADE_NAME_MAX_LEN); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGuildChangeGradeAuthorityPacket(uint8_t grade,uint8_t authority) { auto bytes=guild_packet(GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY);bytes.push_back(grade);bytes.push_back(authority); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGuildOfferPacket(uint32_t experience) { auto bytes=guild_packet(GUILD_SUBHEADER_CG_OFFER);append32(bytes,experience); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGuildPostCommentPacket(const char* message) { // BYTE(strlen)+1 wraps like Windows; that many bytes of the message (terminator included) follow. const uint8_t size=static_cast(static_cast(std::strlen(message))+1); auto bytes=guild_packet(GUILD_SUBHEADER_CG_POST_COMMENT);bytes.push_back(size); bytes.insert(bytes.end(),message,message+size); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGuildDeleteCommentPacket(uint32_t index) { auto bytes=guild_packet(GUILD_SUBHEADER_CG_DELETE_COMMENT);append32(bytes,index); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGuildRefreshCommentsPacket(uint32_t) { // Windows throttles with a static timeGetTime() stamp: one request per 1000 ms, extra calls return true. const auto now=std::chrono::steady_clock::now(); if(m_lastGuildCommentRefresh && now-*m_lastGuildCommentRefresh(index)}; Send(bytes,sizeof(bytes));return true; } bool PythonNetworkStream::SendItemUseToItemPacket(uint16_t source,uint16_t target) { if(!main_actor_can_act(m_dwMainActorVID)) return true; std::vector bytes{HEADER_CG_ITEM_USE_TO_ITEM,1}; // AVA2 INVENTORY append16(bytes,source);bytes.push_back(1);append16(bytes,target); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendGiveItemPacket(uint32_t vid,uint8_t window,uint16_t cell,uint32_t count) { std::vector bytes{HEADER_CG_GIVE_ITEM};append32(bytes,vid); bytes.push_back(window);append16(bytes,cell);append32(bytes,count); Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendScriptAnswerPacket(int answer) { const uint8_t bytes[]={HEADER_CG_SCRIPT_ANSWER,static_cast(answer)}; Send(bytes,sizeof(bytes));return true; } bool PythonNetworkStream::SendScriptButtonPacket(int button) { std::vector bytes{HEADER_CG_SCRIPT_BUTTON};append32(bytes,static_cast(button)); Send(bytes.data(),bytes.size());return true; } } // namespace ava2 namespace ava2 { bool PythonNetworkStream::SendBuildOfflineShopPacket(const std::string& name,const std::vector& items,uint32_t vnum,uint8_t title) { // Serialize the original Win32 packed layout. Original unused fields are zeroed. std::vector bytes(53,0);bytes[0]=HEADER_CG_MY_OFFLINE_SHOP; std::copy_n(name.begin(),std::min(size_t(45),name.size()),bytes.begin()+1); bytes[47]=static_cast(items.size()); for(unsigned i=0;i<4;++i)bytes[48+i]=uint8_t(vnum>>(8*i));bytes[52]=title; auto put=[&](uint64_t value,unsigned width) {for(unsigned i=0;i>(8*i)));}; for(const auto& item:items) {put(item.vnum,4);put(uint32_t(item.count),4);put(item.pos.window_type,1);put(item.pos.cell,2);put(uint64_t(item.price),8);put(item.display_pos,1);} Send(bytes.data(),bytes.size());return true; } bool PythonNetworkStream::SendOfflineShopChangeDecoration(const std::string& sign,uint32_t vnum,uint32_t type) { std::vector bytes(110,0);bytes[0]=57;bytes[1]=12; std::copy_n(sign.begin(),std::min(size_t(45),sign.size()),bytes.begin()+58); // Original owner_id is never assigned; deterministic zero avoids leaking memory. bytes[108]=uint8_t(vnum);bytes[109]=uint8_t(type); Send(bytes.data(),bytes.size());return true; } }