#include "stdafx.h"

//////////////////////////////////////////////////////////////////////////
#include <PacketStruct_AG.h>
#include ".\DominationField.h"
#include <AgentParty/AgentPartyManager.h>
#include "MapInfoParser.h"
#include "DominationInfoParser.h"
#include <Zone/ZoneManager.h>
#include <SolarDateTime.h>

BOOL DominationField::is_gm_observer = TRUE;

_IMPL_POOL(DominationField)
DominationField::DominationField(void)
	: bReCreate_(FALSE)
	, curEventState_(DOMINATION_EVENT_MAX)    // 无效值
{
	guild_count_[offense_guild] = std::make_pair(INVALID_GUILDGUID, 0);
	guild_count_[defense_guild] = std::make_pair(INVALID_GUILDGUID, 0);
	pairKickGuild_ = std::make_pair(INVALID_GUILDGUID, INVALID_GUILDGUID);

	eventUpdateTimer_.SetTimer(EVENT_UPDATE_TIME);
	outsider_updatetimer_.SetTimer(OUTSIDER_UPDATE_TIME);
}

DominationField::~DominationField(void)
{
	outSider_.clear();
}

VOID
DominationField::Create(KEYTYPE key, MAPCODE mapCode, ServerSession* pServerSession)
{
	SetKey(key);
	SetMapCode(mapCode);
	SetLinkedServer(pServerSession);

#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION
	_SetEventInfos(mapCode);
#endif //_NA_007128_20140326_MONDSCHIEN_DOMINATION

	On_create();
}

#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION
VOID DominationField::_SetEventInfos(MAPCODE map_code)
{
	DominationInfoParser* pParser = DominationInfoParser::Instance();
	if (pParser == NULL)
	{
		return;
	}

	event_infos_ = pParser->GetEventInfosFromMapCode(map_code);
}


eDOMINATION_EVENT_STATE DominationField::_GetCurEventState(const WORD day_of_week, const DWORD time) const
{
	//如果注册了 GM 事件，则处理它.
	DominationInfoParser* pParser = DominationInfoParser::Instance();
	const sDOMINATION_EVENT_INFO* const event_info = pParser->GetGMEventInfo(day_of_week, time, GetMapCode());
	if (event_info != NULL)
	{
		const DWORD* times = event_info->m_dwTime;
		for (int cur_event = DOMINATION_EVENT_AUCTION_START;
		cur_event < DOMINATION_EVENT_AUCTION_START2; ++cur_event, ++times)
		{
			const DWORD start_time = *times;
			const DWORD end_time = *(times + 1);
			const bool is_include = Between(time, start_time, end_time);
			if (is_include)
			{
				return (eDOMINATION_EVENT_STATE)cur_event;
			}
		}
	}

	EventInfos::const_iterator event_infos_it = event_infos_.begin();
	EventInfos::const_iterator event_infos_end = event_infos_.end();

	//遍历注册的事件.
	for (; event_infos_it != event_infos_end; ++event_infos_it)
	{
		const sDOMINATION_EVENT_INFO& event_info = event_infos_it->second;
		//检查是否与今天同一天.
		if (event_info.m_wDayOfWeek != day_of_week)
		{
			continue;
		}
		//检查当前时间是否包含在事件时间中.
		const DWORD start_time = event_info.m_dwTime[DOMINATION_EVENT_AUCTION_START];
		const DWORD end_time = event_info.m_dwTime[DOMINATION_EVENT_AUCTION_START2];
		const bool is_include = Between(time, start_time, end_time);
		if (is_include == false)
		{
			continue;
		}
		//如果包含在事件的时间中，则返回当前时间对应的事件状态。
		const DWORD* times = event_info.m_dwTime;
		for (int cur_event = DOMINATION_EVENT_AUCTION_START;
		cur_event < DOMINATION_EVENT_AUCTION_START2; ++cur_event, ++times)
		{
			const DWORD start_time = *times;
			const DWORD end_time = *(times + 1);
			const bool is_include_current = Between(time, start_time, end_time);
			if (is_include_current == false)
			{
				continue;
			}
			return (eDOMINATION_EVENT_STATE)cur_event;
		}
	}

	//如果没有登记的占领战争事件，则处于和平状态，您可以进入。.
	return DOMINATION_EVENT_END;
}
#endif

