#include "stdafx.h"
#include "GameDispatch.h"

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

#include <Network/Address/INET_Addr.h>
#include <Network/Stream/SendStream.h>
#include <Network/Packet/PacketDispatchTable.h>
#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/WrapPacket.h>
#include <Network/Packet/PacketStruct/ServerInfo.h>
#include <Network/Packet/PacketStruct/ServerPacket.h>
#include <Network/Packet/PacketStruct/ServerLogPacket.h>
#include <Network/Packet/PacketStruct/CharAdminPacket.h>

#include <Network/ParsePacket/ParseMoveZone.h>
#include <Network/ParsePacket/ParseCharManage.h>
#include <Network/ParsePacket/ParseCharUpdate.h>
#include <Network/ParsePacket/ParseParty.h>
#include <Network/ParsePacket/ParseCastle.h>
#include <Network/ParsePacket/ParseGuild.h>

#include <Network/SendPacket/SendServerInfo.h>
#include <Network/Dispatch/GameClient/SendCharAdmin.h>

#include <Creature/Character/CharacterClass.h>
#include <Creature/StatueDBMgr.h>

#include <DB/DBComponent.h>
#include <DB/GameDBComponent.h>
#include <DataStorage/SessionData.h>
#include <DataStorage/SessionDataMgr.h>

#include <Castle/CastleDBMgr.h>
#include <GameTime/GameTimeDBMgr.h>
#include <Creature/Siege/SiegeObjectDBMgr.h>
#include <Community/Guild/GuildDBMgr.h>
#include <Ranking/RankingDBMgr.h>
#include <GameEvent/GiveItemMgr.h>

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

#include <Map/FieldMap/MineralVeinDBMgr.h>

#include <Ranking/RankingMgr.h>

#include <Community/Party/PartyDBMgr.h>

namespace DBAgent
{

typedef bool (*GameDispatchFunc) (CSendStream& SendStream, PktBase* lpPktBase);


// forward delc.
bool ParseServerLog(CSendStream& SendStream, PktBase* lpPktBase);


class CGameDispatchTable : public CPacketDispatchTable<GameDispatchFunc>
{
public:

    static CGameDispatchTable& GetInstance();

private:

