#include "stdafx.h"

#include <list>
#include <vector>
#include <algorithm>
#include <numeric>

#include <Log/ServerLog.h>
#include <Utility/Setup/ServerSetup.h>

#include <Network/Stream/SendStream.h>
#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/WrapPacket.h>
#include <Network/Packet/PacketStruct/ServerInfo.h>
#include <Network/SendPacket/SendGuild.h>
#include <Network/Dispatch/GameDispatch.h>

#include <DB/DBComponent.h>
#include <DB/GuildDBComponent.h>

#include <DataStorage/CharacterData.h>
#include <DataStorage/CharacterDataMgr.h>
#include <DataStorage/SessionData.h>
#include <DataStorage/SessionDataMgr.h>

#include <Creature/Siege/SiegeObjectDBMgr.h>
#include <Community/Guild/GuildUtil.h>

#include "GuildDBMgr.h"
#include "GuildDB.h"

CGuildDB::CGuildDB(CDBComponent& DBComponent)
:	CGuild(), m_DBComponent(DBComponent)
{
}

CGuildDB::CGuildDB(CDBComponent& DBComponent, unsigned long dwGID, unsigned char cNation, char* szName)
:	CGuild(dwGID, cNation, szName), m_DBComponent(DBComponent)
{
}

CGuildDB::CGuildDB(CDBComponent& DBComponent, GuildInfoDB& guildInfo)
:	CGuild(guildInfo), m_DBComponent(DBComponent)
{
}

CGuildDB::~CGuildDB(void)
{
}


bool CGuildDB::SetMark(char* szMark)
{
	::memcpy(m_szMark, szMark, MAX_MARK_SIZE);
	DeductGold(Guild::SET_MARK_GOLD);

	return DBComponent::GuildDB::UpdateGuildMark(m_DBComponent, m_dwGID, m_szMark, MAX_MARK_SIZE, m_dwGold);
}

bool CGuildDB::SetLevel(unsigned char cLevel)
{
	m_cLevel = cLevel;

	unsigned long dwSetLevelGold = ms_arySetLevelGold[cLevel];

	DeductGold(dwSetLevelGold);

	return DBComponent::GuildDB::UpdateGuildLevel(m_DBComponent, m_dwGID, m_cLevel, m_dwGold);
}

// ´õÀÌ»ó ±æµå ±¹ÀûÀº º¯°æÇÒ ¼ö ¾ø½À´Ï´Ù. (2004-11-22 by ·Îµò)
/*
bool CGuildDB::SetInclination(unsigned char cInclination)
{
	m_cInclination = cInclination;

	SYSTEMTIME systemTime;
	::memset(&systemTime, 0, sizeof(SYSTEMTIME));

	GetLocalTime(&systemTime);

	m_tmChangeInclination.Year = systemTime.wYear;
	m_tmChangeInclination.Month = systemTime.wMonth;
	m_tmChangeInclination.Day = systemTime.wDay;
	m_tmChangeInclination.Hour = systemTime.wHour;
	m_tmChangeInclination.Minute = systemTime.wMinute;
	m_tmChangeInclination.Second = systemTime.wSecond;
	m_tmChangeInclination.MSecond = systemTime.wMilliseconds;

	// ÇØ´ç ±æµåÀÇ ÁøÁö¸¦ ¸ðµÎ Æı«ÇÑ´Ù.
	int nDestroyCampNum = CSiegeObjectDBMgr::GetInstance().DestroyCamp( m_dwGID ) ;

	// ¸í¼ºÄ¡ º¯°æ
	if (nDestroyCampNum > 0)
	{
		AddAllMemberFame( Guild::TYPE_VALUE, nDestroyCampNum * Siege::FAME_FOR_DESTROYED_CAMP ) ;
	}

	if (RACE_BOTH != (m_cInclination & RACE_BIT))
	{
		std::list<unsigned long> deleteList;

		for (MemberList::iterator it = m_MemberList.begin(); it != m_MemberList.end(); ++it)
		{
			MemberInfo memberInfo = *it;
			CClass::RaceType eRace = CClass::GetRace(memberInfo.m_MemberListInfo.m_cClass);

			// Á¾Á·ÀÌ ±æµå ¼ºÇâ°ú ´Ù¸£¸é °­Á¦ Å»Åð ´çÇÑ´Ù.
			if ((RACE_HUMAN == (m_cInclination & RACE_BIT) && CClass::AKHAN == eRace) || 
				(RACE_AKHAN == (m_cInclination & RACE_BIT) && CClass::HUMAN == eRace))
			{
				deleteList.push_back(memberInfo.m_dwCID);
			}
		}

		for (std::list<unsigned long>::iterator DeleteIt = deleteList.begin(); DeleteIt != deleteList.end(); ++DeleteIt)
		{
			LeaveMember(*DeleteIt);
		}

		deleteList.clear();
	}

	// WORK_LIST 2.3 °èÁ¤ ±¹Àû º¯°æ ±â´É ±¸Çö
	// ±¹Àû º¯°æÀ¸·Î ÀÎÇÑ ¸í¼ºÄ¡ °¨¼Ò
//	AddAllMemberFame( Guild::TYPE_HALF, 0 );

	return DBComponent::GuildDB::UpdateGuildInclination(m_DBComponent, m_dwGID, m_cInclination);
}
*/

bool CGuildDB::SetRight(GuildRight guildRight)
{
	m_GuildRight = guildRight;

	return DBComponent::GuildDB::UpdateGuildRight(m_DBComponent, m_dwGID, 
		reinterpret_cast<char *>(&guildRight), sizeof(GuildRight));
}

bool CGuildDB::SetTitle(unsigned long dwCID, unsigned char cTitle)
{
/*	// Å×½ºÆ®
	{
		int iTest = 0;
		for (MemberList::iterator it = m_MemberList.begin(); it != m_MemberList.end(); ++it)
		{
			MemberInfo memberInfo = *it;
			if (JOIN_WAIT == memberInfo.m_MemberListInfo.m_cTitle && 0 == memberInfo.m_cTactics)
			{
				iTest++;
			}
		}
	}
*/

	MemberList::iterator it = m_MemberList.begin();
	for (; it != m_MemberList.end(); ++it)
	{
		if (dwCID == it->m_dwCID)
		{
			break;
		}
	}

	if (it == m_MemberList.end()) 
	{ 
		return E_NOT_MEMBER; 
	}

	MemberInfo& memberInfo = *it;

	SYSTEMTIME systemTime;
	::memset(&systemTime, 0, sizeof(SYSTEMTIME));

	memberInfo.m_MemberListInfo.m_cTitle = cTitle;

	// Å»Åð ½Åû
	if (LEAVE_WAIT == cTitle)
	{
		GetLocalTime(&systemTime);

		memberInfo.m_LeaveGuildTime.Year = systemTime.wYear;
		memberInfo.m_LeaveGuildTime.Month = systemTime.wMonth;
		memberInfo.m_LeaveGuildTime.Day = systemTime.wDay;
		memberInfo.m_LeaveGuildTime.Hour = systemTime.wHour;
		memberInfo.m_LeaveGuildTime.Minute = systemTime.wMinute;
		memberInfo.m_LeaveGuildTime.Second = systemTime.wSecond;
		memberInfo.m_LeaveGuildTime.MSecond = systemTime.wMilliseconds;
	}
	else
	{
		::memset(&memberInfo.m_LeaveGuildTime, 0, sizeof(TIME));
	}

	return DBComponent::GuildDB::UpdateMemberTitle(m_DBComponent, dwCID, cTitle, systemTime);
}