VOID
DominationField::On_create()
{
	MSG_AG_ZONE_DOMINATION_FIELD_CREATE_CMD msg;
	msg.m_dwKey = 0;
	msg.m_MapCode = GetMapCode();
	msg.m_RoomKey = GetKey();
	SendToLinkedServer(&msg, sizeof(msg));

	// 在服务器运行时重新启动游戏服务器时进行同步.
	MSG_AG_ZONE_DOMINATION_FIELD_INFO_SYN msgSyn;
	msgSyn.m_RoomKey = GetKey();
	msgSyn.m_byEventState = curEventState_;

	SendToLinkedServer(&msgSyn, sizeof(msgSyn));
}


VOID
DominationField::_ReSetDomination()
{
	if (FALSE == bReCreate_)
	{
		if (pairKickGuild_.first)
		{
			_KickUser(pairKickGuild_.first);
			pairKickGuild_.first = 0;
		}

		if (pairKickGuild_.second)
		{
			_KickUser(pairKickGuild_.second);
			pairKickGuild_.second = 0;
		}
	}
	else
	{
		bReCreate_ = FALSE;

		_KickUser(INVALID_GUILDGUID);
		pairKickGuild_ = std::make_pair(INVALID_GUILDGUID, INVALID_GUILDGUID);

		//.//

		KEYTYPE key = GetKey();
		MAPCODE mCode = GetMapCode();
		ServerSession* pSession = GetLinkedServer();

		Destroy();
		Create(key, mCode, pSession);
	}

#ifdef _NA_006826_20130722_DOMINATION_RENEWAL
	if (curEventState_ == DOMINATION_EVENT_END)
	{
		GUILDGUID winner_guild = guild_count_[defense_guild].first;
		_KickUsers_ExceptWinGuild(winner_guild);
	}
#endif //_NA_006826_20130722_DOMINATION_RENEWAL
}

VOID
DominationField::On_destroy()
{
	guild_count_[offense_guild] = std::make_pair(0, 0);
	guild_count_[defense_guild] = std::make_pair(0, 0);
}

VOID
DominationField::ReadyUser(User * pUser, eSEND_TYPE type, MAPCODE FieldCode, DWORD dwAreaID, WzVector * pwvStartPos, bool bFirstJoin)
{
	if (!dwAreaID)
	{                           // (CHANGES) 从0902开始，如果是合法领域 assert(GetMapInfo() != NULL)
		const sMAPINFO* psMAPINFO = GetMapInfo();// MapInfoParser::Instance()->FindMapInfo(GetMapCode());
		const GUILDGUID guildGuid = pUser->GetSelectedCharGuildGuid();
		const BYTE guildIdx = _GetGuildCountIndex(guildGuid);

		// 实际起始位置由 GameServer 决定.
		if (defense_guild == guildIdx)
			dwAreaID = psMAPINFO->wStartAreaID;
		else if (offense_guild == guildIdx)
			dwAreaID = psMAPINFO->wStartAreaID2;
		else
		{
			SUNLOG(eDEV_LOG, "[DominationField::ReadyUser] MapCode[%d] CharName[%s]",
				GetMapCode(), pUser->GetSelectedCharName());
		}
	}

	ZoneInterface::ReadyUser(pUser, type, FieldCode, dwAreaID, pwvStartPos, bFirstJoin);

	//记录占领区公会成员人数作为游戏日志（中国要求）.
	BYTE player_count = _CountingPlayer(pUser->GetSelectedCharGuildGuid());
	GAMELOG->LogDominationFieldEnterCount(ACT_DOMINATION_FIELD_JOIN_COUNT, pUser,
		player_count, GetMapCode());
}

