710 lines
18 KiB
C++
710 lines
18 KiB
C++
#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;
|
|
|
|
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;
|
|
|
|
// OUT 반환
|
|
RankInfo = *pInfo;
|
|
|
|
return RC::RC_GUILD_SUCCESS;
|
|
}
|
|
|
|
VOID Guild::RankUp()
|
|
{
|
|
BYTE prevGrade = (BYTE)GetGuildGrade();
|
|
|
|
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 );
|
|
|
|
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()
|
|
{
|
|
//1. 현재 길드레벨에서 가능한 군단의 개수를 가져온다.
|
|
GuildRankInfo* pInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( GetGuildGrade() );
|
|
if( !pInfo ) return NULL;
|
|
|
|
// 0은 직할 군단이다. 따라서 1부터 시작한다. 군단 최대 개수는 직할군단을 포함하는 개수이다. 따라서 "<" 비교한다.
|
|
for( BYTE i = 1; i < pInfo->m_byCreateCopsCount; i++ )
|
|
{
|
|
GUILD_CORPS_MAP_ITER iter = m_mapGuildCorps.find( i );
|
|
|
|
// i 군단이 존재하면
|
|
if( iter != m_mapGuildCorps.end() )
|
|
continue;
|
|
|
|
return i;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
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();
|
|
|
|
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 );
|
|
|
|
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()
|
|
{
|
|
GuildRankInfo* pGuildInfo = GuildRankInfoParser::Instance()->FindGuildRankInfo( (eGUILD_GRADE)m_GuildInfo.m_GuildGrade );
|
|
if( !pGuildInfo ) return FALSE;
|
|
return ( GetMemberCount() >= pGuildInfo->m_wMaxMember );
|
|
}
|
|
|
|
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);
|
|
}
|
|
|