#include "stdafx.h"
#include "CharacterData.h"
#include "SessionData.h"
#include "DBDataMgr.h"
#include "DBItemSerialMgr.h"

#include <DB/DBComponent.h>
#include <DB/GameDBComponent.h>
#include <Log/ServerLog.h>

#include <Item/ItemStructure.h>

#include <Item/ItemStructure.h>
#include <Item/ItemConstants.h>
#include <Item/Container/ContainerConstant.h>
#include <Item/RebalanceConvert/ContainerChecker.h>
#include <Item/RebalanceConvert/RebalanceItem.h>
#include <Utility/Debug/PerformanceCheck.h>

#include <Network/Packet/PacketStruct/CharLoginOutPacketStruct.h>
#include <mmsystem.h>

#include <Network/Dispatch/GameDispatch.h>
#include <Creature/Character/CharacterCreate.h>
#include <Creature/Character/ExpTable.h>

#include <Community/FriendList.h>

#include <DataStorage/SessionDataMgr.h>

#include <GameTime/GameTimeDBMgr.h>

namespace DBAgent
{
namespace DataStorage
{

CCharacterData::CCharacterData()
:   m_FriendList(0), m_BanList(0), m_dwUpdateData(0), m_dwLastDBUpdateTime(0)
{
    ClearData();
}

CCharacterData::~CCharacterData()
{

}

void CCharacterData::SetUID(unsigned long dwUID)
{
	m_dwUID = dwUID;
}

void CCharacterData::SetPID(unsigned long dwPID)
{
    m_CharInfo.PID = dwPID;
    m_dwUpdateData |= CHANGED_CHAR_INFOST;
}	


void CCharacterData::SetGID(unsigned long dwGID)
{
    m_CharInfo.GID = dwGID;
    m_dwUpdateData |= CHANGED_CHAR_INFOST;
}

void CCharacterData::SetServerID(unsigned long dwServerID)
{
    m_CharInfoEx.ServerID = dwServerID;
    m_dwUpdateData |= CHANGED_CHAR_INFOEX;
}

bool CCharacterData::SetInfo(const CHAR_INFOST& charInfoST, bool bChangeName)
{   
    CHAR_INFOST local_InfoST = charInfoST;

    if(!bChangeName)
    {
        // À̸§À» º¯°æÇÏÁö ¾Ê´Â °æ¿ì´Â, À̸§À» Áö±Ý À̸§À¸·Î µ¤¾î¾º¿î´Ù.
        memcpy(local_InfoST.Name, m_CharInfo.Name, 
            sizeof(char) * CHAR_INFOST::MAX_NAME_LEN);
    }

    if(m_CharInfo.CID != local_InfoST.CID || 0 == local_InfoST.Level)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¿¡·¯ : UpdateCID : %10u, Level : %d", 
            m_CharInfo.CID, local_InfoST.CID, local_InfoST.Level);

        return false;
    }
    else if(0 != memcmp(&m_CharInfo, &local_InfoST, sizeof(CHAR_INFOST)))
    {
        m_CharInfo = local_InfoST;
        m_dwUpdateData |= CHANGED_CHAR_INFOST;
    }

    return true;
}

void CCharacterData::SetPos(const CHAR_POS& charPos)
{
    if(0 != memcmp(&m_CharPos, &charPos, sizeof(CHAR_POS)))
    {
        m_CharPos = charPos;
        m_dwUpdateData |= CHANGED_CHAR_POS;
    }
}

void CCharacterData::SetSkill(const SKILL& skill)
{
    if(0 != memcmp(&m_Skill, &skill, sizeof(SKILL)))
    {
        m_Skill = skill;
        m_dwUpdateData |= CHANGED_SKILL;
    }

}

void CCharacterData::SetQuick(const QUICK& quick)
{
    if(0 != memcmp(&m_Quick, &quick, sizeof(QUICK)))
    {
        m_Quick = quick;
        m_dwUpdateData |= CHANGED_QUICK;
    }
}

void CCharacterData::SetSpell(const SPELL& spell)
{
	if(0 != memcmp(&m_Spell, &spell, sizeof(SPELL)))
	{
		m_Spell = spell;
		m_dwUpdateData |= CHANGED_SPELL;
	}
}

void CCharacterData::SetInfoEx(const CHAR_INFOEX& charInfoEx)
{
    if(0 != memcmp(&m_CharInfoEx, &charInfoEx, sizeof(CHAR_INFOEX)))
    {
        m_CharInfoEx = charInfoEx;
        m_dwUpdateData |= CHANGED_CHAR_INFOEX;
    }
}


void CCharacterData::SetQuest(const QUEST& quest)
{
    if(0 != memcmp(&m_Quest, &quest, sizeof(QUEST)))
    {
        m_Quest = quest;
        m_dwUpdateData |= CHANGED_QUEST;
    }
}


void CCharacterData::SetHistory(const HISTORY& history)
{
    if(0 != memcmp(&m_History, &history, sizeof(HISTORY)))
    {
        m_History = history;
        m_dwUpdateData |= CHANGED_HISTORY;
    }
}


void CCharacterData::SetConfig(const CONFIG& config)
{
    if(0 != memcmp(&m_Config, &config, sizeof(CONFIG)))
    {
        m_Config = config;
        m_dwUpdateData |= CHANGED_CONFIG;
    }
}


bool CCharacterData::SetEquip(const char* szData, unsigned long dwDataLen)
{
    if(EQUIP::MAX_EQUIP_SIZE < dwDataLen)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¿¡·¯ : ÀåºñÁ¤º¸(%u)ÀÇ Å©±â(%u) ¿¡·¯", 
            GetCID(), EQUIP::MAX_EQUIP_SIZE, dwDataLen);

        return false;
    }
    else if(m_Equip.dwSize != dwDataLen || 0 != memcmp(m_Equip.Data, szData, dwDataLen))
    {
        memcpy(m_Equip.Data, szData, dwDataLen);
        m_Equip.dwSize = dwDataLen;

        m_dwUpdateData |= CHANGED_EQUIP;
    }

    return true;
}


bool CCharacterData::SetInven(const char* szData, unsigned long dwDataLen)
{
    if(INVEN::MAX_INVEN_SIZE < dwDataLen)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¿¡·¯ : Àκ¥Á¤º¸(%u)ÀÇ Å©±â(%u) ¿¡·¯",
            GetCID(), INVEN::MAX_INVEN_SIZE, dwDataLen);

        return false;
    }
    else if(m_Inven.dwSize != dwDataLen || 0 != memcmp(m_Inven.Data, szData, dwDataLen))
    {
        memcpy(m_Inven.Data, szData, dwDataLen);
        m_Inven.dwSize = dwDataLen;

        m_dwUpdateData |= CHANGED_INVEN;
    }

    return true;
}


bool CCharacterData::SetExtra(const char* szData, unsigned long dwDataLen)
{
    if(EXTRA::MAX_EXTRA_SIZE < dwDataLen)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¿¡·¯ : EXTRAÁ¤º¸(%u)ÀÇ Å©±â(%u) ¿¡·¯",
            GetCID(), EXTRA::MAX_EXTRA_SIZE, dwDataLen);

        return false;
    }
    else if(m_Extra.dwSize != dwDataLen || 0 != memcmp(m_Extra.Data, szData, dwDataLen))
    {
        memcpy(m_Extra.Data, szData, dwDataLen);
        m_Extra.dwSize = dwDataLen;

        m_dwUpdateData |= CHANGED_EXTRA;
    }

    return true;
}

