#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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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 s_playerSkills; static std::map 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 s_playerPoints; struct PlayerQuickSlot { int type=0; int pos=0; }; static std::array 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& 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 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 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 scale{}; // CItemData::m_ScaleTable.tInfo (ENABLE_SASH_SYSTEM) }; static std::unordered_map s_itemMap; static uint32_t s_selectedItemVnum = 0; static bool s_hasSelectedItem=false; static std::array s_playerItems{}; static std::map,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 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(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(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 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(it->second.applyType),it->second.applyValue}:std::pair{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(window); const auto nativeCell=static_cast(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(data.flags)); if(field==1)return PyInt_FromLong((data.anti_flags&static_cast(mask))!=0); if(field==4)return PyInt_FromLong(std::bit_cast(data.vnum)); if(field==5)return PyInt_FromLong(std::bit_cast(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(window);const auto c=static_cast(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(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(window);const auto c=static_cast(cell); const auto actual=valid_player_item_position(w,c)?GetPlayerItemData(w,c).vnum:0; return PyInt_FromLong(static_cast(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(window);const auto c=static_cast(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(vnum))total+=item.count; } return PyInt_FromLong(std::bit_cast(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(window);const auto c=static_cast(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(window);const auto c=static_cast(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(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(window);const auto c=static_cast(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(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(window);const auto c=static_cast(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(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(window);const auto c=static_cast(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(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(window);const auto c=static_cast(cell); if((w==1||w==2)&&c>=180&&c<216)return PyInt_FromLong(6); if(!select_item_data(static_cast(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(window);slot=static_cast(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(window);slot=static_cast(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(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(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 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 affects{}; }; static std::map s_partyMembers; static std::set s_challengeInstances,s_revengeInstances,s_cantFightInstances; static std::array s_killLog{}; static void player_trace_error(const std::string& text) { std::cerr<<"[AVA2 TraceError] "<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(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=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 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 && indexm_dwRace : 0; } static uint32_t GetPlayerRaceStat() { switch (GetPlayerRace()) { case 0: /* MAIN_RACE_WARRIOR_M */ case 4: /* MAIN_RACE_WARRIOR_W */ return static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)); case 5: /* MAIN_RACE_ASSASSIN_M */ case 1: /* MAIN_RACE_ASSASSIN_W */ return static_cast(GetPlayerStatusPoint(14 /* POINT_DX */)); case 2: /* MAIN_RACE_SURA_M */ case 6: /* MAIN_RACE_SURA_W */ return static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)); case 3: /* MAIN_RACE_SHAMAN_W */ case 7: /* MAIN_RACE_SHAMAN_M */ return static_cast(GetPlayerStatusPoint(15 /* POINT_IQ */)); case 8: /* MAIN_RACE_WOLFMAN_M */ return static_cast(GetPlayerStatusPoint(14 /* POINT_DX */)); } return static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)); } static uint32_t GetHitRate() { long long dx = GetPlayerStatusPoint(14 /* POINT_DX */); long long level = GetPlayerStatusPoint(1 /* POINT_LEVEL */); long long src = (dx * 4 + level * 2) / 6; return static_cast(100 * (std::min(150LL, src) + 210) / 300); } static uint32_t GetEvadeRate() { long long dx = GetPlayerStatusPoint(14 /* POINT_DX */); return static_cast(30 * (2 * dx + 5) / (dx + 95)); } static uint32_t GetTotalAtk(uint32_t dwWeaponPower, uint32_t dwRefineBonus) { uint32_t dwLvAtk = 2 * static_cast(GetPlayerStatusPoint(1 /* POINT_LEVEL */)); uint32_t dwStAtk = (4 * static_cast(GetPlayerStatusPoint(12 /* POINT_ST */)) + 2 * GetPlayerRaceStat()) / 3; uint32_t hr = GetHitRate(); uint32_t dwWepAtk = 2 * (dwWeaponPower + dwRefineBonus); return dwLvAtk + (dwStAtk + dwWepAtk) * hr / 100; } static void UpdateBattleStatus() { s_playerPoints[0 /* POINT_NONE */] = 0; s_playerPoints[18 /* POINT_EVADE_RATE */] = GetEvadeRate(); s_playerPoints[204 /* POINT_HIT_RATE */] = GetHitRate(); s_playerPoints[200 /* POINT_MIN_WEP */] = s_dwWeaponMinPower + s_dwWeaponAddPower; s_playerPoints[201 /* POINT_MAX_WEP */] = s_dwWeaponMaxPower + s_dwWeaponAddPower; s_playerPoints[202 /* POINT_MIN_MAGIC_WEP */] = s_dwWeaponMinMagicPower + s_dwWeaponAddPower; s_playerPoints[203 /* POINT_MAX_MAGIC_WEP */] = s_dwWeaponMaxMagicPower + s_dwWeaponAddPower; 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(sashItem.alSockets[0]); auto sashMinWep = static_cast(static_cast(selectedItem->values[3] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); auto sashMaxWep = static_cast(static_cast(selectedItem->values[4] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); auto sashMinMag = static_cast(static_cast(selectedItem->values[1] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); auto sashMaxMag = static_cast(static_cast(selectedItem->values[2] + selectedItem->values[5]) * (sashAbsorbPerc / 100.0) + 0.5); s_playerPoints[200 /* POINT_MIN_WEP */] = oldMinWep + sashMinWep; s_playerPoints[201 /* POINT_MAX_WEP */] = oldMaxWep + sashMaxWep; s_playerPoints[202 /* POINT_MIN_MAGIC_WEP */] = oldMinMag + sashMinMag; s_playerPoints[203 /* POINT_MAX_MAGIC_WEP */] = oldMaxMag + sashMaxMag; s_playerPoints[29 /* POINT_MIN_ATK */] = oldMinAtt + sashMinWep; s_playerPoints[30 /* POINT_MAX_ATK */] = oldMaxAtt + sashMaxWep; } } } } void SetWeaponPower(uint32_t dwMinPower, uint32_t dwMaxPower, uint32_t dwMinMagicPower, uint32_t dwMaxMagicPower, uint32_t dwAddPower) { s_dwWeaponMinPower = dwMinPower; s_dwWeaponMaxPower = dwMaxPower; s_dwWeaponMinMagicPower = dwMinMagicPower; s_dwWeaponMaxMagicPower = dwMaxMagicPower; s_dwWeaponAddPower = dwAddPower; UpdateBattleStatus(); } void UpdateEquippedWeaponPower() { uint32_t minPower = 0; uint32_t maxPower = 0; uint32_t minMagicPower = 0; uint32_t maxMagicPower = 0; uint32_t addPower = 0; const auto weaponSlot = GetPlayerItemData(1, 184 /* c_Equipment_Weapon */); if (weaponSlot.vnum != 0) { const auto* pkWeapon = find_item_info(weaponSlot.vnum); if (pkWeapon && pkWeapon->type == 1 /* ITEM_TYPE_WEAPON */) { minPower = pkWeapon->values[3]; maxPower = pkWeapon->values[4]; minMagicPower = pkWeapon->values[1]; maxMagicPower = pkWeapon->values[2]; addPower = pkWeapon->values[5]; long rarityValue = weaponSlot.alSockets[4 /* RARITY_VALUE_INDEX */]; if (rarityValue > 0) { long rarityType = weaponSlot.alSockets[5 /* RARITY_TYPE_INDEX */]; maxPower += CPythonItem::Instance().GetRarityPoint(-2, rarityType); maxMagicPower += CPythonItem::Instance().GetRarityPoint(-1, rarityType); uint32_t rarityMaxPower = CPythonItem::Instance().GetRarityPoint(-2, rarityType) * (float(maxPower) / 100.0f); uint32_t rarityMaxMagicNumber = CPythonItem::Instance().GetRarityPoint(-1, rarityType) * (float(maxMagicPower) / 100.0f); maxPower += rarityMaxPower; maxMagicPower += rarityMaxMagicNumber; } } } SetWeaponPower(minPower, maxPower, minMagicPower, maxMagicPower, addPower); } bool HasEnoughArrow() { const auto arrowSlot = GetPlayerItemData(1, 189 /* c_Equipment_Arrow */); if (arrowSlot.vnum != 0) { const auto* pkArrow = find_item_info(arrowSlot.vnum); if (pkArrow && pkArrow->type == 1 /* ITEM_TYPE_WEAPON */) { if (pkArrow->subType == 6 /* WEAPON_ARROW */ || pkArrow->subType == 9 /* WEAPON_QUIVER */) { return true; } } } uint32_t vid = PythonNetworkStream::Instance().GetMainActorVID(); player_window_call("OnCannotShotError", Py_BuildValue("(is)", vid, "EMPTY_ARROW")); return false; } void ResetPlayerState() { 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 && cellsecond; } void SetPlayerItem(int slot,uint32_t vnum,int count) { if(slot<0 || slot>=static_cast(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> 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(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 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, METH_VARARGS, nullptr}, {"SetDropSoundFileName", item_SetSoundFileName, 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 s_autoPotionInfo; static std::map 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(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 s_eventData; bool LoadNewRegen() { s_eventData.clear(); std::string text; try { text = ReadPackedText("locale/newregen.txt"); } catch (...) { return false; } const std::string mapName = CPythonBackground::Instance().GetWarpMapName(); std::istringstream stream(text); std::string line; while (std::getline(stream, line)) { if (line.empty() || line.rfind("//", 0) == 0) continue; std::vector tokens; std::stringstream ss(line); std::string token; while (std::getline(ss, token, '\t')) { tokens.push_back(token); } if (tokens.size() != 16) continue; if (!mapName.empty() && mapName != tokens[2]) continue; TNewRegen data{}; data.x = std::strtol(tokens[3].c_str(), nullptr, 10); data.y = std::strtol(tokens[4].c_str(), nullptr, 10); data.day = static_cast(std::strtol(tokens[7].c_str(), nullptr, 10)); data.hour = static_cast(std::strtol(tokens[8].c_str(), nullptr, 10)); data.minute = static_cast(std::strtol(tokens[9].c_str(), nullptr, 10)); data.second = static_cast(std::strtol(tokens[10].c_str(), nullptr, 10)); data.safeRange = std::strtol(tokens[12].c_str(), nullptr, 10); if (data.safeRange == 0) continue; data.hours_range = static_cast(std::strtol(tokens[13].c_str(), nullptr, 10)); data.minute_range = static_cast(std::strtol(tokens[14].c_str(), nullptr, 10)); data.mob_vnum = static_cast(std::strtoul(tokens[15].c_str(), nullptr, 10)); data.leftTime = -1; s_eventData.push_back(data); } return true; } static int DISTANCE_APPROX_SERVER(int dx, int dy) { int min, max; if (dx < 0) dx = -dx; if (dy < 0) dy = -dy; if (dx < dy) { min = dx; max = dy; } else { min = dy; max = dx; } return (((max << 8) + (max << 3) - (max << 4) - (max << 1) + (min << 7) - (min << 5) + (min << 3) - (min << 1)) >> 8); } static void positionToGlobal(float eX, float eY, long& X, long& Y) { X = static_cast(eX) / 100; Y = static_cast(eY) / 100; long lX = X, lY = Y; CPythonBackground::Instance().LocalPositionToGlobalPosition(lX, lY); X = lX * 100; Y = lY * 100; } static void localToGlobal(long& X, long& Y) { long lX = X, lY = Y; CPythonBackground::Instance().LocalPositionToGlobalPosition(lX, lY); X = lX * 100; Y = lY * 100; } bool CheckBossSafeRange() { if (s_eventData.empty()) return false; const auto* actor = player_main_actor(); if (!actor) return false; long mainX = 0, mainY = 0; positionToGlobal(actor->m_lCurX, actor->m_lCurY, mainX, mainY); const time_t cur_Time = time(nullptr); const struct tm vKey = *localtime(&cur_Time); int myear = vKey.tm_year; int mmon = vKey.tm_mon; int mday = vKey.tm_mday; int yday = vKey.tm_yday; int day = vKey.tm_wday; int hour = vKey.tm_hour; int minute = vKey.tm_min; int second = vKey.tm_sec; for (auto& newRegen : s_eventData) { if (newRegen.day != 0) { const int curDay = vKey.tm_wday + 1; if (curDay != newRegen.day) continue; } long posGlobalX = newRegen.x, posGlobalY = newRegen.y; localToGlobal(posGlobalX, posGlobalY); int fDist = DISTANCE_APPROX_SERVER(mainX - posGlobalX, mainY - posGlobalY); if (fDist <= newRegen.safeRange) { std::vector m_Data; NetworkActorManager::Instance().GetMobWithVnum(newRegen.mob_vnum, m_Data); if (!m_Data.empty()) { for (const auto* bossInstance : m_Data) { if (bossInstance) { long bossX = 0, bossY = 0; positionToGlobal(bossInstance->m_lCurX, bossInstance->m_lCurY, bossX, bossY); fDist = DISTANCE_APPROX_SERVER(mainX - bossX, mainY - bossY); if (fDist <= newRegen.safeRange) return true; } } } else { const int nowTime = int(time(nullptr)); if (newRegen.leftTime < 0) { bool isSuccess = false; const int now = int(time(nullptr)) + 2; const uint8_t regenHour = newRegen.hour; const uint8_t regenMinute = newRegen.minute; const uint8_t regenSecond = newRegen.second; while (true) { ++second; if (second == 60) { minute += 1; second = 0; if (minute == 60) { minute = 0; hour += 1; if (hour == 24) { hour = 0; day += 1; if (day == 7) day = 0; mday += 1; yday += 1; if (mday == 32) { mday = 1; mmon += 1; if (mmon == 12) { mmon = 0; myear += 1; yday = 0; } } } } } if (second == 0) { if (newRegen.hours_range) { if ((hour % newRegen.hours_range) == 0 && regenMinute == minute) { isSuccess = true; break; } } if (newRegen.minute_range) { if ((minute % newRegen.minute_range) == 0) { isSuccess = true; break; } } } if (regenHour == hour && regenMinute == minute && regenSecond == second) { if (newRegen.day) { if (newRegen.day - 1 == day) { isSuccess = true; break; } } else { isSuccess = true; break; } } if (time(nullptr) > now) break; } if (isSuccess) { std::tm tm{}; tm.tm_year = myear; tm.tm_mon = mmon; tm.tm_mday = mday; tm.tm_isdst = 0; tm.tm_wday = day; tm.tm_hour = hour; tm.tm_min = minute; tm.tm_sec = second; tm.tm_yday = yday; const time_t t = mktime(&tm); newRegen.leftTime = int(t); if (newRegen.leftTime - nowTime >= 0 && newRegen.leftTime - nowTime <= 30) return true; } else { return false; } } else { if (newRegen.leftTime - nowTime >= 0 && newRegen.leftTime - nowTime <= 30) return true; } } } } return false; } static PyObject* player_LoadNewRegen(PyObject*, PyObject*) { LoadNewRegen(); return Py_BuildNone(); } 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 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(curX), static_cast(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, METH_VARARGS, nullptr}, {"GetSkillNextEfficientPercentage", player_GetSkillPower, 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