#include "stdafx.h"

#include "CastlePacketParse.h"
#include "DBAgentDispatch.h"

#include <Utility/Setup/ServerSetup.h>

#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/WrapPacket.h>
#include <Network/Packet/PacketStruct/CastlePacket.h>
#include <Network/Packet/PacketStruct/ServerInfo.h>
#include <Network/Dispatch/GameClient/SendCharCastle.h>
#include <Network/Dispatch/GameClient/SendCharEtc.h>
#include <Network/Packet/PacketStruct/CharStatusPacket.h>

#include <Castle/Castle.h>
#include <Castle/CastleMgr.h>

#include <GameTime/GameTimeConstants.h>
#include <GameTime/GameTimeMgr.h>

#include <Creature/Siege/SiegeObject.h>
#include <Creature/Siege/Camp.h>
#include <Creature/Siege/MiningCamp.h>
#include <Creature/Siege/CampShop.h>
#include <Creature/Siege/WorldWeapon.h>
#include <Creature/Siege/CastleGate.h>
#include <Creature/Siege/CastleArms.h>
#include <Creature/Siege/SiegeArms.h>
#include <Creature/Siege/SiegeObjectMgr.h>
#include <Creature/Character/CharRespawnMgr.h>
#include <Creature/EnemyCheck.h>

#include <Community/Guild/Guild.h>
#include <Community/Guild/GuildMgr.h>

#include <Map/FieldMap/MineralVeinMgr.h>

#include <Skill/Spell/Spell.h>
#include <Skill/Spell/SpellTable.h>
#include <Skill/Spell/GlobalSpellMgr.h>
#include <Skill/Spell/SpellKind.h>
#include <Skill/Spell/SpellUtil.h>
#include <Skill/SkillStructure.h>
#include <Skill/SkillTable.h>

using namespace Castle;

// ¼º µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ®
bool DBAgentPacketParse::ParseCastleInfo(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	// edith ¼¼±Ý (¼º»ý¼º ºÎºÐ)
	PktCastleInfo* lpPktCastleInfo = static_cast<PktCastleInfo*>(lpPktBase);

	unsigned char cCastleObjectNum = lpPktCastleInfo->m_cCastleObjectNum;
	unsigned short wSize = lpPktCastleInfo->m_wSize;

	if (lpPktCastleInfo->m_bStartFlag)
	{
		Castle::CCastleMgr::GetInstance().Destroy();
	}

	Castle::CCastleMgr::GetInstance().SerializeIn(reinterpret_cast<char*>(lpPktCastleInfo + 1),	wSize, cCastleObjectNum);
	return true;
}

// ±æµå ¿ä»õ µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ®
bool DBAgentPacketParse::ParseCampInfo(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCampInfo* lpPktCampInfo = static_cast<PktCampInfo*>(lpPktBase);

	unsigned short wSize = lpPktCampInfo->m_wSize;
	unsigned long dwCID = lpPktCampInfo->m_dwCID;

	if (lpPktCampInfo->m_bStartFlag)
	{
		CSiegeObjectMgr::GetInstance().DestroyAllCamp();
	}

	CSiegeObjectMgr::GetInstance().SerializeIn(reinterpret_cast<char*>(lpPktCampInfo + 1), wSize, dwCID);

	return true;
}

// Áö·Â µ¥ÀÌÅÍ ¾÷µ¥ÀÌÆ®
bool DBAgentPacketParse::ParseFertilityInfo(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktFertilityInfo* lpPktFertilityInfo = static_cast<PktFertilityInfo*>(lpPktBase);

	unsigned short wSize = lpPktFertilityInfo->m_wSize;
	unsigned short wNum = lpPktFertilityInfo->m_wNum;

	CMineralVeinMgr::GetInstance().SetNowFertility(wNum, reinterpret_cast<unsigned long*>(lpPktFertilityInfo+1));
	return true;
}

// ¿ùµå ¿þÆù ¾÷µ¥ÀÌÆ®
bool DBAgentPacketParse::ParseWorldWeaponInfo(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktWorldWeaponInfo* lpPktWeaponInfo = static_cast<PktWorldWeaponInfo* >(lpPktBase);

	CSiegeObjectMgr::GetInstance().SetWorldWeaponInfo(lpPktWeaponInfo->m_cKarRemainSiegeTime, lpPktWeaponInfo->m_cMerRemainSiegeTime);
	return true;
}

// »õ·Î ±¸ÃàÁßÀÎ ±æµå ¿ä»õ
bool DBAgentPacketParse::ParseCreateCamp(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCreateCamp* lpPktCreateCamp = static_cast<PktCreateCamp*>(lpPktBase);
	CSiegeObject* lpCamp = NULL;

	// »ý¼º¿¡ ½ÇÆÐÇß´Ù¸é...
	if (PktCreateCamp::ERROR_EXIST_ANOTHER_WEAPON == lpPktCreateCamp->GetError())
	{
		// µ¿½Ã¿¡ µÎ°³ÀÇ »ý¼º 󸮸¦ ¸·±â À§Çؼ­...
		CSiegeObjectMgr::GetInstance().ReleaseWorldWeaponCreation();
	}

	switch ( lpPktCreateCamp->m_wObjectType )
	{
	case Siege::CAMP:
		{
			lpCamp = CSiegeObjectMgr::GetInstance().CreateCamp(lpPktCreateCamp->m_dwCID, lpPktCreateCamp->m_dwCampID, lpPktCreateCamp->m_dwGID,
															   lpPktCreateCamp->m_dwHP, lpPktCreateCamp->m_cState, lpPktCreateCamp->m_cUpgradeStep,
															   CampRight(), lpPktCreateCamp->m_Pos, lpPktCreateCamp->m_cMaterial, true);
		}
		break;

	case Siege::KARTERANT_WEAPON:
	case Siege::MERKADIA_WEAPON:
		{
			if (NULL == CSiegeObjectMgr::GetInstance().GetWorldWeapon())
			{
				lpCamp = CSiegeObjectMgr::GetInstance().CreateWorldWeapon(lpPktCreateCamp->m_dwCID, lpPktCreateCamp->m_dwCampID, lpPktCreateCamp->m_dwGID,
																		lpPktCreateCamp->m_dwHP, lpPktCreateCamp->m_cState, lpPktCreateCamp->m_cUpgradeStep,
																		CampRight(), lpPktCreateCamp->m_Pos, lpPktCreateCamp->m_cMaterial, true,
																		lpPktCreateCamp->m_wObjectType);

				// µ¿½Ã¿¡ µÎ°³ÀÇ »ý¼º 󸮸¦ ¸·±â À§Çؼ­...
				CSiegeObjectMgr::GetInstance().ReleaseWorldWeaponCreation();
			}
		}
		break;
	}
	
	if (lpCamp)
	{
        const int MAX_BUFFER = sizeof(PktCreateCamp);
		char szBuffer[MAX_BUFFER];

		PktCreateCamp* lpPktCC = reinterpret_cast<PktCreateCamp*>(szBuffer);

		lpPktCC->m_dwActorCID	= lpPktCreateCamp->m_dwActorCID;
		lpPktCC->m_dwCID		= lpCamp->GetCID();
		lpPktCC->m_dwCampID		= lpCamp->GetCampID();
		lpPktCC->m_dwGID		= lpCamp->GetGID();
		lpPktCC->m_dwHP			= lpCamp->GetNowHP();
		lpPktCC->m_wObjectType	= lpCamp->GetObjectType();
		lpPktCC->m_cZone		= CServerSetup::GetInstance().GetServerZone();
		lpPktCC->m_cChannel		= CServerSetup::GetInstance().GetServerChannel();
		lpPktCC->m_cState		= lpCamp->GetState();
		lpPktCC->m_cSubState	= lpCamp->GetSubState();
		lpPktCC->m_cUpgradeStep	= lpCamp->GetUpgradeStep();
		lpPktCC->m_CampRight	= reinterpret_cast<CCamp*>(lpCamp)->GetCampRight();
		lpPktCC->m_Pos.fPointX	= lpCamp->GetPosition().m_fPointX;
		lpPktCC->m_Pos.fPointY	= lpCamp->GetPosition().m_fPointY;
		lpPktCC->m_Pos.fPointZ	= lpCamp->GetPosition().m_fPointZ;
		lpPktCC->m_cMaterial	= lpCamp->GetMaterialNum();

		Guild::CGuild* lpGuild = Guild::CGuildMgr::GetInstance().GetGuild( lpCamp->GetGID() );
		if (lpGuild)
		{
			lpPktCC->m_cNation	= lpGuild->GetNation();
		}
		else
		{
			// ±æµå Á¤º¸°¡ ¾øÀ» ¶§ Á¦»ï±¹ÀûÀ¸·Î Àӽà »ç¿ë
			lpPktCC->m_cNation	= Creature::ALMIGHTY_PIRATE;
		}

		if (true == PacketWrap::WrapCrypt(szBuffer, MAX_BUFFER, CmdCreateCamp, 0 ,0))
		{
			CCreatureManager::GetInstance().SendAllCharacter(szBuffer, MAX_BUFFER, CmdCreateCamp);
		}
	}

	return true;
}

