1778 lines
77 KiB
C++
1778 lines
77 KiB
C++
#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 <algorithm>
|
|
#include <iostream>
|
|
#include <bit>
|
|
#include <stdexcept>
|
|
#include <cstring>
|
|
|
|
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<std::vector<uint8_t>> PythonNetworkStream::PopSendPackets() {
|
|
auto packets=std::move(m_sendPackets);m_sendPackets.clear();m_sendSequence.clear();m_sendBuffer.clear();return packets;
|
|
}
|
|
std::vector<std::pair<std::vector<uint8_t>,bool>> PythonNetworkStream::PopSendPacketsWithSequence() {
|
|
std::vector<std::pair<std::vector<uint8_t>,bool>> packets;
|
|
for(size_t i=0;i<m_sendPackets.size();++i) packets.emplace_back(std::move(m_sendPackets[i]),m_sendSequence[i]);
|
|
m_sendPackets.clear();m_sendSequence.clear();m_sendBuffer.clear();
|
|
return packets;
|
|
}
|
|
|
|
void PythonNetworkStream::SetGuildID(uint32_t id) {
|
|
if(m_guildID==id)return;
|
|
m_guildID=id;
|
|
auto it=GetGuildState().names.find(id);
|
|
update_player_guild(id,it==GetGuildState().names.end()?"":it->second);
|
|
}
|
|
|
|
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<uint8_t>& 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<const uint8_t*>(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<uint8_t> PythonNetworkStream::PopSendBytes() {
|
|
std::vector<uint8_t> 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] "<<text<<std::endl; }
|
|
}
|
|
|
|
// CPythonNetworkStream::CheckPacket: skip padding, reject unmapped headers and wait
|
|
// until the whole static/dynamic packet is buffered.
|
|
bool PythonNetworkStream::CheckPacket(uint8_t* retHeader) {
|
|
*retHeader=0;
|
|
while(!m_recvBuffer.empty() && m_recvBuffer.front()==0) m_recvBuffer.erase(m_recvBuffer.begin());
|
|
if(m_recvBuffer.empty()) return false;
|
|
const uint8_t header=m_recvBuffer.front();
|
|
const auto* type=gc_packet_type(header);
|
|
if(!type || !type->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()<need) return false;
|
|
*retHeader=header;
|
|
m_lastPacket[0]=m_lastPacket[1];m_lastPacket[1]=header;
|
|
return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::ProcessRecvData() {
|
|
if(m_startGameRequested) { m_startGameRequested=false;inventory_callback(m_poHandler,"SetGamePhase",nullptr); }
|
|
bool progress = false;
|
|
uint8_t header = 0;
|
|
while (CheckPacket(&header)) {
|
|
const auto* type=gc_packet_type(header);
|
|
bool ret;
|
|
// LoadingPhase() handles MAIN_CHARACTER* itself and falls back to GamePhase();
|
|
// GamePhase() has no case for them, so in Game they hit RecvDefaultPacket.
|
|
const bool loadingOnly=header==HEADER_GC_MAIN_CHARACTER || header==HEADER_GC_MAIN_CHARACTER2_EMPIRE ||
|
|
header==HEADER_GC_MAIN_CHARACTER3_BGM || header==HEADER_GC_MAIN_CHARACTER4_BGM_VOL;
|
|
if(loadingOnly && m_phase==PHASE_GAME) {
|
|
trace_error("Unprocessed packet header "+std::to_string(header)+", state Game");
|
|
m_recvBuffer.clear();
|
|
} else if(DispatchGamePhasePacket(header,ret)) {
|
|
// RecvErrorPacket
|
|
if(!ret) { trace_error("Phase Game does not handle this header (header: "+std::to_string(header)+")");m_recvBuffer.clear(); }
|
|
} else if(type->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<EPhase>(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<uint8_t> 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<int32_t>(end));m_refreshStatus=true;
|
|
}
|
|
inventory_callback(m_phaseWindows[5],"BINARY_NEW_AddAffect",Py_BuildValue("iiii",std::bit_cast<int32_t>(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<int32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<float>(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<sizeof(p)) throw std::runtime_error("invalid AVA2 dynamic packet length");
|
|
if (m_recvBuffer.size() < p.wSize) return false;
|
|
|
|
if((p.wSize-sizeof(p))%sizeof(TPacketGCSyncPosition::Element)) throw std::runtime_error("invalid AVA2 sync packet length");
|
|
Read(sizeof(p), &p);
|
|
size_t elemCount = (p.wSize - sizeof(p)) / sizeof(TPacketGCSyncPosition::Element);
|
|
for (size_t i = 0; i < elemCount; ++i) {
|
|
TPacketGCSyncPosition::Element elem;
|
|
Read(sizeof(elem), &elem);
|
|
GlobalToLocalPosition(elem.lX,elem.lY);
|
|
NetworkActorManager::Instance().SyncActor(elem.dwVID, elem.lX, elem.lY);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// CPythonNetworkStream::RecvChatPacket (ENABLE_MULTILANGUAGE_SYSTEM branch).
|
|
bool PythonNetworkStream::RecvChatPacket() {
|
|
TPacketGCChat kChat;
|
|
if (!Peek(sizeof(kChat), &kChat)) return false;
|
|
if (kChat.size < sizeof(kChat)) throw std::runtime_error("invalid AVA2 chat packet length");
|
|
if (m_recvBuffer.size() < kChat.size) return false;
|
|
|
|
Read(sizeof(kChat), &kChat);
|
|
std::string text(kChat.size - sizeof(kChat), '\0');
|
|
if (!text.empty()) Read(text.size(), text.data());
|
|
text.resize(strnlen(text.c_str(), text.size())); // buf[uChatSize]='\0' + C-string use
|
|
|
|
if (kChat.type >= 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<class Packet> 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<float>(p.lX);
|
|
float wy = static_cast<float>(p.lZ);
|
|
float wz = static_cast<float>(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<uint8_t> bytes{HEADER_CG_SHOP_SEARCH};
|
|
auto put=[&](uint64_t value,unsigned width) { for(unsigned i=0;i<width;++i)bytes.push_back(uint8_t(value>>(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<uint8_t> 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<uint8_t,10> 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()<size)return false;
|
|
const auto sub=header[3];
|
|
const char* error=sub==5?"NOT_ENOUGH_MONEY":sub==6?"SOLDOUT":sub==7?"INVENTORY_FULL":sub==8?"INVALID_POS":sub==11?"NOT_ENOUGH_MONEY_EX":sub==12?"NOT_ENOUGH_COUNT":nullptr;
|
|
if(sub!=0&&sub!=10&&sub!=1&&sub!=2&&sub!=3&&sub!=4&&!error)return false;
|
|
if(sub==0&&size<4928)throw std::runtime_error("truncated AVA2 shop start");
|
|
if(sub==2&&size<128)throw std::runtime_error("truncated AVA2 shop item");
|
|
if(sub==3&&size<12)throw std::runtime_error("truncated AVA2 shop price");
|
|
std::vector<uint8_t> 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<width;++i)value|=uint64_t(p[offset+i])<<(i*8);return value; };
|
|
ShopItemRecord item;item.vnum=read(0,4);item.price=std::bit_cast<int64_t>(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<int32_t>(static_cast<uint32_t>(read(25+4*i,4)));
|
|
for(unsigned i=0;i<15;++i)item.attributes[i]={p[57+3*i],std::bit_cast<int16_t>(static_cast<uint16_t>(read(58+3*i,2)))};
|
|
for(unsigned i=0;i<7;++i)item.gloveAttributes[i]={p[102+3*i],std::bit_cast<int16_t>(static_cast<uint16_t>(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<bytes[8];++tab) {
|
|
const auto* p=bytes.data()+9+4953*tab;
|
|
SetShopTab(tab,std::string(reinterpret_cast<const char*>(p),strnlen(reinterpret_cast<const char*>(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<int32_t>(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<int64_t>(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<uint8_t> 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<uint8_t>(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<uint8_t,58> bytes{};bytes[0]=57;bytes[1]=buy?1:0;
|
|
if(buy) {
|
|
for(unsigned i=0;i<4;++i)bytes[53+i]=static_cast<uint8_t>(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<uint8_t> 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<uint8_t>(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<uint32_t>(p.arg1), p.arg3);
|
|
for (int i = 0; i < static_cast<int>(ITEM_SOCKET_SLOT_MAX_NUM); ++i) {
|
|
CPythonExchange::Instance().SetItemMetinSocketToSelf(pos, i, p.alValues[i]);
|
|
}
|
|
for (int i = 0; i < static_cast<int>(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<int>(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<uint32_t>(p.arg1), p.arg3);
|
|
for (int i = 0; i < static_cast<int>(ITEM_SOCKET_SLOT_MAX_NUM); ++i) {
|
|
CPythonExchange::Instance().SetItemMetinSocketToTarget(pos, i, p.alValues[i]);
|
|
}
|
|
for (int i = 0; i < static_cast<int>(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<int>(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<uint32_t>(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<uint8_t> 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<uint8_t>(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<uint8_t>& bytes,uint16_t value) { bytes.push_back(value);bytes.push_back(value>>8); }
|
|
void append32(std::vector<uint8_t>& 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<uint8_t>& 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<copy && text[i];++i) bytes[start+i]=static_cast<uint8_t>(text[i]);
|
|
}
|
|
std::vector<uint8_t> guild_packet(uint8_t subheader) { return {HEADER_CG_GUILD,subheader}; }
|
|
}
|
|
|
|
// ── Script / quest (AVA2 PythonNetworkStreamPhaseGame.cpp) ──
|
|
bool PythonNetworkStream::SendAnswerMakeGuildPacket(const char* name) {
|
|
std::vector<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> bytes{HEADER_CG_QUEST_CONFIRM,answer};append32(bytes,pid);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendSelectItemPacket(uint32_t itemPos) {
|
|
std::vector<uint8_t> bytes{HEADER_CG_SCRIPT_SELECT_ITEM};append32(bytes,itemPos);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendTargetInfoLoadPacket(uint32_t vid) {
|
|
std::vector<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t>(static_cast<uint8_t>(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<std::chrono::milliseconds(1000)) return true;
|
|
m_lastGuildCommentRefresh=now;
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_REFRESH_COMMENT);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendGuildChangeMemberGradePacket(uint32_t pid,uint8_t grade) {
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE);append32(bytes,pid);bytes.push_back(grade);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendGuildUseSkillPacket(uint32_t skillID,uint32_t targetVID) {
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_USE_SKILL);append32(bytes,skillID);append32(bytes,targetVID);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendGuildChangeMemberGeneralPacket(uint32_t pid,uint8_t flag) {
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL);append32(bytes,pid);bytes.push_back(flag);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendGuildInviteAnswerPacket(uint32_t guildID,uint8_t answer) {
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER);append32(bytes,guildID);bytes.push_back(answer);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendGuildChargeGSPPacket(uint32_t money) {
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_CHARGE_GSP);append32(bytes,money);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendGuildDepositMoneyPacket(uint32_t money) {
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_DEPOSIT_MONEY);append32(bytes,money);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
bool PythonNetworkStream::SendGuildWithdrawMoneyPacket(uint32_t money) {
|
|
auto bytes=guild_packet(GUILD_SUBHEADER_CG_WITHDRAW_MONEY);append32(bytes,money);
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
|
|
bool PythonNetworkStream::SendRefinePacket(uint8_t pos,uint8_t type,uint8_t storage,int32_t index) {
|
|
const uint8_t bytes[]={HEADER_CG_REFINE,pos,type,storage,static_cast<uint8_t>(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<uint8_t> 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<uint8_t> 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<uint8_t>(answer)};
|
|
Send(bytes,sizeof(bytes));return true;
|
|
}
|
|
bool PythonNetworkStream::SendScriptButtonPacket(int button) {
|
|
std::vector<uint8_t> bytes{HEADER_CG_SCRIPT_BUTTON};append32(bytes,static_cast<uint32_t>(button));
|
|
Send(bytes.data(),bytes.size());return true;
|
|
}
|
|
|
|
} // namespace ava2
|
|
|
|
namespace ava2 {
|
|
bool PythonNetworkStream::SendBuildOfflineShopPacket(const std::string& name,const std::vector<TOfflineShopItemTable>& items,uint32_t vnum,uint8_t title) {
|
|
// Serialize the original Win32 packed layout. Original unused fields are zeroed.
|
|
std::vector<uint8_t> 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<uint8_t>(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<width;++i)bytes.push_back(uint8_t(value>>(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<uint8_t> 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;
|
|
}
|
|
}
|