bool CGuildDB::SetRelation(unsigned long dwTargetGID, unsigned char cRelationType, unsigned char cActorType, unsigned char cInsert)
{
	switch (cActorType)
	{
		// ³»°¡ ´ë»ó ±æµå¿¡ ¼±¾ð
		case Guild::BY_MINE:
		{
			switch (cRelationType)
			{
				case Guild::HOSTILITY:
				case Guild::ALERT_HOSTILITY:
				case Guild::COUNTER_HOSTILITY:
				{
					unsigned char cOldRelation = GetRelation(dwTargetGID);
					if (Guild::NEUTRALITY == cOldRelation || Guild::MINE == cOldRelation)
					{
						if(cInsert == 0)
						{
							// ¾÷µ¥ÀÌÆ®
							if (!DBComponent::GuildDB::UpdateGuildRelation(m_DBComponent, m_dwGID, dwTargetGID, cRelationType))
							{
								ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è DB ¿¡ ¾÷µ¥ÀÌÆ® ½ÇÆÐ",
										m_dwGID, dwTargetGID, cRelationType);
								return false;
							}
						}
						else
						{
							// Ãß°¡
							if (!DBComponent::GuildDB::InsertGuildRelation(m_DBComponent, m_dwGID, dwTargetGID, cRelationType))
							{
								ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è DB ¿¡ Ãß°¡ ½ÇÆÐ",
										m_dwGID, dwTargetGID, cRelationType);
								return false;
							}
						}

						RelationMap::iterator itr = m_Relation[Guild::BY_MINE].find(dwTargetGID);
						if (itr != m_Relation[Guild::BY_MINE].end())
						{
							itr->second = cRelationType;
						}
						else
						{
							if (!m_Relation[Guild::BY_MINE].insert(std::make_pair(dwTargetGID, cRelationType)).second)
							{
								ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è Ãß°¡ ½ÇÆÐ",
										m_dwGID, dwTargetGID, cRelationType);
								return false;
							}
						}
					}
					else
					{
						// ¾÷µ¥ÀÌÆ®
						if (!DBComponent::GuildDB::UpdateGuildRelation(m_DBComponent, m_dwGID, dwTargetGID, cRelationType))
						{
							ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è DB ¿¡ ¾÷µ¥ÀÌÆ® ½ÇÆÐ",
									m_dwGID, dwTargetGID, cRelationType);
							return false;
						}

						RelationMap::iterator itr = m_Relation[Guild::BY_MINE].find(dwTargetGID);
						if (itr != m_Relation[Guild::BY_MINE].end())
						{
							itr->second = cRelationType;
						}
						else
						{
							ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è ¾÷µ¥ÀÌÆ® ½ÇÆÐ (±æµå °ü°è¸¦ ãÀ»¼ö ¾øÀ½)",
									m_dwGID, dwTargetGID, cRelationType);
							return false;
						}
					}

					break;
				}

				case Guild::NEUTRALITY:
				{
					// A->B¿¡°Ô ÀϹæÀûÀ¸·Î Àû´ë¼±¾ðÀ» ÇÑ´ÙÀ½
					// ÀϹæÀûÀ¸·Î A->B¿¡°Ô ÆòÈ­¼±¾ðÀ» ÇßÀ¸¸é.. DB´Â 5·Î Áö¿öÁØ´Ù.
					// ±×¸®°í ³ªÀÚ½ÅÇÑÅ×´Â Á¦°ÅÇØÁØ´Ù.

					// Á¤º¸ ¾÷µ¥ÀÌÆ®
					// ÀÌÁ¦ Á¤º¸»óÅ°¡ 5·Î ¹Ù²¼±â¶§¹®¿¡ TargetGuild°¡ ÆòÈ­¼±¾ðÀ» ÇØÁÖÁö ¾ÊÀ¸¸é ¾ÈµÈ´Ù.
					if (!DBComponent::GuildDB::UpdateGuildRelation(m_DBComponent, m_dwGID, dwTargetGID, Guild::TARGET_NEUTRALITY))
					{
						ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è DB ¿¡ ¾÷µ¥ÀÌÆ® ½ÇÆÐ",
								m_dwGID, dwTargetGID, Guild::TARGET_NEUTRALITY);
						return false;
					}

/*
					// »èÁ¦
					if (!DBComponent::GuildDB::DeleteGuildRelation(m_DBComponent, m_dwGID, dwTargetGID))
					{
						ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è DB ¿¡ »èÁ¦ ½ÇÆÐ",
								m_dwGID, dwTargetGID, cRelationType);
						return false;
					}
*/
					RelationMap::iterator itr = m_Relation[Guild::BY_MINE].find(dwTargetGID);
					if (itr != m_Relation[Guild::BY_MINE].end())
					{
						m_Relation[Guild::BY_MINE].erase(itr);
					}
					else
					{
						ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è »èÁ¦ ½ÇÆÐ (±æµå °ü°è¸¦ ãÀ»¼ö ¾øÀ½)",
								m_dwGID, dwTargetGID, cRelationType);
						return false;
					}

					break;
				}

				default: return false;
			}

			break;
		}

		// ´ë»ó ±æµå°¡ ³ª¿¡°Ô ¼±¾ð
		case Guild::BY_TARGET:
		{
			switch (cRelationType)
			{
				case Guild::TARGET_NEUTRALITY:
				{
					// »èÁ¦
					if (!DBComponent::GuildDB::DeleteGuildRelation(m_DBComponent, dwTargetGID, m_dwGID, Guild::TARGET_NEUTRALITY))
					{
						ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è DB ¿¡ »èÁ¦ ½ÇÆÐ",
								m_dwGID, dwTargetGID, cRelationType);
						return false;
					}

					// ³ª ÀÚ½ÅÀÌ ³ª¿¡°Ô Á¤ÀÇµÈ Å¸Äϱæµå¸¦ »èÁ¦ÇÏ´Â ·ÎÁ÷ÀÌ´Ù.
					RelationMap::iterator itr = m_Relation[Guild::BY_TARGET].find(dwTargetGID);
					if (itr != m_Relation[Guild::BY_TARGET].end())
					{
						m_Relation[Guild::BY_TARGET].erase(itr);
					}
					else
					{
						ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è »èÁ¦ ½ÇÆÐ (±æµå °ü°è¸¦ ãÀ»¼ö ¾øÀ½)",
								dwTargetGID, m_dwGID, cRelationType);
						return false;
					}
					break;
				}

				case Guild::HOSTILITY:
				case Guild::ALERT_HOSTILITY:
				case Guild::COUNTER_HOSTILITY:
				{
					RelationMap::iterator itr = m_Relation[Guild::BY_TARGET].find(dwTargetGID);
					if (itr != m_Relation[Guild::BY_TARGET].end())
					{
						itr->second = cRelationType;
					}
					else
					{
						m_Relation[Guild::BY_TARGET].insert(std::make_pair(dwTargetGID, cRelationType)).second;
					}

					break;
				}

				case Guild::NEUTRALITY:
				{
					// Àû´ë¸¦ Guild::TARGET_NEUTRALITY·Î ¹Ù²ãÁà¾ßÇÑ´Ù.
					RelationMap::iterator itr = m_Relation[Guild::BY_TARGET].find(dwTargetGID);
					if (itr != m_Relation[Guild::BY_TARGET].end())
					{
						itr->second = Guild::TARGET_NEUTRALITY;
					}
					else
					{
						m_Relation[Guild::BY_TARGET].insert(std::make_pair(dwTargetGID, Guild::TARGET_NEUTRALITY)).second;
					}

					break;
/*
					// ÀÌ ºÎºÐÀº Guild::TARGET_NEUTRALITY ¿©±â¿¡¼­ »©ÁֹǷΠ¿©±â¼­´Â »©¼­´Â ¾ÈµÈ´Ù.
					RelationMap::iterator itr = m_Relation[Guild::BY_TARGET].find(dwTargetGID);
					if (itr != m_Relation[Guild::BY_TARGET].end())
					{
						m_Relation[Guild::BY_TARGET].erase(itr);
					}
					else
					{
						ERRLOG3(g_Log, "GID:0x%08x  TargetGID:0x%08x  Relation:%d  ±æµå °ü°è »èÁ¦ ½ÇÆÐ (±æµå °ü°è¸¦ ãÀ»¼ö ¾øÀ½)",
								dwTargetGID, m_dwGID, cRelationType);
						return false;
					}

					break;
*/
				}
				default: return false;
			}

			break;
		}
	}

	return true;
}