// »õ·Î »ý¼ºµÈ °ø¼º º´±â
bool DBAgentPacketParse::ParseCreateSiegeArms(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCreateSiegeArms* lpPktCreateSiegeArms = static_cast<PktCreateSiegeArms*>(lpPktBase);

	CSiegeObject* lpSiegeAmrs = CSiegeObjectMgr::GetInstance().CreateSiegeArms(lpPktCreateSiegeArms->m_dwCID, lpPktCreateSiegeArms->m_dwOwnerID,
																			   lpPktCreateSiegeArms->m_cNation, lpPktCreateSiegeArms->m_dwHP,
																			   lpPktCreateSiegeArms->m_wObjectType, lpPktCreateSiegeArms->m_cState,
																			   lpPktCreateSiegeArms->m_cUpgradeStep, lpPktCreateSiegeArms->m_Pos);

	if (lpSiegeAmrs)
	{
		const int MAX_BUFFER = sizeof(PktCreateSiegeArms);
		char szBuffer[MAX_BUFFER];

		PktCreateSiegeArms* lpPktCSA = reinterpret_cast<PktCreateSiegeArms*>(szBuffer);

		lpPktCSA->m_dwCID			= lpSiegeAmrs->GetCID();
		lpPktCSA->m_dwOwnerID		= lpSiegeAmrs->GetOwnerID();
		lpPktCSA->m_cNation			= lpSiegeAmrs->GetNation();
		lpPktCSA->m_wObjectType		= lpSiegeAmrs->GetObjectType();
		lpPktCSA->m_dwHP			= lpSiegeAmrs->GetNowHP();
		lpPktCSA->m_cState			= lpSiegeAmrs->GetState();
		lpPktCSA->m_cUpgradeStep	= lpSiegeAmrs->GetUpgradeStep();
		lpPktCSA->m_cZone			= CServerSetup::GetInstance().GetServerZone();
		lpPktCSA->m_cChannel		= CServerSetup::GetInstance().GetServerChannel();
		lpPktCSA->m_Pos.fPointX		= lpSiegeAmrs->GetPosition().m_fPointX;
		lpPktCSA->m_Pos.fPointY		= 0.0f;
		lpPktCSA->m_Pos.fPointZ		= lpSiegeAmrs->GetPosition().m_fPointZ;

		if (true == PacketWrap::WrapCrypt(szBuffer, MAX_BUFFER, CmdCreateSiegeArms, 0 ,0))
		{
			// Vincent - ºê·Îµå ij½ºÆ® Å×½ºÆ® ÄÚµå
			//lpSiegeAmrs->SendToRadiusCell(szBuffer, MAX_BUFFER, CmdCreateSiegeArms);
			lpSiegeAmrs->SendToRange(Siege::BROADCAST_RADIUS, szBuffer, MAX_BUFFER, CmdCreateSiegeArms);
		}
	}

	return true;
}