    CGameDispatchTable();
};


CGameDispatchTable& CGameDispatchTable::GetInstance()
{
    static CGameDispatchTable gameDispatchTable;
    return gameDispatchTable;
}

CGameDispatchTable::CGameDispatchTable()
:    CPacketDispatchTable<GameDispatchFunc>(UCHAR_MAX)
{
    // µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® °ü·Ã
    AddDispatch(CmdDepositUpdate,           ParseCharUpdate::UpdateDepositDB);
    AddDispatch(CmdDeposit,                 ParseCharUpdate::UpdateDeposit);
    AddDispatch(CmdFriendDB,                ParseCharUpdate::UpdateFriendDB);
    AddDispatch(CmdQuestDB,                 ParseCharUpdate::UpdateQuestDB);
    AddDispatch(CmdConfigInfoDB,            ParseCharUpdate::UpdateConfigInfoDB);

    // Á¸À̵¿ °ü·Ã
    AddDispatch(CmdAgentZone,               ParseMoveZone::Parse);

    // ÆÄƼ °ü·Ã
    AddDispatch(CmdAgentParty,              ParseParty::Parse);

    // ¹èƲ±×¶ó¿îµå °ü·Ã
    AddDispatch(CmdBGServerCharSlot,        ParseCharManage::BGServerCharSlot);

    // ·Î±× °ü·Ã
    AddDispatch(CmdServerLog,               ParseServerLog);
    
    // ±æµå °ü·Ã
    AddDispatch(CmdCreateGuild,             ParseGuild::CreateGuild);
    AddDispatch(CmdGuildCmd,                ParseGuild::GuildCmd);
    AddDispatch(CmdGuildMark,               ParseGuild::GuildMark);
    AddDispatch(CmdGuildLevel,              ParseGuild::GuildLevel);
	AddDispatch(CmdGuildRelation,           ParseGuild::GuildRelation);
    AddDispatch(CmdGuildInclination,	    ParseGuild::GuildInclination);
    AddDispatch(CmdGuildRight,			    ParseGuild::SetGuildRight);
    AddDispatch(CmdGuildSafe,				ParseGuild::GuildSafe);
    AddDispatch(CmdGuildMemberInfoUpdate,   ParseGuild::GuildMemberInfoUpdate);

    // °ø¼º °ü·Ã
    AddDispatch(CmdCreateCamp,              ParseCastle::CreateCamp);
    AddDispatch(CmdCreateSiegeArms,         ParseCastle::CreateSiegeArms);
    AddDispatch(CmdCastleCmd,               ParseCastle::CastleCmd);
    AddDispatch(CmdCampCmd,                 ParseCastle::CampCmd);
    AddDispatch(CmdSiegeArmsCmd,            ParseCastle::SiegeArmsCmd);
    AddDispatch(CmdCastleRight,             ParseCastle::SetCastleRight);
    AddDispatch(CmdCampRight,               ParseCastle::SetCampRight);
	AddDispatch(CmdCampMessage,				ParseCastle::CampMessage);
	AddDispatch(CmdMiningCampMineralInfo,	ParseCastle::MiningCampMineralInfo);
	AddDispatch(CmdFertilityInfo,			ParseCastle::FertilityInfo);
	AddDispatch(CmdCampShopInfo,			ParseCastle::CampShopInfo);
	AddDispatch(CmdCastleTaxMove,			ParseCastle::CastleTaxMove);
	AddDispatch(CmdCastleMineralInfo,		ParseCastle::CastleMineralInfo);
	AddDispatch(CmdWarOnOff,				ParseCastle::WarOnOff);
	AddDispatch(CmdStatueCmd,				ParseCastle::StatueCmd);

	AddDispatch(CmdAdminCommandLog,			ParseCharAdmin::AdminCommandLog);
	
	AddDispatch(CmdRealmPoint,				ParseCastle::RealmPoint);

	// µà¾ó °ü·Ã.
	AddDispatch(CmdSaveEnemy,				ParseCharUpdate::SaveEnemy);

	// Á¶À̽ºÆ½ °ü·Ã.
	AddDispatch(CmdKeyInfo,					ParseCharUpdate::UpdateKeyInfo);

	// ¾ÆÀÌÅÛ °ü·Ã
	AddDispatch(CmdCharUseCashItem,			ParseCharUpdate::UseCashItem);
	AddDispatch(CmdExtraEvent,				ParseCharUpdate::ExtraEvent);
}


CMultiDispatch& CGameDispatch::GetDispatchTable()
{
    static CMultiDispatch gameDispatch;
    return gameDispatch;
}


CGameDispatch::CGameDispatch(CSession& Session)
    :   CRylServerDispatch(Session, MAX_PACKET_DISPATCH_PER_PULSE),
        m_nHumanNum(1), 
        m_nAkhanNum(1), 
        m_dwServerID(0)
{


}

CGameDispatch::~CGameDispatch()
{


}

void CGameDispatch::Connected()
{
    DETLOG3(g_Log, "SS:0x%08x/DP:0x%08x/IP:%15s/GameServer Connected",
        &GetSession(), this, GetRemoteAddr().get_addr_string());		
}

void CGameDispatch::Disconnected()
{
    DETLOG3(g_Log, "SS:0x%08x/DP:0x%08x/IP:%15s/GameServer Disconnected",
        &GetSession(), this, GetRemoteAddr().get_addr_string());

    if(0 != m_dwServerID)
    {
        GetDispatchTable().RemoveDispatch(m_dwServerID);

        if(0LL != m_GameItemSerialMgr.GetItemSerial())
        {
            // ¾ÆÀÌÅÛ ½Ã¸®¾ó DB¿¡ ÀúÀå
            m_GameItemSerialMgr.SaveItemSerial(
                CDBSingleObject::GetInstance(), m_dwServerID);
        }

        // ä³Î Á¤º¸ ¾÷µ¥ÀÌÆ®
        DBAgent::SendPacket::UpdateChannelAllServer();

        // ÇöÀç ¼­¹ö¿¡ ·Î±×ÀÎµÈ »ç¶÷À» ÀüºÎ ³»·Á¹ö¸°´Ù.
        DataStorage::CSessionDataMgr::GetInstance().SessionCloseCurrentServer(m_dwServerID);
    }
}



bool CGameDispatch::DispatchPacket(PktBase* lpPktBase)
{
	// °ÔÀÓ¼­¹ö¿¡¼­ DBAgent·Î º¸³»´Â ÆÐŶÁ¤º¸

    PktBase::CMDType cCmd =lpPktBase->GetCmd();

    bool bResult = false;
    GameDispatchFunc lpDispatchFunc = 0;

    
    CSendStream& SendStream = GetSendStream();

    switch(cCmd)
    {
        // ·Î±×ÀÎ /  ·Î±×¾Æ¿ô / µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ®
    case CmdDBUpdateData:       
		// À¯Àú°¡ ·Î±×ÀÎÇϰųª ·Î±×¾Æ¿ôÇÒ¶§ ¿©±â·Î ¸Þ½ÃÁö¸¦ º¸³½´Ù.
		// ¿©±â¼­ ŸÀÓDB¸¦ ¾÷µ¥ÀÌÆ® Çϰųª ÇÑ´Ù.
        bResult = ParseCharUpdate::Parse(SendStream, m_dwServerID, 
            m_GameItemSerialMgr, static_cast<PktDBUpdate*>(lpPktBase));
        break;

    case CmdSysServerLogin:         bResult = ServerLogin(lpPktBase);           break;  // ¼­¹ö ·Î±×ÀÎ
    case CmdSysServerLogout:        bResult = ServerLogout(lpPktBase);          break;  // ¼­¹ö ·Î±×¾Æ¿ô
    case CmdUserKill:               bResult = UserKillAck(lpPktBase);           break;  // À¯Àú Á×À̱â
    case CmdCharAdminCmd:           bResult = CharAdminCmd(lpPktBase);          break;  // ¿î¿µÀÚ ¸í·É
    case CmdGiveItemToTempInven:    bResult = GiveItemToTempInven(lpPktBase);   break;  // ÀÓ½ÃÀκ¥À¸·Î ¾ÆÀÌÅÛ ÁÖ±â
    case CmdCharNameChange:         bResult = ChangeName(lpPktBase);            break;  // ij¸¯ÅÍ À̸§À» ¹Ù²Û´Ù

    default:

        // ±âŸ ¸í·É(Å×ÀÌºí¿¡¼­ °Ë»ö)
        lpDispatchFunc = CGameDispatchTable::GetInstance().GetDispatch(cCmd);
        if(0 != lpDispatchFunc)
        {
            bResult = lpDispatchFunc(SendStream, lpPktBase);
        }
        else
        {
            ERRLOG5(g_Log, "SS:0x%08x/DP:0x%08x/IP:%15s/Cmd:0x%02X/ServerID:0x%08X / "
                "°ÔÀÓ¼­¹ö ÆÐŶ ó¸® ½ÇÆÐ : ¾ø´Â Ä¿¸ÇµåÀÔ´Ï´Ù",
                &GetSession(), this, GetRemoteAddr().get_addr_string(), cCmd, m_dwServerID);

            bResult = true;
        }
        break;
    }

    if(!bResult)
    {
        ERRLOG5(g_Log, "SS:0x%08x/DP:0x%08x/IP:%15s/Cmd:0x%02X/ServerID:0x%08X / °ÔÀÓ¼­¹ö ÆÐŶ ó¸® ½ÇÆÐ : 󸮸¦ ½ÇÆÐÇß½À´Ï´Ù",
            &GetSession(), this, GetRemoteAddr().get_addr_string(), cCmd, m_dwServerID);
    }

    return true;
}




bool CGameDispatch::ServerLogin(PktBase* lpPktBase)
{
    PktSL* lpPktSL = static_cast<PktSL*>(lpPktBase);

    m_dwServerID = lpPktSL->m_dwServerID;

    INFLOG4(g_Log, "SS:0x%08x/DP:0x%08x/IP:%15s/ServerID:0x%08X/°ÔÀÓ¼­¹ö ¿¬°á ½Ãµµ : ÆÐŶ ¹ÞÀ½",
        &GetSession(), this, GetRemoteAddr().get_addr_string(), m_dwServerID);

    GET_MULTI_DISPATCH(lpGameDispatch, m_dwServerID, 
        CGameDispatch, GetDispatchTable());
    
    if(0 != lpGameDispatch)
    {
        ERRLOG4(g_Log, "SS:0x%08x/DP:0x%08x/IP:%15s/ServerID:0x%08X/°ÔÀÓ¼­¹ö ¿¬°á ½ÇÆÐ : ÀÌ¹Ì ¿¬°áÀÌ ÀÖ½À´Ï´Ù. Á¢¼ÓÀ» ²÷½À´Ï´Ù.",
            &GetSession(), this, GetRemoteAddr().get_addr_string(), m_dwServerID);

        CloseSession();
    }
    else
    {
        // Dispatch ¼¼ÆÃ.
        GetDispatchTable().SetDispatch(m_dwServerID, this);

        // ¾ÆÀÌÅÛ ½Ã¸®¾ó ·Îµå.
        if(!m_GameItemSerialMgr.LoadItemSerial(CDBSingleObject::GetInstance(), m_dwServerID))
        {
            ERRLOG4(g_Log, "SS:0x%08x/DP:0x%08x/IP:%15s/ServerID:0x%08X/°ÔÀÓ¼­¹ö ¿¬°á ½ÇÆÐ : ¾ÆÀÌÅÛ ½Ã¸®¾ó ·Îµå ½ÇÆÐ. Á¢¼ÓÀ» ²÷½À´Ï´Ù.",
                &GetSession(), this, GetRemoteAddr().get_addr_string(), m_dwServerID);

            CloseSession();
            return false;
        }
        
        CSendStream& SendStream = GetSendStream();

        // ±æµå Á¤º¸ ¾÷µ¥ÀÌÆ®
        Guild::CGuildDBMgr::GetInstance().SendGuildDBList(SendStream);
        
        SERVER_ID serverID;
        serverID.dwID = m_dwServerID;

        /// ¼º ¹× Ä·ÇÁ, °ø¼ºº´±â °ü·Ã Á¤º¸ ¾÷µ¥ÀÌÆ®.
        Castle::CCastleDBMgr::GetInstance().SendCastleInfo(SendStream, serverID.GetZone(), serverID.GetChannel());
		CGameTimeDBMgr::GetInstance().SendGameTimeInfo(GameTime::TYPE_GAMESERVER_LOGIN, true, true, true, true, true);
		CSiegeObjectDBMgr::GetInstance().SendWorldWeaponInfo(SendStream, serverID.GetZone(), serverID.GetChannel());
        CSiegeObjectDBMgr::GetInstance().SendCampInfo(SendStream, serverID.GetZone(), serverID.GetChannel());
        CSiegeObjectDBMgr::GetInstance().SendSiegeArmsInfo(SendStream, serverID.GetZone(), serverID.GetChannel());

		// ÄÁÅÙÃ÷ : ´ÙÅ© Ä«³ª¹ø ±¹°¡ ÀüÀï
		if (true == CServerSetup::GetInstance().UseContents(GameRYL::STONE_BATTLE))
		{
			// ¼®»ó Á¤º¸ ¾÷µ¥ÀÌÆ®
			// ÁÖÀÇ : ¼º Á¤º¸°¡ ¼®»ó Á¤º¸º¸´Ù ¸ÕÀú º¸³»Á®¾ßÇÑ´Ù.!!
			//		  ¼º¿¡ ÀÇÇØ ¼®»ó ÀÎæƮ È¿°ú°¡ ¿µÇâÀ» ¹Þ±â ¶§¹®ÀÌ´Ù.!!
			if (SERVER_ID::STONE_WAR1 <= serverID.GetZone() && serverID.GetZone() <= SERVER_ID::STONE_WAR3)
			{
				CStatueDBMgr::GetInstance().SendStatueInfo(SendStream, serverID.GetChannel());
			}
		}
/*
		// ÄÁÅÙÃ÷ : ½Å±ÔÁ¸
		if (true == CServerSetup::GetInstance().UseContents(GameRYL::NEWZONE_ZONE9))
		{
			// »ý¸íÃàÃâ±â Á¤º¸ ¾÷µ¥ÀÌÆ®
			// ÁÖÀÇ : ¼º Á¤º¸°¡ »ý¸íÃàÃâ±â Á¤º¸º¸´Ù ¸ÕÀú º¸³»Á®¾ßÇÑ´Ù.!!			
			if (serverID.GetZone() == SERVER_ID::ZONE9)
			{
				CStatueDBMgr::GetInstance().SendStatueInfo(SendStream, serverID.GetChannel());
			}
		}
*/
		// Áö·Â Á¤º¸ ¾÷µ¥ÀÌÆ®
		CMineralVeinDBMgr::GetInstance().SendFertilityInfo(SendStream, serverID.GetZone(), serverID.GetChannel());

        // ä³Î Á¤º¸ ¾÷µ¥ÀÌÆ®
        DBAgent::SendPacket::UpdateChannelAllServer();

        // ·©Å· Á¤º¸ ¾÷µ¥ÀÌÆ®
        CRankingDBMgr::GetInstance().SendRankingInfo(SendStream);

		// ÆÄƼ Á¤º¸°¡ ÀÖÀ¸¸é º¸³»ÁØ´Ù //
		CPartyDBMgr::GetInstance().SendToGameServerPartyData(SendStream);

        // ¼­¹ö ·Î±×ÀÎ Ackº¸³¿.
        return SendPacket::ServerLoginAck(m_SendStream, 
            m_dwServerID, m_GameItemSerialMgr.GetItemSerial());		
    }
    
    return true;
}

bool CGameDispatch::ServerLogout(PktBase* lpPktBase)
{
    // ¹ÞÀº ÆÐŶ ±×´ë·Î µ¹·Á ÁØ´Ù.

    char* lpBuffer = m_SendStream.GetBuffer(sizeof(PktBase));
    if(0 != lpBuffer)
    {
        return m_SendStream.WrapHeader(sizeof(PktBase), CmdSysServerLogout, 0, 0);
    }

    return false;
}


bool CGameDispatch::UserKillAck(PktBase* lpPktBase)
{
    // À¯Àú Á×À̱⸦ ½ÇÆÐÇؼ­, Ack·Î ¿À´Â °æ¿ìÀÌ´Ù.

    PktUK* lpPktUK = static_cast<PktUK*>(lpPktBase);

    if(2 == lpPktUK->GetError())
    {
        using namespace DataStorage;

        CSessionData* lpSessionData = 
            CSessionDataMgr::GetInstance().GetOpenSession(lpPktUK->m_dwUserID);

        if(0 != lpSessionData && 
            CSessionData::SE_CHAR_ENABLED == lpSessionData->GetSessionState())
        {
            if(lpSessionData->GetServerID() == lpPktUK->m_dwServerID)
            {
                CSessionDataMgr::GetInstance().SessionCloseWithLogout(
                    lpPktUK->m_dwUserID, lpPktUK->m_dwServerID);

                ERRLOG2(g_Log, "UID:%10u / ServerID:0x%08X / °ÔÀÓ¼­¹ö ¼¼¼Ç °­Á¦ Á¾·á : À¯Àú Á×À̱⠽ÇÆÐ", 
                    lpPktUK->m_dwUserID, lpPktUK->m_dwServerID);
            }
            else
            {
                ERRLOG3(g_Log, "UID:%10u / FromServerID:0x%08X / TargetServerID:0x%08X / "
                    "°ÔÀÓ¼­¹ö ¼¼¼Ç °­Á¦ Á¾·á ½ÇÆÐ : ½ÇÆÐ ¼­¹ö¿Í Á×À̱⠿äû ¼­¹ö°¡ ´Ù¸§",
                    lpPktUK->m_dwUserID, lpPktUK->m_dwServerID, lpSessionData->GetServerID());
            }
        }
    }

    return true;
}



bool CGameDispatch::CharAdminCmd(PktBase* lpPktBase)
{
    PktAdmin* lpPktAdmin = static_cast<PktAdmin*>(lpPktBase);

    PktAdmin pktSendAdmin;
    
    // ÆÐŶ ³»¿ëÀ» ±×´ë·Î º¹»ç.
    memcpy(&pktSendAdmin, lpPktAdmin, sizeof(PktAdmin));

	// Áß°è¼­¹ö °­Á¦ Á¾·á
	/*if(lpPktAdmin->m_usCmd == PktAdmin::DBAGENT_KILL)
	{
		int nZero = 0;
		int nError = 10 / nZero;
		*reinterpret_cast<int*>(nError) = 0xFFFFFFFF;
	}*/


    // ÃßÀûÇÑ À§Ä¡ ÁÂÇ¥¸¦, °ÔÀÓ ¼­¹ö·ÎºÎÅÍ ¹ÞÀº °æ¿ì¶ó¸é...
    if (lpPktAdmin->m_usCmd == PktAdmin::REQUEST_TRACE_POS)
    {
        // ÇØ´ç °ÔÀÓ ¼­¹ö¿¡°Ô¸¸ TRACE ¸í·É Àü¼Û
        pktSendAdmin.m_usCmd = PktAdmin::TRACE_CHAR;

        SERVER_ID serverID;

        serverID.sID.Type       = CServerSetup::GameServer;
        serverID.sID.Group      = CServerSetup::GetInstance().GetServerGroup();
        serverID.sID.Channel    = lpPktAdmin->m_ZoneInfo.m_cChannel;
        serverID.sID.ID         = lpPktAdmin->m_ZoneInfo.m_cZone;
        
        GET_MULTI_DISPATCH(lpGameDispatch, serverID.dwID, 
            CGameDispatch, CGameDispatch::GetDispatchTable());

        if(0 != lpGameDispatch)
        {
			serverID.dwID = m_dwServerID;

            // °ÔÀÓ ¼­¹ö·Î º¸³¾¶§´Â channel ÀÌ -1 À̾î¾ß ÇÑ´Ù. -_-;
			pktSendAdmin.m_ZoneInfo.m_cZone = serverID.GetZone();
			pktSendAdmin.m_ZoneInfo.m_cChannel = -1;

            if(PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktSendAdmin), 
                sizeof(PktAdmin), CmdCharAdminCmd, 0, 0))
            {
                lpGameDispatch->GetSendStream().PutBuffer(
                    reinterpret_cast<char*>(&pktSendAdmin), sizeof(PktAdmin), CmdCharAdminCmd);
            }
        }