void CGuildDB::DeleteRelation()
{
	std::vector<unsigned long> vecTargetGID;
	vecTargetGID.reserve(m_Relation[Guild::BY_MINE].size());

	RelationMap::iterator itr = m_Relation[Guild::BY_MINE].begin();
	while (itr != m_Relation[Guild::BY_MINE].end())
	{
		vecTargetGID.push_back(itr->first);
		++itr;
	}

	std::vector<unsigned long>::iterator vecItr = vecTargetGID.begin();
	while (vecItr != vecTargetGID.end())
	{
		CGuildDBMgr::GetInstance().SetRelation(GetGID(), (*vecItr), Guild::NEUTRALITY);

		PktGuildRelation pktGuildRelation;
		memset(&pktGuildRelation, 0, sizeof(PktGuildRelation));

		pktGuildRelation.m_dwCID = 0;
		pktGuildRelation.m_dwGID = GetGID();
		pktGuildRelation.m_dwTargetGID = (*vecItr);
		pktGuildRelation.m_dwValue = 0;
		pktGuildRelation.m_cSubCmd = PktGuildRelation::GR_PEACE;

		if(PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktGuildRelation), 
			sizeof(PktGuildRelation), CmdGuildRelation, 0, 0))
		{
			DBAgent::CGameDispatch::GetDispatchTable().Process(CSendPacketAllServer(
					reinterpret_cast<char*>(&pktGuildRelation), 
					sizeof(PktGuildRelation), CmdGuildRelation));
		}

		++vecItr;
	}
}

void CGuildDB::CancelAlertAndCounterHostility()
{
	std::vector<unsigned long> vecTargetGID;
	vecTargetGID.reserve(m_Relation[Guild::BY_MINE].size());

	RelationMap::iterator itr = m_Relation[Guild::BY_MINE].begin();
	while (itr != m_Relation[Guild::BY_MINE].end())
	{
		if (itr->second == Guild::ALERT_HOSTILITY ||
			itr->second == Guild::COUNTER_HOSTILITY)
		{
			vecTargetGID.push_back(itr->first);
		}

		++itr;
	}

	std::vector<unsigned long>::iterator vecItr = vecTargetGID.begin();
	while (vecItr != vecTargetGID.end())
	{
		CGuildDBMgr::GetInstance().SetRelation(GetGID(), (*vecItr), Guild::NEUTRALITY);

		PktGuildRelation pktGuildRelation;
		memset(&pktGuildRelation, 0, sizeof(PktGuildRelation));

		pktGuildRelation.m_dwCID = 0;
		pktGuildRelation.m_dwGID = GetGID();
		pktGuildRelation.m_dwTargetGID = (*vecItr);
		pktGuildRelation.m_dwValue = 0;
		pktGuildRelation.m_cSubCmd = PktGuildRelation::GR_PEACE;

		if(PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktGuildRelation), 
			sizeof(PktGuildRelation), CmdGuildRelation, 0, 0))
		{
			DBAgent::CGameDispatch::GetDispatchTable().Process(CSendPacketAllServer(
				reinterpret_cast<char*>(&pktGuildRelation), 
				sizeof(PktGuildRelation), CmdGuildRelation));
		}

		++vecItr;
	}
}

void CGuildDB::CancelAlertHostility(unsigned long dwTargetGID)
{
	CGuildDBMgr::GetInstance().SetRelation(GetGID(), dwTargetGID, Guild::NEUTRALITY);

	PktGuildRelation pktGuildRelation;
	memset(&pktGuildRelation, 0, sizeof(PktGuildRelation));

	pktGuildRelation.m_dwCID = 0;
	pktGuildRelation.m_dwGID = GetGID();
	pktGuildRelation.m_dwTargetGID = dwTargetGID;
	pktGuildRelation.m_dwValue = 0;
	pktGuildRelation.m_cSubCmd = PktGuildRelation::GR_PEACE;

	if(PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktGuildRelation), 
		sizeof(PktGuildRelation), CmdGuildRelation, 0, 0))
	{
		DBAgent::CGameDispatch::GetDispatchTable().Process(CSendPacketAllServer(
			reinterpret_cast<char*>(&pktGuildRelation), 
			sizeof(PktGuildRelation), CmdGuildRelation));
	}
}

// ------------------------------------------------------------------------------------------------
// ±æµå ±Ý°í ¹æÃâ
//
// Input : dwGold - ¹æÃâÇÏ´Â ÃÑ ±Ý¾×
// Return : unsigned long - ±æµå¿ø ÇÑ ¸í´ç ¾ò°ÔµÇ´Â ±Ý¾×
// ------------------------------------------------------------------------------------------------
unsigned long CGuildDB::ReleaseGold(unsigned long dwGold)
{
	// °¡ÀÔ ´ë±âÀÚ¿Í Å»Åð ´ë±âÀÚ´Â Á¦¿Ü
    MemberList::difference_type nMemberNum = 
        std::count_if(m_MemberList.begin(), m_MemberList.end(), IsCurrentMember());

	if (0 == nMemberNum)
	{
		ERRLOG1(g_Log, "GID:%10u ±æµå¿øÀÌ ¾ø´Â ±æµåÀÔ´Ï´Ù.", m_dwGID);
		return 0;
	}

	unsigned long dwGoldPerChar = dwGold / nMemberNum;
	unsigned long dwDeductGold = dwGoldPerChar * nMemberNum;

	if (m_dwGold < dwDeductGold || 0 == dwGoldPerChar)
	{
		return 0;
	}

	// Çѹøµµ ·Î±×ÀÎ ÇÏÁö¾Ê¾Æ ij½ÃDB¿¡µµ ¾ø´Â ±æµå¿øÀÇ °æ¿ì DB¿¡ Á÷Á¢ µ·À» ³Ö¾îÁØ´Ù. 
	// (½ÇÁ¦·Î´Â ±æµå¿ø Àü¿øÀÌ ¾÷µ¥ÀÌÆ®µÇÁö¸¸ Á¢¼ÓÇÑ Ä³¸¯Å͵éÀº Á¤º¸°¡ ¸®Ç÷¹À̽ºµÇ¹Ç·Î Àǹ̾ø´Ù.)
	if (!DBComponent::GuildDB::ReleaseGold(m_DBComponent, m_dwGID, dwGoldPerChar))
	{
		ERRLOG1(g_Log, "GID:%10u ±æµå ±Ý°í ¹æÃâ ½ÇÆÐ : DB ¿¡·¯.", m_dwGID);
		return 0;
	}

	DeductGold(dwDeductGold);

	for (MemberList::iterator it = m_MemberList.begin(); it != m_MemberList.end(); ++it)
	{
		if (IsCurrentMember()(*it))
		{
			MemberInfo memberInfo = *it;

            using namespace DBAgent::DataStorage;

            CSessionData*   lpSessionData = 
                CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

            CCharacterData* lpCharacterData = 0;

			if (0 == lpSessionData || 0 == (lpCharacterData = lpSessionData->GetCharacterData()))
			{
				// ·Î±×¾Æ¿ôÇÑ ±æµå¿øµé¿¡°Ôµµ ³ª´²ÁØ´Ù.
                lpCharacterData = static_cast<CCharacterData*>(
                    CCharacterDataMgr::GetInstance().GetLogoutData(memberInfo.m_dwCID));
			}

			if (0 != lpCharacterData)
			{
                CHAR_INFOST charInfoST = lpCharacterData->GetInfo();

                if(charInfoST.Gold <= ULONG_MAX - dwGoldPerChar)
                {
                    charInfoST.Gold += dwGoldPerChar;
                }
                else
                {
                    SERLOG4(g_Log, "GID:%10u / CID:%10 / Gold:%10u / GoldPerChar:%10u / "
                        "±æµå ±Ý¾× ¹æÃâ½Ã¿¡, µ·ÀÌ 42¾ïÀ» ³ÑÀº »ç¶÷ÀÌ ÀÖ½À´Ï´Ù. 42¾ïÀ¸·Î ¸ÂÃä´Ï´Ù", 
                        m_dwGID, memberInfo.m_dwCID, charInfoST.Gold, dwGoldPerChar);

                    charInfoST.Gold = ULONG_MAX;
                }

                lpCharacterData->SetInfo(charInfoST);
			}
		}
	}

	return dwGoldPerChar;
}

