1393 lines
35 KiB
C++
1393 lines
35 KiB
C++
#include "StdAfx.h"
|
|
|
|
#ifdef ENABLE_WIKI
|
|
#include "PythonWiki.h"
|
|
#include "PythonNetworkStream.h"
|
|
#include "PythonPlayer.h"
|
|
#include "../GameLib/ItemManager.h"
|
|
#include <map>
|
|
#include "../eterPack/EterPackManager.h"
|
|
|
|
bool printLocalDatainSysser = false;
|
|
|
|
CPythonWiki::~CPythonWiki(){Destroy();}
|
|
CPythonWiki::CPythonWiki(){Destroy();}
|
|
|
|
void CPythonWiki::Destroy()
|
|
{
|
|
auto it = m_vecRefineTable.begin();
|
|
while (it != m_vecRefineTable.end())
|
|
{
|
|
delete it->second;
|
|
it = m_vecRefineTable.erase(it);
|
|
}
|
|
m_vecRefineTable.clear();
|
|
}
|
|
|
|
|
|
constexpr DWORD bossChests[][2] = {
|
|
{50070,691},
|
|
{50071,791},
|
|
{50073,2091},
|
|
{50076,2191},
|
|
{50079,2206},
|
|
{50078,1304},
|
|
{50077,1901},
|
|
{51115,4140},
|
|
};
|
|
|
|
constexpr DWORD dangeonChests[][2] = {
|
|
{50082,1093},
|
|
{80030,2092},
|
|
{50186,2598},
|
|
{51110,6091},
|
|
{51111,6191},
|
|
{54705,6812},
|
|
{51116,6231},
|
|
// {51117,6231},
|
|
};
|
|
|
|
constexpr DWORD otherChests[][2] = {
|
|
{77904,0},
|
|
{77910,0},
|
|
{77911,0},
|
|
{77912,0},
|
|
{77901,0},
|
|
{77902,0},
|
|
{77903,0},
|
|
};
|
|
|
|
constexpr DWORD eventChests[][2] = {
|
|
{50011,0},
|
|
{77916,0},
|
|
{50928,0},
|
|
{50929,0},
|
|
{50930,0},
|
|
{50275,0},
|
|
{50276,0},
|
|
{50277,0},
|
|
};
|
|
|
|
constexpr DWORD eventBoss[] = {
|
|
1093,
|
|
2493
|
|
};
|
|
|
|
const std::map<BYTE, std::vector<DWORD>> m_CostumeData = {
|
|
|
|
{0, //Weapon
|
|
{
|
|
40101,
|
|
40102,
|
|
40103,
|
|
40104,
|
|
40105,
|
|
40106,
|
|
40129,
|
|
40130,
|
|
40131,
|
|
40132,
|
|
40133,
|
|
40134,
|
|
40445,
|
|
40446,
|
|
40447,
|
|
40448,
|
|
40449,
|
|
40450,
|
|
34503,
|
|
34504,
|
|
34505,
|
|
34506,
|
|
34507,
|
|
34508,
|
|
34509,
|
|
40431,
|
|
40432,
|
|
40433,
|
|
40434,
|
|
40435,
|
|
40436,
|
|
40437,
|
|
40600,
|
|
40601,
|
|
40602,
|
|
40603,
|
|
40604,
|
|
40605,
|
|
40606,
|
|
40610,
|
|
40611,
|
|
40612,
|
|
40613,
|
|
40614,
|
|
40615,
|
|
40616,
|
|
40620,
|
|
40621,
|
|
40622,
|
|
40623,
|
|
40624,
|
|
40625,
|
|
40626,
|
|
}
|
|
},
|
|
|
|
{1, //Armor
|
|
{
|
|
41120,
|
|
41122,
|
|
41121,
|
|
41119,
|
|
41003,
|
|
41004,
|
|
34500,
|
|
34501,
|
|
34044,
|
|
34045,
|
|
34090,
|
|
34091,
|
|
34092,
|
|
34093,
|
|
34094,
|
|
34095,
|
|
}
|
|
},
|
|
{2, //Hair
|
|
{
|
|
45003,
|
|
45004,
|
|
45058,
|
|
45057,
|
|
45006,
|
|
45005,
|
|
34502,
|
|
34510,
|
|
45309,
|
|
45310,
|
|
45500,
|
|
45501,
|
|
45502,
|
|
45503,
|
|
45504,
|
|
45504,
|
|
}
|
|
},
|
|
|
|
{3, //Sash
|
|
{
|
|
86008,
|
|
86014,
|
|
86018,
|
|
86024,
|
|
86044,
|
|
86048,
|
|
86054,
|
|
86058,
|
|
86004,
|
|
86028,
|
|
86034,
|
|
86038,
|
|
86064,
|
|
86065,
|
|
86066,
|
|
}
|
|
},
|
|
{4, //Shining
|
|
{
|
|
65000,
|
|
65001,
|
|
65002,
|
|
65003,
|
|
65100,
|
|
65101,
|
|
65102,
|
|
65103,
|
|
}
|
|
},
|
|
{5, //Mount
|
|
{
|
|
71124,
|
|
71502,
|
|
71505,
|
|
71508,
|
|
71511,
|
|
71243,
|
|
71261,
|
|
71262,
|
|
71247,
|
|
71253,
|
|
71252,
|
|
71246,
|
|
71255,
|
|
71254,
|
|
71248,
|
|
71249,
|
|
71236,
|
|
71235,
|
|
71234,
|
|
71233,
|
|
71230,
|
|
}
|
|
},
|
|
{6, //Pet
|
|
{
|
|
53001,
|
|
53004,
|
|
53007,
|
|
53010,
|
|
53013,
|
|
}
|
|
},
|
|
{7, //Levelable Pet
|
|
{
|
|
55701,
|
|
55703,
|
|
55704,
|
|
55702,
|
|
55707,
|
|
55705,
|
|
55706,
|
|
}
|
|
},
|
|
};
|
|
|
|
void CPythonWiki::ReadData(const char* localeFile)
|
|
{
|
|
if (!LoadRefineTable("locale/common/refine_table.txt"))
|
|
TraceError("CPythonApplication - CPythonWiki::LoadRefineTable(locale/common/refine_table.txt)");
|
|
char szItemProto[256];
|
|
snprintf(szItemProto, sizeof(szItemProto), "%s/item_proto", localeFile);
|
|
if (!LoadItemTable(szItemProto))
|
|
TraceError("CPythonWiki - LoadItemTable(%s) Error", szItemProto);
|
|
ReadSpecialDropItemFile("locale/common/special_item_group.txt");
|
|
ReadMobDropItemFile("locale/common/mob_drop_item.txt");
|
|
}
|
|
|
|
bool CPythonWiki::ReadSpecialDropItemFile(const char* c_pszFileName)
|
|
{
|
|
CTextFileLoader loader;
|
|
if (!loader.Load(c_pszFileName))
|
|
return false;
|
|
|
|
int iVnum;
|
|
std::vector<special_data> vecSpecialData;
|
|
std::string stName;
|
|
TTokenVector* pTok;
|
|
|
|
for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
|
|
{
|
|
loader.SetChildNode(i);
|
|
loader.GetCurrentNodeName(&stName);
|
|
if (!loader.GetTokenInteger("vnum", &iVnum))
|
|
{
|
|
TraceError("ReadSpecialDropItemFile:Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
|
|
loader.SetParentNode();
|
|
continue;
|
|
}
|
|
vecSpecialData.clear();
|
|
for (int k = 1; k < 256; ++k)
|
|
{
|
|
char buf[4];
|
|
snprintf(buf, sizeof(buf), "%d", k);
|
|
if (loader.GetTokenVector(buf, &pTok))
|
|
{
|
|
vecSpecialData.push_back(special_data(std::stoi(pTok->at(0)), std::stoi(pTok->at(1))));
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (vecSpecialData.size())
|
|
{
|
|
if (printLocalDatainSysser)
|
|
{
|
|
TraceError(" ");
|
|
TraceError("ChestIndex: %d", iVnum);
|
|
for (DWORD j = 0; j < vecSpecialData.size(); ++j)
|
|
TraceError("Chest Data - Index: %d ItemVnum: %d ItemCount: %d", j, vecSpecialData[j].itemVnum, vecSpecialData[j].count);
|
|
}
|
|
m_vecSpecialDrop.emplace(iVnum, vecSpecialData);
|
|
}
|
|
loader.SetParentNode();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CPythonWiki::ReadMobDropItemFile(const char* c_pszFileName)
|
|
{
|
|
CTextFileLoader loader;
|
|
if (!loader.Load(c_pszFileName))
|
|
return false;
|
|
|
|
int iVnum;
|
|
std::vector<special_data> vecSpecialData;
|
|
std::string stName;
|
|
TTokenVector* pTok;
|
|
|
|
for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
|
|
{
|
|
loader.SetChildNode(i);
|
|
loader.GetCurrentNodeName(&stName);
|
|
if (!loader.GetTokenInteger("mob", &iVnum))
|
|
{
|
|
TraceError("ReadMobDropItemFile:Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
|
|
loader.SetParentNode();
|
|
continue;
|
|
}
|
|
vecSpecialData.clear();
|
|
for (int k = 1; k < 256; ++k)
|
|
{
|
|
char buf[4];
|
|
snprintf(buf, sizeof(buf), "%d", k);
|
|
if (loader.GetTokenVector(buf, &pTok))
|
|
{
|
|
vecSpecialData.push_back(special_data(std::stoi(pTok->at(0)), std::stoi(pTok->at(1))));
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (vecSpecialData.size())
|
|
{
|
|
if (printLocalDatainSysser)
|
|
{
|
|
TraceError(" ");
|
|
TraceError("MobIndex: %d", iVnum);
|
|
for (DWORD j = 0; j < vecSpecialData.size(); ++j)
|
|
TraceError("Mob Data - Index: %d ItemVnum: %d ItemCount: %d", j, vecSpecialData[j].itemVnum, vecSpecialData[j].count);
|
|
}
|
|
m_vecMobDrop.emplace(iVnum, vecSpecialData);
|
|
}
|
|
loader.SetParentNode();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CompareLevel(character_data i, character_data j)
|
|
{
|
|
return (i.level > j.level);
|
|
}
|
|
|
|
bool CompareLevelLow(character_data i, character_data j)
|
|
{
|
|
return (i.level < j.level);
|
|
}
|
|
bool CPythonWiki::LoadItemTable(const char* c_szFileName)
|
|
{
|
|
CMappedFile file;
|
|
LPCVOID pvData;
|
|
if (!CEterPackManager::Instance().Get(file, c_szFileName, &pvData))
|
|
return false;
|
|
DWORD dwFourCC, dwElements, dwDataSize, dwVersion = 0, dwStride = 0;
|
|
DWORD s_adwItemProtoKey[4] =
|
|
{
|
|
173217,
|
|
72619434,
|
|
408587239,
|
|
27973291
|
|
};
|
|
file.Read(&dwFourCC, sizeof(DWORD));
|
|
if (dwFourCC == MAKEFOURCC('M', 'I', 'P', 'X'))
|
|
{
|
|
file.Read(&dwVersion, sizeof(DWORD));
|
|
file.Read(&dwStride, sizeof(DWORD));
|
|
if (dwVersion != 1)
|
|
{
|
|
TraceError("CPythonItem::LoadItemTable: invalid item_proto[%s] VERSION[%d]", c_szFileName, dwVersion);
|
|
return false;
|
|
}
|
|
if (dwStride != sizeof(CItemData::TItemTable))
|
|
{
|
|
TraceError("CPythonItem::LoadItemTable: invalid item_proto[%s] STRIDE[%d] != sizeof(SItemTable)",c_szFileName, dwStride, sizeof(CItemData::TItemTable));
|
|
return false;
|
|
}
|
|
}
|
|
else if (dwFourCC != MAKEFOURCC('M', 'I', 'P', 'T'))
|
|
{
|
|
TraceError("CPythonItem::LoadItemTable: invalid item proto type %s", c_szFileName);
|
|
return false;
|
|
}
|
|
file.Read(&dwElements, sizeof(DWORD));
|
|
file.Read(&dwDataSize, sizeof(DWORD));
|
|
BYTE* pbData = new BYTE[dwDataSize];
|
|
file.Read(pbData, dwDataSize);
|
|
CLZObject zObj;
|
|
if (!CLZO::Instance().Decompress(zObj, pbData, s_adwItemProtoKey))
|
|
{
|
|
delete[] pbData;
|
|
return false;
|
|
}
|
|
CItemData::TItemTable* table = (CItemData::TItemTable*)zObj.GetBuffer();
|
|
for (DWORD i = 0; i < dwElements; ++i, ++table)
|
|
CPythonWiki::Instance().LoadItem(table);
|
|
delete[] pbData;
|
|
|
|
for (DWORD j = 0; j < 4; j++)
|
|
{
|
|
std::stable_sort(m_vecWeapon[j].begin(), m_vecWeapon[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecArmor[j].begin(), m_vecArmor[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecHelmets[j].begin(), m_vecHelmets[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecShields[j].begin(), m_vecShields[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecEarrings[j].begin(), m_vecEarrings[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecBracelet[j].begin(), m_vecBracelet[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecNecklace[j].begin(), m_vecNecklace[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecShoes[j].begin(), m_vecShoes[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecBelt[j].begin(), m_vecBelt[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecTalisman[j].begin(), m_vecTalisman[j].end(), CompareLevel);
|
|
std::stable_sort(m_vecRings[j].begin(), m_vecRings[j].end(), CompareLevel);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CPythonWiki::BlackList(DWORD vnum, DWORD type, DWORD subtype)
|
|
{
|
|
// Talisman blacklist.
|
|
//if (type == CItemData::ITEM_TYPE_ARMOR && subtype == CItemData::ARMOR_PENDANT)
|
|
// return false;
|
|
|
|
switch (vnum)
|
|
{
|
|
// warrior & weapon blacklist. begin
|
|
case 529:
|
|
case 269:
|
|
case 3189:
|
|
case 329:
|
|
case 579:
|
|
case 569:
|
|
case 3239:
|
|
case 359:
|
|
case 3249:
|
|
case 1909:
|
|
case 1949:
|
|
case 709:
|
|
case 749:
|
|
case 809:
|
|
case 849:
|
|
case 909:
|
|
case 949:
|
|
case 3209:
|
|
case 3200:
|
|
case 229:
|
|
case 239:
|
|
case 3179:
|
|
// warrior & Armour blacklist. begin
|
|
case 19299:
|
|
case 21219:
|
|
// warrior & Helmets blacklist. begi
|
|
case 12949:
|
|
case 12909:
|
|
// Ninja & weapon blacklist. begin
|
|
case 1209:
|
|
case 1149:
|
|
case 539:
|
|
case 519:
|
|
case 1199:
|
|
case 2219:
|
|
case 2229:
|
|
case 1929:
|
|
case 1939:
|
|
case 729:
|
|
case 739:
|
|
case 829:
|
|
case 929:
|
|
case 939:
|
|
case 1920:
|
|
case 1930:
|
|
case 930:
|
|
case 920:
|
|
case 720:
|
|
case 730:
|
|
case 530:
|
|
case 4039:
|
|
case 1159:
|
|
case 839:
|
|
// Ninja & Armour blacklist. begin
|
|
case 19499:
|
|
// Ninja & Helmets blacklist. begi
|
|
case 12959:
|
|
case 12919:
|
|
// Shaman & weapon blacklist. begin
|
|
case 5189:
|
|
case 5179:
|
|
case 7319:
|
|
case 509:
|
|
case 5159:
|
|
case 7329:
|
|
case 1959:
|
|
case 759:
|
|
case 859:
|
|
case 869:
|
|
case 959:
|
|
case 1950:
|
|
case 950:
|
|
case 750:
|
|
case 7189:
|
|
case 5139:
|
|
case 5149:
|
|
case 7179:
|
|
case 1969:
|
|
// Shaman & Armour blacklist. begin
|
|
case 19899:
|
|
case 21279:
|
|
case 12009:
|
|
// Ninja & Helmets blacklist. begi
|
|
case 12979:
|
|
case 21239:
|
|
case 12939:
|
|
// Sura & weapon blacklist. begin
|
|
case 369:
|
|
case 349:
|
|
case 559:
|
|
case 219:
|
|
case 1919:
|
|
case 719:
|
|
case 819:
|
|
case 919:
|
|
case 190:
|
|
case 710:
|
|
case 209:
|
|
case 910:
|
|
// Sura & Armour blacklist. begin
|
|
case 19699:
|
|
case 21259:
|
|
// Sura & Helmets blacklist. begin
|
|
case 12969:
|
|
case 12929:
|
|
// Shields blacklist. begin
|
|
case 13189:
|
|
case 13159:
|
|
case 13309:
|
|
case 13219:
|
|
case 13229:
|
|
case 13239:
|
|
case 13249:
|
|
// pendientes blacklist begin
|
|
case 17309:
|
|
// brazaletes blacklist begin
|
|
case 14309:
|
|
//collares blacklist begin
|
|
case 16309:
|
|
// Belts blacklist. begin
|
|
case 18209:
|
|
case 18129:
|
|
case 18139:
|
|
case 18149:
|
|
case 18159:
|
|
// Shoes blacklist. begin
|
|
case 15469:
|
|
case 15479:
|
|
case 15249:
|
|
return false;
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
BYTE CPythonWiki::GetRefineLevel(DWORD vnum, DWORD type, DWORD subtype)
|
|
{
|
|
if (type == CItemData::ITEM_TYPE_ARMOR && subtype == CItemData::ARMOR_PENDANT)
|
|
return 200;
|
|
|
|
//Ymir new weapon and armor set!
|
|
/*
|
|
constexpr DWORD darkVnums[] = {
|
|
320,
|
|
340,
|
|
1190,
|
|
2210,
|
|
3230,
|
|
5170,
|
|
7310,
|
|
12780,
|
|
12800,
|
|
12820,
|
|
12840,
|
|
12860,
|
|
21210,
|
|
21230,
|
|
21250,
|
|
21270
|
|
};
|
|
for (UINT i = 0; i < _countof(darkVnums); i++)
|
|
{
|
|
if (vnum >= darkVnums[i] && vnum <= darkVnums[i] + 15)
|
|
return 15;
|
|
}
|
|
*/
|
|
return 9;
|
|
}
|
|
|
|
refineTable* CPythonWiki::GetRefineItem(DWORD index)
|
|
{
|
|
const auto it = m_vecRefineTable.find(index);
|
|
if (it != m_vecRefineTable.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool CPythonWiki::LoadRefineTable(const char* c_szFileName)
|
|
{
|
|
CMappedFile File;
|
|
LPCVOID pData;
|
|
if (!CEterPackManager::Instance().Get(File, c_szFileName, &pData))
|
|
return false;
|
|
|
|
CMemoryTextFileLoader textFileLoader;
|
|
textFileLoader.Bind(File.Size(), pData);
|
|
|
|
CTokenVector TokenVector;
|
|
for (DWORD i = 0; i < textFileLoader.GetLineCount(); ++i)
|
|
{
|
|
if (textFileLoader.GetLineString(i)[0] == '#')
|
|
continue;
|
|
if (!textFileLoader.SplitLine(i, &TokenVector, "\t"))
|
|
continue;
|
|
if (TokenVector.size() != 15)
|
|
{
|
|
TraceError("CPythonWiki::LoadRefineTable(%s) - StrangeLine in %d\n", c_szFileName, i);
|
|
continue;
|
|
}
|
|
refineTable* p = new refineTable;
|
|
memset(p, 0, sizeof(refineTable));
|
|
|
|
p->id = (DWORD)atoi(TokenVector[0].c_str());
|
|
p->refine_count = 0;
|
|
|
|
int row = 1;
|
|
for (DWORD j = 0; j < MAX_REFINE_ITEM;++j)
|
|
{
|
|
p->item_vnums[j] = (DWORD)atoi(TokenVector[row].c_str());
|
|
|
|
if (p->item_vnums[j] != 0){
|
|
p->refine_count = j + 1;
|
|
}
|
|
|
|
|
|
row += 1;
|
|
p->item_count[j] = (DWORD)atoi(TokenVector[row].c_str());
|
|
row += 1;
|
|
}
|
|
|
|
p->cost = (DWORD)atoi(TokenVector[11].c_str());
|
|
//p->src_num = (DWORD)atoi(TokenVector[12].c_str());
|
|
//p->result_vnum = (DWORD)atoi(TokenVector[13].c_str());
|
|
p->prob = (DWORD)atoi(TokenVector[14].c_str());
|
|
m_vecRefineTable.insert(std::make_pair(p->id, p));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool isFirstItem(DWORD itemVnum, const char* szname)
|
|
{
|
|
std::string str = szname;
|
|
//str += std::to_string(szname);
|
|
if (str.find("+0") != std::string::npos)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool isLastItem(DWORD itemVnum, const char* szname, BYTE itemType, BYTE itemSubtype)
|
|
{
|
|
std::string str = szname;
|
|
//str += std::to_string(itemVnum);
|
|
|
|
DWORD maxRefine = CPythonWiki::Instance().GetRefineLevel(itemVnum, itemType, itemSubtype);
|
|
std::string strrefine = "+";
|
|
strrefine += std::to_string(maxRefine);
|
|
//TraceError(" %s %s", str.c_str(), strrefine.c_str());
|
|
if (str.find(strrefine.c_str()) != std::string::npos)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void CPythonWiki::ListReverse()
|
|
{
|
|
for (DWORD j = 0; j < 3; j++)
|
|
{
|
|
std::stable_sort(m_vecStoneCategory[j].begin(), m_vecStoneCategory[j].end(), CompareLevelLow);
|
|
std::stable_sort(m_vecBossCategory[j].begin(), m_vecBossCategory[j].end(), CompareLevelLow);
|
|
std::stable_sort(m_vecMonsterCategory[j].begin(), m_vecMonsterCategory[j].end(), CompareLevelLow);
|
|
}
|
|
}
|
|
|
|
bool BlackListMonster(DWORD vnum)
|
|
{
|
|
//metines
|
|
if (vnum >= 8001 && vnum <= 8014)
|
|
return false;
|
|
if (vnum >= 8024 && vnum <= 8027)
|
|
return false;
|
|
if (vnum >= 8051 && vnum <= 8056)
|
|
return false;
|
|
// if (vnum >= 8469 && vnum <= 8471)
|
|
// return false;
|
|
switch (vnum)
|
|
{
|
|
//monsters
|
|
case 191:
|
|
case 192:
|
|
case 193:
|
|
case 194:
|
|
case 491:
|
|
case 492:
|
|
case 493:
|
|
case 494:
|
|
case 591:
|
|
case 691:
|
|
case 791:
|
|
case 1091:
|
|
case 1092:
|
|
case 1093:
|
|
case 2191:
|
|
case 1304:
|
|
case 2206:
|
|
case 1901:
|
|
case 1191:
|
|
case 2091:
|
|
case 2092:
|
|
case 2307:
|
|
case 2493:
|
|
case 2598:
|
|
case 3190:
|
|
case 3191:
|
|
case 3290:
|
|
case 3291:
|
|
case 3390:
|
|
case 3391:
|
|
case 3490:
|
|
case 3491:
|
|
case 3590:
|
|
case 3591:
|
|
case 3690:
|
|
case 3691:
|
|
case 3790:
|
|
case 3791:
|
|
case 3890:
|
|
case 3891:
|
|
case 6091:
|
|
case 6191:
|
|
case 9018:
|
|
case 20442:
|
|
case 533:
|
|
case 9836:
|
|
case 9838:
|
|
case 9840:
|
|
case 9842:
|
|
case 9844:
|
|
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CPythonWiki::LoadMonster(CPythonNonPlayer::TMobTable* monster)
|
|
{
|
|
if (BlackListMonster(monster->dwVnum))
|
|
return;
|
|
|
|
if (monster->bType == 0 || monster->bType == 2) // monster & stone
|
|
{
|
|
if (monster->bLevel >= 1 && monster->bLevel <= 99)
|
|
{
|
|
if (monster->bType == 2)
|
|
m_vecStoneCategory[0].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
else if (monster->bRank >= CPythonNonPlayer::MOB_RANK_BOSS)
|
|
m_vecBossCategory[0].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
else
|
|
m_vecMonsterCategory[0].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
}
|
|
else if (monster->bLevel >= 100 && monster->bLevel <= 120)
|
|
{
|
|
if (monster->bType == 2)
|
|
m_vecStoneCategory[1].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
else if (monster->bRank >= CPythonNonPlayer::MOB_RANK_BOSS)
|
|
m_vecBossCategory[1].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
else
|
|
m_vecMonsterCategory[1].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
}
|
|
else if (monster->bLevel >= 121)
|
|
{
|
|
if (monster->bType == 2)
|
|
m_vecStoneCategory[2].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
else if (monster->bRank >= CPythonNonPlayer::MOB_RANK_BOSS)
|
|
m_vecBossCategory[2].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
else
|
|
m_vecMonsterCategory[2].emplace_back(character_data(monster->dwVnum, monster->bLevel));
|
|
}
|
|
}
|
|
}
|
|
|
|
void CPythonWiki::LoadItem(CItemData::TItemTable* item)
|
|
{
|
|
constexpr BYTE flagList[CRaceData::JOB_MAX_NUM] = { CItemData::ITEM_ANTIFLAG_WARRIOR , CItemData::ITEM_ANTIFLAG_ASSASSIN ,CItemData::ITEM_ANTIFLAG_SHAMAN ,CItemData::ITEM_ANTIFLAG_SURA };
|
|
|
|
if (isLastItem(item->dwVnum, item->szLocaleName, item->bType, item->bSubType))
|
|
{
|
|
if (!BlackList(item->dwVnum, item->bType, item->bSubType))
|
|
return;
|
|
DWORD itemLevel = 0;
|
|
for (DWORD j = 0; j < CItemData::ITEM_LIMIT_MAX_NUM; j++)
|
|
{
|
|
if (item->aLimits[j].bType == CItemData::LIMIT_LEVEL)
|
|
{
|
|
itemLevel = item->aLimits[j].lValue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (item->bType == CItemData::ITEM_TYPE_WEAPON)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecWeapon[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bType == CItemData::ITEM_TYPE_ARMOR)
|
|
{
|
|
if (item->bSubType == CItemData::ARMOR_BODY)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecArmor[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bSubType == CItemData::ARMOR_HEAD)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecHelmets[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bSubType == CItemData::ARMOR_SHIELD)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecShields[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bSubType == CItemData::ARMOR_WRIST)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecBracelet[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bSubType == CItemData::ARMOR_FOOTS)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecShoes[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bSubType == CItemData::ARMOR_NECK)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecNecklace[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bSubType == CItemData::ARMOR_EAR)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecEarrings[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bSubType == CItemData::ARMOR_PENDANT)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecTalisman[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
|
|
}
|
|
else if (item->bType == CItemData::ITEM_TYPE_BELT)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecBelt[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
else if (item->bType == CItemData::ITEM_TYPE_RINGS)
|
|
{
|
|
for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
{
|
|
if (!(item->dwAntiFlags & flagList[j]))
|
|
m_vecRings[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
}
|
|
}
|
|
//else if (item->bType == CItemData::ITEM_TYPE_PENDANT)
|
|
//{
|
|
// for (BYTE j = 0; j < CRaceData::JOB_MAX_NUM; ++j)
|
|
// {
|
|
// if (!(item->dwAntiFlags & flagList[j]))
|
|
// m_vecTalisman[j].emplace_back(character_data(item->dwVnum, itemLevel));
|
|
// }
|
|
//}
|
|
}
|
|
}
|
|
|
|
PyObject* wikiGetRefineItems(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iRefineIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iRefineIndex))
|
|
return Py_BadArgument();
|
|
const auto item = CPythonWiki::Instance().GetRefineItem(iRefineIndex);
|
|
if (!item)
|
|
return Py_BuildValue("i", 0);
|
|
return Py_BuildValue("iiiiiiiiiiiiii", item->id,item->item_vnums[0], item->item_count[0],item->item_vnums[1], item->item_count[1],item->item_vnums[2], item->item_count[2],item->item_vnums[3], item->item_count[3],item->item_vnums[4], item->item_count[4],item->cost, item->prob, item->refine_count);
|
|
}
|
|
|
|
PyObject* wikiIsBlackList(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iItemVnum;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iItemVnum))
|
|
return Py_BadArgument();
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iItemVnum))
|
|
return Py_BadArgument();
|
|
int iSubtype;
|
|
if (!PyTuple_GetInteger(poArgs, 2, &iItemVnum))
|
|
return Py_BadArgument();
|
|
return Py_BuildValue("i", CPythonWiki::Instance().BlackList(iItemVnum, iType, iSubtype));
|
|
}
|
|
|
|
PyObject* wikiGetCategorySize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
int iCategoryType;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iCategoryType))
|
|
return Py_BadArgument();
|
|
if (iType >= 0 && iType <= 3)
|
|
{
|
|
if (iCategoryType == 0)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecWeapon[iType].size());
|
|
else if (iCategoryType == 1)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecArmor[iType].size());
|
|
else if (iCategoryType == 2)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecHelmets[iType].size());
|
|
else if (iCategoryType == 3)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecShields[iType].size());
|
|
else if (iCategoryType == 4)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecEarrings[iType].size());
|
|
else if (iCategoryType == 5)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecBracelet[iType].size());
|
|
else if (iCategoryType == 6)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecNecklace[iType].size());
|
|
else if (iCategoryType == 7)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecShoes[iType].size());
|
|
else if (iCategoryType == 8)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecBelt[iType].size());
|
|
else if (iCategoryType == 9)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecTalisman[iType].size());
|
|
else if (iCategoryType == 10)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecRings[iType].size());
|
|
}
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
PyObject* wikiGetCategoryData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
int iCategoryType;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iCategoryType))
|
|
return Py_BadArgument();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 2, &iIndex))
|
|
return Py_BadArgument();
|
|
if (iType >= 0 && iType <= 3)
|
|
{
|
|
if (iCategoryType == 0)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecWeapon[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 1)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecArmor[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 2)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecHelmets[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 3)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecShields[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 4)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecEarrings[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 5)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecBracelet[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 6)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecNecklace[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 7)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecShoes[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 8)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecBelt[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 9)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecTalisman[iType][iIndex].itemVnum);
|
|
else if (iCategoryType == 10)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecRings[iType][iIndex].itemVnum);
|
|
}
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
PyObject* wikiReadData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
char* locale;
|
|
if (!PyTuple_GetString(poArgs, 0, &locale))
|
|
return Py_BuildException();
|
|
CPythonWiki::Instance().ReadData(locale);
|
|
return Py_BuildNone();
|
|
}
|
|
|
|
PyObject* wikiGetRefineMaxLevel(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iItemVnum;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iItemVnum))
|
|
return Py_BuildException();
|
|
CItemManager::Instance().SelectItemData(iItemVnum);
|
|
CItemData* pItemData = CItemManager::Instance().GetSelectedItemDataPointer();
|
|
if (!pItemData)
|
|
return Py_BuildValue("i", CPythonWiki::Instance().GetRefineLevel(iItemVnum, 0, 0));
|
|
return Py_BuildValue("i", CPythonWiki::Instance().GetRefineLevel(iItemVnum, pItemData->GetType(), pItemData->GetSubType()));
|
|
}
|
|
|
|
PyObject* wikiGetChestSize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BuildException();
|
|
if (iType == 0)
|
|
return Py_BuildValue("i", _countof(bossChests));
|
|
else if (iType == 1)
|
|
return Py_BuildValue("i", _countof(dangeonChests));
|
|
else if (iType == 2)
|
|
return Py_BuildValue("i", _countof(otherChests));
|
|
else if (iType == 3)
|
|
return Py_BuildValue("i", _countof(eventChests));
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
PyObject* wikiGetChestData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BuildException();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iIndex))
|
|
return Py_BuildException();
|
|
if (iType == 0)
|
|
return Py_BuildValue("ii", bossChests[iIndex][0], bossChests[iIndex][1]);
|
|
else if (iType == 1)
|
|
return Py_BuildValue("ii", dangeonChests[iIndex][0], dangeonChests[iIndex][1]);
|
|
else if (iType == 2)
|
|
return Py_BuildValue("ii", otherChests[iIndex][0], otherChests[iIndex][1]);
|
|
else if (iType == 3)
|
|
return Py_BuildValue("ii", eventChests[iIndex][0], eventChests[iIndex][1]);
|
|
return Py_BuildValue("ii", 0,0);
|
|
}
|
|
|
|
PyObject* wikiGetSpecialInfoSize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iItemVnum;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iItemVnum))
|
|
return Py_BuildException();
|
|
const auto it = CPythonWiki::Instance().m_vecSpecialDrop.find(iItemVnum);
|
|
if (it != CPythonWiki::Instance().m_vecSpecialDrop.end())
|
|
return Py_BuildValue("i", it->second.size());
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
PyObject* wikiGetSpecialInfoData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iItemVnum;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iItemVnum))
|
|
return Py_BuildException();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iIndex))
|
|
return Py_BuildException();
|
|
const auto it = CPythonWiki::Instance().m_vecSpecialDrop.find(iItemVnum);
|
|
if (it != CPythonWiki::Instance().m_vecSpecialDrop.end())
|
|
return Py_BuildValue("ii", it->second[iIndex].itemVnum, it->second[iIndex].count);
|
|
return Py_BuildValue("ii", 0, 0);
|
|
}
|
|
|
|
PyObject* wikiGetMobInfoSize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iItemVnum;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iItemVnum))
|
|
return Py_BuildException();
|
|
const auto it = CPythonWiki::Instance().m_vecMobDrop.find(iItemVnum);
|
|
if (it != CPythonWiki::Instance().m_vecMobDrop.end())
|
|
return Py_BuildValue("i", it->second.size());
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
PyObject* wikiGetMobInfoData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iItemVnum;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iItemVnum))
|
|
return Py_BuildException();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iIndex))
|
|
return Py_BuildException();
|
|
const auto it = CPythonWiki::Instance().m_vecMobDrop.find(iItemVnum);
|
|
if (it == CPythonWiki::Instance().m_vecMobDrop.end())
|
|
return Py_BuildValue("ii",0,0);
|
|
return Py_BuildValue("ii", it->second[iIndex].itemVnum, it->second[iIndex].count);
|
|
}
|
|
|
|
PyObject* wikiGetBossSize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
if (iType == 3) // event boss
|
|
return Py_BuildValue("i", (sizeof(eventBoss) / sizeof(eventBoss[0])));
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecBossCategory[iType].size());
|
|
}
|
|
|
|
PyObject* wikiGetBossData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iIndex))
|
|
return Py_BadArgument();
|
|
if (iType == 3) // event boss
|
|
return Py_BuildValue("i", eventBoss[iIndex]);
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecBossCategory[iType][iIndex]);
|
|
}
|
|
|
|
PyObject* wikiCostumeSize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
const auto it = m_CostumeData.find(iType);
|
|
if (it != m_CostumeData.end())
|
|
return Py_BuildValue("i", it->second.size());
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
PyObject* wikiCostumeData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iIndex))
|
|
return Py_BadArgument();
|
|
const auto it = m_CostumeData.find(iType);
|
|
if (it != m_CostumeData.end())
|
|
return Py_BuildValue("i", it->second[iIndex]);
|
|
return Py_BuildValue("i", 0);
|
|
}
|
|
|
|
PyObject* wikiGetMonsterSize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecMonsterCategory[iType].size());
|
|
}
|
|
|
|
PyObject* wikiGetMonsterData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iIndex))
|
|
return Py_BadArgument();
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecMonsterCategory[iType][iIndex]);
|
|
}
|
|
|
|
PyObject* wikiGetStoneSize(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecStoneCategory[iType].size());
|
|
}
|
|
|
|
PyObject* wikiGetStoneData(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int iType;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &iType))
|
|
return Py_BadArgument();
|
|
int iIndex;
|
|
if (!PyTuple_GetInteger(poArgs, 1, &iIndex))
|
|
return Py_BadArgument();
|
|
return Py_BuildValue("i", CPythonWiki::Instance().m_vecStoneCategory[iType][iIndex]);
|
|
}
|
|
|
|
PyObject* wikiGetItemDropFromChest(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int szItemVnum = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &szItemVnum))
|
|
return Py_BadArgument();
|
|
bool szIsRefineItem = false;
|
|
if (!PyTuple_GetBoolean(poArgs, 1, &szIsRefineItem))
|
|
return Py_BadArgument();
|
|
|
|
PyObject* poList = PyList_New(0);
|
|
|
|
const BYTE refineLevel = szIsRefineItem ? CPythonWiki::Instance().GetRefineLevel(szItemVnum, 0, 0) : 0;
|
|
const auto m_vec_ItemRange = CPythonWiki::Instance().GetSpecialDrop();
|
|
|
|
for (const auto& [chestVnum, chestData] : m_vec_ItemRange)
|
|
{
|
|
if (chestData.size() > 0)
|
|
{
|
|
if (szIsRefineItem)
|
|
{
|
|
for (const auto& dataItem : chestData)
|
|
{
|
|
if (szItemVnum >= dataItem.itemVnum && szItemVnum <= dataItem.itemVnum + refineLevel)
|
|
{
|
|
const auto obj = Py_BuildValue("i", chestVnum);
|
|
PyList_Append(poList, obj);
|
|
#ifdef ENABLE_LEAK_FIX
|
|
fix_leak.push_back(obj);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (const auto& dataItem : chestData)
|
|
{
|
|
if (szItemVnum == dataItem.itemVnum)
|
|
{
|
|
const auto obj = Py_BuildValue("i", chestVnum);
|
|
PyList_Append(poList, obj);
|
|
#ifdef ENABLE_LEAK_FIX
|
|
fix_leak.push_back(obj);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
#ifdef ENABLE_LEAK_FIX
|
|
fix_leak.push_back(poList);
|
|
#endif
|
|
return Py_BuildValue("O", poList);
|
|
}
|
|
|
|
PyObject* wikiGetItemDropFromMonster(PyObject* poSelf, PyObject* poArgs)
|
|
{
|
|
int szItemVnum = 0;
|
|
if (!PyTuple_GetInteger(poArgs, 0, &szItemVnum))
|
|
return Py_BadArgument();
|
|
bool szIsRefineItem = false;
|
|
if (!PyTuple_GetBoolean(poArgs, 1, &szIsRefineItem))
|
|
return Py_BadArgument();
|
|
|
|
PyObject* poList = PyList_New(0);
|
|
const BYTE refineLevel = szIsRefineItem ? CPythonWiki::Instance().GetRefineLevel(szItemVnum, 0, 0) : 0;
|
|
const auto m_vec_ItemRange = CPythonWiki::Instance().GetMobDrop();
|
|
for (const auto& [mobVnum, mobData] : m_vec_ItemRange)
|
|
{
|
|
if (mobData.size() > 0)
|
|
{
|
|
if (szIsRefineItem)
|
|
{
|
|
for (const auto& dataItem : mobData)
|
|
{
|
|
if (szItemVnum >= dataItem.itemVnum && szItemVnum <= dataItem.itemVnum + refineLevel)
|
|
{
|
|
const auto obj = Py_BuildValue("i", mobVnum);
|
|
PyList_Append(poList, obj);
|
|
#ifdef ENABLE_LEAK_FIX
|
|
fix_leak.push_back(obj);
|
|
#endif
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (const auto& dataItem : mobData)
|
|
{
|
|
if (szItemVnum == dataItem.itemVnum)
|
|
{
|
|
const auto obj = Py_BuildValue("i", mobVnum);
|
|
PyList_Append(poList, obj);
|
|
#ifdef ENABLE_LEAK_FIX
|
|
fix_leak.push_back(obj);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#ifdef ENABLE_LEAK_FIX
|
|
fix_leak.push_back(poList);
|
|
#endif
|
|
return Py_BuildValue("O", poList);
|
|
}
|
|
|
|
void initWiki()
|
|
{
|
|
static PyMethodDef s_methods[] =
|
|
{
|
|
{ "GetRefineItems", wikiGetRefineItems, METH_VARARGS },
|
|
{ "IsBlackList", wikiIsBlackList, METH_VARARGS },
|
|
|
|
{ "GetCategorySize", wikiGetCategorySize, METH_VARARGS },
|
|
{ "GetCategoryData", wikiGetCategoryData, METH_VARARGS },
|
|
|
|
{ "GetBossSize", wikiGetBossSize, METH_VARARGS },
|
|
{ "GetBossData", wikiGetBossData, METH_VARARGS },
|
|
|
|
{ "GetMonsterSize", wikiGetMonsterSize, METH_VARARGS },
|
|
{ "GetMonsterData", wikiGetMonsterData, METH_VARARGS },
|
|
|
|
{ "GetCostumeSize", wikiCostumeSize, METH_VARARGS },
|
|
{ "GetCostumeData", wikiCostumeData, METH_VARARGS },
|
|
|
|
{ "GetStoneSize", wikiGetStoneSize, METH_VARARGS },
|
|
{ "GetStoneData", wikiGetStoneData, METH_VARARGS },
|
|
|
|
{ "GetChestSize", wikiGetChestSize, METH_VARARGS },
|
|
{ "GetChestData", wikiGetChestData, METH_VARARGS },
|
|
|
|
{ "GetSpecialInfoSize", wikiGetSpecialInfoSize, METH_VARARGS },
|
|
{ "GetSpecialInfoData", wikiGetSpecialInfoData, METH_VARARGS },
|
|
|
|
{ "GetMobInfoSize", wikiGetMobInfoSize, METH_VARARGS },
|
|
{ "GetMobInfoData", wikiGetMobInfoData, METH_VARARGS },
|
|
|
|
{ "ReadData", wikiReadData, METH_VARARGS },
|
|
|
|
{ "GetRefineMaxLevel", wikiGetRefineMaxLevel, METH_VARARGS },
|
|
|
|
{ "GetItemDropFromChest", wikiGetItemDropFromChest, METH_VARARGS },
|
|
{ "GetItemDropFromMonster", wikiGetItemDropFromMonster, METH_VARARGS },
|
|
|
|
{ NULL, NULL, NULL },
|
|
};
|
|
PyObject* poModule = Py_InitModule("wiki", s_methods);
|
|
}
|
|
#endif
|
|
|