inguz/Sun1602
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9cb257e7aec2120e1d94046adfa0272047ab349c
Sun1602/Server/GameServer/PacketHandler/Handler_GZ_GUILD.cpp
T
git 9cb257e7ae Add GameClients drops and keep current 1602 source work. 
CN1602 is the local client. KR is the official tree with unpacked Data, System, and Sound. Packed .wpk files stay off git.
2026-08-30 23:24:31 +03:00

2901 lines
98 KiB
C++
Raw Blame History

#include "StdAfx.h"
#include ".\handler_gz_guild.h"
#include <PacketStruct_GZ.h>
#include <PacketStruct_CG.h>
#include <PacketStruct_AG.h>
#include <PacketStruct_DG.h>
#include <BitStream.hpp>
#include <SCItemSlot.h>
#include <GuildRankInfoParser.h>
#include ".\Player.h"
#include ".\GameGuildManager.h"
#include ".\GameGuild.h"
#include ".\GameGuildMember.h"
#include "GameGuildRelation.h"
#include "GameGuildExtension.h"
#include "GameParty/NewGamePartyManager.h"
#include "ItemManager.h"
#include "GameDominationManager.h"
#include <ResultCode.h>
#include "GameDominationManager.h"
#include "DominationArea.h"
#include "GuildInfoParser.h"
//_NA_20110406_CHANGE_RULE_FOR_DOMINATION_JOIN
#include "DominationMember.h"
#include <PointSystem/PacketStruct_CG_PointSystem.h>
#include <PacketStruct_PointSystem.h>
#include <CurrencyInfoParser.h>
#ifdef _NA_006088_20120910_CHAOS_ZONE_FREE_PVP
#include "GameInstanceDungeon.h"
#endif // _NA_006088_20120910_CHAOS_ZONE_FREE_PVP
#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION
#include "GameDominationField.h"
#include "GameZoneManager.h"
#include "GuildFacilities.h"
#endif //_NA_007128_20140326_MONDSCHIEN_DOMINATION
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
#include "SunRanking/SunRankingManager.h"
#include "SunRanking/SunRankingGradeManager.h"
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
//--------------------------------------------------------------------------------------------------
// changes, f100819.1L
const nsPacket::PacketHandlerInfo Handler_GZ_GUILD::GetPacketHandlerNodes()
{
#define HANDLER_NODE_INFO(c, p, phase) { MAKEWORD(c, p), phase, Handler_GZ_GUILD::On##p }
#define HANDLER_NODE_INFO_EOR() { 0, static_cast<ePHASE_SHIFT>(0), NULL }
static const nsPacket::PacketHandlerNode handlers_static_[] =
{
#if !defined(_NA002635_GZ_DZ_PROTOCOL_UINIFICATION)
HANDLER_NODE_INFO(DG_CONNECTION, DG_CONNECTION_GROUND_CMD, PHASE_SERVICE),
#endif
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_INFO_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_SELECT_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CREATE_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DESTROY_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_WITHDRAW_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_JOIN_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_JOIN_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_SELECT_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CREATE_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DESTROY_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_WITHDRAW_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_KICKPLAYER_NAK, PHASE_SERVICE),
// 公会积分相关
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DONATE_UP_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DONATE_UP_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CONVERT_UP2GP_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CONVERT_UP2GP_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RANKUP_BRD, PHASE_SERVICE),
#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHUNTING_PVP_RESULT_BRD, PHASE_SERVICE),
#endif
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELATION_INFO_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_BOTH_RELATION_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELATION_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELATION_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELATION_DELETE_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELATION_DELETE_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELATION_BOTH_AGAINST_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELATION_BOTH_AGAINST_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_DUTY_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_DUTY_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RIGHT_DELEGATION_LIST_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RIGHT_DELEGATION_LIST_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RIGHT_DELEGATION_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RIGHT_DELEGATION_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_MASTER_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_MASTER_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_EMPTY_COMMANDER_INFO_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_EMPTY_COMMANDER_INFO_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CREATE_CORPS_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CREATE_CORPS_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DESTROY_CORPS_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DESTROY_CORPS_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_COMMANDER_BRD, PHASE_SERVICE), // 变更公会军团长
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_COMMANDER_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_CORPS_BRD, PHASE_SERVICE), // 公会军团移动
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_CORPS_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CREATE_REAR_CAMP_BRD, PHASE_SERVICE), // 创建公会训练营
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CREATE_REAR_CAMP_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DESTROY_REAR_CAMP_BRD, PHASE_SERVICE), // 解散公会训练营
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DESTROY_REAR_CAMP_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_INVITE_ACK, PHASE_SERVICE), // 公会邀请
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_INVITE_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_LOGIN_CHAR_BRD, PHASE_SERVICE), // 公会会员登录
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_LOGIN_CHAR_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_LOGOUT_CHAR_BRD, PHASE_SERVICE), // 会员注销
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHAR_LEVELUP_BRD, PHASE_SERVICE), // 公会成员升级
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_KICKPLAYER_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_TOTALINFO_REQ_ACK, PHASE_SERVICE), // 公会信息请求
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_TOTALINFO_REQ_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_GM_GUILD_POINT_BRD, PHASE_SERVICE), // GM指令公会积分设置
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_GM_GUILD_POINT_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_CHANGE_CHAOSTATE_BRD, PHASE_SERVICE), // 变更公会会员卡吴尚泰.
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_ENTER_SERVER_ACK, PHASE_SERVICE), // 行会成员服务器间移动.
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_GUILDMARK_REGISTER_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_GUILDMARK_REGISTER_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_GUILDMARK_DELETE_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_GUILDMARK_DELETE_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_DESTROY_WAIT_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RECOVERY_GUILD_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RECOVERY_GUILD_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_WAREHOUSE_OPEN_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_WAREHOUSE_OPEN_NAK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_NAME_CHANGE_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_NAME_CHANGE_BRD, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_NAME_CHANGE_NAK, PHASE_SERVICE),
//{_KR_001385_20091013_DOMINATION_BASICINFO_SETTING
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_AUCTION_INFO_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_INFO_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_UPDATE_INFO_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_ACCEP_HEIM_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_INIT_ACTIONINFO_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_BATTING_HEIM_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_RETURNHIME_ACK, PHASE_SERVICE),
//}
//_NA_20100604_BETTER_DOMINATION_MANAGER
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_UPDATE_GUILDINFO_ACK, PHASE_SERVICE),
//_NA_20100913_GUILD_WAREHOUSE_GM_COMMAND
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_GM_WAREHOUSE_FORCE_CLOSE_BRD, PHASE_SERVICE),
//_NA_20110216_INCREASE_DOMINATION_DEFFENSEWALL_POINT
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_ADD_DEFFENSEWALL_POINT_ACK, PHASE_SERVICE),
//_NA_20110406_CHANGE_RULE_FOR_DOMINATION_JOIN
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_MEMBER_JOIN_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_MEMBER_LEAVE_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_MEMBERLIST_ANS, PHASE_SERVICE),
#ifdef _NA004034_20120102_GUILD_POINT_SYSTEM
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILDPOINTSYSTEM, PHASE_SERVICE),
#endif
#ifdef _NA_004034_20120102_GUILD_INTRODUCTION
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_INTRODUCTION_SAVE_ACK, PHASE_SERVICE),
#endif //_NA_004034_20120102_GUILD_INTRODUCTION
#ifdef _NA_003923_20120130_GUILD_RENEWAL
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_IN_GAME_GUILD_LOG_LIST_ANS, PHASE_SERVICE),
#endif
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RENAME_CHAR_CMD, PHASE_SERVICE),
#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION
HANDLER_NODE_INFO(GZ_GUILD, GZ_DOMINATION_CONTINENT_LORD_INFO_ACK, PHASE_SERVICE),
#endif //_NA_007128_20140326_MONDSCHIEN_DOMINATION
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_JOIN_REQUEST_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_JOIN_REQUEST_REJECT_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_RELOAD_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_FACILITY_UPGRADE_ACK, PHASE_SERVICE),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_FACILITY_SELECT_ACK, PHASE_SERVICE),
#endif //_NA_007330_20140620_GUILD_SYSTEM_EXTENSION
#ifdef _NA_008334_20150608_SONNENSCHEIN
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_SONNENSCHEIN_INITIALIZE_CMD, PHASE_UNLIMITED),
HANDLER_NODE_INFO(GZ_GUILD, GZ_GUILD_SONNENSCHEIN_UPDATE_ACK, PHASE_UNLIMITED),
#endif //_NA_008334_20150608_SONNENSCHEIN
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_GZ_GUILD_IMPL(DG_CONNECTION_GROUND_CMD)
{
__UNUSED((pServerSession, pRecvMsg, wSize));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_INFO_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_INFO_BRD * pMsg = (MSG_GZ_GUILD_INFO_BRD *)pRecvMsg;
}
//?? ??
Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DESTROY_BRD* receive_msg = static_cast<MSG_GZ_GUILD_DESTROY_BRD*>(pRecvMsg);
#ifdef _USING_GUILD_DESTROY_LOGGING
SUNLOG(eCRITICAL_LOG,
_T("|行会解散完毕|Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_BRD)|MSG_GZ_GUILD_DESTROY_BRD接收|PlayerKey:%u, GuildGuid:%d|"),
receive_msg->m_dwKey, receive_msg->m_GuildGuid);
#endif // _USING_GUILD_DESTROY_LOGGING
// 不管现在有没有下命令的玩家，都要解散公会.
g_GameGuildManager.DestroyGuild(receive_msg->m_GuildGuid);
//(shogen)(20090819)
//Player* player = PlayerManager::Instance()->FindPlayerByUserKey( receive_msg->m_dwKey );
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(receive_msg->m_dwKey);
if (player == NULL)
{
return;
}
player->GetCharInfo()->m_GuildGuid = 0;
player->GetCharInfo()->m_eGuildDuty = eGUILD_DUTY_NONE;
MSG_AG_GUILD_DESTROY_ACK msg;
player->SendPacket(&msg, sizeof(msg));
MSG_CG_GUILD_DESTROY_BRD brd_msg;
brd_msg.m_MasterPlayerKey = player->GetObjectKey();
#ifdef _USING_GUILD_DESTROY_LOGGING
SUNLOG(eCRITICAL_LOG,
_T("|行会解散完毕|Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_BRD)|MSG_CG_GUILD_DESTROY_BRD 接收|PlayerGuildGuid:%d, PlayerGuildDuty:%d, MasterPlayerKey:%u|"),
player->GetCharInfo()->m_GuildGuid,
player->GetCharInfo()->m_eGuildDuty,
brd_msg.m_MasterPlayerKey);
#endif // _USING_GUILD_DESTROY_LOGGING
player->SendPacketAround(&brd_msg, sizeof(brd_msg), FALSE);
}
//公会解散失败
Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DESTROY_NAK * pMsg = (MSG_GZ_GUILD_DESTROY_NAK *)pRecvMsg;
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_DESTROY_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
}
//加入公会
Handler_GZ_GUILD_IMPL(GZ_GUILD_JOIN_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_JOIN_BRD* pMsg = (MSG_GZ_GUILD_JOIN_BRD*)pRecvMsg;
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
if (SunRankingGradeManager::Instance()->IsSettleChannel())
{
SunRankingManager::Instance()->SetGuildGuid(pMsg->m_MemberInfo.m_CharGuid, pMsg->m_GuildGuid);
}
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
//现服不存在该帮派，无需执行.
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGuild) return;
//如果命令者存在..
Player* pOperPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pOperPlayer)
{
MSG_CG_GUILD_JOIN_ACK ackMsg;
pOperPlayer->SendPacket(&ackMsg, sizeof(ackMsg));
}
//如果用户存在..
Player* pTargetPlayer = PlayerManager::Instance()->FindPlayerByName(pMsg->m_MemberInfo.m_tszCharName);
if (pTargetPlayer)
{
RC::eGUILD_RESULT rc = g_GameGuildManager.JoinGuild(pMsg->m_GuildGuid, pMsg->m_MemberInfo);
if (rc != RC::RC_GUILD_SUCCESS)
{
SUNLOG(eCRITICAL_LOG, "Handler_GZ_GUILD_IMPL(GZ_GUILD_JOIN_ACK) 失败, rc = %d", rc);
return;
}
// 设置该玩家的信息.
pTargetPlayer->GetCharInfo()->m_GuildGuid = pMsg->m_GuildGuid;
util::GUILDNAMECOPY(pTargetPlayer->GetCharInfo()->m_tszGuildName, pGuild->GetGuildName());
// 从GuildServer处收到ack后发送ack
//将公会号码从BRD传送也不错…首先就这样...
MSG_AG_GUILD_JOIN_SUCCESS_CMD msg;
msg.m_GuildGuid = pMsg->m_GuildGuid;
pTargetPlayer->SendPacket(&msg, sizeof(msg));
// 发送公会关系列表，显示与周边玩家有关系的玩家的渲染信息.
MSG_CG_GUILD_ADD_INFO_ACK msgAddInfo;
msgAddInfo.m_AddInfo.m_GuildGuid = pMsg->m_GuildGuid;
GuildSmallContentEntry::RelationSystem::LoadRelationInfo(&msgAddInfo.m_AddInfo);
msgAddInfo.m_byRelCnt = msgAddInfo.m_AddInfo.m_byRelationGuildCnt;
pTargetPlayer->SendPacket(&msgAddInfo, msgAddInfo.GetSize());
// 加入公会后周边玩家加入公会的最低信息
// （公会名称、公会标志、公会标志边框、公会等级）.
pTargetPlayer->FirstGuildMemberEnter();
// 加入公会的人需要公会信息时，自动按G将相关信息申请包从Clara发送.
MSG_CG_GUILD_JOIN_CMD cmdMsg;
cmdMsg.m_GuildGuid = pMsg->m_GuildGuid;
pTargetPlayer->SendPacket(&cmdMsg, sizeof(cmdMsg));
// 队伍中的时候受到邀请时，队伍成员中现在加入的公会和
//如果存在敌对关系的公会成员，将退出队伍.
WORD PartyKey = pTargetPlayer->GetPartyState().GetPartyKey();
BOOL bIsExistHostilityMember = FALSE;
bIsExistHostilityMember = NewGamePartyManager::Instance()->IsExistHostilityMember(PartyKey, pTargetPlayer->GetGuildGuid());
if (bIsExistHostilityMember)
{
MSG_AG_PARTY_LEAVE_BY_GUILDRELATION_SYN msg;
msg.m_dwMemberKey = pTargetPlayer->GetObjectKey();
msg.m_wPartykey = PartyKey;
msg.m_bReason = eREASON_LEAVE_PARTY_BY_GUILDRELATION;
g_pGameServer->SendToServer(AGENT_SERVER, &msg, sizeof(msg));
}
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
g_GameGuildManager.ApplyGuildFacilityPassive(pTargetPlayer, true);
g_GameGuildManager.SendGuildFacilityTotalInfo(pTargetPlayer, pMsg->m_GuildGuid);
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
#ifdef _NA_008334_20150608_SONNENSCHEIN
pGuild->ApplyGuildRewardOption(pTargetPlayer);
#else
GameDominationManager::Instance()->ApplyAllRewardOption(pTargetPlayer); // 适用公会加入奖励选项
#endif //_NA_008334_20150608_SONNENSCHEIN
GameDominationManager::Instance()->SendAreaInfoToPlayer(pTargetPlayer);
#ifdef _NA_006088_20120910_CHAOS_ZONE_FREE_PVP
// 在卡奥斯约翰内部加入公会时解除印章效果..
if (pTargetPlayer->GetGameZonePtr()->GetZoneType() == eZONETYPE_INSTANCE)
{
GameInstanceDungeon* const instance_dungeon = \
static_cast<GameInstanceDungeon*>(pTargetPlayer->GetGameZonePtr());
if (instance_dungeon->GetTypeOfIndun() == INDUN_KIND_CHAOS_ZONE)
{
#ifdef _NA_008334_20150608_SONNENSCHEIN
pGuild->ApplyGuildRewardOption(pTargetPlayer, FALSE);
#else
GameDominationManager::Instance()->ApplyAllRewardOption(pTargetPlayer, false);
#endif //_NA_008334_20150608_SONNENSCHEIN
GameDominationManager::Instance()->SendAreaInfoToPlayer(pTargetPlayer, false);
}
}
#endif // _NA_006088_20120910_CHAOS_ZONE_FREE_PVP
GameField* pField = pTargetPlayer->GetField();
if (NULL != pField)
{
const FIELDCODE fCode = pField->GetFieldCode();
GameDominationManager::Instance()->ApplyRewardField(pTargetPlayer, fCode);
}
}
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
else
{
RC::eGUILD_RESULT rc = g_GameGuildManager.JoinGuild(pMsg->m_GuildGuid, pMsg->m_MemberInfo);
if (rc != RC::RC_GUILD_SUCCESS)
{
SUNLOG(eCRITICAL_LOG, "Handler_GZ_GUILD_IMPL(GZ_GUILD_JOIN_ACK) 失败, rc = %d", rc);
return;
}
}
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
//告诉公会成员加入了.（这次加入的人不发送.）
MSG_CG_GUILD_JOIN_BRD brdMsg;
brdMsg.m_MemberInfo = pMsg->m_MemberInfo;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg), pMsg->m_MemberInfo.m_CharGuid);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_WITHDRAW_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_WITHDRAW_BRD * pMsg = (MSG_GZ_GUILD_WITHDRAW_BRD *)pRecvMsg;
g_GameGuildManager.LeaveGuild(pMsg->m_GuildGuid, pMsg->m_CharGuid);
CHARGUID TargetGuid = 0;
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
g_GameGuildManager.ApplyGuildFacilityPassive(pPlayer, false);
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
#ifdef _NA_008334_20150608_SONNENSCHEIN
GameGuild* player_guild = pPlayer->GetGuild();
if (player_guild != NULL) {
player_guild->ApplyGuildRewardOption(pPlayer, FALSE);
}
#else
GameDominationManager::Instance()->ApplyAllRewardOption(pPlayer, false); // 删除公会退出奖励选项
#endif //_NA_008334_20150608_SONNENSCHEIN
#ifdef _NA004034_20120102_GUILD_POINT_SYSTEM
// 删除捐献的公会硬币
PointWalletManager* const pointwallet_manager = pPlayer->GetPointWalletManager();
const DWORD code = CURRENCY_INFO_DONATION_GUILDCOIN;
INT donation_coin = pointwallet_manager->GetPointWallet(code);
if (donation_coin > 0) {
pointwallet_manager->ChangeWalletPoint(code, -donation_coin);
}
#endif //_NA004034_20120102_GUILD_POINT_SYSTEM
GameField* pField = pPlayer->GetField();
if (NULL != pField)
{
const FIELDCODE fCode = pField->GetFieldCode();
GameDominationManager::Instance()->ApplyRewardField(pPlayer, fCode, false);
}
pPlayer->GetCharInfo()->m_GuildGuid = 0;
pPlayer->GetCharInfo()->m_eGuildDuty = (eGUILD_DUTY)0;
pPlayer->GetCharInfo()->m_GuildPenaltyTime = pMsg->m_MemberPenaltyTime;
pPlayer->GetCharInfo()->m_ePenaltyType = eGUILD_WITHDRAW;
TargetGuid = pPlayer->GetCharGuid();
// 已退出行会，通知当事人.
MSG_CG_GUILD_WITHDRAW_ACK msgACK;
msgACK.m_byPenaltyType = pMsg->m_byPenaltyType;
pPlayer->SendPacket(&msgACK, sizeof(msgACK));
//AgentServer的该玩家的GuildGuid必须为0.
MSG_AG_GUILD_WITHDRAW_ACK ACK;
pPlayer->SendPacket(&ACK, sizeof(ACK));
//因为Render情报被强退的家伙周围。
MSG_CG_GUILD_LEAVE_BRD brdMsg;
brdMsg.m_LeaverObjectKey = pPlayer->GetObjectKey();
pPlayer->SendPacketAround(&brdMsg, sizeof(brdMsg), FALSE);
}
//向该公会成员告知成员已退出.
MSG_CG_GUILD_WITHDRAW_BRD msgBRD;
_tcsncpy(
msgBRD.m_szCharName,
pMsg->m_szCharName,
_countof(msgBRD.m_szCharName)
);
msgBRD.m_byPenaltyType = pMsg->m_byPenaltyType;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &msgBRD, sizeof(msgBRD), TargetGuid);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CREATE_ACK * pMsg = (MSG_GZ_GUILD_CREATE_ACK *)pRecvMsg;
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
SunRankingManager::Instance()->SetGuildGuid(pMsg->m_dwKey, pMsg->m_GameGuildInfo.m_GuildGuid);
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
// ack来之前出去的话？？会怎么样呢？不花钱就生成。
//提前扣除资金
// ack来之前出去也会在Guild或DB中储存相关信息，再次登录时可以获得正常信息.
RC::eGUILD_RESULT rc = g_GameGuildManager.CreateGuild(pPlayer, pMsg->m_GameGuildInfo, pMsg->m_BaseMemberInfo);
if (rc != RC::RC_GUILD_SUCCESS)
{
MSG_CG_GUILD_CREATE_NAK msg;
msg.m_byErrorCode = rc;
pPlayer->SendPacket(&msg, sizeof(msg));
SUNLOG(eCRITICAL_LOG, "[Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_ACK)] 失败, Guid = %u, rc = %d", pMsg->m_GameGuildInfo.m_GuildGuid, rc);
return;
}
// 代理提示：只通知guild guid信息
MSG_AG_GUILD_CREATE_ACK msg;
msg.m_GuildGuid = pMsg->m_GameGuildInfo.m_GuildGuid;
pPlayer->SendPacket(&msg, sizeof(msg));
// 本来是AgentServer发过来的（虽然更准确，但是为了让人明确处理，GUILD相关的分组就不要在AGENT处理了。）
MSG_CG_GUILD_CREATE_ACK msgACK;
msgACK.m_GuildGuid = pMsg->m_GameGuildInfo.m_GuildGuid;
pPlayer->SendPacket(&msgACK, sizeof(msgACK));
MSG_CG_GUILD_CREATE_BRD bmsg;
bmsg.m_MasterPlayerKey = pPlayer->GetObjectKey();
memcpy(bmsg.m_tszGuildName, pPlayer->GetCharInfo()->m_tszGuildName, MAX_GUILDNAME_LENGTH*sizeof(TCHAR));
pPlayer->SendPacketAround(&bmsg, sizeof(bmsg), FALSE);
//在游戏服务器上创建行会后，请求公会设施信息
MSG_GZ_GUILD_FACILITY_SELECT_SYN facility_msg;
facility_msg.guild_guid = pMsg->m_GameGuildInfo.m_GuildGuid;
pPlayer->SendToGuildServer(&facility_msg, sizeof(facility_msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CREATE_NAK * pMsg = (MSG_GZ_GUILD_CREATE_NAK *)pRecvMsg;
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
//带来最初生成的公会信息.
const GuildRankInfo* pGuildInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo(1);
if (!pGuildInfo) return;
#ifdef _NA_003923_20120130_GUILD_RENEWAL
MONEY return_heim = GuildInfoParser::Instance()->GetGuildInfo().guild_create_heim_;
#else
MONEY return_heim = pGuildInfo->m_dwHeim;
#endif
pPlayer->PlusMoney(return_heim);
MSG_CG_GUILD_CREATE_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
}
// 因为已经收到了公会情报
// 查询公会信息后交给客户即可.
Handler_GZ_GUILD_IMPL(GZ_GUILD_SELECT_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_SELECT_ACK * pMsg = (MSG_GZ_GUILD_SELECT_ACK *)pRecvMsg;
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
GameGuild * pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
ASSERT(pGuild); if (!pGuild) return;
}
//------------------------------------------------------------------------------------------------------
// NAK
//------------------------------------------------------------------------------------------------------
// 公会服务器没有立即获取公会信息。
//客户端输出合适的信息.
Handler_GZ_GUILD_IMPL(GZ_GUILD_SELECT_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_SELECT_NAK* pMsg = (MSG_GZ_GUILD_SELECT_NAK *)pRecvMsg;
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_JOIN_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_JOIN_NAK * pMsg = (MSG_GZ_GUILD_JOIN_NAK *)pRecvMsg;
Player* pOperPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pOperPlayer)
{
//加入公会失败的话，要加入的人和想要加入的人都要发送.
MSG_CG_GUILD_JOIN_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pOperPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Player* pTargetPlayer = PlayerManager::Instance()->FindPlayerByName(pMsg->m_szTargetCharName);
if (pTargetPlayer)
{
MSG_CG_GUILD_JOIN_FAILED_CMD cmdMsg;
cmdMsg.m_byErrorCode = pMsg->m_byErrorCode;
pTargetPlayer->SendPacket(&cmdMsg, sizeof(cmdMsg));
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_WITHDRAW_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_WITHDRAW_NAK * pMsg = (MSG_GZ_GUILD_WITHDRAW_NAK *)pRecvMsg;
Player * pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_WITHDRAW_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_KICKPLAYER_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_KICKPLAYER_NAK *pMsg = (MSG_GZ_GUILD_KICKPLAYER_NAK *)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
MSG_CG_GUILD_KICKPLAYER_NAK msg;
msg.m_dwKey = pMsg->m_dwKey;
_tcsncpy(
msg.m_ptszKickCharName,
pMsg->m_ptszCharName,
_countof(msg.m_ptszKickCharName)
);
msg.m_ptszKickCharName[_countof(msg.m_ptszKickCharName) - 1] = '\0';
msg.m_dwErrorCode = pMsg->m_dwErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
}
}
// 变更公会公告
// 向公会献上UP
Handler_GZ_GUILD_IMPL(GZ_GUILD_DONATE_UP_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DONATE_UP_BRD* pMsg = (MSG_GZ_GUILD_DONATE_UP_BRD*)pRecvMsg;
// 有该玩家时告知成功
CHARGUID TargetGuid = 0;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
// 必须从持有的指针中删除!!
UPTYPE UpPoint = pPlayer->GetCharInfo()->m_UserPoint;
if (UpPoint >= pMsg->m_DonateUP)
pPlayer->GetCharInfo()->m_UserPoint = UpPoint - pMsg->m_DonateUP;
else
SUNLOG(eCRITICAL_LOG, "[GZ_GUILD_DONATE_UP_BRD] 错误!![CharGuid:%u][DonateUP:%u]", pPlayer->GetCharGuid(), pMsg->m_DonateUP);
TargetGuid = pPlayer->GetCharGuid();
MSG_CG_GUILD_DONATE_UP_ACK msg;
msg.m_RemainUP = pPlayer->GetCharInfo()->m_UserPoint;
msg.m_GuildUP = pMsg->m_TotalUP;
pPlayer->SendPacket(&msg, sizeof(msg));
}
if (!g_GameGuildManager.FindGuild(pMsg->m_GuildGuid))
{
SUNLOG(eCRITICAL_LOG, "[GZ_GUILD_DONATE_UP_BRD] 未找到相应公会 [GuildGuid:%u]", pMsg->m_GuildGuid);
return;
}
MSG_CG_GUILD_DONATE_UP_BRD brdMsg;
brdMsg.m_GuildUP = pMsg->m_TotalUP;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg), TargetGuid);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_DONATE_UP_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DONATE_UP_NAK* pMsg = (MSG_GZ_GUILD_DONATE_UP_NAK*)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
MSG_CG_GUILD_DONATE_UP_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
}
MessageOut(eFULL_LOG, "GZ_GUILD_DONATE_UP_NAK[UserKey:%u]", pRecvMsg->m_dwKey);
}
// 转换为UP->GP
Handler_GZ_GUILD_IMPL(GZ_GUILD_CONVERT_UP2GP_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CONVERT_UP2GP_BRD* pMsg = (MSG_GZ_GUILD_CONVERT_UP2GP_BRD*)pRecvMsg;
CHARGUID TargetGuid = 0;
// 有该玩家时告知成功
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
MSG_CG_GUILD_CONVERT_UP2GP_ACK msg;
msg.m_RemainUP = pMsg->m_RemainUP;
msg.m_NowGP = pMsg->m_TotalGP;
pPlayer->SendPacket(&msg, sizeof(msg));
TargetGuid = pPlayer->GetCharGuid();
}
// 当前游戏服务器上存在该帮派时发送分组.
if (!g_GameGuildManager.FindGuild(pMsg->m_GuildGuid))
return;
MSG_CG_GUILD_CONVERT_UP2GP_BRD msg;
msg.m_RemainUP = pMsg->m_RemainUP;
msg.m_NowGP = pMsg->m_TotalGP;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &msg, sizeof(msg), TargetGuid);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CONVERT_UP2GP_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CONVERT_UP2GP_NAK* pMsg = (MSG_GZ_GUILD_CONVERT_UP2GP_NAK*)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
MSG_CG_GUILD_CONVERT_UP2GP_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
}
MessageOut(eFULL_LOG, "GZ_GUILD_CONVERT_UP2GP_NAK[UserKey:%u][ErrorCode:%u]", pRecvMsg->m_dwKey, pMsg->m_byErrorCode);
}
// 公会排名上升
Handler_GZ_GUILD_IMPL(GZ_GUILD_RANKUP_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_RANKUP_BRD* pMsg = (MSG_GZ_GUILD_RANKUP_BRD*)pRecvMsg;
CHARGUID OperCharGuid = 0;
g_GameGuildManager.RankUpGuild(pMsg->m_GuildGuid, pMsg->m_byLevel);
#if !defined(_NA004034_20120102_GUILD_POINT_SYSTEM)
// 有该玩家时告知成功
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
MSG_CG_GUILD_RANKUP_ACK msg;
msg.m_byNowLevel = pMsg->m_byLevel;
msg.m_RemainGP = pMsg->m_RemainGP;
msg.m_RemainUP = pMsg->m_RemainUP;
msg.m_RemainMoney = pPlayer->GetMoney();
pPlayer->SendPacket(&msg, sizeof(msg));
OperCharGuid = pPlayer->GetCharGuid();
}
#endif //_NA004034_20120102_GUILD_POINT_SYSTEM
MSG_CG_GUILD_RANKUP_BRD brdMsg;
brdMsg.m_byNowLevel = pMsg->m_byLevel;
brdMsg.m_RemainGP = pMsg->m_RemainGP;
brdMsg.m_RemainUP = pMsg->m_RemainUP;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg), OperCharGuid);
}
#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHUNTING_PVP_RESULT_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHUNTING_PVP_RESULT_BRD * pMsg = (MSG_GZ_GUILD_CHUNTING_PVP_RESULT_BRD *)pRecvMsg;
g_GameGuildManager.SetChuntingPVPInfo(pMsg->m_GuildGuid, pMsg->m_PVPInfo);
}
#endif
//公会职责
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_DUTY_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_DUTY_BRD *pMsg = (MSG_GZ_GUILD_CHANGE_DUTY_BRD *)pRecvMsg;
// 现在成为目标的成员有可能会登录也有可能没有。
// 因此，如果现在Player经纪人无法用名字搜索，那么现在游戏服务器上没有相应的目标成员。
//当然游戏公会也没有击球员。（必须不存在。）
Player* pTargetPlayer = PlayerManager::Instance()->FindPlayerByName(pMsg->m_szTargetCharName);
if (pTargetPlayer)
{
// 当前游戏服务器上有行会将更改相关信息.
g_GameGuildManager.ChangeMemberDuty(pMsg->m_GuildGuid, pTargetPlayer->GetCharGuid(), (eGUILD_DUTY)pMsg->m_byDuty);
}
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGuild) return;
MSG_CG_GUILD_CHANGE_DUTY_BRD brdMsg;
brdMsg.m_byDuty = pMsg->m_byDuty;
_tcsncpy(
brdMsg.m_szTargetCharName,
pMsg->m_szTargetCharName,
_countof(brdMsg.m_szTargetCharName)
);
brdMsg.m_szTargetCharName[_countof(brdMsg.m_szTargetCharName) - 1] = '\0';
pGuild->SendPacketAll(&brdMsg, sizeof(brdMsg));
/* 确认客户端未处理并进行注释处理
Player* pOperPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if( pOperPlayer )
{
MSG_CG_GUILD_CHANGE_DUTY_ACK Ack;
Ack.m_byDuty = pMsg->m_byDuty;
strncpy( Ack.m_szTargetCharName, pMsg->m_szTargetCharName, MAX_CHARNAME_LENGTH );
pOperPlayer->SendPacket( &Ack, sizeof(Ack) );
}
*/
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_DUTY_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_DUTY_NAK *pMsg = (MSG_GZ_GUILD_CHANGE_DUTY_NAK *)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_CHANGE_DUTY_NAK Nak;
Nak.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&Nak, sizeof(Nak));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RIGHT_DELEGATION_LIST_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_RIGHT_DELEGATION_LIST_ACK *pMsg = (MSG_GZ_GUILD_RIGHT_DELEGATION_LIST_ACK *)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_RIGHT_DELEGATION_LIST_ACK Ack;
_tcsncpy(
Ack.m_szTargetCharName,
pMsg->m_szTargetCharName,
_countof(Ack.m_szTargetCharName)
);
Ack.m_szTargetCharName[_countof(Ack.m_szTargetCharName) - 1] = '\0';
CopyMemory(Ack.m_DelegateRight, pMsg->m_DelegateRight, sizeof(Ack.m_DelegateRight));
pPlayer->SendPacket(&Ack, sizeof(Ack));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RIGHT_DELEGATION_LIST_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_RIGHT_DELEGATION_LIST_NAK *pMsg = (MSG_GZ_GUILD_RIGHT_DELEGATION_LIST_NAK *)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_RIGHT_DELEGATION_LIST_NAK Nak;
Nak.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&Nak, sizeof(Nak));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RIGHT_DELEGATION_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_RIGHT_DELEGATION_BRD* pMsg = (MSG_GZ_GUILD_RIGHT_DELEGATION_BRD*)pRecvMsg;
Player* pOperPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pOperPlayer)
{
MSG_CG_GUILD_RIGHT_DELEGATION_ACK Ack;
_tcsncpy(
Ack.m_szTargetCharName,
pMsg->m_szTargetCharName,
_countof(Ack.m_szTargetCharName)
);
Ack.m_szTargetCharName[_countof(Ack.m_szTargetCharName) - 1] = '\0';
pOperPlayer->SendPacket(&Ack, sizeof(Ack));
}
Player* pTargetPlayer = PlayerManager::Instance()->FindPlayerByName(pMsg->m_szTargetCharName);
if (pTargetPlayer)
{
MSG_CG_GUILD_RIGHT_DELEGATION_CMD cmdMsg;
pTargetPlayer->SendPacket(&cmdMsg, sizeof(cmdMsg));
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RIGHT_DELEGATION_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_RIGHT_DELEGATION_NAK* pMsg = (MSG_GZ_GUILD_RIGHT_DELEGATION_NAK*)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_RIGHT_DELEGATION_NAK Nak;
Nak.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&Nak, sizeof(Nak));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_MASTER_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
//收到这个包的游戏服务器不管有没有该玩家..。必须设置该公会信息.
MSG_GZ_GUILD_CHANGE_MASTER_BRD* pMsg = (MSG_GZ_GUILD_CHANGE_MASTER_BRD*)pRecvMsg;
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (pGuild)
{
g_GameGuildManager.ChangeMaster(pMsg->m_GuildGuid, pMsg->m_OldMasterCharGuid, pMsg->m_NewMasterCharGuid);
MSG_CG_GUILD_CHANGE_MASTER_BRD brdMsg;
_tcsncpy(
brdMsg.m_szOldMasterName,
pMsg->m_szOldMasterCharName,
_countof(brdMsg.m_szOldMasterName)
);
brdMsg.m_szOldMasterName[_countof(brdMsg.m_szOldMasterName) - 1] = '\0';
_tcsncpy(
brdMsg.m_szNewMasterName,
pMsg->m_szNewMasterCharName,
_countof(brdMsg.m_szNewMasterName)
);
brdMsg.m_szNewMasterName[_countof(brdMsg.m_szNewMasterName) - 1] = '\0';
pGuild->SendPacketAll(&brdMsg, sizeof(brdMsg));
GameDominationManager::Instance()->ChangeGuildMaster(pMsg->m_GuildGuid, pMsg->m_szNewMasterCharName);
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_MASTER_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_MASTER_NAK* pMsg = (MSG_GZ_GUILD_CHANGE_MASTER_NAK*)pRecvMsg;
Player *pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_CHANGE_MASTER_NAK Nak;
Nak.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&Nak, sizeof(Nak));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_EMPTY_COMMANDER_INFO_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_EMPTY_COMMANDER_INFO_ACK* pMsg = (MSG_GZ_GUILD_EMPTY_COMMANDER_INFO_ACK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_EMPTY_COMMANDER_INFO_ACK AckMsg;
AckMsg.m_byEmptyCommanderCount = pMsg->m_byEmptyCommanderCount;
CopyMemory(AckMsg.m_byCorpsNum, pMsg->m_byCorpsNum, sizeof(BYTE)*MAX_GUILD_CORPS_NUM);
pPlayer->SendPacket(&AckMsg, AckMsg.GetSize());
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_EMPTY_COMMANDER_INFO_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_EMPTY_COMMANDER_INFO_NAK* pMsg = (MSG_GZ_GUILD_EMPTY_COMMANDER_INFO_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_EMPTY_COMMANDER_INFO_NAK NakMsg;
NakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&NakMsg, sizeof(NakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_CORPS_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CREATE_CORPS_BRD* pMsg = (MSG_GZ_GUILD_CREATE_CORPS_BRD*)pRecvMsg;
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGuild)
{
SUNLOG(eCRITICAL_LOG, "[Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_CORPS_BRD)] 不存在的公会, Guid = %d", pMsg->m_GuildGuid);
return;
}
Player* pTarget = PlayerManager::Instance()->FindPlayerByName(pMsg->m_szTargetCharName);
if (pTarget)
{
//游戏服务器目前正在连接游戏服务器，只有成员的信息。
//因此，改变新军长的职责和军团号码。
//在游戏服务器上无法用CharGuid搜索Player。因此，将名字带到包里.
g_GameGuildManager.ChangeCommander(pMsg->m_GuildGuid, pTarget->GetCharGuid(), pMsg->m_byCorpsNum);
}
MSG_CG_GUILD_CREATE_CORPS_BRD brdMsg;
brdMsg.m_byCorpsNum = pMsg->m_byCorpsNum;
_tcsncpy(
brdMsg.m_szTargetCharName,
pMsg->m_szTargetCharName,
_countof(brdMsg.m_szTargetCharName)
);
// NOTE: cg消息不是以null结尾的.
pGuild->SendPacketAll(&brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_CORPS_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CREATE_CORPS_NAK* pMsg = (MSG_GZ_GUILD_CREATE_CORPS_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_CREATE_CORPS_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_CORPS_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DESTROY_CORPS_BRD* pMsg = (MSG_GZ_GUILD_DESTROY_CORPS_BRD*)pRecvMsg;
// 告诉全公会成员.
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGuild)
{
SUNLOG(eCRITICAL_LOG, "[Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_CORPS_BRD)] 不存在的公会, Guid = %d", pMsg->m_GuildGuid);
return;
}
//游戏服务器不管理军团信息，只管理培养营地.
pGuild->DestroyRearCamp(pMsg->m_byCorpsNum);
MSG_CG_GUILD_DESTROY_CORPS_BRD brdMsg;
brdMsg.m_byCorpsNum = pMsg->m_byCorpsNum;
pGuild->SendPacketAll(&brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_CORPS_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DESTROY_CORPS_NAK* pMsg = (MSG_GZ_GUILD_DESTROY_CORPS_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_DESTROY_CORPS_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_COMMANDER_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_COMMANDER_BRD* pMsg = (MSG_GZ_GUILD_CHANGE_COMMANDER_BRD*)pRecvMsg;
//** 下达命令的人的游戏服务器和成为军团长的游戏服务器有不同的情况。.
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGuild) return;
// NOTE: f110502.4L, 修正了一个问题，没有找到玩家如果全名公会.
Player* pTarget = PlayerManager::Instance()->FindPlayerByName(pMsg->m_szTargetCharName);
if (pTarget)
{
//游戏服务器目前正在连接游戏服务器，只有成员的信息。
//因此，改变新军长的职责和军团号码。
//在游戏服务器上无法用CharGuid搜索Player。因此，将名字带到包里.
g_GameGuildManager.ChangeCommander(pMsg->m_GuildGuid, pTarget->GetCharGuid(), pMsg->m_byCorpsNum);
}
MSG_CG_GUILD_CHANGE_COMMANDER_BRD brdMsg;
brdMsg.m_byCorpsNum = pMsg->m_byCorpsNum;
_tcsncpy(
brdMsg.m_szTargetCharName,
pMsg->m_szTargetCharName,
_countof(brdMsg.m_szTargetCharName)
);
pGuild->SendPacketAll(&brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_COMMANDER_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_COMMANDER_NAK* pMsg = (MSG_GZ_GUILD_CHANGE_COMMANDER_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_CHANGE_COMMANDER_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_CORPS_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_CORPS_BRD* pMsg = (MSG_GZ_GUILD_CHANGE_CORPS_BRD*)pRecvMsg;
g_GameGuildManager.ChangeCorps(pMsg->m_GuildGuid, pMsg->m_TargetCharGuid, pMsg->m_byCorpsNum);
MSG_CG_GUILD_CHANGE_CORPS_BRD brdMsg;
brdMsg.m_byCorpsNum = pMsg->m_byCorpsNum;
_tcsncpy(
brdMsg.m_szTargetCharName,
pMsg->m_szTargetCharName,
_countof(brdMsg.m_szTargetCharName)
);
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_CORPS_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_CORPS_NAK* pMsg = (MSG_GZ_GUILD_CHANGE_CORPS_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_CHANGE_CORPS_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_REAR_CAMP_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CREATE_REAR_CAMP_BRD* pMsg = (MSG_GZ_GUILD_CREATE_REAR_CAMP_BRD*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
//改变所有游戏服务器的相应公会军团训练营地状态.
g_GameGuildManager.CreateRearCamp(pMsg->m_GuildGuid, pMsg->m_byCorpsNum);
MSG_CG_GUILD_CREATE_REAR_CAMP_BRD brdMsg;
brdMsg.m_byCorpsNum = pMsg->m_byCorpsNum;
_tcsncpy(
brdMsg.m_szTargetCharName,
pMsg->m_szTargetCharName,
_countof(brdMsg.m_szTargetCharName)
);
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CREATE_REAR_CAMP_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CREATE_REAR_CAMP_NAK* pMsg = (MSG_GZ_GUILD_CREATE_REAR_CAMP_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_CREATE_REAR_CAMP_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_REAR_CAMP_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DESTROY_REAR_CAMP_BRD* pMsg = (MSG_GZ_GUILD_DESTROY_REAR_CAMP_BRD*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
//改变所有游戏服务器的该公会军团的训练卡组状态.
g_GameGuildManager.DestroyRearCamp(pMsg->m_GuildGuid, pMsg->m_byCorpsNum);
MSG_CG_GUILD_DESTROY_REAR_CAMP_BRD brdMsg;
brdMsg.m_byCorpsNum = pMsg->m_byCorpsNum;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_REAR_CAMP_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_DESTROY_REAR_CAMP_NAK* pMsg = (MSG_GZ_GUILD_DESTROY_REAR_CAMP_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_DESTROY_REAR_CAMP_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_INVITE_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_INVITE_ACK* recv_msg = (MSG_GZ_GUILD_INVITE_ACK*)pRecvMsg;
Player* request_player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
if (request_player == NULL)
{
return;
}
Player* target_player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_TargetUserKey);
if (target_player == NULL)
{
MSG_CG_GUILD_INVITE_NAK nak_msg;
nak_msg.m_byErrorCode = RC::RC_GUILD_FAILED;
request_player->SendPacket(&nak_msg, sizeof(nak_msg));
return;
}
//发送邀请包.
MSG_CG_GUILD_INVITE_CMD cmd_msg;
_tcsncpy(
cmd_msg.m_OperCharName,
request_player->GetCharName(),
_countof(cmd_msg.m_OperCharName)
);
#ifdef _NA_003923_20120130_GUILD_RENEWAL
GUILD_RENDER_INFO guild_render_info;
if (request_player->GetGuildRenderInfo(&guild_render_info, request_player->GetGuildGuid()))
{
_tcsncpy(
cmd_msg.m_OperGuildName,
guild_render_info.m_tszGuildName,
_countof(cmd_msg.m_OperGuildName)
);
cmd_msg.m_OperGuildName[_countof(cmd_msg.m_OperGuildName) - 1] = '\0';
}
else
{
cmd_msg.m_OperCharName[0] = '\0';
}
#endif
cmd_msg.m_OperUserKey = request_player->GetUserKey();
target_player->SendPacket(&cmd_msg, sizeof(cmd_msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_INVITE_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_INVITE_NAK* pMsg = (MSG_GZ_GUILD_INVITE_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_INVITE_NAK nak;
nak.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nak, sizeof(nak));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_LOGIN_CHAR_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
// 登录成功时在游戏服务器上要做的事情.。
//该玩家的行会存在时只追加成员，
//如果不存在，创建公会后增加成员.
MSG_GZ_GUILD_LOGIN_CHAR_BRD* pMsg = (MSG_GZ_GUILD_LOGIN_CHAR_BRD*)pRecvMsg;
// 只要是有登录成员的游戏服务器，就可以在公会设置成员信息.
CHARGUID TargetGuid = 0;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
if (g_GameGuildManager.LoginChar(pMsg->m_GuildInfo, pMsg->m_MemberInfo))
{
//如果没有下载公会信息，请在创建公会后申请相关信息
MSG_GZ_GUILD_RELATION_INFO_SYN msg;
msg.m_dwKey = pMsg->m_dwKey;
msg.m_GuildGuid = pMsg->m_GuildInfo.m_GuildGuid;
pPlayer->SendToGuildServer(&msg, sizeof(msg));
//__NA_0_20090720_GUILD_RENDER_INFO_MODIFY
//(lst1024)(090715)服务器驱动后首次登录时无公会信息。
//Enter时点找不到公会，创建公会后发送.
pPlayer->FirstGuildMemberEnter();
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
//在游戏服务器上创建行会后，请求公会设施信息
MSG_GZ_GUILD_FACILITY_SELECT_SYN facility_msg;
facility_msg.guild_guid = pMsg->m_GuildInfo.m_GuildGuid;
pPlayer->SendToGuildServer(&facility_msg, sizeof(facility_msg));
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
}
else
{
//如果已经存在公会信息，请向公会成员ADD后，回答ADDINFO..
MSG_CG_GUILD_ADD_INFO_ACK msg;
msg.m_AddInfo.m_GuildGuid = pMsg->m_GuildInfo.m_GuildGuid;
GuildSmallContentEntry::RelationSystem::LoadRelationInfo(&msg.m_AddInfo);
msg.m_byRelCnt = msg.m_AddInfo.m_byRelationGuildCnt;
pPlayer->SendPacket(&msg, sizeof(msg));
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
g_GameGuildManager.SendGuildFacilityTotalInfo(pPlayer, pMsg->m_GuildInfo.m_GuildGuid);
#endif //_NA_007330_20140620_GUILD_SYSTEM_EXTENSION
}
TargetGuid = pPlayer->GetCharGuid();
MSG_CG_GUILD_LOGIN_CHAR_CMD cmdMsg;
cmdMsg.m_GuildInfo = pMsg->m_GuildInfo;
cmdMsg.m_CorpsTotalInfo = pMsg->m_CorpsTotalInfo;
cmdMsg.m_MemberInfo = pMsg->m_MemberInfo;
pPlayer->SendPacket(&cmdMsg, sizeof(cmdMsg));
//_NA_0_20100208_DOMINATION_AREA_INFO
GameDominationManager::Instance()->SendAreaInfoToPlayer(pPlayer);
}
//检查当前游戏服务器是否存在该行会.
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildInfo.m_GuildGuid);
if (!pGuild) return;
// 将该玩家登录的消息告知现在的公会成员.
MSG_CG_GUILD_LOGIN_CHAR_BRD brdMsg;
_tcsncpy(
brdMsg.m_szCharName,
pMsg->m_MemberInfo.m_tszCharName,
_countof(brdMsg.m_szCharName)
);
g_GameGuildManager.SendPacket(pMsg->m_GuildInfo.m_GuildGuid, &brdMsg, sizeof(brdMsg), TargetGuid);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_LOGIN_CHAR_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_LOGIN_CHAR_NAK* pMsg = (MSG_GZ_GUILD_LOGIN_CHAR_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
//登录失败时在游戏服务器上要做的事情..
SUNLOG(eCRITICAL_LOG, "[Handler_GZ_GUILD_IMPL(GZ_GUILD_LOGIN_CHAR_NAK)] 公会成员登录失败, 角色名 = %s", pPlayer->GetCharName());
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_LOGOUT_CHAR_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_LOGOUT_CHAR_BRD* pMsg = (MSG_GZ_GUILD_LOGOUT_CHAR_BRD*)pRecvMsg;
//检查当前游戏服务器是否存在该行会.
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGuild) return;
g_GameGuildManager.Logout(pMsg->m_GuildGuid, pMsg->m_CharGuid);
// 将该玩家登录的消息告知现在的公会成员.
MSG_CG_GUILD_LOGOUT_CHAR_BRD brdMsg;
_tcsncpy(brdMsg.m_szCharName, pMsg->m_szCharName, _countof(brdMsg.m_szCharName));
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHAR_LEVELUP_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHAR_LEVELUP_BRD* pMsg = (MSG_GZ_GUILD_CHAR_LEVELUP_BRD*)pRecvMsg;
//检查当前游戏服务器是否存在该行会.
GameGuild* pGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGuild) return;
MSG_CG_GUILD_CHAR_LEVELUP_BRD brdMsg;
_tcsncpy(brdMsg.m_szCharName, pMsg->m_szCharName, _countof(brdMsg.m_szCharName));
brdMsg.m_Level = pMsg->m_Level;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg));
}
// [7/24/2009 lst1024] Agent User信息更新时注意事项
//用户在角色选择窗口时
// Game Server的Player客体在生成或删除后，在Player Maager中找不到。
// Agent Server的User客体已经生成，可以用UserGUID找到。
//--无法通过CharName或CharGUID找到。-
// 修正：DZ GUILD KICKPLAYER DBR中DB结果需要强退UserGUID.
Handler_GZ_GUILD_IMPL(GZ_GUILD_KICKPLAYER_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_KICKPLAYER_BRD *pMsg = (MSG_GZ_GUILD_KICKPLAYER_BRD *)pRecvMsg;
// 除名
g_GameGuildManager.LeaveGuild(pMsg->m_GuildGuid, pMsg->m_CharGuid);
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer)
{
//在Agent的User信息中初始化公会相关信息.
MSG_AG_GUILD_KICKPLAYER_ACK msgACK;
msgACK.m_dwKey = pMsg->m_dwKey;
_tcsncpy(
msgACK.m_ptszCharName,
pMsg->m_ptszCharName,
_countof(msgACK.m_ptszCharName)
);
msgACK.m_ptszCharName[_countof(msgACK.m_ptszCharName) - 1] = '\0';
pPlayer->SendPacket(&msgACK, sizeof(msgACK));
}
Player* pKickedPlayer = PlayerManager::Instance()->FindPlayerByName(pMsg->m_ptszCharName);
if (pKickedPlayer)
{
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
g_GameGuildManager.ApplyGuildFacilityPassive(pKickedPlayer, false);
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
#ifdef _NA_008334_20150608_SONNENSCHEIN
GameGuild* player_guild = pKickedPlayer->GetGuild();
if (player_guild != NULL) {
player_guild->ApplyGuildRewardOption(pKickedPlayer, FALSE);
}
#else
GameDominationManager::Instance()->ApplyAllRewardOption(pKickedPlayer, false); // 删除公会退出奖励选项
#endif //_NA_008334_20150608_SONNENSCHEIN
#ifdef _NA004034_20120102_GUILD_POINT_SYSTEM
// 删除捐献的公会硬币
PointWalletManager* const pointwallet_manager = pKickedPlayer->GetPointWalletManager();
const DWORD code = CURRENCY_INFO_DONATION_GUILDCOIN;
INT donation_coin = pointwallet_manager->GetPointWallet(code);
if (donation_coin > 0) {
pointwallet_manager->ChangeWalletPoint(code, -donation_coin);
}
#endif //_NA004034_20120102_GUILD_POINT_SYSTEM
GameField* pField = pKickedPlayer->GetField();
if (NULL != pField)
{
const FIELDCODE fCode = pField->GetFieldCode();
GameDominationManager::Instance()->ApplyRewardField(pKickedPlayer, fCode, false);
}
pKickedPlayer->GetCharInfo()->m_GuildGuid = 0;
pKickedPlayer->GetCharInfo()->m_eGuildDuty = (eGUILD_DUTY)0;
pKickedPlayer->GetCharInfo()->m_GuildPenaltyTime = pMsg->m_MemberPenaltyTime;
pKickedPlayer->GetCharInfo()->m_ePenaltyType = eGUILD_KICK;
MSG_CG_GUILD_KICKPLAYER_CMD cmdMsg;
pKickedPlayer->SendPacket(&cmdMsg, sizeof(cmdMsg));
//因为Render情报被强退的家伙周围。
MSG_CG_GUILD_LEAVE_BRD brdMsg;
brdMsg.m_LeaverObjectKey = pKickedPlayer->GetObjectKey();
pKickedPlayer->SendPacketAround(&brdMsg, sizeof(brdMsg), FALSE);
}
// 通知当前游戏服务器的所有行会成员.
MSG_CG_GUILD_KICKPLAYER_BRD msgBRD;
_tcsncpy(
msgBRD.m_szCharName,
pMsg->m_ptszCharName,
_countof(msgBRD.m_szCharName)
);
msgBRD.m_szCharName[_countof(msgBRD.m_szCharName) - 1] = '\0';
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &msgBRD, sizeof(msgBRD), pMsg->m_CharGuid);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_TOTALINFO_REQ_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_TOTALINFO_REQ_ACK* pMsg = (MSG_GZ_GUILD_TOTALINFO_REQ_ACK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_TOTALINFO_REQ_ACK ackMsg;
ackMsg.m_GuildInfo = pMsg->m_GuildInfo;
ackMsg.m_CorpsTotalInfo = pMsg->m_CropsTotalInfo;
ackMsg.m_MemberTotalInfo = pMsg->m_MemberTotalInfo;
#ifdef _NA004034_20120102_GUILD_POINT_SYSTEM
memcpy(&ackMsg.guild_info_extra_, &pMsg->guild_info_extra_, sizeof(pMsg->guild_info_extra_));
#endif //_NA004034_20120102_GUILD_POINT_SYSTEM
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
ackMsg.m_GuildJoinRequestTotalInfo = pMsg->m_GuildJoinRequestTotalInfo;
#endif //_NA_007330_20140620_GUILD_SYSTEM_EXTENSION
pPlayer->SendPacket(&ackMsg, ackMsg.GetSize());
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_TOTALINFO_REQ_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_TOTALINFO_REQ_NAK* pMsg = (MSG_GZ_GUILD_TOTALINFO_REQ_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_TOTALINFO_REQ_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_GM_GUILD_POINT_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_GM_GUILD_POINT_BRD* pMsg = (MSG_GZ_GUILD_GM_GUILD_POINT_BRD*)pRecvMsg;
MSG_CG_GUILD_GM_GUILD_POINT_BRD brdMsg;
brdMsg.m_GuildGuid = pMsg->m_GuildGuid;
brdMsg.m_UP = pMsg->m_UP;
brdMsg.m_GP = pMsg->m_GP;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_GM_GUILD_POINT_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_GM_GUILD_POINT_NAK* pMsg = (MSG_GZ_GUILD_GM_GUILD_POINT_NAK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer) return;
MSG_CG_GUILD_GM_GUILD_POINT_NAK nakMsg;
nakMsg.m_byErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&nakMsg, sizeof(nakMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_CHANGE_CHAOSTATE_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_CHANGE_CHAOSTATE_BRD* pMsg = (MSG_GZ_GUILD_CHANGE_CHAOSTATE_BRD*)pRecvMsg;
MSG_CG_GUILD_CHANGE_CHAOSTATE_BRD brdMsg;
_tcsncpy(brdMsg.m_szCharName, pMsg->m_szCharName, _countof(brdMsg.m_szCharName));
brdMsg.m_byChaoState = pMsg->m_byChaoState;
g_GameGuildManager.SendPacket(pMsg->m_GuildGuid, &brdMsg, sizeof(brdMsg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_ENTER_SERVER_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_ENTER_SERVER_ACK* pMsg = (MSG_GZ_GUILD_ENTER_SERVER_ACK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
if (pPlayer)
{
if (g_GameGuildManager.LoginChar(pMsg->m_GameGuildInfo, pMsg->m_BaseMemberInfo))
{
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
MSG_GZ_GUILD_FACILITY_SELECT_SYN facility_msg;
facility_msg.guild_guid = pMsg->m_GameGuildInfo.m_GuildGuid;
g_pGameServer->SendToServer(GAME_DBPROXY, &facility_msg, sizeof(facility_msg));
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
}
}
#else // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
if (pPlayer)
g_GameGuildManager.EnterServer(pMsg->m_GameGuildInfo, pMsg->m_BaseMemberInfo);
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_BOTH_RELATION_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_BOTH_RELATION_ACK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pPlayer, pMsg->m_dwKey);
GameGuild* pRequestGuild = g_GameGuildManager.FindGuild(pMsg->m_RequestGuildGuid);
if (!pRequestGuild) return;
GameGuild* pResponseGuild = g_GameGuildManager.FindGuild(pMsg->m_ResponseGuildGuid);
if (pResponseGuild)
{
GameGuildMember* pMember =
pResponseGuild->FindMember(pMsg->m_ResponsePlayerIndex);
if (pMember)
{
Player* pRelationRightPlayer =
PlayerManager::Instance()->FindPlayerByName(pMember->GetCharName());
if (pRelationRightPlayer)
{
MSG_CG_GUILD_RELATION_REQUEST_CMD msg;
msg.m_eType = pMsg->m_eRelationType;
msg.m_RequestUserKey = pPlayer->GetUserKey();
util::GUILDNAMECOPY(msg.m_RequestGuildName, pRequestGuild->GetGuildName());
pRelationRightPlayer->SendPacket(&msg, sizeof(msg));
return;
}
}
}
MSG_CG_GUILD_RELATION_NAK msgNAK;
msgNAK.m_byErrorCode = RC::RC_GUILD_CURRENT_NONE_MASTER;
pPlayer->SendPacket(&msgNAK, sizeof(msgNAK));
return;
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELATION_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RELATION_NAK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pRequestPlayer, pMsg->m_dwKey);
MSG_CG_GUILD_RELATION_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pRequestPlayer->SendPacket(&msg, sizeof(msg));
PLAYER_PTR_USERKEY(Player, pRelationMaster, pMsg->m_OtherGuildMasterUid);
pRelationMaster->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELATION_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RELATION_BRD, pMsg, pRecvMsg);
#ifdef _NA_003923_20120130_GUILD_RENEWAL
if (pMsg->m_eRelationType == eGUILD_RELATION_CANCEL_BOTH_HOSTILITY)
{
GuildSmallContentEntry::RelationSystem::RemoveRelation(
pMsg->m_GuildGuid,
pMsg->m_RelationGuildGuid,
pMsg->m_eRelationType
);
}
else
{
GuildSmallContentEntry::RelationSystem::AddRelation(
pMsg->m_GuildGuid,
pMsg->m_RelationGuildGuid,
pMsg->m_eRelationType,
pMsg->m_RelationApplyTime,
pMsg->m_RelationChangeTime,
pMsg->m_tszRelationGuildName,
pMsg->m_tszRequestGuildName
);
}
#else
GuildSmallContentEntry::RelationSystem::AddRelation(
pMsg->m_GuildGuid, pMsg->m_RelationGuildGuid,
pMsg->m_eRelationType, pMsg->m_tszRelationGuildName, pMsg->m_tszRequestGuildName);
#endif
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELATION_BOTH_AGAINST_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RELATION_BOTH_AGAINST_BRD, pMsg, pRecvMsg);
#ifdef _NA_003923_20120130_GUILD_RENEWAL
GuildSmallContentEntry::RelationSystem::AddRelation(
pMsg->m_GuildGuid,
pMsg->m_RelGuildGuid,
eGUILD_RELATION_BOTH_HOSTILITY,
pMsg->m_RelationApplyTime,
pMsg->m_RelationChangeTime,
"");
#else
GuildSmallContentEntry::RelationSystem::AddRelation(
pMsg->m_GuildGuid, pMsg->m_RelGuildGuid, eGUILD_RELATION_BOTH_HOSTILITY, "");
#endif
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELATION_DELETE_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RELATION_DELETE_BRD, pMsg, pRecvMsg);
GuildSmallContentEntry::RelationSystem::RemoveRelation(
pMsg->m_GuildGuid, pMsg->m_RelGuildGuid, pMsg->m_eType);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELATION_BOTH_AGAINST_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RELATION_BOTH_AGAINST_NAK, pMsg, pRecvMsg);
Player *pRequestPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pRequestPlayer)
{
MSG_CG_GUILD_RELATION_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pRequestPlayer->SendPacket(&msg, sizeof(msg));
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELATION_DELETE_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RELATION_DELETE_NAK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pRequestPlayer, pMsg->m_dwKey);
MSG_CG_GUILD_RELATION_DELETE_NAK msg;
msg.m_byErrorCode = pMsg->m_byErrorCode;
pRequestPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELATION_INFO_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RELATION_INFO_BRD, pMsg, pRecvMsg);
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
GuildSmallContentEntry::RelationSystem::SaveRelationInfo(&pMsg->m_AddInfo);
if (pPlayer)
{
MSG_CG_GUILD_ADD_INFO_ACK msg;
msg.m_AddInfo.m_GuildGuid = pMsg->m_AddInfo.m_GuildGuid;
GuildSmallContentEntry::RelationSystem::LoadRelationInfo(&msg.m_AddInfo);
msg.m_byRelCnt = msg.m_AddInfo.m_byRelationGuildCnt;
pPlayer->SendPacket(&msg, msg.GetSize());
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_WAIT_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_DESTROY_WAIT_BRD, receive_msg, pRecvMsg);
#ifdef _USING_GUILD_DESTROY_LOGGING
SUNLOG(eCRITICAL_LOG,
_T("|申请解散公会|Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_WAIT_BRD)|MSG_GZ_GUILD_DESTROY_WAIT_BRD 接收|Key:%u, GuildGuid:%d|"),
receive_msg->m_dwKey,
receive_msg->m_GuildGuid);
#endif // _USING_GUILD_DESTROY_LOGGING
Player* player = PlayerManager::Instance()->FindPlayerByUserKey(receive_msg->m_dwKey);
if (player != NULL)
{
MSG_CG_GUILD_DESTROY_WAIT_ACK msg;
msg.m_GuildGuid = receive_msg->m_GuildGuid;
#ifdef _USING_GUILD_DESTROY_LOGGING
SUNLOG(eCRITICAL_LOG,
_T("|申请解散公会|Handler_GZ_GUILD_IMPL(GZ_GUILD_DESTROY_WAIT_BRD)|MSG_CG_GUILD_DESTROY_WAIT_ACK 接收|GuildGuid:%d|"), msg.m_GuildGuid);
#endif // _USING_GUILD_DESTROY_LOGGING
player->SendPacket(&msg, sizeof(msg));
}
GuildSmallContentEntry::RelationSystem::RemainRelationDestroy(receive_msg->m_GuildGuid);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RECOVERY_GUILD_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RECOVERY_GUILD_BRD, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pPlayer, pMsg->m_dwKey);
MSG_CG_GUILD_RECOVERY_GUILD_ACK msg;
msg.m_GuildGuid = pMsg->m_GuildGuid;
pPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RECOVERY_GUILD_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_RECOVERY_GUILD_NAK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pPlayer, pMsg->m_dwKey);
MSG_CG_GUILD_RECOVERY_GUILD_NAK msg;
msg.m_byErrorCode = RC::RC_GUILD_RECOVERY_FAILED;
pPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_GUILDMARK_REGISTER_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_GUILDMARK_REGISTER_BRD, pMsg, pRecvMsg);
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
GuildSmallContentEntry::GuildMark::GuildMarkInfo info;
info.guild_Index = pMsg->m_GuildIndex;
info.pattern_index = pMsg->m_PatternIndex;
info.background_index = pMsg->m_BackGroundIndex;
info.posType = pMsg->m_SlotPos;
info.slot_Index = pMsg->m_SlotIdx;
GuildSmallContentEntry::GuildMark::RegisterMark(pPlayer, info);
GameDominationManager::Instance()->ChangeGuildMark(info.guild_Index, info.pattern_index, info.background_index);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_GUILDMARK_DELETE_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_GUILDMARK_DELETE_BRD, pMsg, pRecvMsg);
GuildSmallContentEntry::GuildMark::GuildMarkInfo info;
info.guild_Index = pMsg->m_GuildIndex;
info.pattern_index = pMsg->m_PatternIndex;
info.background_index = pMsg->m_BackGroundIndex;
GuildSmallContentEntry::GuildMark::DeleteMark(info);
GameDominationManager::Instance()->ChangeGuildMark(info.guild_Index, info.pattern_index, info.background_index);
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_GUILDMARK_REGISTER_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_GUILDMARK_REGISTER_NAK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pPlayer, pMsg->m_dwKey);
MSG_CG_GUILD_GUILDMARK_REGISTER_NAK msg;
msg.m_bErrorCode = pMsg->m_Result;
pPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_GUILDMARK_DELETE_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_GUILDMARK_DELETE_NAK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pPlayer, pMsg->m_dwKey);
MSG_CG_GUILD_GUILDMARK_DELETE_NAK msg;
msg.m_bErrorCode = pMsg->m_Result;
pPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_WAREHOUSE_OPEN_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_WAREHOUSE_OPEN_BRD, pMsg, pRecvMsg);
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (pPlayer && pPlayer->GetField())
{
CGuildWarehouseSlotContainer* pContainer = g_GameGuildManager.GetGuildWarehouse(pMsg->m_GuildGuid);
if (pContainer && pPlayer->GetGuildWarehouseContainer())
{
pContainer->OpenInit(pPlayer, pMsg->m_SlotTabNum, pMsg->m_WarehouseRight);
pContainer->SerializeItemInfo(pMsg->m_ItemInfo, SERIALIZE_STORE);
pContainer->SerializeMoney(pMsg->m_WarehouseMoney);
pContainer->OpenWarehouse();
MSG_CG_GUILD_WAREHOUSE_OPEN_ACK msg;
msg.m_SlotTabNum = pContainer->GetSlotTabNum();
msg.m_WarehouseMoney = pContainer->GetCurMoney();
msg.m_Size = sizeof(RENDER_ITEMSTREAMEX)*(MAX_GUILD_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());
SUNLOG(eDEV_LOG, "帮会仓库打开成功 char[%u] guild[%u]",
pMsg->m_OperCharGuid, pMsg->m_GuildGuid);
}
else
{
pContainer->ClearAll();
MSG_CG_GUILD_WAREHOUSE_OPEN_NAK msg;
msg.m_bErrorCode = RC::RC_GUILD_WAREHOUSE_GET_CANNOT_DB;
pPlayer->SendPacket(&msg, sizeof(msg));
SUNLOG(eCRITICAL_LOG, "帮会仓库打开失败 char[%u] guild[%u]",
pMsg->m_OperCharGuid, pMsg->m_GuildGuid);
}
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_WAREHOUSE_OPEN_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_WAREHOUSE_OPEN_NAK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pPlayer, pRecvMsg->m_dwKey);
CGuildWarehouseSlotContainer* pContainer = g_GameGuildManager.GetGuildWarehouse(pMsg->m_GuildGuid);
if (pContainer)
{
//pContainer->ClearAll();
}
else
{
SUNLOG(eCRITICAL_LOG, "GZ_GUILD_WAREHOUSE_OPEN_NAK 公会仓库错误[%u]", pMsg->m_GuildGuid);
}
MSG_CG_GUILD_WAREHOUSE_OPEN_NAK msg;
msg.m_bErrorCode = pMsg->m_bErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_NAME_CHANGE_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_NAME_CHANGE_ACK* pMsg = (MSG_GZ_GUILD_NAME_CHANGE_ACK*)pRecvMsg;
Player* pPlayer = PlayerManager::Instance()->FindPlayerByUserKey(pMsg->m_dwKey);
if (!pPlayer)
{
SUNLOG(eCRITICAL_LOG, "[GZ_GUILD_NAME_CHANGE_ACK] 删除物品失败");
return;
}
// 通知变更物品
SCSlotContainer* inventory = pPlayer->GetItemManager()->GetItemSlotContainer(SI_INVENTORY);
//_NA_0_20100901_GUILD_NAME_CHANGE_ITEM_LOG = {
const TCHAR* add_info = NULL;
SCItemSlot& item_slot = (SCItemSlot &)inventory->GetSlot(pMsg->m_TargetPos);
if (item_slot.GetItemInfo())
{
TCHAR buf[MAX_ADDINFO_SIZE];
_sntprintf(buf, MAX_ADDINFO_SIZE, "BGuildName:%s, AGuildName:%s, GuildGuid:%d",
pMsg->m_tszCurrentGuildName, pMsg->m_tszchangeGuildName,
pPlayer->GetGuildGuid());
buf[MAX_ADDINFO_SIZE - 1] = '\0';
add_info = buf;
}
GAMELOG->LogItem(ITEM_USE, pPlayer, &item_slot, 0, 1, NULL, NULL, add_info);
//}
inventory->DeleteSlot(pMsg->m_TargetPos, NULL);
MSG_CG_ITEM_DELETE_CMD msg;
msg.m_byReason = RC::RC_ITEM_DELETE_SUCCESS;
msg.m_atIndex = SI_INVENTORY;
msg.m_atPos = pMsg->m_TargetPos;
pPlayer->SendPacket(&msg, sizeof(msg));
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_NAME_CHANGE_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_NAME_CHANGE_BRD* pMsg = (MSG_GZ_GUILD_NAME_CHANGE_BRD*)pRecvMsg;
// 改变当前游戏服务器的行会名称.
g_GameGuildManager.ChangeGuildName(pMsg->m_GuildGuid, pMsg->m_tszGuildName);
// 更新区域占领战信息.
GameDominationManager::Instance()->ChangeGuildName(pMsg->m_GuildGuid, pMsg->m_tszGuildName);
//.//
GameGuild* pGameGuild = g_GameGuildManager.FindGuild(pMsg->m_GuildGuid);
if (!pGameGuild)
return;
MSG_CG_GUILD_NAME_CHANGE_BRD MemberMsgBRD;
MSG_CG_GUILD_NAME_CHANGE_SECTOR_BRD AroundMsgBRD;
util::GUILDNAMECOPY(MemberMsgBRD.m_tszGuildName, pMsg->m_tszGuildName);
util::GUILDNAMECOPY(AroundMsgBRD.m_tszGuildName, pMsg->m_tszGuildName);
pGameGuild->SendPacketMemberAndAroundAll(MemberMsgBRD, AroundMsgBRD);
//.//
STLX_VECTOR<GUILDGUID> vGuildGuid;
if (0 == pGameGuild->GetRelationGuid(vGuildGuid))
return;
MSG_CG_GUILD_NAME_CHANGE_RELATION_BRD RelationMsgBRD;
RelationMsgBRD.m_GuildGuid = pMsg->m_GuildGuid;
util::GUILDNAMECOPY(RelationMsgBRD.m_tszGuildName, pMsg->m_tszGuildName);
STLX_VECTOR<GUILDGUID>::iterator it = vGuildGuid.begin();
for (; it != vGuildGuid.end(); ++it)
{
GameGuild* pGameGuild = g_GameGuildManager.FindGuild(*it);
if (pGameGuild)
{
RelationMsgBRD.m_RelationType = pGameGuild->GetRelationType(pMsg->m_GuildGuid);
pGameGuild->SendPacketMember(RelationMsgBRD);
}
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_NAME_CHANGE_NAK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
PACKET_PTR_CONVERT(MSG_GZ_GUILD_NAME_CHANGE_NAK, pMsg, pRecvMsg);
PLAYER_PTR_USERKEY(Player, pPlayer, pRecvMsg->m_dwKey);
MSG_CG_GUILD_NAME_CHANGE_NAK msg;
msg.m_bErrorCode = pMsg->m_byErrorCode;
pPlayer->SendPacket(&msg, sizeof(msg));
SCSlotContainer* pInventory = pPlayer->GetItemManager()->GetItemSlotContainer(SI_INVENTORY);
pInventory->SetLock(pMsg->m_TargetPos, FALSE);
}
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_INFO_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_INFO_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_INFO_ACK*>(pRecvMsg);
GameDominationManager* const domination_manager = GameDominationManager::Instance();
const DOMINATION_INFO& domination_info = recv_msg->m_DominationInfo;
GameDominationManager::Instance()->UpdateDominationInfo(domination_info, DOMINATION_INIT);
}
#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_CONTINENT_LORD_INFO_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_CONTINENT_LORD_INFO_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_CONTINENT_LORD_INFO_ACK*>(pRecvMsg);
GameDominationManager* const domination_manager = GameDominationManager::Instance();
GameDominationManager::Instance()->SetDominationContinentLordInfo(recv_msg->m_lordInfo);
}
#endif //_NA_007128_20140326_MONDSCHIEN_DOMINATION
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_AUCTION_INFO_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_DOMINATION_AUCTION_INFO_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_AUCTION_INFO_ACK*>(pRecvMsg);
const int data_count = recv_msg->m_DataCount;
const MAPCODE map_code = recv_msg->m_MapCode;
if (data_count < 0 || data_count > MAX_DOMINATION_AUCTION)
{
assert(!"Invalid auction data count");
SUNLOG(eCRITICAL_LOG, __FUNCTION__":Invalid auction data count : %d", data_count);
return;
}
//gamelulu_debug
SUNLOG(eFULL_LOG, __FUNCTION__":auction info ack : %d", recv_msg->m_MapCode);
GameDominationManager::Instance()->SetAuctionData(map_code, recv_msg->m_ActionInfo, data_count);
}
//_KR_001385_20091105_DOMINATION_UPDATEDOMINATIONINFO
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_UPDATE_INFO_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_UPDATE_INFO_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_UPDATE_INFO_ACK*>(pRecvMsg);
GameDominationManager* const domination_manager = GameDominationManager::Instance();
if (recv_msg->m_ResultCode == RC::DOMINATION_RESULT_FAIL)
{
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]update failed[map:%d]",
recv_msg->m_DominationInfo.m_FieldCode);
return;
}
const DOMINATION_INFO& domination_info = recv_msg->m_DominationInfo;
domination_manager->UpdateDominationInfo(domination_info, recv_msg->m_eSetType);
SUNLOG(eFULL_LOG, "["__FUNCTION__"]update success[map:%d]", domination_info.m_FieldCode);
//_NA_20100604_BETTER_DOMINATION_MANAGER
if (FIELD_SERVER == g_pGameServer->GetServerType())
{
if (recv_msg->m_eSetType == DOMINATION_SUCCESS_DEFENCE)
{
domination_manager->UpdateGuildInfoByDomination(
recv_msg->m_DominationInfo.m_inGuildInfo.m_GuildGuid, DOMINATION_DEFENSE_COUNT);
}
else if (recv_msg->m_eSetType == DOMINATION_DISGUILD_SET)
{
domination_manager->UpdateGuildInfoByDomination(
recv_msg->m_DominationInfo.m_disGuildInfo.m_GuildGuid, DOMINATION_JOIN_COUNT);
}
else if (recv_msg->m_eSetType == DOMINATION_SUCCESS_OFFENCE)
{
domination_manager->UpdateGuildInfoByDomination(
recv_msg->m_DominationInfo.m_disGuildInfo.m_GuildGuid, DOMINATION_MAP_COUNT);
domination_manager->UpdateGuildInfoByDomination(
recv_msg->m_DominationInfo.m_inGuildInfo.m_GuildGuid, DOMINATION_MAP_COUNT);
}
}
}
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_ACCEP_HEIM_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_ACCEP_HEIM_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_ACCEP_HEIM_ACK*>(pRecvMsg);
Player *player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
if (player == NULL)
{
SUNLOG(eCRITICAL_LOG, __FUNCTION__":找不到角色");
return;
}
GameDominationManager* const domination_manager = GameDominationManager::Instance();
const DominationAuctionInfo& curActionInfo = recv_msg->m_DominationActionInfo;
if (recv_msg->m_ResultCode != RC::DOMINATION_RESULT_SUCCESS)
{
MSG_CG_DOMINATION_ACCEP_HEIM_ACK nak_msg;
//删除拍卖物品时，DB保存失败时恢复删除的物品
nak_msg.m_ResultCode = recv_msg->m_ResultCode;
SUNLOG(eCRITICAL_LOG, __FUNCTION__":数据库返回错误 : %d", recv_msg->m_ResultCode);
player->SendPacket(&nak_msg, sizeof(nak_msg));
#ifdef _CH_20100420_CHANGE_DOMINATION_APPLY_WAY
MSG_CG_ITEM_OBTAIN_ITEM_CMD send_msg;
MAPCODE map_code = curActionInfo.m_ActionInfo.m_FieldCode;
SLOTCODE item_code = DominationInfoParser::Instance()->GetBattingItemCodeByMapCode(map_code);
const int amount_cost = recv_msg->number_of_betting_item;
RC::eITEM_RESULT result_code = player->GetItemManager()->Obtain(item_code,
amount_cost,
&send_msg.m_tagInventory);
if (result_code == RC::RC_ITEM_SUCCESS)
{
SUNLOG(eCRITICAL_LOG, __FUNCTION__":奖励物品[%d]", amount_cost);
player->SendPacket(&send_msg, send_msg.GetSize());
}
#endif//_CH_20100420_CHANGE_DOMINATION_APPLY_WAY
}
else if (recv_msg->m_ResultCode == RC::DOMINATION_RESULT_SUCCESS)
{
MAPCODE map_code = curActionInfo.m_ActionInfo.m_FieldCode;
bool result_flag = domination_manager->UpdateAuctionData(player, map_code, curActionInfo);
if (result_flag == false)
{
return;
}
MSG_CG_DOMINATION_ACCEP_HEIM_ACK send_msg;
send_msg.m_ResultCode = recv_msg->m_ResultCode;
#ifdef _CH_20100420_CHANGE_DOMINATION_APPLY_WAY
send_msg.betting_item_count_ = recv_msg->number_of_betting_item;
send_msg.m_TokenPos = recv_msg->m_TokenPos;
#else
send_msg.m_Cost = player->GetMoney();
#endif
player->SendPacket(&send_msg, sizeof(send_msg));
}
}
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_INIT_ACTIONINFO_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_INIT_ACTIONINFO_ACK* recv_msg = static_cast<MSG_GZ_DOMINATION_INIT_ACTIONINFO_ACK*>(pRecvMsg);
if (recv_msg->m_ResultCode != RC::DOMINATION_RESULT_SUCCESS)
{
SUNLOG(eFULL_LOG, "["__FUNCTION__"]错误代码 [%d]\n", recv_msg->m_ResultCode);
}
else if (recv_msg->m_ResultCode == RC::DOMINATION_RESULT_SUCCESS)
{
GameDominationManager::Instance()->ClearAuctionInfo(recv_msg->m_MapCode);
SUNLOG(eFULL_LOG, "["__FUNCTION__"]拍卖信息初始化成功");
}
}
#ifdef _CH_20100420_CHANGE_DOMINATION_APPLY_WAY
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_BATTING_HEIM_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_BATTING_HEIM_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_BATTING_HEIM_ACK*>(pRecvMsg);
Player *player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
if (player == NULL)
{
SUNLOG(eFULL_LOG, "["__FUNCTION__"]未找到角色信息[%d]", recv_msg->m_dwKey);
return;
}
const GameField* const current_field_Data = player->GetField();
if (current_field_Data == NULL)
{
assert(!"未找到玩家场景数据");
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]未找到玩家场景数据[%d]\n",
recv_msg->m_dwKey);
return;
}
if (recv_msg->m_ResultCode != RC::DOMINATION_RESULT_SUCCESS)
{
MSG_CG_DOMINATION_BATTING_HEIM_ACK nak_msg;
nak_msg.m_ResultCode = recv_msg->m_ResultCode;
nak_msg.m_RemainCost = 0;
#ifdef _NA_000000_20130429_DOMINATION_PENALTY
if (recv_msg->m_ResultCode == RC::DOMINATION_RESULT_PENALTY_TIME)
nak_msg.penalty_time = recv_msg->penalty_time;
#endif //_NA_000000_20130429_DOMINATION_PENALTY
player->SendPacket(&nak_msg, sizeof(nak_msg));
return;
}
const GameDominationManager* const domination_manager = GameDominationManager::Instance();
const MAPCODE map_code = recv_msg->m_mapCode;
if (domination_manager->FindAreaInfo(map_code) == NULL)
{
MSG_CG_DOMINATION_BATTING_HEIM_ACK nak_msg;
nak_msg.m_ResultCode = RC::DOMINATION_RESULT_FAIL;
nak_msg.m_RemainCost = 0;
player->SendPacket(&nak_msg, sizeof(nak_msg));
return;
}
const GUILDGUID guild_guid = player->GetGuildGuid();
const MONEY tender_cost =
domination_manager->GetTenderCost(map_code, guild_guid);
const RC::eDOMINATION_RESULT result_code = (tender_cost) ? RC::DOMINATION_RESULT_OVERAP_APPLY :
RC::DOMINATION_RESULT_SUCCESS;
MSG_CG_DOMINATION_BATTING_HEIM_ACK send_msg;
send_msg.m_ResultCode = result_code;
send_msg.m_RemainCost = player->GetMoney();
player->SendPacket(&send_msg, sizeof(send_msg));
}
#else//_CH_20100420_CHANGE_DOMINATION_APPLY_WAY
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_BATTING_HEIM_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_BATTING_HEIM_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_BATTING_HEIM_ACK*>(pRecvMsg);
Player *player = PlayerManager::Instance()->FindPlayerByUserKey(recv_msg->m_dwKey);
if (player == NULL)
{
SUNLOG(eFULL_LOG, "["__FUNCTION__"]未找到角色信息[%d]", recv_msg->m_dwKey);
return;
}
if (recv_msg->m_ResultCode != RC::DOMINATION_RESULT_SUCCESS)
{
MSG_CG_DOMINATION_BATTING_HEIM_ACK nak_msg;
nak_msg.m_ResultCode = recv_msg->m_ResultCode;
nak_msg.m_RemainCost = 0;
player->SendPacket(&nak_msg, sizeof(nak_msg));
return;
}
MSG_CG_DOMINATION_BATTING_HEIM_ACK send_msg;
send_msg.m_ResultCode = recv_msg->m_ResultCode;
send_msg.m_RemainCost = player->GetMoney();
player->SendPacket(&send_msg, sizeof(send_msg));
}
#endif//_CH_20100420_CHANGE_DOMINATION_APPLY_WAY
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_RETURNHIME_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_RETURNHIME_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_RETURNHIME_ACK*>(pRecvMsg);
GameDominationManager::Instance()->SendInitActionInfo(recv_msg->m_MapCode);
}
//_NA_20100604_BETTER_DOMINATION_MANAGER
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_UPDATE_GUILDINFO_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_UPDATE_GUILDINFO_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_UPDATE_GUILDINFO_ACK*>(pRecvMsg);
if (recv_msg->db_result_ == MSG_GZ_DOMINATION_UPDATE_GUILDINFO_ACK::DB_RESULT_FAIL)
{
assert(!"失败~！ 增加统治公会信息计数");
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]失败~！ 增加统治公会信息计数");
return;
}
GameGuild* game_guild = g_GameGuildManager.FindGuild(recv_msg->guild_guid_);
if (game_guild == NULL) return;
//--?? ???
WORD number_of_domination_map =
GameDominationManager::Instance()->GetAreaCount(recv_msg->guild_guid_);
MSG_CG_DOMINATION_UPDATE_GUILDINFO_BRD brd_msg;
{
brd_msg.domination_map_count_ = number_of_domination_map;
brd_msg.domination_join_count_ = recv_msg->domination_join_count_;
brd_msg.domination_defense_count_ = recv_msg->domination_defense_count_;
brd_msg.domination_hunting_count_ = recv_msg->domination_hunting_count_;
}
game_guild->SendPacketMember(brd_msg);
}
// _NA_20100913_GUILD_WAREHOUSE_GM_COMMAND
//GM下令强制关闭公会仓库通知
// 如果这个公会仓库是在单独的游戏服务器上使用的，就好像用户执行了关闭.
Handler_GZ_GUILD_IMPL(GZ_GUILD_GM_WAREHOUSE_FORCE_CLOSE_BRD)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_GUILD_GM_WAREHOUSE_FORCE_CLOSE_BRD* msg = \
static_cast<MSG_GZ_GUILD_GM_WAREHOUSE_FORCE_CLOSE_BRD*>(pRecvMsg);
GameGuild* guild = g_GameGuildManager.FindGuild(msg->guild_guid);
if (guild == NULL) {
return;
}
CGuildWarehouseSlotContainer* guild_warehouse = guild->GetGuildWareHouse();
if (guild_warehouse == NULL) {
return;
}
Player* player = guild_warehouse->GetUsedPlayer();
if (player == NULL && guild_warehouse->IsOpened() == FALSE) {
// 除非没有播放器在使用并且没有打开，否则没有什么要清除的。.
return;
}
// 关闭处理遵循来自客户端的 CG_GUILD_WAREHOUSE_CLOSE_SYN 数据包的处理，但
// 看起来它需要一些清理.
if (guild_warehouse->IsChanged())
{
if (player != NULL) {
player->SerializeInfoToDBProxy(UPDATE_FACTOR_NORMAL_CLOSE);
}
}
else
{
if (player != NULL)
{
MSG_CG_GUILD_WAREHOUSE_CLOSE_ACK ack;
player->SendPacket(&ack, sizeof(ack));
MSG_DG_GUILD_WAREHOUSE_CLOSE_SYN syn;
syn.m_dwKey = player->GetUserKey();
syn.m_GuildGuid = guild->GetGuildGuid();
player->SendToGameDBPServer(&syn, sizeof(syn));
}
guild_warehouse->CloseWarehouse();
}
}
//_NA_20110216_INCREASE_DOMINATION_DEFFENSEWALL_POINT
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_ADD_DEFFENSEWALL_POINT_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_ADD_DEFFENSEWALL_POINT_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_ADD_DEFFENSEWALL_POINT_ACK*>(pRecvMsg);
GameDominationManager* const domination_manager = GameDominationManager::Instance();
Player *player = PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->m_dwKey);
if (player == NULL)
{
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]未找到角色信息");
return;
}
DominationArea* domination_area =
domination_manager->GetAreaInfo(recv_msg->domination_info_.m_FieldCode);
if (domination_area == NULL)
{
return;
}
domination_area->SetTransactionToDeffenseWall(false);
if (recv_msg->db_result_ == false)
{
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]更新数据库失败，开始奖励物品");
if (domination_manager->RewardItem(player, 1, recv_msg->item_code) == RC::RC_ITEM_FAILED)
{
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]奖励物品失败");
}
MSG_CG_DOMINATION_ADD_DEFFENSEWALL_POINT_ACK nak_msg;
nak_msg.result_code_ = RC::DOMINATION_RESULT_DBERROR;
player->SendPacket(&nak_msg, sizeof(nak_msg));
return;
}
domination_manager->UpdateDominationInfo(recv_msg->domination_info_, DOMINATION_INFO_SET);
MSG_CG_DOMINATION_ADD_DEFFENSEWALL_POINT_ACK ack_msg;
ack_msg.result_code_ = RC::DOMINATION_RESULT_SUCCESS;
player->SendPacket(&ack_msg, sizeof(ack_msg));
}
//_NA_20110406_CHANGE_RULE_FOR_DOMINATION_JOIN
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_MEMBER_JOIN_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_MEMBER_JOIN_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_MEMBER_JOIN_ACK*>(pRecvMsg);
GameDominationManager* const domination_manager = GameDominationManager::Instance();
Player* player =
PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->member_info_.member_guid_);
if (player == NULL)
{
return;
}
if (recv_msg->db_result_ == false)
{
MSG_CG_DOMINATION_MEMBER_JOIN_ACK nak_msg;
nak_msg.result_code_ = RC::DOMINATION_RESULT_DBERROR;
player->SendPacket(&nak_msg, sizeof(nak_msg));
return;
}
DominationArea* domination_area = domination_manager->GetAreaInfo(recv_msg->map_code_);
if (domination_area == NULL)
{
return;
}
domination_area->GetMember()->MemberInsert(&recv_msg->member_info_);
MSG_CG_DOMINATION_MEMBER_JOIN_ACK ack_msg;
ack_msg.result_code_ = RC::DOMINATION_RESULT_SUCCESS;
player->SendPacket(&ack_msg, sizeof(ack_msg));
domination_manager->SendMemberList(player, recv_msg->map_code_);
}
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_MEMBER_LEAVE_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_MEMBER_LEAVE_ACK* recv_msg =
static_cast<MSG_GZ_DOMINATION_MEMBER_LEAVE_ACK*>(pRecvMsg);
// 如果 DB 处理失败，它只有在自己请求时才发送失败响应。.
if (recv_msg->db_result_ == false)
{
if (recv_msg->member_guid_ == recv_msg->requester_guid)
{
Player* const leave_member =
PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->member_guid_);
if (leave_member == NULL)
{
return;
}
MSG_CG_DOMINATION_MEMBER_LEAVE_ACK nak_msg;
nak_msg.result_code_ = RC::DOMINATION_RESULT_DBERROR;
leave_member->SendPacket(&nak_msg, sizeof(nak_msg));
}
return;
}
// 如果DB处理成功，则先移除target进行同步.
GameDominationManager* const domination_manager = GameDominationManager::Instance();
DominationArea* domination_area = domination_manager->GetAreaInfo(recv_msg->map_code_);
if (domination_area == NULL)
{
return;
}
domination_area->GetMember()->MemberDelete(recv_msg->member_guid_);
// 如果公会会长要求，只发送参与者名单.
if (recv_msg->member_guid_ != recv_msg->requester_guid)
{
Player* const guild_master =
PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->requester_guid);
if (guild_master == NULL)
{
return;
}
domination_manager->SendMemberList(guild_master, recv_msg->map_code_);
return;
}
// 如果需要，发送成功响应和人员列表.
Player* const leave_member =
PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->member_guid_);
if (leave_member == NULL)
{
return;
}
MSG_CG_DOMINATION_MEMBER_LEAVE_ACK ack_msg;
ack_msg.result_code_ = RC::DOMINATION_RESULT_SUCCESS;
ack_msg.memeber_guid_ = recv_msg->member_guid_;
leave_member->SendPacket(&ack_msg, sizeof(ack_msg));
domination_manager->SendMemberList(leave_member, recv_msg->map_code_);
}
Handler_GZ_GUILD_IMPL(GZ_DOMINATION_MEMBERLIST_ANS)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
const MSG_GZ_DOMINATION_MEMBERLIST_ANS* recv_msg =
static_cast<MSG_GZ_DOMINATION_MEMBERLIST_ANS*>(pRecvMsg);
GameDominationManager* const domination_manager = GameDominationManager::Instance();
DominationArea* domination_area = domination_manager->GetAreaInfo(recv_msg->map_code_);
if (domination_area == NULL)
{
return;
}
domination_area->GetMember()->SetInfo(recv_msg->member_list_, recv_msg->data_count_);
}
#ifdef _NA004034_20120102_GUILD_POINT_SYSTEM
Handler_GZ_GUILD_IMPL(GZ_GUILDPOINTSYSTEM)
{
const MSG_GZ_GUILDPOINTSYSTEM* packet = \
static_cast<MSG_GZ_GUILDPOINTSYSTEM*>(pRecvMsg);
switch (packet->packet_type)
{
case ZG_GUILDPOINT_CHANGE_BRD:
{
const MSG_ZG_GUILDPOINT_CHANGE_BRD* packet2 = \
static_cast<MSG_ZG_GUILDPOINT_CHANGE_BRD*>(pRecvMsg);
MSG_CG_POINTWALLET_GUILDPOINT_CHANGE_BRD brd_msg(\
packet2->guildpoint.guid_, packet2->guildpoint.code_,
packet2->guildpoint.uuid_, packet2->guildpoint.point_);
g_GameGuildManager.SendPacket(packet2->guildpoint.guid_, &brd_msg, sizeof(brd_msg));
} break;
}
}
#endif
#ifdef _NA_004034_20120102_GUILD_INTRODUCTION
Handler_GZ_GUILD_IMPL(GZ_GUILD_INTRODUCTION_SAVE_ACK)
{
const MSG_GZ_GUILD_INTRODUCTION_SAVE_ACK* packet = \
static_cast<MSG_GZ_GUILD_INTRODUCTION_SAVE_ACK*>(pRecvMsg);
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
DWORD result = packet->result_;
if (result == RC::RC_GUILD_SUCCESS)
{
MSG_CG_GUILD_INTRODUCTION_CHANGE_BRD brd_msg;
memset(brd_msg.introduction_strings_, 0, sizeof(brd_msg.introduction_strings_));
memcpy(brd_msg.introduction_strings_, \
packet->introduction_strings_, MAX_GUILD_INTRODUCTION_LENGTH);
g_GameGuildManager.SendPacket(packet->guild_guid, &brd_msg, sizeof(brd_msg));
}
Player* player = PlayerManager::Instance()->FindPlayerByUserKey(pRecvMsg->m_dwKey);
if (player && player->GetField())
{
MSG_CG_GUILD_INTRODUCTION_SAVE_ACK msg;
msg.result_ = result;
player->SendPacket(&msg, sizeof(msg));
}
#else //_NA_007330_20140620_GUILD_SYSTEM_EXTENSION
PLAYER_PTR_USERKEY(Player, player, pRecvMsg->m_dwKey);
DWORD result = packet->result_;
MSG_CG_GUILD_INTRODUCTION_SAVE_ACK msg;
msg.result_ = result;
player->SendPacket(&msg, sizeof(msg));
if (result == RC::RC_GUILD_SUCCESS)
{
MSG_CG_GUILD_INTRODUCTION_CHANGE_BRD brd_msg;
memset(brd_msg.introduction_strings_, 0, sizeof(brd_msg.introduction_strings_));
memcpy(brd_msg.introduction_strings_, \
packet->introduction_strings_, MAX_GUILD_INTRODUCTION_LENGTH);
g_GameGuildManager.SendPacket(player->GetGuildGuid(), &brd_msg, sizeof(brd_msg));
}
#endif //_NA_007330_20140620_GUILD_SYSTEM_EXTENSION
}
#endif //_NA_004034_20120102_GUILD_INTRODUCTION
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
Handler_GZ_GUILD_IMPL(GZ_GUILD_JOIN_REQUEST_ACK)
{
const MSG_GZ_GUILD_JOIN_REQUEST_ACK* packet = \
static_cast<MSG_GZ_GUILD_JOIN_REQUEST_ACK*>(pRecvMsg);
DWORD result = packet->result_;
if (result == RC::RC_GUILD_SUCCESS)
{
//向公会成员发送数据包以添加加入公会的请求列表。
MSG_CG_GUILD_JOIN_REQUEST_BRD brd_msg;
brd_msg.request_info = packet->request_info;
g_GameGuildManager.SendPacket(packet->request_info.m_guild_guid, &brd_msg, sizeof(brd_msg));
}
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(packet->request_info.m_char_guid);
if (player && player->GetField())
{
MSG_CG_GUILD_JOIN_REQUEST_ACK msg;
msg.guild_guid = packet->request_info.m_guild_guid;
msg.result_ = result;
player->SendPacket(&msg, sizeof(msg));
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_JOIN_REQUEST_REJECT_ACK)
{
const MSG_GZ_GUILD_JOIN_REQUEST_REJECT_ACK* packet = \
static_cast<MSG_GZ_GUILD_JOIN_REQUEST_REJECT_ACK*>(pRecvMsg);
DWORD result = packet->result;
if (result == RC::RC_GUILD_SUCCESS)
{
// 一个数据包被发送给公会成员，以将他们从公会成员请求列表中删除。
MSG_CG_GUILD_JOIN_REQUEST_REJECT_BRD brd_msg;
brd_msg.char_guid = packet->target_guid;
g_GameGuildManager.SendPacket(packet->guild_guid, &brd_msg, sizeof(brd_msg));
// 向公会成员发送数据包
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(packet->target_guid);
if (player == NULL || player->GetField() == NULL)
{
return;
}
MSG_CG_GUILD_JOIN_REQUEST_REJECT_ACK msg;
msg.Init();
util::GUILDNAMECOPY(msg.guild_name, packet->guild_name);
msg.guild_guid = packet->guild_guid;
switch (packet->reject_type)
{
case eGUILD_JOIN_REJECT_TYPE_NORMAL:
msg.result_ = RC::RC_GUILD_JOIN_REQUEST_REJECT;
break;
case eGUILD_JOIN_REJECT_TYPE_TIMEOUT:
msg.result_ = RC::RC_GUILD_JOIN_REQUEST_OVER_WAIT_TIME;
break;
case eGUILD_JOIN_REJECT_TYPE_FAILED: // 如果您加入了另一个公会或创建了一个公会，请不要发送数据包。
return;
default:
SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]拒绝类型无效(%d)", packet->reject_type);
return;
}
player->SendPacket(&msg, sizeof(msg));
}
else
{
// 在失败的情况下，数据包被发送到适当的机构。
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(packet->char_guid);
if (player && player->GetField())
{
MSG_CG_GUILD_JOIN_REQUEST_REJECT_ACK msg;
msg.Init();
util::GUILDNAMECOPY(msg.guild_name, packet->guild_name);
msg.guild_guid = packet->guild_guid;
msg.result_ = result;
player->SendPacket(&msg, sizeof(msg));
}
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_RELOAD_ACK)
{
const MSG_GZ_GUILD_RELOAD_ACK* packet = \
static_cast<MSG_GZ_GUILD_RELOAD_ACK*>(pRecvMsg);
//如果公会在当前服务器上不存在，则无需运行.
GameGuild* pGuild = g_GameGuildManager.FindGuild(packet->guild_guid);
if (!pGuild) return;
//如果订阅者存在..
Player* pTargetPlayer = PlayerManager::Instance()->FindPlayerByUserKey(packet->m_dwKey);
if (pTargetPlayer)
{
// 设置用户信息.
pTargetPlayer->GetCharInfo()->m_GuildGuid = packet->guild_guid;
util::GUILDNAMECOPY(pTargetPlayer->GetCharInfo()->m_tszGuildName, pGuild->GetGuildName());
// 从 GuildServer 收到 ack 后发送 ack
// 从BRD发送公会号就可以了..首先是这样的...
MSG_AG_GUILD_JOIN_SUCCESS_CMD msg;
msg.m_GuildGuid = packet->guild_guid;
pTargetPlayer->SendPacket(&msg, sizeof(msg));
// 发送公会关系列表，显示与周围用户有关系的用户的渲染信息。.
MSG_CG_GUILD_ADD_INFO_ACK msgAddInfo;
msgAddInfo.m_AddInfo.m_GuildGuid = packet->guild_guid;
GuildSmallContentEntry::RelationSystem::LoadRelationInfo(&msgAddInfo.m_AddInfo);
msgAddInfo.m_byRelCnt = msgAddInfo.m_AddInfo.m_byRelationGuildCnt;
pTargetPlayer->SendPacket(&msgAddInfo, msgAddInfo.GetSize());
// 加入公会后，公会周围的用户将收到与加入公会相关的最少信息。
// (公会名称, 公会标志, 公会标志边框, 公会等级) 应该是可见的.
pTargetPlayer->FirstGuildMemberEnter();
// 如果公会成员需要公会信息，让克拉拉通过自动按G发送信息请求。.
MSG_CG_GUILD_JOIN_CMD cmdMsg;
cmdMsg.m_GuildGuid = packet->guild_guid;
pTargetPlayer->SendPacket(&cmdMsg, sizeof(cmdMsg));
// 如果您在参加聚会时受到邀请，则为您当前加入的公会
// 如果有敌对的公会成员，离开队伍.
WORD PartyKey = pTargetPlayer->GetPartyState().GetPartyKey();
BOOL bIsExistHostilityMember = FALSE;
bIsExistHostilityMember = NewGamePartyManager::Instance()->IsExistHostilityMember(PartyKey, pTargetPlayer->GetGuildGuid());
if (bIsExistHostilityMember)
{
MSG_AG_PARTY_LEAVE_BY_GUILDRELATION_SYN msg;
msg.m_dwMemberKey = pTargetPlayer->GetObjectKey();
msg.m_wPartykey = PartyKey;
msg.m_bReason = eREASON_LEAVE_PARTY_BY_GUILDRELATION;
g_pGameServer->SendToServer(AGENT_SERVER, &msg, sizeof(msg));
}
#ifdef _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
g_GameGuildManager.ApplyGuildFacilityPassive(pTargetPlayer, true);
#endif // _NA_007330_20140620_GUILD_SYSTEM_EXTENSION
#ifdef _NA_008334_20150608_SONNENSCHEIN
pGuild->ApplyGuildRewardOption(pTargetPlayer);
#else
GameDominationManager::Instance()->ApplyAllRewardOption(pTargetPlayer); // 应用公会会员补偿选项
#endif //_NA_008334_20150608_SONNENSCHEIN
GameDominationManager::Instance()->SendAreaInfoToPlayer(pTargetPlayer);
#ifdef _NA_006088_20120910_CHAOS_ZONE_FREE_PVP
// 移除混沌区域内加入公会时的封印效果..
if (pTargetPlayer->GetGameZonePtr()->GetZoneType() == eZONETYPE_INSTANCE)
{
GameInstanceDungeon* const instance_dungeon = \
static_cast<GameInstanceDungeon*>(pTargetPlayer->GetGameZonePtr());
if (instance_dungeon->GetTypeOfIndun() == INDUN_KIND_CHAOS_ZONE)
{
#ifdef _NA_008334_20150608_SONNENSCHEIN
pGuild->ApplyGuildRewardOption(pTargetPlayer, FALSE);
#else
GameDominationManager::Instance()->ApplyAllRewardOption(pTargetPlayer, false);
#endif //_NA_008334_20150608_SONNENSCHEIN
GameDominationManager::Instance()->SendAreaInfoToPlayer(pTargetPlayer, false);
}
}
#endif // _NA_006088_20120910_CHAOS_ZONE_FREE_PVP
GameField* pField = pTargetPlayer->GetField();
if (NULL != pField)
{
const FIELDCODE fCode = pField->GetFieldCode();
GameDominationManager::Instance()->ApplyRewardField(pTargetPlayer, fCode);
}
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_FACILITY_UPGRADE_ACK)
{
const MSG_GZ_GUILD_FACILITY_UPGRADE_ACK* recv_msg =
static_cast<MSG_GZ_GUILD_FACILITY_UPGRADE_ACK*>(pRecvMsg);
if (recv_msg->result == RC::RC_GUILD_SUCCESS)
{
GameGuild* game_guild = g_GameGuildManager.FindGuild(recv_msg->guild_guid);
if (game_guild != NULL)
{
MSG_CG_GUILD_FACILITY_UPGRADE_BRD brd_msg;
brd_msg.facility_info = recv_msg->facility_info;
game_guild->SendPacketAll(&brd_msg, sizeof(brd_msg));
//设施升级处理
game_guild->UpdateGuildFacility(recv_msg->char_guid, recv_msg->facility_info, recv_msg->cur_level, recv_msg->add_level);
}
}
Player* player = PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->char_guid);
if (player != NULL)
{
MSG_CG_GUILD_FACILITY_UPGRADE_ACK ack_msg;
ack_msg.facility_code = recv_msg->facility_code;
ack_msg.result = recv_msg->result;
player->SendPacket(&ack_msg, sizeof(ack_msg));
}
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_FACILITY_SELECT_ACK)
{
const MSG_GZ_GUILD_FACILITY_SELECT_ACK* recv_msg =
static_cast<MSG_GZ_GUILD_FACILITY_SELECT_ACK*>(pRecvMsg);
GameGuild* game_guild = g_GameGuildManager.FindGuild(recv_msg->guild_guid);
if (game_guild == NULL)
{
SUNLOG(eCRITICAL_LOG,
"["__FUNCTION__"] 公会设施信息已保存，但公会在游戏服务器上不存在(%d)",
recv_msg->guild_guid);
return;
}
GuildFacilities*const guild_facilities = game_guild->GetGuildFacilities();
if (guild_facilities == NULL)
{
SUNLOG(eCRITICAL_LOG,
"["__FUNCTION__"] 公会设施信息已保存，但公会没有公会设施等级。(%d)",
recv_msg->guild_guid);
return;
}
for (int i = 0; i < recv_msg->total_info.m_count; ++i)
{
guild_facilities->SetGuildFacility(recv_msg->total_info.m_GuildFacilityInfo[i]);
}
guild_facilities->SetLoaded(true);
//公会设施信息全部加载完毕后，发送给所有公会成员。
MSG_CG_GUILD_FACILITY_TOTALINFO_ACK total_msg;
total_msg.guild_facility_total_info = recv_msg->total_info;
game_guild->SendPacketAll(&total_msg, sizeof(total_msg));
//将所有公会设施被动应用到所有公会成员.
g_GameGuildManager.ApplyGuildFacilityPassiveAllmember(recv_msg->guild_guid, true);
}
#endif //_NA_007330_20140620_GUILD_SYSTEM_EXTENSION
#ifdef _NA_003923_20120130_GUILD_RENEWAL
Handler_GZ_GUILD_IMPL(GZ_GUILD_IN_GAME_GUILD_LOG_LIST_ANS)
{
const MSG_GZ_GUILD_IN_GAME_GUILD_LOG_LIST_ANS* recv_msg =
static_cast<MSG_GZ_GUILD_IN_GAME_GUILD_LOG_LIST_ANS*>(pRecvMsg);
Player* const request_player =
PlayerManager::Instance()->FindPlayerByCharKey(recv_msg->request_char_guid_);
if (request_player == NULL)
{
return;
}
MSG_CG_GUILD_IN_GAME_GUILD_LOG_LIST_ANS send_msg;
send_msg.log_category_ = recv_msg->log_category_;
send_msg.log_count_ = recv_msg->log_count_;
CopyMemory(send_msg.log_data_, recv_msg->log_data_, sizeof(send_msg.log_data_));
request_player->SendPacket(&send_msg, send_msg.GetSize());
}
#endif
Handler_GZ_GUILD_IMPL(GZ_GUILD_RENAME_CHAR_CMD)
{
const MSG_GZ_GUILD_RENAME_CHAR_CMD* recv_msg = \
static_cast<MSG_GZ_GUILD_RENAME_CHAR_CMD*>(pRecvMsg);
GUILDGUID guild_guid = recv_msg->guildguid;
CHARGUID char_guid = recv_msg->charguid;
const TCHAR* character_name = recv_msg->character_name_;
GameGuild* pGameGuild = g_GameGuildManager.FindGuild(guild_guid);
if (pGameGuild)
{
GameGuildMember* guild_member = pGameGuild->FindMember(char_guid);
if (guild_member) {
guild_member->SetCharName(character_name);
}
}
GameDominationManager::Instance()->GuildMasterNameChange(\
guild_guid, char_guid, character_name);
}
#ifdef _NA_008334_20150608_SONNENSCHEIN
Handler_GZ_GUILD_IMPL(GZ_GUILD_SONNENSCHEIN_INITIALIZE_CMD)
{
MSG_GZ_GUILD_SONNENSCHEIN_INITIALIZE_CMD* ack_msg = \
static_cast<MSG_GZ_GUILD_SONNENSCHEIN_INITIALIZE_CMD*>(pRecvMsg);
g_GameGuildManager.InitializeAllSonnenScheinPhase();
}
Handler_GZ_GUILD_IMPL(GZ_GUILD_SONNENSCHEIN_UPDATE_ACK)
{
__TOUCHED((pServerSession, pRecvMsg, wSize));
MSG_GZ_GUILD_SONNENSCHEIN_UPDATE_ACK* ack_msg = \
static_cast<MSG_GZ_GUILD_SONNENSCHEIN_UPDATE_ACK*>(pRecvMsg);
// 实际上，在更新GameServer信息后，当Sonenshine结束时，GameServer信息被传送到DB。
// Guji 这里不需要更新游戏服务器公会的信息。
// 但是考虑到可能的查询失败，DB中更新的信息在GameGuild中更新
g_GameGuildManager.SetGuildSonnenScheinPhase(ack_msg->guild_guid, ack_msg->sonnenschein_phase);
GameGuild* guild = g_GameGuildManager.FindGuild(ack_msg->guild_guid);
if (NULL != guild)
{
MSG_CG_GUILD_SONNENSCHEIN_UPDATE_CMD cmd_msg;
cmd_msg.sonnenschein_phase = ack_msg->sonnenschein_phase;
cmd_msg.m_dwPlayerKey = 0;
guild->SendPacketMemberAround(cmd_msg, INVALID_GUILDGUID);
}
}
#endif //_NA_008334_20150608_SONNENSCHEIN
Reference in New Issue View Git Blame Copy Permalink