#include "StdAfx.h"
#include ".\guild.h"
#include ".\guildMember.h"
#include <Struct.h>
#include <PacketStruct_DZ.h>
#include <GuildServer.h>
#include <SerializeStream.h>

#include <GuildRankInfoParser.h>
#include <MaxGuildMemberInfoParser.h>

#include <Guild/GuildManager.h>

#ifdef _NA_20100604_BETTER_DOMINATION_MANAGER
    #include "DominationManager.h"
#endif

__IMPL_GUILDPOOL(Guild)
Guild::Guild(void)
{
}

Guild::~Guild(void)
{
}

VOID Guild::InitializeGuild()
{
	m_nMasterChangeTime = 0;
	ZeroMemory( &m_GuildInfo, sizeof(m_GuildInfo) );
	ZeroMemory( m_szGuildNotice, MAX_GUILDNOTICE_LENGTH * sizeof(TCHAR));

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
	memset( &m_ChuntingPVPInfo, 0, sizeof(CHUNTING_PVP_INFO) );
#endif

}

VOID Guild::ReleaseGuild()
{
	m_GuildRelationEntry.RelationRelease();
}

VOID Guild::SetGuildInfo( BASE_GUILD_INFO & IN rInfo )
{
	SerializeBaseGuildInfo( rInfo, SERIALIZE_STORE );
}

GuildMember*		Guild::FindMember( CHARGUID CharGuid )
{
	GUILD_CORPS_MAP_ITER iter;
	for( iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); iter++ )
	{
		GuildCorps* pCorps = iter->second;
		if( !pCorps )	continue;

		GuildMember* pMember = pCorps->FindMember( CharGuid );
		if( !pMember )	continue;

		return pMember;
	}

	return NULL;
}

// ??????? ???
GuildMember * Guild::FindMemberByCharName( const TCHAR* ptszCharName )
{
	GUILD_CORPS_MAP_ITER iter;
	for( iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
	{
		GuildCorps* pCorps = iter->second;
		if( !pCorps )		continue;

		GuildMember* pMember = pCorps->FindMember( ptszCharName );
		if( pMember )		return pMember;
	}

	return NULL;
}


RC::eGUILD_RESULT		Guild::CanRankUp( OUT GuildRankInfo& RankInfo )
{
	BYTE byGuildMaxLevel = GuildRankInfoParser::Instance()->GetGuildMaxLevel();

	// ???? ????? ????? ??? ???????, ?? ?????? ?? ??? ????? ?? ?? ????.
	if( m_GuildInfo.m_GuildGrade >= byGuildMaxLevel )
		return RC::RC_GUILD_MAX_GUILD_RANK;

#ifdef _NA_003923_20120130_GUILD_RENEWAL
	const GuildRankInfo* pInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo(
		static_cast<BYTE>(m_GuildInfo.m_GuildGrade + 1) );
	if( !pInfo )
		return RC::RC_GUILD_NOT_FOUND_GUILD_INFO_FOR_GRADE;

	if( m_GuildInfo.m_GuildCoin < pInfo->need_guild_coin_to_rankup_ )
		return RC::RC_GUILD_NOT_ENOUGH_UP;
#else
	GuildRankInfo* pInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( (eGUILD_GRADE)(m_GuildInfo.m_GuildGrade + 1) );
	if( !pInfo )
		return RC::RC_GUILD_NOT_FOUND_GUILD_INFO_FOR_GRADE;

	//1. UP ???
	if( m_GuildInfo.m_UserPoint < pInfo->m_UP )
		return RC::RC_GUILD_NOT_ENOUGH_UP;

	//2. GP ???
	if( m_GuildInfo.m_GuildPoint < pInfo->m_GP )
		return RC::RC_GUILD_NOT_ENOUGH_GP;
#endif

	// OUT ???
	RankInfo = *pInfo;

	return RC::RC_GUILD_SUCCESS;
}

VOID Guild::RankUp()
{
	BYTE prevGrade = (BYTE)GetGuildGrade();

#ifdef _NA_003923_20120130_GUILD_RENEWAL
	const GuildRankInfo* pInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo(
		static_cast<BYTE>(m_GuildInfo.m_GuildGrade + 1) );
	if( !pInfo )
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::RankUp()] Error!! CurGuildGrade = %d", m_GuildInfo.m_GuildGrade );
		return;
	}

	SetGuildGrade( (eGUILD_GRADE)(GetGuildGrade() + 1) );
	SetGuildCoin( m_GuildInfo.m_GuildCoin - pInfo->need_guild_coin_to_rankup_ );
	SetGuildGP( m_GuildInfo.m_GuildPoint + pInfo->reward_gp_by_levelup_ );