bool CCharacterData::SetExchange(const char* szData, unsigned long dwDataLen)
{
    if(EXCHANGE::MAX_EXCHANGE_SIZE < dwDataLen)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¿¡·¯ : EXCHANGEÁ¤º¸(%u)ÀÇ Å©±â(%u) ¿¡·¯",
            GetCID(), EXCHANGE::MAX_EXCHANGE_SIZE, dwDataLen);

        return false;
    }
    else if(m_Exchange.dwSize != dwDataLen || 0 != memcmp(m_Exchange.Data, szData, dwDataLen))
    {
        memcpy(m_Exchange.Data, szData, dwDataLen);
        m_Exchange.dwSize = dwDataLen;

        m_dwUpdateData |= CHANGED_EXCHANGE;
    }

    return true;
}

bool CCharacterData::SetTempInven(const char* szData, unsigned long dwDataLen)
{
    if(TEMPINVEN::MAX_TEMPINVEN_SIZE < dwDataLen)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¿¡·¯ : ÀÓ½ÃÀκ¥Á¤º¸(%u)ÀÇ Å©±â(%u) ¿¡·¯",
            GetCID(), TEMPINVEN::MAX_TEMPINVEN_SIZE, dwDataLen);

        return false;
    }
    else if(m_TempInven.dwSize != dwDataLen || 0 != memcmp(m_TempInven.Data, szData, dwDataLen))
    {
        memcpy(m_TempInven.Data, szData, dwDataLen);
        m_TempInven.dwSize = dwDataLen;

        m_dwUpdateData |= CHANGED_TEMPINVEN;
    }

    return true;
}

bool CCharacterData::SetGuildWarFlag(unsigned char cFlag)
{
	if (cFlag >= Creature::WAR_OFF && cFlag <= Creature::WAR_INSTANCE)
	{
		m_CharInfoEx.GuildWarFlag = cFlag;
		return DBComponent::GameDB::UpdateGuildWarFlag(CDBSingleObject::GetInstance(), GetCID(), cFlag);
	}

	return false;
}

bool CCharacterData::SetRealmWarFlag(unsigned char cFlag)
{
	if (cFlag >= Creature::WAR_OFF && cFlag <= Creature::WAR_INSTANCE)
	{
		m_CharInfoEx.RealmWarFlag = cFlag;
		return DBComponent::GameDB::UpdateRealmWarFlag(CDBSingleObject::GetInstance(), GetCID(), cFlag);
	}

	return false;
}

void CCharacterData::ClearData()
{
    memset(&m_CharInfo, 0, sizeof(CHAR_INFOST));    // ±âº» Á¤º¸
    memset(&m_CharPos, 0, sizeof(CHAR_POS));		// À§Ä¡ Á¤º¸
    memset(&m_Skill, 0, sizeof(SKILL));		        // ½ºÅ³ Á¤º¸
    memset(&m_Quick, 0, sizeof(QUICK));		        // Äü½½·Ô

    memset(&m_CharInfoEx, 0, sizeof(CHAR_INFOEX));	// Ãß°¡ Á¤º¸
    memset(&m_Quest, 0, sizeof(QUEST));		        // Äù½ºÆ®
    memset(&m_History, 0, sizeof(HISTORY));		    // È÷½ºÅ丮	
    memset(&m_Config, 0, sizeof(CONFIG));		    // ¼³Á¤

    memset(&m_Equip, 0, sizeof(EQUIP));     		// Àåºñ
    memset(&m_Inven, 0, sizeof(INVEN));     		// Àκ¥
    memset(&m_Extra, 0, sizeof(EXTRA));     		// ¿©ºÐ
    memset(&m_Exchange, 0, sizeof(EXCHANGE));		// ±³È¯
    memset(&m_TempInven, 0, sizeof(TEMPINVEN));	    // Àӽà Àκ¥Å丮

    m_BanList.Clear();		// °ÅºÎ
    m_FriendList.Clear();	// Ä£±¸

    m_dwUID = 0;

    memset(&m_EquipView, 0, sizeof(unsigned short) * MAX_EQUIP_VIEW); // Àåºñ ºä
    m_dwUpdateData = 0;     // µ¥ÀÌÅÍ°¡ ¾÷µ¥ÀÌÆ®µÇ¾ú´ÂÁö¸¦ ³ªÅ¸³¿.
}

void CCharacterData::ReloadEquipView()
{    
    const char* lpDataPos = m_Equip.Data;
    const char* lpDataEnd = m_Equip.Data + m_Equip.dwSize;

    memset(m_EquipView, 0, sizeof(unsigned short) * MAX_EQUIP_VIEW);

    for(; lpDataPos < lpDataEnd; )
    {
        const Item::ItemData* lpItemData =
            reinterpret_cast<const Item::ItemData*>(lpDataPos);

        unsigned short usIndex = lpItemData->m_ItemPos.m_cIndex;

        if(usIndex < MAX_EQUIP_VIEW)
        {
            m_EquipView[usIndex] = lpItemData->m_usProtoTypeID;
        }
        else
        {
            ERRLOG3(g_Log, "CID:%10u / Àåºñ ºä ¼¼ÆÃÁß¿¡ À߸øµÈ Àåºñ(PrototypeID:%6d/Pos:%4d) ¹ß°ß.",
                GetCID(), lpItemData->m_usProtoTypeID, usIndex);
        }

        lpDataPos += lpItemData->m_cItemSize;

        if(0 == lpItemData->m_cItemSize)
        {
            ERRLOG4(g_Log, "CID:%10u / Àåºñ ºä ¼¼ÆÃÁß¿¡ À߸øµÈ Àåºñ Á¤º¸ ¹ß°ß. "
                "(PrototypeID:%6d/Pos:%4d/itemSize:%d)",
                GetCID(), lpItemData->m_usProtoTypeID, usIndex, lpItemData->m_cItemSize);
            
            break;
        }
    }
}