        return true;
    }
    else if (lpPktAdmin->m_usCmd == PktAdmin::TRACE_CHAR)
    {
		using namespace DBAgent::DataStorage;

		// ij¸¯ÅÍ°¡ ·Î±×¾Æ¿ôÇÑ »óŶó¸é
		if (false == CSessionDataMgr::GetInstance().IsLoadedChar(lpPktAdmin->m_stName))
		{
			// ÇØ´ç °ÔÀÓ ¼­¹ö¿¡°Ô ÇØ´ç ij¸¯ÅÍ°¡ ·Î±×¾Æ¿ô Çß´Ù´Â Á¤º¸¸¦ º¸³½´Ù.
			pktSendAdmin.m_usCmd = PktAdmin::TRACE_CHAR;

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

			if(0 != lpGameDispatch)
			{
				// °ÔÀÓ ¼­¹ö·Î º¸³¾¶§´Â channel ÀÌ -1 À̾î¾ß ÇÑ´Ù. -_-;
				pktSendAdmin.m_ZoneInfo.m_cChannel = -1;
				pktSendAdmin.m_Position.fPointX = 0.0f;
				pktSendAdmin.m_Position.fPointY = 0.0f;
				pktSendAdmin.m_Position.fPointZ = 0.0f;

				if(PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktSendAdmin), 
					sizeof(PktAdmin), CmdCharAdminCmd, 0, PktAdmin::E_LOGOUT_CHAR))
				{
					lpGameDispatch->GetSendStream().PutBuffer(
						reinterpret_cast<char*>(&pktSendAdmin), sizeof(PktAdmin), CmdCharAdminCmd);
				}
			}
		}
		else
		{
			pktSendAdmin.m_usCmd = PktAdmin::REQUEST_TRACE_POS;

			SERVER_ID serverID;
			serverID.dwID = m_dwServerID;

			// TRACE ½ÃÄÑ¾ß ÇÒ Ä³¸¯ÅÍ°¡ ÇöÀç ÀÖ´Â Á¸ÀÇ ¹øÈ£¸¦ ±â¾ïÇصдÙ.
			pktSendAdmin.m_ZoneInfo.m_cZone = serverID.GetZone();
			pktSendAdmin.m_ZoneInfo.m_cChannel = 0;
		}
    }