unsigned long CGuildDB::SetNewMaster(void)
{
	// Â÷±â ±æµå ¸¶½ºÅÍ´Â ·£´ýÀ¸·Î ¼±ÃâÇ쵂 Á÷À§°¡ ³ôÀº ±æµå¿øÀ» ¿ì¼±½Ã ÇÑ´Ù.
	MemberList vecShuffleList(m_MemberList.size());
	std::copy(m_MemberList.begin(), m_MemberList.end(), vecShuffleList.begin());
	std::random_shuffle(vecShuffleList.begin(), vecShuffleList.end());

	MemberList::iterator it = vecShuffleList.begin();
	for (; it != vecShuffleList.end(); ++it)
	{
		MemberInfo memberInfo = *it;
		if (MIDDLE_ADMIN == memberInfo.m_MemberListInfo.m_cTitle)
		{
			SetTitle(memberInfo.m_dwCID, MASTER);
			return memberInfo.m_dwCID;
		}
	}

	for (it = vecShuffleList.begin(); it != vecShuffleList.end(); ++it)
	{
		MemberInfo memberInfo = *it;
		if (COMMON == memberInfo.m_MemberListInfo.m_cTitle)
		{
			if(!memberInfo.m_cTactics)
			{
				SetTitle(memberInfo.m_dwCID, MASTER);
				return memberInfo.m_dwCID;
			}					
		}
	}

	return 0;
}

int	 CGuildDB::GetLoginedTotalMemberNum() const
{
	if (0 == m_MemberList.size()) return 0;

	int nLoginedMemberNum = 0;

	MemberList::const_iterator it = m_MemberList.begin();
	MemberList::const_iterator end = m_MemberList.end();

	while (it != end)
	{
		const MemberInfo& memberInfo = *it;

		using namespace DBAgent::DataStorage;

		CSessionData*   lpSessionData = 
			CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

		if (lpSessionData && CSessionData::SE_CHAR_ENABLED == lpSessionData->GetSessionState())
		{
			++nLoginedMemberNum;
		}

		++it;
	}

	return nLoginedMemberNum;
}

int  CGuildDB::GetLoginedCurrentMemberNum() const
{
	if (0 == m_MemberList.size()) return 0;

	int nLoginedMemberNum = 0;

	MemberList::const_iterator it = m_MemberList.begin();
	MemberList::const_iterator end = m_MemberList.end();

	while (it != end)
	{
		const MemberInfo& memberInfo = *it;

		if (true == IsCurrentMember()(memberInfo))
		{
			using namespace DBAgent::DataStorage;

			CSessionData*   lpSessionData = 
				CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

			if (lpSessionData && CSessionData::SE_CHAR_ENABLED == lpSessionData->GetSessionState())
			{
				++nLoginedMemberNum;
			}
		}

		++it;
	}

	return nLoginedMemberNum;
}

void CGuildDB::AddAllMemberFame(unsigned char cType, int nFame, Guild::CGuildDB* lpEnemyGuild)
{
	if (0 == m_MemberList.size()) return;

	MemberList::iterator it = m_MemberList.begin();
	MemberList::iterator end = m_MemberList.end();

	while (it != end)
	{
		MemberInfo& memberInfo = *it;

		if (true == IsCurrentMember()(memberInfo))
		{
			using namespace DBAgent::DataStorage;

			CSessionData*   lpSessionData = 
				CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

			CCharacterData* lpCharacterData = 0;

			if (0 == lpSessionData || 0 == (lpCharacterData = lpSessionData->GetCharacterData()))
			{
				// ij¸¯ÅÍ°¡ ¾È¸Å´Þ·ÁÀÖ´Â °æ¿ì, ij¸¯Å͸¦ ºÒ·¯¿Â´Ù.
				lpCharacterData = static_cast<CCharacterData*>(
					CCharacterDataMgr::GetInstance().GetLogoutData(memberInfo.m_dwCID));

				if (0 != lpCharacterData)
				{
					CHAR_INFOST charInfoST = lpCharacterData->GetInfo();

					if (Guild::TYPE_VALUE == cType)
					{
						if (nFame < 0 && static_cast<unsigned long>(abs(nFame)) > charInfoST.Fame) 
						{
							charInfoST.Fame = 0;
						}
						else 
						{
							charInfoST.Fame += nFame;
						}
					}
					else if (Guild::TYPE_HALF == cType)
					{
						charInfoST.Fame /= 2;
					}

					lpCharacterData->SetInfo(charInfoST);
				}
			}
			else if(CSessionData::SE_CHAR_ENABLED == lpSessionData->GetSessionState())
			{
				// °ÔÀÓ¿¡ Á¢¼ÓÇØ ÀÖ´Â À¯ÀúÀÏ °æ¿ì
				SERVER_ID serverID;
				serverID.dwID = memberInfo.m_dwServerID;

				// ÇØ´ç Á¸ ¼­¹ö¿¡°Ô ÆÐŶ Àü¼Û
				if(lpEnemyGuild)
				{
					DBAgent::SendPacket::GuildMemberFameUpdate(
						memberInfo.m_dwCID, m_dwGID, cType, nFame, serverID.GetZone(), lpEnemyGuild->GetGID());
				}
				else
				{
					DBAgent::SendPacket::GuildMemberFameUpdate(memberInfo.m_dwCID, m_dwGID, cType, nFame, serverID.GetZone(), 0);
				}
			}
		}

		++it;
	}
}