// ¼º °ü·Ã ¸í·É ÆÐŶ
bool DBAgentPacketParse::ParseCastleCmd(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCastleCmd* lpPktCastleCmd = static_cast<PktCastleCmd*>(lpPktBase);

	CCastle* lpCastle = CCastleMgr::GetInstance().GetCastle(lpPktCastleCmd->m_dwCastleID);
	CSiegeObject* lpCastleObject = CSiegeObjectMgr::GetInstance().GetSiegeObject(lpPktCastleCmd->m_dwCastleObjectID);
	unsigned long dwCID = lpPktCastleCmd->m_dwCID;
	unsigned long dwValue1 = lpPktCastleCmd->m_dwValue1;
	unsigned long dwValue2 = lpPktCastleCmd->m_dwValue2;
	unsigned char cState = lpPktCastleCmd->m_cState;
	unsigned char cSubCmd = lpPktCastleCmd->m_cSubCmd;

	if (lpCastle && lpCastleObject)
	{
		switch (cSubCmd)
		{
			// ------------------------------------------------------------------------
			// ¼º »ó¡¹°
			// [In/Out] dwValue1 : ¼¼À² ŸÀÔ
			// [In/Out] dwValue2 : ¼¼À²
			case PktCastleCmd::CASTLE_SET_TAX:	// ¼¼À² Á¶Á¤
			{
				lpCastle->SetTax(static_cast<unsigned char>(dwValue1), static_cast<unsigned char>(dwValue2));
			}
			break;

			case PktCastleCmd::CASTLE_UPGRADE_EMBLEM:			// »ó¡¹° ¾÷±×·¹À̵å	[In/Out] dwValue1 : ¾÷±×·¹À̵å ŸÀÔ
			case PktCastleCmd::CASTLE_UPDATE_EMBLEM:			// ¼º »ó¡¹° Æı«		[In] dwValue1 : ¼ÒȯÁßÀÎ »ó¡¹°ÀÌ ¾Æ±º°ÍÀÎÁö Àû±º°ÍÀÎÁö Á¤º¸
																//						[Out] dwValue1 : ÇöÀç »ó¡¹°ÀÇ GID
			case PktCastleCmd::CASTLE_SUMMON_EMBLEM_COMPLETE:	// ¼º »ó¡¹° ¼Òȯ ¿Ï·á	[In/Out] dwValue1 : ¾Æ±ºÀÌ ¼Òȯ¿Ï·á
			{
				lpCastleObject->Update(cState, dwValue1, 0, 0, cSubCmd);				
			}
			break;

			// [In/Out] dwValue1 : ¾÷±×·¹ÀÌµå ´Ü°è
			case PktCastleCmd::CASTLE_UPGRADE_EMBLEM_COMPLETE:	// »ó¡¹° ¾÷±×·¹ÀÌµå ¿Ï·á
			{
				lpCastleObject->Upgrade(static_cast<unsigned char>(dwValue1));
			}
			break;

			// [In/Out] dwValue1 : »õ·Î¿î ¼ºÀÇ ¼ÒÀ¯ ±¹°¡
			case PktCastleCmd::CASTLE_CHANGE_MASTER:	// ¼ºÁÖ º¯°æ
			{
				// ¼ºÁÖ º¯°æµÈ Á¤º¸¸¦ ¾Ë·ÁÁØ´Ù.
				lpCastle->ChangeCastleMaster(static_cast<unsigned char>(dwValue1));

				// ¸®½ºÆù Æ÷ÀÎÆ® ±¹Àû º¯°æ
				CCharRespawnMgr::GetInstance().SetCastleRespawnPointNation(lpCastle->GetNameID(), static_cast<unsigned char>(dwValue1));

				// NPC µéÀÇ GID º¯°æ
				CCreatureManager::GetInstance().SetNationToCastleNPC(lpCastle->GetCastleID(), static_cast<unsigned char>(dwValue1));

				// °ø¼ºÀü Áß ·Î±×ÀÎÇÒ °æ¿ì °ø¼ºÃøÀº ¸®½ºÆù Áö¿ªÀ¸·Î À̵¿½ÃŲ´Ù.
				if(CServerSetup::GetInstance().GetServerZone() == SERVER_ID::CAPITAL)
				{
					if(CGameTimeMgr::GetInstance().IsSiegeWarTime())
					{
						CCreatureManager::GetInstance().ProcessAllCharacter(SiegeMovePos);
					}
				}
			}
			break;

			// [In/Out] dwValue1 : ¼¼±Ý ŸÀÔ
			// [In/Out] dwValue2 : ȸ¼öÇÒ ¼¼±Ý
			case PktCastleCmd::CASTLE_TAKE_TAXMONEY:	// ¼¼±Ý ȸ¼ö
			{
				lpCastle->TakeTaxMoney(static_cast<unsigned char>(dwValue1), dwValue2);
			}
			break;

			case PktCastleCmd::CASTLE_LOSE_OWNERSHIP:	// ¼º ¼ÒÀ¯ Á߸³È­
			{
				lpCastle->LoseOwnership();

				// ¸®½ºÆù Æ÷ÀÎÆ® »èÁ¦
				CCharRespawnMgr::GetInstance().SetCastleRespawnPointNation(lpCastle->GetNameID(), Creature::STATELESS);

				// NPC µéÀÇ GID º¯°æ
				CCreatureManager::GetInstance().SetNationToCastleNPC(lpCastle->GetCastleID(), Creature::STATELESS);
			}
			break;

			// [In/Out] dwValue1 : ±¤¹°ID
			// [In] dwValue2 : ȹµæ·®
			// [Out] dwValue2 : ÃÖÁ¾³²Àº¾ç
			case PktCastleCmd::CASTLE_GAIN_MINERAL:		// ±¤¹° ȹµæ
			{
				unsigned short wMineralID = static_cast<unsigned short>(dwValue1);
				unsigned short wAmount = static_cast<unsigned short>(dwValue2);

				lpCastle->GainMineral(wMineralID, wAmount);
			}
			break;

			// ------------------------------------------------------------------------
			// ¼º¹®
			// [Out] dwValue1 : SubState (OPENED)
			case PktCastleCmd::CASTLE_GATE_OPEN:	// ¼º¹® ¿­±â
			{
				if (Siege::GATE == lpCastleObject->GetObjectType())
				{
					reinterpret_cast<CCastleGate*>(lpCastleObject)->Open();
				}
			}
			break;

			// [Out] dwValue1 : SubState (CLOSED)
			case PktCastleCmd::CASTLE_GATE_CLOSE:	// ¼º¹® ´Ý±â
			{
				if (Siege::GATE == lpCastleObject->GetObjectType())
				{
					reinterpret_cast<CCastleGate*>(lpCastleObject)->Close();
				}
			}
			break;

			case PktCastleCmd::CASTLE_UPGRADE_GATE:		// ¼º¹® ¾÷±×·¹À̵å	[In/Out] dwValue1 : ¾÷±×·¹ÀÌµå ºñ¿ë (»ç¿ëÀº ¾ÈÇÔ)
			case PktCastleCmd::CASTLE_REPAIR_GATE:		// ¼º¹® ¼ö¸®		[In/Out] dwValue1 : ¼ö¸® ºñ¿ë       (»ç¿ëÀº ¾ÈÇÔ)
			case PktCastleCmd::CASTLE_RESTORE_GATE:		// ¼º¹® º¹±¸		[In/Out] dwValue1 : º¹±¸ ºñ¿ë       (»ç¿ëÀº ¾ÈÇÔ)
			{
				lpCastleObject->Update(cState, dwValue1, 0, 0, cSubCmd);
			}
			break;

			// [In/Out] dwValue1 : ¾÷±×·¹ÀÌµå ´Ü°è
			case PktCastleCmd::CASTLE_UPGRADE_GATE_COMPLETE:	// ¼º¹® ¾÷±×·¹ÀÌµå ¿Ï·á
			{
				lpCastleObject->Upgrade(static_cast<unsigned char>(dwValue1));
			}
			break;

			// [In] dwValue1 : ¼ö¸®µÇ¾î Ãß°¡µÉ HP
			// [Out] dwValue1 : ¼ö¸®µÈ ÃÖÁ¾ HP (ÇöÀç HP)
			case PktCastleCmd::CASTLE_REPAIR_GATE_COMPLETE:		// ¼º¹® ¼ö¸® ¿Ï·á
			{
				lpCastleObject->Repair(static_cast<unsigned short>(dwValue1));
			}
			break;

			// [In] dwValue1 : º¹±¸µÈ HP ¶ó°íÇÏÁö¸¸.. ½ÇÀº 0 ÀÌ´Ù. (Àû¿ë ¾ÈµÊ)
			// [Out] dwValue1 : ÇöÀç HP
			case PktCastleCmd::CASTLE_RESTORE_GATE_COMPLETE:	// ¼º¹® º¹±¸ ¿Ï·á
			{
				lpCastleObject->Restore();
			}
			break;

			case PktCastleCmd::CASTLE_DESTROY_GATE:	// ¼º¹® Æı«
			{
				lpCastleObject->Destroy(0, false);
			}
			break;

			// ------------------------------------------------------------------------
			// ¼ö¼º º´±â
			case PktCastleCmd::CASTLE_CREATE_ARMS:				// ¼ö¼º º´±â °³¹ß		[In/Out] dwValue1 : °³¹ß ºñ¿ë		[In] dwValue2 : »óÀ§ 16ºñÆ® : »ý»ê½Ã°£ / ÇÏÀ§ 16ºñÆ® : º´±â ŸÀÔ	[Out] dwValue2 : º´±â ŸÀÔ
			case PktCastleCmd::CASTLE_UPGRADE_ARMS:				// ¼ö¼º º´±â ¾÷±×·¹À̵å	[In/Out] dwValue1 : ¾÷±×·¹ÀÌµå ºñ¿ë	[In/Out] dwValue2 : ¾÷±×·¹ÀÌµå ½Ã°£ (ºÐ)
			case PktCastleCmd::CASTLE_REPAIR_ARMS:				// ¼ö¼º º´±â ¼ö¸®		[In/Out] dwValue1 : ¼ö¸® ºñ¿ë		[In/Out] dwValue2 : ¼ö¸®ÇÒ HP ¾ç
			{
				lpCastleObject->Update(cState, dwValue1, dwValue2, dwCID, cSubCmd);
			}
			break;
			
			// [In/Out] dwValue1 : º´±â ŸÀÔ
			case PktCastleCmd::CASTLE_CREATE_ARMS_COMPLETE:		// ¼ö¼º º´±â °³¹ß ¿Ï·á
			{
				if (lpCastleObject->IsCastleArms())
				{
					reinterpret_cast<CCastleArms*>(lpCastleObject)->ChangeType(static_cast<unsigned short>(dwValue1));
				}
			}
			break;

			// [In/Out] dwValue1 : ¾÷±×·¹ÀÌµå ´Ü°è
			case PktCastleCmd::CASTLE_UPGRADE_ARMS_COMPLETE:	// ¼ö¼º º´±â ¾÷±×·¹ÀÌµå ¿Ï·á
			{
				lpCastleObject->Upgrade(static_cast<unsigned char>(dwValue1));
			}
			break;

			// [In/Out] dwValue1 : ¼ö¸®·Î ȸº¹µÉ HP
            // [Out] dwValue2 : ¼ö¸®·Î ȸº¹µÈ ÇöÀç HP
			case PktCastleCmd::CASTLE_REPAIR_ARMS_COMPLETE:		// ¼ö¼º º´±â ¼ö¸® ¿Ï·á
			{
				lpCastleObject->Repair(static_cast<unsigned short>(dwValue1));
			}
			break;

			// [In] dwValue1 : 0 : Æı«, 1 : º´±â°ü¸® NPC·Î º¯Çü( »ý»ê ºñ¿ë Àý¹ÝÀ» µ¹·ÁÁÜ )
			// [Out] dwValue1 : º´±â °ü¸® NPC Type ID
			case PktCastleCmd::CASTLE_DESTROY_ARMS:				// ¼ö¼º º´±â Æı«
			{
				lpCastleObject->AllGetOff();
				lpCastleObject->Destroy(0, (0 != dwValue1));
			}
			break;


			// [Out] dwValue1 : Full HP ( To DBAgentServer )
			case PktCastleCmd::CASTLE_GATE_FORCE_OPEN:			// ¼º¹®À» °­Á¦·Î ¿­¸° »óÅ·Π¸¸µç´Ù.
			{
				if (lpCastleObject->IsGate())
				{
					static_cast<CCastleGate* >(lpCastleObject)->ForceOpen();
				}
			}
			break;

			// [Out] dwValue1 : Full HP ( To DBAgentServer )
			case PktCastleCmd::CASTLE_GATE_FORCE_CLOSE:			// ¼º¹®À» °­Á¦·Î ´ÝÈù »óÅ·Π¸¸µç´Ù.
			{
				if (lpCastleObject->IsGate())
				{
					static_cast<CCastleGate* >(lpCastleObject)->ForceClose();
				}
			}
			break;
		}
	}

	return true;
}