bool CCharacterData::GetFromDB(CDBComponent& DBComponent, unsigned long dwCID)
{
    PERFORMANCE_CHECK(FunctionTimingCheck);

    ClearData();

    using namespace DBComponent;

	bool bResult = false;

    FRIEND  Friend  = {0,};
    BAN     Ban     = {0,};

    // CharInfo ¾÷µ¥ÀÌÆ®
    if (!GameDB::GetCharInfo(DBComponent, dwCID, &m_CharInfo, m_EquipView, MAX_EQUIP_VIEW))
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetCharInfo È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // CharPos ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetCharPos(DBComponent, dwCID, &m_CharPos)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetCharPos È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // Quick ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetQuick(DBComponent, dwCID, &m_Quick)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetQuick È£Ãâ ½ÇÆÐ", dwCID);        
    }
	// Spell ¾÷µ¥ÀÌÆ®
	else if (!GameDB::GetSpell(DBComponent, dwCID, &m_Spell)) 
	{
		SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetSpell È£Ãâ ½ÇÆÐ", dwCID);        
	}
    // Skill ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetCharSkill(DBComponent, dwCID, &m_Skill)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetCharSkill È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // Equip ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetEquip(DBComponent, dwCID, &m_Equip)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetEquip È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // Inven ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetInven(DBComponent, dwCID, &m_Inven)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetInven È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // Extra ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetExtra(DBComponent, dwCID, &m_Extra)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetExtra È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // Exchange ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetExchange(DBComponent, dwCID, &m_Exchange)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetExchange È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // TempInven ¾÷µ¥ÀÌÆ®
    else if (!GameDB::GetTempInven(DBComponent, dwCID, &m_TempInven)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetTempInven È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // CharInfoEx
    else if (!GameDB::GetCharInfoEx(DBComponent, dwCID, &m_CharInfoEx)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetCharInfoEx È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // Friend
    else if (!GameDB::GetFriend(DBComponent, dwCID, &Friend)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetFriend È£Ãâ ½ÇÆÐ", dwCID);        
    } 
    else if(!m_FriendList.SerializeIn(Friend.Data, Friend.Info, Friend.dwSize, Friend.dwInfoSize))
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : CFriend::SerializeIn È£Ãâ ½ÇÆÐ", dwCID);        
    }	
    // Ban
    else if(!GameDB::GetBan(DBComponent, dwCID, &Ban)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetBan È£Ãâ ½ÇÆÐ", dwCID);        
    } 
    else if(!m_BanList.SerializeIn(Ban.Data, Ban.Info, Ban.dwSize, Ban.dwInfoSize))
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : CBan::SerializeIn È£Ãâ ½ÇÆÐ", dwCID);        
    }
    // Quest
    else if (!GameDB::GetQuest(DBComponent, dwCID, &m_Quest)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetQuest È£Ãâ ½ÇÆÐ", dwCID);
    }
    // History
    else if (!GameDB::GetHistory(DBComponent, dwCID, &m_History)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetHistory È£Ãâ ½ÇÆÐ", dwCID);
    }
    // Config
    else if (!GameDB::GetConfig(DBComponent, dwCID, &m_Config)) 
    {
        SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ½ÇÆÐ : GetConfig È£Ãâ ½ÇÆÐ", dwCID);
    }
    else
    {			
		// Friend Á¤º¸ ¼³Á¤ (½Ã°£ÀÌ »ý±â¸é ¼öÁ¤ÇÏ°ÚÀ½) //
		unsigned long dwListCID[CFriendList::MAX_FRIENDS_NUM];

		// Ä£±¸¸®½ºÆ®¿¡ CID ¸¸ °¡Áö°í ¿Â´Ù. //
		m_FriendList.GetCIDList(dwListCID);

		for(unsigned char cIndex = 0; cIndex < m_FriendList.GetFriendNum(); cIndex++)
		{
			CSessionData* lpSessionData = CSessionDataMgr::GetInstance().GetCharLoadedSession(dwListCID[cIndex]);

			CFriendList::Rebind* lpRebind = m_FriendList.GetFriend(dwListCID[cIndex]);

			if(lpRebind)			
			{				
				if(lpSessionData)
				{
					CCharacterData*	lpCharacterData = lpSessionData->GetCharacterData();				

					if(lpCharacterData)
					{
						// Frind ÃʱâÈ­ //
						lpRebind->InitializeFriendInfo(lpCharacterData->GetServerID(), lpCharacterData->GetGID(),
							lpCharacterData->GetClass(), lpCharacterData->GetLevel());
					}
					else
					{
						lpRebind->UpdateServerID(0);
					}
				}
				else
				{
					lpRebind->UpdateServerID(0);
				}
			}
		}

		// Ban Á¤º¸ ¼³Á¤ (½Ã°£ÀÌ »ý±â¸é ¿©±âµµ ¼öÁ¤ÇÏ°ÚÀ½) //

		// °ÅºÎ¸®½ºÆ®¿¡ CID ¸¸ °¡Áö°í ¿Â´Ù. //
		m_BanList.GetCIDList(dwListCID);

		for(unsigned char cIndex = 0; cIndex < m_BanList.GetBanNum(); cIndex++)
		{
			CSessionData* lpSessionData = CSessionDataMgr::GetInstance().GetCharLoadedSession(dwListCID[cIndex]);

			CBanList::Rebind* lpRebind = m_BanList.GetBan(dwListCID[cIndex]);

			if(lpRebind)			
			{								
				if(lpSessionData)
				{
					CCharacterData*	lpCharacterData = lpSessionData->GetCharacterData();

					if(lpCharacterData)
					{
						// Frind ÃʱâÈ­ //
						lpRebind->InitializeBanInfo(lpCharacterData->GetServerID(), lpCharacterData->GetGID(),
							lpCharacterData->GetClass(), lpCharacterData->GetLevel());
					}
					else
					{
						lpRebind->UpdateServerID(0);
					}
				}
				else
				{
					lpRebind->UpdateServerID(0);
				}
			}
		}

        INFLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ·Îµå ¼º°ø : CCharacterData::GetFromDB", dwCID);
        bResult = true;
    }

    return bResult;
}

bool CCharacterData::AddGold(unsigned long dwGold)
{
    m_CharInfo.Gold += dwGold;
	m_dwUpdateData |= CHANGED_CHAR_INFOST;
	return true;
}

bool CCharacterData::DeductGold(unsigned long dwGold)
{
    if (dwGold <= m_CharInfo.Gold)
    { 
        m_CharInfo.Gold -= dwGold;
		m_dwUpdateData |= CHANGED_CHAR_INFOST;
		return true;
    }
	return false;
}