/*
	else if (lpPktAdmin->m_usCmd == PktAdmin::INFO_CHAR)
	{
		using namespace DBAgent::DataStorage;

		// ij¸¯ÅÍ°¡ ·Î±×¾Æ¿ôÇÑ »óŶó¸é
		if (false == CSessionDataMgr::GetInstance().IsLoadedChar(lpPktAdmin->m_stName))
		{
			pktSendAdmin.m_usCmd = PktAdmin::INFO_CHAR;

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

			if(0 != lpGameDispatch)
			{
				// °ÔÀÓ ¼­¹ö·Î º¸³¾¶§´Â channel ÀÌ -1 À̾î¾ß ÇÑ´Ù. -_-;
				pktSendAdmin.m_ZoneInfo.m_cChannel = -1;
				pktSendAdmin.m_Position.fPointX = 0.0f;
				pktSendAdmin.m_Position.fPointY = 0.0f;
				pktSendAdmin.m_Position.fPointZ = 0.0f;

				if (PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktSendAdmin), 
					sizeof(PktAdmin), CmdCharAdminCmd, 0, PktAdmin::E_LOGOUT_CHAR))
				{
					lpGameDispatch->GetSendStream().PutBuffer(
						reinterpret_cast<char*>(&pktSendAdmin), sizeof(PktAdmin), CmdCharAdminCmd);
				}
			}
		}
	}
*/    
    if(PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktSendAdmin), 
        sizeof(PktAdmin), CmdCharAdminCmd, 0, 0))
    {
        // ¸ðµç °ÔÀÓ¼­¹ö·Î Àü¼Û.
        GetDispatchTable().Process(CSendPacketAllServer(
            reinterpret_cast<char*>(&pktSendAdmin), sizeof(PktAdmin), CmdCharAdminCmd));
    }

    return true;
}