// ±æµå ¿ä»õ ¸í·É ÆÐŶ
bool DBAgentPacketParse::ParseCampCmd(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCampCmd* lpPktCampCmd = static_cast<PktCampCmd*>(lpPktBase);

	CCamp* lpCamp = CSiegeObjectMgr::GetInstance().GetCamp(lpPktCampCmd->m_dwCampID);
	unsigned char cState = lpPktCampCmd->m_cState;
	unsigned long dwValue1 = lpPktCampCmd->m_dwValue1;
	unsigned long dwValue2 = lpPktCampCmd->m_dwValue2;
	unsigned char cSubCmd = lpPktCampCmd->m_cSubCmd;

	if (lpCamp)
	{
		switch (cSubCmd)
		{
			// ±æµå ¿ä»õ ±¸Ãà ¿Ï·á
			case PktCampCmd::CAMP_BUILD_COMPLETE:
			{
				lpCamp->Build();

				// ¸®½ºÆù Æ÷ÀÎÆ® Ãß°¡
				CCharRespawnMgr::GetInstance().AddCampRespawnPoint(lpCamp->GetCampID(), lpCamp->GetGID(), lpCamp->GetPosition());
			}
			break;

			// ±æµå ¿ä»õ ±¸Ãà ÇØÁ¦Áß
			// ±æµå ¿ä»õ ½ºÅ¸Æ®Å¶À¸·Î º¯È¯Áß
			// ±æµå ¿ä»õ ¾÷±×·¹À̵åÁß
			// ±æµå ¿ä»õ ¼ö¸®Áß
			// ±æµå ¿ä»õ º¯ÇüÁß
			case PktCampCmd::CAMP_CANCEL:
			case PktCampCmd::CAMP_TO_STARTKIT:
			case PktCampCmd::CAMP_UPGRADE:			// dwValue1[In] : ¾÷±×·¹ÀÌµå ´Ü°è
			case PktCampCmd::CAMP_REPAIR:			// dwValue1[In] : ¼ö¸®·Î ȸº¹µÉ HP
			case PktCampCmd::CAMP_CHANGE_TYPE:		// dwValue1[In] : º¯ÇüÇÒ Å¸ÀÔ
			{
				lpCamp->Update(cState, dwValue1, dwValue2, 0, cSubCmd);
			}
			break;

			// ±æµå ¿ä»õ ±¸Ãà ÇØÁ¦ ¿Ï·á
			case PktCampCmd::CAMP_CANCEL_COMPLETE:
			{
				// ¸®½ºÆù Æ÷ÀÎÆ® »èÁ¦
				CCharRespawnMgr::GetInstance().DeleteCampRespawnPoint(lpCamp->GetCampID());

				lpCamp->Cancel();
				CSiegeObjectMgr::GetInstance().DeleteCamp(lpCamp->GetCampID());
			}
			break;

			// ±æµå ¿ä»õ ¾÷±×·¹ÀÌµå ¿Ï·á
			case PktCampCmd::CAMP_UPGRADE_COMPLETE:	// dwValue1[In] : ¾÷±×·¹ÀÌµå ´Ü°è
			{
				lpCamp->Upgrade(static_cast<unsigned char>(dwValue1));
			}
			break;

			// ±æµå ¿ä»õ ¼ö¸® ¿Ï·á
			case PktCampCmd::CAMP_REPAIR_COMPLETE:	// dwValue1[In] : ¼ö¸®·Î ȸº¹µÈ HP
			{
				lpCamp->Repair(static_cast<unsigned short>(dwValue1));
			}
			break;

			// ½ºÅ¸Æ®Å¶À¸·Î
			case PktCampCmd::CAMP_TO_STARTKIT_COMPLETE:
			{
				// ¸®½ºÆù Æ÷ÀÎÆ® »èÁ¦
				CCharRespawnMgr::GetInstance().DeleteCampRespawnPoint(lpCamp->GetCampID());

				lpCamp->Destroy( lpCamp->GetGID() );
				CSiegeObjectMgr::GetInstance().DeleteCamp( lpCamp->GetCampID() );
			}
			break;

			// ±æµå ¿ä»õ Æı«½Ã / 7ÀÏ°£ Ä·ÇÁ ¹Ì»ç¿ë½Ã Æı«
			case PktCampCmd::CAMP_DESTROY:			// dwValue1[In] : Æı«ÇÑ ±æµåÀÇ ID
			{
				// ¸®½ºÆù Æ÷ÀÎÆ® »èÁ¦
				CCharRespawnMgr::GetInstance().DeleteCampRespawnPoint(lpCamp->GetCampID());

				lpCamp->Destroy( dwValue1 );
				CSiegeObjectMgr::GetInstance().DeleteCamp( lpCamp->GetCampID() );
			}
			break;

			// ±æµå ¿ä»õ º¯Çü ¿Ï·á
			case PktCampCmd::CAMP_CHANGE_COMPLETE:	// dwValue1[In] : º¯ÇüµÈ ŸÀÔ
			{
				lpCamp->ChangeType( static_cast<unsigned short>(dwValue1) );

				CSiegeObjectMgr::GetInstance().ChangeCampType( lpCamp->GetCampID(), static_cast<unsigned short>(dwValue1) );
			}
			break;

			// ä±¼±â »óÅ º¯°æ
			// dwValue1[In] : ä±¼±â »óÅ On / Ready / Off
			case PktCampCmd::MINING_CAMP_ON_OFF:
			{
				CMiningCamp* lpMiningCamp = reinterpret_cast<CMiningCamp*>(lpCamp);
				if ( NULL != lpMiningCamp )
				{
					lpMiningCamp->OnOff( static_cast<unsigned char>(dwValue1) );
				}
				else
				{
					ERRLOG1(g_Log, "ä±¼±â ij½ºÆà ½ÇÆÐ CampID : 0x%10u", lpCamp->GetCampID());
				}
			}
			break;

			// ä±¼±â ´©Àû ±¤¹° ȹµæ
			// dwValue1[In] : ´©Àû ±¤¹° ¾ÆÀÌÅÛ ¾ÆÀ̵ð
			// dwValue2[In] : ´©Àû ±¤¹° ȹµæ·®
			case PktCampCmd::MINING_CAMP_GAIN_MINERAL:
			{
				CMiningCamp* lpMiningCamp = reinterpret_cast<CMiningCamp*>(lpCamp);
				if ( NULL != lpMiningCamp )
				{
					unsigned short wMineralID = static_cast<unsigned short>(dwValue1);
					unsigned short wAmount = static_cast<unsigned short>(dwValue2);

					lpMiningCamp->GainMineral( wMineralID, wAmount );
				}
				else
				{
					ERRLOG1(g_Log, "ä±¼±â ij½ºÆà ½ÇÆÐ CampID : 0x%10u", lpCamp->GetCampID());
				}
			}
			break;

			// ¼¼À² º¯°æ (±æµå ¿ä»õ »óÁ¡)
			// dwValue1[In] : º¯°æ ÈÄ ¼¼À²
			case PktCampCmd::CAMP_SHOP_CHANGE_TAX:
			{
				CCampShop* lpCampShop = reinterpret_cast<CCampShop*>(lpCamp);
				if (NULL != lpCampShop)
				{
					unsigned char cTax = static_cast<unsigned char>(dwValue1);
					lpCampShop->SetTax(cTax);
				}
				else
				{
					ERRLOG1(g_Log, "»óÁ¡ ŸÀÔ Ä³½ºÆà ½ÇÆÐ CampID : 0x%10u", lpCamp->GetCampID());
				}
			}
			break;

			// ¼öÀÍ±Ý È¹µæ (±æµå ¿ä»õ »óÁ¡)
			// dwValue1[In] : ¼öÀͱÝ
			case PktCampCmd::CAMP_SHOP_GAIN_TAX:
			{
				CCampShop* lpCampShop = reinterpret_cast<CCampShop*>(lpCamp);
				if (NULL != lpCampShop)
				{
					unsigned long dwGold = dwValue1;
					lpCampShop->DeductGold(dwGold);

					Guild::CGuild* lpGuild = Guild::CGuildMgr::GetInstance().GetGuild(lpCampShop->GetGID());
					if (NULL != lpGuild)
					{
						lpGuild->AddGold(dwGold);
						lpGuild->SendGuildSafe(lpCampShop->GetCID(), "±æµå ¿ä»õ »óÁ¡", PktGuildSafe::SC_CAMPSHOP);
					}
				}
				else
				{
					ERRLOG1(g_Log, "»óÁ¡ ŸÀÔ Ä³½ºÆà ½ÇÆÐ CampID : 0x%10u", lpCamp->GetCampID());
				}
			}
			break;

			// ¿ùµå ¿þÆù ¹«±â ÀåÀü
			case PktCampCmd::WORLDWEAPON_CHARGE:
			{
				CWorldWeapon* lpWorldWeapon = reinterpret_cast<CWorldWeapon*>(lpCamp);
				if ( NULL != lpWorldWeapon )
				{
					lpWorldWeapon->UpdateWeaponState(Siege::WEAPON_CHARGE);
				}
				else
				{
					ERRLOG1(g_Log, "¿ùµå ¿þÆù ij½ºÆà ½ÇÆÐ CampID : 0x%10u", lpCamp->GetCampID());
				}
			}
			break;

			// ¿ùµå ¿þÆù ¹«±â ÀåÀü ¿Ï·á
			case PktCampCmd::WORLDWEAPON_CHARGE_COMPLETE:
			{
				CWorldWeapon* lpWorldWeapon = reinterpret_cast<CWorldWeapon*>(lpCamp);
				if ( NULL != lpWorldWeapon )
				{
					lpWorldWeapon->UpdateWeaponState(Siege::WEAPON_READY);
				}
				else
				{
					ERRLOG1(g_Log, "¿ùµå ¿þÆù ij½ºÆà ½ÇÆÐ CampID : 0x%10u", lpCamp->GetCampID());
				}
			}
			break;

			// ¿ùµå ¿þÆù ¹«±â ¹ß»ç
			// dwValue1[In] : X ÁÂÇ¥
			// dwValue2[In] : Z ÁÂÇ¥
			case PktCampCmd::WORLDWEAPON_FIRE:
			{
				CWorldWeapon* lpWorldWeapon = reinterpret_cast<CWorldWeapon*>(lpCamp);
				if ( NULL != lpWorldWeapon )
				{
					lpWorldWeapon->UpdateWeaponState(Siege::WEAPON_FIRE, dwValue1, dwValue2);
				}
				else
				{
					ERRLOG1(g_Log, "¿ùµå ¿þÆù ij½ºÆà ½ÇÆÐ CampID : 0x%10u", lpCamp->GetCampID());
				}
			}
			break;
		}
	}

	return true;
}