bool CCharacterData::UpdateDBData(CDBComponent& DBComponent)
{
    PERFORMANCE_CHECK(FunctionTimingCheck);

    unsigned long dwCID = GetCID();

    // ¹«°á¼º °Ë»ç
    if (!IsValidData())
    {
        SERLOG1(g_Log, "CID:%10u / UpdateToDB ¿¡¼­ ¹«°á¼º °Ë»ç ½ÇÆÐ.", dwCID);
        return false;
    }
    else if(IsDataChanged())
    {
        using namespace DBComponent;

//		INFLOG2(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® Áغñ : CCharacterData::UpdateToDB, %d ºÎºÐ ¾÷µ¥ÀÌÆ® ½ÃÀÛ", dwCID, m_dwUpdateData);

        FRIEND  Friend  = {0,};
        BAN     Ban     = {0,};

        Friend.dwSize		= FRIEND::MAX_FRIEND_SIZE;
		Friend.dwInfoSize	= FRIEND::MAX_FRIENDINFO_SIZE;
        Ban.dwSize			= BAN::MAX_BAN_SIZE;
		Ban.dwInfoSize		= BAN::MAX_BANINFO_SIZE;

        // Àåºñ ºä ´Ù½Ã ·Îµå
        ReloadEquipView();

/*
		unsigned long       dwUpdateData = 0;

        // CharInfo ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_CHAR_INFOST) && 
            !GameDB::UpdateCharInfo(DBComponent, dwCID, &m_CharInfo, m_EquipView, MAX_EQUIP_VIEW))
        {
			dwUpdateData |= CHANGED_CHAR_INFOST;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharInfo È£Ãâ ½ÇÆÐ", dwCID);                
        }
        // CharPos ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_CHAR_POS) && 
            !GameDB::UpdateCharPos(DBComponent, dwCID, &m_CharPos)) 
        {
			dwUpdateData |= CHANGED_CHAR_POS;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharPos È£Ãâ ½ÇÆÐ", dwCID);
        }        
        // Quick ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_QUICK) &&
            !GameDB::UpdateQuick(DBComponent, dwCID, &m_Quick))
        {
			dwUpdateData |= CHANGED_QUICK;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharInfo È£Ãâ ½ÇÆÐ", dwCID);
        }
		// Spell ¾÷µ¥ÀÌÆ®
		if((m_dwUpdateData & CHANGED_SPELL) &&
			!GameDB::UpdateSpell(DBComponent, dwCID, &m_Spell))
		{
			dwUpdateData |= CHANGED_SPELL;
			SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateSpellInfo È£Ãâ ½ÇÆÐ", dwCID);
		}
        // Skill ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_SKILL) && 
            !GameDB::UpdateCharSkill(DBComponent, dwCID, &m_Skill)) 
        {
			dwUpdateData |= CHANGED_SKILL;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharSkill È£Ãâ ½ÇÆÐ", dwCID);            
        }
        // Equip ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_EQUIP) && 
            !GameDB::UpdateEquip(DBComponent, dwCID, &m_Equip)) 
        {
			dwUpdateData |= CHANGED_EQUIP;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateEquip È£Ãâ ½ÇÆÐ", dwCID);
        }
        // Inven ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_INVEN) && 
            !GameDB::UpdateInven(DBComponent, dwCID, &m_Inven)) 
        {
			dwUpdateData |= CHANGED_INVEN;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateInven È£Ãâ ½ÇÆÐ", dwCID);            
        }
        // Extra ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_EXTRA) && 
            !GameDB::UpdateExtra(DBComponent, dwCID, &m_Extra))
        {
			dwUpdateData |= CHANGED_EXTRA;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateExtra È£Ãâ ½ÇÆÐ", dwCID);            
        }                
        // Exchange ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_EXCHANGE) && 
            !GameDB::UpdateExchange(DBComponent, dwCID, &m_Exchange)) 
        {
			dwUpdateData |= CHANGED_EXCHANGE;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateExchange È£Ãâ ½ÇÆÐ", dwCID);            
        }
		// TempInven ¾÷µ¥ÀÌÆ®
		if((m_dwUpdateData & CHANGED_TEMPINVEN) && 
			!GameDB::UpdateTempInven(DBComponent, dwCID, &m_TempInven)) 
		{
			dwUpdateData |= CHANGED_TEMPINVEN;
			SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateTempInven È£Ãâ ½ÇÆÐ", dwCID);            
		}
        // CharInfoEx
        if((m_dwUpdateData & CHANGED_CHAR_INFOEX) &&
            !GameDB::UpdateCharInfoEx(DBComponent, dwCID, &m_CharInfoEx)) 
        {
			dwUpdateData |= CHANGED_CHAR_INFOEX;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharInfoEx È£Ãâ ½ÇÆÐ", dwCID);
        }               
        // Quest
        if((m_dwUpdateData & CHANGED_QUEST) &&
            !GameDB::UpdateQuest(DBComponent, dwCID, &m_Quest)) 
        {
			dwUpdateData |= CHANGED_QUEST;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateQuest È£Ãâ ½ÇÆÐ", dwCID);            
        }
        // History
        if((m_dwUpdateData & CHANGED_HISTORY) && 
            !GameDB::UpdateHistory(DBComponent, dwCID, &m_History)) 
        {
			dwUpdateData |= CHANGED_HISTORY;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateHistory È£Ãâ ½ÇÆÐ", dwCID);            
        }
        // Config
        if((m_dwUpdateData & CHANGED_CONFIG) &&
            !GameDB::UpdateConfig(DBComponent, dwCID, &m_Config)) 
        {
			dwUpdateData |= CHANGED_CONFIG;
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateConfig È£Ãâ ½ÇÆÐ", dwCID);
        }
        // Friend
        if(m_dwUpdateData & CHANGED_FRIENDLIST)
        {
            if(!m_FriendList.SerializeOut(Friend.Data, Friend.Info, Friend.dwSize, Friend.dwInfoSize))
            {
				dwUpdateData |= CHANGED_FRIENDLIST;
                SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : CFriend::SerializeOut È£Ãâ ½ÇÆÐ", dwCID);
            }        
            else if(!GameDB::UpdateFriend(DBComponent, dwCID, &Friend)) 
            {
				dwUpdateData |= CHANGED_FRIENDLIST;
                SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateFriend È£Ãâ ½ÇÆÐ", dwCID);
            }
        }        
        
        if(m_dwUpdateData & CHANGED_BANLIST)
        {
            // Ban
            if(!m_BanList.SerializeOut(Ban.Data, Ban.Info, Ban.dwSize, Ban.dwInfoSize))
            {
				dwUpdateData |= CHANGED_BANLIST;
                SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : CBan::SerializeOut È£Ãâ ½ÇÆÐ", dwCID);
                return false;
            }
            else if(!GameDB::UpdateBan(DBComponent, dwCID, &Ban)) 
            {
				dwUpdateData |= CHANGED_BANLIST;
                SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateBan È£Ãâ ½ÇÆÐ", dwCID);
                return false;
            }
        }

        // µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® Ç÷¡±× ¸®¼Â.
		if(dwUpdateData == 0)
		{
			INFLOG2(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¼º°ø : CCharacterData::UpdateToDB, %d ºÎºÐ ¾÷µ¥ÀÌÆ® ¼º°ø", dwCID, m_dwUpdateData);
			m_dwUpdateData = 0;
		}
		else
		{
//			SERLOG2(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : %d ºÎºÐ ½ÇÆÐ", dwCID, m_dwUpdateData);
//			m_dwUpdateData = 0;
			m_dwUpdateData = dwUpdateData;
			SERLOG2(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : %d ºÎºÐ ÀçµµÀü", dwCID, m_dwUpdateData);
		}
*/
        // CharInfo ¾÷µ¥ÀÌÆ®
        if((m_dwUpdateData & CHANGED_CHAR_INFOST) && 
            !GameDB::UpdateCharInfo(DBComponent, dwCID, &m_CharInfo, m_EquipView, MAX_EQUIP_VIEW))
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharInfo È£Ãâ ½ÇÆÐ", dwCID);                
        }
        // CharPos ¾÷µ¥ÀÌÆ®
        else if((m_dwUpdateData & CHANGED_CHAR_POS) && 
            !GameDB::UpdateCharPos(DBComponent, dwCID, &m_CharPos)) 
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharPos È£Ãâ ½ÇÆÐ", dwCID);
        }        
        // Quick ¾÷µ¥ÀÌÆ®
        else if((m_dwUpdateData & CHANGED_QUICK) &&
            !GameDB::UpdateQuick(DBComponent, dwCID, &m_Quick))
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharInfo È£Ãâ ½ÇÆÐ", dwCID);
        }
		// Spell ¾÷µ¥ÀÌÆ®
		else if((m_dwUpdateData & CHANGED_SPELL) &&
			!GameDB::UpdateSpell(DBComponent, dwCID, &m_Spell))
		{
			SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateSpellInfo È£Ãâ ½ÇÆÐ", dwCID);
		}
        // Skill ¾÷µ¥ÀÌÆ®
        else if((m_dwUpdateData & CHANGED_SKILL) && 
            !GameDB::UpdateCharSkill(DBComponent, dwCID, &m_Skill)) 
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharSkill È£Ãâ ½ÇÆÐ", dwCID);            
        }
        // Equip ¾÷µ¥ÀÌÆ®
        else if((m_dwUpdateData & CHANGED_EQUIP) && 
            !GameDB::UpdateEquip(DBComponent, dwCID, &m_Equip)) 
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateEquip È£Ãâ ½ÇÆÐ", dwCID);
        }
        // Inven ¾÷µ¥ÀÌÆ®
        else if((m_dwUpdateData & CHANGED_INVEN) && 
            !GameDB::UpdateInven(DBComponent, dwCID, &m_Inven)) 
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateInven È£Ãâ ½ÇÆÐ", dwCID);            
        }
        // Extra ¾÷µ¥ÀÌÆ®
        else if((m_dwUpdateData & CHANGED_EXTRA) && 
            !GameDB::UpdateExtra(DBComponent, dwCID, &m_Extra))
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateExtra È£Ãâ ½ÇÆÐ", dwCID);            
        }                
        // Exchange ¾÷µ¥ÀÌÆ®
        else if((m_dwUpdateData & CHANGED_EXCHANGE) && 
            !GameDB::UpdateExchange(DBComponent, dwCID, &m_Exchange)) 
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateExchange È£Ãâ ½ÇÆÐ", dwCID);            
        }
		// TempInven ¾÷µ¥ÀÌÆ®
		else if((m_dwUpdateData & CHANGED_TEMPINVEN) && 
			!GameDB::UpdateTempInven(DBComponent, dwCID, &m_TempInven)) 
		{
			SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateTempInven È£Ãâ ½ÇÆÐ", dwCID);            
		}
        // CharInfoEx
        else if((m_dwUpdateData & CHANGED_CHAR_INFOEX) &&
            !GameDB::UpdateCharInfoEx(DBComponent, dwCID, &m_CharInfoEx)) 
        {
            SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateCharInfoEx È£Ãâ ½ÇÆÐ", dwCID);
        }               
        else 
        {
            // Friend
            if(m_dwUpdateData & CHANGED_FRIENDLIST)
            {
                if(!m_FriendList.SerializeOut(Friend.Data, Friend.Info, Friend.dwSize, Friend.dwInfoSize))
                {
                    SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : CFriend::SerializeOut È£Ãâ ½ÇÆÐ", dwCID);
                    return false;
                }        
                else if(!GameDB::UpdateFriend(DBComponent, dwCID, &Friend)) 
                {
                    SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateFriend È£Ãâ ½ÇÆÐ", dwCID);
                    return false;
                }
            }        
            
            if(m_dwUpdateData & CHANGED_BANLIST)
            {
                // Ban
                if(!m_BanList.SerializeOut(Ban.Data, Ban.Info, Ban.dwSize, Ban.dwInfoSize))
                {
                    SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : CBan::SerializeOut È£Ãâ ½ÇÆÐ", dwCID);
                    return false;
                }
                else if(!GameDB::UpdateBan(DBComponent, dwCID, &Ban)) 
                {
                    SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateBan È£Ãâ ½ÇÆÐ", dwCID);
                    return false;
                }
            }
        
            // Quest
            if((m_dwUpdateData & CHANGED_QUEST) &&
                !GameDB::UpdateQuest(DBComponent, dwCID, &m_Quest)) 
            {
                SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateQuest È£Ãâ ½ÇÆÐ", dwCID);            
            }
            // History
            else if((m_dwUpdateData & CHANGED_HISTORY) && 
                !GameDB::UpdateHistory(DBComponent, dwCID, &m_History)) 
            {
                SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateHistory È£Ãâ ½ÇÆÐ", dwCID);            
            }
            // Config
            else if((m_dwUpdateData & CHANGED_CONFIG) &&
                !GameDB::UpdateConfig(DBComponent, dwCID, &m_Config)) 
            {
                SERLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ : UpdateConfig È£Ãâ ½ÇÆÐ", dwCID);
            }
            else
            {
                // µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® Ç÷¡±× ¸®¼Â.
                m_dwUpdateData = 0;
                INFLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¼º°ø : CCharacterData::UpdateToDB", dwCID);
                return true;
            }
        }

        // µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ½ÇÆÐ
        return false;
    }
    else
    {
        INFLOG1(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® ¼º°ø : º¯°æµÈ µ¥ÀÌÅÍ°¡ ¾ø¾î¼­ ¾÷µ¥ÀÌÆ®ÇÏÁö ¾Ê¾Ò½À´Ï´Ù.", dwCID);
    }

    m_dwLastDBUpdateTime = timeGetTime();
    return true;
}