bool CGameDispatch::GiveItemToTempInven(PktBase* lpPktBase)
{
    PktGiveItemToTempInven* lpPktGiveItemToTempInven = 
        static_cast<PktGiveItemToTempInven*>(lpPktBase);

    GiveItemInfo* lpPos = lpPktGiveItemToTempInven->m_GiveItemInfo;
    GiveItemInfo* lpEnd = lpPos + lpPktGiveItemToTempInven->m_cGiveItemNum;

    CGiveItemMgr& giveItemMgr = CGiveItemMgr::GetInstance();

    for(; lpPos != lpEnd; ++lpPos)
    {
        // ¾ÆÀÌÅÛ ³Ö±â¿¡ ¼º°øÇßÀ¸¸é ¾ÆÀÌÅÛ ½Ã¸®¾óÀ» ä¿ö¼­ ÁØ´Ù. ä¿ö¼­ ÁØ ½Ã¸®¾óÀ» DB¿¡ °»½ÅÇÑ´Ù.
        if(0 != lpPos->m_dwItemUID)
        {
            giveItemMgr.UpdateItemSerial(
                lpPos->m_dwCreateID, lpPos->m_dwItemUID);
        }
    }

    return true;
}

bool CGameDispatch::ChangeName(PktBase* lpPktBase)
{
    PktCharNameChange* lpCharNameChange = 
        reinterpret_cast<PktCharNameChange*>(lpPktBase);

    unsigned long dwUID = lpCharNameChange->m_dwUID;
    unsigned long dwCID = lpCharNameChange->m_dwCID;
    const char* szChangeName	= lpCharNameChange->m_szCharName;
   	Item::ItemPos   ItemPos		= lpCharNameChange->m_ItemPos;         // °è¸íÇã°¡¼­ À§Ä¡

    unsigned char   cNameChangeCount = 0;
    unsigned short  usError          = 0;

    using namespace DBAgent::DataStorage;

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

    CCharacterData* lpCharacterData = 0;

    if (0 != lpSessionData && 
        lpSessionData->GetUID() == dwUID &&
        lpSessionData->GetCID() == dwCID &&
        (0 != (lpCharacterData = lpSessionData->GetCharacterData())) && 
        dwCID == lpCharacterData->GetCID())
    {
        unsigned long dwResult = 0;

		const char* szPrevName = lpCharacterData->GetName();

        // Ä«¿îÆ®¸¦ ÁÙÀδÙ.
        CHAR_INFOEX infoEx = lpCharacterData->GetInfoEx();
/*
        if (0 == infoEx.cNameChangeCount)
        {
            usError = PktCharNameChange::ERR_NAMECHANGE_COUNT;
        }
        else
*/
		// ÀÌ»óÀÌ ¾øÀ¸¸é ¿©±â¼­ ¾ÆÀÌÅÛÀ» °¨¼Ò½ÃŲ´Ù.
		if (DBComponent::GameDB::ChangeCharName(
            CDBSingleObject::GetInstance(), dwCID, szChangeName, dwResult))
        {   
            if (0 == dwResult)
            {
                CHAR_INFOST charInfoST = lpCharacterData->GetInfo();

                strncpy(charInfoST.Name, szChangeName, CHAR_INFOST::MAX_NAME_LEN);
                charInfoST.Name[CHAR_INFOST::MAX_NAME_LEN - 1] = 0;

                lpCharacterData->SetInfo(charInfoST, true);

				infoEx.cNameChangeCount = 0;
                // --infoEx.cNameChangeCount;     // ¾ÆÀÌÅÛÀ¸·Î ¹Ù²ïÈÄ À̺κÐÀº »ç¿ë¾ÈÇÔ.

                cNameChangeCount = infoEx.cNameChangeCount;
                lpCharacterData->SetInfoEx(infoEx);

				// ·©Å·¿¡¼­ ã´Â´Ù //
				if(CRankingMgr::GetInstance().GetRank(szPrevName, (unsigned char)lpCharacterData->GetClass()))
				{	
					const CHAR_INFOST& charInfo = lpCharacterData->GetInfo();

					// µ¥ÀÌÅÍ »èÁ¦ //
					CRankingDBMgr::GetInstance().DeleteRanking(RankingNode(szPrevName, charInfo.Fame, 
						static_cast<unsigned char>(charInfo.Level), static_cast<unsigned char>(charInfo.Class)));

					// µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ® //
					CRankingDBMgr::GetInstance().UpdateRanking(RankingNode(szChangeName, charInfo.Fame, 
									static_cast<unsigned char>(charInfo.Level), static_cast<unsigned char>(charInfo.Class)));
				}
            }
            else if(1 == dwResult)
            {
                ERRLOG3(g_Log, "UID:%10u / CID:%10u / ChangeName:%s / ij¸¯ÅÍ À̸§ ¹Ù²Ù±â ½ÇÆÐ : À̸§ÀÌ ÀÌ¹Ì ÀÖ½À´Ï´Ù",
                    dwUID, dwCID, szChangeName);

                usError = PktCharNameChange::ERR_ALREADY_USE_NAME;
            }
            else
            {
                ERRLOG4(g_Log, "UID:%10u / CID:%10u / ChangeName:%s / dwResult:%10u / ij¸¯ÅÍ À̸§ ¹Ù²Ù±â ½ÇÆÐ : ¾Ë ¼ö ¾ø´Â dwResult°ªÀÔ´Ï´Ù",
                    dwUID, dwCID, szChangeName, dwResult);

                usError = PktCharNameChange::ERR_SERVER;
            }
        }
        else
        {
            ERRLOG3(g_Log, "UID:%10u / CID:%10u / ChangeName:%s / ij¸¯ÅÍ À̸§ ¹Ù²Ù±â ½ÇÆÐ : DBÈ£Ãâ ¿¡·¯",
                dwUID, dwCID, szChangeName);

            usError = PktCharNameChange::ERR_SERVER;
        }
    }
    else
    {
        ERRLOG3(g_Log, "UID:%10u / CID:%10u / ChangeName:%s / "
            "ij¸¯ÅÍ À̸§ ¹Ù²Ù±â ½ÇÆÐ : ij¸¯ÅÍ°¡ È°¼ºÈ­ µÈ ¼¼¼ÇÀÌ ¾ø½À´Ï´Ù",
            dwUID, dwCID, szChangeName);

        usError = PktCharNameChange::ERR_CANNOT_FIND_CHARACTER;
    }

    GameClientSendPacket::SendCharNameChange(GetSendStream(), dwUID, dwCID, 
        szChangeName, cNameChangeCount, &ItemPos, usError);
    return true;
}