// °ø¼º º´±â ¸í·É ÆÐŶ
bool DBAgentPacketParse::ParseSiegeArmsCmd(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktSiegeArmsCmd* lpPktSACmd = static_cast<PktSiegeArmsCmd*>(lpPktBase);

	unsigned char cState = lpPktSACmd->m_cState;
	unsigned long dwValue = lpPktSACmd->m_dwValue;
	unsigned char cSubCmd = lpPktSACmd->m_cSubCmd;

	CSiegeArms* lpSiegeArms = reinterpret_cast<CSiegeArms*>( CSiegeObjectMgr::GetInstance().GetSiegeObject(lpPktSACmd->m_dwArmsID) );

    if (lpSiegeArms)
	{
		switch (cSubCmd)
		{
			// °ø¼º º´±â »ý¼º ¿Ï·á
		case PktSiegeArmsCmd::SIEGE_CREATE_ARMS_COMPLETE:
			{
				lpSiegeArms->Build(static_cast<unsigned char>(dwValue));
			}
			break;

			// °ø¼º º´±â »ý¼º Ãë¼Ò (¹Ù·ÎµÊ)
			// °ø¼º º´±â¸¦ ½ºÅ¸Æ®Å¶À¸·Î ¿Ï·á
		case PktSiegeArmsCmd::SIEGE_CANCEL:			
		case PktSiegeArmsCmd::SIEGE_TO_STARTKIT_COMPLETE:
			{
				bool bMaterial = false;

				if (PktSiegeArmsCmd::SIEGE_CANCEL==cSubCmd)					
				{
					bMaterial = true;
				}

				lpSiegeArms->AllGetOff();
				lpSiegeArms->ToStarterKit(bMaterial);
				lpSiegeArms->Destroy(0, false);
				CSiegeObjectMgr::GetInstance().DeleteSiegeObject(lpSiegeArms->GetCID());
			}
			break;

			// °ø¼º º´±â ¼ö¸®
			// °ø¼º º´±â ½ºÅ¸Æ® ŶÀ¸·Î º¯Çü
		case PktSiegeArmsCmd::SIEGE_REPAIR_ARMS:	// [In/Out] dwValue1 : RepairHP
		case PktSiegeArmsCmd::SIEGE_TO_STARTKIT:
			{
				lpSiegeArms->Update(cState, dwValue, 0, 0, cSubCmd);
			}
			break;

			// °ø¼º º´±â ¼ö¸® ¿Ï·á
		case PktSiegeArmsCmd::SIEGE_REPAIR_ARMS_COMPLETE:
			{
				lpSiegeArms->Repair(static_cast<unsigned short>(dwValue));
			}
			break;

			
			// °ø¼º º´±â Æı«
		case PktSiegeArmsCmd::SIEGE_DESTROY_ARMS:
			{
				lpSiegeArms->AllGetOff();
				lpSiegeArms->Destroy(0, false);
				CSiegeObjectMgr::GetInstance().DeleteSiegeObject(lpSiegeArms->GetCID());
			}
			break;
		}
	}

	return true;
}

// ¼º °ü¸® ±ÇÇÑ º¯°æ
bool DBAgentPacketParse::ParseCastleRight(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCastleRight* lpPktCastleRight = static_cast<PktCastleRight*>(lpPktBase);

	CCastle* lpCastle = CCastleMgr::GetInstance().GetCastle(lpPktCastleRight->m_dwCastleID);

	if (lpCastle)
	{
		lpCastle->SetRight(lpPktCastleRight->m_CastleRight);
	}

	return true;
}

// ±æµå ¿ä»õ °ü¸® ±ÇÇÑ º¯°æ
bool DBAgentPacketParse::ParseCampRight(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCampRight* lpPktCampRight = static_cast<PktCampRight*>(lpPktBase);

	CCamp* lpCamp = CSiegeObjectMgr::GetInstance().GetCamp(lpPktCampRight->m_dwCampID);

	if (lpCamp)
	{
		lpCamp->SetRight(lpPktCampRight->m_CampRight);
	}

	return true;
}

// °ø¼º ½Ã°£ °ü·Ã ÆÐŶ
bool DBAgentPacketParse::ParseGameTimeInfo(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktGameTimeInfo* lpPktGTI = static_cast<PktGameTimeInfo*>(lpPktBase);
	CastleSiegeInfo* lpCastleSiegeInfo = reinterpret_cast<CastleSiegeInfo*>(lpPktGTI + 1);
	unsigned char cType = lpPktGTI->m_cType;
	unsigned short wSize = lpPktGTI->m_wSize;
	bool bGuildUpdated = lpPktGTI->m_GuildTimeInfo.m_bUpdated;
	bool bRealmUpdated = lpPktGTI->m_RealmTimeInfo.m_bUpdated;
	bool bSiegeUpdated = lpPktGTI->m_SiegeTimeInfo.m_bUpdated;
	bool bEventUpdated = lpPktGTI->m_EventTimeInfo.m_bUpdated;

	// °¢ ¼ºµéÀÇ °ø¼º °¡´É Á¤º¸ ¼ÂÆÃ
	for (int i=0; i<lpPktGTI->m_cCastleNum; ++i)
	{
		if (lpCastleSiegeInfo)
		{
			CCastle* lpCastle = CCastleMgr::GetInstance().GetCastle(lpCastleSiegeInfo->m_dwCastleID);
			if (lpCastle)
			{
				lpCastle->SetEnableSiege(lpCastleSiegeInfo->m_bEnableSiege);
			}
		}

		++lpCastleSiegeInfo;
	}

	unsigned char cOldGuildTime = CGameTimeMgr::GetInstance().GetCurrentGuildTime();
	unsigned char cOldRealmTime = CGameTimeMgr::GetInstance().GetCurrentRealmTime();
	unsigned char cOldSiegeTime = CGameTimeMgr::GetInstance().GetCurrentSiegeTime();
	unsigned char cOldEventTime = CGameTimeMgr::GetInstance().GetCurrentEventTime();

	// GameTimeMgr ¿¡ °ª ¼ÂÆÃ
	switch (cType)
	{
		case GameTime::TYPE_GAMESERVER_LOGIN:
		{
			CGameTimeMgr::GetInstance().SetTimeValue(GameTime::GUILD, lpPktGTI->m_GuildTimeInfo.m_cNowGuildTime,
				lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cDay,
				lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cMinute,
				lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_dwTime);

			lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::GUILD);

			CGameTimeMgr::GetInstance().SetTimeValue(GameTime::REALM, lpPktGTI->m_RealmTimeInfo.m_cNowRealmTime,
				lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cDay,
				lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cMinute,
				lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_dwTime);

			lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::REALM);

			CGameTimeMgr::GetInstance().SetTimeValue(GameTime::SIEGE, lpPktGTI->m_SiegeTimeInfo.m_cNowSiegeTime,
				lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cDay,
				lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cMinute,
				lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_dwTime);

			lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::SIEGE);

			CGameTimeMgr::GetInstance().SetTimeValue(GameTime::EVENT, lpPktGTI->m_EventTimeInfo.m_cNowEventTime,
				lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cDay,
				lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cMinute,
				lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_dwTime);

			lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::EVENT);
		}
		break;

		case GameTime::TYPE_CHANGE_GAME_TIME:
		{
			if (bGuildUpdated)
			{
				CGameTimeMgr::GetInstance().SetTimeValue(GameTime::GUILD, lpPktGTI->m_GuildTimeInfo.m_cNowGuildTime,
					lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cDay,
					lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_cMinute,
					lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_dwTime);

				lpPktGTI->m_GuildTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::GUILD);
			}

			if (bRealmUpdated)
			{
				CGameTimeMgr::GetInstance().SetTimeValue(GameTime::REALM, lpPktGTI->m_RealmTimeInfo.m_cNowRealmTime,
					lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cDay,
					lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_cMinute,
					lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_dwTime);

				lpPktGTI->m_RealmTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::REALM);
			}

			if (bSiegeUpdated)
			{
				CGameTimeMgr::GetInstance().SetTimeValue(GameTime::SIEGE, lpPktGTI->m_SiegeTimeInfo.m_cNowSiegeTime,
					lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cDay,
					lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_cMinute,
					lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_dwTime);

				lpPktGTI->m_SiegeTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::SIEGE);				
			}

			if (bEventUpdated)
			{
				CGameTimeMgr::GetInstance().SetTimeValue(GameTime::EVENT, lpPktGTI->m_EventTimeInfo.m_cNowEventTime,
					lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cMonth, lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cDay,
					lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cHour, lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_cMinute,
					lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_dwTime);

				lpPktGTI->m_EventTimeInfo.m_TimeInfo.m_dwTime = CGameTimeMgr::GetInstance().GetDetailRemainSec(GameTime::EVENT);				
			}
		}
		break;

		case GameTime::TYPE_CHARACTER_LOGIN:
		case GameTime::TYPE_ENABLE_CASTLE_SIEGE:
			break;
	}

	unsigned char cNowGuildTime = CGameTimeMgr::GetInstance().GetCurrentGuildTime();
	unsigned char cNowRealmTime = CGameTimeMgr::GetInstance().GetCurrentRealmTime();
	unsigned char cNowSiegeTime = CGameTimeMgr::GetInstance().GetCurrentSiegeTime();
	unsigned char cNowEventTime = CGameTimeMgr::GetInstance().GetCurrentEventTime();

	// ÆÄÀ̽ĺ° ·ê ¼³Á¤
	switch (CServerSetup::GetInstance().GetServerZone())
	{
		case SERVER_ID::CAPITAL :
		{
			// ÄÁÅÙÃ÷ : °ø¼ºÀü
			if (true == CServerSetup::GetInstance().UseContents(GameRYL::SIEGE))
			{
				if (CGameTimeMgr::GetInstance().IsGuildWarTime())
				{
					EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_GUILD_WAR ) ;
				}
				else if (CGameTimeMgr::GetInstance().IsSiegeWarTime())
				{
					EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_SIEGE_WAR ) ;
				}
				else
				{
					EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_REALM_WAR ) ;
				}
			}
			else
			{
				if (CGameTimeMgr::GetInstance().IsGuildWarTime())
				{
					EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_GUILD_WAR ) ;
				}
				else
				{
					EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_REALM_WAR ) ;
				}
			}
		}
		break;

		case SERVER_ID::STONE_WAR1 :
		case SERVER_ID::STONE_WAR2 :
		case SERVER_ID::STONE_WAR3 :
		{
			if (true == CServerSetup::GetInstance().UseContents(GameRYL::STONE_BATTLE))
			{
				if (CGameTimeMgr::GetInstance().IsRealmWarTime())
				{
					EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_STATUE_WAR ) ;
				}
				else
				{
					EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_REALM_WAR ) ;
				}
			}
			else
			{
				EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_REALM_WAR ) ;
			}
		}
		break ;

		case SERVER_ID::ZONE12:
		{
			EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_REALM_WAR ) ;
		}
		break ;

		case SERVER_ID::ZONE1:
		case SERVER_ID::ZONE2:
		case SERVER_ID::ZONE4:
		case SERVER_ID::ZONE5:
		{
			EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_HUNTING ) ;
		}
		break ;

		default :
		{
			EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_REALM_WAR ) ;
