#include "stdafx.h"
#include "SessionData.h"
#include "SessionDataMgr.h"

#include "StoreData.h"
#include "CharacterData.h"

#include "AdminDataMgr.h"

#include "StoreDataMgr.h"
#include "CharacterDataMgr.h"


#include <Network/Dispatch/LoginDispatch.h>
#include <Network/Dispatch/GameDispatch.h>
#include <Network/Dispatch/AuthDispatch.h>
#include <Network/Dispatch/UIDDispatch.h>

#include <Network/SendPacket/SendServerInfo.h>

#include <GameTime/GameTimeDBMgr.h>

#include <Community/Guild/GuildDB.h>
#include <Community/Guild/GuildDBMgr.h>

#include <DB/DBComponent.h>
#include <DB/GameDBComponent.h>
#include <Log/ServerLog.h>
#include <Network/Packet/PacketStruct/ServerInfo.h>

#include <Utility/Debug/PerformanceCheck.h>
#include <Utility/Setup/ServerSetup.h>

namespace DBAgent
{
namespace DataStorage
{

const char* g_szSessionStateString[CSessionData::SE_MAX_STATE] =
{
    "NONE",
    "USER_ENABLED",
    "USER_DISABLED",
    "MOVE",
    "CHAR_ENABLED",
    "CHAR_DISABLED"
};

RequestData::RequestData()
{
    m_dwRequestKey = m_dwSelectedCID = m_dwServerID = m_dwSessionID = 0;
    m_PeerAddress.S_un.S_addr = 0;
    
    memset(m_szAccount, 0, sizeof(char) * MaxName);
    memset(m_szPassword, 0, sizeof(char) * MaxPass);
}

RequestData::RequestData(unsigned long dwRequestKey, unsigned long dwSelectedCID, 
                         unsigned long dwServerID, unsigned long dwSessionID,
                         IN_ADDR peerAddr, const char* szAccountName, const char* szPassword)
                         :   m_dwRequestKey(dwRequestKey), m_dwSelectedCID(dwSelectedCID),
                             m_dwServerID(dwServerID), m_dwSessionID(dwSessionID),
                             m_PeerAddress(peerAddr)
{
    if(0 != szAccountName && strlen(szAccountName) > 0)
    {
        strcpy(m_szAccount, szAccountName);
    }
    else
    {
        memset(m_szAccount, 0, sizeof(char) * MaxName);
    }

    if(0 != szPassword && strlen(szPassword) > 0)
    {
        strcpy(m_szPassword, szPassword);
    }
    else
    {
        memset(m_szPassword, 0, sizeof(char) * MaxPass);
    }
}


CSessionData::CSessionData()
:   m_nUnifiedStoreInfoNum(0),
    m_nUnifiedCharDataNum(0),
    m_dwUID(0), 
    m_dwCID(0), 
    m_dwSessionID(0), 
    m_dwServerID(0),
    m_eSessionState(SE_NONE),
    m_dwFlags(0),
    m_lpCharacterData(0),
    m_lpStoreData(0),
    m_cAdminLevel(0),
    m_cOldServerGroupID(0),
    m_cTransferedCharCount(UCHAR_MAX),
    m_cNewZone(0), 
	m_dwPlayTime(0) 
{
    memset(&m_PremiumService, 0, sizeof(PREMIUMSERVICE));
    memset(&m_UserInfo, 0, sizeof(USER_INFO));
    memset(m_CharView, 0, sizeof(CHAR_VIEW) * USER_INFO::MAX_CHAR_NUM);
    memset(m_szAccount, 0, sizeof(char) * CHAR_INFOST::MAX_ACCOUNT_LEN);
    memset(&m_NewPos, 0, sizeof(POS));

    memset(m_UnifiedStoreInfo, 0, sizeof(UnifiedStoreInfo) * PktUnifiedCharInfo::MAX_STORE_INFO);
    memset(m_UnifiedCharData, 0, sizeof(UnifiedCharData) * PktUnifiedCharInfo::MAX_CHAR_DATA);

	memset(m_SaveEnemy, 0, sizeof(SaveEnemy)*SaveEnemy::MAX_SAVING_ENEMY);

    m_RemoteAddress.S_un.S_addr = 0;
}

CSessionData::~CSessionData()
{
	m_RequestQueue.clear();
}


bool CSessionData::GetCharView(unsigned long dwCID, CHAR_VIEW& charView_Out)
{
    for(unsigned int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        if(m_CharView[nCount].CID == dwCID)
        {
            charView_Out = m_CharView[nCount];
            return true;
        }
    }

    return false;
}

// WORK_LIST 2.3 °èÁ¤ ±¹Àû º¯°æ ±â´É ±¸Çö
bool CSessionData::SetCharViewGID(unsigned long dwCID, unsigned long dwGID)
{
	for(unsigned int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
	{
		if(m_CharView[nCount].CID == dwCID)
		{
			m_CharView[nCount].GID = dwGID;
			return true;
		}
	}

	return false;
}

bool CSessionData::SetCharViewFame(unsigned long dwCID, unsigned long dwFame)
{
	for(unsigned int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
	{
		if(m_CharView[nCount].CID == dwCID)
		{
			m_CharView[nCount].Fame = dwFame;
			return true;
		}
	}

	return false;
}

bool CSessionData::HasCharacter(unsigned long dwCID) const 
{ 
    if(0 != dwCID)
    {
        for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
        {
            if (dwCID == m_UserInfo.CharID[nCount])
            {
                return true;
            }
        }
    }

    return false;
}

bool CSessionData::GetPlayTimeFromDB(CDBComponent& DBComponent)
{
	if (GameRYL::CHINA != CServerSetup::GetInstance().GetNationType())
	{
		m_dwPlayTime = 0;
		return true;
	}

	using namespace DBComponent;

    if (!GameDB::GetPlayTime(DBComponent, m_dwUID, &m_dwPlayTime)) 
    {
        SERLOG1(g_Log, "UID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetPlayTime È£Ãâ ½ÇÆÐ", m_dwUID);
		return false;
    }

	return true;
}

bool CSessionData::GetPremiumServiceFromDB(CDBComponent& DBComponent)
{
    memset(&m_PremiumService, 0, sizeof(PREMIUMSERVICE));

	using namespace DBComponent;

    if (!GameDB::GetPremiumService(DBComponent, m_dwUID, m_PremiumService)) 
    {
//      SERLOG1(g_Log, "UID:%10u / ÇÁ¸®¹Ì¾ö À¯Àú ¾Æ´Ô", m_dwUID);
		return false;
    }

	if(m_PremiumService.lPremiumTime == 0)
		m_PremiumService.iPremiumType = 0;

	return true;
}

bool CSessionData::GetUserInfoFromDB(CDBComponent& DBComponent)
{
    PERFORMANCE_CHECK(FunctionTimingCheck);

    memset(&m_UserInfo, 0, sizeof(USER_INFO));
    memset(m_CharView, 0, sizeof(CHAR_VIEW) * USER_INFO::MAX_CHAR_NUM);

    using namespace DBComponent;

    // À¯Àú Á¤º¸ ¾ò±â
    bool bFirstLoadUserInfoResult = 
        GameDB::GetUserInfo(DBComponent, m_dwUID, m_UserInfo, m_cOldServerGroupID, true);

    if (!bFirstLoadUserInfoResult) 
    {
        if(!GameDB::InsertUser(DBComponent, m_dwUID, m_cOldServerGroupID))
        {
            SERLOG3(g_Log, "UID:%10u / ServerGroupID:%d / À¯Àú »ðÀÔ ½ÇÆÐ : %s",
                m_dwUID, m_cOldServerGroupID, DBComponent.GetErrorString());

            return false;
        }        
    }

    if (!bFirstLoadUserInfoResult && 
        !GameDB::GetUserInfo(DBComponent, m_dwUID, m_UserInfo, m_cOldServerGroupID)) 
    {
        SERLOG3(g_Log, "UID:%10u / ServerGroupID:%d / À¯Àú Á¤º¸ ¾ò±â ½ÇÆÐ : %s",
            m_dwUID, m_cOldServerGroupID, DBComponent.GetErrorString());        
    }
    else
    {
        bool bGetViewResult = true;

        for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
        {
            if (0 != m_UserInfo.CharID[nCount] && 
                !GameDB::GetCharView(DBComponent, m_UserInfo.CharID[nCount], &m_CharView[nCount]))
            {
                SERLOG5(g_Log, "UID:%10u / ServerGroupID:%d / CID:%10u / Slot:%d / ij¸¯ÅÍ ºä ¾ò±â ½ÇÆÐ : %s", 
                    m_dwUID, m_cOldServerGroupID, m_UserInfo.CharID[nCount], nCount, DBComponent.GetErrorString());
/*
				// edith 2010.01.03 Á¦³Ê·² ³×Æ®¿öÅ©·Î DB¿¬°áÀÌ ²÷¾îÁ³À»¶§ GetCharView¸¦ ½ÇÆÐÇÏ´Ï
				// GameDBÀÇ UserInfoÀÇ CID¸¦ 0À¸·Î ÃʱâÈ­ Çغ­·¯ ³ªÁß¿¡ DB¿¡ CID°¡ 0ÀÎ Á¤º¸°¡ ¾÷µ¥ÀÌÆ® µÇ¾î
				// ij¸¯ÅÍ°¡ »èÁ¦µÇ´Â ¹ö±×°³ µÆ´Ù.

				m_UserInfo.CharID[nCount] = 0;
				if (!GameDB::UpdateUser(DBComponent, m_dwUID, &m_UserInfo))
				{
					bGetViewResult = false;
				}
*/
					bGetViewResult = false;
            }
        }

        if(bGetViewResult)
        {
            INFLOG2(g_Log, "UID:%10u / ServerGroupID:%d / À¯Àú Á¤º¸ ¾ò±â ¼º°ø", 
                m_dwUID, m_cOldServerGroupID);
            return true;
        }
    }

    return false;
}

bool CSessionData::GetUnifiedInfo(CDBComponent& DBComponent, unsigned long UserID_In)
{
	using namespace DBComponent;

	memset(m_UnifiedStoreInfo, 0, sizeof(UnifiedStoreInfo) * PktUnifiedCharInfo::MAX_STORE_INFO);

	m_nUnifiedStoreInfoNum = PktUnifiedCharInfo::MAX_STORE_INFO;

	return GameDB::GetUnifiedItemStoreInfo(DBComponent, UserID_In, m_UnifiedStoreInfo, m_nUnifiedStoreInfoNum);		
}

bool CSessionData::GetUnifiedDataFromDB(CDBComponent& DBComponent)
{
    // UnifiedStoreInfo / UnifiedCharData ¸¦ Àо ¼¼¼Ç¿¡ ÀúÀåÇÑ´Ù.
    memset(m_UnifiedStoreInfo, 0, sizeof(UnifiedStoreInfo) * PktUnifiedCharInfo::MAX_STORE_INFO);
    memset(m_UnifiedCharData, 0, sizeof(UnifiedCharData) * PktUnifiedCharInfo::MAX_CHAR_DATA);

    m_nUnifiedStoreInfoNum = PktUnifiedCharInfo::MAX_STORE_INFO;
    m_nUnifiedCharDataNum = PktUnifiedCharInfo::MAX_CHAR_DATA;

    using namespace DBComponent;

    // ÅëÇÕ Á¤º¸ Àбâ.
    if(!GameDB::GetUnifiedItemStoreInfo(DBComponent, m_dwUID, m_UnifiedStoreInfo, m_nUnifiedStoreInfoNum))
    {
        ERRLOG2(g_Log, "UID:%10u / ÅëÇÕ Ã¢°í Á¤º¸ Àоî¿À±â ½ÇÆÐ : %s", m_dwUID, DBComponent.GetErrorString());
    }
    else if(!GameDB::GetUnifiedCharList(DBComponent, m_dwUID, m_UnifiedCharData, m_nUnifiedCharDataNum))
    {
        ERRLOG2(g_Log, "UID:%10u / ÅëÇÕ Ä³¸¯ÅÍ Á¤º¸ Àоî¿À±â ½ÇÆÐ : %s", m_dwUID, DBComponent.GetErrorString());    
    }
    else
    {
        unsigned char cAgentServerType = static_cast<unsigned char>(
            CServerSetup::GetInstance().GetAgentServerType());

        bool bHasUnifiedStoreInfo = HasUnifiedStoreInfo(cAgentServerType);

        switch(cAgentServerType)
        {
        case UnifiedConst::Part2Unified:
            
            m_cOldServerGroupID = UnifiedConst::Part2Unified;
            
            if(!GetUserInfoFromDB(DBComponent))
            {
                ERRLOG2(g_Log, "UID:%10u / ÅëÇÕ Ä³¸¯ÅÍ À¯Àú »ý¼º ½ÇÆÐ : %s", 
                    m_dwUID, DBComponent.GetErrorString());
            }
            else
            {
                unsigned char cAgentServerType = 
                    static_cast<unsigned char>(CServerSetup::GetInstance().GetAgentServerType());

                if (m_UserInfo.FirstLogin & UnifiedConst::SELECTED_PART2)
                {
                    // â°í¸¦ ÀÌ¹Ì ¼±ÅÃÇÑ °æ¿ì´Â â°í Á¤º¸¸¦ ÁÙ ÇÊ¿ä°¡ ¾ø´Ù.
                    memset(m_UnifiedStoreInfo, 0, sizeof(UnifiedStoreInfo) * PktUnifiedCharInfo::MAX_STORE_INFO);
                    m_nUnifiedStoreInfoNum = 0;
                }
                else
                {
                    // ¼­¹ö±×·ì ID°¡ ÇöÀç Áß°è¼­¹öŸÀÔº¸´Ù ÀÛÀº °ª¸¸ Ã߸°´Ù.
                    UnifiedStoreInfo* lpStorePos = m_UnifiedStoreInfo;
                    UnifiedStoreInfo* lpStoreEnd = m_UnifiedStoreInfo + m_nUnifiedStoreInfoNum;

                    for(; lpStorePos < lpStoreEnd; )
                    {
                        // ÇöÀç º¸À¯ÁßÀΠâ°í´Â º¸³» ÁÙ ÇÊ¿ä ¾ø´Ù.
                        if(cAgentServerType <= lpStorePos->cOldServerGroupID)
                        {
                            memmove(lpStorePos, lpStorePos + 1, sizeof(UnifiedStoreInfo) * (lpStoreEnd - lpStorePos - 1));
                            --m_nUnifiedStoreInfoNum;

                            lpStoreEnd = m_UnifiedStoreInfo + m_nUnifiedStoreInfoNum;
                        }
                        else
                        {
                            ++lpStorePos;
                        }
                    }

                    // â°í°¡ ¾ø°Å³ª, â°í°¡ À־ ÀÚ±â â°í¸¸ ÀÖ´Â °æ¿ì¿¡´Â, 
                    // â°í¸¦ ÀÌ¹Ì ¼±ÅÃÇÑ °Í ó·³ ÇØ ÁØ´Ù.
                    if (0 == m_nUnifiedStoreInfoNum ||
                       (1 == m_nUnifiedStoreInfoNum && m_UnifiedStoreInfo->cOldServerGroupID == cAgentServerType))
                    {
                        m_UserInfo.FirstLogin |= UnifiedConst::SELECTED_PART2;
                        DBComponent::GameDB::UpdateUserFirstLogin(DBComponent, m_dwUID, m_UserInfo.FirstLogin);
                    }
                }
                
                // ¼­¹ö±×·ì ID°¡ ÇöÀç Áß°è¼­¹öŸÀÔº¸´Ù ÀÛÀº °ª¸¸ Ã߸°´Ù.
                UnifiedCharData* lpCharPos = m_UnifiedCharData;
                UnifiedCharData* lpCharEnd = m_UnifiedCharData+ m_nUnifiedCharDataNum;

                for(; lpCharPos < lpCharEnd; )
                {
                    // ÇöÀç º¸À¯ÁßÀΠij¸¯ÅÍ´Â º¸³» Áà¾ß ÇÑ´Ù.
                    if(cAgentServerType < lpCharPos->cOldServerGroupID)
                    {
                        memmove(lpCharPos, lpCharPos + 1, sizeof(UnifiedStoreInfo) * (lpCharEnd - lpCharPos - 1));
                        --m_nUnifiedCharDataNum;

                        lpCharEnd = m_UnifiedCharData+ m_nUnifiedCharDataNum;
                    }
                    else
                    {
                        ++lpCharPos;
                    }
                }

                INFLOG4(g_Log, "UID:%10u / FirstLogin:%d / ReadStoreInfo:%d / ReadCharData:%d / ¼­¹öÅëÇÕ Á¤º¸¸¦ Àдµ¥ ¼º°øÇß½À´Ï´Ù", 
                    m_dwUID, m_UserInfo.FirstLogin, m_nUnifiedStoreInfoNum, m_nUnifiedCharDataNum);

                return true;
            }
            break;
        
        case UnifiedConst::Part2Selectable:
                                            
            if (0 == m_nUnifiedStoreInfoNum || 
                (1 == m_nUnifiedStoreInfoNum && bHasUnifiedStoreInfo))
            {
                m_cOldServerGroupID = UnifiedConst::Part2Selectable;

                memset(m_UnifiedStoreInfo, 0, sizeof(UnifiedStoreInfo) * PktUnifiedCharInfo::MAX_STORE_INFO);
                m_nUnifiedStoreInfoNum = 0;
            }
            else
            {
                m_cOldServerGroupID = 1;
            }

            INFLOG3(g_Log, "UID:%10u / ReadStoreInfo:%d / ReadCharData:%d / ¼­¹öÅëÇÕ Á¤º¸¸¦ Àдµ¥ ¼º°øÇß½À´Ï´Ù",
                m_dwUID, m_nUnifiedStoreInfoNum, m_nUnifiedCharDataNum);

            return true;            
        }
    }
    
    m_nUnifiedStoreInfoNum = 0;
    m_nUnifiedCharDataNum = 0;

    m_cOldServerGroupID = 0;    
    return false;
}

void CSessionData::SetRequestData(const RequestData& reqData)
{
    m_dwSessionID   = reqData.m_dwSessionID;
    m_dwServerID    = reqData.m_dwServerID;
    m_RemoteAddress = reqData.m_PeerAddress;

    strcpy(m_szAccount, reqData.m_szAccount);
}


bool CSessionData::UserEnable(CDBComponent& DBComponent, unsigned long dwUID)
{
    if (SE_USER_ENABLED == m_eSessionState || SE_CHAR_ENABLED == m_eSessionState)
    {
        LogUserDataError("À¯Àú È°¼ºÈ­ ½Ãµµ ½ÇÆÐ", LOG_FFL);
    }
    // DB¿¡¼­ À¯Àú Á¤º¸ ¹× ºä¸¦ ¾ò¾î¿Â´Ù.
    else if (GetUserInfoFromDB(DBComponent))
    {
        // À¯Àú È°¼ºÈ­.
        SetSessionState(SE_USER_ENABLED);
        INFLOG1(g_Log, "UID:%10u / À¯Àú È°¼ºÈ­", m_dwUID);

        // ¿î¿µÀÚ ·¹º§ ¼³Á¤.
        m_cAdminLevel = CAdminDataMgr::GetInstance().GetAdminLevel(m_dwUID, m_RemoteAddress);

        // À¯Àú ¼ö ´Ã¸².
        GET_SINGLE_DISPATCH(lpAuthDispatch, 
            CAuthDispatch, CAuthDispatch::GetDispatchTable());

        if(0 != lpAuthDispatch)
        {
            lpAuthDispatch->IncUserNum();
        }
        
        return true;
    }

    return false;
}

bool CSessionData::UserDisable()
{
    if (SE_USER_ENABLED == m_eSessionState || SE_MOVE == m_eSessionState)
    {
        // À¯Àú ºñÈ°¼ºÈ­ »óÅ Àüȯ
        SetSessionState(SE_USER_DISABLED);

        // À¯Àú ºñÈ°¼ºÈ­ Àü¼Û
        SendPacket::UpdateUIDTable(PktUUT::UpdateUIDTableUserLogout,
            m_szAccount, NULL, m_dwUID, m_dwCID, m_dwSessionID, m_dwServerID, m_RemoteAddress);

        // À¯Àú ¼ö ÁÙÀÓ
        GET_SINGLE_DISPATCH(lpAuthDispatch, 
            CAuthDispatch, CAuthDispatch::GetDispatchTable());

        if(0 != lpAuthDispatch)
        {
            lpAuthDispatch->DecUserNum();
        }

        // Ȥ½Ã µ¥ÀÌÅÍ°¡ ·ÎµåµÇ¾î ÀÖÀ¸¸é ¾ð·ÎµåÇÑ´Ù.
        UnloadData();
        GetBilling().ClearBilling();
    }
    else
    {
        LogUserDataError("À¯Àú ºñÈ°¼ºÈ­ ½Ãµµ ½ÇÆÐ", LOG_FFL);
        return false;
    }
    
    return true;
}

bool CSessionData::UserMove()
{
    if (SE_USER_ENABLED == m_eSessionState)
    {
        // ij¸¯ÅÍ À̵¿
        SetSessionState(SE_MOVE);
        SendPacket::UpdateUIDTable(PktUUT::UpdateUIDTableUserMove,
            m_szAccount, NULL, m_dwUID, m_dwCID, m_dwSessionID, m_dwServerID, m_RemoteAddress);

        // À¯Àú ¼ö ÁÙÀÓ
        GET_SINGLE_DISPATCH(lpAuthDispatch, 
            CAuthDispatch, CAuthDispatch::GetDispatchTable());

        if(0 != lpAuthDispatch)
        {
            lpAuthDispatch->DecUserNum();
        }

        UnloadData();        
    }
    else
    {
        LogUserDataError("À¯Àú À̵¿ ½Ãµµ ½ÇÆÐ", LOG_FFL);
        return false;
    }

    return true;
}

bool CSessionData::LoadData(unsigned long dwCID)
{
    DBDataError eStoreDataError     = DATA_SUCCEEDED;
    DBDataError eCharacterDataError = DATA_SUCCEEDED;

    // â°í µ¥ÀÌÅÍ ·Îµå (â°í°¡ ºñ¾ú°Å³ª, ´Ù¸¥ UIDµ¥ÀÌÅ͸¦ °¡Áø °æ¿ì¿¡¸¸ ·Îµå)
    if(0 == m_lpStoreData || m_dwUID != m_lpStoreData->GetUID())
    {            
        if(0 != m_lpStoreData)
        {
            // µ¥ÀÌÅÍ ¹Ý³³
            CStoreDataMgr::GetInstance().UnloadData(*this, m_lpStoreData);
            m_lpStoreData = 0;
        }

        // µ¥ÀÌÅÍ ·Îµå
        eStoreDataError = CStoreDataMgr::GetInstance().LoadData(*this, 
            UnifiedStoreKey(m_dwUID, m_cOldServerGroupID), m_lpStoreData);
    }

    // ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå (ij¸¯ÅÍ µ¥ÀÌÅÍ°¡ ºñ¾ú°Å³ª, ´Ù¸¥ ij¸¯ÅÍ µ¥ÀÌÅ͸¦ °¡Áø °æ¿ì¿¡¸¸ ·Îµå)
    if(0 == m_lpCharacterData || dwCID != m_lpCharacterData->GetCID())
    {
        if(0 != m_lpCharacterData)
        {
            // µ¥ÀÌÅÍ ¹Ý³³
            CCharacterDataMgr::GetInstance().UnloadData(*this, m_lpCharacterData);
            m_lpCharacterData = 0;
        }

	    // µ¥ÀÌÅÍ ·Îµå
        eCharacterDataError = 
            CCharacterDataMgr::GetInstance().LoadData(*this, dwCID, m_lpCharacterData);        
    }

    // °á°ú ó¸®
    if (eStoreDataError != DATA_SUCCEEDED || 
        eCharacterDataError != DATA_SUCCEEDED)
    {
        // ¿¡·¯Ã³¸®. µ¥ÀÌÅ͸¦ UnloadÇÏ°í ·Î±×¸¦ Âï´Â´Ù.
        if(0 != m_lpStoreData && eStoreDataError == DATA_SUCCEEDED)
        {
            CStoreDataMgr::GetInstance().UnloadData(*this, m_lpStoreData);
            m_lpStoreData = 0;
        }

        if(0 != m_lpCharacterData && eCharacterDataError == DATA_SUCCEEDED)
        {
            CCharacterDataMgr::GetInstance().UnloadData(*this, m_lpCharacterData);
            m_lpCharacterData = 0;
        }

        ERRLOG5(g_Log, "UID:%10u / ServerGroupID:%d / CID:%10u / Store:%s / Character:%s / â°í, ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ.", 
            m_dwUID, m_cOldServerGroupID, dwCID,
            g_szDBDataErrorString[eStoreDataError],
            g_szDBDataErrorString[eCharacterDataError]);

        return false;
    }

    m_dwCID = dwCID;
    return true;
}

void CSessionData::UnloadData()
{
    if(0 != m_lpStoreData)
    {
        CStoreDataMgr::GetInstance().UnloadData(*this, m_lpStoreData);
        m_lpStoreData = 0;
    }

    if(0 != m_lpCharacterData)    
    {
        CCharacterDataMgr::GetInstance().UnloadData(*this, m_lpCharacterData);
        m_lpCharacterData = 0;
    }
    
    m_dwCID = 0;	
}

bool CSessionData::CharEnable(unsigned long dwCID, unsigned long dwServerID)
{
    if (SE_USER_ENABLED != m_eSessionState && SE_CHAR_ENABLED != m_eSessionState)
    {
        if(LoadData(dwCID))
        {
            // À̵¿ Á¸ ¾÷µ¥ÀÌÆ®
            UpdateMoveZone();

			// edith 2008.12.4 ·Î±×ÀΠŸÀÓ°»½Å±â´É Ãß°¡
			// ij¸¯ÅÍ°¡ Enable ‰Â »óŸé ÇöÀç¼­¹ö¿¡ ·Î±×ÀÎµÈ ½Ã°£À» ³ªÅ¸³½´Ù.
			CTime timeLogin = CTime::GetCurrentTime();
			TIME* pLoginTime = m_lpCharacterData->GetLoginTime();
			if(pLoginTime)
			{
				pLoginTime->Year		= timeLogin.GetYear();
				pLoginTime->Month		= timeLogin.GetMonth();
				pLoginTime->Day			= timeLogin.GetDay();			
				pLoginTime->Hour		= timeLogin.GetHour();
				pLoginTime->Minute		= timeLogin.GetMinute();
				pLoginTime->Second		= timeLogin.GetSecond();
			}

            // ±âŸ Á¤º¸ ¼¼Æà (µ¥ÀÌÅÍ ¼¼Æà ÈÄ ÇÔ¼ö È£Ãâ ÇÊ¿ä)
            m_dwServerID = dwServerID;
            m_lpCharacterData->SetServerID(dwServerID);

            // ij¸¯ÅÍ È°¼ºÈ­
            SetSessionState(SE_CHAR_ENABLED);
            LogCharData("ij¸¯ÅÍ È°¼ºÈ­");
            
            GET_MULTI_DISPATCH(lpGameDispatch, dwServerID, 
                CGameDispatch, CGameDispatch::GetDispatchTable());

            if(0 != lpGameDispatch)
            {
                lpGameDispatch->IncCharNum(m_lpCharacterData->GetRace());
            }

            return true;
        }
    }
    else
    {
        SERLOG4(g_Log, "UID:%10u / CID:%10u / ServerID:0x%08X / ST:%s / ij¸¯ÅÍ È°¼ºÈ­ ½Ãµµ ½ÇÆÐ : "
            "¼¼¼Ç »óÅ°¡ ÀÌ»óÇÕ´Ï´Ù.", m_dwUID, dwCID, dwServerID, g_szSessionStateString[m_eSessionState]);
    }

    return false;
}

bool CSessionData::CharDisable(unsigned long dwCID, unsigned long dwServerID)
{
    if (SE_CHAR_ENABLED == m_eSessionState)
    {        
        if (m_dwCID != dwCID || m_dwServerID != dwServerID)
        {
            SERLOG5(g_Log, "UID:%10u / CID:%10u / ServerID:0x%08X / DisableCID:%10u / DisableServerID:0x%08X / "
                "ij¸¯ÅÍ ºñÈ°¼ºÈ­ ½ÇÆÐ : ´Ù¸¥ ij¸¯ÅÍ·Î, ȤÀº ´Ù¸¥ ¼­¹ö¿¡¼­ ºñÈ°¼ºÈ­ ½Ãµµ",
                m_dwUID, m_dwCID, m_dwServerID, dwCID, dwServerID);
        }
        else
        {
            int nRace = (0 != m_lpCharacterData) ? m_lpCharacterData->GetRace() : -1;

            // ij¸¯ÅÍ ºñÈ°¼ºÈ­ Àü¼Û
            SendPacket::UpdateUIDTable(PktUUT::UpdateUIDTableCharLogout,
                m_szAccount, NULL, m_dwUID, m_dwCID, m_dwSessionID, m_dwServerID, m_RemoteAddress);
            
            // µ¥ÀÌÅÍ ¹Ý³³. ¼º°øÇÏ´ø ½ÇÆÐÇÏ´ø, ¼ÒÀ¯±ÇÀº ÀÒ¾î¹ö¸®°Ô µÈ´Ù.
            UnloadData();

            // ij¸¯ÅÍ ºñÈ°¼ºÈ­ (ÇÔ¼ö È£Ãâ ÈÄ¿¡ µ¥ÀÌÅÍ ¸®¼Â)
            SetSessionState(SE_CHAR_DISABLED);

            GET_MULTI_DISPATCH(lpGameDispatch, dwServerID, 
                CGameDispatch, CGameDispatch::GetDispatchTable());

            if(0 != lpGameDispatch)
            {
                lpGameDispatch->DecCharNum(nRace);
            }

            // ¼ø¼­ ÁÖÀÇ! ¸Ç ¸¶Áö¸·¿¡ 0À¸·Î Ŭ¸®¾î!
            m_dwCID = 0;
            m_dwServerID = 0;
            m_cNewZone = 0;
            GetBilling().ClearBilling();
            return true;
        }
    }
    else
    {
        LogCharDataError("ij¸¯ÅÍ ºñÈ°¼ºÈ­ ½Ãµµ ½ÇÆÐ", LOG_FFL);
    }
    
    return false;
}

bool CSessionData::CharMove(unsigned long dwCID, unsigned long dwServerID)
{
    if (SE_CHAR_ENABLED == m_eSessionState)
    {
        if (m_dwCID != dwCID || m_dwServerID != dwServerID)
        {
            SERLOG5(g_Log, "UID:%10u / CID:%10u / ServerID:0x%08X / DisableCID:%10u / DisableServerID:0x%08X / "
                "ij¸¯ÅÍ À̵¿ ½ÇÆÐ : ´Ù¸¥ ij¸¯ÅÍ·Î, ȤÀº ´Ù¸¥ ¼­¹ö¿¡¼­ ºñÈ°¼ºÈ­ ½Ãµµ",
                m_dwUID, m_dwCID, m_dwServerID, dwCID, dwServerID);
        }
        else
        {
            int nRace = (0 != m_lpCharacterData) ? m_lpCharacterData->GetRace() : -1;

            // ij¸¯ÅÍ À̵¿ Àü¼Û
            SendPacket::UpdateUIDTable(PktUUT::UpdateUIDTableCharLogout,
                m_szAccount, NULL, m_dwUID, m_dwCID, m_dwSessionID, m_dwServerID, m_RemoteAddress);

            LogCharData("ij¸¯ÅÍ À̵¿");

            // µ¥ÀÌÅÍ ¹Ý³³. ¼º°øÇÏ´ø ½ÇÆÐÇÏ´ø, ¼ÒÀ¯±ÇÀº ÀÒ¾î¹ö¸®°Ô µÈ´Ù.
            UnloadData();

            // ij¸¯ÅÍ À̵¿(ÇÔ¼ö È£Ãâ µÚ¿¡ µ¥ÀÌÅÍ ¸®¼Â
            SetSessionState(SE_MOVE);

            GET_MULTI_DISPATCH(lpGameDispatch, dwServerID, 
                CGameDispatch, CGameDispatch::GetDispatchTable());

            if(0 != lpGameDispatch)
            {
                lpGameDispatch->DecCharNum(nRace);
            }

            // ¼ø¼­ ÁÖÀÇ! ¸Ç ¸¶Áö¸·¿¡ 0À¸·Î Ŭ¸®¾î!
            m_dwCID = 0;
            m_dwServerID = 0;
            GetBilling().ClearBilling();
            return true;
        }
    }
    else
    {
        LogCharDataError("ij¸¯ÅÍ À̵¿ ½Ãµµ ½ÇÆÐ", LOG_FFL);
    }

    return false;
}


// ---------------------------------------------------------------------------
// Á¸ À̵¿ °ü·Ã ºÎºÐ

// Á¸ À̵¿ ¼³Á¤
bool CSessionData::SetMoveZone(unsigned char cZone, const POS& Pos)		
{	
    if (!CheckCharZone(cZone))
    {
        return false;
    }

    m_cNewZone = cZone;	
    m_NewPos = Pos;		

    return true;
}

// Á¸ À̵¿ ¾÷µ¥ÀÌÆ®
void CSessionData::UpdateMoveZone()
{	
    if (0 != m_cNewZone && 0 != m_lpCharacterData)
    {
        CHAR_POS charPos;

        charPos.LastPoint = m_NewPos;
        charPos.SavePoint = m_NewPos;

        m_lpCharacterData->SetPos(charPos);
    }

    m_cNewZone = 0;
}

// ij¸¯ÅÍ Á¸ üũ
bool CSessionData::CheckCharZone(unsigned char cZone)
{
	if(this->m_cAdminLevel)
	{
		return true;
	}

	bool bResult = false;

	// edith 2009.07.30 Á¾Á·º°·Î °¥¼ö¾ø´Â Á¸À» Á¦ÇÑÇÑ´Ù.
	int nRace = (0 != m_lpCharacterData) ? m_lpCharacterData->GetRace() : -1;
	if(nRace == CClass::HUMAN)
	{
		if(cZone == SERVER_ID::ZONE2 || cZone == SERVER_ID::ZONE5)
			return false;
	}
	else if(nRace == CClass::AKHAN)
	{
		if(cZone == SERVER_ID::ZONE1 || cZone == SERVER_ID::ZONE4)
			return false;
	}

	if (cZone == SERVER_ID::ZONE1 || cZone == SERVER_ID::ZONE2 || cZone == SERVER_ID::ZONE4 || cZone == SERVER_ID::ZONE5)
	{
		// ÆÄÆ®1¿¡¼­ 2·Î Ãß°¡µÈ ±âº»¼­¹ö
		bResult = true;
	}
	else if (cZone == SERVER_ID::CAPITAL || cZone == SERVER_ID::ZONE12 || cZone == SERVER_ID::PRISON)
	{
		// ÆÄÆ®2¿¡¼­ »ç¿ëÇß´ø ·ÎÁ÷
		bResult = true;
	}
	else if (cZone == SERVER_ID::STONE_WAR1 || cZone == SERVER_ID::STONE_WAR2 || cZone == SERVER_ID::STONE_WAR3)
	{
		// ´ÙÅ©Ä«³ª¹Ý Á¦ÇÑ
		if (true == CServerSetup::GetInstance().UseContents(GameRYL::STONE_BATTLE))
		{
			bResult = true;
		}
	}
	else if (cZone == SERVER_ID::ZONE9)
		bResult = true;
	

/*
	else if (cZone == SERVER_ID::ZONE9)
	{
		// ½Å±ÔÁ¸ Á¦ÇÑ
		if (true == CServerSetup::GetInstance().UseContents(GameRYL::NEWZONE_ZONE9))
		{
			bResult = true;
		}
	}
*/
	return bResult;
}

// edith 2008.02.28 ij¸¯ÅÍ ½ÃÀÛ Á¸
unsigned char CSessionData::GetCharStartZone(char cRace)
{
	if(cRace == CHAR_CREATE::HUMAN)
		return SERVER_ID::ZONE1;

//	else if(cRace == CHAR_CREATE::AKHAN)
	return SERVER_ID::ZONE2;

//	return SERVER_ID::ZONE12;
}

void CSessionData::LogUserData(const char* szMessage)
{
    RULLOG5(g_Log, "UID:%10u / ServerID:0x%08X / ST:%s / IP:%15s / %s",
        m_dwUID, m_dwServerID, g_szSessionStateString[m_eSessionState],
        inet_ntoa(m_RemoteAddress), szMessage);
}

void CSessionData::LogCharData(const char* szMessage)
{
    if(0 != m_lpCharacterData)
    {
        RULLOG9(g_Log, "UID:%10u / CID:%10u / ServerID:0x%08X / ST:%s / "
            "IP:%15s / DataCID:%10u / Name:%-16s / Lev:%3d / %s",
            m_dwUID, m_dwCID, m_dwServerID, g_szSessionStateString[m_eSessionState], 
            inet_ntoa(m_RemoteAddress), m_lpCharacterData->GetCID(), 
            m_lpCharacterData->GetName(), m_lpCharacterData->GetInfo().Level, szMessage);
    }
    else
    {
        LogUserData(szMessage);
    }
}

void CSessionData::LogUserDataError(const char* szMessage, const char* szRoutine, 
                                    const char* szFile, int nLine)
{
    g_Log.DetailLog(LOG_ERROR, szRoutine, szFile, nLine, 
        "UID:%10u / ServerID:0x%08X / ST:%s / IP:%15s / %s",
        m_dwUID, m_dwServerID, g_szSessionStateString[m_eSessionState],
        inet_ntoa(m_RemoteAddress), szMessage);
}

void CSessionData::LogCharDataError(const char* szMessage, const char* szRoutine, 
                                    const char* szFile, int nLine)
{
    if(0 != m_lpCharacterData)
    {
        g_Log.DetailLog(LOG_ERROR, szRoutine, szFile, nLine, 
            "UID:%10u / CID:%10u / ServerID:0x%08X / ST:%s / "
            "IP:%15s / DataCID:%10u / Name:%-16s / Lev:%3d / %s",
            m_dwUID, m_dwCID, m_dwServerID, g_szSessionStateString[m_eSessionState], 
            inet_ntoa(m_RemoteAddress), m_lpCharacterData->GetCID(), 
            m_lpCharacterData->GetName(), m_lpCharacterData->GetInfo().Level, szMessage);
    }
    else
    {
        LogUserDataError(szMessage, szRoutine, szFile, nLine);
    }
}

//! ¿äû Å¥ °ü·Ã (dwRequestKey°¡ 0ÀÌ¸é ¿¡·¯)
void CSessionData::PushRequest(const RequestData& reqData)
{
    m_RequestQueue.push_back(reqData);
}

RequestData CSessionData::PopRequest()
{
    RequestData data;

    if(m_RequestQueue.empty())
    {
        data.m_dwRequestKey = 0;
        data.m_dwServerID = 0;
        data.m_dwSelectedCID = 0;
    }
    else
    {
        data = m_RequestQueue.front();
        m_RequestQueue.pop_front();
    }    

    return data;
}

const UnifiedCharData* CSessionData::GetUnifiedCharData(unsigned long dwCID) const
{
    const UnifiedCharData* lpPos = m_UnifiedCharData;
    const UnifiedCharData* lpEnd = m_UnifiedCharData + m_nUnifiedCharDataNum;

    for(; lpPos != lpEnd; ++lpPos)
    {
        if (lpPos->dwNewCID == dwCID)
        {
            return lpPos;
        }
    }

    return 0;
}

bool CSessionData::HasUnifiedStoreInfo(unsigned char cOldServerGroupID)
{
    const UnifiedStoreInfo* lpPos = m_UnifiedStoreInfo;
    const UnifiedStoreInfo* lpEnd = m_UnifiedStoreInfo + m_nUnifiedStoreInfoNum;

    for(; lpPos != lpEnd; ++lpPos)
    {
        if(lpPos->cOldServerGroupID == cOldServerGroupID)
        {
            return true;
        }
    }

    return false;
}

bool CSessionData::ChangeUnifiedStoreInfoGroup(CDBComponent& DBComponent, 
                                               unsigned char cOldServerGroupID, 
                                               unsigned char cNewServerGroupID)
{
    CStoreDataMgr&  storeDataMgr = CStoreDataMgr::GetInstance();
    UnifiedStoreKey storeKey(m_dwUID, cOldServerGroupID);    

    if (HasUnifiedStoreInfo(cOldServerGroupID) &&
        !storeDataMgr.IsDataLoginDB(storeKey) &&
        !storeDataMgr.IsDataLogoutDB(storeKey))
    {
        // â°í¸¦ ¼±ÅÃÇÑ Àû ¾ø°í, Á¸ÀçÇϴ â°íÀÌ°í, ij½¬¿¡¼­ ´©°¡ »ç¿ëÇÏ°í Àִ°¡¸¦ 
        // È®ÀÎÇÑ ´ÙÀ½, ´ÙÀ½À» ¼öÇàÇÑ´Ù.
       
        // cOldServerGroupIDÀÇ Ã¢°í µ¥ÀÌÅ͸¦ cChangedServerGroupID·Î µ¤¾î ¾º¿ì°í,
        // cOldServerGroupIDÀÇ Ã¢°í µ¥ÀÌÅ͸¦ NULL·Î ¸¸µç´Ù.
        if(!DBComponent::GameDB::ChangeUnifiedItemStoreGroup(
            DBComponent, storeKey.first, cOldServerGroupID, cNewServerGroupID))
        {
            // â°í ±×·ì ¹øÈ£ º¯°æ ½ÇÆÐ
            ERRLOG2(g_Log, "UID:%10u / SelectedServerGroupID:%d / ÅëÇÕ¼­¹ö ¼±Åà ½ÇÆÐ : â°í ±×·ì ¹øÈ£ º¯°æ ½ÇÆÐ",
                storeKey.first, cOldServerGroupID);            
        }
        else
        {
            // 3. ¸Þ¸ð¸®ÀÇ UnifiedStoreInfo¸¦ ¸ÂÃç¼­ º¯°æÇÑ´Ù.
            UnifiedStoreInfo* lpPos = m_UnifiedStoreInfo;
            UnifiedStoreInfo* lpEnd = m_UnifiedStoreInfo + m_nUnifiedStoreInfoNum;

            for(; lpPos != lpEnd; ++lpPos)
            {
                if (lpPos->cOldServerGroupID == cOldServerGroupID)
                {
                    lpPos->cOldServerGroupID = cNewServerGroupID;
                    break;
                }
            }

            return true;
        }
    }
    else
    {
        ERRLOG2(g_Log, "UID:%10u / SelectedServerGroupID:%d / ÅëÇÕ¼­¹ö ¼±Åà ½ÇÆÐ : À߸øµÈ ¼­¹ö±×·ì ¼±ÅÃ",
            storeKey.first, storeKey.second);
    }

    return false;
}

bool CSessionData::ChangeUnifiedCharServerGroupID(CDBComponent& DBComponent, unsigned long dwUID, 
                                                  unsigned long dwCID, unsigned char cOldServerGroupID)
{
    if (0 != GetUnifiedCharData(dwCID))
    {
        if (!DBComponent::GameDB::UpdateUnifiedCharServerGroupID(
            DBComponent, dwUID, dwCID, cOldServerGroupID))
        {
            // ¿¡·¯ ·Î±× ³²±è
            ERRLOG3(g_Log, "UID:%10u / CID:%10u / ServerGroupID:%d / ÅëÇÕ¼­¹ö ¼±Åà ½ÇÆÐ : ij¸¯ÅÍ ¼­¹ö±×·ì IDº¯°æ ½ÇÆÐ",
                dwUID, dwCID, cOldServerGroupID);
        }
        else
        {
            UnifiedCharData* lpPos = m_UnifiedCharData;
            UnifiedCharData* lpEnd = m_UnifiedCharData + m_nUnifiedCharDataNum;

            for(; lpPos != lpEnd; ++lpPos)
            {
                if (lpPos->dwNewCID == dwCID)
                {
                    // ¸Þ¸ð¸® µ¥ÀÌÅ͸¦ ¼öÁ¤ÇÑ´Ù.
                    lpPos->cOldServerGroupID = cOldServerGroupID;
                    break;
                }
            } 

            return true;
        }
    }
    else
    {
        ERRLOG3(g_Log, "UID:%10u / CID:%10u / ServerGroupID:%d / ÅëÇÕ¼­¹ö ¼±Åà ½ÇÆÐ : À߸øµÈ ij¸¯ÅÍ ¼±ÅÃ",
            dwUID, dwCID, cOldServerGroupID);
    }

    return false;
}


bool CSessionData::DelUnifiedCharData(unsigned long dwCID)
{
    UnifiedCharData* lpPos = m_UnifiedCharData;
    UnifiedCharData* lpEnd = m_UnifiedCharData + m_nUnifiedCharDataNum;

    for(; lpPos != lpEnd; ++lpPos)
    {
        if (lpPos->dwNewCID == dwCID)
        {
            memmove(lpPos, lpPos + 1, lpEnd - lpPos - 1);
            return true;
        }
    }

    return false;
}

bool CSessionData::UpdateCharacterBinding(CDBComponent& DBComponent, 
                                          unsigned long dwSelectedCID[USER_INFO::MAX_CHAR_NUM])
{
    // UserInfo¸¦ °»½ÅÇÑ´Ù.
    USER_INFO userInfo = m_UserInfo;

    unsigned char cSelectedCount = 0;

    for(int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        if(0 == userInfo.CharID[nCount] && 0 != dwSelectedCID[nCount])
        {
            userInfo.CharID[nCount] = dwSelectedCID[nCount];
            ++cSelectedCount;
        }
    }

    // UserInfo¸¦ DB¿¡ ¾÷µ¥ÀÌÆ®ÇÑ´Ù.
    if (0 != memcmp(&m_UserInfo, &userInfo, sizeof(USER_INFO)))
    {
        if (!DBComponent::GameDB::UpdateUser(DBComponent, m_dwUID, &userInfo))
        {
            // DBÄõ¸® ½ÇÆÐ!
            return false;
        }
        else
        {
            m_UserInfo = userInfo;
        }
    }

    // ij¸¯ÅÍ ÀÌÀü ȸ¼ö¸¦ DB¿¡ ±â·ÏÇÑ´Ù.
    m_cTransferedCharCount += cSelectedCount;
    UpdateTransferedCharCount(DBComponent);    

    // ¼±ÅÃÇÑ Ä³¸¯ÅÍ ºä¸¦ ´Ù½Ã ¾ò¾î¿Â´Ù.
    bool bGetViewResult = true;

    for (int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        if (0 != m_UserInfo.CharID[nCount] && 
            !DBComponent::GameDB::GetCharView(DBComponent, m_UserInfo.CharID[nCount], &m_CharView[nCount]))
        {
            SERLOG5(g_Log, "UID:%10u / ServerGroupID:%d / CID:%10u / Slot:%d / ij¸¯ÅÍ ºä ¾ò±â ½ÇÆÐ : %s", 
                m_dwUID, m_cOldServerGroupID, m_UserInfo.CharID[nCount], nCount, DBComponent.GetErrorString());

            bGetViewResult = false;
        }
    }

    if(bGetViewResult)
    {
        INFLOG2(g_Log, "UID:%10u / ServerGroupID:%d / À¯Àú Á¤º¸ ¾ò±â ¼º°ø", 
            m_dwUID, m_cOldServerGroupID);
        return true;
    }

    return false;
}

CClass::RaceType CSessionData::CheckUnifiedCharRace(unsigned long dwSelectedCID[USER_INFO::MAX_CHAR_NUM])
{
    CClass::RaceType eLastRace = CClass::MAX_RACE;
    CClass::RaceType eCharRace = CClass::MAX_RACE;

    unsigned long dwCheckCID[USER_INFO::MAX_CHAR_NUM];
    memset(dwCheckCID, 0, sizeof(unsigned long) * USER_INFO::MAX_CHAR_NUM);

    for(int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        if(0 != m_UserInfo.CharID[nCount])
        {
            dwCheckCID[nCount] = m_UserInfo.CharID[nCount];
        }
        else if(0 != dwSelectedCID[nCount])
        {
            dwCheckCID[nCount] = dwSelectedCID[nCount];
        }
    }

    for(int nCount = 0; nCount < USER_INFO::MAX_CHAR_NUM; ++nCount)
    {
        if(0 != dwCheckCID[nCount])
        {
            UnifiedCharData* lpPos = m_UnifiedCharData;
            UnifiedCharData* lpEnd = m_UnifiedCharData + m_nUnifiedCharDataNum;

            for(; lpPos != lpEnd; ++lpPos)
            {
                if (lpPos->dwNewCID == dwCheckCID[nCount])
                {
                    eCharRace = CClass::GetRace(static_cast<unsigned char>(lpPos->sClass));

                    if(eLastRace == CClass::MAX_RACE)
                    {
                        eLastRace = eCharRace;
                    }
                    else if(eLastRace != eCharRace)
                    {
                        // ij¸¯ÅÍ°¡ Á¾Á·ÀÌ ´Ù¸¥ °Ô ¼¯¿© ÀÖÀ¸¸é ¾ÈµÈ´Ù.
                        return CClass::MAX_RACE;
                    }
                }
            }
        }
    }

    return eLastRace;
}


unsigned char CSessionData::GetTransferedCharCount(CDBComponent& DBComponent)
{
    if (UCHAR_MAX == m_cTransferedCharCount)
    {
        OleDB::PARAM_INFO paramInfo;
        memset(&paramInfo, 0, sizeof(OleDB::PARAM_INFO));

        paramInfo.ColNum = 1;
        paramInfo.eParamIO[0]   = DBPARAMIO_INPUT;
        paramInfo.ColType[0]    = DBTYPE_I4;
		paramInfo.ColSize[0]    = sizeof(unsigned long);
        
        // DB¿¡¼­ ·Îµå
        if (!DBComponent.ExecuteQueryWithParams(
            "SELECT TransferCharCount FROM UserFirstLoginInfo WHERE UID=?", 
            reinterpret_cast<char*>(&m_dwUID), paramInfo))
        {
            ERRLOG2(g_Log, "UID:%10u / ij¸¯ÅÍ ÀÌÀü ȸ¼ö ·Îµå ½ÇÆÐ : DBÄõ¸® ½ÇÆÐ : %s", 
                m_dwUID, DBComponent.GetErrorString());
        }
        else if (!DBComponent.GetData(&m_cTransferedCharCount))
        {
            ERRLOG2(g_Log, "UID:%10u / ij¸¯ÅÍ ÀÌÀü ȸ¼ö ·Îµå ½ÇÆÐ : DB GetData ½ÇÆÐ : %s", 
                m_dwUID, DBComponent.GetErrorString());
        }
    }

    return m_cTransferedCharCount;
}

bool CSessionData::UpdateTransferedCharCount(CDBComponent& DBComponent)
{
    // DB¿¡ ±â·ÏÇÑ´Ù.
    OleDB::PARAM_INFO paramInfo;
    memset(&paramInfo, 0, sizeof(OleDB::PARAM_INFO));

    paramInfo.ColNum = 2;
    paramInfo.eParamIO[0]   = DBPARAMIO_INPUT;
    paramInfo.ColType[0]    = DBTYPE_UI1;
	paramInfo.ColSize[0]    = sizeof(unsigned char);
    
    paramInfo.eParamIO[1]   = DBPARAMIO_INPUT;
    paramInfo.ColType[1]    = DBTYPE_I4;
	paramInfo.ColSize[1]    = sizeof(unsigned long);

#pragma pack(1)

    struct UpdateTransferCharCountParam
    {
        unsigned char   m_cTransferedCharCount;
        unsigned long   m_dwUID;
    };

#pragma pack()

    UpdateTransferCharCountParam paramData;

    paramData.m_cTransferedCharCount = m_cTransferedCharCount;
    paramData.m_dwUID = m_dwUID;

    // DB¿¡¼­ ·Îµå
    if (!DBComponent.ExecuteQueryWithParams(
        "UPDATE UserFirstLoginInfo SET TransferCharCount=? WHERE UID=?", 
        reinterpret_cast<char*>(&paramData), paramInfo))
    {
        ERRLOG2(g_Log, "UID:%10u / ij¸¯ÅÍ ÀÌÀü ȸ¼ö ¾÷µ¥ÀÌÆ® ½ÇÆÐ : DBÄõ¸® ½ÇÆÐ : %s", 
            m_dwUID, DBComponent.GetErrorString());

        return false;
    }

    return true;
}


bool CSessionData::GetRealmPointCheck()
{
	DBAgent::DataStorage::CCharacterData* lpCharacterData = GetCharacterData();

	// ÀÌÇÔ¼ö´Â ij¸¯ÅÍ°¡ ·Î±×¾Æ¿ô µÉ¶§ µé¾î¿Â´Ù.

	if(lpCharacterData)
	{
		unsigned char cRealmPoint = lpCharacterData->GetRealmPoint();

		// ÇöÀç ½Ã°£ÀÌ ÀüÀïÁßÀÌ°í.
		if(CGameTimeDBMgr::GetInstance().GetCurrentGameTime(GameTime::REALM)==GameTime::RT_REALM_WAR
			|| CGameTimeDBMgr::GetInstance().GetCurrentGameTime(GameTime::REALM)==GameTime::RT_REALM_WAR_END_5)
		{
			// ij¸¯ÅÍ¿¡ ÁÖ¿öÁ®¾ßÇÒ Àӽà ·¤¸§Æ÷ÀÎÆ®°¡ ¾øÀ¸¸é.
			if(!lpCharacterData->GetRealmCheckPoint())
			{
				// 1Æ÷ÀÎÆ®ÀÇ ·¼¸§Æ÷ÀÎÆ®¸¦ ÁØ´Ù. ¿©±â¼­ AddRealmPoint´Â ÇØ´ç ¼­¹ö¿¡
				// ·Î±×ÀÎÇÑ ½Ã°£ºÎÅÍ ·¤¸§Àü/2ÀÇ ½Ã°£ÀÌ Áö³ª¾ß¸¸ ÁØ´Ù.
/*
				// edith 2010.01.10 ½Ã°£º°·Î ·¼¸§ Æ÷ÀÎÆ® ÁÖ´Â ºÎºÐ »èÁ¦
				// ½Ã°£¿¡ µû¶ó ·¼¸§Æ÷ÀÎÆ®¸¦ ÁÖ´Â ·ÎÁ÷ÀÌ Á¦°ÅµÆ°í. ±æµå¿øÀÇ ¼ö¿¡ µû¶ó º°À» ÁÖ°Ô ¼öÁ¤µÆ´Ù.
				RealmPoint::AddRealmPoint(this, 1);
*/
				// ¸¸¾à ·¼¸§Æ÷ÀÎÆ®ÀÇ °ªÀÌ ´õÅ©¸é.
				// ÀÌ·ÎÁ÷Àº AddRealmPoint ÇÔ¼ö¸¦ È£ÃâÇϱâÀü¿¡ 1ÀÌ°í ·Î±×¾Æ¿ô½Ã È£ÃâÇؼ­ 
				// ·¤¸§Æ÷ÀÎÆ®°ªÀÌ 2ÀÌ¸é ¹Ù·Î ÁÖ¾îÁöÁö ¾Ê°í 
				// ·¤¸§Ã¼Å© Æ÷ÀÎÆ®¿¡ 1Æ÷ÀÎÆ®¸¦ Á༭ ´ÙÀ½ ·Î±×Àνà ¹ÞÀ»¼ö ÀÖ°Ô Çϱâ À§ÇÑ·ÎÁ÷
				// Áï ·Î±×¾Æ¿ô½Ã AddRealmPoint ÇÔ¼ö´Â À¯Àú°¡ ·¤¸§Æ÷ÀÎÆ®¸¦ ¹ÞÀ»¼öÀÖ´Â »óȲÀÌ³Ä ¾Æ´Ï³Ä¸¦ °Ë»ç
				// Çϱâ À§ÇÑ ÇÔ¼ö·Î »ç¿ëµÇ°í ÀÖÀ½. 
				if(cRealmPoint<lpCharacterData->GetRealmPoint())
				{
					lpCharacterData->SetRealmCheckPoint(1);
					lpCharacterData->SetRealmPoint(cRealmPoint);
					lpCharacterData->SetRealmMinute(0);					
				}
				else
				{
					// ¸¸¾à Æ÷ÀÎÆ®°¡ °°°Å³ª ÀÛÀ¸¸é À̸»Àº Æ÷ÀÎÆ®°¡ º¯°æµÈ°Ô ¾ø´Ù.
					// ±×·³ À¯ÀúÀÇ ·¤¸§Àü ½Ã°£À» °»½ÅÇØÁØ´Ù.
					// edith 2008.12.4 ·Î±×ÀΠŸÀÓÀ¸·Î ó¸®
					TIME* pTime = lpCharacterData->GetLoginTime();
//					TIME* pTime = lpCharacterData->GetLogoutTime();

					if(pTime)
					{
						CTime timeCurrent = CTime::GetCurrentTime();

						CTime timeLogin(pTime->Year, pTime->Month, pTime->Day, pTime->Hour, pTime->Minute, pTime->Second, pTime->MSecond);

						CTimeSpan ts = timeCurrent - timeLogin;

						unsigned char cMinute = lpCharacterData->GetRealmMinute();

						lpCharacterData->SetRealmMinute((unsigned char)(ts.GetTotalMinutes()+cMinute));
					}					
				}
			}			
		}		

		// edith 2010.01.02 °øÇåÆ÷ÀÎÆ®¸¦ ±æµå¿ø Á¤º¸¿¡ µû¶ó ó¸®ÇØÁÖ´Â ÇÔ¼ö.
		unsigned int GID = lpCharacterData->GetGID();
		Guild::CGuildDB* lpGuild = static_cast<Guild::CGuildDB*>(
            Guild::CGuildDBMgr::GetInstance().GetGuild( GID ));

		if(lpGuild)
		{
			unsigned char MaxNum = lpGuild->GetMaxMemberNum();
			unsigned char CurNum = lpGuild->GetCurrentMemberNum();
			lpCharacterData->SetRealmPoint(MaxNum/10);
		}
		else 
			lpCharacterData->SetRealmPoint(0);


		CTime timeLogin = CTime::GetCurrentTime();

		TIME* pLoggoutTime = lpCharacterData->GetLogoutTime();

		if(pLoggoutTime)
		{
			pLoggoutTime->Year		= timeLogin.GetYear();
			pLoggoutTime->Month		= timeLogin.GetMonth();
			pLoggoutTime->Day		= timeLogin.GetDay();			
			pLoggoutTime->Hour		= timeLogin.GetHour();
			pLoggoutTime->Minute	= timeLogin.GetMinute();
			pLoggoutTime->Second	= timeLogin.GetSecond();
		}
	}	
	return true;
}


}
}