void CGameDispatch::IncCharNum(int nRace)
{
    switch(nRace)
    {
    case CClass::HUMAN: ++m_nHumanNum;  break;
    case CClass::AKHAN: ++m_nAkhanNum;  break;
    }
}

void CGameDispatch::DecCharNum(int nRace)
{
    switch(nRace)
    {
    case CClass::HUMAN: --m_nHumanNum;  break;
    case CClass::AKHAN: --m_nAkhanNum;  break;
    }
}

int CGameDispatch::GetCharNum(int nRace) const
{
    int nNum = -1;

    switch(nRace)
    {
    case CClass::HUMAN: nNum = m_nHumanNum; break;
    case CClass::AKHAN: nNum = m_nAkhanNum; break;
    }

    return (nNum < 1) ? 1 : nNum;
}

int CGameDispatch::GetCharNum() const 
{
    int nUserNumber = m_nHumanNum + m_nAkhanNum - 1;
    return (nUserNumber < 1) ? 1 : nUserNumber;
}



// ³ªÁß¿¡ °³¼ö ¸¹¾ÆÁö¸é ºÐ¸®ÇÒ °Í..
bool ParseServerLog(CSendStream& SendStream, PktBase* lpPktBase)
{
    PktServerLog* lpPktServerLog = static_cast<PktServerLog*>(lpPktBase);

    switch(lpPktServerLog->m_cLogCmd)
    {
    case PktServerLog::ITEM_DUPLICATED_LOG:
        {
            PktItemDuplicated* lpPktItemDup = static_cast<PktItemDuplicated*>(lpPktServerLog);

            if(!DBComponent::GameDB::InsertItemDuplicatedLog(CDBSingleObject::GetInstance(),
                lpPktItemDup->m_dwItemSerial, lpPktItemDup->m_szName, 
                lpPktItemDup->m_dwUID, lpPktItemDup->m_dwCID, lpPktItemDup->m_dwQty))
            {
                ERRLOG5(g_Log, "UID:%10u / CID:%10u / CharName:%s / ItemSerial:0x%I64X / Qty:%u / ¾ÆÀÌÅÛ º¹»ç°¡ ¹ß°ßµÇ¾ú½À´Ï´Ù",
                    lpPktItemDup->m_dwUID, lpPktItemDup->m_dwCID, lpPktItemDup->m_szName, 
                    lpPktItemDup->m_dwItemSerial, lpPktItemDup->m_dwQty);
            }
        }
        break;


    }

    return true;
}




