1466 lines
40 KiB
C++
1466 lines
40 KiB
C++
#include "StdAfx.h"
|
||
#include "StdItemProvider.h"
|
||
#include "../misc/caches/StdItemConfigCacher.h"
|
||
#include "../base/Container.hpp"
|
||
using namespace wylib::stream;
|
||
|
||
LPCTSTR CStdItemProvider::StdItemCacheFile = _T(
|
||
"./data/runtime/cache/StdItems.cch");
|
||
|
||
CStdItemProvider::CStdItemProvider() :
|
||
Inherited(), Inherited2(), m_DataAllocator(_T("ItemDataAlloc")), m_DeriveDataAllocator(
|
||
_T("EquipDeriveDataAlloc")), m_SmithDataAllocator(
|
||
_T("SmithDataAllocator")), m_FiveAttrDataAllocator(
|
||
_T("FiveAttrDataAllocator")), m_FiveAttrListDataAllocator(
|
||
_T("FiveAttrListDataAllocator")), m_SuitAttrDataAllocator(_T("SuitAttrDataAllocator")){
|
||
//m_pStdItemsBack = 0;
|
||
m_nItemCount = 0;
|
||
memset(m_orangeEquipAttr, 0, sizeof(m_orangeEquipAttr));
|
||
|
||
}
|
||
|
||
CStdItemProvider::~CStdItemProvider() {
|
||
}
|
||
|
||
bool CStdItemProvider::LoadStdItems(LPCTSTR sFilePath, bool bBackLoad) {
|
||
bool Result = false;
|
||
DWORD dwSrcCRC;
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
try {
|
||
if (!bBackLoad) {
|
||
#ifdef _DEBUG
|
||
if (IsDebuggerPresent())
|
||
{
|
||
if (readCacheData(-1))
|
||
{
|
||
OutputMsg(rmTip, "[StdItemProvider] StdItem data force loaded from cache. you may delete cache file to cause load from source!");
|
||
return true;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
//对配置脚本进行预处理
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
// //计算脚本文本CRC值
|
||
// dwSrcCRC = ~CRC32Update(0xFFFFFFFF, sText, (int)strlen(sText));
|
||
// //尝试从缓存文件快速读取配置数据，如果无法从缓存中读取或数据已经变更则重新加载源数据
|
||
// Result = readCacheData(dwSrcCRC, bBackLoad);
|
||
// if (Result) {
|
||
// OutputMsg(rmTip,
|
||
// "[StdItemProvider] StdItem config data loaded from cache");
|
||
// } else {
|
||
//设置脚本内容
|
||
if (!setScript(sText))
|
||
showError(_T("syntax error on StdItem config"));
|
||
FILE* fp = fopen("scripterror.txt", "wb");
|
||
if (fp)
|
||
{
|
||
fputs(sText, fp);
|
||
fclose(fp);
|
||
}
|
||
//读取标准物品配置数据
|
||
Result = readStdItems(bBackLoad);
|
||
//保存物品配置数据缓存
|
||
if (Result)
|
||
saveCacheData(dwSrcCRC);
|
||
// }
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load StdItem config error: %s"), s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on load StdItem config"));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return Result;
|
||
}
|
||
|
||
void CStdItemProvider::completeRead(CStdItem *pStdItems,
|
||
const INT_PTR nItemCount, CDataAllocator &dataAllocator,
|
||
bool bBackLoad) {
|
||
if (bBackLoad) {
|
||
m_Lock.Lock();
|
||
//m_pStdItemsBack = pStdItems;
|
||
m_ItemBack.reserve(0);
|
||
m_ItemBack.trunc(0);
|
||
m_ItemBack.addArray(pStdItems, nItemCount);
|
||
m_nItemCount = nItemCount;
|
||
m_DataAllocatorBack.~CObjectAllocator();
|
||
m_DataAllocatorBack = dataAllocator;
|
||
ZeroMemory(&dataAllocator, sizeof(dataAllocator));
|
||
m_Lock.Unlock();
|
||
return;
|
||
}
|
||
|
||
//读取物品配置完成，将临时列表中的物品数据全部拷贝到自身中
|
||
reserve(nItemCount);
|
||
trunc(0);
|
||
addArray(pStdItems, nItemCount);
|
||
//调用自身的物品属性申请器的析构函数，以便释放之前的物品属性的内存块
|
||
m_DataAllocator.~CObjectAllocator();
|
||
//将临时的物品属性申请器的内存数据拷贝到自身申请器中
|
||
m_DataAllocator = dataAllocator;
|
||
//情况临时物品属性申请器的内存数据，防止新读取的物品属性数据被销毁
|
||
ZeroMemory(&dataAllocator, sizeof(dataAllocator));
|
||
}
|
||
|
||
void CStdItemProvider::UpdateItemConfig() {
|
||
reserve(m_nItemCount);
|
||
trunc(0);
|
||
//addArray(m_pStdItemsBack, m_nItemCount);
|
||
addList(m_ItemBack);
|
||
m_DataAllocator.~CObjectAllocator();
|
||
m_DataAllocator = m_DataAllocatorBack;
|
||
|
||
//m_pStdItemsBack = 0;
|
||
m_nItemCount = 0;
|
||
ZeroMemory(&m_DataAllocatorBack, sizeof(m_DataAllocatorBack));
|
||
}
|
||
|
||
bool CStdItemProvider::readStdItems(bool bBackLoad) {
|
||
|
||
if (!openGlobalTable("StdItems"))
|
||
return false;
|
||
CBaseList<CStdItem> itemList;
|
||
//获取配置中的物品数量
|
||
const INT_PTR nItemCount = lua_objlen(m_pLua, -1) + 1;
|
||
//如果物品数量为0则输出未配置任何物品的错误
|
||
if (nItemCount <= 0)
|
||
showError(_T("no item data on StdItem config"));
|
||
//申请出物品数据并将物品数据内存块清空
|
||
itemList.reserve(nItemCount);
|
||
CStdItem *pStdItems = itemList;
|
||
ZeroMemory(pStdItems, sizeof(CStdItem) * nItemCount);
|
||
|
||
//循环读取物品配置数据
|
||
if (enumTableFirst()) {
|
||
INT_PTR nIdx = 1;
|
||
CDataAllocator dataAllocator;
|
||
do {
|
||
//读取物品配置数据
|
||
//CStdItem item = pStdItems[nIdx];
|
||
int index = getFieldInt("id");
|
||
CStdItem& item = pStdItems[index];
|
||
if(index > nItemCount)
|
||
{
|
||
showErrorFormat(_T("readItemData itemindex %d, maxCount %d"),index, nItemCount);
|
||
endTableEnum();
|
||
return false;
|
||
}
|
||
if(!readItemData(dataAllocator, item))
|
||
break;
|
||
item.m_nIndex = index;
|
||
//如果该物品的ID不是期望的值，则输出错误并终止读取
|
||
// if (item.m_nIndex != nIdx) {
|
||
// showErrorFormat(_T("unexpected itemindex %d, request %d"),
|
||
// item.m_nIndex, nIdx);
|
||
// endTableEnum();
|
||
// break;
|
||
// }
|
||
nIdx++;
|
||
} while (enumTableNext());
|
||
//完成数据读取，将读取的数据应用到自身
|
||
completeRead(pStdItems, nItemCount, dataAllocator, bBackLoad);
|
||
|
||
}
|
||
|
||
closeTable();
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
void CStdItemProvider::ReadItemForge()
|
||
{
|
||
if (!openGlobalTable("ForgeConfig"))
|
||
return;
|
||
int nDef = 0;
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
ItemForgeCfg forge;
|
||
forge.nId = getFieldInt("id", &nDef);
|
||
forge.nDropId = getFieldInt("dropid", &nDef);
|
||
forge.nLevel = getFieldInt("level", &nDef);
|
||
m_forgeList.push_back(forge);
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
|
||
if (!openGlobalTable("ForgeBaseConfig"))
|
||
return;
|
||
nForgeItemId = getFieldInt("itemID",&nDef);
|
||
nOnceForgeCost = getFieldInt("one",&nDef);
|
||
nTenForgeCost = getFieldInt("ten",&nDef);
|
||
nBagone = getFieldInt("bagone",&nDef);
|
||
nBagten = getFieldInt("bagten",&nDef);
|
||
nEquipment = getFieldInt("equipment",&nDef);
|
||
closeTable();
|
||
}
|
||
|
||
void CStdItemProvider::ReadItemCompose()
|
||
{
|
||
if (!openGlobalTable("ItemMergeConfig"))
|
||
return;
|
||
|
||
int nDef = 0;
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
ItemComposeCfg compose;
|
||
compose.nId = getFieldInt("Eid", &nDef);
|
||
compose.nLevelLimt = getFieldInt("level", &nDef);
|
||
|
||
compose.nOpenServerDay = getFieldInt("openserverday", &nDef);
|
||
compose.nArea = getFieldInt("area", &nDef);
|
||
if(feildTableExists("table") && openFieldTable("table"))
|
||
{
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
ComposeTableCfg tf;
|
||
tf.nType = getFieldInt("type");
|
||
tf.nCount = getFieldInt("count");
|
||
tf.nId = getFieldInt("id");
|
||
compose.table.push_back(tf);
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
if(feildTableExists("compose") && openFieldTable("compose"))
|
||
{
|
||
compose.composeItem.nType = getFieldInt("type");
|
||
compose.composeItem.nCount = getFieldInt("count");
|
||
compose.composeItem.nId = getFieldInt("id");
|
||
closeTable();
|
||
}
|
||
if(feildTableExists("mergelimit") && openFieldTable("mergelimit"))
|
||
{
|
||
compose.nCircle = getFieldInt("zsLevel", &nDef);
|
||
compose.nOfficeId = getFieldInt("office", &nDef);
|
||
compose.nVipLimit = getFieldInt("vip", &nDef);
|
||
compose.nGhostLevelLimit = getFieldInt("smLevel", &nDef);
|
||
closeTable();
|
||
}
|
||
|
||
m_composeList[compose.nId] = compose;
|
||
}while(enumTableNext());
|
||
}
|
||
}while(enumTableNext());
|
||
}
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
bool CStdItemProvider::readItemData(CDataAllocator &dataAllocator, CStdItem &item) {
|
||
INT_PTR nLevel;
|
||
int nDefVal = 0;
|
||
|
||
getFieldStringBuffer("name", item.m_sName, sizeof(item.m_sName));
|
||
item.m_btType = (BYTE) getFieldInt("type");
|
||
item.m_wIcon = (WORD) getFieldInt("icon");
|
||
item.m_wShape = (WORD) getFieldInt("shape", &nDefVal);
|
||
item.m_wBack = (WORD) getFieldInt("back", &nDefVal);
|
||
//item.m_dwDura = (UINT) getFieldInt("dura", &nDefVal);
|
||
double nDwDefVal = 0;
|
||
//item.m_dwUseDurDrop = (UINT) getFieldInt("useDurDrop", &nDefVal);
|
||
item.m_nCDTime = getFieldInt("cdTime", &nDefVal);
|
||
item.m_wDupCount = (WORD) getFieldInt("dup");
|
||
item.m_btColGroup = (BYTE) getFieldInt("colGroup");
|
||
if (item.m_btColGroup >= CUserBag::s_nMaxItemCDGroupCount)
|
||
return false;
|
||
|
||
item.m_btDealType = (BYTE) getFieldInt("dealType");
|
||
item.m_nPrice = getFieldInt("dealPrice");
|
||
item.m_UseTime = getFieldInt("time");
|
||
//item.m_btSmithId = (BYTE) getFieldInt("smithId", &nDefVal);
|
||
item.m_nRecoverId = getFieldInt("recoverid", &nDefVal);
|
||
item.m_wSuitID = getFieldInt("suitId", &nDefVal); //套装的ID
|
||
item.m_wResonanceId = getFieldInt("resonanceId", &nDefVal); //共鸣ID
|
||
item.b_showQuality = getFieldInt("showQuality", &nDefVal); //显示的品质
|
||
item.m_nDropBroadcast = getFieldInt("dropBroadcast", &nDefVal);
|
||
//item.w_candidateIconCount = (WORD) getFieldInt("candidateIconCount",
|
||
// &nDefVal); //获取图标
|
||
//item.b_specRing = (BYTE) getFieldInt("specRing", &nDefVal);
|
||
item.m_btBatchType = (BYTE) getFieldInt("batchType", &nDefVal);
|
||
item.m_nBatchValue = getFieldInt("batchValue", &nDefVal);
|
||
item.m_nSillId = 0;//getFieldInt("skillID2", &nDefVal);
|
||
//item.m_nConsignType = getFieldInt("consignType", &nDefVal);
|
||
item.m_DropCount = 0;
|
||
|
||
//nDefVal = -1;
|
||
//item.m_nValidFbId = getFieldInt("validFbId", &nDefVal); // 物品生效的副本ID。默认为-1
|
||
//item.m_nValidSceneId = getFieldInt("validSceneId", &nDefVal);// 物品生效的场景ID。默认为-1
|
||
|
||
item.m_nPackageType = getFieldInt("packageType");
|
||
item.m_ndropGroupid = getFieldInt("dropGroupid", &nDefVal);
|
||
item.m_nsuggVocation = getFieldInt("suggVocation",&nDefVal);
|
||
|
||
item.m_nItemlvl = getFieldInt("itemlvl",&nDefVal);
|
||
item.nRecycling = getFieldInt("recycling",&nDefVal);
|
||
item.nItemlevel = getFieldInt("itemlevel",&nDefVal);
|
||
item.nJpdrop = getFieldInt("jpdrop",&nDefVal);
|
||
item.nTips = getFieldInt("tipsid",&nDefVal);
|
||
|
||
item.m_nOpenDaylimit = getFieldInt("openDaylimit", &nDefVal);
|
||
|
||
bool boDefVal = false;
|
||
item.m_Flags.canMoveKb = (bool)getFieldInt("canMoveKb", &nDefVal);
|
||
item.m_Flags.denyDeal = (bool)getFieldInt("denyDeal", &nDefVal);
|
||
item.m_Flags.denySell = (bool)getFieldInt("denySell", &nDefVal);
|
||
item.m_Flags.denyDestroy = (bool)getFieldInt("denyDestroy", &nDefVal);
|
||
item.m_Flags.recordLog = (bool)getFieldInt("recordLog", &nDefVal);
|
||
|
||
item.m_CanUseType = 0;
|
||
item.m_CanUseCount = 0;
|
||
if (feildTableExists("UseLimit") && openFieldTable("UseLimit"))
|
||
{
|
||
item.m_CanUseType = getFieldInt("CanUseType", &nDefVal);
|
||
item.m_CanUseCount = getFieldInt("CanUseCount", &nDefVal);
|
||
closeTable();
|
||
}
|
||
|
||
if (feildTableExists("deathsplit") && openFieldTable("deathsplit")) {
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
ItemDeathSplit splt;
|
||
splt.nType = getFieldInt("type",&nDefVal);
|
||
splt.nItemId = getFieldInt("id",&nDefVal);
|
||
splt.nCount = getFieldInt("count",&nDefVal);
|
||
item.m_nDeathsplit.push_back(splt);
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
if (feildTableExists("select") && openFieldTable("select")) {
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
SelectItemInfo info;
|
||
info.nIndex = getFieldInt("index",&nDefVal);
|
||
info.m_ndropGroupid = getFieldInt("dorpid",&nDefVal);
|
||
if (feildTableExists("item") && openFieldTable("item")) {
|
||
ItemDeathSplit splt;
|
||
splt.nType = getFieldInt("type",&nDefVal);
|
||
splt.nItemId = getFieldInt("id",&nDefVal);
|
||
splt.nCount = getFieldInt("count",&nDefVal);
|
||
info.items.push_back(splt);
|
||
closeTable();
|
||
}
|
||
item.m_SelectItems.push_back(info);
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
// 读取物品可存在的场景集合
|
||
item.m_existScenes.nCount = 0;
|
||
if (feildTableExists("existScenes") && openFieldTable("existScenes")) {
|
||
INT_PTR count = lua_objlen(m_pLua, -1);
|
||
item.m_existScenes.nCount = count;
|
||
item.m_existScenes.pSceneId = (int *) dataAllocator.allocObjects(
|
||
count * sizeof(*(item.m_existScenes.pSceneId)));
|
||
INT_PTR index = 0;
|
||
if (count > 0 && enumTableFirst()) {
|
||
do {
|
||
int nSceneId = getFieldInt(NULL);
|
||
if (index < count) {
|
||
item.m_existScenes.pSceneId[index] = nSceneId;
|
||
index++;
|
||
if (nSceneId == -1) // -1表示不限制场景
|
||
{
|
||
endTableEnum();
|
||
break;
|
||
}
|
||
} else {
|
||
endTableEnum();
|
||
break;
|
||
}
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
} else {
|
||
// 默认不配置表示所有场景都能用
|
||
item.m_existScenes.nCount = 1;
|
||
item.m_existScenes.pSceneId = (int *) dataAllocator.allocObjects(
|
||
item.m_existScenes.nCount
|
||
* sizeof(*(item.m_existScenes.pSceneId)));
|
||
item.m_existScenes.pSceneId[0] = -1;
|
||
}
|
||
|
||
//读取物品静态属性
|
||
if (feildTableExists("staitcAttrs") && openFieldTable("staitcAttrs")) {
|
||
readItemAttributeTable(dataAllocator, item.m_StaticAttrs);
|
||
closeTable();
|
||
}
|
||
//读取物品品质属性
|
||
if (feildTableExists("qualityAttrs") && openFieldTable("qualityAttrs")) {
|
||
if (enumTableFirst()) {
|
||
nLevel = 0;
|
||
do {
|
||
readItemAttributeTable(dataAllocator,
|
||
item.m_QualityAttrs[nLevel]);
|
||
nLevel++;
|
||
if (nLevel >= CStdItem::MaxItemQuality) {
|
||
endTableEnum();
|
||
break;
|
||
}
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
//读取物品强化属性
|
||
if (feildTableExists("strongAttrs") && openFieldTable("strongAttrs")) {
|
||
if (enumTableFirst()) {
|
||
nLevel = 0;
|
||
do {
|
||
readItemAttributeTable(dataAllocator,
|
||
item.m_StrongAttrs[nLevel]);
|
||
nLevel++;
|
||
if (nLevel >= CStdItem::MaxItemStrong) {
|
||
endTableEnum();
|
||
break;
|
||
}
|
||
} while (enumTableNext());
|
||
//item.m_StrongCount = (BYTE) nLevel;
|
||
}
|
||
closeTable();
|
||
}
|
||
//读取物品联合属性
|
||
/*
|
||
if ( feildTableExists("unitedAttrs") && openFieldTable("unitedAttrs") )
|
||
{
|
||
item.m_UnitedAttrs.nCount = lua_objlen(m_pLua, -1);
|
||
if ( enumTableFirst() )
|
||
{
|
||
CStdItem::UnitedAttributeGroup *pUnitedGroups;
|
||
item.m_UnitedAttrs.pGroups = pUnitedGroups = (CStdItem::UnitedAttributeGroup*)dataAllocator.allocObjects(
|
||
sizeof(*pUnitedGroups) * item.m_UnitedAttrs.nCount);
|
||
do
|
||
{
|
||
//读取联合属性的联合物品表
|
||
if ( feildTableExists("items") && openFieldTable("items") )
|
||
{
|
||
readUnitedItemTable(dataAllocator, *pUnitedGroups);
|
||
closeTable();
|
||
}
|
||
//读取联合属性表
|
||
if ( feildTableExists("attrs") && openFieldTable("attrs") )
|
||
{
|
||
readItemAttributeTable(dataAllocator, *pUnitedGroups);
|
||
closeTable();
|
||
}
|
||
pUnitedGroups++;
|
||
}
|
||
while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
*/
|
||
|
||
//读取精锻随机属性
|
||
/*
|
||
if ( feildTableExists("smithAttrs") && openFieldTable("smithAttrs") )
|
||
{
|
||
item.m_SmithAttrs.nCount = lua_objlen(m_pLua, -1);
|
||
item.m_SmithAttrs.pAttrs = (PRANDOMATTRTERM)dataAllocator.allocObjects(
|
||
sizeof(*item.m_SmithAttrs.pAttrs) * item.m_SmithAttrs.nCount);
|
||
CRandAttrReader randReader;
|
||
randReader.readConfig(m_pLua, item.m_SmithAttrs.pAttrs, item.m_SmithAttrs.nCount);
|
||
closeTable();
|
||
}
|
||
*/
|
||
|
||
//读取物品标志属性
|
||
if (feildTableExists("flags") && openFieldTable("flags")) {
|
||
readItemFlags(item);
|
||
closeTable();
|
||
}
|
||
//读取物品使用条件表
|
||
if (feildTableExists("conds") && openFieldTable("conds")) {
|
||
readItemConditionTable(dataAllocator, item.m_Conditions);
|
||
closeTable();
|
||
}
|
||
//读取物品预留配置
|
||
if (feildTableExists("reserves") && openFieldTable("reserves")) {
|
||
readItemReservesTable(dataAllocator, item.m_Reserves);
|
||
closeTable();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::readItemAttributeTable(CDataAllocator &dataAllocator,
|
||
CStdItem::AttributeGroup &AttrGroup) {
|
||
PGAMEATTR pAttr;
|
||
AttrGroup.nCount = lua_objlen(m_pLua, -1);
|
||
|
||
if (enumTableFirst()) {
|
||
pAttr = AttrGroup.pAttrs = (PGAMEATTR) dataAllocator.allocObjects(
|
||
sizeof(*AttrGroup.pAttrs) * AttrGroup.nCount);
|
||
do {
|
||
// read type
|
||
pAttr->type = getFieldInt("type");
|
||
//判断物品属性类型是否有效
|
||
if (pAttr->type < aUndefined || pAttr->type >= GameAttributeCount) {
|
||
showErrorFormat(_T("item type config error %d"), pAttr->type);
|
||
}
|
||
// read value
|
||
switch (AttrDataTypes[pAttr->type]) {
|
||
case adSmall:
|
||
case adShort:
|
||
case adInt:
|
||
pAttr->value.nValue = getFieldInt("value");
|
||
break;
|
||
case adUSmall:
|
||
case adUShort:
|
||
case adUInt:
|
||
pAttr->value.uValue = (UINT) getFieldInt64("value");
|
||
break;
|
||
case adFloat:
|
||
pAttr->value.fValue = (float) getFieldNumber("value");
|
||
break;
|
||
}
|
||
pAttr++;
|
||
} while (enumTableNext());
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::readUnitedItemTable(CDataAllocator &dataAllocator,
|
||
CStdItem::UnitedAttributeGroup &unitedGroup) {
|
||
unitedGroup.nUnitedItemCount = lua_objlen(m_pLua, -1);
|
||
if (enumTableFirst()) {
|
||
PWORD pItemIds;
|
||
unitedGroup.pUnitedItemIds = pItemIds =
|
||
(PWORD) dataAllocator.allocObjects(
|
||
sizeof(*unitedGroup.pUnitedItemIds)
|
||
* unitedGroup.nUnitedItemCount);
|
||
do {
|
||
*pItemIds = getFieldInt(NULL);
|
||
pItemIds++;
|
||
} while (enumTableNext());
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
bool CStdItemProvider::readItemFlags(CStdItem &item) {
|
||
bool boDefVal = false;
|
||
//item.m_Flags.recordLog = getFieldBoolean("recordLog", &boDefVal);
|
||
item.m_Flags.denyStorage = getFieldBoolean("denyStorage", &boDefVal);
|
||
item.m_Flags.denyGuildDepot = getFieldBoolean("denyGuildDepot", &boDefVal);
|
||
item.m_Flags.autoBindOnTake = getFieldBoolean("autoBindOnTake", &boDefVal);
|
||
item.m_Flags.autoStartTime = getFieldBoolean("autoStartTime", &boDefVal);
|
||
//item.m_Flags.denyDeal = getFieldBoolean("denyDeal", &boDefVal);
|
||
//item.m_Flags.denySell = getFieldBoolean("denySell", &boDefVal);
|
||
//item.m_Flags.denyDestroy = getFieldBoolean("denyDestroy", &boDefVal);
|
||
item.m_Flags.destroyOnOffline = getFieldBoolean("destroyOnOffline",&boDefVal);
|
||
|
||
item.m_Flags.destroyOnDie = getFieldBoolean("destroyOnDie", &boDefVal);
|
||
item.m_Flags.denyDropdown = getFieldBoolean("denyDropdown", &boDefVal);
|
||
item.m_Flags.dieDropdown = getFieldBoolean("dieDropdown", &boDefVal);
|
||
item.m_Flags.offlineDropdown = getFieldBoolean("offlineDropdown",
|
||
&boDefVal);
|
||
// //item.m_Flags.inlayable = getFieldBoolean("inlayable", &boDefVal);
|
||
// //item.m_Flags.hideDura = getFieldBoolean("hideDura", &boDefVal);
|
||
// item.m_Flags.denySplite = getFieldBoolean("denySplite", &boDefVal);
|
||
item.m_Flags.asQuestItem = getFieldBoolean("asQuestItem", &boDefVal);
|
||
// item.m_Flags.monAlwaysDropdown = getFieldBoolean("monAlwaysDropdown",
|
||
// &boDefVal);
|
||
// item.m_Flags.hideQualityName = getFieldBoolean("hideQualityName",
|
||
// &boDefVal);
|
||
// item.m_Flags.denyTipsAutoLine = getFieldBoolean("denyTipsAutoLine",
|
||
// &boDefVal);
|
||
item.m_Flags.showLootTips = getFieldBoolean("showLootTips", &boDefVal);
|
||
// item.m_Flags.denyDropDua = getFieldBoolean("denyDropDua", &boDefVal);
|
||
//item.m_Flags.denyRepair = getFieldBoolean("denyRepair", &boDefVal);
|
||
// item.m_Flags.canDig = getFieldBoolean("canDig", &boDefVal);
|
||
// item.m_Flags.fullDel = getFieldBoolean("fullDel", &boDefVal);
|
||
item.m_Flags.denyBuffOverlay = getFieldBoolean("denyBuffOverlay", &boDefVal);
|
||
// item.m_Flags.skillRemoveItem = getFieldBoolean("skillRemoveItem",
|
||
// &boDefVal);
|
||
// item.m_Flags.denyHeroUse = getFieldBoolean("denyHeroUse", &boDefVal);
|
||
item.m_Flags.matchAllSuit = getFieldBoolean("matchAllSuit", &boDefVal);
|
||
//item.m_Flags.canMoveKb = getFieldBoolean("canMoveKb", &boDefVal);
|
||
// item.m_Flags.notConsumeForCircleForge = getFieldBoolean(
|
||
// "notConsumeForCircleForge", &boDefVal);
|
||
// item.m_Flags.notShowAppear = getFieldBoolean("notShowAppear", &boDefVal);
|
||
// item.m_Flags.boDelete = getFieldBoolean("isDelete", &boDefVal);
|
||
// item.m_Flags.showdura = getFieldBoolean("showdura", &boDefVal);
|
||
// item.m_Flags.bMeltingFlag = getFieldBoolean("MeltingFlag", &boDefVal);
|
||
// item.m_Flags.bCanIdentify = getFieldBoolean("canIdentify", &boDefVal);//是否可以被鉴定，默认不可鉴定
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::readItemConditionTable(CDataAllocator &dataAllocator,
|
||
CStdItem::ItemUseCondTable &condTable) {
|
||
condTable.nCount = lua_objlen(m_pLua, -1);
|
||
if (enumTableFirst()) {
|
||
CStdItem::ItemUseCondition *pConds;
|
||
condTable.pConds = pConds =
|
||
(CStdItem::ItemUseCondition*) dataAllocator.allocObjects(
|
||
sizeof(*condTable.pConds) * condTable.nCount);
|
||
do {
|
||
pConds->btCond = getFieldInt("cond");
|
||
pConds->nValue = getFieldInt("value");
|
||
pConds++;
|
||
} while (enumTableNext());
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::readItemReservesTable(CDataAllocator &dataAllocator,
|
||
CStdItem::ItemReservesTable &table) {
|
||
table.nCount = lua_objlen(m_pLua, -1);
|
||
if (enumTableFirst()) {
|
||
CStdItem::ItemReserve *pConfigs;
|
||
table.pConfigs = pConfigs =
|
||
(CStdItem::ItemReserve*) dataAllocator.allocObjects(
|
||
sizeof(*table.pConfigs) * table.nCount);
|
||
do {
|
||
pConfigs->nValue1 = getFieldInt("value1");
|
||
pConfigs->nValue2 = getFieldInt("value2");
|
||
pConfigs++;
|
||
} while (enumTableNext());
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::readCacheData(DWORD dwSrcCRC32, bool bBackLoad) {
|
||
#ifdef _DEBUG
|
||
CStdItem *pStdItems;
|
||
INT_PTR nItemCount;
|
||
CStdItemConfigCacher cache;
|
||
CDataAllocator allocator;
|
||
|
||
if ( !cache.LoadFromCache(StdItemCacheFile, dwSrcCRC32, allocator, (void**)&pStdItems, nItemCount) )
|
||
return false;
|
||
completeRead(pStdItems, nItemCount, allocator, bBackLoad);
|
||
return true;
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
bool CStdItemProvider::saveCacheData(DWORD dwSrcCRC32) {
|
||
#ifdef _DEBUG
|
||
bool result = false;
|
||
const CStdItem *pStdItems = *this;
|
||
CStdItemConfigCacher cache;
|
||
|
||
try
|
||
{
|
||
result = cache.SaveToCache(StdItemCacheFile, dwSrcCRC32, m_DataAllocator, pStdItems, count());
|
||
if ( !result )
|
||
{
|
||
showError(_T("save StdItem config data cache failure!"));
|
||
}
|
||
}
|
||
catch (RefString &s)
|
||
{
|
||
OutputMsg(rmError, s.rawStr());
|
||
}
|
||
catch (...)
|
||
{
|
||
OutputMsg(rmError, _T("unexpected error on save StdItem config cache!"));
|
||
}
|
||
return result;
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
void CStdItemProvider::showError(LPCTSTR sError) {
|
||
m_sLastErrDesc = sError;
|
||
RefString s = _T("[StdItemProvider]");
|
||
s += sError;
|
||
throw s;
|
||
}
|
||
|
||
bool CStdItemProvider::LoadSmithData(LPCTSTR sFilePath) {
|
||
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on StdItem config"));
|
||
} else {
|
||
CDataAllocator smithDataAllocator;
|
||
Result = ReadSmithData(smithDataAllocator);
|
||
m_SmithDataAllocator.~CObjectAllocator();
|
||
m_SmithDataAllocator = smithDataAllocator;
|
||
ZeroMemory(&smithDataAllocator, sizeof(smithDataAllocator));
|
||
if (!Result) {
|
||
return false;
|
||
}
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load Item smith config error: %s"), s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on mith config config"));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
|
||
return true;
|
||
}
|
||
|
||
//读取
|
||
bool CStdItemProvider::ReadEquipDerive() {
|
||
if (!openGlobalTable("EquipDeriveConfig"))
|
||
return false;
|
||
INT_PTR nIndex = 0;
|
||
CDataAllocator deriveDataAllocator;
|
||
if (enumTableFirst()) {
|
||
do {
|
||
INT_PTR levelIndex = 0; //配置索引
|
||
if (enumTableFirst()) {
|
||
do {
|
||
int nLevel = getFieldInt("level"); //强化效果所需星星数
|
||
if (nIndex == 0) //装备强化衍生光效配置
|
||
{
|
||
int nDefVal = 0;
|
||
STARDERIVE star;
|
||
star.wStarCount = (WORD) nLevel;
|
||
star.wAppear = (WORD) getFieldInt("appear", &nDefVal);
|
||
m_starderive.add(star);
|
||
}
|
||
if (feildTableExists("prop") && openFieldTable("prop")) {
|
||
if (nIndex == 0) //装备升星的加成
|
||
{
|
||
readItemAttributeTable(deriveDataAllocator,
|
||
m_starderive[levelIndex++].attriGroup);
|
||
} else if (nIndex == 1)
|
||
{
|
||
|
||
} else if (nIndex == 2) //橙装的属性加成
|
||
{
|
||
readItemAttributeTable(deriveDataAllocator,
|
||
m_orangeEquipAttr[levelIndex++]);
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
} while (enumTableNext());
|
||
}
|
||
|
||
nIndex++;
|
||
} while (enumTableNext());
|
||
}
|
||
m_DeriveDataAllocator.~CObjectAllocator();
|
||
m_DeriveDataAllocator = deriveDataAllocator;
|
||
ZeroMemory(&deriveDataAllocator, sizeof(deriveDataAllocator));
|
||
closeTable();
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::ReadQualitdataIndex(CDataAllocator& dataAllocator) {
|
||
if (!openGlobalTable("QualityDataIndex")) {
|
||
return false;
|
||
}
|
||
//获取配置中的物品数量
|
||
const INT_PTR nCount = lua_objlen(m_pLua, -1);
|
||
//如果物品数量为0则输出未配置任何物品的错误
|
||
if (nCount <= 0)
|
||
showError(_T("no QualitdataIndex on QualityDataIndex"));
|
||
INT_PTR nListIndex = 0; //当前遍历的index
|
||
m_qualityDataIndexList.count = nCount;
|
||
m_qualityDataIndexList.pData = (DataList<int>*) dataAllocator.allocObjects(
|
||
nCount * sizeof(DataList<int> ));
|
||
if (enumTableFirst()) {
|
||
do {
|
||
|
||
DataList<int>* pIndexList = m_qualityDataIndexList.pData
|
||
+ nListIndex;
|
||
|
||
if (feildTableExists("index") && openFieldTable("index")) {
|
||
const INT_PTR nDataCount = lua_objlen(m_pLua, -1);
|
||
pIndexList->count = nDataCount;
|
||
pIndexList->pData = (int*) dataAllocator.allocObjects(nDataCount * sizeof(int));
|
||
if (enumTableFirst()) {
|
||
int nDataIndex = 0;
|
||
do{
|
||
int* pIndex = pIndexList->pData + nDataIndex;
|
||
*pIndex = getFieldInt(NULL);
|
||
nDataIndex++;
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
// const INT_PTR nDataCount = lua_objlen(m_pLua, -1);
|
||
// pIndexList->count = nDataCount;
|
||
// pIndexList->pData = (int*) dataAllocator.allocObjects(
|
||
// nDataCount * sizeof(int));
|
||
// if (enumTableFirst()) {
|
||
// int nDataIndex = 0;
|
||
|
||
// do {
|
||
// int* pIndex = pIndexList->pData + nDataIndex;
|
||
// *pIndex = getFieldInt(NULL);
|
||
// nDataIndex++;
|
||
// } while (enumTableNext());
|
||
// }
|
||
nListIndex++;
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
return true;
|
||
}
|
||
|
||
//读取极品属性的数据
|
||
bool CStdItemProvider::ReadSmithData(CDataAllocator &dataAllocator) {
|
||
if (!ReadQualitdataIndex(dataAllocator)) {
|
||
return false;
|
||
}
|
||
if (!openGlobalTable("SmithConfig"))
|
||
return false;
|
||
CBaseList<CStdItem> itemList;
|
||
|
||
//获取配置中的物品数量
|
||
const INT_PTR nSmithCount = lua_objlen(m_pLua, -1);
|
||
//如果物品数量为0则输出未配置任何物品的错误
|
||
if (nSmithCount <= 0)
|
||
showError(_T("no smith data on smith config"));
|
||
//申请出物品数据并将物品数据内存块清空
|
||
m_smithData.count = nSmithCount;
|
||
if (nSmithCount > 0) {
|
||
m_smithData.pData =
|
||
(DataList<RANDOMATTRTERM>*) dataAllocator.allocObjects(
|
||
nSmithCount * sizeof(DataList<RANDOMATTRTERM> ));
|
||
} else {
|
||
return false;
|
||
}
|
||
INT_PTR nIndex = 0; //当前遍历的index
|
||
if (enumTableFirst()) {
|
||
do {
|
||
DataList<RANDOMATTRTERM>* pSmithData = m_smithData.pData + nIndex;
|
||
const INT_PTR nItemCount = lua_objlen(m_pLua, -1);
|
||
pSmithData->count = nItemCount;
|
||
|
||
pSmithData->pData = (PRANDOMATTRTERM) dataAllocator.allocObjects(
|
||
nItemCount * sizeof(RANDOMATTRTERM));
|
||
CRandAttrReader randReader;
|
||
if (randReader.readConfig(m_pLua,
|
||
(PRANDOMATTRTERM) pSmithData->pData, dataAllocator,
|
||
nItemCount) != nItemCount) {
|
||
OutputMsg(rmError, "Read Smith%d.txt Error", nIndex);
|
||
return false;
|
||
}
|
||
nIndex++;
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
return true;
|
||
}
|
||
|
||
DataList<RANDOMATTRTERM> * CStdItemProvider::GetSmithData(int nSmithId) {
|
||
if (nSmithId == 0 || nSmithId >= m_smithData.count)
|
||
return NULL;
|
||
return m_smithData.pData + nSmithId;
|
||
}
|
||
DataList<int>* CStdItemProvider::GetQualityIndexList(int nIndex) {
|
||
if (nIndex <= 0 || nIndex > m_qualityDataIndexList.count) {
|
||
return NULL;
|
||
}
|
||
return m_qualityDataIndexList.pData + nIndex - 1;
|
||
}
|
||
bool CStdItemProvider::ReadItemEval() {
|
||
|
||
if (!openGlobalTable("EquipValuation"))
|
||
return false;
|
||
for (INT_PTR i = 0; i < enMaxVocCount - 1; i++) {
|
||
m_evals[i].reset();
|
||
}
|
||
|
||
INT_PTR i = 0;
|
||
if (enumTableFirst()) {
|
||
do {
|
||
if (enumTableFirst()) {
|
||
do {
|
||
tagGameAttribute attr;
|
||
attr.type = (BYTE) getFieldInt("attrId");
|
||
attr.value.fValue = (float) getFieldNumber("unitVal");
|
||
|
||
m_evals[i] << attr;
|
||
|
||
} while (enumTableNext());
|
||
}
|
||
|
||
i++;
|
||
} while (enumTableNext());
|
||
|
||
}
|
||
|
||
closeTable();
|
||
|
||
return true;
|
||
|
||
}
|
||
|
||
void CStdItemProvider::AddItemOutPutCount(INT_PTR wItemId, int nCount,
|
||
const INT_PTR nLogIdent) {
|
||
bool bNeedSave = false;
|
||
|
||
switch (nLogIdent) {
|
||
case GameLog::clKillMonsterItem: //杀怪获得物品
|
||
case GameLog::clBuyItem: //用户从NPC商店购买物品
|
||
case GameLog::clAchieveRewardItem: //成就奖励物品
|
||
case GameLog::clQuestGiveItem: //任务奖励物品
|
||
case GameLog::clBuyStoreItem: //购买商城物品
|
||
bNeedSave = true;
|
||
break;
|
||
|
||
default:
|
||
bNeedSave = false;
|
||
break;
|
||
}
|
||
|
||
if (!bNeedSave)
|
||
return;
|
||
|
||
if (wItemId > 0 && wItemId < Inherited::count()) {
|
||
CStdItem* stdItem = &(this->operator CStdItem*()[wItemId]);
|
||
if (stdItem) {
|
||
stdItem->m_DropCount += nCount;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CStdItemProvider::SendItemOutPutToLog() {
|
||
// for (INT_PTR i = 0; i < Inherited::count(); i++) {
|
||
// const CStdItem* pItem = &(this->operator CStdItem*()[i]);
|
||
// if (pItem && pItem->m_DropCount > 0) {
|
||
// }
|
||
// }
|
||
}
|
||
|
||
bool CStdItemProvider::LoadGodStoveConfig(LPCTSTR sFilePath) {
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on StdItem config"));
|
||
} else {
|
||
CDataAllocator dataAllocator;
|
||
Result = ReadGodStoveConfig(dataAllocator);
|
||
m_EquipPosStrongAllocator.~CObjectAllocator();
|
||
m_EquipPosStrongAllocator = dataAllocator;
|
||
ZeroMemory(&dataAllocator, sizeof(dataAllocator));
|
||
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load GodStoveStrongConfig error: %s"),
|
||
s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on GodStoveConfig "));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::ReadGodStoveConfig(CDataAllocator& dataAllocator) {
|
||
if (!openGlobalTable("GodStoveConfig")) {
|
||
return false;
|
||
}
|
||
//宝石属性衍生属性加成
|
||
if (feildTableExists("GodStoveDeriveConfig")
|
||
&& openFieldTable("GodStoveDeriveConfig")) {
|
||
//const INT_PTR count = lua_objlen(m_pLua, -1);
|
||
if ( enumTableFirst()) {
|
||
do {
|
||
GODSTOVEDERIVE derive;
|
||
derive.nLevel = getFieldInt("level");
|
||
if (feildTableExists("prop") && openFieldTable("prop")) {
|
||
readItemAttributeTable(dataAllocator, derive.attriGroup);
|
||
closeTable();
|
||
}
|
||
m_godStoveDerive.add(derive);
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
closeTable();
|
||
return true;
|
||
}
|
||
|
||
CStdItem::AttributeGroup* CStdItemProvider::GetGodStoveDeriveAttrByLevel(
|
||
INT_PTR nLevel) {
|
||
for (INT_PTR i = m_godStoveDerive.count() - 1; i >= 0; i--) {
|
||
GODSTOVEDERIVE& derive = m_godStoveDerive[i];
|
||
if (nLevel >= derive.nLevel) {
|
||
return &derive.attriGroup;
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
bool CStdItemProvider::LoadComposeConfig(LPCTSTR sFilePath) {
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on StdItem config"));
|
||
} else {
|
||
ReadItemCompose();
|
||
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("LoadComposeConfig error: %s"),
|
||
s.rawStr());
|
||
Result = false;
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on ComposeConfig "));
|
||
Result = false;
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return Result;
|
||
}
|
||
|
||
bool CStdItemProvider::LoadForgeConfig(LPCTSTR sFilePath) {
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on StdItem config"));
|
||
} else {
|
||
ReadItemForge();
|
||
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load GodStoveStrongConfig error: %s"),
|
||
s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on GodStoveConfig "));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return true;
|
||
}
|
||
|
||
bool CStdItemProvider::LoadAttri(PGAMEATTR pAttr, LPCSTR reserve0Name)
|
||
{
|
||
do
|
||
{
|
||
pAttr->type = getFieldInt("type");
|
||
//
|
||
if ( pAttr->type < aUndefined || pAttr->type >= GameAttributeCount )
|
||
{
|
||
showErrorFormat(_T("LoadAttri type config error %d"),pAttr->type);
|
||
}
|
||
switch(AttrDataTypes[pAttr->type])
|
||
{
|
||
case adSmall:
|
||
case adShort:
|
||
case adInt:
|
||
pAttr->value.nValue = getFieldInt("value");
|
||
break;
|
||
case adUSmall:
|
||
case adUShort:
|
||
case adUInt:
|
||
pAttr->value.uValue = (UINT)getFieldInt64("value");
|
||
break;
|
||
case adFloat:
|
||
pAttr->value.fValue = (float)getFieldNumber("value");
|
||
break;
|
||
}
|
||
int nDef =0;
|
||
if (reserve0Name)
|
||
{
|
||
pAttr->reserve[0] = getFieldInt(reserve0Name,&nDef);
|
||
}
|
||
++pAttr;
|
||
}while(enumTableNext());
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
bool CStdItemProvider::LoadSuitItemConfig(LPCTSTR sFilePath) {
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on StdItem config"));
|
||
} else {
|
||
ReadSuitItem();
|
||
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load ReadSuitItem error: %s"),
|
||
s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on ReadSuitItem "));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return true;
|
||
}
|
||
|
||
|
||
void CStdItemProvider::ReadSuitItem()
|
||
{
|
||
if(!openGlobalTable("SuitItemCfg"))
|
||
return;
|
||
int nDef = 0;
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
SuitAttr suit;
|
||
suit.nSuitId = getFieldInt("suitid", &nDef);
|
||
suit.nSuitNum = getFieldInt("suitnum", &nDef);
|
||
suit.nPercent = getFieldInt("percent", &nDef);
|
||
getFieldStringBuffer("name", suit.name, sizeof(suit.name));
|
||
int nKey = suit.nSuitId *100 + suit.nSuitNum;
|
||
m_SuitAttrs[nKey] = suit;
|
||
SuitAttr* arrCfg = &m_SuitAttrs[nKey];
|
||
if(arrCfg) {
|
||
if(feildTableExists("attr") && openFieldTable("attr"))
|
||
{
|
||
int nCount = (int)lua_objlen(m_pLua,-1);
|
||
PGAMEATTR pAttr = NULL;
|
||
arrCfg->attri.nCount = nCount;
|
||
if(nCount > 0)
|
||
{
|
||
arrCfg->attri.pAttrs = (PGAMEATTR)m_SuitAttrDataAllocator.allocObjects(sizeof(GAMEATTR) * nCount);
|
||
ZeroMemory(arrCfg->attri.pAttrs, sizeof(GAMEATTR) * nCount);
|
||
pAttr = arrCfg->attri.pAttrs;
|
||
}
|
||
if(enumTableFirst())
|
||
{
|
||
if(!LoadAttri(pAttr))
|
||
{
|
||
return;
|
||
}
|
||
pAttr++;
|
||
}
|
||
closeTable();
|
||
}
|
||
}
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
|
||
bool CStdItemProvider::LoadNumericalConfig(LPCTSTR sFilePath) {
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on StdItem config"));
|
||
} else {
|
||
ReadNumerical();
|
||
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load ReadNumerical error: %s"),
|
||
s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on ReadNumerical "));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return true;
|
||
}
|
||
|
||
|
||
void CStdItemProvider::ReadNumerical()
|
||
{
|
||
if(!openGlobalTable("NumericalIcon"))
|
||
return;
|
||
int nDef = 0;
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
SourceConfig config;
|
||
config.nId = getFieldInt("id", &nDef);
|
||
getFieldStringBuffer("name", config.name, sizeof(config.name));
|
||
m_SourceConfigs[config.nId] = config;
|
||
} while (enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
|
||
SuitAttr* CStdItemProvider::getSuitPtrDataByKey(int nSuitId, int nSuitNum)
|
||
{
|
||
int nKey =nSuitId *100 + nSuitNum;
|
||
std::map<int , SuitAttr>::iterator it = m_SuitAttrs.find(nKey);
|
||
if( it != m_SuitAttrs.end())
|
||
{
|
||
return &(it->second);
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
bool CStdItemProvider::SuitIsExists(int nKey)
|
||
{
|
||
std::map<int , SuitAttr>::iterator it = m_SuitAttrs.find(nKey);
|
||
if( it != m_SuitAttrs.end())
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool CStdItemProvider::LoadRecoverItemConfig(LPCTSTR sFilePath) {
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on RecoverItem config"));
|
||
} else {
|
||
ReadRecoverItemConfig();
|
||
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load RecoverItemConfig error: %s"),
|
||
s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on RecoverItemConfig "));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return true;
|
||
}
|
||
|
||
|
||
void CStdItemProvider::ReadRecoverItemConfig()
|
||
{
|
||
if (!openGlobalTable("YBrecoverConfig"))
|
||
return;
|
||
|
||
int nDef = 0;
|
||
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
ItemRecoverCfg recover;
|
||
recover.nId = getFieldInt("id", &nDef);
|
||
recover.nTimesLimit = getFieldInt("timeslimit", &nDef);
|
||
recover.nTimeLimit = getFieldInt("daylimit", &nDef);
|
||
recover.nRightLimt = getFieldInt("privilegelimit", &nDef);
|
||
if(feildTableExists("item") && openFieldTable("item"))
|
||
{
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
ComposeTableCfg tf;
|
||
tf.nType = getFieldInt("type");
|
||
tf.nCount = getFieldInt("count");
|
||
tf.nId = getFieldInt("id");
|
||
recover.cost.push_back(tf);
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
if(feildTableExists("privilegeaward") && openFieldTable("privilegeaward"))
|
||
{
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
int nType = getFieldInt("type");
|
||
if(feildTableExists("award") && openFieldTable("award"))
|
||
{
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
ComposeTableCfg tf;
|
||
tf.nType = getFieldInt("type");
|
||
tf.nCount = getFieldInt("count");
|
||
tf.nId = getFieldInt("id");
|
||
recover.nAwards[nType].push_back(tf);
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
if(feildTableExists("recoverlimit") && openFieldTable("recoverlimit"))
|
||
{
|
||
recover.nLevelLimt = getFieldInt("level", &nDef);
|
||
recover.nCircle = getFieldInt("zsLevel", &nDef);
|
||
recover.nOpenServerDay = getFieldInt("openDay", &nDef);
|
||
closeTable();
|
||
}
|
||
|
||
m_recoverLists[recover.nId] = recover;
|
||
}while(enumTableNext());
|
||
}
|
||
closeTable();
|
||
}
|
||
|
||
|
||
bool CStdItemProvider::LoadWarehousemConfig(LPCTSTR sFilePath) {
|
||
CMemoryStream ms;
|
||
CCustomLuaPreProcessor pp;
|
||
|
||
bool Result = true;
|
||
try {
|
||
|
||
//从文件加载配置脚本
|
||
if (ms.loadFromFile(sFilePath) <= 0)
|
||
showErrorFormat(_T("unable to load from %s"), sFilePath);
|
||
GetLogicServer()->GetVSPDefine().RegisteToPreprocessor(pp);
|
||
LPCTSTR sText = pp.parse((LPCTSTR) ms.getMemory(), sFilePath);
|
||
|
||
//设置脚本内容
|
||
if (!setScript(sText)) {
|
||
showError(_T("syntax error on ReadWarehouse config"));
|
||
} else {
|
||
ReadWarehouse();
|
||
|
||
}
|
||
} catch (RefString &s) {
|
||
OutputMsg(rmError, _T("load ReadWarehouse error: %s"),
|
||
s.rawStr());
|
||
} catch (...) {
|
||
OutputMsg(rmError, _T("unexpected error on ReadWarehouse "));
|
||
}
|
||
//销毁脚本虚拟机
|
||
setScript(NULL);
|
||
return true;
|
||
}
|
||
|
||
|
||
//仓库
|
||
void CStdItemProvider::ReadWarehouse()
|
||
{
|
||
if (!openGlobalTable("WarehouseConfig"))
|
||
return;
|
||
int nDef = 0;
|
||
if(feildTableExists("openprivilege") && openFieldTable("openprivilege"))
|
||
{
|
||
m_WarehouseCfg.nOpenLevel = getFieldInt("openlevel", &nDef);
|
||
m_WarehouseCfg.nOpenCardLv = getFieldInt("vip", &nDef);
|
||
closeTable();
|
||
}
|
||
m_WarehouseCfg.nInitial = getFieldInt("initial", &nDef);
|
||
if(feildTableExists("warehouses") && openFieldTable("warehouses"))
|
||
{
|
||
INT_PTR count = lua_objlen(m_pLua, -1);
|
||
if(count <= 0)
|
||
return;
|
||
count += 1;
|
||
std::vector<int> lists(count, 0);
|
||
if(enumTableFirst())
|
||
{
|
||
do
|
||
{
|
||
int nCount = getFieldInt("count", &nDef);
|
||
int nCardlv = getFieldInt("vip", &nDef);
|
||
lists[nCardlv] = nCount;
|
||
} while (enumTableNext());
|
||
|
||
}
|
||
m_WarehouseCfg.v_warehouses = lists;
|
||
closeTable();
|
||
}
|
||
}
|