2742 lines
100 KiB
C++
2742 lines
100 KiB
C++
#include "stdafx.h"
|
|
#include ".\handler_dg_charinfo.h"
|
|
#include <PacketStruct_DG.h>
|
|
#include <PacketStruct_CG.h>
|
|
#include <PacketStruct_AG.h>
|
|
#include "PlayerManager.h"
|
|
#include "Player.h"
|
|
#include <Macro.h>
|
|
#include <ServerSession.h>
|
|
#include <VarPacket.h>
|
|
#include "ItemManager.h"
|
|
#include "SCItemSlotContainer.h"
|
|
#include "DropManager.h"
|
|
#include "ObjectFactory.h"
|
|
#include "QuestManager.h"
|
|
#include "MissionManager.h"
|
|
#include "Skill.h"
|
|
#include "SkillManager.h"
|
|
#include <SkillSystem/PerkManager.h> //_NA002217_100728_EP2_PERK_SYSTEM_
|
|
#include "GameZone.h"
|
|
#include "GameZoneManager.h"
|
|
#include "WarehouseSlotContainer.h"
|
|
#include "GuildWarehouseSlotContainer.h"
|
|
#include "QuickManager.h"
|
|
#include "QuickStyleManager.h"
|
|
#include "EventInventorySlotContainer.h"
|
|
#include "GameServerEx.h"
|
|
#include "MissionManager.h"
|
|
#include "QuestManager_Concrete.h"
|
|
#include <AreaConquestCommonHeader.h>
|
|
#include <SunEventInfoParser.h>
|
|
#include <WayPoint.h>
|
|
#include "StatusManager.h"
|
|
#include <BitStream.hpp>
|
|
#include "GameShopManager.h"
|
|
#include ".\FriendInvitation\GFriendInvitationController.h"
|
|
|
|
#ifdef __CN_OO0510__FATIGUE_MATCHING_UPDATE
|
|
#include <FatigueOptionParser.h>
|
|
#endif //__CN_OO0510__FATIGUE_MATCHING_UPDATE
|
|
|
|
#include "RankingSystemCtl.h"
|
|
|
|
#include "GameGuildManager.h"
|
|
#include <PacketStruct_GZ.h>
|
|
#include <World/SSQ/SSQHandlerInGame.h>
|
|
|
|
#include "CollectedList.h"
|
|
#include "GameDominationManager.h"
|
|
#ifdef _NA_1419_20100121_ACCUMULATE_POINT
|
|
#include "AccumulatePoint.h"
|
|
#endif
|
|
#include "SystemMemo.h"
|
|
//_NA_20100604_BETTER_DOMINATION_MANAGER
|
|
#include ".\GameGuild.h"
|
|
|
|
#include "ComposeOrDecomposeImplement.h"
|
|
|
|
#ifdef _NA_0_20110308_SKILL_COOL_TIME_STORAGE
|
|
#include "./SkillSystem/SkillCoolTimeAccessor.h"
|
|
#endif
|
|
#include "ImplementUtil.h"
|
|
|
|
#ifdef _NA_003027_20111013_HONOR_SYSTEM
|
|
#include <HonorSystem/HonorSystem.h>
|
|
#include <HonorSystem/HonorSystemPacket.h>
|
|
#endif //_NA_003027_20111013_HONOR_SYSTEM
|
|
|
|
#ifdef _NA_0_20110613_GAME_SHOP_RENEWAL
|
|
#include "./GameShop/GameShop.Manager.h"
|
|
#include "./GameShop/GameShop.EventProcessor.h"
|
|
#endif
|
|
|
|
#ifdef _NA_007919_20141211_ADD_GMCOMMAND_EVENT
|
|
#include "PeakTimeEvent.h"
|
|
#endif //_NA_007919_20141211_ADD_GMCOMMAND_EVENT
|
|
|
|
#include <ExtraNpcManager.h>
|
|
#include <PacketStruct_MonsterBook.h>
|
|
|
|
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
#include "SunRanking/SunRankingManager.h"
|
|
#include "SunRanking/SunRankingGradeManager.h"
|
|
#include "StatueManager.h"
|
|
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
// changes, f100819.1L
|
|
const nsPacket::PacketHandlerInfo Handler_DG_CHARINFO::GetPacketHandlerNodes()
|
|
{
|
|
#define HANDLER_NODE_INFO(c, p, phase) { MAKEWORD(c, p), phase, Handler_DG_CHARINFO::On##p }
|
|
#define HANDLER_NODE_INFO_EOR() { 0, static_cast<ePHASE_SHIFT>(0), NULL }
|
|
|
|
static const nsPacket::PacketHandlerNode handlers_static_[] =
|
|
{
|
|
HANDLER_NODE_INFO(DG_ITEM, DG_ITEM_SERIAL_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_ITEM, DG_ITEM_SERIAL_NAK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_CHAR_ITEM_CMD, PHASE_SERVICE),
|
|
#ifdef _NA_20100106_REPURCHAS_BUGFIX_2496
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_CHAR_REPURCHASE_ITEM_CMD, PHASE_SERVICE),
|
|
#endif //_NA_20100106_REPURCHAS_BUGFIX_2496
|
|
//_KR_0_20091021_FIRENDINVITATION_EXTEND
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_INVITATEDFRIEND_CMD, PHASE_SERVICE),
|
|
//C_NA_0_20100520_ACSYSTEM_CHANGED
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_CHAR_ACHIEVEMENT_CMD, PHASE_SERVICE),
|
|
|
|
#ifdef _NA_0_20110308_SKILL_COOL_TIME_STORAGE
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_SKILL_COOL_TIME_CMD, PHASE_SERVICE),
|
|
#endif
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_SKILL_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_QUICK_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_STYLE_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_QUEST_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_EXTRA_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_UPDATE_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_UPDATE_NAK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_QUERY_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_QUERY_NAK, PHASE_SERVICE),
|
|
//_NA002217_100728_EP2_PERK_SYSTEM_
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_SKILL_LIST_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_SKILL_PERK_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_SKILL_PERK_CONTROL_CMD, PHASE_SERVICE),
|
|
//
|
|
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_WAREHOUSE_START_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_WAREHOUSE_START_NAK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_WAREHOUSE_END_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_WAREHOUSE_END_NAK, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_WAREHOUSE_PWD_SETTING_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_ITEM, DG_ITEM_INVENTORY_FLAG_STREAM_CMD, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_WAREHOUSE_FLAG_STREAM_CMD, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_SELECT_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_SELECT_NAK, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_UPDATE_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_UPDATE_NAK, PHASE_SERVICE),
|
|
|
|
// 오픈베타 에테르 이벤트
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_ITEM_STATUS_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_ITEM_STATUS_NAK, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_ITEM_REG_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_ITEM_REG_NAK, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_USETIME_CMD, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_QUERY_EXIST_ACK, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_STATUS_UPDATE_ACK, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_SSQ_REWARD_EXIST_CMD, PHASE_SERVICE),
|
|
// DG_EVENT_SSQ_REWARD_UPDATE_SYN, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_SSQ_REWARD_UPDATE_ACK, PHASE_SERVICE),
|
|
//_KR_0_20091021_FIRENDINVITATION_EXTEND = {
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_INVITATEFRIEND_REWARDUPDATE_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_INVITATEFRIEND_REWARDUPDATE_NAK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_INVITATEFRIEND_RECALLSELECT_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_INVITATEFRIEND_RECALLSELECT_NAK, PHASE_SERVICE),
|
|
//}
|
|
#ifdef _NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_DOMINATION_REWARD_AND_DEL_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_LOTTO_REWARD_AND_DEL_ACK, PHASE_SERVICE),
|
|
#endif////_NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
|
|
//_NA_20100812_INTEGRATE_SYSTEM_MEMO_DOMINATION
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_SYSTEMMEMO_ITEM_CHECK_ACK, PHASE_SERVICE),
|
|
// 미션 랭킹 관련
|
|
#ifdef _NA_008012_20150130_RANKING_SYSTEM
|
|
HANDLER_NODE_INFO(DG_MISSION, DG_MISSION_RECORD_SELECT_CMD, PHASE_SERVICE),
|
|
// HANDLER_NODE_INFO(DG_MISSION, DG_MISSION_CLEAR_UPDATE_ACK, PHASE_SERVICE),
|
|
//HANDLER_NODE_INFO(DG_MISSION, DG_MISSION_CLEAR_UPDATE_NAK, PHASE_SERVICE),
|
|
//HANDLER_NODE_INFO(DG_MISSION, DG_MISSION_RECORD_UPDATE_ACK, PHASE_SERVICE),
|
|
//HANDLER_NODE_INFO(DG_MISSION, DG_MISSION_RECORD_UPDATE_NAK, PHASE_SERVICE),
|
|
#endif // _NA_008012_20150130_RANKING_SYSTEM
|
|
|
|
#ifdef _NA_0_20110613_GAME_SHOP_RENEWAL
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_EXIST_CHARNAME_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_EXIST_CHARNAME_NAK, PHASE_SERVICE),
|
|
#else
|
|
#if !defined(__NA000000_SHOP_USERID_50_PASSING_PROC__)
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_EXIST_CHARNAME_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_EXIST_CHARNAME_NAK, PHASE_SERVICE),
|
|
#endif
|
|
#endif
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_SHOP_RECV_GIFT_NTF, PHASE_SERVICE),
|
|
#ifdef __CN_OO0510__FATIGUE_MATCHING_UPDATE
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_FATIGUE_CMD, PHASE_SERVICE),
|
|
#endif
|
|
|
|
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_WAYPOINT_INFO_LOAD_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_WAYPOINT_INFO_LOAD_NAK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_WAYPOINT_INFO_SAVE_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_WAYPOINT_INFO_SAVE_NAK, PHASE_SERVICE),
|
|
//{__NA001164_20081024_CHAR_WAY_POINT_PACKET
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_CHAR_WAYPOINT_INFO_LOAD_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_CHAR_WAYPOINT_INFO_SAVE_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_CHAR_WAYPOINT_INFO_DEL_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAYPOINT, DG_CHAR_WAYPOINT_INFO_NAK, PHASE_SERVICE),
|
|
//}
|
|
#ifdef _NA_008012_20150130_RANKING_SYSTEM
|
|
HANDLER_NODE_INFO(DG_MISSION, DG_MISSION_RANKING_POINT_REQ_ACK, PHASE_SERVICE),
|
|
#endif // _NA_008012_20150130_RANKING_SYSTEM
|
|
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_GUILD_WAREHOUSE_CLOSE_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_GUILD_WAREHOUSE_CLOSE_NAK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_GUILD_WAREHOUSE_TAPEX_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_WAREHOUSE, DG_GUILD_WAREHOUSE_TAPEX_NAK, PHASE_SERVICE),
|
|
//{__NA001283_20090227_COLLECTION_LIST
|
|
HANDLER_NODE_INFO(DG_COLLECT, DG_COLLECT_LIST_LOAD_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_COLLECT, DG_COLLECT_ADD_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_COLLECT, DG_COLLECT_DEL_ACK, PHASE_SERVICE),
|
|
|
|
HANDLER_NODE_INFO(DG_COLLECT, DG_COLLECT_NAK, PHASE_SERVICE),
|
|
//}
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_HEIM_LOTTO_PICK_NTF, PHASE_SERVICE),
|
|
#ifdef _NA_1419_20100121_ACCUMULATE_POINT
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_ACCUMULATEPOINT_MATCHDATE_NTF, PHASE_SERVICE),
|
|
#endif
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_SELECT_COMPOSITION_OR_DECOMPOSITION_HISTORIES_ACK, PHASE_SERVICE),
|
|
HANDLER_NODE_INFO(DG_OTHER, DG_OTHER_EXTEND_CHAR_SLOT_ACK, PHASE_SERVICE),
|
|
|
|
#ifdef _NA_003027_20111013_HONOR_SYSTEM
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_HONORSYSTEM, PHASE_UNLIMITED),
|
|
#endif //_NA_003027_20111013_HONOR_SYSTEM
|
|
#ifdef _NA004034_20120102_POINT_WALLET_SYSTEM
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARINFO_POINTWALLET_SYSTEM, PHASE_UNLIMITED),
|
|
#endif //_NA004034_20120102_POINT_WALLET_SYSTEM
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARNAME_CHANGE_ACK, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARACTER_EXTRA_INFO_CMD, PHASE_UNLIMITED), // _NA_006372_20130108_BADGE_ITEM
|
|
#ifdef _NA_000000_20140120_SMART_NPC_SYSTEM
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_EVENT_SMARTNPC_SYSTEM, PHASE_UNLIMITED),
|
|
#endif //_NA_000000_20140120_SMART_NPC_SYSTEM
|
|
#ifdef _NA_007086_20140318_MONSTERBOOK
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_CHARACTER_MONSTERBOOK_CMD, PHASE_UNLIMITED),
|
|
#endif //_NA_007086_20140318_MONSTERBOOK
|
|
|
|
#ifdef _NA_007932_20150106_USER_EXTRA_INFO
|
|
HANDLER_NODE_INFO(DG_CHARINFO, DG_USER_EXTRA_INFO_CMD, PHASE_UNLIMITED),
|
|
#endif // _NA_007932_20150106_USER_EXTRA_INFO
|
|
#ifdef _NA_007919_20141211_ADD_GMCOMMAND_EVENT
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_GMEVENT_PEAKTIME_REGISTER_ACK, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_EVENT, DG_GMEVENT_PEAKTIME_TERMINATE_ACK, PHASE_UNLIMITED),
|
|
#endif //_NA_007919_20141211_ADD_GMCOMMAND_EVENT
|
|
|
|
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_SUN_RANKING_UPDATE_ACK, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_SUN_RANKING_SELECT_ACK, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_SUN_RANKING_GRADE_SELECT_ACK, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_STATUE_SELECT_ACK, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_STATUE_ITEM_SLOT_INFO_INSERT_ACK, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_SUN_RANKING_SETTLE_START_CMD, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_SUN_RANKING_SETTLE_COMPLETE_CMD, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_SUN_RANKING_SELECT_COMPLETE_CMD, PHASE_UNLIMITED),
|
|
HANDLER_NODE_INFO(DG_SUN_RANKING, DG_SUN_RANKING_GRADE_SELECT_COMPLETE_CMD, PHASE_UNLIMITED),
|
|
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
//
|
|
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;
|
|
};
|
|
//--------------------------------------------------------------------------------------------------
|
|
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_CHAR_ITEM_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_CHAR_ITEM_CMD * pRecvMsg = (MSG_DG_CHARINFO_CHAR_ITEM_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
// Agent에 플레이어 HP 정보를 보내준다.
|
|
MSG_AG_CHARINFO_CHAR_CMD CharInfoMsg;
|
|
CharInfoMsg.m_MaxHP = pRecvMsg->m_CharacterInfo.m_iMaxHP;
|
|
CharInfoMsg.m_HP = pRecvMsg->m_CharacterInfo.m_iHP;
|
|
CharInfoMsg.m_MaxMP = pRecvMsg->m_CharacterInfo.m_iMaxMP;
|
|
CharInfoMsg.m_MP = pRecvMsg->m_CharacterInfo.m_iMP;
|
|
|
|
CharInfoMsg.m_dwCHuntingVCount = pRecvMsg->m_CharacterInfo.m_iCHuntingVCount;
|
|
CharInfoMsg.m_dwCHuntingTotCount = pRecvMsg->m_CharacterInfo.m_iCHuntingTotCount;
|
|
CharInfoMsg.m_byChaoState = pRecvMsg->m_CharacterInfo.m_ChaoState;
|
|
|
|
CharInfoMsg.m_MaxSD = pRecvMsg->m_CharacterInfo.m_iMaxSD;
|
|
CharInfoMsg.m_SD = pRecvMsg->m_CharacterInfo.m_iSD;
|
|
|
|
#ifdef _NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
|
|
CharInfoMsg.max_FP = pRecvMsg->m_CharacterInfo.max_FP_;
|
|
CharInfoMsg.cur_FP = pRecvMsg->m_CharacterInfo.cur_FP_;
|
|
#endif //_NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
|
|
|
|
pPlayer->SendPacket( &CharInfoMsg, sizeof(CharInfoMsg) );
|
|
// 캐릭터 정보 셋팅
|
|
pPlayer->SetCharInfo( &pRecvMsg->m_CharacterInfo );
|
|
|
|
ProtectorInventory& rPROTECT = pPlayer->GetWarehouseInventoryProtector().INVENTORY();
|
|
rPROTECT.SetPasswordFromDB( pRecvMsg->m_CharacterInfo.m_InventoryPwd );
|
|
BOOL bPwdSet = rPROTECT.IsEmptyPassword() ? FALSE : TRUE;
|
|
rPROTECT.Block( bPwdSet, FALSE );
|
|
|
|
{
|
|
eSPECIAL_RENDER_EFFECT effect = eSPECIAL_RENDER_EFFECT_NONE;
|
|
switch( pRecvMsg->m_CharacterInfo.m_ChangeOfClassStep )
|
|
{
|
|
case eCHAREX_BERSERKER_100LEVEL:
|
|
case eCHAREX_DRAGON_KNIGHT_100LEVEL:
|
|
case eCHAREX_SHADOW_100LEVEL:
|
|
case eCHAREX_VALKYRIE_100LEVEL:
|
|
case eCHAREX_ELEMENTALIST_100LEVEL:
|
|
case eCHAREX_MYSTIC_100LEVEL:
|
|
case eCHAREX_HELLROID_100LEVEL:
|
|
#ifdef _NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
|
|
case eCHAREX_WITCHBLADE_100LEVEL:
|
|
#endif //_NA_007514_20140828_NEW_CHARACTER_WITCHBLADE
|
|
effect = eSPECIAL_RENDER_EFFECT_CHANGEofCLASS_1st;
|
|
}
|
|
pPlayer->RENDER_EFFECT.AddEffect( effect );
|
|
};
|
|
|
|
// 아이템 정보 셋팅
|
|
// pPlayer->GetItemManager()->DBLoad( &pRecvMsg->m_ItemInfo );
|
|
pPlayer->GetItemManager()->SerializeItemTotalInfo( pRecvMsg->m_ItemInfo, SERIALIZE_STORE );
|
|
|
|
if (pRecvMsg->m_CharacterInfo.m_bActiveEtherDevice) {
|
|
pPlayer->m_EtherManager.ActiveBulletItem( pRecvMsg->m_CharacterInfo.m_byEtherBulletPos );
|
|
}
|
|
}
|
|
|
|
#ifdef _NA_20100106_REPURCHAS_BUGFIX_2496
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_CHAR_REPURCHASE_ITEM_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_CHAR_REPURCHASE_ITEM_CMD * pRecvMsg = (MSG_DG_CHARINFO_CHAR_REPURCHASE_ITEM_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetItemManager()->GetTradingImpl()->SerializeRepurchaseItems(
|
|
pRecvMsg->m_RepurchasItem, SERIALIZE_STORE);
|
|
}
|
|
#endif //_NA_20100106_REPURCHAS_BUGFIX_2496
|
|
|
|
// implemented by _KR_0_20091021_FIRENDINVITATION_EXTEND
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_INVITATEDFRIEND_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_INVITATEDFRIEND_CMD * pRecvMsg = (MSG_DG_CHARINFO_INVITATEDFRIEND_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
GFriendInvitationController::Instance()->GetInvitatedFrindInfo(pPlayer,
|
|
pRecvMsg, SERIALIZE_STORE);
|
|
}
|
|
|
|
//C_NA_0_20100520_ACSYSTEM_CHANGED
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_CHAR_ACHIEVEMENT_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_CHAR_ACHIEVEMENT_CMD * pRecvMsg = (MSG_DG_CHARINFO_CHAR_ACHIEVEMENT_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetACManager()->Serialize(pRecvMsg->achievement_info_, ACHIEVEMENT_SAVE);
|
|
}
|
|
|
|
#ifdef _NA_0_20110308_SKILL_COOL_TIME_STORAGE
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_SKILL_COOL_TIME_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_SKILL_COOL_TIME_CMD * pRecvMsg = (MSG_DG_CHARINFO_SKILL_COOL_TIME_CMD *)pMsg;
|
|
Player * player = PlayerManager::Instance()->FindPlayerByUserKey(pRecvMsg->m_dwKey);
|
|
if(player == NULL)
|
|
return;
|
|
|
|
SkillCoolTimeAccessor::Instance()->ApplySkillCoolTime(player, &(pRecvMsg->skill_cool_time));
|
|
}
|
|
#endif
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_SKILL_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_SKILL_CMD * pRecvMsg = (MSG_DG_CHARINFO_SKILL_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->SerializeSkillTotalInfo( pRecvMsg->m_SkillInfo, SERIALIZE_STORE );
|
|
}
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_QUICK_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_QUICK_CMD * pRecvMsg = (MSG_DG_CHARINFO_QUICK_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetQuickManager()->SerializeQuickTotalInfo( pRecvMsg->m_QuickInfo, SERIALIZE_STORE );
|
|
pPlayer->GetQuickManager()->UpdateOriginalItems();
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_STYLE_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_STYLE_CMD * pRecvMsg = (MSG_DG_CHARINFO_STYLE_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetStyleManager()->SerializeStyleTotalInfo( pRecvMsg->m_StyleInfo, SERIALIZE_STORE );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_QUEST_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_QUEST_CMD * pRecvMsg = (MSG_DG_CHARINFO_QUEST_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetMissionManager()->SerializeStream( pRecvMsg->m_pMissionStream, MAX_MISSIONSTREAM_SIZE, SERIALIZE_STORE );
|
|
pPlayer->GetQuestManager()->SerializeProgrStream( pRecvMsg->m_pProgrQStream, MAX_PROGR_QUESTSTREAM_SIZE, QSERIALIZE_SAVE );
|
|
pPlayer->GetQuestManager()->SerializeComplStream( pRecvMsg->m_pComplQStream, MAX_COMPL_QUESTSTREAM_SIZE, QSERIALIZE_SAVE );
|
|
|
|
// Agent로 QUEST정보 보냄
|
|
/*MSG_AG_CHARINFO_QUEST_CMD msg;
|
|
memcpy( msg.m_pMissionStream, pRecvMsg->m_pMissionStream, MAX_MISSIONSTREAM_SIZE );
|
|
memcpy( msg.m_pQuestStream, pRecvMsg->m_pQuestStream, MAX_MISSIONSTREAM_SIZE );
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );*/
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_EXTRA_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_EXTRA_CMD * pRecvMsg = (MSG_DG_CHARINFO_EXTRA_CMD *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetStatusManager()->SerialzieStatusDetailInfo( pRecvMsg->m_TotalInfo, SERIALIZE_STORE );
|
|
pPlayer->SerialzieStatusGMInfo( pRecvMsg->m_GMStateInfo, SERIALIZE_STORE );
|
|
}
|
|
|
|
//==================================================================================================
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARINFO_SKILL_LIST_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
#if !defined(_NA002217_100728_EP2_PERK_SYSTEM_)
|
|
ASSERT(!"Current version not supported");
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARINFO_SKILL_PERK_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
#if !defined(_NA002217_100728_EP2_PERK_SYSTEM_)
|
|
ASSERT(!"Current version not supported");
|
|
return;
|
|
#endif
|
|
|
|
#ifdef _NA002217_100728_EP2_PERK_SYSTEM_
|
|
const MSG_DG_CHARINFO_SKILL_PERK_CMD* recv_msg = static_cast<MSG_DG_CHARINFO_SKILL_PERK_CMD*>(pMsg);
|
|
const DWORD user_guid = recv_msg->m_dwKey;
|
|
const CHARGUID char_guid = recv_msg->char_guid_;
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey(user_guid);
|
|
if (!FlowControl::FCAssert(player && player->GetCharGuid() == char_guid)) {
|
|
return;
|
|
}
|
|
|
|
nsSkill::PerkManager* perk_manager = player->GetPerkManager();
|
|
perk_manager->StorePerk(recv_msg->container_, char_guid);
|
|
#endif
|
|
}
|
|
|
|
#ifdef __WAVERIX_TEST_LOGIC_TASK_MACRO__
|
|
extern void __WxTest_Receive_Perk_Control_DG(const MSG_DG_CHARINFO_SKILL_PERK_CONTROL_CMD* msg_cmd);
|
|
#define DEBUG_REPORT_RECEIVE_PERK_CONTROL(msg) __WxTest_Receive_Perk_Control_DG(msg)
|
|
#else
|
|
#define DEBUG_REPORT_RECEIVE_PERK_CONTROL(msg)
|
|
#endif
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARINFO_SKILL_PERK_CONTROL_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
#if !defined(_NA002217_100728_EP2_PERK_SYSTEM_)
|
|
ASSERT(!"Current version not supported");
|
|
return;
|
|
#endif
|
|
#ifdef _NA002217_100728_EP2_PERK_SYSTEM_
|
|
const MSG_DG_CHARINFO_SKILL_PERK_CONTROL_CMD* recv_msg = \
|
|
static_cast<MSG_DG_CHARINFO_SKILL_PERK_CONTROL_CMD*>(pMsg);
|
|
const DWORD user_key = recv_msg->m_dwKey;
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey(user_key);
|
|
if (!FlowControl::FCAssert(player != NULL)) {
|
|
return;
|
|
}
|
|
//
|
|
GameField* const game_field = player->GetField();
|
|
if (game_field == NULL) {
|
|
return;
|
|
}
|
|
//
|
|
nsSkill::PerkManager* perk_manager = player->GetPerkManager();
|
|
const PerkControl& req_info = recv_msg->header;
|
|
switch (req_info.request)
|
|
{
|
|
case req_info.eReq_InsertS2S:
|
|
case req_info.eReq_DeleteS2S:
|
|
break;
|
|
default:
|
|
SUNLOG(eCRITICAL_LOG, _T("|[%s]|斤口=unauthrization request|瑯뵀Guid=%u|Requester=%s|"),
|
|
__FUNCTION__, user_key, player->GetCharName());
|
|
return;
|
|
}
|
|
//
|
|
MSG_CG_SKILL_PERK_CONTROL_CMD msg_cmd;
|
|
nsSkill::PerkManager::eRequestResult result = \
|
|
perk_manager->ProcessRequestedMessage(req_info, &msg_cmd.header, &msg_cmd.data);
|
|
if (result == perk_manager->eReqResult_NeedForward)
|
|
{
|
|
ASSERT(!"unexprected status");
|
|
}
|
|
else if (result == perk_manager->eReqResult_ReplyResult)
|
|
{
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
}
|
|
DEBUG_REPORT_RECEIVE_PERK_CONTROL(recv_msg);
|
|
#endif //_NA002217_100728_EP2_PERK_SYSTEM_
|
|
}
|
|
|
|
//==================================================================================================
|
|
|
|
class PassiveSkillListOpr
|
|
{
|
|
BYTE m_byCount;
|
|
SLOTCODE *m_SkillCodeArray;
|
|
public:
|
|
PassiveSkillListOpr( SLOTCODE *SkillCodeArray ) : m_SkillCodeArray(SkillCodeArray), m_byCount(0) {}
|
|
BYTE GetCount() { return m_byCount; }
|
|
|
|
VOID operator () ( Skill *pSkill )
|
|
{
|
|
m_SkillCodeArray[m_byCount] = pSkill->GetSkillCode();
|
|
++m_byCount;
|
|
}
|
|
};
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_UPDATE_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_UPDATE_ACK * pRecvMsg = (MSG_DG_CHARINFO_UPDATE_ACK *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return;
|
|
|
|
//SUNLOG( eFULL_LOG, "DG_CHARINFO_UPDATE_ACK[%s][%d]", pPlayer->GetCharName(), pPlayer->GetBehave() );
|
|
|
|
g_GameGuildManager.DestroyMember( pPlayer->GetCharInfo()->m_GuildGuid, pPlayer->GetCharGuid() );
|
|
|
|
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
SunRankingManager::Instance()->ProcessDisconnect(pPlayer);
|
|
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
|
|
MSG_DG_CHARINFO_DISCONNECT_CHAR_CMD cmd;
|
|
pPlayer->SendToGameDBPServer( &cmd, sizeof(cmd) );
|
|
|
|
MSG_AG_ZONE_ROOM_LEAVE_ACK msg;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
|
|
PlayerManager::Instance()->RemovePlayer( pPlayer );
|
|
}
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_UPDATE_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_UPDATE_NAK * pRecvMsg = (MSG_DG_CHARINFO_UPDATE_NAK *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return;
|
|
|
|
//SUNLOG( eCRITICAL_LOG, "DG_CHARINFO_UPDATE_NAK[%u][%u][%u]", UserKey, pPlayer->GetUserID(), pRecvMsg->m_dwErrorCode );
|
|
|
|
//2007.02.14 발렌타인데이 쓸쓸하게 추가함.
|
|
MSG_AG_ZONE_ROOM_LEAVE_NAK nmsg;
|
|
nmsg.m_dwErrorCode = pRecvMsg->m_dwErrorCode;
|
|
pPlayer->SendPacket( &nmsg, sizeof(nmsg) );
|
|
}
|
|
|
|
#ifdef __WAVERIX_TEST_LOGIC_TASK_MACRO__
|
|
extern void __WxTest_Receive_Perk_List(const MSG_CG_CHARINFO_SKILL_PERK_CMD* msg_cmd);
|
|
#define DEBUG_REPORT_RECEIVE_PERK_LIST(msg) __WxTest_Receive_Perk_List(msg)
|
|
#else
|
|
#define DEBUG_REPORT_RECEIVE_PERK_LIST(msg)
|
|
#endif
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARINFO_QUERY_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
const MSG_DG_CHARINFO_QUERY_ACK* recv_msg = static_cast<MSG_DG_CHARINFO_QUERY_ACK*>(pMsg);
|
|
PlayerManager* const player_manager = PlayerManager::Instance();
|
|
const DWORD user_key = recv_msg->m_dwKey;
|
|
Player* const player = player_manager->FindPlayerByUserKey(user_key);
|
|
if (player == NULL) {
|
|
return;
|
|
}
|
|
player_manager->AddPlayerName(player);
|
|
//
|
|
const ePLAYER_STATE player_state = static_cast<ePLAYER_STATE>(player->GetState());
|
|
if (player_state == PLAYER_CHARINFO_FIRST_REQUESTED)
|
|
{
|
|
static char busy_access_buffer[1024 * 64];
|
|
;{
|
|
MSG_CG_CHARINFO_CHAR_ITEM_CMD& msg_items = \
|
|
*new (busy_access_buffer) MSG_CG_CHARINFO_CHAR_ITEM_CMD;
|
|
//
|
|
player->CopyToCharInfo(msg_items.m_CharacterInfo);
|
|
// TODO: need check about size cacluation
|
|
msg_items.m_Size = sizeof(RENDER_ITEMSTREAMEX) *
|
|
(MAX_INVENTORY_SLOT_NUM + MAX_TEMPINVENTORY_SLOT_NUM);
|
|
BitStream stream(msg_items.m_BitStreamBuffer, msg_items.m_Size, true);
|
|
//// LOAD
|
|
// removed by __001347_LTJ_REMOVE_TEMP_INVENTORY
|
|
//GetItemSlotContainer(SI_TEMPINVENTORY)->Serialize(stream, eSLOT_SERIALIZE_CLIENT_LOAD);
|
|
//// 유료화탭은 별도로 분리해야함
|
|
SCItemSlotContainer* const inventory = \
|
|
player->GetItemManager()->GetItemSlotContainer(SI_INVENTORY);
|
|
inventory->Serialize(stream, eSLOT_SERIALIZE_CLIENT_LOAD);
|
|
msg_items.m_Size = stream.GetNumberOfBytesUsed();
|
|
|
|
msg_items.Encode();
|
|
player->SendPacket(&msg_items, msg_items.GetSize());
|
|
};
|
|
;{
|
|
MSG_CG_CHARINFO_SKILL_CMD& msg_cmd = \
|
|
*new (busy_access_buffer) MSG_CG_CHARINFO_SKILL_CMD;
|
|
player->SerializeSkillTotalInfo(msg_cmd.m_SkillInfo, SERIALIZE_LOAD);
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
};
|
|
;{
|
|
MSG_CG_CHARINFO_QUICK_CMD& msg_cmd = \
|
|
*new (busy_access_buffer) MSG_CG_CHARINFO_QUICK_CMD;
|
|
player->GetQuickManager()->SerializeQuickTotalInfo(msg_cmd.m_QuickInfo, SERIALIZE_LOAD);
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
};
|
|
;{
|
|
MSG_CG_CHARINFO_STYLE_CMD& msg_cmd = \
|
|
*new (busy_access_buffer) MSG_CG_CHARINFO_STYLE_CMD;
|
|
player->GetStyleManager()->SerializeStyleTotalInfo(msg_cmd.m_StyleInfo, SERIALIZE_LOAD);
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
};
|
|
|
|
#ifdef _NA_0_20110308_SKILL_COOL_TIME_STORAGE
|
|
;{
|
|
MSG_CG_CHARINFO_SKILL_COOL_TIME_CMD& msg_cmd = \
|
|
*new (busy_access_buffer) MSG_CG_CHARINFO_SKILL_COOL_TIME_CMD;
|
|
SkillCoolTimeAccessor::Instance()->GetSkillCoolTime(player, &(msg_cmd.skill_cool_time));
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
};
|
|
#endif
|
|
|
|
#ifdef _NA002217_100728_EP2_PERK_SYSTEM_
|
|
;{
|
|
//MSG_CG_CHARINFO_SKILL_LIST_CMD& msg_cmd = \
|
|
// *new (busy_access_buffer) MSG_CG_CHARINFO_SKILL_LIST_CMD;
|
|
};
|
|
;{
|
|
MSG_CG_CHARINFO_SKILL_PERK_CMD& msg_cmd = \
|
|
*new (busy_access_buffer) MSG_CG_CHARINFO_SKILL_PERK_CMD;
|
|
nsSkill::PerkManager* const perk_manager = player->GetPerkManager();
|
|
perk_manager->LoadPerk(&msg_cmd.container_);
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
DEBUG_REPORT_RECEIVE_PERK_LIST(&msg_cmd);
|
|
};
|
|
#endif
|
|
;{
|
|
MSG_AG_MISSION_STREAM_CMD& msg_cmd = \
|
|
*new (busy_access_buffer) MSG_AG_MISSION_STREAM_CMD;
|
|
player->GetMissionManager()->SerializeStream(msg_cmd.m_TotalInfo, SERIALIZE_LOAD);
|
|
if (0 != msg_cmd.m_TotalInfo.m_Count)
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
};
|
|
;{
|
|
// 퀘스트 정보 보냄
|
|
player->GetQuestManager()->SendQuestStream();
|
|
};
|
|
;{
|
|
// AC 정보 보냄
|
|
MSG_CG_AREACONQUEST_STREAM_CMD& msg_cmd = \
|
|
*new (busy_access_buffer) MSG_CG_AREACONQUEST_STREAM_CMD;
|
|
//C_NA_0_20100520_ACSYSTEM_CHANGED
|
|
player->GetACManager()->Serialize(msg_cmd.achievement_info_, ACSERIALIZE_CLIENT_LOAD);
|
|
player->SendPacket(&msg_cmd, msg_cmd.GetSize());
|
|
};
|
|
|
|
#ifdef _NA_1419_20100121_ACCUMULATE_POINT
|
|
// 적립 포인트 보냄
|
|
player->GetAccumulatePoint()->SendPacketAccumulatePoint();
|
|
#endif
|
|
#ifdef _NA_003027_20111013_HONOR_SYSTEM
|
|
{
|
|
WORD normalQ_count, dailyQ_count;
|
|
player->GetQuestManager()->GetCompleteQuestCount(normalQ_count, dailyQ_count);
|
|
player->GetACManager()->ProcessQuestCount(normalQ_count, dailyQ_count);
|
|
}
|
|
#endif//_NA_003027_20111013_HONOR_SYSTEM
|
|
//#ifdef _NA_006372_20130108_BADGE_ITEM
|
|
// ;{
|
|
// MSG_CG_CHARINFO_CHAR_ITEM_TOGGLE_CMD& msg_cmd = \
|
|
// *new (busy_access_buffer)MSG_CG_CHARINFO_CHAR_ITEM_TOGGLE_CMD;
|
|
//
|
|
// const nsSlot::TOGGLE_ITEMS* toggle_item_info = player->GetToggleItemInfo();
|
|
// memcpy(msg_cmd.toggle_items_info_, toggle_item_info, sizeof(msg_cmd.toggle_items_info_));
|
|
// player->SendPacket(&msg_cmd, sizeof(msg_cmd));
|
|
// };
|
|
//#endif //_NA_006372_20130108_BADGE_ITEM
|
|
//_NA_005026_20120527_CHAOS_ZONE_BATTLE_GROUND
|
|
;{
|
|
MSG_CG_CHARINFO_CHAOS_ZONE_RECORD_INFOS_CMD& cmd_msg = \
|
|
*new (busy_access_buffer)MSG_CG_CHARINFO_CHAOS_ZONE_RECORD_INFOS_CMD;
|
|
|
|
// 전장전적..
|
|
const BattleGroundRecordInfos record_infos = \
|
|
player->GetExtraInfoManager().GetBattleGroundRecordInfos();
|
|
memcpy(cmd_msg.chaos_zone_record_infos.battle_ground_record,
|
|
record_infos.battle_ground_record,
|
|
sizeof(cmd_msg.chaos_zone_record_infos.battle_ground_record));
|
|
#ifdef _NA_007065_20140217_CHAOSZONE_GOLDRUSH
|
|
const GoldRushRecordInfos goldrush_infos = \
|
|
player->GetExtraInfoManager().GetGoldRushRecordInfos();
|
|
memcpy(cmd_msg.chaos_zone_record_infos.goldrush_record, goldrush_infos.goldrush_record,
|
|
sizeof(cmd_msg.chaos_zone_record_infos.goldrush_record));
|
|
#endif //_NA_007065_20140217_CHAOSZONE_GOLDRUSH
|
|
|
|
player->SendPacket(&cmd_msg, sizeof(cmd_msg));
|
|
};
|
|
|
|
#ifdef _NA_007086_20140318_MONSTERBOOK
|
|
;{
|
|
MonsterBook& monsterbook = player->GetMonsterBook();
|
|
MSG_CG_MONSTERBOOK_SERIALIZE_CMD& cmd_msg =
|
|
*new (busy_access_buffer) MSG_CG_MONSTERBOOK_SERIALIZE_CMD;
|
|
cmd_msg.monster_code_count = monsterbook.monster_code_count;
|
|
memcpy(&cmd_msg.monster_code, &monsterbook.monster_code, sizeof(cmd_msg.monster_code));
|
|
player->SendPacket(&cmd_msg, sizeof(cmd_msg));
|
|
};
|
|
#endif //_NA_007086_20140318_MONSTERBOOK
|
|
#ifdef _NA_007932_20150112_ATTENDANCE_CHECK_SYSTEM
|
|
;{
|
|
AttendanceManager& attendance_manager = player->GetExtraInfoManager().GetAttendanceManager();
|
|
attendance_manager.ToAttend(player);
|
|
|
|
MSG_CG_CHARINFO_ATTENDANCE_INFO_PACKET msg;
|
|
memcpy(&msg.attendance_infos, &attendance_manager.GetAttendanceInfos(),
|
|
sizeof(msg.attendance_infos));
|
|
player->SendPacket(&msg, sizeof(msg));
|
|
};
|
|
#endif // _NA_007932_20150112_ATTENDANCE_CHECK_SYSTEM
|
|
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
;{
|
|
MSG_CG_CHARINFO_SUN_RANKING_GRADE_PACKET msg;
|
|
SunRankingGradeManager::Instance()->GetTopGrade(player->GetCharGuid(), msg.grade, msg.ranking_type);
|
|
player->SendPacket(&msg, sizeof(msg));
|
|
};
|
|
;{
|
|
MSG_CG_ETC_STATUE_INFO_ACK msg;
|
|
StatueInfo* statue_info = StatueManager::Instance()->GetStatue(eSTATUE_TYPE_BEST_OF_BEST, eSTATUE_INDEX_FIRST);
|
|
if (statue_info != NULL)
|
|
{
|
|
msg.info = *statue_info;
|
|
player->SendPacket(&msg, sizeof(msg));
|
|
}
|
|
};
|
|
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
#ifdef _NA_008404_20150712_MINIGAME_SYSTEM
|
|
;{
|
|
if (player->GetExtraInfoManager().GetMiniGameManager().IsEventProgress(eMINIGAME_TYPE_BINGO))
|
|
{
|
|
MSG_CG_CHARINFO_MINIGAME_BINGO_INFO_PACKET info_packet;
|
|
memcpy(&info_packet.minigame_bingo_infos,
|
|
&(player->GetExtraInfoManager().GetMiniGameManager().GetMiniGameBingoInfos()),
|
|
sizeof(info_packet.minigame_bingo_infos));
|
|
player->SendPacket(&info_packet, sizeof(info_packet));
|
|
}
|
|
};
|
|
#endif // _NA_008404_20150712_MINIGAME_SYSTEM
|
|
}
|
|
else if (player_state == PLAYER_CHARINFO_REQUESTED)
|
|
{
|
|
// nothing to do
|
|
}
|
|
else
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, _T("|[%s]|[U:%d,ID:%s]InvalidState"),
|
|
__FUNCTION__, user_key, player->GetUserID());
|
|
};
|
|
//
|
|
//---------------------------------------------------------------------------------------------
|
|
// extra control
|
|
;{
|
|
//캐릭터 정보를 처음 세팅하는 곳이므로... 적립된 HP는 maxhp의 30%로 한다.
|
|
const DWORD max_hp = player->GetMaxHP();
|
|
const DWORD hp = player->GetHP();
|
|
DWORD reserve_hp = static_cast<DWORD>(double(max_hp) * 0.3f);
|
|
DWORD calc = hp + reserve_hp;
|
|
if (calc > max_hp) {
|
|
reserve_hp = calc - max_hp;
|
|
}
|
|
player->SetReserveHP(reserve_hp); // range = [0, max_hp * 30%]
|
|
};
|
|
//---------------------------------------------------------------------------------------------
|
|
// manipulate logic related to guild
|
|
if (player->GetGuildGuid() != 0)
|
|
{
|
|
if (player_state == PLAYER_CHARINFO_FIRST_REQUESTED)
|
|
{
|
|
// 최초 접속이면 길드서버에 로그인 준비를 시킨다.
|
|
// 여기서 로그인을 못하는 이유는 아직 클라이언트가 로딩중이기 때문이다.
|
|
// 로그인 패킷이 있는데 이 패킷을 보내는 이유는 현재 최초 접속인데 길드 서버에
|
|
// 로그인한 상태의 유저가 있을지 모르기 때문이다.
|
|
// 길드 서버에 로그인한 상태의 유저가 있으면 해당 유저는 길드정보를 받지 못하기 때문에 안된다.
|
|
MSG_GZ_GUILD_PRE_LOGIN_CMD msg_pre_login;
|
|
msg_pre_login.m_GuildGuid = player->GetGuildGuid();
|
|
msg_pre_login.m_CharGuid = player->GetCharGuid();
|
|
if (!player->SendToGuildServer(&msg_pre_login, sizeof(msg_pre_login)))
|
|
{
|
|
SUNLOG(eCRITICAL_LOG,
|
|
_T("|[%s]|MSG_GZ_GUILD_PRE_LOGIN_CMD message send failed, ")
|
|
_T("GuildGuid = %u, CharGuid = %u|"),
|
|
__FUNCTION__, msg_pre_login.m_GuildGuid, msg_pre_login.m_CharGuid);
|
|
}
|
|
#ifdef _NA_008334_20150608_SONNENSCHEIN
|
|
#else
|
|
GameDominationManager::Instance()->ApplyAllRewardOption(player); // 보상옵션 적용
|
|
#endif //_NA_008334_20150608_SONNENSCHEIN
|
|
}
|
|
else if (player_state == PLAYER_CHARINFO_REQUESTED)
|
|
{
|
|
//최초 접속이 아니면 게임서버간 이동이므로...
|
|
MSG_GZ_GUILD_ENTER_SERVER_SYN msg_enter_server;
|
|
msg_enter_server.m_GuildGuid = player->GetGuildGuid();
|
|
msg_enter_server.m_CharGuid = player->GetCharGuid();
|
|
if (!player->SendToGuildServer(&msg_enter_server, sizeof(msg_enter_server)))
|
|
{
|
|
SUNLOG(eCRITICAL_LOG,
|
|
_T("|[%s]|MSG_GZ_GUILD_ENTER_SERVER_SYN message send failed, ")
|
|
_T("GuildGuid = %u, CharGuid = %u|"),
|
|
__FUNCTION__, msg_enter_server.m_GuildGuid, msg_enter_server.m_CharGuid);
|
|
}
|
|
#ifdef _NA_008334_20150608_SONNENSCHEIN
|
|
#else
|
|
GameDominationManager::Instance()->ApplyAllRewardOption(player); // 보상옵션 적용
|
|
#endif //_NA_008334_20150608_SONNENSCHEIN
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------------------------
|
|
// state control
|
|
player->SetState(PLAYER_LOADING);
|
|
//---------------------------------------------------------------------------------------------
|
|
// last section
|
|
// #1. latest information update logic
|
|
//
|
|
GameZone* game_zone = player->GetGameZonePtr();
|
|
GameZone* enter_zone = NULL;
|
|
MAPCODE field_code = 0;
|
|
WzID area_id = 0;
|
|
WzVector start_pos;
|
|
const eZONE_STATE eRoomState = player->GetGameZone(enter_zone, field_code, &area_id, &start_pos);
|
|
const KEYTYPE room_key = enter_zone->GetKey();
|
|
enter_zone = g_GameZoneManager.GetZone(room_key);
|
|
//
|
|
;{
|
|
MSG_AG_ZONE_ROOM_JOIN_ACK msg_join_ack;
|
|
if (game_zone && enter_zone)
|
|
{
|
|
player->GetPos(&msg_join_ack.ReturnPos);
|
|
msg_join_ack.ReturnFieldCode = field_code;
|
|
msg_join_ack.ReturnZoneType = game_zone->GetZoneType();
|
|
msg_join_ack.ReturnZoneKey = game_zone->GetKey();
|
|
}
|
|
else
|
|
{
|
|
msg_join_ack.ReturnPos.x = 0;
|
|
msg_join_ack.ReturnPos.y = 0;
|
|
msg_join_ack.ReturnPos.z = 0;
|
|
msg_join_ack.ReturnFieldCode = 0;
|
|
msg_join_ack.ReturnZoneType = eZONETYPE_MAX;
|
|
msg_join_ack.ReturnZoneKey = 0;
|
|
}
|
|
player->SendPacket(&msg_join_ack, sizeof(msg_join_ack));
|
|
};
|
|
|
|
//
|
|
//---------------------------------------------------------------------------------------------
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHARINFO_QUERY_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_QUERY_NAK * pRecvMsg = (MSG_DG_CHARINFO_QUERY_NAK *)pMsg;
|
|
DWORD UserKey = pRecvMsg->m_dwKey;
|
|
// 캐릭터 정보들 저장
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( UserKey );
|
|
if( !pPlayer ) return;
|
|
|
|
SUNLOG( eCRITICAL_LOG,
|
|
"[DG_CHARINFO_ALL_REQ_NAK][U:%d,ID:%s,E:%u]DG_CHARINFO_ALL_REQ_NAK",
|
|
pPlayer->GetUserKey(), pPlayer->GetUserID(), pRecvMsg->m_dwErrorCode );
|
|
|
|
MSG_AG_ZONE_ROOM_JOIN_NAK msg;
|
|
msg.m_dwErrorCode = pRecvMsg->m_dwErrorCode;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_ITEM_SERIAL_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_ITEM_SERIAL_ACK * pRecvMsg = (MSG_DG_ITEM_SERIAL_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
SCSlotContainer *pContainer = pPlayer->GetItemManager()->GetItemSlotContainer(pRecvMsg->m_SlotIdx);
|
|
|
|
if( !pContainer->IsEmpty(pRecvMsg->m_ItemPos) )
|
|
{
|
|
SCItemSlot & slot = (SCItemSlot &)pContainer->GetSlot(pRecvMsg->m_ItemPos);
|
|
ASSERT( slot.GetSerial() == TEMP_DBSERIAL_VALUE );
|
|
slot.SetType( pRecvMsg->m_Type );
|
|
slot.SetSerial( pRecvMsg->m_DBSerial );
|
|
pContainer->SetLock(pRecvMsg->m_ItemPos,FALSE);
|
|
|
|
if (nsSlot::ItemManagerUpdateImpl* const item_updater_impl =
|
|
pPlayer->GetItemManager()->GetUpdaterImpl())
|
|
{
|
|
item_updater_impl->AddSerialCode( eSERIAL_MAKE, pRecvMsg->m_SlotIdx, pRecvMsg->m_ItemPos, slot.GetWorldSerial() );
|
|
item_updater_impl->AddExpirationItem( slot );
|
|
#ifdef _NA_008440_20150818_ADD_CHARGE_SUB_IMMEDIATELY_USE
|
|
item_updater_impl->AddImmediatelyUseItem( slot );
|
|
#endif // _NA_008440_20150818_ADD_CHARGE_SUB_IMMEDIATELY_USE
|
|
}
|
|
|
|
if( pRecvMsg->m_SlotIdx == SI_INVENTORY
|
|
|| pRecvMsg->m_SlotIdx == SI_TEMPINVENTORY
|
|
|| pRecvMsg->m_SlotIdx == SI_EQUIPMENT
|
|
|| pRecvMsg->m_SlotIdx == SI_WAREHOUSE )
|
|
{
|
|
GAMELOG->LogItem( ITEM_MAKE_SERIAL, pPlayer, (SCItemSlot*)&slot, 0, slot.GetNum() );
|
|
}
|
|
|
|
#ifdef _NA_0_20110613_GAME_SHOP_RENEWAL
|
|
if (pRecvMsg->m_SlotIdx == SI_INVENTORY)
|
|
{
|
|
GameShop::EventProcessor* event_processor = GameShop::Manager::Instance()->FindEventProcessor(pPlayer->GetUserGuid());
|
|
if (event_processor)
|
|
{
|
|
event_processor->Item_Serial_Update(slot);
|
|
}
|
|
}
|
|
#endif // _NA_0_20110613_GAME_SHOP_RENEWAL
|
|
}
|
|
}
|
|
Handler_DG_CHARINFO_IMPL( DG_ITEM_SERIAL_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_ITEM_SERIAL_NAK * pRecvMsg = (MSG_DG_ITEM_SERIAL_NAK *)pMsg;
|
|
|
|
//Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
//ASSERT( pPlayer );
|
|
//if( !pPlayer ) return ;
|
|
|
|
//SCSlotContainer *pContainer = pPlayer->GetItemManager()->GetItemSlotContainer(pRecvMsg->m_SlotIdx);
|
|
//SCSlot & slot = pContainer->GetSlot(pRecvMsg->m_ItemPos);
|
|
//ASSERT( slot.GetSerial() == TEMP_DBSERIAL_VALUE );
|
|
//pContainer->SetLock( pRecvMsg->m_ItemPos, TRUE );
|
|
|
|
//pPlayer->GetItemManager()->AddSerialCode( pRecvMsg->m_SlotIdx, pRecvMsg->m_ItemPos, pRecvMsg->m_DBSerial );
|
|
|
|
/*if( pRecvMsg->m_SlotIdx == SI_INVENTORY
|
|
|| pRecvMsg->m_SlotIdx == SI_TEMPINVENTORY
|
|
|| pRecvMsg->m_SlotIdx == SI_EQUIPMENT
|
|
|| pRecvMsg->m_SlotIdx == SI_WAREHOUSE )
|
|
{
|
|
GAMELOG->LogItem( ITEM_MAKE_SERIAL, pPlayer, (SCItemSlot*)&slot );
|
|
}*/
|
|
|
|
SUNLOG( eCRITICAL_LOG, "Error:MSG_DG_ITEM_SERIAL_NAK" );
|
|
}
|
|
|
|
#if SUN_CODE_BACKUP
|
|
// CHANGES: f110428.x, removed block, __NA002610_110428_REMOVE_INFINITY_USING_LUCKY
|
|
Handler_DG_CHARINFO_IMPL( DG_ITEM_FATE_ITEM_IDENTIFY_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_ITEM_FATE_ITEM_IDENTIFY_ACK* pRecvMsg = (MSG_DG_ITEM_FATE_ITEM_IDENTIFY_ACK*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
MSG_CG_ITEM_VALIDATION_OF_REIHALT_NAK NakMsg;
|
|
SCSlotContainer * pContainer = pPlayer->GetItemManager()->GetItemSlotContainer( SI_INVENTORY );
|
|
|
|
SCItemSlot & rTargetItemSlot = (SCItemSlot &)pContainer->GetSlot( pRecvMsg->m_ItemPos );
|
|
if( !rTargetItemSlot.GetItemInfo() )
|
|
{
|
|
NakMsg.m_dwErrorCode = RC::RC_ITEM_NOINFO;
|
|
pPlayer->SendPacket( &NakMsg, sizeof(NakMsg) );
|
|
return;
|
|
}
|
|
|
|
//Fate아이템인가?
|
|
if( !rTargetItemSlot.IsFateItem() )
|
|
{
|
|
NakMsg.m_dwErrorCode = RC::RC_ITEM_NOT_FATE_ITEM;
|
|
pPlayer->SendPacket( &NakMsg, sizeof(NakMsg) );
|
|
rTargetItemSlot.SetLock( FALSE );
|
|
return;
|
|
}
|
|
|
|
//이미 감정 했는가?
|
|
if( rTargetItemSlot.GetFateIdentify() )
|
|
{
|
|
NakMsg.m_dwErrorCode = RC::RC_ITEM_ALREADY_IDENTYFIED_FATE_ITEM;
|
|
pPlayer->SendPacket( &NakMsg, sizeof(NakMsg) );
|
|
rTargetItemSlot.SetLock( FALSE );
|
|
return;
|
|
}
|
|
|
|
//무제한 발급
|
|
if( 0 == pRecvMsg->m_Result )
|
|
{
|
|
if( !rTargetItemSlot.CalFateInfo() )
|
|
{
|
|
NakMsg.m_dwErrorCode = RC::RC_ITEM_FAILED;
|
|
pPlayer->SendPacket( &NakMsg, sizeof(NakMsg) );
|
|
rTargetItemSlot.SetLock( FALSE );
|
|
return;
|
|
}
|
|
rTargetItemSlot.SetDateTime( INFINITE_ITEM_DAY * 24 * 60 * 60 );
|
|
rTargetItemSlot.SetFatePeriod( INFINITE_ITEM_DAY );
|
|
|
|
GAMELOG->LogItem( ITEM_IDENTIFY_LUCKY_ITEM, pPlayer, &rTargetItemSlot );
|
|
}
|
|
|
|
//무제한 발급 초과
|
|
else if( 2 == pRecvMsg->m_Result )
|
|
{
|
|
DWORD FateDateTime = 0;
|
|
do
|
|
{
|
|
if( !rTargetItemSlot.CalFateDateTime( FateDateTime ) )
|
|
{
|
|
NakMsg.m_dwErrorCode = RC::RC_ITEM_FAILED;
|
|
pPlayer->SendPacket( &NakMsg, sizeof(NakMsg) );
|
|
rTargetItemSlot.SetLock( FALSE );
|
|
return;
|
|
}
|
|
}while( FateDateTime == INFINITE_ITEM_DAY );
|
|
|
|
if( !rTargetItemSlot.CalFateInfo() )
|
|
{
|
|
NakMsg.m_dwErrorCode = RC::RC_ITEM_FAILED;
|
|
pPlayer->SendPacket( &NakMsg, sizeof(NakMsg) );
|
|
rTargetItemSlot.SetLock( FALSE );
|
|
return;
|
|
}
|
|
rTargetItemSlot.SetDateTime( FateDateTime * 24 * 60 * 60 );
|
|
rTargetItemSlot.SetFatePeriod( FateDateTime );
|
|
GAMELOG->LogItem( ITEM_IDENTIFY_LUCKY_ITEM, pPlayer, &rTargetItemSlot );
|
|
}
|
|
// 시스템 에러 1 == pRecvMsg->m_Result
|
|
else
|
|
{
|
|
NakMsg.m_dwErrorCode = RC::RC_ITEM_FAILED;
|
|
pPlayer->SendPacket( &NakMsg, sizeof(NakMsg) );
|
|
rTargetItemSlot.SetLock( FALSE );
|
|
return;
|
|
}
|
|
|
|
rTargetItemSlot.SetLock( FALSE );
|
|
|
|
MSG_CG_ITEM_VALIDATION_OF_REIHALT_ACK AckMsg;
|
|
AckMsg.m_TargetItemPos = pRecvMsg->m_ItemPos;
|
|
SCItemSlot & rSlot = (SCItemSlot &)pPlayer->GetItemManager()->GetItemSlotContainer(SI_INVENTORY)->GetSlot( pRecvMsg->m_ItemPos );
|
|
rSlot.CopyOut(AckMsg.m_TargetItemStream);
|
|
pPlayer->SendPacket( &AckMsg, sizeof( AckMsg ));
|
|
}
|
|
#endif //SUN_CODE_BACKUP
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_ITEM_INVENTORY_FLAG_STREAM_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_ITEM_INVENTORY_FLAG_STREAM_CMD* pRecvMsg = (MSG_DG_ITEM_INVENTORY_FLAG_STREAM_CMD*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
ProtectorInventory& rPROTECT = pPlayer->GetWarehouseInventoryProtector().INVENTORY();
|
|
rPROTECT.SetControlFieldStream( pRecvMsg->m_dwFlagStream );
|
|
if( rPROTECT.IsEmptyPassword() && !rPROTECT.IsUsable() )
|
|
rPROTECT.Block( FALSE );
|
|
}
|
|
|
|
|
|
/*
|
|
Handler_DG_CHARINFO_IMPL( DG_ITEM_WAREHOUSEITEMALL_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_ITEM_WAREHOUSEITEMALL_ACK * pRecvMsg = (MSG_DG_ITEM_WAREHOUSEITEMALL_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
ItemManager * pMGR = pPlayer->GetItemManager();
|
|
pPlayer->SerializeWarehouseTotalInfo( pRecvMsg->m_ItemInfo, SERIALIZE_STORE );
|
|
pMGR->SetWarehouseMoney( pRecvMsg->m_Money );
|
|
|
|
MSG_CG_ITEM_WAREHOUSEITEMALL_ACK msg;
|
|
msg.m_WarehouseMoney = pMGR->GetWarehouseMoney();
|
|
pPlayer->SerializeWarehouseTotalInfo( msg.m_ItemInfo, SERIALIZE_LOAD );
|
|
pPlayer->SendPacket( &msg, msg.GetSize() );
|
|
}
|
|
*/
|
|
Handler_DG_CHARINFO_IMPL( DG_WAREHOUSE_START_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAREHOUSE_START_ACK * pRecvMsg = (MSG_DG_WAREHOUSE_START_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
// 창고 시작 상태로 바꿈
|
|
CWarehouseSlotContainer * pContainer = pPlayer->GetWarehouseContainer();
|
|
ASSERT( !pContainer->IsStarted() );
|
|
pContainer->SerializeItemInfo( pRecvMsg->m_ItemInfo, SERIALIZE_STORE );
|
|
pContainer->SerializeMoney( pRecvMsg->m_WarehouseMoney );
|
|
pContainer->StartWarehouse();
|
|
|
|
MSG_CG_WAREHOUSE_START_ACK msg;
|
|
|
|
ProtectorWarehouse& rPROTECT = pPlayer->GetWarehouseInventoryProtector().WAREHOUSE();
|
|
rPROTECT.SetPasswordFromDB( pRecvMsg->m_WarehousePwd );
|
|
rPROTECT.Initialized();
|
|
|
|
INT iFlag = (rPROTECT.IsEmptyPassword() ? MSG_CG_WAREHOUSE_START_ACK::EMPTY_PWD : MSG_CG_WAREHOUSE_START_ACK::EXIST_PWD );
|
|
|
|
if( rPROTECT.IsEmptyPassword() )
|
|
{
|
|
rPROTECT.Block( FALSE );
|
|
//msg.m_byWarehouseLock = MSG_CG_WAREHOUSE_START_ACK::UNLOCK;
|
|
iFlag |= (rPROTECT.IsUsable() ? MSG_CG_WAREHOUSE_START_ACK::ENABLE : MSG_CG_WAREHOUSE_START_ACK::DISABLED);
|
|
msg.m_byWarehouseLock = (BYTE)iFlag;
|
|
}
|
|
else
|
|
{
|
|
iFlag |= (rPROTECT.IsUsable() ? MSG_CG_WAREHOUSE_START_ACK::ENABLE : MSG_CG_WAREHOUSE_START_ACK::DISABLED);
|
|
// else의 경우에는 Block이 TRUE, FALSE인 경우가 있을 것이다.
|
|
// 창고를 한두번 여나? ㅋㅋ
|
|
msg.m_byWarehouseLock = (BYTE)iFlag;
|
|
//msg.m_byWarehouseLock = rPROTECT.IsUsable() ?
|
|
// MSG_CG_WAREHOUSE_START_ACK::UNLOCK : MSG_CG_WAREHOUSE_START_ACK::LOCK;
|
|
}
|
|
|
|
msg.m_WarehouseMoney = pContainer->GetCurMoney();
|
|
|
|
msg.m_Size = sizeof(RENDER_ITEMSTREAMEX)*(MAX_WAREHOUSE_SLOT_NUM);
|
|
BitStream stream( msg.m_BitStreamBuffer, msg.m_Size, TRUE );
|
|
pContainer->Serialize( stream, eSLOT_SERIALIZE_CLIENT_LOAD );
|
|
msg.m_Size = stream.GetNumberOfBytesUsed();
|
|
|
|
pPlayer->SendPacket( &msg, msg.GetSize() );
|
|
|
|
//창고 정보 로그 남기기
|
|
GAMELOG->WriteWareHouseInfo( pPlayer, TRUE );
|
|
//GAMELOG->LogInvenInfo( SNAPSHOT_WAREHOUSE_OPEN_INVEN, pPlayer );
|
|
GAMELOG->LogSnapShot( pPlayer );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAREHOUSE_FLAG_STREAM_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAREHOUSE_FLAG_STREAM_CMD* pRecvMsg = (MSG_DG_WAREHOUSE_FLAG_STREAM_CMD*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
WarehouseInventoryProtector& rPROTECTOR = pPlayer->GetWarehouseInventoryProtector();
|
|
rPROTECTOR.SSN_ENCODED_STREAM().CopyFrom( pRecvMsg->m_EncodedSSN.GetBUFFER() );
|
|
rPROTECTOR.SSN_ENCODED_STREAM().MakeSafeString();
|
|
ProtectorWarehouse& rPROTECT = rPROTECTOR.WAREHOUSE();
|
|
rPROTECT.SetControlFieldStream( pRecvMsg->m_dwFlagStream );
|
|
//memcpy( &pPlayer->GetWarehouseInventoryProtector().CONTROL_FIELD(), &pRecvMsg->m_dwFlagStream, sizeof(DWORD) );
|
|
// 아래의 경우는 있을 수 없는 상황이다. 하지만 최초 접속자에 한해서 발생할 수 있다.
|
|
// 창고 비번은 창고를 불러들여야만 가능하기 때문... 차라리 최초 접속상황이 아닌 경우를 처리 할 수 있으면
|
|
if( rPROTECT.IsInitialized() )
|
|
{
|
|
if( rPROTECT.IsEmptyPassword() && !rPROTECT.IsUsable() )
|
|
rPROTECT.Block( FALSE );
|
|
}
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAREHOUSE_PWD_SETTING_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return;
|
|
|
|
WarehouseInventoryProtector& rPROTECTOR = pPlayer->GetWarehouseInventoryProtector();
|
|
rPROTECTOR.OnRecvDG_WAREHOUSE_PWD_SETTING_ACK( (MSG_DG_WAREHOUSE_PWD_SETTING_ACK*)pMsg, wSize );
|
|
}
|
|
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAREHOUSE_START_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAREHOUSE_START_NAK * pRecvMsg = (MSG_DG_WAREHOUSE_START_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
SUNLOG( eCRITICAL_LOG, "[%s:%d]창고열기에러", pPlayer->GetCharName(), pRecvMsg->m_dwErrorCode );
|
|
|
|
MSG_CG_WAREHOUSE_START_NAK msg;
|
|
msg.m_dwErrorCode = pRecvMsg->m_dwErrorCode;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
|
|
ProtectorWarehouse& rPROTECT = pPlayer->GetWarehouseInventoryProtector().WAREHOUSE();
|
|
rPROTECT.TESTnSET_Transaction_PWD_CONFIG( FALSE );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAREHOUSE_END_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAREHOUSE_END_ACK * pRecvMsg = (MSG_DG_WAREHOUSE_END_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
CWarehouseSlotContainer * pContainer = pPlayer->GetWarehouseContainer();
|
|
|
|
|
|
MSG_CG_WAREHOUSE_END_ACK msg;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAREHOUSE_END_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAREHOUSE_END_NAK * pRecvMsg = (MSG_DG_WAREHOUSE_END_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
CWarehouseSlotContainer * pContainer = pPlayer->GetWarehouseContainer();
|
|
// 시작상태로 되돌림
|
|
pContainer->SetStarted(true);
|
|
|
|
MSG_CG_WAREHOUSE_END_NAK msg;
|
|
msg.m_dwErrorCode = pRecvMsg->m_dwErrorCode;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_SELECT_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_SELECT_ACK * pRecvMsg = (MSG_DG_EVENT_SELECT_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetEventSlotContainer()->OnSelect( TRUE, &pRecvMsg->m_TotalInfo );
|
|
|
|
MSG_CG_EVENT_SELECT_ACK msg;
|
|
pPlayer->GetEventSlotContainer()->Serialize( msg.m_TotalInfo, SERIALIZE_LOAD );
|
|
pPlayer->SendPacket( &msg, msg.GetSize() );
|
|
|
|
}
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_SELECT_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_SELECT_NAK * pRecvMsg = (MSG_DG_EVENT_SELECT_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetEventSlotContainer()->OnSelect( FALSE, NULL );
|
|
|
|
MSG_CG_EVENT_SELECT_NAK msg;
|
|
msg.m_byErrorCode = RC::RC_ITEM_NOTEXIST_ITEM; //pRecvMsg->m_byErrorCode;//< 아이템이 없을 경우만 로직적으로 nak가 오게되어있음
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_UPDATE_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_UPDATE_ACK * pRecvMsg = (MSG_DG_EVENT_UPDATE_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
|
|
MSG_CG_EVENT_MOVE_ITEM_TO_INVEN_ACK msg;
|
|
pPlayer->GetEventSlotContainer()->OnMoveItemToInventory( TRUE, pRecvMsg->m_ItemPos, &msg.m_TotalInfo );
|
|
|
|
pPlayer->SendPacket( &msg, msg.GetSize() );
|
|
|
|
}
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_UPDATE_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_UPDATE_NAK * pRecvMsg = (MSG_DG_EVENT_UPDATE_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
MSG_CG_EVENT_MOVE_ITEM_TO_INVEN_ACK msg_dummy; // TODO: need modify
|
|
pPlayer->GetEventSlotContainer()->OnMoveItemToInventory( FALSE, 0, &msg_dummy.m_TotalInfo);
|
|
|
|
MSG_CG_EVENT_MOVE_ITEM_TO_INVEN_NAK msg;
|
|
msg.m_byErrorCode = pRecvMsg->m_byErrorCode;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
// 이벤트 응모 현황(?) 수신
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_ITEM_STATUS_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_ITEM_STATUS_ACK* pRecvMsg = ( MSG_DG_EVENT_ITEM_STATUS_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
// ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
#ifdef _WHATTHEHELL_SUNEVENT_20060727
|
|
EVENT_INFO *pEventInfo = NULL;
|
|
|
|
for( WORD i = 0; i < pRecvMsg->m_wEventNum && i < _MAX_EVENT_ROW_NUM ; i++ )
|
|
{
|
|
pEventInfo = SunEventInfoParser::Instance()->FindEventInfo( pRecvMsg->m_EventStatus[i].m_dwEventID );
|
|
|
|
// 현재 유효한 이벤트만 등록(지나간 이벤트 내용은 저장하지 않는다)
|
|
if( pEventInfo )
|
|
{
|
|
pPlayer->AddEventStatus( pRecvMsg->m_EventStatus[i] );
|
|
}
|
|
else
|
|
{
|
|
SUNLOG( eCRITICAL_LOG, "Passed Event Status[%u][CharGuid:%u]", pRecvMsg->m_EventStatus[i].m_dwEventID, pPlayer->GetCharGuid() );
|
|
}
|
|
}
|
|
#else
|
|
const DWORD eventNum = pRecvMsg->m_wEventNum;
|
|
IPlayerEventD& rEventD = pPlayer->PlayerEvent();
|
|
for( DWORD idx=0 ; idx<eventNum && idx<_MAX_EVENT_ROW_NUM ; ++idx )
|
|
{
|
|
EVENT_STATUS_EX& rInfo = pRecvMsg->m_EventStatus[idx];
|
|
rEventD.AddEventStatus( rInfo );
|
|
}
|
|
#endif
|
|
|
|
|
|
// MessageOut( eFULL_LOG, "Event Status Check[%u][C:%u][Event:%u]", pRecvMsg->m_dwKey, pPlayer->GetCharGuid(), pRecvMsg->m_wEventNum );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_ITEM_STATUS_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_ITEM_STATUS_NAK* pRecvMsg = (MSG_DG_EVENT_ITEM_STATUS_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
//ASSERT( pPlayer );
|
|
if( !pPlayer )
|
|
{
|
|
MessageOut( eFULL_LOG, "Event Status Check Failed[%u]", pRecvMsg->m_dwKey );
|
|
return ;
|
|
}
|
|
/*
|
|
MSG_CG_EVENT_ITEM_STATUS_NAK msg;
|
|
msg.m_dwKey = pPlayer->GetUserGuid();
|
|
msg.m_dwErrorCode = 0; // 일단 임시로 0에 맞춘다
|
|
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
*/
|
|
// MessageOut( eFULL_LOG, "Event Status Check Failed[%u][C:%u]", pRecvMsg->m_dwKey, pPlayer->GetCharGuid() );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_ITEM_REG_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_ITEM_REG_ACK* pRecvMsg = (MSG_DG_EVENT_ITEM_REG_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
MSG_CG_EVENT_ITEM_REG_ACK msg;
|
|
|
|
msg.m_dwKey = pPlayer->GetUserGuid();
|
|
msg.m_dwEventID = pRecvMsg->m_dwEventID;
|
|
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
MessageOut( eFULL_LOG, "Event_Reg Success[%u][C:%u][Event:%u]", pRecvMsg->m_dwKey, pPlayer->GetCharGuid(), pRecvMsg->m_dwEventID );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_ITEM_REG_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_ITEM_REG_NAK* pRecvMsg = (MSG_DG_EVENT_ITEM_REG_NAK *)pMsg;
|
|
MSG_CG_EVENT_ITEM_REG_NAK msg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
msg.m_dwErrorCode = 0; // 일단 임시로 0에 맞춘다
|
|
|
|
// 삭제된 아이템 다시 복구해 줘야 된다!!!
|
|
EVENT_INFO * pEventInfo = SunEventInfoParser::Instance()->FindEventInfo( pRecvMsg->m_dwEventID );
|
|
|
|
if( pEventInfo )
|
|
{
|
|
SLOTCODE delItem[_MAX_EVENT_REGITEM]={0,};
|
|
POSTYPE delpos[_MAX_EVENT_REGITEM]={0,};
|
|
|
|
int i = 0;
|
|
for( ; i<_MAX_EVENT_REGITEM; i++ )
|
|
{
|
|
delItem[i] = (SLOTCODE)pEventInfo->m_dwRegisterItemIndex[i];
|
|
delpos[i] = (POSTYPE)pEventInfo->m_wRegisterItemNum[i];
|
|
|
|
if( !delItem[i] || !delpos[i] )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
pPlayer->GetItemManager()->ObtainAllKindOfItem( i, delItem, delpos, &msg.m_TotalInfo );
|
|
// 게임 로그 : 복구 처리 로그
|
|
GAMELOG->LogMultiItem( ITEM_EVENT_ETHER_REG_FAILED, pPlayer, i, delItem, delpos );
|
|
}
|
|
else
|
|
{
|
|
msg.m_TotalInfo.m_InvenCount = 0;
|
|
msg.m_TotalInfo.m_TmpInvenCount = 0;
|
|
}
|
|
pPlayer->SendPacket( &msg, msg.GetSize() );
|
|
|
|
MessageOut( eFULL_LOG, "Event_Reg Failed[%u][C:%u][Event:%u]", pRecvMsg->m_dwKey, pPlayer->GetCharGuid() );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_USETIME_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_USETIME_CMD* pRecvMsg = (MSG_DG_EVENT_USETIME_CMD*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
MSG_CG_EVENT_TIME_CMD cmdMsg;
|
|
|
|
cmdMsg.m_EventUseTime = pRecvMsg->m_EventUseTime;
|
|
|
|
pPlayer->SendPacket( &cmdMsg, sizeof(cmdMsg) );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_QUERY_EXIST_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_QUERY_EXIST_ACK* pRecvMsg = (MSG_DG_EVENT_QUERY_EXIST_ACK *)pMsg;
|
|
|
|
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer )
|
|
return ;
|
|
|
|
pPlayer->GetEventSlotContainer()->OnSelect( FALSE, NULL );
|
|
|
|
MSG_CG_EVENT_QUERY_EXIST_ACK msgACK;
|
|
msgACK.m_bExist = pRecvMsg->m_bExist;
|
|
pPlayer->SendPacket( &msgACK, sizeof(msgACK) );
|
|
}
|
|
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_EVENT_SSQ_REWARD_EXIST_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
const MSG_DG_EVENT_SSQ_REWARD_EXIST_CMD* recv_msg =
|
|
static_cast<MSG_DG_EVENT_SSQ_REWARD_EXIST_CMD*>(pMsg);
|
|
|
|
Player* const player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
|
|
if (player == NULL || player->GetField() == NULL) {
|
|
return;
|
|
}
|
|
// (Work To Do)
|
|
// 1. Player 입장시 미션 보상 처럼 처리할 수 있도록 하자.
|
|
ISSQHandlerInGame& ssq_handler = player->SSQHandler;
|
|
const BOOLEAN is_valid_state = ssq_handler.IsValidState();
|
|
if (is_valid_state == false) {
|
|
ssq_handler.Init();
|
|
}
|
|
ssq_handler->SetRewardInfo(recv_msg->m_RewardInfo);
|
|
// 나중에 유저가 입장시 패킷을 전송한다.
|
|
//_NA000023_090323_ENHANCED_INVENTORY_SLOT_FUNCTIONALITY_DB_
|
|
// (CHANGES) (f100714.2L) pre-fetch to support a delayed event query process
|
|
// Old comments -
|
|
// (WAVERIX) (090813) (CHANGES) 클라이언트 패킷 수신에 의한 것이 아니라 정확한 Scene동기화
|
|
// 처리를 확신할 수 없는 상황이 존재한다. 'CG_SHOP_IS_RECV_GIFT_SYN'요청시 처리하도록 변경해 봄.
|
|
// reference : CG_SHOP_IS_RECV_GIFT_SYN handler
|
|
bool is_acceptable_status = false;
|
|
;{
|
|
GameZone* enter_zone = 0;
|
|
MAPCODE field_code = 0;
|
|
WzID area_id = 0;
|
|
WzVector start_pos;
|
|
|
|
eZONE_STATE zone_state = player->GetGameZone(enter_zone, field_code, &area_id, &start_pos);
|
|
if (ePRS_AT_ZONE & zone_state) {
|
|
is_acceptable_status = true;
|
|
}
|
|
};
|
|
//
|
|
if (is_acceptable_status == false) {
|
|
return;
|
|
}
|
|
//
|
|
if (FIELD_SERVER == g_pGameServer->GetServerType()) {
|
|
ssq_handler->Send_RewardProcess(player, true);
|
|
}
|
|
}
|
|
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_SSQ_REWARD_UPDATE_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_EVENT_SSQ_REWARD_UPDATE_ACK* const pRecvMsg = static_cast<MSG_DG_EVENT_SSQ_REWARD_UPDATE_ACK*>( pMsg );
|
|
|
|
Player* const pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer )
|
|
return ;
|
|
|
|
// (Work To Do)
|
|
// 1. 보상 처리할 것, 그 결과 클라로 전송할 것.
|
|
// 2. 보상 트랜젝션 해제 처리할 것.
|
|
// (080917)
|
|
// - 보상 처리는 통보식이며, 응답후 처리는 하지 않는다.
|
|
// 이유? 성공후 바로 떠나도록 유도할 예정이니까...
|
|
#if WAVERIX_CODE_BACKUP
|
|
ISSQHandlerInGame& rHandler = pPlayer->SSQHandler;
|
|
if( !rHandler.IsValidState() )
|
|
{
|
|
ASSERT( !"transaction이 꼬이는 현상인가? 확인이 필요하다." );
|
|
return;
|
|
}
|
|
|
|
const BOOLEAN isUpdated = pRecvMsg->m_UpdateResult;
|
|
if( !isUpdated )
|
|
{
|
|
ASSERT( !"어지간해서는 여기에 도달하지 않기를 바라는 마음뿐..." );
|
|
return;
|
|
}
|
|
|
|
//SSQ_RESERVED_REWARD_INFO info;
|
|
//if( !rHandler->GetRewardInfo( info ) )
|
|
// return;
|
|
|
|
//rHandler->Rewarded();
|
|
#endif
|
|
}
|
|
|
|
#ifdef _NA_008012_20150130_RANKING_SYSTEM
|
|
Handler_DG_CHARINFO_IMPL( DG_MISSION_RECORD_SELECT_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_MISSION_RECORD_SELECT_CMD* pRecvMsg = (MSG_DG_MISSION_RECORD_SELECT_CMD *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
// 초기화, 기록 저장
|
|
MISSION_RECORD_INFO * pRecordInfo = pRecvMsg->m_MissionRecord;
|
|
for( BYTE i = 0 ; i < MAX_MISSION_NUM+1 ; ++i )
|
|
{
|
|
if( i < pRecvMsg->m_byCount && pRecordInfo[i].m_byMissionNo != 0 )
|
|
pPlayer->SetBestMissionTime( pRecordInfo[i].m_byMissionNo, pRecordInfo[i].m_iClearTime );
|
|
else
|
|
pPlayer->SetBestMissionTime( i, INT_MAX );
|
|
}
|
|
|
|
}
|
|
#endif // _NA_008012_20150130_RANKING_SYSTEM
|
|
|
|
#ifdef _NA_0_20110613_GAME_SHOP_RENEWAL
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_EXIST_CHARNAME_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_EXIST_CHARNAME_ACK * pRecvMsg = (MSG_DG_OTHER_EXIST_CHARNAME_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
USERGUID user_guid = pPlayer->GetUserGuid();
|
|
GameShop::EventProcessor* proc = GameShop::Manager::Instance()->FindEventProcessor(user_guid);
|
|
if (proc)
|
|
proc->Receive_CharacterNameCheck(pRecvMsg->m_UserGuid,
|
|
pRecvMsg->m_CharGuid,
|
|
pRecvMsg->character_class_,
|
|
pRecvMsg->character_level_,
|
|
pRecvMsg->m_tszCharName, "");
|
|
else
|
|
GameShop::EventProcessor::SendFail_CharacterNameCheck(pPlayer, RC::RC_SHOP_FAILED);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_EXIST_CHARNAME_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_EXIST_CHARNAME_NAK * pRecvMsg = (MSG_DG_OTHER_EXIST_CHARNAME_NAK *)pMsg;
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
GameShop::EventProcessor::SendFail_CharacterNameCheck(pPlayer, RC::RC_SHOP_NOT_EXIST_CHARACTER_NAME);
|
|
}
|
|
|
|
#else
|
|
|
|
#if !defined(__NA000000_SHOP_USERID_50_PASSING_PROC__)
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_EXIST_CHARNAME_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_EXIST_CHARNAME_ACK * pRecvMsg = (MSG_DG_OTHER_EXIST_CHARNAME_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
switch( pRecvMsg->m_Type )
|
|
{
|
|
case eCHARNAME_ACTION_SHOP_SEND_GIFT:
|
|
{
|
|
RC::eSHOP_RESULT rt = g_GameShopManager.OnSendGiftNDoRequest(TRUE, pPlayer, pRecvMsg->m_UserGuid, pRecvMsg->m_CharGuid, pRecvMsg->m_tszCharName);
|
|
if( rt != RC::RC_SHOP_PENDING && rt != RC::RC_SHOP_SUCCESS )
|
|
{
|
|
MSG_CG_SHOP_SEND_GIFT_NAK nmsg;
|
|
nmsg.m_byErrorCode = rt;
|
|
pPlayer->SendPacket( &nmsg, sizeof(nmsg) );
|
|
}
|
|
}break;
|
|
}
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_EXIST_CHARNAME_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_EXIST_CHARNAME_NAK * pRecvMsg = (MSG_DG_OTHER_EXIST_CHARNAME_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
switch( pRecvMsg->m_Type )
|
|
{
|
|
case eCHARNAME_ACTION_SHOP_SEND_GIFT:
|
|
{
|
|
RC::eSHOP_RESULT rt = g_GameShopManager.OnSendGiftNDoRequest(FALSE, pPlayer, 0, 0, NULL);
|
|
if( rt != RC::RC_SHOP_PENDING && rt != RC::RC_SHOP_SUCCESS )
|
|
{
|
|
MSG_CG_SHOP_SEND_GIFT_NAK nmsg;
|
|
nmsg.m_byErrorCode = rt;
|
|
pPlayer->SendPacket( &nmsg, sizeof(nmsg) );
|
|
}
|
|
}break;
|
|
}
|
|
}
|
|
#endif //!__NA000000_SHOP_USERID_50_PASSING_PROC__
|
|
#endif //_NA_0_20110613_GAME_SHOP_RENEWAL
|
|
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_SHOP_RECV_GIFT_NTF )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_SHOP_RECV_GIFT_NTF * pRecvMsg = (MSG_DG_OTHER_SHOP_RECV_GIFT_NTF *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
#ifdef _NA_0_20110613_GAME_SHOP_RENEWAL
|
|
MSG_CG_SHOP_EXIST_GIFT_NTF ntf_message;
|
|
pPlayer->SendPacket(&ntf_message, sizeof(ntf_message));
|
|
#else
|
|
MSG_CG_SHOP_SEND_GIFT_NTF ntf;
|
|
pPlayer->SendPacket( &ntf, sizeof(ntf) );
|
|
#endif
|
|
}
|
|
|
|
#ifdef __CN_OO0510__FATIGUE_MATCHING_UPDATE
|
|
|
|
// DB에서 피로도 정보를 준다. 이 정보는 존을 이동할 때 마다 날라올 것이다
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_FATIGUE_CMD )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_FATIGUE_CMD* pRecvMsg = (MSG_DG_OTHER_FATIGUE_CMD*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
if( !pPlayer ) return ;
|
|
|
|
//1. 플레이어의 피로도 시간을 세팅한다.
|
|
pPlayer->SetPlayTime( pRecvMsg->m_wPlayTime );
|
|
pPlayer->SetOfflineTime( pRecvMsg->m_wOfflineTime );
|
|
|
|
//2. 피로도 정보 초기화
|
|
pPlayer->GetFatigueManager()->Init( pPlayer );
|
|
|
|
//2. 클라이어트에 현재 피로도 정보를 보내준다.
|
|
MSG_CG_CHARINFO_FATIGUE_CMD cmd;
|
|
cmd.m_wPlayTime = pRecvMsg->m_wPlayTime;
|
|
cmd.m_wOfflineTime = pRecvMsg->m_wOfflineTime;
|
|
|
|
if( FatigueOptionParser::Instance()->IsUse() == TRUE )
|
|
{
|
|
if( (pPlayer->GetAge() >= 18) && (pPlayer->GetRealNameAuth() == 1) )
|
|
cmd.m_byType = 0;
|
|
else
|
|
cmd.m_byType = 1;
|
|
}
|
|
else
|
|
cmd.m_byType = 0;
|
|
|
|
pPlayer->SendPacket( &cmd, sizeof(cmd) );
|
|
}
|
|
|
|
#endif //__CN_OO0510__FATIGUE_MATCHING_UPDATE
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAYPOINT_INFO_LOAD_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAYPOINT_INFO_LOAD_ACK * pRecvMsg = (MSG_DG_WAYPOINT_INFO_LOAD_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetWayPoint()->Serialize( pRecvMsg->m_Info, SERIALIZE_STORE );
|
|
|
|
MSG_CG_WAYPOINT_INFO_LOAD_ACK msg;
|
|
pPlayer->GetWayPoint()->Serialize( msg.m_Info, SERIALIZE_LOAD );
|
|
pPlayer->SendPacket( &msg, msg.GetSize() );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAYPOINT_INFO_LOAD_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAYPOINT_INFO_LOAD_NAK * pRecvMsg = (MSG_DG_WAYPOINT_INFO_LOAD_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
MSG_CG_WAYPOINT_INFO_LOAD_NAK msg;
|
|
msg.m_dwErrorCode = pRecvMsg->m_dwErrorCode;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAYPOINT_INFO_SAVE_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAYPOINT_INFO_SAVE_ACK * pRecvMsg = (MSG_DG_WAYPOINT_INFO_SAVE_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
BOOL rt = pPlayer->GetWayPoint()->Insert( pRecvMsg->m_MapCode );
|
|
ASSERT( rt && "WAYPOINT에 중복등록할수없다." );
|
|
|
|
MSG_CG_WAYPOINT_INFO_SAVE_ACK msg;
|
|
// msg.m_WPIndex = pRecvMsg->m_WPIndex;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_WAYPOINT_INFO_SAVE_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_WAYPOINT_INFO_SAVE_NAK * pRecvMsg = (MSG_DG_WAYPOINT_INFO_SAVE_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
MSG_CG_WAYPOINT_INFO_SAVE_NAK msg;
|
|
msg.m_dwErrorCode = pRecvMsg->m_dwErrorCode;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHAR_WAYPOINT_INFO_LOAD_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHAR_WAYPOINT_INFO_LOAD_ACK * pRecvMsg = (MSG_DG_CHAR_WAYPOINT_INFO_LOAD_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
pPlayer->GetCharWayPoint()->Serialize( pRecvMsg->m_Info, SERIALIZE_STORE );
|
|
|
|
MSG_CG_CHAR_WAYPOINT_INFO_LOAD_ACK msg;
|
|
pPlayer->GetCharWayPoint()->Serialize( msg.m_Info, SERIALIZE_LOAD );
|
|
pPlayer->SendPacket( &msg, msg.GetSize() );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHAR_WAYPOINT_INFO_SAVE_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHAR_WAYPOINT_INFO_SAVE_ACK * pRecvMsg = (MSG_DG_CHAR_WAYPOINT_INFO_SAVE_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
BOOL rt = pPlayer->GetCharWayPoint()->Insert( pRecvMsg->m_Info );
|
|
ASSERT( rt && "CharWAYPOINT에 중복등록할수없다." );
|
|
|
|
MSG_CG_CHAR_WAYPOINT_INFO_SAVE_ACK msg;
|
|
msg.m_Info = pRecvMsg->m_Info;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHAR_WAYPOINT_INFO_DEL_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHAR_WAYPOINT_INFO_DEL_ACK * pRecvMsg = (MSG_DG_CHAR_WAYPOINT_INFO_DEL_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
BOOL rt = pPlayer->GetCharWayPoint()->Delete( pRecvMsg->m_IdxWayPoint );
|
|
ASSERT( rt && "WAYPOINT에 가 존재하지 않는다." );
|
|
|
|
|
|
//item 삭제시간 다시셋팅
|
|
ItemManager* pItemManager = pPlayer->GetItemManager();
|
|
if(!pItemManager)
|
|
return;
|
|
|
|
SCSlotContainer* pContainer = (SCSlotContainer *)pItemManager->GetItemSlotContainer(SI_INVENTORY);
|
|
if(!pContainer)
|
|
return;
|
|
|
|
for(int pos = 0; pos < MAX_INVENTORY_SLOT_NUM; ++pos)
|
|
{
|
|
if( pContainer->IsEmpty(pos) )
|
|
continue;
|
|
|
|
SCItemSlot &rItemSlot = (SCItemSlot &)pContainer->GetSlot(pos);
|
|
|
|
if( rItemSlot.GetSerial() != 0 &&
|
|
rItemSlot.IsWayPointItem() &&
|
|
rItemSlot.IsProgressTime() )
|
|
{
|
|
rItemSlot.ResetWayPointDelete();
|
|
pPlayer->GetItemManager()->SendItemChange(rItemSlot);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 삭제중 아이템이 사라졌더라도 NAK아님 (DB기준)
|
|
MSG_CG_CHAR_WAYPOINT_INFO_DEL_ACK msg;
|
|
msg.m_IdxWayPoint = pRecvMsg->m_IdxWayPoint;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_CHAR_WAYPOINT_INFO_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHAR_WAYPOINT_INFO_NAK * pRecvMsg = (MSG_DG_CHAR_WAYPOINT_INFO_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
MSG_CG_CHAR_WAYPOINT_INFO_NAK msg;
|
|
msg.m_dwErrorCode = pRecvMsg->m_dwErrorCode;
|
|
pPlayer->SendPacket( &msg, sizeof(msg) );
|
|
}
|
|
|
|
#ifdef _NA_008012_20150130_RANKING_SYSTEM
|
|
Handler_DG_CHARINFO_IMPL( DG_MISSION_RANKING_POINT_REQ_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_MISSION_RANKING_POINT_REQ_ACK * pRecvMsg = (MSG_DG_MISSION_RANKING_POINT_REQ_ACK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->Point.UserGUID );
|
|
ASSERT( pPlayer);
|
|
if(!pPlayer) return;
|
|
|
|
if( !(pPlayer->GetRankingSystemCtl()) )
|
|
{
|
|
ASSERT(FALSE);
|
|
SUNLOG(eCRITICAL_LOG, "[SetPointRanking] Player's RankingSystemCtl is NULL[%u]", pRecvMsg->Point.UserGUID );
|
|
return;
|
|
}
|
|
|
|
#ifdef _NA_006801_20130814_RENEWAL_RANKINGSYSTEM_MINOR
|
|
pPlayer->GetRankingSystemCtl()->SetPlayerPoint( pRecvMsg->Point.UserGUID, pRecvMsg->Point.Point,
|
|
pRecvMsg->Point.DBKey, pRecvMsg->Point.ranking_type );
|
|
#else
|
|
pPlayer->GetRankingSystemCtl()->SetPlayerPoint( pRecvMsg->Point.UserGUID, pRecvMsg->Point.Point, pRecvMsg->Point.DBKey );
|
|
#endif //_NA_006801_20130814_RENEWAL_RANKINGSYSTEM_MINOR
|
|
}
|
|
#endif // _NA_008012_20150130_RANKING_SYSTEM
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_STATUS_UPDATE_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
const MSG_DG_EVENT_STATUS_UPDATE_ACK* pRecvMsg = (const MSG_DG_EVENT_STATUS_UPDATE_ACK*)pMsg;
|
|
// 트랜잭션의 상태를 확인할 필요 있다.
|
|
//ASSERT( !"Not Implementation - check transaction state" );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_GUILD_WAREHOUSE_CLOSE_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
PACKET_PTR_CONVERT(MSG_DG_GUILD_WAREHOUSE_CLOSE_ACK, pRecvMsg, pMsg);
|
|
CGuildWarehouseSlotContainer* pContainer = g_GameGuildManager.GetGuildWarehouse(pRecvMsg->m_GuildGuid);
|
|
if(pContainer)
|
|
{
|
|
// 중국 복사 버그 수정 (유저 창고의 방식 사용) [10/12/2009 lst1024]
|
|
if (pContainer->IsOpened())
|
|
pContainer->CloseWarehouse();
|
|
}
|
|
else
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "DG_GUILD_WAREHOUSE_CLOSE_ACK NONE GUILDWAREHOUSE(%d)(%u)", pRecvMsg->m_GuildGuid, pRecvMsg->m_dwKey);
|
|
}
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_GUILD_WAREHOUSE_CLOSE_NAK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
PACKET_PTR_CONVERT(MSG_DG_GUILD_WAREHOUSE_CLOSE_NAK, pRecvMsg, pMsg);
|
|
CGuildWarehouseSlotContainer* pContainer = g_GameGuildManager.GetGuildWarehouse(pRecvMsg->m_GuildGuid);
|
|
if(pContainer)
|
|
{
|
|
if(!pContainer->IsOpened())
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "DG_GUILD_WAREHOUSE_CLOSE_NAK ERROR(%d)(%u)", pRecvMsg->m_GuildGuid, pRecvMsg->m_dwKey);
|
|
return;
|
|
}
|
|
|
|
pContainer->CloseWarehouse();
|
|
}
|
|
else
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "DG_GUILD_WAREHOUSE_CLOSE_ACK NONE GUILDWAREHOUSE(%d)(%u)", pRecvMsg->m_GuildGuid, pRecvMsg->m_dwKey);
|
|
}
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_GUILD_WAREHOUSE_TAPEX_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
PACKET_PTR_CONVERT(MSG_DG_GUILD_WAREHOUSE_TAPEX_ACK, pRecvMsg, pMsg);
|
|
PLAYER_PTR_USERKEY(Player, pPlayer, pRecvMsg->m_dwKey);
|
|
|
|
CGuildWarehouseSlotContainer* pGuildWareHouse = g_GameGuildManager.GetGuildWarehouse(pRecvMsg->m_GuildGuid);
|
|
if(pGuildWareHouse)
|
|
{
|
|
// 길드창고 확장재 아이템 사용 로그
|
|
const ItemManager* const item_manager = pPlayer->GetItemManager();
|
|
SCSlotContainer* const slot_container = \
|
|
static_cast<SCSlotContainer*>( item_manager->GetItemSlotContainer(SI_INVENTORY) );
|
|
const SCItemSlot& item_slot = \
|
|
static_cast<const SCItemSlot&>(slot_container->GetSlot(pRecvMsg->m_SlotPos));
|
|
|
|
GAMELOG->LogItem(ITEM_USE, pPlayer, &item_slot);
|
|
|
|
pPlayer->GetItemManager()->DeleteWastedItem(pRecvMsg->m_SlotIndex, pRecvMsg->m_SlotPos);
|
|
pGuildWareHouse->SetSlotTabNum(pRecvMsg->m_TabCount);
|
|
|
|
// 클라에서 이 패킷을 처리 안하기 때문에 없앰
|
|
//MSG_CG_GUILD_WAREHOUSE_TAPEX_ACK msg;
|
|
//msg.m_SlotTabNum = pGuildWareHouse->GetSlotTabNum();
|
|
//pPlayer->SendPacket(&msg, sizeof(msg));
|
|
}
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_GUILD_WAREHOUSE_TAPEX_NAK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
PACKET_PTR_CONVERT(MSG_DG_GUILD_WAREHOUSE_TAPEX_NAK, pRecvMsg, pMsg);
|
|
PLAYER_PTR_USERKEY(Player, pPlayer, pRecvMsg->m_dwKey);
|
|
|
|
// 클라에서 이 패킷을 처리 안하기 때문에 없앰
|
|
//MSG_CG_GUILD_WAREHOUSE_TAPEX_NAK msg;
|
|
//msg.m_bErrorCode = pRecvMsg->m_bErrorCode;
|
|
//pPlayer->SendPacket(&msg, sizeof(msg));
|
|
}
|
|
|
|
//{__NA001283_20090227_COLLECTION_LIST
|
|
Handler_DG_CHARINFO_IMPL( DG_COLLECT_LIST_LOAD_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_COLLECT_LIST_LOAD_ACK * pRecvMsg = (MSG_DG_COLLECT_LIST_LOAD_ACK*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
CollectedList* pCollectedList = pPlayer->GetCollectedList();
|
|
if( NULL == pCollectedList )
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "DG_COLLECT_LIST_LOAD_ACK ERROR(%d)(%u) 채집 리스트가 존재 하지 않는다.", pPlayer->GetCharGuid(), pRecvMsg->m_dwKey);
|
|
return;
|
|
}
|
|
pCollectedList->SerializeStream( pRecvMsg->m_Info, SERIALIZE_STORE );
|
|
pCollectedList->SetIsLoad(true);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_COLLECT_ADD_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_COLLECT_ADD_ACK* pRecvMsg = (MSG_DG_COLLECT_ADD_ACK*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
CollectedList* pCollectedList = pPlayer->GetCollectedList();
|
|
if( NULL == pCollectedList )
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "MSG_DG_COLLECT_ADD_ACK ERROR(%d)(%u) 채집 리스트가 존재 하지 않는다.",
|
|
pPlayer->GetCharGuid(), pRecvMsg->m_dwKey);
|
|
return;
|
|
}
|
|
|
|
if( false == pCollectedList->IsLoaded() )
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "MSG_DG_COLLECT_ADD_ACK ERROR(%d)(%u) 아직 채집 리스트를 DB에서 로드 하지 않았다.",
|
|
pPlayer->GetCharGuid(), pRecvMsg->m_dwKey);
|
|
return;
|
|
}
|
|
|
|
if( pRecvMsg->m_wCount != pCollectedList->GetCount(pRecvMsg->m_CollectionID) )
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "MSG_DG_COLLECT_ADD_ACK ERROR(%d)(%u) 채집 횟수가 틀리다. DBA[%u] GAME[%u]",
|
|
pPlayer->GetCharGuid(), pRecvMsg->m_dwKey, pRecvMsg->m_wCount,
|
|
pCollectedList->GetCount(pRecvMsg->m_CollectionID));
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_COLLECT_DEL_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_COLLECT_DEL_ACK* pRecvMsg = (MSG_DG_COLLECT_DEL_ACK*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
CollectedList* pCollectedList = pPlayer->GetCollectedList();
|
|
if( NULL == pCollectedList )
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "DG_COLLECT_DEL_ACK ERROR(%d)(%u) 채집 리스트가 존재 하지 않는다.", pPlayer->GetCharGuid(), pRecvMsg->m_dwKey);
|
|
return;
|
|
}
|
|
|
|
if( false == pCollectedList->IsLoaded() )
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "DG_COLLECT_DEL_ACK ERROR(%d)(%u) 아직 채집 리스트를 DB에서 로드 하지 않았다.", pPlayer->GetCharGuid(), pRecvMsg->m_dwKey);
|
|
return;
|
|
}
|
|
|
|
pPlayer->GetCollectedList()->Delete( pRecvMsg->m_CollectionID );
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_COLLECT_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_COLLECT_NAK* pRecvMsg = (MSG_DG_COLLECT_NAK *)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer ) return ;
|
|
|
|
SUNLOG( eCRITICAL_LOG, "[DG_COLLECT_NAK] [%s], ErrorCode[%d]", pPlayer->GetCharName(), pRecvMsg->m_dwErrorCode );
|
|
}
|
|
//}__NA001283_20090227_COLLECTION_LIST
|
|
|
|
// implemented by __NA_001359_20090619_HEIM_LOTTO_SYSTEM
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_HEIM_LOTTO_PICK_NTF )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_HEIM_LOTTO_PICK_NTF* pRecvMsg = (MSG_DG_OTHER_HEIM_LOTTO_PICK_NTF*)pMsg;
|
|
|
|
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey( pRecvMsg->m_dwKey );
|
|
ASSERT( pPlayer );
|
|
if( !pPlayer || pPlayer->GetCharGuid() != pRecvMsg->iCharGuid ) {
|
|
return;
|
|
}
|
|
|
|
TCHAR tszAddInfo[MAX_ADDINFO_SIZE + 1];
|
|
_snprintf(tszAddInfo, MAX_ADDINFO_SIZE, "%d(%d): %d-%d-%d-%d",
|
|
pRecvMsg->wDrawNum, pRecvMsg->bIsAuto,
|
|
pRecvMsg->bPickedNum[0], pRecvMsg->bPickedNum[1], pRecvMsg->bPickedNum[2], pRecvMsg->bPickedNum[3]
|
|
);
|
|
tszAddInfo[MAX_ADDINFO_SIZE] = '\0';
|
|
GAMELOG->LogSimpleAction(ACT_HEIM_LOTTO_PICK, pPlayer, tszAddInfo);
|
|
}
|
|
|
|
#ifdef _NA_1419_20100121_ACCUMULATE_POINT
|
|
Handler_DG_CHARINFO_IMPL( DG_OTHER_ACCUMULATEPOINT_MATCHDATE_NTF )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_OTHER_ACCUMULATEPOINT_MATCHDATE_NTF* pRecvMsg = (MSG_DG_OTHER_ACCUMULATEPOINT_MATCHDATE_NTF*)pMsg;
|
|
AccumulatePoint::SyncMatchDate(pRecvMsg->wYear, pRecvMsg->wDayOfWeek, pRecvMsg->dwSecond);
|
|
}
|
|
#endif
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_OTHER_SELECT_COMPOSITION_OR_DECOMPOSITION_HISTORIES_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
__UNUSED(pServerSession);
|
|
ComposeOrDecomposeImplement implement;
|
|
implement.HandleGetHistoriesResponseFromDBP(pMsg, wSize);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_OTHER_EXTEND_CHAR_SLOT_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
__UNUSED(pServerSession);
|
|
|
|
using namespace util::internal;
|
|
|
|
const MSG_DG_OTHER_EXTEND_CHAR_SLOT_ACK* dbp_ack(NULL);
|
|
Player* requester(NULL);
|
|
if (CheckRequestMessage(pMsg, wSize, dbp_ack, requester) == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int result_code = 0;
|
|
if (CheckRequesterState(requester, __FUNCTION__, result_code) == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (dbp_ack->result_code != MSG_DG_OTHER_EXTEND_CHAR_SLOT_ACK::kSuccess)
|
|
{
|
|
MSG_CG_ITEM_USE_NAK msg;
|
|
msg.m_ErrorCode = RC::RC_ITEM_UNUSABLE_FUNCTION;
|
|
requester->SendPacket(&msg, sizeof(msg));
|
|
return;
|
|
}
|
|
|
|
requester->GetItemManager()->DeleteWastedItem(SI_INVENTORY, dbp_ack->extend_item_position);
|
|
}
|
|
|
|
//_KR_0_20091021_FIRENDINVITATION_EXTEND
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_INVITATEFRIEND_REWARDUPDATE_ACK )
|
|
{
|
|
GFriendInvitationController::Instance()->OnRewardItemUpdateACK(pServerSession, pMsg, wSize);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_INVITATEFRIEND_REWARDUPDATE_NAK )
|
|
{
|
|
GFriendInvitationController::Instance()->OnRewardItemUpdateNAK(pServerSession, pMsg, wSize);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_INVITATEFRIEND_RECALLSELECT_ACK )
|
|
{
|
|
GFriendInvitationController::Instance()->OnRecallInfoSelectACK(pServerSession, pMsg, wSize);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_INVITATEFRIEND_RECALLSELECT_NAK )
|
|
{
|
|
GFriendInvitationController::Instance()->OnRecallInfoSelectNAK(pServerSession, pMsg, wSize);
|
|
}
|
|
|
|
#ifdef _NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_DOMINATION_REWARD_AND_DEL_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
const MSG_DG_EVENT_DOMINATION_REWARD_AND_DEL_ACK* recv_msg =
|
|
static_cast<MSG_DG_EVENT_DOMINATION_REWARD_AND_DEL_ACK*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->request_char_guid_);
|
|
if (player == NULL)
|
|
{
|
|
assert(!"Player Not Fount");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"][%u]Player Not Found",
|
|
recv_msg->request_char_guid_);
|
|
return;
|
|
}
|
|
//--gamelulu debuging log
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]Reward Start[Name:%s][Cost:%%I64u]",
|
|
player->GetCharName(),
|
|
recv_msg->tender_cost_);
|
|
|
|
//-- 보상 조건 체크
|
|
if (recv_msg->result_value_ != 0)
|
|
{
|
|
assert(!"DB Query Result Fail");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"][User:%u]DB Query Result Fail",
|
|
recv_msg->request_char_guid_);
|
|
return;
|
|
}
|
|
else if (recv_msg->request_char_guid_ != recv_msg->db_result_char_guid_)
|
|
{
|
|
assert(!"CharGuid Not Same");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]CharGuid Not Same[DB:%u]!=[REQ:%u]",
|
|
recv_msg->db_result_char_guid_,
|
|
recv_msg->request_char_guid_);
|
|
return;
|
|
}
|
|
else if (recv_msg->request_reward_type_ != recv_msg->db_result_reward_type_)
|
|
{
|
|
assert(!"Money Type Not Same");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"][User:%u]Money Type Not Same[DB:%d]!=[REQ:%d]",
|
|
recv_msg->request_char_guid_,
|
|
recv_msg->db_result_reward_type_,
|
|
recv_msg->request_reward_type_);
|
|
return;
|
|
}
|
|
else if (recv_msg->request_map_code_ != recv_msg->db_result_map_code_)
|
|
{
|
|
assert(!"MapCode Not Same");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"][User:%u]MapCode Not Same[DB:%u]!=[REQ:%u]",
|
|
recv_msg->request_char_guid_,
|
|
recv_msg->db_result_map_code_,
|
|
recv_msg->request_map_code_);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
#ifdef _CH_20100420_CHANGE_DOMINATION_APPLY_WAY
|
|
//gamelulu say : 보상을 받을때 중복갯수의 최대치 때문에 여러게의 슬롯을 사용해야 한다.
|
|
//현재 최대치 이상이 삽입 가능한지가 체크 되지 않기 때문에 최대치까지만 보상을 하며
|
|
//보상의 횟수를 늘린다. 다만 중간에 실패 했을 경우 DB에 그 내용을 저장하여 차후 다시
|
|
//보상을 시도하게 한다.
|
|
MONEY amount_heim =
|
|
DominationInfoParser::Instance()->GetAreaLimitMoney(recv_msg->request_map_code_);
|
|
//--gamelulu debuging log
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]Script Heim[Name:%s][Heim:%I64u]",
|
|
player->GetCharName(), amount_heim);
|
|
|
|
SLOTCODE item_code =
|
|
DominationInfoParser::Instance()->GetBattingItemCodeByMapCode(recv_msg->request_map_code_);
|
|
|
|
//--보상 분할 처리
|
|
int temp_cost = static_cast<int>(recv_msg->tender_cost_);//기존 Money패킷을 그대로 쓰기 때문
|
|
int number_of_insertable_item;//한개의 슬롯을 대상으로 습득 할 수 있는 아이템 갯수
|
|
for(;temp_cost > 0 ; temp_cost -= number_of_insertable_item)
|
|
{
|
|
//--습득 가능 여부 & 습득 할 수 있는 아이템 갯수(OUT)
|
|
RC::eITEM_RESULT result_value =
|
|
player->GetPostManager()->CheckRewardItem(player, temp_cost, item_code,
|
|
number_of_insertable_item);
|
|
|
|
if (result_value != RC::RC_ITEM_SUCCESS)
|
|
{
|
|
MSG_CG_EVENT_ITEM_REWARD_RESULT_CMD nak_msg;
|
|
nak_msg.memo_guid_ = recv_msg->memo_guid_;
|
|
nak_msg.result_value_ = false;
|
|
|
|
player->SendPacket(&nak_msg, sizeof(nak_msg));
|
|
|
|
//--보상 DB 롤백
|
|
MSG_DG_EVENT_DOMINATION_ITEM_ROLLBACK_SYN send_msg;
|
|
send_msg.char_guid_ = recv_msg->db_result_char_guid_;
|
|
send_msg.map_code_ = recv_msg->db_result_map_code_;
|
|
send_msg.reward_type_ = recv_msg->db_result_reward_type_;
|
|
send_msg.tender_cost_ = temp_cost;
|
|
|
|
player->SendToGameDBPServer(&send_msg, sizeof(send_msg));
|
|
|
|
SUNLOG(eFULL_LOG, "["__FUNCTION__"]Inventory Is Full:%u]",
|
|
recv_msg->request_char_guid_);
|
|
|
|
return;
|
|
}
|
|
|
|
//--아이템 보상
|
|
RC::eITEM_RESULT reward_result_value =
|
|
player->GetPostManager()->RewardItem(player, number_of_insertable_item, item_code);
|
|
|
|
if (reward_result_value != RC::RC_ITEM_SUCCESS)
|
|
{
|
|
MSG_CG_EVENT_ITEM_REWARD_RESULT_CMD nak_msg;
|
|
nak_msg.memo_guid_ = recv_msg->memo_guid_;
|
|
nak_msg.result_value_ = false;
|
|
|
|
player->SendPacket(&nak_msg, sizeof(nak_msg));
|
|
|
|
//--보상 DB 롤백
|
|
MSG_DG_EVENT_DOMINATION_ITEM_ROLLBACK_SYN send_msg;
|
|
send_msg.char_guid_ = recv_msg->db_result_char_guid_;
|
|
send_msg.map_code_ = recv_msg->db_result_map_code_;
|
|
send_msg.reward_type_ = recv_msg->db_result_reward_type_;
|
|
send_msg.tender_cost_ = temp_cost;
|
|
|
|
player->SendToGameDBPServer(&send_msg, sizeof(send_msg));
|
|
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]Domination Item Reward Fail[User:%u]",
|
|
recv_msg->request_char_guid_);
|
|
|
|
return;
|
|
}
|
|
}
|
|
//--최종 하임 보상및 보상 결과 알림
|
|
//2010.07.13 : 보상 금액인 1억으로 MAX를 정한다. 비정상적인 하임 습득에 대한 일시적 처리
|
|
//현재 중국은 1억으로 일괄 보상
|
|
const ULONGLONG max_reward_money = 100000000;
|
|
|
|
if (amount_heim > max_reward_money)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]Reward Heim[Name:%s][Heim:%I64u]",
|
|
player->GetCharName(), amount_heim);
|
|
|
|
amount_heim = max_reward_money;
|
|
}
|
|
|
|
player->GetPostManager()->RewardHeim(player, amount_heim, recv_msg->request_reward_type_);
|
|
|
|
MSG_CG_EVENT_ITEM_REWARD_RESULT_CMD cmd_msg;
|
|
cmd_msg.memo_guid_ = recv_msg->memo_guid_;
|
|
cmd_msg.result_value_ = true;
|
|
|
|
player->SendPacket(&cmd_msg, sizeof(cmd_msg));
|
|
#else
|
|
//--보상 로직
|
|
player->GetPostManager()->RewardHeim(player, recv_msg->tender_cost_,
|
|
recv_msg->db_result_reward_type_);
|
|
//--보상 완료 알림
|
|
MSG_CG_EVENT_ITEM_REWARD_RESULT_CMD cmd_msg;
|
|
cmd_msg.memo_guid_ = recv_msg->memo_guid_;
|
|
cmd_msg.result_value_ = true;
|
|
|
|
player->SendPacket(&cmd_msg, sizeof(cmd_msg));
|
|
#endif
|
|
}
|
|
}
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_LOTTO_REWARD_AND_DEL_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
const MSG_DG_EVENT_LOTTO_REWARD_AND_DEL_ACK* recv_msg =
|
|
static_cast<MSG_DG_EVENT_LOTTO_REWARD_AND_DEL_ACK*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->request_char_guid_);
|
|
if (player == NULL)
|
|
{
|
|
assert(!"Player Not Fount");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"][%u]Player Not Found",
|
|
recv_msg->request_char_guid_);
|
|
return;
|
|
}
|
|
|
|
//--보상 조건
|
|
if (recv_msg->result_value_ != 0)
|
|
{
|
|
assert(!"DB Query Result Fail");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"][User:%u]DB Query Result Fail",
|
|
recv_msg->request_char_guid_);
|
|
return;
|
|
}
|
|
else if (recv_msg->request_char_guid_ != recv_msg->db_result_char_guid_)
|
|
{
|
|
assert(!"CharGuid Not Same");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]CharGuid Not Same[DB:%u]!=[REQ:%u]",
|
|
recv_msg->db_result_char_guid_, recv_msg->request_char_guid_);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
//--보상 로직
|
|
player->GetPostManager()->RewardHeim(player, recv_msg->db_result_prize_money_,
|
|
SYSMEMO_LOTTO_WIN);
|
|
}
|
|
}
|
|
#endif//_NA_20100420_CHANGE_SYSTEM_MEMO_LOGIC
|
|
|
|
// implemented by _NA_20100812_INTEGRATE_SYSTEM_MEMO_DOMINATION
|
|
Handler_DG_CHARINFO_IMPL( DG_EVENT_SYSTEMMEMO_ITEM_CHECK_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
const MSG_DG_EVENT_SYSTEMMEMO_ITEM_CHECK_ACK* recv_msg =
|
|
static_cast<MSG_DG_EVENT_SYSTEMMEMO_ITEM_CHECK_ACK*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->char_guid_);
|
|
if (player == NULL)
|
|
{
|
|
assert(!"Player Not Fount");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"][%u]Player Not Found", recv_msg->char_guid_);
|
|
return;
|
|
}
|
|
|
|
GameDominationManager* domination_manager = GameDominationManager::Instance();
|
|
RC::eITEM_RESULT result_value = RC::RC_ITEM_SUCCESS;
|
|
|
|
if(recv_msg->db_result_value_ == true)
|
|
{
|
|
//-- 아이템 보상
|
|
result_value = domination_manager->GetSystemMemo()->RewardSysMemoItem(player, recv_msg);
|
|
}
|
|
else
|
|
{
|
|
assert(!"Reward item check fail");
|
|
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]Reward Item check fail");
|
|
|
|
result_value = RC::RC_ITEM_FAILED;
|
|
}
|
|
|
|
MSG_CG_EVENT_SYSTEMMEMO_ITEM_REWARD_ANS ans_msg;
|
|
{
|
|
ans_msg.memo_guid_ = recv_msg->memo_guid_;
|
|
ans_msg.result_value_ = result_value;
|
|
}
|
|
player->SendPacket(&ans_msg, sizeof(ans_msg));
|
|
}
|
|
|
|
#ifdef _NA_003027_20111013_HONOR_SYSTEM
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARINFO_HONORSYSTEM)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
HonorSystem::Instance()->ParseDGPacket(pMsg);
|
|
}
|
|
#endif //_NA_003027_20111013_HONOR_SYSTEM
|
|
|
|
#ifdef _NA004034_20120102_POINT_WALLET_SYSTEM
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARINFO_POINTWALLET_SYSTEM)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_CHARINFO_POINTWALLET_SYSTEM* packet = \
|
|
static_cast<MSG_DG_CHARINFO_POINTWALLET_SYSTEM*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey( packet->m_dwKey );
|
|
if( !player ) return ;
|
|
|
|
PointWalletManager* const pointwallet_manager = player->GetPointWalletManager();
|
|
pointwallet_manager->ParseDGPacket(packet);
|
|
}
|
|
#endif //_NA004034_20120102_POINT_WALLET_SYSTEM
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARNAME_CHANGE_ACK)
|
|
{
|
|
MSG_DG_CHARNAME_CHANGE_ACK* packet = \
|
|
static_cast<MSG_DG_CHARNAME_CHANGE_ACK*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey( packet->m_dwKey );
|
|
if( !player ) return ;
|
|
|
|
POSTYPE item_pos = packet->item_pos;
|
|
SLOTIDX slot_index = packet->slot_index;
|
|
|
|
ItemManager* item_manager = player->GetItemManager();
|
|
if (item_manager == NULL) {
|
|
return;
|
|
}
|
|
SCSlotContainer* container = (SCSlotContainer*)item_manager->GetItemSlotContainer(slot_index);
|
|
if (container == NULL) {
|
|
return;
|
|
}
|
|
SCItemSlot& item_slot = (SCItemSlot&)container->GetSlot(item_pos);
|
|
if (item_slot.GetSerial() == 0) {
|
|
return;
|
|
}
|
|
const BASE_ITEMINFO* item_info = item_slot.GetItemInfo();
|
|
if (item_info == NULL) {
|
|
return;
|
|
}
|
|
|
|
item_slot.SetLock(FALSE);
|
|
|
|
if (packet->result == 0) // success ~~
|
|
{
|
|
// 성공의 경우에는 먼저 아이템 사용 로그부터 남긴다
|
|
GAMELOG->LogItem(ITEM_USE, player, &item_slot);
|
|
|
|
// 소모성 아이템 삭제
|
|
if (item_info->m_wType == eITEMTYPE_CHARACTER_NAME_CHANGE)
|
|
{
|
|
if(item_slot.GetNum() <= 1) {
|
|
container->DeleteSlot(item_pos, NULL);
|
|
}
|
|
else {
|
|
container->UpdateSlot(item_pos, -1);
|
|
}
|
|
}
|
|
|
|
player->ResetUseItem(item_info->m_wCoolTimeType);
|
|
|
|
MSG_CG_ITEM_USE_ACK ack;
|
|
ack.m_atIndex = slot_index;
|
|
ack.m_atPos = item_pos;
|
|
player->SendPacket(&ack, (WORD)sizeof(ack));
|
|
}
|
|
|
|
MSG_CG_CHARNAME_CHANGE_REQUEST_ACK msg;
|
|
msg.result = packet->result;
|
|
player->SendPacket(&msg, sizeof(msg));
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARACTER_EXTRA_INFO_CMD)
|
|
{
|
|
MSG_DG_CHARACTER_EXTRA_INFO_CMD* packet = \
|
|
static_cast<MSG_DG_CHARACTER_EXTRA_INFO_CMD*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey( packet->m_dwKey );
|
|
if( !player ) return ;
|
|
|
|
#ifdef _NA_006372_20130108_BADGE_ITEM
|
|
;{
|
|
// store toggle item info (D->G)
|
|
ToggleItemInfos& toggle_item_info_container = \
|
|
player->GetExtraInfoManager().GetToggleItemInfos();
|
|
memcpy(&toggle_item_info_container, &packet->toggle_item_info_, \
|
|
sizeof(packet->toggle_item_info_));
|
|
};
|
|
#endif //_NA_006372_20130108_BADGE_ITEM
|
|
//_NA_005026_20120527_CHAOS_ZONE_BATTLE_GROUND
|
|
;{
|
|
player->GetExtraInfoManager().SetBattleGroundRecordInfos(packet->battle_ground_record_infos_);
|
|
};
|
|
|
|
#ifdef _NA_007065_20140217_CHAOSZONE_GOLDRUSH
|
|
;{
|
|
player->GetExtraInfoManager().SetGoldRushRecordInfos(packet->goldrush_record_infos_);
|
|
};
|
|
#endif //_NA_007065_20140217_CHAOSZONE_GOLDRUSH
|
|
#ifdef _NA_000000_20130521_DAILY_QUEST_RESET_ITEM
|
|
;{
|
|
player->GetExtraInfoManager().SetDailyQuestResetUseTime(\
|
|
packet->daily_quest_reset_item_use_time);
|
|
};
|
|
#endif //_NA_000000_20130521_DAILY_QUEST_RESET_ITEM
|
|
#ifdef _NA_008404_20150712_MINIGAME_SYSTEM
|
|
;{
|
|
player->GetExtraInfoManager().SetMiniGameBingoInfos(\
|
|
packet->minigame_bingo_infos);
|
|
};
|
|
#endif //_NA_008404_20150712_MINIGAME_SYSTEM
|
|
|
|
//player->GetExtraInfoManager().OnEnterField(); // 옵션 중복 적용 문제 생겨서 제거함 - arycoat.2013.04.03.
|
|
}
|
|
|
|
#ifdef _NA_007932_20150106_USER_EXTRA_INFO
|
|
Handler_DG_CHARINFO_IMPL(DG_USER_EXTRA_INFO_CMD)
|
|
{
|
|
MSG_DG_USER_EXTRA_INFO_CMD* packet = \
|
|
static_cast<MSG_DG_USER_EXTRA_INFO_CMD*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey( packet->m_dwKey );
|
|
if( !player ) return ;
|
|
|
|
// UserExtraInfo 추가시 수정
|
|
#ifdef _NA_007932_20150112_ATTENDANCE_CHECK_SYSTEM
|
|
;{
|
|
player->GetExtraInfoManager().SetAttendanceInfos(\
|
|
packet->attendance_infos);
|
|
};
|
|
#endif //_NA_007932_20150112_ATTENDANCE_CHECK_SYSTEM
|
|
}
|
|
#endif // _NA_007932_20150106_USER_EXTRA_INFO
|
|
|
|
#ifdef _NA_000000_20140120_SMART_NPC_SYSTEM
|
|
Handler_DG_CHARINFO_IMPL(DG_EVENT_SMARTNPC_SYSTEM)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
g_ExtraNPCManager.ParseDGPacket(pMsg);
|
|
}
|
|
#endif //_NA_000000_20140120_SMART_NPC_SYSTEM
|
|
|
|
#ifdef _NA_007086_20140318_MONSTERBOOK
|
|
Handler_DG_CHARINFO_IMPL(DG_CHARACTER_MONSTERBOOK_CMD)
|
|
{
|
|
MSG_DG_CHARACTER_MONSTERBOOK_CMD* packet = \
|
|
static_cast<MSG_DG_CHARACTER_MONSTERBOOK_CMD*>(pMsg);
|
|
|
|
switch(packet->packet_type)
|
|
{
|
|
case DG_CHARACTER_MONSTERBOOK_SERIALIZE_CMD:
|
|
{
|
|
const MSG_DG_CHARACTER_MONSTERBOOK_SERIALIZE_CMD* packet2 = \
|
|
static_cast<MSG_DG_CHARACTER_MONSTERBOOK_SERIALIZE_CMD*>(pMsg);
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey( packet2->m_dwKey );
|
|
if (!player) return ;
|
|
|
|
MonsterBook& monster_book = player->GetMonsterBook();
|
|
memcpy(&monster_book, &packet2->monster_book, sizeof(monster_book));
|
|
} break;
|
|
case DG_CHARACTER_MONSTERBOOK_ADD_ACK:
|
|
{
|
|
const MSG_DG_CHARACTER_MONSTERBOOK_ADD_ACK* packet2 = \
|
|
static_cast<MSG_DG_CHARACTER_MONSTERBOOK_ADD_ACK*>(pMsg);
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByUserKey( packet2->m_dwKey );
|
|
if (!player) return ;
|
|
DWORD monster_code = packet2->monster_code;
|
|
|
|
MonsterBook& monster_book = player->GetMonsterBook();
|
|
if (monster_book.find(monster_code) == 0) {
|
|
monster_book.push_back(packet2->monster_code);
|
|
|
|
MSG_CG_MONSTERBOOK_ADD_CMD cmd;
|
|
cmd.monster_code_ = monster_code;
|
|
player->SendPacket(&cmd, sizeof(cmd));
|
|
|
|
GAMELOG->LogMonsterBook(ACT_MONSTERBOOK_REGISTER, player, cmd.monster_code_);
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
#endif //_NA_007086_20140318_MONSTERBOOK
|
|
|
|
#ifdef _NA_007919_20141211_ADD_GMCOMMAND_EVENT
|
|
Handler_DG_CHARINFO_IMPL(DG_GMEVENT_PEAKTIME_REGISTER_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_GMEVENT_PEAKTIME_REGISTER_ACK* packet = \
|
|
static_cast<MSG_DG_GMEVENT_PEAKTIME_REGISTER_ACK*>(pMsg);
|
|
|
|
PeakTimeEvent::Instance()->AddGmEvent(packet->register_event);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_GMEVENT_PEAKTIME_TERMINATE_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_GMEVENT_PEAKTIME_TERMINATE_ACK* packet = \
|
|
static_cast<MSG_DG_GMEVENT_PEAKTIME_TERMINATE_ACK*>(pMsg);
|
|
|
|
PeakTimeEvent::Instance()->DeleteProgressEvent();
|
|
}
|
|
#endif //_NA_007919_20141211_ADD_GMCOMMAND_EVENT
|
|
|
|
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
Handler_DG_CHARINFO_IMPL(DG_SUN_RANKING_UPDATE_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_SUN_RANKING_UPDATE_ACK* packet = \
|
|
static_cast<MSG_DG_SUN_RANKING_UPDATE_ACK*>(pMsg);
|
|
|
|
SunRankingManager::Instance()->UpdateFromSunRankingPlayer(packet->info);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_SUN_RANKING_SELECT_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_SUN_RANKING_SELECT_ACK* packet = \
|
|
static_cast<MSG_DG_SUN_RANKING_SELECT_ACK*>(pMsg);
|
|
|
|
for (int i = 0; i < packet->count; ++i)
|
|
{
|
|
SunRankingManager::Instance()->UpdateFromSunRankingPlayer(packet->infos[i]);
|
|
}
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_SUN_RANKING_GRADE_SELECT_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_SUN_RANKING_GRADE_SELECT_ACK* packet = \
|
|
static_cast<MSG_DG_SUN_RANKING_GRADE_SELECT_ACK*>(pMsg);
|
|
|
|
SunRankingGradeManager::Instance()->SetAllGradeInfos(packet->infos, packet->count);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_STATUE_ITEM_SLOT_INFO_INSERT_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_STATUE_ITEM_SLOT_INFO_INSERT_ACK* packet = \
|
|
static_cast<MSG_DG_STATUE_ITEM_SLOT_INFO_INSERT_ACK*>(pMsg);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_STATUE_SELECT_ACK)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_STATUE_SELECT_ACK* packet = \
|
|
static_cast<MSG_DG_STATUE_SELECT_ACK*>(pMsg);
|
|
|
|
if (packet->count > 0)
|
|
{
|
|
StatueManager::Instance()->SetStatue(packet->statue_info.statue_type, packet->statue_info.statue_index, &packet->statue_info);
|
|
}
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_SUN_RANKING_SETTLE_START_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_SUN_RANKING_SETTLE_START_CMD* packet = \
|
|
static_cast<MSG_DG_SUN_RANKING_SETTLE_START_CMD*>(pMsg);
|
|
|
|
SunRankingGradeManager::Instance()->Settle();
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_SUN_RANKING_SETTLE_COMPLETE_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_SUN_RANKING_SETTLE_COMPLETE_CMD* packet = \
|
|
static_cast<MSG_DG_SUN_RANKING_SETTLE_COMPLETE_CMD*>(pMsg);
|
|
|
|
SunRankingGradeManager::Instance()->Settle_Complete();
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_SUN_RANKING_SELECT_COMPLETE_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_SUN_RANKING_SELECT_COMPLETE_CMD* packet = \
|
|
static_cast<MSG_DG_SUN_RANKING_SELECT_COMPLETE_CMD*>(pMsg);
|
|
|
|
SunRankingGradeManager::Instance()->SetLoadComplete(eLOAD_KIND_RANKING_SELECT);
|
|
}
|
|
|
|
Handler_DG_CHARINFO_IMPL(DG_SUN_RANKING_GRADE_SELECT_COMPLETE_CMD)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_DG_SUN_RANKING_GRADE_SELECT_COMPLETE_CMD* packet = \
|
|
static_cast<MSG_DG_SUN_RANKING_GRADE_SELECT_COMPLETE_CMD*>(pMsg);
|
|
|
|
SunRankingGradeManager::Instance()->SetLoadComplete(eLOAD_KIND_GRADE_SELECT);
|
|
}
|
|
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
|