// -----------------------------------------------------------------------------------
// °¢Á¾ ÇÔ¼öÀÚ ¸Þ¼­µå

CGetTotalCount::CGetTotalCount(unsigned short&  usHumanCount, 
                               unsigned short&  usAkhanCount, 
                               unsigned char&   cChannelCount)
                               :   m_usHumanCount(usHumanCount), 
                                   m_usAkhanCount(usAkhanCount), 
                                   m_cChannelCount(cChannelCount)
{
    m_usHumanCount = 0;
    m_usAkhanCount = 0;
    m_cChannelCount = 0;
}

bool CGetTotalCount::operator () (unsigned long dwServerID, CPacketDispatch& packetDispatch)
{
    CGameDispatch& gameDispatch = reinterpret_cast<CGameDispatch&>(packetDispatch);

    int nCharNum = gameDispatch.GetCharNum(CClass::HUMAN);
    m_usHumanCount += nCharNum;

    nCharNum = gameDispatch.GetCharNum(CClass::AKHAN);
    m_usAkhanCount += nCharNum;
     
    ++m_cChannelCount;
    return true;
}

CUserPercentageInZone::CUserPercentageInZone(unsigned short* lpChannelUserNum, 
                                             unsigned char cZone, unsigned char cChannelNum)
                                             :  m_lpChannelUserNum(lpChannelUserNum),
                                                m_cZone(cZone),
                                                m_cChannelNum(cChannelNum),
                                                m_nMaxUserNum(CServerSetup::GetInstance().GetUserLimit())
{
    std::fill_n(m_lpChannelUserNum, m_cChannelNum, 0);
}

