Files
mir_server/server/LogicServer/item/StdItemProvider.h

534 lines
13 KiB
C
Raw Normal View History

2025-01-09 17:45:40 +08:00
#pragma once
#define HUNTCOUNT 5 //1-5为寻宝
#define HUNDRED_37W_FILE_INDEX 7 //37玩百服文件索引
#define TREASUREHUNTFILECOUNT 7 //TreasureHunt文件数量
#define HUNDREDCOUNT 1//百服连连看数
#define HUNDRED_TYPE 5 //百服连连看类型
#define HUNTGRID 18 // 20130909 19个改成18个啦
#define HUNDREDGRID 5//百服连连看总物品数量
#define HUNDRED_REFRESH_COUNT 8//刷新那里固定显示数量
enum enFiveAttrType
{
enFiveAttrErro = 0,
enFiveAttrGold = 1,
enFiveAttrWood = 2,
enFiveAttrWater = 3,
enFiveAttrFire = 4,
enFiveAttrEarth = 5,
enFiveAttrMax,
};
/**
/* 定义游戏中极品属性描述结构
*********************************/
#pragma pack(push,1)
typedef struct tagRandomAttValue
{
GAMEATTRVALUE minValue; //属性值下限
GAMEATTRVALUE maxValue; //属性值上限
unsigned short prob; //选择的几率1表示1%
}RANDOMATTVALUE,*PRANDOMATTVALUE;
typedef struct tagRandomAttributeTerm
{
unsigned char type; //属性类型值为GAMEATTRTYPE的枚举成员使用BYTE成员用于节省内存空间
unsigned char job; //职业要求0-全职业1-战士2-法师3-道士
unsigned short prob; //选择的几率1表示1%
unsigned char maxNum; //最大数量0-不限制
unsigned int lockMaxValue; //锁定最大值,如果指定某属性,且当前属性大于等于该值,则属性值也不变化
DataList<RANDOMATTVALUE> valueList; //属性列表
}RANDOMATTRTERM, *PRANDOMATTRTERM;
#pragma pack(pop)
typedef struct ComposeTable
{
int nId;
int nType;
int nCount;
ComposeTable()
{
memset(this, 0, sizeof(*this));
}
}ComposeTableCfg;
typedef struct ItemCompose
{
int nId;
ComposeTableCfg composeItem;
std::vector<ComposeTableCfg> table;
int nLevelLimt;
int nCircle;
int nOpenServerDay;
int nArea;//区域限制
int nOfficeId;//
int nVipLimit;//
int nGhostLevelLimit;//神魔等级限制
ItemCompose()
{
nId = 0;
table.clear();
nLevelLimt = 0;
nCircle = 0;
nOpenServerDay = 0;
nArea = 0;
nVipLimit = 0;
nOfficeId = 0;
nGhostLevelLimit = 0;
}
}ItemComposeCfg;
typedef struct tagItemRecoverCfg
{
int nId;
std::vector<ComposeTable> cost;
std::map<int, std::vector<ComposeTable> > nAwards;
int nLevelLimt;
int nCircle;
int nOpenServerDay;
int nRightLimt;
int nTimesLimit;
int nTimeLimit;
tagItemRecoverCfg()
{
nId = 0;
cost.clear();
nAwards.clear();
nLevelLimt = 0;
nCircle = 0;
nOpenServerDay = 0;
nRightLimt = 0;
nTimesLimit = 0;
nTimeLimit = 0;
}
}ItemRecoverCfg;
typedef struct ItemForge
{
int nId;
int nDropId;
int nLevel;
ItemForge()
{
memset(this, 0 , sizeof(*this));
}
}ItemForgeCfg;
typedef std::vector<ItemForgeCfg> vItemForge;
typedef struct tagSuitAttr
{
int nSuitId; //套装id
int nSuitNum; //套装数量
int nPercent;//加成百分比
AttriGroup attri; //属性
char name[1024];//
tagSuitAttr()
{
memset(this,0, sizeof(*this));
}
}SuitAttr;
//资源类型
typedef struct tagSourceConfig
{
int nId; //套装id
char name[1024];//
tagSourceConfig()
{
memset(this,0, sizeof(*this));
}
}SourceConfig;
//仓库
typedef struct tagWarehouseCfg
{
int nOpenLevel = 0;
int nOpenCardLv = 0;
int nInitial = 0;
std::vector<int> v_warehouses;
tagWarehouseCfg()
{
v_warehouses.clear();
nOpenLevel = 0;
nOpenCardLv = 0;
nInitial = 0;
}
}WarehouseCfg;
class CStdItemProvider :
protected CVector<CStdItem>,
public CCustomLogicLuaConfig
//public CFileReader<CStdItemProvider>
{
public:
typedef CVector<CStdItem> Inherited;
typedef CCustomLogicLuaConfig Inherited2;
typedef CObjectAllocator<char> CDataAllocator;
//typedef CFileReader<CStdItemProvider> InheritedReader;
static LPCTSTR StdItemCacheFile; //配置数据缓存文件路径
public:
CStdItemProvider();
~CStdItemProvider();
//装备升星效果加成(属性)
typedef struct tagStarDerive
{
WORD wStarCount;//需要多少星
WORD wAppear;//外形,未用
CStdItem::AttributeGroup attriGroup;
}STARDERIVE,*PSTARDERIVE;
//神炉衍生属性
typedef struct tagGodStoveDerive
{
BYTE nLevel; //全部分支等级
CStdItem::AttributeGroup attriGroup;
}GODSTOVEDERIVE,*PGODSTOVEGDERIVE;
//转换为CStdItem数组的类型转换函数
inline operator const CStdItem* () const
{
CStdItemProvider *pProvider = (CStdItemProvider*)this;
return pProvider->Inherited::operator CStdItem*();
}
//通过物品ID获取物品配置对象
inline const CStdItem* GetStdItem(const INT_PTR wItemId) const
{
//ID为0的物品也视为无效物品
if ( wItemId <= 0 || wItemId >= Inherited::count() )
return NULL;
else return &(this->operator const CStdItem*()[wItemId]);
}
inline const char* GetNameById(const INT_PTR nItemId) const
{
const CStdItem* stdItem = GetStdItem(nItemId);
return stdItem?stdItem->m_sName:"";
}
/*
* Comments:
* Param LPCTSTR sItemName:
* @Return const CStdItem*:
*/
inline const CStdItem* GetStdItemByName(LPCTSTR sItemName) const
{
for(INT_PTR i=0 ;i <Inherited::count() ;i ++)
{
const CStdItem* pItem = GetStdItem(i);
if( pItem && strcmp( pItem->m_sName,sItemName) ==0 )
{
return pItem;
}
}
return NULL;
}
//统计产出物品
void AddItemOutPutCount(INT_PTR wItemId,int nCount,const INT_PTR nLogIdent);
//发送统计
void SendItemOutPutToLog();
//获取配置中的物品数量
inline INT_PTR count() const{ return Inherited::count(); }
//从文件加载标准物品配置
// @Param bBackLoad: 是否是后台加载
// @Note: 增加此配置项是为了加快启动速度。在配置文件没有改动的情况下启动服务器直接读取Cache数据省去预处理和解析lua配置处理的操作耗时。
bool LoadStdItems(LPCTSTR sFilePath, bool bBackLoad = false);
//装载装备的精锻的数据
bool LoadSmithData(LPCTSTR sFilePath);
bool LoadForgeConfig(LPCTSTR sFilePath);
bool LoadComposeConfig(LPCTSTR sFilePath);
//加载套装
bool LoadSuitItemConfig(LPCTSTR sFilePath);
void ReadSuitItem();
//仓库
bool LoadWarehousemConfig(LPCTSTR sFilePath);
void ReadWarehouse();
//数值资源
bool LoadNumericalConfig(LPCTSTR sFilePath);
void ReadNumerical();
SourceConfig* GetNumericalConfig(int nId)
{
auto it = m_SourceConfigs.find(nId);
if(it != m_SourceConfigs.end())
{
return &(it->second);
}
return NULL;
}
/// 读取属性表 {{type = 1, value = 1}, {type = 2, value = 2}, {type = 3, value = 3}, }
// 假如 reserve0Name= "job",则对应配置{type = 1, value = 1, job =1},
bool LoadAttri(PGAMEATTR pAttr, LPCSTR reserve0Name = NULL);
//装载装备的评分器
bool LoadItemEval(LPCTSTR sFilePath)
{
/*return InheritedReader::LoadFile(this,sFilePath,
&CStdItemProvider::ReadItemEval);*/
if( Inherited2::LoadFile(sFilePath) )
{
bool r= ReadItemEval();
setScript(NULL);
return r;
}
else
{
return false;
}
}
bool LoadGodStoveConfig(LPCTSTR sFilePath);
/*
* Comments:id获取精锻数据的指针
* Param int nSmithId ()Id
* @Return DataList<RANDOMATTRTERM> *:
*/
DataList<RANDOMATTRTERM> * GetSmithData(int nSmithId);
//获取极品属性 库编号列表
DataList<int>* GetQualityIndexList(int nIndex);
INT_PTR GetQualityIndexListCount(){return m_qualityDataIndexList.count;}
/*
* Comments:
* @Return void:
*/
void UpdateItemConfig();
//返回属性评价器
CAttrEval * GetEval(INT_PTR nVocation=1)
{
if(nVocation >=1 && nVocation <= ArrayCount(m_evals))
{
return &m_evals[nVocation-1];
}
return NULL;
}
//装载装备的衍生的数据
bool LoadEquipDeriveData(LPCTSTR sFilePath)
{
/* return InheritedReader::LoadFile(this,sFilePath,
&CStdItemProvider::ReadEquipDerive); */
if( Inherited2::LoadFile(sFilePath) )
{
bool r= ReadEquipDerive();
setScript(NULL);
return r;
}
else
{
return false;
}
}
//获取装备升星衍生属性
inline PSTARDERIVE GetStarDerive(INT_PTR wStarCount)
{
PSTARDERIVE pStar = NULL;
//必须排序好的
for(int i =0; i< m_starderive.count(); i++)
{
if (wStarCount >= m_starderive[i].wStarCount)
{
pStar = &m_starderive[i];
}
else
{
break;
}
}
return pStar;
}
//获取橙装衍生的属性
inline CStdItem::AttributeGroup * GetOrangeAttr()
{
return m_orangeEquipAttr;
}
//获取衍生属性
CStdItem::AttributeGroup* GetGodStoveDeriveAttrByLevel(INT_PTR nLevel);
ItemComposeCfg* GetComposeCfgById(int nId)
{
std::map<int, ItemComposeCfg>::iterator it = m_composeList.find(nId);
if( it != m_composeList.end())
{
return &(it->second);
}
return NULL;
}
ItemRecoverCfg* GetRecoverItemCfgById(int nId)
{
std::map<int, ItemRecoverCfg>::iterator it = m_recoverLists.find(nId);
if( it != m_recoverLists.end())
{
return &(it->second);
}
return NULL;
}
std::map<int, ItemRecoverCfg>& GetRecoverItemCfgLists()
{
return m_recoverLists;
}
//套装配置
SuitAttr* getSuitPtrDataByKey(int nSuitId, int nSuitNum);
//套装是否存在
bool SuitIsExists(int nKey);
protected:
//以下函数为覆盖父类的相关数据处理函数
void showError(LPCTSTR sError);
private:
//读取标准物品数据配置完成后,将读取的数据保存到自身中
void completeRead(CStdItem *pStdItems, const INT_PTR nItemCount, CDataAllocator &dataAllocator, bool bBackLoad = false);
//从已装载的脚本中读取标准物品配置数据
bool readStdItems(bool bBackLoad = false);
//读取物品配置数据
bool readItemData(CDataAllocator &dataAllocator, CStdItem &item);
//读取物品属性表
bool readItemAttributeTable(CDataAllocator &dataAllocator, CStdItem::AttributeGroup &AttrGroup);
//读取物品联合物品表
bool readUnitedItemTable(CDataAllocator &dataAllocator, CStdItem::UnitedAttributeGroup &unitedGroup);
//读取物品标志属性
bool readItemFlags(CStdItem &item);
//读取物品使用条件表
bool readItemConditionTable(CDataAllocator &dataAllocator, CStdItem::ItemUseCondTable &condTable);
//读取物品预留配置表
bool readItemReservesTable(CDataAllocator &dataAllocator, CStdItem::ItemReservesTable &table);
//读取极品属性数据
bool ReadSmithData(CDataAllocator &dataAllocator);
//极品属性 库编号索引
bool ReadQualitdataIndex(CDataAllocator& dataAllocator);
//装载装备的评分的数据
bool ReadItemEval();
//装载装备的衍生数据
bool ReadEquipDerive();
//读取神炉配置
bool ReadGodStoveConfig(CDataAllocator& dataAllocator);
void ReadItemCompose();
void ReadItemForge();
//回收装备
bool LoadRecoverItemConfig(LPCTSTR sFilePath);
void ReadRecoverItemConfig();
private:
//从缓存文件中读取标准物品配置数据如果缓存数据有效且源数据文件未经修改且读取成功则返回true。
bool readCacheData(DWORD dwSrcCRC32, bool bBackLoad = false);
//将配置数据写入缓存文件中
bool saveCacheData(DWORD dwSrcCRC32);
private:
CDataAllocator m_DataAllocator; //物品属性对象申请器
// 用于后台加载数据
CDataAllocator m_DataAllocatorBack; // 物品属性对象申请器(用于后台加载)
CVector<CStdItem> m_ItemBack; // 后台加载的物品数据
CDataAllocator m_DeriveDataAllocator; //加载装备衍生配置申请器
CDataAllocator m_SmithDataAllocator;
CDataAllocator m_FiveAttrDataAllocator;
CDataAllocator m_FiveAttrListDataAllocator;
CDataAllocator m_EquipPosStrongAllocator;
//CStdItem *m_pStdItemsBack; // 分配的静态物品对象数据内存(用于后台加载)
INT_PTR m_nItemCount; // 分配的静态物品对象数量(用于后台加载)
CCSLock m_Lock;
//玩家的精锻的数据列表
DataList< DataList<RANDOMATTRTERM> > m_smithData;
DataList<DataList<int> > m_qualityDataIndexList;//极品属性库编号列表
CAttrEval m_evals[enMaxVocCount-1] ; //各职业的装备评分器
CStdItem::AttributeGroup m_orangeEquipAttr[CStdItem::MaxOrangeEquipCount]; //橙装的属性衍生加成配置
CVector<STARDERIVE> m_starderive; //升星的属性衍生加成配置
CVector<GODSTOVEDERIVE> m_godStoveDerive; //神炉衍生属性配置 TO DELETE
//合成
std::map<int, ItemComposeCfg> m_composeList;
//
std::map<int, ItemRecoverCfg> m_recoverLists;
//锻造
vItemForge m_forgeList;
CDataAllocator m_SuitAttrDataAllocator;
//套装
std::map<int, SuitAttr> m_SuitAttrs;//套装加成属性
std::map<int, SourceConfig> m_SourceConfigs;//数值资源
public:
//仓库
WarehouseCfg m_WarehouseCfg;
public:
int nForgeItemId = 0; //锻造消耗道具id
int nOnceForgeCost = 0; //锻造一次消耗
int nTenForgeCost = 0; //锻造10次消耗
int nBagten = 0; //锻造十次背包至少剩余格数
int nBagone = 0; //锻造一次背包至少剩余格数
int nEquipment = 0; //锻造功能装备背包栏至少剩余格数
int GetForgeDropIdByLevel(int nLevel)
{
int nDropid = 0;
int nSize = m_forgeList.size();
int nMaxlevel = 0;
for(int size = 0; size < nSize; size++)
{
if(nLevel >= m_forgeList[size].nLevel && m_forgeList[size].nLevel >= nMaxlevel)
{
nMaxlevel = m_forgeList[size].nLevel;
nDropid = m_forgeList[size].nDropId;
}
}
return nDropid;
}
int GetForgeIdByLevel(int nLevel)
{
int nId = 0;
int nSize = m_forgeList.size();
int nMaxlevel = 0;
for(int size = 0; size < nSize; size++)
{
if(nLevel >= m_forgeList[size].nLevel && m_forgeList[size].nLevel >= nMaxlevel)
{
nMaxlevel = m_forgeList[size].nLevel;
nId = m_forgeList[size].nId;
}
}
return nId;
}
};