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>
4382 lines
206 KiB
C++
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
|
|
|