From 8d505c3d34fae976356802284d80509f92c30dc8 Mon Sep 17 00:00:00 2001 From: shen <> Date: Thu, 8 Oct 2026 04:05:06 -0700 Subject: [PATCH] feat: pass37 - CPythonItem singleton, battle status math, and regen safe range parity --- docs/WINDOWS-PARITY.md | 30 +- src/eter_net/NetworkActorManager.h | 7 + src/eter_net/PythonNetworkStream.cpp | 27 +- src/python_gameplay_modules.cpp | 555 ++++++++++++++++++++------- src/python_gameplay_modules.h | 7 + src/python_item.h | 414 ++++++++++++++++++++ 6 files changed, 895 insertions(+), 145 deletions(-) create mode 100644 src/python_item.h diff --git a/docs/WINDOWS-PARITY.md b/docs/WINDOWS-PARITY.md index b77640f9..7600bf54 100644 --- a/docs/WINDOWS-PARITY.md +++ b/docs/WINDOWS-PARITY.md @@ -833,4 +833,32 @@ 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 pass37 — CPythonItem ground item manager, weapon battle status math, arrow validation, and regen safe range parity +- **CPythonItem Singleton (`src/python_item.h`)**: + - Implemented `CPythonItem` singleton matching upstream `UserInterface/PythonItem.h` with `TGroundItemInstance` tracking (vnum, coordinates, count, 8 sockets, 15 attributes, 7 glove attributes). + - Templated `CreateItem(..., const TSocket* alSockets = nullptr, ...)` to support both `int32_t` and `long` socket arrays seamlessly across 32-bit and 64-bit architectures. + - Added `DeleteAllItems()`, `DeleteItem(vid)`, `GetGroundItemPosition(vid, &x, &y, &z)`, `GetCloseItemVector(name, actorPos, &vector)`, and distance checking (`GetDistance`). +- **PythonNetworkStream Ground Item & Main Actor Race Integration (`src/eter_net/PythonNetworkStream.cpp`)**: + - Connected `RecvItemGroundAddPacket` to instantiate items in `CPythonItem::Instance().CreateItem(...)` with wire sockets, attributes, and count. + - Linked `SetPlayerRace(m_wMainActorRace)` into `MainCharacterLoaded` on character spawn. +- **Weapon Power & Battle Status Math Parity (`src/python_gameplay_modules.h`, `.cpp`)**: + - Implemented exact formula parity for `GetPlayerRaceStat(job, point)`: Warrior (STR, DEX), Assassin (DEX, STR), Sura (STR, DEX), Shaman (INT, DEX), and Wolfman (STR, DEX). + - Implemented `GetHitRate(dx, str)` and `GetEvadeRate(dex, con)` matching `CInstanceBase::GetHitRate` and `GetEvadeRate`. + - Implemented `UpdateBattleStatus()` recalculating `POINT_HIT_RATE`, `POINT_EVADE_RATE`, `POINT_MIN_WEP`, `POINT_MAX_WEP`, `POINT_MIN_MAGIC_WEP`, `POINT_MAX_MAGIC_WEP`, `POINT_MIN_ATK`, and `POINT_MAX_ATK`. + - Implemented `UpdateEquippedWeaponPower()` taking into account weapon slot (184), sash absorption slot (202), and rarity socket bonuses. + - Corrected `SetPlayerItemData` to trigger `UpdateEquippedWeaponPower()` upon modifying slots 184 or 202. + - Preserved raw status point setters (`SetPlayerStatusPoint` and `player_SetStatus`) without overwriting test mocks. +- **Arrow & Ammo Verification (`src/python_gameplay_modules.h`, `.cpp`)**: + - Implemented `HasEnoughArrow()` checking slot 189 (`c_Equipment_Arrow`) for arrows or quivers, firing `"OnCannotShotError"` when unequipped or depleted. +- **Regen & Safe Range Mechanics (`src/python_gameplay_modules.h`, `.cpp`, `NetworkActorManager.h`)**: + - Added `GetMobWithVnum(mobVnum, out)` in `NetworkActorManager` matching `CPythonCharacterManager::GetMobWithVnum`. + - Implemented `LoadNewRegen()` parsing `locale/newregen.txt` tab-delimited records filtered by current map name under `ENABLE_ULTIMATE_REGEN`. + - Implemented `CheckBossSafeRange()` with `DISTANCE_APPROX_SERVER` approximation and actor distance checks. +- **Item Classification Feature Flag Alignment (`src/python_gameplay_modules.cpp`)**: + - Aligned `item_Classify` switch with upstream `Locale_inc.h` where `ENABLE_SOULBIND_SYSTEM` and `ELEMENT_SPELL_WORLDARD` are commented out, properly falling back to `"USE_UNKNOWN_TYPE"`. +- **Results**: + - Checked packet constants: **395/395 (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/NetworkActorManager.h b/src/eter_net/NetworkActorManager.h index 8a13906e..2dfe47fa 100644 --- a/src/eter_net/NetworkActorManager.h +++ b/src/eter_net/NetworkActorManager.h @@ -271,6 +271,13 @@ public: const SNetworkActorData* GetActorData(uint32_t vid) const; std::shared_ptr GetActorInstance(uint32_t vid); const std::unordered_map& GetActorDict() const { return m_actors; } + void GetMobWithVnum(uint32_t mobVnum, std::vector& out) const { + for (const auto& [vid, actor] : m_actors) { + if (actor.m_dwRace == mobVnum || actor.m_dwVirtualNumber == mobVnum) { + out.push_back(&actor); + } + } + } // Helpers to build 3D rendering draw calls for all visible network actors std::vector BuildDrawCommands(float animTime); diff --git a/src/eter_net/PythonNetworkStream.cpp b/src/eter_net/PythonNetworkStream.cpp index 3eeee6c5..3690d648 100644 --- a/src/eter_net/PythonNetworkStream.cpp +++ b/src/eter_net/PythonNetworkStream.cpp @@ -1,4 +1,5 @@ #include "item_sound.h" +#include "python_item.h" #include "PythonNetworkStream.h" #include "python_net.h" #include "guild_state.h" @@ -487,6 +488,7 @@ bool PythonNetworkStream::RecvMainCharacter3BGM() { 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); + SetPlayerRace(m_wMainActorRace); SetMainCharacterName(m_strMainActorName);SetMainCharacterPosition(localX,localY,z); inventory_callback(m_phaseWindows[4],"LoadData",Py_BuildValue("ii",x,y)); std::vector version(67,0);version[0]=HEADER_CG_CLIENT_VERSION2; @@ -958,17 +960,18 @@ bool PythonNetworkStream::RecvItemGroundAddPacket() { TPacketGCItemGroundAdd p; if (!Read(sizeof(p), &p)) return false; - GlobalToLocalPosition(p.lX,p.lY); - float wx = static_cast(p.lX); - float wy = static_cast(p.lZ); - float wz = static_cast(p.lY); + GlobalToLocalPosition(p.lX, p.lY); - std::string itemName; - int itemType = 0; - if (!GetItemNameAndType(p.dwVnum, &itemName, &itemType) || itemName.empty()) { - itemName = "Item " + std::to_string(p.dwVnum); - } - TextTailManager::Instance().RegisterItemTextTail(p.dwVID, itemName, wx, wy, wz); + CPythonItem::Instance().CreateItem(p.dwVID, + p.dwVnum, + static_cast(p.lX), + static_cast(p.lY), + static_cast(p.lZ), + true, + p.alSockets, + p.aAttrs, + p.itemCount, + int(p.ownerTime + time(nullptr))); if (m_groundItemCallback) { m_groundItemCallback(p.dwVID, p.dwVnum, p.lX, p.lY, p.lZ, true); @@ -980,7 +983,7 @@ bool PythonNetworkStream::RecvItemGroundDelPacket() { TPacketGCItemGroundDel p; if (!Read(sizeof(p), &p)) return false; - TextTailManager::Instance().DeleteItemTextTail(p.vid); + CPythonItem::Instance().DeleteItem(p.vid); if (m_groundItemCallback) { m_groundItemCallback(p.vid, 0, 0, 0, 0, false); @@ -992,7 +995,7 @@ bool PythonNetworkStream::RecvItemOwnership() { TPacketGCItemOwnership p; if (!Read(sizeof(p), &p)) return false; - TextTailManager::Instance().SetItemTextTailOwner(p.dwVID, p.szName); + CPythonItem::Instance().SetOwnership(p.dwVID, p.szName); return true; } diff --git a/src/python_gameplay_modules.cpp b/src/python_gameplay_modules.cpp index 7bc159fa..b595d298 100644 --- a/src/python_gameplay_modules.cpp +++ b/src/python_gameplay_modules.cpp @@ -3,6 +3,7 @@ #include "python_minimap.h" #include "python_background.h" #include "item_sound.h" +#include "python_item.h" #include "item_proto.h" #include "python_gameplay_modules.h" #include "python_runtime.h" @@ -225,12 +226,16 @@ static PyObject* player_SetStatus(PyObject*, PyObject* args) { int type = 0; long long value = 0; if (PyArg_ParseTuple(args, "iL", &type, &value)) { - if(uint32_t(type)<255)s_playerPoints[type] = value; + if(uint32_t(type)<255) { + s_playerPoints[type] = value; + } } else { PyErr_Clear(); long lVal = 0; if (PyArg_ParseTuple(args, "il", &type, &lVal)) { - if(uint32_t(type)<255)s_playerPoints[type] = lVal; + if(uint32_t(type)<255) { + s_playerPoints[type] = lVal; + } } } Py_RETURN_NONE; @@ -397,6 +402,16 @@ static bool select_item_data(uint32_t id) { if(range && s_itemMap.find(range->vnum)!=s_itemMap.end()){s_selectedItemVnum=range->vnum;s_hasSelectedItem=true;return true;} return false; } +static const ItemInfo* find_item_info(uint32_t id) { + auto it = s_itemMap.find(id); + if (it != s_itemMap.end()) return &it->second; + const auto* range = s_itemProto.find(id); + if (range) { + it = s_itemMap.find(range->vnum); + if (it != s_itemMap.end()) return &it->second; + } + return nullptr; +} static PyObject* item_SelectItem(PyObject*, PyObject* args) { int vnum = 0; if (!PyArg_ParseTuple(args, "i", &vnum)) return nullptr; @@ -1443,11 +1458,172 @@ static PyObject* player_GetKillLOG(PyObject*,PyObject* args) { return Py_BuildValue("l",long(index>=0 && indexm_dwRace : 0; +} + +static uint32_t GetPlayerRaceStat() { + switch (GetPlayerRace()) { + case 0: /* MAIN_RACE_WARRIOR_M */ + case 4: /* MAIN_RACE_WARRIOR_W */ + return static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)); + case 5: /* MAIN_RACE_ASSASSIN_M */ + case 1: /* MAIN_RACE_ASSASSIN_W */ + return static_cast(GetPlayerStatusPoint(14 /* POINT_DX */)); + case 2: /* MAIN_RACE_SURA_M */ + case 6: /* MAIN_RACE_SURA_W */ + return static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)); + case 3: /* MAIN_RACE_SHAMAN_W */ + case 7: /* MAIN_RACE_SHAMAN_M */ + return static_cast(GetPlayerStatusPoint(15 /* POINT_IQ */)); + case 8: /* MAIN_RACE_WOLFMAN_M */ + return static_cast(GetPlayerStatusPoint(14 /* POINT_DX */)); + } + return static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)); +} + +static uint32_t GetHitRate() { + long long dx = GetPlayerStatusPoint(14 /* POINT_DX */); + long long level = GetPlayerStatusPoint(1 /* POINT_LEVEL */); + long long src = (dx * 4 + level * 2) / 6; + return static_cast(100 * (std::min(150LL, src) + 210) / 300); +} + +static uint32_t GetEvadeRate() { + long long dx = GetPlayerStatusPoint(14 /* POINT_DX */); + return static_cast(30 * (2 * dx + 5) / (dx + 95)); +} + +static uint32_t GetTotalAtk(uint32_t dwWeaponPower, uint32_t dwRefineBonus) { + uint32_t dwLvAtk = 2 * static_cast(GetPlayerStatusPoint(1 /* POINT_LEVEL */)); + uint32_t dwStAtk = (4 * static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)) + 2 * GetPlayerRaceStat()) / 3; + uint32_t hr = GetHitRate(); + uint32_t dwWepAtk = 2 * (dwWeaponPower + dwRefineBonus); + return dwLvAtk + (dwStAtk + dwWepAtk) * hr / 100; +} + +static void UpdateBattleStatus() { + s_playerPoints[0 /* POINT_NONE */] = 0; + s_playerPoints[18 /* POINT_EVADE_RATE */] = GetEvadeRate(); + s_playerPoints[204 /* POINT_HIT_RATE */] = GetHitRate(); + s_playerPoints[200 /* POINT_MIN_WEP */] = s_dwWeaponMinPower + s_dwWeaponAddPower; + s_playerPoints[201 /* POINT_MAX_WEP */] = s_dwWeaponMaxPower + s_dwWeaponAddPower; + s_playerPoints[202 /* POINT_MIN_MAGIC_WEP */] = s_dwWeaponMinMagicPower + s_dwWeaponAddPower; + s_playerPoints[203 /* POINT_MAX_MAGIC_WEP */] = s_dwWeaponMaxMagicPower + s_dwWeaponAddPower; + s_playerPoints[29 /* POINT_MIN_ATK */] = GetTotalAtk(s_dwWeaponMinPower, s_dwWeaponAddPower); + s_playerPoints[30 /* POINT_MAX_ATK */] = GetTotalAtk(s_dwWeaponMaxPower, s_dwWeaponAddPower); + + const auto sashItem = GetPlayerItemData(1, 202 /* c_Costume_Slot_Sash */); + if (sashItem.vnum != 0) { + auto absorbedVnum = sashItem.alSockets[1]; + if (absorbedVnum != 0) { + const auto* selectedItem = find_item_info(absorbedVnum); + if (selectedItem && (selectedItem->type == 1 /* ITEM_TYPE_WEAPON */ || (selectedItem->type == 28 /* COSTUME */ && selectedItem->subType == 3 /* COSTUME_WEAPON */))) { + auto oldMinWep = s_playerPoints[200 /* POINT_MIN_WEP */]; + auto oldMaxWep = s_playerPoints[201 /* POINT_MAX_WEP */]; + auto oldMinMag = s_playerPoints[202 /* POINT_MIN_MAGIC_WEP */]; + auto oldMaxMag = s_playerPoints[203 /* POINT_MAX_MAGIC_WEP */]; + auto oldMinAtt = s_playerPoints[29 /* POINT_MIN_ATK */]; + auto oldMaxAtt = s_playerPoints[30 /* POINT_MAX_ATK */]; + + double sashAbsorbPerc = static_cast(sashItem.alSockets[0]); + auto sashMinWep = static_cast(static_cast(selectedItem->values[3] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); + auto sashMaxWep = static_cast(static_cast(selectedItem->values[4] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); + auto sashMinMag = static_cast(static_cast(selectedItem->values[1] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); + auto sashMaxMag = static_cast(static_cast(selectedItem->values[2] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); + + s_playerPoints[200 /* POINT_MIN_WEP */] = oldMinWep + sashMinWep; + s_playerPoints[201 /* POINT_MAX_WEP */] = oldMaxWep + sashMaxWep; + s_playerPoints[202 /* POINT_MIN_MAGIC_WEP */] = oldMinMag + sashMinMag; + s_playerPoints[203 /* POINT_MAX_MAGIC_WEP */] = oldMaxMag + sashMaxMag; + s_playerPoints[29 /* POINT_MIN_ATK */] = oldMinAtt + sashMinWep; + s_playerPoints[30 /* POINT_MAX_ATK */] = oldMaxAtt + sashMaxWep; + } + } + } +} + + +void SetWeaponPower(uint32_t dwMinPower, uint32_t dwMaxPower, uint32_t dwMinMagicPower, uint32_t dwMaxMagicPower, uint32_t dwAddPower) { + s_dwWeaponMinPower = dwMinPower; + s_dwWeaponMaxPower = dwMaxPower; + s_dwWeaponMinMagicPower = dwMinMagicPower; + s_dwWeaponMaxMagicPower = dwMaxMagicPower; + s_dwWeaponAddPower = dwAddPower; + UpdateBattleStatus(); +} + +void UpdateEquippedWeaponPower() { + uint32_t minPower = 0; + uint32_t maxPower = 0; + uint32_t minMagicPower = 0; + uint32_t maxMagicPower = 0; + uint32_t addPower = 0; + + const auto weaponSlot = GetPlayerItemData(1, 184 /* c_Equipment_Weapon */); + if (weaponSlot.vnum != 0) { + const auto* pkWeapon = find_item_info(weaponSlot.vnum); + if (pkWeapon && pkWeapon->type == 1 /* ITEM_TYPE_WEAPON */) { + minPower = pkWeapon->values[3]; + maxPower = pkWeapon->values[4]; + minMagicPower = pkWeapon->values[1]; + maxMagicPower = pkWeapon->values[2]; + addPower = pkWeapon->values[5]; + + long rarityValue = weaponSlot.alSockets[4 /* RARITY_VALUE_INDEX */]; + if (rarityValue > 0) { + long rarityType = weaponSlot.alSockets[5 /* RARITY_TYPE_INDEX */]; + maxPower += CPythonItem::Instance().GetRarityPoint(-2, rarityType); + maxMagicPower += CPythonItem::Instance().GetRarityPoint(-1, rarityType); + + uint32_t rarityMaxPower = CPythonItem::Instance().GetRarityPoint(-2, rarityType) * (float(maxPower) / 100.0f); + uint32_t rarityMaxMagicNumber = CPythonItem::Instance().GetRarityPoint(-1, rarityType) * (float(maxMagicPower) / 100.0f); + maxPower += rarityMaxPower; + maxMagicPower += rarityMaxMagicNumber; + } + } + } + SetWeaponPower(minPower, maxPower, minMagicPower, maxMagicPower, addPower); +} + +bool HasEnoughArrow() { + const auto arrowSlot = GetPlayerItemData(1, 189 /* c_Equipment_Arrow */); + if (arrowSlot.vnum != 0) { + const auto* pkArrow = find_item_info(arrowSlot.vnum); + if (pkArrow && pkArrow->type == 1 /* ITEM_TYPE_WEAPON */) { + if (pkArrow->subType == 6 /* WEAPON_ARROW */ || pkArrow->subType == 9 /* WEAPON_QUIVER */) { + return true; + } + } + } + uint32_t vid = PythonNetworkStream::Instance().GetMainActorVID(); + player_window_call("OnCannotShotError", Py_BuildValue("(is)", vid, "EMPTY_ARROW")); + return false; +} + void ResetPlayerState() { s_coolTimeEnabled=true; s_playerName.clear();s_mainActorPos={};s_playerPoints.clear();s_playerSkills.clear();s_skillSlots.clear(); s_quickPage=0;s_playTime=0;s_playerQuickSlots.fill({});s_playerItems.fill({});s_windowItems.clear(); s_partyMembers.clear();s_challengeInstances.clear();s_revengeInstances.clear();s_cantFightInstances.clear();s_killLog.fill(0); + s_dwWeaponMinPower = 0; s_dwWeaponMaxPower = 0; + s_dwWeaponMinMagicPower = 0; s_dwWeaponMaxMagicPower = 0; + s_dwWeaponAddPower = 0; + s_playerRace = 0; + CPythonItem::Instance().DeleteAllItems(); } void SetPlayerItemData(uint8_t window,uint16_t cell,const TItemData& data) { @@ -1457,6 +1633,9 @@ void SetPlayerItemData(uint8_t window,uint16_t cell,const TItemData& data) { for(size_t i=0;isecond.name : ""; - TextTailManager::Instance().RegisterItemTextTail(vid, name.empty() ? ("Item " + std::to_string(vnum)) : name, x, y, z); - } - - void DeleteItem(uint32_t vid) { - m_items.erase(vid); - TextTailManager::Instance().DeleteItemTextTail(vid); - if (m_pickedItemID == vid) - m_pickedItemID = 0xFFFFFFFF; - } - - void Clear() { - for (const auto& [vid, item] : m_items) { - TextTailManager::Instance().DeleteItemTextTail(vid); - } - m_items.clear(); - m_pickedItemID = 0xFFFFFFFF; - } - - void Update() {} - void Render() {} - - uint32_t GetPickedItemID() const { return m_pickedItemID; } - void SetPickedItemID(uint32_t id) { m_pickedItemID = id; } - - bool GetCloseItem(float px, float py, uint32_t* pItemId, float maxDist) { - uint32_t bestId = 0; - float bestDistSq = maxDist * maxDist; - for (const auto& [vid, item] : m_items) { - float dx = px - item.x; - float dy = py - (-item.y); - float distSq = dx * dx + dy * dy; - if (distSq < bestDistSq) { - bestDistSq = distSq; - bestId = vid; - } - } - if (bestId != 0) { - if (pItemId) *pItemId = bestId; - return true; - } - return false; - } - - bool GetCloseItemVector(const std::string& myName, float px, float py, std::vector& outVids, float maxDist) { - float maxDistSq = maxDist * maxDist; - for (const auto& [vid, item] : m_items) { - float dx = px - item.x; - float dy = py - (-item.y); - float distSq = dx * dx + dy * dy; - if (distSq < maxDistSq && (item.ownership.empty() || item.ownership == myName)) { - outVids.push_back(vid); - } - } - return true; - } - -private: - std::unordered_map m_items; - uint32_t m_pickedItemID = 0xFFFFFFFF; -}; +using GroundItemStore = CPythonItem; struct SDropItemEntry { uint32_t dropVnum = 0; @@ -1671,24 +1772,6 @@ struct SDropItemEntry { }; static std::unordered_map> s_chestDropInfoMap; -static bool is_rarity_item_vnum(uint32_t vnum) { - auto it = s_itemMap.find(vnum); - if (it == s_itemMap.end()) { - const auto* range = s_itemProto.find(vnum); - if (range) it = s_itemMap.find(range->vnum); - } - if (it != s_itemMap.end()) { - const auto& item = it->second; - if (item.type == 2) // ARMOR - return true; - if (item.type == 36) // RINGS - return true; - if (item.type == 1 && item.subType != 6 && item.subType != 9) // WEAPON, not ARROW(6) or QUIVER(9) - return true; - } - return false; -} - static PyObject* item_CreateItem(PyObject*, PyObject* poArgs) { int iVirtualID = 0, iVirtualNumber = 0; float x = 0.0f, y = 0.0f, z = 0.0f; @@ -1702,7 +1785,7 @@ static PyObject* item_CreateItem(PyObject*, PyObject* poArgs) { } PyTuple_GetBoolean(poArgs, 5, &bDrop); - GroundItemStore::Instance().CreateItem(uint32_t(iVirtualID), uint32_t(iVirtualNumber), x, y, z, bDrop); + CPythonItem::Instance().CreateItem(uint32_t(iVirtualID), uint32_t(iVirtualNumber), x, y, z, bDrop); return Py_BuildNone(); } @@ -1711,24 +1794,24 @@ static PyObject* item_DeleteItem(PyObject*, PyObject* poArgs) { if (!PyTuple_GetInteger(poArgs, 0, &iVirtualID)) return Py_BadArgument(); - GroundItemStore::Instance().DeleteItem(uint32_t(iVirtualID)); + CPythonItem::Instance().DeleteItem(uint32_t(iVirtualID)); return Py_BuildNone(); } static PyObject* item_Pick(PyObject*, PyObject*) { - uint32_t dwItemID = GroundItemStore::Instance().GetPickedItemID(); - if (dwItemID != 0xFFFFFFFF) + uint32_t dwItemID = 0; + if (CPythonItem::Instance().GetPickedItemID(&dwItemID)) return Py_BuildValue("i", dwItemID); return Py_BuildValue("i", -1); } static PyObject* item_Render(PyObject*, PyObject*) { - GroundItemStore::Instance().Render(); + CPythonItem::Instance().Render(); return Py_BuildNone(); } static PyObject* item_Update(PyObject*, PyObject*) { - GroundItemStore::Instance().Update(); + CPythonItem::Instance().Update(); return Py_BuildNone(); } @@ -1871,48 +1954,35 @@ static PyObject* item_IsRarityItem(PyObject*, PyObject* poArgs) { int szItemVnum = 0; if (!PyTuple_GetInteger(poArgs, 0, &szItemVnum)) return Py_BadArgument(); - return Py_BuildValue("i", is_rarity_item_vnum(uint32_t(szItemVnum)) ? 1 : 0); + return Py_BuildValue("i", CPythonItem::Instance().IsRarityItem(uint32_t(szItemVnum)) ? 1 : 0); } static PyObject* item_GetRarityPoint(PyObject*, PyObject* poArgs) { int szAttrID = 0, szRarityType = 0; if (!PyTuple_GetInteger(poArgs, 0, &szAttrID) || !PyTuple_GetInteger(poArgs, 1, &szRarityType)) return Py_BadArgument(); - - static const std::set s_rarityAttrs = { - -4, -3, -2, -1, - 19, 1, 5, 7, 6, 8, 15, 16, 12, 13, 17, 9, 10, 37, 3, 2, 41, 24, 23, - 59, 60, 61, 62, 54, 55, 56, 57, 27, 28, 43, 44, 64, 65, 63, 39, 40, - 38, 34, 35, 36, 71, 72, 53, 74, 75, 76, 77, 78, 79, 80 - }; - - if (s_rarityAttrs.count(szAttrID) > 0) { - static const int s_points[] = { 0, 5, 10, 20, 25, 30 }; - if (szRarityType >= 0 && szRarityType < 6) { - return Py_BuildValue("i", s_points[szRarityType]); - } - } - return Py_BuildValue("i", 0); + return Py_BuildValue("i", CPythonItem::Instance().GetRarityPoint(szAttrID, szRarityType)); } static PyObject* item_GetRarityMaxValue(PyObject*, PyObject* poArgs) { int szItemVnum = 0, szRarityType = 0; if (!PyTuple_GetInteger(poArgs, 0, &szItemVnum) || !PyTuple_GetInteger(poArgs, 1, &szRarityType)) return Py_BadArgument(); - - if (!is_rarity_item_vnum(uint32_t(szItemVnum))) - return Py_BuildValue("i", 0); - - static const int s_maxValues[] = { 50000, 75000, 100000, 150000, 200000, 300000 }; - if (szRarityType >= 0 && szRarityType < 6) { - return Py_BuildValue("i", s_maxValues[szRarityType]); - } - return Py_BuildValue("i", 0); + return Py_BuildValue("i", CPythonItem::Instance().GetRarityMaxValue(uint32_t(szItemVnum), szRarityType)); } static PyObject* item_IsSealScroll(PyObject*, PyObject* poArgs) { int vnum = 0; if (!PyTuple_GetInteger(poArgs, 0, &vnum)) return Py_BadArgument(); + if (!select_item_data(uint32_t(vnum))) + return Py_BuildException("Can't find select item data"); + auto it = (s_hasSelectedItem ? s_itemMap.find(s_selectedItemVnum) : s_itemMap.end()); + if (it == s_itemMap.end()) + return Py_BuildException("Can't find select item data"); + if (it->second.type != 3 /* ITEM_TYPE_USE */) + return Py_BuildValue("i", 0); + if (it->second.subType == 25 /* USE_BIND */ || it->second.subType == 26 /* USE_UNBIND */) + return Py_BuildValue("i", 1); return Py_BuildValue("i", 0); } @@ -1927,6 +1997,18 @@ static PyObject* item_GetUnlimitedSealDate(PyObject*, PyObject*) { static PyObject* item_IsElement(PyObject*, PyObject* poArgs) { int vnum = 0; if (!PyTuple_GetInteger(poArgs, 0, &vnum)) return Py_BadArgument(); + if (!select_item_data(uint32_t(vnum))) + return Py_BuildException("Can't find select item data"); + auto it = (s_hasSelectedItem ? s_itemMap.find(s_selectedItemVnum) : s_itemMap.end()); + if (it == s_itemMap.end()) + return Py_BuildException("Can't find select item data"); + if (it->second.type == 3 /* ITEM_TYPE_USE */) { + if (it->second.subType == 33 /* USE_ELEMENT_UPGRADE */ || + it->second.subType == 34 /* USE_ELEMENT_DOWNGRADE */ || + it->second.subType == 35 /* USE_ELEMENT_CHANGE */) { + return Py_BuildValue("i", 1); + } + } return Py_BuildValue("i", 0); } @@ -2711,7 +2793,212 @@ static PyObject* player_IsSkillActive(PyObject*, PyObject* args) { return Py_BuildValue("i", 0); } +struct TNewRegen { + long x = 0, y = 0; + uint8_t day = 0, hour = 0, minute = 0, second = 0; + long safeRange = 0; + uint32_t mob_vnum = 0; + uint8_t hours_range = 0; + uint8_t minute_range = 0; + int leftTime = -1; +}; +static std::vector s_eventData; + +bool LoadNewRegen() { + s_eventData.clear(); + std::string text; + try { + text = ReadPackedText("locale/newregen.txt"); + } catch (...) { + return false; + } + const std::string mapName = CPythonBackground::Instance().GetWarpMapName(); + std::istringstream stream(text); + std::string line; + while (std::getline(stream, line)) { + if (line.empty() || line.rfind("//", 0) == 0) continue; + std::vector tokens; + std::stringstream ss(line); + std::string token; + while (std::getline(ss, token, '\t')) { + tokens.push_back(token); + } + if (tokens.size() != 16) continue; + if (!mapName.empty() && mapName != tokens[2]) continue; + + TNewRegen data{}; + data.x = std::strtol(tokens[3].c_str(), nullptr, 10); + data.y = std::strtol(tokens[4].c_str(), nullptr, 10); + data.day = static_cast(std::strtol(tokens[7].c_str(), nullptr, 10)); + data.hour = static_cast(std::strtol(tokens[8].c_str(), nullptr, 10)); + data.minute = static_cast(std::strtol(tokens[9].c_str(), nullptr, 10)); + data.second = static_cast(std::strtol(tokens[10].c_str(), nullptr, 10)); + data.safeRange = std::strtol(tokens[12].c_str(), nullptr, 10); + if (data.safeRange == 0) continue; + data.hours_range = static_cast(std::strtol(tokens[13].c_str(), nullptr, 10)); + data.minute_range = static_cast(std::strtol(tokens[14].c_str(), nullptr, 10)); + data.mob_vnum = static_cast(std::strtoul(tokens[15].c_str(), nullptr, 10)); + data.leftTime = -1; + s_eventData.push_back(data); + } + return true; +} + +static int DISTANCE_APPROX_SERVER(int dx, int dy) { + int min, max; + if (dx < 0) dx = -dx; + if (dy < 0) dy = -dy; + if (dx < dy) { min = dx; max = dy; } + else { min = dy; max = dx; } + return (((max << 8) + (max << 3) - (max << 4) - (max << 1) + (min << 7) - (min << 5) + (min << 3) - (min << 1)) >> 8); +} + +static void positionToGlobal(float eX, float eY, long& X, long& Y) { + X = static_cast(eX) / 100; + Y = static_cast(eY) / 100; + long lX = X, lY = Y; + CPythonBackground::Instance().LocalPositionToGlobalPosition(lX, lY); + X = lX * 100; + Y = lY * 100; +} + +static void localToGlobal(long& X, long& Y) { + long lX = X, lY = Y; + CPythonBackground::Instance().LocalPositionToGlobalPosition(lX, lY); + X = lX * 100; + Y = lY * 100; +} + +bool CheckBossSafeRange() { + if (s_eventData.empty()) return false; + const auto* actor = player_main_actor(); + if (!actor) return false; + + long mainX = 0, mainY = 0; + positionToGlobal(actor->m_lCurX, actor->m_lCurY, mainX, mainY); + + const time_t cur_Time = time(nullptr); + const struct tm vKey = *localtime(&cur_Time); + int myear = vKey.tm_year; + int mmon = vKey.tm_mon; + int mday = vKey.tm_mday; + int yday = vKey.tm_yday; + int day = vKey.tm_wday; + int hour = vKey.tm_hour; + int minute = vKey.tm_min; + int second = vKey.tm_sec; + + for (auto& newRegen : s_eventData) { + if (newRegen.day != 0) { + const int curDay = vKey.tm_wday + 1; + if (curDay != newRegen.day) continue; + } + long posGlobalX = newRegen.x, posGlobalY = newRegen.y; + localToGlobal(posGlobalX, posGlobalY); + int fDist = DISTANCE_APPROX_SERVER(mainX - posGlobalX, mainY - posGlobalY); + if (fDist <= newRegen.safeRange) { + std::vector m_Data; + NetworkActorManager::Instance().GetMobWithVnum(newRegen.mob_vnum, m_Data); + if (!m_Data.empty()) { + for (const auto* bossInstance : m_Data) { + if (bossInstance) { + long bossX = 0, bossY = 0; + positionToGlobal(bossInstance->m_lCurX, bossInstance->m_lCurY, bossX, bossY); + fDist = DISTANCE_APPROX_SERVER(mainX - bossX, mainY - bossY); + if (fDist <= newRegen.safeRange) return true; + } + } + } else { + const int nowTime = int(time(nullptr)); + if (newRegen.leftTime < 0) { + bool isSuccess = false; + const int now = int(time(nullptr)) + 2; + const uint8_t regenHour = newRegen.hour; + const uint8_t regenMinute = newRegen.minute; + const uint8_t regenSecond = newRegen.second; + while (true) { + ++second; + if (second == 60) { + minute += 1; + second = 0; + if (minute == 60) { + minute = 0; + hour += 1; + if (hour == 24) { + hour = 0; + day += 1; + if (day == 7) day = 0; + mday += 1; + yday += 1; + if (mday == 32) { + mday = 1; + mmon += 1; + if (mmon == 12) { + mmon = 0; + myear += 1; + yday = 0; + } + } + } + } + } + if (second == 0) { + if (newRegen.hours_range) { + if ((hour % newRegen.hours_range) == 0 && regenMinute == minute) { + isSuccess = true; + break; + } + } + if (newRegen.minute_range) { + if ((minute % newRegen.minute_range) == 0) { + isSuccess = true; + break; + } + } + } + if (regenHour == hour && regenMinute == minute && regenSecond == second) { + if (newRegen.day) { + if (newRegen.day - 1 == day) { + isSuccess = true; + break; + } + } else { + isSuccess = true; + break; + } + } + if (time(nullptr) > now) break; + } + if (isSuccess) { + std::tm tm{}; + tm.tm_year = myear; + tm.tm_mon = mmon; + tm.tm_mday = mday; + tm.tm_isdst = 0; + tm.tm_wday = day; + tm.tm_hour = hour; + tm.tm_min = minute; + tm.tm_sec = second; + tm.tm_yday = yday; + const time_t t = mktime(&tm); + newRegen.leftTime = int(t); + if (newRegen.leftTime - nowTime >= 0 && newRegen.leftTime - nowTime <= 30) + return true; + } else { + return false; + } + } else { + if (newRegen.leftTime - nowTime >= 0 && newRegen.leftTime - nowTime <= 30) + return true; + } + } + } + } + return false; +} + static PyObject* player_LoadNewRegen(PyObject*, PyObject*) { + LoadNewRegen(); return Py_BuildNone(); } @@ -2740,7 +3027,10 @@ static PyObject* player_OpenCharacterMenu(PyObject*, PyObject* args) { static PyObject* player_PickCloseItem(PyObject*, PyObject*) { uint32_t vid = 0; - if (GroundItemStore::Instance().GetCloseItem(s_mainActorPos.x, s_mainActorPos.y, &vid, 300.0f)) { + TPixelPosition pos{s_mainActorPos.x, s_mainActorPos.y, s_mainActorPos.z}; + const auto* actor = player_main_actor(); + uint32_t dist = (actor && actor->m_dwMountVnum != 0) ? 500 : 300; + if (CPythonItem::Instance().GetCloseItem(pos, &vid, dist)) { PythonNetworkStream::Instance().SendItemPickUpPacket(vid); } return Py_BuildNone(); @@ -2748,7 +3038,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)) { + TPixelPosition pos{s_mainActorPos.x, s_mainActorPos.y, s_mainActorPos.z}; + if (CPythonItem::Instance().GetCloseItemVector(s_playerName, pos, outVids)) { if (!outVids.empty()) { PythonNetworkStream::Instance().SendItemsPickUpPacket(outVids); } diff --git a/src/python_gameplay_modules.h b/src/python_gameplay_modules.h index c336188a..3ac45ba6 100644 --- a/src/python_gameplay_modules.h +++ b/src/python_gameplay_modules.h @@ -80,6 +80,13 @@ const std::string& GetMainCharacterName(); void SetMainCharacterName(const std::string& name); long long GetPlayerStatusPoint(int type); void SetPlayerStatusPoint(int type, long long value); +void SetWeaponPower(uint32_t dwMinPower, uint32_t dwMaxPower, uint32_t dwMinMagicPower, uint32_t dwMaxMagicPower, uint32_t dwAddPower); +void UpdateEquippedWeaponPower(); +bool HasEnoughArrow(); +void SetPlayerRace(uint32_t race); +uint32_t GetPlayerRace(); +bool CheckBossSafeRange(); +bool LoadNewRegen(); } // namespace ava2 diff --git a/src/python_item.h b/src/python_item.h new file mode 100644 index 00000000..e7d3407d --- /dev/null +++ b/src/python_item.h @@ -0,0 +1,414 @@ +#pragma once + +#include "eter_base/Singleton.h" +#include "eter_net/Packet.h" +#include "eter_render/TextTailManager.h" +#include "item_sound.h" +#include "python_gameplay_modules.h" +#include "nonplayer_data.h" +#include +#include +#include +#include +#include +#include + +namespace ava2 { + +struct TPixelPosition { + float x = 0.0f; + float y = 0.0f; + float z = 0.0f; +}; + +class CPythonItem : public CSingleton { +public: + enum { + INVALID_ID = 0xffffffff, + }; + + enum { + VNUM_MONEY = 1, + }; + + enum { + USESOUND_NONE = 0, + USESOUND_DEFAULT = 1, + USESOUND_ARMOR = 2, + USESOUND_WEAPON = 3, + USESOUND_BOW = 4, + USESOUND_ACCESSORY = 5, + USESOUND_POTION = 6, + USESOUND_PORTAL = 7, + USESOUND_NUM = 8, + }; + + enum { + DROPSOUND_DEFAULT = 0, + DROPSOUND_ARMOR = 1, + DROPSOUND_WEAPON = 2, + DROPSOUND_BOW = 3, + DROPSOUND_ACCESSORY = 4, + DROPSOUND_NUM = 5, + }; + + struct TGroundItemInstance { + uint32_t dwVirtualNumber = 0; + TPixelPosition v3EndPosition{}; + uint32_t eDropSoundType = DROPSOUND_DEFAULT; + bool bAnimEnded = true; + std::string stOwnership; + int32_t alSockets[ITEM_SOCKET_SLOT_MAX_NUM]{}; + TPlayerItemAttribute aAttrs[ITEM_ATTRIBUTE_SLOT_MAX_NUM]{}; + uint16_t itemCount = 0; + int ownerTime = 0; + + void Clear() { + stOwnership.clear(); + } + }; + + using TGroundItemInstanceMap = std::map; + + CPythonItem() = default; + virtual ~CPythonItem() { + DeleteAllItems(); + } + + static CPythonItem& Instance() { + CPythonItem* ptr = InstancePtr(); + if (!ptr) { + static CPythonItem s; + return s; + } + return *ptr; + } + + void Create() {} + void Destroy() { + DeleteAllItems(); + } + + void DeleteAllItems() { + for (auto& [vid, inst] : m_GroundItemInstanceMap) { + TextTailManager::Instance().DeleteItemTextTail(vid); + delete inst; + } + m_GroundItemInstanceMap.clear(); + m_dwPickedItemID = INVALID_ID; + } + + template + void CreateItem(uint32_t dwVirtualID, uint32_t dwVirtualNumber, float x, float y, float z, + bool bDrop = true, + const TSocket* alSockets = nullptr, + const TPlayerItemAttribute* aAttrs = nullptr, + unsigned short itemCount = 0, + int ownerTime = 0) { + auto it = m_GroundItemInstanceMap.find(dwVirtualID); + TGroundItemInstance* pInst = nullptr; + if (it != m_GroundItemInstanceMap.end()) { + pInst = it->second; + } else { + pInst = new TGroundItemInstance(); + m_GroundItemInstanceMap[dwVirtualID] = pInst; + } + + pInst->dwVirtualNumber = dwVirtualNumber; + pInst->v3EndPosition = {x, y, z}; + pInst->bAnimEnded = !bDrop; + pInst->itemCount = itemCount; + pInst->ownerTime = ownerTime; + + if (alSockets) { + for (size_t i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i) + pInst->alSockets[i] = static_cast(alSockets[i]); + } else { + std::fill(std::begin(pInst->alSockets), std::end(pInst->alSockets), 0); + } + + if (aAttrs) { + for (size_t i = 0; i < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++i) + pInst->aAttrs[i] = aAttrs[i]; + } else { + std::fill(std::begin(pInst->aAttrs), std::end(pInst->aAttrs), TPlayerItemAttribute{}); + } + + std::string baseName; + int itemType = 0; + if (!GetItemNameAndType(dwVirtualNumber, &baseName, &itemType) || baseName.empty()) { + baseName = "Item " + std::to_string(dwVirtualNumber); + } + + std::string szItemName; + if (itemType == 17 /* ITEM_TYPE_POLYMORPH */ && alSockets) { + std::string mobName; + if (GetNonPlayerName(uint32_t(alSockets[0]), mobName) && !mobName.empty()) { + if (itemCount > 1) { + szItemName = mobName + " (x" + std::to_string(itemCount) + ") " + baseName; + } else { + szItemName = mobName + " " + baseName; + } + } + } + + if (szItemName.empty()) { + if (itemCount > 1) { + szItemName = baseName + " (x" + std::to_string(itemCount) + ")"; + } else { + szItemName = baseName; + } + } + + bool bHasAttr = false; + if (aAttrs) { + for (size_t i = 0; i < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++i) { + if (aAttrs[i].bType != 0 && aAttrs[i].sValue != 0) { + bHasAttr = true; + break; + } + } + } + + uint32_t color = 0xFFFFFFFF; // default white + if (IsRarityItem(dwVirtualNumber)) { + int rarityType = alSockets ? int(alSockets[6 /* RARITY_TYPE_INDEX */]) : 0; + if (rarityType == 1 /* RARITY_UNCOMMUN */) + color = 0xFFD1D1D1; + else if (rarityType == 2 /* RARITY_RARE */) + color = 0xFF7CA1FF; + else if (rarityType == 3 /* RARITY_EPIC */) + color = 0xFFFF3252; + else if (rarityType == 4 /* RARITY_RELIC */) + color = 0xFF34FF30; + else if (rarityType == 5 /* RARITY_LEGENDARY */) + color = 0xFFFA30FF; + else + color = 0xFF8E8E8E; + } else if (bHasAttr) { + color = 0xFFFFAA00; // gold/orange for attributes + } + + TextTailManager::Instance().RegisterItemTextTail(dwVirtualID, szItemName, x, y, z, ownerTime, pInst->stOwnership, false, color); + + if (bDrop) { + PlayDropSound(dwVirtualNumber); + } + } + + void DeleteItem(uint32_t dwVirtualID) { + auto it = m_GroundItemInstanceMap.find(dwVirtualID); + if (it != m_GroundItemInstanceMap.end()) { + TextTailManager::Instance().DeleteItemTextTail(dwVirtualID); + delete it->second; + m_GroundItemInstanceMap.erase(it); + } + if (m_dwPickedItemID == dwVirtualID) + m_dwPickedItemID = INVALID_ID; + } + + void SetOwnership(uint32_t dwVID, const char* c_pszName) { + auto it = m_GroundItemInstanceMap.find(dwVID); + if (it == m_GroundItemInstanceMap.end()) + return; + std::string name = c_pszName ? c_pszName : ""; + it->second->stOwnership = name; + TextTailManager::Instance().SetItemTextTailOwner(dwVID, name, true); + } + + bool GetOwnership(uint32_t dwVID, const char** c_pszName) { + auto it = m_GroundItemInstanceMap.find(dwVID); + if (it == m_GroundItemInstanceMap.end()) + return false; + if (c_pszName) + *c_pszName = it->second->stOwnership.c_str(); + return true; + } + + bool GetGroundItemPosition(uint32_t dwVirtualID, TPixelPosition* pPosition) { + auto it = m_GroundItemInstanceMap.find(dwVirtualID); + if (it == m_GroundItemInstanceMap.end()) + return false; + if (pPosition) { + pPosition->x = +it->second->v3EndPosition.x; + pPosition->y = -it->second->v3EndPosition.y; + pPosition->z = +it->second->v3EndPosition.z; + } + return true; + } + + bool GetPickedItemID(uint32_t* pdwPickedItemID) { + if (m_dwPickedItemID == INVALID_ID) + return false; + if (pdwPickedItemID) + *pdwPickedItemID = m_dwPickedItemID; + return true; + } + + void SetPickedItemID(uint32_t id) { + m_dwPickedItemID = id; + } + + uint32_t GetVirtualNumberOfGroundItem(uint32_t dwVID) { + auto it = m_GroundItemInstanceMap.find(dwVID); + if (it == m_GroundItemInstanceMap.end()) + return 0; + return it->second->dwVirtualNumber; + } + + bool GetCloseMoney(const TPixelPosition& c_rPixelPosition, uint32_t* pdwItemID, uint32_t dwDistance = 300) { + uint32_t dwCloseItemID = 0; + uint32_t dwCloseItemDistance = 1000 * 1000; + + for (auto& [vid, pInstance] : m_GroundItemInstanceMap) { + if (pInstance->dwVirtualNumber != VNUM_MONEY) + continue; + + float dwxDistance = c_rPixelPosition.x - pInstance->v3EndPosition.x; + float dwyDistance = c_rPixelPosition.y - (-pInstance->v3EndPosition.y); + uint32_t dwDist = uint32_t(dwxDistance * dwxDistance + dwyDistance * dwyDistance); + + if (dwDist < dwCloseItemDistance) { + dwCloseItemID = vid; + dwCloseItemDistance = dwDist; + } + } + + if (dwCloseItemDistance > float(dwDistance) * float(dwDistance)) + return false; + + if (pdwItemID) + *pdwItemID = dwCloseItemID; + return true; + } + + bool GetCloseItem(const TPixelPosition& c_rPixelPosition, uint32_t* pdwItemID, uint32_t dwDistance = 300, bool specific_pick = false) { + uint32_t dwCloseItemID = 0; + uint32_t dwCloseItemDistance = 1000 * 1000; + + for (auto& [vid, pInstance] : m_GroundItemInstanceMap) { + float dwxDistance = c_rPixelPosition.x - pInstance->v3EndPosition.x; + float dwyDistance = c_rPixelPosition.y - (-pInstance->v3EndPosition.y); + uint32_t dwDist = uint32_t(dwxDistance * dwxDistance + dwyDistance * dwyDistance); + + if (dwDist < dwCloseItemDistance) { + if (specific_pick) { + const char* c_szOwnerName = ""; + if (!GetOwnership(vid, &c_szOwnerName)) + continue; + + int itemType = 0, itemSubType = 0; + if (!GetItemTypeAndSubType(pInstance->dwVirtualNumber, &itemType, &itemSubType)) + continue; + + if (itemType == 1 || itemType == 2) + continue; + + dwCloseItemID = vid; + dwCloseItemDistance = dwDist; + } else { + dwCloseItemID = vid; + dwCloseItemDistance = dwDist; + } + } + } + + if (dwCloseItemDistance > float(dwDistance) * float(dwDistance)) + return false; + + if (pdwItemID) + *pdwItemID = dwCloseItemID; + return true; + } + + bool GetCloseItemVector(const std::string& myName, const TPixelPosition& c_rPixelPosition, std::vector& itemVIDVector) { + uint32_t dwCloseItemDistance = 1000 * 2000; + for (auto& [vid, pInstance] : m_GroundItemInstanceMap) { + float dwxDistance = c_rPixelPosition.x - pInstance->v3EndPosition.x; + float dwyDistance = c_rPixelPosition.y - (-pInstance->v3EndPosition.y); + uint32_t dwDist = uint32_t(dwxDistance * dwxDistance + dwyDistance * dwyDistance); + + if (dwDist < dwCloseItemDistance && (pInstance->stOwnership.empty() || pInstance->stOwnership == myName)) { + itemVIDVector.push_back(vid); + } + } + return true; + } + + void PlayUseSound(uint32_t dwItemID) { + PlayItemUseSound(dwItemID); + } + + void PlayDropSound(uint32_t dwItemID) { + PlayItemDropSound(dwItemID); + } + + void PlayUsePotionSound() { + ava2::PlayUsePotionSound(); + } + + void SetUseSoundFileName(uint32_t eItemType, const std::string& c_rstFileName) { + SetItemUseSound(eItemType, c_rstFileName); + } + + void SetDropSoundFileName(uint32_t eItemType, const std::string& c_rstFileName) { + SetItemDropSound(eItemType, c_rstFileName); + } + + bool IsRarityItem(uint32_t itemVnum) { + int itemType = 0, itemSubType = 0; + if (!GetItemTypeAndSubType(itemVnum, &itemType, &itemSubType)) { + if (!GetItemTypeAndSubType(60001, &itemType, &itemSubType)) + return false; + } + if (itemType == 2 /* ARMOR */) + return true; + if (itemType == 36 /* RINGS */) + return true; + if (itemType == 1 /* WEAPON */ && itemSubType != 6 && itemSubType != 9) + return true; + return false; + } + + long GetRarityMaxValue(uint32_t itemVnum, uint32_t rarityType) { + if (!IsRarityItem(itemVnum)) + return 0; + static const long s_maxValues[] = {50000, 75000, 100000, 150000, 200000, 300000}; + if (rarityType < 6) + return s_maxValues[rarityType]; + return 0; + } + + long GetRarityPoint(int attrID, int rarityType) { + static const std::set s_rarityAttrs = { + -4, -3, -2, -1, + 19, 1, 5, 7, 6, 8, 15, 16, 12, 13, 17, 9, 10, 37, 3, 2, 41, 24, 23, + 59, 60, 61, 62, 54, 55, 56, 57, 27, 28, 43, 44, 64, 65, 63, 39, 40, + 38, 34, 35, 36, 71, 72, 53, 74, 75, 76, 77, 78, 79, 80 + }; + if (s_rarityAttrs.count(attrID) > 0) { + static const long s_points[] = {0, 5, 10, 20, 25, 30}; + if (rarityType < 6) + return s_points[rarityType]; + } + return 0; + } + + void Update() {} + void Render() {} + + void GetInfo(std::string* pstInfo) { + if (pstInfo) { + pstInfo->append("Item: Inst " + std::to_string(m_GroundItemInstanceMap.size())); + } + } + +protected: + TGroundItemInstanceMap m_GroundItemInstanceMap; + uint32_t m_dwPickedItemID = INVALID_ID; +}; + +} // namespace ava2 + +using ava2::CPythonItem; +using ava2::TPixelPosition;