563 lines
13 KiB
C++
563 lines
13 KiB
C++
#include "stdafx.h"
|
|
#include "../eterPack/EterPackManager.h"
|
|
#include "pythonnonplayer.h"
|
|
#include "InstanceBase.h"
|
|
#include "PythonCharacterManager.h"
|
|
|
|
#ifdef ENABLE_WIKI
|
|
#include "PythonWiki.h"
|
|
#endif
|
|
|
|
bool CPythonNonPlayer::LoadNonPlayerData(const char * c_szFileName)
|
|
{
|
|
static DWORD s_adwMobProtoKey[4] =
|
|
{
|
|
4813894,
|
|
18955,
|
|
552631,
|
|
6822045
|
|
};
|
|
|
|
CMappedFile file;
|
|
LPCVOID pvData;
|
|
|
|
Tracef("CPythonNonPlayer::LoadNonPlayerData: %s, sizeof(TMobTable)=%u\n", c_szFileName, sizeof(TMobTable));
|
|
|
|
if (!CEterPackManager::Instance().Get(file, c_szFileName, &pvData))
|
|
return false;
|
|
|
|
DWORD dwFourCC, dwElements, dwDataSize;
|
|
|
|
file.Read(&dwFourCC, sizeof(DWORD));
|
|
|
|
if (dwFourCC != MAKEFOURCC('M', 'M', 'P', 'T'))
|
|
{
|
|
TraceError("CPythonNonPlayer::LoadNonPlayerData: invalid Mob 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_adwMobProtoKey))
|
|
{
|
|
delete [] pbData;
|
|
return false;
|
|
}
|
|
|
|
DWORD structSize = zObj.GetSize() / dwElements;
|
|
DWORD structDiff = zObj.GetSize() % dwElements;
|
|
#ifdef ENABLE_PROTOSTRUCT_AUTODETECT
|
|
if (structDiff!=0 && !CPythonNonPlayer::TMobTableAll::IsValidStruct(structSize))
|
|
#else
|
|
if ((zObj.GetSize() % sizeof(TMobTable)) != 0)
|
|
#endif
|
|
{
|
|
TraceError("CPythonNonPlayer::LoadNonPlayerData: invalid size %u check data format. structSize %u, structDiff %u", zObj.GetSize(), structSize, structDiff);
|
|
return false;
|
|
}
|
|
|
|
for (DWORD i = 0; i < dwElements; ++i)
|
|
{
|
|
#ifdef ENABLE_PROTOSTRUCT_AUTODETECT
|
|
CPythonNonPlayer::TMobTable t = {0};
|
|
CPythonNonPlayer::TMobTableAll::Process(zObj.GetBuffer(), structSize, i, t);
|
|
#else
|
|
CPythonNonPlayer::TMobTable & t = *((CPythonNonPlayer::TMobTable *) zObj.GetBuffer() + i);
|
|
#endif
|
|
TMobTable * pTable = &t;
|
|
|
|
TMobTable * pNonPlayerData = new TMobTable;
|
|
memcpy(pNonPlayerData, pTable, sizeof(TMobTable));
|
|
#ifdef ENABLE_WIKI
|
|
CPythonWiki::Instance().LoadMonster(pNonPlayerData);
|
|
#endif
|
|
//TraceError("%d : %s type[%d] color[%d]", pNonPlayerData->dwVnum, pNonPlayerData->szLocaleName, pNonPlayerData->bType, pNonPlayerData->dwMonsterColor);
|
|
m_NonPlayerDataMap.insert(TNonPlayerDataMap::value_type(pNonPlayerData->dwVnum, pNonPlayerData));
|
|
}
|
|
#ifdef ENABLE_WIKI
|
|
CPythonWiki::Instance().ListReverse();
|
|
#endif
|
|
delete [] pbData;
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNonPlayer::GetName(DWORD dwVnum, const char ** c_pszName)
|
|
{
|
|
const TMobTable * p = GetTable(dwVnum);
|
|
|
|
if (!p)
|
|
return false;
|
|
|
|
*c_pszName = p->szLocaleName;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNonPlayer::GetInstanceType(DWORD dwVnum, BYTE* pbType)
|
|
{
|
|
const TMobTable * p = GetTable(dwVnum);
|
|
|
|
// dwVnum를 찾을 수 없으면 플레이어 캐릭터로 간주 한다. 문제성 코드 -_- [cronan]
|
|
if (!p)
|
|
return false;
|
|
|
|
*pbType=p->bType;
|
|
|
|
return true;
|
|
}
|
|
|
|
const CPythonNonPlayer::TMobTable * CPythonNonPlayer::GetTable(DWORD dwVnum)
|
|
{
|
|
TNonPlayerDataMap::iterator itor = m_NonPlayerDataMap.find(dwVnum);
|
|
|
|
if (itor == m_NonPlayerDataMap.end())
|
|
return NULL;
|
|
|
|
return itor->second;
|
|
}
|
|
|
|
BYTE CPythonNonPlayer::GetEventType(DWORD dwVnum)
|
|
{
|
|
const TMobTable * p = GetTable(dwVnum);
|
|
|
|
if (!p)
|
|
{
|
|
//Tracef("CPythonNonPlayer::GetEventType - Failed to find virtual number\n");
|
|
return ON_CLICK_EVENT_NONE;
|
|
}
|
|
|
|
return p->bOnClickType;
|
|
}
|
|
|
|
#if defined(WJ_SHOW_MOB_INFO) && defined(ENABLE_SHOW_MOBLEVEL) && !defined(ENABLE_SEND_TARGET_INFO)
|
|
DWORD CPythonNonPlayer::GetMonsterLevel(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
return c_pTable->bLevel;
|
|
}
|
|
#endif
|
|
|
|
#if defined(WJ_SHOW_MOB_INFO) && defined(ENABLE_SHOW_MOBAIFLAG)
|
|
bool CPythonNonPlayer::IsAggressive(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
return (IS_SET(c_pTable->dwAIFlag, AIFLAG_AGGRESSIVE));
|
|
}
|
|
#endif
|
|
|
|
BYTE CPythonNonPlayer::GetEventTypeByVID(DWORD dwVID)
|
|
{
|
|
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(dwVID);
|
|
|
|
if (NULL == pInstance)
|
|
{
|
|
//Tracef("CPythonNonPlayer::GetEventTypeByVID - There is no Virtual Number\n");
|
|
return ON_CLICK_EVENT_NONE;
|
|
}
|
|
|
|
WORD dwVnum = pInstance->GetVirtualNumber();
|
|
return GetEventType(dwVnum);
|
|
}
|
|
|
|
const char* CPythonNonPlayer::GetMonsterName(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
static const char* sc_szEmpty="";
|
|
return sc_szEmpty;
|
|
}
|
|
|
|
return c_pTable->szLocaleName;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterColor(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
return c_pTable->dwMonsterColor;
|
|
}
|
|
#ifdef ENABLE_SEND_TARGET_INFO
|
|
DWORD CPythonNonPlayer::GetMonsterMaxHP(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD dwMaxHP = 0;
|
|
return dwMaxHP;
|
|
}
|
|
|
|
return c_pTable->dwMaxHP;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterRaceFlag(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD dwRaceFlag = 0;
|
|
return dwRaceFlag;
|
|
}
|
|
|
|
return c_pTable->dwRaceFlag;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterLevel(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD level = 0;
|
|
return level;
|
|
}
|
|
|
|
return c_pTable->bLevel;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterDamage1(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD range = 0;
|
|
return range;
|
|
}
|
|
|
|
return c_pTable->dwDamageRange[0];
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterDamage2(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD range = 0;
|
|
return range;
|
|
}
|
|
|
|
return c_pTable->dwDamageRange[1];
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterExp(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD dwExp = 0;
|
|
return dwExp;
|
|
}
|
|
|
|
return c_pTable->dwExp;
|
|
}
|
|
|
|
float CPythonNonPlayer::GetMonsterDamageMultiply(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD fDamMultiply = 0;
|
|
return fDamMultiply;
|
|
}
|
|
|
|
return c_pTable->fDamMultiply;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterST(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD bStr = 0;
|
|
return bStr;
|
|
}
|
|
|
|
return c_pTable->bStr;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMonsterDX(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
DWORD bDex = 0;
|
|
return bDex;
|
|
}
|
|
|
|
return c_pTable->bDex;
|
|
}
|
|
|
|
bool CPythonNonPlayer::IsMonsterStone(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable * c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return c_pTable->bType == 2;
|
|
}
|
|
#endif
|
|
BYTE CPythonNonPlayer::GetMobRegenCycle(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
return c_pTable->bRegenCycle;
|
|
}
|
|
|
|
BYTE CPythonNonPlayer::GetMobRegenPercent(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
return c_pTable->bRegenPercent;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMobGoldMin(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
return c_pTable->dwGoldMin;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMobGoldMax(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
return c_pTable->dwGoldMax;
|
|
}
|
|
|
|
DWORD CPythonNonPlayer::GetMobResist(DWORD dwVnum, BYTE bResistNum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
|
|
if (bResistNum >= MOB_RESISTS_MAX_NUM)
|
|
return 0;
|
|
|
|
return c_pTable->cResists[bResistNum];
|
|
}
|
|
void CPythonNonPlayer::GetMatchableMobList(int iLevel, int iInterval, TMobTableList * pMobTableList)
|
|
{
|
|
/*
|
|
pMobTableList->clear();
|
|
|
|
TNonPlayerDataMap::iterator itor = m_NonPlayerDataMap.begin();
|
|
for (; itor != m_NonPlayerDataMap.end(); ++itor)
|
|
{
|
|
TMobTable * pMobTable = itor->second;
|
|
|
|
int iLowerLevelLimit = iLevel-iInterval;
|
|
int iUpperLevelLimit = iLevel+iInterval;
|
|
|
|
if ((pMobTable->abLevelRange[0] >= iLowerLevelLimit && pMobTable->abLevelRange[0] <= iUpperLevelLimit) ||
|
|
(pMobTable->abLevelRange[1] >= iLowerLevelLimit && pMobTable->abLevelRange[1] <= iUpperLevelLimit))
|
|
{
|
|
pMobTableList->push_back(pMobTable);
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
void CPythonNonPlayer::Clear()
|
|
{
|
|
}
|
|
|
|
#ifdef ENABLE_MOB_SCALE_SYSTEM
|
|
bool CPythonNonPlayer::LoadMobScale(const char * c_szFileName)
|
|
{
|
|
const VOID* pvData;
|
|
CMappedFile kFile;
|
|
if (!CEterPackManager::Instance().Get(kFile, c_szFileName, &pvData))
|
|
return false;
|
|
|
|
CMemoryTextFileLoader kTextFileLoader;
|
|
kTextFileLoader.Bind(kFile.Size(), pvData);
|
|
|
|
CTokenVector kTokenVector;
|
|
for (DWORD i = 0; i < kTextFileLoader.GetLineCount(); ++i)
|
|
{
|
|
if (!kTextFileLoader.SplitLineByTab(i, &kTokenVector))
|
|
continue;
|
|
|
|
if (kTokenVector.size() < 4)
|
|
{
|
|
TraceError("LoadMobScale: invalid line %d (%s).", i, c_szFileName);
|
|
continue;
|
|
}
|
|
|
|
DWORD dwMobNum = atoi(kTokenVector[MOBSCALETABLE_MOB_NUM].c_str());
|
|
float fx = atof(kTokenVector[MOBSCALETABLE_X].c_str());
|
|
float fy = atof(kTokenVector[MOBSCALETABLE_Y].c_str());
|
|
float fz = atof(kTokenVector[MOBSCALETABLE_Z].c_str());
|
|
|
|
TMobScaleTable * pMobScale = new TMobScaleTable;
|
|
pMobScale->dwMobNum = dwMobNum;
|
|
pMobScale->fx = fx;
|
|
pMobScale->fy = fy;
|
|
pMobScale->fz = fz;
|
|
|
|
m_NonMobScaleDataMap.insert(TNonMobScaleDataMap::value_type(dwMobNum, pMobScale));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
const CPythonNonPlayer::TMobScaleTable * CPythonNonPlayer::GetScaleTable(DWORD dwVnum)
|
|
{
|
|
TNonMobScaleDataMap::iterator itor = m_NonMobScaleDataMap.find(dwVnum);
|
|
|
|
if (itor == m_NonMobScaleDataMap.end())
|
|
return NULL;
|
|
|
|
return itor->second;
|
|
}
|
|
|
|
bool CPythonNonPlayer::GetScale(DWORD dwVnum, float & fx, float & fy, float & fz)
|
|
{
|
|
const CPythonNonPlayer::TMobScaleTable * c_pTable = GetScaleTable(dwVnum);
|
|
if (!c_pTable)
|
|
{
|
|
fx = 1.0f;
|
|
fy = 1.0f;
|
|
fz = 1.0f;
|
|
}
|
|
else
|
|
{
|
|
fx = c_pTable->fx;
|
|
fy = c_pTable->fy;
|
|
fz = c_pTable->fz;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
void CPythonNonPlayer::Destroy()
|
|
{
|
|
for (TNonPlayerDataMap::iterator itor=m_NonPlayerDataMap.begin(); itor!=m_NonPlayerDataMap.end(); ++itor)
|
|
{
|
|
delete itor->second;
|
|
}
|
|
m_NonPlayerDataMap.clear();
|
|
}
|
|
|
|
CPythonNonPlayer::CPythonNonPlayer()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
CPythonNonPlayer::~CPythonNonPlayer(void)
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
#ifdef ENABLE_WIKI
|
|
DWORD CPythonNonPlayer::GetMonsterPrice1(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
return c_pTable->dwGoldMin;
|
|
}
|
|
DWORD CPythonNonPlayer::GetMonsterPrice2(DWORD dwVnum)
|
|
{
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
return c_pTable->dwGoldMax;
|
|
}
|
|
char CPythonNonPlayer::GetMonsterResist(DWORD dwVnum, BYTE byResist)
|
|
{
|
|
if (byResist >= MOB_RESISTS_MAX_NUM)
|
|
return 0;
|
|
const CPythonNonPlayer::TMobTable* c_pTable = GetTable(dwVnum);
|
|
if (!c_pTable)
|
|
return 0;
|
|
return c_pTable->cResists[byResist];
|
|
}
|
|
#endif
|
|
|
|
#ifdef ENABLE_NPC_WEAR_ITEM
|
|
#include "PythonBackground.h"
|
|
bool CPythonNonPlayer::LoadNPCWear(const char* szNPCWearFile)
|
|
{
|
|
m_mapnpcWear.clear();
|
|
CMappedFile File;
|
|
LPCVOID pData;
|
|
if (!CEterPackManager::Instance().Get(File, szNPCWearFile, &pData))
|
|
return false;
|
|
CMemoryTextFileLoader textFileLoader;
|
|
textFileLoader.Bind(File.Size(), pData);
|
|
CTokenVector TokenVector;
|
|
for (DWORD i = 0; i < textFileLoader.GetLineCount(); ++i)
|
|
{
|
|
if (!textFileLoader.SplitLine(i, &TokenVector, "\t"))
|
|
continue;
|
|
else if (TokenVector.size() != NPC_WEAR_MAX+2)
|
|
continue;
|
|
const DWORD npcVnum = atoi(TokenVector[0].c_str());
|
|
std::vector<int> m_vec;
|
|
m_vec.resize(NPC_WEAR_MAX);
|
|
for (BYTE i = 0; i < NPC_WEAR_MAX; ++i)
|
|
m_vec[i] = atoi(TokenVector[i+2].c_str());
|
|
if (m_vec[NPC_WEAR_RACE] > 7)
|
|
continue;
|
|
auto it = m_mapnpcWear.find(TokenVector[1].c_str());
|
|
if (it != m_mapnpcWear.end())
|
|
it->second.emplace(npcVnum, m_vec);
|
|
else
|
|
{
|
|
std::map<DWORD, std::vector<int>> m_map;
|
|
m_map.emplace(npcVnum, m_vec);
|
|
m_mapnpcWear.emplace(TokenVector[1].c_str(), m_map);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
int CPythonNonPlayer::GetNPCWear(const int raceIndex, const BYTE wearIndex)
|
|
{
|
|
if (wearIndex >= NPC_WEAR_MAX)
|
|
return -1;
|
|
CPythonBackground& rkBG = CPythonBackground::Instance();
|
|
const auto itSpecial = m_mapnpcWear.find(rkBG.GetWarpMapName());
|
|
if (itSpecial != m_mapnpcWear.end())
|
|
{
|
|
auto itEx = itSpecial->second.find(raceIndex);
|
|
if (itEx != itSpecial->second.end())
|
|
return itEx->second[wearIndex];
|
|
}
|
|
const auto itAll = m_mapnpcWear.find("all");
|
|
if (itAll != m_mapnpcWear.end())
|
|
{
|
|
auto itEx = itAll->second.find(raceIndex);
|
|
if (itEx != itAll->second.end())
|
|
return itEx->second[wearIndex];
|
|
}
|
|
return -1;
|
|
}
|
|
#endif
|
|
|