//			EnemyCheck::CCheckTable::GetInstance().SetEnemyCheckRule( EnemyCheck::RULE_HUNTING ) ;
		}
		break ;
	}

	// ±æµåÀü ½Ã°£ÀÌ ³¡³­ °æ¿ì ¿ùµå¿þÆù Æı«Á¤º¸ °»½Å
	if (GameTime::TYPE_CHANGE_GAME_TIME == cType &&
		CGameTimeMgr::GetInstance().IsGuildWarTime(cOldGuildTime) && !CGameTimeMgr::GetInstance().IsGuildWarTime())
	{
		CSiegeObjectMgr::GetInstance().DecreaseWeaponRemainSiegeTime();
	}

    // °ø¼ºÀüÀÌ ³¡³­ °æ¿ì 
	if (GameTime::TYPE_CHANGE_GAME_TIME == cType &&
		CGameTimeMgr::GetInstance().IsSiegeWarTime(cOldSiegeTime) && !CGameTimeMgr::GetInstance().IsSiegeWarTime())
	{
		// ¼º ¼ö¼º º´±â¸¦ º´±â °ü¸® NPC ·Î ¹Ù²Û´Ù.
		CCastleMgr::GetInstance().DestroyAllCastleArms();

		// ¼º ¼¼À² º¯°æ °¡´É Á¤º¸ °»½Å
		CCastleMgr::GetInstance().EnableTaxChange();
	}

	// Ŭ¶óÀ̾ðÆ®¿¡°Ô Àü¼Û
	char* szPacket = reinterpret_cast<char *>(lpPktGTI);
	if (PacketWrap::WrapCrypt(szPacket, wSize, CmdGameTimeInfo, 0, 0))
	{
		CCreatureManager::GetInstance().SendAllCharacter(szPacket, wSize, CmdGameTimeInfo);
	}

	// Instance On ÀÎ °æ¿ì Ç÷¡±× ²¨ÁÖ±â
	if (cType == GameTime::TYPE_CHANGE_GAME_TIME)
	{
		if (!CGameTimeMgr::GetInstance().IsGuildWarTime())
		{
			CCreatureManager::GetInstance().ClearGuildWarInstanceFlag();
		}

		// ÄÁÅÙÃ÷ : ´ÙÅ© Ä«³ª¹ø ±¹°¡ ÀüÀï
		if (true == CServerSetup::GetInstance().UseContents(GameRYL::STONE_BATTLE))
		{
			if (!CGameTimeMgr::GetInstance().IsRealmWarReadyTime() &&
				!CGameTimeMgr::GetInstance().IsRealmWarTime())
			{
				CCreatureManager::GetInstance().ClearRealmWarInstanceFlag();
			}
		}
	}

	if (cType == GameTime::TYPE_CHANGE_GAME_TIME)
	{

		// ±æµåÀüÀÌ ½ÇÇàµÇ¸é °­Á¦·Î À̵¿ÇÏ°Ô ÇÏ´Â ·ÎÁ÷ ÀÌ°Ô ¿ø¼Ò½º¿¡¼­ »ç¿ëµÆ´Ù.
		if (bGuildUpdated && cOldGuildTime != cNowGuildTime && GameTime::GT_GUILD_WAR == cNowGuildTime)
		{
			// Á¸À̵¿ÀÌ ÇÊ¿äÇÑ °æ¿ì Á¸À̵¿ ó¸®
			CCreatureManager::GetInstance().MoveCharacterToGuildWarZone(GameTime::GUILD);
		}

		// ÄÁÅÙÃ÷ : ´ÙÅ© Ä«³ª¹ø ±¹°¡ ÀüÀï
		if (true == CServerSetup::GetInstance().UseContents(GameRYL::STONE_BATTLE))
		{
			if (bRealmUpdated && cOldRealmTime != cNowRealmTime && GameTime::RT_PREPARE_START_10 == cNowRealmTime)
			{
				// Á¸À̵¿ÀÌ ÇÊ¿äÇÑ °æ¿ì Á¸À̵¿ ó¸®
				CCreatureManager::GetInstance().MoveCharacterToRealmWarZone(GameTime::REALM);
			}

			if (bRealmUpdated && cOldRealmTime != cNowRealmTime && GameTime::RT_REALM_WAR == cNowRealmTime &&
				(SERVER_ID::STONE_WAR1 <= CServerSetup::GetInstance().GetServerZone() && CServerSetup::GetInstance().GetServerZone() <= SERVER_ID::STONE_WAR3))
			{
				// Á¸À̵¿ÀÌ ÇÊ¿äÇÑ °æ¿ì Á¸À̵¿ ó¸®
				CCreatureManager::GetInstance().MoveCharacterToRealmWarZone(GameTime::REALM, false);
			}
		}
	}

	// ÄÁÅÙÃ÷ : ´ÙÅ© Ä«³ª¹ø ±¹°¡ ÀüÀï
	if (true == CServerSetup::GetInstance().UseContents(GameRYL::STONE_BATTLE))
	{
		if (SERVER_ID::STONE_WAR1 <= CServerSetup::GetInstance().GetServerZone() && CServerSetup::GetInstance().GetServerZone() <= SERVER_ID::STONE_WAR3)
		{
			// ´ÙÅ© Ä«³ª¹ø¿¡ ±¹°¡ÀüÀï ½Ã°£¿¡¸¸ °øÇåÈÆÀå È¿°ú¸¦ Àû¿ëÇÑ´Ù.
			if (GameTime::TYPE_CHANGE_GAME_TIME == cType)
			{
				if (CGameTimeMgr::GetInstance().IsRealmWarReadyTime(cOldRealmTime) && CGameTimeMgr::GetInstance().IsRealmWarTime())
				{
					// ÀÎþƮ¿¡ °øÇåÈÆÀå È¿°ú Ãß°¡.
					CCreatureManager::GetInstance().ProcessAllCharacter(RealmSkill::RealmInchantAdd);
				}
				else if (CGameTimeMgr::GetInstance().IsRealmWarTime(cOldRealmTime) && !CGameTimeMgr::GetInstance().IsRealmWarTime())
				{
					// ÀÎþƮ¿¡ °øÇåÈÆÀå È¿°ú »èÁ¦.
					CCreatureManager::GetInstance().ProcessAllCharacter(RealmSkill::RealmInchantRemove);
				}
			}

			// ´ÙÅ© Ä«³ª¹ø¿¡ ±¹°¡ ÀüÀï 10ºÐ Àü¿¡ ¼®»ó ÃʱâÈ­
			if (cOldRealmTime != cNowRealmTime && GameTime::RT_PREPARE_START_10 == cNowRealmTime)
			{
				SERLOG0(g_Log, "±¹°¡ ÀüÀï ½Ã°£ 10ºÐ ÀüÀ̹ǷΠ¼®»ó Á¤º¸¸¦ ÃʱâÈ­ ÇÕ´Ï´Ù.");
				CCreatureManager::GetInstance().InitRealmStatue();

				// ¶óÁö¸Ê Ç¥½Ã Á¤º¸ º¸³»±â
				CCreatureManager::GetInstance().SendRealmStatueDisplayInfo();

				// ¼®»ó ÀÎæƮ È¿°ú Á¤º¸¸¦ °è»êÇÑ´Ù.
				CCreatureManager::GetInstance().CalculateRealmStatueEnchantInfo();

				// edith 2008.06.04 ÀÎþƮ°¡ ±¹°¡ ÀüÀï½Ã 2½Ã°£ Â¥¸®·Î °É¸®±â ¶§¹®¿¡ Á¦¿Ü
				// ±¹°¡ ÀüÀï ¼®»ó ÀÎæƮ Á¦°Å
//				CCreatureManager::GetInstance().ClearRealmStatueEnchant();
			}

			// ´ÙÅ© Ä«³ª¹ø¿¡ ±¹°¡ ÀüÀï Á¾·á½Ã ·ÎµùÁßÀÎ ¼®»ó Á߸³È­
			if (CGameTimeMgr::GetInstance().IsRealmWarTime(cOldRealmTime) && !CGameTimeMgr::GetInstance().IsRealmWarTime())
			{
				SERLOG0(g_Log, "±¹°¡ ÀüÀï ½Ã°£ÀÌ Á¾·áµÇ¾úÀ¸¹Ç·Î ¼ÒȯÁßÀÎ ¼®»óÀ» Á߸³È­ ÇÕ´Ï´Ù.");
				CCreatureManager::GetInstance().InitRealmLoadingStatue();

				// ¶óÁö¸Ê Ç¥½Ã Á¤º¸ º¸³»±â
				CCreatureManager::GetInstance().SendRealmStatueDisplayInfo();

				// ¼®»ó ÀÎæƮ È¿°ú Á¤º¸¸¦ °è»êÇÑ´Ù.
				CCreatureManager::GetInstance().CalculateRealmStatueEnchantInfo();

				// ±¹°¡ ÀüÀï ¼®»ó ÀÎæƮ ÄÑÁÖ±â
				// edith 2008.06.04 ÀÎþƮ°¡ ±¹°¡ ÀüÀï½Ã 2½Ã°£ Â¥¸®·Î °É¸®±â
				// ¼®»óÀüÀÌ Á¾·áÇßÀ¸´Ï 2½Ã°£ Â¥¸® ¹öÇÁ¸¦ °É¾îÁØ´Ù.
				CCreatureManager::GetInstance().AddRealmStatueEnchant();
			}
		}
	}