inline void CopyAndAdvanceDst(char*& lpWritePos, const void* lpData, unsigned long dwSize, 
                              unsigned short* lpSizeArray_Out, DBUpdateData::UpdateList eUpdatePos)
{
    memcpy(lpWritePos, lpData, dwSize);
    lpWritePos += dwSize;
    lpSizeArray_Out[eUpdatePos] = static_cast<unsigned short>(dwSize);
}

bool CCharacterData::SerializeOut(char* lpBuffer_Out, unsigned short* lpSizeArray_Out, 
                                unsigned long &dwBufferSize_InOut, unsigned long dwSizeArrayNum)
{
    // ¹öÆÛ ¹Ù¿îµù üũ ¹× SizeArrayüũ
    
    if(0 == lpBuffer_Out || 0 == lpSizeArray_Out)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¹öÆÛ¿¡ ¾²±â ½ÇÆÐ : ÀÔ·Â µ¥ÀÌÅÍ°¡ ÀÌ»óÇÕ´Ï´Ù."
            "lpBuffer_Out:%p / lpSizeArray_Out:%p", GetCID(), lpBuffer_Out, lpSizeArray_Out);

        return false;
    }

    unsigned long dwEstimateSize = 
        sizeof(CHAR_INFOST) + sizeof(CHAR_POS) + sizeof(SKILL) + sizeof(QUICK) + sizeof(SPELL) +
        m_Equip.dwSize + m_Inven.dwSize + m_Extra.dwSize + m_Exchange.dwSize + m_TempInven.dwSize;

    if(dwBufferSize_InOut < dwEstimateSize)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¹öÆÛ¿¡ ¾²±â ½ÇÆÐ : ¹öÆÛ Å©±â°¡ ºÎÁ·ÇÕ´Ï´Ù."
            "ÇÊ¿ä Å©±â:%10u / ¹ÞÀº Å©±â:%10u", GetCID(), dwEstimateSize, dwBufferSize_InOut);

        return false;
    }

    if(dwSizeArrayNum < DBUpdateData::MAX_UPDATE_DB)
    {
        SERLOG3(g_Log, "CID:%10u / ij¸¯ÅÍ µ¥ÀÌÅÍ ¹öÆÛ¿¡ ¾²±â ½ÇÆÐ : SizeArray Å©±â°¡ ºÎÁ·ÇÕ´Ï´Ù."
            "ÇÊ¿ä °³¼ö:%10u / ¹ÞÀº °³¼ö:%10u", GetCID(), DBUpdateData::MAX_UPDATE_DB, dwSizeArrayNum);

        return false;
    }

    char* lpWritePos = lpBuffer_Out;

    CopyAndAdvanceDst(lpWritePos, &m_CharInfo, sizeof(CHAR_INFOST), lpSizeArray_Out, DBUpdateData::STATUS_UPDATE);
    CopyAndAdvanceDst(lpWritePos, &m_CharPos, sizeof(CHAR_POS), lpSizeArray_Out, DBUpdateData::POSITION_UPDATE);
    CopyAndAdvanceDst(lpWritePos, &m_Skill, sizeof(SKILL), lpSizeArray_Out, DBUpdateData::SKILL_UPDATE);
    CopyAndAdvanceDst(lpWritePos, &m_Quick, sizeof(QUICK), lpSizeArray_Out, DBUpdateData::QUICKSLOT_UPDATE);
	CopyAndAdvanceDst(lpWritePos, &m_Spell, sizeof(SPELL), lpSizeArray_Out, DBUpdateData::SPELL_UPDATE);
    CopyAndAdvanceDst(lpWritePos, m_Equip.Data, m_Equip.dwSize, lpSizeArray_Out, DBUpdateData::ITEM_EQUIP_UPDATE);
    CopyAndAdvanceDst(lpWritePos, m_Inven.Data, m_Inven.dwSize, lpSizeArray_Out, DBUpdateData::ITEM_INVEN_UPDATE);
    CopyAndAdvanceDst(lpWritePos, m_Extra.Data, m_Extra.dwSize, lpSizeArray_Out, DBUpdateData::ITEM_EXTRA_UPDATE);
    CopyAndAdvanceDst(lpWritePos, m_Exchange.Data, m_Exchange.dwSize, lpSizeArray_Out, DBUpdateData::ITEM_EXCHANGE_UPDATE);
    CopyAndAdvanceDst(lpWritePos, m_TempInven.Data, m_TempInven.dwSize, lpSizeArray_Out, DBUpdateData::ITEM_TEMPINVEN_UPDATE);


    dwBufferSize_InOut = static_cast<unsigned long>(lpWritePos - lpBuffer_Out);
    return true;
}