VOID
DominationField::On_readyuser(User* pUser)
{
	pUser->SetZoneState(ePRS_BEFORE_ENTER_DOMINATION_FIELD);
	pUser->SetZoneKey(GetKey());
	pUser->SetZoneType(eZONETYPE_DOMINATION_FIELD);
}

VOID
DominationField::On_enteruser(User* pUser)
{
	ZoneInterface::On_enteruser(pUser);

	pUser->SetZoneState(ePRS_AT_DOMINATION_FIELD);
	pUser->SetSelectedCharMapCode(GetMapCode());

	AgentPartyManager::Instance()->EnterZone(pUser, this);

	// 只有首次访问者不经过 _CanJoinEach 逻辑。
	// 实际可以进入的情况是使用GM命令的时候

	RC::eROOM_RESULT join_result = _CanJoinEach(pUser, (eZONEPUBLIC)0, NULL);
	RC::eROOM_RESULT count_result = _GuildCount(pUser, +1);
	if (RC::RC_ROOM_SUCCESS != join_result || RC::RC_ROOM_SUCCESS != count_result)
	{
		const byte bySts = pUser->GetSts();
		const bool bGMUser = (eGM_GRADE_BASE<bySts && bySts<eGM_GRADE_MAX) ? true : false;
		OUTSIDERS* outSider = NULL;

		if (is_gm_observer && bGMUser)
			outSider = &outSiderOb_;
		else
			outSider = &outSider_;

		outSider->push_back(std::make_pair(pUser->GetPlayerKey(), 0));

		SUNLOG(eCRITICAL_LOG,
			"[DominationField::On_enteruser] outSider_ MapCode[%d] NAME[%s], JOINCODE[%d], COUNTCODE[%d]",
			GetMapCode(), pUser->GetSelectedCharName(), join_result, count_result);
		return;
	}
	SUNLOG(eDEV_LOG, "[DominationField::On_enteruser] InSider_ MapCode[%d] NAME[%s]",
		GetMapCode(), pUser->GetSelectedCharName());
}

VOID
DominationField::On_leaveuser(User* pUser)
{
	if (pUser->GetPartyState().IsPartyMember() == true)
	{
		AgentPartyManager::Instance()->LeaveZone(pUser, this);
	}

	if (FALSE == _GuildCount(pUser, -1))
	{
		SUNLOG(eDEV_LOG, "[DominationField::On_leaveuser] OutSider_ MapCode[%d] GUILDGUID[%d]",
			GetMapCode(), pUser->GetSelectedCharGuildGuid());
		return;
	}
	SUNLOG(eDEV_LOG, "[DominationField::On_leaveuser] InSider_ MapCode[%d] GUILDGUID[%d]",
		GetMapCode(), pUser->GetSelectedCharGuildGuid());
}

//_NA001385_20090924_DOMINATION_EVENT_CONTROLL