void CGuildDB::AddLoginedMemberFame(unsigned char cType, int nFame, Guild::CGuildDB* lpEnemyGuild)
{
	if (0 == m_MemberList.size()) return;

	MemberList::iterator it = m_MemberList.begin();
	MemberList::iterator end = m_MemberList.end();

	while (it != end)
	{
		MemberInfo& memberInfo = *it;

		if (true == IsCurrentMember()(memberInfo))
		{
			using namespace DBAgent::DataStorage;

			CSessionData*   lpSessionData = 
				CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

			if (lpSessionData && CSessionData::SE_CHAR_ENABLED == lpSessionData->GetSessionState())
			{
				// °ÔÀÓ¿¡ Á¢¼ÓÇØ ÀÖ´Â À¯ÀúÀÏ °æ¿ì
				SERVER_ID serverID;
				serverID.dwID = memberInfo.m_dwServerID;

				if(lpEnemyGuild)
				{
					// ÇØ´ç Á¸ ¼­¹ö¿¡°Ô ÆÐŶ Àü¼Û
					DBAgent::SendPacket::GuildMemberFameUpdate(
						memberInfo.m_dwCID, m_dwGID, cType, nFame, serverID.GetZone(), lpEnemyGuild->GetGID());
				}
				else
				{
					// Àû´ë ±æµå°¡ ¾øÀ¸¸é 0À¸·Î Àü´Þ.
					// ÇØ´ç Á¸ ¼­¹ö¿¡°Ô ÆÐŶ Àü¼Û
					DBAgent::SendPacket::GuildMemberFameUpdate(
						memberInfo.m_dwCID, m_dwGID, cType, nFame, serverID.GetZone(), 0);
				}
			}
		}

		++it;
	}
}


void CGuildDB::AddMemberFame(unsigned char cType, unsigned long dwCID, int nFame)
{
	if (0 == m_MemberList.size()) return;

	MemberList::iterator it = m_MemberList.begin();
	for (; it != m_MemberList.end(); ++it)
	{
		if ((*it).m_dwCID == dwCID)
		{
			break;
		}
	}

	if (it == m_MemberList.end()) 
	{ 
		ERRLOG2(g_Log, "GID:%10u ±æµå ¸â¹ö°¡ ¾Æ´Ñ ij¸¯ÅÍÀÇ ¸í¼ºÄ¡¸¦ º¯°æÇÏ·Á ÇÕ´Ï´Ù. (CID : 0x%08x)", m_dwGID, dwCID);
		return;
	}

	MemberInfo& memberInfo = *it;

	using namespace DBAgent::DataStorage;

	CSessionData*   lpSessionData = 
		CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

	CCharacterData* lpCharacterData = 0;

	if (0 == lpSessionData || 0 == (lpCharacterData = lpSessionData->GetCharacterData()))
	{
		// ij¸¯ÅÍ°¡ ¾È¸Å´Þ·ÁÀÖ´Â °æ¿ì, ij¸¯Å͸¦ ºÒ·¯¿Â´Ù.
		lpCharacterData = static_cast<CCharacterData*>(
			CCharacterDataMgr::GetInstance().GetLogoutData(memberInfo.m_dwCID));

		if (0 != lpCharacterData)
		{
			CHAR_INFOST charInfoST = lpCharacterData->GetInfo();

			if (Guild::TYPE_VALUE == cType)
			{
				if (nFame < 0 && static_cast<unsigned long>(abs(nFame)) > charInfoST.Fame) 
				{
					charInfoST.Fame = 0;
				}
				else 
				{
					charInfoST.Fame += nFame;
				}
			}
			else if (Guild::TYPE_HALF == cType)
			{
				charInfoST.Fame /= 2;
			}

			lpCharacterData->SetInfo(charInfoST);
		}
	}
	else if(CSessionData::SE_CHAR_ENABLED == lpSessionData->GetSessionState())
	{
		// °ÔÀÓ¿¡ Á¢¼ÓÇØ ÀÖ´Â À¯ÀúÀÏ °æ¿ì
		SERVER_ID serverID;
		serverID.dwID = memberInfo.m_dwServerID;

		// ÇØ´ç Á¸ ¼­¹ö¿¡°Ô ÆÐŶ Àü¼Û
		DBAgent::SendPacket::GuildMemberFameUpdate(
			memberInfo.m_dwCID, m_dwGID, cType, nFame, serverID.GetZone());
	}
}

void CGuildDB::AddGoldToMaster(unsigned long dwGold)
{
	if (0 == m_MemberList.size()) return;

	MemberInfo& memberInfo = GetMaster();

	using namespace DBAgent::DataStorage;

	CSessionData*   lpSessionData = 
		CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

	CCharacterData* lpCharacterData = 0;

	if (0 == lpSessionData || 0 == (lpCharacterData = lpSessionData->GetCharacterData()))
	{
		// ij¸¯ÅÍ°¡ ¾È¸Å´Þ·ÁÀÖ´Â °æ¿ì, ij¸¯Å͸¦ ºÒ·¯¿Â´Ù.
		lpCharacterData = static_cast<CCharacterData*>(
			CCharacterDataMgr::GetInstance().GetLogoutData(memberInfo.m_dwCID));

		if (0 != lpCharacterData)
		{
			CHAR_INFOST charInfoST = lpCharacterData->GetInfo();

			if (charInfoST.Gold <= ULONG_MAX - dwGold)
			{
				charInfoST.Gold += dwGold;
			}
			else
			{
				ERRLOG1(g_Log, "CID : 0x%08x µ· ¿À¹ö ÇÃ·Î¿ì ¹ß»ý", memberInfo.m_dwCID);
			}

			lpCharacterData->SetInfo(charInfoST);
		}
	}		
	else if(CSessionData::SE_CHAR_ENABLED == lpSessionData->GetSessionState())
	{
		// °ÔÀÓ¿¡ Á¢¼ÓÇØ ÀÖ´Â À¯ÀúÀÏ °æ¿ì
		SERVER_ID serverID;
		serverID.dwID = memberInfo.m_dwServerID;

		// ÇØ´ç Á¸ ¼­¹ö¿¡°Ô ÆÐŶ Àü¼Û
		DBAgent::SendPacket::GuildMemberGoldUpdate(
			memberInfo.m_dwCID, m_dwGID, dwGold, serverID.GetZone());
	}
}

bool CGuildDB::JoinMember(MemberInfo& memberInfo)
{
	MemberList::iterator it = m_MemberList.begin();
	for (; it != m_MemberList.end(); ++it)
	{
		if (memberInfo.m_dwCID == it->m_dwCID)
		{
			break;
		}
	}

	if (it != m_MemberList.end()) 
	{ 
		ERRLOG1(g_Log, "GID:%10u ±æµå ¸â¹ö Ãß°¡ ½ÇÆÐ : ÀÌ¹Ì °¡ÀԵǾî ÀÖ´Â ¸â¹öÀÔ´Ï´Ù.", m_dwGID);
		return false; 
	}

	m_MemberList.push_back(memberInfo);

	if (DELETE_GUILD_MEMBER_NUM <= GetCurrentAllMember())
	{
		::memset(&m_tmCheckMember, 0, sizeof(TIME));

		SYSTEMTIME systemTime;
		::memset(&systemTime, 0, sizeof(SYSTEMTIME));

		DBComponent::GuildDB::UpdateGuildTime(m_DBComponent, m_dwGID, MEMBER_NUM_DOWN, systemTime);
	}

    // ÇöÀç ·Î±×ÀÎÇØ ÀÖÀ¸¸é GID¸¦ Àç¼³Á¤ÇØÁØ´Ù.
    // ·Î±×ÀÎ ÇÑ Ä³¸¯Å͸¸ ±æµå¿¡ °¡ÀÔÇØ ÀÖÀ¸¹Ç·Î ·Î±×¾Æ¿ô DBÀ» °Ë»öÇÒ ÇÊ¿ä´Â ¾ø´Ù.

    using namespace DBAgent::DataStorage;

    CSessionData*   lpSessionData = CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);
    CCharacterData* lpCharacterData = 0;

    if (0 != lpSessionData && (0 != (lpCharacterData = lpSessionData->GetCharacterData())))
    {
        lpCharacterData->SetGID(m_dwGID);
    }

	return true;
}

