feat: pass37 - CPythonItem singleton, battle status math, and regen safe range parity
This commit is contained in:
+29
-1
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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;
|
||||
Reference in New Issue
Block a user