RC::eROOM_RESULT DominationField::_CanJoinEach(User* pUser, eZONEPUBLIC roomPublic, TCHAR* pszRoomPWD)
{
	if (DOMINATION_EVENT_SYSTEM_RESET != curEventState_)
	{
		const byte bySts = pUser->GetSts();
		const bool bGMUser = (eGM_GRADE_BASE<bySts && bySts<eGM_GRADE_MAX) ? true : false;

		if (is_gm_observer && bGMUser)
		{
			SUNLOG(eDEV_LOG, "[DominationField::_CanJoinEach] MapCode[%d] CharName[%s] - GM Entered",
				GetMapCode(), pUser->GetSelectedCharName());
			return RC::RC_ROOM_SUCCESS;
		}
	}

	// 如果成员人数大于MAX_FIELD_PARTYMEMBER_NUM，则不能进入。.
	DWORD MemberNum = AgentPartyManager::Instance()->GetMemberNum(pUser->GetPartyState().GetPartyKey());
	if (MemberNum > MAX_FIELD_PARTYMEMBER_NUM)
	{
		return RC::RC_ROOM_PARTY_MEMBER_ACCESS;
	}

	const sDOMINATION_INFO* pInfo = DominationInfoParser::Instance()->GetDominationInfo(GetMapCode());
	if (NULL == pInfo)
		return RC::RC_ROOM_INVALIDROOMTYPE;

	const GUILDGUID guildGuid = pUser->GetSelectedCharGuildGuid();
	const INT guildIdx = _GetGuildCountIndex(guildGuid);

#ifdef _NA_006826_20130722_DOMINATION_RENEWAL
	// 没有公会就不能进入。
	if (guildGuid == INVALID_GUILDGUID) {
		return RC::RC_ROOM_MISMATCH_JOIN_GUILD;
	}
#else
	if (guildIdx == empty_guild_idx)
	{
		return RC::RC_ROOM_MISMATCH_JOIN_GUILD;
	}
#endif //_NA_006826_20130722_DOMINATION_RENEWAL

	RC::eROOM_RESULT result = RC::RC_ROOM_SUCCESS;
	switch (curEventState_)
	{
	case DOMINATION_EVENT_SYSTEM_RESET:                     // 没有球或水进入
		result = RC::RC_ROOM_NOT_OPEN_TIME_FOR_DOMINATION;
		break;

	case DOMINATION_EVENT_WAIT:                             // 允许球和水进入（计数限制）
	case DOMINATION_EVENT_START:
#ifdef _NA_006826_20130722_DOMINATION_RENEWAL
		// 任何公会都可以进入
#else
		if (guild_count_[guildIdx].second >= pInfo->m_MaxUser)
			result = RC::RC_ROOM_LIMIT_MAX_GUILDMEMBER;
#endif //_NA_006826_20130722_DOMINATION_RENEWAL
		break;
	case DOMINATION_EVENT_SELECT_ATTACKGUILD:               //gamelulu : 增加区域职业事件
	case DOMINATION_EVENT_SELECT_ATTACKGUILD_END:
	case DOMINATION_EVENT_AUCTION_START:                    // 无限制攻击（大师公会）
	case DOMINATION_EVENT_AUCTION_END:
	case DOMINATION_EVENT_END:
		if (guildIdx != defense_guild)
			result = RC::RC_ROOM_MISMATCH_JOIN_GUILD;
		break;
	default:
		SUNLOG(eDEV_LOG, "[DominationField::_CanJoinEach] MapCode[%d] CharName[%s] curEventState[%d]",
			GetMapCode(), pUser->GetSelectedCharName(), curEventState_);
		result = RC::RC_ROOM_NOT_OPEN_TIME_FOR_DOMINATION;
		break;
	}

	return result;
}

// 当状态信息提供给现场服务器时，在ACK消息中更新公会信息。
//
// 创建时curEventState_的初始值改变时产生SYN信息。
// 数据从公会服务器同步到游戏服务器时产生的SYN信息。
// SYN信息是在_UpdateTimeEvent期间curEventState_的值改变时产生的。（ReCreate也一样）
// 确认输赢时产生SYN信息