#else
	GuildRankInfo* pInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( (eGUILD_GRADE)( m_GuildInfo.m_GuildGrade + 1) );
	if( !pInfo )
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::RankUp()] Error!! CurGuildGrade = %d", m_GuildInfo.m_GuildGrade );
		return;
	}
	
	SetGuildGrade( (eGUILD_GRADE)(GetGuildGrade() + 1) );
	SetGuildUP( m_GuildInfo.m_UserPoint - pInfo->m_UP );
	SetGuildGP( m_GuildInfo.m_GuildPoint - pInfo->m_GP );
#endif

	GUILDLOG->LogRankUp(this, prevGrade);
}


BOOL Guild::SendDBProxy( MSG_BASE * pMsg, WORD wSize )
{

	return TRUE;
}


//??? ???
BOOL Guild::SetMemberDuty(CHARGUID CharGuid, eGUILD_DUTY eDuty)
{ 
	GuildMember* pMember = FindMember(CharGuid);
	if(!pMember) { return FALSE; }
	eGUILD_DUTY prevDuty = pMember->GetDuty();
	pMember->SetDuty(eDuty);

	GUILDLOG->LogDutyChange(this, pMember, prevDuty);

	return TRUE;
}

BOOL	Guild::IsExistMemberDuty( eGUILD_DUTY eDuty, BYTE byCorpsNum )
{
	GuildCorps* pCorps = FindCorps( byCorpsNum );
	if( !pCorps )		return FALSE;

	return FALSE;
}


VOID 				Guild::SetGuildNotice( const TCHAR* pszGuildNotice )
{
	strncpy( m_szGuildNotice, pszGuildNotice, MAX_GUILDNOTICE_LENGTH );
	m_szGuildNotice[MAX_GUILDNOTICE_LENGTH] = '\0';
}


VOID 				Guild::SetGuildName( const TCHAR* pszGuildName )
{
    strncpy(m_GuildInfo.m_tszGuildName, pszGuildName, _countof(m_GuildInfo.m_tszGuildName));
    m_GuildInfo.m_tszGuildName[_countof(m_GuildInfo.m_tszGuildName) - 1] = '\0';
}



GuildCorps* Guild::FindCorps( BYTE corps_number ) const
{
	GUILD_CORPS_MAP::const_iterator iter = m_mapGuildCorps.find(corps_number);     
	if (iter != m_mapGuildCorps.end())
	{
		GuildCorps* corps = iter->second;
		if (corps != NULL)
        {
            return corps;
        }
	}
	return NULL;
}

WORD	Guild::GetMemberCount()
{
	WORD wCount = 0;

	for( GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
	{
		GuildCorps* pCorps = iter->second;
		if( !pCorps )	continue;

		wCount += pCorps->GetMemberCount();
	}

	return wCount;	
}

//DB???? ?????? ??????? ?? ??? ???? ???????.
GuildCorps*	Guild::CreateCorps( BYTE byCorpsNum )
{
	GuildCorps* pCorps = FindCorps( byCorpsNum );
	if( pCorps )
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::CreateCorps] Already Corps Create, GuildGuid = %u, CoprsNum = %d", GetGuildGuid(), byCorpsNum );
		return NULL;
	}

	GuildCorps* pNewCorps = new GuildCorps;
	pNewCorps->SetNumber( byCorpsNum );
	m_mapGuildCorps.insert( std::make_pair( byCorpsNum, pNewCorps ) );
	return pNewCorps;
}