/*
	// edith 2008.06.03 ÀÌ°Å ¹®Á¦°¡ ÀÖÁö¾Ê¾Æ??
	// °ø¼±Àü ÄÁÅÙÃ÷´Â ¼®»óÀü¿ë ¸Æ°ú ºÐ¸®°¡ µÆ±â¶§¹®¿¡ ¾Æ·¡ ·ÎÁ÷Àº ÇÊ¿ä°¡ ¾ø´Ù.
	// ÄÁÅÙÃ÷ : °ø¼ºÀü
	if (true == CServerSetup::GetInstance().UseContents(GameRYL::SIEGE))
	{
		if (SERVER_ID::CAPITAL == CServerSetup::GetInstance().GetServerZone())
		{
			// ´ÙÅ© Ä«³ª¹ø °ø¼ºÀü ½ÃÀÛ½Ã
			if (!CGameTimeMgr::GetInstance().IsSiegeWarTime(cOldSiegeTime) && CGameTimeMgr::GetInstance().IsSiegeWarTime())
			{
				// ¼®»ó ÀÎæƮ È¿°ú Á¤º¸¸¦ °è»êÇÑ´Ù.
				CCreatureManager::GetInstance().CalculateRealmStatueEnchantInfo();

				// edith 2008.06.04 ÀÎþƮ°¡ ±¹°¡ ÀüÀï½Ã 2½Ã°£ Â¥¸®·Î °É¸®±â ¶§¹®¿¡ Á¦¿Ü
				// ±¹°¡ ÀüÀï ¼®»ó ÀÎæƮ Á¦°Å
				CCreatureManager::GetInstance().ClearRealmStatueEnchant();
			}

			// ´ÙÅ© Ä«³ª¹ø¿¡ °ø¼ºÀü Á¾·á½Ã
			if (CGameTimeMgr::GetInstance().IsSiegeWarTime(cOldSiegeTime) && !CGameTimeMgr::GetInstance().IsSiegeWarTime())
			{
				// ¼®»ó ÀÎæƮ È¿°ú Á¤º¸¸¦ °è»êÇÑ´Ù.
				CCreatureManager::GetInstance().CalculateRealmStatueEnchantInfo();

				// ±¹°¡ ÀüÀï ¼®»ó ÀÎæƮ ÄÑÁÖ±â
				CCreatureManager::GetInstance().AddRealmStatueEnchant();
			}
		}
	}
*/
	// Ä«³ª¹øÀÏ °æ¿ì. °ø¼ºÃøÀº ¸®½ºÆù Áö¿ªÀ¸·Î À̵¿½ÃŲ´Ù //			
	if(CServerSetup::GetInstance().GetServerZone() == SERVER_ID::CAPITAL)
	{
		if(cType==GameTime::TYPE_CHANGE_GAME_TIME)
		{
			if((CGameTimeMgr::GetInstance().IsSiegeWarTime(cOldSiegeTime) && !CGameTimeMgr::GetInstance().IsSiegeWarTime()) || cNowSiegeTime==GameTime::ST_SIEGE_WAR)
			{
				CCreatureManager::GetInstance().ProcessAllCharacter(SiegeMovePos);
			}
		}		
	}

	return true;
}

// ¼º Àӽà ¼¼±Ý -> ´©Àû ¼¼±Ý À̵¿ Á¤º¸ ¾÷µ¥ÀÌÆ®
bool DBAgentPacketParse::ParseCastleTaxMove(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCastleTaxMove* lpPktCTM = static_cast<PktCastleTaxMove*>(lpPktBase);

	CCastle* lpCastle = CCastleMgr::GetInstance().GetCastle(lpPktCTM->m_dwCastleID);
	if (lpCastle)
	{
		lpCastle->UpdateTaxMoveInfo(lpPktCTM->m_dwMoveTempMoney, lpPktCTM->m_dwResultTaxMoney);
	}

	return true;
}

// °ø¼º ½Ã°£ ÈÄ ¼ºÀÇ ³²Àº °ø¼º Ƚ¼ö Á¤º¸ ¾÷µ¥ÀÌÆ®
bool DBAgentPacketParse::ParseCastleSiegeCount(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCastleSiegeCount* lpPktCSC = static_cast<PktCastleSiegeCount*>(lpPktBase);

	CCastle* lpCastle = CCastleMgr::GetInstance().GetCastle(lpPktCSC->m_dwCastleID);
	if (lpCastle)
	{
		lpCastle->UpdateSiegeCountInfo(lpPktCSC->m_cSiegeCount, lpPktCSC->m_cInvincibleCount, lpPktCSC->m_wTotalSiegeCount);
	}

	return true;
}

// ±æµå ¿ä»õ °ü·Ã ¸Þ¼¼Áö ÆÐŶ Àü¼Û
bool DBAgentPacketParse::ParseCampMessage(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktCampMessage* lpPktCM = static_cast<PktCampMessage*>(lpPktBase);

	bool			bNotify = lpPktCM->m_bNotify;
	unsigned long	dwGID = lpPktCM->m_dwGID;
	
	char* szPacket = reinterpret_cast<char *>(lpPktCM);
	if (PacketWrap::WrapCrypt(szPacket, sizeof(PktCampMessage), CmdCampMessage, 0, 0))
	{
        if (bNotify)
		{
			CCreatureManager::GetInstance().SendAllCharacter(szPacket, sizeof(PktCampMessage), CmdCampMessage);
		}
		else
		{
			Guild::CGuild* lpGuild = Guild::CGuildMgr::GetInstance().GetGuild( dwGID );
			if ( lpGuild )
			{
				lpGuild->SendCurrentMember(szPacket, sizeof(PktCampMessage), CmdCampMessage);
			}
		}
	}

	return true;
}