VOID DominationField::SetGuildGuid(GUILDGUID offense, GUILDGUID defense, eDOMINATION_EVENT_TYPE eSetType)
{
	const GUILDGUID oldOffense = guild_count_[offense_guild].first;
	const GUILDGUID oldDefense = guild_count_[defense_guild].first;

	switch (eSetType)
	{
	case DOMINATION_INFO_SET:   // 当攻击者被指定时
	case DOMINATION_INIT:       // 运行服务器时，gm 命令，状态同步 - Kicks 现有用户
		if (oldDefense != defense)
		{
			pairKickGuild_.first = oldDefense;
			guild_count_[defense_guild] = std::make_pair(defense, 0);

			SUNLOG(eDEV_LOG, "[Domi::SetGuild] MapCode[%d] defenseArg[%d] defenseMem[%d] EventState[%d]",
				GetMapCode(), defense, guild_count_[defense_guild].first, curEventState_);
		}

		if (oldOffense != offense)
		{
			pairKickGuild_.second = oldOffense;
			guild_count_[offense_guild] = std::make_pair(offense, 0);

			SUNLOG(eDEV_LOG, "[Domi::SetGuild] MapCode[%d] offenseArg[%d] offenseMem[%d] EventState[%d]",
				GetMapCode(), offense, guild_count_[offense_guild].first, curEventState_);
		}
		break;

	case DOMINATION_SUCCESS_DEFENCE:    // 防守成功
		pairKickGuild_.second = offense;
		break;

	case DOMINATION_SUCCESS_OFFENCE:    // 攻击成功
		pairKickGuild_.first = defense;
		std::swap(guild_count_[offense_guild], guild_count_[defense_guild]);
		break;
#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION 
	case DOMINATION_TURN_OVER:  //Montshine 雕刻成功
		if (oldDefense != defense)
		{
			pairKickGuild_.first = oldDefense;
			guild_count_[defense_guild] = std::make_pair(defense, 0);

			SUNLOG(eDEV_LOG, "[Domi::SetGuild] MapCode[%d] defenseArg[%d] defenseMem[%d] EventState[%d]",
				GetMapCode(), defense, guild_count_[defense_guild].first, curEventState_);
		}
		break;
#endif
	}

	switch (eSetType)
	{
	case DOMINATION_SUCCESS_DEFENCE:
	case DOMINATION_SUCCESS_OFFENCE:
	{
		guild_count_[offense_guild] = std::make_pair(INVALID_GUILDGUID, 0);

		MSG_AG_ZONE_DOMINATION_FIELD_INFO_SYN msg;
		msg.m_RoomKey = GetKey();
		msg.m_byEventState = curEventState_ = DOMINATION_EVENT_END;

		SendToLinkedServer(&msg, sizeof(msg));
	}
	break;
	}


#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION 
	//发生失误时不要设置踢球计时器
	if (0 == kickTimer_.GetRemainedTime() && eSetType != DOMINATION_TURN_OVER)
	{
		SUNLOG(eCRITICAL_LOG, "[DominationField::SetGuildGuid] 统治到期 !!!");
		kickTimer_.SetTimer(KICK_TIME);
	}
#else
	if (0 == kickTimer_.GetRemainedTime())
	{
		SUNLOG(eCRITICAL_LOG, "[DominationField::SetGuildGuid] Domination Expired !!!");
		kickTimer_.SetTimer(KICK_TIME);
	}
#endif
}

//////////////////////////////////////////////////////////////////////////

INT DominationField::_GetGuildCountIndex(const GUILDGUID guildGuid)
{
	ASSERT(guildGuid != INVALID_GUILDGUID);

	if (guildGuid == guild_count_[offense_guild].first)
		return offense_guild;

	if (guildGuid == guild_count_[defense_guild].first)
		return defense_guild;

	return empty_guild_idx;
}