bool CUserPercentageInZone::operator () (unsigned long dwServerID, CPacketDispatch& packetDispatch)
{
    CGameDispatch& gameDispatch = reinterpret_cast<CGameDispatch&>(packetDispatch);

    SERVER_ID serverID;
    serverID.dwID = dwServerID;

    if(serverID.GetZone() == m_cZone)
    {
        if(serverID.GetChannel() < m_cChannelNum)
        {
            m_lpChannelUserNum[serverID.GetChannel()] = 
                gameDispatch.GetCharNum() * 100 / m_nMaxUserNum + 1;
        }
    }

    return true;
}


CSendPacketToZone::CSendPacketToZone(const char* szData, unsigned long dwDataLen, 
                                     unsigned char cPacketCmd, unsigned char cZone)
                                     :  m_szData(szData), m_dwDataLen(dwDataLen),
                                        m_cPacketCmd(cPacketCmd), m_cZone(cZone)
{


}

bool CSendPacketToZone::operator () (unsigned long dwServerID, CPacketDispatch& packetDispatch)
{
    SERVER_ID serverID;
    serverID.dwID = dwServerID;

    if(serverID.GetZone() == m_cZone)
    {
        return reinterpret_cast<CRylServerDispatch&>(packetDispatch).GetSendStream().PutBuffer(
            m_szData, m_dwDataLen, m_cPacketCmd);
    }

    return true;
}

}