feat: pass37 - CPythonItem singleton, battle status math, and regen safe range parity

This commit is contained in:
shen
2026-10-08 04:05:06 -07:00
parent 263c96aaa4
commit 8d505c3d34
6 changed files with 895 additions and 145 deletions
+29 -1
View File
@@ -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.
+7
View File
@@ -271,6 +271,13 @@ public:
const SNetworkActorData* GetActorData(uint32_t vid) const;
std::shared_ptr<ActorInstance> GetActorInstance(uint32_t vid);
const std::unordered_map<uint32_t, SNetworkActorData>& GetActorDict() const { return m_actors; }
void GetMobWithVnum(uint32_t mobVnum, std::vector<const SNetworkActorData*>& 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<Render3DDraw> BuildDrawCommands(float animTime);
+15 -12
View File
@@ -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<uint8_t> 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<float>(p.lX);
float wy = static_cast<float>(p.lZ);
float wz = static_cast<float>(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<float>(p.lX),
static_cast<float>(p.lY),
static_cast<float>(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;
}
+423 -132
View File
@@ -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 && index<int(s_killLog.size())?s_killLog[size_t(index)]:0));
}
static uint32_t s_dwWeaponMinPower = 0;
static uint32_t s_dwWeaponMaxPower = 0;
static uint32_t s_dwWeaponMinMagicPower = 0;
static uint32_t s_dwWeaponMaxMagicPower = 0;
static uint32_t s_dwWeaponAddPower = 0;
static uint32_t s_playerRace = 0;
void SetPlayerRace(uint32_t race) {
s_playerRace = race;
}
uint32_t GetPlayerRace() {
if (s_playerRace != 0) return s_playerRace;
const auto* actor = player_main_actor();
return actor ? actor->m_dwRace : 0;
}
static uint32_t GetPlayerRaceStat() {
switch (GetPlayerRace()) {
case 0: /* MAIN_RACE_WARRIOR_M */
case 4: /* MAIN_RACE_WARRIOR_W */
return static_cast<uint32_t>(GetPlayerStatusPoint(12 /* POINT_ST */));
case 5: /* MAIN_RACE_ASSASSIN_M */
case 1: /* MAIN_RACE_ASSASSIN_W */
return static_cast<uint32_t>(GetPlayerStatusPoint(14 /* POINT_DX */));
case 2: /* MAIN_RACE_SURA_M */
case 6: /* MAIN_RACE_SURA_W */
return static_cast<uint32_t>(GetPlayerStatusPoint(12 /* POINT_ST */));
case 3: /* MAIN_RACE_SHAMAN_W */
case 7: /* MAIN_RACE_SHAMAN_M */
return static_cast<uint32_t>(GetPlayerStatusPoint(15 /* POINT_IQ */));
case 8: /* MAIN_RACE_WOLFMAN_M */
return static_cast<uint32_t>(GetPlayerStatusPoint(14 /* POINT_DX */));
}
return static_cast<uint32_t>(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<uint32_t>(100 * (std::min(150LL, src) + 210) / 300);
}
static uint32_t GetEvadeRate() {
long long dx = GetPlayerStatusPoint(14 /* POINT_DX */);
return static_cast<uint32_t>(30 * (2 * dx + 5) / (dx + 95));
}
static uint32_t GetTotalAtk(uint32_t dwWeaponPower, uint32_t dwRefineBonus) {
uint32_t dwLvAtk = 2 * static_cast<uint32_t>(GetPlayerStatusPoint(1 /* POINT_LEVEL */));
uint32_t dwStAtk = (4 * static_cast<uint32_t>(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<double>(sashItem.alSockets[0]);
auto sashMinWep = static_cast<long long>(static_cast<double>(selectedItem->values[3] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5);
auto sashMaxWep = static_cast<long long>(static_cast<double>(selectedItem->values[4] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5);
auto sashMinMag = static_cast<long long>(static_cast<double>(selectedItem->values[1] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5);
auto sashMaxMag = static_cast<long long>(static_cast<double>(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;i<ITEM_SOCKET_SLOT_MAX_NUM;++i) slot.sockets[i]=data.alSockets[i];
for(size_t i=0;i<ITEM_ATTRIBUTE_SLOT_MAX_NUM;++i) slot.attrs[i]={data.aAttr[i].bType,data.aAttr[i].sValue};
}
if (window == 1 && (cell == 184 || cell == 202)) {
UpdateEquippedWeaponPower();
}
}
void SetPlayerItemCount(uint8_t window,uint16_t cell,uint32_t count) {
auto data=GetPlayerItemData(window,cell);data.count=count;SetPlayerItemData(window,cell,data);
@@ -1585,85 +1764,7 @@ void EndSkillCoolTime(uint32_t skillIndex) {
// GroundItemStore & Chest Drop Cache
// ---------------------------------------------------------------------
class GroundItemStore {
public:
static GroundItemStore& Instance() {
static GroundItemStore s_instance;
return s_instance;
}
struct SGroundItem {
uint32_t vid = 0;
uint32_t vnum = 0;
float x = 0.0f, y = 0.0f, z = 0.0f;
bool bDrop = true;
std::string ownership;
};
void CreateItem(uint32_t vid, uint32_t vnum, float x, float y, float z, bool bDrop) {
m_items[vid] = SGroundItem{vid, vnum, x, y, z, bDrop, ""};
auto it = s_itemMap.find(vnum);
std::string name = it != s_itemMap.end() ? it->second.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<uint32_t>& 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<uint32_t, SGroundItem> 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<uint32_t, std::vector<SDropItemEntry>> 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<int> 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<TNewRegen> 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<std::string> 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<uint8_t>(std::strtol(tokens[7].c_str(), nullptr, 10));
data.hour = static_cast<uint8_t>(std::strtol(tokens[8].c_str(), nullptr, 10));
data.minute = static_cast<uint8_t>(std::strtol(tokens[9].c_str(), nullptr, 10));
data.second = static_cast<uint8_t>(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<uint8_t>(std::strtol(tokens[13].c_str(), nullptr, 10));
data.minute_range = static_cast<uint8_t>(std::strtol(tokens[14].c_str(), nullptr, 10));
data.mob_vnum = static_cast<uint32_t>(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<long>(eX) / 100;
Y = static_cast<long>(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<const SNetworkActorData*> 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<uint32_t> 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);
}
+7
View File
@@ -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
+414
View File
@@ -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 <map>
#include <vector>
#include <string>
#include <set>
#include <cmath>
#include <algorithm>
namespace ava2 {
struct TPixelPosition {
float x = 0.0f;
float y = 0.0f;
float z = 0.0f;
};
class CPythonItem : public CSingleton<CPythonItem> {
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<uint32_t, TGroundItemInstance*>;
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 <typename TSocket = int32_t>
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<int32_t>(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<uint32_t>& 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<int> 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;