BOOL DominationField::_ReturnToEntrance(User* pUser)
{
	S_TRY
	{
		if (pUser->IsBeginTransaction())
		S_THROW(1);

	if (pUser->GetBehaveState() != PLAYER_BEHAVE_IDLE_STATE)
		S_THROW(2);

	DominationInfoParser* pDomiParser = DominationInfoParser::Instance();
	const sDOMINATION_INFO* pDomiInfo = pDomiParser->GetDominationInfo(GetMapCode());
	if (NULL == pDomiInfo)
		S_THROW(3);

	MapInfoParser* pMapParser = MapInfoParser::Instance();
	const WORD IdxPortal = pMapParser->GetCurrentMapPortalIndexVer2(pDomiInfo->m_DominationMapCode, pDomiInfo->m_LinkMapCode);
	if (0 == IdxPortal)
		S_THROW(4);

	sMAP_ENTERENCE_PORTAL* pFromInfo = pMapParser->GetMapPortal(IdxPortal);
	if (!pFromInfo)
		S_THROW(5);

	ZoneInterface* pToZone = g_ZoneManager.FindStaticZone(pFromInfo->wWorldTo);
	if (!pToZone)
		S_THROW(6);

	RC::eROOM_RESULT rt = pToZone->CanJoin(pUser, (eZONEPUBLIC)0, NULL);
	if (RC::RC_ROOM_SUCCESS != rt)
		S_THROW(7);

	CheckMoveZonePolicy* const pCheckMoveZonePolicy =
		MoveZonePolicy<MZTF_STATIC_TO_STATIC>::AlignInfo(
			pUser
			//{		From		|			To		}
			, pUser->GetZoneType(),	pToZone->GetType()	//	eZONETYPE
			, pUser->GetZoneKey(),	pToZone->GetKey()	//	ZoneKey
			);
	RoomArgument args(eZONEPUBLIC_PUBLIC, NULL, pFromInfo->wFieldTo, pFromInfo->m_dwToAreaID);
	rt = g_ZoneManager.MoveZone(pCheckMoveZonePolicy, args);
	if (RC::RC_ROOM_SUCCESS != rt)
		S_THROW(8);

	MSG_CG_ZONE_GMPORTAL_FIELD_MOVE_CMD msgCMD;
	msgCMD.m_MapCode = pDomiInfo->m_LinkMapCode;
	pUser->SendPacket(&msgCMD, sizeof(msgCMD));

	//野战记录
	GAMELOG->MoveVillage(pUser, pFromInfo->wWorldFrom, pFromInfo->wWorldTo, FALSE);
	}
		S_CATCH(DWORD, err)
	{
		SUNLOG(eCRITICAL_LOG, "[DominationField::_ReturnToEntrance_error] "
			"MapCode[%d] GUILDGUID[%d] NAME[%s] err[%d]",
			GetMapCode(), pUser->GetSelectedCharGuildGuid(),
			pUser->GetSelectedCharName(), err);

		return FALSE;
	}

	return TRUE;
}

BYTE DominationField::_CountingPlayer(GUILDGUID guild_guid)
{
	const ZONE_USER_LIST& user_list = GetUserList();

	BYTE user_num = 0;

	FOREACH_CONTAINER(const ZONE_USER_LIST::value_type& node, user_list, ZONE_USER_LIST)
	{
		User* const user = node.second;
		if (user->GetSelectedCharGuildGuid() == guild_guid)
		{
			++user_num;
		}
	}

	return user_num;
}

//在占领前的地图中，对应公会的 
RC::eROOM_RESULT DominationField::_GuildCount(User* pUser, INT count)
{
	ASSERT(pUser);

#ifdef _NA_006826_20130722_DOMINATION_RENEWAL
	return RC::RC_ROOM_SUCCESS;
#endif //_NA_006826_20130722_DOMINATION_RENEWAL

	const GUILDGUID guildGuid = pUser->GetSelectedCharGuildGuid();
	if (INVALID_GUILDGUID == guildGuid)
		return RC::RC_ROOM_NOT_INCLUDE_GUILD;

	std::pair<BOOL, INT> guildCount = _Counting(guildGuid, count);

	if (FALSE == guildCount.first)
		return RC::RC_ROOM_MISMATCH_JOIN_GUILD;

	if (DOMINATION_EVENT_WAIT == curEventState_ ||
		DOMINATION_EVENT_START == curEventState_)       //克拉拉只在占领战中计算.
	{
		const sDOMINATION_INFO* pInfo =
			DominationInfoParser::Instance()->GetDominationInfo(GetMapCode());

		if ((pInfo != NULL &&
			guildCount.second > pInfo->m_MaxUser) ||
			guildCount.second < 0)
		{
			SUNLOG(eCRITICAL_LOG, "[DominationField::_GuildCount]"
				"error MapCode[%d] GUILDGUID[%d] CUR_COUNT[%d] MAX[%d]",
				GetMapCode(), guildGuid, guildCount.second, pInfo->m_MaxUser);

			//return RC::RC_ROOM_LIMIT_MAX_GUILDMEMBER;   // 修复了公会计数丢失的错误。 ?[4/20/2010 lst1024]
		}
		// NOTE: f110817.2L, 关于 brdCount.m_byCount 的客户端用法只显示
		// 像数组一样没有偏移控制的 UI 呈现
		MSG_CG_DOMINATION_COUNT_NOSES_BRD brdCount;
		brdCount.m_byCount = guildCount.second;

		const ZONE_USER_LIST& rList = GetUserList();
		FOREACH_CONTAINER(const ZONE_USER_LIST::value_type& rNode, rList, ZONE_USER_LIST)
		{
			User* const pBrdUser = rNode.second;
			if (pBrdUser->GetSelectedCharGuildGuid() == guildGuid)
				pBrdUser->SendPacket(&brdCount, sizeof(brdCount));
		}
	}

	return RC::RC_ROOM_SUCCESS;
}