VOID		Guild::DestroyCorps( BYTE byCorpsNum )
{
	GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.find( byCorpsNum );
	if( iter != m_mapGuildCorps.end() )
	{
		GuildCorps* pCorps = iter->second;
		if( pCorps )		delete pCorps;
		m_mapGuildCorps.erase( iter );
	}
}

//???? ???? ?????? ?????? ???????. ( ?????????? ?????? ???????. )
GuildCorps*		Guild::CreateCorpsBySequence()
{
	BYTE byCorpsNum = GetEmptyCorpsNumBySequence();
	if( byCorpsNum == 0 )		
		return NULL;

	return CreateCorps( byCorpsNum );
}

//?? ????? ???? ????? ????? ?? ??? ?????? ????? ???????.
//???? ??? ?????? ???? ???? ?????? 0?? ???????.
//?? ??????? ???? ?????? ????? ???? ?? ????.
BYTE			Guild::GetEmptyCorpsNumBySequence()
{
#ifdef _NA_003923_20120130_GUILD_RENEWAL
	const GuildRankInfo* pInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( GetGuildGrade() );
	if( !pInfo )		return 0;
	return 0;
#else
	GuildRankInfo* pInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( GetGuildGrade() );
	if( !pInfo )		return 0;
	for( BYTE i = 1; i < pInfo->m_byCreateCopsCount; i++ )
	{
		GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.find( i );
		if( iter != m_mapGuildCorps.end() )
			continue;
		return i;
	}
	return 0;
#endif
}

GuildMember* Guild::FindMaster() const
{
	GuildCorps* corps = FindCorps(0);
	if (corps == NULL)
    {
        return NULL;
    }
	return corps->FindCommander();
}

const TCHAR* Guild::GetMasterCharName()
{
	GuildMember* pGuildMaster = FindMaster();
	if(!pGuildMaster) 
		return NULL;
	
	return pGuildMaster->GetCharName();
}

GuildMember*	Guild::FindMemberByDuty(eGUILD_DUTY eDuty)
{
	GUILD_CORPS_MAP_ITER iter;
	for( iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
	{
		GuildCorps* pCorps = iter->second;
		if(pCorps)
		{
			GuildMember* Member = pCorps->FindMemberByDuty(eDuty);
			if(Member)  return Member; 
			else	continue;
		}
	}

	return NULL;
}

VOID	Guild::CreateGuild( GUILDGUID GuidGuid, const TCHAR* tszGuildName, BYTE byCorpsNum, CHARGUID MasterCharGuid, const TCHAR* tszMasterCharName, eGUILD_DUTY MasterDuty,
							BYTE byMasterClass, LEVELTYPE MasterLevel, BYTE byChaoState, INT64 nGuildPanaltyTime, INT64 nDestroyRequestTime, INT64 nMasterChangeTime )
{
	InitializeGuild();

	SetGuildGuid( GuidGuid );
	SetGuildName( tszGuildName );
	SetGuildGrade( eGUILD_GRADE_LEGION );
	SetGuildGP( 0 );	
	SetGuildUP( 0 );
	SetPenaltyTime( nGuildPanaltyTime );
	SetDestroyTime( nDestroyRequestTime );
	SetMasterChangeTime( nMasterChangeTime );
	GuildCorps* pCorps = CreateCorps( byCorpsNum );		//???? ???? ????
	if( !pCorps )
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::CreateGuild] Corps Create Fail, GuildGuid = %u, MasterCharGuid = %u", GuidGuid, MasterCharGuid );
		return;
	}

	GuildMember* pMaster = pCorps->CreateMember( MasterCharGuid, tszMasterCharName, MasterDuty, byMasterClass, MasterLevel, byChaoState, TRUE );
	if( !pMaster )
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::CreateGuild] Corps Create GuildMaster, GuildGuid = %u, MasterCharGuid = %u", GuidGuid, MasterCharGuid );
		return;
	}
}