bool CGuildDB::LeaveMember(unsigned long dwCID)
{
	MemberList::iterator it = m_MemberList.begin();
	for (; it != m_MemberList.end(); ++it)
	{
		if (dwCID == it->m_dwCID)
		{
			break;
		}
	}

	if (it == m_MemberList.end()) 
	{ 
		ERRLOG2(g_Log, "GID:%10u ±æµå ¸â¹ö »èÁ¦ ½ÇÆÐ : ±æµå¿øÀÌ ¾Æ´Ñ ij¸¯ÅÍÀÔ´Ï´Ù. CID:%10u", 
			m_dwGID, dwCID);
		return false; 
	}

	MemberInfo memberInfo = *it;

	if (false == DBComponent::GuildDB::DeleteGuildMember(m_DBComponent, m_dwGID, dwCID, memberInfo.m_MemberListInfo.m_cRank))
	{
		ERRLOG2(g_Log, "GID:%10u ±æµå ¸â¹ö »èÁ¦ ½ÇÆÐ : DB¿¡¼­ »èÁ¦ ½ÇÆÐ. CID:%10u", m_dwGID, dwCID);
		return false;
	}

	// WORK_LIST 2.3 °èÁ¤ ±¹Àû º¯°æ ±â´É ±¸Çö
	// ±æµå ±¹°¡ º¯°æÀ¸·Î Å»ÅðµÉ½Ã, Å»Åð ´ë±âÀÚÈÄ Å»Åð ½Ã, ÃàÃâ´çÇҽà ¸ðµÎ ¸í¼ºÀÌ °¨¼ÒÇÑ´Ù.
//	AddMemberFame(Guild::TYPE_HALF, dwCID, 0);

	// ÇØ´ç ij¸¯ÅÍÀÇ °ø¼º º´±âµéÀ» ¸ðµÎ Æı«ÇÑ´Ù. (³²Àº HP¿¡ ºñ·ÊÇÏ°Ô ÀÚÀç °¹¼ö¿Í ½ºÅ¸Æ®Å¶À» µ¹·ÁÁØ´Ù.)
	CSiegeObjectDBMgr::GetInstance().DestroySiegeArms(dwCID);

	m_MemberList.erase(it);

	if (DELETE_GUILD_MEMBER_NUM > GetCurrentMemberNum())
	{
		SYSTEMTIME systemTime;
		::memset(&systemTime, 0, sizeof(SYSTEMTIME));

		GetLocalTime(&systemTime);

		m_tmCheckMember.Year = systemTime.wYear;
		m_tmCheckMember.Month = systemTime.wMonth;
		m_tmCheckMember.Day = systemTime.wDay;
		m_tmCheckMember.Hour = systemTime.wHour;
		m_tmCheckMember.Minute = systemTime.wMinute;
		m_tmCheckMember.Second = systemTime.wSecond;
		m_tmCheckMember.MSecond = systemTime.wMilliseconds;

		DBComponent::GuildDB::UpdateGuildTime(m_DBComponent, m_dwGID, MEMBER_NUM_DOWN, systemTime);
	}

    using namespace DBAgent::DataStorage;

    CSessionData* lpSessionData = 
        CSessionDataMgr::GetInstance().GetCharLoadedSession(memberInfo.m_dwCID);

    CCharacterData* lpCharacterData = 0;

    // ¿­¸° ¼¼¼ÇÀÌ ¾ø°Å³ª. ¿­·È´Ù ÇÏ´õ¶óµµ µ¥ÀÌÅÍ°¡ ¾ø´Â °æ¿ì´Â ·Î±×¾Æ¿ô µ¥ÀÌÅÍ¿¡¼­ °Ë»ö
    if (0 == lpSessionData || (0 == (lpCharacterData = lpSessionData->GetCharacterData())))
    {
        lpCharacterData = static_cast<CCharacterData*>(
            CCharacterDataMgr::GetInstance().GetLogoutData(memberInfo.m_dwCID));
    }

	if (0 != lpCharacterData)
	{
        // GID¸¦ 0 À¸·Î ¼Â.
        lpCharacterData->SetGID(0);		
	}

	return true;
}

bool CGuildDB::UpdateMemberInfo(unsigned long dwCID, MemberListInfo memberListInfo, MemberDetailInfo memberDetailInfo)
{
	MemberList::iterator it = m_MemberList.begin();
	for (; it != m_MemberList.end(); ++it)
	{
		if (dwCID == it->m_dwCID)
		{
			break;
		}
	}

	if (it == m_MemberList.end())
	{
		ERRLOG2(g_Log, "GID:%10u ±æµå¿ø Á¤º¸ °»½Å ½ÇÆÐ : ±æµå¿øÀÌ ¾Æ´Õ´Ï´Ù. CID:%10u", m_dwGID, dwCID);
		return false;
	}

	MemberInfo& memberInfo = *it;

	memberInfo.m_MemberListInfo = memberListInfo;
	memberInfo.m_MemberDetailInfo = memberDetailInfo;

	const unsigned long dwFameSum = std::accumulate(m_MemberList.begin(), m_MemberList.end(), 0, SumMemberFame());
	const unsigned long dwPreFame = m_dwFame;
	const unsigned char cCurrentMemberNum = GetCurrentAllMember();
	m_dwFame = (0 != cCurrentMemberNum) ? (dwFameSum / cCurrentMemberNum) : 0;

	if (dwPreFame != m_dwFame)
	{
		return DBComponent::GuildDB::UpdateGuildFame(m_DBComponent, m_dwGID, m_dwFame);
	}

	return true;
}

void CGuildDB::KickAllWaitMember()
{
	std::list<unsigned long> lstKickMembers;

	MemberList::iterator itr = m_MemberList.begin();
	while (itr != m_MemberList.end())
	{
		// ¿ëº´Àº Á¦¿Ü
		if (JOIN_WAIT == (*itr).m_MemberListInfo.m_cTitle && 0 == (*itr).m_cTactics)
		{
			lstKickMembers.push_back((*itr).m_dwCID);
		}

		++itr;
	}

	if (!lstKickMembers.empty())
	{
		unsigned short wError = 0;
		std::list<unsigned long>::iterator KickItr = lstKickMembers.begin();
		while (KickItr != lstKickMembers.end())
		{
			if ( LeaveMember( (*KickItr) ) )
			{
				PktGuildCmd pktGuildCmd;
				memset(&pktGuildCmd, 0, sizeof(PktGuildCmd));

				pktGuildCmd.m_dwGID = GetGID() ;
				pktGuildCmd.m_dwSenderID = (*KickItr) ;
				pktGuildCmd.m_dwReferenceID = (*KickItr) ;
				pktGuildCmd.m_wCmd = PktGuildCmd::GC_KICK ;

				if(PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktGuildCmd), 
					sizeof(PktGuildCmd), CmdGuildCmd, 0, 0))
				{
					DBAgent::CGameDispatch::GetDispatchTable().Process(CSendPacketAllServer(
						reinterpret_cast<char*>(&pktGuildCmd), 
						sizeof(PktGuildCmd), CmdGuildCmd));
				}
			}

			++KickItr;
		}
	}
}