std::pair<BOOL, INT> DominationField::_Counting(GUILDGUID guildGuid, INT count)
{
	ASSERT(guildGuid);

	for (int i = 0; i < max_guild; ++i)
	{
		if (guild_count_[i].first == guildGuid)
		{
			INT& _count = guild_count_[i].second;

			_count += count;

			return std::make_pair(TRUE, _count);
		}
	}

	return std::make_pair(FALSE, 0);
}

VOID DominationField::_KickUser(GUILDGUID guildGuid)
{
	const ZONE_USER_LIST& rList = GetUserList();
	ZONE_USER_LIST::const_iterator it = rList.begin();
	ZONE_USER_LIST::const_iterator itend = rList.end();

	while (it != itend)
	{
		User* const pUser = it->second;
		++it;

		if (NULL == pUser)
			continue;

		if (INVALID_GUILDGUID == guildGuid)
		{
			_ReturnToEntrance(pUser);   // 立即强制移动
		}
		else
		{
			if (pUser->GetSelectedCharGuildGuid() == guildGuid)
			{
				const DWORD dwPlayerKey = pUser->GetPlayerKey();
				outSider_.push_back(std::make_pair(dwPlayerKey, 0));
			}
		}
	}
}

VOID DominationField::KickUser(DWORD playerKey)
{
	outSider_.push_back(std::make_pair(playerKey, 0));
}