VOID		Guild::Destroy()
{
	GUILD_CORPS_MAP_ITER iter;
	for( iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
	{
		GuildCorps* pCorps = iter->second;
		if( pCorps )
		{
			pCorps->Destroy();
			delete pCorps;
		}
	}

	m_mapGuildCorps.clear();
}

BYTE		Guild::GetEmptyCommanderInfo( BYTE* pEmptyCommderInfo )
{
	BYTE byCount = 0;

	GUILD_CORPS_MAP_ITER iter;
	for( iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
	{
		GuildCorps* pCorps = iter->second;
		if( pCorps && !pCorps->FindCommander() )
		{
			pEmptyCommderInfo[byCount] = pCorps->GetNumber();
			byCount++;		
			if( byCount >= MAX_GUILD_CORPS_NUM )
			{
				SUNLOG( eCRITICAL_LOG, "[Guild::GetEmptyCommanderInfo] Overflow CorpsInfo, GuildGuid = %u", GetGuildGuid() );
				return 0;
			}
		}
	}

	return byCount;
}

//??? ????
RC::eGUILD_RESULT Guild::JoinGuild( BYTE byCorpsNum, CHARGUID CharGuid, const TCHAR* tszCharName, eGUILD_DUTY Duty, BYTE byClass, LEVELTYPE Level, BYTE byChaoState )
{
	GuildCorps* pCorps = FindCorps(byCorpsNum);
	if( !pCorps )
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::JoinGuild] Corps(%d) Not Exist", byCorpsNum );
		return RC::RC_GUILD_CORPS_NOT_FOUND;
	}

	//???? ?????? ???? ???????? ???? ???? ?????? ?????? ???????.
	GuildMember* pMember = pCorps->CreateMember( CharGuid, tszCharName, Duty, byClass, Level, byChaoState, TRUE );
	if( !pMember )		return RC::RC_GUILD_FAILED;
	
	return RC::RC_GUILD_SUCCESS;
}

RC::eGUILD_RESULT			Guild::LeaveGuild( CHARGUID CharGuid )
{
	GuildMember* pMember = FindMember( CharGuid );
	if( !pMember )			return RC::RC_GUILD_NOT_GUILD_MEMBER;

	GuildCorps* pCorps = FindCorps( pMember->GetCorpsNumber() );
	if( !pCorps )			return RC::RC_GUILD_CORPS_NOT_FOUND;

	pCorps->DestroyMember( CharGuid );
	
	return RC::RC_GUILD_SUCCESS;
}

RC::eGUILD_RESULT			Guild::ChangeCorps( CHARGUID CharGuid, BYTE byNewCorpsNum )
{
	GuildMember* pMember = FindMember( CharGuid );
	if( !pMember )
		return RC::RC_GUILD_NOT_GUILD_MEMBER;

	//???????? ????? ??????????? ??????.
	if( byNewCorpsNum == pMember->GetCorpsNumber() )
		return RC::RC_GUILD_SUCCESS;

	GuildCorps* pOldCorps = FindCorps( pMember->GetCorpsNumber() );
	if( !pOldCorps )
		return RC::RC_GUILD_CORPS_NOT_FOUND;

	GuildCorps* pNewCorps = FindCorps( byNewCorpsNum );
	if( !pNewCorps )
		return RC::RC_GUILD_CORPS_NOT_FOUND;

	pOldCorps->DeleteMember( CharGuid );
	pNewCorps->InsertMember( pMember );
	pMember->SetCorpsNumber( byNewCorpsNum );

	return RC::RC_GUILD_SUCCESS;
}

