From efd3a44fa04a89d9fc9633ef073f0450ccab7150 Mon Sep 17 00:00:00 2001 From: shen <> Date: Thu, 8 Oct 2026 02:11:08 -0700 Subject: [PATCH] feat(parity): replicate batch items pickup, dragon soul refine packet, target sync, and attackability (pass35) --- docs/AVA2-PACKET-CONSTANTS.json | 2 +- docs/WINDOWS-PARITY.md | 22 +++++++++ src/eter_net/Packet.h | 71 ++++++++++++++++++++++++++++ src/eter_net/PythonNetworkStream.cpp | 25 ++++++++++ src/eter_net/PythonNetworkStream.h | 2 + src/python_gameplay_modules.cpp | 64 +++++++++++++++++++++++-- 6 files changed, 181 insertions(+), 5 deletions(-) diff --git a/docs/AVA2-PACKET-CONSTANTS.json b/docs/AVA2-PACKET-CONSTANTS.json index d96ebad9..28a4cc71 100644 --- a/docs/AVA2-PACKET-CONSTANTS.json +++ b/docs/AVA2-PACKET-CONSTANTS.json @@ -1,6 +1,6 @@ { "reference": "upstream/ava2-client/UserInterface/Packet.h preprocessed with AVA2 Windows feature headers", - "checked": 243, + "checked": 301, "mismatches": [], "unmatched": [] } diff --git a/docs/WINDOWS-PARITY.md b/docs/WINDOWS-PARITY.md index ee4651bc..df857e24 100644 --- a/docs/WINDOWS-PARITY.md +++ b/docs/WINDOWS-PARITY.md @@ -785,3 +785,25 @@ Validation: macOS build and Android arm64 libmain.so pass. Five targeted CTests - CTest suite: **41/41 tests passed (100%)**. - Android arm64 `libmain.so` and macOS arm64 `ava2_client` build cleanly. +## 2026-10-08 pass35 — Batch items pickup, dragon soul refine packet, target sync, and attackability parity +- **Comprehensive Packet Constants Expansion (`src/eter_net/Packet.h`)**: + - Added 58 missing packet constants to `EPacketCG` and `EPacketGC` including `HEADER_CG_ITEMS_PICKUP = 235`, `HEADER_CG_DRAGON_SOUL_REFINE = 205`, `HEADER_CG_PVP = 41`, `HEADER_CG_SHOP = 50`, `HEADER_CG_MYSHOP = 55`, `HEADER_CG_OFFLINE_SHOP = 57`, `HEADER_CG_EMPIRE = 90`, `HEADER_GC_EMPIRE = 90`, `HEADER_CG_DUNGEON = 110`, `HEADER_CG_SASH = 211`, `HEADER_CG_FISHING = 222`, etc. + - Checked packet constants increased from 243 to **301/301 (100% parity)** with 0 mismatches and 0 unmatched. + - Added wire structures `TPacketCGItemsPickUp` and `TPacketCGDragonSoulRefine`. +- **Batch Ground Item Pickup Parity (`PythonNetworkStream.h` / `.cpp`, `python_gameplay_modules.cpp`)**: + - Implemented `SendItemsPickUpPacket(const std::vector& itemVector)` sending `TPacketCGItemsPickUp` followed by vector item VIDs. + - Updated `player_PickCloseItemVector` to send a single batch `SendItemsPickUpPacket` rather than looping individual single item packets, matching upstream `CPythonPlayer::SendPickUPItemPacket`. +- **Dragon Soul Refinement Parity (`PythonNetworkStream.h` / `.cpp`, `python_gameplay_modules.cpp`)**: + - Implemented `SendDragonSoulRefinePacket(uint8_t bRefineType, const TItemPos* pos)` matching upstream `CPythonNetworkStream::SendDragonSoulRefinePacket`. + - Replicated `player_SendDragonSoulRefine` 1:1, parsing dictionary `(window_type, cell)` into `TItemPos RefineItemPoses[DS_REFINE_WINDOW_MAX_NUM]` and dispatching the network packet. +- **Targeting & Attackability Parity (`python_gameplay_modules.cpp`)**: + - Updated `player_SetTarget` and `player_ClearTarget` (and `player_Clear`) to send `SendTargetPacket(vid)` / `SendTargetPacket(0)`. + - Replicated upstream `CInstanceBase::IsAttackableInstance` in `player_CanAttackInstance`: friendly NPCs (`bType == 1`) return false, monsters (`bType == 0`) return true, and PCs check killer state, empire, PK mode (Free, Revenge alignment conflict, Guild), and self VID. +- **Results**: + - Checked packet constants: **301/301 (100%)**, 0 mismatches, 0 unmatched. + - `python3 tools/audit_windows_parity.py`: **0 placeholder bindings**. + - `python3 tools/audit_ava2_python_interfaces.py`: **46 Windows modules compared; 0 missing methods; 0 overlapping placeholder methods**. + - CTest suite: **41/41 tests passed (100%)**. + - Android arm64 `libmain.so` and macOS arm64 `ava2_client` build cleanly. + + diff --git a/src/eter_net/Packet.h b/src/eter_net/Packet.h index fc6569ca..80ed5372 100644 --- a/src/eter_net/Packet.h +++ b/src/eter_net/Packet.h @@ -107,6 +107,45 @@ enum EPacketCG { HEADER_CG_ANSWER_MAKE_GUILD = 81, HEADER_CG_SCRIPT_SELECT_ITEM = 114, HEADER_CG_QUEST_INPUT_LONG_STRING = 214, + HEADER_CG_PLAYER_CREATE = 4, + HEADER_CG_PLAYER_DESTROY = 5, + HEADER_CG_PLAYER_SELECT = 6, + HEADER_CG_CHARACTER_MOVE = 7, + HEADER_CG_PVP = 41, + HEADER_CG_SHOP = 50, + HEADER_CG_MYSHOP = 55, + HEADER_CG_OFFLINE_SHOP = 57, + HEADER_CG_EMPIRE = 90, + HEADER_CG_MARK_LOGIN = 100, + HEADER_CG_MARK_CRCLIST = 101, + HEADER_CG_MARK_UPLOAD = 102, + HEADER_CG_CRC_REPORT = 103, + HEADER_CG_MARK_IDXLIST = 104, + HEADER_CG_HACK = 105, + HEADER_CG_CHANGE_NAME = 106, + HEADER_CG_SMS = 107, + HEADER_CG_CHINA_MATRIX_CARD = 108, + HEADER_CG_LOGIN2 = 109, + HEADER_CG_DUNGEON = 110, + HEADER_CG_LOGIN3 = 111, + HEADER_CG_GUILD_SYMBOL_UPLOAD = 112, + HEADER_CG_GUILD_SYMBOL_CRC = 113, + HEADER_CG_LOGIN4 = 115, + HEADER_CG_LOGIN5_OPENID = 116, + HEADER_CG_REQUEST_FLAG = 118, + HEADER_CG_MINI_GAME_CATCH_KING = 163, + HEADER_CG_RUNUP_MATRIX_ANSWER = 201, + HEADER_CG_NEWCIBN_PASSPOD_ANSWER = 202, + HEADER_CG_HS_ACK = 203, + HEADER_CG_DRAGON_SOUL_REFINE = 205, + HEADER_CG_67_ATTR = 208, + HEADER_CG_CLOSE_67_ATTR = 209, + HEADER_CG_SASH = 211, + HEADER_CG_CALENDAR_SYSTEM = 220, + HEADER_CG_FISHING = 222, + HEADER_CG_ITEMS_PICKUP = 235, + HEADER_CG_KEY_AGREEMENT = 251, + HEADER_CG_CLIENT_VERSION = 253, }; // AVA2 Packet.h limits and CG subheaders used by the messenger/guild/quest senders. @@ -270,6 +309,25 @@ enum EPacketGC { HEADER_GC_HANDSHAKE_OK = 0xfc, HEADER_GC_PHASE = 0xfd, HEADER_GC_HANDSHAKE = 0xff, + HEADER_GC_ITEM_UNBIND_TIME = 33, + HEADER_GC_ALERT = 35, + HEADER_GC_EMPIRE = 90, + HEADER_GC_MARK_BLOCK = 100, + HEADER_GC_MARK_DIFF_DATA = 101, + HEADER_GC_MARK_IDXLIST = 102, + HEADER_GC_CHINA_MATRIX_CARD = 116, + HEADER_GC_LOGIN_KEY = 118, + HEADER_GC_GUILD_SYMBOL_DATA = 133, + HEADER_GC_AUTH_SUCCESS = 150, + HEADER_GC_PANAMA_PACK = 151, + HEADER_GC_AUTH_SUCCESS_OPENID = 154, + HEADER_GC_RUNUP_MATRIX_QUIZ = 201, + HEADER_GC_NEWCIBN_PASSPOD_REQUEST = 202, + HEADER_GC_NEWCIBN_PASSPOD_FAILURE = 203, + HEADER_GC_RESPOND_CHANNELSTATUS = 210, + HEADER_GC_KEY_AGREEMENT_COMPLETED = 250, + HEADER_GC_KEY_AGREEMENT = 251, + HEADER_GC_BINDUDP = 254, }; enum EExchangeSubheaderCG { @@ -462,6 +520,19 @@ struct TPacketCGSyncPositionElement { int32_t lY; }; +constexpr size_t DS_REFINE_WINDOW_MAX_NUM = 15; + +struct TPacketCGItemsPickUp { + uint8_t header; + uint32_t count; +}; + +struct TPacketCGDragonSoulRefine { + uint8_t header; + uint8_t bSubType; + TItemPos ItemGrid[DS_REFINE_WINDOW_MAX_NUM]; +}; + // 1:1 upstream SPacketCGRefine (Locale_inc.h: ENABLE_MULTI_REFINE_WORLDARD on, // ENABLE_FEATURES_REFINE_SYSTEM off) -> 5 bytes. struct TPacketCGRefine { diff --git a/src/eter_net/PythonNetworkStream.cpp b/src/eter_net/PythonNetworkStream.cpp index c5377b99..294c9d39 100644 --- a/src/eter_net/PythonNetworkStream.cpp +++ b/src/eter_net/PythonNetworkStream.cpp @@ -1305,6 +1305,31 @@ bool PythonNetworkStream::SendItemPickUpPacket(uint32_t vid) { return true; } +bool PythonNetworkStream::SendItemsPickUpPacket(const std::vector& itemVector) { + if(!main_actor_can_act(m_dwMainActorVID)) return true; + if (itemVector.empty()) return true; + TPacketCGItemsPickUp p{}; + p.header = HEADER_CG_ITEMS_PICKUP; + p.count = static_cast(itemVector.size()); + Send(&p, sizeof(p)); + for (uint32_t vid : itemVector) { + Send(&vid, sizeof(vid)); + } + return true; +} + +bool PythonNetworkStream::SendDragonSoulRefinePacket(uint8_t bRefineType, const TItemPos* pos) { + if(!main_actor_can_act(m_dwMainActorVID)) return true; + TPacketCGDragonSoulRefine p{}; + p.header = HEADER_CG_DRAGON_SOUL_REFINE; + p.bSubType = bRefineType; + if (pos) { + std::copy_n(pos, DS_REFINE_WINDOW_MAX_NUM, p.ItemGrid); + } + 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; diff --git a/src/eter_net/PythonNetworkStream.h b/src/eter_net/PythonNetworkStream.h index cf8fe19b..cc89aa73 100644 --- a/src/eter_net/PythonNetworkStream.h +++ b/src/eter_net/PythonNetworkStream.h @@ -84,6 +84,8 @@ public: bool SendItemUsePacket(uint8_t window, uint16_t cell); bool SendItemMovePacket(uint8_t srcWindow, uint16_t srcCell, uint8_t dstWindow, uint16_t dstCell, uint32_t count); bool SendItemPickUpPacket(uint32_t vid); + bool SendItemsPickUpPacket(const std::vector& itemVector); + bool SendDragonSoulRefinePacket(uint8_t bRefineType, const TItemPos* pos); bool SendItemDropPacket(uint8_t window, uint16_t cell, uint32_t gold); bool SendItemDropPacketNew(uint8_t window,uint16_t cell,uint32_t gold,uint32_t count); bool SendOnClickPacket(uint32_t vid); diff --git a/src/python_gameplay_modules.cpp b/src/python_gameplay_modules.cpp index 5c4fdc4e..c041e993 100644 --- a/src/python_gameplay_modules.cpp +++ b/src/python_gameplay_modules.cpp @@ -2292,9 +2292,34 @@ static PyObject* player_ActEmotion(PyObject*, PyObject* args) { static PyObject* player_CanAttackInstance(PyObject*, PyObject* args) { int vid = 0; if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException(); + const auto* mainActor = player_main_actor(); const auto* target = NetworkActorManager::Instance().GetActorData(vid); - if (!target) return Py_BuildValue("i", 0); - return Py_BuildValue("i", 1); + if (!mainActor || !target) return Py_BuildValue("i", 0); + if (mainActor->m_dwVID == target->m_dwVID) return Py_BuildValue("i", 0); + + // If target is PC (bType == 6) + if (target->m_bType == 6) { + if (target->m_dwStateFlags & NetworkActorManager::ADD_CHARACTER_STATE_KILLER) return Py_BuildValue("i", 1); + if (mainActor->m_byPKMode == 1 /* PK_MODE_FREE */ && target->m_byPKMode != 4 /* PK_MODE_PROTECT */) + return Py_BuildValue("i", 1); + if (mainActor->m_dwEmpireID != target->m_dwEmpireID) + return Py_BuildValue("i", 1); + if (mainActor->m_byPKMode == 2 /* PK_MODE_GUILD */ && mainActor->m_dwGuildID != 0 && mainActor->m_dwGuildID != target->m_dwGuildID) + return Py_BuildValue("i", 1); + if (mainActor->m_byPKMode == 3 /* PK_MODE_REVENGE */) { + if ((mainActor->m_sAlignment < 0 && target->m_sAlignment >= 0) || (mainActor->m_sAlignment >= 0 && target->m_sAlignment < 0)) + return Py_BuildValue("i", 1); + } + return Py_BuildValue("i", 0); + } + + // If target is Mob / Monster (bType == 0) + if (target->m_bType == 0) { + return Py_BuildValue("i", 1); + } + + // Friendly NPC (bType == 1, etc.) + return Py_BuildValue("i", 0); } static PyObject* player_ChangeCurrentSkillNumberOnly(PyObject*, PyObject* args) { @@ -2309,6 +2334,7 @@ static PyObject* player_Clear(PyObject*, PyObject*) { s_playerSkills.clear(); s_skillSlots.clear(); s_targetVID = 0; + PythonNetworkStream::Instance().SendTargetPacket(0); return Py_BuildNone(); } @@ -2319,6 +2345,7 @@ static PyObject* player_ClearSkillDict(PyObject*, PyObject*) { static PyObject* player_ClearTarget(PyObject*, PyObject*) { s_targetVID = 0; + PythonNetworkStream::Instance().SendTargetPacket(0); return Py_BuildNone(); } @@ -2510,6 +2537,7 @@ static PyObject* player_SetTarget(PyObject*, PyObject* args) { int vid = 0; if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException(); s_targetVID = uint32_t(vid); + PythonNetworkStream::Instance().SendTargetPacket(uint32_t(vid)); return Py_BuildNone(); } @@ -2627,8 +2655,8 @@ static PyObject* player_PickCloseItem(PyObject*, PyObject*) { static PyObject* player_PickCloseItemVector(PyObject*, PyObject*) { std::vector outVids; if (GroundItemStore::Instance().GetCloseItemVector(s_playerName, s_mainActorPos.x, s_mainActorPos.y, outVids, 300.0f)) { - for (uint32_t vid : outVids) { - PythonNetworkStream::Instance().SendItemPickUpPacket(vid); + if (!outVids.empty()) { + PythonNetworkStream::Instance().SendItemsPickUpPacket(outVids); } } return Py_BuildNone(); @@ -2670,6 +2698,34 @@ static PyObject* player_SendClickItemPacket(PyObject*, PyObject* args) { static PyObject* player_SendDragonSoulRefine(PyObject*, PyObject* args) { int subHeader = 0; if (!PyTuple_GetInteger(args, 0, &subHeader)) return Py_BuildException(); + TItemPos RefineItemPoses[DS_REFINE_WINDOW_MAX_NUM]{}; + switch (subHeader) { + case DS_SUB_HEADER_CLOSE: + break; + case DS_SUB_HEADER_DO_UPGRADE: + case DS_SUB_HEADER_DO_IMPROVEMENT: + case DS_SUB_HEADER_DO_REFINE: { + PyObject* pDic = nullptr; + if (PyTuple_Size(args) > 1) { + pDic = PyTuple_GetItem(args, 1); + if (pDic && PyDict_Check(pDic)) { + Py_ssize_t pos = 0; + PyObject *key = nullptr, *value = nullptr; + while (PyDict_Next(pDic, &pos, &key, &value)) { + int i = PyInt_AsLong(key); + if (i >= 0 && i < (int)DS_REFINE_WINDOW_MAX_NUM && PyTuple_Check(value) && PyTuple_Size(value) >= 2) { + int wType = 0, cell = 0; + PyTuple_GetInteger(value, 0, &wType); + PyTuple_GetInteger(value, 1, &cell); + RefineItemPoses[i] = TItemPos(uint8_t(wType), uint16_t(cell)); + } + } + } + } + break; + } + } + PythonNetworkStream::Instance().SendDragonSoulRefinePacket(uint8_t(subHeader), RefineItemPoses); return Py_BuildNone(); }