void CGuildDB::SendLoginOutMember(unsigned long dwCID, unsigned long dwServerID)
{
	MemberList::iterator it = m_MemberList.begin();
	for (; it != m_MemberList.end(); ++it)
	{
		if (dwCID == it->m_dwCID)
		{
			break;
		}
	}

	if (it == m_MemberList.end()) 
	{ 
		ERRLOG2(g_Log, "GID:%10u ±æµå¿ø ·Î±×ÀÎ/¾Æ¿ô ½ÇÆÐ : ±æµå¿øÀÌ ¾Æ´Õ´Ï´Ù. CID:%10u", m_dwGID, dwCID);
		return; 
	}

	MemberInfo& LoginOutMemberInfo = *it;
	LoginOutMemberInfo.m_dwServerID = dwServerID;

	char* szSenderName = LoginOutMemberInfo.m_strName;

	// ·Î±×¾Æ¿ô ½Ã°£ üũ (±æµå »èÁ¦½Ã ÇÊ¿ä)
	if (0 == dwServerID)
	{
		// °¡ÀÔ´ë±âÀÚ´Â ±æµå¿øÀ¸·Î Ãë±ÞÇÏÁö ¾Ê´Â´Ù.
		if (JOIN_WAIT != LoginOutMemberInfo.m_MemberListInfo.m_cTitle)
		{
			SYSTEMTIME systemTime;
			::memset(&systemTime, 0, sizeof(SYSTEMTIME));

			// ¸¶½ºÅÍ°¡ ÀÏÁ¤±â°£(TRANFER_MASTER_TIME)µ¿¾È ·Î±×ÀÎÇÏÁö ¾ÊÀ¸¸é ÀÚµ¿À¸·Î ±ÇÇÑÀÌ ¾çµµµÈ´Ù.
			if (MASTER == LoginOutMemberInfo.m_MemberListInfo.m_cTitle)
			{
				GetLocalTime(&systemTime);

				m_tmGMLastLogout.Year = systemTime.wYear;
				m_tmGMLastLogout.Month = systemTime.wMonth;
				m_tmGMLastLogout.Day = systemTime.wDay;
				m_tmGMLastLogout.Hour = systemTime.wHour;
				m_tmGMLastLogout.Minute = systemTime.wMinute;
				m_tmGMLastLogout.Second = systemTime.wSecond;
				m_tmGMLastLogout.MSecond = systemTime.wMilliseconds;

				DBComponent::GuildDB::UpdateGuildTime(m_DBComponent, m_dwGID, MASTER_LOGOUT, systemTime);
			}

			// ÀÏÁ¤±â°£(DELETE_GUILD_LOGOUT_TIME)µ¿¾È ±æµå¿ø Áß ¾Æ¹«µµ ·Î±×ÀÎÇÏÁö ¾ÊÀ¸¸é ±æµå°¡ ÇØüµÈ´Ù.
			MemberList::iterator it = m_MemberList.begin();
			for (; it != m_MemberList.end(); ++it)
			{
				MemberInfo memberInfo = *it;

				if (0 != memberInfo.m_dwServerID)
				{
					break;
				}
			}

			if (it == m_MemberList.end())
			{
				GetLocalTime(&systemTime);

				m_tmLastLogout.Year = systemTime.wYear;
				m_tmLastLogout.Month = systemTime.wMonth;
				m_tmLastLogout.Day = systemTime.wDay;
				m_tmLastLogout.Hour = systemTime.wHour;
				m_tmLastLogout.Minute = systemTime.wMinute;
				m_tmLastLogout.Second = systemTime.wSecond;
				m_tmLastLogout.MSecond = systemTime.wMilliseconds;

				DBComponent::GuildDB::UpdateGuildTime(m_DBComponent, m_dwGID, LAST_LOGOUT, systemTime);
			}
		}
	}
	else
	{
		if (MASTER == LoginOutMemberInfo.m_MemberListInfo.m_cTitle)
		{
			::memset(&m_tmGMLastLogout, 0, sizeof(TIME));
		}

		::memset(&m_tmLastLogout, 0, sizeof(TIME));
	}

    DBAgent::SendPacket::GuildCmd(NULL, m_dwGID, dwCID, dwServerID, 
        PktGuildCmd::GC_LOGINOUT, szSenderName, m_strName, PktBase::NO_SERVER_ERR);
}

unsigned char CGuildDB::GetTacticsMember(unsigned long dwCID)
{
	MemberList::iterator it = m_MemberList.begin();

	for (; it != m_MemberList.end(); ++it)
	{
		if (dwCID == it->m_dwCID)
		{
			return (*it).m_cTactics;			
		}
	}

	return 0;
}

void CGuildDB::SetTacticsMember(unsigned long dwCID, unsigned char cTactics)
{
	MemberList::iterator it = m_MemberList.begin();

	for (; it != m_MemberList.end(); ++it)
	{
		if (dwCID == it->m_dwCID)
		{
			(*it).m_cTactics = cTactics;			
			return;
		}
	}	
}

void CGuildDB::SendJoinTacticsMember(CSendStream* lpSendStream, unsigned long dwCID, unsigned char cTitle, unsigned char CType)
{
	unsigned short wError = PktBase::NO_SERVER_ERR;

	using namespace DBAgent::DataStorage;

	CSessionData*   lpSessionData = CSessionDataMgr::GetInstance().GetCharLoadedSession(dwCID);
	CCharacterData* lpCharacterData = 0;

	if (0 == lpSessionData || 0 == (lpCharacterData = lpSessionData->GetCharacterData()))
	{
		wError = PktBase::SERVER_ERROR;
	}
	else
	{
		const CHAR_INFOST& charInfoST = lpCharacterData->GetInfo();

		const int MAX_PACKET_DATA = sizeof(PktGuildCmd) + sizeof(MemberInfo);
		char szPacketData[MAX_PACKET_DATA];

		PktGuildCmd*    lpPktGCAck = reinterpret_cast<PktGuildCmd*>(szPacketData);
		MemberInfo*     lpMemberInfo = reinterpret_cast<MemberInfo*>(lpPktGCAck + 1);
		memset(lpMemberInfo, 0, sizeof(MemberInfo));

		lpMemberInfo->m_dwCID		= dwCID;
		lpMemberInfo->m_dwServerID	= lpSessionData->GetServerID();
		lpMemberInfo->m_cTactics	= Guild::TACTICS_WAIT;
		strncpy(lpMemberInfo->m_strName, charInfoST.Name, Guild::MAX_MEMBER_NAME_LEN);

		// °¡ÀÔÀº ¹«Á¶°Ç ³¡À¸·Î ÇÑ ÈÄ °¡ÀÔ »óȲ¿¡ µû¶ó Á÷À§¸¦ ¹Ù²ãÁØ´Ù.
		lpMemberInfo->m_MemberListInfo.m_cTitle = cTitle;

		lpMemberInfo->m_MemberListInfo.m_cLevel = charInfoST.Level;
		lpMemberInfo->m_MemberListInfo.m_cClass = static_cast<unsigned char>(charInfoST.Class);

		lpMemberInfo->m_MemberDetailInfo.m_dwFame = charInfoST.Fame;
		lpMemberInfo->m_MemberDetailInfo.m_dwGold = charInfoST.Gold;

		if (!JoinMember(*lpMemberInfo))
		{
			ERRLOG1(g_Log, "GID:%10u ±æµå ¿ëº´ ¸â¹ö Ãß°¡ ½ÇÆÐ : JoinMember½ÇÆÐ.", m_dwGID);

			wError = PktBase::SERVER_ERROR;            
		}
		else if (!DBComponent::GuildDB::InsertGuildMember(m_DBComponent, m_dwGID, lpMemberInfo->m_dwCID, 
			lpMemberInfo->m_MemberListInfo.m_cTitle, lpMemberInfo->m_MemberListInfo.m_cRank))
		{			
			ERRLOG1(g_Log, "GID:%10u ±æµå ¿ëº´ ¸â¹ö Ãß°¡ ½ÇÆÐ : DB¿¡ »ðÀÔ ½ÇÆÐ.", m_dwGID);

			wError = PktBase::SERVER_ERROR;
			LeaveMember(lpMemberInfo->m_dwCID);
		}

		DBComponent::GuildDB::UpdateGuildMemberTactics(m_DBComponent, GetGID(), dwCID, Guild::TACTICS_WAIT);

		// ¼­¿­ Á¶Á¤À» À§ÇØ °¡ÀÔ½ÃŲ ÈÄ Á÷À§¸¦ Àû¿ë½ÃÄÑÁØ´Ù.
		SetTitle(dwCID, cTitle);

		MemberList::iterator it = m_MemberList.begin();
		for (; it != m_MemberList.end(); ++it)
		{
			if (dwCID == it->m_dwCID)
			{
				break;
			}
		}

		MemberInfo memberInfo = *it;

		lpMemberInfo->m_MemberListInfo.m_cTitle = memberInfo.m_MemberListInfo.m_cTitle;			

		lpPktGCAck->m_dwGID			= m_dwGID;
		lpPktGCAck->m_dwSenderID	= dwCID;
		lpPktGCAck->m_dwReferenceID = cTitle;
		lpPktGCAck->m_wCmd			= CType;

		strncpy(lpPktGCAck->m_szGuildName, m_strName, Guild::MAX_GUILD_NAME_LEN);
		strncpy(lpPktGCAck->m_szSenderName, charInfoST.Name, Guild::MAX_MEMBER_NAME_LEN);

		lpPktGCAck->InitPtHead(sizeof(PktGuildCmd) + sizeof(MemberInfo), CmdGuildCmd, 0, wError);	

		if(PacketWrap::WrapHeader(szPacketData, MAX_PACKET_DATA, CmdGuildCmd, 0, wError))
		{
			if (PktBase::NO_SERVER_ERR == wError)
			{
				DBAgent::CGameDispatch::GetDispatchTable().Process(
					CSendPacketAllServer(szPacketData, MAX_PACKET_DATA, CmdGuildCmd));
			}
			else if(0 != lpSendStream)
			{
				lpSendStream->PutBuffer(szPacketData, MAX_PACKET_DATA, CmdGuildCmd);
			}
		}
	}
}