// ????? ? ?????.
BOOL	Guild::IsFullCorpsMemberByDuty( BYTE byCorpsNum, eGUILD_DUTY Duty )
{
	GuildCorps* pCorps = FindCorps( byCorpsNum );
	if( !pCorps )
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::IsFullMemberByCorps] Not Exist Corps, Corps = %d, Duty = %d ", byCorpsNum, Duty );
		return TRUE;
	}

	BYTE byCurCount = pCorps->GetMemberCountByDuty( Duty );
	BYTE byMaxCount = MaxGuildMemberInfoParser::Instance()->GetMaxCorpsMemberByDuty( GetGuildGrade(), byCorpsNum, Duty );
	if( byCurCount >= byMaxCount )
		return TRUE;

	return FALSE;
}

BOOL	Guild::CreateRearCamp( BYTE byCorpsNum )
{
	GuildCorps* pCorps = FindCorps( byCorpsNum );
	if( !pCorps )		return FALSE;

	pCorps->SetRearCamp( TRUE );

	return TRUE;
}

BOOL	Guild::DestroyRearCamp( BYTE byCorpsNum )
{
	GuildCorps* pCorps = FindCorps( byCorpsNum );
	if( !pCorps )		return FALSE;

	pCorps->SetRearCamp( FALSE );
	return TRUE;
}

//????? ??? ????? ???? ???.
RC::eGUILD_RESULT			Guild::DestroyMember( CHARGUID CharGuid )
{
	GuildMember* pMember = FindMember( CharGuid );
	if( !pMember )			return RC::RC_GUILD_NOT_GUILD_MEMBER;

	GuildCorps* pCorps = FindCorps( pMember->GetCorpsNumber() );
	if( !pCorps )			return RC::RC_GUILD_CORPS_NOT_FOUND;

	pCorps->DestroyMember( CharGuid );
	return RC::RC_GUILD_SUCCESS;
}

VOID Guild::SerializeBaseGuildInfo( INOUT BASE_GUILD_INFO&  rInfo, eSERIALIZE se )
{
	if( se == SERIALIZE_LOAD )
	{
		rInfo.m_GuildGuid		= GetGuildGuid();
		rInfo.m_GuildGrade		= (BYTE)GetGuildGrade();
		memcpy( rInfo.m_tszGuildName, GetGuildName(), MAX_GUILDNAME_LENGTH*sizeof(TCHAR) );
	}
	else
	{
		SetGuildGuid( rInfo.m_GuildGuid );
		SetGuildGrade( (eGUILD_GRADE)rInfo.m_GuildGrade );
		SetGuildName( rInfo.m_tszGuildName );
	}
}

VOID	Guild::SerializeGameGuildInfo( INOUT GAME_GUILD_INFO&  rInfo, eSERIALIZE se )
{
	SerializeBaseGuildInfo( rInfo, se );

	if( se == SERIALIZE_LOAD )
	{
		AcquireGuildMark(rInfo.m_BackGroundIdx, rInfo.m_PatternIdx);

	#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
		rInfo.m_ChuntingPVPInfo = m_ChuntingPVPInfo;
	#endif
	}
	else
	{
	#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
		m_ChuntingPVPInfo	= rInfo.m_ChuntingPVPInfo;
	#endif
	}
}