VOID DominationField::_UpdateTimeEvent()
{
	if (NULL == GetLinkedServer())
		return;

	if (eventUpdateTimer_.IsExpired())
	{
		DWORD dwTime = 0;
		const WORD wDayOfWeek = util::GetDateTime_Week_HHMMSS(dwTime);
		DominationInfoParser* pParser = DominationInfoParser::Instance();

#ifdef _NA_007128_20140326_MONDSCHIEN_DOMINATION
		//您不会从解析器获取事件信息，而是从 EventInfos 获取征服前信息
		eDOMINATION_EVENT_STATE curEventState = _GetCurEventState(wDayOfWeek, dwTime);
#else    
		eDOMINATION_EVENT_STATE curEventState = pParser->GetCurEventState(wDayOfWeek, dwTime);
#endif
		if (curEventState_ == curEventState)
			return;

		if (DOMINATION_EVENT_END == curEventState_ &&
			DOMINATION_EVENT_START == curEventState)
			return;

		// 有时需要实时事件日志，因此信息保留为 eCRITICAL_LOG。.
		const char* event_string = curEventState == DOMINATION_EVENT_AUCTION_START ? "AUCTION_START"
			: curEventState == DOMINATION_EVENT_AUCTION_START2 ? "AUCTION_START2"
			: curEventState == DOMINATION_EVENT_SYSTEM_RESET ? "SYSTEM_RESET"
			: curEventState == DOMINATION_EVENT_AUCTION_END ? "AUCTION_END"
			: curEventState == DOMINATION_EVENT_SELECT_ATTACKGUILD ? "SELECT_ATTACKGUILD"
			: curEventState == DOMINATION_EVENT_SELECT_ATTACKGUILD_END ? "SELECT_ATTACKGUILD_END"
			: curEventState == DOMINATION_EVENT_WAIT ? "WAIT"
			: curEventState == DOMINATION_EVENT_START ? "START"
			: curEventState == DOMINATION_EVENT_END ? "END"
			: curEventState == DOMINATION_EVENT_MAX ? "MAX"
			: "EMPTY";

		SUNLOG(eCRITICAL_LOG, "[DominationField::_UpdateTimeEvent] map[%d] Event[%s] off[%d] def[%d]"
			, GetMapCode(), event_string,
			guild_count_[offense_guild].first, guild_count_[defense_guild].first);

		if (DOMINATION_EVENT_MAX != curEventState_ &&
			DOMINATION_EVENT_SYSTEM_RESET == curEventState)
		{
			bReCreate_ = TRUE;
			pairKickGuild_.first = guild_count_[defense_guild].first;
			pairKickGuild_.second = guild_count_[offense_guild].first;

			kickTimer_.SetTimer(KICK_TIME);
		}


		curEventState_ = curEventState;

		MSG_AG_ZONE_DOMINATION_FIELD_INFO_SYN msg;
		msg.m_RoomKey = GetKey();
		msg.m_byEventState = curEventState;

		SendToLinkedServer(&msg, sizeof(msg));
	}
}

BOOL DominationField::Process()
{
	_UpdateTimeEvent();

	if (outsider_updatetimer_.IsExpired() &&
		false == outSider_.empty())
	{
		OUTSIDER out_sider = outSider_.front();
		outSider_.pop_front();
		User* pUser = FindUser(out_sider.first);

		if (pUser)
		{
			if (FALSE == _ReturnToEntrance(pUser))
			{
				if (out_sider.second++ > 10)  // //强制退出.
				{
					SUNLOG(eCRITICAL_LOG, "[DominationField::Process] 尝试 10 次后强制退出"
						"MapCode[%d] GUILDGUID[%d] NAME[%s]",
						GetMapCode(), pUser->GetSelectedCharGuildGuid(),
						pUser->GetSelectedCharName());

					pUser->SetDisconnectCode(RC::RC_DISCONNECTION_INVALID_CHAR_STATE);
					pUser->DisconnectUser();
				}
				else
				{
					outSider_.push_back(out_sider);
				}
			}
			else
			{
				SUNLOG(eFULL_LOG, "[DominationField::Process] out_sider_ReturnToEntrance ",
					"MapCode[%d] GUILDGUID[%d] NAME[%s]",
					GetMapCode(), pUser->GetSelectedCharGuildGuid(),
					pUser->GetSelectedCharName());
			}
		}
		else
		{
			SUNLOG(eCRITICAL_LOG, "[DominationField::Process]未找到用户 key[%d] count[%d]",
				out_sider.first, out_sider.second);
		}
	}

	if (kickTimer_.IsExpiredManual(FALSE))
	{
		_ReSetDomination();
	}

	return TRUE;
}

#ifdef _NA_006826_20130722_DOMINATION_RENEWAL
void DominationField::_KickUsers_ExceptWinGuild(GUILDGUID winner_guild)
{
	const ZONE_USER_LIST& rList = GetUserList();
	ZONE_USER_LIST::const_iterator it = rList.begin();

	while (it != rList.end())
	{
		User* const pUser = it->second;
		++it;

		if (pUser->GetSelectedCharGuildGuid() != winner_guild)
		{
			_ReturnToEntrance(pUser);   // 立即强制移动
		}
	}
}
#endif //_NA_006826_20130722_DOMINATION_RENEWAL