866 lines
22 KiB
C++
866 lines
22 KiB
C++
#include "StdAfx.h"
|
|
#include "BasicFunctionsSystem.h"
|
|
|
|
|
|
BasicFunctionsSystem::BasicFunctionsSystem()
|
|
{
|
|
|
|
}
|
|
|
|
BasicFunctionsSystem::~BasicFunctionsSystem()
|
|
{
|
|
}
|
|
|
|
bool BasicFunctionsSystem::Initialize(void *data, SIZE_T size)
|
|
{
|
|
PACTORDBDATA pActorData = (ACTORDBDATA *)data;
|
|
if (pActorData == NULL || size != sizeof(ACTORDBDATA))
|
|
{
|
|
OutputMsg(rmError, _T("data len error len=%d ,correct len=%d"), size, sizeof(ACTORDBDATA));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
VOID BasicFunctionsSystem::ProcessNetData(INT_PTR nCmd, CDataPacketReader &packet)
|
|
{
|
|
|
|
if (m_pEntity == NULL)
|
|
return;
|
|
if (m_pEntity->GetHandle().GetType() != enActor)
|
|
return;
|
|
switch (nCmd)
|
|
{
|
|
case encompostItem: //合成
|
|
{
|
|
HandleComposeItem(packet);
|
|
break;
|
|
}
|
|
case enForgeItem: //锻造
|
|
{
|
|
HandleForgeItem(packet);
|
|
break;
|
|
}
|
|
case enForgeItemId: //id本服锻造id
|
|
{
|
|
HandleForgeInfo(packet);
|
|
break;
|
|
}
|
|
case enRefining://洗炼
|
|
{
|
|
HandleRefining(packet);
|
|
break;
|
|
}
|
|
case enRefiningReplace://
|
|
{
|
|
HandleRefiningReplace(packet);
|
|
break;
|
|
}
|
|
case enItemUpStar:
|
|
{
|
|
UpdateItemStar(packet);
|
|
break;
|
|
}
|
|
case enYBRecoverInfo:
|
|
{
|
|
SendRecoverItemInfo();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void BasicFunctionsSystem::HandleForgeItem(CDataPacketReader& inPakcet)
|
|
{
|
|
if(!m_pEntity) return;
|
|
CActor* pActor = (CActor*)m_pEntity;
|
|
BYTE nCount = 0;
|
|
inPakcet >>nCount;
|
|
if(nCount != 1 && nCount != 10)
|
|
{
|
|
return;
|
|
}
|
|
CStdItemProvider& stdItemPv = GetLogicServer()->GetDataProvider()->GetStdItemProvider();
|
|
static int itemId = stdItemPv.nForgeItemId;
|
|
int nCost = nCount > 1?stdItemPv.nTenForgeCost:stdItemPv.nOnceForgeCost;
|
|
CUserBag& bag = m_pEntity->GetBagSystem();
|
|
|
|
|
|
int nType = nCount > 1? BagTenForge : BagForge;
|
|
int tipId = nCount > 1? tmTenForgeNoBagNum : tmForgeNoBagNum;
|
|
if(!bag.bagIsEnough(nType) )
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmTenForgeNoBagNum,tstUI);
|
|
return;
|
|
}
|
|
if(bag.GetItemCount(itemId) < nCost)
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmItemNotEnough,tstUI);
|
|
return;
|
|
}
|
|
int nTopLevel = GetGlobalLogicEngine()->GetTopTitleMgr().GetTopMaxLevel();
|
|
int nDropId = stdItemPv.GetForgeDropIdByLevel(nTopLevel);
|
|
|
|
std::vector<DROPINFO> nResults;
|
|
nResults.clear();
|
|
//扣道具
|
|
do
|
|
{
|
|
CUserItem *pUserItem = bag.FindItem(itemId);
|
|
if(pUserItem)
|
|
{
|
|
int cost = nCost < pUserItem->wCount? nCost:pUserItem->wCount;
|
|
nCost -= cost;
|
|
if(nCost < 0)
|
|
{
|
|
nCost = 0;
|
|
}
|
|
if(cost > 0)
|
|
bag.DeleteItem(pUserItem, cost,"self_compose_item",GameLog::Log_ForgeItem,true);
|
|
}
|
|
}while(nCost > 0);
|
|
|
|
for(int i = 0; i < nCount; i++)
|
|
{
|
|
std::vector<DROPGOODS> dropInfos;
|
|
GetLogicServer()->GetDataProvider()->GetDropCfg().GetGiftDropInfoByDropGroupId(nDropId, dropInfos);
|
|
int count = dropInfos.size();
|
|
if(count)
|
|
{
|
|
for(int j = 0; j < count; j++)
|
|
{
|
|
//printf("error forge item count %d\n", dropInfos[j].info.nCount);
|
|
const CStdItem* pStdItem = GetLogicServer()->GetDataProvider()->GetStdItemProvider().GetStdItem(dropInfos[j].info.nId);
|
|
if(!pStdItem)
|
|
continue;
|
|
|
|
CUserItemContainer::ItemOPParam iParam;
|
|
iParam.wItemId = dropInfos[j].info.nId;
|
|
iParam.wCount = (WORD)dropInfos[j].info.nCount;
|
|
iParam.btQuality = pStdItem->b_showQuality;
|
|
iParam.btStrong = 0;
|
|
iParam.btBindFlag = 0;
|
|
int num = dropInfos[j].v_bestAttr.size();
|
|
|
|
for(int k = 0; k < num; k++)
|
|
{
|
|
char buf[10];
|
|
if(k != 0)
|
|
strcat(iParam.cBestAttr, "|");
|
|
|
|
DropAttribute data = dropInfos[j].v_bestAttr[k];
|
|
sprintf(buf, "%d,%d", data.nType, data.nValue);
|
|
strcat(iParam.cBestAttr, buf);
|
|
}
|
|
iParam.cBestAttr[sizeof(iParam.cBestAttr)-1]= '\0';
|
|
|
|
pActor->GiveAward(dropInfos[j].info.nType, dropInfos[j].info.nId, dropInfos[j].info.nCount,0,0,0,0,GameLog::Log_ForgeItem,"",0, &iParam);
|
|
nResults.push_back(dropInfos[j].info);
|
|
//祖玛级以上的广播
|
|
if (pActor && pStdItem->m_nItemlvl > 2) {
|
|
GetGlobalLogicEngine()->GetEntityMgr()->BroadTipmsgWithParams(tmActorForgeItem, tstChatSystem, pActor->GetEntityName(),pStdItem->m_sName);
|
|
GetGlobalLogicEngine()->GetEntityMgr()->BroadTipmsgWithParams(tmActorForgeItem, tstRevolving, pActor->GetEntityName(), pStdItem->m_sName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int nSize = nResults.size();
|
|
pActor->GetAchieveSystem().ActorAchievementComplete(nAchieveForge, nCount);
|
|
CActorPacket ap;
|
|
CDataPacket& dataPacket = pActor->AllocPacket(ap);
|
|
dataPacket << (BYTE)enBasicFunctionsSystemID << (BYTE)enForgeResult;
|
|
dataPacket << (BYTE)nSize;
|
|
for(int k = 0; k < nSize; k++)
|
|
{
|
|
dataPacket<<(BYTE)(nResults[k].nType);
|
|
dataPacket<<(int)(nResults[k].nId);
|
|
dataPacket<<(int)(nResults[k].nCount);
|
|
}
|
|
ap.flush();
|
|
}
|
|
|
|
void BasicFunctionsSystem::HandleComposeItem(CDataPacketReader& inPacket)
|
|
{
|
|
|
|
if(!m_pEntity) return;
|
|
CActor* pActor = (CActor*)m_pEntity;
|
|
WORD nId = 0;
|
|
BYTE nTimes = 0;
|
|
inPacket >> nId >> nTimes;
|
|
|
|
if ( nTimes != 1 && nTimes != 10 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
CStdItemProvider& stdItemPv = GetLogicServer()->GetDataProvider()->GetStdItemProvider();
|
|
|
|
ItemComposeCfg* pComposeCfg = stdItemPv.GetComposeCfgById(nId);
|
|
if(!pComposeCfg)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!pActor->CheckGhostLevel(pComposeCfg->nGhostLevelLimit))
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmComPoseLimit, tstUI);
|
|
return;
|
|
}
|
|
if(!pActor->CheckLevel(pComposeCfg->nLevelLimt, pComposeCfg->nCircle))
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmComPoseLimit, tstUI);
|
|
return;
|
|
}
|
|
if(!pActor->CheckOffice(pComposeCfg->nOfficeId))
|
|
{
|
|
auto Cfgptr = GetLogicServer()->GetDataProvider()->GetMiscConfig().GetOfficeCfgPtrByLevel(pComposeCfg->nOfficeId);
|
|
if(Cfgptr)
|
|
pActor->SendTipmsgFormatWithId(tmComPoseOfficeLimit, tstUI,Cfgptr->sName);
|
|
return;
|
|
}
|
|
if(pActor->GetMiscSystem().GetMaxColorCardLevel() < pComposeCfg->nVipLimit)
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmComPoseVipLimit, tstUI);
|
|
return;
|
|
}
|
|
|
|
int nDays = GetLogicServer()->GetDaysSinceOpenServer();
|
|
if(nDays < pComposeCfg->nOpenServerDay)
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmCircleOpenServerDayLimit, tstUI, nDays);
|
|
return;
|
|
}
|
|
|
|
if(pComposeCfg->nArea)
|
|
{
|
|
if (!m_pEntity->HasMapAttribute(pComposeCfg->nArea))
|
|
{
|
|
m_pEntity->SendTipmsgFormatWithId(tmNotInSafeArea, tstUI);
|
|
return;
|
|
}
|
|
}
|
|
|
|
CUserBag& bag = m_pEntity->GetBagSystem();
|
|
int count = pComposeCfg->table.size();
|
|
for(int i = 0; i < count; i++)
|
|
{
|
|
ComposeTableCfg& table = pComposeCfg->table[i];
|
|
// CUserItem *pUserItem = bag.FindItem(table.nId, -1, -1, table.nCount);
|
|
// if(pUserItem ==NULL)
|
|
// {
|
|
// pActor->SendTipmsgFormatWithId(tmItemNotExist,tstUI);
|
|
// return;
|
|
// }
|
|
bool bResult = pActor->CheckActorSource(table.nType, table.nId, table.nCount * nTimes, tstUI);
|
|
if(!bResult)
|
|
{
|
|
// pActor->SendTipmsgFormatWithId(tmItemNotEnough,tstUI);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
if(!bag.bagIsEnough(nTimes == 1 ? BagCompose:BagComposes) )
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmComposeBagLimit,tstUI);
|
|
return;
|
|
}
|
|
if(pComposeCfg->composeItem.nType == qatEquipment)
|
|
{
|
|
CUserItemContainer::ItemOPParam ItemOp;
|
|
ItemOp.wItemId = (WORD)pComposeCfg->composeItem.nId;
|
|
ItemOp.wCount = (WORD)pComposeCfg->composeItem.nCount * nTimes;
|
|
if(!pActor->GetBagSystem().CanAddItem(ItemOp))
|
|
{
|
|
pActor->SendTipmsgFormatWithId(tmLeftBagNumNotEnough,tstUI);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
for(int i = 0; i < count; i++)
|
|
{
|
|
ComposeTableCfg& table = pComposeCfg->table[i];
|
|
// if(table.nType == 0)
|
|
// {
|
|
// CUserItem *pUserItem = bag.FindItem(table.nId, -1, -1, table.nCount);
|
|
// if(pUserItem ==NULL)
|
|
// {
|
|
// pActor->SendTipmsgFormatWithId(tmItemNotExist,tstUI);
|
|
// return;
|
|
// }
|
|
// bag.DeleteItem(pUserItem,table.nCount,"self_compose_item",GameLog::clComPoseItem,true);
|
|
// }
|
|
// else
|
|
// {
|
|
// pActor->GiveAward(table.nType,table.nId, -(table.nCount));
|
|
// }
|
|
char logs[64] = {0};
|
|
if(table.nType == 0 ) {
|
|
const CStdItem* pStdItem = stdItemPv.GetStdItem(table.nId);
|
|
if(pStdItem) {
|
|
sprintf_s(logs,64,"%s",pStdItem->m_sName);
|
|
logs[63] = 0;
|
|
}
|
|
}else
|
|
{
|
|
const SourceConfig* pConfig = stdItemPv.GetNumericalConfig(table.nId);
|
|
if(pConfig) {
|
|
sprintf_s(logs,64,"%s",pConfig->name);
|
|
logs[63] = 0;
|
|
}
|
|
}
|
|
pActor->RemoveConsume(table.nType, table.nId, table.nCount * nTimes, -1, -1,-1,0, GameLog::Log_Compose,logs);
|
|
}
|
|
|
|
// int nCount = pComposeCfg->composeItem.size();
|
|
// for(int i = 0; i < nCount; i++)
|
|
// {
|
|
// ComposeTableCfg& table = pComposeCfg->composeItem[i];
|
|
// CUserItem *pUserItem = bag.FindItem( pComposeCfg->composeItem.nId, -1, -1, pComposeCfg->composeItem.nCount);
|
|
// if(pUserItem ==NULL)
|
|
// {
|
|
// pActor->SendTipmsgFormatWithId(tmItemNotExist,tstUI);
|
|
// return;
|
|
// }
|
|
// pActor->GiveAward( pComposeCfg->composeItem.nType, pComposeCfg->composeItem.nId, pComposeCfg->composeItem.nCount);
|
|
// }
|
|
// CUserItem *pUserItem = bag.FindItem( pComposeCfg->composeItem.nId, -1, -1, pComposeCfg->composeItem.nCount);
|
|
// if(pUserItem ==NULL)
|
|
// {
|
|
// pActor->SendTipmsgFormatWithId(tmItemNotExist,tstUI);
|
|
// return;
|
|
// }
|
|
|
|
((CActor*)m_pEntity)->GetQuestSystem()->OnQuestEvent(CQuestData::qtCompose, 1 * nTimes, nId);
|
|
pActor->GiveAward( pComposeCfg->composeItem.nType, pComposeCfg->composeItem.nId, pComposeCfg->composeItem.nCount * nTimes,0,0,0,0,GameLog::Log_Compose);
|
|
CActorPacket ap;
|
|
CDataPacket& data = ((CActor*)m_pEntity)->AllocPacket(ap);
|
|
data<<(BYTE)GetSystemID() << (BYTE)enCompostResult;
|
|
ap.flush();
|
|
return;
|
|
}
|
|
|
|
void BasicFunctionsSystem::HandleForgeInfo(CDataPacketReader& inPacket)
|
|
{
|
|
if(!m_pEntity) return;
|
|
CActor* pActor = (CActor*)m_pEntity;
|
|
CActorPacket ap;
|
|
CDataPacket& data = pActor->AllocPacket(ap);
|
|
data <<(BYTE)enBasicFunctionsSystemID <<(BYTE)enForgeItemIdResult ;
|
|
CStdItemProvider& stdItemPv = GetLogicServer()->GetDataProvider()->GetStdItemProvider();
|
|
|
|
int nTopLevel = GetGlobalLogicEngine()->GetTopTitleMgr().GetTopMaxLevel();
|
|
int nId = stdItemPv.GetForgeIdByLevel(nTopLevel);
|
|
data<<(BYTE)nId;
|
|
ap.flush();
|
|
}
|
|
|
|
void BasicFunctionsSystem::HandleRefining(CDataPacketReader& inPacket)
|
|
{
|
|
if(!m_pEntity) return ;
|
|
CActor* pActor = (CActor*)m_pEntity;
|
|
int nerrorCore = 0;
|
|
byte nType = 0;//type: 1为装备 2:背包
|
|
inPacket >> nType;
|
|
byte nReplace = 0; //1替换 0 ：不替换
|
|
CUserItem::ItemSeries series;
|
|
inPacket >> series.llId;
|
|
inPacket >> nReplace;
|
|
int nEqPos = 0;
|
|
BYTE bCanReplace = 0;
|
|
CUserItem* pUseItem = NULL;
|
|
do
|
|
{
|
|
CUserBag& bag = ((CActor*)m_pEntity)->GetBagSystem();
|
|
if(nType == 1)
|
|
{
|
|
CUserEquipment& equip = ((CActor*)m_pEntity)->GetEquipmentSystem();
|
|
for(int nPos = itWeaponPos; nPos < itMaxEquipPos; nPos++)
|
|
{
|
|
if(equip.m_Items[nPos])
|
|
{
|
|
if(equip.m_Items[nPos]->series.llId == series.llId)
|
|
{
|
|
pUseItem = equip.m_Items[nPos];
|
|
nEqPos = nPos;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else if(nType == 2) {
|
|
// CUserBag& bag = ((CAvtor*)m_pEntity)->GetBagSystem();
|
|
pUseItem = bag.FindItemByGuid(series);
|
|
}
|
|
else
|
|
nerrorCore =1;
|
|
|
|
if(nerrorCore)
|
|
break;
|
|
|
|
|
|
if(!pUseItem)
|
|
{
|
|
nerrorCore = 2;
|
|
break;
|
|
}
|
|
if (((CActor *)m_pEntity)->GetDealSystem().FindDealItem(pUseItem))
|
|
{
|
|
((CActor *)m_pEntity)->SendTipmsgFormatWithId(tmFailForDealing,tstUI);
|
|
nerrorCore = 6;
|
|
break;
|
|
}
|
|
RefiningCfg* cfg = GetLogicServer()->GetDataProvider()->GetRefiningConfig().getRefiningCfg(pUseItem->wItemId);
|
|
if(!cfg)
|
|
{
|
|
nerrorCore = 3;
|
|
break;
|
|
}
|
|
int nCostYb = 0;
|
|
if(cfg->cost.size())
|
|
{
|
|
for(int i = 0; i < cfg->cost.size(); i++)
|
|
{
|
|
bool bReplace = false;
|
|
ACTORAWARD& table = cfg->cost[i];
|
|
ReplaceCfg* res = GetLogicServer()->GetDataProvider()->GetRefiningConfig().getReplaceCfg(table.wId);
|
|
if(res)
|
|
{
|
|
if(nReplace & (1<< res->nId))
|
|
{
|
|
bReplace = true;
|
|
nCostYb += table.wCount*(res->nPrice);
|
|
}
|
|
}
|
|
if(!bReplace)
|
|
{
|
|
if(!pActor->CheckActorSource(table.btType, table.wId, table.wCount, tstUI))
|
|
{
|
|
nerrorCore = 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
if(nerrorCore)
|
|
break;
|
|
|
|
if(nCostYb)
|
|
{
|
|
if(!pActor->CheckActorSource(qatYuanbao, qatYuanbao, nCostYb, tstUI))
|
|
{
|
|
nerrorCore = 5;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(cfg->cost.size())
|
|
{
|
|
for(int i = 0; i < cfg->cost.size(); i++)
|
|
{
|
|
bool bReplace = false;
|
|
ACTORAWARD& table = cfg->cost[i];
|
|
ReplaceCfg* res = GetLogicServer()->GetDataProvider()->GetRefiningConfig().getReplaceCfg(table.wId);
|
|
if(res)
|
|
{
|
|
if(nReplace & (1<< res->nId))
|
|
bReplace = true;
|
|
}
|
|
if(!bReplace)
|
|
{
|
|
pActor->RemoveConsume(table.btType, table.wId, table.wCount, -1, -1,-1,0, GameLog::Log_Refining);
|
|
}
|
|
|
|
}
|
|
}
|
|
if(nCostYb)
|
|
{
|
|
pActor->RemoveConsume(qatYuanbao, qatYuanbao, nCostYb, -1, -1,-1,0, GameLog::Log_Refining);
|
|
}
|
|
|
|
DROPGOODS item;
|
|
const CStdItem* pStdItem = GetLogicServer()->GetDataProvider()->GetStdItemProvider().GetStdItem(pUseItem->wItemId);
|
|
if(pStdItem && Item::itUndefinedType < pStdItem->m_btType < Item::itEquipMax)
|
|
{
|
|
GetLogicServer()->GetDataProvider()->GetRefiningConfig().GetRefineAttribute(cfg->nRefineId, item);
|
|
}
|
|
std::map<int, int> new_attr;
|
|
memset(pUseItem->Refining, 0, sizeof(pUseItem->Refining));
|
|
int num = item.v_bestAttr.size();
|
|
for(int j = 0; j < num; j++)
|
|
{
|
|
char buf[10];
|
|
if(j != 0)
|
|
strcat(pUseItem->Refining, "|");
|
|
|
|
DropAttribute data = item.v_bestAttr[j];
|
|
sprintf(buf, "%d,%d", data.nType, data.nValue);
|
|
new_attr[data.nType] = data.nValue;
|
|
strcat(pUseItem->Refining, buf);
|
|
}
|
|
pUseItem->Refining[sizeof(pUseItem->Refining)-1]= '\0';
|
|
|
|
//默认木有极品属性的数据直接替换
|
|
if(strlen(pUseItem->cBestAttr) == 0 && strlen(pUseItem->Refining))
|
|
{
|
|
memcpy(pUseItem->cBestAttr, pUseItem->Refining, sizeof(pUseItem->cBestAttr));
|
|
memset(pUseItem->Refining, 0, sizeof(pUseItem->Refining));
|
|
bCanReplace = 1;
|
|
}
|
|
std::map<int, int> old_attr;
|
|
if(!bCanReplace && strlen(pUseItem->cBestAttr))
|
|
{
|
|
std::vector<std::string> results = SplitStr(pUseItem->cBestAttr, "|");
|
|
int nCount = results.size();
|
|
for (int i = 0; i < nCount; i++) {
|
|
std::vector<std::string> temp_res = SplitStr(results[i], ",");
|
|
if (temp_res.size() >= 2) {
|
|
int nType = atoi(temp_res[0].c_str());
|
|
int nValue = atoi(temp_res[1].c_str());
|
|
old_attr[nType] = nValue;
|
|
}
|
|
}
|
|
if(old_attr.size() )
|
|
{
|
|
bool bAutoReplace = true;
|
|
std::map<int, int>::iterator it = old_attr.begin();
|
|
for(; it != old_attr.end(); it++)
|
|
{
|
|
std::map<int, int>::iterator iter = new_attr.find(it->first);
|
|
if(iter == new_attr.end() || (iter->second < it->second))
|
|
{
|
|
bAutoReplace = false;
|
|
break;
|
|
}
|
|
}
|
|
if(bAutoReplace) {
|
|
memcpy(pUseItem->cBestAttr, pUseItem->Refining, sizeof(pUseItem->cBestAttr));
|
|
memset(pUseItem->Refining, 0, sizeof(pUseItem->Refining));
|
|
bCanReplace = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bCanReplace)
|
|
{
|
|
//需要重新计算属性
|
|
m_pEntity->CollectOperate(CEntityOPCollector::coRefAbility);
|
|
// 更新升级后的血、蓝
|
|
}
|
|
if(nReplace)
|
|
{
|
|
((CActor*)m_pEntity)->SendTipmsgFormatWithId(tmRefiningReplace,tstUI);
|
|
}
|
|
|
|
if(nType == 2)
|
|
bag.NotifyItemChange(pUseItem);
|
|
else if(nType == 1)
|
|
((CActor*)m_pEntity)->GetEquipmentSystem().EquipChange(nEqPos);
|
|
|
|
} while(false);
|
|
|
|
CActorPacket ap;
|
|
CDataPacket& data = ((CActor*)m_pEntity)->AllocPacket(ap);
|
|
data <<(byte)GetSystemID()<<(byte)enRefiningResult;
|
|
data <<(byte)nerrorCore;
|
|
data << (int64)series.llId;
|
|
data << (byte)bCanReplace;
|
|
if(pUseItem)
|
|
{
|
|
data.writeString(pUseItem->cBestAttr);
|
|
data.writeString(pUseItem->Refining);
|
|
}
|
|
ap.flush();
|
|
|
|
}
|
|
|
|
void BasicFunctionsSystem::HandleRefiningReplace(CDataPacketReader& inPacket)
|
|
{
|
|
if(!m_pEntity) return ;
|
|
byte errorCode = 0;
|
|
byte nType = 0;//type: 1为装备 2:背包
|
|
inPacket >> nType;
|
|
CUserItem::ItemSeries series;
|
|
inPacket >> series.llId;
|
|
CUserItem* pUseItem = NULL;
|
|
int nEqPos = 0;
|
|
do
|
|
{
|
|
if(nType == 1)
|
|
{
|
|
CUserEquipment& equip = ((CActor*)m_pEntity)->GetEquipmentSystem();
|
|
for(int nPos = itWeaponPos; nPos < itMaxEquipPos; nPos++)
|
|
{
|
|
if(equip.m_Items[nPos])
|
|
{
|
|
if(equip.m_Items[nPos]->series.llId == series.llId)
|
|
{
|
|
pUseItem = equip.m_Items[nPos];
|
|
nEqPos = nPos;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(nType == 2) {
|
|
CUserBag& bag = ((CActor*)m_pEntity)->GetBagSystem();
|
|
pUseItem = bag.FindItemByGuid(series);
|
|
}
|
|
else
|
|
errorCode = 1;
|
|
|
|
if(errorCode)
|
|
break;
|
|
|
|
if(!pUseItem)
|
|
{
|
|
errorCode = 2;
|
|
break;
|
|
}
|
|
|
|
if(strlen(pUseItem->Refining) == 0)
|
|
{
|
|
errorCode = 3;
|
|
break;
|
|
}
|
|
|
|
memcpy(pUseItem->cBestAttr, pUseItem->Refining, sizeof(pUseItem->cBestAttr));
|
|
memset(pUseItem->Refining, 0, sizeof(pUseItem->Refining));
|
|
|
|
if(nType == 2)
|
|
((CActor*)m_pEntity)->GetBagSystem().NotifyItemChange(pUseItem);
|
|
else if(nType == 1)
|
|
((CActor*)m_pEntity)->GetEquipmentSystem().EquipChange(nEqPos);
|
|
//需要重新计算属性
|
|
m_pEntity->CollectOperate(CEntityOPCollector::coRefAbility);
|
|
// 更新升级后的血、蓝
|
|
|
|
} while (false);
|
|
|
|
CActorPacket ap;
|
|
CDataPacket& data = ((CActor*)m_pEntity)->AllocPacket(ap);
|
|
data <<(byte)GetSystemID() <<(byte)enRefiningReplaceResult;
|
|
data <<(byte)errorCode;
|
|
data << (int64)series.llId;
|
|
if(pUseItem)
|
|
{
|
|
data.writeString(pUseItem->cBestAttr);
|
|
data.writeString(pUseItem->Refining);
|
|
}
|
|
ap.flush();
|
|
|
|
}
|
|
|
|
void BasicFunctionsSystem::SendRecoverItemInfo()
|
|
{
|
|
if(!m_pEntity) return;
|
|
CActorPacket ap;
|
|
CDataPacket & outPack = ((CActor*)m_pEntity)->AllocPacket(ap);
|
|
outPack << (BYTE) GetSystemID()<<(BYTE)enYBRecoverInfoResult;
|
|
int nCount = 0;
|
|
int nPos = outPack.getPosition();
|
|
outPack<<(int)nCount;
|
|
CStdItemProvider& stdItemPv = GetLogicServer()->GetDataProvider()->GetStdItemProvider();
|
|
std::map<int, ItemRecoverCfg>& m_Cfgs = stdItemPv.GetRecoverItemCfgLists();
|
|
int nNowOpenDay = GetLogicServer()->GetDaysSinceOpenServer();
|
|
CScriptValueList paramList, retParamList;
|
|
CHAR sFnArgs[1024];
|
|
sFnArgs[0]=0;
|
|
paramList << ((CActor*)m_pEntity);
|
|
paramList << ≈
|
|
if(GetGlobalLogicEngine()->GetGlobalNpc()->GetScript().Call("ClientGetData", paramList, retParamList, 1))
|
|
{
|
|
if(retParamList.count() > 0)
|
|
{
|
|
int *pInt = (int*)outPack.getPositionPtr(nPos);
|
|
*pInt = (int)retParamList[0];
|
|
}
|
|
}
|
|
ap.flush();
|
|
}
|
|
|
|
void BasicFunctionsSystem::UpdateItemStar(CDataPacketReader& packet)
|
|
{
|
|
if(!m_pEntity) return;
|
|
// CUserItem::ItemSeries series;
|
|
// packet >> series.llId;
|
|
byte nReplace = 0; //1替换 0 ：不替换
|
|
CUserItem::ItemSeries series;
|
|
packet >> series.llId;
|
|
packet >> nReplace;
|
|
int errorCode = 0;
|
|
CActor* pActor = (CActor*)m_pEntity;
|
|
if(!pActor) return;
|
|
CUserItem * pUseItem = NULL;
|
|
do
|
|
{
|
|
int nEqPos = 0;
|
|
pUseItem = pActor->GetEquipmentSystem().GetEquipByGuid(series);
|
|
if(!pUseItem) {
|
|
errorCode = 1;//道具不存在
|
|
break;
|
|
}
|
|
nEqPos = pActor->GetEquipmentSystem().FindIndex(series);
|
|
if(nEqPos == -1) {
|
|
errorCode = 1;//道具不存在
|
|
break;
|
|
}
|
|
|
|
ItemUpStarCfg * cfg = GetLogicServer()->GetDataProvider()->GetUpStar().getItemUpStarCfg(pUseItem->wItemId, pUseItem->wStar+1);
|
|
if(!cfg) {
|
|
errorCode = 3;
|
|
break;
|
|
}
|
|
|
|
ItemUpStarCfg* pCostcfg = GetLogicServer()->GetDataProvider()->GetUpStar().getItemUpStarCfg(pUseItem->wItemId, pUseItem->wStar);
|
|
if(!pCostcfg) {
|
|
errorCode = 2;
|
|
break;
|
|
}
|
|
// if(pCostcfg->cost.size() > 0) {
|
|
// for(auto co : pCostcfg->cost) {
|
|
// if(!pActor->CheckActorSource(co.btType, co.wId, co.wCount, tstUI))
|
|
// return;
|
|
// }
|
|
// }
|
|
int nCostYb = 0;
|
|
if(pCostcfg->cost.size())
|
|
{
|
|
for(int i = 0; i < pCostcfg->cost.size(); i++)
|
|
{
|
|
bool bReplace = false;
|
|
ACTORAWARD& table = pCostcfg->cost[i];
|
|
StarReplaceCfg* res = GetLogicServer()->GetDataProvider()->GetUpStar().getUpStareplaceCfg(table.wId);
|
|
if(res)
|
|
{
|
|
if(nReplace & (1<< res->nId))
|
|
{
|
|
bReplace = true;
|
|
nCostYb += table.wCount*(res->nPrice);
|
|
}
|
|
}
|
|
if(!bReplace)
|
|
{
|
|
if(!pActor->CheckActorSource(table.btType, table.wId, table.wCount, tstUI))
|
|
{
|
|
errorCode = 4;
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
if(errorCode)
|
|
return;
|
|
|
|
if(nCostYb)
|
|
{
|
|
if(!pActor->CheckActorSource(qatYuanbao, qatYuanbao, nCostYb, tstUI))
|
|
{
|
|
errorCode = 5;
|
|
return;
|
|
}
|
|
}
|
|
if(errorCode)
|
|
return;
|
|
|
|
|
|
int nDownLv = 0;
|
|
if(wrand(10000) > cfg->nUpRate) {
|
|
int nrate = wrand(cfg->nMaxRate);
|
|
if(cfg->m_rates.size()) {
|
|
int nrand = 0;
|
|
for(auto r : cfg->m_rates) {
|
|
nrand += r.nRate;
|
|
if(nrate <= nrand) {
|
|
nDownLv = r.nValue;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(nDownLv > pUseItem->wStar)
|
|
nDownLv = pUseItem->wStar;
|
|
((CActor*)m_pEntity)->SendTipmsgFormatWithId(tmUpStarFailDownStar, tstUI, nDownLv);
|
|
pUseItem->wStar -= nDownLv;
|
|
errorCode = 4;
|
|
}
|
|
else
|
|
{
|
|
pUseItem->wStar += 1;
|
|
int nTipId = 0;
|
|
if(pUseItem->wStar >= 11) {
|
|
nTipId = tmItemUpMaxStar2;
|
|
}
|
|
else if(pUseItem->wStar >= 8)
|
|
{
|
|
nTipId = tmItemUpMaxStar1;
|
|
}
|
|
if(nTipId > 0)
|
|
{
|
|
LPCTSTR sFormat = GetLogicServer()->GetDataProvider()->GetTipmsgConfig().GetTipmsg(nTipId);
|
|
const CStdItem* pStdItem = GetLogicServer()->GetDataProvider()->GetStdItemProvider().GetStdItem(pUseItem->wItemId);
|
|
if(pStdItem && sFormat) {
|
|
char sContent[1024]={0};
|
|
sprintf_s(sContent, sizeof(sContent), sFormat, ( char *)(pActor->GetEntityName()), ( char *)(pStdItem->m_sName), pUseItem->wStar);
|
|
GetGlobalLogicEngine()->GetEntityMgr()->BroadNotice(sContent,tstRevolving);
|
|
GetGlobalLogicEngine()->GetEntityMgr()->BroadNotice(sContent,tstChatSystem);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(pCostcfg->cost.size())
|
|
{
|
|
for(int i = 0; i < pCostcfg->cost.size(); i++)
|
|
{
|
|
bool bReplace = false;
|
|
ACTORAWARD& table = pCostcfg->cost[i];
|
|
StarReplaceCfg* res = GetLogicServer()->GetDataProvider()->GetUpStar().getUpStareplaceCfg(table.wId);
|
|
if(res)
|
|
{
|
|
if(nReplace & (1<< res->nId))
|
|
bReplace = true;
|
|
}
|
|
if(!bReplace)
|
|
{
|
|
pActor->RemoveConsume(table.btType, table.wId, table.wCount, -1, -1,-1,0, GameLog::Log_UpStar);
|
|
}
|
|
}
|
|
}
|
|
if(nCostYb)
|
|
{
|
|
pActor->RemoveConsume(qatYuanbao, qatYuanbao, nCostYb, -1, -1,-1,0, GameLog::Log_UpStar);
|
|
}
|
|
// if(pCostcfg->cost.size() > 0) {
|
|
// for(auto co : pCostcfg->cost) {
|
|
// pActor->RemoveConsume(co.btType, co.wId, co.wCount,-1,-1,-1,0,GameLog::Log_UpStar,"up item star cost");
|
|
// }
|
|
// }
|
|
|
|
pActor->GetEquipmentSystem().EquipChange(nEqPos);
|
|
//需要重新计算属性
|
|
m_pEntity->CollectOperate(CEntityOPCollector::coRefAbility);
|
|
// 更新升级后的血、蓝
|
|
|
|
if(nReplace)
|
|
{
|
|
((CActor*)m_pEntity)->SendTipmsgFormatWithId(tmRefiningReplace,tstUI);
|
|
}
|
|
break;
|
|
|
|
}while(false);
|
|
CActorPacket ap;
|
|
CDataPacket& data = pActor->AllocPacket(ap);
|
|
data <<(BYTE)GetSystemID() <<(BYTE)enItemUpStarResult;
|
|
data <<(BYTE)errorCode;
|
|
data <<(int64)series.llId;
|
|
if(pUseItem)
|
|
data <<(WORD)(pUseItem->wStar);
|
|
ap.flush();
|
|
}
|