VOID	Guild::SerializeGuildInfo( INOUT GUILD_INFO&  rInfo, eSERIALIZE se )
{
	SerializeGameGuildInfo( rInfo, se );

	if( se == SERIALIZE_LOAD )
	{
		rInfo.m_GuildPoint		= GetGuildGP();
		rInfo.m_UserPoint		= GetGuildUP();
#ifdef _NA_003923_20120130_GUILD_RENEWAL
		rInfo.m_GuildCoin		= GetGuildCoin();
		rInfo.m_GuildGP			= m_GuildInfo.m_GuildGP;
#endif

		rInfo.m_GuildDestroyWaitFlag = CheckGuildDeleteState();
		rInfo.m_GuildPenaltyTime	= GetPenaltyTime();
		rInfo.m_GuildDestroyTime	= GetDestroyTime();
		AcquireGuildMark(rInfo.m_BackGroundIdx, rInfo.m_PatternIdx);
		rInfo.m_nMasterChangeTime	= GetMasterChangeTime();
#ifdef _NA_20100604_BETTER_DOMINATION_MANAGER
        rInfo.m_DominationMapCount = 
            DominationManager::Instance()->NumberOfDominationAreaByGuild(rInfo.m_GuildGuid);
        rInfo.m_DominationJoinCount = GetDominationJoinCount();
        rInfo.m_DominationDefenseCount = GetDominationDefenseCount();
        rInfo.m_DominationHuntingCount = GetDominationHuntingCount();
#endif
	}
	else
	{
		SetGuildGP( rInfo.m_GuildPoint );
		SetGuildUP( rInfo.m_UserPoint );
#ifdef _NA_003923_20120130_GUILD_RENEWAL
		SetGuildCoin( rInfo.m_GuildCoin );
		m_GuildInfo.m_GuildGP = rInfo.m_GuildGP;
#endif

		SetDeleteGuildState(rInfo.m_GuildDestroyWaitFlag);
		SetPenaltyTime(rInfo.m_GuildPenaltyTime);
		SetDestroyTime(rInfo.m_GuildDestroyTime);
		RegisterGuildMark(rInfo.m_BackGroundIdx, rInfo.m_PatternIdx);
		SetMasterChangeTime( rInfo.m_nMasterChangeTime );
#ifdef _NA_20100604_BETTER_DOMINATION_MANAGER
        SetDominationJointCount(rInfo.m_DominationJoinCount);
        SetDominationDefenseCount(rInfo.m_DominationDefenseCount);
        SetDominationHuntingCount(rInfo.m_DominationHuntingCount);
#endif
	}
}