void CGuildDB::SendJoinMember(CSendStream* lpSendStream, unsigned long dwCID, unsigned char cTitle)
{
	unsigned short wError = PktBase::NO_SERVER_ERR;

    using namespace DBAgent::DataStorage;

    CSessionData*   lpSessionData = CSessionDataMgr::GetInstance().GetCharLoadedSession(dwCID);
    CCharacterData* lpCharacterData = 0;

    if (0 == lpSessionData || 0 == (lpCharacterData = lpSessionData->GetCharacterData()))
    {
		wError = PktBase::SERVER_ERROR;
	}
	else
	{
        const CHAR_INFOST& charInfoST = lpCharacterData->GetInfo();
		const CHAR_INFOEX& charInfoEX = lpCharacterData->GetInfoEx();

        const int MAX_PACKET_DATA = sizeof(PktGuildCmd) + sizeof(MemberInfo);
        char szPacketData[MAX_PACKET_DATA];

        PktGuildCmd*    lpPktGCAck = reinterpret_cast<PktGuildCmd*>(szPacketData);
        MemberInfo*     lpMemberInfo = reinterpret_cast<MemberInfo*>(lpPktGCAck + 1);
        memset(lpMemberInfo, 0, sizeof(MemberInfo));

        lpMemberInfo->m_dwCID = dwCID;
        lpMemberInfo->m_dwServerID = lpSessionData->GetServerID();
        strncpy(lpMemberInfo->m_strName, charInfoST.Name, Guild::MAX_MEMBER_NAME_LEN);
        
        // °¡ÀÔÀº ¹«Á¶°Ç ³¡À¸·Î ÇÑ ÈÄ °¡ÀÔ »óȲ¿¡ µû¶ó Á÷À§¸¦ ¹Ù²ãÁØ´Ù.
        lpMemberInfo->m_MemberListInfo.m_cTitle = JOIN_WAIT;

        lpMemberInfo->m_MemberListInfo.m_cLevel = charInfoST.Level;
        lpMemberInfo->m_MemberListInfo.m_cClass = static_cast<unsigned char>(charInfoST.Class);
		lpMemberInfo->m_MemberListInfo.m_cGuildWarFlag = charInfoEX.GuildWarFlag;

        lpMemberInfo->m_MemberDetailInfo.m_dwFame = charInfoST.Fame;
        lpMemberInfo->m_MemberDetailInfo.m_dwGold = charInfoST.Gold;

		if (!JoinMember(*lpMemberInfo))
		{
            ERRLOG1(g_Log, "GID:%10u ±æµå ¸â¹ö Ãß°¡ ½ÇÆÐ : JoinMember½ÇÆÐ.", m_dwGID);

			wError = PktBase::SERVER_ERROR;            
		}
        else if (!DBComponent::GuildDB::InsertGuildMember(m_DBComponent, m_dwGID, lpMemberInfo->m_dwCID, 
			lpMemberInfo->m_MemberListInfo.m_cTitle, lpMemberInfo->m_MemberListInfo.m_cRank))
		{			
            ERRLOG1(g_Log, "GID:%10u ±æµå ¸â¹ö Ãß°¡ ½ÇÆÐ : DB¿¡ »ðÀÔ ½ÇÆÐ.", m_dwGID);

			wError = PktBase::SERVER_ERROR;
            LeaveMember(lpMemberInfo->m_dwCID);
		}

		// ¼­¿­ Á¶Á¤À» À§ÇØ °¡ÀÔ½ÃŲ ÈÄ Á÷À§¸¦ Àû¿ë½ÃÄÑÁØ´Ù.
		SetTitle(dwCID, cTitle);

		MemberList::iterator it = m_MemberList.begin();
		for (; it != m_MemberList.end(); ++it)
		{
			if (dwCID == it->m_dwCID)
			{
				break;
			}
		}

		MemberInfo memberInfo = *it;

		lpMemberInfo->m_MemberListInfo.m_cTitle = memberInfo.m_MemberListInfo.m_cTitle;

		lpPktGCAck->m_dwGID = m_dwGID;
		lpPktGCAck->m_dwSenderID = dwCID;
		lpPktGCAck->m_dwReferenceID = cTitle;
		lpPktGCAck->m_wCmd = PktGuildCmd::GC_JOIN;

		strncpy(lpPktGCAck->m_szGuildName, m_strName, Guild::MAX_GUILD_NAME_LEN);
		strncpy(lpPktGCAck->m_szSenderName, charInfoST.Name, Guild::MAX_MEMBER_NAME_LEN);
        
        lpPktGCAck->InitPtHead(sizeof(PktGuildCmd) + sizeof(MemberInfo), CmdGuildCmd, 0, wError);	

        if(PacketWrap::WrapHeader(szPacketData, MAX_PACKET_DATA, CmdGuildCmd, 0, wError))
        {
		    if (PktBase::NO_SERVER_ERR == wError)
		    {
                DBAgent::CGameDispatch::GetDispatchTable().Process(
                    CSendPacketAllServer(szPacketData, MAX_PACKET_DATA, CmdGuildCmd));
		    }
		    else if(0 != lpSendStream)
		    {
                lpSendStream->PutBuffer(szPacketData, MAX_PACKET_DATA, CmdGuildCmd);
		    }
        }
    }
}