// ä±¼±â ÇÁ·Î¼¼½º ½ÇÇà
bool DBAgentPacketParse::ParseProcessMining(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	// °ÔÀÓÀÌ µÇ´Â Á¸ ¼­¹ö¿¡¼­¸¸ °¡´ÉÇÏ´Ù.
	char cZone = CServerSetup::GetInstance().GetServerZone();
	if (SERVER_ID::CAPITAL == cZone)
	{
		PktProcessMining* lpPktPM = static_cast<PktProcessMining*>(lpPktBase);
		unsigned long dwProcessType = lpPktPM->m_dwProcessType;

		// ä±¼±â ÇÁ·Î¼¼½º ½ÇÇà
		CSiegeObjectMgr::GetInstance().ProcessMiningCamp( dwProcessType );
	}

	return true;
}

// ±æµåÀü, ±¹°¡Àü Ç÷¡±× ó¸®
bool DBAgentPacketParse::ParseWarOnOff(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	// Game -> DB·Î ¹ÞÀ½.
	PktWarOnOff* lpPktWarOnOff = static_cast<PktWarOnOff*>(lpPktBase);
	unsigned long	dwCID	= lpPktWarOnOff->m_dwCID;
	unsigned char	cType	= lpPktWarOnOff->m_cType;
	unsigned char	cFlag	= lpPktWarOnOff->m_cFlag;
	unsigned short	wError	= PktWarOnOff::NO_SERVER_ERR;

	CCharacter* lpCharacter = CCreatureManager::GetInstance().GetCharacter(dwCID);
	if (NULL != lpCharacter)
	{
		if (GameTime::GUILD == cType)
		{
			switch (cFlag)
			{
				case Creature::WAR_OFF:			lpCharacter->SetGuildWarFlag(cFlag);	break;
				case Creature::WAR_ON:			lpCharacter->SetGuildWarFlag(cFlag);	break;
				case Creature::WAR_INSTANCE:	lpCharacter->SetGuildWarFlag(cFlag);	break;
				default:	return true;
			}
		}
		else if (GameTime::REALM == cType)
		{
			switch (cFlag)
			{
				case Creature::WAR_OFF:			lpCharacter->SetRealmWarFlag(cFlag);	break;
				case Creature::WAR_ON:			lpCharacter->SetRealmWarFlag(cFlag);	break;
				case Creature::WAR_INSTANCE:	lpCharacter->SetRealmWarFlag(cFlag);	break;
				default:	return true;
			}
		}
		else
		{
			wError = PktWarOnOff::E_INVALID_TYPE;	
		}

		CGameClientDispatch* lpDispatch = lpCharacter->GetDispatcher();
		
		if (NULL != lpDispatch)
		{
			GameClientSendPacket::SendWarOnOff(lpDispatch->GetSendStream(), lpCharacter->GetCID(), cType, cFlag, wError);

			if (GameTime::GUILD == cType)
			{
				if (CServerSetup::GetInstance().GetServerZone() != SERVER_ID::CAPITAL)
				{
					// Âü°¡ ¹öÆ° Ŭ¸¯À¸·Î ÀνºÅϽº°¡ µÇ¸é Á¸ À̵¿
					if (CGameTimeMgr::GetInstance().IsGuildWarTime() &&	lpCharacter->GetGuildWarFlag() != Creature::WAR_OFF)
					{
						lpCharacter->MoveToGuildWarZone();
					}								
				}
			}
			else if (GameTime::REALM == cType)
			{
				if ((CGameTimeMgr::GetInstance().IsRealmWarReadyTime() || CGameTimeMgr::GetInstance().IsRealmWarTime()) &&
					lpCharacter->GetRealmWarFlag() == Creature::WAR_INSTANCE)
				{
					lpCharacter->MoveToRealmWarZone();
				}
			}
		}
	}

	return true;
}

bool DBAgentPacketParse::ParseRealmPoint(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktRealmPoint* lpPktRealmPoint = static_cast<PktRealmPoint*>(lpPktBase);

	unsigned char cRealmPoint	= lpPktRealmPoint->m_cRealmPoint;
	unsigned long dwCID			= lpPktRealmPoint->m_dwCID;
	unsigned char cType			= lpPktRealmPoint->m_cType;

	CCharacter* lpCharacter = CCreatureManager::GetInstance().GetCharacter(dwCID);

	if(lpCharacter)
	{
		lpCharacter->SetRealmPoint(cRealmPoint);

		CGameClientDispatch* lpDispatch = lpCharacter->GetDispatcher();
		
		if(lpDispatch)
		{
			GameClientSendPacket::SendRealmPoint(lpDispatch->GetSendStream(), dwCID, cRealmPoint, cType, 0);

			return true;
		}
	}
	return false;	
}


bool DBAgentPacketParse::ParseStatueCmd(CDBAgentDispatch& DBAgentDispatch, PktBase* lpPktBase)
{
	PktStatueCmd* lpPktStatueCmd = static_cast<PktStatueCmd*>(lpPktBase);

	unsigned short wSubCmd = lpPktStatueCmd->m_wSubCmd;
	unsigned short wSize = lpPktStatueCmd->m_wSize;
	unsigned long dwValue = lpPktStatueCmd->m_dwValue;

	switch (wSubCmd)
	{
		case PktStatueCmd::CMD_INFO:
			{
				// ÄÁÅÙÃ÷ : ´ÙÅ© Ä«³ª¹ø ±¹°¡ ÀüÀï
				if (true == CServerSetup::GetInstance().UseContents(GameRYL::STONE_BATTLE))
				{
					StatueInfo* lpStatueInfo = reinterpret_cast<StatueInfo*>(lpPktStatueCmd + 1);
					for (unsigned long i=0; i<dwValue; ++i, ++lpStatueInfo)
					{
						CCreatureManager::GetInstance().SetRealmStatueInfo(lpStatueInfo->m_dwIndex, lpStatueInfo->m_wKID, lpStatueInfo->m_dwLostHP);
					}

					// ¼®»ó¿¡ ÀÇÇÑ ÀÎæµå °ªÀ» °è»êÇÑ´Ù. ( ¼ºÀÇ ÀÇÇÑ º¸³Ê½º±îÁö °è»êÇÑ´Ù. )
					CCreatureManager::GetInstance().CalculateRealmStatueEnchantInfo();
				}
/*
				// ÄÁÅÙÃ÷ : ½Å±ÔÁ¸
				else if (true == CServerSetup::GetInstance().UseContents(GameRYL::NEWZONE_ZONE9))
				{
					StatueInfo* lpStatueInfo = reinterpret_cast<StatueInfo*>(lpPktStatueCmd + 1);
					for (unsigned long i=0; i<dwValue; ++i, ++lpStatueInfo)
					{
						CCreatureManager::GetInstance().SetRealmStatueInfo(lpStatueInfo->m_dwIndex, lpStatueInfo->m_wKID, lpStatueInfo->m_dwLostHP);
					}
				}
*/
			}
			break;

		case PktStatueCmd::CMD_UPDATE_LOST_HP:
		case PktStatueCmd::CMD_UPDATE_KID:
		default:
			return false;
			break;
	}

	return true;
}

void DBAgentPacketParse::SiegeMovePos(CCharacter* pCharacter)
{
	if(!pCharacter)
	{
		return;
	}

	if(pCharacter->IsRideArms())
	{
		return;
	}

	unsigned char cNation = Castle::CCastleMgr::GetInstance().GetNation();

	Position Pos;

	float fPosX = static_cast<float>(Math::Random::ComplexRandom(6));
	float fPosZ = static_cast<float>(Math::Random::ComplexRandom(6));

	if(cNation!=pCharacter->GetNation())
	{
		const Position currPos = pCharacter->GetCurrentPos();

		if(currPos.m_fPointX>=1890 && currPos.m_fPointX<=2205 &&
			currPos.m_fPointZ>=2835 && currPos.m_fPointZ<=3150)
		{
			if(cNation==Creature::MERKADIA)
			{
				Pos.m_fPointX = 1094.0f + fPosX;
				Pos.m_fPointY = 70.0f;
				Pos.m_fPointZ = 2594.0f + fPosZ;
			}
			else
			{
				Pos.m_fPointX = 3294.0f + fPosX;
				Pos.m_fPointY = 70.0f;
				Pos.m_fPointZ = 2994.0f + fPosZ;
			}

			pCharacter->MoveTo(Pos, false);

			POS sendPos;
			sendPos.fPointX = Pos.m_fPointX;
			sendPos.fPointY = Pos.m_fPointY;
			sendPos.fPointZ = Pos.m_fPointZ;

			GameClientSendPacket::SendCharBindPosition(*pCharacter, 0, PktBP::BP_WARP, sendPos, CServerSetup::GetInstance().GetServerZone(), 0);
		}
	}	
}