bool CCharacterData::SerializeIn(const char* lpBuffer_In, const unsigned short* lpSizeArray_In, 
                                 unsigned long dwBufferSize, unsigned long dwSizeArrayNum)
{
    unsigned long dwCID = GetCID();

    // µ¥ÀÌÅͱæÀÌ Ã¼Å© ¹× ¹öÆÛ±æÀÌ Ã¼Å©
    if(0 == lpBuffer_In || 0 == lpSizeArray_In || dwSizeArrayNum < DBUpdateData::MAX_UPDATE_DB)
    {
        SERLOG4(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : ÀÔ·Â µ¥ÀÌÅÍ°¡ ÀÌ»óÇÕ´Ï´Ù."
            "lpBuffer_Out:%p / lpSizeArray_Out:%p / dwSizeArrayNum : %d",
            dwCID, lpBuffer_In, lpSizeArray_In, dwSizeArrayNum);

        return false;
    }

    if (sizeof(CHAR_INFOST) != lpSizeArray_In[DBUpdateData::STATUS_UPDATE] || 
        sizeof(CHAR_POS) != lpSizeArray_In[DBUpdateData::POSITION_UPDATE] || 
        sizeof(SKILL) != lpSizeArray_In[DBUpdateData::SKILL_UPDATE] || 
        sizeof(QUICK) != lpSizeArray_In[DBUpdateData::QUICKSLOT_UPDATE] ||
		sizeof(SPELL) != lpSizeArray_In[DBUpdateData::SPELL_UPDATE])
    {
//        SERLOG10(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : ÀÔ·Â µ¥ÀÌÅÍ°¡ ÀÌ»óÇÕ´Ï´Ù. sizeof(CHAR_INFOST) : %d/%d / sizeof(CHAR_POS) : %d/%d / sizeof(SKILL) : %d/%d / sizeof(QUICK) : %d/%d / sizeof(SPELL) : %d/%d",
        SERLOG10(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : ÀÔ·Â µ¥ÀÌÅÍ°¡ ÀÌ»óÇÕ´Ï´Ù. sizeof(CHAR_INFOST) : %d/%d / sizeof(CHAR_POS) : %d/%d / sizeof(SKILL) : %d/%d / sizeof(QUICK) : %d/%d / sizeof(SPELL) : %d",
            dwCID, 
			sizeof(CHAR_INFOST), lpSizeArray_In[DBUpdateData::STATUS_UPDATE],
            sizeof(CHAR_POS), lpSizeArray_In[DBUpdateData::POSITION_UPDATE],
            sizeof(SKILL), lpSizeArray_In[DBUpdateData::SKILL_UPDATE],
            sizeof(QUICK), lpSizeArray_In[DBUpdateData::QUICKSLOT_UPDATE],
			lpSizeArray_In[DBUpdateData::SPELL_UPDATE]);
//			sizeof(SPELL), lpSizeArray_In[DBUpdateData::SPELL_UPDATE]);

        return false;
    }

    const char* lpReadPos = lpBuffer_In; 

    // ¾÷µ¥ÀÌÆ®½Ã CID´Ù¸£¸é Áñ!
    if(!SetInfo(*reinterpret_cast<const CHAR_INFOST*>(lpReadPos)))
    {
        return false;
    }

    lpReadPos += sizeof(CHAR_INFOST);

    SetPos(*reinterpret_cast<const CHAR_POS*>(lpReadPos));
    lpReadPos += sizeof(CHAR_POS);

    SetSkill(*reinterpret_cast<const SKILL*>(lpReadPos));
    lpReadPos += sizeof(SKILL);

    SetQuick(*reinterpret_cast<const QUICK*>(lpReadPos));
    lpReadPos += sizeof(QUICK);

	//! ½ºÆç µ¥ÀÌÅÍ ¼¼ÆÃ
	SetSpell(*reinterpret_cast<const SPELL*>(lpReadPos));
	lpReadPos += sizeof(SPELL);


    //! Àåºñ µ¥ÀÌÅÍ ¼¼ÆÃ
    if(!SetEquip(lpReadPos, lpSizeArray_In[DBUpdateData::ITEM_EQUIP_UPDATE]))
    {
        SERLOG1(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : Àåºñ ¼¼Æà ½ÇÆÐ.", dwCID);
        return false;
    }
    lpReadPos += lpSizeArray_In[DBUpdateData::ITEM_EQUIP_UPDATE];
    
    //! Àκ¥Å丮 µ¥ÀÌÅÍ ¼¼ÆÃ
    if(!SetInven(lpReadPos, lpSizeArray_In[DBUpdateData::ITEM_INVEN_UPDATE]))
    {
        SERLOG1(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : Àκ¥ ¼¼Æà ½ÇÆÐ.", dwCID);
        return false;
    }
    lpReadPos += lpSizeArray_In[DBUpdateData::ITEM_INVEN_UPDATE];

    //! Ãß°¡ µ¥ÀÌÅÍ ¼¼ÆÃ
    if(!SetExtra(lpReadPos, lpSizeArray_In[DBUpdateData::ITEM_EXTRA_UPDATE]))
    {
        SERLOG1(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : Extra ¼¼Æà ½ÇÆÐ.", dwCID);
        return false;
    }
    lpReadPos += lpSizeArray_In[DBUpdateData::ITEM_EXTRA_UPDATE];

    //! ±³È¯Ã¢ µ¥ÀÌÅÍ ¼¼ÆÃ
    if(!SetExchange(lpReadPos, lpSizeArray_In[DBUpdateData::ITEM_EXCHANGE_UPDATE]))
    {
        SERLOG1(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : Exchange ¼¼Æà ½ÇÆÐ.", dwCID);
        return false;
    }
    lpReadPos += lpSizeArray_In[DBUpdateData::ITEM_EXCHANGE_UPDATE];

    //! Àӽà Àκ¥Å丮 µ¥ÀÌÅÍ ¼¼ÆÃ
    if(!SetTempInven(lpReadPos, lpSizeArray_In[DBUpdateData::ITEM_TEMPINVEN_UPDATE]))
    {
        SERLOG1(g_Log, "CID:%10u / ¹öÆÛ µ¥ÀÌÅ͸¦ ij¸¯ÅÍ¿¡ ¾²±â ½ÇÆÐ : ÀÓ½ÃÀκ¥ ¼¼Æà ½ÇÆÐ.", dwCID);
        return false;
    }
    lpReadPos += lpSizeArray_In[DBUpdateData::ITEM_TEMPINVEN_UPDATE];


    return true;
}

bool CCharacterData::AddFriend(unsigned long dwFriendCID, const char* szCharacterName, unsigned long dwGID, unsigned short wClass, char cLevel, unsigned long dwServerID)
{
    if(m_FriendList.Add(dwFriendCID, szCharacterName, dwGID, wClass, cLevel, dwServerID))
    {
        m_dwUpdateData |= CHANGED_FRIENDLIST;
        return true;
    }

    return false;
}

bool CCharacterData::RemoveFriend(unsigned long dwFriendCID)
{
    if(m_FriendList.Remove(dwFriendCID))
    {
        m_dwUpdateData |= CHANGED_FRIENDLIST;
        return true;
    }

    return false;
}

bool CCharacterData::AddBan(unsigned long dwBanCID, const char* szBanName, unsigned long dwGID, unsigned short wClass, char cLevel, unsigned long dwServerID)
{
    if(m_BanList.Add(dwBanCID, szBanName, dwGID, wClass, cLevel, dwServerID))
    {
        m_dwUpdateData |= CHANGED_BANLIST;
        return true;
    }

    return false;
}

bool CCharacterData::RemoveBan(unsigned long dwBanCID)
{
    if(m_BanList.Remove(dwBanCID))
    {
        m_dwUpdateData |= CHANGED_BANLIST;
        return true;
    }

    return false;
}


bool CCharacterData::SetFriendGroup(unsigned long dwCID, unsigned long dwGroup)
{
    CFriendList::Rebind* lpRebind = m_FriendList.GetFriend(dwCID);
    if (0 != lpRebind && lpRebind->SetGroup(dwGroup))
    {
        m_dwUpdateData |= CHANGED_FRIENDLIST;
        return true;
    }

    return false;
}

bool CCharacterData::FriendSerializeIn(const char* lpData, unsigned long dwDataLen)
{
    if(m_FriendList.SerializeIn(lpData, dwDataLen))
    {
        m_dwUpdateData |= CHANGED_FRIENDLIST;
        return true;
    }
    
    return false;
}

bool CCharacterData::BanSerializeIn(const char* lpData, unsigned long dwDataLen)
{
    if(m_BanList.SerializeIn(lpData, dwDataLen))
    {
        m_dwUpdateData |= CHANGED_BANLIST;
        return true;
    }

    return false;
}


//! °¡Áö°í ÀÖ´Â µ¥ÀÌÅ͸¦ ÆÄÀÏ·Î ´ýÇÁ¸¦ ³²±â°Å³ª, ÆÄÀÏ¿¡¼­ µ¥ÀÌÅ͸¦ ºÒ·¯ ¿Â´Ù.
bool CCharacterData::WriteDataToDumpFile(const char* szFileName)
{

    return false;
}

bool CCharacterData::ReadDataFromDumpFile(const char* szFileName)
{

    return false;
}


bool CCharacterData::ConvertToPart2Item(bool bConvertSkillToTicket)
{
    RebalanceLib::CItemArrayChecker<
        ContainerConstant::INVENTORY_WIDTH,
        ContainerConstant::INVENTORY_HEIGHT,
        ContainerConstant::MAX_INVENTORY_TAB>   invenChecker(TakeType::TS_INVEN);

    RebalanceLib::CItemListChecker<Item::MAX_TEMP_INVEN_ITEM_NUM>   
        tempInvenChecker(TakeType::TS_TEMPINVEN);

    RebalanceLib::SkillBookInfo skillBookInfo;

    EQUIP		Equip;		// Àåºñ
    INVEN		Inven;		// Àκ¥
    EXTRA		Extra;		// ¿©ºÐ
    EXCHANGE	Exchange;	// ±³È¯Ã¢
    TEMPINVEN	TempInven;	// Àӽà Àκ¥Å丮

    unsigned long dwGold = m_CharInfo.Gold;

	// ij¸¯ÅÍ ÀÌÀü.
	m_CharInfo.Chance = 3;

    CDBAgentItemSerialMgr& dbItemSerialMgr = 
        CDBAgentItemSerialMgr::GetInstance();

    unsigned __int64 dwItemSerial = dbItemSerialMgr.GetItemSerial();

    memset(&skillBookInfo, 0, sizeof(RebalanceLib::SkillBookInfo));
    memset(&Equip, 0, sizeof(EQUIP));
    memset(&Inven, 0, sizeof(INVEN));
    memset(&Extra, 0, sizeof(EXTRA));
    memset(&Exchange, 0, sizeof(EXCHANGE));
    memset(&TempInven, 0, sizeof(TEMPINVEN));

    Equip.dwSize        = EQUIP::MAX_EQUIP_SIZE;
    Inven.dwSize        = INVEN::MAX_INVEN_SIZE;
    Extra.dwSize        = EXTRA::MAX_EXTRA_SIZE;
    Exchange.dwSize     = EXCHANGE::MAX_EXCHANGE_SIZE;
    TempInven.dwSize    = TEMPINVEN::MAX_TEMPINVEN_SIZE;

    // ½ºÅ³ ´õÇϱâ
    int nMaxSlotNum = std::min(m_Skill.wSlotNum, unsigned short(SKILL::MAX_SLOT_NUM));
    for(int nCount = 0; nCount < nMaxSlotNum; ++nCount)
    {
        SKILLSLOT& skillSlot = m_Skill.SSlot[nCount];

        if(skillSlot.SKILLINFO.cLockCount < CSkillMgr::MAX_SKILL_LOCKCOUNT)
        {
            for(int nLockCount = 0; nLockCount < skillSlot.SKILLINFO.cLockCount; ++nLockCount)
            {
                skillBookInfo.m_dwBookNum[nLockCount] += CSkillMgr::MAX_SKILL_LEVEL;
            }

            skillBookInfo.m_dwBookNum[skillSlot.SKILLINFO.cLockCount] += 
                skillSlot.SKILLINFO.cSkillLevel;
        }
    }

    // ¾ÆÀÌÅÛ ÄÁ¹öÆÃ
    if(!RebalanceLib::ConvertContainer(0, m_CharInfo.CID, 0, 0, 
        m_Equip.Data, m_Equip.dwSize, Equip.Data, Equip.dwSize))
    {
        ERRLOG1(g_Log, "CID:%10u / EQUIP ÄÁ¹öÆÿ¡ ½ÇÆÐÇß½À´Ï´Ù", m_CharInfo.CID);
    }
    else if(!RebalanceLib::ConvertContainer(0, m_CharInfo.CID, &invenChecker, 
        bConvertSkillToTicket ? &skillBookInfo : 0, 
        m_Inven.Data, m_Inven.dwSize, Inven.Data, Inven.dwSize))
    {
        ERRLOG1(g_Log, "CID:%10u / INVEN ÄÁ¹öÆÿ¡ ½ÇÆÐÇß½À´Ï´Ù", m_CharInfo.CID);        
    }
    else if(!RebalanceLib::ConvertContainer(0, m_CharInfo.CID, 0, 
        bConvertSkillToTicket ? &skillBookInfo : 0,  
        m_Extra.Data, m_Extra.dwSize, Extra.Data, Extra.dwSize))
    {
        ERRLOG1(g_Log, "CID:%10u / EXTRA ÄÁ¹öÆÿ¡ ½ÇÆÐÇß½À´Ï´Ù", m_CharInfo.CID);        
    }
    else if(!RebalanceLib::ConvertContainer(0, m_CharInfo.CID, 0, 
        bConvertSkillToTicket ? &skillBookInfo : 0, 
        m_Exchange.Data, m_Exchange.dwSize, Exchange.Data, Exchange.dwSize))
    {
        ERRLOG1(g_Log, "CID:%10u / EXCHANGE ÄÁ¹öÆÿ¡ ½ÇÆÐÇß½À´Ï´Ù", m_CharInfo.CID);        
    }
    else if(!RebalanceLib::ConvertContainer(0, m_CharInfo.CID, &tempInvenChecker, 
        bConvertSkillToTicket ? &skillBookInfo : 0, 
        m_TempInven.Data, m_TempInven.dwSize, TempInven.Data, TempInven.dwSize))
    {
        ERRLOG1(g_Log, "CID:%10u / TEMPINVEN ÄÁ¹öÆÿ¡ ½ÇÆÐÇß½À´Ï´Ù", m_CharInfo.CID);        
    }
    else 
    {
        for(int nCount = 0; nCount < CSkillMgr::MAX_SKILL_LOCKCOUNT; ++nCount)
        {
            // 3¹è·Î º¸»óÇÑ´Ù.
            skillBookInfo.m_dwBookNum[nCount] *= 3;
        }

        if (bConvertSkillToTicket && !RebalanceLib::AddSkillBook(
            0, m_CharInfo.CID, "Inventory", dbItemSerialMgr, dwGold,
            Inven.Data, Inven.dwSize, INVEN::MAX_INVEN_SIZE, invenChecker, skillBookInfo))
        {
            ERRLOG1(g_Log, "CID:%10u / Àκ¥Å丮 ½ºÅ³ºÏ ³Ö¾îÁֱ⿡ ½ÇÆÐÇß½À´Ï´Ù", m_CharInfo.CID);        
        }
        else if (bConvertSkillToTicket && !skillBookInfo.IsEmpty() && 
            !RebalanceLib::AddSkillBook(0, m_CharInfo.CID, "TempInven", dbItemSerialMgr, dwGold, 
            TempInven.Data, TempInven.dwSize, TEMPINVEN::MAX_TEMPINVEN_SIZE, tempInvenChecker, skillBookInfo))
        {
            ERRLOG1(g_Log, "CID:%10u / ÀÓ½ÃÀκ¥ ½ºÅ³ºÏ ³Ö¾îÁֱ⿡ ½ÇÆÐÇß½À´Ï´Ù", m_CharInfo.CID);        
        }
        else
        {
            if(dwItemSerial < dbItemSerialMgr.GetItemSerial())
            {
                dbItemSerialMgr.SaveItemSerial(
                    CDBSingleObject::GetInstance(), dbItemSerialMgr.GetServerID());
            }

            m_CharInfo.Gold = dwGold;

            unsigned char cLevelIndex = (0 < m_CharInfo.Level) ? m_CharInfo.Level - 1 : 0;

            m_CharInfo.Exp = static_cast<unsigned __int64>(
                m_CharInfo.Exp * EXP::ExpConvertTable[cLevelIndex]);

            memset(&m_Skill, 0, sizeof(SKILL));
            memset(&m_Quick, 0, sizeof(QUICK));
            memset(&m_Quest, 0, sizeof(QUEST));         // ÄÁ¹öÆÃÇÒ¶§ Äù½ºÆ®/È÷½ºÅ丮 ÀüºÎ ³¯¸°´Ù.
            memset(&m_History, 0, sizeof(HISTORY));     // 

            unsigned short usHumanCount = 0;
            unsigned short usAkhanCount = 0;
            unsigned char  cChannelCount = 0;
            
            CGameDispatch::GetDispatchTable().Process(
                CGetTotalCount(usHumanCount, usAkhanCount, cChannelCount));

            // ij¸¯ÅÍ ÁÂÇ¥¸¦ ¼¼ÆÃÇÑ´Ù.
            m_CharPos.LastPoint = CharCreate::GetDefaultCharacterPos(m_CharInfo.Race, 
                0 == m_CharInfo.Race ? usHumanCount : usAkhanCount);

            memset(&m_CharPos.SavePoint, 0, sizeof(POS));

            // ¼±Åà ¼­¹ö±ºÀ» 0À¸·Î ³õ´Â´Ù. ÀÚµ¿À¸·Î ½ÅÀÇ ´ëÁö·Î À̵¿ÇÒ°ÍÀÓ.
            m_CharInfoEx.ServerID = 0;

            m_Equip     = Equip;		// Àåºñ
            m_Inven     = Inven;		// Àκ¥
            m_Extra     = Extra;		// ¿©ºÐ
            m_Exchange  = Exchange;	    // ±³È¯Ã¢
            m_TempInven = TempInven;	// Àӽà Àκ¥Å丮
        }

        if(!skillBookInfo.IsEmpty())
        {
            for(int nCount = 0; nCount < CSkillMgr::MAX_SKILL_LOCKCOUNT; ++nCount)
            {
                if(0 != skillBookInfo.m_dwBookNum[nCount])
                {
                    ERRLOG3(g_Log, "CID:%10u / LockCount:%d / Num:%d / ½ºÅ³ºÏÀ» ³Ö¾îÁÖÁö ¸øÇß½À´Ï´Ù",
                        m_CharInfo.CID, nCount + 1, skillBookInfo.m_dwBookNum[nCount]);
                }
            }
        }

        return true;
    }

    return false;
}



}
}