inguz/Sun1602
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
Sun1602/Server/GameServer/PacketHandler/Handler_CG_EVENT.cpp
T
pencil_qianbi 7a644cf496 all
2022-10-26 12:25:11 +08:00

1145 lines
40 KiB
C++
Raw Permalink Blame History

#include "StdAfx.h"
#include <PacketStruct_CG.h>
#include <PacketStruct_DG.h>
#include <SunEventInfoParser.h>
#include <DropRatioInfoList.h>
#include "Handler_CG_Event.h"
#include "EventInventorySlotContainer.h"
#include "EventManager.h"
#include "Player.h"
#include "ItemManager.h"
#include "RewardManager.h"
#include "Skill.h"
#include ".\FriendInvitation\GFriendInvitationController.h"
#include "ChaoState.h"
#ifdef _NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
#include "PostManager.h"
#endif
#ifdef _CH_20100420_CHANGE_DOMINATION_APPLY_WAY
#include "DominationInfoParser.h"
#endif
//--------------------------------------------------------------------------------------------------
// changes, f100819.1L
const nsPacket::PacketHandlerInfo Handler_CG_EVENT::GetPacketHandlerNodes()
{
#define HANDLER_NODE_INFO(c, p, phase) { MAKEWORD(c, p), phase, Handler_CG_EVENT::On##p }
#define HANDLER_NODE_INFO_EOR() { 0, static_cast<ePHASE_SHIFT>(0), NULL }
static const nsPacket::PacketHandlerNode handlers_static_[] =
{
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_SELECT_SYN, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_MOVE_ITEM_TO_INVEN_SYN, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_ITEM_STATUS_SYN, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_ITEM_REG_SYN, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_QUERY_EXIST_SYN, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_TIME_PERIOD_SYN, PHASE_SERVICE),
// <Desc> 기존과 다른 체계. 바로 보상 받는 형태다.
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_REQUEST_ITEM_SYN, PHASE_SERVICE), // 성공시 CG_EVENT_ITEM_REWARD_CMD
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_DONATION_HEIM_SYN, PHASE_SERVICE), // 기부 요청
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_BUFF_EVENT_SYN, PHASE_SERVICE), // 버프 이벤트 요청
//_KR_0_20091021_FIRENDINVITATION_EXTEND = {
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_INVITATEFRIEND_REWARD_SYN, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_INVITATEFRIEND_RECALL_SYN, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_INVITATEFRIEND_RECALL_QUESTION_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_INVITATEFRIEND_RECALL_QUESTION_NAK, PHASE_SERVICE),
//}
#ifdef _NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_DOMINATION_REWARD_CMD, PHASE_SERVICE),
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_LOTTO_REWARD_CMD, PHASE_SERVICE),
#endif//_NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
//_NA_20100812_INTEGRATE_SYSTEM_MEMO_DOMINATION
HANDLER_NODE_INFO(CG_EVENT, CG_EVENT_SYSTEMMEMO_ITEM_REWARD_REQ, PHASE_SERVICE),
//
HANDLER_NODE_INFO_EOR() // end of records
};
//
BOOST_STATIC_ASSERT(_countof(handlers_static_) >= 1);
nsPacket::PacketHandlerInfo return_value = { handlers_static_, _countof(handlers_static_) - 1 };
//
return return_value;
};
//--------------------------------------------------------------------------------------------------
struct sEventTransactionWrap
{
sEventTransactionWrap( sTransaction& rTrans ) : m_rTrans(rTrans) { m_rTrans.Enter(); }
~sEventTransactionWrap() { m_rTrans.Leave(); }
sTransaction& m_rTrans;
};
inline static VOID _RegisterEventStatus( DWORD eventID, Player* IN pPlayer, EVENT_STATUS_EX** OUT ppOutEventStatus )
{
EVENT_STATUS_EX eventStatus; // auto clear
eventStatus.m_dwEventID = eventID;
IPlayerEventD& rEventD = pPlayer->PlayerEvent();
rEventD.AddEventStatus( eventStatus );
(*ppOutEventStatus) = rEventD.FindEventStatus( eventID );
}
#define CHECK_IS_NOT_FIELDSERVER() (g_pGameServer->GetServerType() != FIELD_SERVER)
Handler_CG_EVENT_IMPL( CG_EVENT_SELECT_SYN )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_CG_EVENT_SELECT_SYN* pMsg = (MSG_CG_EVENT_SELECT_SYN *)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
ASSERT( pPlayer );
if( !pPlayer ) return ;
if( !pPlayer->GetField() ) return;
RC::eITEM_RESULT rt = pPlayer->GetEventSlotContainer()->Open();
if( rt == RC::RC_ITEM_EVENT_SUCCESS /*RC::RC_EVENT_SUCCESS*/ )
{
MSG_DG_EVENT_SELECT_SYN msg;
//msg.m_UserGuid = pPlayer->GetUserGuid();
pPlayer->SendToGameDBPServer( &msg, sizeof(msg) );
}
else
{
MSG_CG_EVENT_SELECT_NAK nmsg;
nmsg.m_byErrorCode = rt;
pPlayer->SendPacket( &nmsg, sizeof(nmsg) );
}
}
Handler_CG_EVENT_IMPL( CG_EVENT_MOVE_ITEM_TO_INVEN_SYN )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_CG_EVENT_MOVE_ITEM_TO_INVEN_SYN* pMsg = (MSG_CG_EVENT_MOVE_ITEM_TO_INVEN_SYN *)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
ASSERT( pPlayer );
if( !pPlayer ) return ;
if( !pPlayer->GetField() ) return;
EventInventorySlotContainer* const event_container = pPlayer->GetEventSlotContainer();
MSG_DG_EVENT_UPDATE_SYN msg;
RC::eITEM_RESULT rt = event_container->MoveItemToInventory(pMsg->m_ItemPos, msg.m_ItemSeq);
if( rt == RC::RC_ITEM_EVENT_SUCCESS /*RC::RC_EVENT_SUCCESS*/ )
{
//msg.m_UserGuid = pPlayer->GetUserGuid();
msg.m_ItemPos = pMsg->m_ItemPos;
pPlayer->SendToGameDBPServer( &msg, sizeof(msg) );
}
else
{
// CHANGES: f110316.4L, fixed locking state when the result of MoveItemToInventory is fails.
if (rt != RC::RC_ITEM_EVENT_ALREADY_ANOTHER_TRANSACTION) {
// NOTE: nothing to do except unlocking
event_container->OnMoveItemToInventory(false, INVALID_POSTYPE_VALUE, NULL);
}
MSG_CG_EVENT_MOVE_ITEM_TO_INVEN_NAK nmsg;
nmsg.m_byErrorCode = rt;
pPlayer->SendPacket( &nmsg, sizeof(nmsg) );
}
}
// 이벤트 응모 상태 확인
Handler_CG_EVENT_IMPL( CG_EVENT_ITEM_STATUS_SYN )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_CG_EVENT_ITEM_STATUS_SYN* pMsg = (MSG_CG_EVENT_ITEM_STATUS_SYN*)pRecvMsg;
MSG_CG_EVENT_ITEM_STATUS_ACK msgACK;
// 해당 유저의 이벤트 상태 보내준다
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
ASSERT( pPlayer );
if( !(pPlayer && pPlayer->GetField()) )
return;
IPlayerEventD& rPEvent = pPlayer->PlayerEvent();
msgACK.m_wEventNum = rPEvent.GetEventNum();
if( msgACK.m_wEventNum )
rPEvent.GetEventStatus( (DWORD)_countof(msgACK.m_EventStatus), msgACK.m_EventStatus );
pPlayer->SendPacket( &msgACK, msgACK.GetSize() );
MessageOut( eFULL_LOG, "Event Status Check[%u][C:%u][Event:%u]", pMsg->m_dwKey, pPlayer->GetCharGuid(), msgACK.m_wEventNum );
}
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// <Handler for CG_EVENT_ITEM_REG_SYN>
// - SubHandler
//
struct SubHandler_for_CG_EVENT_ITEM_REG_SYN
{
static const DWORD ERRCODE_DEFAULT = 1000000;
static const DWORD ERRCODE_RANDREWARD = ERRCODE_DEFAULT+2;
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
//
static VOID On_eEVENT_REGITEM_GETITEM( FlowControl& flow, Player* const pPlayer, EVENT_INFO* const pEventInfo )
{
if( !pPlayer->GetField() )
{
SUNLOG( eCRITICAL_LOG, "[Handler_CG_EVENT_IMPL::On_eEVENT_REGITEM_GETITEM] Not Exist GameField" );
return;
}
IPlayerEventD& rEventD = pPlayer->PlayerEvent();
const CODETYPE eventID = pEventInfo->m_dwEventID;
FLOWCONTROL_START()
{
// start LOGIC_BLOCK
EVENT_STATUS_EX* pEventStatus = rEventD.FindEventStatus( eventID );
if( NULL == pEventStatus )
_RegisterEventStatus( eventID, pPlayer, &pEventStatus );
{ // 제한 개수 초과 - 이미 등록 완료
const WORD registerLimit = (WORD)pEventInfo->m_byCountMax;
if(registerLimit)
IfFailThenBreak(registerLimit > pEventStatus->m_wRegisterCnt,
RC::RC_EVENT_ITEM_NUM_OVERFLOW);
};
ItemManager* const pItemManager = pPlayer->GetItemManager();
// 등록할 아이템이 등록할 개수만큼 존재하는지 검사
SLOTCODE delItem[_MAX_EVENT_REGITEM] = { 0, };
POSTYPE delpos[_MAX_EVENT_REGITEM] = { 0, };
typedef util::SEQ_MASK<DWORD, -1, _MAX_EVENT_REGITEM> REG_ITEM_CODE_ARRAY;
POSTYPE delitemUB = 0;
FOREACH_ARR_CONTAIN( idx, REG_ITEM_CODE_ARRAY, pEventInfo->m_dwRegisterItemIndex )
{
const SLOTCODE itemCode = (SLOTCODE)pEventInfo->m_dwRegisterItemIndex[idx];
const POSTYPE itemCnt = (POSTYPE)pEventInfo->m_wRegisterItemNum[idx];
if( !itemCnt )
break;
IfFailThenBreak(pItemManager->ExistItem(SI_INVENTORY, itemCode, itemCnt),
RC::RC_EVENT_NOTEXISTITEM);
delItem[idx] = itemCode;
delpos[idx] = itemCnt;
++delitemUB;
}
if( flow.IsErrorOccured() )
break;
MSG_CG_ITEM_LOSE_ACK loseMsg;
// 아이템 다 존재하면 한꺼번에 삭제해야 뒷탈이 없다
IfFailThenBreak(
RC::RC_ITEM_SUCCESS == pItemManager->DeleteAllKindOfItem(delitemUB, delItem, delpos,
&loseMsg.m_ItemInfo),
RC::RC_EVENT_NOTEXISTITEM);
GAMELOG->LogMultiItem( ITEM_EVENT_ETHER_REG, pPlayer, delitemUB, delItem, delpos );
pPlayer->SendPacket( &loseMsg, loseMsg.GetSize() ); // 대신 니 아이템도 내놔~
// 모두 통과하면 응모 횟수 하나 증가
if( pEventStatus->m_wRegisterCnt < (WORD)-1 )
++pEventStatus->m_wRegisterCnt;
MSG_DG_EVENT_ITEM_REG_SYN updateMsg;
// DBProxy에 경품 응모 등록 요청
updateMsg.m_dwKey = pPlayer->GetUserGuid();
updateMsg.m_dwCharGUID = pPlayer->GetCharGuid();
{ // 완료 여부 체크
const WORD registerLimit = (WORD)pEventInfo->m_byCountMax;
pEventStatus->m_Status =
( registerLimit && (registerLimit <= pEventStatus->m_wRegisterCnt) ) ? 1 : 0;
updateMsg.m_EventStatus = (*pEventStatus);
}
pPlayer->SendToGameDBPServer( &updateMsg, sizeof(updateMsg) );
MessageOut( eFULL_LOG, "Event Item Register[%u][C:%u][Event:%u/%u]",
updateMsg.m_dwKey, updateMsg.m_dwCharGUID, eventID, pEventStatus->m_wRegisterCnt );
return /*RETURN TRUE VALUE*/;
}
FLOWCONTROL_END;
return /*RETURN FALSE VALUE*/;
}
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
//
static VOID On_eEVENT_REGITEM_RANDREWARD( FlowControl& flow, Player* const pPlayer, EVENT_INFO* const pEventInfo )
{
if( !pPlayer->GetField() )
{
SUNLOG( eCRITICAL_LOG, "[Handler_CG_EVENT_IMPL::On_eEVENT_REGITEM_RANDREWARD] Not Exist GameField" );
return;
}
IPlayerEventD& rEventD = pPlayer->PlayerEvent();
const CODETYPE eventID = pEventInfo->m_dwEventID;
FLOWCONTROL_START()
{
// start LOGIC_BLOCK
// 해당 이벤트를 얻은 다음, 조건 체크 - 성공하면 아이템 지급
// 조건 체크
ItemManager* const pItemManager = pPlayer->GetItemManager();
// 등록할 아이템이 등록할 개수만큼 존재하는지 검사
SLOTCODE delItem[_MAX_EVENT_REGITEM] = { 0, };
POSTYPE delpos[_MAX_EVENT_REGITEM] = { 0, };
typedef util::SEQ_MASK<DWORD, -1, _MAX_EVENT_REGITEM> REG_ITEM_CODE_ARRAY;
POSTYPE delitemUB = 0;
FOREACH_ARR_CONTAIN( idx, REG_ITEM_CODE_ARRAY, pEventInfo->m_dwRegisterItemIndex )
{
const SLOTCODE itemCode = (SLOTCODE)pEventInfo->m_dwRegisterItemIndex[idx];
const POSTYPE itemCnt = (POSTYPE)pEventInfo->m_wRegisterItemNum[idx];
if( !itemCnt )
break;
IfFailThenBreak(pItemManager->ExistItem(SI_INVENTORY, itemCode, itemCnt),
RC::RC_EVENT_NOTEXISTITEM);
delItem[idx] = itemCode;
delpos[idx] = itemCnt;
++delitemUB;
}
if( flow.IsErrorOccured() )
break;
// 등록 아이템을 없앤다
// 먼저 없애고 넣다가 실패하면 최악의 경우 아이템이 없어지므로 복구하면 되지만
// 넣고 나서 없애다가 실패하면 최악의 경우 공짜로 아이템을 넘겨주므로 에러를 알아내기 더 어려워진다
MSG_CG_ITEM_LOSE_ACK loseMsg;
IfFailThenBreak(
RC::RC_ITEM_SUCCESS == pItemManager->DeleteAllKindOfItem(delitemUB, delItem, delpos,
&loseMsg.m_ItemInfo),
RC::RC_EVENT_NOTEXISTITEM);
GAMELOG->LogMultiItem( ITEM_EVENT_ETHER_DELETE, pPlayer, delitemUB, delItem, delpos );
// 보상 아이템 획득에 랜덤 확률 적용 - 있는 것들만큼 해당 아이템을 줄 확률이 바뀐다. 1개면 100%, 2개면 50%씩, 3개면 33.3333...%
DWORD rewardCnt = 0;
FOREACH_ARR_CONTAIN( idx, REG_ITEM_CODE_ARRAY, pEventInfo->m_dwRewardInfo )
{
++rewardCnt;
}
IfFailThenBreak(rewardCnt != 0, RC::RC_EVENT_FAILED);
// 보상 아이템 준다!
const DWORD nRandIndex = (DWORD)rand() % rewardCnt; // 있는 아이템 개수만큼 랜덤 적용
const CODETYPE randRewardIndex = pEventInfo->m_dwRewardInfo[nRandIndex];
MSG_CG_EVENT_ITEM_REWARD_CMD rewardMsg;
IfFailThen(
RC::RC_REWARD_SUCCESS == g_RewardManager.RewardItem(RewardManager::eREWARD_EVENT,
randRewardIndex, 1, pPlayer, rewardMsg.m_TotalInfo), RC::RC_EVENT_CANT_OBTAIN)
{
INVENTORY_TOTAL_INFO tempTotalInfo; // 임시 변수
// (WAVERIX) (090610) (CHANGES) 복구 처리
/*RC::RC_ITEM_NOTEXIST_ITEM != */
pPlayer->GetItemManager()->ObtainAllKindOfItem(delitemUB, delItem, delpos,
&tempTotalInfo);
break; //이건 필요 없지만...
}
if( flow.IsErrorOccured() )
break;
pPlayer->SendPacket( &loseMsg, loseMsg.GetSize() ); // 아이템 등록했고
// 보상 아이템 확인
SLOTCODE* pRewardCodes = g_RewardManager.GetRewardItemCode();
IfFailThenBreak(pRewardCodes, ERRCODE_RANDREWARD);
rewardMsg.m_dwEventID = eventID;
rewardMsg.m_Money = pPlayer->GetMoney();
pPlayer->SendPacket( &rewardMsg, rewardMsg.GetSize() ); // 등록됐으니 아이템 받아라!
#define _WHATTHEHELL_ITEMREWARD_DBREG_20060603
#ifdef _WHATTHEHELL_ITEMREWARD_DBREG_20060603 // 아이템 보상받은 것도 DB에 등록
EVENT_STATUS_EX* pEventStatus = rEventD.FindEventStatus( eventID );
if( NULL == pEventStatus )
_RegisterEventStatus( eventID, pPlayer, &pEventStatus );
// 최대값 체크
if( pEventStatus->m_wRegisterCnt < (WORD)-1 )
++pEventStatus->m_wRegisterCnt;
// DBProxy에 아이템 등록됐음을 알려준다
MSG_DG_EVENT_ITEM_REG_SYN updateMsg;
// DBProxy에 경품 응모 등록 요청
updateMsg.m_dwKey = pPlayer->GetUserGuid();
updateMsg.m_dwCharGUID = pPlayer->GetCharGuid();
{ // 완료 여부 체크
const WORD registerLimit = (WORD)pEventInfo->m_byCountMax;
pEventStatus->m_Status = 0; // 여기는 완료가 없단다...
//( registerLimit && (registerLimit <= pEventStatus->m_wRegisterCnt) ) ? 1 : 0;
updateMsg.m_EventStatus = (*pEventStatus);
}
pPlayer->SendToGameDBPServer( &updateMsg, sizeof(updateMsg) );
#endif
MessageOut( eFULL_LOG, "Event Item Register And Reward[%u][C:%u][E:%u]",
updateMsg.m_dwKey, updateMsg.m_dwCharGUID, eventID );
return /*RETURN TRUE VALUE*/;
}
FLOWCONTROL_END;
return /*RETURN FALSE VALUE*/;
}
};
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// <MSG_CG_EVENT_ITEM_REG_SYN>
// - 이벤트 아이템 등록
//
Handler_CG_EVENT_IMPL( CG_EVENT_ITEM_REG_SYN )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_CG_EVENT_ITEM_REG_SYN* pMsg = (const MSG_CG_EVENT_ITEM_REG_SYN*)pRecvMsg;
if( CHECK_IS_NOT_FIELDSERVER() )
return;
const CODETYPE eventID = pMsg->m_dwEventID;
const DWORD userKey = pMsg->m_dwKey;
Player* const pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( userKey );
if (NULL == pPlayer)
return;
if( !pPlayer->GetField() )
{
SUNLOG( eCRITICAL_LOG, "[Handler_CG_EVENT_IMPL( CG_EVENT_ITEM_REG_SYN )] Not Exist GameField" );
return;
}
FlowControl flow;
FLOWCONTROL_START()
{
// start LOGIC_BLOCK
IfFailThenBreak(pPlayer && pPlayer->GetField(),
SubHandler_for_CG_EVENT_ITEM_REG_SYN::ERRCODE_DEFAULT);
IfFailThenBreak(pPlayer->GetChaoState().CanUseFuction(CHAO_USE_EVENT),
RC::RC_EVENT_UNABLE_FUNCTION_FOR_CHAOSTATE);
IfFailThenBreak(pPlayer->GetBehave() != PLAYER_BEHAVE_UNEXPECTED_WAITING, RC::RC_EVENT_FAILED);
SunEventInfoParser* const pSunEventInfoParser = SunEventInfoParser::Instance();
EVENT_INFO* const pEventInfo = pSunEventInfoParser->FindEventInfo( eventID );
IfFailThenBreak(pEventInfo, RC::RC_EVENT_INVALID_EVENT);
// ...이건 99.9% 참이 될 것이다. (EventManager 동작 하)
IfFailThenBreak(pEventInfo->CheckEvent(), RC::RC_EVENT_INVALID_EVENT);
IfFailThenBreak(pEventInfo->CheckLevel(pPlayer->GetLevel()), RC::RC_EVENT_UNQUALIFIED);
{ // Check Inventory Constraint
ProtectorInventory& rPROTECT = pPlayer->GetWarehouseInventoryProtector().INVENTORY();
IfFailThenBreak(rPROTECT.IsUsable(), RC::RC_EVENT_ITEM_INVENTORY_LOCKED);
};
IPlayerEventD& rEventD = pPlayer->PlayerEvent();
const eEVENT_MODE eventMode = (eEVENT_MODE)pEventInfo->m_byEventMode;
switch( eventMode )
{
case eEVENT_REGITEM_GETITEM: //경품 응모
SubHandler_for_CG_EVENT_ITEM_REG_SYN::On_eEVENT_REGITEM_GETITEM( flow, pPlayer, pEventInfo );
break;
case eEVENT_REGITEM_RANDREWARD: // 랜덤하게 아이템 지급
SubHandler_for_CG_EVENT_ITEM_REG_SYN::On_eEVENT_REGITEM_RANDREWARD( flow, pPlayer, pEventInfo );
break;
}
if( flow.IsErrorOccured() )
break;
return /*RETURN TRUE VALUE*/;
}
FLOWCONTROL_END;
switch( const DWORD errcode = flow.GetErrorCode() )
{
case RC::RC_EVENT_FAILED:
case RC::RC_EVENT_INVALID_EVENT:
case RC::RC_EVENT_ITEM_INVENTORY_LOCKED:
case RC::RC_EVENT_ITEM_NUM_OVERFLOW:
case RC::RC_EVENT_NOTEXISTITEM:
case RC::RC_EVENT_UNQUALIFIED:
{
MSG_CG_EVENT_ITEM_REG_NAK msgNAK;
msgNAK.m_dwEventID = eventID;
msgNAK.m_dwErrorCode = errcode;
pPlayer->SendPacket( &msgNAK, sizeof(msgNAK) );
}
break;
case SubHandler_for_CG_EVENT_ITEM_REG_SYN::ERRCODE_DEFAULT:
case SubHandler_for_CG_EVENT_ITEM_REG_SYN::ERRCODE_RANDREWARD:
default:
SUNLOG( eCRITICAL_LOG, _T("[CG_EVENT_ITEM_REG_SYN] Unexpected Status [%u]"), errcode );
break;
}
return /*RETURN FALSE VALUE*/;
}
//
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Handler_CG_EVENT_IMPL( CG_EVENT_TIME_PERIOD_SYN )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_CG_EVENT_TIME_PERIOD_SYN* pMsg = (MSG_CG_EVENT_TIME_PERIOD_SYN*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
ASSERT( pPlayer );
if( !pPlayer ) return ;
if( !pPlayer->GetField() ) return;
time_t t;
util::TimeSync::time(&t);
MSG_CG_EVENT_TIME_PERIOD_ACK arkMsg(t);
pPlayer->SendPacket( &arkMsg, sizeof(arkMsg) );
}
Handler_CG_EVENT_IMPL( CG_EVENT_QUERY_EXIST_SYN )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_CG_EVENT_QUERY_EXIST_SYN* pMsg = (MSG_CG_EVENT_QUERY_EXIST_SYN*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
if( !(pPlayer && pPlayer->GetField()) )
return;
RC::eITEM_RESULT rt = pPlayer->GetEventSlotContainer()->Open();
if( rt == RC::RC_ITEM_EVENT_SUCCESS /*RC::RC_EVENT_SUCCESS*/ )
{
MSG_DG_EVENT_QUERY_EXIST_SYN msgSYN;
//msg.m_UserGuid = pPlayer->GetUserGuid();
pPlayer->SendToGameDBPServer( &msgSYN, sizeof(msgSYN) );
}
else
{
MSG_CG_EVENT_QUERY_EXIST_ACK msgACK;
msgACK.m_bExist = MSG_CG_EVENT_QUERY_EXIST_ACK::DISABLED;
pPlayer->SendPacket( &msgACK, sizeof(msgACK) );
}
}
//PACKET_CG_FWD_OPEN( CG_EVENT, CG_EVENT_REQUEST_ITEM_SYN )
// CODETYPE m_EventID;
// BYTE m_RequestItemIndex;
//
// MSG_CG_EVENT_REQUEST_ITEM_SYN( const CODETYPE eventID, const BYTE requestItemIndex )
// : MSG_CG_EVENT_REQUEST_ITEM_SYN(), m_EventID(eventID), m_RequestItemIndex(requestItemIndex) {}
//PACKET_CG_FWD_CLOSE
//
//PACKET_CG_FWD_OPEN( CG_EVENT, CG_EVENT_REQUEST_ITEM_NAK )
// CODETYPE m_EventID;
// DWORD m_ErrorCode;
//
// inline VOID SetInfo( const CODETYPE eventID, DWORD errorCode ) { m_EventID=eventID; m_ErrorCode = errorCode; }
//PACKET_CG_FWD_CLOSE
//
//
// <Desc> 기존과 다른 체계. 바로 보상 받는 형태다.
Handler_CG_EVENT_IMPL( CG_EVENT_REQUEST_ITEM_SYN ) // 성공시 CG_EVENT_ITEM_REWARD_CMD
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_CG_EVENT_REQUEST_ITEM_SYN* pMsg = (MSG_CG_EVENT_REQUEST_ITEM_SYN*)pRecvMsg;
if( CHECK_IS_NOT_FIELDSERVER() )
return;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
if (NULL == pPlayer)
return;
if( !pPlayer->GetField() )
{
SUNLOG( eCRITICAL_LOG, "[Handler_CG_EVENT_IMPL( CG_EVENT_REQUEST_ITEM_SYN )] Not Exist GameField" );
return;
}
DWORD eventID = 0;
FlowControl flow;
FLOWCONTROL_START()
{
// start LOGIC_BLOCK
if( FALSE == flow.FCAssert( pPlayer && pPlayer->GetField() ) )
{
SetFailFc(pPlayer, 1000);
break;
}
IfFailThenBreak(pPlayer->GetChaoState().CanUseFuction(CHAO_USE_EVENT),
RC::RC_EVENT_UNABLE_FUNCTION_FOR_CHAOSTATE);
IfFailThenBreak(pPlayer->GetBehave() != PLAYER_BEHAVE_UNEXPECTED_WAITING, RC::RC_EVENT_FAILED);
IfFailThenBreak(!pPlayer->EventTransaction().IsTransaction(), 1100);
sEventTransactionWrap autoTrans(pPlayer->EventTransaction());
eventID = pMsg->m_EventID;
SunEventInfoParser* pEventParser = SunEventInfoParser::Instance();
EVENT_INFO* pEventInfo = pEventParser->FindEventInfo( eventID );
IfFailThenBreak(pEventInfo, RC::RC_EVENT_INVALID_EVENT);
const DWORD eventMode = pEventInfo->m_byEventMode;
IfFailThenBreak(eEVENT_ITEM_SELECT == eventMode && pEventInfo->CheckEvent(),
RC::RC_EVENT_INVALID_EVENT);
// 이벤트 상태 필요
IfFailThenBreak(pEventInfo->CheckLevel(pPlayer->GetLevel()), RC::RC_EVENT_UNQUALIFIED);
EVENT_STATUS_EX* pEventStatus = pPlayer->PlayerEvent().FindEventStatus( eventID );
if( NULL == pEventStatus )
_RegisterEventStatus( eventID, pPlayer, &pEventStatus );
IfFailThenBreak(0 == pEventStatus->m_wRegisterCnt, RC::RC_EVENT_REWARDED_ITEM_NUM_OVERFLOW);
const BYTE requestIndex = pMsg->m_RequestItemIndex;
const CODETYPE requestRewardIndex = pEventInfo->m_dwRewardInfo[0];
IfFailThenBreak(_MAX_EVENT_REWARD > requestIndex && requestRewardIndex,
RC::RC_EVENT_ITEM_NUM_OVERFLOW);
ProtectorInventory& rPROTECT = pPlayer->GetWarehouseInventoryProtector().INVENTORY();
IfFailThenBreak(rPROTECT.IsUsable(), RC::RC_EVENT_ITEM_INVENTORY_LOCKED);
// 아이템 획득
// 실패 조건 (일반적인 에러, 뺏지맨과 같은 인벤에서의 중복 허용 여부, ~~)
MSG_CG_EVENT_ITEM_REWARD_CMD msgREWARD;
const RC::eREWARD_RESULT eRET = g_RewardManager.RewardItem(
RewardManager::eREWARD_EVENT,
requestRewardIndex,
(1<<requestIndex), pPlayer,
msgREWARD.m_TotalInfo
);
IfFailThenBreak(eRET == RC::RC_REWARD_SUCCESS,
RC::RC_EVENT_CANT_OBTAIN/*MSG_CG_EVENT_REQUEST_ITEM_NAK::_ERR_CANT_OBTAIN*/);
msgREWARD.m_dwEventID = pMsg->m_EventID;
msgREWARD.m_Money = pPlayer->GetMoney();
pPlayer->SendPacket( &msgREWARD, msgREWARD.GetSize() ); // 등록됐으니 아이템 받아라!
// SendToDB - ITEM_STATUS_REG (Heim, RegCnt~~)
pEventStatus->m_wRegisterCnt = 1; // 완료, 1개만 요청한다.
pEventStatus->m_Status = 1;
MSG_DG_EVENT_STATUS_UPDATE_SYN msgSYN;
msgSYN.m_EventStatus = *pEventStatus;
pPlayer->SendToGameDBPServer( &msgSYN, sizeof(msgSYN) );
return /*RETURN TRUE VALUE*/;
}
FLOWCONTROL_END;
switch( flow.GetErrorCode() )
{
case RC::RC_EVENT_FAILED:
case RC::RC_EVENT_INVALID_EVENT: // 이벤트 중이 아니다
case RC::RC_EVENT_ITEM_NUM_OVERFLOW: // 이벤트 아이템 등록 제한 개수를 넘었다
case RC::RC_EVENT_NOTEXISTITEM: // 이벤트에 응모할 아이템이 없다
case RC::RC_EVENT_CANT_OBTAIN: // 보상 아이템을 넣을 수가 없다
case RC::RC_EVENT_REWARDED_ITEM_NUM_OVERFLOW:
case RC::RC_EVENT_ITEM_INVENTORY_LOCKED:
case RC::RC_EVENT_UNQUALIFIED:
{
MSG_CG_EVENT_REQUEST_ITEM_NAK msgNAK;
msgNAK.SetInfo( (CODETYPE)eventID, flow.GetErrorCode() );
pPlayer->SendPacket( &msgNAK, sizeof(msgNAK) );
};
break;
case 1000: break; // fault-assertion
case 1100:
SUNLOG( eCRITICAL_LOG, _T("Irregular C/S Packet Policy [%u] %s"), pPlayer->GetCharGuid(), pPlayer->GetCharName() );
break;
default:
SUNLOG( eCRITICAL_LOG, _T("Unhandled Error Occured! %u"), flow.GetErrorCode() );
break;
}
return /*RETURN FALSE VALUE*/;
}
// <MSG_CG_EVENT_DONATION_HEIM_SYN>
// <returns>
// MSG_CG_EVENT_DONATION_HEIM_ACK
// MSG_CG_EVENT_ITEM_REWARD_CMD <- 특정 조건 만족시 (특정 구간 최소값<=curheims<=최대값, 회수 이내) 아이템 보상
Handler_CG_EVENT_IMPL( CG_EVENT_DONATION_HEIM_SYN ) // 기부 요청
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_CG_EVENT_DONATION_HEIM_SYN* pMsg = (MSG_CG_EVENT_DONATION_HEIM_SYN*)pRecvMsg;
if( CHECK_IS_NOT_FIELDSERVER() )
return;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
if (NULL == pPlayer)
return;
if( !pPlayer->GetField() )
{
SUNLOG( eCRITICAL_LOG, "[Handler_CG_EVENT_IMPL( CG_EVENT_DONATION_HEIM_SYN )] Not Exist GameField" );
return;
}
const DWORD eventID = pMsg->m_EventID;
MONEY donateHeims = 0;
FlowControl flow;
FLOWCONTROL_START()
{
// start LOGIC_BLOCK
if( FALSE == flow.FCAssert( pPlayer && pPlayer->GetField() ) )
{
SetFailFc( pPlayer, 1000 );
break;
}
IfFailThenBreak(pPlayer->GetChaoState().CanUseFuction(CHAO_USE_EVENT),
RC::RC_EVENT_UNABLE_FUNCTION_FOR_CHAOSTATE);
IfFailThenBreak(pPlayer->GetBehave() != PLAYER_BEHAVE_UNEXPECTED_WAITING, RC::RC_EVENT_FAILED);
IfFailThenBreak(!pPlayer->EventTransaction().IsTransaction(), 1100);
// Player* 의 이벤트 트랜젝션은 DB로 다녀와야 하는 경우 사용할 예정이긴 한데, 필요 없을 수도 있다.
// 좀더 경우를 따져 볼 것.
sEventTransactionWrap autoTrans(pPlayer->EventTransaction());
SunEventInfoParser* pEventParser = SunEventInfoParser::Instance();
EVENT_INFO* pEventInfo = pEventParser->FindEventInfo( eventID );
IfFailThenBreak(pEventInfo, RC::RC_EVENT_FAILED);
const DWORD eventMode = pEventInfo->m_byEventMode;
IfFailThenBreak(eEVENT_DONATION_HEIM == eventMode && pEventInfo->CheckEvent(),
RC::RC_EVENT_FAILED);
IfFailThenBreak(pEventInfo->CheckLevel(pPlayer->GetLevel()), RC::RC_EVENT_UNQUALIFIED);
donateHeims = pMsg->m_DonatedHeims;
IfFailThenBreak(pPlayer->GetMoney() >= donateHeims, RC::RC_EVENT_INSUFFICIENT_HEIM);
// 이벤트 상태 필요
EVENT_STATUS_EX* pEventStatus = pPlayer->PlayerEvent().FindEventStatus( eventID );
if( NULL == pEventStatus )
_RegisterEventStatus( eventID, pPlayer, &pEventStatus );
ProtectorInventory& rPROTECT = pPlayer->GetWarehouseInventoryProtector().INVENTORY();
IfFailThenBreak(rPROTECT.IsUsable(), RC::RC_EVENT_ITEM_INVENTORY_LOCKED);
// 기부 금액 변동에 따른 구간별 보상 처리 계산, MONEY->DWORD 변환이 존재하고 있다. 경고 목적으로 남겨둔다.
sEVENT_MINMAX_QUERY query( pEventInfo->m_EventRewardCode, pEventStatus->m_CurDonatedHeims, donateHeims, pEventInfo, pEventStatus->m_DonateHeimRewardCnt, pEventStatus->m_wRegisterCnt );
sEVENT_MINMAX_RESULT rResult;
pEventParser->FindMinMaxInfoByBoundary( query, rResult );
if( sEVENT_MINMAX_RESULT::CNTL_FAIL == rResult.m_Result )
{
SetFailFc( sEVENT_MINMAX_RESULT::CNTL_FAIL != rResult.m_Result,
rResult.m_ResultCode ? rResult.m_ResultCode : RC::RC_EVENT_FAILED );
break;
}
if( sEVENT_MINMAX_RESULT::CNTL_SUCCESS == rResult.m_Result )
IfFailThenBreak(rResult.m_DropCode, 1200);
// 돈 차감, 이 이후로 성공 여부 꼭 확인할 것, 실패시 복구 처리.
IfFailThenBreak(pPlayer->MinusMoney(donateHeims), RC::RC_EVENT_FAILED);
if( sEVENT_MINMAX_RESULT::CNTL_UPDATE == rResult.m_Result )
{ // 기부만 성공시
// update event status
pEventStatus->m_wRegisterCnt = (WORD)rResult.m_TotalRounds;
pEventStatus->m_DonateHeimRewardCnt = (BYTE)rResult.m_RewaredCount;
pEventStatus->m_CurDonatedHeims = rResult.m_CalcedDonatedMoney;
MSG_CG_EVENT_DONATION_HEIM_ACK msgACK;
msgACK.SetInfo( eventID, RC::RC_EVENT_SUCCESS_HEIM_DONATION );
msgACK.SetTotalHeim( pPlayer->GetMoney() );
pPlayer->SendPacket( &msgACK, sizeof(msgACK) /*msgACK.GetSize()*/ );
// SendToDB - ITEM_STATUS_REG (Heim, RegCnt~~)
MSG_DG_EVENT_STATUS_UPDATE_SYN msgSYN;
msgSYN.m_EventStatus = *pEventStatus;
pPlayer->SendToGameDBPServer( &msgSYN, sizeof(msgSYN) );
return;
}
// sEVENT_MINMAX_RESULT::CNTL_SUCCESS ...
//
// 보상 조건... 여기서부터의 에러는 ERR_CANT_OBTAIN_ITEM로서 돈 차감 복구처리를 해줘야 한다.
MSG_CG_EVENT_ITEM_REWARD_CMD msgREWARD;
DropObj* pDropObj = DropRatioInfoList::Instance()->PopRandomItemTypeIndex( rResult.m_DropCode );
if( FALSE == flow.FCAssert( pDropObj && DROP_OBJ_ITEM==pDropObj->GetType() ) )
{
SetFailFc( pDropObj, RC::RC_EVENT_CANT_OBTAIN );
break;
}
DropItemObj* pDropItemObj = static_cast<DropItemObj*>( pDropObj );
SLOTCODE itemCode = (SLOTCODE)pDropItemObj->GetItemCode();
POSTYPE itemNum = 1;
// 아이템 획득
// 실패 조건 (일반적인 에러, ~~)
if( RC::RC_ITEM_SUCCESS != pPlayer->GetItemManager()->ObtainAllKindOfItem(
1, &itemCode, &itemNum,
&msgREWARD.m_TotalInfo
) )
{
SetFailFc( pDropObj, RC::RC_EVENT_CANT_OBTAIN );
break;
}
//////////////////////////////////////////////////////////////////////////
//
msgREWARD.m_dwEventID = pMsg->m_EventID;
msgREWARD.m_Money = pPlayer->GetMoney();
pPlayer->SendPacket( &msgREWARD, msgREWARD.GetSize() ); // 등록됐으니 아이템 받아라!
// update event status
pEventStatus->m_wRegisterCnt = (WORD)rResult.m_TotalRounds;
pEventStatus->m_DonateHeimRewardCnt = (BYTE)rResult.m_RewaredCount;
pEventStatus->m_CurDonatedHeims = rResult.m_CalcedDonatedMoney;
// SendToDB - ITEM_STATUS_REG (Heim, RegCnt~~)
MSG_DG_EVENT_STATUS_UPDATE_SYN msgSYN;
msgSYN.m_EventStatus = *pEventStatus;
pPlayer->SendToGameDBPServer( &msgSYN, sizeof(msgSYN) );
return /*RETURN TRUE VALUE*/;
}
FLOWCONTROL_END;
switch( flow.GetErrorCode() )
{
case RC::RC_EVENT_FAILED: // 기본 에러,
case RC::RC_EVENT_INSUFFICIENT_HEIM: // 하임 부족
case RC::RC_EVENT_DONATION_HEIM_LIMIT: // 최소 기부 하임 만족 못함
case RC::RC_EVENT_REWARDED_ITEM_NUM_OVERFLOW: // 더 이상 보상 받을 수 없다.
case RC::RC_EVENT_ITEM_INVENTORY_LOCKED:
case RC::RC_EVENT_UNQUALIFIED:
{
MSG_CG_EVENT_DONATION_HEIM_ACK msgFAIL;
msgFAIL.SetInfo( (CODETYPE)eventID, (RC::eEVENT_RESULT)flow.GetErrorCode() );
msgFAIL.SetTotalHeim( pPlayer->GetMoney() );
pPlayer->SendPacket( &msgFAIL, sizeof(msgFAIL) /*msgFAIL.GetSize()*/ );
};
break;
case RC::RC_EVENT_CANT_OBTAIN:
{
// Heim 이 미리 차감되어 있었던 관계로 복구를 해줘야 한다.
pPlayer->PlusMoney( donateHeims );
MSG_CG_EVENT_DONATION_HEIM_ACK msgFAIL;
msgFAIL.SetInfo( (CODETYPE)eventID, (RC::eEVENT_RESULT)flow.GetErrorCode() );
msgFAIL.SetTotalHeim( pPlayer->GetMoney() );
pPlayer->SendPacket( &msgFAIL, sizeof(msgFAIL) /*msgFAIL.GetSize()*/ );
}
break;
case 1000: break; // fault-assertion
case 1100:
SUNLOG( eCRITICAL_LOG, _T("Irregular C/S Packet Policy [%u] %s"), pPlayer->GetCharGuid(), pPlayer->GetCharName() );
break;
case 1200:
SUNLOG( eCRITICAL_LOG, _T("[ErrorCode:%u] {%s}"), flow.GetErrorCode(), flow.GetErrorString() );
break;
default:
SUNLOG( eCRITICAL_LOG, _T("Unhandled Error Occured! %u"), flow.GetErrorCode() );
break;
}
return /*RETURN FALSE VALUE*/;
}
#include <SkillInfoParser.h>
#include "SkillManager.h"
// <CG_EVENT_BUFF_EVENT_SYN>
// <returns>
// - CG_EVENT_BUFF_EVENT_ACK
// - RC_EVENT_SUCCESS = 성공시
// - RC_EVENT_XXX = 실패 + 각 사례별 + 특정 사례는 그 원인이 추가로 붙는다.
// <NOTE>
// - 이것이 적용되면서 모든 이벤트에 다음과 같은 내용이 포함되어야 한다.
// - RC_EVENT_UNQUALIFIED = 실패 (적용 레벨이 아니다.)
Handler_CG_EVENT_IMPL(CG_EVENT_BUFF_EVENT_SYN ) // 버프 이벤트 요청
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const DWORD ERRCODE_DEFAULT = 1000;
const DWORD ERRCODE_TRANSACTION = ERRCODE_DEFAULT+1;
const MSG_CG_EVENT_BUFF_EVENT_SYN* pMsg = (const MSG_CG_EVENT_BUFF_EVENT_SYN*)pRecvMsg;
if( CHECK_IS_NOT_FIELDSERVER() )
return;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
if (NULL == pPlayer)
return;
if( !pPlayer->GetField() )
{
SUNLOG( eCRITICAL_LOG, "[Handler_CG_EVENT_IMPL( CG_EVENT_BUFF_EVENT_SYN )] Not Exist GameField" );
return;
}
typedef MSG_CG_EVENT_BUFF_EVENT_ACK::eRET_UNQUALIFIED eRET_UNQUALIFIED;
eRET_UNQUALIFIED addinInfo = MSG_CG_EVENT_BUFF_EVENT_ACK::RUC_EMPTY; // passing info for Error
CODETYPE eventID = 0; // passing info for Error
const MONSTERCODE recvedNpcCode = pMsg->m_NpcCode;
// (CHANGES) (100122) (WAVERIX) make packet with clear stream
char __buffer_block[sizeof(MSG_CG_EVENT_BUFF_EVENT_ACK)] = { 0, };
MSG_CG_EVENT_BUFF_EVENT_ACK& msgACK = *new (__buffer_block) MSG_CG_EVENT_BUFF_EVENT_ACK;
FlowControl flow;
FLOWCONTROL_START()
{
// start LOGIC_BLOCK
IfFailThenBreak(pPlayer && pPlayer->GetField() && sizeof(*pMsg) == wSize, ERRCODE_DEFAULT);
IfFailThenBreak(pPlayer->GetChaoState().CanUseFuction(CHAO_USE_EVENT),
RC::RC_EVENT_UNABLE_FUNCTION_FOR_CHAOSTATE);
IfFailThenBreak(pPlayer->GetBehave() != PLAYER_BEHAVE_UNEXPECTED_WAITING, RC::RC_EVENT_FAILED);
IfFailThenBreak(!pPlayer->EventTransaction().IsTransaction(), ERRCODE_TRANSACTION);
// Player* 의 이벤트 트랜젝션은 DB로 다녀와야 하는 경우 사용할 예정이긴 한데, 필요 없을 수도 있다.
// 좀더 경우를 따져 볼 것.
sEventTransactionWrap autoTrans(pPlayer->EventTransaction());
EventManager* const pEventManager = EventManager::GetEventManager();
SunEventInfoParser* const pEventParser = SunEventInfoParser::Instance();
typedef EventQueryResult::BuffEventIDs BuffEventIDs;
BuffEventIDs queryResult;
const BOOLEAN querySuccess = pEventManager->GetBuffEventIDbyNpcID( recvedNpcCode, &queryResult );
IfFailThenBreak(querySuccess, RC::RC_EVENT_INVALID_EVENT);
DWORD successCount = 0;
DWORD lastError = RC::RC_EVENT_SUCCESS;
BYTE count = queryResult.Count;
FOREACH_ARRAY(const BuffEventIDs::ARRAY::type eventID, queryResult.List, BuffEventIDs::ARRAY)
{
if( !(count--) )
break;
if( !eventID )
continue;
EVENT_INFO* const pEventInfo = pEventParser->FindEventInfo( eventID );
if( !( pEventInfo && pEventInfo->CheckEvent() ) )
{ lastError = RC::RC_EVENT_INVALID_EVENT; continue; }
const DWORD eventMode = pEventInfo->m_byEventMode;
if( (eEVENT_BUFF_GRANT != eventMode) )
{ lastError = RC::RC_EVENT_FAILED; continue; }
// <THINKING NOTE>
// - 1. BUFF를 적용해주는 처리 ( eEVENT_BUFF_GRANT일 경우, rewardinfo[0]에 skill정보가 입력된다. )
// - 1) applicable level check
// - 2. 중복 적용 방지
// - 1) assert( applied buff count == 1)
if( FALSE == pEventInfo->CheckLevel( pPlayer->GetLevel() ) )
{ lastError = RC::RC_EVENT_UNQUALIFIED; continue; }
// 노파심에서 CheckEvent가 수행되었다. 이벤트 조건에 만족하고 있을 것이다.
// 보상 아이템 준다!
const DWORD FIXED_SELECT_REWARD_INDEX = 0;
const DWORD skillInData = (pPlayer->CanApplyPCBangBenefit(true) == false)
? pEventInfo->m_dwRewardInfo[FIXED_SELECT_REWARD_INDEX]
: pEventInfo->m_dwPCRoomRewardInfo[FIXED_SELECT_REWARD_INDEX];
const SLOTCODE rewardSkill = SAFE_NUMERIC_TYPECAST(DWORD, skillInData, SLOTCODE) ? (SLOTCODE)skillInData : 0;
IfFailThenBreak(rewardSkill, RC::RC_EVENT_FAILED);
SkillInfoParser* const pSkillInfoParser = SkillInfoParser::Instance();
// 새로운 스킬에 대해 메모리를 할당받고 스킬정보를 셋팅한다.
SkillScriptInfo* const pBaseSkillInfo = pSkillInfoParser->GetSkillInfo( rewardSkill );
IfFailThenBreak(pBaseSkillInfo, RC::RC_EVENT_FAILED);
WzVector wvCurPos; pPlayer->GetPos(&wvCurPos);
SkillInfo skill_info_data(pPlayer, rewardSkill, 0);
skill_info_data.SetArgsObjectInfo(pPlayer->GetObjectKey(), &wvCurPos, &wvCurPos, &wvCurPos);
pPlayer->GetSkillManager()->RegisterSkill( SKILL_TYPE_ACTIVE, &skill_info_data);
msgACK.SetInfo_SUCCESS( eventID );
pPlayer->SendPacket( &msgACK, msgACK.GetSize() );
++successCount;
}
if( 0 == successCount )
{
SetFailFc( lastError, lastError );
break;
}
return; // SUCCESS
}
FLOWCONTROL_END;
switch( const DWORD errCode = flow.GetErrorCode() )
{
case RC::RC_EVENT_FAILED: // (기존:기타 이유로 실패시)
msgACK.SetInfo_FAIL();
break;
case RC::RC_EVENT_INVALID_EVENT: // (기존)
msgACK.SetInfo_INVALID();
break;
case RC::RC_EVENT_CANT_BUFF_GRANTED: // (신규:이미 부여되어 있을 경우)
msgACK.SetInfo_CANT_BUFF_GRANTED( eventID );
break;
case RC::RC_EVENT_UNQUALIFIED: // (신규:보상을 받을 수 없다. 자격이 안되서) + 추가 사유 기재 필요
msgACK.SetInfo_UNQUALIFIED( eventID, addinInfo );
break;
case RC::RC_EVENT_SUCCESS:
break;
case RC::RC_EVENT_UNABLE_FUNCTION_FOR_CHAOSTATE:
// skip logging because of too many logged. average = { 1hit/2sec }
break;
case ERRCODE_DEFAULT: // fault-assertion
case ERRCODE_TRANSACTION:
default:
SUNLOG( eCRITICAL_LOG, _T("[ErrorCode:%u] {%s}:[%u]"), flow.GetErrorCode(), flow.GetErrorString(), wSize );
return;
}
pPlayer->SendPacket( &msgACK, msgACK.GetSize() );
return /*RETURN FALSE VALUE*/;
}
Handler_CG_EVENT_IMPL(CG_EVENT_INVITATEFRIEND_REWARD_SYN )
{
GFriendInvitationController::Instance()->OnRewardSYN(pServerSession, pRecvMsg, wSize);
}
Handler_CG_EVENT_IMPL(CG_EVENT_INVITATEFRIEND_RECALL_SYN )
{
GFriendInvitationController::Instance()->OnRecallSYN(pServerSession, pRecvMsg, wSize);
}
Handler_CG_EVENT_IMPL(CG_EVENT_INVITATEFRIEND_RECALL_QUESTION_ACK )
{
GFriendInvitationController::Instance()->OnRecallQuestionACK(pServerSession, pRecvMsg, wSize);
}
Handler_CG_EVENT_IMPL(CG_EVENT_INVITATEFRIEND_RECALL_QUESTION_NAK )
{
GFriendInvitationController::Instance()->OnRecallQuestionNAK(pServerSession, pRecvMsg, wSize);
}
#ifdef _NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
//보상 타입과 mapcode를 받고 DB에 내용및 금액 확인 요청
//왕의 증표 사용시 유저의 인벤토리 공간확인및 Rock을 확인하여 DB에 요청
Handler_CG_EVENT_IMPL(CG_EVENT_DOMINATION_REWARD_CMD )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_CG_EVENT_DOMINATION_REWARD_CMD* recv_msg =
static_cast<MSG_CG_EVENT_DOMINATION_REWARD_CMD*>(pRecvMsg);
Player* player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
if (player == NULL)
{
assert(!"Player Not Found");
return;
}
eSYSTEM_MEMO_TYPE recv_reward_type;
MAPCODE recv_map_code;
//--메모 내용 검사
if (player->GetPostManager()->GetValueInMemo(recv_msg->memo_subject_,
recv_reward_type, recv_map_code))
{
MSG_DG_EVENT_DOMINATION_REWARD_AND_DEL_SYN send_msg;
send_msg.recv_char_guid_ = player->GetCharGuid();
send_msg.reward_area_mapcode_ = recv_map_code;
send_msg.reward_type_ = recv_reward_type;
send_msg.memo_guid_ = recv_msg->memo_guid_;
g_pGameServer->SendToServer(GAME_DBPROXY, &send_msg, sizeof(send_msg));
}
else
{
assert(!"Request SystemMemo Reward Value Is Incorrect");
SUNLOG(eCRITICAL_LOG,"["__FUNCTION__"]User[%u] SystemMemo[%s] Is Incorrect",
player->GetCharGuid(),recv_msg->memo_subject_);
}
}
//플레이어정보와 로또 index정보로 DB내용 및 금액 확인 요청
Handler_CG_EVENT_IMPL(CG_EVENT_LOTTO_REWARD_CMD )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_CG_EVENT_LOTTO_REWARD_CMD* recv_msg =
static_cast<MSG_CG_EVENT_LOTTO_REWARD_CMD*>(pRecvMsg);
const Player* player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
if (player == NULL)
{
assert(!"Player Not Found");
return;
}
MSG_DG_EVENT_LOTTO_REWARD_AND_DEL_SYN send_msg;
send_msg.request_char_guid_ = player->GetCharGuid();
send_msg.lotto_entry_index_ = recv_msg->lotto_entry_index_;
send_msg.memo_guid_ = recv_msg->memo_guid_;
g_pGameServer->SendToServer(GAME_DBPROXY, &send_msg, sizeof(send_msg));
}
#endif//_NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
// implemented by _NA_20100812_INTEGRATE_SYSTEM_MEMO_DOMINATION
//시스템 메모 GUID와 해당 케릭터 GUID정보를 DBP보내 보상 아이템을 확인한다.
Handler_CG_EVENT_IMPL(CG_EVENT_SYSTEMMEMO_ITEM_REWARD_REQ )
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_CG_EVENT_SYSTEMMEMO_ITEM_REWARD_REQ* recv_msg =
static_cast<MSG_CG_EVENT_SYSTEMMEMO_ITEM_REWARD_REQ*>(pRecvMsg);
const Player* player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
if (player == NULL)
{
assert(!"Player Not Found");
return;
}
MSG_DG_EVENT_SYSTEMMEMO_ITEM_CHECK_SYN syn_msg;
{
syn_msg.char_guid_ = player->GetCharGuid();
syn_msg.memo_guid_ = recv_msg->memo_guid_;
_tcsncpy(syn_msg.memo_contents_, recv_msg->memo_contents_,
_countof(syn_msg.memo_contents_));
syn_msg.memo_contents_[_countof(syn_msg.memo_contents_) - 1] = '\0';
}
g_pGameServer->SendToServer(GAME_DBPROXY, &syn_msg, sizeof(syn_msg));
}
Reference in New Issue View Git Blame Copy Permalink