VOID HumanSkillUpgrade::DepleteItem1()
{
__ENTER_FUNCTION
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_SKILL_STUDY;
INT iItemID = g_SkillStudyCondition.m_aSkillStydy_Condition[m_iSkillID].m_iSpendItem1ID[m_iLevel];
if(( iItemID == INVALID_ID )||( iItemID == 0 ))
{
return;
}
INT iHadItemCount = HumanItemLogic::CalcBagItemCount( m_pHuman, iItemID );
INT iRequireItemNum = g_SkillStudyCondition.m_aSkillStydy_Condition[m_iSkillID].m_iSpendItem1Num[m_iLevel];
HumanItemLogic::EraseBagItem( &ItemLogParam, m_pHuman, iItemID, iHadItemCount-iRequireItemNum );
SaveItemLog( &ItemLogParam );
__LEAVE_FUNCTION
}
uint CGExchangeOkIIIHandler::Execute( CGExchangeOkIII* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
EXCHANGE_CERTIFY_EACH_OTHER(pHuman)
ObjID_t DestID = pHuman->m_ExchangBox.m_ObjID;
Obj_Character *pTarget = (Obj_Character*)(pScene->GetObjManager()->GetObj( DestID ));
if(pTarget->GetObjType() != Obj::OBJ_TYPE_HUMAN)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGExchangeOkIIIHandler: %s ask not a human.", pHuman->GetName() ) ;
return PACKET_EXE_CONTINUE;
}
Obj_Human* pDestHuman = (Obj_Human*)pTarget;
if( pDestHuman == NULL )
{
Assert(FALSE);
return PACKET_EXE_CONTINUE;
}
// 不同阵营，不让查看
if( pHuman->IsEnemy( pDestHuman ) )
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGExchangeOkIIIHandler: %s cann't ask %s's detailattr ", pHuman->GetName(), pDestHuman->GetName() ) ;
return PACKET_EXE_CONTINUE;
}
if(pHuman->m_ExchangBox.m_Status == ServerExchangeBox::EXCHANGE_WAIT_FOR_CONFIRM)
{
//设置可以交换
pHuman->m_ExchangBox.m_Status = ServerExchangeBox::EXCHANGE_CONFIRM_READY;
if(pDestHuman->m_ExchangBox.m_Status == ServerExchangeBox::EXCHANGE_CONFIRM_READY)
{//可以交换了
//1.变量初始化
ItemContainer* pMyExchangeContainer = &(pHuman->m_ExchangBox.m_Container);
ItemContainer* pOtExchangeContainer = &(pDestHuman->m_ExchangBox.m_Container);
ItemContainer* pMyExchangePetContainer = &(pHuman->m_ExchangBox.m_PetContainer);
ItemContainer* pOtExchangePetContainer = &(pDestHuman->m_ExchangBox.m_PetContainer);
_EXCHANGE_ITEM_LIST ItemListMeToOt;
_EXCHANGE_ITEM_LIST ItemListOtToMe;
ItemListMeToOt.Init();
ItemListOtToMe.Init();
//2.验证循环
g_pLog->FastSaveLog( LOG_FILE_1, "<交易> [%s] 与 [%s] 开始验证循环", pHuman->GetName(), pDestHuman->GetName()) ;
for(INT i = 0; i<EXCHANGE_BOX_SIZE; i++)
{
if(pMyExchangeContainer->GetItem(i)->IsEmpty() == FALSE)
{
ItemListMeToOt.AddItem( pMyExchangeContainer->GetItem(i) );
}
if(pOtExchangeContainer->GetItem(i)->IsEmpty() == FALSE)
{
ItemListOtToMe.AddItem( pOtExchangeContainer->GetItem(i) );
}
}
for(INT i = 0; i<EXCHANGE_PET_BOX_SIZE; i++)
{
if(pMyExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
ItemListMeToOt.AddItem( pMyExchangePetContainer->GetItem(i) );
}
if(pOtExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
ItemListOtToMe.AddItem( pOtExchangePetContainer->GetItem(i) );
}
}
if( FALSE == HumanItemLogic::CanReceiveExchangeItemList( pHuman, ItemListOtToMe) )
{//空间不够
GCExchangeError MsgSelf;
MsgSelf.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_ROOM_SELF);
pHuman->GetPlayer()->SendPacket(&MsgSelf);
GCExchangeError MsgOther;
MsgOther.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_ROOM_OTHER);
pDestHuman->GetPlayer()->SendPacket(&MsgOther);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] 空间不够", pHuman->GetName()) ;
return PACKET_EXE_CONTINUE;
}
if( FALSE == HumanItemLogic::CanReceiveExchangeItemList( pDestHuman, ItemListMeToOt) )
{//空间不够
GCExchangeError MsgSelf;
MsgSelf.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_ROOM_SELF);
pDestHuman->GetPlayer()->SendPacket(&MsgSelf);
GCExchangeError MsgOther;
MsgOther.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_ROOM_OTHER);
pHuman->GetPlayer()->SendPacket(&MsgOther);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] 空间不够", pDestHuman->GetName()) ;
return PACKET_EXE_CONTINUE;
}
if( pHuman->m_ExchangBox.m_Money > pHuman->GetMoney() )
{//金钱非法
GCExchangeError MsgSelf;
MsgSelf.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_MONEY_SELF);
pHuman->GetPlayer()->SendPacket(&MsgSelf);
GCExchangeError MsgOther;
MsgOther.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_MONEY_OTHER);
pDestHuman->GetPlayer()->SendPacket(&MsgOther);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] 金钱不足", pHuman->GetName()) ;
return PACKET_EXE_CONTINUE;
}
if( pDestHuman->m_ExchangBox.m_Money > pDestHuman->GetMoney() )
{//金钱非法
GCExchangeError MsgSelf;
MsgSelf.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_MONEY_SELF);
pDestHuman->GetPlayer()->SendPacket(&MsgSelf);
GCExchangeError MsgOther;
MsgOther.SetID(EXCHANGE_MSG::ERR_NOT_ENOUGHT_MONEY_OTHER);
pHuman->GetPlayer()->SendPacket(&MsgOther);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] 金钱不足", pDestHuman->GetName()) ;
return PACKET_EXE_CONTINUE;
}
//2.1宠物验证
Obj_Pet* pDestPet = pDestHuman->GetPet();
Obj_Pet* pMyPet = pHuman->GetPet();
PET_GUID_t DestPetGuid;
PET_GUID_t MyPetGuid;
if(pDestPet)
{
DestPetGuid = pDestPet->GetPetGUID();
}
if(pMyPet)
{
MyPetGuid = pMyPet->GetPetGUID();
}
//如果是当前召唤出来的宠物,先收回来再换
for(INT i = 0; i<EXCHANGE_PET_BOX_SIZE; i++)
{
if(pMyExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
INT nPetLevel = pMyExchangePetContainer->GetItem(i)->GetLevel();
INT nHumanLevel = pDestHuman->GetLevel();
PET_GUID_t ExchPetGuid = pMyExchangePetContainer->GetItem(i)->GetPetGUID();
if(nPetLevel>nHumanLevel)
{
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_PET_LEVEL_TOO_HIGH);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> 宠物级别过高 petlevel = %d, humanlevel = %d", nPetLevel, nHumanLevel) ;
return PACKET_EXE_CONTINUE;
}
if(ExchPetGuid == MyPetGuid)
{
pHuman->ReCallPet();
}
}
if(pOtExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
INT nPetLevel = pOtExchangePetContainer->GetItem(i)->GetLevel();
INT nHumanLevel = pHuman->GetLevel();
PET_GUID_t ExchPetGuid = pOtExchangePetContainer->GetItem(i)->GetPetGUID();
if(nPetLevel>nHumanLevel)
{
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_PET_LEVEL_TOO_HIGH);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> 宠物级别过高 petlevel = %d, humanlevel = %d", nPetLevel, nHumanLevel) ;
return PACKET_EXE_CONTINUE;
}
if(ExchPetGuid == DestPetGuid)
{
pDestHuman->ReCallPet();
}
}
}
//3.移动物品循环
g_pLog->FastSaveLog( LOG_FILE_1, "<交易> [%s] 与 [%s] 开始移动循环", pHuman->GetName(), pDestHuman->GetName()) ;
GCExchangeSuccessIII MsgSuccessToMe, MsgSuccessToOt;
GCExchangeSuccessIII::_SUCC_ITEM ItemListToMe[EXCHANGE_BOX_SIZE+EXCHANGE_PET_BOX_SIZE];
INT MyItemNum = 0;
GCExchangeSuccessIII::_SUCC_ITEM ItemListToOt[EXCHANGE_BOX_SIZE+EXCHANGE_PET_BOX_SIZE];
INT OtItemNum = 0;
BOOL bFlag = FALSE;
//用来记录可以交换的物品
struct ExItem_t
{
UCHAR uItemType;
INT nIndex;
INT nIndexInEx;
ExItem_t()
{
uItemType = 0;
nIndex = -1;
nIndexInEx = -1;
}
};
INT ExItemNumOt = 0;
ExItem_t ExItemIndexInOt[EXCHANGE_BOX_SIZE];
INT ExItemNumMy = 0;
ExItem_t ExItemIndexInMy[EXCHANGE_BOX_SIZE];
INT ExPetItemNumOt = 0;
ExItem_t ExPetItemIndexInOt[EXCHANGE_PET_BOX_SIZE];
INT ExPetItemNumMy = 0;
ExItem_t ExPetItemIndexInMy[EXCHANGE_PET_BOX_SIZE];
for(INT i = 0; i<EXCHANGE_BOX_SIZE; i++)
{
if(pMyExchangeContainer->GetItem(i)->IsEmpty() == FALSE)
{
Item* pItemRef = pMyExchangeContainer->GetItem(i);
ItemContainer* pMyBagContainer = HumanItemLogic::GetItemContain(pHuman, pItemRef->GetItemTableIndex());
ExItemIndexInMy[ExItemNumMy].uItemType = pItemRef->GetItemClass();
ExItemIndexInMy[ExItemNumMy].nIndex = pMyBagContainer->GetIndexByGUID(&pItemRef->GetGUID());
ExItemIndexInMy[ExItemNumMy].nIndexInEx = i;
ExItemNumMy++;
}
if(pOtExchangeContainer->GetItem(i)->IsEmpty() == FALSE)
{
Item* pItemRef = pOtExchangeContainer->GetItem(i);
ItemContainer* pOtBagContainer = HumanItemLogic::GetItemContain(pDestHuman, pItemRef->GetItemTableIndex());
ExItemIndexInOt[ExItemNumOt].uItemType = pItemRef->GetItemClass();
ExItemIndexInOt[ExItemNumOt].nIndex = pOtBagContainer->GetIndexByGUID(&pItemRef->GetGUID());
ExItemIndexInOt[ExItemNumOt].nIndexInEx = i;
ExItemNumOt++;
}
}
for(INT i = 0; i<EXCHANGE_PET_BOX_SIZE; i++)
{
if(pMyExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
Item* pItemRef = pMyExchangePetContainer->GetItem(i);
ItemContainer* pMyPetContainer = pHuman->GetPetContain();
ExPetItemIndexInMy[ExPetItemNumMy].nIndex = pMyPetContainer->GetIndexByGUID(&pItemRef->GetPetGUID());
ExPetItemIndexInMy[ExPetItemNumMy].nIndexInEx = i;
ExPetItemNumMy++;
}
if(pOtExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
Item* pItemRef = pOtExchangePetContainer->GetItem(i);
ItemContainer* pOtPetContainer = pDestHuman->GetPetContain();
ExPetItemIndexInOt[ExPetItemNumOt].nIndex = pOtPetContainer->GetIndexByGUID(&pItemRef->GetPetGUID());
ExPetItemIndexInOt[ExPetItemNumOt].nIndexInEx = i;
ExPetItemNumOt++;
}
}
//3.1先把能交换的交换掉，如果在对方的包中找到了正在跟自己交易的物品，直接交换这两个物品的位置
for(INT i = 0; i<EXCHANGE_BOX_SIZE; i++)
{
if(pMyExchangeContainer->GetItem(i)->IsEmpty() == FALSE)
{
INT result = 0;
Item* pItemRef = pMyExchangeContainer->GetItem(i);
//自己的容器
ItemContainer* pMyBagContainer = HumanItemLogic::GetItemContain(pHuman, pItemRef->GetItemTableIndex());
INT BagIndex = pMyBagContainer->GetIndexByGUID(&pItemRef->GetGUID());
//对方的容器
ItemContainer* pOtBagContainer = HumanItemLogic::GetItemContain(pDestHuman, pItemRef->GetItemTableIndex());
//去换能换得
for(INT j = 0; j<ExItemNumOt; j++)
{
//此位置已经无效
if(ExItemIndexInOt[j].nIndex == -1)
continue;
//只有同一类型的物品才能够交换
if(pItemRef->GetItemClass()!=ExItemIndexInOt[j].uItemType)
continue;
//解锁自己
g_ItemOperator.UnlockItem( pMyBagContainer, BagIndex );
//先解锁对方
g_ItemOperator.UnlockItem( pOtBagContainer, ExItemIndexInOt[j].nIndex );
//设置自己物品已经不是交易物品了
pMyBagContainer->GetItem(BagIndex)->SetInExchange(FALSE);
//设置对方物品已经不是交易物品了
pOtBagContainer->GetItem(ExItemIndexInOt[j].nIndex)->SetInExchange(FALSE);
//与一个对方欲交易的物品交换
result =
g_ItemOperator.ExchangeItem
(
pMyBagContainer,
BagIndex,
pOtBagContainer,
ExItemIndexInOt[j].nIndex
);
if(result<0)
{//拷贝失败
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_ILLEGAL);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] <-> [%s] 物品 [%d]失败 result = %d", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetItemTableIndex(), result );
return PACKET_EXE_CONTINUE;
}
else
{
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_EXCHANGE_TOOTHER;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.TargetGUID = pDestHuman->GetGUID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.ItemGuid = pItemRef->GetGUID();
ItemLogParam.ItemType = pItemRef->GetItemTableIndex();
ItemListToOt[OtItemNum].m_FromType = 0;
ItemListToOt[OtItemNum].m_FromIndex = i;
ItemListToOt[OtItemNum].m_ToType = EXCHANGE_MSG::POS_BAG;
ItemListToOt[OtItemNum++].m_ToIndex = pOtBagContainer->ConIndex2BagIndex(ExItemIndexInOt[j].nIndex);
ItemListToMe[MyItemNum].m_FromType = 0;
ItemListToMe[MyItemNum].m_FromIndex = ExItemIndexInOt[j].nIndexInEx;
ItemListToMe[MyItemNum].m_ToType = EXCHANGE_MSG::POS_BAG;
ItemListToMe[MyItemNum++].m_ToIndex = pMyBagContainer->ConIndex2BagIndex(BagIndex);
//从交易盒中删掉此物品,在后面的移动中就不用再移动它了
g_ItemOperator.EraseItem(pMyExchangeContainer, i);
g_ItemOperator.EraseItem(pOtExchangeContainer, ExItemIndexInOt[j].nIndexInEx);
ExItemIndexInOt[j].nIndex = -1;
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] <-> [%s] 物品 [%d]成功", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetItemTableIndex() );
break;
}
}
}
}
//3.2不能交换的一个一个放进去，剩下的直接由系统找格放入
for(INT i = 0; i<EXCHANGE_BOX_SIZE; i++)
{
if(pMyExchangeContainer->GetItem(i)->IsEmpty() == FALSE)
{
INT result = 0;
Item* pItemRef = pMyExchangeContainer->GetItem(i);
//自己的容器
ItemContainer* pMyBagContainer = HumanItemLogic::GetItemContain(pHuman, pItemRef->GetItemTableIndex());
INT BagIndex = pMyBagContainer->GetIndexByGUID(&pItemRef->GetGUID());
//对方的容器
ItemContainer* pOtBagContainer = HumanItemLogic::GetItemContain(pDestHuman, pItemRef->GetItemTableIndex());
//先解锁
g_ItemOperator.UnlockItem( pMyBagContainer, BagIndex );
pMyBagContainer->GetItem(BagIndex)->SetInExchange(FALSE);
//自动找格，支持自动叠加
//这里的自动找格改成可以自动叠加，这里会有一个问题，上面收取检测时是不考虑叠加状态的，所以，如果非叠加状态下的
//可以收取一系列物品，可叠加的一定可以接受。检测的范围会大一点。
result =
g_ItemOperator.MoveItem
(
pMyBagContainer,
BagIndex,
bFlag,
pOtBagContainer
);
if(result<0)
{//拷贝失败
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_ILLEGAL);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 物品 [%d]失败 result = %d", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetItemTableIndex(), result );
return PACKET_EXE_CONTINUE;
}
else
{
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_EXCHANGE_TOOTHER;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.TargetGUID = pDestHuman->GetGUID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.ItemGuid = pItemRef->GetGUID();
ItemLogParam.ItemType = pItemRef->GetItemTableIndex();
ItemListToOt[OtItemNum].m_FromType = 0;
ItemListToOt[OtItemNum].m_FromIndex = i;
ItemListToOt[OtItemNum].m_ToType = EXCHANGE_MSG::POS_BAG;
ItemListToOt[OtItemNum++].m_ToIndex = pOtBagContainer->ConIndex2BagIndex(result);
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 物品 [%d]成功", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetItemTableIndex() );
}
}
if(pOtExchangeContainer->GetItem(i)->IsEmpty() == FALSE)
{
INT result = 0;
Item* pItemRef = pOtExchangeContainer->GetItem(i);
//对方的容器
ItemContainer* pOtBagContainer = HumanItemLogic::GetItemContain(pDestHuman, pItemRef->GetItemTableIndex());
INT BagIndex = pOtBagContainer->GetIndexByGUID(&pItemRef->GetGUID());
//自己的容器
ItemContainer* pMyBagContainer = HumanItemLogic::GetItemContain(pHuman, pItemRef->GetItemTableIndex());
//先解锁
g_ItemOperator.UnlockItem( pOtBagContainer, BagIndex );
pOtBagContainer->GetItem(BagIndex)->SetInExchange(FALSE);
//自动找格，支持自动叠加
result =
g_ItemOperator.MoveItem
(
pOtBagContainer,
BagIndex,
bFlag,
pMyBagContainer
);
if(result<0)
{//拷贝失败
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_ILLEGAL);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 物品 [%d]失败 result = %d", pDestHuman->GetName(), pHuman->GetName(), pItemRef->GetItemTableIndex(), result );
return PACKET_EXE_CONTINUE;
}
else
{
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_EXCHANGE_TOOTHER;
ItemLogParam.CharGUID = pDestHuman->GetGUID();
ItemLogParam.TargetGUID = pHuman->GetGUID();
ItemLogParam.XPos = pDestHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pDestHuman->getWorldPos()->m_fZ;
ItemLogParam.SceneID = pDestHuman->getScene()->SceneID();
ItemLogParam.ItemGuid = pItemRef->GetGUID();
ItemLogParam.ItemType = pItemRef->GetItemTableIndex();
SaveItemLog(&ItemLogParam);
ItemListToMe[MyItemNum].m_FromType = 0;
ItemListToMe[MyItemNum].m_FromIndex = i;
ItemListToMe[MyItemNum].m_ToType = EXCHANGE_MSG::POS_BAG;
ItemListToMe[MyItemNum++].m_ToIndex = pMyBagContainer->ConIndex2BagIndex(result);
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 物品 [%d]成功", pDestHuman->GetName(), pHuman->GetName(), pItemRef->GetItemTableIndex() );
}
}
}
//3.3换宠物
g_pLog->FastSaveLog( LOG_FILE_1, "<交易> [%s] 与 [%s] 开始交换宠物", pHuman->GetName(), pDestHuman->GetName()) ;
for(INT i = 0; i<EXCHANGE_PET_BOX_SIZE; i++)
{
INT result = 0;
Item* pItemRef = pMyExchangePetContainer->GetItem(i);
if(pItemRef->IsEmpty())
continue;
PET_LOG_PARAM PetLogParam;
PetLogParam.PetGUID = pItemRef->GetPetGUID();
PetLogParam.DataID = pItemRef->GetDataID();
//自己的容器
ItemContainer* pMyPetContainer = pHuman->GetPetContain();
INT PetIndexInBag = pMyPetContainer->GetIndexByGUID(&pItemRef->GetPetGUID());
//对方的容器
ItemContainer* pOtPetContainer = pDestHuman->GetPetContain();
//去换能换得
for(INT j = 0; j<ExPetItemNumOt; j++)
{
//如果无效
if(ExPetItemIndexInOt[j].nIndex == -1)
continue;
//解锁自己
g_ItemOperator.UnlockItem( pMyPetContainer, PetIndexInBag );
//先解锁对方
g_ItemOperator.UnlockItem( pOtPetContainer, ExPetItemIndexInOt[j].nIndex );
//设置自己物品已经不是交易物品了
pMyPetContainer->GetItem(PetIndexInBag)->SetInExchange(FALSE);
//设置对方物品已经不是交易物品了
pOtPetContainer->GetItem(ExPetItemIndexInOt[j].nIndex )->SetInExchange(FALSE);
//与一个对方欲交易的物品交换
result =
g_ItemOperator.ExchangeItem
(
pMyPetContainer,
PetIndexInBag,
pOtPetContainer,
ExPetItemIndexInOt[j].nIndex
);
if(result<0)
{//拷贝失败
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_ILLEGAL);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] <-> [%s] 物品 [%d]失败 result = %d", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetItemTableIndex(), result );
return PACKET_EXE_CONTINUE;
}
else
{
PetLogParam.CharGUID = pDestHuman->GetGUID();
PetLogParam.OPType = PET_OP_EXCHANGE_OTHER;
PetLogParam.SceneID = pDestHuman->getScene()->SceneID();
PetLogParam.TargetGUID = pHuman->GetGUID();
PetLogParam.XPos = pDestHuman->getWorldPos()->m_fX;
PetLogParam.ZPos = pDestHuman->getWorldPos()->m_fZ;
SavePetLog(&PetLogParam);
ItemListToMe[MyItemNum].m_FromType = EXCHANGE_MSG::POS_PET;
ItemListToMe[MyItemNum].m_FromIndex = ExPetItemIndexInOt[j].nIndexInEx;
ItemListToMe[MyItemNum].m_ToType = EXCHANGE_MSG::POS_PET;
ItemListToMe[MyItemNum++].m_ToIndex = PetIndexInBag;
ItemListToOt[OtItemNum].m_FromType = EXCHANGE_MSG::POS_PET;
ItemListToOt[OtItemNum].m_FromIndex = i;
ItemListToOt[OtItemNum].m_ToType = EXCHANGE_MSG::POS_PET;
ItemListToOt[OtItemNum++].m_ToIndex = ExPetItemIndexInOt[j].nIndex;
//从交易盒中删掉此物品,在后面的移动中就不用再移动它了
g_ItemOperator.EraseItem(pMyExchangePetContainer, i);
g_ItemOperator.EraseItem(pOtExchangePetContainer, ExPetItemIndexInOt[j].nIndexInEx);
ExPetItemIndexInOt[j].nIndex = -1;
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] <-> [%s] 物品 [%s]成功", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetName() );
break;
}
}
}
//3.4移宠物
for(INT i = 0; i<EXCHANGE_PET_BOX_SIZE; i++)
{
if(pMyExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
INT result = 0;
Item* pItemRef = pMyExchangePetContainer->GetItem(i);
PET_LOG_PARAM PetLogParam;
PetLogParam.PetGUID = pItemRef->GetPetGUID();
PetLogParam.DataID = pItemRef->GetDataID();
//自己的容器
ItemContainer* pMyPetContainer = pHuman->GetPetContain();
INT PetIndexInBag = pMyPetContainer->GetIndexByGUID(&pItemRef->GetPetGUID());
//对方的容器
ItemContainer* pOtPetContainer = pDestHuman->GetPetContain();
//先解锁
g_ItemOperator.UnlockItem( pMyPetContainer, PetIndexInBag );
pMyPetContainer->GetItem(PetIndexInBag)->SetInExchange(FALSE);
//自动找格，支持自动叠加
//这里的自动找格改成可以自动叠加，这里会有一个问题，上面收取检测时是不考虑叠加状态的，所以，如果非叠加状态下的
//可以收取一系列物品，可叠加的一定可以接受。检测的范围会大一点。
result =
g_ItemOperator.MoveItem
(
pMyPetContainer,
PetIndexInBag,
pOtPetContainer
);
if(result<0)
{//拷贝失败
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_ILLEGAL);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 宠物 [%s]失败 result = %d", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetName(), result );
return PACKET_EXE_CONTINUE;
}
else
{
PetLogParam.CharGUID = pDestHuman->GetGUID();
PetLogParam.OPType = PET_OP_EXCHANGE_OTHER;
PetLogParam.SceneID = pDestHuman->getScene()->SceneID();
PetLogParam.TargetGUID = pHuman->GetGUID();
PetLogParam.XPos = pDestHuman->getWorldPos()->m_fX;
PetLogParam.ZPos = pDestHuman->getWorldPos()->m_fZ;
SavePetLog(&PetLogParam);
ItemListToOt[OtItemNum].m_FromType = EXCHANGE_MSG::POS_PET;
ItemListToOt[OtItemNum].m_FromIndex = i;
ItemListToOt[OtItemNum].m_ToType = EXCHANGE_MSG::POS_PET;
ItemListToOt[OtItemNum++].m_ToIndex = result;
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 宠物 [%s]成功", pHuman->GetName(), pDestHuman->GetName(), pItemRef->GetName() );
}
}
if(pOtExchangePetContainer->GetItem(i)->IsEmpty() == FALSE)
{
INT result = 0;
Item* pItemRef = pOtExchangePetContainer->GetItem(i);
PET_LOG_PARAM PetLogParam;
PetLogParam.PetGUID = pItemRef->GetPetGUID();
PetLogParam.DataID = pItemRef->GetDataID();
//对方的容器
ItemContainer* pOtPetContainer = pDestHuman->GetPetContain();
INT PetIndexInBag = pOtPetContainer->GetIndexByGUID(&pItemRef->GetPetGUID());
//自己的容器
ItemContainer* pMyPetContainer = pHuman->GetPetContain();
//先解锁
g_ItemOperator.UnlockItem( pOtPetContainer, PetIndexInBag );
pOtPetContainer->GetItem(PetIndexInBag)->SetInExchange(FALSE);
//自动找格，支持自动叠加
result =
g_ItemOperator.MoveItem
(
pOtPetContainer,
PetIndexInBag,
pMyPetContainer
);
if(result<0)
{//拷贝失败
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_ILLEGAL);
pHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 宠物 [%s]失败 result = %d", pDestHuman->GetName(), pHuman->GetName(), pItemRef->GetName(), result );
return PACKET_EXE_CONTINUE;
}
else
{
PetLogParam.CharGUID = pHuman->GetGUID();
PetLogParam.OPType = PET_OP_EXCHANGE_OTHER;
PetLogParam.SceneID = pHuman->getScene()->SceneID();
PetLogParam.TargetGUID = pDestHuman->GetGUID();
PetLogParam.XPos = pHuman->getWorldPos()->m_fX;
PetLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
SavePetLog(&PetLogParam);
ItemListToMe[MyItemNum].m_FromType = EXCHANGE_MSG::POS_PET;
ItemListToMe[MyItemNum].m_FromIndex = i;
ItemListToMe[MyItemNum].m_ToType = EXCHANGE_MSG::POS_PET;
ItemListToMe[MyItemNum++].m_ToIndex = result;
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 宠物 [%s]成功", pDestHuman->GetName(), pHuman->GetName(), pItemRef->GetName() );
}
}
}
//2.换钱
g_pLog->FastSaveLog( LOG_FILE_1, "<交易> [%s] 与 [%s] 开始交换金钱", pHuman->GetName(), pDestHuman->GetName()) ;
if( pHuman->m_ExchangBox.m_Money <= pHuman->GetMoney() && pHuman->m_ExchangBox.m_Money>0 )
{
pDestHuman->SetMoney(pDestHuman->GetMoney()+pHuman->m_ExchangBox.m_Money);
pHuman->SetMoney(pHuman->GetMoney()-pHuman->m_ExchangBox.m_Money);
MONEY_LOG_PARAM MoneyLogParam;
MoneyLogParam.CharGUID = pHuman->GetGUID();
MoneyLogParam.TargetGUID = pDestHuman->GetGUID();
MoneyLogParam.OPType = MONEY_EXCHANGE_OUTCOME;
MoneyLogParam.Count = pHuman->m_ExchangBox.m_Money;
MoneyLogParam.SceneID = pHuman->getScene()->SceneID();
MoneyLogParam.XPos = pHuman->getWorldPos()->m_fX;
MoneyLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
SaveMoneyLog(&MoneyLogParam);
MoneyLogParam.CharGUID = pDestHuman->GetGUID();
MoneyLogParam.TargetGUID = pHuman->GetGUID();
MoneyLogParam.OPType = MONEY_EXCHANGE_INCOME;
MoneyLogParam.Count = pHuman->m_ExchangBox.m_Money;
MoneyLogParam.SceneID = pDestHuman->getScene()->SceneID();
MoneyLogParam.XPos = pDestHuman->getWorldPos()->m_fX;
MoneyLogParam.ZPos = pDestHuman->getWorldPos()->m_fZ;
SaveMoneyLog(&MoneyLogParam);
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 金钱 [%d]", pHuman->GetName(), pDestHuman->GetName(), pHuman->m_ExchangBox.m_Money );
}
if( pDestHuman->m_ExchangBox.m_Money <= pDestHuman->GetMoney() && pDestHuman->m_ExchangBox.m_Money>0 )
{
pHuman->SetMoney(pHuman->GetMoney()+pDestHuman->m_ExchangBox.m_Money);
pDestHuman->SetMoney(pDestHuman->GetMoney() - pDestHuman->m_ExchangBox.m_Money);
MONEY_LOG_PARAM MoneyLogParam;
MoneyLogParam.CharGUID = pHuman->GetGUID();
MoneyLogParam.TargetGUID = pDestHuman->GetGUID();
MoneyLogParam.OPType = MONEY_EXCHANGE_INCOME;
MoneyLogParam.Count = pDestHuman->m_ExchangBox.m_Money;
MoneyLogParam.SceneID = pHuman->getScene()->SceneID();
MoneyLogParam.XPos = pHuman->getWorldPos()->m_fX;
MoneyLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
SaveMoneyLog(&MoneyLogParam);
MoneyLogParam.CharGUID = pDestHuman->GetGUID();
MoneyLogParam.TargetGUID = pHuman->GetGUID();
MoneyLogParam.OPType = MONEY_EXCHANGE_OUTCOME;
MoneyLogParam.Count = pDestHuman->m_ExchangBox.m_Money;
MoneyLogParam.SceneID = pDestHuman->getScene()->SceneID();
MoneyLogParam.XPos = pDestHuman->getWorldPos()->m_fX;
MoneyLogParam.ZPos = pDestHuman->getWorldPos()->m_fZ;
SaveMoneyLog(&MoneyLogParam);
g_pLog->FastSaveLog( LOG_FILE_1, " <交易> [%s] -> [%s] 金钱 [%d]", pDestHuman->GetName(), pHuman->GetName(), pDestHuman->m_ExchangBox.m_Money );
}
//给双方发送成功消息
MsgSuccessToMe.SetItemNum(MyItemNum);
MsgSuccessToMe.SetItemList(ItemListToMe);
pHuman->GetPlayer()->SendPacket(&MsgSuccessToMe);
MsgSuccessToOt.SetItemNum(OtItemNum);
MsgSuccessToOt.SetItemList(ItemListToOt);
pDestHuman->GetPlayer()->SendPacket(&MsgSuccessToOt);
g_pLog->FastSaveLog( LOG_FILE_1, "<交易> [%s] 与 [%s] 交易成功", pHuman->GetName(), pDestHuman->GetName()) ;
//能走到这儿证明所有操作都已完成清空各自的交易盒
pHuman->m_ExchangBox.CleanUp();
pDestHuman->m_ExchangBox.CleanUp();
}
else
{//啥也不做,等待对方消息
}
}
else
{//一定出错了
GCExchangeError Msg;
Msg.SetID(EXCHANGE_MSG::ERR_ILLEGAL);
pHuman->GetPlayer()->SendPacket(&Msg);
pHuman->m_ExchangBox.CleanUp();
pDestHuman->GetPlayer()->SendPacket(&Msg);
pDestHuman->m_ExchangBox.CleanUp();
return PACKET_EXE_CONTINUE;
}
return PACKET_EXE_CONTINUE ;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
UINT CGEquipRefiningHandler::Execute( CGEquipRefining* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID );
//切场景时丢弃换装消息
//交易状态不可操作
//摆摊状态不可操作
// 获取炼化的装备
BYTE iEquipItemPos = pPacket->GetEquipItemPos();
Assert(iEquipItemPos >= 0 );
Assert(iEquipItemPos <= MAX_BAG_SIZE);
GCEquipRefining msg;
ItemContainer* pBagContainer = HumanItemLogic::GetBagContainer(pHuman, iEquipItemPos);
if (pBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRefiningHandler equipment BagIndex is invalid, BagIndex = %d", iEquipItemPos) ;
msg.SetResult(EQUIPREFINING_NOT_SUCH_ITEM);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
Item* pEquipment = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(iEquipItemPos));
Assert(NULL != pEquipment);
//一些验证：星级，等级...
if( NULL == pEquipment || ICLASS_EQUIP != pEquipment->GetItemClass() || !(pEquipment->IsRuler(IRL_DISCARD) )
|| pEquipment->IsAdsorbMagic() || pEquipment->GetRequireLevel() < EQUIP_REFINING_MIN_LEVEL //已经附魔或者需求等级小于40
|| 0 == pEquipment->GetEquipGemCount()) //没有镶嵌宝石
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRefiningHandler equipment type is invalid, BagIndex = %d", iEquipItemPos) ;
msg.SetResult(EQUIPREFINING_NOT_SUCH_ITEM);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
//获取炼化神器
BYTE iRefiningItemPos = pPacket->GetRefiningItemPos();
Assert(iRefiningItemPos >= 0 );
Assert(iRefiningItemPos <= MAX_BAG_SIZE);
pBagContainer = HumanItemLogic::GetBagContainer(pHuman, iRefiningItemPos);
if (pBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRefiningHandler refining BagIndex is invalid, BagIndex = %d", iRefiningItemPos) ;
msg.SetResult(EQUIPREFINING_NOT_SUCH_ITEM);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
Item* pRefiningItem = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(iRefiningItemPos));
Assert(NULL != pRefiningItem);
if(NULL == pRefiningItem || pRefiningItem->GetItemClass() != ICLASS_COMITEM || pRefiningItem->GetItemType() != COMITEM_EQUIP_REFINING)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRefiningHandler refining type is invalid, BagIndex = %d", iRefiningItemPos) ;
msg.SetResult(EQUIPREFINING_NOT_SUCH_ITEM);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
//逻辑处理
COMMITEM_INFO_TB* pGet = g_ItemTable.GetCommItemInfoTB(pRefiningItem->GetItemTableIndex());
Assert(NULL != pGet);
if ((pEquipment->GetRequireLevel()-1)/10+1 != pGet->m_nLevel)//验证等级
{
msg.SetResult(EQUIPREFINING_NOT_SUCH_ITEM);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
if ( 0 == pEquipment->GetAttrCount())// && pEquipment->GetLevel()
{
msg.SetResult(EQUIPREFINING_NOT_HAVE_ATTR);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
//EQUIP_TB* pGet = g_ItemTable.GetEquipTB(pEquipment->GetItemTableIndex());
//Assert(NULL != pGet);
//删除装备和炼化神符道具
UINT iPrice = pEquipment->GetSellPrice();//保留将要删除的装备属性给后面用
BYTE iRequireLevel = pEquipment->GetRequireLevel();
BYTE curEquipPoint = pEquipment->GetEquipPoint();
BYTE attrCount = 0;
_ITEM_ATTR tmpItemAttr[MAX_ITEM_ATTR];
for (BYTE index=0; index<pEquipment->GetAttrCount(); ++index)
{
tmpItemAttr[index] = pEquipment->GetEquipAttr(index);
if (tmpItemAttr[index].m_AttrType > 0)
{
attrCount++;
}
}
Assert(attrCount == pEquipment->GetAttrCount());
//开始删除装备和扣除金钱
BOOL bRet = FALSE;
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_EQUIP_REFINING;
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman, pBagContainer->BagIndex2ConIndex(iEquipItemPos));
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
else
{
msg.SetResult(EQUIPREFINING_ERASE_ITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
//删除炼化道具
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman, pBagContainer->BagIndex2ConIndex(iRefiningItemPos));
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
else
{
msg.SetResult(EQUIPREFINING_ERASE_ITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
UINT iSoulBeadBagIndex = 0;
Item* pSoulBeadItem = NULL;
//武魂珠
if (HEQUIP_MAINHAND == curEquipPoint)
{
bRet = HumanItemLogic::CreateItemToBag(&ItemLogParam,pHuman,ITEM_WU_SOUL_BEAD, iSoulBeadBagIndex);
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
else
{
msg.SetResult(EQUIPREFINING_ERASE_ITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
pSoulBeadItem = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(iSoulBeadBagIndex));
Assert(NULL != pSoulBeadItem);
Assert(ICLASS_SOUL_BEAD == pSoulBeadItem->GetItemClass());
pSoulBeadItem->SetSoulBeadPrice(iPrice);//由基本价格计算得出
pSoulBeadItem->SetSoulBeadNeedLevel(iRequireLevel);
pSoulBeadItem->SetWuSoulBeadAttr(attrCount, tmpItemAttr);
}//器魂珠
else if (EQUIP_CAP == pEquipment->GetItemType()//EQUIP_PIFENG == pEquipment->GetEquipPoint() ||
|| EQUIP_SHOULDER == pEquipment->GetItemType() || EQUIP_HAND == pEquipment->GetItemType()
|| EQUIP_ARMOR == pEquipment->GetItemType() || EQUIP_BOOT == pEquipment->GetItemType())
{
bRet = HumanItemLogic::CreateItemToBag(&ItemLogParam,pHuman,ITEM_WU_SOUL_BEAD, iSoulBeadBagIndex);
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
else
{
msg.SetResult(EQUIPREFINING_ERASE_ITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
pSoulBeadItem = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(iSoulBeadBagIndex));
Assert(NULL != pSoulBeadItem);
Assert(ICLASS_SOUL_BEAD == pSoulBeadItem->GetItemClass());
pSoulBeadItem->SetSoulBeadPrice(iPrice);//由基本价格计算得出
pSoulBeadItem->SetSoulBeadNeedLevel(iRequireLevel);
pSoulBeadItem->SetQiSoulBeadAttr(attrCount, tmpItemAttr);
}
// 通知增加道具到背包
GCNotifyEquip ItemMsg;
Assert(pSoulBeadItem);
ItemMsg.SetBagIndex(iSoulBeadBagIndex);
pSoulBeadItem->SaveValueTo(ItemMsg.GetItem());
pGamePlayer->SendPacket(&ItemMsg);
msg.SetResult(EQUIPREFINING_SUCCESS);
//pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
uint CGShopBuyHandler::Execute( CGShopBuy* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
BYTE m_nndex = pPacket->GetIndex(); //资源位置索引
UINT UniqueID = pPacket->GetUniqueID();
SceneID_t SceneID = UniqueID>>16;
ObjID_t NpcObjID= UniqueID&0x00ff;
//距离判定
Obj* pNpcObj = (Obj*) (pScene->GetObjManager()->GetObj(NpcObjID));
if(pNpcObj == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopBuyHandler Illegal Obj") ;
return PACKET_EXE_CONTINUE ;
}
FLOAT fDist = MySqrt(pNpcObj->getWorldPos(), pHuman->getWorldPos());
if(fDist>MAX_NPC_DISTANCE)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopBuyHandler Out Of Range") ;
return PACKET_EXE_CONTINUE ;
}
if(pHuman->Shop( ) == NULL)
{//没有打开交易窗口就买
Assert(0);
return PACKET_EXE_CONTINUE ;
}
//打开商店时，这个商店的指针已经被存在human身上了，关闭商店时它会被清空
_SHOP* pShop = pHuman->Shop( ) ;
INT itemNumber = 0;
//暂时规定200以上为回购的商品栏
if(m_nndex >= 200)
{//在回购队列中查找
m_nndex -= 200;
_ITEM tempItem;
UINT uPrice = 0;
if(!pHuman->GetFromSoldListByIndex(m_nndex, tempItem, uPrice))
{
//Assert(0);
return PACKET_EXE_CONTINUE ;
}
itemNumber = tempItem.GetItemCount();
INT iPrice = (INT)uPrice;
if( ((INT)pHuman->GetMoney()) < iPrice )
{//金钱不够
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_MONEY_FAIL);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
return PACKET_EXE_CONTINUE ;
}
if(!pHuman->RecieveOneFromSoldList(m_nndex))
{
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_BAG_FULL);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
return PACKET_EXE_CONTINUE ;
}
else
{//从回购列表里面购买成功
pHuman->SetMoney( pHuman->GetMoney() - iPrice);
MONEY_LOG_PARAM MoneyLogParam;
MoneyLogParam.CharGUID = pHuman->GetGUID();
MoneyLogParam.OPType = MONEY_SHOP_COST;
MoneyLogParam.Count = iPrice;
MoneyLogParam.SceneID = pHuman->getScene()->SceneID();
MoneyLogParam.XPos = pHuman->getWorldPos()->m_fX;
MoneyLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
SaveMoneyLog(&MoneyLogParam);
GCShopBuy Msg ;
Msg.SetBuyOk( (BYTE)GCShopBuy::BUY_OK );
Msg.SetIndex( tempItem.m_ItemIndex );
Msg.SetNum( tempItem.GetItemCount() );
pHuman->GetPlayer()->SendPacket( &Msg ) ;
//更新回购按钮
//刷新整个回购列表商品到界面
GCShopSoldList::_MERCHANDISE_ITEM SoldItem[MAX_BOOTH_SOLD_NUMBER];
// 20100413 AddCodeBegin
pHuman->ReorderSoldList(); // 重新整理回购物品列表，去除中间的空物品格
// 20100413 AddCodeBegin
pHuman->GetSlodListInfo(&SoldItem[0]);
GCShopSoldList MsgSold;
MsgSold.SetMerchadiseNum(MAX_BOOTH_SOLD_NUMBER);
MsgSold.SetMerchadiseList(&SoldItem[0]);
pHuman->GetPlayer()->SendPacket( &MsgSold );
}
}
else
{//在商人挂的商店里查找
//一次点击可以买的个数 0为约定值，为默认购买数量以商店配置文件为准
INT itemNumber;
if (pPacket->GetCount() == 0)
{
itemNumber = 1;
}
else
{
itemNumber = pPacket->GetCount();
}
if( pShop->m_IsDyShop )
{
//校验商店版本，不匹配提示客户端刷新贩卖列表
if (pShop->m_nVersion != pPacket->GetVersion())
{
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_MUST_FRESH);
pPlayer->SendPacket( &Msg ) ;
//填充消息
GCShopUpdateMerchandiseList::_MERCHANDISE_ITEM MerchandiseList[MAX_BOOTH_NUMBER];
INT k = 0;
for(INT i = 0;i<pShop->m_ItemList->m_ListCount;i++)
{
MerchandiseList[k].idTable = pShop->m_ItemList->m_ListTypeIndex[i];
MerchandiseList[k].MaxNumber = pShop->m_ItemList->m_TypeMaxNum[i];
MerchandiseList[k].nPrice = pShop->m_ItemList->m_Price[i];
MerchandiseList[k].nPriceType = pShop->m_ItemList->m_PriceType[i];
MerchandiseList[k++].byNumber = pShop->m_ItemList->m_TypeMaxNum[i];
}
GCShopUpdateMerchandiseList listMsg;
listMsg.SetMerchadiseNum(k);//一定要先设置数量再设置List
listMsg.SetMerchadiseList(MerchandiseList);
listMsg.SetVersion(pShop->m_nVersion);
pHuman->GetPlayer()->SendPacket( &listMsg ) ;
return PACKET_EXE_CONTINUE ;
}
//有限商品不够卖了
if(pShop->m_ItemList->m_TypeMaxNum[m_nndex] < itemNumber)
{//卖完了，直接返回，
//应该不会走到这里，
//首先表里不应该出现0,
//其次卖完的时候服务器会通知所有连在他之上的客户端
//在界面上删掉这个商品，这样玩家也不可能再点这个商品了
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_NO_MERCH);
pPlayer->SendPacket( &Msg ) ;
return PACKET_EXE_CONTINUE ;
}
}
uint BaseMoney= 0;
//静态商店，只扣游戏币
if (!pShop->m_IsDyShop)
{
//计算价格
BaseMoney = ShopMgr::ConvertItemType2Money(pShop->m_ItemList->m_ListType[m_nndex]);
if(BaseMoney<0) BaseMoney = 0;
BaseMoney *= static_cast<INT>(pShop->m_scale);
BaseMoney *= itemNumber;
if( pHuman->GetMoney() < BaseMoney )
{//金钱不够
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_MONEY_FAIL);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
return PACKET_EXE_CONTINUE ;
}
}
else//动态商店
{
INT nPriceType = pShop->m_ItemList->m_PriceType[m_nndex];
INT nPrice = pShop->m_ItemList->m_Price[m_nndex];
switch (nPriceType)
{
case PRICE_GOLD:
{
INT nGold = pHuman->GetMoney();
nGold -= nPrice*itemNumber;
if (nGold < 0)//这里只管防止发生错误，为什么就不管了
{
nGold = 0;
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_MONEY_FAIL);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
return PACKET_EXE_CONTINUE ;
}
pHuman->SetMoney(nGold);
}
break;
case PRICE_RMB:
break;
case PRICE_GP://帮贡
{
INT nTotal = pHuman->GetHonor() - nPrice*itemNumber;
if (nTotal < 0)
{
nTotal = 0;
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_MONEY_FAIL);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
return PACKET_EXE_CONTINUE ;
}
pHuman->SetHonor(nTotal);
}
break;
}
}
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_CREATE_FROM_SHOP;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
ItemLogParam.ShopGUID = pShop->m_ShopId;
if(!HumanItemLogic::CreateMultiItemToBag(&ItemLogParam,
pHuman,
pShop->m_ItemList->m_ListTypeIndex[m_nndex],
itemNumber))
{
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_BAG_FULL);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
return PACKET_EXE_CONTINUE ;
}
else
{
SaveItemLog(&ItemLogParam);
if (!pShop->m_IsDyShop)
{
pHuman->SetMoney( pHuman->GetMoney() - BaseMoney);
MONEY_LOG_PARAM MoneyLogParam;
MoneyLogParam.CharGUID = pHuman->GetGUID();
MoneyLogParam.OPType = MONEY_SHOP_COST;
MoneyLogParam.Count = BaseMoney;
MoneyLogParam.SceneID = pHuman->getScene()->SceneID();
MoneyLogParam.XPos = pHuman->getWorldPos()->m_fX;
MoneyLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
SaveMoneyLog(&MoneyLogParam);
}
GCShopBuy Msg ;
Msg.SetBuyOk((BYTE)GCShopBuy::BUY_OK);
Msg.SetIndex(pShop->m_ItemList->m_ListTypeIndex[m_nndex]);
Msg.SetNum(itemNumber);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
//要更新此商人的动态商品表
if(pShop->m_IsDyShop)
{
// 扣除有限物品
pShop->m_ItemList->m_TypeMaxNum[m_nndex] -= itemNumber;
//填充消息
GCShopUpdateMerchandiseList::_MERCHANDISE_ITEM MerchandiseList[MAX_BOOTH_NUMBER];
INT k = 0;
for(INT i = 0;i<pShop->m_ItemList->m_ListCount;i++)
{
MerchandiseList[k].idTable = pShop->m_ItemList->m_ListTypeIndex[i];
MerchandiseList[k].MaxNumber = pShop->m_ItemList->m_TypeMaxNum[i];
MerchandiseList[k].nPrice = pShop->m_ItemList->m_Price[i];
MerchandiseList[k].nPriceType = pShop->m_ItemList->m_PriceType[i];
MerchandiseList[k++].byNumber = pShop->m_ItemList->m_TypeMaxNum[i];
}
GCShopUpdateMerchandiseList Msg;
Msg.SetMerchadiseNum(k);//一定要先设置数量再设置List
Msg.SetMerchadiseList(MerchandiseList);
Msg.SetVersion(pShop->m_nVersion);
pHuman->GetPlayer()->SendPacket( &Msg ) ;
}
return PACKET_EXE_CONTINUE ;
}
}
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopBuyHandler m_nndex=%d",
m_nndex) ;
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
uint CGDiscardEquipHandler::Execute(CGDiscardEquip* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
HUMAN_EQUIP EquipPoint = (HUMAN_EQUIP)pPacket->GetEquipPoint();
//Assert( pHuman->GetDB()->GetEquipDB()->IsSet(EquipPoint)) ;
Item* pEquip = HumanItemLogic::GetEquip(pHuman,EquipPoint);
if(!pEquip)
{
Assert(pEquip);
return PACKET_EXE_CONTINUE;
}
GCDiscardEquipResult Msg;
if(pEquip->IsEmpty())
{
Msg.SetResult(DISCARDEQUIP_NO_SUCH_EQUIP);
}
if(pEquip->IsRuler(IRL_DISCARD))
{
Msg.SetItemTableIndex(pEquip->GetItemTableIndex());
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_DISCARD_EQUIP;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.BagPos = EquipPoint;
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
BOOL bRet = g_ItemOperator.EraseItem(pHuman->GetEquipContain(),EquipPoint);
if(bRet) SaveItemLog(&ItemLogParam);
pHuman->SetEquipVer(pHuman->GetEquipVer()+1);
pHuman->ItemEffectFlush();
Msg.SetResult(DISCARDEQUIP_SUCCESS);
Msg.SetEquipPoint(EquipPoint);
//如果可见
if(pHuman->IsVisualPart(EquipPoint))
{
GCCharEquipment OtherMsg;
OtherMsg.setObjID(pHuman->GetID());
OtherMsg.setID(EquipPoint,-1, -1);
pScene->BroadCast(&OtherMsg,pHuman,TRUE);
}
}
else
{
Msg.SetResult(DISCARDEQUIP_CANNT_DISCARD);
}
pGamePlayer->SendPacket(&Msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGDiscardEquipHandler: ok EquipPoint=%d",
EquipPoint ) ;
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
UINT CGSouXiaRefiningHandler::Execute( CGSouXiaRefining* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID );
//切场景时丢弃换装消息
//交易状态不可操作
//摆摊状态不可操作
// 获取缝合的捜侠录和缝合道具
BYTE iRefiningSouXiaItem = pPacket->GetRefiningSouXiaIndex();
Assert(iRefiningSouXiaItem >= 0 );
Assert(iRefiningSouXiaItem <= MAX_BAG_SIZE);
BYTE iRefiningSouXiaItem2 = pPacket->GetRefiningSouXia2Index();
Assert(iRefiningSouXiaItem2 >= 0 );
Assert(iRefiningSouXiaItem2 <= MAX_BAG_SIZE);
BYTE iRefiningItem = pPacket->GetRefiningItemIndex();
Assert(iRefiningItem >= 0 );
Assert(iRefiningItem <= MAX_BAG_SIZE);
GCSouXiaRefining refiningMsg;
// 背包索引获取搜侠道具信息并验证
ItemContainer* pBagContainer = HumanItemLogic::GetBagContainer(pHuman, iRefiningSouXiaItem);
if (pBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSouXiaRefining souxia BagIndex is invalid, BagIndex = %d", iRefiningSouXiaItem) ;
return PACKET_EXE_ERROR;
}
Item* pRefiningSouXiaItem = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(iRefiningSouXiaItem));
if(pRefiningSouXiaItem->GetItemClass() != ICLASS_EQUIP || EQUIP_SOUXIA != pRefiningSouXiaItem->GetItemType())
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSouXiaRefining souxia type is invalid, BagIndex = %d", iRefiningSouXiaItem) ;
refiningMsg.SetResult(GET_ITEM_ERROR);
pGamePlayer->SendPacket(&refiningMsg);
return PACKET_EXE_ERROR;
}
// 背包索引获取第二本搜侠录道具信息
pBagContainer = HumanItemLogic::GetBagContainer(pHuman, iRefiningSouXiaItem2);
if (pBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSouXiaRefining souxia BagIndex is invalid, BagIndex = %d", iRefiningSouXiaItem2) ;
return PACKET_EXE_ERROR;
}
Item* pRefiningSouXiaItem2 = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(iRefiningSouXiaItem2));
if(pRefiningSouXiaItem2->GetItemClass() != ICLASS_EQUIP || EQUIP_SOUXIA != pRefiningSouXiaItem2->GetItemType())
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSouXiaRefining souxia type is invalid, BagIndex = %d", iRefiningSouXiaItem2) ;
refiningMsg.SetResult(GET_ITEM_ERROR);
pGamePlayer->SendPacket(&refiningMsg);
return PACKET_EXE_ERROR;
}
// 背包索引获取炼化道具信息
pBagContainer = HumanItemLogic::GetBagContainer(pHuman, iRefiningItem);
if (pBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSouXiaRefining refiningItem BagIndex is invalid, BagIndex = %d", iRefiningItem) ;
return PACKET_EXE_ERROR;
}
Item* pRefiningItem = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(iRefiningItem));
if(pRefiningItem->GetItemClass() != ICLASS_COMITEM || COMITEM_SOUXIA != pRefiningItem->GetItemType())
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSouXiaRefining refiningItem type is invalid, BagIndex = %d", iRefiningSouXiaItem2) ;
refiningMsg.SetResult(GET_ITEM_ERROR);
pGamePlayer->SendPacket(&refiningMsg);
return PACKET_EXE_ERROR;
}
SOUXIA_INFO_TB* pGet = g_ItemTable.GetSouXiaTB(pRefiningItem->GetItemTableIndex());
if (NULL != pGet && ITEM_REFINING == pGet->m_nUseType)
{
if(pGet->m_nNeedLevel > pHuman->GetLevel()) // 使用道具没有达到限制等级
{
refiningMsg.SetResult(HUMAN_LEVEL_NOT_ENOUGH);
Player* pPlayer = pHuman->GetPlayer();
if( pPlayer != NULL )
{
pPlayer->SendPacket( &refiningMsg );
}
return PACKET_EXE_CONTINUE;
}
}
// 炼化逻辑
ItemParamValue ipv = (ItemParamValue)IPV_INT;
INT iParamSouXiaID = pRefiningSouXiaItem->GetItemParam(0,ipv);
INT iParamSouXiaPos = pRefiningSouXiaItem->GetItemParam(4,ipv);
INT iParamSouXiaID2 = pRefiningSouXiaItem2->GetItemParam(0,ipv);
INT iParamSouXiaPos2 = pRefiningSouXiaItem2->GetItemParam(4,ipv);
//两本捜侠录都为空
if ( (iParamSouXiaID == 0 && iParamSouXiaPos <= 0 ) && (iParamSouXiaID2 == 0 && iParamSouXiaPos2 <= 0 ))
{
refiningMsg.SetResult(SOUXIA_EMPTY);
Player* pPlayer = pHuman->GetPlayer();
if( pPlayer != NULL )
{
pPlayer->SendPacket( &refiningMsg );
}
return PACKET_EXE_CONTINUE;
}
BOOL bRefiningResult = FALSE;
BYTE refiningType = 0;
BYTE refiningRule = 0;
SHORT refiningRate = -1;
BYTE randNum = pScene->GetRand100();
SOUXIA_DATA randSouXiaData;//炼化随机后取得的新数据
if (pGet->m_nRefiningRule[0][0] > 0)//炼化技能道具
{
refiningRule = pGet->m_nRefiningRule[0][0];
refiningRate = pGet->m_nRefiningRule[0][1];
if (randNum < refiningRate)
{
bRefiningResult = SouXiaLogic::RefiningSouXia(pHuman, pRefiningSouXiaItem, pRefiningSouXiaItem2, refiningRule, randSouXiaData, ITEM_SOUXIASKILL);
refiningType = ITEM_SOUXIASKILL;
}
}
else if (pGet->m_nRefiningRule[1][0] > 0)//炼化配方道具
{
refiningRule = pGet->m_nRefiningRule[1][0];
refiningRate = pGet->m_nRefiningRule[1][1];
if (randNum < refiningRate)
{
bRefiningResult = SouXiaLogic::RefiningSouXia(pHuman, pRefiningSouXiaItem, pRefiningSouXiaItem2, refiningRule, randSouXiaData, ITEM_PRODUCT);
refiningType = ITEM_PRODUCT;
}
}
else if (pGet->m_nRefiningRule[2][0] > 0)//炼化神兽召唤道具
{
refiningRule = pGet->m_nRefiningRule[2][0];
refiningRate = pGet->m_nRefiningRule[2][1];
if (randNum < refiningRate)
{
bRefiningResult = SouXiaLogic::RefiningSouXia(pHuman, pRefiningSouXiaItem, pRefiningSouXiaItem2, refiningRule, randSouXiaData, ITEM_PET_ZHAOHUAN);
refiningType = ITEM_PET_ZHAOHUAN;
}
}
else if (pGet->m_nRefiningRule[3][0] > 0)//炼化坐骑召唤道具
{
refiningRule = pGet->m_nRefiningRule[3][0];
refiningRate = pGet->m_nRefiningRule[3][1];
if (randNum < refiningRate)
{
bRefiningResult = SouXiaLogic::RefiningSouXia(pHuman, pRefiningSouXiaItem, pRefiningSouXiaItem2, refiningRule, randSouXiaData, ITEM_ZUOJI_ZHAOHUAN);
refiningType = ITEM_ZUOJI_ZHAOHUAN;
}
}
if (!bRefiningResult)
{
refiningMsg.SetResult(SOUXIA_SKILL_REFINING_FAIL);
Player* pPlayer = pHuman->GetPlayer();
if( pPlayer != NULL )
{
pPlayer->SendPacket( &refiningMsg );
}
return PACKET_EXE_CONTINUE;
}
// 手续费用的扣除
// 成功删除使用的道具和捜侠录
if (randNum <= refiningRate)
{
UINT newSouXiaIndex = 0;
BYTE newSouXiaCurPos = 0;
// 取玩家身上捜侠录的数据pos 和 skillId
if (iParamSouXiaID == 0 && iParamSouXiaPos <= 0)//第一本为空
{
newSouXiaIndex = iParamSouXiaID2;
newSouXiaCurPos = iParamSouXiaPos2;
}
if (iParamSouXiaID2 == 0 && iParamSouXiaPos2 <= 0)//第二本为空
{
newSouXiaIndex = iParamSouXiaID;
newSouXiaCurPos = iParamSouXiaPos;
}
// 第一本的最大页数
BYTE maxPage = 0, maxPage2 = 0;
pGet = g_ItemTable.GetSouXiaTB(pRefiningSouXiaItem->GetItemTableIndex());
Assert(pGet);
maxPage = pGet->m_nMaxPages[0];
// 第二本最大页数
pGet = g_ItemTable.GetSouXiaTB(pRefiningSouXiaItem2->GetItemTableIndex());
Assert(pGet);
maxPage2 = pGet->m_nMaxPages[0];
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_REFINING_SOUXIA;
UINT newSouXiaBagIndex = 0;//新的捜侠录item背包索引
if (maxPage >= maxPage2) // 第一本的最大页大于第二本则保留第一本
{
BOOL bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman, pBagContainer->BagIndex2ConIndex(iRefiningSouXiaItem2));
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
else
{
refiningMsg.SetResult(ERASE_ITEM_FAIL);
pGamePlayer->SendPacket(&refiningMsg);
return PACKET_EXE_CONTINUE;
}
if (iParamSouXiaPos2 >= 0)
{
pHuman->EraseSouXia(iParamSouXiaPos2);//人身上销毁第二本
}
newSouXiaBagIndex = iRefiningSouXiaItem;//保留第一本的数据的bagindex
if ( (iParamSouXiaID > 0 && iParamSouXiaPos >= 0) && (iParamSouXiaID2 > 0 && iParamSouXiaPos2 >= 0))
{
newSouXiaIndex = iParamSouXiaID;
newSouXiaCurPos = iParamSouXiaPos;
}
}
else // 销毁第一本
{
BOOL bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman, pBagContainer->BagIndex2ConIndex(iRefiningSouXiaItem));
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
else
{
refiningMsg.SetResult(ERASE_ITEM_FAIL);
pGamePlayer->SendPacket(&refiningMsg);
return PACKET_EXE_CONTINUE;
}
if (iParamSouXiaPos >= 0)
{
pHuman->EraseSouXia(iParamSouXiaPos);//人身上销毁第一本
}
newSouXiaBagIndex = iRefiningSouXiaItem2;//保留第二本的数据的bagindex
if ( (iParamSouXiaID > 0 && iParamSouXiaPos >= 0) && (iParamSouXiaID2 > 0 && iParamSouXiaPos2 >= 0))
{
newSouXiaIndex = iParamSouXiaID2;
newSouXiaCurPos = iParamSouXiaPos2;
}
}
Assert (newSouXiaIndex > 0 && newSouXiaCurPos >= 0);
randSouXiaData.m_CurPos = newSouXiaCurPos;
randSouXiaData.m_SouXiaID = newSouXiaIndex;
// 销毁炼化道具
BOOL bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman, pBagContainer->BagIndex2ConIndex(iRefiningItem));
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
else
{
refiningMsg.SetResult(ERASE_ITEM_FAIL);
pGamePlayer->SendPacket(&refiningMsg);
return PACKET_EXE_CONTINUE;
}
// 改变保留的捜侠录道具的信息
Item* pNewSouXiaItem = HumanItemLogic::GetBagItem(pHuman, pBagContainer->BagIndex2ConIndex(newSouXiaBagIndex));
Assert(pNewSouXiaItem);
bRet = g_ItemOperator.SetItemParam( pHuman->GetBaseContain(),pHuman->GetBaseContain()->BagIndex2ConIndex(newSouXiaBagIndex),0, ipv, newSouXiaIndex);
if (!bRet)
{
return PACKET_EXE_CONTINUE;
}
bRet = g_ItemOperator.SetItemParam( pHuman->GetBaseContain(),pHuman->GetBaseContain()->BagIndex2ConIndex(newSouXiaBagIndex), 4, ipv, newSouXiaCurPos);
if (!bRet)
{
return PACKET_EXE_CONTINUE;
}
/*bRet = g_ItemOperator.SetItemParam( pHuman->GetBaseContain(),pHuman->GetBaseContain()->BagIndex2ConIndex(newSouXiaBagIndex),8, ipv, refiningType);
if (!bRet)
{
return PACKET_EXE_CONTINUE;
}*/
// 以上设置ITEM param注意保存到文件,并且要通知ITEM 的param 改变
GCItemInfo Msg;
Msg.setID( newSouXiaBagIndex );
Msg.setIsNull(FALSE);
pNewSouXiaItem->SaveValueTo(Msg.getItem());
pHuman->GetPlayer()->SendPacket(&Msg);
pHuman->SetSouXia(randSouXiaData, newSouXiaCurPos);
// 保存到文件
_SOUXIA_DB_LOAD SouXia_db_Load;
SouXia_db_Load.m_SouXiaData[newSouXiaCurPos] = randSouXiaData;
pHuman->GetDB()->SetSouXiaDBInfo(&SouXia_db_Load, newSouXiaCurPos);
// 发送新的捜侠录消息
refiningMsg.SetNewItemBagIndex(newSouXiaBagIndex);
refiningMsg.SetSouXiaData(&randSouXiaData);//炼化以后的捜侠录数据
refiningMsg.SetCurRefiningType(refiningType);
refiningMsg.SetResult(SOUXIA_REFINING_SUCCESS);
Player* pPlayer = pHuman->GetPlayer();
if( pPlayer != NULL )
{
pPlayer->SendPacket( &refiningMsg );
}
}
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
ORESULT AbilityMachining::OnProcSuccess(Obj_Human* pHuman)
{
__ENTER_FUNCTION
Assert( pHuman );
AbilityOpera* pAbilityOpera;
pAbilityOpera = pHuman->GetAbilityOpera();
Assert( pAbilityOpera );
LuaInterface* pLuaInterface;
pLuaInterface = pHuman->getScene()->GetLuaInterface();
GamePlayer* pGamePlayer;
pGamePlayer = (GamePlayer*)pHuman->GetPlayer();
Assert( pGamePlayer != NULL );
switch( pAbilityOpera->m_SubType )
{
case NORMAL_TYPE:
break;
case GEM_COMPOUND:
{
_ITEM_TYPE GemType;
UINT bi;
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_CREATE_ABILITY_COMPOUD;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
GemType = ConvertSerial2ItemType( pAbilityOpera->m_uItemIndex );
//GemType.m_Quality++;
HumanItemLogic::CreateItemToBag(&ItemLogParam,pHuman,GemType.ToSerial(),bi);
if(bi==INVALID_INDEX) //创建失败
{
return OR_ERROR;
}
SaveItemLog(&ItemLogParam);
GCNotifyEquip Msg;
Msg.SetBagIndex( bi );
Item* pItem = HumanItemLogic::GetBagItem(pHuman,bi);
Assert(pItem);
pItem->SaveValueTo(Msg.GetItem());
pGamePlayer->SendPacket(&Msg);
// 发送成功消息以及物品和状态变化
GCAbilitySucc SuccMsg;
SuccMsg.SetAbilityID( EAN_GEM_COMPOUNDED );
SuccMsg.SetPrescriptionID( INVALID_ID );
SuccMsg.SetItemSerial( GemType.ToSerial() );
//SuccMsg.SetSuccFlag( TRUE );
pGamePlayer->SendPacket( &SuccMsg );
}
break;
case GEM_EMBED: // 不需要额外的处理了
{
// 发送成功消息以及物品和状态变化
Item* pItem = HumanItemLogic::GetBagItem(pHuman, pAbilityOpera->m_BagPos[1]);
Assert( pItem );
GCAbilitySucc SuccMsg;
SuccMsg.SetAbilityID( EAN_GEM_EMBEDDED );
SuccMsg.SetPrescriptionID( INVALID_ID );
SuccMsg.SetItemSerial( pItem->GetItemTableIndex() );
//SuccMsg.SetSuccFlag( TRUE );
pGamePlayer->SendPacket( &SuccMsg );
}
break;
default:
Assert(FALSE);
return OR_ERROR;
}
// 判断一下熟练度是否足够升级了
pLuaInterface->ExeScript_DDD( ABILITY_LOGIC_SCRIPT,
"CheckAbilityLevel",
(INT)pHuman->getScene()->SceneID(),
(INT)pHuman->GetID(),
(INT)pAbilityOpera->m_AbilityID ) ;
return OR_OK;
__LEAVE_FUNCTION
return OR_ERROR;
}
ORESULT AbilityMachining::OnProcOver(Obj_Human* pHuman)
{
__ENTER_FUNCTION
Assert( pHuman );
AbilityOpera* pAbilityOpera;
pAbilityOpera = pHuman->GetAbilityOpera();
Assert( pAbilityOpera );
switch( pAbilityOpera->m_SubType )
{
case NORMAL_TYPE:
return AbilityCompound::OnProcOver(pHuman);
case GEM_COMPOUND:
{
ORESULT res;
BOOL flag = FALSE;
LuaInterface* pLuaInterface;
UINT itemIndex;
res = CanUseAbility(pHuman); // 以免过程中某些状态发生变化
if( res != OR_OK )
{
return res;
}
pLuaInterface = pHuman->getScene()->GetLuaInterface();
itemIndex = HumanItemLogic::GetBagItem(pHuman,
pAbilityOpera->m_BagPos[0])->GetItemTableIndex();
// 不管成功失败，宝石是没有了
GCDiscardItemResult Msg;
GamePlayer* pGamePlayer;
pGamePlayer = (GamePlayer*)pHuman->GetPlayer();
Assert( pGamePlayer != NULL );
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_GEM_COMPOUND_LOST;
BOOL bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,pAbilityOpera->m_BagPos[0]);
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
Msg.setItemTableIndex( itemIndex );
Msg.setResult( DISCARDITEM_SUCCESS );
Msg.setBagIndex( pAbilityOpera->m_BagPos[0] );
pGamePlayer->SendPacket( &Msg );
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,pAbilityOpera->m_BagPos[1]);
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
Msg.setBagIndex( pAbilityOpera->m_BagPos[1] );
pGamePlayer->SendPacket( &Msg );
if( pLuaInterface->ExeScript_DDD( ABILITY_LOGIC_SCRIPT,
"CompoundProc",
(INT)pHuman->getScene()->SceneID(),
(INT)pHuman->GetID(),
(INT)itemIndex ) != FALSE ) // 这里显然需要调用 lua script
{ // 脚本判断是否合成成功，成功了自动增加熟练度
flag = TRUE;
pAbilityOpera->m_uItemIndex = itemIndex;
res = OnProcSuccess( pHuman );
}
if( flag == TRUE )
{
return res;
}
else
{
return OR_FAILURE;
}
}
break;
case GEM_EMBED:
{
ORESULT res;
enum EmbedResult
{
EMBED_SUCCESS = 0,
GEM_GONE,
EQUIP_GONE,
BOTH_GONE,
};
EmbedResult flag;
LuaInterface* pLuaInterface;
BYTE GemBagIndex = pAbilityOpera->m_BagPos[0];
BYTE EquipBagIndex = pAbilityOpera->m_BagPos[1];
UINT GemIndex =
HumanItemLogic::GetBagItem(pHuman,GemBagIndex)->GetItemTableIndex();
UINT EquipIndex =
HumanItemLogic::GetBagItem(pHuman,EquipBagIndex)->GetItemTableIndex();
res = CanUseAbility(pHuman); // 以免过程中某些状态发生变化
if( res != OR_OK )
{
return res;
}
pLuaInterface = pHuman->getScene()->GetLuaInterface();
// 脚本判断是否镶嵌成功，如果成功则主动加上熟练度
// 否则返回失败情况
flag = (EmbedResult)pLuaInterface->ExeScript_DDD( ABILITY_LOGIC_SCRIPT,
"EmbedProc",
(INT)pHuman->getScene()->SceneID(),
(INT)pHuman->GetID(),
(INT)GemIndex ) ;
GCDiscardItemResult Msg;
Msg.setResult( DISCARDITEM_SUCCESS );
GamePlayer* pGamePlayer = (GamePlayer*)(pHuman->GetPlayer());
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_MACHINE_LOST;
BOOL bRet = FALSE;
switch(flag)
{
case EMBED_SUCCESS:
{
INT nRet;// = pHuman->UseGem(GemBagIndex, EquipBagIndex);
if(USEGEM_SUCCESS == nRet)
{
g_ImpactCore.SendImpactToUnit(*pHuman, 49, pHuman->GetID());
}
}
return OnProcSuccess(pHuman);
case GEM_GONE:
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
//pHuman->EraseItem(GemBagIndex);
Msg.setItemTableIndex( GemIndex );
Msg.setBagIndex( GemBagIndex );
pGamePlayer->SendPacket( &Msg );
return OR_FAILURE;
case EQUIP_GONE:
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,EquipBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
//pHuman->EraseItem(EquipBagIndex);
Msg.setItemTableIndex( EquipIndex );
Msg.setBagIndex( EquipBagIndex );
pGamePlayer->SendPacket( &Msg );
return OR_FAILURE;
case BOTH_GONE:
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,EquipBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
Msg.setItemTableIndex( GemIndex );
Msg.setBagIndex( GemBagIndex );
pGamePlayer->SendPacket( &Msg );
Msg.setItemTableIndex( EquipIndex );
Msg.setBagIndex( EquipBagIndex );
pGamePlayer->SendPacket( &Msg );
return OR_FAILURE;
default:
Assert(FALSE);
return OR_ERROR;
}
}
break;
default:
Assert(FALSE);
return OR_ERROR;
}
return OR_WARNING;
__LEAVE_FUNCTION
return OR_ERROR;
}
ORESULT AbilityInlay::OnProcOver(Obj_Human* pHuman)
{
__ENTER_FUNCTION
Assert( pHuman );
ORESULT res;
res = CanUseAbility(pHuman); // 以免过程中某些状态发生变化
if( res != OR_OK )
{
return res;
}
AbilityOpera* pAbilityOpera;
pAbilityOpera = pHuman->GetAbilityOpera();
Assert( pAbilityOpera );
BYTE GemBagIndex = pAbilityOpera->m_BagPos[0];
BYTE EquipBagIndex = pAbilityOpera->m_BagPos[1];
CHAR MaterialBagIndex1 = (CHAR)pAbilityOpera->m_BagPos[2];
CHAR MaterialBagIndex2 = (CHAR)pAbilityOpera->m_BagPos[3];
Item* pGemItem = HumanItemLogic::GetBagItem( pHuman, GemBagIndex );
Item* pEquipItem = HumanItemLogic::GetBagItem( pHuman, EquipBagIndex );
Item* pMaterialItem1 = NULL;
Item* pMaterialItem2 = NULL;
if( MaterialBagIndex1 != -1 )
{
pMaterialItem1 = HumanItemLogic::GetBagItem( pHuman, MaterialBagIndex1 );
Assert(pMaterialItem1 != NULL);
}
if( MaterialBagIndex2 != -1 )
{
pMaterialItem2 = HumanItemLogic::GetBagItem( pHuman, MaterialBagIndex2 );
Assert(pMaterialItem1 != NULL);
}
Assert( (pGemItem != NULL) && (pEquipItem != NULL) );
UINT GemIndex = pGemItem->GetItemTableIndex();
UINT EquipIndex = pEquipItem->GetItemTableIndex();
INT MaterialIndex1 = -1;
INT MaterialIndex2 = -1;
if( pMaterialItem1 )
{
MaterialIndex1 = pMaterialItem1->GetItemTableIndex();
//if(pMaterialItem1)
// pMaterialItem1->SetItemParam( 0, IPV_INT, INT( EquipBagIndex ) );//modi:lby20071114记录当前装备的id
}
if( pMaterialItem2 )
{
MaterialIndex2 = pMaterialItem2->GetItemTableIndex();
//if(pMaterialItem2)
//pMaterialItem2->SetItemParam( 0, IPV_INT, INT( EquipBagIndex ) );//modi:lby20071114记录当前装备的id
}
if( (pGemItem->IsLock())
|| (pEquipItem->IsLock())
|| (pGemItem->IsPWLock())
|| (pEquipItem->IsPWLock())
)
{ // 这里判断是否锁定，下面消耗时就不再判断了
return OR_STUFF_LACK;
}
if( pMaterialItem1 )
{
if( pMaterialItem1->IsLock()
|| pMaterialItem1->IsPWLock()
)
return OR_STUFF_LACK;
}
if( pMaterialItem2 )
{
if( pMaterialItem2->IsLock()
|| pMaterialItem2->IsPWLock()
)
return OR_STUFF_LACK;
}
EmbedResult flag;
LuaInterface* pLuaInterface;
pLuaInterface = pHuman->getScene()->GetLuaInterface();
// 脚本判断是否镶嵌成功，如果成功则主动加上熟练度
// 否则返回失败情况
flag = (EmbedResult)pLuaInterface->ExeScript_DDDDDD(ABILITY_LOGIC_SCRIPT, DEF_GEM_EMBED_PROCESS,
(INT)pHuman->getScene()->SceneID(),
(INT)pHuman->GetID(),
(INT)EquipBagIndex,
(INT)GemIndex,
(INT)MaterialIndex1,
(INT)MaterialIndex2 ) ;
GCDiscardItemResult Msg;
Msg.setResult( DISCARDITEM_SUCCESS );
GamePlayer* pGamePlayer = (GamePlayer*)(pHuman->GetPlayer());
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_INLAY_LOST;
BOOL bRet = FALSE;
switch(flag)
{
case EMBED_SUCCESS:
{
if( MaterialIndex1 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex1);
if(bRet) SaveItemLog(&ItemLogParam);
}
if( MaterialIndex2 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex2);
if(bRet) SaveItemLog(&ItemLogParam);
}
INT nRet ;//= pHuman->UseGem(GemBagIndex, EquipBagIndex);
if(USEGEM_SUCCESS == nRet)
{
g_ImpactCore.SendImpactToUnit(*pHuman, 49, pHuman->GetID());
}
return OnProcSuccess(pHuman);
}
case GEM_GONE:
if( MaterialIndex1 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
}
if( MaterialIndex2 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex2);
if(bRet) SaveItemLog(&ItemLogParam);
}
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
Msg.setItemTableIndex( GemIndex );
Msg.setBagIndex( GemBagIndex );
pGamePlayer->SendPacket( &Msg );
return OR_FAILURE;
case EQUIP_GONE:
if( MaterialIndex1 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,EquipBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
}
if( MaterialIndex2 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex2);
if(bRet) SaveItemLog(&ItemLogParam);
}
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,EquipBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
Msg.setItemTableIndex( EquipIndex );
Msg.setBagIndex( EquipBagIndex );
pGamePlayer->SendPacket( &Msg );
return OR_FAILURE;
case BOTH_GONE:
if( MaterialIndex1 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,EquipBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
}
if( MaterialIndex2 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
}
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,EquipBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
Msg.setItemTableIndex( GemIndex );
Msg.setBagIndex( GemBagIndex );
pGamePlayer->SendPacket( &Msg );
Msg.setItemTableIndex( EquipIndex );
Msg.setBagIndex( EquipBagIndex );
pGamePlayer->SendPacket( &Msg );
return OR_FAILURE;
case ENERGY_NOT_ENOUGH:
return OR_NOT_ENOUGH_ENERGY;
case GEM_DEGRADE_1:
{
if( MaterialIndex1 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex1);
if(bRet) SaveItemLog(&ItemLogParam);
}
if( MaterialIndex2 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex2);
if(bRet) SaveItemLog(&ItemLogParam);
}
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
_ITEM_TYPE type = ConvertSerial2ItemType(GemIndex);
/* if(type.m_Quality>1)
{
type.m_Quality--;
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_CREATE_REMOVE_GEM;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
UINT GemBagIndex_Temp = GemBagIndex;
HumanItemLogic::CreateItemToBag(&ItemLogParam,pHuman,type.ToSerial(),GemBagIndex_Temp,ITEM_DROP_MONSTER);
}*/
Msg.setItemTableIndex( GemIndex );
Msg.setBagIndex( GemBagIndex );
pGamePlayer->SendPacket( &Msg );
}
return OR_FAILURE;
case GEM_DEGRADE_2:
{
if( MaterialIndex1 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex1);
if(bRet) SaveItemLog(&ItemLogParam);
}
if( MaterialIndex2 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex2);
if(bRet) SaveItemLog(&ItemLogParam);
}
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
_ITEM_TYPE type = ConvertSerial2ItemType(GemIndex);
/*if(type.m_Quality>2)
{
type.m_Quality -= 2;
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_CREATE_REMOVE_GEM;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
UINT GemBagIndex_Temp = GemBagIndex;
HumanItemLogic::CreateItemToBag(&ItemLogParam,pHuman,type.ToSerial(),GemBagIndex_Temp,ITEM_DROP_MONSTER);
}*/
Msg.setItemTableIndex( GemIndex );
Msg.setBagIndex( GemBagIndex );
pGamePlayer->SendPacket( &Msg );
}
return OR_FAILURE;
case GEM_DEGRADE_3:
{
if( MaterialIndex1 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex1);
if(bRet) SaveItemLog(&ItemLogParam);
}
if( MaterialIndex2 != -1 )
{
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,MaterialBagIndex2);
if(bRet) SaveItemLog(&ItemLogParam);
}
bRet = HumanItemLogic::EraseBagItem(&ItemLogParam,pHuman,GemBagIndex);
if(bRet) SaveItemLog(&ItemLogParam);
_ITEM_TYPE type = ConvertSerial2ItemType(GemIndex);
/*if(type.m_Quality>3)
{
type.m_Quality -= 3;
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_CREATE_REMOVE_GEM;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
UINT GemBagIndex_Temp = GemBagIndex;
HumanItemLogic::CreateItemToBag(&ItemLogParam,pHuman,type.ToSerial(),GemBagIndex_Temp,ITEM_DROP_MONSTER);
}*/
Msg.setItemTableIndex( GemIndex );
Msg.setBagIndex( GemBagIndex );
pGamePlayer->SendPacket( &Msg );
}
return OR_FAILURE;
default:
Assert(FALSE);
return OR_ERROR;
}
__LEAVE_FUNCTION
return OR_ERROR;
}
uint CGShopSpecialRepairHandler::Execute( CGShopSpecialRepair* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
//交易状态不可操作
if(pHuman->m_ExchangBox.m_Status > 0)
{//丢弃
g_pLog->FastSaveLog( LOG_FILE_1, "ERROR: ObjID=%d, ExchangBox::m_Status>0" ,pHuman->GetID()) ;
return PACKET_EXE_CONTINUE ;
}
//摆摊状态不可操作
if(pHuman->m_StallBox.GetStallStatus() == ServerStallBox::STALL_OPEN)
{//丢弃
g_pLog->FastSaveLog( LOG_FILE_1, "ERROR: ObjID=%d, ServerStallBox::STALL_OPEN" ,pHuman->GetID()) ;
return PACKET_EXE_CONTINUE ;
}
BYTE Opt = pPacket->GetOpt();
BYTE BagIndex = pPacket->GetBagIndex(); //包中的位置
Item* pCurItem = NULL;
INT MoneySpent = 0;
INT MoneyLast = 0;
INT MoneyHave = pHuman->GetMoney();
INT RepairedIndex = 0;
GCShopSpecialRepairResult MsgResult;
GCShopSpecialRepairResult::REPAIRED_ITEM ItemList;
if(Opt == CGShopSpecialRepair::FromBag)
{
//一定是修理单个
ItemContainer* pItemContainer = HumanItemLogic::GetBagContainer(pHuman, BagIndex);
if (pItemContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler BagIndex is invalid, BagIndex = %d", BagIndex) ;
return PACKET_EXE_ERROR;
}
if (!pItemContainer->IsCanUse())
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler extrabag is invalid time BagIndex = %d", BagIndex) ;
return PACKET_EXE_CONTINUE ;
}
pCurItem = pItemContainer->GetItem(pItemContainer->BagIndex2ConIndex(BagIndex));
if(!pCurItem->IsEmpty())
{
if(pCurItem->GetItemClass() != ICLASS_EQUIP)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler pCurItem->GetItemClass() != ICLASS_EQUIP ") ;
return PACKET_EXE_ERROR ;
}
EQUIP_SPECIALREPAIR_TB* pSpecialRepair = g_ItemTable.GetSpecialRepairTB();
Assert (pSpecialRepair != NULL);
if (!pSpecialRepair)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[CGShopSpecialRepairHandler::Execute] GetSpecialRepairTB index is error");
return PACKET_EXE_ERROR;
}
//获得Human背包中对应ItemIndex的物品位置
UINT nItemCount = HumanItemLogic::CalcBagItemCount(pHuman, pSpecialRepair->m_ItemID);
if((nItemCount == 0)||(nItemCount < pPacket->GetItemNum()))
{
MsgResult.SetResult(EQUIPSPECIALREPAIR_ITEM);
pGamePlayer->SendPacket(&MsgResult);
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler nItemIndex = %d", pSpecialRepair->m_ItemID) ;
return PACKET_EXE_CONTINUE ;
}
FLOAT fCur = (FLOAT)pCurItem->GetDurPoints();
FLOAT fMax = (FLOAT)pCurItem->GetMaxDurPoint();
FLOAT fCurMax = (FLOAT)pCurItem->GetCurMaxDurPoint();
if(fMax != fCurMax)
{
UINT nUsedItem = 0;
for (UINT i=0; i<pPacket->GetItemNum(); ++i)
{
++nUsedItem;
fCurMax = pSpecialRepair->m_RecoverPoint + fCurMax;
if (fCurMax>=fMax)
{
fCurMax = fMax;
break;
}
}
HumanItemLogic::SetBagItemCurMaxDur(pHuman,(UINT)BagIndex, (INT)fCurMax);
HumanItemLogic::SetBagItemDur(pHuman,(UINT)BagIndex, (INT)fCurMax);
ITEM_LOG_PARAM LogParam;
LogParam.OpType = ITEM_SPECIALREPAIR_CONSUME;
LogParam.CharGUID = pHuman->GetGUID();
LogParam.XPos = pHuman->getWorldPos()->m_fX;
LogParam.ZPos = pHuman->getWorldPos()->m_fZ;
LogParam.SceneID = pHuman->getScene()->SceneID();
BOOL bOK = HumanItemLogic::EraseBagItem(&LogParam,pHuman, pSpecialRepair->m_ItemID, nUsedItem);
Assert(bOK);
SaveItemLog(&LogParam);
ItemList.IsIn = GCShopSpecialRepairResult::BAG;
ItemList.nCurDur = pCurItem->GetDurPoints();
ItemList.nCurMaxDur = pCurItem->GetCurMaxDurPoint();
ItemList.BagIndex = BagIndex;
MsgResult.SetResult(EQUIPSPECIALREPAIR_SUCCESS);
MsgResult.SetReList(&ItemList);
pHuman->GetPlayer()->SendPacket(&MsgResult);
return PACKET_EXE_CONTINUE ;
}
else
{
MsgResult.SetResult(EQUIPSPECIALREPAIR_NOREAPIR);
pGamePlayer->SendPacket(&MsgResult);
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler needn't repair") ;
return PACKET_EXE_CONTINUE ;
}
}
else
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler BagIndex = %d", BagIndex) ;
return PACKET_EXE_CONTINUE ;
}
}
else if(Opt == CGShopSpecialRepair::FromEquip)
{
pCurItem = HumanItemLogic::GetEquip(pHuman,(HUMAN_EQUIP)BagIndex);
if(!pCurItem->IsEmpty())
{//有东西
if(pCurItem->GetItemClass() != ICLASS_EQUIP)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler pCurItem->GetItemClass() != ICLASS_EQUIP ") ;
return PACKET_EXE_ERROR ;
}
EQUIP_SPECIALREPAIR_TB* pSpecialRepair = g_ItemTable.GetSpecialRepairTB();
Assert (pSpecialRepair != NULL);
if (!pSpecialRepair)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[CGShopSpecialRepairHandler::Execute] GetSpecialRepairTB index is error");
return PACKET_EXE_ERROR;
}
//获得Human背包中对应ItemIndex的物品位置
UINT nItemCount = HumanItemLogic::CalcBagItemCount(pHuman, pSpecialRepair->m_ItemID);
if((nItemCount == 0)||(nItemCount < pPacket->GetItemNum()))
{
MsgResult.SetResult(EQUIPSPECIALREPAIR_ITEM);
pGamePlayer->SendPacket(&MsgResult);
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler nItemIndex = %d", pSpecialRepair->m_ItemID) ;
return PACKET_EXE_CONTINUE ;
}
FLOAT fCur = (FLOAT)pCurItem->GetDurPoints();
FLOAT fMax = (FLOAT)pCurItem->GetMaxDurPoint();
FLOAT fCurMax = (FLOAT)pCurItem->GetCurMaxDurPoint();
if(fMax != fCurMax)
{
UINT nUsedItem = 0;
for (UINT i=0; i<pPacket->GetItemNum(); ++i)
{
++nUsedItem;
fCurMax = pSpecialRepair->m_RecoverPoint + fCurMax;
if (fCurMax>=fMax)
{
fCurMax = fMax;
break;
}
}
HumanItemLogic::SetCurEquipMaxDur(pHuman,(HUMAN_EQUIP)BagIndex, (INT)fCurMax);
HumanItemLogic::SetEquipDur(pHuman,(HUMAN_EQUIP)BagIndex, (INT)fCurMax);
ITEM_LOG_PARAM LogParam;
LogParam.OpType = ITEM_SPECIALREPAIR_CONSUME;
LogParam.CharGUID = pHuman->GetGUID();
LogParam.XPos = pHuman->getWorldPos()->m_fX;
LogParam.ZPos = pHuman->getWorldPos()->m_fZ;
LogParam.SceneID = pHuman->getScene()->SceneID();
BOOL bOK = HumanItemLogic::EraseBagItem(&LogParam,pHuman, pSpecialRepair->m_ItemID,nUsedItem);
Assert(bOK);
SaveItemLog(&LogParam);
ItemList.IsIn = GCShopSpecialRepairResult::EQUIP;
ItemList.nCurDur = pCurItem->GetDurPoints();
ItemList.nCurMaxDur = pCurItem->GetCurMaxDurPoint();
ItemList.BagIndex = BagIndex;
MsgResult.SetResult(EQUIPSPECIALREPAIR_SUCCESS);
MsgResult.SetReList(&ItemList);
pHuman->GetPlayer()->SendPacket(&MsgResult);
if ((INT)fCur == 0)
{
pHuman->ItemEffectFlush();
}
return PACKET_EXE_CONTINUE ;
}
else
{
MsgResult.SetResult(EQUIPSPECIALREPAIR_NOREAPIR);
pGamePlayer->SendPacket(&MsgResult);
g_pLog->FastSaveLog( LOG_FILE_1, "CGShopSpecialRepairHandler needn't repair") ;
return PACKET_EXE_CONTINUE ;
}
}
}
g_pLog->FastSaveLog( LOG_FILE_1, "ERROR:CGShopSpecialRepairHandler error Opt=", Opt);
return PACKET_EXE_ERROR;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
uint CGDiscardItemHandler::Execute(CGDiscardItem* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
BYTE Opt = pPacket->GetOpt();
BYTE BagIndex = pPacket->GetBagIndex();
Assert(BagIndex<MAX_BAG_SIZE);
if(Opt == CGDiscardItem::FromBag)
{
Item* pBagItem = HumanItemLogic::GetItem(pHuman,BagIndex);
Assert(pBagItem);
if(pBagItem->IsEmpty())
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGDiscardItemHandler: ok BagIndex=%d occur null type ", BagIndex ) ;
return PACKET_EXE_CONTINUE;
}
GCDiscardItemResult Msg;
Msg.setItemTableIndex(pBagItem->GetItemTableIndex());
if(pBagItem->IsRuler(IRL_DISCARD))
{
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_USEGEM_LOST;
BOOL bRet = HumanItemLogic::EraseItem(&ItemLogParam,pHuman,BagIndex);
if(bRet)
{
SaveItemLog(&ItemLogParam);
}
Msg.setResult(DISCARDITEM_SUCCESS);
Msg.setBagIndex(BagIndex);
}
else
{
Msg.setResult(DISCARDITEM_FAIL);
}
pGamePlayer->SendPacket(&Msg);
}
else if(Opt == CGDiscardItem::FromBank)
{
Item* pBagItem = HumanItemLogic::GetBankItem(pHuman,BagIndex);
Assert(pBagItem);
if(pBagItem->IsEmpty())
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGDiscardItemHandler: ok BagIndex=%d occur null type ", BagIndex ) ;
return PACKET_EXE_CONTINUE;
}
GCDiscardItemResult Msg;
Msg.setItemTableIndex(pBagItem->GetItemTableIndex());
if(pBagItem->IsRuler(IRL_DISCARD))
{
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_DISCARD_EQUIP;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.BagPos = BagIndex;
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemContainer* pBankContainer = pHuman->GetBankContain();
if(g_ItemOperator.EraseItem(pBankContainer, BagIndex) == FALSE)
{
SaveItemLog(&ItemLogParam);
g_pLog->FastSaveLog( LOG_FILE_1, "CGDiscardItemHandler: ok BagIndex=%d occur null type ", BagIndex ) ;
return PACKET_EXE_CONTINUE;
}
Msg.setOpt(GCDiscardItemResult::FromBank);
Msg.setResult(DISCARDITEM_SUCCESS);
Msg.setBagIndex(BagIndex);
}
else
{
Msg.setResult(DISCARDITEM_FAIL);
}
pGamePlayer->SendPacket(&Msg);
}
g_pLog->FastSaveLog( LOG_FILE_1, "CGDiscardEquipHandler: ok BagIndex=%d",
BagIndex ) ;
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
uint CGPackage_SwapItemHandler :: Execute( CGPackage_SwapItem* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
//得到所要交换的两个索引
INT index1 = pPacket->GetPackageIndex1();
INT index2 = pPacket->GetPackageIndex2();
INT bSucc = -1;
GCPackage_SwapItem msg;
//扩展包互换 禁止
if ((index1>=EXTRA_CONTAINER_OFFSET)&&(index2>=EXTRA_CONTAINER_OFFSET))
{
msg.SetResult(SWITCHITEM_EXTRBAG_EXCHANGE_FAIL);
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, index2=%d extrabag fail",
index1, index2) ;
return PACKET_EXE_CONTINUE;
}
if (index1>=EXTRA_CONTAINER_OFFSET)
{
ItemContainer* pExtraBagContainer = HumanItemLogic::GetBagByExtraContainPos(pHuman, index1);
//位置无效
if (pExtraBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, is invalid", index1) ;
return PACKET_EXE_ERROR;
}
//扩展包不存在
if (!pExtraBagContainer->IsValid())
{
msg.SetResult(SWITCHITEM_SOURCEEXTRBAG_NOALIVE);
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, extrabag is not alive", index1) ;
return PACKET_EXE_CONTINUE;
}
//非空扩展包不许移动
if (!pExtraBagContainer->IsEmpty())
{
msg.SetResult(SWITCHITEM_SOURCEEXTRBAG_ITEM_FAIL);
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, extrabag has items", index1) ;
return PACKET_EXE_CONTINUE;
}
ItemContainer* pExtraContainer = pHuman->GetExtraContain();
INT index_container1 = pExtraContainer->BagIndex2ConIndex(index1);
ItemContainer* pBagContainer = HumanItemLogic::GetBagContainer(pHuman, index2);
INT index_container2 = pBagContainer->BagIndex2ConIndex(index2);
if (pExtraBagContainer->IsInContainer(index2))
{
return PACKET_EXE_CONTINUE;
}
Item* pItem2 = pBagContainer->GetItem(index_container2);
//不能将扩展包移动到有物品位置
if (!pItem2->IsEmpty())
{
msg.SetResult(SWITCHITEM_SOURCEEXTRBAG_ITEM_FAIL);
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, extrabag has items", index1) ;
return PACKET_EXE_CONTINUE;
}
bSucc = g_ItemOperator.MoveItem(pExtraContainer, index_container1, pBagContainer, index_container2);
if (bSucc>=0)
{
pHuman->ReInitExtraBag();
msg.SetResult(SWITCHITEM_SUCCESS);
msg.SetPackageIndex1(index1);
msg.SetPackageIndex2(index2);
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, index2=%d Success",
index1, index2 ) ;
return PACKET_EXE_CONTINUE;
}
}
if ((index2>=EXTRA_CONTAINER_OFFSET)&&(index2<BASE_BAG_POS))
{
ItemContainer* pBagContainer = HumanItemLogic::GetBagContainer(pHuman, index1);
Item* pItem1 = pBagContainer->GetItem(pBagContainer->BagIndex2ConIndex(index1));
if (pItem1->IsEmpty())
{
return PACKET_EXE_CONTINUE;
}
ItemContainer* pExtraContainer = pHuman->GetExtraContain();
//将物品放入扩展包
ItemContainer* pExtraBagContainer = HumanItemLogic::GetBagByExtraContainPos(pHuman, index2);
if (pExtraBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index2=%d, is invalid", index2) ;
return PACKET_EXE_ERROR;
}
INT index_container1 = pBagContainer->BagIndex2ConIndex(index1);
INT index_container2 = pExtraContainer->BagIndex2ConIndex(index2);
//扩展包不存在
if (!pExtraBagContainer->IsValid())
{
if (pItem1->GetItemClass() == ICLASS_EXTRABAG)
{
INT ret = g_ItemOperator.MoveItem(pBagContainer, index_container1,
pExtraContainer, index_container2);
if (ret>=0)
{
msg.SetResult(SWITCHITEM_SUCCESS);
msg.SetPackageIndex1(index1);
msg.SetPackageIndex2(index2);
pGamePlayer->SendPacket(&msg);
Item* pDestItem = pExtraContainer->GetItem(index_container2);
Assert(pDestItem);
if (pDestItem->GetExtraBagBeginTime() == INVALID_TIME)
{
pDestItem->SetExtraBagBeginTime();
}
pHuman->ReInitExtraBag();
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: use extrabagitem, index2=%d ", index2 ) ;
return PACKET_EXE_CONTINUE;
}
msg.SetResult(SWITCHITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index2=%d, can't put", index2) ;
return PACKET_EXE_CONTINUE;
}
if (pExtraBagContainer->IsInContainer(index1))
{
return PACKET_EXE_CONTINUE;
}
if (pExtraBagContainer->IsCanUse())
{
INT nBagIndex = -1;
nBagIndex =g_ItemOperator.MoveItem(pBagContainer, index_container1, pExtraBagContainer, -1);
if (nBagIndex>=0)
{
msg.SetResult(SWITCHITEM_SUCCESS);
msg.SetPackageIndex1(index1);
msg.SetPackageIndex2(pExtraBagContainer->ConIndex2BagIndex(nBagIndex));
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, index2=%d Success",
index1, index2 ) ;
return PACKET_EXE_CONTINUE;
}
msg.SetResult(SWITCHITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
msg.SetResult(SWITCHITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
if (index2 == BASE_BAG_POS)
{
if (index1<MAX_SINGLEBAG_SIZE)
{
return PACKET_EXE_CONTINUE;
}
ItemContainer* pBagContainer = pHuman->GetBaseContain();
ItemContainer* pExtraBagContainer = HumanItemLogic::GetBagContainer(pHuman, index1);
if (pExtraBagContainer == NULL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, index2=%d fail",
index1, index2 ) ;
return PACKET_EXE_ERROR;
}
INT index_container1 = pExtraBagContainer->BagIndex2ConIndex(index1);
INT nBagIndex = -1;
nBagIndex =g_ItemOperator.MoveItem(pExtraBagContainer, index_container1, pBagContainer, -1);
if (nBagIndex>=0)
{
msg.SetResult(SWITCHITEM_SUCCESS);
msg.SetPackageIndex1(index1);
msg.SetPackageIndex2(pBagContainer->ConIndex2BagIndex(nBagIndex));
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, index2=%d Success",
index1, index2 ) ;
return PACKET_EXE_CONTINUE;
}
msg.SetResult(SWITCHITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
//调用物品底层交换物品
Item* pItem1 = HumanItemLogic::GetBagItem(pHuman, index1);
Item* pItem2 = HumanItemLogic::GetBagItem(pHuman, index2);
if ((pItem1==NULL)||(pItem2==NULL))
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, index2=%d pos fail",
index1, index2) ;
return PACKET_EXE_ERROR;
}
//判断是否在同一个容器内
ItemContainer* pBagContainer = HumanItemLogic::GetBagContainer(pHuman, index1);
if(pBagContainer != HumanItemLogic::GetBagContainer(pHuman, index2)) return PACKET_EXE_CONTINUE;
if (!pBagContainer->IsCanUse())
{
msg.SetResult(SWITCHITEM_SOURCEEXTRBAG_ITEM_FAIL);
pGamePlayer->SendPacket(&msg);
return PACKET_EXE_CONTINUE;
}
//转换Index基数
INT index_container1 = pBagContainer->BagIndex2ConIndex(index1);
INT index_container2 = pBagContainer->BagIndex2ConIndex(index2);
//两个物品格都是空格
if(pItem1->IsEmpty() && pItem2->IsEmpty())
{
return PACKET_EXE_CONTINUE;
}
// Item1 -> Item2(EMPTY)
else if(!(pItem1->IsEmpty()) && pItem2->IsEmpty())
{
bSucc = g_ItemOperator.MoveItem(pBagContainer, index_container1, pBagContainer, index_container2) >= 0;
}
// Item1(EMPTY) <- Item2
else if(pItem1->IsEmpty() && !(pItem2->IsEmpty()))
{
bSucc = g_ItemOperator.MoveItem(pBagContainer, index_container2, pBagContainer, index_container1) >= 0;
}
// Item1 <-> Item2
else
{
ITEM_LOG_PARAM ItemLogParam;
//合并相同的物品
//1、判断两个物品是不是可以叠加的
if(pItem1->GetItemTableIndex() == pItem2->GetItemTableIndex() && pItem1->IsCanLay())
{
int Count = pItem1->GetLayedNum();
//2、转移物品
if(g_ItemOperator.MoveItem(pBagContainer, index_container1, index_container2) >= 0)
{
//合并成功，将结果通知客户端，不能只发送Index，需要包括内容；
_ITEM temp1;
pItem1->SaveValueTo(&temp1);
GCItemInfo msg1;
msg1.setID(index1);
msg1.setIsNull(pItem1->IsEmpty());
msg1.setItem(&temp1);
pGamePlayer->SendPacket(&msg1);
_ITEM temp2;
pItem2->SaveValueTo(&temp2);
GCItemInfo msg2;
msg2.setID(index2);
msg2.setIsNull(pItem2->IsEmpty());
msg2.setItem(&temp2);
pGamePlayer->SendPacket(&msg2);
ITEM_LOG_PARAM ItemLogParam;
ItemLogParam.OpType = ITEM_TILED_BAG_DEST;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
ItemLogParam.ContainerPos = index2;
ItemLogParam.Count = Count;
ItemLogParam.ItemGuid = pItem2->GetGUID();
SaveItemLog(&ItemLogParam);
ItemLogParam.OpType = ITEM_TILED_BAG_DEST;
ItemLogParam.CharGUID = pHuman->GetGUID();
ItemLogParam.SceneID = pHuman->getScene()->SceneID();
ItemLogParam.XPos = pHuman->getWorldPos()->m_fX;
ItemLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
ItemLogParam.ContainerPos = index1;
ItemLogParam.Count = Count;
ItemLogParam.ItemGuid = pItem1->GetGUID();
SaveItemLog(&ItemLogParam);
return PACKET_EXE_CONTINUE ;
}
}
// 交换两物品
bSucc = g_ItemOperator.ExchangeItem(pBagContainer, index_container1, pBagContainer, index_container2) == ITEMOE_SUCCESS;
}
msg.SetResult(SWITCHITEM_SUCCESS);
msg.SetPackageIndex1(index1);
msg.SetPackageIndex2(index2);
pGamePlayer->SendPacket(&msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGPackage_SwapItem: index1=%d, index2=%d Succ=%s",
index1, index2, bSucc?"TRUE":"FALSE" ) ;
return PACKET_EXE_CONTINUE ;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
