Files
AVA2/src/scripting/python_gameplay_modules.cpp
T
shenleiandClaude Opus 5.5 64d25e3571 Mobile step 6: client-side auto hunt with AUTO button
Engine-free AutoHunt state machine (search/engage/loot/return/paused) driven
from the game loop through the existing manual paths: move target, target
packet, normal attack, quickslot skills, item pick-up and belt potions.
player.SetAutoHunt/GetAutoHuntState/SetAutoHuntOption with autohunt.cfg;
AUTO button on the combat wheel (tap toggles, long press opens settings).
Tests: ava2.auto_hunt, extended ava2.touch_game; 54/54.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 22:05:15 +09:00

4382 lines
206 KiB
C++

#include "ava2_text_file.h"
#include "ava2_text_file_loader.h"
#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"
#include "python_app.h"
#include "shared/common/PythonUtils.h"
#include "python_native_modules.h"
#include "map_coordinates.h"
#include "nonplayer_data.h"
#include "game_type.h"
#include "guild_state.h"
#include "skill_cooldown.h"
#include "auto_hunt.h"
#include "python_system.h"
#include "eter_net/PythonNetworkStream.h"
#include "eter_net/NetworkActorManager.h"
#include "eter_render/TerrainHeightmap.h"
#include "eter_render/TextTailManager.h"
#include "eter_sound/SoundManager.h"
#include "eter_resource/ResourceManager.h"
#include "eter_image/GrpImageInstance.h"
#include "eter_image/GrpImage.h"
#include "eter_base/Timer.h"
#include "skill_description.h"
#include <Python.h>
#include <cmath>
#include <string>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <array>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <iostream>
#include <iterator>
#include <cctype>
#include <algorithm>
namespace ava2 {
namespace {
struct PlayerSkill {
int index = 0;
int grade = 0;
int level = 0;
float currentPower=0,nextPower=0;
SkillCooldown cooldown;
bool active = false;
};
static std::map<int, PlayerSkill> s_playerSkills;
static std::map<int,int> s_skillSlots;
static uint32_t s_targetVID = 0;
static bool s_coolTimeEnabled = true;
static SkillCastCallback s_skillCastCallback = nullptr;
static int s_curSkillSlotIndex = 0;
static std::unordered_map<int, long long> s_playerPoints;
struct PlayerQuickSlot { int type=0; int pos=0; };
static std::array<PlayerQuickSlot,36> s_playerQuickSlots{};
static int s_quickPage=0;
static PyObject* s_playerGameWindow=nullptr;
static PyObject* player_SetGameWindow(PyObject*,PyObject* args) {
PyObject* window;if(!PyArg_ParseTuple(args,"O",&window)) return nullptr;
if(window==Py_None || (PyInt_Check(window) && PyInt_AsLong(window)==0)) window=nullptr;
if(window==s_playerGameWindow) Py_RETURN_NONE;
Py_XINCREF(window);
auto* old=s_playerGameWindow; s_playerGameWindow=nullptr;
// The previous GameWindow destructor calls SetGameWindow(0). Dispose it
// before assigning its successor so it cannot clear the new callback owner.
Py_XDECREF(old);
s_playerGameWindow=window;
Py_RETURN_NONE;
}
static bool player_window_call(const char* name, PyObject* args = nullptr) {
if (!s_playerGameWindow) {
Py_XDECREF(args);
return true;
}
if (!args) {
args = PyTuple_New(0);
}
return PyCallClassMemberFunc(s_playerGameWindow, name, args);
}
static PyObject* player_GetQuickPage(PyObject*,PyObject*) {return PyInt_FromLong(s_quickPage);}
static PyObject* player_SetQuickPage(PyObject*,PyObject* args) {
int page;if(!PyArg_ParseTuple(args,"i",&page)) return nullptr;
s_quickPage=page<0?4+page:(page>=4?page%4:page);
if(!player_window_call("RefreshInventory")) return nullptr;Py_RETURN_NONE;
}
static PyObject* player_LocalQuickIndex(PyObject*,PyObject* args) {
int index;if(!PyArg_ParseTuple(args,"i",&index)) return nullptr;
return PyLong_FromUnsignedLong(uint32_t(s_quickPage)*8u+uint32_t(index));
}
static bool quick_send(const std::vector<uint8_t>& bytes) {
auto& stream=PythonNetworkStream::Instance();
try {
if(bytes[0]==HEADER_CG_QUICKSLOT_ADD) return stream.SendQuickSlotAddPacket(bytes[1],bytes[2],bytes[3]);
if(bytes[0]==HEADER_CG_QUICKSLOT_DEL) return stream.SendQuickSlotDelPacket(bytes[1]);
return stream.SendQuickSlotMovePacket(bytes[1],bytes[2]);
}
catch(const std::exception& e) {PyErr_SetString(PyExc_RuntimeError,e.what());return false;}
}
static PyObject* player_AddEmptyQuick(PyObject*,PyObject* args) {
int type,pos;if(!PyArg_ParseTuple(args,"ii",&type,&pos)) return nullptr;
for(int local=0;local<8;++local) {int global=s_quickPage*8+local;
if(global>=0&&global<36&&s_playerQuickSlots[global].type==0) {
if(!quick_send({HEADER_CG_QUICKSLOT_ADD,uint8_t(global),uint8_t(type),uint8_t(pos)})) return nullptr;break;
}
}Py_RETURN_NONE;
}
static PyObject* player_DeleteQuick(PyObject*,PyObject* args) {
int index;if(!PyArg_ParseTuple(args,"i",&index)) return nullptr;
if(uint32_t(index)<32 && !quick_send({HEADER_CG_QUICKSLOT_DEL,uint8_t(index)})) return nullptr;Py_RETURN_NONE;
}
static PyObject* player_RemoveQuickByValue(PyObject*,PyObject* args) {
int type,pos;if(!PyArg_ParseTuple(args,"ii",&type,&pos)) return nullptr;
for(int index=0;index<36;++index)
if(s_playerQuickSlots[index].type==type && s_playerQuickSlots[index].pos==pos)
if(!quick_send({HEADER_CG_QUICKSLOT_DEL,uint8_t(index)})) return nullptr;
Py_RETURN_NONE;
}
static PyObject* player_MoveQuick(PyObject*,PyObject* args) {
int source,local;if(!PyArg_ParseTuple(args,"ii",&source,&local)) return nullptr;
if(!quick_send({HEADER_CG_QUICKSLOT_SWAP,uint8_t(source),uint8_t(s_quickPage*8+local)})) return nullptr;Py_RETURN_NONE;
}
static PyObject* player_GetSkillIndex(PyObject*, PyObject* args) {
int slot = 0;
if (!PyArg_ParseTuple(args, "i", &slot)) return Py_BuildValue("i", 0);
auto it = s_playerSkills.find(slot);
if (it != s_playerSkills.end()) return Py_BuildValue("i", it->second.index);
return Py_BuildValue("i", 0);
}
static PyObject* player_GetSkillGrade(PyObject*, PyObject* args) {
int slot = 0;
if (!PyArg_ParseTuple(args, "i", &slot)) return Py_BuildValue("i", 0);
auto it = s_playerSkills.find(slot);
if (it != s_playerSkills.end()) return Py_BuildValue("i", it->second.grade);
return Py_BuildValue("i", 0);
}
static PyObject* player_GetSkillLevel(PyObject*, PyObject* args) {
int slot = 0;
if (!PyArg_ParseTuple(args, "i", &slot)) return Py_BuildValue("i", 0);
auto it = s_playerSkills.find(slot);
if (it != s_playerSkills.end()) return Py_BuildValue("i", it->second.level);
return Py_BuildValue("i", 0);
}
static PyObject* player_SetSkill(PyObject*,PyObject* args) {
int slot,index;if(!PyArg_ParseTuple(args,"ii",&slot,&index)) return nullptr;
SetPlayerSkill(slot,index);Py_RETURN_NONE;
}
static PyObject* player_AffectIndexToSkillIndex(PyObject*,PyObject* args) {
int affect;if(!PyArg_ParseTuple(args,"i",&affect)) return nullptr;
return PyInt_FromLong(AffectIndexToSkillIndex(affect));
}
static PyObject* player_GetSkillSlotIndex(PyObject*,PyObject* args) {
int index;if(!PyArg_ParseTuple(args,"i",&index)) return nullptr;
auto it=s_skillSlots.find(index);
if(it==s_skillSlots.end()) return Py_BuildException();
return PyInt_FromLong(it->second);
}
template<bool Next> static PyObject* player_GetSkillPower(PyObject*,PyObject* args) {
int slot;if(!PyArg_ParseTuple(args,"i",&slot)) return nullptr;
auto it=s_playerSkills.find(slot);
return PyFloat_FromDouble(it==s_playerSkills.end()?0:(Next?it->second.nextPower:it->second.currentPower));
}
static PyObject* player_GetLocalQuickSlot(PyObject*, PyObject* args) {
int slot = 0;
if (!PyArg_ParseTuple(args, "i", &slot)) return nullptr;
int global=s_quickPage*8+slot;
if (global >= 0 && global < (int)s_playerQuickSlots.size()) {
return Py_BuildValue("ii", s_playerQuickSlots[global].type, s_playerQuickSlots[global].pos);
}
return Py_BuildValue("ii", 0, 0);
}
static PyObject* player_GetGlobalQuickSlot(PyObject*, PyObject* args) {
int slot = 0;
if (!PyArg_ParseTuple(args, "i", &slot)) return nullptr;
if (slot >= 0 && slot < (int)s_playerQuickSlots.size()) {
return Py_BuildValue("ii", s_playerQuickSlots[slot].type, s_playerQuickSlots[slot].pos);
}
return Py_BuildValue("ii", 0, 0);
}
static PyObject* player_RequestAddLocalQuickSlot(PyObject*, PyObject* args) {
int slot,type,pos;if(!PyArg_ParseTuple(args,"iii",&slot,&type,&pos)) return nullptr;
if(uint32_t(slot)<8 && !quick_send({HEADER_CG_QUICKSLOT_ADD,uint8_t(s_quickPage*8+slot),uint8_t(type),uint8_t(pos)})) return nullptr;
Py_RETURN_NONE;
}
static bool use_global_quick_slot(int global) {
if (global >= 0 && global < (int)s_playerQuickSlots.size()) {
if(s_playerQuickSlots[global].type==1) PythonNetworkStream::Instance().SendItemUsePacket(1,uint16_t(s_playerQuickSlots[global].pos));
else if(s_playerQuickSlots[global].type==3) {
if(!player_window_call("BINARY_ActEmotion",Py_BuildValue("(i)",s_playerQuickSlots[global].pos))) return false;
}
else if (s_playerQuickSlots[global].type == 2) { // Skill
int skillSlot = s_playerQuickSlots[global].pos;
ClickSkillSlot(skillSlot);
}
}
return true;
}
static PyObject* player_RequestUseLocalQuickSlot(PyObject*, PyObject* args) {
int slot = 0;
if (!PyArg_ParseTuple(args, "i", &slot)) return nullptr;
if(slot<0 || slot>=8) Py_RETURN_NONE;
if(!use_global_quick_slot(s_quickPage*8+slot)) return nullptr;
Py_RETURN_NONE;
}
// Mobile HUD potion belt (ui_mobile_hud.py): a fixed quickslot page shown next to the current
// one, so it addresses global slots. Not in the original player module; same packets as the
// local variants.
static PyObject* player_RequestUseGlobalQuickSlot(PyObject*, PyObject* args) {
int global = 0;
if (!PyArg_ParseTuple(args, "i", &global)) return nullptr;
if(global<0 || global>=32) Py_RETURN_NONE;
if(!use_global_quick_slot(global)) return nullptr;
Py_RETURN_NONE;
}
static PyObject* player_RequestAddGlobalQuickSlot(PyObject*, PyObject* args) {
int global,type,pos;if(!PyArg_ParseTuple(args,"iii",&global,&type,&pos)) return nullptr;
if(uint32_t(global)<32 && !quick_send({HEADER_CG_QUICKSLOT_ADD,uint8_t(global),uint8_t(type),uint8_t(pos)})) return nullptr;
Py_RETURN_NONE;
}
static PyObject* player_MoveQuickGlobal(PyObject*,PyObject* args) {
int source,target;if(!PyArg_ParseTuple(args,"ii",&source,&target)) return nullptr;
if(uint32_t(source)<32 && uint32_t(target)<32 && !quick_send({HEADER_CG_QUICKSLOT_SWAP,uint8_t(source),uint8_t(target)})) return nullptr;
Py_RETURN_NONE;
}
static std::string s_playerName = "";
struct Position3D { float x = 0.0f; float y = 0.0f; float z = 0.0f; };
static Position3D s_mainActorPos{0.0f, 0.0f, 0.0f};
static PyObject* player_GetStatus(PyObject*, PyObject* args) {
int type = 0;
if (!PyArg_ParseTuple(args, "i", &type)) return Py_BuildValue("i", 0);
if(uint32_t(type)>=255)return PyInt_FromLong(0);
auto it = s_playerPoints.find(type);
if (it != s_playerPoints.end()) {
return Py_BuildValue("l", (long)it->second);
}
return Py_BuildValue("i", 0);
}
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) {
SetPlayerStatusPoint(type, value);
}
} else {
PyErr_Clear();
long lVal = 0;
if (PyArg_ParseTuple(args, "il", &type, &lVal)) {
if(uint32_t(type)<255) {
SetPlayerStatusPoint(type, lVal);
}
}
}
Py_RETURN_NONE;
}
static PyObject* player_GetName(PyObject*, PyObject*) {
return Py_BuildValue("s", s_playerName.c_str());
}
static PyObject* player_GetMainCharacterName(PyObject*, PyObject*) {
return Py_BuildValue("s", s_playerName.c_str());
}
static PyObject* player_IsObserverMode(PyObject*,PyObject*) { return Py_BuildValue("i",int(PythonNetworkStream::Instance().IsObserverMode())); }
static PyObject* player_HasMobilePhoneNumber(PyObject*,PyObject*) { return Py_BuildValue("i",int(PythonNetworkStream::Instance().HasMobilePhoneNumber())); }
static PyObject* player_GetMainCharacterIndex(PyObject*,PyObject*) { return PyLong_FromUnsignedLong(PythonNetworkStream::Instance().GetMainActorVID()); }
static PyObject* player_IsMainCharacterIndex(PyObject*,PyObject* args) {
unsigned long vid;if(!PyArg_ParseTuple(args,"k",&vid)) return nullptr;
return PyInt_FromLong(vid==PythonNetworkStream::Instance().GetMainActorVID());
}
static PyObject* player_GetMainCharacterPosition(PyObject*, PyObject*) {
return Py_BuildValue("fff", s_mainActorPos.x, s_mainActorPos.y, s_mainActorPos.z);
}
// CPythonPlayer::NEW_GetMainActorPtr: the main character's instance, nullptr before it is added.
static const SNetworkActorData* player_main_actor() {
return NetworkActorManager::Instance().GetActorData(PythonNetworkStream::Instance().GetMainActorVID());
}
// CPythonPlayer::m_dwPlayTime (player.SetPlayTime from the select phase).
static uint32_t s_playTime = 0;
static PyObject* player_GetGuildID(PyObject*, PyObject*) {
const auto* pInstance = player_main_actor();
if (!pInstance)
return Py_BuildValue("i", 0);
return Py_BuildValue("i", int(pInstance->m_dwGuildID));
}
static PyObject* player_GetGuildName(PyObject*, PyObject*) {
if (const auto* pInstance = player_main_actor()) {
// CPythonGuild::GetGuildName: m_GuildNameMap lookup.
const auto& names = GetGuildState().names;
auto it = names.find(pInstance->m_dwGuildID);
if (it != names.end())
return Py_BuildValue("s", it->second.c_str());
}
return Py_BuildValue("s", "");
}
static PyObject* player_GetPKMode(PyObject*, PyObject*) {
const auto* pInstance = player_main_actor();
return Py_BuildValue("i", pInstance ? int(pInstance->m_byPKMode) : 0);
}
static PyObject* player_IsGameMaster(PyObject*, PyObject*) {
const auto* mainPlayer = player_main_actor();
return Py_BuildValue("i", mainPlayer != nullptr ? int(IsGameMaster(*mainPlayer)) : 0);
}
// CPythonPlayer::GetRace: the main character's race (the port keeps it on the network stream).
static PyObject* player_GetRace(PyObject*, PyObject*) {
return Py_BuildValue("i", int(PythonNetworkStream::Instance().GetMainActorRace()));
}
static PyObject* player_GetJob(PyObject*, PyObject*) {
// RaceToJob, ENABLE_WOLFMAN_CHARACTER off.
const int race = int(PythonNetworkStream::Instance().GetMainActorRace());
const int JOB_NUM = 4;
return Py_BuildValue("i", race % JOB_NUM);
}
// playerGetEXP / playerGetConquerorEXP: DWORD dwEXP = GetStatus(POINT_EXP / POINT_CONQUEROR_EXP),
// built with "l" (a 32-bit long on Windows).
template<int Point> static PyObject* player_GetDWORDStatus(PyObject*, PyObject*) {
const uint32_t dwEXP = uint32_t(GetPlayerStatusPoint(Point));
return Py_BuildValue("l", long(int32_t(dwEXP)));
}
static PyObject* player_GetPlayTime(PyObject*, PyObject*) {
return Py_BuildValue("i", int(s_playTime));
}
static PyObject* player_SetPlayTime(PyObject*, PyObject* poArgs) {
int iTime;
if (!PyTuple_GetInteger(poArgs, 0, &iTime))
return Py_BuildException();
s_playTime = uint32_t(iTime);
return Py_BuildNone();
}
static PyObject* player_SlotTypeToInvenType(PyObject*, PyObject* poArgs) {
int slotType = 0;
if (!PyTuple_GetInteger(poArgs, 0, &slotType))
return Py_BadArgument();
return Py_BuildValue("i", int(SlotTypeToInvenType(uint8_t(slotType))));
}
static PyObject* player_ClickSkillSlot(PyObject*, PyObject* args) {
int skillSlot = 0;
if (!PyTuple_GetInteger(args, 0, &skillSlot)) return Py_BadArgument();
ClickSkillSlot(skillSlot);
if (s_skillCastCallback) {
s_skillCastCallback(-1, skillSlot);
}
Py_RETURN_NONE;
}
static PyObject* player_IsSkillCoolTime(PyObject*,PyObject* args) {
int slot;if(!PyArg_ParseTuple(args,"i",&slot)) return nullptr;
if(uint32_t(slot)>=255) return PyInt_FromLong(0);
auto it=s_playerSkills.find(slot);
return PyInt_FromLong(it!=s_playerSkills.end() && it->second.cooldown.cooling(CTimer::Instance().GetCurrentSecond(),s_coolTimeEnabled));
}
static PyObject* player_GetSkillCoolTime(PyObject*,PyObject* args) {
int slot;if(!PyArg_ParseTuple(args,"i",&slot)) return nullptr;
if(uint32_t(slot)>=255) return Py_BuildValue("ff",0.0f,0.0f);
auto it=s_playerSkills.find(slot);
SkillCooldown cooldown=it==s_playerSkills.end()?SkillCooldown{}:it->second.cooldown;
return Py_BuildValue("ff",cooldown.total,cooldown.elapsed(CTimer::Instance().GetCurrentSecond()));
}
static PyObject* player_ToggleCoolTime(PyObject*,PyObject*) {
s_coolTimeEnabled=!s_coolTimeEnabled;return PyInt_FromLong(s_coolTimeEnabled);
}
struct ItemInfo {
uint32_t vnum = 0;
std::string name;
std::string iconPath;
std::string modelPath;
int type = 0;
int subType = 0;
int width = 1;
int height = 0;
int limitLevel = 0;
int applyType = 0;
int applyValue = 0;
int values[6] = {0};
std::string desc;
std::string summary;
uint32_t imageHandle = 0;
std::array<ItemScaleInfo,10> scale{}; // CItemData::m_ScaleTable.tInfo (ENABLE_SASH_SYSTEM)
};
static std::unordered_map<uint32_t, ItemInfo> s_itemMap;
static uint32_t s_selectedItemVnum = 0;
static bool s_hasSelectedItem=false;
static std::array<PlayerItemSlot,262> s_playerItems{};
static std::map<std::pair<uint8_t,uint16_t>,TItemData> s_windowItems;
static ItemProto s_itemProto;
static bool ItemResourceExists(const std::string& path) {try {ReadPackedText(path);return true;}catch(const std::exception&){return CResourceManager::ResourceExists(path);}}
template<bool drop> static PyObject* item_SetSoundFileName(PyObject*,PyObject* args) {
int type;char* filename;
if(!PyTuple_GetInteger(args,0,&type)||!PyTuple_GetString(args,1,&filename))return Py_BadArgument();
if constexpr(drop)SetItemDropSound(uint32_t(type),filename);else SetItemUseSound(uint32_t(type),filename);
Py_RETURN_NONE;
}
static PyObject* item_GetApplyPoint(PyObject*, PyObject* poArgs) {
int applyType = 0;
if (!PyTuple_GetInteger(poArgs, 0, &applyType))
return Py_BadArgument();
return Py_BuildValue("i", int(ApplyTypeToPointType(uint8_t(applyType))));
}
static PyObject* item_LoadItemTable(PyObject*,PyObject* args) {
const char* path;if(!PyArg_ParseTuple(args,"s",&path))return nullptr;
LoadItemTable(path);
Py_RETURN_NONE; // Original wrapper ignores native loader success.
}
static bool select_item_data(uint32_t id) {
if(s_itemMap.find(id)!=s_itemMap.end()){s_selectedItemVnum=id;s_hasSelectedItem=true;return true;}
const auto* range=s_itemProto.find(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;
if(!select_item_data(uint32_t(vnum)))select_item_data(60001);
// Original failed selection keeps the previous pointer if fallback also fails.
Py_RETURN_NONE;
}
static PyObject* item_Classify(PyObject* args,int query) {
int vnum=0;if(!PyArg_ParseTuple(args,"i",&vnum))return nullptr;
if(!select_item_data(static_cast<uint32_t>(vnum)))select_item_data(60001);
const auto selected=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(selected==s_itemMap.end()) { PyErr_SetString(PyExc_RuntimeError,"Can't find select item data");return nullptr; }
const auto& item=selected->second;
if(query==0)return PyInt_FromLong(item.type==3&&item.subType==2);
if(query==1)return PyInt_FromLong(item.type==3&&item.subType==14);
if(query==2)return PyInt_FromLong(item.type==21);
if(query==3)return PyInt_FromLong(item.type==10);
if(query==4)return PyInt_FromLong(item.type==3||item.type==18);
if(query==6)return PyInt_FromLong(item.type==1||item.type==2);
if(item.type!=3)return PyString_FromString("NOT_USE_TYPE");
const char* use="USE_UNKNOWN_TYPE";
switch(item.subType) {
case 2:use="USE_TUNING";break;
case 14:use="USE_DETACHMENT";break;
case 17:use="USE_CLEAN_SOCKET";break;
case 18:use="USE_CHANGE_ATTRIBUTE";break;
case 19:use="USE_ADD_ATTRIBUTE";break;
case 20:use="USE_ADD_ACCESSORY_SOCKET";break;
case 21:use="USE_PUT_INTO_ACCESSORY_SOCKET";break;
case 22:use="USE_ADD_ATTRIBUTE2";break;
case 24:use="USE_CHANGE_ATTRIBUTE2";break;
case 29:use="USE_PUT_INTO_BELT_SOCKET";break;
case 30:use="USE_PUT_INTO_RING_SOCKET";break;
case 31:use="USE_CHANGE_COSTUME_ATTR";break;
case 32:use="USE_RESET_COSTUME_ATTR";break;
}
return PyString_FromString(use);
}
static PyObject* item_IsRefineScroll(PyObject*,PyObject* args) { return item_Classify(args,0); }
static PyObject* item_IsDetachScroll(PyObject*,PyObject* args) { return item_Classify(args,1); }
static PyObject* item_IsKey(PyObject*,PyObject* args) { return item_Classify(args,2); }
static PyObject* item_IsMetin(PyObject*,PyObject* args) { return item_Classify(args,3); }
static PyObject* item_CanAddToQuickSlotItem(PyObject*,PyObject* args) { return item_Classify(args,4); }
static PyObject* item_GetUseType(PyObject*,PyObject* args) { return item_Classify(args,5); }
static PyObject* item_IsEquipmentVID(PyObject*,PyObject* args) { return item_Classify(args,6); }
static PyObject* item_GetItemName(PyObject*, PyObject*) {
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end()) {
return PyString_FromString(it->second.name.c_str());
}
PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;
}
static PyObject* item_GetItemType(PyObject*, PyObject*) {
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end()) {
return PyInt_FromLong(it->second.type);
}
PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;
}
static PyObject* item_GetItemSubType(PyObject*, PyObject*) {
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end()) {
return PyInt_FromLong(it->second.subType);
}
PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;
}
static PyObject* item_GetIconImage(PyObject*, PyObject*) {
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end()) {
auto& info = it->second;
if (info.imageHandle == 0 && !info.iconPath.empty()) {
std::string p = ItemResourceExists(info.iconPath)?info.iconPath:"icon/item/27995.tga";
if (p.rfind("d:/", 0) == 0 || p.rfind("D:/", 0) == 0) p = p.substr(3);
CResource* pRes = CResourceManager::Instance().GetResourcePointer(p.c_str());
if (pRes && pRes->IsType(CGraphicImage::Type())) {
auto* pImg = static_cast<CGraphicImage*>(pRes);
info.imageHandle = GrpRegisterImageHandle(pImg);
}
}
return PyInt_FromLong((long)info.imageHandle);
}
PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;
}
static PyObject* item_GetIconImageFileName(PyObject*, PyObject*) {
auto it=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(it==s_itemMap.end()) {PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;}
const auto& declared=it->second.iconPath;
const auto path=ItemResourceExists(declared)?declared:std::string("icon/item/27995.tga");
if(!ItemResourceExists(path))return PyString_FromString("Noname");
auto* resource=CResourceManager::Instance().GetResourcePointer(path.c_str());
if(!resource||!resource->IsType(CGraphicImage::Type()))return PyString_FromString("Noname");
return PyString_FromString(resource->GetFileName());
}
static PyObject* item_GetItemSize(PyObject*, PyObject*) {
auto it=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(it==s_itemMap.end()) {PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;}
return Py_BuildValue("(ii)",1,it->second.height);
}
static PyObject* item_refine_field(bool set) {
if((s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end())==s_itemMap.end()) {
PyErr_SetString(PyExc_RuntimeError,"Can't find select item data");return nullptr;
}
auto it=s_itemProto.records.find(s_selectedItemVnum);
if(it==s_itemProto.records.end())return PyInt_FromLong(0);
return PyInt_FromLong(set?int32_t(it->second.refineSet):int32_t(it->second.refined));
}
static PyObject* item_GetRefinedVnum(PyObject*,PyObject*) {return item_refine_field(false);}
static PyObject* item_GetRefineSet(PyObject*,PyObject*) {return item_refine_field(true);}
static PyObject* item_SelectItemWiki(PyObject*,PyObject* args) {
int id;if(!PyArg_ParseTuple(args,"i",&id))return nullptr;
return PyInt_FromLong(select_item_data(uint32_t(id)));
}
static const ItemProtoRecord* selected_item_record() {
if((s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end())==s_itemMap.end()) {
PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;
}
auto it=s_itemProto.records.find(s_selectedItemVnum);
static const ItemProtoRecord empty;
return it==s_itemProto.records.end()?&empty:&it->second;
}
static PyObject* item_buy_price(PyObject*,PyObject*) {
const auto* item=selected_item_record();if(!item)return nullptr;
return PyLong_FromLongLong(item->buyPrice);
}
static PyObject* item_sell_price(PyObject*,PyObject*) {
const auto* item=selected_item_record();if(!item)return nullptr;
return PyLong_FromLongLong(item->sellPrice);
}
static PyObject* item_flag_query(PyObject* args,int field) {
int mask;if(!PyArg_ParseTuple(args,"i",&mask))return nullptr;
const auto* item=selected_item_record();if(!item)return nullptr;
uint32_t bits=field==0?item->antiFlags:field==1?item->flags:item->wearFlags;
return PyInt_FromLong((bits&uint32_t(mask))!=0);
}
static PyObject* item_anti_flag(PyObject*,PyObject* args){return item_flag_query(args,0);}
static PyObject* item_flag(PyObject*,PyObject* args){return item_flag_query(args,1);}
static PyObject* item_wear_flag(PyObject*,PyObject* args){return item_flag_query(args,2);}
static PyObject* item_one_gold(PyObject*,PyObject*) {
const auto* item=selected_item_record();if(!item)return nullptr;
return PyInt_FromLong((item->flags&8u)!=0);
}
static PyObject* item_socket(PyObject*,PyObject* args) {
int raw;if(!PyArg_ParseTuple(args,"i",&raw))return nullptr;
const auto* item=selected_item_record();if(!item)return nullptr;
uint8_t index=uint8_t(raw);
return PyInt_FromLong(index<8?item->sockets[index]:-1);
}
static PyObject* item_table_pair(PyObject* args,bool apply) {
int raw;if(!PyArg_ParseTuple(args,"i",&raw))return nullptr;
uint8_t index=uint8_t(raw);
auto it=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(it==s_itemMap.end()){PyErr_SetString(PyExc_RuntimeError,"Not yet select item data");return nullptr;}
if(index>=(apply?3:2)){PyErr_SetString(PyExc_RuntimeError,"Invalid item table index");return nullptr;}
std::pair<uint8_t,int32_t> value{};
auto proto=s_itemProto.records.find(s_selectedItemVnum);
if(proto!=s_itemProto.records.end())value=apply?proto->second.applies[index]:proto->second.limits[index];
else if(index==0)value=apply?std::pair<uint8_t,int32_t>{uint8_t(it->second.applyType),it->second.applyValue}:std::pair<uint8_t,int32_t>{uint8_t(it->second.limitLevel>0?1:0),it->second.limitLevel};
if(apply&&value.first==7&&it->second.type==1&&it->second.subType==3)
value.second=int32_t(uint32_t(value.second)-uint32_t(GetTwoHandedAttackSpeedDecrease()));
return Py_BuildValue("ii",int(value.first),value.second);
}
static PyObject* item_GetLimit(PyObject*,PyObject* args){return item_table_pair(args,false);}
static PyObject* item_GetAffect(PyObject*,PyObject* args){return item_table_pair(args,true);}
static PyObject* item_GetValue(PyObject*, PyObject* args) {
int idx = 0;
if (!PyArg_ParseTuple(args, "i", &idx)) return PyInt_FromLong(0);
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end() && idx >= 0 && idx < 6) {
return PyInt_FromLong(it->second.values[idx]);
}
return PyInt_FromLong(0);
}
static PyObject* item_GetItemDescription(PyObject*, PyObject*) {
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end()) {
return PyString_FromString(it->second.desc.c_str());
}
PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;
}
static PyObject* item_GetItemSummary(PyObject*, PyObject*) {
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end()) {
return PyString_FromString(it->second.summary.c_str());
}
PyErr_SetString(PyExc_RuntimeError,"no selected item data");return nullptr;
}
static PyObject* item_GetNames(PyObject*, PyObject*) {
auto it = (s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if (it != s_itemMap.end()) {
return PyString_FromString(it->second.name.c_str());
}
return PyString_FromString("");
}
static bool valid_player_item_position(uint8_t window,uint16_t cell) {
const unsigned capacity=window==1?262:window==2?228:
window==5?1152:(window>=6&&window<=10)?180:
window==11?6:window==12?102:0;
return cell<capacity;
}
static PyObject* player_ItemMetadata(PyObject* args, int field) {
int window=1, cell=0, mask=0;
const auto count=PyTuple_Size(args);
if(field==1) {
if(count==2) { if(!PyArg_ParseTuple(args,"ii",&cell,&mask))return nullptr; }
else if(count==3) { if(!PyArg_ParseTuple(args,"iii",&window,&cell,&mask))return nullptr; }
else { PyErr_SetString(PyExc_RuntimeError,"invalid item position arguments");return nullptr; }
} else {
if(count==1) { if(!PyArg_ParseTuple(args,"i",&cell))return nullptr; }
else if(count==2) { if(!PyArg_ParseTuple(args,"ii",&window,&cell))return nullptr; }
else { PyErr_SetString(PyExc_RuntimeError,"invalid item position arguments");return nullptr; }
}
const auto nativeWindow=static_cast<uint8_t>(window);
const auto nativeCell=static_cast<uint16_t>(cell);
// Active AVA2 GameType.h SItemPos::IsValidCell bounds, including its
// exclusion of safebox/mall and the separate belt window.
if(!valid_player_item_position(nativeWindow,nativeCell))return PyInt_FromLong(0);
const auto data=GetPlayerItemData(nativeWindow,nativeCell);
if(field==0)return PyInt_FromLong(std::bit_cast<int32_t>(data.flags));
if(field==1)return PyInt_FromLong((data.anti_flags&static_cast<uint32_t>(mask))!=0);
if(field==4)return PyInt_FromLong(std::bit_cast<int32_t>(data.vnum));
if(field==5)return PyInt_FromLong(std::bit_cast<int32_t>(data.count));
const auto* proto=s_itemProto.find(data.vnum);
return PyInt_FromLong(proto?(field==2?proto->type:proto->subtype):0);
}
static PyObject* player_GetItemFlags(PyObject*,PyObject* args) { return player_ItemMetadata(args,0); }
static PyObject* player_GetISellItemPrice(PyObject*,PyObject* args) {
int window=1,cell=0;
if(PyTuple_Size(args)==1) { if(!PyArg_ParseTuple(args,"i",&cell))return nullptr; }
else if(!PyArg_ParseTuple(args,"ii",&window,&cell))return nullptr;
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
if(!valid_player_item_position(w,c))return PyInt_FromLong(0);
const auto data=GetPlayerItemData(w,c);
const auto* proto=s_itemProto.find(data.vnum);
if(!proto)return PyInt_FromLong(0);
uint32_t price=0;
if(proto->flags&8u) {
// The original divides by this field without guarding corrupt data.
if(!proto->sellPrice) { PyErr_SetString(PyExc_ZeroDivisionError,"zero item sell price");return nullptr; }
price=data.count/proto->sellPrice;
} else price=proto->sellPrice*data.count;
return PyInt_FromLong(std::bit_cast<int32_t>(price));
}
static PyObject* player_IsAntiFlagBySlot(PyObject*,PyObject* args) { return player_ItemMetadata(args,1); }
static PyObject* player_GetItemTypeBySlot(PyObject*,PyObject* args) { return player_ItemMetadata(args,2); }
static PyObject* player_GetItemSubTypeBySlot(PyObject*,PyObject* args) { return player_ItemMetadata(args,3); }
static PyObject* player_GetItemIndex(PyObject*, PyObject* args) {
return player_ItemMetadata(args,4);
}
static PyObject* player_IsSameItemVnum(PyObject*,PyObject* args) {
int vnum=0,window=1,cell=0;
if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&vnum,&cell))return nullptr; }
else if(!PyArg_ParseTuple(args,"iii",&vnum,&window,&cell))return nullptr;
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
const auto actual=valid_player_item_position(w,c)?GetPlayerItemData(w,c).vnum:0;
return PyInt_FromLong(static_cast<uint32_t>(vnum)==actual);
}
static PyObject* player_GetItemNewName(PyObject*,PyObject* args) {
int window=1,cell=0;
if(PyTuple_Size(args)==1) { if(!PyArg_ParseTuple(args,"i",&cell))return nullptr; }
else if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&window,&cell))return nullptr; }
else return PyString_FromString("^");
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
if(!valid_player_item_position(w,c))return PyString_FromString("^");
const auto data=GetPlayerItemData(w,c);
return PyString_FromStringAndSize(data.name,strnlen(data.name,sizeof(data.name)));
}
static PyObject* player_GetItemCount(PyObject*, PyObject* args) {
return player_ItemMetadata(args,5);
}
static PyObject* player_CountItems(PyObject* args,uint8_t window,uint16_t capacity) {
int vnum = 0;
if (!PyArg_ParseTuple(args, "i", &vnum)) return nullptr;
uint32_t total = 0;
for(uint16_t cell=0;cell<capacity;++cell) {
const auto item=GetPlayerItemData(window,cell);
if(item.vnum==static_cast<uint32_t>(vnum))total+=item.count;
}
return PyInt_FromLong(std::bit_cast<int32_t>(total));
}
static PyObject* player_GetItemCountByVnum(PyObject*, PyObject* args) {
return player_CountItems(args,1,262);
}
static PyObject* player_GetItemCountByTT(PyObject*, PyObject* args) {
return player_CountItems(args,6,180);
}
static PyObject* player_GetItemGrade(PyObject*, PyObject* args) {
int window = 1, slot = 0;
if(PyTuple_Size(args)==1) { if(!PyArg_ParseTuple(args,"i",&slot))return nullptr; }
else if(!PyArg_ParseTuple(args,"ii",&window,&slot))return nullptr;
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(slot);
const auto vnum=valid_player_item_position(w,c)?GetPlayerItemData(w,c).vnum:0;
if(!select_item_data(vnum))select_item_data(60001);
const auto found=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(found==s_itemMap.end()) { PyErr_SetString(PyExc_RuntimeError,"Can't find item data");return nullptr; }
const auto& name=found->second.name;
const char last=name.empty()?'0':name.back();
return PyInt_FromLong(last>='0'&&last<='9'?last-'0':0);
}
static PyObject* player_IsValuableItem(PyObject*,PyObject* args) {
int window=1,cell=0;
if(PyTuple_Size(args)==1) { if(!PyArg_ParseTuple(args,"i",&cell))return nullptr; }
else if(!PyArg_ParseTuple(args,"ii",&window,&cell))return nullptr;
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
const auto data=valid_player_item_position(w,c)?GetPlayerItemData(w,c):TItemData{};
if(!select_item_data(data.vnum))select_item_data(60001);
if(!s_itemMap.contains(s_selectedItemVnum)) { PyErr_SetString(PyExc_RuntimeError,"Can't find item data");return nullptr; }
// Original Packet.h METIN_SOCKET_COUNT is six, not the eight stored sockets.
bool valuable=false;
for(size_t i=0;i<6;++i)valuable|=data.alSockets[i]!=0;
const auto* proto=s_itemProto.find(s_selectedItemVnum);
return PyInt_FromLong(valuable||(proto&&proto->sellPrice>5000));
}
static PyObject* player_CanUnlock(PyObject*,PyObject* args) {
int key=0,window=1,cell=0;
if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&key,&cell))return nullptr; }
else if(!PyArg_ParseTuple(args,"iii",&key,&window,&cell))return nullptr;
if(!select_item_data(static_cast<uint32_t>(key)))select_item_data(60001);
auto selected=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(selected==s_itemMap.end()) { PyErr_SetString(PyExc_RuntimeError,"Can't find item data");return nullptr; }
if(selected->second.type!=21)return PyInt_FromLong(0);
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
const auto vnum=valid_player_item_position(w,c)?GetPlayerItemData(w,c).vnum:0;
if(!select_item_data(vnum))select_item_data(60001);
selected=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(selected==s_itemMap.end()) { PyErr_SetString(PyExc_RuntimeError,"Can't find item data");return nullptr; }
return PyInt_FromLong(selected->second.type==20);
}
static PyObject* player_CanDetach(PyObject*,PyObject* args) {
int scroll=0,window=1,cell=0;
if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&scroll,&cell))return nullptr; }
else if(!PyArg_ParseTuple(args,"iii",&scroll,&window,&cell))return nullptr;
if(!select_item_data(static_cast<uint32_t>(scroll)))select_item_data(60001);
auto selected=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(selected==s_itemMap.end()) { PyErr_SetString(PyExc_RuntimeError,"Can't find item data");return nullptr; }
if(selected->second.type!=3||selected->second.subType!=14)return PyInt_FromLong(0);
const auto* scrollProto=s_itemProto.find(s_selectedItemVnum);
const bool sashClean=scrollProto&&scrollProto->values[0]==7;
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
const auto data=valid_player_item_position(w,c)?GetPlayerItemData(w,c):TItemData{};
if(!select_item_data(data.vnum))select_item_data(60001);
selected=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(selected==s_itemMap.end()) { PyErr_SetString(PyExc_RuntimeError,"Can't find item data");return nullptr; }
if(sashClean)return PyInt_FromLong(selected->second.type==28&&selected->second.subType==3&&data.alSockets[1]>0);
const auto* target=s_itemProto.find(s_selectedItemVnum);
if(target&&(target->flags&1u))
for(size_t i=0;i<6;++i)if(static_cast<uint32_t>(data.alSockets[i])>2)return PyInt_FromLong(1);
return PyInt_FromLong(0);
}
static PyObject* player_CanAttachMetin(PyObject*,PyObject* args) {
int metin=0,window=1,cell=0;
if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&metin,&cell))return nullptr; }
else if(!PyArg_ParseTuple(args,"iii",&metin,&window,&cell))return nullptr;
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
if((w==1||w==2)&&c>=180&&c<216)return PyInt_FromLong(5);
const auto data=valid_player_item_position(w,c)?GetPlayerItemData(w,c):TItemData{};
const auto* stone=s_itemProto.find(static_cast<uint32_t>(metin));
const auto* target=s_itemProto.find(data.vnum);
if(!stone||!target) { PyErr_SetString(PyExc_RuntimeError,"can't find item data");return nullptr; }
if(!(stone->wearFlags&target->wearFlags))return PyInt_FromLong(2);
if(target->type==13)return PyInt_FromLong(0);
bool silver=false;
for(const auto socket:data.alSockets) {
if(stone->subtype==0&&(socket==1||socket==2))return PyInt_FromLong(1);
if(stone->subtype==1) {
if(socket==2)return PyInt_FromLong(1);
if(socket==1)silver=true;
}
}
return PyInt_FromLong(silver?4:3);
}
static PyObject* player_CanRefine(PyObject*,PyObject* args) {
int scroll=0,window=1,cell=0;
if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&scroll,&cell))return nullptr; }
else if(!PyArg_ParseTuple(args,"iii",&scroll,&window,&cell))return nullptr;
const auto w=static_cast<uint8_t>(window);const auto c=static_cast<uint16_t>(cell);
if((w==1||w==2)&&c>=180&&c<216)return PyInt_FromLong(6);
if(!select_item_data(static_cast<uint32_t>(scroll)))select_item_data(60001);
auto selected=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(selected==s_itemMap.end()||selected->second.type!=3||selected->second.subType!=2)return PyInt_FromLong(0);
const auto vnum=valid_player_item_position(w,c)?GetPlayerItemData(w,c).vnum:0;
if(!select_item_data(vnum))select_item_data(60001);
selected=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
if(selected==s_itemMap.end())return PyInt_FromLong(0);
if(selected->second.type==13)return PyInt_FromLong(7);
const auto* proto=s_itemProto.find(s_selectedItemVnum);
return PyInt_FromLong(proto&&proto->refined?1:5);
}
static PyObject* player_IsRefineGradeScroll(PyObject*, PyObject* args) {
// Original PythonPlayerModule switch has no breaks: every signature
// reaches Py_BuildException(). ScriptLib's no-message helper clears
// errors and returns None, so the selection/grade code is unreachable.
(void)args;
PyErr_Clear();
Py_RETURN_NONE;
}
static PyObject* player_GetItemMetinSocket(PyObject*, PyObject* args) {
int window = 1, slot = 0, socket = 0;
if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&slot,&socket))return nullptr; }
else if(!PyArg_ParseTuple(args,"iii",&window,&slot,&socket))return nullptr;
window=static_cast<uint8_t>(window);slot=static_cast<uint16_t>(slot);
if (valid_player_item_position(window,slot) && socket >= 0 && socket < 8) {
return PyInt_FromLong(GetPlayerItemData(window,slot).alSockets[socket]);
}
return Py_BuildValue("l", 0L);
}
static PyObject* player_GetItemAttribute(PyObject*, PyObject* args) {
int window = 1, slot = 0, attr = 0;
if(PyTuple_Size(args)==2) { if(!PyArg_ParseTuple(args,"ii",&slot,&attr))return nullptr; }
else if(!PyArg_ParseTuple(args,"iii",&window,&slot,&attr))return nullptr;
window=static_cast<uint8_t>(window);slot=static_cast<uint16_t>(slot);
if (valid_player_item_position(window,slot) && attr >= 0 && attr < 15) {
const auto data=GetPlayerItemData(window,slot);
return Py_BuildValue("ii",data.aAttr[attr].bType,data.aAttr[attr].sValue);
}
return Py_BuildValue("ii", 0, 0);
}
static PyObject* player_GetElk(PyObject*, PyObject*) {
auto it = s_playerPoints.find(11);
long long gold = (it != s_playerPoints.end()) ? it->second : 0LL;
return PyLong_FromLongLong(gold);
}
static PyObject* player_GetMoney(PyObject*, PyObject*) {
auto it = s_playerPoints.find(11);
long long gold = (it != s_playerPoints.end()) ? it->second : 0LL;
return PyLong_FromLongLong(gold);
}
static PyObject* player_IsEquipmentSlot(PyObject*, PyObject* args) {
int slot = 0;
if(!PyArg_ParseTuple(args,"i",&slot))return nullptr;
return PyInt_FromLong(slot>=180&&slot<=228);
}
static PyObject* player_IsDSEquipmentSlot(PyObject*,PyObject* args) {
int window=0,slot=0;
if(!PyArg_ParseTuple(args,"ii",&window,&slot))return nullptr;
return PyInt_FromLong(static_cast<uint8_t>(window)==1&&slot>=216&&slot<=228);
}
static PyObject* player_IsCostumeSlot(PyObject*, PyObject* args) {
int slot = 0;
if(!PyArg_ParseTuple(args,"i",&slot))return nullptr;
return PyInt_FromLong(slot>=199&&slot<=203);
}
static PyObject* player_IsBeltInventorySlot(PyObject*, PyObject* args) {
int slot = 0;
if(!PyArg_ParseTuple(args,"i",&slot))return nullptr;
const auto cell=static_cast<uint16_t>(slot);
return PyInt_FromLong(cell>=246&&cell<262);
}
} // namespace
int AffectIndexToSkillIndex(int affect) {
// AVA2 PythonPlayer::__Initialize: this map is independent of skill registration.
static const int mapping[][2]={{14,3},{15,4},{16,19},{17,49},{18,34},{20,64},{21,65},{22,94},{23,95},{24,110},{29,96},{30,111},{32,66},{33,19},{19,63},{26,78},{25,79},{46,182}};
for(const auto& entry:mapping) if(entry[0]==affect) return entry[1];
return 0;
}
void UseGuildSkill(int skillSlot) {
if (uint32_t(skillSlot) >= 255) return;
auto it = s_playerSkills.find(skillSlot);
if (it == s_playerSkills.end() || it->second.index == 0) return;
int skillIndex = it->second.index;
const auto* pSkillData = FindSkillDescription(uint32_t(skillIndex));
float now = CTimer::Instance().GetCurrentSecond();
if (it->second.cooldown.cooling(now, s_coolTimeEnabled)) {
player_window_call("OnCannotUseSkill", Py_BuildValue("(is)", PythonNetworkStream::Instance().GetMainActorVID(), "WAIT_COOLTIME"));
return;
}
bool onlyGuildWar = pSkillData && (pSkillData->attributes & (1u << 19 /* SKILL_ATTRIBUTE_ONLY_FOR_GUILD_WAR */));
if (onlyGuildWar && !GetGuildState().IsDoingGuildWar()) {
player_window_call("OnCannotUseSkill", Py_BuildValue("(is)", PythonNetworkStream::Instance().GetMainActorVID(), "ONLY_FOR_GUILD_WAR"));
return;
}
PythonNetworkStream::Instance().SendGuildUseSkillPacket(uint32_t(skillIndex), 0);
float baseCoolTime = pSkillData ? EvaluateSkillFormula(pSkillData->cooldownFormula, it->second.currentPower) : 0.0f;
long long castSpd = 0;
auto spdIt = s_playerPoints.find(19 /* POINT_CASTING_SPEED */);
if (spdIt != s_playerPoints.end()) castSpd = spdIt->second;
int iSpd = 100 - int(castSpd);
if (iSpd > 0) iSpd = 100 + iSpd;
else if (iSpd < 0) iSpd = 10000 / (100 - iSpd);
else iSpd = 100;
float coolTime = baseCoolTime * float(iSpd) / 100.0f;
it->second.cooldown = {coolTime, now};
player_window_call("RunUseSkillEvent", Py_BuildValue("(if)", skillSlot, coolTime));
}
static bool s_isAtkKey = false;
static std::array<bool, 256> s_movementKeys{};
static bool s_joystickActive = false;
static float s_joystickX = 0.0f, s_joystickY = 0.0f;
bool GetPlayerMovementYaw(float cameraYaw, float& movementYaw) {
float x = float(int(s_movementKeys[32] || s_movementKeys[205]) - int(s_movementKeys[30] || s_movementKeys[203]));
float z = float(int(s_movementKeys[31] || s_movementKeys[208]) - int(s_movementKeys[17] || s_movementKeys[200]));
// Joystick screen-down is "back" like DIK_S, so it maps onto the same camera-relative axes.
if (s_joystickActive) { x = s_joystickX; z = s_joystickY; }
if (x == 0.0f && z == 0.0f) return false;
movementYaw = std::atan2(x, z) * 180.0f / 3.14159265f - cameraYaw;
movementYaw = std::fmod(movementYaw + 720.0f, 360.0f);
return true;
}
// CPythonPlayer::SetTarget(dwVID, FALSE) as CPythonPlayerEventHandler::OnHit calls it: a different
// victim replaces the target only once the 1 s target hold has run out. CanChangeTarget and
// IsTargetableInstance are not checked.
static uint32_t s_targetEndTime = 0;
static void SetPlayerHitTarget(uint32_t vid) {
const uint32_t now = GetServerMSec();
if (s_targetVID == vid) {
s_targetEndTime = now + 1000;
return;
}
if (s_targetEndTime > now) return;
s_targetEndTime = now + 1000;
s_targetVID = vid;
PythonNetworkStream::Instance().SendTargetPacket(vid);
}
static float s_attackCameraYaw = 0.0f;
// CPythonPlayer::NEW_Attack + CInstanceBase::NEW_Attack(fDirRot). Not ported from __CanAttack:
// emotion / private shop / observer / new-mount skill checks. Bow mode needs a live target (the
// clickable-distance reserve and arrow flight are not ported).
static bool PlayerNewAttack() {
auto& manager = NetworkActorManager::Instance();
auto* main = manager.GetMainInstance();
if (!main || !main->m_pActorInstance) return false;
auto& inst = *main->m_pActorInstance;
if (!inst.CanAct() || inst.IsUsingSkill()) return false;
float dirYaw = inst.GetYaw();
if (inst.IsBowMode()) {
const auto* target = s_targetVID ? manager.GetActorData(s_targetVID) : nullptr;
if (!target || !target->m_pActorInstance || target->m_pActorInstance->IsDead()) {
player_window_call("OnCannotUseSkill", Py_BuildValue("(is)", PythonNetworkStream::Instance().GetMainActorVID(), "NEED_TARGET"));
return false;
}
if (!HasEnoughArrow()) return false;
const float dx = target->m_pActorInstance->GetX() - inst.GetX();
const float dz = target->m_pActorInstance->GetZ() - inst.GetZ();
dirYaw = std::fmod(std::atan2(dx, dz) * 180.0f / 3.14159265f + 360.0f, 360.0f);
} else if (!GetPlayerMovementYaw(s_attackCameraYaw, dirYaw)) {
// No hand attacks while mounted without a direction.
if (inst.IsMountingHorse() && inst.IsHandMode()) return false;
dirYaw = inst.GetYaw();
}
// EndWalking / m_isGoing = FALSE.
inst.ClearMoveTarget();
inst.StopMoving();
if (inst.IsPolymorph() || main->m_bType == 7) return inst.InputNormalAttackCommand(dirYaw);
return inst.InputComboAttackCommand(dirYaw);
}
bool IsPlayerAttacking() {
auto* main = NetworkActorManager::Instance().GetMainInstance();
return main && main->m_pActorInstance && main->m_pActorInstance->IsAttacking();
}
bool ProcessPlayerAttack(float cameraYaw, float frameDt, bool wasMoving) {
s_attackCameraYaw = cameraYaw;
auto& manager = NetworkActorManager::Instance();
auto* main = manager.GetMainInstance();
if (!main || !main->m_pActorInstance) return false;
auto& inst = *main->m_pActorInstance;
inst.SetReportAttacks(true);
// CInstanceBase::Update: ComboProcess, then CPythonPlayer input (m_isAtkKey -> NEW_Attack).
inst.ComboProcess();
if (s_isAtkKey) PlayerNewAttack();
// CPythonPlayerEventHandler::OnAttack: SendCharacterStatePacket(pos, rot, FUNC_COMBO, motion).
uint16_t motion;
bool stopSent = false;
while (inst.PopAttackMotion(&motion)) {
// EndWalking reports the stop (FUNC_WAIT) before the attack state.
if (wasMoving && !stopSent) {
PythonNetworkStream::Instance().SendCharacterMovePacket(0, 0,
uint8_t(std::fmod(inst.GetYaw() + 360.0f, 360.0f) / 5.0f),
int32_t(inst.GetX()), int32_t(inst.GetZ()), GetServerMSec());
stopSent = true;
}
PythonNetworkStream::Instance().SendCharacterMovePacket(3, uint8_t(motion),
uint8_t(std::fmod(inst.GetYaw() + 360.0f, 360.0f) / 5.0f),
int32_t(inst.GetX()), int32_t(inst.GetZ()), GetServerMSec());
}
// CInstanceBase::AttackProcess: hit-test every attackable instance (enemies and stones; PvP
// rules are not ported). Each hit is OnHit: SetTarget + SendAttackPacket(0, vid).
if (!inst.CanCheckAttacking()) return stopSent;
for (const auto& [vid, victim] : manager.GetActorDict()) {
if (vid == main->m_dwVID || !victim.m_pActorInstance) continue;
if (victim.m_bType != 0 && victim.m_bType != 2) continue; // TYPE_ENEMY / TYPE_STONE
const auto& v = *victim.m_pActorInstance;
if (v.IsDead()) continue;
if (inst.TestAttackHit(vid, v.GetX(), v.GetZ(), v.GetDefendingRadius(), frameDt, IsBossRace(victim.m_dwRace))) {
SetPlayerHitTarget(vid);
PythonNetworkStream::Instance().SendAttackPacket(0, vid);
}
}
return stopSent;
}
// Mobile step 6 auto hunt (src/game/auto_hunt.h). Fills the logic's view of the world from the
// same state manual play uses and carries out its decisions through the manual paths: actor move
// target (main.cpp sends the move packets), PlayerNewAttack (= held attack key), ClickSkillSlot,
// the pick-up packet and quickslot use.
static AutoHunt s_autoHunt;
static bool IsAutoHuntSkillReady(int skillSlot, float now) {
auto it = s_playerSkills.find(skillSlot);
if (it == s_playerSkills.end() || it->second.index == 0 || it->second.level <= 0) return false;
const int index = it->second.index;
if (index == 121 || index == 122 || index == 123) return false; // fishing / combo
if (GetSkillTypeById(uint32_t(index)) == 3 /* SKILL_TYPE_GUILD */) return false;
if (it->second.cooldown.cooling(now, s_coolTimeEnabled)) return false;
const auto* data = FindSkillDescription(uint32_t(index));
const bool toggle = data && (data->attributes & (1u << 1 /* SKILL_ATTRIBUTE_TOGGLE */));
return !(toggle && it->second.active);
}
static bool IsAutoHuntPotionSlot(int global) {
if (global < 0 || global >= int(s_playerQuickSlots.size())) return false;
const auto& quick = s_playerQuickSlots[global];
return quick.type == 1 /* SLOT_TYPE_INVENTORY */ && GetPlayerItemData(1, uint16_t(quick.pos)).count > 0;
}
static int PointPercent(int cur, int max) {
auto c = s_playerPoints.find(cur), m = s_playerPoints.find(max);
if (c == s_playerPoints.end() || m == s_playerPoints.end() || m->second <= 0) return 100;
return int(c->second * 100 / m->second);
}
void ProcessAutoHunt() {
if (!s_autoHunt.IsOn()) return;
auto& manager = NetworkActorManager::Instance();
auto* main = manager.GetMainInstance();
if (!main || !main->m_pActorInstance) return;
auto& inst = *main->m_pActorInstance;
AutoHuntInput in;
in.now = GetServerMSec();
in.x = inst.GetX();
in.z = inst.GetZ();
in.dead = inst.IsDead();
in.canAct = inst.CanAct();
in.busy = inst.IsAttacking() || inst.IsUsingSkill();
float yaw;
in.manual = s_isAtkKey || GetPlayerMovementYaw(0.0f, yaw) || IsPlayerMouseMoving();
in.hpPercent = PointPercent(5 /* POINT_HP */, 6 /* POINT_MAX_HP */);
in.spPercent = PointPercent(7 /* POINT_SP */, 8 /* POINT_MAX_SP */);
in.attackRange = inst.IsBowMode() ? 900.0f : 150.0f;
in.hpSlotUsable = IsAutoHuntPotionSlot(s_autoHunt.options.hpSlot);
in.spSlotUsable = IsAutoHuntPotionSlot(s_autoHunt.options.spSlot);
for (const auto& [vid, actor] : manager.GetActorDict()) {
if (vid == main->m_dwVID || !actor.m_pActorInstance) continue;
if (actor.m_bType != 0 && actor.m_bType != 2) continue; // TYPE_ENEMY / TYPE_STONE
const auto& v = *actor.m_pActorInstance;
if (v.IsDead()) continue;
in.mobs.push_back({vid, v.GetX(), v.GetZ(), v.GetDefendingRadius(), actor.m_bType == 2});
}
for (const auto& [vid, item] : CPythonItem::Instance().GetGroundItems()) {
if (!item->stOwnership.empty() && item->stOwnership != s_playerName) continue;
in.items.push_back({vid, item->v3EndPosition.x, -item->v3EndPosition.y});
}
// The combat wheel shows quickslot pages 1-3 (ui_mobile_combat.py); page 4 is the potion belt.
const float nowSec = CTimer::Instance().GetCurrentSecond();
const int page = s_quickPage < 3 ? s_quickPage : 0;
for (int local = 0; local < 8; ++local) {
const auto& quick = s_playerQuickSlots[page * 8 + local];
if (quick.type == 2 /* SLOT_TYPE_SKILL */ && IsAutoHuntSkillReady(quick.pos, nowSec))
in.readySkillSlots.push_back(quick.pos);
}
const AutoHuntOutput out = s_autoHunt.Update(in);
if (out.move == AutoHuntOutput::Move::Go) {
inst.SetMoveTarget(out.moveX, out.moveZ);
} else if (out.move == AutoHuntOutput::Move::Stop) {
inst.ClearMoveTarget();
inst.StopMoving();
}
if (out.useQuickSlot >= 0) use_global_quick_slot(out.useQuickSlot);
if (out.target && out.target != s_targetVID) {
s_targetVID = out.target;
PythonNetworkStream::Instance().SendTargetPacket(out.target);
}
if (out.attack) {
if (const auto* victim = manager.GetActorData(out.attack); victim && victim->m_pActorInstance) {
if (!inst.IsAttacking()) {
const float dx = victim->m_pActorInstance->GetX() - inst.GetX();
const float dz = victim->m_pActorInstance->GetZ() - inst.GetZ();
inst.SetYaw(std::fmod(std::atan2(dx, dz) * 180.0f / 3.14159265f + 360.0f, 360.0f));
}
if (out.skillSlot >= 0) ClickSkillSlot(out.skillSlot);
else PlayerNewAttack();
}
}
if (out.pick) PythonNetworkStream::Instance().SendItemPickUpPacket(out.pick);
if (out.stopped) player_window_call("OnAutoHuntStopped");
}
bool IsAutoHuntOn() { return s_autoHunt.IsOn(); }
static float s_fCmrRotSpd = 0.0f;
static uint32_t s_inGuildAreaID = 0xffffffff;
static bool IsMainActorFishingMode() {
const auto* pActor = player_main_actor();
if (pActor && pActor->m_dwMountVnum != 0) return false;
uint32_t weaponVnum = 0;
const auto equipWeapon = GetPlayerItemData(1, 184 /* EQUIPMENT_WEAPON */);
if (equipWeapon.vnum != 0) {
weaponVnum = equipWeapon.vnum;
} else if (pActor && pActor->m_dwWeapon != 0) {
weaponVnum = pActor->m_dwWeapon;
}
if (weaponVnum != 0) {
const auto* proto = s_itemProto.find(weaponVnum);
if (proto && proto->type == 13 /* ITEM_TYPE_ROD */) return true;
}
return false;
}
static bool IsMainActorFishing() {
const auto* pActor = player_main_actor();
return pActor && pActor->m_isFishing;
}
static bool NEW_CancelFishing() {
if (IsMainActorFishing()) {
static uint32_t s_dwLastCancelTime = 0;
uint32_t now = CTimer::Instance().GetCurrentMillisecond();
if (now < s_dwLastCancelTime + 500)
return false;
PythonNetworkStream::Instance().SendFishingPacket(0);
s_dwLastCancelTime = now;
return true;
}
return false;
}
static void NEW_Fishing() {
if (IsMainActorFishing()) {
PythonNetworkStream::Instance().SendFishingPacket(0);
} else {
if (IsMainActorFishingMode()) {
float curX = s_mainActorPos.x;
float curY = s_mainActorPos.y;
const auto* pActor = player_main_actor();
if (curX == 0.0f && curY == 0.0f && pActor) {
curX = float(pActor->m_lCurX);
curY = float(pActor->m_lCurY);
}
float charRot = pActor ? pActor->m_fRot : 0.0f;
int foundRot = -1;
const float c_fFishingDistance = 600.0f;
for (float fRot = 0.0f; fRot <= 180.0f; fRot += 10.0f) {
float radRight = (charRot + fRot) * 3.14159265358979323846f / 180.0f;
float rx = curX + c_fFishingDistance * sinf(radRight);
float ry = curY + c_fFishingDistance * cosf(radRight);
if (CPythonBackground::Instance().IsAttrOn(rx, ry, 2 /* ATTRIBUTE_WATER */)) {
foundRot = int(charRot + fRot);
break;
}
float radLeft = (charRot - fRot) * 3.14159265358979323846f / 180.0f;
float lx = curX + c_fFishingDistance * sinf(radLeft);
float ly = curY + c_fFishingDistance * cosf(radLeft);
if (CPythonBackground::Instance().IsAttrOn(lx, ly, 2 /* ATTRIBUTE_WATER */)) {
foundRot = int(charRot - fRot);
break;
}
}
if (foundRot >= 0) {
PythonNetworkStream::Instance().SendFishingPacket(foundRot);
} else {
player_window_call("OnFishingWrongPlace", Py_BuildValue("()"));
}
}
}
}
void ClickSkillSlot(int skillSlot) {
if (uint32_t(skillSlot) >= 255) return;
auto it = s_playerSkills.find(skillSlot);
if (it == s_playerSkills.end() || it->second.index == 0) return;
int skillIndex = it->second.index;
const auto* pSkillData = FindSkillDescription(uint32_t(skillIndex));
// Guild skill check
int skillType = GetSkillTypeById(uint32_t(skillIndex));
if (skillType == 3 /* SKILL_TYPE_GUILD */) {
UseGuildSkill(skillSlot);
return;
}
// Special skill check (fishing)
if (skillIndex == 123 /* SKILL_INDEX_FISHING */ || skillIndex == 121) {
if (IsMainActorFishingMode()) {
NEW_Fishing();
} else {
player_window_call("OnCannotUseSkill", Py_BuildValue("(is)", PythonNetworkStream::Instance().GetMainActorVID(), "EQUIP_FISHING_ROD"));
}
return;
}
// Special skill check (combo)
if (skillIndex == 122 /* c_iSkillIndex_Combo */) {
if (it->second.level > 0) {
PythonNetworkStream::Instance().SendUseSkillPacket(uint32_t(skillIndex), 0);
} else {
player_window_call("OnCannotUseSkill", Py_BuildValue("(is)", PythonNetworkStream::Instance().GetMainActorVID(), "NOT_YET_LEARN"));
}
return;
}
// Toggle skill active check (turns off if already active)
bool isToggle = pSkillData && (pSkillData->attributes & (1u << 1 /* SKILL_ATTRIBUTE_TOGGLE */));
if (isToggle && it->second.active) {
PythonNetworkStream::Instance().SendUseSkillPacket(uint32_t(skillIndex), 0);
return;
}
// Cooltime check
float now = CTimer::Instance().GetCurrentSecond();
if (it->second.cooldown.cooling(now, s_coolTimeEnabled)) {
player_window_call("OnCannotUseSkill", Py_BuildValue("(is)", PythonNetworkStream::Instance().GetMainActorVID(), "WAIT_COOLTIME"));
return;
}
// Target check
uint32_t targetVID = s_targetVID;
bool needTarget = pSkillData && (pSkillData->attributes & (1u << 0 /* SKILL_ATTRIBUTE_NEED_TARGET */));
bool canUseForMe = pSkillData && (pSkillData->attributes & (1u << 8 /* SKILL_ATTRIBUTE_CAN_USE_FOR_ME */));
if (needTarget && targetVID == 0 && !canUseForMe) {
player_window_call("OnCannotUseSkill", Py_BuildValue("(is)", PythonNetworkStream::Instance().GetMainActorVID(), "NEED_TARGET"));
return;
}
// Send use skill packet
PythonNetworkStream::Instance().SendUseSkillPacket(uint32_t(skillIndex), targetVID);
// Run cooltime
float baseCoolTime = pSkillData ? EvaluateSkillFormula(pSkillData->cooldownFormula, it->second.currentPower) : 0.0f;
long long castSpd = 0;
auto spdIt = s_playerPoints.find(19 /* POINT_CASTING_SPEED */);
if (spdIt != s_playerPoints.end()) castSpd = spdIt->second;
int iSpd = 100 - int(castSpd);
if (iSpd > 0) iSpd = 100 + iSpd;
else if (iSpd < 0) iSpd = 10000 / (100 - iSpd);
else iSpd = 100;
float coolTime = baseCoolTime * float(iSpd) / 100.0f;
it->second.cooldown = {coolTime, now};
player_window_call("RunUseSkillEvent", Py_BuildValue("(if)", skillSlot, coolTime));
if (s_skillCastCallback) {
s_skillCastCallback(-1, skillSlot);
}
}
void SetPlayerAffect(unsigned affect) {
if (s_playerGameWindow) {
player_window_call("SetAffect", Py_BuildValue("(I)", affect));
}
int skillIndex = AffectIndexToSkillIndex(int(affect));
if (skillIndex > 0) {
auto it = s_skillSlots.find(skillIndex);
if (it != s_skillSlots.end()) {
auto sit = s_playerSkills.find(it->second);
if (sit != s_playerSkills.end()) {
sit->second.active = true;
if (s_playerGameWindow) {
player_window_call("ActivateSkillSlot", Py_BuildValue("(i)", it->second));
}
}
}
}
}
void ResetPlayerAffect(unsigned affect) {
if (s_playerGameWindow) {
player_window_call("ResetAffect", Py_BuildValue("(I)", affect));
}
int skillIndex = AffectIndexToSkillIndex(int(affect));
if (skillIndex > 0) {
auto it = s_skillSlots.find(skillIndex);
if (it != s_skillSlots.end()) {
auto sit = s_playerSkills.find(it->second);
if (sit != s_playerSkills.end()) {
sit->second.active = false;
if (s_playerGameWindow) {
player_window_call("DeactivateSkillSlot", Py_BuildValue("(i)", it->second));
}
}
}
}
}
void SetComboSkillFlag(bool bFlag) {
auto it = s_skillSlots.find(122 /* c_iSkillIndex_Combo */);
if (it == s_skillSlots.end()) return;
auto sit = s_playerSkills.find(it->second);
if (sit == s_playerSkills.end() || sit->second.level <= 0) return;
int level = sit->second.level;
uint32_t mainVID = PythonNetworkStream::Instance().GetMainActorVID();
auto pMain = NetworkActorManager::Instance().GetActorInstance(mainVID);
if (pMain) {
pMain->SetComboType(bFlag ? level : 0);
}
}
void SetMainCharacterPosition(float x, float y, float z) {
s_mainActorPos.x = x;
s_mainActorPos.y = y;
s_mainActorPos.z = z;
}
void GetMainCharacterPosition(float& x, float& y, float& z) {
x = s_mainActorPos.x;
y = s_mainActorPos.y;
z = s_mainActorPos.z;
}
const std::string& GetMainCharacterName() { return s_playerName; }
void SetMainCharacterName(const std::string& name) {
s_playerName = name;
}
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 void UpdateBattleStatus();
long long GetPlayerStatusPoint(int type) {if(uint32_t(type)>=255)return 0;auto it=s_playerPoints.find(type);return it==s_playerPoints.end()?0:it->second;}
void SetPlayerStatusPoint(int type, long long value) {
if(uint32_t(type)>=255)return;
if (value == 0 && (s_dwWeaponMinPower != 0 || s_dwWeaponMaxPower != 0)) {
if (type == 18 || type == 29 || type == 30 || type == 200 || type == 201 || type == 202 || type == 203 || type == 204)
return;
}
s_playerPoints[type] = value;
switch (type) {
case 1: case 12: case 14: case 15: // level, ST, DX, IQ
UpdateBattleStatus();
break;
}
}
PlayerItemSlot GetPlayerItem(int slot) {
if (slot >= 0 && slot < (int)s_playerItems.size()) return s_playerItems[slot];
return PlayerItemSlot{};
}
void ClearPlayerPythonWindow() {auto* old=s_playerGameWindow;s_playerGameWindow=nullptr;Py_XDECREF(old);}
void AddPlayerQuickSlot(int index,uint8_t type,uint8_t pos) {if(index>=0&&index<36) s_playerQuickSlots[index]={type,pos};}
void DeletePlayerQuickSlot(int index) {if(index>=0&&index<36) s_playerQuickSlots[index]={};}
void SwapPlayerQuickSlots(int source,int target) {if(source>=0&&source<36&&target>=0&&target<36) std::swap(s_playerQuickSlots[source],s_playerQuickSlots[target]);}
void SetPlayerSkill(int slot,int index) {
if(uint32_t(slot)>=255) return;
s_playerSkills[slot].index=index;s_skillSlots[index]=slot;
}
void SetPlayerLegacySkillLevel(int index,int level) {
auto it=s_skillSlots.find(index);if(it==s_skillSlots.end()) return;
auto& skill=s_playerSkills[it->second];skill.grade=-1;skill.level=level;
}
void SetPlayerSkillLevel(int index,int grade,int level) {
auto it=s_skillSlots.find(index);if(it==s_skillSlots.end()) return;
auto& skill=s_playerSkills[it->second];
if(grade>=0 && grade<=3) {skill.grade=grade;skill.level=level-(grade==0?0:(grade==1?19:(grade==2?29:39)));}
// AVA2 Locale.cpp tables, including zero-initialized tail entries through index49.
static const unsigned international[50]={0,5,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,50,52,54,56,58,60,63,66,69,72,82,85,88,91,94,98,102,106,110,115,125,125};
static const unsigned ymir[50]={0,5,7,9,11,13,15,17,19,20,22,24,26,28,30,32,34,36,38,40,50,52,55,58,61,63,66,69,72,75,80,82,84,87,90,95,100,110,120,130,150,150};
if(uint32_t(level)>40) {skill.currentPower=skill.nextPower=0;return;}
const auto* powers=IsYmirLocale()?ymir:international;
skill.currentPower=powers[level]/100.0f;skill.nextPower=powers[level+1]/100.0f;
}
// CPythonPlayer party / PVP instance sets / kill log (AVA2 PythonPlayer.cpp).
struct PartyMemberInfo {
uint32_t vid=0,pid=0;std::string name;uint8_t state=0,hp=0;std::array<int16_t,PARTY_AFFECT_SLOT_MAX_NUM> affects{};
};
static std::map<uint32_t,PartyMemberInfo> s_partyMembers;
static std::set<uint32_t> s_challengeInstances,s_revengeInstances,s_cantFightInstances;
static std::array<int32_t,9> s_killLog{};
static void player_trace_error(const std::string& text) { std::cerr<<"[AVA2 TraceError] "<<text<<std::endl; }
static PartyMemberInfo* find_party_member(uint32_t pid) {
auto found=s_partyMembers.find(pid);return found==s_partyMembers.end()?nullptr:&found->second;
}
void AppendPartyMember(uint32_t pid,const std::string& name) {
PartyMemberInfo info;info.pid=pid;info.name=name;s_partyMembers.insert({pid,info});
}
void LinkPartyMember(uint32_t pid,uint32_t vid) {
auto* member=find_party_member(pid);
if(!member) {player_trace_error(" CPythonPlayer::LinkPartyMember(dwPID="+std::to_string(int(pid))+", dwVID="+std::to_string(int(vid))+") - Failed to find party member");return;}
member->vid=vid;
ava2::NetworkActorManager::Instance().RefreshTextTail(vid);
}
void UnlinkPartyMember(uint32_t pid) {
auto* member=find_party_member(pid);
if(!member) {player_trace_error(" CPythonPlayer::UnlinkPartyMember(dwPID="+std::to_string(int(pid))+") - Failed to find party member");return;}
member->vid=0;
}
void UpdatePartyMemberInfo(uint32_t pid,uint8_t state,uint8_t hp) {
auto* member=find_party_member(pid);
if(!member) {player_trace_error(" CPythonPlayer::UpdatePartyMemberInfo(dwPID="+std::to_string(int(pid))+", byState="+std::to_string(state)+", byHPPercentage="+std::to_string(hp)+") - Failed to find character");return;}
member->state=state;member->hp=hp;
}
void UpdatePartyMemberAffect(uint32_t pid,uint8_t slot,int16_t affect) {
if(slot>=PARTY_AFFECT_SLOT_MAX_NUM) {player_trace_error(" CPythonPlayer::UpdatePartyMemberAffect(dwPID="+std::to_string(int(pid))+", byAffectSlotIndex="+std::to_string(slot)+", sAffectNumber="+std::to_string(affect)+") - Strange affect slot index");return;}
auto* member=find_party_member(pid);
if(!member) {player_trace_error(" CPythonPlayer::UpdatePartyMemberAffect(dwPID="+std::to_string(int(pid))+", byAffectSlotIndex="+std::to_string(slot)+", sAffectNumber="+std::to_string(affect)+") - Failed to find character");return;}
member->affects[slot]=affect;
}
bool GetPartyMemberState(uint32_t pid,uint8_t* state) {
auto* member=find_party_member(pid);if(!member) return false;*state=member->state;return true;
}
bool PartyMemberPIDToVID(uint32_t pid,uint32_t* vid) {
auto* member=find_party_member(pid);if(!member) return false;*vid=member->vid;return true;
}
bool PartyMemberVIDToPID(uint32_t vid,uint32_t* pid) {
for(const auto& [memberPid,member]:s_partyMembers) if(member.vid==vid) {*pid=memberPid;return true;}
return false;
}
static inline bool party_member_vid_to_pid(uint32_t vid,uint32_t* pid) {
return PartyMemberVIDToPID(vid, pid);
}
// CPythonBackground::m_strMapName: only Warp() sets it (LoadMap does not), Destroy() clears it.
static std::string s_warpMapName;
bool IsPartyMemberByVID(uint32_t vid) { uint32_t pid;return party_member_vid_to_pid(vid,&pid); }
void RememberChallengeInstance(uint32_t vid) { s_revengeInstances.erase(vid);s_challengeInstances.insert(vid); }
void RememberRevengeInstance(uint32_t vid) { s_challengeInstances.erase(vid);s_revengeInstances.insert(vid); }
void RememberCantFightInstance(uint32_t vid) { s_cantFightInstances.insert(vid); }
void ForgetInstance(uint32_t vid) { s_challengeInstances.erase(vid);s_revengeInstances.erase(vid);s_cantFightInstances.erase(vid); }
void SetKillLOG(const int32_t* log) { std::copy(log,log+s_killLog.size(),s_killLog.begin()); }
// CPythonPlayer::NEW_ClearSkillData. __GetSkillType(it->first) passes the dict key
// (skill index) as a slot index, so the type is looked up on the skill in that slot.
void NEW_ClearSkillData(bool all) {
for(auto it=s_skillSlots.begin();it!=s_skillSlots.end();) {
auto slot=s_playerSkills.find(it->first);
const int type=slot==s_playerSkills.end()?0:GetSkillTypeById(uint32_t(slot->second.index));
if(all || type==1) it=s_skillSlots.erase(it); else ++it;
}
for(auto& [slot,skill]:s_playerSkills) { skill=PlayerSkill{};skill.nextPower=0.05f; }
// Windows passes Py_BuildNone() as the args tuple: the call raises TypeError and ScriptLib prints it.
if(s_playerGameWindow) { Py_INCREF(Py_None);PyCallClassMemberFunc(s_playerGameWindow,"BINARY_CheckGameButton",Py_None); }
}
namespace {
void itemDefault(ItemInfo& item,const std::string& icon,const std::string& model) {
item.iconPath=icon;item.modelPath=model;item.desc.clear();item.summary.clear();
auto it=s_itemProto.records.find(item.vnum);if(it!=s_itemProto.records.end())it->second.sockets.fill(0);
}
std::string itemIcon(uint32_t id) {char path[64];std::snprintf(path,sizeof(path),"icon/item/%05d.tga",std::bit_cast<int32_t>(id));return path;}
uint32_t itemNameHash(const std::string& name) {uint32_t result=5381;for(char c:name)result=result*33+uint32_t(int32_t(int8_t(c)));return result;}
std::string itemSnap(const std::string& source) {if(source.size()<2||source[0]!='"')return source;return source.substr(1,source.size()-1-(source.back()=='"'));}
}
void ResetItemDatabase() {
// Avoid the original Destroy() dangling selected/range pointers on locale reload.
s_itemMap.clear();s_itemProto={};s_selectedItemVnum=0;s_hasSelectedItem=false;
}
bool LoadItemList(const std::string& path) {
std::string data;try {data=ReadPackedText(path);}catch(const std::exception&){return false;}
for(const auto& line:ava2TextLines(data)) {
auto fields=ava2TabTokens(line,false);if(fields.size()!=3&&fields.size()!=4)continue;
uint32_t id=uint32_t(std::strtol(fields[0].c_str(),nullptr,10));
auto& item=s_itemMap[id];item.vnum=id;
// AVA2 ignores the second column entirely; only item_proto supplies type.
itemDefault(item,fields[2],fields.size()==4?fields[3]:std::string{});
}
return true;
}
// CItemManager::LoadItemScale + CItemData::SetItemScale (AVA2 GameLib, ENABLE_SASH_SYSTEM).
// MakeItemData creates empty records for vnum+0..4 when absent, as Windows does.
bool LoadItemScale(const std::string& path) {
std::string data;try {data=ReadPackedText(path);}catch(const std::exception&){return false;}
const auto lines=ava2TextLines(data);
for(size_t i=0;i<lines.size();++i) {
auto fields=ava2TabTokens(lines[i],true);if(fields.empty())continue; // SplitLineByTab
if(fields.size()<9) { player_trace_error("LoadItemScale: invalid line "+std::to_string(i)+" ("+path+")."); continue; }
uint32_t pos;const std::string& job=fields[1];
if(job=="JOB_WARRIOR")pos=0;else if(job=="JOB_ASSASSIN")pos=1;else if(job=="JOB_SURA")pos=2;else if(job=="JOB_SHAMAN")pos=3;
else continue; // JOB_WOLFMAN returns (ENABLE_WOLFMAN_CHARACTER off); other jobs leave dwPos uninitialised on Windows.
pos+=1;if(fields[2]=="F")pos+=5;
const uint32_t base=uint32_t(std::atoi(fields[0].c_str()));
for(uint32_t j=0;j<5;++j) {
auto& info=s_itemMap[base+j].scale[pos];
info.scaleX=float(std::atof(fields[3].c_str())/100.0f);info.scaleY=float(std::atof(fields[4].c_str())/100.0f);info.scaleZ=float(std::atof(fields[5].c_str())/100.0f);
info.positionX=float(std::atof(fields[6].c_str())*100.0f);info.positionY=float(std::atof(fields[7].c_str())*100.0f);info.positionZ=float(std::atof(fields[8].c_str())*100.0f);
}
}
return true;
}
bool GetItemScale(uint32_t vnum,uint32_t pos,ItemScaleInfo* out) {
auto it=s_itemMap.find(vnum);if(it==s_itemMap.end()||pos>=it->second.scale.size())return false;
*out=it->second.scale[pos];return true;
}
bool LoadItemDescriptions(const std::string& path) {
std::string data;try {data=ReadPackedText(path);}catch(const std::exception&){return false;}
for(const auto& line:ava2TextLines(data)) {
auto fields=ava2TabTokens(line,true);if(fields.empty())continue;fields.resize(std::max(fields.size(),size_t(4)));
uint32_t id=uint32_t(std::strtol(fields[0].c_str(),nullptr,10));auto it=s_itemMap.find(id);if(it==s_itemMap.end())continue;
it->second.desc=itemSnap(fields[2]);it->second.summary=itemSnap(fields[3]);
}
return true;
}
bool LoadItemTable(const std::string& path) {
std::string data;try {data=ReadPackedText(path);}catch(const std::exception&){return false;}
if(!s_itemProto.load(data))return false;
std::map<uint32_t,uint32_t> nameMap;
for(const auto& record:s_itemProto.recentRecords) {
const auto id=record.vnum;auto it=s_itemMap.find(id);
if(it==s_itemMap.end()) {
std::string icon=itemIcon(id);
if(!ItemResourceExists(icon)) {
auto same=nameMap.find(itemNameHash(record.internalName));icon=itemIcon(same==nameMap.end()?id-id%10:same->second);
if(!ItemResourceExists(icon))icon=itemIcon(27995);
}
auto& item=s_itemMap[id];item.vnum=id;itemDefault(item,icon,{});it=s_itemMap.find(id);
}
nameMap.insert({itemNameHash(record.internalName),id});
s_itemProto.records[id]=record;
auto& item=it->second;item.name=record.name;item.type=record.type;item.subType=record.subtype;item.height=record.size;
std::copy(record.values.begin(),record.values.end(),item.values);
item.limitLevel=0;for(const auto& limit:record.limits)if(limit.first==1)item.limitLevel=limit.second;
item.applyType=record.applies[0].first;item.applyValue=record.applies[0].second;
}
return true;
}
bool GetItemNameAndType(uint32_t vnum,std::string* name,int* type) {
if(!vnum)return false;
auto found=s_itemMap.find(vnum);
if(found==s_itemMap.end()) {
const auto* range=s_itemProto.find(vnum);
if(!range) return false;
found=s_itemMap.find(range->vnum);
if(found==s_itemMap.end()) return false;
}
*name=found->second.name;*type=found->second.type;return true;
}
bool IsPlayerEquipmentItem(uint8_t window,uint16_t cell) {
// CPythonPlayer::IsEquipItemInSlot selects without the Python fallback.
if((window!=1&&window!=2)||cell<180||cell>=216)return false;
select_item_data(GetPlayerItemData(window,cell).vnum);
const auto it=(s_hasSelectedItem?s_itemMap.find(s_selectedItemVnum):s_itemMap.end());
return it!=s_itemMap.end()&&(it->second.type==1||it->second.type==2);
}
bool GetItemTypeAndSubType(uint32_t vnum,int* type,int* subType) {
if(!vnum)return false;
auto found=s_itemMap.find(vnum);
if(found==s_itemMap.end()) {
const auto* range=s_itemProto.find(vnum);
if(!range) return false;
found=s_itemMap.find(range->vnum);
if(found==s_itemMap.end()) return false;
}
*type=found->second.type;*subType=found->second.subType;return true;
}
bool GetItemValue(uint32_t vnum, size_t index, long* outValue) {
if (!vnum || index >= 6) return false;
const auto* range = s_itemProto.find(vnum);
if (range) {
if (outValue) *outValue = range->values[index];
return true;
}
auto found = s_itemMap.find(vnum);
if (found != s_itemMap.end()) {
if (outValue) *outValue = found->second.values[index];
return true;
}
return false;
}
static PyObject* player_IsChallengeInstance(PyObject*,PyObject* args) {
int vid;if(!PyArg_ParseTuple(args,"i",&vid)) return nullptr;return Py_BuildValue("i",int(s_challengeInstances.count(uint32_t(vid))));
}
static PyObject* player_IsRevengeInstance(PyObject*,PyObject* args) {
int vid;if(!PyArg_ParseTuple(args,"i",&vid)) return nullptr;return Py_BuildValue("i",int(s_revengeInstances.count(uint32_t(vid))));
}
static PyObject* player_IsCantFightInstance(PyObject*,PyObject* args) {
int vid;if(!PyArg_ParseTuple(args,"i",&vid)) return nullptr;return Py_BuildValue("i",int(s_cantFightInstances.count(uint32_t(vid))));
}
static PyObject* player_IsPartyMember(PyObject*,PyObject* args) {
int vid;if(!PyArg_ParseTuple(args,"i",&vid)) return nullptr;return Py_BuildValue("i",int(IsPartyMemberByVID(uint32_t(vid))));
}
static PyObject* player_IsPartyLeader(PyObject*,PyObject* args) {
int vid;if(!PyArg_ParseTuple(args,"i",&vid)) return nullptr;
uint32_t pid;if(!party_member_vid_to_pid(uint32_t(vid),&pid)) return Py_BuildValue("i",0);
auto* member=find_party_member(pid);if(!member) return Py_BuildValue("i",0);
return Py_BuildValue("i",int(member->state==1)); // PARTY_ROLE_LEADER
}
static PyObject* player_IsPartyLeaderByPID(PyObject*,PyObject* args) {
int pid;if(!PyArg_ParseTuple(args,"i",&pid)) return nullptr;
auto* member=find_party_member(uint32_t(pid));if(!member) return Py_BuildValue("i",0);
return Py_BuildValue("i",int(member->state==1));
}
static PyObject* player_GetPartyMemberHPPercentage(PyObject*,PyObject* args) {
int pid;if(!PyArg_ParseTuple(args,"i",&pid)) return nullptr;
auto* member=find_party_member(uint32_t(pid));if(!member) return Py_BuildValue("i",0);
return Py_BuildValue("i",int(member->hp));
}
static PyObject* player_GetPartyMemberState(PyObject*,PyObject* args) {
int pid;if(!PyArg_ParseTuple(args,"i",&pid)) return nullptr;
auto* member=find_party_member(uint32_t(pid));if(!member) return Py_BuildValue("i",0);
return Py_BuildValue("i",int(member->state));
}
static PyObject* player_GetPartyMemberAffects(PyObject*,PyObject* args) {
int pid;if(!PyArg_ParseTuple(args,"i",&pid)) return nullptr;
auto* member=find_party_member(uint32_t(pid));if(!member) return Py_BuildValue("i",0);
const auto& a=member->affects;
return Py_BuildValue("iiiiiii",int(a[0]),int(a[1]),int(a[2]),int(a[3]),int(a[4]),int(a[5]),int(a[6]));
}
static PyObject* player_RemovePartyMember(PyObject*,PyObject* args) {
int pid;if(!PyArg_ParseTuple(args,"i",&pid)) return nullptr;
uint32_t vid=0;
if(auto* member=find_party_member(uint32_t(pid))) vid=member->vid;
s_partyMembers.erase(uint32_t(pid));
if(vid>0) ava2::NetworkActorManager::Instance().RefreshTextTail(vid);
Py_RETURN_NONE;
}
static PyObject* player_ExitParty(PyObject*,PyObject*) {
s_partyMembers.clear();
ava2::NetworkActorManager::Instance().RefreshAllPCTextTail();
Py_RETURN_NONE;
}
static PyObject* player_GetKillLOG(PyObject*,PyObject* args) {
int index;if(!PyArg_ParseTuple(args,"i",&index)) return nullptr;
// Windows indexes kill_log[] without a bounds check; out of range returns 0 here.
return Py_BuildValue("l",long(index>=0 && index<int(s_killLog.size())?s_killLog[size_t(index)]: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;
if (s_dwWeaponMinPower != 0 || s_dwWeaponMaxPower != 0) {
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() {
CancelPlayerMovement();
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) {
s_windowItems[{window,cell}]=data;
if(window==1 && cell<s_playerItems.size()) {
auto& slot=s_playerItems[cell];slot={};slot.vnum=data.vnum;slot.count=data.count;
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);
PyCallClassMemberFunc(s_playerGameWindow,"RefreshInventory",Py_BuildValue("()"));
}
TItemData GetPlayerItemData(uint8_t window,uint16_t cell) {
auto found=s_windowItems.find({window,cell});return found==s_windowItems.end()?TItemData{}:found->second;
}
void SetPlayerItem(int slot,uint32_t vnum,int count) {
if(slot<0 || slot>=static_cast<int>(s_playerItems.size())) return;
auto data=GetPlayerItemData(1,slot);data.vnum=vnum;data.count=count;
SetPlayerItemData(1,slot,data);
}
std::string GetWeaponModelPathByVnum(uint32_t vnum) {
auto it = s_itemMap.find(vnum);
if (it != s_itemMap.end() && !it->second.modelPath.empty()) {
std::string p = it->second.modelPath;
if (p.rfind("d:/", 0) == 0 || p.rfind("D:/", 0) == 0) p = p.substr(3);
return p;
}
return "";
}
bool UsePlayerItem(int window, int slot, std::string& outEquippedWeaponModel, std::string& outActionMessage) {
if (slot < 0 || slot >= (int)s_playerItems.size()) return false;
auto& itemSlot = s_playerItems[slot];
if (itemSlot.vnum == 0 || itemSlot.count <= 0) return false;
auto it = s_itemMap.find(itemSlot.vnum);
if (it == s_itemMap.end()) return false;
const auto& info = it->second;
if (slot == 184) {
int emptySlot = -1;
for (int i = 0; i < 180; ++i) {
if (s_playerItems[i].vnum == 0) { emptySlot = i; break; }
}
if (emptySlot >= 0) {
s_playerItems[emptySlot] = itemSlot;
itemSlot = PlayerItemSlot{};
outEquippedWeaponModel = "";
outActionMessage = "UNEQUIPPED: " + info.name;
return true;
}
return false;
}
if (info.type == 1) { // WEAPON
auto prev = s_playerItems[184];
s_playerItems[184] = itemSlot;
s_playerItems[slot] = prev;
outEquippedWeaponModel = GetWeaponModelPathByVnum(s_playerItems[184].vnum);
outActionMessage = "EQUIPPED: " + info.name;
return true;
}
if (info.type == 2) { // ARMOR
int targetSlot = (info.subType == 1) ? 181 : (info.subType == 2 ? 182 : 180);
auto prev = s_playerItems[targetSlot];
s_playerItems[targetSlot] = itemSlot;
s_playerItems[slot] = prev;
outActionMessage = "EQUIPPED: " + info.name;
return true;
}
if (info.type == 3 || itemSlot.vnum == 27003 || itemSlot.vnum == 27006 || itemSlot.vnum == 70038) {
itemSlot.count--;
if (itemSlot.count <= 0) {
itemSlot = PlayerItemSlot{};
}
if (info.vnum == 27003) {
outActionMessage = "USED: Red Potion (+1200 HP)";
} else if (info.vnum == 27006) {
outActionMessage = "USED: Blue Potion (+400 SP)";
} else if (info.vnum == 70038) {
outActionMessage = "USED: Bravery Cape (Lured monsters!)";
} else {
outActionMessage = "USED: " + info.name;
}
return true;
}
return false;
}
bool MovePlayerItem(int srcWindow, int srcSlot, int dstWindow, int dstSlot, int count, std::string& outEquippedWeaponModel) {
if (srcSlot < 0 || srcSlot >= (int)s_playerItems.size() || dstSlot < 0 || dstSlot >= (int)s_playerItems.size()) return false;
std::swap(s_playerItems[srcSlot], s_playerItems[dstSlot]);
if (dstSlot == 184 || srcSlot == 184) {
uint32_t eqVnum = s_playerItems[184].vnum;
if (eqVnum > 0) {
outEquippedWeaponModel = GetWeaponModelPathByVnum(eqVnum);
} else {
outEquippedWeaponModel = "";
}
}
return true;
}
void SetPlayerSkillCastCallback(SkillCastCallback cb) {
s_skillCastCallback = cb;
}
void SetSkillCoolTimeAt(int skillIndex,float coolTime,float now) {
auto slot=s_skillSlots.find(skillIndex);if(slot==s_skillSlots.end()) return;
s_playerSkills[slot->second].cooldown={coolTime,now};
}
void SetSkillCoolTime(int skillIndex, float coolTime) {
SetSkillCoolTimeAt(skillIndex,coolTime,CTimer::Instance().GetCurrentSecond());
}
void EndSkillCoolTime(uint32_t skillIndex) {
auto slot = s_skillSlots.find(skillIndex);
if (slot == s_skillSlots.end()) return;
auto it = s_playerSkills.find(slot->second);
if (it != s_playerSkills.end()) {
it->second.cooldown = {};
}
}
// ---------------------------------------------------------------------
// GroundItemStore & Chest Drop Cache
// ---------------------------------------------------------------------
using GroundItemStore = CPythonItem;
struct SDropItemEntry {
uint32_t dropVnum = 0;
int count = 1;
};
static std::unordered_map<uint32_t, std::vector<SDropItemEntry>> s_chestDropInfoMap;
void ClearChestDropInfo(uint32_t chestVnum) {
s_chestDropInfoMap.erase(chestVnum);
}
void AddChestDropItem(uint32_t chestVnum, uint32_t itemVnum, uint32_t count) {
s_chestDropInfoMap[chestVnum].push_back({itemVnum, int(count)});
}
static PyObject* item_CreateItem(PyObject*, PyObject* poArgs) {
int iVirtualID = 0, iVirtualNumber = 0;
float x = 0.0f, y = 0.0f, z = 0.0f;
bool bDrop = true;
if (!PyTuple_GetInteger(poArgs, 0, &iVirtualID) ||
!PyTuple_GetInteger(poArgs, 1, &iVirtualNumber) ||
!PyTuple_GetFloat(poArgs, 2, &x) ||
!PyTuple_GetFloat(poArgs, 3, &y) ||
!PyTuple_GetFloat(poArgs, 4, &z)) {
return Py_BadArgument();
}
PyTuple_GetBoolean(poArgs, 5, &bDrop);
CPythonItem::Instance().CreateItem(uint32_t(iVirtualID), uint32_t(iVirtualNumber), x, y, z, bDrop);
return Py_BuildNone();
}
static PyObject* item_DeleteItem(PyObject*, PyObject* poArgs) {
int iVirtualID = 0;
if (!PyTuple_GetInteger(poArgs, 0, &iVirtualID))
return Py_BadArgument();
CPythonItem::Instance().DeleteItem(uint32_t(iVirtualID));
return Py_BuildNone();
}
static PyObject* item_Pick(PyObject*, PyObject*) {
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*) {
CPythonItem::Instance().Render();
return Py_BuildNone();
}
static PyObject* item_Update(PyObject*, PyObject*) {
CPythonItem::Instance().Update();
return Py_BuildNone();
}
static PyObject* item_GetIconInstance(PyObject*, PyObject*) {
if (!s_hasSelectedItem)
return Py_BuildException("Not yet select item data");
auto it = s_itemMap.find(s_selectedItemVnum);
if (it == s_itemMap.end())
return Py_BuildException("Not yet select item data");
const auto& info = it->second;
std::string p = info.iconPath;
if (p.empty())
p = "icon/item/27995.tga";
if (p.rfind("d:/", 0) == 0 || p.rfind("D:/", 0) == 0) p = p.substr(3);
auto* pRes = CResourceManager::Instance().GetResourcePointer(p.c_str());
if (!pRes || !pRes->IsType(CGraphicImage::Type()))
return Py_BuildException("Cannot get icon image by %d", s_selectedItemVnum);
auto* pImageInstance = CGraphicImageInstance::New();
pImageInstance->SetImagePointer(static_cast<CGraphicImage*>(pRes));
return Py_BuildValue("i", GrpRegisterImageInstanceHandle(pImageInstance));
}
static PyObject* item_DeleteIconInstance(PyObject*, PyObject* poArgs) {
int iHandle = 0;
if (!PyTuple_GetInteger(poArgs, 0, &iHandle))
return Py_BadArgument();
CGraphicImageInstance::Delete(GrpReleaseImageInstanceHandle(uint32_t(iHandle)));
return Py_BuildNone();
}
static PyObject* item_GetDropClear(PyObject*, PyObject* poArgs) {
int iItemIndex = 0;
if (!PyTuple_GetInteger(poArgs, 0, &iItemIndex))
return Py_BadArgument();
s_chestDropInfoMap.erase(uint32_t(iItemIndex));
return Py_BuildNone();
}
static PyObject* item_GetDropInfo(PyObject*, PyObject* poArgs) {
int iItemIndex = 0;
if (!PyTuple_GetInteger(poArgs, 0, &iItemIndex))
return Py_BadArgument();
PyObject* poList = PyList_New(0);
int pageCount = 0;
auto it = s_chestDropInfoMap.find(uint32_t(iItemIndex));
if (it != s_chestDropInfoMap.end() && !it->second.empty()) {
const auto& vec = it->second;
const int gridW = 5, gridH = 8;
std::vector<bool> grid(gridW * gridH, false);
auto findBlank = [&](int h) -> int {
if (h > gridH) return -1;
for (int r = 0; r <= gridH - h; ++r) {
for (int c = 0; c < gridW; ++c) {
bool ok = true;
for (int y = 0; y < h && ok; ++y) {
if (grid[(r + y) * gridW + c])
ok = false;
}
if (ok) return r * gridW + c;
}
}
return -1;
};
auto putItem = [&](int pos, int h) {
int r = pos / gridW;
int c = pos % gridW;
for (int y = 0; y < h; ++y) {
grid[(r + y) * gridW + c] = true;
}
};
for (const auto& drop : vec) {
int itemSize = 1;
auto itemIt = s_itemMap.find(drop.dropVnum);
if (itemIt != s_itemMap.end() && itemIt->second.height > 1)
itemSize = itemIt->second.height;
while (true) {
int pos = findBlank(itemSize);
if (pos >= 0) {
putItem(pos, itemSize);
PyList_Append(poList, Py_BuildValue("iiii", pageCount, pos, drop.dropVnum, drop.count));
break;
} else {
std::fill(grid.begin(), grid.end(), false);
++pageCount;
}
}
}
}
return Py_BuildValue("iO", pageCount, poList);
}
static PyObject* item_HasDropInfo(PyObject*, PyObject* poArgs) {
int iItemIndex = 0;
if (!PyTuple_GetInteger(poArgs, 0, &iItemIndex))
return Py_BadArgument();
auto it = s_itemMap.find(uint32_t(iItemIndex));
if (it == s_itemMap.end())
return Py_BuildValue("b", false);
if (it->second.type != 20 && it->second.type != 23)
return Py_BuildValue("b", false);
auto dropIt = s_chestDropInfoMap.find(uint32_t(iItemIndex));
bool bHasInfo = dropIt != s_chestDropInfoMap.end() && !dropIt->second.empty();
return Py_BuildValue("b", bHasInfo);
}
static PyObject* item_GetItemsByName(PyObject*, PyObject* poArgs) {
char* szItemName = nullptr;
if (!PyTuple_GetString(poArgs, 0, &szItemName))
return Py_BadArgument();
std::string searched = szItemName ? szItemName : "";
std::transform(searched.begin(), searched.end(), searched.begin(), [](unsigned char c) { return std::tolower(c); });
PyObject* poList = PyList_New(0);
for (const auto& [vnum, item] : s_itemMap) {
if (searched.empty()) continue;
std::string name = item.name;
std::transform(name.begin(), name.end(), name.begin(), [](unsigned char c) { return std::tolower(c); });
if (name.compare(0, searched.length(), searched) == 0) {
PyList_Append(poList, PyInt_FromLong(vnum));
}
}
return poList;
}
static PyObject* item_IsRarityItem(PyObject*, PyObject* poArgs) {
int szItemVnum = 0;
if (!PyTuple_GetInteger(poArgs, 0, &szItemVnum))
return Py_BadArgument();
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();
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();
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);
}
static PyObject* item_GetDefaultSealDate(PyObject*, PyObject*) {
return Py_BuildValue("i", 86400);
}
static PyObject* item_GetUnlimitedSealDate(PyObject*, PyObject*) {
return Py_BuildValue("i", -1);
}
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);
}
void initItem() {
ResetItemDatabase();
static PyMethodDef methods[] = {
{"SetUseSoundFileName", item_SetSoundFileName<false>, METH_VARARGS, nullptr},
{"SetDropSoundFileName", item_SetSoundFileName<true>, METH_VARARGS, nullptr},
{"SelectItem", item_SelectItem, METH_VARARGS, nullptr},
{"GetItemName", item_GetItemName, METH_VARARGS, nullptr},
{"GetItemDescription", item_GetItemDescription, METH_VARARGS, nullptr},
{"GetItemSummary", item_GetItemSummary, METH_VARARGS, nullptr},
{"GetIconImage", item_GetIconImage, METH_VARARGS, nullptr},
{"GetIconImageFileName", item_GetIconImageFileName, METH_VARARGS, nullptr},
{"GetItemSize", item_GetItemSize, METH_VARARGS, nullptr},
{"GetItemType", item_GetItemType, METH_VARARGS, nullptr},
{"GetItemSubType", item_GetItemSubType, METH_VARARGS, nullptr},
{"GetIBuyItemPrice", item_buy_price, METH_VARARGS, nullptr},
{"GetISellItemPrice", item_sell_price, METH_VARARGS, nullptr},
{"IsAntiFlag", item_anti_flag, METH_VARARGS, nullptr},
{"IsFlag", item_flag, METH_VARARGS, nullptr},
{"IsWearableFlag", item_wear_flag, METH_VARARGS, nullptr},
{"Is1GoldItem", item_one_gold, METH_VARARGS, nullptr},
{"GetLimit", item_GetLimit, METH_VARARGS, nullptr},
{"GetAffect", item_GetAffect, METH_VARARGS, nullptr},
{"GetValue", item_GetValue, METH_VARARGS, nullptr},
{"GetSocket", item_socket, METH_VARARGS, nullptr},
{"GetIconInstance", item_GetIconInstance, METH_VARARGS, nullptr},
{"GetUseType", item_GetUseType, METH_VARARGS, nullptr},
{"DeleteIconInstance", item_DeleteIconInstance, METH_VARARGS, nullptr},
{"IsEquipmentVID", item_IsEquipmentVID, METH_VARARGS, nullptr},
{"IsRefineScroll", item_IsRefineScroll, METH_VARARGS, nullptr},
{"IsDetachScroll", item_IsDetachScroll, METH_VARARGS, nullptr},
{"IsKey", item_IsKey, METH_VARARGS, nullptr},
{"IsMetin", item_IsMetin, METH_VARARGS, nullptr},
{"CanAddToQuickSlotItem", item_CanAddToQuickSlotItem, METH_VARARGS, nullptr},
{"Update", item_Update, METH_VARARGS, nullptr},
{"Render", item_Render, METH_VARARGS, nullptr},
{"CreateItem", item_CreateItem, METH_VARARGS, nullptr},
{"DeleteItem", item_DeleteItem, METH_VARARGS, nullptr},
{"Pick", item_Pick, METH_VARARGS, nullptr},
{"LoadItemTable", item_LoadItemTable, METH_VARARGS, nullptr},
{"IsSealScroll", item_IsSealScroll, METH_VARARGS, nullptr},
{"GetDefaultSealDate", item_GetDefaultSealDate, METH_VARARGS, nullptr},
{"GetUnlimitedSealDate", item_GetUnlimitedSealDate, METH_VARARGS, nullptr},
{"GetNames", item_GetNames, METH_VARARGS, nullptr},
{"IsElement", item_IsElement, METH_VARARGS, nullptr},
{"GetApplyPoint", item_GetApplyPoint, METH_VARARGS, nullptr},
{"GetItemsByName", item_GetItemsByName, METH_VARARGS, nullptr},
{"HasDropInfo", item_HasDropInfo, METH_VARARGS, nullptr},
{"GetDropInfo", item_GetDropInfo, METH_VARARGS, nullptr},
{"GetDropClear", item_GetDropClear, METH_VARARGS, nullptr},
{"IsRarityItem", item_IsRarityItem, METH_VARARGS, nullptr},
{"GetRarityPoint", item_GetRarityPoint, METH_VARARGS, nullptr},
{"GetRarityMaxValue", item_GetRarityMaxValue, METH_VARARGS, nullptr},
{"SelectItemWiki", item_SelectItemWiki, METH_VARARGS, nullptr},
{"GetRefineSet", item_GetRefineSet, METH_VARARGS, nullptr},
{"GetRefinedVnum", item_GetRefinedVnum, METH_VARARGS, nullptr},
{nullptr, nullptr, 0, nullptr}
};
auto* module = Py_InitModule("item", methods);
PyModule_AddIntConstant(module, "ITEM_TYPE_GIFTBOX", 23);
PyModule_AddIntConstant(module, "USESOUND_ACCESSORY", 5);
PyModule_AddIntConstant(module, "USESOUND_ARMOR", 2);
PyModule_AddIntConstant(module, "USESOUND_BOW", 4);
PyModule_AddIntConstant(module, "USESOUND_DEFAULT", 1);
PyModule_AddIntConstant(module, "USESOUND_WEAPON", 3);
PyModule_AddIntConstant(module, "USESOUND_POTION", 6);
PyModule_AddIntConstant(module, "USESOUND_PORTAL", 7);
PyModule_AddIntConstant(module, "DROPSOUND_ACCESSORY", 4);
PyModule_AddIntConstant(module, "DROPSOUND_ARMOR", 1);
PyModule_AddIntConstant(module, "DROPSOUND_BOW", 3);
PyModule_AddIntConstant(module, "DROPSOUND_DEFAULT", 0);
PyModule_AddIntConstant(module, "DROPSOUND_WEAPON", 2);
PyModule_AddIntConstant(module, "EQUIPMENT_COUNT", 12);
PyModule_AddIntConstant(module, "EQUIPMENT_HEAD", 181);
PyModule_AddIntConstant(module, "EQUIPMENT_BODY", 180);
PyModule_AddIntConstant(module, "EQUIPMENT_WEAPON", 184);
PyModule_AddIntConstant(module, "EQUIPMENT_WRIST", 183);
PyModule_AddIntConstant(module, "EQUIPMENT_SHOES", 182);
PyModule_AddIntConstant(module, "EQUIPMENT_NECK", 185);
PyModule_AddIntConstant(module, "EQUIPMENT_EAR", 186);
PyModule_AddIntConstant(module, "EQUIPMENT_UNIQUE1", 187);
PyModule_AddIntConstant(module, "EQUIPMENT_UNIQUE2", 188);
PyModule_AddIntConstant(module, "EQUIPMENT_ARROW", 189);
PyModule_AddIntConstant(module, "EQUIPMENT_SHIELD", 190);
PyModule_AddIntConstant(module, "EQUIPMENT_PENDANT", 209);
PyModule_AddIntConstant(module, "EQUIPMENT_OLDPET", 210);
PyModule_AddIntConstant(module, "EQUIPMENT_PET", 211);
PyModule_AddIntConstant(module, "RINGS_SLOT_START", 205);
PyModule_AddIntConstant(module, "RINGS_SLOT_COUNT", 2);
PyModule_AddIntConstant(module, "ITEM_TYPE_RINGS", 36);
PyModule_AddIntConstant(module, "SKIN_SASH_SLOT_START", 207);
PyModule_AddIntConstant(module, "SKIN_SASH_SLOT_COUNT", 1);
PyModule_AddIntConstant(module, "COSTUME_TYPE_SKIN_SASH", 5);
PyModule_AddIntConstant(module, "COSTUME_TYPE_MOUNT_SKIN", 7);
PyModule_AddIntConstant(module, "SLOT_MOUNT_SKIN", 215);
PyModule_AddIntConstant(module, "EQUIPMENT_RING1", 202);
PyModule_AddIntConstant(module, "EQUIPMENT_RING2", 203);
PyModule_AddIntConstant(module, "EQUIPMENT_BELT", 204);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_ELEC", 100);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_FIRE", 101);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_ICE", 102);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_WIND", 103);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_EARTH", 104);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_DARK", 105);
PyModule_AddIntConstant(module, "APPLY_SUNGMA_STR", 119);
PyModule_AddIntConstant(module, "APPLY_SUNGMA_HP", 120);
PyModule_AddIntConstant(module, "APPLY_SUNGMA_MOVE", 121);
PyModule_AddIntConstant(module, "APPLY_SUNGMA_INMUNE", 122);
PyModule_AddIntConstant(module, "EQUIPMENT_GLOVE", 208);
PyModule_AddIntConstant(module, "APPLY_ENCHANT_ELEC", 123);
PyModule_AddIntConstant(module, "APPLY_ENCHANT_FIRE", 124);
PyModule_AddIntConstant(module, "APPLY_ENCHANT_ICE", 125);
PyModule_AddIntConstant(module, "APPLY_ENCHANT_WIND", 126);
PyModule_AddIntConstant(module, "APPLY_ENCHANT_EARTH", 127);
PyModule_AddIntConstant(module, "APPLY_ENCHANT_DARK", 128);
PyModule_AddIntConstant(module, "APPLY_RESIST_HUMAN", 99);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_SWORD", 129);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_TWOHAND", 130);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_DAGGER", 131);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_BELL", 132);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_FAN", 133);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_BOW", 134);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_ZODIAC", 135);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_DESERT", 136);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_INSECT", 137);
PyModule_AddIntConstant(module, "ITEM_TYPE_NONE", 0);
PyModule_AddIntConstant(module, "ITEM_TYPE_WEAPON", 1);
PyModule_AddIntConstant(module, "ITEM_TYPE_ARMOR", 2);
PyModule_AddIntConstant(module, "ITEM_TYPE_USE", 3);
PyModule_AddIntConstant(module, "ITEM_TYPE_AUTOUSE", 4);
PyModule_AddIntConstant(module, "ITEM_TYPE_MATERIAL", 5);
PyModule_AddIntConstant(module, "ITEM_TYPE_SPECIAL", 6);
PyModule_AddIntConstant(module, "ITEM_TYPE_TOOL", 7);
PyModule_AddIntConstant(module, "ITEM_TYPE_LOTTERY", 8);
PyModule_AddIntConstant(module, "ITEM_TYPE_ELK", 9);
PyModule_AddIntConstant(module, "ITEM_TYPE_METIN", 10);
PyModule_AddIntConstant(module, "ITEM_TYPE_CONTAINER", 11);
PyModule_AddIntConstant(module, "ITEM_TYPE_FISH", 12);
PyModule_AddIntConstant(module, "ITEM_TYPE_ROD", 13);
PyModule_AddIntConstant(module, "ITEM_TYPE_RESOURCE", 14);
PyModule_AddIntConstant(module, "ITEM_TYPE_CAMPFIRE", 15);
PyModule_AddIntConstant(module, "ITEM_TYPE_UNIQUE", 16);
PyModule_AddIntConstant(module, "ITEM_TYPE_SKILLBOOK", 17);
PyModule_AddIntConstant(module, "ITEM_TYPE_QUEST", 18);
PyModule_AddIntConstant(module, "ITEM_TYPE_POLYMORPH", 19);
PyModule_AddIntConstant(module, "ITEM_TYPE_TREASURE_BOX", 20);
PyModule_AddIntConstant(module, "ITEM_TYPE_TREASURE_KEY", 21);
PyModule_AddIntConstant(module, "ITEM_TYPE_PICK", 24);
PyModule_AddIntConstant(module, "ITEM_TYPE_BLEND", 27);
PyModule_AddIntConstant(module, "ITEM_TYPE_DS", 29);
PyModule_AddIntConstant(module, "ITEM_TYPE_SPECIAL_DS", 30);
PyModule_AddIntConstant(module, "ITEM_TYPE_RING", 33);
PyModule_AddIntConstant(module, "ITEM_TYPE_BELT", 34);
PyModule_AddIntConstant(module, "ITEM_TYPE_SHINING", 35);
PyModule_AddIntConstant(module, "SHINING_SLOT_START", 212);
PyModule_AddIntConstant(module, "SHINING_SLOT_COUNT", 3);
PyModule_AddIntConstant(module, "MATERIAL_LEATHER", 0);
PyModule_AddIntConstant(module, "ITEM_TYPE_PET", 37);
PyModule_AddIntConstant(module, "COSTUME_TYPE_PET", 6);
PyModule_AddIntConstant(module, "PET_LEVELABLE", 0);
PyModule_AddIntConstant(module, "PET_EGG", 1);
PyModule_AddIntConstant(module, "PET_TRANSPORTBOX", 2);
PyModule_AddIntConstant(module, "PET_PROTEIN", 3);
PyModule_AddIntConstant(module, "PET_CHANGE_NAME_ITEM", 4);
PyModule_AddIntConstant(module, "PET_DEW", 5);
PyModule_AddIntConstant(module, "PET_SKILL", 6);
PyModule_AddIntConstant(module, "PET_PRIMIUM_FEEDSTUFF", 7);
PyModule_AddIntConstant(module, "PET_ATTR_CHANGE", 8);
PyModule_AddIntConstant(module, "PET_ATTR_DETERMINE", 9);
PyModule_AddIntConstant(module, "PET_EXPFOOD_PER", 10);
PyModule_AddIntConstant(module, "PET_SKILL_DEL_BOOK", 11);
PyModule_AddIntConstant(module, "PET_SKILL_ALL_DEL_BOOK", 12);
PyModule_AddIntConstant(module, "PET_EXPFOOD", 13);
PyModule_AddIntConstant(module, "PET_FEEDSTUFF", 14);
PyModule_AddIntConstant(module, "ITEM_TYPE_COSTUME", 28);
PyModule_AddIntConstant(module, "COSTUME_TYPE_BODY", 0);
PyModule_AddIntConstant(module, "COSTUME_TYPE_HAIR", 1);
PyModule_AddIntConstant(module, "COSTUME_TYPE_MOUNT", 2);
PyModule_AddIntConstant(module, "COSTUME_TYPE_SASH", 3);
PyModule_AddIntConstant(module, "COSTUME_SLOT_SASH", 202);
PyModule_AddIntConstant(module, "COSTUME_TYPE_WEAPON", 4);
PyModule_AddIntConstant(module, "COSTUME_SLOT_START", 199);
PyModule_AddIntConstant(module, "COSTUME_SLOT_COUNT", 4);
PyModule_AddIntConstant(module, "COSTUME_SLOT_BODY", 199);
PyModule_AddIntConstant(module, "COSTUME_SLOT_HAIR", 200);
PyModule_AddIntConstant(module, "COSTUME_SLOT_MOUNT", 201);
PyModule_AddIntConstant(module, "COSTUME_SLOT_WEAPON", 204);
PyModule_AddIntConstant(module, "COSTUME_SLOT_END", 203);
PyModule_AddIntConstant(module, "BELT_INVENTORY_SLOT_START", 246);
PyModule_AddIntConstant(module, "BELT_INVENTORY_SLOT_COUNT", 16);
PyModule_AddIntConstant(module, "BELT_INVENTORY_SLOT_END", 262);
PyModule_AddIntConstant(module, "WEAPON_SWORD", 0);
PyModule_AddIntConstant(module, "WEAPON_DAGGER", 1);
PyModule_AddIntConstant(module, "WEAPON_BOW", 2);
PyModule_AddIntConstant(module, "WEAPON_TWO_HANDED", 3);
PyModule_AddIntConstant(module, "WEAPON_BELL", 4);
PyModule_AddIntConstant(module, "WEAPON_FAN", 5);
PyModule_AddIntConstant(module, "WEAPON_ARROW", 6);
PyModule_AddIntConstant(module, "WEAPON_MOUNT_SPEAR", 7);
PyModule_AddIntConstant(module, "WEAPON_NUM_TYPES", 10);
PyModule_AddIntConstant(module, "WEAPON_QUIVER", 9);
PyModule_AddIntConstant(module, "USE_POTION", 0);
PyModule_AddIntConstant(module, "USE_TALISMAN", 1);
PyModule_AddIntConstant(module, "USE_TUNING", 2);
PyModule_AddIntConstant(module, "USE_MOVE", 3);
PyModule_AddIntConstant(module, "USE_TREASURE_BOX", 4);
PyModule_AddIntConstant(module, "USE_MONEYBAG", 5);
PyModule_AddIntConstant(module, "USE_BAIT", 6);
PyModule_AddIntConstant(module, "USE_ABILITY_UP", 7);
PyModule_AddIntConstant(module, "USE_AFFECT", 8);
PyModule_AddIntConstant(module, "USE_CREATE_STONE", 9);
PyModule_AddIntConstant(module, "USE_SPECIAL", 10);
PyModule_AddIntConstant(module, "USE_POTION_NODELAY", 11);
PyModule_AddIntConstant(module, "USE_CLEAR", 12);
PyModule_AddIntConstant(module, "USE_INVISIBILITY", 13);
PyModule_AddIntConstant(module, "USE_DETACHMENT", 14);
PyModule_AddIntConstant(module, "USE_TIME_CHARGE_PER", 27);
PyModule_AddIntConstant(module, "USE_TIME_CHARGE_FIX", 28);
PyModule_AddIntConstant(module, "SHINING_WEAPON", 0);
PyModule_AddIntConstant(module, "SHINING_ARMOR", 1);
PyModule_AddIntConstant(module, "SHINING_SPECIAL", 2);
PyModule_AddIntConstant(module, "MATERIAL_DS_REFINE_NORMAL", 5);
PyModule_AddIntConstant(module, "MATERIAL_DS_REFINE_BLESSED", 6);
PyModule_AddIntConstant(module, "MATERIAL_DS_REFINE_HOLLY", 7);
PyModule_AddIntConstant(module, "METIN_NORMAL", 0);
PyModule_AddIntConstant(module, "METIN_GOLD", 1);
PyModule_AddIntConstant(module, "LIMIT_NONE", 0);
PyModule_AddIntConstant(module, "LIMIT_LEVEL", 1);
PyModule_AddIntConstant(module, "LIMIT_STR", 2);
PyModule_AddIntConstant(module, "LIMIT_DEX", 3);
PyModule_AddIntConstant(module, "LIMIT_INT", 4);
PyModule_AddIntConstant(module, "LIMIT_CON", 5);
PyModule_AddIntConstant(module, "LIMIT_PCBANG", 6);
PyModule_AddIntConstant(module, "LIMIT_REAL_TIME", 7);
PyModule_AddIntConstant(module, "LIMIT_REAL_TIME_START_FIRST_USE", 8);
PyModule_AddIntConstant(module, "LIMIT_TIMER_BASED_ON_WEAR", 9);
PyModule_AddIntConstant(module, "LIMIT_TYPE_MAX_NUM", 10);
PyModule_AddIntConstant(module, "LIMIT_MAX_NUM", 2);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_FEMALE", 1);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_MALE", 2);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_WARRIOR", 4);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_ASSASSIN", 8);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_SURA", 16);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_SHAMAN", 32);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_GET", 64);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_DROP", 128);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_SELL", 256);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_EMPIRE_A", 512);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_EMPIRE_B", 1024);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_EMPIRE_R", 2048);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_SAVE", 4096);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_GIVE", 8192);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_PKDROP", 16384);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_STACK", 32768);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_MYSHOP", 65536);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_SAFEBOX", 131072);
PyModule_AddIntConstant(module, "ITEM_FLAG_UNIQUE", 32);
PyModule_AddIntConstant(module, "ITEM_FLAG_CONFIRM_WHEN_USE", 256);
PyModule_AddIntConstant(module, "ITEM_FLAG_STACKABLE", 4);
PyModule_AddIntConstant(module, "ANTIFLAG_FEMALE", 1);
PyModule_AddIntConstant(module, "ANTIFLAG_MALE", 2);
PyModule_AddIntConstant(module, "ANTIFLAG_WARRIOR", 4);
PyModule_AddIntConstant(module, "ANTIFLAG_ASSASSIN", 8);
PyModule_AddIntConstant(module, "ANTIFLAG_SURA", 16);
PyModule_AddIntConstant(module, "ANTIFLAG_SHAMAN", 32);
PyModule_AddIntConstant(module, "ANTIFLAG_GET", 64);
PyModule_AddIntConstant(module, "ANTIFLAG_DROP", 128);
PyModule_AddIntConstant(module, "ANTIFLAG_SELL", 256);
PyModule_AddIntConstant(module, "ANTIFLAG_EMPIRE_A", 512);
PyModule_AddIntConstant(module, "ANTIFLAG_EMPIRE_B", 1024);
PyModule_AddIntConstant(module, "ANTIFLAG_EMPIRE_R", 2048);
PyModule_AddIntConstant(module, "ANTIFLAG_SAVE", 4096);
PyModule_AddIntConstant(module, "ANTIFLAG_GIVE", 8192);
PyModule_AddIntConstant(module, "ANTIFLAG_PKDROP", 16384);
PyModule_AddIntConstant(module, "ANTIFLAG_STACK", 32768);
PyModule_AddIntConstant(module, "ANTIFLAG_MYSHOP", 65536);
PyModule_AddIntConstant(module, "ANTIFLAG_SAFEBOX", 131072);
PyModule_AddIntConstant(module, "WEARABLE_BODY", 1);
PyModule_AddIntConstant(module, "WEARABLE_HEAD", 2);
PyModule_AddIntConstant(module, "WEARABLE_FOOTS", 4);
PyModule_AddIntConstant(module, "WEARABLE_WRIST", 8);
PyModule_AddIntConstant(module, "WEARABLE_WEAPON", 16);
PyModule_AddIntConstant(module, "WEARABLE_NECK", 32);
PyModule_AddIntConstant(module, "WEARABLE_EAR", 64);
PyModule_AddIntConstant(module, "WEARABLE_UNIQUE", 128);
PyModule_AddIntConstant(module, "WEARABLE_SHIELD", 256);
PyModule_AddIntConstant(module, "WEARABLE_ARROW", 512);
PyModule_AddIntConstant(module, "WEARABLE_GLOVE", 65536);
PyModule_AddIntConstant(module, "WEARABLE_PENDANT", 131072);
PyModule_AddIntConstant(module, "ARMOR_BODY", 0);
PyModule_AddIntConstant(module, "ARMOR_HEAD", 1);
PyModule_AddIntConstant(module, "ARMOR_SHIELD", 2);
PyModule_AddIntConstant(module, "ARMOR_WRIST", 3);
PyModule_AddIntConstant(module, "ARMOR_FOOTS", 4);
PyModule_AddIntConstant(module, "ARMOR_NECK", 5);
PyModule_AddIntConstant(module, "ARMOR_EAR", 6);
PyModule_AddIntConstant(module, "ARMOR_GLOVE", 7);
PyModule_AddIntConstant(module, "GLOVE_ATTR_MAX_NUM", 7);
PyModule_AddIntConstant(module, "ARMOR_PENDANT", 8);
PyModule_AddIntConstant(module, "ITEM_APPLY_MAX_NUM", 3);
PyModule_AddIntConstant(module, "ITEM_SOCKET_MAX_NUM", 8);
PyModule_AddIntConstant(module, "APPLY_NONE", 0);
PyModule_AddIntConstant(module, "APPLY_STR", 5);
PyModule_AddIntConstant(module, "APPLY_DEX", 6);
PyModule_AddIntConstant(module, "APPLY_CON", 3);
PyModule_AddIntConstant(module, "APPLY_INT", 4);
PyModule_AddIntConstant(module, "APPLY_MAX_HP", 1);
PyModule_AddIntConstant(module, "APPLY_MAX_SP", 2);
PyModule_AddIntConstant(module, "APPLY_HP_REGEN", 10);
PyModule_AddIntConstant(module, "APPLY_SP_REGEN", 11);
PyModule_AddIntConstant(module, "APPLY_DEF_GRADE_BONUS", 54);
PyModule_AddIntConstant(module, "APPLY_ATT_GRADE_BONUS", 53);
PyModule_AddIntConstant(module, "APPLY_ATT_SPEED", 7);
PyModule_AddIntConstant(module, "APPLY_MOV_SPEED", 8);
PyModule_AddIntConstant(module, "APPLY_CAST_SPEED", 9);
PyModule_AddIntConstant(module, "APPLY_MAGIC_ATT_GRADE", 55);
PyModule_AddIntConstant(module, "APPLY_MAGIC_DEF_GRADE", 56);
PyModule_AddIntConstant(module, "APPLY_SKILL", 51);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_ANIMAL", 18);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_UNDEAD", 21);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_DEVIL", 22);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_HUMAN", 17);
PyModule_AddIntConstant(module, "APPLY_BOW_DISTANCE", 52);
PyModule_AddIntConstant(module, "APPLY_RESIST_BOW", 34);
PyModule_AddIntConstant(module, "APPLY_RESIST_FIRE", 35);
PyModule_AddIntConstant(module, "APPLY_RESIST_ELEC", 36);
PyModule_AddIntConstant(module, "APPLY_RESIST_MAGIC", 37);
PyModule_AddIntConstant(module, "APPLY_POISON_PCT", 12);
PyModule_AddIntConstant(module, "APPLY_SLOW_PCT", 14);
PyModule_AddIntConstant(module, "APPLY_STUN_PCT", 13);
PyModule_AddIntConstant(module, "APPLY_CRITICAL_PCT", 15);
PyModule_AddIntConstant(module, "APPLY_PENETRATE_PCT", 16);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_ORC", 19);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_MILGYO", 20);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_UNDEAD", 21);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_DEVIL", 22);
PyModule_AddIntConstant(module, "APPLY_STEAL_HP", 23);
PyModule_AddIntConstant(module, "APPLY_STEAL_SP", 24);
PyModule_AddIntConstant(module, "APPLY_MANA_BURN_PCT", 25);
PyModule_AddIntConstant(module, "APPLY_DAMAGE_SP_RECOVER", 26);
PyModule_AddIntConstant(module, "APPLY_BLOCK", 27);
PyModule_AddIntConstant(module, "APPLY_DODGE", 28);
PyModule_AddIntConstant(module, "APPLY_RESIST_SWORD", 29);
PyModule_AddIntConstant(module, "APPLY_RESIST_TWOHAND", 30);
PyModule_AddIntConstant(module, "APPLY_RESIST_DAGGER", 31);
PyModule_AddIntConstant(module, "APPLY_RESIST_BELL", 32);
PyModule_AddIntConstant(module, "APPLY_RESIST_FAN", 33);
PyModule_AddIntConstant(module, "APPLY_RESIST_WIND", 38);
PyModule_AddIntConstant(module, "APPLY_REFLECT_MELEE", 39);
PyModule_AddIntConstant(module, "APPLY_REFLECT_CURSE", 40);
PyModule_AddIntConstant(module, "APPLY_POISON_REDUCE", 41);
PyModule_AddIntConstant(module, "APPLY_KILL_SP_RECOVER", 42);
PyModule_AddIntConstant(module, "APPLY_EXP_DOUBLE_BONUS", 43);
PyModule_AddIntConstant(module, "APPLY_GOLD_DOUBLE_BONUS", 44);
PyModule_AddIntConstant(module, "APPLY_ITEM_DROP_BONUS", 45);
PyModule_AddIntConstant(module, "APPLY_POTION_BONUS", 46);
PyModule_AddIntConstant(module, "APPLY_KILL_HP_RECOVER", 47);
PyModule_AddIntConstant(module, "APPLY_IMMUNE_STUN", 48);
PyModule_AddIntConstant(module, "APPLY_IMMUNE_SLOW", 49);
PyModule_AddIntConstant(module, "APPLY_IMMUNE_FALL", 50);
PyModule_AddIntConstant(module, "APPLY_MAX_STAMINA", 58);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_WARRIOR", 59);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_ASSASSIN", 60);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_SURA", 61);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_SHAMAN", 62);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_MONSTER", 63);
PyModule_AddIntConstant(module, "APPLY_MALL_ATTBONUS", 64);
PyModule_AddIntConstant(module, "APPLY_MALL_DEFBONUS", 65);
PyModule_AddIntConstant(module, "APPLY_MALL_EXPBONUS", 66);
PyModule_AddIntConstant(module, "APPLY_MALL_ITEMBONUS", 67);
PyModule_AddIntConstant(module, "APPLY_MALL_GOLDBONUS", 68);
PyModule_AddIntConstant(module, "APPLY_MAX_HP_PCT", 69);
PyModule_AddIntConstant(module, "APPLY_MAX_SP_PCT", 70);
PyModule_AddIntConstant(module, "APPLY_SKILL_DAMAGE_BONUS", 71);
PyModule_AddIntConstant(module, "APPLY_NORMAL_HIT_DAMAGE_BONUS", 72);
PyModule_AddIntConstant(module, "APPLY_SKILL_DEFEND_BONUS", 73);
PyModule_AddIntConstant(module, "APPLY_NORMAL_HIT_DEFEND_BONUS", 74);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_STONE", 139);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_BOSS", 140);
PyModule_AddIntConstant(module, "APPLY_PC_BANG_EXP_BONUS", 76);
PyModule_AddIntConstant(module, "APPLY_PC_BANG_DROP_BONUS", 77);
PyModule_AddIntConstant(module, "APPLY_RESIST_WARRIOR", 78);
PyModule_AddIntConstant(module, "APPLY_RESIST_ASSASSIN", 79);
PyModule_AddIntConstant(module, "APPLY_RESIST_SURA", 80);
PyModule_AddIntConstant(module, "APPLY_RESIST_SHAMAN", 81);
PyModule_AddIntConstant(module, "APPLY_ENERGY", 82);
PyModule_AddIntConstant(module, "APPLY_COSTUME_ATTR_BONUS", 84);
PyModule_AddIntConstant(module, "APPLY_MAGIC_ATTBONUS_PER", 85);
PyModule_AddIntConstant(module, "APPLY_MELEE_MAGIC_ATTBONUS_PER", 86);
PyModule_AddIntConstant(module, "APPLY_RESIST_ICE", 87);
PyModule_AddIntConstant(module, "APPLY_RESIST_EARTH", 88);
PyModule_AddIntConstant(module, "APPLY_RESIST_DARK", 89);
PyModule_AddIntConstant(module, "APPLY_ANTI_CRITICAL_PCT", 90);
PyModule_AddIntConstant(module, "APPLY_ANTI_PENETRATE_PCT", 91);
PyModule_AddIntConstant(module, "APPLY_RANDOM", 118);
PyModule_AddIntConstant(module, "APPLY_RESIST_HUMAN", 99);
PyModule_AddIntConstant(module, "RARITY_NORMAL", 0);
PyModule_AddIntConstant(module, "RARITY_UNCOMMUN", 1);
PyModule_AddIntConstant(module, "RARITY_RARE", 2);
PyModule_AddIntConstant(module, "RARITY_EPIC", 3);
PyModule_AddIntConstant(module, "RARITY_RELIC", 4);
PyModule_AddIntConstant(module, "RARITY_LEGENDARY", 5);
PyModule_AddIntConstant(module, "RARITY_MAX", 6);
PyModule_AddIntConstant(module, "RARITY_TYPE_INDEX", 6);
PyModule_AddIntConstant(module, "RARITY_VALUE_INDEX", 7);
PyModule_AddIntConstant(module, "SPECIAL_ATTR_COSTUME_BODY_LIMIT", 3);
PyModule_AddIntConstant(module, "SPECIAL_ATTR_COSTUME_HAIR_LIMIT", 3);
PyModule_AddIntConstant(module, "SPECIAL_ATTR_COSTUME_WEAPON_LIMIT", 3);
PyModule_AddIntConstant(module, "SPECIAL_ATTR_COSTUME_MOUNT_SKIN_LIMIT", 3);
PyModule_AddIntConstant(module, "SPECIAL_ATTR_COSTUME_SHINING_LIMIT", 3);
PyModule_AddIntConstant(module, "SPECIAL_ATTR_COSTUME_SASH_SKIN_LIMIT", 3);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_WOLFMAN", 1 << 18);
PyModule_AddIntConstant(module, "ITEM_ANTIFLAG_BIND", 1 << 19);
PyModule_AddIntConstant(module, "ANTIFLAG_WOLFMAN", 1 << 18);
PyModule_AddIntConstant(module, "ANTIFLAG_BIND", 1 << 19);
PyModule_AddIntConstant(module, "APPLY_BLEEDING_REDUCE", 92);
PyModule_AddIntConstant(module, "APPLY_BLEEDING_PCT", 93);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_WOLFMAN", 94);
PyModule_AddIntConstant(module, "APPLY_RESIST_WOLFMAN", 95);
PyModule_AddIntConstant(module, "APPLY_RESIST_CLAW", 96);
PyModule_AddIntConstant(module, "APPLY_ATTBONUS_CLAW", 96);
PyModule_AddIntConstant(module, "APPLY_ACCEDRAIN_RATE", 97);
PyModule_AddIntConstant(module, "APPLY_RESIST_MAGIC_REDUCTION", 98);
PyModule_AddIntConstant(module, "E_SEAL_DATE_DEFAULT_TIMESTAMP", 0);
PyModule_AddIntConstant(module, "E_SEAL_DATE_UNLIMITED_TIMESTAMP", -1);
}
struct AutoPotionInfo {
bool bActivated = false;
long currentAmount = 0;
long totalAmount = 0;
long inventorySlotIndex = 0;
};
static std::map<int, AutoPotionInfo> s_autoPotionInfo;
static std::map<int, uint32_t> s_emotionIcons;
static int s_mouseFunc[8] = {0};
static int s_mouseState[8] = {0};
bool IsPlayerMouseMoving() { return s_mouseState[0] == 1 && (s_mouseFunc[0] == 0 || s_mouseFunc[0] == 1); }
bool IsPlayerCameraDragging() { return s_mouseState[1] == 1 && s_mouseFunc[1] == 2; }
void CancelPlayerMovement() { s_movementKeys.fill(false); s_joystickActive=false; std::fill(std::begin(s_mouseState),std::end(s_mouseState),0); }
void SetPlayerJoystick(bool active, float x, float y) { s_joystickActive=active; s_joystickX=active?x:0.0f; s_joystickY=active?y:0.0f; }
bool IsPlayerGameWindow(const void* handler) { return handler && handler==s_playerGameWindow; }
static int s_mouseMiddleButtonState = 0;
static bool s_playerVisible = true;
static bool s_levelLimit = false;
static int s_eventGame = 0;
static PyObject* player_ActEmotion(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
return Py_BuildNone();
}
static PyObject* player_CanAttackInstance(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
const auto* mainActor = player_main_actor();
const auto* target = NetworkActorManager::Instance().GetActorData(vid);
if (!mainActor || !target) return Py_BuildValue("i", 0);
if (mainActor->m_dwVID == target->m_dwVID) return Py_BuildValue("i", 0);
// If target is PC (bType == 6)
if (target->m_bType == 6) {
if (target->m_dwStateFlags & NetworkActorManager::ADD_CHARACTER_STATE_KILLER) return Py_BuildValue("i", 1);
if (mainActor->m_byPKMode == 1 /* PK_MODE_FREE */ && target->m_byPKMode != 4 /* PK_MODE_PROTECT */)
return Py_BuildValue("i", 1);
if (mainActor->m_dwEmpireID != target->m_dwEmpireID)
return Py_BuildValue("i", 1);
if (mainActor->m_byPKMode == 2 /* PK_MODE_GUILD */ && mainActor->m_dwGuildID != 0 && mainActor->m_dwGuildID != target->m_dwGuildID)
return Py_BuildValue("i", 1);
if (mainActor->m_byPKMode == 3 /* PK_MODE_REVENGE */) {
if ((mainActor->m_sAlignment < 0 && target->m_sAlignment >= 0) || (mainActor->m_sAlignment >= 0 && target->m_sAlignment < 0))
return Py_BuildValue("i", 1);
}
return Py_BuildValue("i", 0);
}
// If target is Mob / Monster (bType == 0)
if (target->m_bType == 0) {
return Py_BuildValue("i", 1);
}
// Friendly NPC (bType == 1, etc.)
return Py_BuildValue("i", 0);
}
static PyObject* player_ChangeCurrentSkillNumberOnly(PyObject*, PyObject* args) {
int slot = 0;
if (!PyTuple_GetInteger(args, 0, &slot)) return Py_BadArgument();
s_curSkillSlotIndex = slot;
player_window_call("ChangeCurrentSkill", Py_BuildValue("(i)", slot));
return Py_BuildNone();
}
static PyObject* player_Clear(PyObject*, PyObject*) {
s_playerSkills.clear();
s_skillSlots.clear();
s_targetVID = 0;
s_inGuildAreaID = 0xffffffff;
s_isAtkKey = false;
PythonNetworkStream::Instance().SendTargetPacket(0);
return Py_BuildNone();
}
static PyObject* player_ClearSkillDict(PyObject*, PyObject*) {
s_playerSkills.clear();
return Py_BuildNone();
}
static PyObject* player_ClearTarget(PyObject*, PyObject*) {
s_targetVID = 0;
PythonNetworkStream::Instance().SendTargetPacket(0);
return Py_BuildNone();
}
static PyObject* player_ComboAttack(PyObject*, PyObject*) {
PlayerNewAttack();
return Py_BuildNone();
}
static PyObject* player_EndKeyWalkingImmediately(PyObject*, PyObject*) {
s_movementKeys.fill(false);
NEW_CancelFishing();
return Py_BuildNone();
}
static PyObject* player_EndMouseWalking(PyObject*, PyObject*) {
return Py_BuildNone();
}
static PyObject* player_GetAlignmentData(PyObject*, PyObject*) {
int alignment = 0;
auto it = s_playerPoints.find(39 /* POINT_ALIGNMENT */);
if (it != s_playerPoints.end()) alignment = int(it->second);
int grade = 4;
if (alignment >= 12000) grade = 8;
else if (alignment >= 8000) grade = 7;
else if (alignment >= 4000) grade = 6;
else if (alignment >= 1000) grade = 5;
else if (alignment >= 0) grade = 4;
else if (alignment >= -4000) grade = 3;
else if (alignment >= -8000) grade = 2;
else if (alignment >= -12000) grade = 1;
else grade = 0;
return Py_BuildValue("ii", alignment, grade);
}
static PyObject* player_GetAutoPotionInfo(PyObject*, PyObject* args) {
int potionType = 0;
if (!PyTuple_GetInteger(args, 0, &potionType)) return Py_BadArgument();
const auto& info = s_autoPotionInfo[potionType];
return Py_BuildValue("biii", info.bActivated, int(info.currentAmount), int(info.totalAmount), int(info.inventorySlotIndex));
}
static PyObject* player_SetAutoPotionInfo(PyObject*, PyObject* args) {
int potionType = 0;
if (!PyTuple_GetInteger(args, 0, &potionType)) return Py_BadArgument();
auto& info = s_autoPotionInfo[potionType];
int bActivated = 0;
if (!PyTuple_GetInteger(args, 1, &bActivated)) return Py_BadArgument();
info.bActivated = (bActivated != 0);
if (!PyTuple_GetLong(args, 2, &info.currentAmount)) return Py_BadArgument();
if (!PyTuple_GetLong(args, 3, &info.totalAmount)) return Py_BadArgument();
if (!PyTuple_GetLong(args, 4, &info.inventorySlotIndex)) return Py_BadArgument();
return Py_BuildNone();
}
static PyObject* player_GetCharacterDistance(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
const auto* target = NetworkActorManager::Instance().GetActorData(vid);
if (!target) return Py_BuildValue("f", -1.0f);
float dx = s_mainActorPos.x - float(target->m_lCurX);
float dy = s_mainActorPos.y - float(target->m_lCurY);
return Py_BuildValue("f", std::sqrt(dx * dx + dy * dy));
}
static PyObject* player_RegisterEmotionIcon(PyObject*, PyObject* args) {
int idx = 0; char* filename = nullptr;
if (!PyTuple_GetInteger(args, 0, &idx) || !PyTuple_GetString(args, 1, &filename)) return Py_BuildException();
auto* pRes = CResourceManager::Instance().GetResourcePointer(filename);
if (pRes && pRes->IsType(CGraphicImage::Type())) {
auto* pImageInstance = CGraphicImageInstance::New();
pImageInstance->SetImagePointer(static_cast<CGraphicImage*>(pRes));
s_emotionIcons[idx] = GrpRegisterImageInstanceHandle(pImageInstance);
} else {
s_emotionIcons[idx] = 0;
}
return Py_BuildNone();
}
static PyObject* player_GetEmotionIconImage(PyObject*, PyObject* args) {
int idx = 0;
if (!PyTuple_GetInteger(args, 0, &idx)) return Py_BuildException();
auto it = s_emotionIcons.find(idx);
return Py_BuildValue("i", it != s_emotionIcons.end() ? it->second : 0);
}
static PyObject* player_GetEventGame(PyObject*, PyObject*) {
return Py_BuildValue("i", s_eventGame);
}
static PyObject* player_SetEventGame(PyObject*, PyObject* args) {
int val = 0;
if (!PyTuple_GetInteger(args, 0, &val)) return Py_BuildException();
s_eventGame = val;
return Py_BuildNone();
}
static PyObject* player_GetGem(PyObject*, PyObject*) {
auto it = s_playerPoints.find(240 /* POINT_GEM */);
return Py_BuildValue("i", it != s_playerPoints.end() ? int(it->second) : 0);
}
static PyObject* player_GetItemLink(PyObject*, PyObject* args) {
int window = 1, cell = 0;
if (PyTuple_Size(args) == 1) {
if (!PyTuple_GetInteger(args, 0, &cell)) return Py_BuildException();
} else if (PyTuple_Size(args) == 2) {
if (!PyTuple_GetInteger(args, 0, &window) || !PyTuple_GetInteger(args, 1, &cell)) return Py_BuildException();
} else return Py_BuildException();
const auto item = GetPlayerItemData(window, cell);
if (!item.vnum) return Py_BuildValue("s", "");
select_item_data(item.vnum);
const auto it = s_itemMap.find(item.vnum);
const std::string name = it != s_itemMap.end() ? it->second.name : "Item";
char itemlink[1024];
int len = snprintf(itemlink, sizeof(itemlink), "item:%x:%x", item.vnum, item.flags);
for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i) len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x", item.alSockets[i]);
for (int i = 0; i < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++i) len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%d", item.aAttr[i].bType, item.aAttr[i].sValue);
for (int i = 0; i < GLOVE_ATTR_MAX_NUM; ++i) len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%d", item.randomAttr[i].bType, item.randomAttr[i].sValue);
char buf[1024];
snprintf(buf, sizeof(buf), " |cffffc700|H%s|h[%s]|h|r", itemlink, name.c_str());
return Py_BuildValue("s", buf);
}
static PyObject* player_GetItemRandomAttribute(PyObject*, PyObject* args) {
int window = 1, cell = 0, attrSlot = 0;
if (PyTuple_Size(args) == 2) {
if (!PyTuple_GetInteger(args, 0, &cell) || !PyTuple_GetInteger(args, 1, &attrSlot)) return Py_BuildException();
} else if (PyTuple_Size(args) == 3) {
if (!PyTuple_GetInteger(args, 0, &window) || !PyTuple_GetInteger(args, 1, &cell) || !PyTuple_GetInteger(args, 2, &attrSlot)) return Py_BuildException();
} else return Py_BuildException();
const auto item = GetPlayerItemData(window, cell);
if (attrSlot >= 0 && attrSlot < GLOVE_ATTR_MAX_NUM) {
return Py_BuildValue("ii", item.randomAttr[attrSlot].bType, item.randomAttr[attrSlot].sValue);
}
return Py_BuildValue("ii", 0, 0);
}
static PyObject* player_GetMainCharacterPart(PyObject*, PyObject* args) {
int part = 0;
if (!PyTuple_GetInteger(args, 0, &part)) return Py_BadArgument();
const auto* actor = player_main_actor();
if (!actor) return Py_BuildValue("i", 0);
if (part == 0) return Py_BuildValue("i", int(actor->m_dwArmor));
if (part == 1) return Py_BuildValue("i", int(actor->m_dwWeapon));
if (part == 2) return Py_BuildValue("i", int(actor->m_dwHair));
if (part == 3) return Py_BuildValue("i", int(actor->m_dwSash));
return Py_BuildValue("i", 0);
}
static PyObject* player_GetMainCharacterShiningPart(PyObject*, PyObject* args) {
int part = 0;
if (!PyTuple_GetInteger(args, 0, &part)) return Py_BadArgument();
const auto* actor = player_main_actor();
if (actor && part >= 0 && part < CHR_SHINING_NUM)
return Py_BuildValue("i", int(actor->m_shining[part]));
return Py_BuildValue("i", 0);
}
static PyObject* player_GetMouseFunc(PyObject*, PyObject* args) {
int btn = 0;
if (!PyTuple_GetInteger(args, 0, &btn)) return Py_BuildException();
if (btn >= 0 && btn < 8) return Py_BuildValue("i", s_mouseFunc[btn]);
return Py_BuildValue("i", 0);
}
static PyObject* player_SetMouseFunc(PyObject*, PyObject* args) {
int btn = 0, func = 0;
if (!PyTuple_GetInteger(args, 0, &btn) || !PyTuple_GetInteger(args, 1, &func)) return Py_BuildException();
if (btn >= 0 && btn < 8) s_mouseFunc[btn] = func;
return Py_BuildNone();
}
static PyObject* player_SetMouseState(PyObject*, PyObject* args) {
int btn = 0, state = 0;
if (!PyTuple_GetInteger(args, 0, &btn) || !PyTuple_GetInteger(args, 1, &state)) return Py_BuildException();
if (btn >= 0 && btn < 8) s_mouseState[btn] = state;
return Py_BuildNone();
}
static PyObject* player_SetMouseMiddleButtonState(PyObject*, PyObject* args) {
int state = 0;
if (!PyTuple_GetInteger(args, 0, &state)) return Py_BuildException();
s_mouseMiddleButtonState = state;
return Py_BuildNone();
}
static PyObject* player_GetTargetVID(PyObject*, PyObject*) {
return Py_BuildValue("i", int(s_targetVID));
}
static PyObject* player_SetTarget(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
s_targetVID = uint32_t(vid);
PythonNetworkStream::Instance().SendTargetPacket(uint32_t(vid));
return Py_BuildNone();
}
static PyObject* player_HidePlayer(PyObject*, PyObject*) {
s_playerVisible = false;
return Py_BuildNone();
}
static PyObject* player_ShowPlayer(PyObject*, PyObject*) {
s_playerVisible = true;
return Py_BuildNone();
}
static PyObject* player_IsActingEmotion(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_IsEquippingBelt(PyObject*, PyObject*) {
const auto data = GetPlayerItemData(1, 203);
return Py_BuildValue("b", data.vnum != 0 && data.count > 0);
}
static PyObject* player_IsAvailableBeltInventoryCell(PyObject*, PyObject* args) {
const auto data = GetPlayerItemData(1, 203);
if (!data.vnum || data.count == 0) return Py_BuildValue("b", false);
const auto* proto = s_itemProto.find(data.vnum);
long beltGrade = proto ? proto->values[0] : 0;
int pos = 0;
if (!PyTuple_GetInteger(args, 0, &pos)) return Py_BadArgument();
int cell = pos - 246;
if (cell < 0 || cell >= 16) return Py_BuildValue("b", false);
static const uint8_t rules[16] = {1, 2, 4, 6, 3, 3, 4, 6, 5, 5, 5, 6, 7, 7, 7, 7};
return Py_BuildValue("b", rules[cell] <= beltGrade);
}
static PyObject* player_IsInSafeArea(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_IsMountingHorse(PyObject*, PyObject*) {
const auto* actor = player_main_actor();
return Py_BuildValue("i", (actor && actor->m_dwMountVnum != 0) ? 1 : 0);
}
static PyObject* player_IsOpenPrivateShop(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_IsPVPInstance(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
return Py_BuildValue("i", 0);
}
static PyObject* player_IsSameEmpire(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
const auto* mainActor = player_main_actor();
const auto* target = NetworkActorManager::Instance().GetActorData(vid);
if (!mainActor || !target) return Py_BuildValue("i", 0);
return Py_BuildValue("i", (mainActor->m_dwEmpireID == target->m_dwEmpireID) ? 1 : 0);
}
static PyObject* player_IsShiningSlot(PyObject*, PyObject* args) {
int slot = 0;
if (!PyTuple_GetInteger(args, 0, &slot)) return Py_BuildException();
return Py_BuildValue("i", (slot >= 211 && slot <= 214) ? 1 : 0);
}
static PyObject* player_IsSkillActive(PyObject*, PyObject* args) {
int slot = 0;
if (!PyTuple_GetInteger(args, 0, &slot)) return Py_BuildException();
auto it = s_playerSkills.find(slot);
if (it != s_playerSkills.end()) {
return Py_BuildValue("i", it->second.active ? 1 : 0);
}
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();
}
static PyObject* player_MoveItem(PyObject*, PyObject* args) {
int srcWindow = 1, srcCell = 0, dstWindow = 1, dstCell = 0;
if (PyTuple_Size(args) == 2) {
if (!PyTuple_GetInteger(args, 0, &srcCell) || !PyTuple_GetInteger(args, 1, &dstCell))
return Py_BuildException();
} else if (PyTuple_Size(args) == 4) {
if (!PyTuple_GetInteger(args, 0, &srcWindow) || !PyTuple_GetInteger(args, 1, &srcCell) ||
!PyTuple_GetInteger(args, 2, &dstWindow) || !PyTuple_GetInteger(args, 3, &dstCell))
return Py_BuildException();
} else return Py_BuildException();
auto srcItem = GetPlayerItemData(srcWindow, srcCell);
auto dstItem = GetPlayerItemData(dstWindow, dstCell);
SetPlayerItemData(srcWindow, srcCell, dstItem);
SetPlayerItemData(dstWindow, dstCell, srcItem);
return Py_BuildNone();
}
static PyObject* player_OpenCharacterMenu(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
if (auto* actor = NetworkActorManager::Instance().GetActorData(uint32_t(vid))) {
player_window_call("SetPCTargetBoard", Py_BuildValue("(is)", vid, actor->m_stName.c_str()));
}
return Py_BuildNone();
}
static PyObject* player_PickCloseItem(PyObject*, PyObject*) {
uint32_t vid = 0;
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();
}
static PyObject* player_PickCloseItemVector(PyObject*, PyObject*) {
std::vector<uint32_t> outVids;
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);
}
}
return Py_BuildNone();
}
static PyObject* player_RegisterCacheEffect(PyObject*, PyObject* args) {
int eft = 0; char* filename = nullptr;
if (!PyTuple_GetInteger(args, 0, &eft) || !PyTuple_GetString(args, 1, &filename)) return Py_BadArgument();
return Py_BuildNone();
}
static PyObject* player_RegisterEffect(PyObject*, PyObject* args) {
int eft = 0; char* filename = nullptr;
if (!PyTuple_GetInteger(args, 0, &eft) || !PyTuple_GetString(args, 1, &filename)) return Py_BadArgument();
return Py_BuildNone();
}
static PyObject* player_Render(PyObject*, PyObject*) {
return Py_BuildNone();
}
static PyObject* player_RequestFlag(PyObject*, PyObject* args) {
char* name = nullptr;
if (!PyTuple_GetString(args, 0, &name)) return Py_BadArgument();
return Py_BuildNone();
}
static PyObject* player_ResetCameraRotation(PyObject*, PyObject*) {
return Py_BuildNone();
}
static PyObject* player_SendClickItemPacket(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
PythonNetworkStream::Instance().SendItemPickUpPacket(uint32_t(vid));
return Py_BuildNone();
}
static PyObject* player_SendDragonSoulRefine(PyObject*, PyObject* args) {
int subHeader = 0;
if (!PyTuple_GetInteger(args, 0, &subHeader)) return Py_BuildException();
TItemPos RefineItemPoses[DS_REFINE_WINDOW_MAX_NUM]{};
switch (subHeader) {
case DS_SUB_HEADER_CLOSE:
break;
case DS_SUB_HEADER_DO_UPGRADE:
case DS_SUB_HEADER_DO_IMPROVEMENT:
case DS_SUB_HEADER_DO_REFINE: {
PyObject* pDic = nullptr;
if (PyTuple_Size(args) > 1) {
pDic = PyTuple_GetItem(args, 1);
if (pDic && PyDict_Check(pDic)) {
Py_ssize_t pos = 0;
PyObject *key = nullptr, *value = nullptr;
while (PyDict_Next(pDic, &pos, &key, &value)) {
int i = PyInt_AsLong(key);
if (i >= 0 && i < (int)DS_REFINE_WINDOW_MAX_NUM && PyTuple_Check(value) && PyTuple_Size(value) >= 2) {
int wType = 0, cell = 0;
PyTuple_GetInteger(value, 0, &wType);
PyTuple_GetInteger(value, 1, &cell);
RefineItemPoses[i] = TItemPos(uint8_t(wType), uint16_t(cell));
}
}
}
}
break;
}
}
PythonNetworkStream::Instance().SendDragonSoulRefinePacket(uint8_t(subHeader), RefineItemPoses);
return Py_BuildNone();
}
void SetPlayerAttackKey(bool pressed) {
if (pressed && IsMainActorFishingMode()) {
NEW_Fishing();
return;
}
s_isAtkKey = pressed;
}
static PyObject* player_SetAttackKeyState(PyObject*, PyObject* args) {
int pressed = 0;
if (!PyTuple_GetInteger(args, 0, &pressed)) return Py_BuildException();
SetPlayerAttackKey(pressed != 0);
return Py_BuildNone();
}
static PyObject* player_SetAutoCameraRotationSpeed(PyObject*, PyObject* args) {
float spd = 0.0f;
if (!PyTuple_GetFloat(args, 0, &spd)) return Py_BuildException();
s_fCmrRotSpd = spd;
return Py_BuildNone();
}
static PyObject* player_SetItemAttribute(PyObject*, PyObject* args) {
int window = 1, slot = 0, attrSlot = 0, attrType = 0, attrValue = 0;
if (PyTuple_Size(args) == 4) {
if (!PyTuple_GetInteger(args, 0, &slot) || !PyTuple_GetInteger(args, 1, &attrSlot) ||
!PyTuple_GetInteger(args, 2, &attrType) || !PyTuple_GetInteger(args, 3, &attrValue))
return Py_BuildException();
} else if (PyTuple_Size(args) == 5) {
if (!PyTuple_GetInteger(args, 0, &window) || !PyTuple_GetInteger(args, 1, &slot) ||
!PyTuple_GetInteger(args, 2, &attrSlot) || !PyTuple_GetInteger(args, 3, &attrType) ||
!PyTuple_GetInteger(args, 4, &attrValue))
return Py_BuildException();
} else return Py_BuildException();
auto item = GetPlayerItemData(window, slot);
if (attrSlot >= 0 && attrSlot < 15) {
item.aAttr[attrSlot].bType = attrType;
item.aAttr[attrSlot].sValue = attrValue;
SetPlayerItemData(window, slot, item);
}
return Py_BuildNone();
}
static PyObject* player_SetItemCount(PyObject*, PyObject* args) {
int slot = 0, count = 0, window = 1;
if (PyTuple_Size(args) == 2) {
if (!PyTuple_GetInteger(args, 0, &slot) || !PyTuple_GetInteger(args, 1, &count))
return Py_BuildException();
} else if (PyTuple_Size(args) == 3) {
if (!PyTuple_GetInteger(args, 0, &window) || !PyTuple_GetInteger(args, 1, &slot) ||
!PyTuple_GetInteger(args, 2, &count))
return Py_BuildException();
} else return Py_BuildException();
if (count == 0) return Py_BuildException();
SetPlayerItemCount(window, slot, count);
return Py_BuildNone();
}
static PyObject* player_SetItemData(PyObject*, PyObject* args) {
int slot = 0, vnum = 0, count = 0;
if (!PyTuple_GetInteger(args, 0, &slot) || !PyTuple_GetInteger(args, 1, &vnum) ||
!PyTuple_GetInteger(args, 2, &count))
return Py_BuildException();
TItemData item{};
item.vnum = vnum;
item.count = count;
SetPlayerItemData(1, slot, item);
return Py_BuildNone();
}
static PyObject* player_SetItemMetinSocket(PyObject*, PyObject* args) {
int window = 1, slot = 0, socket = 0, num = 0;
if (PyTuple_Size(args) == 3) {
if (!PyTuple_GetInteger(args, 0, &slot) || !PyTuple_GetInteger(args, 1, &socket) ||
!PyTuple_GetInteger(args, 2, &num))
return Py_BuildException();
} else if (PyTuple_Size(args) == 4) {
if (!PyTuple_GetInteger(args, 0, &window) || !PyTuple_GetInteger(args, 1, &slot) ||
!PyTuple_GetInteger(args, 2, &socket) || !PyTuple_GetInteger(args, 3, &num))
return Py_BuildException();
} else return Py_BuildException();
auto item = GetPlayerItemData(window, slot);
if (socket >= 0 && socket < 8) {
item.alSockets[socket] = num;
SetPlayerItemData(window, slot, item);
}
return Py_BuildNone();
}
static PyObject* player_SetMainCharacterIndex(PyObject*, PyObject* args) {
int vid = 0;
if (!PyTuple_GetInteger(args, 0, &vid)) return Py_BuildException();
PythonNetworkStream::Instance().SetMainActorVID(uint32_t(vid));
NetworkActorManager::Instance().SetMainActorVID(uint32_t(vid));
return Py_BuildNone();
}
static PyObject* player_SetQuickCameraMode(PyObject*, PyObject* args) {
int enable = 0;
if (!PyTuple_GetInteger(args, 0, &enable)) return Py_BadArgument();
return Py_BuildNone();
}
static PyObject* player_SetSingleDIKKeyState(PyObject*, PyObject* args) {
int dik = 0, pressed = 0;
if (!PyTuple_GetInteger(args, 0, &dik) || !PyTuple_GetInteger(args, 1, &pressed))
return Py_BuildException();
if (NEW_CancelFishing())
return Py_BuildNone();
if (dik >= 0 && dik < int(s_movementKeys.size())) s_movementKeys[dik] = pressed != 0;
return Py_BuildNone();
}
static PyObject* player_SetWeaponAttackBonusFlag(PyObject*, PyObject* args) {
int flag = 0;
if (!PyTuple_GetInteger(args, 0, &flag)) return Py_BuildException();
return Py_BuildNone();
}
static PyObject* player_StartMouseWalking(PyObject*, PyObject*) {
return Py_BuildNone();
}
static PyObject* player_ToggleLevelLimit(PyObject*, PyObject*) {
s_levelLimit = !s_levelLimit;
return Py_BuildValue("i", s_levelLimit ? 1 : 0);
}
static PyObject* player_Update(PyObject*, PyObject*) {
float curX = s_mainActorPos.x;
float curY = s_mainActorPos.y;
const auto* pActor = player_main_actor();
if (curX == 0.0f && curY == 0.0f && pActor) {
curX = float(pActor->m_lCurX);
curY = float(pActor->m_lCurY);
}
uint32_t dwAreaID = CPythonMiniMap::Instance().GetGuildAreaID(static_cast<uint32_t>(curX), static_cast<uint32_t>(curY));
if (dwAreaID != s_inGuildAreaID) {
if (dwAreaID != 0xffffffff) {
player_window_call("BINARY_Guild_EnterGuildArea", Py_BuildValue("(i)", dwAreaID));
} else {
player_window_call("BINARY_Guild_ExitGuildArea", Py_BuildValue("(i)", dwAreaID));
}
s_inGuildAreaID = dwAreaID;
}
return Py_BuildNone();
}
static PyObject* player_UseGuildSkill(PyObject*, PyObject* args) {
int slot = 0;
if (!PyTuple_GetInteger(args, 0, &slot)) return Py_BuildException();
UseGuildSkill(slot);
return Py_BuildNone();
}
static PyObject* player_isItem(PyObject*, PyObject* args) {
int slot = 0;
if (!PyTuple_GetInteger(args, 0, &slot)) return Py_BuildException();
const auto data = GetPlayerItemData(1, slot);
return Py_BuildValue("i", (data.vnum != 0 && data.count > 0) ? 1 : 0);
}
static PyObject* player_GetItemBind(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_IsTournamentMap(PyObject*, PyObject*) {
bool isTourney = (s_warpMapName == "metin2_map_colosseum" || CPythonBackground::Instance().GetWarpMapName() == "metin2_map_colosseum");
return Py_BuildValue("i", isTourney ? 1 : 0);
}
static PyObject* player_GetItemUnbindTime(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_GetItemElementGrade(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_GetItemElementAttack(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_GetItemElementType(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_GetItemElementValue(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_GetElements(PyObject*, PyObject*) {
return Py_BuildValue("i", 6);
}
static PyObject* player_IsCombatZoneMap(PyObject*, PyObject*) {
bool isCombat = (s_warpMapName == "metin2_map_battlefied" || CPythonBackground::Instance().GetWarpMapName() == "metin2_map_battlefied");
return Py_BuildValue("i", isCombat ? 1 : 0);
}
static PyObject* player_GetCombatZonePoints(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_CanSealItem(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_GetItemSealDate(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
static PyObject* player_GetItemUnSealLeftTime(PyObject*, PyObject*) {
return Py_BuildValue("i", 0);
}
// Mobile step 6 auto hunt (ui_mobile_autohunt.py). Not in the original player module.
static void auto_hunt_load();
static PyObject* player_SetAutoHunt(PyObject*, PyObject* args) {
int on = 0;
if (!PyArg_ParseTuple(args, "i", &on)) return nullptr;
auto_hunt_load();
if (on && !s_autoHunt.IsOn()) {
const auto* main = NetworkActorManager::Instance().GetMainInstance();
if (main && main->m_pActorInstance) s_autoHunt.Start(main->m_pActorInstance->GetX(), main->m_pActorInstance->GetZ());
} else if (!on && s_autoHunt.IsOn()) {
s_autoHunt.Stop();
if (auto* main = NetworkActorManager::Instance().GetMainInstance(); main && main->m_pActorInstance) {
main->m_pActorInstance->ClearMoveTarget();
main->m_pActorInstance->StopMoving();
}
}
return PyInt_FromLong(s_autoHunt.IsOn());
}
static PyObject* player_IsAutoHunt(PyObject*, PyObject*) { return PyInt_FromLong(s_autoHunt.IsOn()); }
static PyObject* player_GetAutoHuntState(PyObject*, PyObject*) {
return Py_BuildValue("(si)", AutoHuntStateName(s_autoHunt.GetState()), int(s_autoHunt.GetTarget()));
}
static int* auto_hunt_int_option(const std::string& name) {
auto& o = s_autoHunt.options;
if (name == "hp_percent") return &o.hpPercent;
if (name == "sp_percent") return &o.spPercent;
if (name == "hp_slot") return &o.hpSlot;
if (name == "sp_slot") return &o.spSlot;
return nullptr;
}
static bool* auto_hunt_bool_option(const std::string& name) {
auto& o = s_autoHunt.options;
if (name == "skills") return &o.useSkills;
if (name == "pickup") return &o.pickUp;
if (name == "stones") return &o.attackStones;
return nullptr;
}
// autohunt.cfg next to metin2.cfg (CPythonSystem config directory), "name value" per line.
static std::string auto_hunt_config_path() {
std::string directory = CPythonSystem::GetConfigDirectory();
if (!directory.empty() && directory.back() != '/' && directory.back() != '\\') directory += '/';
return directory + "autohunt.cfg";
}
static void auto_hunt_set(const std::string& name, int value) {
if (name == "radius") s_autoHunt.options.radius = float(std::clamp(value, 300, 5000));
else if (int* i = auto_hunt_int_option(name)) *i = name == "hp_slot" || name == "sp_slot" ? std::clamp(value, 0, 31) : std::clamp(value, 0, 100);
else if (bool* b = auto_hunt_bool_option(name)) *b = value != 0;
}
static void auto_hunt_load() {
static bool loaded = false;
if (loaded) return;
loaded = true;
std::ifstream file(auto_hunt_config_path());
std::string name; int value;
while (file >> name >> value) auto_hunt_set(name, value);
}
static void auto_hunt_save() {
const auto& o = s_autoHunt.options;
std::ofstream file(auto_hunt_config_path(), std::ios::trunc);
file << "radius " << int(o.radius) << "\nskills " << o.useSkills << "\npickup " << o.pickUp
<< "\nstones " << o.attackStones << "\nhp_percent " << o.hpPercent << "\nsp_percent " << o.spPercent
<< "\nhp_slot " << o.hpSlot << "\nsp_slot " << o.spSlot << "\n";
}
static PyObject* player_SetAutoHuntOption(PyObject*, PyObject* args) {
char* name = nullptr; int value = 0;
if (!PyArg_ParseTuple(args, "si", &name, &value)) return nullptr;
const std::string key(name);
if (key != "radius" && !auto_hunt_int_option(key) && !auto_hunt_bool_option(key)) {
PyErr_Format(PyExc_KeyError, "%s", name);
return nullptr;
}
auto_hunt_load();
auto_hunt_set(key, value);
auto_hunt_save();
Py_RETURN_NONE;
}
static PyObject* player_GetAutoHuntOption(PyObject*, PyObject* args) {
char* name = nullptr;
if (!PyArg_ParseTuple(args, "s", &name)) return nullptr;
auto_hunt_load();
if (std::string(name) == "radius") return PyInt_FromLong(long(s_autoHunt.options.radius));
if (int* i = auto_hunt_int_option(name)) return PyInt_FromLong(*i);
if (bool* b = auto_hunt_bool_option(name)) return PyInt_FromLong(*b);
PyErr_Format(PyExc_KeyError, "%s", name);
return nullptr;
}
void initPlayer() {
static PyMethodDef methods[] = {
{"GetAutoPotionInfo", player_GetAutoPotionInfo, METH_VARARGS, nullptr},
{"SetAutoPotionInfo", player_SetAutoPotionInfo, METH_VARARGS, nullptr},
{"GetItemBind", player_GetItemBind, METH_VARARGS, nullptr},
{"IsTournamentMap", player_IsTournamentMap, METH_VARARGS, nullptr},
{"IsAntiFlagBySlot", player_IsAntiFlagBySlot, METH_VARARGS, nullptr},
{"GetItemTypeBySlot", player_GetItemTypeBySlot, METH_VARARGS, nullptr},
{"GetItemSubTypeBySlot", player_GetItemSubTypeBySlot, METH_VARARGS, nullptr},
{"IsSameItemVnum", player_IsSameItemVnum, METH_VARARGS, nullptr},
{"PickCloseItemVector", player_PickCloseItemVector, METH_VARARGS, nullptr},
{"PickCloseItem", player_PickCloseItem, METH_VARARGS, nullptr},
{"SetGameWindow", player_SetGameWindow, METH_VARARGS, nullptr},
{"RegisterEffect", player_RegisterEffect, METH_VARARGS, nullptr},
{"RegisterCacheEffect", player_RegisterCacheEffect, METH_VARARGS, nullptr},
{"SetMouseState", player_SetMouseState, METH_VARARGS, nullptr},
{"SetMouseFunc", player_SetMouseFunc, METH_VARARGS, nullptr},
{"GetMouseFunc", player_GetMouseFunc, METH_VARARGS, nullptr},
{"SetMouseMiddleButtonState", player_SetMouseMiddleButtonState, METH_VARARGS, nullptr},
{"SetMainCharacterIndex", player_SetMainCharacterIndex, METH_VARARGS, nullptr},
{"GetMainCharacterIndex", player_GetMainCharacterIndex, METH_VARARGS, nullptr},
{"GetMainCharacterName", player_GetMainCharacterName, METH_VARARGS, nullptr},
{"GetMainCharacterPosition", player_GetMainCharacterPosition, METH_VARARGS, nullptr},
{"IsMainCharacterIndex", player_IsMainCharacterIndex, METH_VARARGS, nullptr},
{"CanAttackInstance", player_CanAttackInstance, METH_VARARGS, nullptr},
{"IsActingEmotion", player_IsActingEmotion, METH_VARARGS, nullptr},
{"IsPVPInstance", player_IsPVPInstance, METH_VARARGS, nullptr},
{"IsSameEmpire", player_IsSameEmpire, METH_VARARGS, nullptr},
{"IsChallengeInstance", player_IsChallengeInstance, METH_VARARGS, nullptr},
{"IsRevengeInstance", player_IsRevengeInstance, METH_VARARGS, nullptr},
{"IsCantFightInstance", player_IsCantFightInstance, METH_VARARGS, nullptr},
{"GetCharacterDistance", player_GetCharacterDistance, METH_VARARGS, nullptr},
{"IsInSafeArea", player_IsInSafeArea, METH_VARARGS, nullptr},
{"IsMountingHorse", player_IsMountingHorse, METH_VARARGS, nullptr},
{"IsObserverMode", player_IsObserverMode, METH_VARARGS, nullptr},
{"ActEmotion", player_ActEmotion, METH_VARARGS, nullptr},
{"ShowPlayer", player_ShowPlayer, METH_VARARGS, nullptr},
{"HidePlayer", player_HidePlayer, METH_VARARGS, nullptr},
{"ComboAttack", player_ComboAttack, METH_VARARGS, nullptr},
{"RequestFlag", player_RequestFlag, METH_VARARGS, nullptr},
{"SetAutoCameraRotationSpeed", player_SetAutoCameraRotationSpeed, METH_VARARGS, nullptr},
{"SetAttackKeyState", player_SetAttackKeyState, METH_VARARGS, nullptr},
{"SetSingleDIKKeyState", player_SetSingleDIKKeyState, METH_VARARGS, nullptr},
{"EndKeyWalkingImmediately", player_EndKeyWalkingImmediately, METH_VARARGS, nullptr},
{"StartMouseWalking", player_StartMouseWalking, METH_VARARGS, nullptr},
{"EndMouseWalking", player_EndMouseWalking, METH_VARARGS, nullptr},
{"ResetCameraRotation", player_ResetCameraRotation, METH_VARARGS, nullptr},
{"SetQuickCameraMode", player_SetQuickCameraMode, METH_VARARGS, nullptr},
{"SetSkill", player_SetSkill, METH_VARARGS, nullptr},
{"GetSkillIndex", player_GetSkillIndex, METH_VARARGS, nullptr},
{"GetSkillSlotIndex", player_GetSkillSlotIndex, METH_VARARGS, nullptr},
{"GetSkillGrade", player_GetSkillGrade, METH_VARARGS, nullptr},
{"GetSkillLevel", player_GetSkillLevel, METH_VARARGS, nullptr},
{"GetSkillCurrentEfficientPercentage", player_GetSkillPower<false>, METH_VARARGS, nullptr},
{"GetSkillNextEfficientPercentage", player_GetSkillPower<true>, METH_VARARGS, nullptr},
{"ClickSkillSlot", player_ClickSkillSlot, METH_VARARGS, nullptr},
{"ChangeCurrentSkillNumberOnly", player_ChangeCurrentSkillNumberOnly, METH_VARARGS, nullptr},
{"ClearSkillDict", player_ClearSkillDict, METH_VARARGS, nullptr},
{"GetItemIndex", player_GetItemIndex, METH_VARARGS, nullptr},
{"GetItemFlags", player_GetItemFlags, METH_VARARGS, nullptr},
{"GetItemCount", player_GetItemCount, METH_VARARGS, nullptr},
{"GetItemCountByVnum", player_GetItemCountByVnum, METH_VARARGS, nullptr},
{"GetItemMetinSocket", player_GetItemMetinSocket, METH_VARARGS, nullptr},
{"GetItemAttribute", player_GetItemAttribute, METH_VARARGS, nullptr},
{"GetItemCountByTT", player_GetItemCountByTT, METH_VARARGS, nullptr},
{"GetItemUnbindTime", player_GetItemUnbindTime, METH_VARARGS, nullptr},
{"GetISellItemPrice", player_GetISellItemPrice, METH_VARARGS, nullptr},
{"MoveItem", player_MoveItem, METH_VARARGS, nullptr},
{"SendClickItemPacket", player_SendClickItemPacket, METH_VARARGS, nullptr},
{"GetName", player_GetName, METH_VARARGS, nullptr},
{"IsGameMaster", player_IsGameMaster, METH_VARARGS, nullptr},
{"GetJob", player_GetJob, METH_VARARGS, nullptr},
{"GetRace", player_GetRace, METH_VARARGS, nullptr},
{"GetPlayTime", player_GetPlayTime, METH_VARARGS, nullptr},
{"SetPlayTime", player_SetPlayTime, METH_VARARGS, nullptr},
{"IsSkillCoolTime", player_IsSkillCoolTime, METH_VARARGS, nullptr},
{"GetSkillCoolTime", player_GetSkillCoolTime, METH_VARARGS, nullptr},
{"IsSkillActive", player_IsSkillActive, METH_VARARGS, nullptr},
{"UseGuildSkill", player_UseGuildSkill, METH_VARARGS, nullptr},
{"AffectIndexToSkillIndex", player_AffectIndexToSkillIndex, METH_VARARGS, nullptr},
{"GetEXP", player_GetDWORDStatus<3 /* POINT_EXP */>, METH_VARARGS, nullptr},
{"GetConquerorEXP", player_GetDWORDStatus<212 /* POINT_CONQUEROR_EXP */>, METH_VARARGS, nullptr},
{"GetStatus", player_GetStatus, METH_VARARGS, nullptr},
{"SetStatus", player_SetStatus, METH_VARARGS, nullptr},
{"GetElk", player_GetElk, METH_VARARGS, nullptr},
{"GetMoney", player_GetMoney, METH_VARARGS, nullptr},
{"GetGuildID", player_GetGuildID, METH_VARARGS, nullptr},
{"GetGuildName", player_GetGuildName, METH_VARARGS, nullptr},
{"GetAlignmentData", player_GetAlignmentData, METH_VARARGS, nullptr},
{"RequestAddLocalQuickSlot", player_RequestAddLocalQuickSlot, METH_VARARGS, nullptr},
{"RequestAddToEmptyLocalQuickSlot", player_AddEmptyQuick, METH_VARARGS, nullptr},
{"RequestDeleteGlobalQuickSlot", player_DeleteQuick, METH_VARARGS, nullptr},
{"RequestMoveGlobalQuickSlotToLocalQuickSlot", player_MoveQuick, METH_VARARGS, nullptr},
{"RequestUseLocalQuickSlot", player_RequestUseLocalQuickSlot, METH_VARARGS, nullptr},
{"RequestUseGlobalQuickSlot", player_RequestUseGlobalQuickSlot, METH_VARARGS, nullptr},
{"RequestAddGlobalQuickSlot", player_RequestAddGlobalQuickSlot, METH_VARARGS, nullptr},
{"RequestMoveGlobalQuickSlotToGlobalQuickSlot", player_MoveQuickGlobal, METH_VARARGS, nullptr},
{"LocalQuickSlotIndexToGlobalQuickSlotIndex", player_LocalQuickIndex, METH_VARARGS, nullptr},
{"GetQuickPage", player_GetQuickPage, METH_VARARGS, nullptr},
{"SetQuickPage", player_SetQuickPage, METH_VARARGS, nullptr},
{"GetLocalQuickSlot", player_GetLocalQuickSlot, METH_VARARGS, nullptr},
{"GetGlobalQuickSlot", player_GetGlobalQuickSlot, METH_VARARGS, nullptr},
{"RemoveQuickSlotByValue", player_RemoveQuickByValue, METH_VARARGS, nullptr},
{"isItem", player_isItem, METH_VARARGS, nullptr},
{"IsEquipmentSlot", player_IsEquipmentSlot, METH_VARARGS, nullptr},
{"IsDSEquipmentSlot", player_IsDSEquipmentSlot, METH_VARARGS, nullptr},
{"IsCostumeSlot", player_IsCostumeSlot, METH_VARARGS, nullptr},
{"IsValuableItem", player_IsValuableItem, METH_VARARGS, nullptr},
{"IsOpenPrivateShop", player_IsOpenPrivateShop, METH_VARARGS, nullptr},
{"IsShiningSlot", player_IsShiningSlot, METH_VARARGS, nullptr},
{"IsBeltInventorySlot", player_IsBeltInventorySlot, METH_VARARGS, nullptr},
{"IsEquippingBelt", player_IsEquippingBelt, METH_VARARGS, nullptr},
{"IsAvailableBeltInventoryCell", player_IsAvailableBeltInventoryCell, METH_VARARGS, nullptr},
{"GetItemElementGrade", player_GetItemElementGrade, METH_VARARGS, nullptr},
{"GetItemElementAttack", player_GetItemElementAttack, METH_VARARGS, nullptr},
{"GetItemElementType", player_GetItemElementType, METH_VARARGS, nullptr},
{"GetItemElementValue", player_GetItemElementValue, METH_VARARGS, nullptr},
{"GetElements", player_GetElements, METH_VARARGS, nullptr},
{"GetItemGrade", player_GetItemGrade, METH_VARARGS, nullptr},
{"CanRefine", player_CanRefine, METH_VARARGS, nullptr},
{"CanDetach", player_CanDetach, METH_VARARGS, nullptr},
{"CanUnlock", player_CanUnlock, METH_VARARGS, nullptr},
{"CanAttachMetin", player_CanAttachMetin, METH_VARARGS, nullptr},
{"IsRefineGradeScroll", player_IsRefineGradeScroll, METH_VARARGS, nullptr},
{"ClearTarget", player_ClearTarget, METH_VARARGS, nullptr},
{"SetTarget", player_SetTarget, METH_VARARGS, nullptr},
{"OpenCharacterMenu", player_OpenCharacterMenu, METH_VARARGS, nullptr},
{"Update", player_Update, METH_VARARGS, nullptr},
{"Render", player_Render, METH_VARARGS, nullptr},
{"Clear", player_Clear, METH_VARARGS, nullptr},
{"IsCombatZoneMap", player_IsCombatZoneMap, METH_VARARGS, nullptr},
{"GetCombatZonePoints", player_GetCombatZonePoints, METH_VARARGS, nullptr},
{"IsPartyMember", player_IsPartyMember, METH_VARARGS, nullptr},
{"IsPartyLeader", player_IsPartyLeader, METH_VARARGS, nullptr},
{"IsPartyLeaderByPID", player_IsPartyLeaderByPID, METH_VARARGS, nullptr},
{"GetPartyMemberHPPercentage", player_GetPartyMemberHPPercentage, METH_VARARGS, nullptr},
{"GetPartyMemberState", player_GetPartyMemberState, METH_VARARGS, nullptr},
{"GetPartyMemberAffects", player_GetPartyMemberAffects, METH_VARARGS, nullptr},
{"RemovePartyMember", player_RemovePartyMember, METH_VARARGS, nullptr},
{"ExitParty", player_ExitParty, METH_VARARGS, nullptr},
{"GetPKMode", player_GetPKMode, METH_VARARGS, nullptr},
{"HasMobilePhoneNumber", player_HasMobilePhoneNumber, METH_VARARGS, nullptr},
{"RegisterEmotionIcon", player_RegisterEmotionIcon, METH_VARARGS, nullptr},
{"GetEmotionIconImage", player_GetEmotionIconImage, METH_VARARGS, nullptr},
{"SetWeaponAttackBonusFlag", player_SetWeaponAttackBonusFlag, METH_VARARGS, nullptr},
{"ToggleCoolTime", player_ToggleCoolTime, METH_VARARGS, nullptr},
{"ToggleLevelLimit", player_ToggleLevelLimit, METH_VARARGS, nullptr},
{"GetTargetVID", player_GetTargetVID, METH_VARARGS, nullptr},
{"SetItemData", player_SetItemData, METH_VARARGS, nullptr},
{"SetItemMetinSocket", player_SetItemMetinSocket, METH_VARARGS, nullptr},
{"SetItemAttribute", player_SetItemAttribute, METH_VARARGS, nullptr},
{"SetItemCount", player_SetItemCount, METH_VARARGS, nullptr},
{"GetItemLink", player_GetItemLink, METH_VARARGS, nullptr},
{"SlotTypeToInvenType", player_SlotTypeToInvenType, METH_VARARGS, nullptr},
{"SendDragonSoulRefine", player_SendDragonSoulRefine, METH_VARARGS, nullptr},
{"GetItemRandomAttribute", player_GetItemRandomAttribute, METH_VARARGS, nullptr},
{"CanSealItem", player_CanSealItem, METH_VARARGS, nullptr},
{"GetItemSealDate", player_GetItemSealDate, METH_VARARGS, nullptr},
{"GetItemUnSealLeftTime", player_GetItemUnSealLeftTime, METH_VARARGS, nullptr},
{"GetItemNewName", player_GetItemNewName, METH_VARARGS, nullptr},
{"GetKillLOG", player_GetKillLOG, METH_VARARGS, nullptr},
{"GetMainCharacterPart", player_GetMainCharacterPart, METH_VARARGS, nullptr},
{"GetMainCharacterShiningPart", player_GetMainCharacterShiningPart, METH_VARARGS, nullptr},
{"LoadNewRegen", player_LoadNewRegen, METH_VARARGS, nullptr},
{"GetGem", player_GetGem, METH_VARARGS, nullptr},
{"SetEventGame", player_SetEventGame, METH_VARARGS, nullptr},
{"GetEventGame", player_GetEventGame, METH_VARARGS, nullptr},
{"SetAutoHunt", player_SetAutoHunt, METH_VARARGS, nullptr},
{"IsAutoHunt", player_IsAutoHunt, METH_VARARGS, nullptr},
{"GetAutoHuntState", player_GetAutoHuntState, METH_VARARGS, nullptr},
{"SetAutoHuntOption", player_SetAutoHuntOption, METH_VARARGS, nullptr},
{"GetAutoHuntOption", player_GetAutoHuntOption, METH_VARARGS, nullptr},
{nullptr, nullptr, 0, nullptr}
};
NetworkActorManager::SetPartyMemberQuery(IsPartyMemberByVID);
NetworkActorManager::SetNPCWearQuery([](uint32_t race, uint8_t wearIndex) {
return NonPlayerData::Instance().getNPCWear(int(race), wearIndex, CPythonBackground::Instance().GetWarpMapName());
});
NetworkActorManager::SetItemScaleQuery([](uint32_t vnum, uint32_t pos, float scale[3], float position[3]) {
ItemScaleInfo info;
if (!GetItemScale(vnum, pos, &info)) return false;
scale[0] = info.scaleX; scale[1] = info.scaleY; scale[2] = info.scaleZ;
position[0] = info.positionX; position[1] = info.positionY; position[2] = info.positionZ;
return true;
});
// CItemManager::GetItemDataPointer (vnum ranges resolve to the base row) for the model parts.
NetworkActorManager::SetItemDataQuery([](uint32_t vnum, SItemModelData* out) {
if (!vnum) return false;
auto found = s_itemMap.find(vnum);
if (found == s_itemMap.end()) {
const auto* range = s_itemProto.find(vnum);
if (!range) return false;
found = s_itemMap.find(range->vnum);
if (found == s_itemMap.end()) return false;
}
const auto& info = found->second;
out->vnum = found->first;
out->model = info.modelPath;
out->type = uint8_t(info.type);
out->subType = uint8_t(info.subType);
std::copy_n(info.values, 6, out->values);
const auto* proto = s_itemProto.find(found->first);
out->specular = proto ? float(proto->specular) / 100.0f : 0.0f;
return true;
});
NetworkActorManager::SetAffectChangeHandler(SetPlayerAffect, ResetPlayerAffect);
auto* module = Py_InitModule("player", methods);
PyModule_AddIntConstant(module, "LEVEL", 1);
PyModule_AddIntConstant(module, "CONQUEROR_LEVEL", 205);
PyModule_AddIntConstant(module, "CONQUEROR_LEVEL_STEP", 206);
PyModule_AddIntConstant(module, "SUNGMA_STR", 207);
PyModule_AddIntConstant(module, "SUNGMA_HP", 208);
PyModule_AddIntConstant(module, "SUNGMA_MOVE", 209);
PyModule_AddIntConstant(module, "SUNGMA_INMUNE", 210);
PyModule_AddIntConstant(module, "CONQUEROR_POINT", 211);
PyModule_AddIntConstant(module, "CONQUEROR_EXP", 212);
PyModule_AddIntConstant(module, "CONQUEROR_NEXT_EXP", 213);
PyModule_AddIntConstant(module, "VOICE", 2);
PyModule_AddIntConstant(module, "EXP", 3);
PyModule_AddIntConstant(module, "NEXT_EXP", 4);
PyModule_AddIntConstant(module, "HP", 5);
PyModule_AddIntConstant(module, "MAX_HP", 6);
PyModule_AddIntConstant(module, "SP", 7);
PyModule_AddIntConstant(module, "MAX_SP", 8);
PyModule_AddIntConstant(module, "STAMINA", 9);
PyModule_AddIntConstant(module, "MAX_STAMINA", 10);
PyModule_AddIntConstant(module, "ELK", 11);
PyModule_AddIntConstant(module, "ST", 12);
PyModule_AddIntConstant(module, "HT", 13);
PyModule_AddIntConstant(module, "DX", 14);
PyModule_AddIntConstant(module, "IQ", 15);
PyModule_AddIntConstant(module, "ATT_POWER", 16);
PyModule_AddIntConstant(module, "ATT_MIN", 29);
PyModule_AddIntConstant(module, "ATT_MAX", 30);
PyModule_AddIntConstant(module, "MIN_MAGIC_WEP", 202);
PyModule_AddIntConstant(module, "MAX_MAGIC_WEP", 203);
PyModule_AddIntConstant(module, "ATT_SPEED", 17);
PyModule_AddIntConstant(module, "ATT_BONUS", 95);
PyModule_AddIntConstant(module, "EVADE_RATE", 18);
PyModule_AddIntConstant(module, "MOVING_SPEED", 19);
PyModule_AddIntConstant(module, "DEF_GRADE", 20);
PyModule_AddIntConstant(module, "DEF_BONUS", 96);
PyModule_AddIntConstant(module, "CASTING_SPEED", 21);
PyModule_AddIntConstant(module, "MAG_ATT", 22);
PyModule_AddIntConstant(module, "MAG_DEF", 23);
PyModule_AddIntConstant(module, "EMPIRE_POINT", 24);
PyModule_AddIntConstant(module, "STAT", 26);
PyModule_AddIntConstant(module, "SKILL_PASSIVE", 27);
PyModule_AddIntConstant(module, "SKILL_SUPPORT", 27);
PyModule_AddIntConstant(module, "SKILL_ACTIVE", 28);
PyModule_AddIntConstant(module, "SKILL_HORSE", 113);
PyModule_AddIntConstant(module, "PLAYTIME", 31);
PyModule_AddIntConstant(module, "BOW_DISTANCE", 34);
PyModule_AddIntConstant(module, "HP_RECOVERY", 35);
PyModule_AddIntConstant(module, "SP_RECOVERY", 36);
PyModule_AddIntConstant(module, "ATTACKER_BONUS", 91);
PyModule_AddIntConstant(module, "MAX_NUM", 255);
PyModule_AddIntConstant(module, "POINT_CRITICAL_PCT", 40);
PyModule_AddIntConstant(module, "POINT_PENETRATE_PCT", 41);
PyModule_AddIntConstant(module, "POINT_MALL_ATTBONUS", 114);
PyModule_AddIntConstant(module, "POINT_MALL_DEFBONUS", 115);
PyModule_AddIntConstant(module, "POINT_MALL_EXPBONUS", 116);
PyModule_AddIntConstant(module, "POINT_MALL_ITEMBONUS", 117);
PyModule_AddIntConstant(module, "POINT_MALL_GOLDBONUS", 118);
PyModule_AddIntConstant(module, "POINT_MAX_HP_PCT", 119);
PyModule_AddIntConstant(module, "POINT_MAX_SP_PCT", 120);
PyModule_AddIntConstant(module, "POINT_SKILL_DAMAGE_BONUS", 121);
PyModule_AddIntConstant(module, "POINT_NORMAL_HIT_DAMAGE_BONUS", 122);
PyModule_AddIntConstant(module, "POINT_SKILL_DEFEND_BONUS", 123);
PyModule_AddIntConstant(module, "POINT_NORMAL_HIT_DEFEND_BONUS", 124);
PyModule_AddIntConstant(module, "POINT_PC_BANG_EXP_BONUS", 125);
PyModule_AddIntConstant(module, "POINT_PC_BANG_DROP_BONUS", 126);
PyModule_AddIntConstant(module, "ENERGY", 128);
PyModule_AddIntConstant(module, "ENERGY_END_TIME", 129);
PyModule_AddIntConstant(module, "SKILL_GRADE_NORMAL", 0);
PyModule_AddIntConstant(module, "SKILL_GRADE_MASTER", 1);
PyModule_AddIntConstant(module, "SKILL_GRADE_GRAND_MASTER", 2);
PyModule_AddIntConstant(module, "SKILL_GRADE_PERFECT_MASTER", 3);
PyModule_AddIntConstant(module, "CATEGORY_ACTIVE", 1);
PyModule_AddIntConstant(module, "CATEGORY_PASSIVE", 2);
PyModule_AddIntConstant(module, "INVENTORY_PAGE_COLUMN", 5);
PyModule_AddIntConstant(module, "INVENTORY_PAGE_ROW", 9);
PyModule_AddIntConstant(module, "INVENTORY_PAGE_SIZE", 45);
PyModule_AddIntConstant(module, "INVENTORY_PAGE_COUNT", 4);
PyModule_AddIntConstant(module, "INVENTORY_SLOT_COUNT", 262);
PyModule_AddIntConstant(module, "EQUIPMENT_SLOT_START", 180);
PyModule_AddIntConstant(module, "EQUIPMENT_PAGE_COUNT", 12);
PyModule_AddIntConstant(module, "NEW_EQUIPMENT_SLOT_START", 202);
PyModule_AddIntConstant(module, "NEW_EQUIPMENT_SLOT_COUNT", 10);
PyModule_AddIntConstant(module, "MBF_SKILL", 4);
PyModule_AddIntConstant(module, "MBF_ATTACK", 3);
PyModule_AddIntConstant(module, "MBF_CAMERA", 2);
PyModule_AddIntConstant(module, "MBF_SMART", 0);
PyModule_AddIntConstant(module, "MBF_MOVE", 1);
PyModule_AddIntConstant(module, "MBF_AUTO", 5);
PyModule_AddIntConstant(module, "MBS_PRESS", 1);
PyModule_AddIntConstant(module, "MBS_CLICK", 0);
PyModule_AddIntConstant(module, "MBT_RIGHT", 1);
PyModule_AddIntConstant(module, "MBT_LEFT", 0);
PyModule_AddIntConstant(module, "ON_TOP_WND_NONE", 0);
PyModule_AddIntConstant(module, "ON_TOP_WND_SHOP", 1);
PyModule_AddIntConstant(module, "ON_TOP_WND_EXCHANGE", 2);
PyModule_AddIntConstant(module, "ON_TOP_WND_SAFEBOX", 3);
PyModule_AddIntConstant(module, "ON_TOP_WND_PRIVATE_SHOP", 4);
PyModule_AddIntConstant(module, "ON_TOP_WND_ITEM_COMB", 5);
PyModule_AddIntConstant(module, "ON_TOP_WND_PET_FEED", 6);
PyModule_AddIntConstant(module, "ON_TOP_WND_ATTR_67", 7);
PyModule_AddIntConstant(module, "SLOT_TYPE_NONE", 0);
PyModule_AddIntConstant(module, "SLOT_TYPE_INVENTORY", 1);
PyModule_AddIntConstant(module, "SLOT_TYPE_SKILL", 2);
PyModule_AddIntConstant(module, "SLOT_TYPE_SHOP", 4);
PyModule_AddIntConstant(module, "SLOT_TYPE_EXCHANGE_OWNER", 5);
PyModule_AddIntConstant(module, "SLOT_TYPE_EXCHANGE_TARGET", 6);
PyModule_AddIntConstant(module, "SLOT_TYPE_QUICK_SLOT", 7);
PyModule_AddIntConstant(module, "SLOT_TYPE_SAFEBOX", 8);
PyModule_AddIntConstant(module, "SLOT_TYPE_PRIVATE_SHOP", 9);
PyModule_AddIntConstant(module, "SLOT_TYPE_MALL", 10);
PyModule_AddIntConstant(module, "SLOT_TYPE_EMOTION", 3);
PyModule_AddIntConstant(module, "SLOT_TYPE_DRAGON_SOUL_INVENTORY", 11);
PyModule_AddIntConstant(module, "RESERVED_WINDOW", 0);
PyModule_AddIntConstant(module, "INVENTORY", 1);
PyModule_AddIntConstant(module, "EQUIPMENT", 2);
PyModule_AddIntConstant(module, "SAFEBOX", 3);
PyModule_AddIntConstant(module, "MALL", 4);
PyModule_AddIntConstant(module, "DRAGON_SOUL_INVENTORY", 5);
PyModule_AddIntConstant(module, "GROUND", 13);
PyModule_AddIntConstant(module, "SWITCHBOT", 11);
PyModule_AddIntConstant(module, "SLOT_TYPE_SWITCHBOT", 17);
PyModule_AddIntConstant(module, "CHANGE_EQUIP", 12);
PyModule_AddIntConstant(module, "SLOT_TYPE_CHANGE_EQUIP", 18);
PyModule_AddIntConstant(module, "CHANGE_EQUIP_SLOT_START", 208);
PyModule_AddIntConstant(module, "CHANGE_EQUIP_SLOT_COUNT", 102);
PyModule_AddIntConstant(module, "CHANGE_EQUIP_PAGE_EXTRA", 3);
PyModule_AddIntConstant(module, "ITEM_MONEY", -1);
PyModule_AddIntConstant(module, "SKILL_SLOT_COUNT", 255);
PyModule_AddIntConstant(module, "EFFECT_PICK", 0);
PyModule_AddIntConstant(module, "METIN_SOCKET_TYPE_NONE", 0);
PyModule_AddIntConstant(module, "METIN_SOCKET_TYPE_SILVER", 1);
PyModule_AddIntConstant(module, "METIN_SOCKET_TYPE_GOLD", 2);
PyModule_AddIntConstant(module, "METIN_SOCKET_MAX_NUM", 8);
PyModule_AddIntConstant(module, "ATTRIBUTE_SLOT_NORM_NUM", 5);
PyModule_AddIntConstant(module, "ATTRIBUTE_SLOT_RARE_NUM", 2);
PyModule_AddIntConstant(module, "ATTRIBUTE_SLOT_NORM_START", 0);
PyModule_AddIntConstant(module, "ATTRIBUTE_SLOT_NORM_END", 5);
PyModule_AddIntConstant(module, "ATTRIBUTE_SLOT_RARE_START", 5);
PyModule_AddIntConstant(module, "ATTRIBUTE_SLOT_RARE_END", 7);
PyModule_AddIntConstant(module, "ATTRIBUTE_SLOT_MAX_NUM", 15);
PyModule_AddIntConstant(module, "REFINE_CANT", 0);
PyModule_AddIntConstant(module, "REFINE_OK", 1);
PyModule_AddIntConstant(module, "REFINE_ALREADY_MAX_SOCKET_COUNT", 2);
PyModule_AddIntConstant(module, "REFINE_NEED_MORE_GOOD_SCROLL", 3);
PyModule_AddIntConstant(module, "REFINE_CANT_MAKE_SOCKET_ITEM", 4);
PyModule_AddIntConstant(module, "REFINE_NOT_NEXT_GRADE_ITEM", 5);
PyModule_AddIntConstant(module, "REFINE_CANT_REFINE_METIN_TO_EQUIPMENT", 6);
PyModule_AddIntConstant(module, "REFINE_CANT_REFINE_ROD", 7);
PyModule_AddIntConstant(module, "ATTACH_METIN_CANT", 0);
PyModule_AddIntConstant(module, "ATTACH_METIN_OK", 1);
PyModule_AddIntConstant(module, "ATTACH_METIN_NOT_MATCHABLE_ITEM", 2);
PyModule_AddIntConstant(module, "ATTACH_METIN_NO_MATCHABLE_SOCKET", 3);
PyModule_AddIntConstant(module, "ATTACH_METIN_NOT_EXIST_GOLD_SOCKET", 4);
PyModule_AddIntConstant(module, "ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT", 5);
PyModule_AddIntConstant(module, "DETACH_METIN_CANT", 0);
PyModule_AddIntConstant(module, "DETACH_METIN_OK", 1);
PyModule_AddIntConstant(module, "PARTY_STATE_NORMAL", 0);
PyModule_AddIntConstant(module, "PARTY_STATE_LEADER", 1);
PyModule_AddIntConstant(module, "PARTY_STATE_ATTACKER", 2);
PyModule_AddIntConstant(module, "PARTY_STATE_TANKER", 3);
PyModule_AddIntConstant(module, "PARTY_STATE_BUFFER", 4);
PyModule_AddIntConstant(module, "PARTY_STATE_SKILL_MASTER", 5);
PyModule_AddIntConstant(module, "PARTY_STATE_BERSERKER", 6);
PyModule_AddIntConstant(module, "PARTY_STATE_DEFENDER", 7);
PyModule_AddIntConstant(module, "PARTY_STATE_MAX_NUM", 8);
PyModule_AddIntConstant(module, "SKILL_INDEX_TONGSOL", 121);
PyModule_AddIntConstant(module, "SKILL_INDEX_FISHING", 123);
PyModule_AddIntConstant(module, "SKILL_INDEX_MINING", 124);
PyModule_AddIntConstant(module, "SKILL_INDEX_MAKING", 125);
PyModule_AddIntConstant(module, "SKILL_INDEX_COMBO", 122);
PyModule_AddIntConstant(module, "SKILL_INDEX_LANGUAGE1", 126);
PyModule_AddIntConstant(module, "SKILL_INDEX_LANGUAGE2", 127);
PyModule_AddIntConstant(module, "SKILL_INDEX_LANGUAGE3", 128);
PyModule_AddIntConstant(module, "SKILL_INDEX_POLYMORPH", 129);
PyModule_AddIntConstant(module, "SKILL_INDEX_RIDING", 130);
PyModule_AddIntConstant(module, "SKILL_INDEX_SUMMON", 131);
PyModule_AddIntConstant(module, "PK_MODE_PEACE", 0);
PyModule_AddIntConstant(module, "PK_MODE_REVENGE", 1);
PyModule_AddIntConstant(module, "PK_MODE_FREE", 2);
PyModule_AddIntConstant(module, "PK_MODE_PROTECT", 3);
PyModule_AddIntConstant(module, "PK_MODE_GUILD", 4);
PyModule_AddIntConstant(module, "PK_MODE_MAX_NUM", 5);
PyModule_AddIntConstant(module, "BLOCK_EXCHANGE", 1);
PyModule_AddIntConstant(module, "BLOCK_PARTY", 2);
PyModule_AddIntConstant(module, "BLOCK_GUILD", 4);
PyModule_AddIntConstant(module, "BLOCK_WHISPER", 8);
PyModule_AddIntConstant(module, "BLOCK_FRIEND", 16);
PyModule_AddIntConstant(module, "BLOCK_PARTY_REQUEST", 32);
PyModule_AddIntConstant(module, "PARTY_EXP_NON_DISTRIBUTION", 0);
PyModule_AddIntConstant(module, "PARTY_EXP_DISTRIBUTION_PARITY", 1);
PyModule_AddIntConstant(module, "EMOTION_CLAP", 1);
PyModule_AddIntConstant(module, "EMOTION_CHEERS_1", 2);
PyModule_AddIntConstant(module, "EMOTION_CHEERS_2", 3);
PyModule_AddIntConstant(module, "EMOTION_DANCE_1", 4);
PyModule_AddIntConstant(module, "EMOTION_DANCE_2", 5);
PyModule_AddIntConstant(module, "EMOTION_DANCE_3", 6);
PyModule_AddIntConstant(module, "EMOTION_DANCE_4", 7);
PyModule_AddIntConstant(module, "EMOTION_DANCE_5", 8);
PyModule_AddIntConstant(module, "EMOTION_DANCE_6", 9);
PyModule_AddIntConstant(module, "EMOTION_CONGRATULATION", 10);
PyModule_AddIntConstant(module, "EMOTION_FORGIVE", 11);
PyModule_AddIntConstant(module, "EMOTION_ANGRY", 12);
PyModule_AddIntConstant(module, "EMOTION_ATTRACTIVE", 13);
PyModule_AddIntConstant(module, "EMOTION_SAD", 14);
PyModule_AddIntConstant(module, "EMOTION_SHY", 15);
PyModule_AddIntConstant(module, "EMOTION_CHEERUP", 16);
PyModule_AddIntConstant(module, "EMOTION_BANTER", 17);
PyModule_AddIntConstant(module, "EMOTION_JOY", 18);
PyModule_AddIntConstant(module, "EMOTION_KISS", 51);
PyModule_AddIntConstant(module, "EMOTION_FRENCH_KISS", 52);
PyModule_AddIntConstant(module, "EMOTION_SLAP", 53);
PyModule_AddIntConstant(module, "AUTO_POTION_TYPE_HP", 0);
PyModule_AddIntConstant(module, "AUTO_POTION_TYPE_SP", 1);
PyModule_AddIntConstant(module, "DRAGON_SOUL_PAGE_SIZE", 32);
PyModule_AddIntConstant(module, "DRAGON_SOUL_PAGE_COUNT", 6);
PyModule_AddIntConstant(module, "DRAGON_SOUL_SLOT_COUNT", 1152);
PyModule_AddIntConstant(module, "DRAGON_SOUL_EQUIPMENT_SLOT_START", 216);
PyModule_AddIntConstant(module, "DRAGON_SOUL_EQUIPMENT_PAGE_COUNT", 2);
PyModule_AddIntConstant(module, "DRAGON_SOUL_EQUIPMENT_FIRST_SIZE", 6);
PyModule_AddIntConstant(module, "DRAGON_SOUL_REFINE_CLOSE", 1);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_DO_UPGRADE", 2);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_DO_IMPROVEMENT", 3);
PyModule_AddIntConstant(module, "DS_SUB_HEADER_DO_REFINE", 4);
PyModule_AddIntConstant(module, "REVIVE_TYPE_HERE", 0);
PyModule_AddIntConstant(module, "REVIVE_TYPE_TOWN", 1);
PyModule_AddIntConstant(module, "REVIVE_TYPE_AUTO_TOWN", 2);
PyModule_AddIntConstant(module, "REVIVE_TYPE_MAX", 3);
PyModule_AddIntConstant(module, "AUTOMATIC_PICK_UP_ACTIVATE", 1);
PyModule_AddIntConstant(module, "SLOT_TYPE_UPGRADE_INVENTORY", 12);
PyModule_AddIntConstant(module, "SLOT_TYPE_BOOK_INVENTORY", 13);
PyModule_AddIntConstant(module, "SLOT_TYPE_STONE_INVENTORY", 14);
PyModule_AddIntConstant(module, "SLOT_TYPE_CHANGE_INVENTORY", 15);
PyModule_AddIntConstant(module, "SLOT_TYPE_COSTUME_INVENTORY", 16);
PyModule_AddIntConstant(module, "UPGRADE_INVENTORY", 6);
PyModule_AddIntConstant(module, "BOOK_INVENTORY", 7);
PyModule_AddIntConstant(module, "STONE_INVENTORY", 8);
PyModule_AddIntConstant(module, "CHANGE_INVENTORY", 9);
PyModule_AddIntConstant(module, "COSTUME_INVENTORY", 10);
PyModule_AddIntConstant(module, "SPECIAL_PAGE_SIZE", 45);
PyModule_AddIntConstant(module, "SPECIAL_PAGE_COUNT", 4);
PyModule_AddIntConstant(module, "SPECIAL_SLOT_COUNT", 180);
PyModule_AddIntConstant(module, "MISSION_NONE", 0);
PyModule_AddIntConstant(module, "MISSION_BOSS", 1);
PyModule_AddIntConstant(module, "MISSION_CATCH_FISH", 2);
PyModule_AddIntConstant(module, "MISSION_CRAFT_ITEM", 3);
PyModule_AddIntConstant(module, "MISSION_CRAFT_GAYA", 4);
PyModule_AddIntConstant(module, "MISSION_DESTROY_ITEM", 5);
PyModule_AddIntConstant(module, "MISSION_DUNGEON", 6);
PyModule_AddIntConstant(module, "MISSION_EARN_MONEY", 7);
PyModule_AddIntConstant(module, "MISSION_FEED_PET", 8);
PyModule_AddIntConstant(module, "MISSION_LEVEL_UP", 9);
PyModule_AddIntConstant(module, "MISSION_MOUNT_TIME", 11);
PyModule_AddIntConstant(module, "MISSION_OPEN_OFFLINESHOP", 12);
PyModule_AddIntConstant(module, "MISSION_PLAYTIME", 13);
PyModule_AddIntConstant(module, "MISSION_REFINE_ITEM", 14);
PyModule_AddIntConstant(module, "MISSION_REFINE_ALCHEMY", 15);
PyModule_AddIntConstant(module, "MISSION_SASH", 16);
PyModule_AddIntConstant(module, "MISSION_SELL_ITEM", 17);
PyModule_AddIntConstant(module, "MISSION_SPEND_MONEY", 18);
PyModule_AddIntConstant(module, "MISSION_SPRITE_STONE", 19);
PyModule_AddIntConstant(module, "MISSION_STONE", 20);
PyModule_AddIntConstant(module, "MISSION_USE_EMOTICON", 21);
PyModule_AddIntConstant(module, "MISSION_WHISPER", 22);
PyModule_AddIntConstant(module, "MISSION_SHOUT_CHAT", 23);
PyModule_AddIntConstant(module, "MISSION_KILLPLAYER", 24);
PyModule_AddIntConstant(module, "MISSION_MONSTER", 10);
PyModule_AddIntConstant(module, "BONUS_EVENT", 1);
PyModule_AddIntConstant(module, "DOUBLE_BOSS_LOOT_EVENT", 2);
PyModule_AddIntConstant(module, "DOUBLE_METIN_LOOT_EVENT", 3);
PyModule_AddIntConstant(module, "DOUBLE_MISSION_BOOK_EVENT", 4);
PyModule_AddIntConstant(module, "DUNGEON_COOLDOWN_EVENT", 5);
PyModule_AddIntConstant(module, "DUNGEON_TICKET_LOOT_EVENT", 6);
PyModule_AddIntConstant(module, "EMPIRE_WAR_EVENT", 7);
PyModule_AddIntConstant(module, "MOONLIGHT_EVENT", 8);
PyModule_AddIntConstant(module, "TOURNAMENT_EVENT", 9);
PyModule_AddIntConstant(module, "WHELL_OF_FORTUNE_EVENT", 10);
PyModule_AddIntConstant(module, "HALLOWEEN_EVENT", 11);
PyModule_AddIntConstant(module, "NPC_SEARCH_EVENT", 12);
PyModule_AddIntConstant(module, "EXP_EVENT", 13);
PyModule_AddIntConstant(module, "ITEM_DROP_EVENT", 14);
PyModule_AddIntConstant(module, "YANG_DROP_EVENT", 15);
PyModule_AddIntConstant(module, "CARD_EVENT", 16);
PyModule_AddIntConstant(module, "CATCH_KING_EVENT", 17);
PyModule_AddIntConstant(module, "TREASURE_KEY", 18);
PyModule_AddIntConstant(module, "BEGGINER_EVENT", 19);
PyModule_AddIntConstant(module, "METIN_SOCKET_MAX_NUM_EX", 5);
PyModule_AddIntConstant(module, "KILL_SHINSO", 0);
PyModule_AddIntConstant(module, "KILL_JINNO", 1);
PyModule_AddIntConstant(module, "KILL_CHUNJO", 2);
PyModule_AddIntConstant(module, "KILL_ALLPLAYER", 3);
PyModule_AddIntConstant(module, "KILL_DUELWON", 4);
PyModule_AddIntConstant(module, "KILL_DUELLOST", 5);
PyModule_AddIntConstant(module, "KILL_MONSTER", 6);
PyModule_AddIntConstant(module, "KILL_METINSTONE", 7);
PyModule_AddIntConstant(module, "KILL_BOSSES", 8);
PyModule_AddIntConstant(module, "GEM", 240);
// Element Spell Worldard
PyModule_AddIntConstant(module, "ATT_ELEMENTS", 180);
PyModule_AddIntConstant(module, "ELEMENT_UPGRADE_CANT_ADD", 0);
PyModule_AddIntConstant(module, "ELEMENT_UPGRADE_ADD", 1);
PyModule_AddIntConstant(module, "ELEMENT_DOWNGRADE_CANT_ADD", 2);
PyModule_AddIntConstant(module, "ELEMENT_DOWNGRADE_ADD", 3);
PyModule_AddIntConstant(module, "ELEMENT_CHANGE_CANT_ADD", 4);
PyModule_AddIntConstant(module, "ELEMENT_CHANGE_ADD", 5);
PyModule_AddIntConstant(module, "ELEMENT_CANT_WORLDARD", 6);
PyModule_AddIntConstant(module, "MAX_ELEMENTS_SPELL", 3);
// Refine Features
PyModule_AddIntConstant(module, "REFINE_PERCENTAGE_LOW", 5);
PyModule_AddIntConstant(module, "REFINE_PERCENTAGE_MEDIUM", 10);
PyModule_AddIntConstant(module, "REFINE_PERCENTAGE_EXTRA", 15);
PyModule_AddIntConstant(module, "REFINE_VNUM_POTION_LOW", 56001);
PyModule_AddIntConstant(module, "REFINE_VNUM_POTION_MEDIUM", 56002);
PyModule_AddIntConstant(module, "REFINE_VNUM_POTION_EXTRA", 56003);
}
// initChat: src/python_chat.cpp (CPythonChat / CWhisper port).
static PyObject* snd_PlaySound(PyObject*, PyObject* args) {
char* filename = nullptr;
if (!PyArg_ParseTuple(args, "s", &filename) || !filename) Py_RETURN_NONE;
SoundManager::Instance().PlaySound2D(filename);
Py_RETURN_NONE;
}
static PyObject* snd_PlaySound3D(PyObject*, PyObject* args) {
float x = 0.0f, y = 0.0f, z = 0.0f;
char* filename = nullptr;
int playCount = 1;
if (PyArg_ParseTuple(args, "fffs|i", &x, &y, &z, &filename, &playCount) && filename) {
SoundManager::Instance().PlaySound3D(x, y, z, filename, playCount);
}
Py_RETURN_NONE;
}
static PyObject* snd_PlayMusic(PyObject*, PyObject* args) {
char* filename = nullptr;
if (PyArg_ParseTuple(args, "s", &filename) && filename) {
SoundManager::Instance().PlayMusic(filename);
}
Py_RETURN_NONE;
}
static PyObject* snd_FadeInMusic(PyObject*, PyObject* args) {
char* filename = nullptr;
float speed = 0.016f;
if (PyArg_ParseTuple(args, "s|f", &filename, &speed) && filename) {
SoundManager::Instance().FadeInMusic(filename, speed);
}
Py_RETURN_NONE;
}
static PyObject* snd_FadeOutMusic(PyObject*, PyObject* args) {
char* filename = nullptr;
float speed = 0.016f;
if (PyArg_ParseTuple(args, "s|f", &filename, &speed) && filename) {
SoundManager::Instance().FadeOutMusic(filename, speed);
}
Py_RETURN_NONE;
}
static PyObject* snd_FadeOutAllMusic(PyObject*, PyObject*) {
SoundManager::Instance().FadeOutAllMusic();
Py_RETURN_NONE;
}
static PyObject* snd_FadeLimitOutMusic(PyObject*, PyObject* args) {
char* filename = nullptr;
float limit = 0.0f;
float speed = 0.016f;
if (PyArg_ParseTuple(args, "sf|f", &filename, &limit, &speed) && filename) {
SoundManager::Instance().FadeLimitOutMusic(filename, limit, speed);
}
Py_RETURN_NONE;
}
static PyObject* snd_StopAllSound(PyObject*, PyObject*) {
SoundManager::Instance().StopAllSound3D();
Py_RETURN_NONE;
}
static PyObject* snd_SetMusicVolume(PyObject*, PyObject* args) {
float vol = 0.0f;
if (PyArg_ParseTuple(args, "f", &vol)) {
SoundManager::Instance().SetMusicVolume(vol);
} else {
int iVol = 0;
PyErr_Clear();
if (PyArg_ParseTuple(args, "i", &iVol)) {
SoundManager::Instance().SetMusicVolumeGrade(iVol);
}
}
Py_RETURN_NONE;
}
static PyObject* snd_SetSoundVolumef(PyObject*, PyObject* args) {
float vol = 0.0f;
if (PyArg_ParseTuple(args, "f", &vol)) {
SoundManager::Instance().SetSoundVolumeRatio(vol);
}
Py_RETURN_NONE;
}
static PyObject* snd_SetSoundVolume(PyObject*, PyObject* args) {
int grade = 0;
if (PyArg_ParseTuple(args, "i", &grade)) {
SoundManager::Instance().SetSoundVolumeGrade(grade);
} else {
float fVol = 0.0f;
PyErr_Clear();
if (PyArg_ParseTuple(args, "f", &fVol)) {
SoundManager::Instance().SetSoundVolume(fVol);
}
}
Py_RETURN_NONE;
}
static PyObject* snd_SetSoundScale(PyObject*, PyObject* args) {
float scale = 200.0f;
if (PyArg_ParseTuple(args, "f", &scale)) {
SoundManager::Instance().SetSoundScale(scale);
}
Py_RETURN_NONE;
}
static PyObject* snd_SetAmbienceSoundScale(PyObject*, PyObject* args) {
float scale = 1000.0f;
if (PyArg_ParseTuple(args, "f", &scale)) {
SoundManager::Instance().SetAmbienceSoundScale(scale);
}
Py_RETURN_NONE;
}
void initsnd() {
static PyMethodDef methods[] = {
{"PlaySound", snd_PlaySound, METH_VARARGS, nullptr},
{"PlaySound3D", snd_PlaySound3D, METH_VARARGS, nullptr},
{"PlayMusic", snd_PlayMusic, METH_VARARGS, nullptr},
{"FadeInMusic", snd_FadeInMusic, METH_VARARGS, nullptr},
{"FadeOutMusic", snd_FadeOutMusic, METH_VARARGS, nullptr},
{"FadeOutAllMusic", snd_FadeOutAllMusic, METH_VARARGS, nullptr},
{"FadeLimitOutMusic", snd_FadeLimitOutMusic, METH_VARARGS, nullptr},
{"StopAllSound", snd_StopAllSound, METH_VARARGS, nullptr},
{"SetMusicVolumef", snd_SetMusicVolume, METH_VARARGS, nullptr},
{"SetMusicVolume", snd_SetMusicVolume, METH_VARARGS, nullptr},
{"SetSoundVolumef", snd_SetSoundVolumef, METH_VARARGS, nullptr},
{"SetSoundVolume", snd_SetSoundVolume, METH_VARARGS, nullptr},
{"SetSoundScale", snd_SetSoundScale, METH_VARARGS, nullptr},
{"SetAmbienceSoundScale", snd_SetAmbienceSoundScale, METH_VARARGS, nullptr},
{nullptr, nullptr, 0, nullptr}
};
Py_InitModule("snd", methods);
}
} // namespace ava2