VOID	Guild::SerializeCorpsInfo( INOUT GUILD_CORPS_TOTAL_INFO&  rInfo, eSERIALIZE se )
{
	if( se == SERIALIZE_LOAD )
	{
		ZeroMemory( &rInfo, sizeof(rInfo) );

		for( GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
		{
			GuildCorps* pCorps = iter->second;
			if( !pCorps )	continue;

			BYTE byCorpsNum = pCorps->GetNumber();

			rInfo.m_CorpsInfo[byCorpsNum].m_bCreate = TRUE;
			rInfo.m_CorpsInfo[byCorpsNum].m_byCorpsNum = byCorpsNum;
			rInfo.m_CorpsInfo[byCorpsNum].m_bRearCamp = pCorps->IsExistRearCamp();
		}

	}
	else //STORE
	{
		for( int i = 0 ; i < MAX_GUILD_CORPS_NUM; i++ )
		{
			if( rInfo.m_CorpsInfo[i].m_bCreate )
			{
				GuildCorps* pCorps = FindCorps( i );
				if( pCorps )
				{
					pCorps->SetRearCamp( rInfo.m_CorpsInfo[i].m_bRearCamp );
				}
				else
				{
					//DB???? ???????? ???? ?????? ??????? ???? ??????...
					GuildCorps* pNewCorps = CreateCorps( rInfo.m_CorpsInfo[i].m_byCorpsNum );
					if( pNewCorps )	pNewCorps->SetRearCamp( rInfo.m_CorpsInfo[i].m_bRearCamp );
				}
			}
		}
	}	

}

VOID Guild::SerializeBaseMemberTotalInfo( INOUT BASE_GUILD_MEMBER_TOTAL_INFO&  rInfo, eSERIALIZE se )
{
	if( se == SERIALIZE_LOAD )
	{
		rInfo.m_byMemberCount = 0;

		for( GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
		{
			GuildCorps* pCorps = iter->second;
			if( !pCorps )	continue;

			pCorps->SerializeBaseMemberTotalInfo( rInfo, se );
		}

	}
	else
	{
		SUNLOG( eCRITICAL_LOG, "[Guild::SerializeMemberInfo] ?????" );
	}

}

VOID Guild::SerializeMemberTotalInfo( INOUT GUILD_MEMBER_TOTAL_INFO&  rInfo, eSERIALIZE se )
{
	if( se == SERIALIZE_LOAD )
	{
		rInfo.m_byMemberCount = 0;

		for( GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
		{
			GuildCorps* pCorps = iter->second;
			if( !pCorps )	continue;

			pCorps->SerializeMemberTotalInfo( rInfo, se );
		}
	}
	else
	{
		//????? ???? ??? ?????? ???? ??????? ???.
		for( GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
		{
			GuildCorps* pCorps = iter->second;
			if( !pCorps )	continue;

			pCorps->SerializeMemberTotalInfo( rInfo, se );
		}
	}
}

VOID	Guild::SerializeServerMemberTotalInfo( INOUT SERVER_GUILD_MEMBER_TOTAL_INFO&  rInfo, eSERIALIZE se )
{
	if( se == SERIALIZE_LOAD )
	{
		rInfo.m_byMemberCount = 0;

		for( GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
		{
			GuildCorps* pCorps = iter->second;
			if( !pCorps )	continue;

			pCorps->SerializeServerMemberTotalInfo( rInfo, se );
		}
	}
	else
	{
		//????? ???? ??? ?????? ???? ??????? ???.
		for( GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.begin(); iter != m_mapGuildCorps.end(); ++iter )
		{
			GuildCorps* pCorps = iter->second;
			if( !pCorps )	continue;

			pCorps->SerializeServerMemberTotalInfo( rInfo, se );
		}
	}
}

BOOL		Guild::GetBaseMemberInfo( CHARGUID CharGuid, OUT BASE_GUILD_MEMBER_INFO& info )
{
	GuildMember* pMember = FindMember( CharGuid );
	if( !pMember )		return FALSE;

	pMember->SerializeBaseMemberInfo( info, SERIALIZE_LOAD );

	return TRUE;
}

BOOL		Guild::GetMemberInfo( CHARGUID CharGuid, OUT GUILD_MEMBER_INFO& info )
{
	GuildMember* pMember = FindMember( CharGuid );
	if( !pMember )		return FALSE;

	pMember->SerializeMemberInfo( info, SERIALIZE_LOAD );

	return TRUE;
}

VOID		Guild::GetWorldGuildInfo( WORLD_GUILD_INFO&  rInfo )
{
	SerializeBaseGuildInfo( rInfo, SERIALIZE_LOAD );
	CopyMemory( rInfo.m_szGuildNotice, GetGuildNotice(), MAX_GUILDNOTICE_LENGTH * sizeof(TCHAR));
}

BOOL Guild::IsFullMember()
{
#ifdef _NA_003923_20120130_GUILD_RENEWAL
	const GuildRankInfo* pGuildInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( m_GuildInfo.m_GuildGrade );
	if( !pGuildInfo )		return FALSE;
	return ( GetMemberCount() >= pGuildInfo->max_member_count_ );
#else
	GuildRankInfo* pGuildInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( (eGUILD_GRADE)m_GuildInfo.m_GuildGrade );
	if( !pGuildInfo )		return FALSE;
	return ( GetMemberCount() >= pGuildInfo->m_wMaxMember );
#endif
}

VOID Guild::ChangeGuildName( const TCHAR* pszGuildName )
{
    util::GUILDNAMECOPY(m_GuildInfo.m_tszGuildName, pszGuildName);
}

int Guild::GetRelationGuid(STLX_VECTOR<GUILDGUID>& vGuildGuid, eGUILD_RELATION RelationType)
{
	int size = m_GuildRelationEntry.GetRelationCount(RelationType);
	vGuildGuid.reserve(size);

	return m_GuildRelationEntry.GetRelationGuid(vGuildGuid,RelationType);
}