Solution refactoring and restructuring, removed Boost dependency, removed unused tools

src/UserInterface/AbstractApplication.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "AbstractSingleton.h"
+
+class IAbstractApplication : public TAbstractSingleton<IAbstractApplication>
+{
+	public:
+		struct SCameraPos
+		{
+			float m_fUpDir;
+			float m_fViewDir;
+			float m_fCrossDir;
+
+			SCameraPos() : m_fUpDir(0.0f), m_fViewDir(0.0f), m_fCrossDir(0.0f) {}
+		};
+
+		struct SCameraSetting
+		{
+			D3DXVECTOR3				v3CenterPosition;
+			SCameraPos				kCmrPos;
+			float					fRotation;
+			float					fPitch;
+			float					fZoom;
+
+			SCameraSetting() :	v3CenterPosition(0.0f, 0.0f, 0.0f),
+								fRotation(0.0f),
+								fPitch(0.0f),
+								fZoom(0.0f) {}
+		};
+
+	public:
+		IAbstractApplication() {}
+		virtual ~IAbstractApplication() {}
+
+		virtual void GetMousePosition(POINT* ppt) = 0;
+		virtual float GetGlobalTime() = 0;
+		virtual float GetGlobalElapsedTime() = 0;
+
+		virtual void SkipRenderBuffering(DWORD dwSleepMSec) = 0;
+		virtual void SetServerTime(time_t tTime) = 0;
+		virtual void SetCenterPosition(float fx, float fy, float fz) = 0;
+
+		virtual void SetEventCamera(const SCameraSetting & c_rCameraSetting) = 0;
+		virtual void BlendEventCamera(const SCameraSetting & c_rCameraSetting, float fBlendTime) = 0;
+		virtual void SetDefaultCamera() = 0;
+
+		virtual void RunIMEUpdate() = 0;
+		virtual void RunIMETabEvent() = 0;
+		virtual void RunIMEReturnEvent() = 0;
+
+		virtual void RunIMEChangeCodePage() = 0;
+		virtual void RunIMEOpenCandidateListEvent() = 0;
+		virtual void RunIMECloseCandidateListEvent() = 0;
+		virtual void RunIMEOpenReadingWndEvent() = 0;
+		virtual void RunIMECloseReadingWndEvent() = 0;
+};

src/UserInterface/AbstractCharacterManager.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "AbstractSingleton.h"
+
+class CInstanceBase;
+
+class IAbstractCharacterManager : public TAbstractSingleton<IAbstractCharacterManager>
+{
+	public:
+		IAbstractCharacterManager() {}
+		virtual ~IAbstractCharacterManager() {}
+
+		virtual void Destroy() = 0;
+		virtual CInstanceBase *						GetInstancePtr(DWORD dwVID) = 0;
+};

src/UserInterface/AbstractChat.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "AbstractSingleton.h"
+
+class IAbstractChat : public TAbstractSingleton<IAbstractChat>
+{
+	public:
+		IAbstractChat() {}
+		virtual ~IAbstractChat() {}
+
+		virtual void AppendChat(int iType, const char * c_szChat) = 0;
+};

src/UserInterface/AbstractPlayer.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "AbstractSingleton.h"
+
+class CInstanceBase;
+
+class IAbstractPlayer : public TAbstractSingleton<IAbstractPlayer>
+{
+	public:
+		IAbstractPlayer() {}
+		virtual ~IAbstractPlayer() {}
+
+		virtual DWORD	GetMainCharacterIndex() = 0;
+		virtual void	SetMainCharacterIndex(int iIndex) = 0;
+		virtual bool	IsMainCharacterIndex(DWORD dwIndex) = 0;
+
+		virtual int		GetStatus(DWORD dwType) = 0;
+
+		virtual const char *	GetName() = 0;
+
+		virtual void	SetRace(DWORD dwRace) = 0;
+
+		virtual void	StartStaminaConsume(DWORD dwConsumePerSec, DWORD dwCurrentStamina) = 0;
+		virtual void	StopStaminaConsume(DWORD dwCurrentStamina) = 0;		
+
+		virtual bool	IsPartyMemberByVID(DWORD dwVID) = 0;		
+		virtual bool	PartyMemberVIDToPID(DWORD dwVID, DWORD * pdwPID) = 0;
+		virtual bool	IsSamePartyMember(DWORD dwVID1, DWORD dwVID2) = 0;
+
+		virtual void	SetItemData(TItemPos itemPos, const TItemData & c_rkItemInst) = 0;
+		virtual void	SetItemCount(TItemPos itemPos, BYTE byCount) = 0;
+		virtual void	SetItemMetinSocket(TItemPos itemPos, DWORD dwMetinSocketIndex, DWORD dwMetinNumber) = 0;
+		virtual void	SetItemAttribute(TItemPos itemPos, DWORD dwAttrIndex, BYTE byType, short sValue) = 0;
+#if defined(GAIDEN)
+		virtual void	SetItemUnbindTime(DWORD dwItemSlotIndex, DWORD dwUnbindSecondsLeft) = 0;
+#endif
+
+		virtual DWORD	GetItemIndex(TItemPos itemPos) = 0;
+		virtual DWORD	GetItemFlags(TItemPos itemPos) = 0;
+		virtual DWORD	GetItemCount(TItemPos itemPos) = 0;
+
+		virtual bool	IsEquipItemInSlot(TItemPos itemPos) = 0;
+
+		virtual void	AddQuickSlot(int QuickslotIndex, char IconType, char IconPosition) = 0;
+		virtual void	DeleteQuickSlot(int QuickslotIndex) = 0;
+		virtual void	MoveQuickSlot(int Source, int Target) = 0;
+
+		virtual void	SetWeaponPower(DWORD dwMinPower, DWORD dwMaxPower, DWORD dwMinMagicPower, DWORD dwMaxMagicPower, DWORD dwAddPower) = 0;
+
+		virtual void	SetTarget(DWORD dwVID, BOOL bForceChange = TRUE) = 0;
+		virtual void	NotifyCharacterUpdate(DWORD dwVID) = 0;		
+		virtual void	NotifyCharacterDead(DWORD dwVID) = 0;
+		virtual void	NotifyDeletingCharacterInstance(DWORD dwVID) = 0;
+		virtual void	NotifyChangePKMode() = 0;
+				
+		virtual void	SetObserverMode(bool isEnable) = 0;
+		virtual void	SetMobileFlag(BOOL bFlag) = 0;
+		virtual void	SetComboSkillFlag(BOOL bFlag) = 0;
+
+		virtual void	StartEmotionProcess() = 0;
+		virtual void	EndEmotionProcess() = 0;
+
+		virtual CInstanceBase* NEW_GetMainActorPtr() = 0;
+};
+

src/UserInterface/AbstractSingleton.h

@@ -0,0 +1,29 @@
+#pragma once
+
+template <typename T> 
+class TAbstractSingleton
+{ 
+	static T * ms_singleton;
+	
+public: 
+	TAbstractSingleton()
+	{ 
+		assert(!ms_singleton);
+		int offset = (int) (T*) 1 - (int) (CSingleton <T>*) (T*) 1; 
+		ms_singleton = (T*) ((int) this + offset);
+	} 
+
+	virtual ~TAbstractSingleton()
+	{ 
+		assert(ms_singleton);
+		ms_singleton = 0; 
+	}
+
+	__forceinline static T & GetSingleton()
+	{
+		assert(ms_singleton!=NULL);
+		return (*ms_singleton);
+	}	
+};
+
+template <typename T> T * TAbstractSingleton <T>::ms_singleton = 0;

src/UserInterface/AccountConnector.cpp

@@ -0,0 +1,646 @@
+#include "StdAfx.h"
+#include "AccountConnector.h"
+#include "Packet.h"
+#include "PythonNetworkStream.h"
+#include "../EterBase/tea.h"
+#include "../EterPack/EterPackManager.h"
+
+#include "Hackshield.h"
+#include "WiseLogicXTrap.h"
+
+// CHINA_CRYPT_KEY
+extern DWORD g_adwEncryptKey[4];
+extern DWORD g_adwDecryptKey[4];
+// END_OF_CHINA_CRYPT_KEY
+
+#ifdef USE_OPENID
+extern int openid_test;
+#endif
+
+void CAccountConnector::SetHandler(PyObject* poHandler)
+{
+	m_poHandler = poHandler;
+}
+
+void CAccountConnector::SetLoginInfo(const char * c_szName, const char * c_szPwd)
+{
+	m_strID = c_szName;
+	m_strPassword = c_szPwd;
+}
+
+
+void CAccountConnector::ClearLoginInfo( void )
+{
+	m_strPassword = "";
+}
+
+bool CAccountConnector::Connect(const char * c_szAddr, int iPort, const char * c_szAccountAddr, int iAccountPort)
+{
+	m_strAddr = c_szAddr;
+	m_iPort = iPort;
+
+	__OfflineState_Set();
+
+	// CHINA_CRYPT_KEY
+	if (LocaleService_IsYMIR())
+	{
+	}	
+	else
+	{
+		__BuildClientKey_20050304Myevan();		
+	}
+	// END_OF_CHINA_CRYPT_KEY
+
+	return CNetworkStream::Connect(c_szAccountAddr, iAccountPort);
+}
+
+void CAccountConnector::Disconnect()
+{
+	CNetworkStream::Disconnect();
+	__OfflineState_Set();
+}
+
+bool CAccountConnector::SendNEWCIBNPasspodAnswerPacket(const char * answer)
+{
+	TPacketCGNEWCIBNPasspodAnswer answerPacket;
+	answerPacket.bHeader = HEADER_CG_NEWCIBN_PASSPOD_ANSWER;
+	strncpy(answerPacket.szAnswer, answer, NEWCIBN_PASSPOD_ANSWER_MAX_LEN);
+	answerPacket.szAnswer[NEWCIBN_PASSPOD_ANSWER_MAX_LEN] = '\0';	
+	if (!Send(sizeof(answerPacket), &answerPacket))
+	{
+		TraceError("SendNEWCIBNPasspodAnswerPacket");
+		return false;
+	}
+	return SendSequence();
+}
+
+bool CAccountConnector::SendRunupMatrixCardPacket(const char * c_szMatrixCardString)
+{
+	TPacketCGRunupMatrixAnswer answerPacket;
+	answerPacket.bHeader = HEADER_CG_RUNUP_MATRIX_ANSWER;
+	strncpy(answerPacket.szAnswer, c_szMatrixCardString, RUNUP_MATRIX_ANSWER_MAX_LEN);
+	answerPacket.szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN] = '\0';
+	if (!Send(sizeof(answerPacket), &answerPacket))
+	{
+		TraceError("SendRunupMatrixCardPacketError");
+		return false;
+	}
+	return SendSequence();
+}
+
+bool CAccountConnector::SendChinaMatrixCardPacket(const char * c_szMatrixCardString)
+{
+	TPacketCGChinaMatrixCard MatrixCardPacket;
+	MatrixCardPacket.bHeader = HEADER_CG_CHINA_MATRIX_CARD;
+	strncpy(MatrixCardPacket.szAnswer, c_szMatrixCardString, CHINA_MATRIX_ANSWER_MAX_LEN);
+	MatrixCardPacket.szAnswer[CHINA_MATRIX_ANSWER_MAX_LEN] = '\0';
+
+	if (!Send(sizeof(MatrixCardPacket), &MatrixCardPacket))
+	{
+		Tracen("SendLogin Error");
+		return false;
+	}
+
+	CPythonNetworkStream::Instance().SetWaitFlag();
+	m_isWaitKey = TRUE;
+
+	return SendSequence();
+}
+
+void CAccountConnector::Process()
+{
+	CNetworkStream::Process();
+
+	if (!__StateProcess())
+	{
+		__OfflineState_Set();
+		Disconnect();
+	}
+}
+
+bool CAccountConnector::__StateProcess()
+{
+	switch (m_eState)
+	{
+		case STATE_HANDSHAKE:
+			return __HandshakeState_Process();
+			break;
+		case STATE_AUTH:
+			return __AuthState_Process();
+			break;
+	}
+
+	return true;
+}
+
+bool CAccountConnector::__HandshakeState_Process()
+{
+	if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CAccountConnector::__AuthState_RecvPhase))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CAccountConnector::__AuthState_RecvHandshake))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CAccountConnector::__AuthState_RecvPing))
+		return false;
+
+	//  TODO :  <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> data serialize & deserialize  <20>۾<EFBFBD><DBBE>ؾ<EFBFBD> <20>Ѵ<EFBFBD>.
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_KEYS, &CAccountConnector::__AuthState_RecvHybridCryptKeys))
+		return false;
+
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_SDB, &CAccountConnector::__AuthState_RecvHybridCryptSDB))
+		return false;
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_Process()
+{
+	if (!__AnalyzePacket(0, sizeof(BYTE), &CAccountConnector::__AuthState_RecvEmpty))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CAccountConnector::__AuthState_RecvPhase))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CAccountConnector::__AuthState_RecvPing))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_AUTH_SUCCESS, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthSuccess))
+		return true;
+
+#ifdef USE_OPENID
+	if (!__AnalyzePacket(HEADER_GC_AUTH_SUCCESS_OPENID, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthSuccess_OpenID))
+		return true;
+#endif /* USE_OPENID */
+
+	if (!__AnalyzePacket(HEADER_GC_LOGIN_FAILURE, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthFailure))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_CHINA_MATRIX_CARD, sizeof(TPacketGCChinaMatrixCard), &CAccountConnector::__AuthState_RecvChinaMatrixCard))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_RUNUP_MATRIX_QUIZ, sizeof(TPacketGCRunupMatrixQuiz), &CAccountConnector::__AuthState_RecvRunupMatrixQuiz))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_NEWCIBN_PASSPOD_REQUEST, sizeof(TPacketGCNEWCIBNPasspodRequest), &CAccountConnector::__AuthState_RecvNEWCIBNPasspodRequest))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CAccountConnector::__AuthState_RecvHandshake))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_PANAMA_PACK, sizeof(TPacketGCPanamaPack), &CAccountConnector::__AuthState_RecvPanamaPack))
+		return false;
+
+	//  TODO :  <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> data serialize & deserialize  <20>۾<EFBFBD><DBBE>ؾ<EFBFBD> <20>Ѵ<EFBFBD>.
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_KEYS, &CAccountConnector::__AuthState_RecvHybridCryptKeys))
+		return false;
+
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_SDB, &CAccountConnector::__AuthState_RecvHybridCryptSDB))
+		return false;
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvEmpty()
+{
+	BYTE byEmpty;
+	Recv(sizeof(BYTE), &byEmpty);
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvPhase()
+{
+	TPacketGCPhase kPacketPhase;
+	if (!Recv(sizeof(kPacketPhase), &kPacketPhase))
+		return false;
+
+	if (kPacketPhase.phase == PHASE_HANDSHAKE)
+	{
+		__HandshakeState_Set();
+	}
+	else if (kPacketPhase.phase == PHASE_AUTH)
+	{
+
+#ifdef USE_OPENID		
+		if (!openid_test)
+		{
+			//2012.07.19 OpenID : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 
+			//Ongoing : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD> <20><><EFBFBD><EFBFBD>-> TPacketCGLogin5
+			//Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>Ű<EFBFBD><C5B0><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+
+			//const char* tempAuthKey = "d4025bc1f752b64fe5d51ae575ec4730"; //<2F>ϵ<EFBFBD><CFB5>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD> 32
+			TPacketCGLogin5 LoginPacket;
+			LoginPacket.header = HEADER_CG_LOGIN5_OPENID;
+
+			strncpy(LoginPacket.authKey, LocaleService_GetOpenIDAuthKey(), OPENID_AUTHKEY_LEN);
+			LoginPacket.authKey[OPENID_AUTHKEY_LEN] = '\0';
+			
+			for (DWORD i = 0; i < 4; ++i)
+				LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
+
+			if (!Send(sizeof(LoginPacket), &LoginPacket))
+			{
+				Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin5 Error");
+				return false;
+			}
+
+			if (!SendSequence())
+			{
+				return false;
+			}
+		}
+		else
+		{
+			TPacketCGLogin3 LoginPacket;
+			LoginPacket.header = HEADER_CG_LOGIN3;
+
+			strncpy(LoginPacket.name, m_strID.c_str(), ID_MAX_NUM);
+			strncpy(LoginPacket.pwd, m_strPassword.c_str(), PASS_MAX_NUM);
+			LoginPacket.name[ID_MAX_NUM] = '\0';
+			LoginPacket.pwd[PASS_MAX_NUM] = '\0';
+
+			// <20><><EFBFBD>й<EFBFBD>ȣ<EFBFBD><C8A3> <20>޸𸮿<DEB8> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>־, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			ClearLoginInfo();
+			CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+			rkNetStream.ClearLoginInfo();
+
+			m_strPassword = "";
+
+			for (DWORD i = 0; i < 4; ++i)
+				LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
+
+			if (!Send(sizeof(LoginPacket), &LoginPacket))
+			{
+				Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin3 Error");
+				return false;
+			}
+
+			if (!SendSequence())
+			{
+				return false;
+			}
+		}
+#else /* USE_OPENID */
+
+#ifdef USE_AHNLAB_HACKSHIELD
+		HackShield_SetUserInfo(m_strID.c_str());
+#endif
+#ifdef XTRAP_CLIENT_ENABLE
+		XTrap_SetUserInfo(m_strID.c_str(), NULL, NULL, NULL, NULL);
+#endif
+
+
+		TPacketCGLogin3 LoginPacket;
+		LoginPacket.header = HEADER_CG_LOGIN3;
+
+		strncpy(LoginPacket.name, m_strID.c_str(), ID_MAX_NUM);
+		strncpy(LoginPacket.pwd, m_strPassword.c_str(), PASS_MAX_NUM);
+		LoginPacket.name[ID_MAX_NUM] = '\0';
+		LoginPacket.pwd[PASS_MAX_NUM] = '\0';
+
+		// <20><><EFBFBD>й<EFBFBD>ȣ<EFBFBD><C8A3> <20>޸𸮿<DEB8> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>־, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+		ClearLoginInfo();
+		CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+		rkNetStream.ClearLoginInfo();
+
+		m_strPassword = "";
+
+		for (DWORD i = 0; i < 4; ++i)
+			LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
+
+		if (!Send(sizeof(LoginPacket), &LoginPacket))
+		{
+			Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin3 Error");
+			return false;
+		}
+
+		if (!SendSequence())
+		{
+			return false;
+		}
+#endif /* USE_OPENID */
+
+		__AuthState_Set();
+	}
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvHandshake()
+{
+	TPacketGCHandshake kPacketHandshake;
+	if (!Recv(sizeof(kPacketHandshake), &kPacketHandshake))
+		return false;
+
+	// HandShake
+	{
+		Tracenf("HANDSHAKE RECV %u %d", kPacketHandshake.dwTime, kPacketHandshake.lDelta);
+
+		ELTimer_SetServerMSec(kPacketHandshake.dwTime+ kPacketHandshake.lDelta);
+
+		//DWORD dwBaseServerTime = kPacketHandshake.dwTime+ kPacketHandshake.lDelta;
+		//DWORD dwBaseClientTime = ELTimer_GetMSec();
+
+		kPacketHandshake.dwTime = kPacketHandshake.dwTime + kPacketHandshake.lDelta + kPacketHandshake.lDelta;
+		kPacketHandshake.lDelta = 0;
+
+		Tracenf("HANDSHAKE SEND %u", kPacketHandshake.dwTime);
+
+		if (!Send(sizeof(kPacketHandshake), &kPacketHandshake))
+		{
+			Tracen(" CAccountConnector::__AuthState_RecvHandshake - SendHandshake Error");
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvPanamaPack()
+{
+	TPacketGCPanamaPack kPacket;
+
+	if (!Recv(sizeof(TPacketGCPanamaPack), &kPacket))
+		return false;
+
+	CEterPackManager::instance().RegisterPack(kPacket.szPackName, "*", kPacket.abIV);
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvHybridCryptKeys(int iTotalSize)
+{
+	int iFixedHeaderSize = TPacketGCHybridCryptKeys::GetFixedHeaderSize();
+	
+	TPacketGCHybridCryptKeys kPacket(iTotalSize-iFixedHeaderSize);
+
+	if (!Recv(iFixedHeaderSize, &kPacket))
+		return false;
+
+	if (!Recv(kPacket.iKeyStreamLen, kPacket.m_pStream))
+		return false;
+
+	CEterPackManager::Instance().RetrieveHybridCryptPackKeys( kPacket.m_pStream ); 
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvHybridCryptSDB(int iTotalSize)
+{
+	int iFixedHeaderSize = TPacketGCHybridSDB::GetFixedHeaderSize();
+
+	TPacketGCHybridSDB kPacket(iTotalSize-iFixedHeaderSize);
+
+	if (!Recv(iFixedHeaderSize, &kPacket))
+		return false;
+
+	if (!Recv(kPacket.iSDBStreamLen, kPacket.m_pStream))
+		return false;
+
+	CEterPackManager::Instance().RetrieveHybridCryptPackSDB( kPacket.m_pStream ); 
+	return true;
+}
+
+
+bool CAccountConnector::__AuthState_RecvPing()
+{
+	TPacketGCPing kPacketPing;
+	if (!Recv(sizeof(kPacketPing), &kPacketPing))
+		return false;
+
+	__AuthState_SendPong();
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_SendPong()
+{
+	TPacketCGPong kPacketPong;
+	kPacketPong.bHeader = HEADER_CG_PONG;
+	if (!Send(sizeof(kPacketPong), &kPacketPong))
+		return false;
+
+	return SendSequence();
+}
+
+bool CAccountConnector::__AuthState_RecvAuthSuccess()
+{
+	TPacketGCAuthSuccess kAuthSuccessPacket;
+	if (!Recv(sizeof(kAuthSuccessPacket), &kAuthSuccessPacket))
+		return false;
+
+	if (!kAuthSuccessPacket.bResult)
+	{
+		if (m_poHandler)
+			PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", "BESAMEKEY"));
+	}
+	else
+	{
+		DWORD dwPanamaKey = kAuthSuccessPacket.dwLoginKey ^ g_adwEncryptKey[0] ^ g_adwEncryptKey[1] ^ g_adwEncryptKey[2] ^ g_adwEncryptKey[3];
+		CEterPackManager::instance().DecryptPackIV(dwPanamaKey);
+
+		CPythonNetworkStream & rkNet = CPythonNetworkStream::Instance();
+		rkNet.SetLoginKey(kAuthSuccessPacket.dwLoginKey);
+		rkNet.Connect(m_strAddr.c_str(), m_iPort);
+	}
+
+	Disconnect();
+	__OfflineState_Set();
+
+	return true;
+}
+
+#ifdef USE_OPENID
+bool CAccountConnector::__AuthState_RecvAuthSuccess_OpenID()
+{
+	TPacketGCAuthSuccessOpenID kAuthSuccessOpenIDPacket;
+	if (!Recv(sizeof(kAuthSuccessOpenIDPacket), &kAuthSuccessOpenIDPacket))
+		return false;
+
+	if (!kAuthSuccessOpenIDPacket.bResult)
+	{
+		if (m_poHandler)
+			PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", "BESAMEKEY"));
+	}
+	else
+	{
+		DWORD dwPanamaKey = kAuthSuccessOpenIDPacket.dwLoginKey ^ g_adwEncryptKey[0] ^ g_adwEncryptKey[1] ^ g_adwEncryptKey[2] ^ g_adwEncryptKey[3];
+		CEterPackManager::instance().DecryptPackIV(dwPanamaKey);
+
+		CPythonNetworkStream & rkNet = CPythonNetworkStream::Instance();
+		rkNet.SetLoginInfo(kAuthSuccessOpenIDPacket.login, "0000");		//OpenID <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>й<EFBFBD>ȣ<EFBFBD><C8A3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
+		rkNet.SetLoginKey(kAuthSuccessOpenIDPacket.dwLoginKey);
+		rkNet.Connect(m_strAddr.c_str(), m_iPort);
+	}
+
+	Disconnect();
+	__OfflineState_Set();
+
+	return true;
+}
+#endif /* USE_OPENID */
+
+
+bool CAccountConnector::__AuthState_RecvAuthFailure()
+{
+	TPacketGCLoginFailure packet_failure;
+	if (!Recv(sizeof(TPacketGCLoginFailure), &packet_failure))
+		return false;
+
+	if (m_poHandler)
+		PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", packet_failure.szStatus));
+
+//	__OfflineState_Set();
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvRunupMatrixQuiz()
+{
+	TPacketGCRunupMatrixQuiz kMatrixQuizPacket;
+	if (!Recv(sizeof(TPacketGCRunupMatrixQuiz), &kMatrixQuizPacket))
+		return false;
+
+	PyCallClassMemberFunc(m_poHandler, "BINARY_OnRunupMatrixQuiz", Py_BuildValue("(s)", kMatrixQuizPacket.szQuiz));	
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvNEWCIBNPasspodRequest()
+{
+	TPacketGCNEWCIBNPasspodRequest kRequestPacket;
+	if (!Recv(sizeof(kRequestPacket), &kRequestPacket))
+		return false;
+
+	PyCallClassMemberFunc(m_poHandler, "BINARY_OnNEWCIBNPasspodRequest", Py_BuildValue("()"));	
+	return true;
+}
+
+#define ROW(rows, i) ((rows >> ((4 - i - 1) * 8)) & 0x000000FF)
+#define COL(cols, i) ((cols >> ((4 - i - 1) * 8)) & 0x000000FF)
+
+bool CAccountConnector::__AuthState_RecvChinaMatrixCard()
+{
+	TPacketGCChinaMatrixCard kMatrixCardPacket;
+	if (!Recv(sizeof(TPacketGCChinaMatrixCard), &kMatrixCardPacket))
+		return false;
+
+	if (m_poHandler)
+	{
+		PyObject * pyValue = Py_BuildValue("(iiiiiiii)",	ROW(kMatrixCardPacket.dwRows, 0),
+															ROW(kMatrixCardPacket.dwRows, 1),
+															ROW(kMatrixCardPacket.dwRows, 2),
+															ROW(kMatrixCardPacket.dwRows, 3),
+															COL(kMatrixCardPacket.dwCols, 0),
+															COL(kMatrixCardPacket.dwCols, 1),
+															COL(kMatrixCardPacket.dwCols, 2),
+															COL(kMatrixCardPacket.dwCols, 3));
+		PyCallClassMemberFunc(m_poHandler, "OnMatrixCard", pyValue);
+	}
+
+	return true;
+}
+
+bool CAccountConnector::__AnalyzePacket(UINT uHeader, UINT uPacketSize, bool (CAccountConnector::*pfnDispatchPacket)())
+{
+	BYTE bHeader;
+	if (!Peek(sizeof(bHeader), &bHeader))
+		return true;
+
+	if (bHeader!=uHeader)
+		return true;
+
+	if (!Peek(uPacketSize))
+		return true;
+
+	return (this->*pfnDispatchPacket)();
+}
+
+bool CAccountConnector::__AnalyzeVarSizePacket(UINT uHeader, bool (CAccountConnector::*pfnDispatchPacket)(int))
+{
+	BYTE bHeader;
+	if (!Peek(sizeof(bHeader), &bHeader))
+		return true;
+
+	if (bHeader!=uHeader)
+		return true;
+
+	TDynamicSizePacketHeader dynamicHeader;
+
+	if (!Peek(sizeof(dynamicHeader), &dynamicHeader))
+		return true;
+
+	if (!Peek(dynamicHeader.size))
+		return true;
+
+	return (this->*pfnDispatchPacket)(dynamicHeader.size);
+}
+
+
+void CAccountConnector::__OfflineState_Set()
+{
+	__Inialize();
+}
+
+void CAccountConnector::__HandshakeState_Set()
+{
+	m_eState=STATE_HANDSHAKE;
+}
+
+void CAccountConnector::__AuthState_Set()
+{
+	m_eState=STATE_AUTH;
+}
+
+void CAccountConnector::OnConnectFailure()
+{
+	if (m_poHandler)
+		PyCallClassMemberFunc(m_poHandler, "OnConnectFailure", Py_BuildValue("()"));
+
+	__OfflineState_Set();
+}
+
+void CAccountConnector::OnConnectSuccess()
+{
+	m_eState = STATE_HANDSHAKE;
+}
+
+void CAccountConnector::OnRemoteDisconnect()
+{
+	// Matrix Card Number <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>Ҵµ<D2B4> close <20>Ǹ<EFBFBD> <20><><EFBFBD>α׷<CEB1><D7B7><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
+	if (m_isWaitKey)
+	{
+		if (m_poHandler)
+		{
+			PyCallClassMemberFunc(m_poHandler, "OnExit", Py_BuildValue("()"));
+			return;
+		}
+	}
+
+	__OfflineState_Set();
+}
+
+void CAccountConnector::OnDisconnect()
+{
+	__OfflineState_Set();
+}
+
+void CAccountConnector::__Inialize()
+{
+	m_eState=STATE_OFFLINE;
+	m_isWaitKey = FALSE;
+}
+
+CAccountConnector::CAccountConnector()
+{
+	m_poHandler = NULL;
+	m_strAddr = "";
+	m_iPort = 0;
+
+	SetLoginInfo("", "");
+	SetRecvBufferSize(1024 * 128);
+	SetSendBufferSize(2048);
+	__Inialize();
+}
+
+CAccountConnector::~CAccountConnector()
+{
+	__OfflineState_Set();
+}

src/UserInterface/AccountConnector.h

@@ -0,0 +1,85 @@
+#pragma 
+
+#include "../EterLib/NetStream.h"
+#include "../EterLib/FuncObject.h"
+
+class CAccountConnector : public CNetworkStream, public CSingleton<CAccountConnector>
+{
+	public:
+		enum
+		{
+			STATE_OFFLINE,
+			STATE_HANDSHAKE,
+			STATE_AUTH,
+		};
+
+	public:
+		CAccountConnector();
+		virtual ~CAccountConnector();
+
+		void SetHandler(PyObject* poHandler);
+		void SetLoginInfo(const char * c_szName, const char * c_szPwd);
+		void ClearLoginInfo( void );
+
+		bool SendChinaMatrixCardPacket(const char * c_szMatrixCardString);
+		bool SendRunupMatrixCardPacket(const char * c_szMatrixCardString);
+		bool SendNEWCIBNPasspodAnswerPacket(const char * answer);
+
+		bool Connect(const char * c_szAddr, int iPort, const char * c_szAccountAddr, int iAccountPort);
+		void Disconnect();
+		void Process();
+
+	protected:
+		void OnConnectFailure();
+		void OnConnectSuccess();
+		void OnRemoteDisconnect();
+		void OnDisconnect();
+
+	protected:
+		void __Inialize();
+		bool __StateProcess();
+
+		void __OfflineState_Set();
+		void __HandshakeState_Set();
+		void __AuthState_Set();
+
+		bool __HandshakeState_Process();
+		bool __AuthState_Process();
+
+		bool __AuthState_RecvEmpty();
+		bool __AuthState_RecvPhase();
+		bool __AuthState_RecvHandshake();
+		bool __AuthState_RecvPing();
+		bool __AuthState_SendPong();
+		bool __AuthState_RecvAuthSuccess();
+#ifdef USE_OPENID
+		bool __AuthState_RecvAuthSuccess_OpenID();
+#endif /* USE_OPENID */
+		bool __AuthState_RecvAuthFailure();
+		bool __AuthState_RecvChinaMatrixCard();
+		bool __AuthState_RecvRunupMatrixQuiz();
+		bool __AuthState_RecvNEWCIBNPasspodRequest();
+		bool __AuthState_RecvPanamaPack();
+		bool __AuthState_RecvHybridCryptKeys(int VarSize);
+		bool __AuthState_RecvHybridCryptSDB(int VarSize);
+
+		bool __AnalyzePacket(UINT uHeader, UINT uPacketSize, bool (CAccountConnector::*pfnDispatchPacket)());
+		// TODO:  <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ӽô<D3BD>.  header<65>ڿ<EFBFBD> size 4byte<74><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>´ٴ<C2B4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ϸ<EFBFBD><CFB7><EFBFBD>  Packet System Refactoring<6E>ؾ<EFBFBD> <20>Ѵ<EFBFBD>. 
+		bool __AnalyzeVarSizePacket(UINT uHeader, bool (CAccountConnector::*pfnDispatchPacket)(int));
+
+	protected:
+		UINT m_eState;
+		std::string m_strID;
+		std::string m_strPassword;
+
+		std::string m_strAddr;
+		int m_iPort;
+		BOOL m_isWaitKey;
+
+		PyObject * m_poHandler;
+
+		// CHINA_CRYPT_KEY
+		void __BuildClientKey_20050304Myevan();
+		// END_OF_CHINA_CRYPT_KEY
+};

src/UserInterface/AffectFlagContainer.cpp

@@ -0,0 +1,92 @@
+#include "StdAfx.h"
+#include "AffectFlagContainer.h"
+
+CAffectFlagContainer::CAffectFlagContainer()
+{
+	Clear();
+}
+
+CAffectFlagContainer::~CAffectFlagContainer()
+{
+}
+
+void CAffectFlagContainer::Clear()
+{
+	memset(m_aElement, 0, sizeof(m_aElement));
+}
+
+void CAffectFlagContainer::CopyInstance(const CAffectFlagContainer& c_rkAffectContainer)
+{
+	memcpy(m_aElement, c_rkAffectContainer.m_aElement, sizeof(m_aElement));
+}
+
+void CAffectFlagContainer::CopyData(UINT uPos, UINT uByteSize, const void* c_pvData)
+{
+	const BYTE* c_pbData=(const BYTE*)c_pvData; 
+	Element bMask=0x01;
+
+	UINT uBitEnd=uPos+uByteSize*8;
+	for (UINT i=uPos; i<uBitEnd; ++i)
+	{
+		Set(i, (*c_pbData & bMask) ? true : false);
+		bMask<<=1;
+
+		if (bMask==0)
+		{
+			++c_pbData;
+			bMask=0x01;
+		}
+	}
+}
+
+void CAffectFlagContainer::ConvertToPosition(unsigned* uRetX, unsigned* uRetY) const
+{
+	DWORD* pos = (DWORD*)m_aElement;
+	*uRetX = pos[0];
+	*uRetY = pos[1];
+}
+/*
+const void * CAffectFlagContainer::GetDataPtr(UINT uPos) const
+{
+	if (uPos/8>=BYTE_SIZE)
+	{
+		return NULL;
+	}
+
+	return (const void *)&m_aElement[uPos];
+}
+*/
+
+void CAffectFlagContainer::Set(UINT uPos, bool isSet)
+{
+	if (uPos/8>=BYTE_SIZE)
+	{
+		TraceError("CAffectFlagContainer::Set(uPos=%d>%d, isSet=%d", uPos, BYTE_SIZE*8, isSet);
+		return;
+	}
+
+	BYTE& rElement=m_aElement[uPos/8];
+
+	BYTE bMask=BYTE(1<<(uPos&7));
+	if (isSet)
+		rElement|=bMask;
+	else
+		rElement&=~bMask;
+}
+
+bool CAffectFlagContainer::IsSet(UINT uPos) const
+{
+	if (uPos/8>=BYTE_SIZE)
+	{
+		TraceError("CAffectFlagContainer::IsSet(uPos=%d>%d", uPos, BYTE_SIZE*8);
+		return false;
+	}
+
+	const BYTE& c_rElement=m_aElement[uPos/8];
+
+	BYTE bMask=BYTE(1<<(uPos&7));
+	if (c_rElement&bMask)
+		return true;
+
+	return false;
+}

src/UserInterface/AffectFlagContainer.h

@@ -0,0 +1,29 @@
+#pragma once
+
+class CAffectFlagContainer
+{
+	public:
+		enum
+		{
+			BIT_SIZE = 64,
+			BYTE_SIZE = BIT_SIZE/8+(1*((BIT_SIZE&7) ? 1 : 0)),
+		};
+
+	public:
+		CAffectFlagContainer();
+		~CAffectFlagContainer();		
+
+		void Clear();
+		void CopyInstance(const CAffectFlagContainer& c_rkAffectContainer);		
+		void Set(UINT uPos, bool isSet);
+		bool IsSet(UINT uPos) const;
+
+		void CopyData(UINT uPos, UINT uByteSize, const void* c_pvData);
+
+		void ConvertToPosition(unsigned* uRetX, unsigned* uRetY) const;
+		
+	private:
+		typedef unsigned char Element;
+
+		Element m_aElement[BYTE_SIZE];
+};

src/UserInterface/CameraProcedure.cpp

@@ -0,0 +1,351 @@
+#include "StdAfx.h"
+#include "PythonBackground.h"
+#include "../eterlib/Camera.h"
+
+//////////////////////////////////////////////////////////////////////////
+// <20>޼<EFBFBD><DEBC><EFBFBD>
+
+extern void SetHeightLog(bool isLog);
+
+float CCamera::CAMERA_MIN_DISTANCE = 200.0f;
+float CCamera::CAMERA_MAX_DISTANCE = 2500.0f;
+
+void CCamera::ProcessTerrainCollision()
+{
+	CPythonBackground & rPythonBackground = CPythonBackground::Instance();
+	D3DXVECTOR3 v3CollisionPoint;
+
+	if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kTargetToCameraBottomRay, &v3CollisionPoint))
+	{
+		SetCameraState(CAMERA_STATE_CANTGODOWN);
+		D3DXVECTOR3 v3CheckVector = m_v3Eye - 2.0f * m_fTerrainCollisionRadius * m_v3Up;
+		v3CheckVector.z = rPythonBackground.GetHeight(floorf(v3CheckVector.x), floorf(v3CheckVector.y));
+		D3DXVECTOR3 v3NewEye = v3CheckVector + 2.0f * m_fTerrainCollisionRadius * m_v3Up;
+		if (v3NewEye.z > m_v3Eye.z)
+		{
+			//printf("ToCameraBottom(%f, %f, %f) TCR %f, UP(%f, %f, %f), new %f > old %f", 
+			//	v3CheckVector.x, v3CheckVector.y, v3CheckVector.z, 
+			//	m_fTerrainCollisionRadius,
+			//	m_v3Up.x, m_v3Up.y, m_v3Up.z,
+			//	v3NewEye.z, m_v3Eye.z);
+			SetEye(v3NewEye);
+		}
+		/*
+		SetCameraState(CAMERA_STATE_NORMAL);
+		D3DXVECTOR3 v3NewEye = v3CollisionPoint;
+		SetEye(v3NewEye);
+		*/
+	}
+	else
+		SetCameraState(CAMERA_STATE_NORMAL);
+
+	if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraBottomToTerrainRay, &v3CollisionPoint))
+	{
+		SetCameraState(CAMERA_STATE_CANTGODOWN);
+		if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 2.0f * m_fTerrainCollisionRadius)
+		{
+			D3DXVECTOR3 v3NewEye = v3CollisionPoint + 2.0f * m_fTerrainCollisionRadius * m_v3Up;
+			//printf("CameraBottomToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
+			SetEye(v3NewEye);
+		}
+	}
+	else
+		SetCameraState(CAMERA_STATE_NORMAL);
+/*
+	if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraFrontToTerrainRay, &v3CollisionPoint))
+	{
+		if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 4.0f * m_fTerrainCollisionRadius)
+		{
+			D3DXVECTOR3 v3NewEye = v3CollisionPoint - 4.0f * m_fTerrainCollisionRadius * m_v3View;
+			//printf("CameraFrontToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
+			SetEye(v3NewEye);
+		}
+	}
+
+	if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraBackToTerrainRay, &v3CollisionPoint))
+	{
+		if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < m_fTerrainCollisionRadius)
+		{
+			D3DXVECTOR3 v3NewEye = v3CollisionPoint + m_fTerrainCollisionRadius * m_v3View;
+			//printf("CameraBackToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
+			SetEye(v3NewEye);
+		}
+	}
+
+	// Left
+	if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraLeftToTerrainRay, &v3CollisionPoint))
+	{
+		SetCameraState(CAMERA_STATE_CANTGOLEFT);
+		if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 3.0f * m_fTerrainCollisionRadius)
+		{
+			D3DXVECTOR3 v3NewEye = v3CollisionPoint + 3.0f * m_fTerrainCollisionRadius * m_v3Cross;
+			//printf("CameraLeftToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
+			SetEye(v3NewEye);
+		}
+	}
+	else
+		SetCameraState(CAMERA_STATE_NORMAL);
+
+	// Right
+	if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraRightToTerrainRay, &v3CollisionPoint))
+	{
+		SetCameraState(CAMERA_STATE_CANTGORIGHT);
+		if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 3.0f * m_fTerrainCollisionRadius)
+		{
+			D3DXVECTOR3 v3NewEye = v3CollisionPoint - 3.0f * m_fTerrainCollisionRadius * m_v3Cross;
+			//printf("CameraRightToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
+			SetEye(v3NewEye);
+		}
+	}
+	else
+		SetCameraState(CAMERA_STATE_NORMAL);
+	*/
+}
+
+struct CameraCollisionChecker
+{
+	bool m_isBlocked;
+	std::vector<D3DXVECTOR3>* m_pkVct_v3Position;
+	CDynamicSphereInstance * m_pdsi;
+
+	CameraCollisionChecker(CDynamicSphereInstance * pdsi, std::vector<D3DXVECTOR3>* pkVct_v3Position) : m_pdsi(pdsi), m_pkVct_v3Position(pkVct_v3Position), m_isBlocked(false) 
+	{
+	}
+	void operator () (CGraphicObjectInstance* pOpponent)
+	{
+		if (pOpponent->CollisionDynamicSphere(*m_pdsi))
+ 		{
+			m_pkVct_v3Position->push_back(pOpponent->GetPosition());
+			m_isBlocked = true;
+ 		}
+	}
+};
+
+void CCamera::ProcessBuildingCollision()
+{
+	float fMoveAmountSmall = 2.0f;
+	float fMoveAmountLarge = 4.0f;
+
+	D3DXVECTOR3 v3CheckVector;
+
+	CDynamicSphereInstance s;
+	s.fRadius = m_fObjectCollisionRadius;
+	s.v3LastPosition = m_v3Eye;
+
+	Vector3d aVector3d;
+	aVector3d.Set(m_v3Eye.x, m_v3Eye.y, m_v3Eye.z);
+
+	// <20><>
+
+	CCullingManager & rkCullingMgr = CCullingManager::Instance();
+
+	{
+		v3CheckVector = m_v3Eye - m_fObjectCollisionRadius * m_v3View;
+		s.v3Position = v3CheckVector;
+
+		std::vector<D3DXVECTOR3> kVct_kPosition;
+		CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
+		rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
+		bool bCollide = kCameraCollisionChecker.m_isBlocked;
+
+		if (bCollide)
+		{
+			if (m_v3AngularVelocity.y > 0.0f)
+			{
+				m_v3AngularVelocity.y = 0.0f;
+				m_v3AngularVelocity.z += fMoveAmountLarge;
+			}
+	//		m_v3AngularVelocity.y = fMAX(fMoveAmountSmall, m_v3AngularVelocity.y);
+	//// 		m_v3AngularVelocity.y += fMoveAmountSmall;
+
+			if (kVct_kPosition.size() > 1)
+			{
+	//			m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
+ 				m_v3AngularVelocity.z += fMoveAmountSmall;
+			}
+			else
+			{
+				D3DXVec3Cross(&v3CheckVector, &(kVct_kPosition[0] - m_v3Eye), &m_v3View);
+				float fDot = D3DXVec3Dot(&v3CheckVector, &m_v3Up);
+				if (fDot < 0)
+				{
+	//				m_v3AngularVelocity.x = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.x);
+ 					m_v3AngularVelocity.x -= fMoveAmountSmall;
+				}
+				else if(fDot > 0)
+				{
+	//				m_v3AngularVelocity.x = fMAX(fMoveAmountSmall, m_v3AngularVelocity.x);
+ 					m_v3AngularVelocity.x += fMoveAmountSmall;
+				}
+				else
+				{
+	//				m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
+ 					m_v3AngularVelocity.z += fMoveAmountSmall;
+				}
+			}
+		}
+	}
+
+	// <20><>
+	{
+		v3CheckVector = m_v3Eye + 2.0f * m_fObjectCollisionRadius * m_v3Up;
+		s.v3Position = v3CheckVector;
+
+		std::vector<D3DXVECTOR3> kVct_kPosition;
+		CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
+		rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
+		bool bCollide = kCameraCollisionChecker.m_isBlocked;
+
+		if (bCollide)
+		{
+			m_v3AngularVelocity.z = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.y);
+	// 		m_v3AngularVelocity.z -= 1.0f;
+		}
+	}
+
+	// <20><>
+	{
+		v3CheckVector = m_v3Eye + 3.0f * m_fObjectCollisionRadius * m_v3Cross;
+		s.v3Position = v3CheckVector;
+
+		std::vector<D3DXVECTOR3> kVct_kPosition;
+		CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
+		rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
+		bool bCollide = kCameraCollisionChecker.m_isBlocked;
+
+		if (bCollide)
+		{
+			if (m_v3AngularVelocity.x > 0.0f)
+			{
+				m_v3AngularVelocity.x = 0.0f;
+				m_v3AngularVelocity.y += fMoveAmountLarge;
+			}
+		}
+	}
+
+	// <20><>
+	{
+		v3CheckVector = m_v3Eye - 3.0f * m_fObjectCollisionRadius * m_v3Cross;
+		s.v3Position = v3CheckVector;
+
+		std::vector<D3DXVECTOR3> kVct_kPosition;
+		CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
+		rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
+		bool bCollide = kCameraCollisionChecker.m_isBlocked;
+
+		if (bCollide)
+		{
+			if (m_v3AngularVelocity.x < 0.0f)
+			{
+				m_v3AngularVelocity.x = 0.0f;
+				m_v3AngularVelocity.y += fMoveAmountLarge;
+			}
+		}
+	}
+
+	// <20>Ʒ<EFBFBD>
+	{
+		v3CheckVector = m_v3Eye - 2.0f * m_fTerrainCollisionRadius * m_v3Up;
+		s.v3Position = v3CheckVector;
+
+		std::vector<D3DXVECTOR3> kVct_kPosition;
+		CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
+		rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
+		bool bCollide = kCameraCollisionChecker.m_isBlocked;
+
+		if (bCollide)
+		{
+			if (m_v3AngularVelocity.z < 0.0f)
+			{
+				m_v3AngularVelocity.z = 0.0f;
+				m_v3AngularVelocity.y += fMoveAmountLarge;
+			}
+		}
+	}
+
+	// <20><>
+	{
+		v3CheckVector = m_v3Eye + 4.0f * m_fObjectCollisionRadius * m_v3View;
+		s.v3Position = v3CheckVector;
+
+		std::vector<D3DXVECTOR3> kVct_kPosition;
+		CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
+		rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
+		bool bCollide = kCameraCollisionChecker.m_isBlocked;
+
+		if (bCollide)
+		{
+			if (m_v3AngularVelocity.y < 0.0f)
+			{
+				m_v3AngularVelocity.y = 0.0f;
+				m_v3AngularVelocity.z += fMoveAmountLarge;
+			}
+
+			if (kVct_kPosition.size() > 1)
+			{
+	//			m_v3AngularVelocity.z = fMAX(fMoveAmountLarge, m_v3AngularVelocity.z);
+ 				m_v3AngularVelocity.z += fMoveAmountLarge;
+			}
+			else
+			{
+				D3DXVec3Cross(&v3CheckVector, &(kVct_kPosition[0] - m_v3Eye), &m_v3View);
+				float fDot = D3DXVec3Dot(&v3CheckVector, &m_v3Up);
+				if (fDot < 0)
+				{
+	// 				m_v3AngularVelocity.x = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.x);
+					m_v3AngularVelocity.x -= fMoveAmountSmall;
+				}
+				else if(fDot > 0)
+				{
+	// 				m_v3AngularVelocity.x = fMAX(fMoveAmountSmall, m_v3AngularVelocity.x);
+					m_v3AngularVelocity.x += fMoveAmountSmall;
+				}
+				else
+				{
+	//				m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
+					m_v3AngularVelocity.z += fMoveAmountSmall;
+				}
+			}
+		}
+	}
+}
+
+void CCamera::Update()
+{
+// 	ProcessBuildingCollision();
+
+	RotateEyeAroundTarget(m_v3AngularVelocity.z, m_v3AngularVelocity.x);
+
+	float fNewDistance=fMAX(CAMERA_MIN_DISTANCE, fMIN( CAMERA_MAX_DISTANCE, GetDistance() - m_v3AngularVelocity.y ) );
+	SetDistance(fNewDistance);
+	
+	if (m_bProcessTerrainCollision)
+ 		ProcessTerrainCollision();
+
+	m_v3AngularVelocity *= 0.5f;
+	if (fabs(m_v3AngularVelocity.x) < 1.0f)
+		m_v3AngularVelocity.x = 0.0f;
+	if (fabs(m_v3AngularVelocity.y) < 1.0f)
+		m_v3AngularVelocity.y = 0.0f;
+	if (fabs(m_v3AngularVelocity.z) < 1.0f)
+		m_v3AngularVelocity.z = 0.0f;
+
+	const float CAMERA_MOVABLE_DISTANCE = CAMERA_MAX_DISTANCE - CAMERA_MIN_DISTANCE;
+	const float CAMERA_TARGET_DELTA = CAMERA_TARGET_FACE - CAMERA_TARGET_STANDARD;
+	float fCameraCurMovableDistance=CAMERA_MAX_DISTANCE - GetDistance();
+	float fNewTargetHeight = CAMERA_TARGET_STANDARD + CAMERA_TARGET_DELTA * fCameraCurMovableDistance / CAMERA_MOVABLE_DISTANCE;
+
+	SetTargetHeight(fNewTargetHeight);
+
+	// Cinematic
+#ifdef __20040725_CAMERA_WORK__
+	m_MovementPosition += m_MovementSpeed;
+	
+	if (0.0f != m_MovementPosition.m_fViewDir)
+		MoveFront(m_MovementPosition.m_fViewDir);
+	if (0.0f != m_MovementPosition.m_fCrossDir)
+		MoveAlongCross(m_MovementPosition.m_fCrossDir);
+	if (0.0f != m_MovementPosition.m_fUpDir)
+		MoveVertical(m_MovementPosition.m_fUpDir);
+#endif
+}

src/UserInterface/CheckLatestFiles.cpp

@@ -0,0 +1,64 @@
+#include "StdAfx.h"
+#if defined(CHECK_LATEST_DATA_FILES)
+#include "CheckLatestFiles.h"
+#include "resource.h"
+
+static struct SCHECKFILELIST
+{
+	LPCSTR		szFileName;
+	DWORD		dwCRC32;
+	ULONGLONG	ullSize;
+} s_astCRC32FileList[] = {
+#include "CRC32_inc.h"
+	{ NULL,		0 }
+};
+
+static bool gs_bQuit = false;
+
+bool CheckLatestFiles_PollEvent( void )
+{
+	return gs_bQuit;
+}
+
+// <20><><EFBFBD><EFBFBD>Ÿ <20><><EFBFBD><EFBFBD> CRC32 <20><> <20>˻<EFBFBD><CBBB>ϱ<EFBFBD>
+bool CheckFileCRC32( LPCSTR szFileName, DWORD dwCRC32 )
+{
+	char szMessage[256];
+
+	if (_access( szFileName, 4 ) != 0) {
+		_snprintf(szMessage, sizeof(szMessage)/sizeof(szMessage[0])-1, ApplicationStringTable_GetStringz(IDS_ERR_CANNOT_READ_FILE, "ERR_CANNOT_READ_FILE"), szFileName);
+		ApplicationSetErrorString(szMessage);
+		return false;
+	}
+	DWORD dwLocalCRC32 = GetFileCRC32(szFileName);
+
+	if (dwCRC32 != dwLocalCRC32) {
+		_snprintf(szMessage, sizeof(szMessage)/sizeof(szMessage[0])-1, ApplicationStringTable_GetStringz(IDS_ERR_NOT_LATEST_FILE, "ERR_NOT_LATEST_FILE"), szFileName);
+		ApplicationSetErrorString(szMessage);
+		return false;
+	}
+
+	return true;
+}
+
+UINT CALLBACK CheckLatestFilesEntry(void * pThis)
+{
+	::Sleep( 500 );
+	for( int i=0; s_astCRC32FileList[i].szFileName != NULL; i++ ) {
+		if (false == CheckFileCRC32(s_astCRC32FileList[i].szFileName, s_astCRC32FileList[i].dwCRC32)) {
+			gs_bQuit = true;
+			break;
+		}
+	}
+	return 0;
+}
+
+bool CheckLatestFiles( void )
+{
+	unsigned int uThreadID = 0;
+
+	HANDLE hThread = (HANDLE) _beginthreadex(NULL, 0, CheckLatestFilesEntry, NULL, 0, &uThreadID);
+	::SetThreadPriority(hThread, THREAD_PRIORITY_LOWEST);
+	return true;
+}
+#endif

src/UserInterface/CheckLatestFiles.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#if defined(CHECK_LATEST_DATA_FILES)
+bool CheckLatestFiles( void );
+bool CheckLatestFiles_PollEvent( void );
+#endif

src/UserInterface/GameType.cpp

@@ -0,0 +1,112 @@
+#include "StdAfx.h"
+#include "GameType.h"
+
+std::string g_strResourcePath = "d:/ymir work/";
+std::string g_strImagePath = "d:/ymir work/ui/";
+
+std::string g_strGuildSymbolPathName = "mark/10/";
+
+// DEFAULT_FONT
+static std::string gs_strDefaultFontName = "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ü:12.fnt";
+static std::string gs_strDefaultItalicFontName = "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ü:12i.fnt";
+static CResource* gs_pkDefaultFont = NULL;
+static CResource* gs_pkDefaultItalicFont = NULL;
+
+static bool gs_isReloadDefaultFont = false;
+
+void DefaultFont_Startup()
+{
+	gs_pkDefaultFont = NULL;
+}
+
+void DefaultFont_Cleanup()
+{
+	if (gs_pkDefaultFont)
+		gs_pkDefaultFont->Release();
+}
+
+void DefaultFont_SetName(const char * c_szFontName)
+{
+	gs_strDefaultFontName = c_szFontName;
+	gs_strDefaultFontName += ".fnt";
+
+	gs_strDefaultItalicFontName = c_szFontName;
+	if(strchr(c_szFontName, ':'))
+		gs_strDefaultItalicFontName += "i";
+	gs_strDefaultItalicFontName += ".fnt";
+
+	gs_isReloadDefaultFont = true;
+}
+
+bool ReloadDefaultFonts()
+{
+	CResourceManager& rkResMgr = CResourceManager::Instance();
+
+	gs_isReloadDefaultFont = false;
+
+	CResource* pkNewFont = rkResMgr.GetResourcePointer(gs_strDefaultFontName.c_str());
+	pkNewFont->AddReference();
+	if (gs_pkDefaultFont)
+		gs_pkDefaultFont->Release();
+	gs_pkDefaultFont = pkNewFont;
+
+	CResource* pkNewItalicFont = rkResMgr.GetResourcePointer(gs_strDefaultItalicFontName.c_str());
+	pkNewItalicFont->AddReference();
+	if (gs_pkDefaultItalicFont)
+		gs_pkDefaultItalicFont->Release();
+	gs_pkDefaultItalicFont = pkNewItalicFont;
+
+	return true;
+}
+
+CResource* DefaultFont_GetResource()
+{	
+	if (!gs_pkDefaultFont || gs_isReloadDefaultFont)
+		ReloadDefaultFonts();
+	return gs_pkDefaultFont;
+}
+
+CResource* DefaultItalicFont_GetResource()
+{	
+	if (!gs_pkDefaultItalicFont || gs_isReloadDefaultFont)
+		ReloadDefaultFonts();
+	return gs_pkDefaultItalicFont;
+}
+
+// END_OF_DEFAULT_FONT
+
+void SetGuildSymbolPath(const char * c_szPathName)
+{
+	g_strGuildSymbolPathName = "mark/";
+	g_strGuildSymbolPathName += c_szPathName;
+	g_strGuildSymbolPathName += "/";
+}
+
+const char * GetGuildSymbolFileName(DWORD dwGuildID)
+{
+	return _getf("%s%03d.jpg", g_strGuildSymbolPathName.c_str(), dwGuildID);
+}
+
+BYTE c_aSlotTypeToInvenType[SLOT_TYPE_MAX] =
+{
+	RESERVED_WINDOW,		// SLOT_TYPE_NONE
+	INVENTORY,				// SLOT_TYPE_INVENTORY
+	RESERVED_WINDOW,		// SLOT_TYPE_SKILL
+	RESERVED_WINDOW,		// SLOT_TYPE_EMOTION
+	RESERVED_WINDOW,		// SLOT_TYPE_SHOP
+	RESERVED_WINDOW,		// SLOT_TYPE_EXCHANGE_OWNER
+	RESERVED_WINDOW,		// SLOT_TYPE_EXCHANGE_TARGET
+	RESERVED_WINDOW,		// SLOT_TYPE_QUICK_SLOT
+	RESERVED_WINDOW,		// SLOT_TYPE_SAFEBOX	<- SAFEBOX, MALL<4C><4C> <20><><EFBFBD><EFBFBD> <20>ϵ<EFBFBD> <20>ڵ<EFBFBD><DAB5>Ǿ<EFBFBD><C7BE>ִ<EFBFBD> LEGACY <20>ڵ带 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+	RESERVED_WINDOW,		// SLOT_TYPE_PRIVATE_SHOP
+	RESERVED_WINDOW,		// SLOT_TYPE_MALL		<- SAFEBOX, MALL<4C><4C> <20><><EFBFBD><EFBFBD> <20>ϵ<EFBFBD> <20>ڵ<EFBFBD><DAB5>Ǿ<EFBFBD><C7BE>ִ<EFBFBD> LEGACY <20>ڵ带 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+	DRAGON_SOUL_INVENTORY,	// SLOT_TYPE_DRAGON_SOUL_INVENTORY
+};
+
+BYTE SlotTypeToInvenType(BYTE bSlotType)
+{
+	if (bSlotType >= SLOT_TYPE_MAX)
+		return RESERVED_WINDOW;
+	else
+		return c_aSlotTypeToInvenType[bSlotType];
+}

src/UserInterface/GameType.h

@@ -0,0 +1,360 @@
+#pragma once
+#include "../GameLib/ItemData.h"
+
+struct SAffects
+{
+	enum
+	{
+		AFFECT_MAX_NUM = 32,
+	};
+
+	SAffects() : dwAffects(0) {}
+	SAffects(const DWORD & c_rAffects)
+	{
+		__SetAffects(c_rAffects);
+	}
+	int operator = (const DWORD & c_rAffects)
+	{
+		__SetAffects(c_rAffects);
+	}
+
+	BOOL IsAffect(BYTE byIndex)
+	{
+		return dwAffects & (1 << byIndex);
+	}
+
+	void __SetAffects(const DWORD & c_rAffects)
+	{
+		dwAffects = c_rAffects;
+	}
+
+	DWORD dwAffects;
+};
+
+extern std::string g_strGuildSymbolPathName;
+
+const DWORD c_Name_Max_Length = 64;
+const DWORD c_FileName_Max_Length = 128;
+const DWORD c_Short_Name_Max_Length = 32;
+
+const DWORD c_Inventory_Page_Size = 5*9; // x*y
+const DWORD c_Inventory_Page_Count = 2;
+const DWORD c_ItemSlot_Count = c_Inventory_Page_Size * c_Inventory_Page_Count;
+const DWORD c_Equipment_Count = 12;
+
+const DWORD c_Equipment_Start = c_ItemSlot_Count;
+
+const DWORD c_Equipment_Body	= c_Equipment_Start + 0;
+const DWORD c_Equipment_Head	= c_Equipment_Start + 1;
+const DWORD c_Equipment_Shoes	= c_Equipment_Start + 2;
+const DWORD c_Equipment_Wrist	= c_Equipment_Start + 3;
+const DWORD c_Equipment_Weapon	= c_Equipment_Start + 4;
+const DWORD c_Equipment_Neck	= c_Equipment_Start + 5;
+const DWORD c_Equipment_Ear		= c_Equipment_Start + 6;
+const DWORD c_Equipment_Unique1	= c_Equipment_Start + 7;
+const DWORD c_Equipment_Unique2	= c_Equipment_Start + 8;
+const DWORD c_Equipment_Arrow	= c_Equipment_Start + 9;
+const DWORD c_Equipment_Shield	= c_Equipment_Start + 10;
+
+// <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD><DFB0><EFBFBD> <20>ű<EFBFBD> <20><><EFBFBD><EFBFBD> & <20><>Ʈ
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ۿ<EFBFBD> <20>Ҵ<EFBFBD><D2B4><EFBFBD> <20><> <20>ִ<EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, ä<><C3A4><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>, <20>ڽ<EFBFBD>Ƭ <20>ý<EFBFBD><C3BD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>߷<EFBFBD><DFB7>ִ<EFBFBD>.
+// <20>̰<EFBFBD> <20><> ä<><C3A4><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ó<EFBFBD><C3B3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>... <20><><EFBFBD><EFBFBD>
+// 
+// <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>â<EFBFBD><C3A2><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>DB<44><42> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 90 ~ 102 <20>̰<EFBFBD>,
+// 2013<31><33> <20>ʿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD><DFB0>Ǵ<EFBFBD> <20><><EFBFBD>Ե<EFBFBD><D4B5><EFBFBD> 111 ~ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>. <20><><EFBFBD><EFBFBD> <20><><EFBFBD>񿡼<EFBFBD> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> 121 <20><><EFBFBD><EFBFBD><EFBFBD>̰<EFBFBD>, 122<32><32><EFBFBD>ʹ<EFBFBD> <20><>ȥ<EFBFBD><C8A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
+	const DWORD c_New_Equipment_Start = c_Equipment_Start + 21;
+	const DWORD c_New_Equipment_Count = 3;
+	const DWORD c_Equipment_Ring1 = c_New_Equipment_Start + 0;
+	const DWORD c_Equipment_Ring2 = c_New_Equipment_Start + 1;
+	const DWORD c_Equipment_Belt  = c_New_Equipment_Start + 2;;
+#endif
+
+enum EDragonSoulDeckType
+{
+	DS_DECK_1,
+	DS_DECK_2,
+	DS_DECK_MAX_NUM = 2,
+};
+
+enum EDragonSoulGradeTypes
+{
+	DRAGON_SOUL_GRADE_NORMAL,
+	DRAGON_SOUL_GRADE_BRILLIANT,
+	DRAGON_SOUL_GRADE_RARE,
+	DRAGON_SOUL_GRADE_ANCIENT,
+	DRAGON_SOUL_GRADE_LEGENDARY,
+	DRAGON_SOUL_GRADE_MAX,
+
+};
+
+enum EDragonSoulStepTypes
+{
+	DRAGON_SOUL_STEP_LOWEST,
+	DRAGON_SOUL_STEP_LOW,
+	DRAGON_SOUL_STEP_MID,
+	DRAGON_SOUL_STEP_HIGH,
+	DRAGON_SOUL_STEP_HIGHEST,
+	DRAGON_SOUL_STEP_MAX,
+};
+
+#ifdef ENABLE_COSTUME_SYSTEM
+	const DWORD c_Costume_Slot_Start	= c_Equipment_Start + 19;	// [<5B><><EFBFBD><EFBFBD>] <20><><EFBFBD><EFBFBD>(19) <20>ϵ<EFBFBD><CFB5>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD>. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڽ<EFBFBD><DABD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 19<31><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. <20><><EFBFBD><EFBFBD> common/length.h <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> EWearPositions <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+	const DWORD	c_Costume_Slot_Body		= c_Costume_Slot_Start + 0;
+	const DWORD	c_Costume_Slot_Hair		= c_Costume_Slot_Start + 1;
+	const DWORD c_Costume_Slot_Count	= 2;
+	const DWORD c_Costume_Slot_End		= c_Costume_Slot_Start + c_Costume_Slot_Count;
+#endif
+
+
+// [<5B><><EFBFBD><EFBFBD>] <20><><EFBFBD><EFBFBD>(32) <20>ϵ<EFBFBD><CFB5>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD>. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȥ<EFBFBD><C8A5> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 32<33><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. 
+// <20><><EFBFBD><EFBFBD> common/length.h <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> EWearPositions <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 32<33><32><EFBFBD><EFBFBD> Ȯ<><C8AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD>(32 <20>̻<EFBFBD><CCBB><EFBFBD> Ȯ<><C8AE> <20>ϱ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD>.), 
+// <20><> <20><><EFBFBD>ĺ<EFBFBD><C4BA>͸<EFBFBD> <20><>ȥ<EFBFBD><C8A5> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+const DWORD c_Wear_Max = 32;
+const DWORD c_DragonSoul_Equip_Start = c_ItemSlot_Count + c_Wear_Max;
+const DWORD c_DragonSoul_Equip_Slot_Max = 6;
+const DWORD c_DragonSoul_Equip_End = c_DragonSoul_Equip_Start + c_DragonSoul_Equip_Slot_Max * DS_DECK_MAX_NUM;
+
+// NOTE: 2013<31><33> 2<><32> 5<><35> <20><><EFBFBD><EFBFBD>... <20><>ȥ<EFBFBD><C8A5> <20><>ũ<EFBFBD><C5A9> 2<><32><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴµ<CFB4>, <20><><EFBFBD><EFBFBD> Ȯ<><C8AE> <20><><EFBFBD>ɼ<EFBFBD><C9BC><EFBFBD> <20>־ 3<><33> <20><>ũ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ҵ<EFBFBD> <20><> <20><>. <20><> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ʈ <20>κ<EFBFBD><CEBA>丮<EFBFBD><E4B8AE> <20><><EFBFBD><EFBFBD>
+const DWORD c_DragonSoul_Equip_Reserved_Count = c_DragonSoul_Equip_Slot_Max * 3;		
+
+#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
+	// <20><>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20>κ<EFBFBD><CEBA>丮
+	const DWORD c_Belt_Inventory_Slot_Start = c_DragonSoul_Equip_End + c_DragonSoul_Equip_Reserved_Count;
+	const DWORD c_Belt_Inventory_Width = 4;
+	const DWORD c_Belt_Inventory_Height= 4;
+	const DWORD c_Belt_Inventory_Slot_Count = c_Belt_Inventory_Width * c_Belt_Inventory_Height;
+	const DWORD c_Belt_Inventory_Slot_End = c_Belt_Inventory_Slot_Start + c_Belt_Inventory_Slot_Count;
+
+	const DWORD c_Inventory_Count	= c_Belt_Inventory_Slot_End;
+#else
+	const DWORD c_Inventory_Count	= c_DragonSoul_Equip_End;
+#endif
+
+// <20><>ȥ<EFBFBD><C8A5> <20><><EFBFBD><EFBFBD> <20>κ<EFBFBD><CEBA>丮
+const DWORD c_DragonSoul_Inventory_Start = 0;
+const DWORD c_DragonSoul_Inventory_Box_Size = 32;
+const DWORD c_DragonSoul_Inventory_Count = CItemData::DS_SLOT_NUM_TYPES * DRAGON_SOUL_GRADE_MAX * c_DragonSoul_Inventory_Box_Size;
+const DWORD c_DragonSoul_Inventory_End = c_DragonSoul_Inventory_Start + c_DragonSoul_Inventory_Count;
+
+enum ESlotType
+{
+	SLOT_TYPE_NONE,
+	SLOT_TYPE_INVENTORY,
+	SLOT_TYPE_SKILL,
+	SLOT_TYPE_EMOTION,
+	SLOT_TYPE_SHOP,
+	SLOT_TYPE_EXCHANGE_OWNER,
+	SLOT_TYPE_EXCHANGE_TARGET,
+	SLOT_TYPE_QUICK_SLOT,
+	SLOT_TYPE_SAFEBOX,
+	SLOT_TYPE_PRIVATE_SHOP,
+	SLOT_TYPE_MALL,
+	SLOT_TYPE_DRAGON_SOUL_INVENTORY,
+	SLOT_TYPE_MAX,
+};
+
+enum EWindows
+{
+	RESERVED_WINDOW,
+	INVENTORY,				// <20>⺻ <20>κ<EFBFBD><CEBA>丮. (45ĭ ¥<><C2A5><EFBFBD><EFBFBD> 2<><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> = 90ĭ)
+	EQUIPMENT,
+	SAFEBOX,
+	MALL,
+	DRAGON_SOUL_INVENTORY,
+	GROUND,					// NOTE: 2013<31><33> 2<><32>5<EFBFBD><35> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> unused.. <20><> <20>ִ°<D6B4><C2B0><EFBFBD>???
+	BELT_INVENTORY,			// NOTE: W2.1 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD><DFB0>Ǵ<EFBFBD> <20><>Ʈ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><>Ʈ <20>κ<EFBFBD><CEBA>丮
+	
+	WINDOW_TYPE_MAX,
+};
+
+enum EDSInventoryMaxNum
+{
+	DS_INVENTORY_MAX_NUM = c_DragonSoul_Inventory_Count,
+	DS_REFINE_WINDOW_MAX_NUM = 15,
+};
+
+#pragma pack (push, 1)
+#define WORD_MAX 0xffff
+
+typedef struct SItemPos
+{
+	BYTE window_type;
+	WORD cell;
+    SItemPos ()
+    {
+		window_type =     INVENTORY;
+		cell = WORD_MAX;
+    }
+	SItemPos (BYTE _window_type, WORD _cell)
+    {
+        window_type = _window_type;
+        cell = _cell;
+    }
+
+	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> cell<6C><6C> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> BYTE<54><45> <20><><EFBFBD>κ<EFBFBD><CEBA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, oi
+	// <20> <20>κ<EFBFBD><CEBA><EFBFBD> int, <20> <20>κ<EFBFBD><CEBA><EFBFBD> WORD<52><44> <20>Ǿ<EFBFBD><C7BE>־<EFBFBD>,
+	// <20><><EFBFBD><EFBFBD> ū <20>ڷ<EFBFBD><DAB7><EFBFBD><EFBFBD><EFBFBD> int<6E><74> <20>޴´<DEB4>.
+  //  int operator=(const int _cell)
+  //  {
+		//window_type = INVENTORY;
+  //      cell = _cell;
+  //      return cell;
+  //  }
+	bool IsValidCell()
+	{
+		switch (window_type)
+		{
+		case INVENTORY:
+			return cell < c_Inventory_Count;
+			break;
+		case EQUIPMENT:
+			return cell < c_DragonSoul_Equip_End;
+			break;
+		case DRAGON_SOUL_INVENTORY:
+			return cell < (DS_INVENTORY_MAX_NUM);
+			break;
+		default:
+			return false;
+		}
+	}
+	bool IsEquipCell()
+	{
+		switch (window_type)
+		{
+		case INVENTORY:
+		case EQUIPMENT:
+			return (c_Equipment_Start + c_Wear_Max > cell) && (c_Equipment_Start <= cell);
+			break;
+
+		case BELT_INVENTORY:
+		case DRAGON_SOUL_INVENTORY:
+			return false;
+			break;
+
+		default:
+			return false;
+		}
+	}
+
+#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
+	bool IsBeltInventoryCell()
+	{
+		bool bResult = c_Belt_Inventory_Slot_Start <= cell && c_Belt_Inventory_Slot_End > cell;
+		return bResult;
+	}
+#endif
+
+	bool operator==(const struct SItemPos& rhs) const
+	{
+		return (window_type == rhs.window_type) && (cell == rhs.cell);
+	}
+
+	bool operator<(const struct SItemPos& rhs) const
+	{
+		return (window_type < rhs.window_type) || ((window_type == rhs.window_type) && (cell < rhs.cell));
+	}
+} TItemPos;
+#pragma pack(pop)
+
+const DWORD c_QuickBar_Line_Count = 3;
+const DWORD c_QuickBar_Slot_Count = 12;
+
+const float c_Idle_WaitTime = 5.0f;
+
+const int c_Monster_Race_Start_Number = 6;
+const int c_Monster_Model_Start_Number = 20001;
+
+const float c_fAttack_Delay_Time = 0.2f;
+const float c_fHit_Delay_Time = 0.1f;
+const float c_fCrash_Wave_Time = 0.2f;
+const float c_fCrash_Wave_Distance = 3.0f;
+
+const float c_fHeight_Step_Distance = 50.0f;
+
+enum
+{
+	DISTANCE_TYPE_FOUR_WAY,
+	DISTANCE_TYPE_EIGHT_WAY,
+	DISTANCE_TYPE_ONE_WAY,
+	DISTANCE_TYPE_MAX_NUM,
+};
+
+const float c_fMagic_Script_Version = 1.0f;
+const float c_fSkill_Script_Version = 1.0f;
+const float c_fMagicSoundInformation_Version = 1.0f;
+const float c_fBattleCommand_Script_Version = 1.0f;
+const float c_fEmotionCommand_Script_Version = 1.0f;
+const float c_fActive_Script_Version = 1.0f;
+const float c_fPassive_Script_Version = 1.0f;
+
+// Used by PushMove
+const float c_fWalkDistance = 175.0f;
+const float c_fRunDistance = 310.0f;
+
+#define FILE_MAX_LEN 128
+
+enum
+{
+	ITEM_SOCKET_SLOT_MAX_NUM = 3,
+	ITEM_ATTRIBUTE_SLOT_MAX_NUM = 7,
+};
+
+#pragma pack(push)
+#pragma pack(1)
+
+typedef struct SQuickSlot
+{
+	BYTE Type;
+	BYTE Position;
+} TQuickSlot;
+
+typedef struct TPlayerItemAttribute
+{
+    BYTE        bType;
+    short       sValue;
+} TPlayerItemAttribute;
+
+typedef struct packet_item
+{
+    DWORD       vnum;
+    BYTE        count;
+	DWORD		flags;
+	DWORD		anti_flags;
+	long		alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+    TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
+} TItemData;
+
+typedef struct packet_shop_item
+{
+    DWORD       vnum;
+    DWORD       price;
+    BYTE        count;
+	BYTE		display_pos;
+	long		alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+    TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
+} TShopItemData;
+
+#pragma pack(pop)
+
+inline float GetSqrtDistance(int ix1, int iy1, int ix2, int iy2) // By sqrt
+{
+	float dx, dy;
+
+	dx = float(ix1 - ix2);
+	dy = float(iy1 - iy2);
+
+	return sqrtf(dx*dx + dy*dy);
+}
+
+// DEFAULT_FONT
+void DefaultFont_Startup();
+void DefaultFont_Cleanup();
+void DefaultFont_SetName(const char * c_szFontName);
+CResource* DefaultFont_GetResource();
+CResource* DefaultItalicFont_GetResource();
+// END_OF_DEFAULT_FONT
+
+void SetGuildSymbolPath(const char * c_szPathName);
+const char * GetGuildSymbolFileName(DWORD dwGuildID);
+BYTE SlotTypeToInvenType(BYTE bSlotType);

src/UserInterface/GuildMarkDownloader.cpp

@@ -0,0 +1,453 @@
+#include "StdAfx.h"
+#include "GuildMarkDownloader.h"
+#include "PythonCharacterManager.h"
+#include "Packet.h"
+#include "Test.h"
+
+// MARK_BUG_FIX
+struct SMarkIndex
+{
+	WORD guild_id;
+	WORD mark_id;
+};
+
+// END_OFMARK_BUG_FIX
+
+CGuildMarkDownloader::CGuildMarkDownloader()
+{
+	SetRecvBufferSize(640*1024);
+	SetSendBufferSize(1024);
+	__Initialize();
+}
+
+CGuildMarkDownloader::~CGuildMarkDownloader()
+{
+	__OfflineState_Set();
+}
+
+bool CGuildMarkDownloader::Connect(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey)
+{
+	__OfflineState_Set();
+
+	m_dwHandle=dwHandle;
+	m_dwRandomKey=dwRandomKey;
+	m_dwTodo=TODO_RECV_MARK;
+	return CNetworkStream::Connect(c_rkNetAddr);
+}
+
+bool CGuildMarkDownloader::ConnectToRecvSymbol(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, const std::vector<DWORD> & c_rkVec_dwGuildID)
+{
+	__OfflineState_Set();
+
+	m_dwHandle=dwHandle;
+	m_dwRandomKey=dwRandomKey;
+	m_dwTodo=TODO_RECV_SYMBOL;
+	m_kVec_dwGuildID = c_rkVec_dwGuildID;
+	return CNetworkStream::Connect(c_rkNetAddr);
+}
+
+void CGuildMarkDownloader::Process()
+{
+	CNetworkStream::Process();
+
+	if (!__StateProcess())
+	{
+		__OfflineState_Set();
+		Disconnect();
+	}
+}
+
+void CGuildMarkDownloader::OnConnectFailure()
+{
+	__OfflineState_Set();
+}
+
+void CGuildMarkDownloader::OnConnectSuccess()
+{
+	__LoginState_Set();
+}
+
+void CGuildMarkDownloader::OnRemoteDisconnect()
+{
+	__OfflineState_Set();
+}
+
+void CGuildMarkDownloader::OnDisconnect()
+{
+	__OfflineState_Set();
+}
+
+void CGuildMarkDownloader::__Initialize()
+{
+	m_eState=STATE_OFFLINE;
+	m_pkMarkMgr=NULL;
+	m_currentRequestingImageIndex=0;
+	m_dwBlockIndex=0;
+	m_dwBlockDataPos=0;
+	m_dwBlockDataSize=0;
+
+	m_dwHandle=0;
+	m_dwRandomKey=0;
+	m_dwTodo=TODO_RECV_NONE;
+	m_kVec_dwGuildID.clear();
+}
+
+bool CGuildMarkDownloader::__StateProcess()
+{
+	switch (m_eState)
+	{
+		case STATE_LOGIN:
+			return __LoginState_Process();
+			break;
+		case STATE_COMPLETE:
+			return false;
+	}
+
+	return true;
+}
+
+void CGuildMarkDownloader::__OfflineState_Set()
+{
+	__Initialize();
+}
+
+void CGuildMarkDownloader::__CompleteState_Set()
+{
+	m_eState = STATE_COMPLETE;
+	CPythonCharacterManager::instance().RefreshAllGuildMark();
+}
+
+void CGuildMarkDownloader::__LoginState_Set()
+{
+	m_eState = STATE_LOGIN;
+}
+
+bool CGuildMarkDownloader::__LoginState_Process()
+{
+	BYTE header;
+
+	if (!Peek(sizeof(BYTE), &header))
+		return true;
+	
+	UINT needPacketSize = __GetPacketSize(header);
+
+	if (!needPacketSize)
+		return false;
+
+	if (!Peek(needPacketSize))
+		return true;
+
+	__DispatchPacket(header);
+	return true;
+}
+
+// MARK_BUG_FIX
+UINT CGuildMarkDownloader::__GetPacketSize(UINT header)
+{
+	switch (header)
+	{
+		case HEADER_GC_PHASE:
+			return sizeof(TPacketGCPhase);
+		case HEADER_GC_HANDSHAKE:
+			return sizeof(TPacketGCHandshake);
+		case HEADER_GC_PING:
+			return sizeof(TPacketGCPing);
+		case HEADER_GC_MARK_IDXLIST:
+			return sizeof(TPacketGCMarkIDXList);
+		case HEADER_GC_MARK_BLOCK:
+			return sizeof(TPacketGCMarkBlock);
+		case HEADER_GC_GUILD_SYMBOL_DATA:
+			return sizeof(TPacketGCGuildSymbolData);
+		case HEADER_GC_MARK_DIFF_DATA:	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			return sizeof(BYTE);
+	}
+	return 0;
+}
+
+bool CGuildMarkDownloader::__DispatchPacket(UINT header)
+{
+	switch (header)
+	{
+		case HEADER_GC_PHASE:
+			return __LoginState_RecvPhase();
+		case HEADER_GC_HANDSHAKE:
+			return __LoginState_RecvHandshake();
+		case HEADER_GC_PING:
+			return __LoginState_RecvPing();
+		case HEADER_GC_MARK_IDXLIST:
+			return __LoginState_RecvMarkIndex();
+		case HEADER_GC_MARK_BLOCK:
+			return __LoginState_RecvMarkBlock();
+		case HEADER_GC_GUILD_SYMBOL_DATA:
+			return __LoginState_RecvSymbolData();
+		case HEADER_GC_MARK_DIFF_DATA: // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			return true;
+	}
+	return false;	
+}
+// END_OF_MARK_BUG_FIX
+
+bool CGuildMarkDownloader::__LoginState_RecvHandshake()
+{
+	TPacketGCHandshake kPacketHandshake;
+	if (!Recv(sizeof(kPacketHandshake), &kPacketHandshake))
+		return false;
+
+	TPacketCGMarkLogin kPacketMarkLogin;
+
+	kPacketMarkLogin.header = HEADER_CG_MARK_LOGIN;
+	kPacketMarkLogin.handle = m_dwHandle;
+	kPacketMarkLogin.random_key = m_dwRandomKey;
+
+	if (!Send(sizeof(kPacketMarkLogin), &kPacketMarkLogin))
+		return false;
+
+	return true;
+}
+
+bool CGuildMarkDownloader::__LoginState_RecvPing()
+{
+	TPacketGCPing kPacketPing;
+
+	if (!Recv(sizeof(kPacketPing), &kPacketPing))
+		return false;
+
+	TPacketCGPong kPacketPong;
+	kPacketPong.bHeader = HEADER_CG_PONG;
+
+	if (!Send(sizeof(TPacketCGPong), &kPacketPong))
+		return false;
+
+	return SendSequence();
+}
+
+bool CGuildMarkDownloader::__LoginState_RecvPhase()
+{
+	TPacketGCPhase kPacketPhase;
+
+	if (!Recv(sizeof(kPacketPhase), &kPacketPhase))
+		return false;
+
+	if (kPacketPhase.phase == PHASE_LOGIN)
+	{
+		switch (m_dwTodo)
+		{
+			case TODO_RECV_NONE:
+			{
+				assert(!"CGuildMarkDownloader::__LoginState_RecvPhase - Todo type is none");
+				break;
+			}
+			case TODO_RECV_MARK:
+			{
+				// MARK_BUG_FIX
+				if (!__SendMarkIDXList())
+					return false;
+				// END_OF_MARK_BUG_FIX
+				break;
+			}
+			case TODO_RECV_SYMBOL:
+			{
+				if (!__SendSymbolCRCList())
+					return false;
+				break;
+			}
+		}
+	}
+
+	return true;
+}			 
+
+// MARK_BUG_FIX
+bool CGuildMarkDownloader::__SendMarkIDXList()
+{
+	TPacketCGMarkIDXList kPacketMarkIDXList;
+	kPacketMarkIDXList.header = HEADER_CG_MARK_IDXLIST;
+	if (!Send(sizeof(kPacketMarkIDXList), &kPacketMarkIDXList))
+		return false;
+
+	return true;
+}
+
+bool CGuildMarkDownloader::__LoginState_RecvMarkIndex()
+{
+	TPacketGCMarkIDXList kPacketMarkIndex;
+
+	if (!Peek(sizeof(kPacketMarkIndex), &kPacketMarkIndex))
+		return false;
+
+	//DWORD bufSize = sizeof(WORD) * 2 * kPacketMarkIndex.count;
+
+	if (!Peek(kPacketMarkIndex.bufSize))
+		return false;
+
+	Recv(sizeof(kPacketMarkIndex));
+
+	WORD guildID, markID;
+
+	for (DWORD i = 0; i < kPacketMarkIndex.count; ++i)
+	{
+		Recv(sizeof(WORD), &guildID);
+		Recv(sizeof(WORD), &markID);
+
+		// <20><><EFBFBD><EFBFBD>ID -> <20><>ũID <20>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD>
+		CGuildMarkManager::Instance().AddMarkIDByGuildID(guildID, markID);
+	}
+
+	// <20><><EFBFBD><EFBFBD> <20><>ũ <20>̹<EFBFBD><CCB9><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5>Ѵ<EFBFBD>. (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
+	CGuildMarkManager::Instance().LoadMarkImages();
+
+	m_currentRequestingImageIndex = 0;
+	__SendMarkCRCList();
+	return true;
+}
+
+bool CGuildMarkDownloader::__SendMarkCRCList()
+{
+	TPacketCGMarkCRCList kPacketMarkCRCList;
+
+	if (!CGuildMarkManager::Instance().GetBlockCRCList(m_currentRequestingImageIndex, kPacketMarkCRCList.crclist))
+		__CompleteState_Set();
+	else
+	{
+		kPacketMarkCRCList.header = HEADER_CG_MARK_CRCLIST;
+		kPacketMarkCRCList.imgIdx = m_currentRequestingImageIndex;
+		++m_currentRequestingImageIndex;
+
+		if (!Send(sizeof(kPacketMarkCRCList), &kPacketMarkCRCList))
+			return false;
+	}
+	return true;
+}
+
+bool CGuildMarkDownloader::__LoginState_RecvMarkBlock()
+{
+	TPacketGCMarkBlock kPacket;
+
+	if (!Peek(sizeof(kPacket), &kPacket))
+		return false;
+
+	if (!Peek(kPacket.bufSize))
+		return false;
+
+	Recv(sizeof(kPacket));
+
+	BYTE posBlock;
+	DWORD compSize;
+	char compBuf[SGuildMarkBlock::MAX_COMP_SIZE];
+
+	for (DWORD i = 0; i < kPacket.count; ++i)
+	{
+		Recv(sizeof(BYTE), &posBlock);
+		Recv(sizeof(DWORD), &compSize);
+
+		if (compSize > SGuildMarkBlock::MAX_COMP_SIZE)
+		{
+			TraceError("RecvMarkBlock: data corrupted");
+			Recv(compSize);
+		}
+		else
+		{
+			Recv(compSize, compBuf);
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>. CRC<52><43> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Բ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ȴ<EFBFBD>.
+			CGuildMarkManager::Instance().SaveBlockFromCompressedData(kPacket.imgIdx, posBlock, (const BYTE *) compBuf, compSize);
+		}
+	}
+
+	if (kPacket.count > 0)
+	{
+		// <20><>ũ <20>̹<EFBFBD><CCB9><EFBFBD> <20><><EFBFBD><EFBFBD>
+		CGuildMarkManager::Instance().SaveMarkImage(kPacket.imgIdx);
+
+		// <20><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD>ε<EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ص<EFBFBD> <20><><EFBFBD>ΰ<EFBFBD><CEB0><EFBFBD> <20><> <20><><EFBFBD>̰<EFBFBD> <20><>)
+		std::string imagePath;
+
+		if (CGuildMarkManager::Instance().GetMarkImageFilename(kPacket.imgIdx, imagePath))
+		{
+			CResource * pResource = CResourceManager::Instance().GetResourcePointer(imagePath.c_str());
+			if (pResource->IsType(CGraphicImage::Type()))
+			{
+				CGraphicImage* pkGrpImg=static_cast<CGraphicImage*>(pResource);
+				pkGrpImg->Reload();
+			}
+		}
+	}
+
+	// <20><> <20><>û<EFBFBD><C3BB> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>û<EFBFBD>ϰ<EFBFBD> <20>ƴϸ<C6B4> <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD>
+	if (m_currentRequestingImageIndex < CGuildMarkManager::Instance().GetMarkImageCount())
+		__SendMarkCRCList();
+	else
+		__CompleteState_Set();
+
+	return true;
+}
+// END_OF_MARK_BUG_FIX
+
+bool CGuildMarkDownloader::__SendSymbolCRCList()
+{
+	for (DWORD i=0; i<m_kVec_dwGuildID.size(); ++i)
+	{
+		TPacketCGSymbolCRC kSymbolCRCPacket;
+		kSymbolCRCPacket.header = HEADER_CG_GUILD_SYMBOL_CRC;
+		kSymbolCRCPacket.dwGuildID = m_kVec_dwGuildID[i];
+
+		std::string strFileName = GetGuildSymbolFileName(m_kVec_dwGuildID[i]);
+		kSymbolCRCPacket.dwCRC = GetFileCRC32(strFileName.c_str());
+		kSymbolCRCPacket.dwSize = GetFileSize(strFileName.c_str());
+#ifdef _DEBUG
+		printf("__SendSymbolCRCList [GuildID:%d / CRC:%u]\n", m_kVec_dwGuildID[i], kSymbolCRCPacket.dwCRC);
+#endif
+		if (!Send(sizeof(kSymbolCRCPacket), &kSymbolCRCPacket))
+			return false;
+	}
+
+	return true;
+}
+
+bool CGuildMarkDownloader::__LoginState_RecvSymbolData()
+{
+	TPacketGCBlankDynamic packet;
+	if (!Peek(sizeof(TPacketGCBlankDynamic), &packet))
+		return true;
+
+#ifdef _DEBUG
+	printf("__LoginState_RecvSymbolData [%d/%d]\n", GetRecvBufferSize(), packet.size);
+#endif
+	if (packet.size > GetRecvBufferSize())
+		return true;
+
+	//////////////////////////////////////////////////////////////
+
+	TPacketGCGuildSymbolData kPacketSymbolData;
+	if (!Recv(sizeof(kPacketSymbolData), &kPacketSymbolData))
+		return false;
+
+	WORD wDataSize = kPacketSymbolData.size - sizeof(kPacketSymbolData);
+	DWORD dwGuildID = kPacketSymbolData.guild_id;
+	BYTE * pbyBuf = new BYTE [wDataSize];
+
+	if (!Recv(wDataSize, pbyBuf))
+	{
+		delete[] pbyBuf;
+		return false;
+	}
+
+	MyCreateDirectory(g_strGuildSymbolPathName.c_str());
+
+	std::string strFileName = GetGuildSymbolFileName(dwGuildID);
+
+	FILE * File = fopen(strFileName.c_str(), "wb");
+	if (!File)
+	{
+		delete[] pbyBuf;
+		return false;
+	}
+	fwrite(pbyBuf, wDataSize, 1, File);
+	fclose(File);
+
+#ifdef _DEBUG
+	printf("__LoginState_RecvSymbolData(filename:%s, datasize:%d, guildid:%d)\n", strFileName.c_str(), wDataSize, dwGuildID);
+#endif
+
+	delete[] pbyBuf;
+	return true;
+}

src/UserInterface/GuildMarkDownloader.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "../EterLib/NetStream.h"
+#include "MarkManager.h"
+
+class CGuildMarkDownloader : public CNetworkStream, public CSingleton<CGuildMarkDownloader>
+{
+	public:
+		CGuildMarkDownloader();
+		virtual ~CGuildMarkDownloader();
+
+		bool Connect(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey);
+		bool ConnectToRecvSymbol(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, const std::vector<DWORD> & c_rkVec_dwGuildID);
+
+		void Process();
+
+	private:
+		enum
+		{
+			STATE_OFFLINE,
+			STATE_LOGIN,
+			STATE_COMPLETE,
+		};
+
+		enum
+		{
+			TODO_RECV_NONE,
+			TODO_RECV_MARK,
+			TODO_RECV_SYMBOL,
+		};
+
+	private:
+		void OnConnectFailure();
+		void OnConnectSuccess();
+		void OnRemoteDisconnect();
+		void OnDisconnect();
+
+		void __Initialize();
+		bool __StateProcess();
+
+		UINT __GetPacketSize(UINT header);
+		bool __DispatchPacket(UINT header);
+
+		void __OfflineState_Set();
+		void __CompleteState_Set();
+
+		void __LoginState_Set();
+		bool __LoginState_Process();
+		bool __LoginState_RecvPhase();
+		bool __LoginState_RecvHandshake();
+		bool __LoginState_RecvPing();
+		bool __LoginState_RecvMarkIndex();
+		bool __LoginState_RecvMarkBlock();
+		bool __LoginState_RecvSymbolData();
+		bool __SendMarkIDXList();
+		bool __SendMarkCRCList();
+		bool __SendSymbolCRCList();
+
+	private:
+		DWORD m_dwHandle;
+		DWORD m_dwRandomKey;
+		DWORD m_dwTodo;
+
+		std::vector<DWORD> m_kVec_dwGuildID;
+
+		UINT m_eState;
+
+		BYTE m_currentRequestingImageIndex;
+
+		CGuildMarkManager * m_pkMarkMgr;
+
+		DWORD m_dwBlockIndex;
+		DWORD m_dwBlockDataSize;
+		DWORD m_dwBlockDataPos;
+};

src/UserInterface/GuildMarkUploader.cpp

@@ -0,0 +1,405 @@
+#include "StdAfx.h"
+#include "GuildMarkUploader.h"
+#include "Packet.h"
+#include "Test.h"
+
+#ifdef __VTUNE__
+#else
+
+CGuildMarkUploader::CGuildMarkUploader()
+ : m_pbySymbolBuf(NULL)
+{
+	SetRecvBufferSize(1024);
+	SetSendBufferSize(1024);
+	__Inialize();
+}
+
+CGuildMarkUploader::~CGuildMarkUploader()
+{
+	__OfflineState_Set();
+}
+
+void CGuildMarkUploader::Disconnect()
+{
+	__OfflineState_Set();
+}
+
+bool CGuildMarkUploader::IsCompleteUploading()
+{
+	return STATE_OFFLINE == m_eState;
+}
+
+bool CGuildMarkUploader::__Save(const char* c_szFileName)
+{
+	/* <20><><EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʾƾ<CABE> <20><>;
+	ILuint uImg;
+	ilGenImages(1, &uImg);
+	ilBindImage(uImg);
+	ilEnable(IL_FILE_OVERWRITE);
+	ilEnable(IL_ORIGIN_SET);
+	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
+
+	if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring)c_szFileName))	
+	{
+		return false;
+	}
+
+	if (ilGetInteger(IL_IMAGE_WIDTH) != CGuildMarkImage::WIDTH)	
+	{
+		return false;
+	}
+
+	if (ilGetInteger(IL_IMAGE_HEIGHT) != CGuildMarkImage::HEIGHT)
+	{
+		return false;
+	}
+
+	ilConvertImage(IL_BGRA, IL_BYTE);
+
+	UINT uColCount = CGuildMarkImage::MARK_COL_COUNT;
+	UINT uCol = m_dwGuildID % uColCount;
+	UINT uRow = m_dwGuildID / uColCount;
+
+	ilSetPixels(uCol*SGuildMark::WIDTH, uRow*SGuildMark::HEIGHT, 0, SGuildMark::WIDTH, SGuildMark::HEIGHT, 1, IL_BGRA, IL_BYTE, (ILvoid*)m_kMark.m_apxBuf);
+
+	ilSave(IL_TGA, (ILstring)c_szFileName);
+
+	ilDeleteImages(1, &uImg);
+	*/
+	return true;
+}
+
+bool CGuildMarkUploader::__Load(const char* c_szFileName, UINT* peError)
+{
+	ILuint uImg;
+	ilGenImages(1, &uImg);
+	ilBindImage(uImg);
+	ilEnable(IL_ORIGIN_SET);
+	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
+
+	if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring)c_szFileName))	
+	{
+		*peError=ERROR_LOAD;
+		return false;
+	}
+
+	if (ilGetInteger(IL_IMAGE_WIDTH)!=SGuildMark::WIDTH)	
+	{
+		*peError=ERROR_WIDTH;
+		return false;
+	}
+
+	if (ilGetInteger(IL_IMAGE_HEIGHT)!=SGuildMark::HEIGHT)
+	{
+		*peError=ERROR_HEIGHT;
+		return false;
+	}
+
+	ilConvertImage(IL_BGRA, IL_BYTE);
+
+	ilCopyPixels(0, 0, 0, SGuildMark::WIDTH, SGuildMark::HEIGHT, 1, IL_BGRA, IL_BYTE, m_kMark.m_apxBuf);
+
+	ilDeleteImages(1, &uImg);
+	return true;
+}
+
+bool CGuildMarkUploader::__LoadSymbol(const char* c_szFileName, UINT* peError)
+{
+	//	For Check Image
+	ILuint uImg;
+	ilGenImages(1, &uImg);
+	ilBindImage(uImg);
+	ilEnable(IL_ORIGIN_SET);
+	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
+	if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring)c_szFileName))
+	{
+		*peError=ERROR_LOAD;
+		return false;
+	}
+	if (ilGetInteger(IL_IMAGE_WIDTH) != 64)
+	{
+		*peError=ERROR_WIDTH;
+		return false;
+	}
+	if (ilGetInteger(IL_IMAGE_HEIGHT) != 128)
+	{
+		*peError=ERROR_HEIGHT;
+		return false;
+	}
+	ilDeleteImages(1, &uImg);
+	ilShutDown();
+
+	/////
+
+	FILE * file = fopen(c_szFileName, "rb");
+	if (!file)
+	{
+		*peError=ERROR_LOAD;
+	}
+
+	fseek(file, 0, SEEK_END);
+	m_dwSymbolBufSize = ftell(file);
+	fseek(file, 0, SEEK_SET);
+
+	m_pbySymbolBuf = new BYTE [m_dwSymbolBufSize];
+	fread(m_pbySymbolBuf, m_dwSymbolBufSize, 1, file);
+
+	fclose(file);
+
+	/////
+
+	m_dwSymbolCRC32 = GetFileCRC32(c_szFileName);
+	return true;
+}
+
+bool CGuildMarkUploader::Connect(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError)
+{
+	__OfflineState_Set();
+	SetRecvBufferSize(1024);
+	SetSendBufferSize(1024);
+
+	if (!CNetworkStream::Connect(c_rkNetAddr))
+	{
+		*peError=ERROR_CONNECT;
+		return false;
+	}
+
+	m_dwSendType=SEND_TYPE_MARK;
+	m_dwHandle=dwHandle;
+	m_dwRandomKey=dwRandomKey;
+	m_dwGuildID=dwGuildID;
+
+	if (!__Load(c_szFileName, peError))
+		return false;
+		
+	//if (!__Save(CGraphicMarkInstance::GetImageFileName().c_str()))
+	//	return false;
+	//CGraphicMarkInstance::ReloadImageFile();
+	return true;
+}
+
+bool CGuildMarkUploader::ConnectToSendSymbol(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError)
+{
+	__OfflineState_Set();
+	SetRecvBufferSize(1024);
+	SetSendBufferSize(64*1024);
+
+	if (!CNetworkStream::Connect(c_rkNetAddr))
+	{
+		*peError=ERROR_CONNECT;
+		return false;
+	}
+
+	m_dwSendType=SEND_TYPE_SYMBOL;
+	m_dwHandle=dwHandle;
+	m_dwRandomKey=dwRandomKey;
+	m_dwGuildID=dwGuildID;
+
+	if (!__LoadSymbol(c_szFileName, peError))
+		return false;
+
+	return true;
+}
+
+void CGuildMarkUploader::Process()
+{
+	CNetworkStream::Process();
+
+	if (!__StateProcess())
+	{
+		__OfflineState_Set();
+		Disconnect();
+	}
+}
+
+void CGuildMarkUploader::OnConnectFailure()
+{
+	__OfflineState_Set();
+}
+
+void CGuildMarkUploader::OnConnectSuccess()
+{
+	__LoginState_Set();
+}
+
+void CGuildMarkUploader::OnRemoteDisconnect()
+{
+	__OfflineState_Set();
+}
+
+void CGuildMarkUploader::OnDisconnect()
+{
+	__OfflineState_Set();
+}
+
+void CGuildMarkUploader::__Inialize()
+{
+	m_eState = STATE_OFFLINE;
+
+	m_dwGuildID = 0;
+	m_dwHandle = 0;
+	m_dwRandomKey = 0;
+
+	if (m_pbySymbolBuf)
+	{
+		delete m_pbySymbolBuf;
+	}
+
+	m_dwSymbolBufSize = 0;
+	m_pbySymbolBuf = NULL;
+}
+
+bool CGuildMarkUploader::__StateProcess()
+{
+	switch (m_eState)
+	{
+		case STATE_LOGIN:
+			return __LoginState_Process();
+			break;
+	}
+
+	return true;
+}
+
+void CGuildMarkUploader::__OfflineState_Set()
+{
+	__Inialize();
+}
+
+void CGuildMarkUploader::__CompleteState_Set()
+{
+	m_eState=STATE_COMPLETE;
+
+	__OfflineState_Set();
+}
+
+
+void CGuildMarkUploader::__LoginState_Set()
+{
+	m_eState=STATE_LOGIN;
+}
+
+bool CGuildMarkUploader::__LoginState_Process()
+{
+	if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CGuildMarkUploader::__LoginState_RecvPhase))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CGuildMarkUploader::__LoginState_RecvHandshake))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CGuildMarkUploader::__LoginState_RecvPing))
+		return false;
+
+	return true;
+}
+
+bool CGuildMarkUploader::__SendMarkPacket()
+{
+	TPacketCGMarkUpload kPacketMarkUpload;
+	kPacketMarkUpload.header=HEADER_CG_MARK_UPLOAD;
+	kPacketMarkUpload.gid=m_dwGuildID;
+
+	assert(sizeof(kPacketMarkUpload.image) == sizeof(m_kMark.m_apxBuf));
+	memcpy(kPacketMarkUpload.image, m_kMark.m_apxBuf, sizeof(kPacketMarkUpload.image));
+
+	if (!Send(sizeof(kPacketMarkUpload), &kPacketMarkUpload))
+		return false;
+
+	return true;
+}
+bool CGuildMarkUploader::__SendSymbolPacket()
+{
+	if (!m_pbySymbolBuf)
+		return false;
+
+	TPacketCGSymbolUpload kPacketSymbolUpload;
+	kPacketSymbolUpload.header=HEADER_CG_GUILD_SYMBOL_UPLOAD;
+	kPacketSymbolUpload.handle=m_dwGuildID;
+	kPacketSymbolUpload.size=sizeof(TPacketCGSymbolUpload) + m_dwSymbolBufSize;
+
+	if (!Send(sizeof(TPacketCGSymbolUpload), &kPacketSymbolUpload))
+		return false;
+	if (!Send(m_dwSymbolBufSize, m_pbySymbolBuf))
+		return false;
+
+#ifdef _DEBUG
+	printf("__SendSymbolPacket : [GuildID:%d/PacketSize:%d/BufSize:%d/CRC:%d]\n", m_dwGuildID, kPacketSymbolUpload.size, m_dwSymbolBufSize, m_dwSymbolCRC32);
+#endif
+
+	CNetworkStream::__SendInternalBuffer();
+	__CompleteState_Set();
+
+	return true;
+}
+
+bool CGuildMarkUploader::__LoginState_RecvPhase()
+{
+	TPacketGCPhase kPacketPhase;
+	if (!Recv(sizeof(kPacketPhase), &kPacketPhase))
+		return false;
+
+	if (kPacketPhase.phase==PHASE_LOGIN)
+	{
+		if (SEND_TYPE_MARK == m_dwSendType)
+		{
+			if (!__SendMarkPacket())
+				return false;
+		}
+		else if (SEND_TYPE_SYMBOL == m_dwSendType)
+		{
+			if (!__SendSymbolPacket())
+				return false;
+		}
+	}
+
+	return true;
+}
+
+bool CGuildMarkUploader::__LoginState_RecvHandshake()
+{
+	TPacketGCHandshake kPacketHandshake;
+	if (!Recv(sizeof(kPacketHandshake), &kPacketHandshake))
+		return false;
+
+	{
+		TPacketCGMarkLogin kPacketMarkLogin;
+		kPacketMarkLogin.header=HEADER_CG_MARK_LOGIN;
+		kPacketMarkLogin.handle=m_dwHandle;
+		kPacketMarkLogin.random_key=m_dwRandomKey;
+		if (!Send(sizeof(kPacketMarkLogin), &kPacketMarkLogin))
+			return false;
+	}
+
+	return true;
+}
+
+bool CGuildMarkUploader::__LoginState_RecvPing()
+{
+	TPacketGCPing kPacketPing;
+	if (!Recv(sizeof(kPacketPing), &kPacketPing))
+		return false;
+
+	TPacketCGPong kPacketPong;
+	kPacketPong.bHeader = HEADER_CG_PONG;
+
+	if (!Send(sizeof(TPacketCGPong), &kPacketPong))
+		return false;
+
+	return SendSequence();
+}
+
+bool CGuildMarkUploader::__AnalyzePacket(UINT uHeader, UINT uPacketSize, bool (CGuildMarkUploader::*pfnDispatchPacket)())
+{
+	BYTE bHeader;
+	if (!Peek(sizeof(bHeader), &bHeader))
+		return true;
+
+	if (bHeader!=uHeader)
+		return true;
+
+	if (!Peek(uPacketSize))
+		return true;
+
+	return (this->*pfnDispatchPacket)();
+}
+#endif

src/UserInterface/GuildMarkUploader.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include "../EterLib/NetStream.h"
+#include "MarkImage.h"
+
+#ifdef __VTUNE__
+
+class CGuildMarkUploader : public CNetworkStream, public CSingleton<CGuildMarkUploader>
+{
+	public:
+		enum
+		{
+			ERROR_NONE,
+			ERROR_CONNECT,
+			ERROR_LOAD,
+			ERROR_WIDTH,
+			ERROR_HEIGHT,
+		};
+
+	public:
+		CGuildMarkUploader() {}
+		virtual ~CGuildMarkUploader() {}
+
+		void Disconnect() {}
+		bool Connect(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError) {return false;}
+		bool ConnectToSendSymbol(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError) {return false;}
+		void Process() {}
+};
+
+#else
+
+#include <il/il.h>
+
+class CGuildMarkUploader : public CNetworkStream, public CSingleton<CGuildMarkUploader>
+{
+	public:
+		enum
+		{
+			ERROR_NONE,
+			ERROR_CONNECT,
+			ERROR_LOAD,
+			ERROR_WIDTH,
+			ERROR_HEIGHT,
+		};
+
+		enum
+		{
+			SEND_TYPE_MARK,
+			SEND_TYPE_SYMBOL,
+		};
+
+	public:
+		CGuildMarkUploader();
+		virtual ~CGuildMarkUploader();
+
+		void Disconnect();
+		bool Connect(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError);
+		bool ConnectToSendSymbol(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError);
+		bool IsCompleteUploading();
+
+		void Process();
+
+	private:
+		enum
+		{
+			STATE_OFFLINE,
+			STATE_LOGIN,
+			STATE_COMPLETE,
+		};
+
+	private:
+		void OnConnectFailure();
+		void OnConnectSuccess();
+		void OnRemoteDisconnect();
+		void OnDisconnect();
+
+		bool __Load(const char* c_szFileName, UINT* peError);
+		bool __LoadSymbol(const char* c_szFileName, UINT* peError);
+
+		bool __Save(const char* c_szFileName);
+
+		void __Inialize();
+		bool __StateProcess();
+
+		void __OfflineState_Set();
+		void __CompleteState_Set();
+
+		void __LoginState_Set();
+		bool __LoginState_Process();
+		bool __LoginState_RecvPhase();
+		bool __LoginState_RecvHandshake();
+		bool __LoginState_RecvPing();
+
+		bool __AnalyzePacket(UINT uHeader, UINT uPacketSize, bool (CGuildMarkUploader::*pfnDispatchPacket)());
+
+		bool __SendMarkPacket();
+		bool __SendSymbolPacket();
+
+	private:
+		UINT m_eState;
+
+		DWORD m_dwSendType;
+		DWORD m_dwHandle;
+		DWORD m_dwRandomKey;
+		DWORD m_dwGuildID;
+
+		SGuildMark m_kMark;
+
+		DWORD m_dwSymbolBufSize;
+		DWORD m_dwSymbolCRC32;
+		BYTE * m_pbySymbolBuf;
+};
+
+#endif

src/UserInterface/HackShield.cpp

@@ -0,0 +1,380 @@
+#include "StdAfx.h"
+#include "Hackshield.h"
+
+#ifdef USE_AHNLAB_HACKSHIELD
+
+#if defined(LOCALE_SERVICE_EUROPE)
+#define METIN2HS_MONITORING_SERVER_ADDR "79.110.88.84"
+#elif
+#define METIN2HS_MONITORING_SERVER_ADDR "79.110.88.84" // GF
+#endif
+//#define METIN2HS_MONITORING_SERVER_ADDR "119.192.130.160"  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> pc
+
+#include METIN2HS_INCLUDE_HSUPCHK
+#include METIN2HS_INCLUDE_HSUSERUTIL
+#include METIN2HS_INCLUDE_HSHIELD
+#include METIN2HS_INCLUDE_HSHIELDLIBLINK
+
+#define MA_MAX_PATH MAX_PATH
+#define MA_T
+#define MA_TCHAR char
+#define MA_StringFormat snprintf
+#define MA_ARRAYCOUNT sizeof
+
+static DWORD gs_dwMainThreadID = 0;
+
+static bool gs_isHackDetected = false;
+static char gs_szHackMsg[256];
+
+void MA_PathSplit(MA_TCHAR* src, MA_TCHAR* branch, size_t branchLen, MA_TCHAR* leaf, size_t leafLen)
+{
+	char* p = src;
+	char* n = p;
+	while (n = strchr(p, '\\'))
+		p = n + 1;
+
+	if (branch)
+		strncpy(branch, src, p - src);
+
+	if (leaf)
+		strcpy(leaf, p);	
+}
+
+void MA_PathMerge(MA_TCHAR* dst, size_t dstLen, MA_TCHAR* branch, MA_TCHAR* leaf)
+{
+	snprintf(dst, dstLen, "%s\\%s", branch, leaf);
+}
+
+int __stdcall AhnHS_Callback(long lCode, long lParamSize, void* pParam)
+{
+	switch (lCode)
+	{
+		//Engine Callback
+	case AHNHS_ENGINE_DETECT_GAME_HACK:
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_GAME_HACK\n%s"), (char*)pParam);
+			gs_isHackDetected = true;
+			break;
+		}
+		//â<><C3A2><EFBFBD><EFBFBD> <20><>ŷ<EFBFBD><C5B7> <20><><EFBFBD><EFBFBD>
+	case AHNHS_ENGINE_DETECT_WINDOWED_HACK:
+		{
+			//MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_WINDOWED_HACK"));
+			//gs_isHackDetected = true;
+			break;
+		}
+
+		//Speed <20><><EFBFBD><EFBFBD>
+	case AHNHS_ACTAPC_DETECT_SPEEDHACK:
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_SPEED_HACK"));
+			gs_isHackDetected = true;
+			break;
+		}
+
+		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 
+	case AHNHS_ACTAPC_DETECT_KDTRACE:
+//	case AHNHS_ACTAPC_DETECT_KDTRACE_CHANGED:
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_DEBUGING(checkCode=%x)"), lCode);			
+			gs_isHackDetected = true;
+			break;
+		}
+
+	case AHNHS_ACTAPC_DETECT_AUTOMACRO:
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_MACRO(checkCode=%x)"), lCode);
+			gs_isHackDetected = true;
+			break;
+		}
+
+		// <20>ڵ<EFBFBD> <20><>ġ <20><><EFBFBD><EFBFBD>
+	case AHNHS_ACTAPC_DETECT_ABNORMAL_MEMORY_ACCESS:
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_MEMORY_ACCESS\n%s"), (char*)pParam);
+			gs_isHackDetected = true;
+			break;
+		}
+
+		//<2F>޸<EFBFBD><DEB8><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+	case AHNHS_ACTAPC_DETECT_MEM_MODIFY_FROM_LMP:  //<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ּ<EFBFBD> (Randomized Base Address) Ȯ<><C8AE><EFBFBD>غ<EFBFBD><D8BA><EFBFBD>. Linker->Advanced->(/DYNAMICBASE:NO)
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_MEMORY_MODIFY"));
+			gs_isHackDetected = true;
+			
+		}
+		break;
+
+		// <20>ٽ<EFBFBD><D9BD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>޸<EFBFBD><DEB8><EFBFBD> <20><>ȣ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʽ<EFBFBD><CABD>ϴ<EFBFBD>.
+	case AHNHS_ACTAPC_DETECT_LMP_FAILED:
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("LOCAL_MEMORY_PROTECT_FAILED"));
+			gs_isHackDetected = true;
+			
+		}
+		break;
+
+		//<2F>׿<EFBFBD> <20><>ŷ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>̻<EFBFBD> 
+//	case AHNHS_ACTAPC_DETECT_AUTOMOUSE:
+	case AHNHS_ACTAPC_DETECT_DRIVERFAILED:
+	case AHNHS_ACTAPC_DETECT_HOOKFUNCTION:
+//	case AHNHS_ACTAPC_DETECT_MESSAGEHOOK:
+//	case AHNHS_ACTAPC_DETECT_MODULE_CHANGE:
+	case AHNHS_ACTAPC_DETECT_ENGINEFAILED:
+	case AHNHS_ACTAPC_DETECT_CODEMISMATCH:
+//	case AHNHS_ACTAPC_DETECT_PROTECTSCREENFAILED:	
+		{
+			MA_StringFormat(gs_szHackMsg, MA_ARRAYCOUNT(gs_szHackMsg), MA_T("DETECT_HACKING(checkCode = %x)\n"), lCode);
+			gs_isHackDetected = true;
+			break;
+		}
+	}
+	return 1;
+}
+
+bool HackShield_PollEvent()
+{
+	return gs_isHackDetected;
+	//return false;
+}
+
+bool HackShield_Init()
+{
+
+	MA_TCHAR szModuleDirPath[MA_MAX_PATH];
+	::GetCurrentDirectory(MA_ARRAYCOUNT(szModuleDirPath), szModuleDirPath);
+
+#ifndef _DEBUG
+	//<2F>ٽ<EFBFBD><D9BD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
+	DWORD dwUpRet = 0; 
+	MA_TCHAR szFullFilePath[MA_MAX_PATH];
+	// <20>ٽ<EFBFBD><D9BD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>. 
+	MA_PathMerge(szFullFilePath, MA_ARRAYCOUNT(szFullFilePath), szModuleDirPath, "hshield");
+	AHNHS_EXT_ERRORINFO HsExtError = {0,}; 
+	
+	// _AhnHS_HSUpdate <20>Լ<EFBFBD> ȣ<><C8A3> 
+	dwUpRet = _AhnHS_HSUpdateEx( szFullFilePath, // <20>ٽ<EFBFBD><D9BD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 
+							1000 * 600, // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><>ü Ÿ<><C5B8> <20>ƿ<EFBFBD> 
+							METIN2HS_CODE, // <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> 
+							AHNHSUPDATE_CHKOPT_HOSTFILE| AHNHSUPDATE_CHKOPT_GAMECODE, 
+							HsExtError, 
+							1000* 20 ); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ÿ<>Ӿƿ<D3BE> 
+							
+	// Ex <20>Լ<EFBFBD><D4BC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϽǶ<CFBD><C7B6><EFBFBD> <20>ݵ<EFBFBD><DDB5><EFBFBD> HSUpSetEnv.exe <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> env <20><><EFBFBD>Ͽ<EFBFBD> 
+	// <20><><EFBFBD><EFBFBD> <20>ڵ带 <20>Է<EFBFBD><D4B7>ϼž<CFBC> <20>մϴ<D5B4>. 
+	if ( dwUpRet != ERROR_SUCCESS) 
+	{ 
+		
+		// <20><><EFBFBD><EFBFBD> ó<><C3B3> 
+		switch ( dwUpRet ) 
+		{ 
+			case HSERROR_ENVFILE_NOTREAD: 
+				MessageBox(NULL, MA_T("HACK_SHIELD_UPDATE_ERROR : HSERROR_ENVFILE_NOTREAD"), "HACK_SHIELD", MB_OK);
+				break;
+			case HSERROR_ENVFILE_NOTWRITE: 
+				MessageBox(NULL, MA_T("HACK_SHIELD_UPDATE_ERROR : HSERROR_ENVFILE_NOTWRITE"), "HACK_SHIELD", MB_OK);
+				break;
+			case HSERROR_NETWORK_CONNECT_FAIL: 
+				MessageBox(NULL, MA_T("HACK_SHIELD_UPDATE_ERROR : HSERROR_NETWORK_CONNECT_FAIL"), "HACK_SHIELD", MB_OK);
+				break;
+			case HSERROR_HSUPDATE_TIMEOUT: 
+				MessageBox(NULL, MA_T("HACK_SHIELD_UPDATE_ERROR : HSERROR_HSUPDATE_TIMEOUT"), "HACK_SHIELD", MB_OK);
+				break;
+			case HSERROR_MISMATCH_ENVFILE:
+				MessageBox(NULL, MA_T("HACK_SHIELD_UPDATE_ERROR : HSERROR_MISMATCH_ENVFILE"), "HACK_SHIELD", MB_OK);
+				break;
+			case HSERROR_HOSTFILE_MODIFICATION: 
+				MessageBox(NULL, MA_T("HACK_SHIELD_UPDATE_ERROR : HSERROR_HOSTFILE_MODIFICATION"), "HACK_SHIELD", MB_OK);
+				break;
+			default:
+				break;
+		}
+		
+		MessageBox(NULL, MA_T("HACK_SHIELD_UPDATE_ERROR"), "HACK_SHIELD", MB_OK);
+
+		return false;
+		
+	}
+#endif
+
+	MA_TCHAR szInterfaceFilePath[MA_MAX_PATH];
+	{
+		if (!_AhnHSUserUtil_IsAdmin() && !_AhnHsUserUtil_IsEnableHSAdminRights())
+		{
+			DWORD dwRet = _AhnHsUserUtil_CreateUser();
+			switch (dwRet)
+			{
+			case HSUSERUTIL_ERR_OK: // pass
+				break;
+			case HSUSERUTIL_ERR_NOT_ADMIN: // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϹǷ<CFB9> <20><><EFBFBD><EFBFBD> <20>ƴ<EFBFBD>
+				break;
+			case HSUSERUTIL_ERR_NOT_NT: // 98 <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϹǷ<CFB9> <20><><EFBFBD><EFBFBD> <20>ƴ<EFBFBD>
+				break;
+			case HSUSERUTIL_ERR_DELHIDEIDINFO_FAIL:
+				MessageBox(NULL, MA_T("DEL_SHADOW_HIDDEN_ERROR"), "HACK_SHIELD", MB_OK);
+				return false;
+			case HSUSERUTIL_ERR_DELSHADOWACNT_FAIL:
+				MessageBox(NULL, MA_T("DEL_SHADOW_ACCOUNT_ERROR"), "HACK_SHIELD", MB_OK);
+				return false;			
+			case HSUSERUTIL_ERR_ADDSHADOWACNT_FAIL:
+				MessageBox(NULL, MA_T("ADD_SHADOW_ACCOUNT_ERROR"), "HACK_SHIELD", MB_OK);
+				return false;						
+			}
+
+		}
+
+#ifdef _DEBUG
+		MA_PathMerge(szInterfaceFilePath, MA_ARRAYCOUNT(szInterfaceFilePath), szModuleDirPath, "hshield\\EHsvc.dll");
+#else
+		MA_PathMerge(szInterfaceFilePath, MA_ARRAYCOUNT(szInterfaceFilePath), szModuleDirPath, "hshield\\EHsvc.dll");
+#endif
+	}
+
+#ifndef _DEBUG
+	{
+		AHNHS_EXT_ERRORINFO HsExtError = { 0, };
+		strcpy(HsExtError.szServer, METIN2HS_MONITORING_SERVER_ADDR); //<2F><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20>ּ<EFBFBD>	
+		strcpy(HsExtError.szGameVersion, "1.0.0.0"); //Game <20><><EFBFBD><EFBFBD>
+		strcpy(HsExtError.szUserId, "Metin2User_test"); //<2F><><EFBFBD><EFBFBD> ID
+
+		DWORD dwRet = _AhnHS_StartMonitor (HsExtError, szInterfaceFilePath);
+		if( dwRet != ERROR_SUCCESS )
+		{
+			MessageBox(NULL, MA_T("START_MONITORING_SERVICE_ERROR"), "HACK_SHIELD", MB_OK);
+		}
+	}
+#endif
+
+	{
+		int nRet = _AhnHS_Initialize(szInterfaceFilePath, AhnHS_Callback, 
+			METIN2HS_CODE,
+			METIN2HS_LICENSE,
+			AHNHS_CHKOPT_SPEEDHACK 
+			| AHNHS_CHKOPT_READWRITEPROCESSMEMORY 
+			| AHNHS_CHKOPT_KDTRACER 
+//			| AHNHS_CHKOPT_OPENPROCESS 
+			| AHNHS_CHKOPT_AUTOMOUSE 			
+			| AHNHS_CHKOPT_MESSAGEHOOK
+			| AHNHS_CHKOPT_PROTECT_D3DX
+			| AHNHS_CHKOPT_LOCAL_MEMORY_PROTECTION // <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD> <20><>ȣ
+			//| AHNHS_CHKOPT_ANTIFREESERVER // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			| AHNHS_USE_LOG_FILE			
+//			| AHNHS_ALLOW_SVCHOST_OPENPROCESS
+			//| AHNHS_ALLOW_LSASS_OPENPROCESS // <20>ſ<EFBFBD> ī<><C4AB> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			//| AHNHS_ALLOW_CSRSS_OPENPROCESS // <20>ſ<EFBFBD> ī<><C4AB> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			//| AHNHS_CHKOPT_SELF_DESTRUCTION // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ó<><C3B3>: <20>ݹ<EFBFBD> ó<><C3B3> <20><><EFBFBD><EFBFBD>
+			| AHNHS_CHKOPT_PROCESSSCAN
+			| AHNHS_CHKOPT_UPDATED_FILE_CHECK
+			| AHNHS_CHKOPT_SEND_MONITOR_ONCE // <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD><CDB8><EFBFBD>: 1ȸ<31><C8B8> <20><><EFBFBD><EFBFBD>
+			| AHNHS_CHKOPT_SEND_MONITOR_DELAY // <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD><CDB8><EFBFBD>: <20><><EFBFBD>̵<EFBFBD><CCB5><EFBFBD> õõ<C3B5><C3B5> <20><><EFBFBD><EFBFBD>
+			| AHNHS_DONOT_TERMINATE_PROCESS, // <20><><EFBFBD><EFBFBD> <20>˸<EFBFBD>	
+			AHNHS_SPEEDHACK_SENSING_RATIO_NORMAL
+			);
+
+		if (nRet != HS_ERR_OK) 
+		{
+			//Error ó<><C3B3> 
+			switch(nRet)
+			{
+				case HS_ERR_ANOTHER_SERVICE_RUNNING:
+				{
+					MessageBox(NULL, MA_T("ANOTHER_SERVICE_RUNNING"), "HACK_SHIELD", MB_OK);
+					break;
+				}
+				case HS_ERR_INVALID_LICENSE:
+				{
+					MessageBox(NULL, MA_T("INVALID_LICENSE"), "HACK_SHIELD", MB_OK);
+					break;
+				}
+				case HS_ERR_INVALID_FILES:
+				{
+					MessageBox(NULL, MA_T("INVALID_FILES"), "HACK_SHIELD", MB_OK);
+					break;
+				}
+				case HS_ERR_DEBUGGER_DETECT:
+				{
+					MessageBox(NULL, MA_T("DEBUG_DETECT"), "HACK_SHIELD", MB_OK);
+					break;
+				}
+				case HS_ERR_NEED_ADMIN_RIGHTS:
+				{
+					MessageBox(NULL, MA_T("NEED_ADMIN_RIGHTS"), "HACK_SHIELD", MB_OK);
+					break;
+				}
+				case HS_ERR_COMPATIBILITY_MODE_RUNNING:
+				{
+					MessageBox(NULL, MA_T("COMPATIBILITY_MODE_RUNNING"), "HACK_SHIELD", MB_OK);
+					break;
+				}
+				default:
+				{
+					MA_TCHAR szMsg[255];
+					MA_StringFormat(szMsg, MA_ARRAYCOUNT(szMsg), MA_T("UNKNOWN_ERROR(errorCode=%x)"), nRet);
+					MessageBox(NULL, szMsg, "HACK_SHIELD", MB_OK);
+					break;
+				}
+			}
+			return false;
+		}
+	}
+
+	gs_dwMainThreadID = GetCurrentThreadId();
+
+	{
+		int nRet = _AhnHS_StartService();
+		assert(nRet != HS_ERR_NOT_INITIALIZED);
+		assert(nRet != HS_ERR_ALREADY_SERVICE_RUNNING);
+
+		if (nRet != HS_ERR_OK)
+			{
+			MA_TCHAR szMsg[255];
+			MA_StringFormat(szMsg, MA_ARRAYCOUNT(szMsg), MA_T("START_SERVICE_ERROR(errorCode=%x)"), nRet);
+			MessageBox(NULL, szMsg, "HACK_SHIELD", MB_OK);
+			return false;
+		}
+	}
+	return true;
+}
+
+bool HackShield_Shutdown()
+{
+	if (gs_dwMainThreadID)
+	{
+		gs_dwMainThreadID = 0;
+		_AhnHS_StopService();
+	}
+
+	int nRet = _AhnHS_Uninitialize();
+	if (nRet != HS_ERR_OK)
+	{
+		MA_TCHAR szMsg[255];
+		MA_StringFormat(szMsg, MA_ARRAYCOUNT(szMsg), MA_T("UNINITIALIZE_ERROR(errorCode=%x)"), nRet);
+		MessageBox(NULL, szMsg, "HACK_SHIELD", MB_OK);
+	}
+
+	if (_AhnHsUserUtil_CheckHSShadowAccount())
+	{
+		 _AhnHsUserUtil_DeleteUser();
+	}
+
+	if (gs_isHackDetected)
+	{
+		MessageBox(NULL, gs_szHackMsg, "HACK_SHIELD", MB_OK);
+	}
+	return true;
+}
+
+#define PREFIX_LOCALE		"locale/"
+
+void HackShield_SetUserInfo(const char* szAccountName)
+{
+	MA_TCHAR szUserInfo[256];
+
+	const char* szLocaleName = LocaleService_IsYMIR() ? MA_T("unknown") : LocaleService_GetLocalePath();
+	if( strncmp( szLocaleName, PREFIX_LOCALE, strlen(PREFIX_LOCALE) ) == 0 )
+		szLocaleName += strlen(PREFIX_LOCALE);
+	MA_StringFormat(szUserInfo, MA_ARRAYCOUNT(szUserInfo), MA_T("%s / %s"), szAccountName, szLocaleName );
+	_AhnHS_SetUserId(szUserInfo);
+}
+
+#endif /* USE_AHNLAB_HACKSHIELD */

src/UserInterface/Hackshield.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifdef USE_AHNLAB_HACKSHIELD
+
+#include "HackshieldLicense.h"
+
+#ifndef METIN2HS_INCLUDE
+//#define METIN2HS_INCLUDE				hshield-5.4.8.1
+#define METIN2HS_INCLUDE				hackshield  //2012<31><32> 3<><33>
+#endif
+
+#define METIN2HS_INCLUDE_HSUPCHK		<METIN2HS_INCLUDE/hsupchk.h>
+#define METIN2HS_INCLUDE_HSUSERUTIL		<METIN2HS_INCLUDE/hsuserutil.h>
+#define METIN2HS_INCLUDE_HSHIELD		<METIN2HS_INCLUDE/hshield.h>
+#define METIN2HS_INCLUDE_HSHIELDLIBLINK	<METIN2HS_INCLUDE/hshieldLibLink.h>
+#define METIN2HS_INCLUDE_ANTICPXSVR		<METIN2HS_INCLUDE/AntiCpXSvr.h>
+
+bool HackShield_Init();
+bool HackShield_Shutdown();
+bool HackShield_PollEvent();
+void HackShield_SetUserInfo(const char* szAccountName);
+
+#endif /* USE_AHNLAB_HACKSHIELD */

src/UserInterface/HackshieldLicense_metin2.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#define METIN2HS_EXE_FILE_NAME        "metin2.bin"
+#define METIN2HS_CODE                 5858
+#define METIN2HS_LICENSE              "2A126BBDC6C61351124B2872"

src/UserInterface/HackshieldLicense_metin2client.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#define METIN2HS_EXE_FILE_NAME        "metin2client.bin"
+#define METIN2HS_CODE                 5857
+#define METIN2HS_LICENSE              "B1FECACB51BD40B919EFCDB9"

src/UserInterface/InstanceBaseBattle.cpp

@@ -0,0 +1,719 @@
+#include "StdAfx.h"
+#include "InstanceBase.h"
+#include "PythonBackground.h"
+#include "PythonCharacterManager.h"
+#include "../PRTerrainLib/Terrain.h"
+
+float NEW_UnsignedDegreeToSignedDegree(float fUD)
+{
+	float fSD;
+	if (fUD>180.0f)
+		fSD=-(360.0f-fUD);
+	else if (fUD<-180.0f)
+		fSD=+(360.0f+fUD);
+	else
+		fSD=fUD;
+
+	return fSD;
+}
+
+float NEW_GetSignedDegreeFromDirPixelPosition(const TPixelPosition& kPPosDir)
+{
+	D3DXVECTOR3 vtDir(kPPosDir.x, -kPPosDir.y, kPPosDir.z);
+	D3DXVECTOR3 vtDirNormal;
+	D3DXVec3Normalize(&vtDirNormal, &vtDir);
+
+	D3DXVECTOR3 vtDirNormalStan(0, -1, 0);
+	float fDirRot = D3DXToDegree(acosf(D3DXVec3Dot(&vtDirNormal, &vtDirNormalStan)));
+
+	if (vtDirNormal.x<0.0f)
+		fDirRot=-fDirRot;
+
+	return fDirRot;
+}
+
+bool CInstanceBase::IsFlyTargetObject()
+{
+	return m_GraphicThingInstance.IsFlyTargetObject();
+}
+
+float CInstanceBase::GetFlyTargetDistance()
+{
+	return m_GraphicThingInstance.GetFlyTargetDistance();
+}
+
+void CInstanceBase::ClearFlyTargetInstance()
+{
+	m_GraphicThingInstance.ClearFlyTarget();
+}
+
+void CInstanceBase::SetFlyTargetInstance(CInstanceBase& rkInstDst)
+{
+// NOTE : NEW_Attack <20><> Target<65><74> <20>ٲܶ<D9B2> <20><><EFBFBD>⼭ <20><><EFBFBD><EFBFBD> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD> - [levites]
+//	if (isLock())
+//		return;
+
+	m_GraphicThingInstance.SetFlyTarget(rkInstDst.GetGraphicThingInstancePtr());
+}
+
+void CInstanceBase::AddFlyTargetPosition(const TPixelPosition& c_rkPPosDst)
+{
+	m_GraphicThingInstance.AddFlyTarget(c_rkPPosDst);
+}
+
+void CInstanceBase::AddFlyTargetInstance(CInstanceBase& rkInstDst)
+{
+	m_GraphicThingInstance.AddFlyTarget(rkInstDst.GetGraphicThingInstancePtr());
+}
+
+
+float CInstanceBase::NEW_GetDistanceFromDestInstance(CInstanceBase& rkInstDst)
+{
+	TPixelPosition kPPosDst;
+	rkInstDst.NEW_GetPixelPosition(&kPPosDst);
+
+	return NEW_GetDistanceFromDestPixelPosition(kPPosDst);
+}
+
+float CInstanceBase::NEW_GetDistanceFromDestPixelPosition(const TPixelPosition& c_rkPPosDst)
+{
+	TPixelPosition kPPosCur;
+	NEW_GetPixelPosition(&kPPosCur);
+
+	TPixelPosition kPPosDir;
+	kPPosDir=c_rkPPosDst-kPPosCur;
+
+	return NEW_GetDistanceFromDirPixelPosition(kPPosDir);
+}
+
+float CInstanceBase::NEW_GetDistanceFromDirPixelPosition(const TPixelPosition& c_rkPPosDir)
+{
+	return sqrtf(c_rkPPosDir.x*c_rkPPosDir.x+c_rkPPosDir.y*c_rkPPosDir.y);
+}
+
+float CInstanceBase::NEW_GetRotation()
+{
+	float fCurRot=GetRotation();
+	return NEW_UnsignedDegreeToSignedDegree(fCurRot);
+}
+
+float CInstanceBase::NEW_GetRotationFromDirPixelPosition(const TPixelPosition& c_rkPPosDir)
+{
+	return NEW_GetSignedDegreeFromDirPixelPosition(c_rkPPosDir);
+}
+
+float CInstanceBase::NEW_GetRotationFromDestPixelPosition(const TPixelPosition& c_rkPPosDst)
+{
+	TPixelPosition kPPosCur;
+	NEW_GetPixelPosition(&kPPosCur);
+
+	TPixelPosition kPPosDir;
+	kPPosDir=c_rkPPosDst-kPPosCur;
+
+	return NEW_GetRotationFromDirPixelPosition(kPPosDir);
+}
+
+float CInstanceBase::NEW_GetRotationFromDestInstance(CInstanceBase& rkInstDst)
+{
+	TPixelPosition kPPosDst;
+	rkInstDst.NEW_GetPixelPosition(&kPPosDst);
+
+	return NEW_GetRotationFromDestPixelPosition(kPPosDst);
+}
+
+void CInstanceBase::NEW_GetRandomPositionInFanRange(CInstanceBase& rkInstTarget, TPixelPosition* pkPPosDst)
+{
+	float fDstDirRot=NEW_GetRotationFromDestInstance(rkInstTarget);	
+
+	float fRot=frandom(fDstDirRot-10.0f, fDstDirRot+10.0f);
+
+	D3DXMATRIX kMatRot;
+	D3DXMatrixRotationZ(&kMatRot, D3DXToRadian(-fRot));
+
+	D3DXVECTOR3 v3Src(0.0f, 8000.0f, 0.0f);
+	D3DXVECTOR3 v3Pos;
+	D3DXVec3TransformCoord(&v3Pos, &v3Src, &kMatRot);
+
+	const TPixelPosition& c_rkPPosCur=NEW_GetCurPixelPositionRef();
+	//const TPixelPosition& c_rkPPosFront=rkInstTarget.NEW_GetCurPixelPositionRef();
+
+	pkPPosDst->x=c_rkPPosCur.x+v3Pos.x;
+	pkPPosDst->y=c_rkPPosCur.y+v3Pos.y;
+	pkPPosDst->z=__GetBackgroundHeight(c_rkPPosCur.x, c_rkPPosCur.y);
+}
+
+bool CInstanceBase::NEW_GetFrontInstance(CInstanceBase ** ppoutTargetInstance, float fDistance)
+{
+	const float HALF_FAN_ROT_MIN = 10.0f;
+	const float HALF_FAN_ROT_MAX = 50.0f;
+	const float HALF_FAN_ROT_MIN_DISTANCE = 1000.0f;
+	const float RPM = (HALF_FAN_ROT_MAX-HALF_FAN_ROT_MIN)/HALF_FAN_ROT_MIN_DISTANCE;
+
+	float fDstRot=NEW_GetRotation();
+
+	std::multimap<float, CInstanceBase*> kMap_pkInstNear;
+	{
+		CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+		CPythonCharacterManager::CharacterIterator i;
+		for(i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd(); ++i)
+		{
+			CInstanceBase* pkInstEach=*i;
+			if (pkInstEach==this)
+				continue;
+
+			if (!IsAttackableInstance(*pkInstEach))
+				continue;
+
+			if (NEW_GetDistanceFromDestInstance(*pkInstEach) > fDistance)
+				continue;
+
+			float fEachInstDistance=min(NEW_GetDistanceFromDestInstance(*pkInstEach), HALF_FAN_ROT_MIN_DISTANCE);
+			float fEachInstDirRot=NEW_GetRotationFromDestInstance(*pkInstEach);
+
+			float fHalfFanRot=(HALF_FAN_ROT_MAX-HALF_FAN_ROT_MIN)-RPM*fEachInstDistance+HALF_FAN_ROT_MIN;
+
+			float fMinDstDirRot=fDstRot-fHalfFanRot;
+			float fMaxDstDirRot=fDstRot+fHalfFanRot;
+
+			if (fEachInstDirRot>=fMinDstDirRot && fEachInstDirRot<=fMaxDstDirRot)
+				kMap_pkInstNear.insert(std::multimap<float, CInstanceBase*>::value_type(fEachInstDistance, pkInstEach));
+		}
+	}
+
+	if (kMap_pkInstNear.empty())
+		return false;
+
+	*ppoutTargetInstance = kMap_pkInstNear.begin()->second;
+
+	return true;
+}
+
+// 2004.07.21.levites - <20><><EFBFBD>ĺ<EFBFBD> <20><><EFBFBD><EFBFBD> Ÿ<><C5B8> <20><><EFBFBD><EFBFBD>
+bool CInstanceBase::NEW_GetInstanceVectorInFanRange(float fSkillDistance, CInstanceBase& rkInstTarget, std::vector<CInstanceBase*>* pkVct_pkInst)
+{
+	const float HALF_FAN_ROT_MIN = 20.0f;
+	const float HALF_FAN_ROT_MAX = 40.0f;
+	const float HALF_FAN_ROT_MIN_DISTANCE = 1000.0f;
+	const float RPM = (HALF_FAN_ROT_MAX-HALF_FAN_ROT_MIN)/HALF_FAN_ROT_MIN_DISTANCE;
+
+	float fDstDirRot=NEW_GetRotationFromDestInstance(rkInstTarget);
+
+	// 2004.07.24.myevan - <20><><EFBFBD>ĺ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+	std::multimap<float, CInstanceBase*> kMap_pkInstNear;
+	{
+		CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+		CPythonCharacterManager::CharacterIterator i;
+		for(i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd(); ++i)
+		{
+			CInstanceBase* pkInstEach=*i;
+			if (pkInstEach==this)
+				continue;
+
+			// 2004.07.25.myevan - <20><><EFBFBD><EFBFBD> <20><><EFBFBD>츸 <20>߰<EFBFBD><DFB0>Ѵ<EFBFBD>
+			if (!IsAttackableInstance(*pkInstEach))
+				continue;
+
+			// 2004.07.21.levites - <20><><EFBFBD>ĺ<EFBFBD> <20><><EFBFBD><EFBFBD> Ÿ<><C5B8> <20><><EFBFBD><EFBFBD>
+			if (m_GraphicThingInstance.IsClickableDistanceDestInstance(pkInstEach->m_GraphicThingInstance, fSkillDistance))
+			{
+				float fEachInstDistance=min(NEW_GetDistanceFromDestInstance(*pkInstEach), HALF_FAN_ROT_MIN_DISTANCE);
+				float fEachInstDirRot=NEW_GetRotationFromDestInstance(*pkInstEach);
+
+				float fHalfFanRot=(HALF_FAN_ROT_MAX-HALF_FAN_ROT_MIN)-RPM*fEachInstDistance+HALF_FAN_ROT_MIN;
+
+				float fMinDstDirRot=fDstDirRot-fHalfFanRot;
+				float fMaxDstDirRot=fDstDirRot+fHalfFanRot;
+
+				if (fEachInstDirRot>=fMinDstDirRot && fEachInstDirRot<=fMaxDstDirRot)
+					kMap_pkInstNear.insert(std::multimap<float, CInstanceBase*>::value_type(fEachInstDistance, pkInstEach));
+			}
+		}
+	}
+
+	{
+		std::multimap<float, CInstanceBase*>::iterator i=kMap_pkInstNear.begin();
+		for (i=kMap_pkInstNear.begin(); i!=kMap_pkInstNear.end(); ++i)
+			pkVct_pkInst->push_back(i->second);
+	}
+
+	if (pkVct_pkInst->empty())
+		return false;
+
+	return true;
+}
+
+bool CInstanceBase::NEW_GetInstanceVectorInCircleRange(float fSkillDistance, std::vector<CInstanceBase*>* pkVct_pkInst)
+{
+	std::multimap<float, CInstanceBase*> kMap_pkInstNear;
+
+	{
+		CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+		CPythonCharacterManager::CharacterIterator i;
+		for(i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd(); ++i)
+		{
+			CInstanceBase* pkInstEach=*i;
+
+			// <20>ڽ<EFBFBD><DABD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD><DFB0><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>
+			if (pkInstEach==this)
+				continue;
+
+			// <20><><EFBFBD><EFBFBD> <20><><EFBFBD>츸 <20>߰<EFBFBD><DFB0>Ѵ<EFBFBD>
+			if (!IsAttackableInstance(*pkInstEach))
+				continue;
+
+			if (m_GraphicThingInstance.IsClickableDistanceDestInstance(pkInstEach->m_GraphicThingInstance, fSkillDistance))
+			{
+				float fEachInstDistance=NEW_GetDistanceFromDestInstance(*pkInstEach);
+				kMap_pkInstNear.insert(std::make_pair(fEachInstDistance, pkInstEach));
+			}
+		}
+	}
+
+	{
+		std::multimap<float, CInstanceBase*>::iterator i=kMap_pkInstNear.begin();
+		for (i=kMap_pkInstNear.begin(); i!=kMap_pkInstNear.end(); ++i)
+			pkVct_pkInst->push_back(i->second);
+	}
+
+	if (pkVct_pkInst->empty())
+		return false;
+
+	return true;
+}
+
+BOOL CInstanceBase::NEW_IsClickableDistanceDestPixelPosition(const TPixelPosition& c_rkPPosDst)
+{
+	float fDistance=NEW_GetDistanceFromDestPixelPosition(c_rkPPosDst);
+
+	if (fDistance>150.0f)
+		return FALSE;
+
+	return TRUE;
+}
+
+BOOL CInstanceBase::NEW_IsClickableDistanceDestInstance(CInstanceBase& rkInstDst)
+{
+	float fDistance = 150.0f;
+
+	if (IsBowMode())
+		fDistance = __GetBowRange();
+
+	if (rkInstDst.IsNPC())
+		fDistance = 500.0f;
+
+	if (rkInstDst.IsResource())
+		fDistance = 100.0f;
+
+	return m_GraphicThingInstance.IsClickableDistanceDestInstance(rkInstDst.m_GraphicThingInstance, fDistance);
+}
+
+bool CInstanceBase::NEW_UseSkill(UINT uSkill, UINT uMot, UINT uMotLoopCount, bool isMovingSkill)
+{
+	if (IsDead())
+		return false;
+
+	if (IsStun())
+		return false;
+
+	if (IsKnockDown())
+		return false;
+
+	if (isMovingSkill)
+	{
+		if (!IsWalking())
+			StartWalking();
+
+		m_isGoing = TRUE;
+	}
+	else
+	{
+		if (IsWalking())
+			EndWalking();
+
+		m_isGoing = FALSE;
+	}
+
+	float fCurRot=m_GraphicThingInstance.GetTargetRotation();
+	SetAdvancingRotation(fCurRot);
+
+	m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_SKILL + uMot, 0.1f, uSkill, 1.0f);
+
+	m_GraphicThingInstance.__OnUseSkill(uMot, uMotLoopCount, isMovingSkill);
+
+	if (uMotLoopCount > 0)
+		m_GraphicThingInstance.SetMotionLoopCount(uMotLoopCount);
+
+	return true;
+}
+
+void CInstanceBase::NEW_Attack()
+{
+	float fDirRot=GetRotation();
+	NEW_Attack(fDirRot);
+}
+
+void CInstanceBase::NEW_Attack(float fDirRot)
+{
+	if (IsDead())
+		return;
+
+	if (IsStun())
+		return;
+
+	if (IsKnockDown())
+		return;
+
+	if (IsUsingSkill())
+		return;
+	
+	if (IsWalking())
+		EndWalking();
+
+	m_isGoing = FALSE;
+
+	if (IsPoly())
+	{
+		InputNormalAttack(fDirRot);
+	}
+	else
+	{
+		if (m_kHorse.IsMounting())
+		{
+			InputComboAttack(fDirRot);
+		}
+		else
+		{
+			InputComboAttack(fDirRot);
+		}
+	}
+}
+
+
+void CInstanceBase::NEW_AttackToDestPixelPositionDirection(const TPixelPosition& c_rkPPosDst)
+{
+	float fDirRot=NEW_GetRotationFromDestPixelPosition(c_rkPPosDst);
+	
+	NEW_Attack(fDirRot);
+}
+
+bool CInstanceBase::NEW_AttackToDestInstanceDirection(CInstanceBase& rkInstDst, IFlyEventHandler* pkFlyHandler)
+{
+	return NEW_AttackToDestInstanceDirection(rkInstDst);
+}
+
+bool CInstanceBase::NEW_AttackToDestInstanceDirection(CInstanceBase& rkInstDst)
+{
+	TPixelPosition kPPosDst;
+	rkInstDst.NEW_GetPixelPosition(&kPPosDst);
+	NEW_AttackToDestPixelPositionDirection(kPPosDst);
+
+	return true;
+}
+
+void CInstanceBase::AttackProcess()
+{
+	if (!m_GraphicThingInstance.CanCheckAttacking())
+		return;
+   
+	CInstanceBase * pkInstLast = NULL;
+	CPythonCharacterManager& rkChrMgr = CPythonCharacterManager::Instance();
+	CPythonCharacterManager::CharacterIterator i = rkChrMgr.CharacterInstanceBegin();
+	while (rkChrMgr.CharacterInstanceEnd()!=i)
+	{
+		CInstanceBase* pkInstEach=*i;
+		++i;
+
+		// <20><><EFBFBD>ΰ<EFBFBD><CEB0><EFBFBD> InstanceType <20><><EFBFBD><EFBFBD>
+		if (!IsAttackableInstance(*pkInstEach))
+			continue;
+
+		if (pkInstEach!=this)
+		{
+			if (CheckAttacking(*pkInstEach))
+			{
+				pkInstLast=pkInstEach;
+			}
+		}
+	}
+
+	if (pkInstLast)
+	{
+		m_dwLastDmgActorVID=pkInstLast->GetVirtualID();
+	}
+}
+
+void CInstanceBase::InputNormalAttack(float fAtkDirRot)
+{
+	m_GraphicThingInstance.InputNormalAttackCommand(fAtkDirRot);
+}
+
+void CInstanceBase::InputComboAttack(float fAtkDirRot)
+{
+	m_GraphicThingInstance.InputComboAttackCommand(fAtkDirRot);
+	__ComboProcess();
+}
+
+void CInstanceBase::RunNormalAttack(float fAtkDirRot)
+{
+	EndGoing();
+	m_GraphicThingInstance.NormalAttack(fAtkDirRot);
+}
+
+void CInstanceBase::RunComboAttack(float fAtkDirRot, DWORD wMotionIndex)
+{
+	EndGoing();
+	m_GraphicThingInstance.ComboAttack(wMotionIndex, fAtkDirRot);
+}
+
+// <20><><EFBFBD>ϰ<EFBFBD> TRUE<55><45> <20><><EFBFBD><EFBFBD><EFBFBD>ΰ<EFBFBD><CEB0><EFBFBD> <20>ִ<EFBFBD>
+BOOL CInstanceBase::CheckAdvancing()
+{
+#ifdef __MOVIE_MODE__
+	if (IsMovieMode())
+		return FALSE;
+#endif
+	if (!__IsMainInstance() && !IsAttacking())
+	{
+		if (IsPC() && IsWalking())
+		{
+			CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+			for(CPythonCharacterManager::CharacterIterator i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd();++i)
+			{
+				CInstanceBase* pkInstEach=*i;
+				if (pkInstEach==this)
+					continue;
+				if (!pkInstEach->IsDoor())
+					continue;
+
+				if (m_GraphicThingInstance.TestActorCollision(pkInstEach->GetGraphicThingInstanceRef()))
+				{
+					BlockMovement();
+					return true;
+				}
+			}				
+		}
+		return FALSE;
+	}
+
+	if (m_GraphicThingInstance.CanSkipCollision())
+	{
+		//Tracenf("%x VID %d <20>浹 <20><>ŵ", ELTimer_GetMSec(), GetVirtualID());
+		return FALSE;
+	}
+
+
+	BOOL bUsingSkill = m_GraphicThingInstance.IsUsingSkill();
+
+	m_dwAdvActorVID = 0;
+	UINT uCollisionCount=0;
+
+	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+	for(CPythonCharacterManager::CharacterIterator i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd();++i)
+	{
+		CInstanceBase* pkInstEach=*i;
+		if (pkInstEach==this)
+			continue;
+
+		CActorInstance& rkActorSelf=m_GraphicThingInstance;
+		CActorInstance& rkActorEach=pkInstEach->GetGraphicThingInstanceRef();
+
+		//NOTE : Skil<69><6C> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Door Type<70><65><EFBFBD><EFBFBD> Collisionüũ <20>Ѵ<EFBFBD>.
+		if( bUsingSkill && !rkActorEach.IsDoor() )
+			continue;
+			
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ҽ<EFBFBD> <20>ִ°<D6B4>?
+		if (rkActorSelf.TestActorCollision(rkActorEach))
+		{
+			uCollisionCount++;
+			if (uCollisionCount==2)
+			{
+				rkActorSelf.BlockMovement();
+				return TRUE;
+			}
+			rkActorSelf.AdjustDynamicCollisionMovement(&rkActorEach);
+
+			if (rkActorSelf.TestActorCollision(rkActorEach))
+			{
+				rkActorSelf.BlockMovement();
+				return TRUE;
+			}
+			else
+			{
+				NEW_MoveToDestPixelPositionDirection(NEW_GetDstPixelPositionRef());
+			}
+		}
+	}
+
+	// <20>ʼӼ<CABC> üũ
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	const D3DXVECTOR3 & rv3Position = m_GraphicThingInstance.GetPosition();
+	const D3DXVECTOR3 & rv3MoveDirection = m_GraphicThingInstance.GetMovementVectorRef();
+
+	// NOTE : <20><><EFBFBD><EFBFBD> <20>̵<EFBFBD> <20>Ÿ<EFBFBD><C5B8><EFBFBD> ũ<>ٸ<EFBFBD> <20>ɰ<EFBFBD><C9B0><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ӽ<EFBFBD><D3BC><EFBFBD> üũ<C3BC><C5A9> <20><><EFBFBD><EFBFBD>
+	//        <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 10.0f<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ÿ<EFBFBD> - [levites]
+	int iStep = int(D3DXVec3Length(&rv3MoveDirection) / 10.0f);
+	D3DXVECTOR3 v3CheckStep = rv3MoveDirection / float(iStep);
+	D3DXVECTOR3 v3CheckPosition = rv3Position;
+	for (int j = 0; j < iStep; ++j)
+	{
+		v3CheckPosition += v3CheckStep;
+
+		// Check
+		if (rkBG.isAttrOn(v3CheckPosition.x, -v3CheckPosition.y, CTerrainImpl::ATTRIBUTE_BLOCK))
+		{
+			BlockMovement();
+			//return TRUE;
+		}
+	}
+
+	// Check
+	D3DXVECTOR3 v3NextPosition = rv3Position + rv3MoveDirection;
+	if (rkBG.isAttrOn(v3NextPosition.x, -v3NextPosition.y, CTerrainImpl::ATTRIBUTE_BLOCK))
+	{
+		BlockMovement();
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+BOOL CInstanceBase::CheckAttacking(CInstanceBase& rkInstVictim)
+{
+	if (IsInSafe())
+		return FALSE;
+
+	if (rkInstVictim.IsInSafe())
+		return FALSE;
+
+#ifdef __MOVIE_MODE__
+	return FALSE;
+#endif
+
+	if (!m_GraphicThingInstance.AttackingProcess(rkInstVictim.m_GraphicThingInstance))
+		return FALSE;
+
+	return TRUE;
+}
+
+BOOL CInstanceBase::isNormalAttacking()
+{
+	return m_GraphicThingInstance.isNormalAttacking();
+}
+
+BOOL CInstanceBase::isComboAttacking()
+{
+	return m_GraphicThingInstance.isComboAttacking();
+}
+
+BOOL CInstanceBase::IsUsingSkill()
+{
+	return m_GraphicThingInstance.IsUsingSkill();
+}
+
+BOOL CInstanceBase::IsUsingMovingSkill()
+{
+	return m_GraphicThingInstance.IsUsingMovingSkill();
+}
+
+BOOL CInstanceBase::CanCancelSkill()
+{
+	return m_GraphicThingInstance.CanCancelSkill();
+}
+
+BOOL CInstanceBase::CanAttackHorseLevel()
+{
+	if (!IsMountingHorse())
+		return FALSE;
+
+	return m_kHorse.CanAttack();
+}
+
+bool CInstanceBase::IsAffect(UINT uAffect)
+{
+	return m_kAffectFlagContainer.IsSet(uAffect);
+}
+
+MOTION_KEY CInstanceBase::GetNormalAttackIndex()
+{
+	return m_GraphicThingInstance.GetNormalAttackIndex();
+}
+
+DWORD CInstanceBase::GetComboIndex()
+{
+	return m_GraphicThingInstance.GetComboIndex();
+}
+
+float CInstanceBase::GetAttackingElapsedTime()
+{
+	return m_GraphicThingInstance.GetAttackingElapsedTime();
+}
+
+void CInstanceBase::ProcessHitting(DWORD dwMotionKey, CInstanceBase * pVictimInstance)
+{
+	assert(!"-_-" && "CInstanceBase::ProcessHitting");
+	//m_GraphicThingInstance.ProcessSucceedingAttacking(dwMotionKey, pVictimInstance->m_GraphicThingInstance);
+}
+
+void CInstanceBase::ProcessHitting(DWORD dwMotionKey, BYTE byEventIndex, CInstanceBase * pVictimInstance)
+{
+	assert(!"-_-" && "CInstanceBase::ProcessHitting");
+	//m_GraphicThingInstance.ProcessSucceedingAttacking(dwMotionKey, byEventIndex, pVictimInstance->m_GraphicThingInstance);
+}
+
+void CInstanceBase::GetBlendingPosition(TPixelPosition * pPixelPosition)
+{
+	m_GraphicThingInstance.GetBlendingPosition(pPixelPosition);
+}
+
+void CInstanceBase::SetBlendingPosition(const TPixelPosition & c_rPixelPosition)
+{
+	m_GraphicThingInstance.SetBlendingPosition(c_rPixelPosition);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void CInstanceBase::Revive()
+{
+	m_isGoing=FALSE;
+	m_GraphicThingInstance.Revive();
+
+	__AttachHorseSaddle();
+}
+
+void CInstanceBase::Stun()
+{
+	NEW_Stop();
+	m_GraphicThingInstance.Stun();
+
+	__AttachEffect(EFFECT_STUN);
+}
+
+void CInstanceBase::Die()
+{
+	__DetachHorseSaddle();
+
+	if (IsAffect(AFFECT_SPAWN))
+		__AttachEffect(EFFECT_SPAWN_DISAPPEAR);
+
+	// 2004.07.25.<2E><><EFBFBD><EFBFBD>Ʈ <20>Ⱥٴ<C8BA> <20><><EFBFBD><EFBFBD><EFBFBD>ذ<EFBFBD>
+	////////////////////////////////////////
+	__ClearAffects();
+	////////////////////////////////////////
+
+	OnUnselected();
+	OnUntargeted();
+
+	m_GraphicThingInstance.Die();
+}
+
+void CInstanceBase::Hide()
+{
+	m_GraphicThingInstance.SetAlphaValue(0.0f);
+	m_GraphicThingInstance.BlendAlphaValue(0.0f, 0.1f);
+}
+
+void CInstanceBase::Show()
+{
+	m_GraphicThingInstance.SetAlphaValue(1.0f);
+	m_GraphicThingInstance.BlendAlphaValue(1.0f, 0.1f);
+}

src/UserInterface/InstanceBaseEvent.cpp

@@ -0,0 +1,17 @@
+#include "StdAfx.h"
+#include "InstanceBase.h"
+
+CActorInstance::IEventHandler& CInstanceBase::GetEventHandlerRef()
+{
+	return m_GraphicThingInstance.__GetEventHandlerRef();
+}
+
+CActorInstance::IEventHandler* CInstanceBase::GetEventHandlerPtr()
+{
+	return m_GraphicThingInstance.__GetEventHandlerPtr();
+}
+
+void CInstanceBase::SetEventHandler(CActorInstance::IEventHandler* pkEventHandler)
+{
+	m_GraphicThingInstance.SetEventHandler(pkEventHandler);
+}

src/UserInterface/InstanceBaseMotion.cpp

@@ -0,0 +1,165 @@
+#include "StdAfx.h"
+#include "InstanceBase.h"
+#include "AbstractPlayer.h"
+#include "../gameLib/ActorInstance.h"
+
+const int c_iFishingRotStep = 8;
+const float c_fFishingDistance = 600.0f;
+
+void CInstanceBase::SetMotionMode(int iMotionMode)
+{
+	m_GraphicThingInstance.SetMotionMode(iMotionMode);
+}
+
+int CInstanceBase::GetMotionMode(DWORD dwMotionIndex)
+{
+	return m_GraphicThingInstance.GetMotionMode();
+}
+
+void CInstanceBase::SetLoopMotion(WORD wMotion, float fBlendTime/* =0.1f */, float fSpeedRatio)
+{
+	m_GraphicThingInstance.SetLoopMotion(wMotion, fBlendTime, fSpeedRatio);
+}
+
+void CInstanceBase::PushOnceMotion(WORD wMotion, float fBlendTime, float fSpeedRatio)
+{
+	m_GraphicThingInstance.PushOnceMotion(wMotion, fBlendTime, fSpeedRatio);
+}
+
+void CInstanceBase::PushLoopMotion(WORD wMotion, float fBlendTime, float fSpeedRatio)
+{
+	m_GraphicThingInstance.PushLoopMotion(wMotion, fBlendTime, fSpeedRatio);
+}
+
+void CInstanceBase::ResetLocalTime()
+{
+	m_GraphicThingInstance.ResetLocalTime();
+}
+
+void CInstanceBase::SetEndStopMotion()
+{
+	m_GraphicThingInstance.SetEndStopMotion();
+}
+
+BOOL CInstanceBase::isLock()
+{
+	return m_GraphicThingInstance.isLock();
+}
+
+void CInstanceBase::StartFishing(float frot)
+{
+	BlendRotation(frot);
+
+	const TPixelPosition& c_rkPPosCur=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
+	float fRot = m_GraphicThingInstance.GetTargetRotation();
+	//float fPlainCoordRot=ELRightCoord_ConvertToPlainCoordDegree(fRightCoordRot);
+
+	TPixelPosition kPPosFishing;
+	ELPlainCoord_GetRotatedPixelPosition(c_rkPPosCur.x, c_rkPPosCur.y, c_fFishingDistance, fRot, &kPPosFishing.x, &kPPosFishing.y);	
+	if (!__Background_GetWaterHeight(kPPosFishing, &kPPosFishing.z))
+		kPPosFishing.z=c_rkPPosCur.z;
+	
+	D3DXVECTOR3 v3Fishing;
+	PixelPositionToD3DXVECTOR3(kPPosFishing, &v3Fishing);
+	m_GraphicThingInstance.SetFishingPosition(v3Fishing);
+
+	PushOnceMotion(CRaceMotionData::NAME_FISHING_THROW);
+	PushLoopMotion(CRaceMotionData::NAME_FISHING_WAIT);
+}
+void CInstanceBase::StopFishing()
+{
+	m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_FISHING_STOP);
+	PushLoopMotion(CRaceMotionData::NAME_WAIT);
+}
+void CInstanceBase::ReactFishing()
+{
+	PushOnceMotion(CRaceMotionData::NAME_FISHING_REACT);
+	PushLoopMotion(CRaceMotionData::NAME_FISHING_WAIT);
+}
+void CInstanceBase::CatchSuccess()
+{
+	m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_FISHING_CATCH);
+	PushLoopMotion(CRaceMotionData::NAME_WAIT);
+}
+void CInstanceBase::CatchFail()
+{
+	m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_FISHING_FAIL);
+	PushLoopMotion(CRaceMotionData::NAME_WAIT);
+}
+
+BOOL CInstanceBase::GetFishingRot(int * pirot)
+{
+	const TPixelPosition& c_rkPPosCur=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
+	float fCharacterRot = m_GraphicThingInstance.GetRotation();
+
+	//float frot = fCharacterRot;
+
+	for (float fRot=0.0f; fRot<=180.0f; fRot+=10.0f)
+	{
+		TPixelPosition kPPosFishingRight;
+		ELPlainCoord_GetRotatedPixelPosition(c_rkPPosCur.x, c_rkPPosCur.y, c_fFishingDistance, fCharacterRot+fRot, &kPPosFishingRight.x, &kPPosFishingRight.y);
+		if (__Background_IsWaterPixelPosition(kPPosFishingRight))
+		{
+			*pirot = fCharacterRot+fRot;
+			return TRUE;
+		}
+
+		TPixelPosition kPPosFishingLeft;
+		ELPlainCoord_GetRotatedPixelPosition(c_rkPPosCur.x, c_rkPPosCur.y, c_fFishingDistance, fCharacterRot-fRot, &kPPosFishingLeft.x, &kPPosFishingLeft.y);	
+		if (__Background_IsWaterPixelPosition(kPPosFishingLeft))
+		{
+			*pirot = fCharacterRot-fRot;
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+void CInstanceBase::__EnableChangingTCPState()
+{
+	m_bEnableTCPState = TRUE;
+}
+
+void CInstanceBase::__DisableChangingTCPState()
+{
+	m_bEnableTCPState = FALSE;
+}
+
+void CInstanceBase::ActDualEmotion(CInstanceBase & rkDstInst, WORD wMotionNumber1, WORD wMotionNumber2)
+{
+	if (!IsWaiting())
+	{
+		m_GraphicThingInstance.SetLoopMotion(CRaceMotionData::NAME_WAIT, 0.05f);
+	}
+	if (!rkDstInst.IsWaiting())
+	{
+		rkDstInst.m_GraphicThingInstance.SetLoopMotion(CRaceMotionData::NAME_WAIT, 0.05f);
+	}
+
+	const float c_fEmotionDistance = 100.0f;
+	const TPixelPosition & c_rMainPosition = NEW_GetCurPixelPositionRef();
+	const TPixelPosition & c_rTargetPosition = rkDstInst.NEW_GetCurPixelPositionRef();
+	TPixelPosition kDirection = c_rMainPosition - c_rTargetPosition;
+	float fDistance = sqrtf((kDirection.x*kDirection.x) + (kDirection.y*kDirection.y));
+	TPixelPosition kDstPosition;
+	kDstPosition.x = c_rTargetPosition.x + (kDirection.x/fDistance)*c_fEmotionDistance;
+	kDstPosition.y = c_rTargetPosition.y + (kDirection.y/fDistance)*c_fEmotionDistance;
+
+	DWORD dwCurTime = ELTimer_GetServerMSec() + 500;
+	PushTCPStateExpanded(dwCurTime, kDstPosition, 0.0f, FUNC_EMOTION, MAKELONG(wMotionNumber1, wMotionNumber2), rkDstInst.GetVirtualID());
+
+	__DisableChangingTCPState();
+	rkDstInst.__DisableChangingTCPState();
+
+	if (__IsMainInstance() || rkDstInst.__IsMainInstance())
+	{
+		IAbstractPlayer & rPlayer=IAbstractPlayer::GetSingleton();
+		rPlayer.StartEmotionProcess();
+	}
+}
+
+void CInstanceBase::ActEmotion(DWORD dwMotionNumber)
+{
+	PushOnceMotion(dwMotionNumber);
+}

src/UserInterface/InstanceBaseMovement.cpp

@@ -0,0 +1,356 @@
+#include "StdAfx.h"
+#include "InstanceBase.h"
+#include "PythonBackground.h"
+#include "../eterLib/GrpMath.h"
+
+void CInstanceBase::SetAttackSpeed(UINT uAtkSpd)
+{
+	if (uAtkSpd > 1100)
+		uAtkSpd = 0;
+
+	m_GraphicThingInstance.SetAttackSpeed(uAtkSpd/100.0f);	
+	m_kHorse.SetAttackSpeed(uAtkSpd);
+}
+
+void CInstanceBase::SetMoveSpeed(UINT uMovSpd)
+{
+	if (uMovSpd > 1100)
+		uMovSpd = 0;
+
+	m_GraphicThingInstance.SetMoveSpeed(uMovSpd/100.0f);	
+	m_kHorse.SetMoveSpeed(uMovSpd);
+}
+
+
+void CInstanceBase::SetRotationSpeed(float fRotSpd)
+{
+	m_fMaxRotSpd = fRotSpd;
+}
+
+void CInstanceBase::NEW_Stop()
+{
+	if (__IsSyncing())
+		return;
+
+	if (isLock())
+		return;
+
+	if (IsUsingSkill())
+		return;
+
+	if (!IsWaiting())
+		EndWalking();
+
+	m_GraphicThingInstance.__OnStop();
+}
+
+void CInstanceBase::NEW_SyncPixelPosition(long & nPPosX, long & nPPosY)
+{
+	m_GraphicThingInstance.TEMP_Push(nPPosX, nPPosY);
+}
+
+bool CInstanceBase::NEW_CanMoveToDestPixelPosition(const TPixelPosition& c_rkPPosDst)
+{
+	TPixelPosition kPPosCur;
+	NEW_GetPixelPosition(&kPPosCur);
+
+	if (kPPosCur.x==c_rkPPosDst.x && kPPosCur.y==c_rkPPosDst.y)
+		return false;
+	
+	return true;
+}
+
+float CInstanceBase_GetDegreeFromPosition(float x, float y)
+{
+	D3DXVECTOR3 vtDir(floor(x), floor(y), 0.0f);
+	D3DXVec3Normalize(&vtDir, &vtDir);
+
+	D3DXVECTOR3 vtStan(0, -1, 0);
+	float ret = D3DXToDegree(acosf(D3DXVec3Dot(&vtDir, &vtStan)));
+
+	if (vtDir.x < 0.0f)
+		ret = 360.0f - ret;
+
+	return ret;
+}
+
+float CInstanceBase::NEW_GetAdvancingRotationFromDirPixelPosition(const TPixelPosition& c_rkPPosDir)
+{	
+	float fDirRot=CInstanceBase_GetDegreeFromPosition(c_rkPPosDir.x, -c_rkPPosDir.y);
+	float fClampDirRot=ClampDegree(fDirRot);
+
+	return fClampDirRot;
+}
+
+float CInstanceBase::NEW_GetAdvancingRotationFromDestPixelPosition(const TPixelPosition& c_rkPPosDst)
+{
+	TPixelPosition kPPosCur;
+	NEW_GetPixelPosition(&kPPosCur);
+	return NEW_GetAdvancingRotationFromPixelPosition(kPPosCur, c_rkPPosDst);
+}
+
+float CInstanceBase::NEW_GetAdvancingRotationFromPixelPosition(const TPixelPosition& c_rkPPosSrc, const TPixelPosition& c_rkPPosDst)
+{
+	TPixelPosition kPPosDelta;
+	kPPosDelta=c_rkPPosDst-c_rkPPosSrc;
+	return NEW_GetAdvancingRotationFromDirPixelPosition(kPPosDelta);
+}
+
+
+void CInstanceBase::NEW_SetAdvancingRotationFromDirPixelPosition(const TPixelPosition& c_rkPPosDir)
+{
+	float fClampDirRot=NEW_GetAdvancingRotationFromDirPixelPosition(c_rkPPosDir);
+	m_GraphicThingInstance.SetAdvancingRotation(fClampDirRot);
+
+	float fCurRot=m_GraphicThingInstance.GetRotation();
+	float fAdvRot=m_GraphicThingInstance.GetAdvancingRotation();
+
+	m_iRotatingDirection = GetRotatingDirection(fCurRot, fAdvRot);
+}
+
+
+void CInstanceBase::NEW_SetAdvancingRotationFromPixelPosition(const TPixelPosition& c_rkPPosSrc, const TPixelPosition& c_rkPPosDst)
+{
+	TPixelPosition kPPosDelta;
+	kPPosDelta=c_rkPPosDst-c_rkPPosSrc;
+
+	NEW_SetAdvancingRotationFromDirPixelPosition(kPPosDelta);
+}
+
+bool CInstanceBase::NEW_SetAdvancingRotationFromDestPixelPosition(const TPixelPosition& c_rkPPosDst)
+{
+	if (!NEW_CanMoveToDestPixelPosition(c_rkPPosDst))
+	{
+		Tracenf("Failed to move next position (%f,%f, %f)", c_rkPPosDst.x, c_rkPPosDst.y, c_rkPPosDst.z);
+		return false;
+	}
+
+	TPixelPosition kPPosSrc;
+	NEW_GetPixelPosition(&kPPosSrc);
+	NEW_SetAdvancingRotationFromPixelPosition(kPPosSrc, c_rkPPosDst);
+	return true;
+}
+
+
+void CInstanceBase::SetAdvancingRotation(float fRotation)
+{
+	float frotDifference = GetDegreeDifference(GetRotation(), fRotation);
+
+	if (frotDifference > 45.0f)
+		m_fRotSpd = m_fMaxRotSpd;
+	else
+		m_fRotSpd = m_fMaxRotSpd * 5 / 12;
+
+	m_GraphicThingInstance.SetAdvancingRotation(ClampDegree(fRotation));
+	m_iRotatingDirection = GetRotatingDirection(m_GraphicThingInstance.GetRotation(),
+												m_GraphicThingInstance.GetAdvancingRotation());
+}
+
+void CInstanceBase::StartWalking()
+{
+	m_GraphicThingInstance.Move();
+
+	if (IsAffect(AFFECT_GYEONGGONG))
+	{
+		m_adwCRCAffectEffect[AFFECT_GYEONGGONG] = __EffectContainer_AttachEffect(EFFECT_AFFECT_GYEONGGONG);
+	}
+	else if (IsAffect(AFFECT_KWAESOK))
+	{
+		m_adwCRCAffectEffect[AFFECT_KWAESOK] = __EffectContainer_AttachEffect(EFFECT_AFFECT_KWAESOK);
+	}
+}
+
+void CInstanceBase::EndWalking(float fBlendingTime)
+{
+	assert (!IsWaiting() && "CInstanceBase::EndWalking");
+
+	m_isGoing = FALSE;
+
+	// <20>Ȱ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>߰<EFBFBD> <20>ؾ<EFBFBD> <20>Ѵ<EFBFBD>
+	if (IsWalking()||!IsAttacked())
+	{
+		m_GraphicThingInstance.Stop(fBlendingTime);
+		if (IsAffect(AFFECT_GYEONGGONG))
+		{
+			__EffectContainer_DetachEffect(EFFECT_AFFECT_GYEONGGONG);
+		}
+		else if (IsAffect(AFFECT_KWAESOK))
+		{
+			__EffectContainer_DetachEffect(EFFECT_AFFECT_KWAESOK);
+		}
+	}
+}
+
+void CInstanceBase::EndWalkingWithoutBlending()
+{
+	EndWalking(0.0f);
+}
+
+BOOL CInstanceBase::IsWaiting()
+{
+	return m_GraphicThingInstance.IsWaiting();
+}
+
+BOOL CInstanceBase::IsWalking()
+{
+	return m_GraphicThingInstance.IsMoving();
+}
+
+BOOL CInstanceBase::IsPushing()
+{
+	return m_GraphicThingInstance.IsPushing();
+}
+
+BOOL CInstanceBase::IsAttacked()
+{
+	return m_GraphicThingInstance.IsAttacked();		
+}
+
+BOOL CInstanceBase::IsKnockDown()
+{
+	if (!m_GraphicThingInstance.IsKnockDown())
+		return FALSE;
+
+	return TRUE;
+}
+
+BOOL CInstanceBase::IsAttacking()
+{
+	return m_GraphicThingInstance.isAttacking();
+}
+
+BOOL CInstanceBase::IsActingEmotion()
+{
+	return m_GraphicThingInstance.IsActEmotion();
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+BOOL CInstanceBase::IsGoing()
+{
+	return m_isGoing;
+}
+
+void CInstanceBase::NEW_MoveToDestInstanceDirection(CInstanceBase & rkInstDst)
+{
+	TPixelPosition kPPosDst;
+	rkInstDst.NEW_GetPixelPosition(&kPPosDst);
+
+	NEW_MoveToDestPixelPositionDirection(kPPosDst);
+}
+
+bool CInstanceBase::NEW_MoveToDestPixelPositionDirection(const TPixelPosition & c_rkPPosDst)
+{
+	TPixelPosition kPPosCur;
+	NEW_GetPixelPosition(&kPPosCur);
+	float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(kPPosCur, c_rkPPosDst);
+
+	return NEW_Goto(c_rkPPosDst, fDstRot);
+}
+
+bool CInstanceBase::NEW_Goto(const TPixelPosition& c_rkPPosDst, float fDstRot)
+{
+	if (__IsSyncing())
+	{
+		return false;
+	}
+
+	if (m_GraphicThingInstance.IsUsingMovingSkill())
+	{
+		SetAdvancingRotation(fDstRot);
+		return true;
+	}
+
+	if (isLock())
+	{
+		return false;
+	}
+
+	if (!NEW_CanMoveToDestPixelPosition(c_rkPPosDst))
+	{
+		if (!IsWaiting())
+			EndWalking();
+
+		return true;
+	}
+
+	NEW_SetSrcPixelPosition(NEW_GetCurPixelPositionRef());
+	NEW_SetDstPixelPosition(c_rkPPosDst);
+	NEW_SetDstPixelPositionZ(NEW_GetSrcPixelPositionRef().z);
+	m_fDstRot=fDstRot;
+	m_isGoing = TRUE;
+
+	if (!IsWalking())
+	{
+		StartWalking();
+	}
+
+	NEW_SetAdvancingRotationFromPixelPosition(NEW_GetSrcPixelPositionRef(), NEW_GetDstPixelPositionRef());
+
+	return true;
+}
+
+void CInstanceBase::NEW_MoveToDirection(float fDirRot)
+{
+	if (__IsSyncing())
+		return;
+
+	if (m_GraphicThingInstance.IsUsingMovingSkill())
+	{
+		SetAdvancingRotation(fDirRot);
+		return;
+	}
+
+	if (isLock())
+		return;
+
+	m_isGoing = FALSE;
+
+	SetAdvancingRotation(fDirRot);	
+
+	if (!IsWalking())
+	{ 
+		StartWalking();
+	}
+
+	TPixelPosition kPPosCur;
+	NEW_GetPixelPosition(&kPPosCur);
+	
+	D3DXVECTOR3 kD3DVt3Cur(kPPosCur.x, -kPPosCur.y, kPPosCur.z);		
+	D3DXVECTOR3 kD3DVt3Dst;
+
+	D3DXVECTOR3 kD3DVt3AdvDir(0.0f, -1.0f, 0.0f);
+	D3DXMATRIX kD3DMatAdv;
+	D3DXMatrixRotationZ(&kD3DMatAdv, D3DXToRadian(fDirRot));
+	D3DXVec3TransformCoord(&kD3DVt3AdvDir, &kD3DVt3AdvDir, &kD3DMatAdv);
+	D3DXVec3Scale(&kD3DVt3AdvDir, &kD3DVt3AdvDir, 300.0f);
+	D3DXVec3Add(&kD3DVt3Dst, &kD3DVt3AdvDir, &kD3DVt3Cur);
+
+	TPixelPosition kPPosDst;
+	kPPosDst.x = +kD3DVt3Dst.x;
+	kPPosDst.y = -kD3DVt3Dst.y;
+	kPPosDst.z = +kD3DVt3Dst.z;
+	
+	NEW_SetSrcPixelPosition(kPPosCur);
+	NEW_SetDstPixelPosition(kPPosDst);
+}
+
+void CInstanceBase::EndGoing()
+{
+	if (!IsWaiting())
+		EndWalking();
+
+	//Tracen("EndGoing");
+
+	m_isGoing = FALSE;
+}
+
+void CInstanceBase::SetRunMode()
+{
+	m_GraphicThingInstance.SetRunMode();
+}
+
+void CInstanceBase::SetWalkMode()
+{
+	m_GraphicThingInstance.SetWalkMode();
+}

src/UserInterface/InstanceBaseTransform.cpp

@@ -0,0 +1,93 @@
+#include "StdAfx.h"
+#include "InstanceBase.h"
+#include "PythonBackground.h"
+
+
+
+
+void CInstanceBase::SCRIPT_SetPixelPosition(float fx, float fy)
+{
+	float fz = __GetBackgroundHeight(fx, fy);
+	NEW_SetPixelPosition(TPixelPosition(fx, fy, fz));
+}
+
+void CInstanceBase::NEW_SetPixelPosition(const TPixelPosition & c_rPixelPosition)
+{
+	m_GraphicThingInstance.SetCurPixelPosition(c_rPixelPosition);		
+}
+
+void CInstanceBase::NEW_GetPixelPosition(TPixelPosition * pPixelPosition)
+{
+	*pPixelPosition=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();	
+}
+
+void CInstanceBase::SetRotation(float fRotation)
+{
+	m_GraphicThingInstance.SetRotation(fRotation);
+}
+
+void CInstanceBase::BlendRotation(float fRotation, float fBlendTime)
+{
+	m_GraphicThingInstance.BlendRotation(fRotation, fBlendTime);
+}
+
+void CInstanceBase::NEW_LookAtFlyTarget()
+{
+	m_GraphicThingInstance.LookAtFlyTarget();
+}
+
+void CInstanceBase::NEW_LookAtDestPixelPosition(const TPixelPosition& c_rkPPosDst)
+{
+	m_GraphicThingInstance.LookAt(c_rkPPosDst.x, -c_rkPPosDst.y);
+}
+
+void CInstanceBase::NEW_LookAtDestInstance(CInstanceBase& rkInstDst)
+{
+	m_GraphicThingInstance.LookAt(&rkInstDst.m_GraphicThingInstance);
+// 	Tracenf("LookAt %f", m_GraphicThingInstance.GetTargetRotation());
+}
+
+float CInstanceBase::GetRotation()
+{
+	return m_GraphicThingInstance.GetRotation();
+}
+
+float CInstanceBase::GetAdvancingRotation()
+{
+	return m_GraphicThingInstance.GetAdvancingRotation();
+}
+
+void CInstanceBase::SetDirection(int dir)
+{
+	float fDegree = GetDegreeFromDirection(dir);
+	SetRotation(fDegree);
+	SetAdvancingRotation(fDegree);
+}
+
+void CInstanceBase::BlendDirection(int dir, float blendTime)
+{
+	m_GraphicThingInstance.BlendRotation(GetDegreeFromDirection(dir), blendTime);
+}
+
+float CInstanceBase::GetDegreeFromDirection(int dir)
+{
+	if (dir < 0)
+		return 0.0f;
+
+	if (dir >= DIR_MAX_NUM)
+		return 0.0f;
+	
+	static float s_dirRot[DIR_MAX_NUM]=
+	{
+		+45.0f * 4,
+		+45.0f * 3,
+		+45.0f * 2,
+		+45.0f,
+		+0.0f,
+		360.0f-45.0f,
+		360.0f-45.0f * 2,
+		360.0f-45.0f * 3,
+	};
+
+	return s_dirRot[dir];
+}

src/UserInterface/InsultChecker.cpp

@@ -0,0 +1,97 @@
+#include "StdAfx.h"
+#include "InsultChecker.h"
+
+CInsultChecker& CInsultChecker::GetSingleton()
+{
+	static CInsultChecker s_kInsultChecker;
+	return s_kInsultChecker;
+}
+
+CInsultChecker::CInsultChecker()
+{
+}
+
+CInsultChecker::~CInsultChecker()
+{
+}
+
+void CInsultChecker::Clear()
+{
+	m_kList_stInsult.clear();
+}
+
+void CInsultChecker::AppendInsult(const std::string& c_rstInsult)
+{
+	if (c_rstInsult.length()>0)
+		m_kList_stInsult.push_back(c_rstInsult);
+}
+
+bool CInsultChecker::__GetInsultLength(const char* c_szWord, UINT* puInsultLen)
+{
+	std::list<std::string>::iterator i;
+	for (i=m_kList_stInsult.begin(); i!=m_kList_stInsult.end(); ++i)
+	{
+		std::string& rstInsult=*i;
+
+		int ret=LocaleService_StringCompareCI(c_szWord, rstInsult.c_str(), rstInsult.length());		
+		if (0==ret)
+		{
+			*puInsultLen=rstInsult.length();
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool CInsultChecker::__IsInsult(const char* c_szWord)
+{
+	UINT uInsultLen;
+	return __GetInsultLength(c_szWord, &uInsultLen);
+}
+
+void CInsultChecker::FilterInsult(char* szLine, UINT uLineLen)
+{
+	const char INSULT_FILTER_CHAR = '*'; 
+	for (UINT uPos=0; uPos<uLineLen;)
+	{
+		BYTE bChr=szLine[uPos];
+		UINT uInsultLen;
+		if (__GetInsultLength(szLine+uPos, &uInsultLen))
+		{
+			memset(szLine+uPos, INSULT_FILTER_CHAR, uInsultLen);
+			uPos += uInsultLen;
+		}
+		else
+		{
+			if ( LocaleService_IsLeadByte( bChr ) )
+				uPos += 2;
+			else
+				uPos++;
+		}
+	}
+}
+
+bool CInsultChecker::IsInsultIn(const char* c_szLine, UINT uLineLen)
+{
+	for (UINT uPos=0; uPos<uLineLen;)
+	{
+		BYTE bChr=c_szLine[uPos];
+		if (bChr & 0x80)
+		{
+			if (__IsInsult(c_szLine+uPos))
+				return true;
+
+			uPos+=2;
+		}
+		else
+		{
+			if (__IsInsult(c_szLine+uPos))
+				return true;
+
+			uPos++;
+		}
+	}
+
+	return false;
+}

src/UserInterface/InsultChecker.h

@@ -0,0 +1,24 @@
+#pragma once
+
+class CInsultChecker
+{
+	public:
+		CInsultChecker& GetSingleton();
+
+	public:
+		CInsultChecker();
+		virtual ~CInsultChecker();
+
+		void Clear();
+
+		void AppendInsult(const std::string& c_rstInsult);
+		bool IsInsultIn(const char* c_szLine, UINT uLineLen);
+		void FilterInsult(char* szLine, UINT uLineLen);
+
+	private:
+		bool __GetInsultLength(const char* c_szWord, UINT* puInsultLen);
+		bool __IsInsult(const char* c_szWord);
+
+	private:
+		std::list<std::string> m_kList_stInsult;
+};

src/UserInterface/Locale.cpp

@@ -0,0 +1,441 @@
+#include "StdAfx.h"
+#include "Locale.h"
+#include "PythonApplication.h"
+#include "resource.h"
+#include "../eterBase/CRC32.h"
+#include "../eterpack/EterPackManager.h"
+#include "../eterLocale/Japanese.h"
+#include <windowsx.h>
+
+const char* LSS_YMIR		= "YMIR";
+const char* LSS_JAPAN		= "JAPAN";
+const char* LSS_ENGLISH		= "ENGLISH";
+const char* LSS_HONGKONG	= "HONGKONG";
+const char* LSS_TAIWAN		= "TAIWAN";
+const char* LSS_NEWCIBN		= "NEWCIBN";
+const char* LSS_EUROPE		= "EUROPE";
+const char* LSS_GLOBAL		= "GLOBAL";
+
+static bool IS_CHEONMA = false;
+
+#ifndef LSS_SECURITY_KEY
+#define LSS_SECURITY_KEY	"testtesttesttest"
+#endif
+
+std::string __SECURITY_KEY_STRING__ = LSS_SECURITY_KEY;
+
+char	MULTI_LOCALE_SERVICE[256]	= "YMIR";
+char	MULTI_LOCALE_PATH[256]		= "locale/ymir";
+char	MULTI_LOCALE_NAME[256]		= "ymir";
+int		MULTI_LOCALE_CODE			= 949;
+int		MULTI_LOCALE_REPORT_PORT	= 10000;
+
+void LocaleService_LoadConfig(const char* fileName)
+{
+	NANOBEGIN
+	FILE* fp = fopen(fileName, "rt");
+
+	if (fp)
+	{		
+		char	line[256];			
+		char	name[256];
+		int		code;
+		int		id;
+		if (fgets(line, sizeof(line)-1, fp))
+		{
+			line[sizeof(line)-1] = '\0';
+			sscanf(line, "%d %d %s", &id, &code, name);
+
+			MULTI_LOCALE_REPORT_PORT		= id;
+			MULTI_LOCALE_CODE				= code;
+			strcpy(MULTI_LOCALE_NAME, name);
+			sprintf(MULTI_LOCALE_PATH, "locale/%s", MULTI_LOCALE_NAME);
+		}			
+		fclose(fp);
+	}
+	NANOEND
+}
+
+unsigned LocaleService_GetLastExp(int level)
+{
+	static const int GUILD_LEVEL_MAX = 20;
+
+	if (LocaleService_IsCHEONMA())
+	{
+		static DWORD CHEONMA_GUILDEXP_LIST[GUILD_LEVEL_MAX+1] = 
+		{
+			0,			// 0
+			15000ul,	// 1
+			45000ul,	// 2
+			90000ul,	// 3
+			160000ul,	// 4
+			235000ul,	// 5
+			325000ul,	// 6
+			430000ul,	// 7
+			550000ul,	// 8
+			685000ul,	// 9
+			835000ul,	// 10
+			1000000ul,	// 11
+			1500000ul,	// 12
+			2100000ul,	// 13
+			2800000ul,	// 14
+			3600000ul,	// 15
+			4500000ul,	// 16
+			6500000ul,	// 17
+			8000000ul,	// 18
+			10000000ul,	// 19			
+			42000000UL	// 20
+		};
+		if (level < 0 && level >= GUILD_LEVEL_MAX)
+			return 0;
+		
+		return CHEONMA_GUILDEXP_LIST[level];
+	}
+	
+	static DWORD INTERNATIONAL_GUILDEXP_LIST[GUILD_LEVEL_MAX+1] = 
+	{
+		0,			// 0
+		6000UL,		// 1
+		18000UL,	// 2
+		36000UL,	// 3
+		64000UL,	// 4
+		94000UL,	// 5
+		130000UL,	// 6
+		172000UL,	// 7
+		220000UL,	// 8
+		274000UL,	// 9
+		334000UL,	// 10
+		400000UL,	// 11
+		600000UL,	// 12
+		840000UL,	// 13
+		1120000UL,	// 14
+		1440000UL,	// 15
+		1800000UL,	// 16
+		2600000UL,	// 17
+		3200000UL,	// 18
+		4000000UL,	// 19		
+		16800000UL	// 20		
+	};
+
+	if (level < 0 && level >= GUILD_LEVEL_MAX)
+		return 0;
+	
+	return INTERNATIONAL_GUILDEXP_LIST[level];	
+}
+
+int LocaleService_GetSkillPower(unsigned level)
+{
+	static const unsigned SKILL_POWER_NUM = 50;
+
+	if (level >= SKILL_POWER_NUM)
+		return 0;
+
+	if (LocaleService_IsCHEONMA())
+	{
+		static unsigned CHEONMA_SKILL_POWERS[SKILL_POWER_NUM]=
+		{
+			0,  
+				5,  7,  9, 11, 13, 
+				15, 17, 19, 20, 22, 
+				24, 26, 28, 30, 32, 
+				34, 36, 38, 40, 50, // master
+				52, 55, 58, 61, 63,
+				66, 69, 72, 75, 80, // grand_master
+				82, 84, 87, 90, 95,
+				100,110,120,130,150,// perfect_master
+				150,
+		};
+		return CHEONMA_SKILL_POWERS[level];		
+	}
+	
+	// 0 5 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 50 52 54 56 58 60 63 66 69 72 82 85 88 91 94 98 102 106 110 115 125 125 125 125 125
+	static unsigned INTERNATIONAL_SKILL_POWERS[SKILL_POWER_NUM]=
+	{
+		0, 
+			5,  6,  8, 10, 12, 
+			14, 16, 18, 20, 22, 
+			24, 26, 28, 30, 32, 
+			34, 36, 38, 40, 50, // master
+			52, 54, 56, 58, 60, 
+			63, 66, 69, 72, 82, // grand_master
+			85, 88, 91, 94, 98, 
+			102,106,110,115,125,// perfect_master
+			125,	
+	};
+	return INTERNATIONAL_SKILL_POWERS[level];
+}
+
+const char*	LocaleService_GetSecurityKey()
+{
+	return __SECURITY_KEY_STRING__.c_str();
+}
+
+// CHEONMA
+void LocaleService_SetCHEONMA(bool isEnable)
+{
+	IS_CHEONMA = isEnable;
+}
+
+bool LocaleService_IsCHEONMA()
+{
+	return LocaleService_IsYMIR();
+}
+
+// END_OF_CHEONMA
+
+#if defined(LOCALE_SERVICE_EUROPE) || defined(LOCALE_SERVICE_BRAZIL) || defined(LOCALE_SERVICE_CANADA) || defined(LOCALE_SERVICE_SINGAPORE) || defined(LOCALE_SERVICE_VIETNAM) || defined(LOCALE_SERVICE_TAIWAN) || defined(LOCALE_SERVICE_NEWCIBN)
+#define _LSS_USE_LOCALE_CFG			1
+#define _LSS_SERVICE_NAME			LSS_EUROPE
+#elif defined(LOCALE_SERVICE_ITALY)
+#define _LSS_SERVICE_NAME			LSS_ITALY
+#define _LSS_SERVICE_CODEPAGE		CP_LATIN
+#define _LSS_SERVICE_LOCALE_NAME	"it"
+#define _LSS_SERVICE_LOCALE_PATH	"locale/it"
+#elif defined(LOCALE_SERVICE_ENGLISH)
+#define _LSS_SERVICE_NAME			LSS_ENGLISH
+#define _LSS_SERVICE_CODEPAGE		CP_LATIN
+#define _LSS_SERVICE_LOCALE_NAME	"english"
+#define _LSS_SERVICE_LOCALE_PATH	"locale/english"
+#elif defined(LOCALE_SERVICE_JAPAN)
+#define _LSS_SERVICE_NAME			LSS_JAPAN
+#define _LSS_SERVICE_CODEPAGE		CP_JAPANESE
+#define _LSS_SERVICE_LOCALE_NAME	"japan"
+#define _LSS_SERVICE_LOCALE_PATH	"locale/japan"
+#elif defined(LOCALE_SERVICE_YMIR)
+#define _LSS_SERVICE_NAME			LSS_YMIR
+#define _LSS_SERVICE_CODEPAGE		CP_HANGUL
+#define _LSS_SERVICE_LOCALE_NAME	"ymir"
+#define _LSS_SERVICE_LOCALE_PATH	"locale/ymir"
+#elif defined(LOCALE_SERVICE_HONGKONG)
+#define _LSS_SERVICE_NAME			LSS_HONGKONG
+#define _LSS_SERVICE_CODEPAGE		CP_CHINESE_TRAD
+#define _LSS_SERVICE_LOCALE_NAME	"hongkong"
+#define _LSS_SERVICE_LOCALE_PATH	"locale/hongkong"
+#elif defined(LOCALE_SERVICE_TAIWAN)
+#define _LSS_SERVICE_NAME			LSS_TAIWAN
+#define _LSS_SERVICE_CODEPAGE		CP_CHINESE_TRAD
+#define _LSS_SERVICE_LOCALE_NAME	"taiwan"
+#define _LSS_SERVICE_LOCALE_PATH	"locale/taiwan"
+#elif defined(LOCALE_SERVICE_NEWCIBN)
+#define _LSS_SERVICE_NAME			LSS_NEWCIBN
+#define _LSS_SERVICE_CODEPAGE		CP_CHINESE_SIMPLE
+#define _LSS_SERVICE_LOCALE_NAME	"newcibn"
+#define _LSS_SERVICE_LOCALE_PATH	"locale/newcibn"
+#endif
+
+#if defined(_LSS_USE_LOCALE_CFG)
+#if defined(_LSS_SERVICE_NAME)
+const char* LocaleService_GetName()				{ return _LSS_SERVICE_NAME;}
+#else
+const char* LocaleService_GetName()				{ return MULTI_LOCALE_SERVICE; }
+#endif
+unsigned int LocaleService_GetCodePage()		{ return MULTI_LOCALE_CODE; }
+const char*	LocaleService_GetLocaleName()		{ return MULTI_LOCALE_NAME; }
+const char*	LocaleService_GetLocalePath()		{ return MULTI_LOCALE_PATH; }
+#elif defined(_LSS_SERVICE_NAME)
+const char* LocaleService_GetName()				{ return _LSS_SERVICE_NAME;}
+unsigned int LocaleService_GetCodePage()		{ return _LSS_SERVICE_CODEPAGE; }
+const char*	LocaleService_GetLocaleName()		{ return _LSS_SERVICE_LOCALE_NAME; }
+const char*	LocaleService_GetLocalePath()		{ return _LSS_SERVICE_LOCALE_PATH; }
+#endif
+
+void LocaleService_ForceSetLocale(const char* name, const char* localePath)
+{
+	strcpy(MULTI_LOCALE_NAME, name);
+	strcpy(MULTI_LOCALE_PATH, localePath);
+
+	// <20><><EFBFBD><EFBFBD> õ<><C3B5> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ӽÿ<D3BD><C3BF><EFBFBD> security key <20><><EFBFBD><EFBFBD> (WE <20><><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD><EFBFBD> õ<><C3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD> <20><><EFBFBD><EFBFBD>)
+	if (0 == stricmp(name, "ymir"))
+		__SECURITY_KEY_STRING__ = "testtesttesttest";
+	if (0 == stricmp(name, "we_korea"))
+		__SECURITY_KEY_STRING__ = "1234abcd5678efgh";
+}
+
+#if defined(LOCALE_SERVICE_GLOBAL)
+struct SLOCALEDATA
+{
+	const char* szServiceName;
+	const char* szLocaleName;
+	WORD		wCodePage;
+	const char*	szSecurityKey;
+} gs_stLocaleData[] = {
+	{ LSS_YMIR,		"ymir",			949,	"testtesttesttest"	},		// Korea
+	{ LSS_EUROPE,	"de",			1252,	"1234abcd5678efgh"	},		// GameForge (Germany)
+	{ LSS_EUROPE,	"en",			1252,	"1234abcd5678efgh"	},		// GameForge (United Kingdom)
+	{ LSS_EUROPE,	"us",			1252,	"1234abcd5678efgh"	},		// GameForge (USA)
+	{ LSS_EUROPE,	"es",			1252,	"1234abcd5678efgh"	},		// GameForge (Spain)
+	{ LSS_EUROPE,	"it",			1252,	"1234abcd5678efgh"	},		// GameForge (Italy)
+	{ LSS_EUROPE,	"fr",			1252,	"1234abcd5678efgh"	},		// GameForge (France)
+	{ LSS_EUROPE,	"pt",			1252,	"1234abcd5678efgh"	},		// GameForge (Portugal)
+	{ LSS_EUROPE,	"tr",			1253,	"1234abcd5678efgh"	},		// GameForge (Greece)
+	{ LSS_EUROPE,	"pl",			1250,	"1234abcd5678efgh"	},		// GameForge (Poland)
+	{ LSS_EUROPE,	"tr",			1254,	"1234abcd5678efgh"	},		// GameForge (Turkey)
+	{ LSS_EUROPE,	"dk",			1252,	"1234abcd5678efgh"	},		// GameForge (Demmark)
+	{ LSS_EUROPE,	"ae",			1256,	"1234abcd5678efgh"	},		// GameForge (United Arab Emirate)
+	{ LSS_EUROPE,	"mx",			1252,	"1234abcd5678efgh"	},		// GameForge (Mexico)
+	{ LSS_EUROPE,	"nl",			1252,	"1234abcd5678efgh"	},		// GameForge (Netherlands)
+	{ LSS_EUROPE,	"cz",			1252,	"1234abcd5678efgh"	},		// GameForge (Czech Republic)
+	{ LSS_EUROPE,	"ru",			1251,	"1234abcd5678efgh"	},		// GameForge (Russian Federation)
+	{ LSS_EUROPE,	"hu",			1250,	"1234abcd5678efgh"	},		// GameForge (Hungary)
+	{ LSS_EUROPE,	"ro",			1250,	"1234abcd5678efgh"	},		// GameForge (Romania)
+	{ LSS_EUROPE,	"ca",			1252,	"testtesttesttest"	},		// Z8Games (Canada)
+	{ LSS_EUROPE,	"sg",			1252,	"testtesttesttest"	},		// TEC (Singapore)
+	{ LSS_JAPAN,	"japan",		932,	"testtesttesttest"	},		// Japan
+	{ LSS_EUROPE,	"br",			1252,	"testtesttesttest"	},		// OnGame (Brazil)
+	{ LSS_HONGKONG,	"hongkong",		950,	"testtesttesttest"	},		// HongKong & Taiwan
+	{ LSS_NEWCIBN,	"newcibn",		936,	"testtesttesttest"	},		// CIBN (Free world)
+	{ LSS_ENGLISH,	"english",		949,	"testtesttesttest"	},		// English (Obsoleted)
+	{ LSS_YMIR,		"kr",			949,	"testtesttesttest"	},		// Korea (Obsoleted)
+	{ NULL,			NULL,			0,		"testtesttesttest"	}
+};
+
+const char* LocaleService_GetName()
+{
+	return MULTI_LOCALE_SERVICE;
+}
+
+unsigned int LocaleService_GetCodePage()
+{
+	return MULTI_LOCALE_CODE;
+}
+
+const char*	LocaleService_GetLocaleName()
+{
+	return MULTI_LOCALE_NAME;
+}
+
+const char*	LocaleService_GetLocalePath()
+{
+	return MULTI_LOCALE_PATH;
+}
+
+static int gs_iLocale = -1;
+
+LRESULT CALLBACK SelectDlgProc( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
+{
+	switch( uMsg ) {
+	case WM_INITDIALOG : {
+		char szLocalePath[256], szDisplayName[256];
+		for(int i=0; gs_stLocaleData[i].szServiceName; i++ ) {
+			sprintf(szLocalePath, "locale/%s/item_proto", gs_stLocaleData[i].szLocaleName);
+			if( CEterPackManager::Instance().isExist(szLocalePath)) {
+				sprintf(szDisplayName, "%s (%s, %d)", gs_stLocaleData[i].szLocaleName, gs_stLocaleData[i].szServiceName, gs_stLocaleData[i].wCodePage);
+				int iIndex = ListBox_AddString(GetDlgItem(hDlg, IDC_LOCALE_LIST), szDisplayName);
+				ListBox_SetItemData(GetDlgItem(hDlg, IDC_LOCALE_LIST), iIndex, i);
+			}
+		}
+		return TRUE;
+		}
+	case WM_COMMAND :
+		switch( LOWORD( wParam ) ) {
+		case IDC_LOCALE_LIST: {
+			int iSelected = ListBox_GetCurSel(GetDlgItem(hDlg, IDC_LOCALE_LIST));
+			switch(HIWORD(wParam)) {
+			case LBN_SELCHANGE :
+				gs_iLocale = ListBox_GetItemData(GetDlgItem(hDlg, IDC_LOCALE_LIST), iSelected);
+				break;
+			case LBN_DBLCLK :
+				gs_iLocale = ListBox_GetItemData(GetDlgItem(hDlg, IDC_LOCALE_LIST), iSelected);
+				::EndDialog(hDlg, 0);
+				break;
+			} 
+			break;
+			}
+		case IDC_START: {
+			::EndDialog(hDlg, 0);
+			break;
+			}
+		case IDC_EXIT: {
+			gs_iLocale = -1;
+			::EndDialog(hDlg, 0);
+			break;
+			}
+		}
+		return FALSE;
+	}
+	return FALSE;
+}
+
+bool LocaleService_LoadGlobal(HINSTANCE hInstance)
+{
+	int nFoundLocales = 0;
+	char szLocalePath[256];
+
+	for(int i=0; gs_stLocaleData[i].szServiceName; i++ ) {
+		sprintf(szLocalePath, "locale/%s/item_proto", gs_stLocaleData[i].szLocaleName);
+		if( CEterPackManager::Instance().isExist(szLocalePath)) {
+			nFoundLocales++;
+			if(gs_iLocale == -1)
+				gs_iLocale = i;
+		}
+	}
+	if (gs_iLocale < 0)
+		return false;
+	if(nFoundLocales > 1)
+		::DialogBox(hInstance, MAKEINTRESOURCE(IDD_SELECT_LOCALE), NULL, (DLGPROC) SelectDlgProc);
+	if (gs_iLocale < 0)
+		return false;
+	strcpy(MULTI_LOCALE_SERVICE, gs_stLocaleData[gs_iLocale].szServiceName);
+	strcpy(MULTI_LOCALE_NAME, gs_stLocaleData[gs_iLocale].szLocaleName);
+	sprintf(MULTI_LOCALE_PATH, "locale/%s", gs_stLocaleData[gs_iLocale].szLocaleName);
+	MULTI_LOCALE_CODE = gs_stLocaleData[gs_iLocale].wCodePage;
+	if(gs_stLocaleData[gs_iLocale].szSecurityKey)
+		__SECURITY_KEY_STRING__ = gs_stLocaleData[gs_iLocale].szSecurityKey;
+	return true;
+}
+#else
+bool LocaleService_LoadGlobal(HINSTANCE hInstance)
+{
+	return false;
+}
+#endif
+
+bool LocaleService_IsYMIR()		{ return (stricmp( LocaleService_GetName(), LSS_YMIR ) == 0) || (stricmp( LocaleService_GetLocaleName(), "ymir" ) == 0);	}
+bool LocaleService_IsJAPAN()	{ return (stricmp( LocaleService_GetName(), LSS_JAPAN ) == 0) || (stricmp( LocaleService_GetLocaleName(), "japan" ) == 0);	}
+bool LocaleService_IsENGLISH()	{ return (stricmp( LocaleService_GetName(), LSS_ENGLISH ) == 0);	}
+bool LocaleService_IsEUROPE()	{ return (stricmp( LocaleService_GetName(), LSS_EUROPE ) == 0);		}
+bool LocaleService_IsHONGKONG()	{ return (stricmp( LocaleService_GetName(), LSS_HONGKONG ) == 0);	}
+bool LocaleService_IsTAIWAN()	{ return (stricmp( LocaleService_GetName(), LSS_TAIWAN ) == 0);		}
+bool LocaleService_IsNEWCIBN()	{ return (stricmp( LocaleService_GetName(), LSS_NEWCIBN ) == 0);	}
+
+#if defined(LOCALE_SERVICE_WE_JAPAN)
+BOOL LocaleService_IsLeadByte( const char chByte )
+{
+	return ShiftJIS_IsLeadByte( chByte );
+}
+
+int LocaleService_StringCompareCI( LPCSTR szStringLeft, LPCSTR szStringRight, size_t sizeLength )
+{
+	return ShiftJIS_StringCompareCI( szStringLeft, szStringRight, sizeLength );
+}
+#else
+BOOL LocaleService_IsLeadByte( const char chByte )
+{
+	return (((unsigned char) chByte) & 0x80) != 0;
+}
+
+int LocaleService_StringCompareCI( LPCSTR szStringLeft, LPCSTR szStringRight, size_t sizeLength )
+{
+	return strnicmp( szStringLeft, szStringRight, sizeLength );
+}
+#endif
+
+
+#ifdef USE_OPENID
+
+std::string __OPENID_AUTH_KEY_STRING__;
+int openid_test = 0;
+
+void LocaleService_SetOpenIDAuthKey(const char *authKey)
+{
+	 __OPENID_AUTH_KEY_STRING__ = authKey;
+
+	 return;
+}
+
+const char*	LocaleService_GetOpenIDAuthKey()
+{
+	return __OPENID_AUTH_KEY_STRING__.c_str();
+}
+
+#endif /* USE_OPENID */

src/UserInterface/Locale.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "Locale_inc.h"
+
+bool		LocaleService_IsYMIR();
+bool		LocaleService_IsJAPAN();
+bool		LocaleService_IsENGLISH();
+bool		LocaleService_IsHONGKONG();
+bool		LocaleService_IsTAIWAN();
+bool		LocaleService_IsNEWCIBN();
+bool		LocaleService_IsEUROPE();
+bool		LocaleService_IsWorldEdition();
+
+unsigned	LocaleService_GetCodePage();
+const char* LocaleService_GetName();
+const char*	LocaleService_GetLocaleName();
+const char*	LocaleService_GetLocalePath();
+const char*	LocaleService_GetSecurityKey();
+BOOL		LocaleService_IsLeadByte( const char chByte );
+int			LocaleService_StringCompareCI( LPCSTR szStringLeft, LPCSTR szStringRight, size_t sizeLength );
+
+void		LocaleService_ForceSetLocale(const char* name, const char* localePath);
+void		LocaleService_LoadConfig(const char* fileName);
+bool		LocaleService_LoadGlobal(HINSTANCE hInstance);
+unsigned	LocaleService_GetLastExp(int level);
+int			LocaleService_GetSkillPower(unsigned level);
+
+// CHEONMA
+void		LocaleService_SetCHEONMA(bool isEnable);
+bool		LocaleService_IsCHEONMA();
+// END_OF_CHEONMA
+
+#ifdef USE_OPENID
+void LocaleService_SetOpenIDAuthKey(const char *authKey);
+const char*	LocaleService_GetOpenIDAuthKey();
+#endif

src/UserInterface/Locale_inc.h

@@ -0,0 +1,4 @@
+#define LOCALE_SERVICE_SINGAPORE			// <20>̰<EFBFBD><CCB0><EFBFBD>
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM
+#define ENABLE_NEW_EQUIPMENT_SYSTEM

src/UserInterface/Locale_inc_BR.h

@@ -0,0 +1,7 @@
+#define LOCALE_SERVICE_BRAZIL				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+#define XTRAP_CLIENT_ENABLE
+#define XTRAP_PATCH_ARG	"660970B4483BDC32C5266D9844CFED6230832A3E2F95F8DD45DB9AED6AE8B837900845956432BD8F2D14136A8CF8BD970A93B783971789382A493B68C5C2BA650F7D04245246E41FB1670C4E955F790A585C3F5D8EB0BADD81C6DD2DB7"
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM
+#define ENABLE_DRAGON_SOUL_SYSTEM

src/UserInterface/Locale_inc_CA.h

@@ -0,0 +1,6 @@
+#define LOCALE_SERVICE_CANADA				// ij<><C4B3><EFBFBD><EFBFBD>
+
+#define XTRAP_CLIENT_ENABLE
+#define XTRAP_PATCH_ARG	"660970B4953BDCCFC5266D9844CFED62D9D88487BAFA5824E622544D919AC5C535B7B5BB27DF7189499DA1EFA3745A052BE7AE8B12275EDE90BAFDD333407BF80F7D04245246E40AF7650C4AD8583917B21AD7B2AFDE3D4F588C800D128456E1DFEC"
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM

src/UserInterface/Locale_inc_EU.h

@@ -0,0 +1,5 @@
+#define LOCALE_SERVICE_EUROPE				// <20><><EFBFBD><EFBFBD>
+
+#define LSS_SECURITY_KEY		"1234abcd5678efgh"
+
+#define CHECK_LATEST_DATA_FILES

src/UserInterface/Locale_inc_EU2.h

@@ -0,0 +1,15 @@
+#define LOCALE_SERVICE_EUROPE				// <20><><EFBFBD><EFBFBD>
+
+//#define USE_AHNLAB_HACKSHIELD
+
+//#define CHECK_LATEST_DATA_FILES
+
+#define LSS_SECURITY_KEY					"1234abcd5678efgh"
+
+#define ENABLE_COSTUME_SYSTEM
+
+#define ENABLE_ENERGY_SYSTEM
+
+#define ENABLE_DRAGON_SOUL_SYSTEM
+#define ENABLE_NEW_EQUIPMENT_SYSTEM	
+

src/UserInterface/Locale_inc_GB.h

@@ -0,0 +1,3 @@
+#define LOCALE_SERVICE_GLOBAL			// GLOBAL version
+
+#define USE_RELATIVE_PATH

src/UserInterface/Locale_inc_HK.h

@@ -0,0 +1,2 @@
+#define LOCALE_SERVICE_HONGKONG			// ȫ<><C8AB>
+

src/UserInterface/Locale_inc_JP.h

@@ -0,0 +1,13 @@
+#define LOCALE_SERVICE_WE_JAPAN				// World Edition(<28><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ϻ<EFBFBD>
+#define LOCALE_SERVICE_EUROPE				// <20><><EFBFBD><EFBFBD>
+
+#define LSS_SECURITY_KEY		"1234abcd5678efgh"
+
+#define CHECK_LATEST_DATA_FILES
+
+#define XTRAP_CLIENT_ENABLE
+#define XTRAP_PATCH_ARG	"660970B45839DC81C5456D9844CFED62303A1E1A50FFCBE4EA66A304B961F2C32CE50A020A6641FABDF1012DCA07BBC05387C8AD0D4781097428789FE68B54150F7D04245246E404A17B4351DC553907911A3FD51AEE1C697A03BC66B3A378"
+
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM
+#define USE_OPENID

src/UserInterface/Locale_inc_KO.h

@@ -0,0 +1,9 @@
+#include "Locale_inc_EU.h"
+
+//#define XTRAP_CLIENT_ENABLE
+#define XTRAP_PATCH_ARG	"660970B47839DCBFC5206D9844CFED627251D23A44458651BD1F0E57E26D7C85B4CC00C30B1D1724026D5F65A662992141DB6C233A24040C5A6BCD6D25A5576D0F7D04245246E417A4610E56955D721985C1414D9E254947FC"
+
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM
+#define ENABLE_DRAGON_SOUL_SYSTEM
+#define ENABLE_NEW_EQUIPMENT_SYSTEM

src/UserInterface/Locale_inc_KO_DEV.h

@@ -0,0 +1,5 @@
+#define LOCALE_SERVICE_YMIR					// Korean
+
+#define LOCALE_SERVICE_STAGE_DEVELOPMENT
+
+#define USE_RELATIVE_PATH

src/UserInterface/Locale_inc_NEWCIBN.h

@@ -0,0 +1,6 @@
+#define LOCALE_SERVICE_NEWCIBN			// <20>߱<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM
+#define ENABLE_DRAGON_SOUL_SYSTEM
+#define ENABLE_NEW_EQUIPMENT_SYSTEM

src/UserInterface/Locale_inc_SG.h

@@ -0,0 +1,3 @@
+#define LOCALE_SERVICE_SINGAPORE			// <20>̰<EFBFBD><CCB0><EFBFBD>
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM

src/UserInterface/Locale_inc_TW.h

@@ -0,0 +1,6 @@
+#include "Locale_inc_EU.h"
+
+#define XTRAP_CLIENT_ENABLE
+#define XTRAP_PATCH_ARG	"660970B42839DCB1C5216D9844CFEF627C04A4449DB3397908ECE2111F86F65D381E3E23BC5EFD06F7C156DAF51F09F4775BE1254518FD6714B82A60E9E358CA0F7D04245246E40AF73B1A4EDA427C43693E88A442DE667BA0F0BB5135"
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM

src/UserInterface/Locale_inc_VI.h

@@ -0,0 +1 @@
+#define LOCALE_SERVICE_VIETNAM			// <20><>Ʈ<EFBFBD><C6AE>

src/UserInterface/Locale_inc_VI2.h

@@ -0,0 +1,2 @@
+#define LOCALE_SERVICE_VIETNAM			// <20><>Ʈ<EFBFBD><C6AE>
+#define LOCALE_SERVICE_VIETNAM_MILD		// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>

src/UserInterface/Locale_inc_dev.h

@@ -0,0 +1,9 @@
+#include "Locale_inc_EU.h"
+
+//#define XTRAP_CLIENT_ENABLE
+//#define XTRAP_PATCH_ARG	"660970B47839DCBFC5206D9844CFED627251D23A44458651BD1F0E57E26D7C85B4CC00C30B1D1724026D5F65A662992141DB6C233A24040C5A6BCD6D25A5576D0F7D04245246E417A4610E56955D721985C1414D9E254947FC"
+
+#define ENABLE_COSTUME_SYSTEM
+#define ENABLE_ENERGY_SYSTEM
+#define ENABLE_DRAGON_SOUL_SYSTEM
+#define ENABLE_NEW_EQUIPMENT_SYSTEM

src/UserInterface/MarkImage.cpp

@@ -0,0 +1,313 @@
+#include "stdafx.h"
+#include "MarkImage.h"
+
+#if !defined(_MSC_VER)
+#include <IL/il.h>
+#include "crc32.h"
+#include "lzo_manager.h"
+#include "minilzo.h"
+#define CLZO LZOManager
+#else
+#define sys_err TraceError
+#define sys_log //(n, format, ...) Tracenf(format, __VA_ARGS__)
+#define thecore_memcpy memcpy
+#define itertype(cont) typeof(cont.begin())
+#endif
+
+CGuildMarkImage * NewMarkImage()
+{
+	return new CGuildMarkImage;
+}
+
+void DeleteMarkImage(CGuildMarkImage * pkImage)
+{
+	delete pkImage;
+}
+
+CGuildMarkImage::CGuildMarkImage()
+{
+	m_uImg = INVALID_HANDLE;
+}
+
+CGuildMarkImage::~CGuildMarkImage()
+{
+	Destroy();
+}
+
+void CGuildMarkImage::Destroy()
+{
+	if (INVALID_HANDLE == m_uImg)
+		return;
+
+	ilDeleteImages(1, &m_uImg);
+	m_uImg = INVALID_HANDLE;
+}
+
+void CGuildMarkImage::Create()
+{
+	if (INVALID_HANDLE != m_uImg)
+		return;
+
+	ilGenImages(1, &m_uImg);
+}
+
+bool CGuildMarkImage::Save(const char* c_szFileName) 
+{
+	ilEnable(IL_FILE_OVERWRITE);
+	ilBindImage(m_uImg);
+
+	if (!ilSave(IL_TGA, (const ILstring)c_szFileName))
+		return false;
+
+	return true;
+}
+
+bool CGuildMarkImage::Build(const char * c_szFileName)
+{
+	Destroy();
+	Create();
+
+	ilBindImage(m_uImg);
+	ilEnable(IL_ORIGIN_SET);
+	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
+
+	BYTE * data = (BYTE *) malloc(sizeof(Pixel) * WIDTH * HEIGHT);
+	memset(data, 0, sizeof(Pixel) * WIDTH * HEIGHT);
+
+	if (!ilTexImage(WIDTH, HEIGHT, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, data))
+	{
+		sys_err("CGuildMarkImage: cannot initialize image");
+		return false;
+	}
+
+	free(data);
+
+	ilEnable(IL_FILE_OVERWRITE);
+
+	if (!ilSave(IL_TGA, (const ILstring)c_szFileName))
+		return false;
+
+	return true;
+}
+
+bool CGuildMarkImage::Load(const char * c_szFileName) 
+{
+	Destroy();
+	Create();	
+
+	ilBindImage(m_uImg);
+	ilEnable(IL_ORIGIN_SET);
+	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
+
+	if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring) c_szFileName))
+	{
+		Build(c_szFileName);
+		
+		if (!Load(c_szFileName))
+		{
+			sys_err("CGuildMarkImage: cannot open file for writing %s", c_szFileName);
+			return false;
+		}
+	}
+
+	if (ilGetInteger(IL_IMAGE_WIDTH) != WIDTH)	
+	{
+		sys_err("CGuildMarkImage: %s width must be %u", c_szFileName, WIDTH);
+		return false;
+	}
+
+	if (ilGetInteger(IL_IMAGE_HEIGHT) != HEIGHT)
+	{
+		sys_err("CGuildMarkImage: %s height must be %u", c_szFileName, HEIGHT);
+		return false;
+	}
+
+	ilConvertImage(IL_BGRA, IL_UNSIGNED_BYTE);
+
+	BuildAllBlocks();
+	return true;
+}
+
+void CGuildMarkImage::PutData(UINT x, UINT y, UINT width, UINT height, void * data)
+{
+	ilBindImage(m_uImg);
+	ilSetPixels(x, y, 0, width, height, 1, IL_BGRA, IL_UNSIGNED_BYTE, data);
+}
+
+void CGuildMarkImage::GetData(UINT x, UINT y, UINT width, UINT height, void * data)
+{
+	ilBindImage(m_uImg);
+	ilCopyPixels(x, y, 0, width, height, 1, IL_BGRA, IL_UNSIGNED_BYTE, data);	
+}
+
+// <20>̹<EFBFBD><CCB9><EFBFBD> = 512x512
+//   <20><><EFBFBD><EFBFBD> = <20><>ũ 4 x 4
+//   <20><>ũ = 16 x 12
+// <20><> <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> = 8 x 10
+
+// SERVER
+bool CGuildMarkImage::SaveMark(DWORD posMark, BYTE * pbImage)
+{
+	if (posMark >= MARK_TOTAL_COUNT)
+	{
+		sys_err("CGuildMarkImage::CopyMarkFromData: Invalid mark position %u", posMark);
+		return false;
+	}
+
+	// <20><>ũ<EFBFBD><C5A9> <20><>ü <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20>׸<EFBFBD><D7B8><EFBFBD>.
+	DWORD colMark = posMark % MARK_COL_COUNT;
+	DWORD rowMark = posMark / MARK_COL_COUNT;
+
+	printf("PutMark pos %u %ux%u\n", posMark, colMark * SGuildMark::WIDTH, rowMark * SGuildMark::HEIGHT);
+	PutData(colMark * SGuildMark::WIDTH, rowMark * SGuildMark::HEIGHT, SGuildMark::WIDTH, SGuildMark::HEIGHT, pbImage);
+
+	// <20>׷<EFBFBD><D7B7><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
+	DWORD rowBlock = rowMark / SGuildMarkBlock::MARK_PER_BLOCK_HEIGHT;
+	DWORD colBlock = colMark / SGuildMarkBlock::MARK_PER_BLOCK_WIDTH;
+
+	Pixel apxBuf[SGuildMarkBlock::SIZE];
+	GetData(colBlock * SGuildMarkBlock::WIDTH, rowBlock * SGuildMarkBlock::HEIGHT, SGuildMarkBlock::WIDTH, SGuildMarkBlock::HEIGHT, apxBuf);
+	m_aakBlock[rowBlock][colBlock].Compress(apxBuf);
+	return true;
+}
+
+bool CGuildMarkImage::DeleteMark(DWORD posMark)
+{
+	Pixel image[SGuildMark::SIZE];
+	memset(&image, 0, sizeof(image));
+	return SaveMark(posMark, (BYTE *) &image);
+}
+
+// CLIENT
+bool CGuildMarkImage::SaveBlockFromCompressedData(DWORD posBlock, const BYTE * pbComp, DWORD dwCompSize)
+{
+	if (posBlock >= BLOCK_TOTAL_COUNT)
+		return false;
+
+	Pixel apxBuf[SGuildMarkBlock::SIZE];
+	size_t sizeBuf = sizeof(apxBuf);
+
+	if (LZO_E_OK != lzo1x_decompress_safe(pbComp, dwCompSize, (BYTE *) apxBuf, (lzo_uint*) &sizeBuf, CLZO::Instance().GetWorkMemory()))
+	{
+		sys_err("CGuildMarkImage::CopyBlockFromCompressedData: cannot decompress, compressed size = %u", dwCompSize);
+		return false;
+	}
+
+	if (sizeBuf != sizeof(apxBuf))
+	{
+		sys_err("CGuildMarkImage::CopyBlockFromCompressedData: image corrupted, decompressed size = %u", sizeBuf);
+		return false;
+	}
+
+	DWORD rowBlock = posBlock / BLOCK_COL_COUNT;
+	DWORD colBlock = posBlock % BLOCK_COL_COUNT;
+
+	PutData(colBlock * SGuildMarkBlock::WIDTH, rowBlock * SGuildMarkBlock::HEIGHT, SGuildMarkBlock::WIDTH, SGuildMarkBlock::HEIGHT, apxBuf);
+
+	m_aakBlock[rowBlock][colBlock].CopyFrom(pbComp, dwCompSize, GetCRC32((const char *) apxBuf, sizeof(Pixel) * SGuildMarkBlock::SIZE));
+	return true;
+}
+
+void CGuildMarkImage::BuildAllBlocks() // <20>̹<EFBFBD><CCB9><EFBFBD> <20><>ü<EFBFBD><C3BC> <20><><EFBFBD><EFBFBD>ȭ
+{
+	Pixel apxBuf[SGuildMarkBlock::SIZE];
+	sys_log(0, "CGuildMarkImage::BuildAllBlocks");
+
+	for (UINT row = 0; row < BLOCK_ROW_COUNT; ++row)
+		for (UINT col = 0; col < BLOCK_COL_COUNT; ++col)
+		{
+			GetData(col * SGuildMarkBlock::WIDTH, row * SGuildMarkBlock::HEIGHT, SGuildMarkBlock::WIDTH, SGuildMarkBlock::HEIGHT, apxBuf);
+			m_aakBlock[row][col].Compress(apxBuf);
+		}
+}
+
+DWORD CGuildMarkImage::GetEmptyPosition()
+{
+	SGuildMark kMark;
+
+	for (DWORD row = 0; row < MARK_ROW_COUNT; ++row)
+	{
+		for (DWORD col = 0; col < MARK_COL_COUNT; ++col)
+		{
+			GetData(col * SGuildMark::WIDTH, row * SGuildMark::HEIGHT, SGuildMark::WIDTH, SGuildMark::HEIGHT, kMark.m_apxBuf);
+
+			if (kMark.IsEmpty())
+				return (row * MARK_COL_COUNT + col);
+		}
+	}
+
+	return INVALID_MARK_POSITION;
+}
+
+void CGuildMarkImage::GetDiffBlocks(const DWORD * crcList, std::map<BYTE, const SGuildMarkBlock *> & mapDiffBlocks)
+{
+	BYTE posBlock = 0;
+
+	for (DWORD row = 0; row < BLOCK_ROW_COUNT; ++row)
+		for (DWORD col = 0; col < BLOCK_COL_COUNT; ++col)
+		{
+			if (m_aakBlock[row][col].m_crc != *crcList)
+			{
+				mapDiffBlocks.insert(std::map<BYTE, const SGuildMarkBlock *>::value_type(posBlock, &m_aakBlock[row][col]));
+			}
+			++crcList;
+			++posBlock;
+		}
+}
+
+void CGuildMarkImage::GetBlockCRCList(DWORD * crcList)
+{
+	for (DWORD row = 0; row < BLOCK_ROW_COUNT; ++row)
+		for (DWORD col = 0; col < BLOCK_COL_COUNT; ++col)
+			*(crcList++) = m_aakBlock[row][col].GetCRC();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void SGuildMark::Clear()
+{
+	for (DWORD iPixel = 0; iPixel < SIZE; ++iPixel)
+		m_apxBuf[iPixel] = 0xff000000;	
+}
+
+bool SGuildMark::IsEmpty()
+{
+	for (DWORD iPixel = 0; iPixel < SIZE; ++iPixel)
+		if (m_apxBuf[iPixel] != 0x00000000)
+			return false;
+
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+DWORD SGuildMarkBlock::GetCRC() const
+{
+	return m_crc;
+}
+
+void SGuildMarkBlock::CopyFrom(const BYTE * pbCompBuf, DWORD dwCompSize, DWORD crc)
+{
+	if (dwCompSize > MAX_COMP_SIZE)
+		return;
+
+	m_sizeCompBuf = dwCompSize;
+	thecore_memcpy(m_abCompBuf, pbCompBuf, dwCompSize);
+	m_crc = crc;
+	//printf("SGuildMarkBlock::CopyFrom: %u > %u crc %u\n", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf, m_crc);
+}
+
+void SGuildMarkBlock::Compress(const Pixel * pxBuf)
+{
+	m_sizeCompBuf = MAX_COMP_SIZE;
+
+	if (LZO_E_OK != lzo1x_999_compress((const BYTE *) pxBuf,
+		sizeof(Pixel) * SGuildMarkBlock::SIZE, m_abCompBuf,
+		(lzo_uint*) &m_sizeCompBuf,
+		CLZO::Instance().GetWorkMemory()))
+	{
+		sys_err("SGuildMarkBlock::Compress: Error! %u > %u", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf);
+		return;
+	}
+
+	//sys_log(0, "SGuildMarkBlock::Compress %u > %u", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf);
+	m_crc = GetCRC32((const char *) pxBuf, sizeof(Pixel) * SGuildMarkBlock::SIZE);
+}

src/UserInterface/MarkImage.h

@@ -0,0 +1,111 @@
+#ifndef __INC_METIN_II_MARKIMAGE_H__
+#define __INC_METIN_II_MARKIMAGE_H__
+
+#define IL_STATIC_LIB 1
+#include <IL/il.h>
+
+typedef unsigned long Pixel;
+
+struct SGuildMark
+{
+	enum
+	{
+		WIDTH = 16,
+		HEIGHT = 12,
+		SIZE = WIDTH * HEIGHT,
+	};
+
+	///////////////////////////////////////////////////////////////////////////////
+	Pixel m_apxBuf[SIZE];	// <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD>
+
+	///////////////////////////////////////////////////////////////////////////////
+	void Clear();
+	bool IsEmpty();
+};
+
+struct SGuildMarkBlock
+{
+	enum
+	{
+		MARK_PER_BLOCK_WIDTH = 4,
+		MARK_PER_BLOCK_HEIGHT = 4,
+
+		WIDTH = SGuildMark::WIDTH * MARK_PER_BLOCK_WIDTH,
+		HEIGHT = SGuildMark::HEIGHT * MARK_PER_BLOCK_HEIGHT,
+
+		SIZE = WIDTH * HEIGHT,
+		MAX_COMP_SIZE = (SIZE * sizeof(Pixel)) + ((SIZE * sizeof(Pixel)) >> 4) + 64 + 3 
+	};
+
+	///////////////////////////////////////////////////////////////////////////////
+	Pixel	m_apxBuf[SIZE];	// <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD>
+
+	BYTE 	m_abCompBuf[MAX_COMP_SIZE];	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	size_t	m_sizeCompBuf;	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9>
+	DWORD	m_crc;			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CRC
+
+	///////////////////////////////////////////////////////////////////////////////
+	DWORD	GetCRC() const;
+
+	void	CopyFrom(const BYTE * pbCompBuf, DWORD dwCompSize, DWORD crc);
+	void	Compress(const Pixel * pxBuf);
+};
+
+class CGuildMarkImage
+{
+	public:
+		enum
+		{
+			WIDTH = 512,
+			HEIGHT = 512,
+
+			BLOCK_ROW_COUNT = HEIGHT / SGuildMarkBlock::HEIGHT, // 10
+			BLOCK_COL_COUNT = WIDTH / SGuildMarkBlock::WIDTH, // 8
+
+			BLOCK_TOTAL_COUNT = BLOCK_ROW_COUNT * BLOCK_COL_COUNT, // 80
+
+			MARK_ROW_COUNT = BLOCK_ROW_COUNT * SGuildMarkBlock::MARK_PER_BLOCK_HEIGHT, // 40
+			MARK_COL_COUNT = BLOCK_COL_COUNT * SGuildMarkBlock::MARK_PER_BLOCK_WIDTH, // 32
+
+			MARK_TOTAL_COUNT = MARK_ROW_COUNT * MARK_COL_COUNT, // 1280
+
+			INVALID_MARK_POSITION = 0xffffffff,
+		};
+
+		CGuildMarkImage();
+		virtual ~CGuildMarkImage();
+
+		void Create();
+		void Destroy();
+
+		bool Build(const char * c_szFileName);
+		bool Save(const char* c_szFileName);
+		bool Load(const char* c_szFileName);
+
+		void PutData(UINT x, UINT y, UINT width, UINT height, void* data);
+		void GetData(UINT x, UINT y, UINT width, UINT height, void* data);
+
+		bool SaveMark(DWORD posMark, BYTE * pbMarkImage);
+		bool DeleteMark(DWORD posMark);
+		bool SaveBlockFromCompressedData(DWORD posBlock, const BYTE * pbComp, DWORD dwCompSize); // <20><><EFBFBD><EFBFBD> -> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ
+
+		DWORD GetEmptyPosition(); // <20><> <20><>ũ <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD>´<EFBFBD>.
+
+		void GetBlockCRCList(DWORD * crcList);
+		void GetDiffBlocks(const DWORD * crcList, std::map<BYTE, const SGuildMarkBlock *> & mapDiffBlocks);
+
+	private:
+		enum
+		{
+			INVALID_HANDLE = 0xffffffff,
+		};
+
+		void	BuildAllBlocks();
+
+		SGuildMarkBlock	m_aakBlock[BLOCK_ROW_COUNT][BLOCK_COL_COUNT];
+		Pixel m_apxImage[WIDTH * HEIGHT * sizeof(Pixel)];
+
+		ILuint m_uImg;
+};
+
+#endif

src/UserInterface/MarkManager.cpp

@@ -0,0 +1,488 @@
+#include "stdafx.h"
+#include "MarkManager.h"
+
+#if _MSC_VER < 1200
+#include "crc32.h"
+#else
+#define sys_err TraceError
+#define sys_log // (n, format, ...) Tracenf(format, __VA_ARGS__)
+#define thecore_memcpy memcpy
+#define itertype(cont) typeof((cont).begin())
+#endif
+
+CGuildMarkImage * CGuildMarkManager::__NewImage()
+{
+	return new CGuildMarkImage;
+}
+
+void CGuildMarkManager::__DeleteImage(CGuildMarkImage * pkImgDel)
+{
+	delete pkImgDel;
+}
+
+CGuildMarkManager::CGuildMarkManager()
+{
+#if _MSC_VER >= 1200
+	mkdir("mark");
+#endif
+	// <20><><EFBFBD><EFBFBD> mark id <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
+	for (DWORD i = 0; i < MAX_IMAGE_COUNT * CGuildMarkImage::MARK_TOTAL_COUNT; ++i)
+		m_setFreeMarkID.insert(i);
+}
+
+CGuildMarkManager::~CGuildMarkManager()
+{
+	for (std::map<DWORD, CGuildMarkImage *>::iterator it = m_mapIdx_Image.begin(); it != m_mapIdx_Image.end(); ++it)
+		__DeleteImage(it->second);
+
+	m_mapIdx_Image.clear();
+}
+
+bool CGuildMarkManager::GetMarkImageFilename(DWORD imgIdx, std::string & path) const
+{
+	if (imgIdx >= MAX_IMAGE_COUNT)
+		return false;
+
+	char buf[64];
+	snprintf(buf, sizeof(buf), "mark/%s_%lu.tga", m_pathPrefix.c_str(), imgIdx);
+	path = buf;
+	return true;
+}
+
+void CGuildMarkManager::SetMarkPathPrefix(const char * prefix)
+{
+	m_pathPrefix = prefix;
+}
+
+// <20><>ũ <20>ε<EFBFBD><CEB5><EFBFBD> <20>ҷ<EFBFBD><D2B7><EFBFBD><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
+bool CGuildMarkManager::LoadMarkIndex()
+{
+	char buf[64];
+	snprintf(buf, sizeof(buf), "mark/%s_index", m_pathPrefix.c_str());
+	FILE * fp = fopen(buf, "r");
+
+	if (!fp)
+		return false;
+
+	DWORD guildID;
+	DWORD markID;
+
+	char line[256];
+
+	while (fgets(line, sizeof(line)-1, fp))
+	{
+		sscanf(line, "%lu %lu", &guildID, &markID);
+		line[0] = '\0';
+		AddMarkIDByGuildID(guildID, markID);
+	}
+
+	LoadMarkImages();
+
+	fclose(fp);
+	return true;
+}
+
+bool CGuildMarkManager::SaveMarkIndex()
+{
+	char buf[64];
+	snprintf(buf, sizeof(buf), "mark/%s_index", m_pathPrefix.c_str());
+	FILE * fp = fopen(buf, "w");
+
+	if (!fp)
+	{
+		sys_err("MarkManager::SaveMarkData: cannot open index file.");
+		return false;
+	}
+
+	for (std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.begin(); it != m_mapGID_MarkID.end(); ++it)
+		fprintf(fp, "%d %d\n", it->first, it->second);
+
+	fclose(fp);
+	sys_log(0, "MarkManager::SaveMarkData: index count %d", m_mapGID_MarkID.size());
+	return true;
+}
+
+void CGuildMarkManager::LoadMarkImages()
+{
+	bool isMarkExists[MAX_IMAGE_COUNT];
+	memset(isMarkExists, 0, sizeof(isMarkExists));
+
+	for (std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.begin(); it != m_mapGID_MarkID.end(); ++it)
+	{
+		DWORD markID = it->second;
+
+		if (markID < MAX_IMAGE_COUNT * CGuildMarkImage::MARK_TOTAL_COUNT)
+			isMarkExists[markID / CGuildMarkImage::MARK_TOTAL_COUNT] = true;
+	}
+
+	for (DWORD i = 0; i < MAX_IMAGE_COUNT; ++i)
+		if (isMarkExists[i])
+			__GetImage(i);
+}
+
+void CGuildMarkManager::SaveMarkImage(DWORD imgIdx)
+{
+	std::string path;
+
+	if (GetMarkImageFilename(imgIdx, path))
+		if (!__GetImage(imgIdx)->Save(path.c_str()))
+			sys_err("%s Save failed\n", path.c_str());
+}
+
+CGuildMarkImage * CGuildMarkManager::__GetImage(DWORD imgIdx)
+{
+	std::map<DWORD, CGuildMarkImage *>::iterator it = m_mapIdx_Image.find(imgIdx);
+
+	if (it == m_mapIdx_Image.end())
+	{
+		std::string imagePath;
+
+		if (GetMarkImageFilename(imgIdx, imagePath))
+		{
+			CGuildMarkImage * pkImage = __NewImage();
+			m_mapIdx_Image.insert(std::map<DWORD, CGuildMarkImage *>::value_type(imgIdx, pkImage));
+			pkImage->Load(imagePath.c_str());
+			return pkImage;
+		}
+		else
+			return NULL;
+	}
+	else
+		return it->second;
+}
+
+bool CGuildMarkManager::AddMarkIDByGuildID(DWORD guildID, DWORD markID)
+{
+	if (markID >= MAX_IMAGE_COUNT * CGuildMarkImage::MARK_TOTAL_COUNT)
+		return false;
+
+	//sys_log(0, "MarkManager: guild_id=%d mark_id=%d", guildID, markID);
+	m_mapGID_MarkID.insert(std::map<DWORD, DWORD>::value_type(guildID, markID));
+	m_setFreeMarkID.erase(markID);
+	return true;
+}
+
+DWORD CGuildMarkManager::GetMarkID(DWORD guildID)
+{
+	std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.find(guildID);
+
+	if (it == m_mapGID_MarkID.end())
+		return INVALID_MARK_ID;
+
+	return it->second;
+}
+
+DWORD CGuildMarkManager::__AllocMarkID(DWORD guildID)
+{
+	std::set<DWORD>::iterator it = m_setFreeMarkID.lower_bound(0);
+
+	if (it == m_setFreeMarkID.end())
+		return INVALID_MARK_ID;
+
+	DWORD markID = *it;
+	
+	DWORD imgIdx = markID / CGuildMarkImage::MARK_TOTAL_COUNT;
+	CGuildMarkImage * pkImage = __GetImage(imgIdx); // <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 
+
+	if (pkImage && AddMarkIDByGuildID(guildID, markID))
+		return markID;
+
+	return INVALID_MARK_ID;
+}
+
+DWORD CGuildMarkManager::GetMarkImageCount() const
+{
+	return m_mapIdx_Image.size();
+}
+
+DWORD CGuildMarkManager::GetMarkCount() const
+{
+	return m_mapGID_MarkID.size();
+}
+
+// SERVER
+void CGuildMarkManager::CopyMarkIdx(char * pcBuf) const
+{
+	WORD * pwBuf = (WORD *) pcBuf;
+
+	for (std::map<DWORD, DWORD>::const_iterator it = m_mapGID_MarkID.begin(); it != m_mapGID_MarkID.end(); ++it)
+	{
+		*(pwBuf++) = it->first; // guild id
+		*(pwBuf++) = it->second; // mark id
+	}
+}
+
+// SERVER
+DWORD CGuildMarkManager::SaveMark(DWORD guildID, BYTE * pbMarkImage)
+{
+	DWORD idMark;
+
+	if ((idMark = GetMarkID(guildID)) == INVALID_MARK_ID)
+	{
+		if ((idMark = __AllocMarkID(guildID)) == INVALID_MARK_ID)
+		{
+			sys_err("CGuildMarkManager: cannot alloc mark id %u", guildID);
+			return false;
+		}
+		else
+			sys_log(0, "SaveMark: mark id alloc %u", idMark);
+	}
+	else
+		sys_log(0, "SaveMark: mark id found %u", idMark);
+
+	DWORD imgIdx = (idMark / CGuildMarkImage::MARK_TOTAL_COUNT);
+	CGuildMarkImage * pkImage = __GetImage(imgIdx);
+
+	if (pkImage)
+	{
+		printf("imgidx %u ", imgIdx);
+
+		std::string pathImage;
+		GetMarkImageFilename(imgIdx, pathImage);
+		pkImage->Save(pathImage.c_str());
+
+		SaveMarkIndex();
+	}
+
+	return idMark;
+}
+
+// SERVER
+void CGuildMarkManager::DeleteMark(DWORD guildID)
+{
+	std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.find(guildID);
+
+	if (it == m_mapGID_MarkID.end())
+		return;
+
+	CGuildMarkImage * pkImage;
+
+	if ((pkImage = __GetImage(it->second / CGuildMarkImage::MARK_TOTAL_COUNT)) != NULL)
+		pkImage->DeleteMark(it->second % CGuildMarkImage::MARK_TOTAL_COUNT);
+
+	m_mapGID_MarkID.erase(it);
+	m_setFreeMarkID.insert(it->second);
+
+	SaveMarkIndex();
+}
+
+// SERVER
+void CGuildMarkManager::GetDiffBlocks(DWORD imgIdx, const DWORD * crcList, std::map<BYTE, const SGuildMarkBlock *> & mapDiffBlocks)
+{
+	mapDiffBlocks.clear();
+
+	// Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20><>û<EFBFBD><C3BB> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+	if (m_mapIdx_Image.end() == m_mapIdx_Image.find(imgIdx))
+	{
+		sys_err("invalid idx %u", imgIdx);
+		return;
+	}
+
+	CGuildMarkImage * p = __GetImage(imgIdx);
+
+	if (p)
+		p->GetDiffBlocks(crcList, mapDiffBlocks);
+}
+
+// CLIENT
+bool CGuildMarkManager::SaveBlockFromCompressedData(DWORD imgIdx, DWORD posBlock, const BYTE * pbBlock, DWORD dwSize)
+{
+	CGuildMarkImage * pkImage = __GetImage(imgIdx);
+
+	if (pkImage)
+		pkImage->SaveBlockFromCompressedData(posBlock, pbBlock, dwSize);
+
+	return false;
+}
+
+// CLIENT
+bool CGuildMarkManager::GetBlockCRCList(DWORD imgIdx, DWORD * crcList)
+{
+	// Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20><>û<EFBFBD><C3BB> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+	if (m_mapIdx_Image.end() == m_mapIdx_Image.find(imgIdx))
+	{
+		sys_err("invalid idx %u", imgIdx);
+		return false;
+	}
+
+	CGuildMarkImage * p = __GetImage(imgIdx);
+	
+	if (p)
+		p->GetBlockCRCList(crcList);
+
+	return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// Symbol
+///////////////////////////////////////////////////////////////////////////////////////
+const CGuildMarkManager::TGuildSymbol * CGuildMarkManager::GetGuildSymbol(DWORD guildID)
+{
+	std::map<DWORD, TGuildSymbol>::iterator it = m_mapSymbol.find(guildID);
+
+	if (it == m_mapSymbol.end())
+		return NULL;
+
+	return &it->second;
+}
+
+bool CGuildMarkManager::LoadSymbol(const char* filename)
+{
+	FILE* fp = fopen(filename, "rb");
+
+	if (!fp)
+		return true;
+	else
+	{
+		DWORD symbolCount;
+		fread(&symbolCount, 4, 1, fp);
+
+		for(DWORD i = 0; i < symbolCount; i++)
+		{
+			DWORD guildID;
+			DWORD dwSize;
+			fread(&guildID, 4, 1, fp);
+			fread(&dwSize, 4, 1, fp);
+
+			TGuildSymbol gs;
+			gs.raw.resize(dwSize);
+			fread(&gs.raw[0], 1, dwSize, fp);
+			gs.crc = GetCRC32(reinterpret_cast<const char*>(&gs.raw[0]), dwSize);
+			m_mapSymbol.insert(std::make_pair(guildID, gs));
+		}
+	}
+
+	fclose(fp);
+	return true;
+}
+
+void CGuildMarkManager::SaveSymbol(const char* filename)
+{
+	FILE* fp = fopen(filename, "wb");
+	if (!fp)
+	{
+		sys_err("Cannot open Symbol file (name: %s)", filename);
+		return;
+	}
+
+	DWORD symbolCount = m_mapSymbol.size();
+	fwrite(&symbolCount, 4, 1, fp);
+
+	for (std::map<DWORD, TGuildSymbol>::iterator it = m_mapSymbol.begin(); it != m_mapSymbol.end(); ++it)
+	{
+		DWORD guildID = it->first;
+		DWORD dwSize = it->second.raw.size();
+		fwrite(&guildID, 4, 1, fp);
+		fwrite(&dwSize, 4, 1, fp);
+		fwrite(&it->second.raw[0], 1, dwSize, fp);
+	}
+
+	fclose(fp);
+}
+
+void CGuildMarkManager::UploadSymbol(DWORD guildID, int iSize, const BYTE* pbyData)
+{
+	sys_log(0, "GuildSymbolUpload guildID %lu Size %d", guildID, iSize);
+	
+	if (m_mapSymbol.find(guildID) == m_mapSymbol.end())
+		m_mapSymbol.insert(std::make_pair(guildID, TGuildSymbol()));
+
+	TGuildSymbol& rSymbol = m_mapSymbol[guildID];
+	rSymbol.raw.clear();
+
+	if (iSize > 0)
+	{
+		rSymbol.raw.reserve(iSize);
+		std::copy(pbyData, (pbyData + iSize), std::back_inserter(rSymbol.raw));
+		rSymbol.crc = GetCRC32(reinterpret_cast<const char*>(pbyData), iSize);
+	}
+}
+
+#ifdef __UNITTEST__
+#include "lzo_manager.h"
+
+Guild::CGuildMarkManager * mgr;
+
+void heartbeat(LPHEART ht, int pulse)
+{
+	return;
+}
+
+void SaveMark(DWORD guildID, const char * filename)
+{
+	ILuint m_uImg;
+
+	ilGenImages(1, &m_uImg);
+	ilBindImage(m_uImg);
+	ilEnable(IL_ORIGIN_SET);
+	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
+
+	if (ilLoad(IL_TYPE_UNKNOWN, (const ILstring) filename))
+	{
+		ILuint width = ilGetInteger(IL_IMAGE_WIDTH);
+		ILuint height = ilGetInteger(IL_IMAGE_HEIGHT);
+
+		ilConvertImage(IL_BGRA, IL_UNSIGNED_BYTE);
+
+		BYTE * data = (BYTE *) malloc(sizeof(DWORD) * width * height);
+		ilCopyPixels(0, 0, 0, width, height, 1, IL_BGRA, IL_UNSIGNED_BYTE, data);
+		ilDeleteImages(1, &m_uImg);
+
+		printf("%s w%u h%u ", filename, width, height);
+		mgr->SaveMark(guildID, data);
+	}
+	else
+		printf("%s cannot open file.\n", filename);
+}
+
+int main(int argc, char **argv)
+{
+	LZOManager lzo;
+	char f[64];
+
+	srandom(time(0));
+
+	ilInit(); // DevIL Initialize
+	thecore_init(25, heartbeat);
+
+	std::vector<int> vec_guild_id;
+
+	for (int i = 1; i < 1281; ++i)
+		vec_guild_id.push_back(i);
+
+	mgr = new CGuildMarkManager;
+	mgr->LoadMarkData(vec_guild_id);
+	/*
+	for (int i = 1401; i < 1500; ++i)
+	{
+		snprintf(f, sizeof(f), "%lu.jpg", (random() % 5) + 1);
+		//SaveMark(i, f);
+		mgr->DeleteMark(i);
+	}
+	*/
+	//snprintf(f, sizeof(f), "%lu.jpg", (random() % 5) + 1);
+	//SaveMark(1, f);
+	DWORD idx_client[CGuildMarkImage::BLOCK_TOTAL_COUNT];
+	DWORD idx_server[CGuildMarkImage::BLOCK_TOTAL_COUNT];
+
+	mgr->GetBlockCRCList(0, idx_client);
+	mgr->GetBlockCRCList(1, idx_server);
+
+	std::map<BYTE, const SGuildMarkBlock *> mapDiff;
+	mgr->GetDiffBlocks(1, idx_client, mapDiff);
+
+	printf("#1 Diff %u\n", mapDiff.size());
+
+	for (itertype(mapDiff) it = mapDiff.begin(); it != mapDiff.end(); ++it)
+	{
+		printf("Put Block pos %u crc %u\n", it->first, it->second->m_crc);
+		mgr->SaveBlockFromCompressedData(0, it->first, it->second->m_abCompBuf, it->second->m_sizeCompBuf);
+	}
+
+	mgr->GetBlockCRCList(0, idx_client);
+	mgr->GetDiffBlocks(1, idx_client, mapDiff);
+	printf("#2 Diff %u\n", mapDiff.size());
+	delete mgr;
+	return 1;
+}
+#endif

src/UserInterface/MarkManager.h

@@ -0,0 +1,82 @@
+#ifndef __INC_METIN_II_GUILDLIB_MARK_MANAGER_H__
+#define __INC_METIN_II_GUILDLIB_MARK_MANAGER_H__
+
+#include "MarkImage.h"
+
+class CGuildMarkManager : public singleton<CGuildMarkManager>
+{
+	public:
+		enum
+		{
+			MAX_IMAGE_COUNT = 5,
+			INVALID_MARK_ID = 0xffffffff,
+		};
+
+		// Symbol
+		struct TGuildSymbol
+		{
+			DWORD crc;
+			std::vector<BYTE> raw;
+		};
+
+		CGuildMarkManager();
+		virtual ~CGuildMarkManager();
+
+		const TGuildSymbol * GetGuildSymbol(DWORD GID);
+		bool LoadSymbol(const char* filename);
+		void SaveSymbol(const char* filename);
+		void UploadSymbol(DWORD guildID, int iSize, const BYTE* pbyData);
+
+		//
+		// Mark
+		//
+		void SetMarkPathPrefix(const char * prefix);
+
+		bool LoadMarkIndex(); // <20><>ũ <20>ε<EFBFBD><CEB5><EFBFBD> <20>ҷ<EFBFBD><D2B7><EFBFBD><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
+		bool SaveMarkIndex(); // <20><>ũ <20>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD>
+
+		void LoadMarkImages(); // <20><><EFBFBD><EFBFBD> <20><>ũ <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> <20>ҷ<EFBFBD><D2B7><EFBFBD><EFBFBD><EFBFBD>
+		void SaveMarkImage(DWORD imgIdx); // <20><>ũ <20>̹<EFBFBD><CCB9><EFBFBD> <20><><EFBFBD><EFBFBD>
+
+		bool GetMarkImageFilename(DWORD imgIdx, std::string & path) const;
+		bool AddMarkIDByGuildID(DWORD guildID, DWORD markID);
+		DWORD GetMarkImageCount() const;
+		DWORD GetMarkCount() const;
+		DWORD GetMarkID(DWORD guildID);
+
+		// SERVER
+		void CopyMarkIdx(char * pcBuf) const;
+		DWORD SaveMark(DWORD guildID, BYTE * pbMarkImage);
+		void DeleteMark(DWORD guildID);
+		void GetDiffBlocks(DWORD imgIdx, const DWORD * crcList, std::map<BYTE, const SGuildMarkBlock *> & mapDiffBlocks);
+
+		// CLIENT
+		bool SaveBlockFromCompressedData(DWORD imgIdx, DWORD idBlock, const BYTE * pbBlock, DWORD dwSize);
+		bool GetBlockCRCList(DWORD imgIdx, DWORD * crcList);
+
+	private:
+		// 
+		// Mark
+		//
+		CGuildMarkImage * __NewImage();
+		void __DeleteImage(CGuildMarkImage * pkImgDel);
+
+		DWORD __AllocMarkID(DWORD guildID);
+
+		CGuildMarkImage * __GetImage(DWORD imgIdx);
+		CGuildMarkImage * __GetImagePtr(DWORD idMark);
+
+		std::map<DWORD, CGuildMarkImage *> m_mapIdx_Image; // index = image index
+		std::map<DWORD, DWORD> m_mapGID_MarkID; // index = guild id
+
+		std::set<DWORD> m_setFreeMarkID;
+		std::string		m_pathPrefix;
+
+	private:
+		//
+		// Symbol
+		//
+		std::map<DWORD, TGuildSymbol> m_mapSymbol;
+};
+
+#endif

src/UserInterface/MovieMan.cpp

@@ -0,0 +1,686 @@
+#include "stdafx.h"
+#include "MovieMan.h"
+#include "PythonApplication.h"
+
+// 2007-08-19, nuclei
+// add following files to the [Project Settings-Linker-Input]
+// DEBUG:	../dshow/strmbasd.lib ../dshow/dmoguids.lib ddraw.lib
+// RELEASE:	../dshow/strmbase.lib ../dshow/dmoguids.lib ddraw.lib
+
+// 2007-08-09, nuclei
+// if one of following header files are missing, 
+// please install "Microsoft Platform SDK for Windows Server 2003 R2" or later
+#include "ddraw.h"
+#include "mmstream.h"
+#include "amstream.h"
+#include "ddstream.h"
+#include "uuids.h"
+#include "control.h"
+#include "dmodshow.h"
+#include "dmoreg.h"
+
+#define LOGO_PMANG_FILE			"ymir.mpg"
+#define LOGO_NW_FILE			"logoNW.mpg"
+#define LOGO_EA_FILE			"logoEA.mpg"
+#define LOGO_EA_ENGLISH_FILE	"logoEA_english.mpg"
+#define LOGO_GAMEON				"gameonbi.mpg"	//for japan
+#define LOGO_IAH_FILE			"logoIAH.mpg"
+#define INTRO_FILE				"intro.mpg"
+#define LEGAL_FILE_00			"legal00.mpg"
+#define LEGAL_FILE_01			"legal01.mpg"
+#define TUTORIAL_0				"TutorialMovie\\Tutorial0.mpg"
+#define TUTORIAL_1				"TutorialMovie\\Tutorial1.mpg"
+#define TUTORIAL_2				"TutorialMovie\\Tutorial2.mpg"
+
+void CMovieMan::ClearToBlack()
+{
+	PAINTSTRUCT ps;
+	HDC dc;
+
+	//
+	// Get the repaint DC and then fill the window with black.
+	//
+	HWND window =  CPythonApplication::Instance().GetWindowHandle();//CFFClientApp::GetInstance()->GetMainWindow();
+	InvalidateRect( window, NULL, FALSE );
+	dc = BeginPaint( window, &ps );
+
+	PatBlt( dc, ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom, BLACKNESS);
+
+	EndPaint( window, &ps );
+}
+
+void CMovieMan::FillRect( RECT& fillRect, DWORD fillColor )
+{
+	assert(m_pPrimarySurface);
+
+	if (fillRect.bottom == fillRect.top || fillRect.left == fillRect.right)
+	{
+		// ä<><C3A4> <20>ʿ<EFBFBD> <20><><EFBFBD><EFBFBD>
+		return;
+	}
+
+	DDBLTFX colorFillBltFX;
+	colorFillBltFX.dwSize = sizeof(DDBLTFX);
+	colorFillBltFX.dwFillColor = fillColor;
+	if (!m_usingRGB32 || FAILED(m_pPrimarySurface->Blt(&fillRect, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &colorFillBltFX)))
+	{
+		GDIFillRect(fillRect, fillColor);
+		return;
+	}
+}
+
+inline void CMovieMan::GDIFillRect( RECT& fillRect, DWORD fillColor )
+{
+	HBRUSH fillBrush = CreateSolidBrush(
+		RGB((fillColor >> 16) & 255, (fillColor >> 8) & 255, fillColor & 255)
+		);
+
+	HDC desktopDC = GetDC(0);
+	::FillRect(desktopDC, &fillRect, fillBrush);
+	ReleaseDC(0, desktopDC);
+
+	DeleteObject(fillBrush);
+}
+
+//----------------------------------------------------------------------------------------------------
+// Ư<><C6AF> <20><><EFBFBD>ǽ<EFBFBD><C7BD><EFBFBD> GDI<44><49> <20><><EFBFBD><EFBFBD>ȭ<EFBFBD>鿡 <20>Ѹ<EFBFBD><D1B8><EFBFBD>
+//
+inline void CMovieMan::GDIBlt(IDirectDrawSurface *pSrcSurface, RECT *pDestRect)
+{
+	HDC surfaceDC;
+	HDC desktopDC = GetDC(0);
+	if (SUCCEEDED(pSrcSurface->GetDC(&surfaceDC)))
+	{
+		StretchBlt(desktopDC, pDestRect->left, pDestRect->top, pDestRect->right - pDestRect->left, pDestRect->bottom - pDestRect->top,
+			surfaceDC, 0, 0, m_movieWidth, m_movieHeight, SRCCOPY);
+		pSrcSurface->ReleaseDC(surfaceDC);
+	}
+	ReleaseDC(0, desktopDC);
+}
+
+void CMovieMan::PlayLogo(const char *pcszName)
+{
+	PlayMovie(pcszName);
+}
+
+void CMovieMan::PlayIntro()
+{
+	// <20><>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ű<><C5B0><EFBFBD><EFBFBD> <20>Է<EFBFBD><D4B7>̳<EFBFBD> <20><><EFBFBD>콺 Ŭ<><C5AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ŵ <20><><EFBFBD><EFBFBD>
+	PlayMovie( INTRO_FILE, MOVIEMAN_SKIPPABLE_YES, MOVIEMAN_POSTEFFECT_FADEOUT, 0xFFFFFF );
+}
+
+BOOL CMovieMan::PlayTutorial(LONG nIdx)
+{
+	BOOL bRet = FALSE;
+	ClearToBlack();
+	switch( nIdx ) {
+		case 0: 
+			bRet = PlayMovie( TUTORIAL_0, MOVIEMAN_SKIPPABLE_YES, MOVIEMAN_POSTEFFECT_FADEOUT, 0xFFFFFF );
+			return bRet;
+		case 1: 
+			bRet = PlayMovie( TUTORIAL_1, MOVIEMAN_SKIPPABLE_YES, MOVIEMAN_POSTEFFECT_FADEOUT, 0xFFFFFF );
+			return bRet;
+		case 2: 
+			bRet = PlayMovie( TUTORIAL_2, MOVIEMAN_SKIPPABLE_YES, MOVIEMAN_POSTEFFECT_FADEOUT, 0xFFFFFF );
+			return bRet;
+	}
+	return bRet;
+}
+
+BOOL CMovieMan::PlayMovie( const char *cpFileName, const bool bSkipAllowed, const int nPostEffectID, const DWORD dwPostEffectData )
+{
+	HWND hWnd = CPythonApplication::Instance().GetWindowHandle();
+
+	IDirectDraw *pDD = NULL;
+	DirectDrawCreate(NULL, &pDD, NULL);
+	pDD->SetCooperativeLevel(hWnd, DDSCL_NORMAL);
+
+	DDSURFACEDESC ddsd;
+	ZeroMemory(&ddsd, sizeof(ddsd));
+	ddsd.dwSize = sizeof(ddsd);
+	ddsd.dwFlags = DDSD_CAPS;
+	ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+	if (FAILED(pDD->CreateSurface(&ddsd, &m_pPrimarySurface, NULL)))
+	{
+		pDD->Release();
+		return FALSE;
+	}
+
+	// 32<33><32>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20>˾ƺ<CBBE><C6BA><EFBFBD>
+	ZeroMemory(&ddsd, sizeof(ddsd));
+	ddsd.dwSize = sizeof(ddsd);
+	ddsd.dwFlags = DDSD_PIXELFORMAT;
+	m_pPrimarySurface->GetSurfaceDesc(&ddsd);
+	ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
+	m_usingRGB32 = (ddsd.ddpfPixelFormat.dwRGBBitCount == 32);
+
+	IDirectDrawClipper *pDDClipper = NULL;
+	HRESULT hr = pDD->CreateClipper(0, &pDDClipper, NULL);
+	if (SUCCEEDED(hr))
+	{
+		pDDClipper->SetHWnd(0, hWnd);
+		m_pPrimarySurface->SetClipper(pDDClipper);
+	}
+
+	IMultiMediaStream *pMMStream = NULL;
+	hr = RenderFileToMMStream(cpFileName, &pMMStream, pDD);
+	if (SUCCEEDED(hr))
+	{
+		IMediaStream *pPrimaryVidStream = NULL;
+		HRESULT hr = pMMStream->GetMediaStream(MSPID_PrimaryVideo, &pPrimaryVidStream);
+		if (SUCCEEDED(hr))
+		{
+			IDirectDrawMediaStream *pDDStream = NULL;
+			pPrimaryVidStream->QueryInterface(IID_IDirectDrawMediaStream, (void **) &pDDStream);
+			pPrimaryVidStream->Release();
+
+			ddsd.dwSize = sizeof(ddsd);
+			hr = pDDStream->GetFormat(&ddsd, NULL, NULL, NULL);
+			if (SUCCEEDED(hr))
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<>⸦ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+				m_movieWidth = ddsd.dwWidth;
+				m_movieHeight = ddsd.dwHeight;
+
+				// <20><><EFBFBD><EFBFBD><EFBFBD>۴<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> RGB32<33><32> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> PrimarySurface<63><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD><D9B8><EFBFBD>
+				// GDI fallback <20>ؼ<EFBFBD> StretchBlt <20>Ѵ<EFBFBD>
+				DDSURFACEDESC ddsdBackSurface;
+				ZeroMemory(&ddsdBackSurface, sizeof(ddsdBackSurface));
+				ddsdBackSurface.ddpfPixelFormat.dwSize = sizeof(ddsdBackSurface.ddpfPixelFormat);
+				ddsdBackSurface.ddpfPixelFormat.dwFlags = DDPF_RGB;
+				ddsdBackSurface.ddpfPixelFormat.dwRGBBitCount = 32;
+				ddsdBackSurface.ddpfPixelFormat.dwRBitMask = 255 << 16;
+				ddsdBackSurface.ddpfPixelFormat.dwGBitMask = 255 << 8;
+				ddsdBackSurface.ddpfPixelFormat.dwBBitMask = 255;
+				ddsdBackSurface.dwSize = sizeof(ddsdBackSurface);
+				ddsdBackSurface.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
+				ddsdBackSurface.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
+				ddsdBackSurface.dwHeight = m_movieHeight;
+				ddsdBackSurface.dwWidth = m_movieWidth;
+
+				IDirectDrawSurface *pSurface;
+				hr = pDD->CreateSurface(&ddsdBackSurface, &pSurface, NULL);
+				if (SUCCEEDED(hr))
+				{ 
+					RenderStreamToSurface(pSurface, pDDStream, pMMStream, bSkipAllowed, nPostEffectID, dwPostEffectData);
+					pSurface->Release();
+				}
+			}
+			pDDStream->Release();
+		}
+		pMMStream->Release();
+	}
+
+	m_pPrimarySurface->Release();
+	m_pPrimarySurface = NULL;
+
+	if (m_pBasicAudio)
+	{
+		m_pBasicAudio->Release();
+		m_pBasicAudio = NULL;
+	}
+
+	if (pDDClipper)
+	{
+		pDDClipper->Release();
+		pDDClipper = NULL;
+	}
+
+	pDD->Release(); 
+
+	// Ű<><C5B0><EFBFBD><EFBFBD>, <20><><EFBFBD>콺 <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	MSG msg;
+	while (PeekMessage(&msg, hWnd, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
+	while (PeekMessage(&msg, hWnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE));
+
+	return SUCCEEDED(hr);
+}
+
+//----------------------------------------------------------------------------------------------------
+// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Screen <20><>ǥ<EFBFBD><C7A5> <20><>ȯ
+//
+void CMovieMan::GetWindowRect(RECT& windowRect)
+{
+	HWND hWnd = CPythonApplication::Instance().GetWindowHandle();
+	POINT p;
+
+	//
+	// Get the position of the upper-left client coordinate (in screen space).
+	//
+	p.x = 0;
+	p.y = 0;
+	ClientToScreen( hWnd, &p );
+
+	//
+	// Get the client rectangle of the window.
+	//
+	GetClientRect( hWnd, &windowRect );
+
+	// clientRect<63><74> ClientToScreen <20>ϴ<EFBFBD> <20>Ͱ<EFBFBD> <20><><EFBFBD><EFBFBD>
+	OffsetRect( &windowRect, p.x, p.y );
+}
+
+//----------------------------------------------------------------------------------------------------
+// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>쿡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ä<EFBFBD><C3A4><EFBFBD><EFBFBD> RECT <20><>ȯ(<28><><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
+//
+void CMovieMan::CalcMovieRect(int srcWidth, int srcHeight, RECT& movieRect)
+{
+	RECT windowRect;
+	GetWindowRect(windowRect);
+
+	int nMovieWidth, nMovieHeight;
+	if (srcWidth >= srcHeight)
+	{
+		nMovieWidth = (windowRect.right - windowRect.left);
+		nMovieHeight =  srcHeight * nMovieWidth / srcWidth;
+		if( nMovieHeight > windowRect.bottom - windowRect.top )
+			nMovieHeight = windowRect.bottom - windowRect.top;
+	}
+	else
+	{
+		nMovieHeight = (windowRect.bottom - windowRect.top);
+		nMovieWidth =  srcWidth * nMovieHeight / srcHeight;
+		if( nMovieWidth > windowRect.right - windowRect.left )
+			nMovieWidth = windowRect.right - windowRect.left;
+	}
+	movieRect.left = windowRect.left + ((windowRect.right - windowRect.left) - nMovieWidth) / 2;
+	movieRect.top = windowRect.top + ((windowRect.bottom - windowRect.top) - nMovieHeight) / 2;
+	movieRect.right = movieRect.left + nMovieWidth;
+	movieRect.bottom = movieRect.top + nMovieHeight;
+}
+
+//----------------------------------------------------------------------------------------------------
+// ȭ<><C8AD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>, <20>׻<EFBFBD> 2<><32><EFBFBD><EFBFBD> RECT<43><54> ǥ<><C7A5> <20><><EFBFBD><EFBFBD>
+//
+void CMovieMan::CalcBackgroundRect(const RECT& movieRect, RECT& upperRect, RECT& lowerRect)
+{
+	RECT windowRect;
+	GetWindowRect(windowRect);
+
+	if (m_movieWidth > m_movieHeight)
+	{
+		// <20><><EFBFBD>Ʒ<EFBFBD> <20>ΰ<EFBFBD>
+		SetRect(&upperRect, windowRect.left, windowRect.top, windowRect.right, movieRect.top);
+		SetRect(&lowerRect, windowRect.left, movieRect.bottom, windowRect.right, windowRect.bottom);
+	}
+	else
+	{
+		// <20>¿<EFBFBD> <20>ΰ<EFBFBD>
+		SetRect(&upperRect, windowRect.left, windowRect.top, movieRect.left, windowRect.bottom);
+		SetRect(&lowerRect, movieRect.right, windowRect.top, windowRect.right, windowRect.bottom);
+	}
+}
+
+//----------------------------------------------------------------------------------------------------
+// Ư<><C6AF> <20><><EFBFBD>ǽ<EFBFBD><C7BD><EFBFBD> Blocking<6E><67><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>׸<EFBFBD><D7B8><EFBFBD>
+//
+HRESULT CMovieMan::RenderStreamToSurface(IDirectDrawSurface *pSurface, IDirectDrawMediaStream *pDDStream, IMultiMediaStream *pMMStream, bool bSkipAllowed, int nPostEffectID, DWORD dwPostEffectData)
+{    
+	#define KEY_DOWN(vk)	(GetAsyncKeyState(vk) & 0x8000)
+
+	IDirectDrawStreamSample *pSample = NULL;
+	HRESULT hr = pDDStream->CreateSample(pSurface, NULL, 0, &pSample);
+	if (SUCCEEDED(hr))
+	{
+		// <20><><EFBFBD><EFBFBD> <20>ѹ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ĥ<><C4A5><EFBFBD>ش<EFBFBD>
+		RECT movieRect;
+		RECT upperRect, lowerRect;
+		CalcMovieRect(m_movieWidth, m_movieHeight, movieRect);
+		CalcBackgroundRect(movieRect, upperRect, lowerRect);
+		FillRect(upperRect, 0);
+		FillRect(lowerRect, 0);
+
+		pMMStream->SetState(STREAMSTATE_RUN);
+		while (pSample->Update(0, NULL, NULL, NULL) == S_OK)
+		{
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>߾<EFBFBD><DFBE><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>׸<EFBFBD><D7B8><EFBFBD>
+			CalcMovieRect(m_movieWidth, m_movieHeight, movieRect);
+			if (FAILED(m_pPrimarySurface->Blt(&movieRect, pSurface, NULL, DDBLT_WAIT, NULL)))
+			{
+				GDIBlt(pSurface, &movieRect);
+			}
+
+			// <20>߰<EFBFBD><DFB0><EFBFBD> <20><>ŵ <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD> Ű<><C5B0><EFBFBD><EFBFBD>ESC/<2F><><EFBFBD>콺 <20>Է½<D4B7> Ż<><C5BB>
+			if (bSkipAllowed && (KEY_DOWN(VK_LBUTTON) || KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE)))
+			{
+				break;
+			}
+		}
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ÿ<EFBFBD> 2<><32> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD><CCB5>ƿ<EFBFBD>
+		switch(nPostEffectID)
+		{
+		case MOVIEMAN_POSTEFFECT_FADEOUT:
+			RenderPostEffectFadeOut(pSurface, MOVIEMAN_FADE_DURATION, dwPostEffectData);
+			break;
+		}
+
+		pMMStream->SetState(STREAMSTATE_STOP);
+		pSample->Release();
+	}
+
+	return hr;
+}
+
+HRESULT CMovieMan::RenderFileToMMStream(const char *cpFilename, IMultiMediaStream **ppMMStream, IDirectDraw *pDD)
+{
+	IAMMultiMediaStream *pAMStream;
+	HRESULT hr = CoCreateInstance(CLSID_AMMultiMediaStream, NULL, CLSCTX_INPROC_SERVER, IID_IAMMultiMediaStream, (void **) &pAMStream);
+	if (FAILED(hr))
+	{
+		return hr;
+	}
+
+	WCHAR wPath[MAX_PATH + 1];
+	MultiByteToWideChar(CP_ACP, 0, cpFilename, -1, wPath, MAX_PATH + 1);
+	//
+	WCHAR wsDir[MAX_PATH + 1];
+	::memset(wsDir, 0, sizeof(wsDir));
+	::GetCurrentDirectoryW( MAX_PATH, wsDir );
+	::wcsncat( wsDir, L"\\", sizeof(WCHAR)*1 );
+	::wcsncat( wsDir, wPath, sizeof(WCHAR)*::wcsnlen(wPath, MAX_PATH) );
+	::memset(wPath, 0, sizeof(wPath));
+	::wcsncpy( wPath, wsDir, sizeof(WCHAR)*::wcsnlen(wsDir, MAX_PATH) );
+	//
+
+	pAMStream->Initialize(STREAMTYPE_READ, AMMSF_NOGRAPHTHREAD, NULL);
+	pAMStream->AddMediaStream(pDD, &MSPID_PrimaryVideo, 0, NULL);
+	pAMStream->AddMediaStream(NULL, &MSPID_PrimaryAudio, AMMSF_ADDDEFAULTRENDERER, NULL);
+
+	std::string ext;
+	GetFileExtension(cpFilename, strlen(cpFilename), &ext);
+	std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
+	if (ext == "mpg")
+	{
+		// 2007-08-01, nuclei
+		// MPG<50><47> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵٰ<D1B4> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20>Ŵ<EFBFBD><C5B4><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD><DAB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 
+		// <20>ܺ<EFBFBD> <20>ڵ<EFBFBD>(ffdshow <20><>)<29><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʵ<EFBFBD><CAB5><EFBFBD> <20>Ѵ<EFBFBD>
+		// (<28><>Ÿ <20><><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD><DAB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>)
+		hr = BuildFilterGraphManually(wPath, pAMStream, CLSID_MPEG1Splitter, CLSID_CMpegVideoCodec, CLSID_CMpegAudioCodec);
+	}
+	else if (ext == "mp43")
+	{
+		// 2007-08-12, nuclei
+		// MPEG-4, MP3 <20>ڵ<EFBFBD><DAB5><EFBFBD> <20>̿<EFBFBD><CCBF><EFBFBD> AVI<56><49> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD>(Ȯ<><C8AE><EFBFBD>ڴ<EFBFBD> .mp43<34><33><EFBFBD><EFBFBD> <20>ؾ<EFBFBD><D8BE><EFBFBD>)
+		hr = BuildFilterGraphManually(wPath, pAMStream, CLSID_AviSplitter, CLSID_MP4VideoCodec, CLSID_MP3AudioCodec);
+	}
+	else
+	{
+		hr = pAMStream->OpenFile(wPath, 0);
+	}
+
+	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> hr<68><72> S_OK
+	if (SUCCEEDED(hr))
+	{
+		pAMStream->QueryInterface(IID_IMultiMediaStream, (void**) ppMMStream);
+	}
+
+	pAMStream->Release();
+
+	return hr;
+}
+
+//----------------------------------------------------------------------------------------------------
+// Ư<><C6AF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ȭ<><C8AD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ų<EFBFBD> <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD>
+//
+HRESULT CMovieMan::RenderPostEffectFadeOut(IDirectDrawSurface *pSurface, int fadeOutDuration, DWORD fadeOutColor)
+{
+	// Lock <20>ɱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʱ<EFBFBD>ȭ
+	DDSURFACEDESC lockedSurfaceDesc;
+
+	int *pCopiedSrcSurBuf = NULL;
+	LONG fadeBegin = GetTickCount();
+	float fadeProgress = 0.0;
+	while ((fadeProgress = ((float)((LONG)GetTickCount()) - fadeBegin) / fadeOutDuration) < 1.0)
+	{
+		ZeroMemory(&lockedSurfaceDesc, sizeof(lockedSurfaceDesc));
+		lockedSurfaceDesc.dwSize = sizeof(lockedSurfaceDesc);
+		HRESULT hr = pSurface->Lock(NULL, &lockedSurfaceDesc, DDLOCK_WAIT | DDLOCK_NOSYSLOCK | DDLOCK_READONLY, NULL);
+		if (FAILED(hr))
+		{
+			return hr;
+		}
+
+		// <20><><EFBFBD><EFBFBD> 1ȸ<31><C8B8> <20><><EFBFBD>ǽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD>纻<EFBFBD><E7BABB> FadeOut ó<><C3B3><EFBFBD>Ѵ<EFBFBD>
+		if (!pCopiedSrcSurBuf)
+		{
+			if (!(pCopiedSrcSurBuf = (int*)malloc((LONG)lockedSurfaceDesc.lPitch * m_movieHeight)))
+			{
+				pSurface->Unlock(lockedSurfaceDesc.lpSurface);
+				return E_OUTOFMEMORY;
+			}
+			CopyMemory(pCopiedSrcSurBuf, lockedSurfaceDesc.lpSurface, (LONG)lockedSurfaceDesc.lPitch * m_movieHeight);
+		}
+
+		// <20>ȼ<EFBFBD> <20>ö<EFBFBD><C3B6><EFBFBD>(32<33><32>Ʈ)
+		int *pSrcSurfaceBuf = pCopiedSrcSurBuf;
+		int *pDestSurfaceBuf = (int*)lockedSurfaceDesc.lpSurface;
+
+		int fadeOutColorRed = (int)(((fadeOutColor >> 16) & 255) * fadeProgress);
+		int fadeOutColorGreen = (int)(((fadeOutColor >> 8) & 255) * fadeProgress);
+		int fadeOutColorBlue = (int)((fadeOutColor & 255) * fadeProgress);
+		for(int y = 0; y < m_movieHeight; ++y)
+		{
+			for(int x = 0; x < m_movieWidth; ++x)
+			{
+				DWORD srcPixel = *pSrcSurfaceBuf;
+				*pDestSurfaceBuf = RGB(
+					(srcPixel & 255) * (1 - fadeProgress) + fadeOutColorBlue,
+					((srcPixel >> 8) & 255) * (1 - fadeProgress) + fadeOutColorGreen,
+					((srcPixel >> 16) & 255) * (1 - fadeProgress) + fadeOutColorRed);
+				pSrcSurfaceBuf++;
+				pDestSurfaceBuf++;
+			}
+			pSrcSurfaceBuf += (lockedSurfaceDesc.lPitch / 4) - m_movieWidth;
+			pDestSurfaceBuf += (lockedSurfaceDesc.lPitch / 4) - m_movieWidth;
+		}
+		pSurface->Unlock(lockedSurfaceDesc.lpSurface);
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٲ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD> <20>׸<EFBFBD><D7B8><EFBFBD>
+		RECT movieRect;
+		CalcMovieRect(m_movieWidth, m_movieHeight, movieRect);
+		if (FAILED(m_pPrimarySurface->Blt(&movieRect, pSurface, NULL, DDBLT_WAIT, NULL)))
+		{
+			GDIBlt(pSurface, &movieRect);
+		}
+
+		// <20><> <20>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ĭ <20><>ä<EFBFBD><C3A4><EFBFBD><EFBFBD>
+		RECT upperRect, lowerRect;
+		CalcBackgroundRect(movieRect, upperRect, lowerRect);
+		FillRect(upperRect, (fadeOutColorRed << 16) | (fadeOutColorGreen << 8) | fadeOutColorBlue);
+		FillRect(lowerRect, (fadeOutColorRed << 16) | (fadeOutColorGreen << 8) | fadeOutColorBlue);
+		
+		// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+		if (m_pBasicAudio)
+		{
+			m_pBasicAudio->put_Volume((long)(-10000 * fadeProgress));
+		}
+	}
+
+	// <20>޸<EFBFBD><DEB8><EFBFBD> <20><><EFBFBD><EFBFBD>
+	free(pCopiedSrcSurBuf);
+
+	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1.0<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> FadeOut<75><74> ȭ<><C8AD> <20>׸<EFBFBD><D7B8><EFBFBD>
+	RECT windowRect;
+	GetWindowRect(windowRect);
+	FillRect(windowRect, fadeOutColor);
+
+	return S_OK;
+}
+
+//----------------------------------------------------------------------------------------------------
+// MPEG-1 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ܺ<EFBFBD> <20>ڵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20>Լ<EFBFBD>
+//
+HRESULT CMovieMan::BuildFilterGraphManually(
+	WCHAR* wpFilename, 
+	IAMMultiMediaStream *pAMStream, 
+	const GUID FAR clsidSplitter, 
+	const GUID FAR clsidVideoCodec,
+	const GUID FAR clsidAudioCodec)
+{
+	IGraphBuilder* pGraphBuilder = NULL;
+	pAMStream->GetFilterGraph(&pGraphBuilder);
+
+	assert(pGraphBuilder);
+
+//#ifdef _DEBUG
+//	DWORD dwRegister;
+//	AddToRot(pGraphBuilder, &dwRegister);
+//#endif
+
+	IBaseFilter *pSourceFilter = NULL;
+	IBaseFilter *pSplitterFilter = NULL;
+	IBaseFilter *pVideoFilter = NULL;
+	IBaseFilter *pAudioFilter = NULL;
+
+	CoCreateInstance(clsidSplitter, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void **) &pSplitterFilter);
+	CoCreateInstance(clsidVideoCodec, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void **) &pVideoFilter);
+	CoCreateInstance(clsidAudioCodec, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void **) &pAudioFilter);
+
+	// <20><><EFBFBD><EFBFBD> MP43 <20><><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD> <20><><EFBFBD>ٸ<EFBFBD> DMO <20>ڵ<EFBFBD><DAB5><EFBFBD> <20><><EFBFBD><EFBFBD> <20>־<EFBFBD><D6BE>ش<EFBFBD>
+	// MONSTER<45><52><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>߰ߵ<DFB0> <20><><EFBFBD>̽<EFBFBD>(<28>ڵ<EFBFBD><DAB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
+	if (!pVideoFilter && IsEqualGUID(clsidVideoCodec, CLSID_MP4VideoCodec))
+	{
+		// Create the DMO Wrapper filter.
+		HRESULT hr = CoCreateInstance(CLSID_DMOWrapperFilter, NULL, CLSCTX_INPROC, IID_IBaseFilter, (void **)&pVideoFilter);
+		if (SUCCEEDED(hr)) 
+		{
+			IDMOWrapperFilter *pWrap;
+			hr = pVideoFilter->QueryInterface(IID_IDMOWrapperFilter, (void **)&pWrap);
+			if (SUCCEEDED(hr))
+			{
+				hr = pWrap->Init(CLSID_MP43DMOCodec, DMOCATEGORY_VIDEO_DECODER);
+				pWrap->Release();
+			}
+		}
+	}
+
+	pGraphBuilder->AddSourceFilter(wpFilename, L"Source Filter", &pSourceFilter);
+	pGraphBuilder->AddFilter(pSplitterFilter, L"Splitter");
+	pGraphBuilder->AddFilter(pVideoFilter, L"Video Decoder");
+	pGraphBuilder->AddFilter(pAudioFilter, L"Audio Decoder");
+
+	assert(m_pBasicAudio == NULL);
+	pGraphBuilder->QueryInterface(IID_IBasicAudio, (void**) &m_pBasicAudio);
+
+	// Connect "Source" -> "Splitter"
+	IPin *pInPin = NULL;
+	IPin *pOutPin = NULL;
+	IPin *pSplitterVideoOutPin = NULL;
+	IPin *pSplitterAudioOutPin = NULL;
+	IEnumPins *pEnumPins = NULL;
+	pSourceFilter->EnumPins(&pEnumPins);
+	pEnumPins->Next(1, &pOutPin, NULL);
+	pEnumPins->Release();
+	pSplitterFilter->EnumPins(&pEnumPins);
+	pEnumPins->Next(1, &pInPin, NULL);
+	pEnumPins->Release();
+	HRESULT hr = pGraphBuilder->Connect(pOutPin, pInPin);
+	pInPin->Release();
+	pOutPin->Release();
+	if (SUCCEEDED(hr))
+	{
+		// <20><><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD> Output <20>ɵ<EFBFBD><C9B5><EFBFBD> <20><>Ÿ<EFBFBD><C5B8><EFBFBD><EFBFBD>
+		pSplitterFilter->EnumPins(&pEnumPins);
+		PIN_INFO pinInfo;
+		while( SUCCEEDED(pEnumPins->Next(1, &pInPin, NULL)) )
+		{
+			pInPin->QueryPinInfo(&pinInfo);
+			pinInfo.pFilter->Release();
+			if (pinInfo.dir == PINDIR_OUTPUT)
+			{
+				// Pin<69><6E> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+				pSplitterVideoOutPin = pInPin;
+				pEnumPins->Next(1, &pSplitterAudioOutPin, NULL);
+				break;
+			}
+			pInPin->Release();
+		}
+		pEnumPins->Release();
+
+		// Splitter -> Video/Audio codecs
+		pVideoFilter->EnumPins(&pEnumPins);
+		pEnumPins->Next(1, &pInPin, NULL);
+		pEnumPins->Next(1, &pOutPin, NULL);
+		pEnumPins->Release();
+		hr = pGraphBuilder->Connect(pSplitterVideoOutPin, pInPin);
+		if (SUCCEEDED(hr))
+		{
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			hr = pGraphBuilder->Render(pOutPin);
+			pInPin->Release();
+			pOutPin->Release();
+
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD>
+			if (pSplitterAudioOutPin && pAudioFilter)
+			{
+				pAudioFilter->EnumPins(&pEnumPins);
+				pEnumPins->Next(1, &pInPin, NULL);
+				pEnumPins->Next(1, &pOutPin, NULL);
+				pEnumPins->Release();
+				pGraphBuilder->Connect(pSplitterAudioOutPin, pInPin);
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD> <20>Ѿ <20><> <20><><EFBFBD><EFBFBD>
+				pGraphBuilder->Render(pOutPin);
+				pInPin->Release();
+				pOutPin->Release();
+			}
+		}
+	}
+
+	// <20><><EFBFBD><EFBFBD>
+//#ifdef _DEBUG
+//	RemoveFromRot(dwRegister);
+//#endif
+
+	if (pSplitterVideoOutPin)
+	{
+		pSplitterVideoOutPin->Release();
+	}
+	if (pSplitterAudioOutPin)
+	{
+		pSplitterAudioOutPin->Release();
+	}
+	pVideoFilter->Release();
+	if (pAudioFilter)
+	{
+		pAudioFilter->Release();
+	}
+	pSplitterFilter->Release();
+	pSourceFilter->Release();
+	pGraphBuilder->Release();
+	
+	return hr;
+}
+
+//#ifdef _DEBUG
+//HRESULT	CMovieMan::AddToRot(IGraphBuilder* pGraphBuilder, DWORD *pdwRegister)
+//{
+//	assert(pGraphBuilder);
+//
+//	IMoniker *pMoniker;
+//	IRunningObjectTable *pROT;
+//	if (FAILED(GetRunningObjectTable(0, &pROT))) {
+//		return E_FAIL;
+//	}
+//
+//	ZString monikerName;
+//	monikerName.Format(_T("FilterGraph %08x pid %08x"), (DWORD_PTR)pGraphBuilder, GetCurrentProcessId());
+//	HRESULT hr = CreateItemMoniker(L"!", monikerName, &pMoniker);
+//	if (SUCCEEDED(hr)) {
+//		hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pGraphBuilder,
+//			pMoniker, pdwRegister);
+//		pMoniker->Release();
+//	}
+//	pROT->Release();
+//	return hr;
+//}
+//
+//void CMovieMan::RemoveFromRot(DWORD pdwRegister)
+//{
+//	IRunningObjectTable *pROT;
+//	if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
+//		pROT->Revoke(pdwRegister);
+//		pROT->Release();
+//	}
+//}
+//#endif

src/UserInterface/MovieMan.h

@@ -0,0 +1,78 @@
+#pragma once
+
+// <20><><EFBFBD>̵<EFBFBD><CCB5>ƿ<EFBFBD> <20><><EFBFBD><EFBFBD>(<28><>)
+#define		MOVIEMAN_FADE_DURATION		1300
+#define		MOVIEMAN_SKIPPABLE_YES		true
+#define		MOVIEMAN_POSTEFFECT_FADEOUT	1
+
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> DX 7.0 <20><><EFBFBD><EFBFBD>
+struct IDirectDraw;
+struct IDirectDrawSurface;
+struct IDirectDrawMediaStream;
+struct IGraphBuilder;
+struct IBasicAudio;
+struct IMultiMediaStream;
+struct IAMMultiMediaStream;
+
+const GUID CLSID_MP43DMOCodec = { 0xcba9e78b, 0x49a3, 0x49ea, 0x93, 0xd4, 0x6b, 0xcb, 0xa8, 0xc4, 0xde, 0x07 };
+const GUID CLSID_MP4VideoCodec = { 0x82ccd3e0, 0xf71a, 0x11d0, 0x9f, 0xe5, 0x0, 0x60, 0x97, 0x78, 0xea, 0x66 };
+const GUID CLSID_MP3AudioCodec = { 0x38be3000, 0xdbf4, 0x11d0, 0x86, 0x0e, 0x0, 0xa0, 0x24, 0xcf, 0xef, 0x6d };	
+const GUID CLSID_DIrectSoundRenderer = { 0x79376820, 0x07D0, 0x11CF, 0xA2, 0x4D, 0x0, 0x20, 0xAF, 0xD7, 0x97, 0x67 };
+
+class CMovieMan : public CSingleton<CMovieMan>
+{
+public:
+	CMovieMan()
+		: m_movieWidth(0),
+		  m_movieHeight(0),
+		  m_usingRGB32(false),
+		  m_pPrimarySurface(NULL),
+		  m_pBasicAudio(NULL)
+	{
+		CoInitialize(NULL);
+	};
+
+	virtual ~CMovieMan()
+	{
+		CoUninitialize();
+	};
+
+	void				ClearToBlack();
+	void				PlayLogo(const char *pcszName);
+	void				PlayIntro();
+	BOOL                PlayTutorial(LONG nIdx);
+
+private:
+	bool				m_usingRGB32;
+	int  				m_movieWidth;
+	int  				m_movieHeight;
+	RECT				m_movieRect;
+	IDirectDrawSurface*	m_pPrimarySurface;
+	IBasicAudio*		m_pBasicAudio;
+
+	void				FillRect(RECT& fillRect, DWORD fillColor);
+	inline void			GDIFillRect(RECT& fillRect, DWORD fillColor);
+	inline void			GDIBlt(IDirectDrawSurface *pSrcSurface, RECT *pDestRect);
+
+	void				GetWindowRect(RECT& windowRect);
+	void				CalcMovieRect(int srcWidth, int srcHeight, RECT& movieRect);
+	void				CalcBackgroundRect(const RECT& movieRect, RECT& upperRect, RECT& lowerRect);
+
+	BOOL				PlayMovie(const char *cpFileName, const bool bSkipAllowed = FALSE, const int nPostEffectID = 0, const DWORD dwPostEffectData = 0);
+
+	HRESULT				BuildFilterGraphManually(
+							WCHAR* wpFilename, 
+							IAMMultiMediaStream *pAMStream, 
+							const GUID FAR clsidSplitter, 
+							const GUID FAR clsidVideoCodec,
+							const GUID FAR clsidAudioCodec);
+
+	HRESULT				RenderFileToMMStream(const char *cpFilename, IMultiMediaStream **ppMMStream, IDirectDraw *pDD);
+	HRESULT				RenderStreamToSurface(IDirectDrawSurface *pSurface, IDirectDrawMediaStream *pDDStream, IMultiMediaStream *pMMStream, bool bSkipAllowed, int nPostEffectID, DWORD dwPostEffectData);
+	HRESULT				RenderPostEffectFadeOut(IDirectDrawSurface *pSurface, int fadeOutDuration, DWORD fadeOutColor);
+
+//#ifdef _DEBUG
+//	HRESULT				AddToRot(IGraphBuilder* pGraphBuilder, DWORD *pdwRegister);
+//	void				RemoveFromRot(DWORD pdwRegister);
+//#endif
+};

src/UserInterface/NProtectGameGuard.cpp

@@ -0,0 +1,261 @@
+#include "StdAfx.h"
+#include "NProtectGameGuard.h"
+
+#ifdef USE_NPROTECT_GAMEGUARD
+
+static struct GameGuard
+{
+	bool	 isInitError;
+	bool	 isProcError;
+	unsigned msg;
+	unsigned arg;
+} gs_gameGuard = {
+	false, 0, 0,
+};
+
+#ifdef LOCALE_SERVICE_HONGKONG
+#include "NProtect/NPGameLibHK.h"
+#pragma comment(lib, "NPGameLibHK_MT.lib")
+CNPGameLib npgl("Metin2HK");
+#endif
+
+#ifdef LOCALE_SERVICE_TAIWAN
+#include "NProtect/NPGameLibTW.h"
+#pragma comment(lib, "NPGameLibTW_MT.lib")
+CNPGameLib npgl("Metin2TW");
+#endif
+
+#ifdef LOCALE_SERVICE_EUROPE
+#include "NProtect/NPGameLibEU.h"
+#pragma comment(lib, "NPGameLibEU_MT.lib")
+CNPGameLib npgl("Metin2EU");
+#endif
+
+BOOL CALLBACK NPGameMonCallback(DWORD msg, DWORD arg)
+{
+	switch (msg)
+    {
+	case NPGAMEMON_COMM_ERROR:
+	case NPGAMEMON_COMM_CLOSE:
+	case NPGAMEMON_INIT_ERROR:
+	case NPGAMEMON_SPEEDHACK:
+	case NPGAMEMON_GAMEHACK_KILLED:
+	case NPGAMEMON_GAMEHACK_DETECT:
+	case NPGAMEMON_GAMEHACK_DOUBT:		
+		gs_gameGuard.msg = msg;
+		gs_gameGuard.arg = arg;
+		gs_gameGuard.isProcError = true;
+		return false;		
+		break;
+	}	
+	return true;
+}
+
+bool LocaleService_IsGameGuardError()
+{
+	return gs_gameGuard.isProcError;
+}
+
+bool LocaleService_InitGameGuard()
+{
+	unsigned result = npgl.Init();
+	if (NPGAMEMON_SUCCESS != result)
+	{
+		gs_gameGuard.isInitError = true;
+		gs_gameGuard.msg = result;
+		return false;
+	}
+	return true;
+}
+
+bool LocaleService_RunGameGuard(HWND hWnd)
+{
+	npgl.SetHwnd(hWnd);
+	return true;
+}
+
+void LocaleService_NoticeGameGuardInitError_HongKong()
+{
+	char msg[256];
+	switch (gs_gameGuard.msg)
+	{
+		case NPGAMEMON_ERROR_EXIST:
+			sprintf(msg, "GameGuard<EFBFBD><EFBFBD>?<3F><><EFBFBD>C<EFBFBD>y<EFBFBD><79>??<3F>άO?<3F>s<EFBFBD>Ұʤ<D2B0><CAA4><EFBFBD><EFBFBD>A<EFBFBD><41>?<3F>C ");
+			break;
+		case NPGAMEMON_ERROR_GAME_EXIST:
+			sprintf(msg, "<EFBFBD>C<EFBFBD><EFBFBD>?<3F>ư<EFBFBD>?<3F><>GameGuard<72>w<EFBFBD>b<EFBFBD><62>?<3F><><EFBFBD>C<EFBFBD><43>?<3F>C<EFBFBD><43><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F>s<EFBFBD><73>?<3F>C ");
+			break;
+		case NPGAMEMON_ERROR_INIT:
+			sprintf(msg, "GameGuard<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƿ<EFBFBD>?<3F>C?<3F>s<EFBFBD>Ұʫ<D2B0><CAAB>A<EFBFBD><41>?<3F>άO<CEAC><4F><EFBFBD><EFBFBD><EFBFBD>i??<3F>o<EFBFBD>ͽĬ<CDBD><C4AC><EFBFBD>?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>A<EFBFBD><41>?<3F>C ");
+			break;
+		case NPGAMEMON_ERROR_AUTH_GAMEGUARD:
+		case NPGAMEMON_ERROR_NFOUND_GG:
+		case NPGAMEMON_ERROR_AUTH_INI:
+		case NPGAMEMON_ERROR_NFOUND_INI:
+			sprintf(msg, "<EFBFBD>LGameGuard<EFBFBD><EFBFBD>?<3F>β<EFBFBD><CEB2>Ͳ<EFBFBD><CDB2>ܡC<DCA1>Цw<D0A6><77>GameGuard <20><><EFBFBD>w<EFBFBD><77><EFBFBD>ɡC ");
+			break;
+		case NPGAMEMON_ERROR_CRYPTOAPI:
+			sprintf(msg, "Window<EFBFBD><EFBFBD><EFBFBD>Y<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>t<EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F><><EFBFBD>l<EFBFBD>C<EFBFBD><43>?<3F>s<EFBFBD>w<EFBFBD><77>IE<49>C ");
+			break;
+		case NPGAMEMON_ERROR_EXECUTE:
+			sprintf(msg, "GameGuard<EFBFBD><EFBFBD>?<3F><><EFBFBD>ѡC<D1A1><43>?<3F>s<EFBFBD><73>?GameGuard<72>w<EFBFBD><77><EFBFBD>ɡC ");
+			break;
+		case NPGAMEMON_ERROR_ILLEGAL_PRG:
+			sprintf(msg, "<EFBFBD>o?<3F>D<EFBFBD>k?<3F><><EFBFBD>C<EFBFBD>е<EFBFBD>?<3F><><EFBFBD>ݭn<DDAD><6E>?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F>s<EFBFBD><73>?<3F>C ");
+			break;
+		case NPGMUP_ERROR_ABORT:
+			sprintf(msg, "GameGuard<EFBFBD><EFBFBD>?<3F><>?<3F>C<EFBFBD>p<EFBFBD>G?<3F><><EFBFBD>L<EFBFBD>k<EFBFBD>s<EFBFBD>u<EFBFBD>A<EFBFBD><41>?<3F>վ<EFBFBD><D5BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F>H<EFBFBD><48><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F>w<EFBFBD>C ");
+			break;
+		case NPGMUP_ERROR_CONNECT:
+		case NPGMUP_ERROR_DOWNCFG:
+			sprintf(msg, "GameGuard<EFBFBD>睊(<28><>?)?<3F>A<EFBFBD>s<EFBFBD>u<EFBFBD><75><EFBFBD>ѡC<D1A1>y<EFBFBD><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>A?<3F>s<EFBFBD><73>?<3F>άO<CEAC>p<EFBFBD>G<EFBFBD><47>?<3F>H<EFBFBD><48><EFBFBD><EFBFBD><EFBFBD>𪺸ܽнվ<D0BD>?<3F>H<EFBFBD><48><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F>w<EFBFBD><77><EFBFBD><EFBFBD><EFBFBD>A<EFBFBD>աC ");
+			break;
+		case NPGMUP_ERROR_AUTH:
+			sprintf(msg, "GameGuard<EFBFBD>睊<EFBFBD>S?<3F><><EFBFBD><EFBFBD><EFBFBD>C<EFBFBD><43>?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F><><EFBFBD>r?<3F><><EFBFBD><EFBFBD><EFBFBD>A?<3F>s<EFBFBD><73>?<3F>άO<CEAC>ϥ<EFBFBD>PC<50>޲z?<3F><><EFBFBD>վ<EFBFBD>?<3F>w<EFBFBD><77><EFBFBD>A<EFBFBD><41>?<3F>C ");
+			break;
+		case NPGAMEMON_ERROR_NPSCAN:
+			sprintf(msg, "<EFBFBD>f<EFBFBD>r<EFBFBD>εn<EFBFBD>J<EFBFBD>b<EFBFBD>ȤJ<EFBFBD>I<EFBFBD>u<EFBFBD><EFBFBD><EFBFBD>ˬd<EFBFBD>Ҳե<EFBFBD><EFBFBD>ѡC<EFBFBD>i?<3F>O<EFBFBD>O<EFBFBD><4F><EFBFBD>餣<EFBFBD><E9A4A3><EFBFBD>άO<CEAC>P<EFBFBD>V<EFBFBD>F<EFBFBD>f<EFBFBD>r<EFBFBD>C ");
+			break;
+		default:
+			sprintf(msg, "GameGuard<EFBFBD><EFBFBD>??<3F>o?<3F><>?<3F>C<EFBFBD>бN<D0B1>C<EFBFBD><43><EFBFBD><EFBFBD>?<3F><><EFBFBD>̪<EFBFBD>GameGuard<72><64>?<3F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*.erl<72><6C>?<3F>H<EFBFBD>q<EFBFBD>l<EFBFBD>l<EFBFBD><6C>??<3F>H<EFBFBD><48>game2@inca.co.kr<6B>H<EFBFBD>c<EFBFBD>C ");
+			break;
+	}
+
+	MessageBox(NULL, msg, "GameGuard <20><>?", MB_OK);	
+}
+
+void LocaleService_NoticeGameGuardInitError_International()
+{
+	char msg[256];
+	switch (gs_gameGuard.msg)
+	{
+	case NPGAMEMON_ERROR_EXIST:
+		sprintf(msg, "GameGuard is already running.\nPlease reboot and restart the game.");
+		break;
+	case NPGAMEMON_ERROR_GAME_EXIST:
+		sprintf(msg, "GameGuard is already running.\nPlease restart the game.");
+		break;
+	case NPGAMEMON_ERROR_INIT:
+		sprintf(msg, "GameGuard has initial error.\nPlease kill other conflict programs and restart game.");
+		break;
+	case NPGAMEMON_ERROR_AUTH_GAMEGUARD:
+	case NPGAMEMON_ERROR_NFOUND_GG:
+	case NPGAMEMON_ERROR_AUTH_INI:
+	case NPGAMEMON_ERROR_NFOUND_INI:
+		sprintf(msg, "GameGuard files are modified or deleted.\nPlease reinstall GameGuard.");
+		break;
+	case NPGAMEMON_ERROR_CRYPTOAPI:
+		sprintf(msg, "GameGuard detects Windows system file error.\nPlease reinstall Internet Explorer(IE)");
+		break;
+	case NPGAMEMON_ERROR_EXECUTE:
+		sprintf(msg, "GameGuard running is failed.\nPlease reinstall GameGuard.");
+		break;
+	case NPGAMEMON_ERROR_ILLEGAL_PRG:
+		sprintf(msg, "GameGuard detects Illegal Program.\nPlease kill other programs not needs and restart game");
+		break;
+	case NPGMUP_ERROR_ABORT:
+		sprintf(msg, "GameGuard update was canceled.\nWhen not connect, change the internal or private firewall settings");
+		break;
+	case NPGMUP_ERROR_CONNECT:
+		sprintf(msg, "GameGuard hooking is failed.\nPlease download newer anti-virus and check all system.");
+		break;
+	case NPGAMEMON_ERROR_GAMEGUARD:
+		sprintf(msg, "GameGuard has initial error or old game guard.\nPlease reinstall GameGuard");
+		break;
+	case NPGMUP_ERROR_PARAM:
+		sprintf(msg, "GameGuard detects .ini file is modified.\nPlease reinstall GameGuard");		
+		break;
+	case NPGMUP_ERROR_INIT:
+		sprintf(msg, "GameGuard detects npgmup.des initial error.\nPlease delete GameGuard Folder and reinstall GameGuard");
+		break;
+	case NPGMUP_ERROR_DOWNCFG:
+		sprintf(msg, "GameGuard update server connection is failed.\nPlease restart or check private firewall settings.");
+		break;
+	case NPGMUP_ERROR_AUTH:
+		sprintf(msg, "GameGuard update is not completed.\nPlease pause anti-virus and restart game.");
+		break;
+	case NPGAMEMON_ERROR_NPSCAN:
+		sprintf(msg, "GameGuard virus-hacking checker loading is failed\nPlease check memory lack or virus.");
+		break;
+	default:
+		sprintf(msg, "UnknownErrorCode: %d\nPlease send a letter that has *.erl in game folder to Game1@inca.co.kr", gs_gameGuard.msg);
+		break;
+	}
+	
+	MessageBox(NULL, msg, "GameGuard Initiail Error", MB_OK);	
+}
+
+void LocaleService_NoticeGameGuardProcError_HongKong()
+{
+	char msg[256];
+	switch (gs_gameGuard.msg)
+	{
+		case NPGAMEMON_COMM_ERROR:
+		case NPGAMEMON_COMM_CLOSE:
+			return;
+		case NPGAMEMON_INIT_ERROR:
+			sprintf(msg, "GameGuard<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƿ<EFBFBD>? : %lu", gs_gameGuard.arg);
+			break;
+		case NPGAMEMON_SPEEDHACK:
+			sprintf(msg,  "<EFBFBD>o?speed hack<63>C ");
+			break;
+		case NPGAMEMON_GAMEHACK_KILLED:
+			sprintf(msg,  "<EFBFBD>o?<3F>C<EFBFBD><43>hack<63>C ");
+			break;
+		case NPGAMEMON_GAMEHACK_DETECT:
+			sprintf(msg,  "<EFBFBD>o?<3F>C<EFBFBD><43>hack<63>C ");
+			break;
+		case NPGAMEMON_GAMEHACK_DOUBT:
+			sprintf(msg,  "<EFBFBD>C<EFBFBD><EFBFBD><EFBFBD><EFBFBD>GameGuard<EFBFBD>w<EFBFBD><EFBFBD>?<3F>C ");
+			break;
+	}
+	MessageBox(NULL, msg, "GameGuard Error", MB_OK);
+}
+
+void LocaleService_NoticeGameGuardProcError_International()
+{
+	char msg[256];
+	switch (gs_gameGuard.msg)
+	{
+	case NPGAMEMON_COMM_ERROR:
+	case NPGAMEMON_COMM_CLOSE:
+		break;
+	case NPGAMEMON_INIT_ERROR:
+		wsprintf(msg, "GameGuard has initial error : %lu", gs_gameGuard.arg);			
+		break;
+	case NPGAMEMON_SPEEDHACK:
+		wsprintf(msg, "GameGuard detects SpeedHack");			
+		break;
+	case NPGAMEMON_GAMEHACK_KILLED:
+		wsprintf(msg, "GameGuard detects GameHack\r\n%s", npgl.GetInfo());			
+		break;
+	case NPGAMEMON_GAMEHACK_DETECT:
+		wsprintf(msg, "GameGuard detects GameHack\r\n%s", npgl.GetInfo());			
+		break;
+	case NPGAMEMON_GAMEHACK_DOUBT:
+		wsprintf(msg, "Game or Gamguard was modified.");			
+		break;
+	}
+	MessageBox(NULL, msg, "GameGuard Error", MB_OK);
+}
+
+void LocaleService_NoticeGameGuardMessasge()
+{
+	if (gs_gameGuard.isInitError)
+	{		
+		if (LocaleService_IsHONGKONG())
+			LocaleService_NoticeGameGuardInitError_HongKong();
+		else
+			LocaleService_NoticeGameGuardInitError_International();		
+	
+	}
+	else if (gs_gameGuard.isProcError)
+	{
+		if (LocaleService_IsHONGKONG())
+			LocaleService_NoticeGameGuardProcError_HongKong();
+		else
+			LocaleService_NoticeGameGuardProcError_International();		
+	}
+}
+
+#endif /* USE_NPROTECT_GAMEGUARD */

src/UserInterface/NProtectGameGuard.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifdef USE_NPROTECT_GAMEGUARD
+
+bool GameGuard_Init();
+bool GameGuard_IsError();
+bool GameGuard_Run(HWND hWnd);
+void GameGuard_NoticeMessage();
+
+#endif /* USE_NPROTECT_GAMEGUARD */

src/UserInterface/NetworkActorManager.cpp

@@ -0,0 +1,582 @@
+#include "StdAfx.h"
+#include "NetworkActorManager.h"
+#include "PythonCharacterManager.h"
+#include "PythonItem.h"
+
+#include "AbstractPlayer.h"
+
+void SNetworkActorData::UpdatePosition()
+{
+	DWORD dwClientCurTime=ELTimer_GetMSec();
+	DWORD dwElapsedTime=dwClientCurTime-m_dwClientSrcTime;
+
+	if (dwElapsedTime<m_dwDuration)
+	{
+		float fRate=float(dwElapsedTime)/float(m_dwDuration);
+		m_lCurX=LONG((m_lDstX-m_lSrcX)*fRate+m_lSrcX);
+		m_lCurY=LONG((m_lDstY-m_lSrcY)*fRate+m_lSrcY);
+	}
+	else
+	{
+		m_lCurX=m_lDstX;
+		m_lCurY=m_lDstY;
+	}
+}
+
+void SNetworkActorData::SetDstPosition(DWORD dwServerTime, LONG lDstX, LONG lDstY, DWORD dwDuration)
+{
+	m_lSrcX=m_lCurX;
+	m_lSrcY=m_lCurY;
+	m_lDstX=lDstX;
+	m_lDstY=lDstY;
+
+	m_dwDuration=dwDuration;
+	m_dwServerSrcTime=dwServerTime;
+	m_dwClientSrcTime=ELTimer_GetMSec();		
+}
+
+void SNetworkActorData::SetPosition(LONG lPosX, LONG lPosY)
+{
+	m_lDstX=m_lSrcX=m_lCurX=lPosX;
+	m_lDstY=m_lSrcY=m_lCurY=lPosY;
+}
+
+// NETWORK_ACTOR_DATA_COPY
+SNetworkActorData::SNetworkActorData(const SNetworkActorData& src)
+{
+	__copy__(src);
+}
+
+void SNetworkActorData::operator=(const SNetworkActorData& src)
+{
+	__copy__(src);
+}
+
+void SNetworkActorData::__copy__(const SNetworkActorData& src)
+{
+	m_bType = src.m_bType;
+	m_dwVID = src.m_dwVID;
+	m_dwStateFlags = src.m_dwStateFlags;
+	m_dwEmpireID = src.m_dwEmpireID;
+	m_dwRace = src.m_dwRace;
+	m_dwMovSpd = src.m_dwMovSpd;
+	m_dwAtkSpd = src.m_dwAtkSpd;
+	m_fRot = src.m_fRot;
+	m_lCurX = src.m_lCurX;
+	m_lCurY = src.m_lCurY;
+	m_lSrcX = src.m_lSrcX;
+	m_lSrcY = src.m_lSrcY;
+	m_lDstX = src.m_lDstX;
+	m_lDstY = src.m_lDstY;
+	m_kAffectFlags.CopyInstance(src.m_kAffectFlags);
+	
+	m_dwServerSrcTime = src.m_dwServerSrcTime;
+	m_dwClientSrcTime = src.m_dwClientSrcTime;
+	m_dwDuration = src.m_dwDuration;
+
+	m_dwArmor = src.m_dwArmor;
+	m_dwWeapon = src.m_dwWeapon;
+	m_dwHair = src.m_dwHair;
+
+	m_dwOwnerVID = src.m_dwOwnerVID;
+
+	m_sAlignment = src.m_sAlignment;
+	m_byPKMode = src.m_byPKMode;
+	m_dwMountVnum = src.m_dwMountVnum;
+
+	m_dwGuildID = src.m_dwGuildID;
+	m_dwLevel = src.m_dwLevel;
+	m_stName = src.m_stName;
+}
+// END_OF_NETWORK_ACTOR_DATA_COPY
+	
+SNetworkActorData::SNetworkActorData()
+{
+	SetPosition(0, 0);
+
+	m_bType=0;
+	m_dwVID=0;
+	m_dwStateFlags=0;
+	m_dwRace=0;
+	m_dwMovSpd=0;
+	m_dwAtkSpd=0;
+	m_fRot=0.0f;
+	m_dwArmor=0;
+	m_dwWeapon=0;	
+	m_dwHair=0;
+	m_dwEmpireID=0;
+
+	m_dwOwnerVID=0;
+
+	m_dwDuration=0;
+	m_dwClientSrcTime=0;
+	m_dwServerSrcTime=0;
+
+	m_sAlignment=0;
+	m_byPKMode=0;
+	m_dwMountVnum=0;
+
+	m_stName="";
+
+	m_kAffectFlags.Clear();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+CNetworkActorManager::CNetworkActorManager()
+{
+	m_dwMainVID=0;
+}
+
+CNetworkActorManager::~CNetworkActorManager()
+{
+}
+
+void CNetworkActorManager::Destroy()
+{
+	m_kNetActorDict.clear();
+
+	m_dwMainVID=0;
+	m_lMainPosX=0;
+	m_lMainPosY=0;
+}
+
+void CNetworkActorManager::SetMainActorVID(DWORD dwVID)
+{
+	m_dwMainVID=dwVID;
+	m_lMainPosX=0;
+	m_lMainPosY=0;
+
+	m_kNetActorDict.clear();
+}
+
+void CNetworkActorManager::Update()
+{
+	__OLD_Update();
+}
+
+void CNetworkActorManager::__OLD_Update()
+{
+	__UpdateMainActor();
+
+	CPythonCharacterManager& rkChrMgr=__GetCharacterManager();
+
+	std::map<DWORD, SNetworkActorData>::iterator i;
+	for (i=m_kNetActorDict.begin(); i!=m_kNetActorDict.end(); ++i)
+	{
+		SNetworkActorData& rkNetActorData=i->second;
+		rkNetActorData.UpdatePosition();
+
+		CInstanceBase * pkInstFind = rkChrMgr.GetInstancePtr(rkNetActorData.m_dwVID);
+		if (!pkInstFind)
+		{
+			if (__IsVisibleActor(rkNetActorData))
+				__AppendCharacterManagerActor(rkNetActorData);
+		}
+	}
+}
+
+CInstanceBase* CNetworkActorManager::__FindActor(SNetworkActorData& rkNetActorData, LONG lDstX, LONG lDstY)
+{
+	CPythonCharacterManager& rkChrMgr=__GetCharacterManager();
+	CInstanceBase * pkInstFind = rkChrMgr.GetInstancePtr(rkNetActorData.m_dwVID);
+	if (!pkInstFind)
+	{
+		if (__IsVisiblePos(lDstX, lDstY))
+			return __AppendCharacterManagerActor(rkNetActorData);
+
+		return NULL;
+	}
+
+	return pkInstFind;
+}
+
+CInstanceBase* CNetworkActorManager::__FindActor(SNetworkActorData& rkNetActorData)
+{
+	CPythonCharacterManager& rkChrMgr=__GetCharacterManager();
+	CInstanceBase * pkInstFind = rkChrMgr.GetInstancePtr(rkNetActorData.m_dwVID);
+	if (!pkInstFind)
+	{
+		if (__IsVisibleActor(rkNetActorData))
+			return __AppendCharacterManagerActor(rkNetActorData);
+
+		return NULL;
+	}
+
+	return pkInstFind;
+}
+
+void CNetworkActorManager::__RemoveAllGroundItems()
+{
+	CPythonItem& rkItemMgr=CPythonItem::Instance();
+	rkItemMgr.DeleteAllItems();
+}
+
+void CNetworkActorManager::__RemoveAllActors()
+{
+	m_kNetActorDict.clear();
+
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
+	rkChrMgr.DeleteAllInstances();
+}
+
+void CNetworkActorManager::__RemoveDynamicActors()
+{
+	//copy it
+	std::vector<DWORD> dwCharacterVIDList;
+
+	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+	for(CPythonCharacterManager::CharacterIterator i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd(); ++i)
+	{
+		dwCharacterVIDList.push_back( (*i)->GetVirtualID() );
+	}
+
+	for( int i = 0; i < dwCharacterVIDList.size(); ++i )
+	{
+		CInstanceBase*  pkInstEach = rkChrMgr.GetInstancePtr( dwCharacterVIDList[i] );
+		if( !pkInstEach )
+			continue;
+		
+		CActorInstance* rkActorEach=pkInstEach->GetGraphicThingInstancePtr();
+		if( rkActorEach->IsPC() || rkActorEach->IsNPC() || rkActorEach->IsEnemy() )
+		{
+			rkChrMgr.DeleteInstance(dwCharacterVIDList[i]);
+			std::map<DWORD, SNetworkActorData>::iterator it =m_kNetActorDict.find(dwCharacterVIDList[i]);
+			if (it != m_kNetActorDict.end())
+			{
+				m_kNetActorDict.erase(it);
+			}
+		}
+	}
+						
+	rkChrMgr.DestroyDeadInstanceList();
+}
+
+void CNetworkActorManager::__UpdateMainActor()
+{
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();	
+	CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
+	if (!pkInstMain)
+		return;
+
+	TPixelPosition kPPosMain;
+	pkInstMain->NEW_GetPixelPosition(&kPPosMain);
+
+	m_lMainPosX=LONG(kPPosMain.x);
+	m_lMainPosY=LONG(kPPosMain.y);
+}
+
+extern bool IsWall(unsigned race);
+
+bool CNetworkActorManager::__IsVisibleActor(const SNetworkActorData& c_rkNetActorData)
+{
+	if (__IsMainActorVID(c_rkNetActorData.m_dwVID))
+		return true;
+
+	// 2004.08.02.myevan.<2E>׻<EFBFBD> <20><><EFBFBD>̱<EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>
+	if (c_rkNetActorData.m_kAffectFlags.IsSet(CInstanceBase::AFFECT_SHOW_ALWAYS))
+		return true;
+
+	if (__IsVisiblePos(c_rkNetActorData.m_lCurX, c_rkNetActorData.m_lCurY))
+		return true;
+
+	if (IsWall(c_rkNetActorData.m_dwRace))
+		return true;
+
+ 	return false;
+}
+
+bool CNetworkActorManager::__IsVisiblePos(LONG lPosX, LONG lPosY)
+{
+ 	LONG dx = lPosX-m_lMainPosX;
+	LONG dy = lPosY-m_lMainPosY;
+	LONG len = (LONG)sqrt(double(dx * dx + dy * dy));
+
+	extern int CHAR_STAGE_VIEW_BOUND;
+	if (len < CHAR_STAGE_VIEW_BOUND) // <20>Ÿ<EFBFBD><C5B8><EFBFBD><EFBFBD><EFBFBD> cm
+		return true;
+
+	return false;
+}
+
+bool CNetworkActorManager::__IsMainActorVID(DWORD dwVID)
+{
+	if (dwVID == m_dwMainVID)
+		return true;
+
+	return false;
+}
+
+CPythonCharacterManager& CNetworkActorManager::__GetCharacterManager()
+{
+	return CPythonCharacterManager::Instance();
+}
+
+void CNetworkActorManager::__RemoveCharacterManagerActor(SNetworkActorData& rkNetActorData)
+{
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();	
+
+	if (__IsMainActorVID(rkNetActorData.m_dwVID))
+	{
+		rkChrMgr.DeleteInstance(rkNetActorData.m_dwVID);
+	}
+	else
+	{
+		rkChrMgr.DeleteInstanceByFade(rkNetActorData.m_dwVID);	
+	}	
+}
+
+CInstanceBase* CNetworkActorManager::__AppendCharacterManagerActor(SNetworkActorData& rkNetActorData)
+{
+	Lognf(0, "CNetworkActorManager::__AppendCharacterManagerActor(%d, %s)", rkNetActorData.m_dwVID, rkNetActorData.m_stName.c_str());
+
+	DWORD dwVID=rkNetActorData.m_dwVID;
+
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
+
+
+	CInstanceBase::SCreateData kCreateData;
+	kCreateData.m_bType=rkNetActorData.m_bType;
+	kCreateData.m_dwLevel=rkNetActorData.m_dwLevel;
+	kCreateData.m_dwGuildID=rkNetActorData.m_dwGuildID;
+	kCreateData.m_dwEmpireID=rkNetActorData.m_dwEmpireID;
+	kCreateData.m_dwVID=rkNetActorData.m_dwVID;
+	kCreateData.m_dwMountVnum=rkNetActorData.m_dwMountVnum;
+	kCreateData.m_dwRace=rkNetActorData.m_dwRace;
+	kCreateData.m_fRot=rkNetActorData.m_fRot;
+ 	kCreateData.m_lPosX=rkNetActorData.m_lCurX;
+	kCreateData.m_lPosY=rkNetActorData.m_lCurY;
+	kCreateData.m_stName=rkNetActorData.m_stName;
+	kCreateData.m_dwStateFlags=rkNetActorData.m_dwStateFlags;
+	kCreateData.m_dwMovSpd=rkNetActorData.m_dwMovSpd;
+	kCreateData.m_dwAtkSpd=rkNetActorData.m_dwAtkSpd;
+	kCreateData.m_sAlignment=rkNetActorData.m_sAlignment;
+	kCreateData.m_byPKMode=rkNetActorData.m_byPKMode;
+	kCreateData.m_kAffectFlags=rkNetActorData.m_kAffectFlags;
+	kCreateData.m_dwArmor=rkNetActorData.m_dwArmor;
+	kCreateData.m_dwWeapon=rkNetActorData.m_dwWeapon;
+	kCreateData.m_dwHair=rkNetActorData.m_dwHair;
+	kCreateData.m_isMain=__IsMainActorVID(dwVID);
+
+	CInstanceBase* pOldInstance = rkChrMgr.GetInstancePtr(dwVID);
+	if (pOldInstance)
+	{
+		TPixelPosition oldPos;
+		pOldInstance->GetGraphicThingInstancePtr()->GetPixelPosition( &oldPos );
+
+		bool bIsMountingHorse = pOldInstance->IsMountingHorse();
+		if( (bIsMountingHorse && kCreateData.m_dwMountVnum == 0) ||  
+			(!bIsMountingHorse && kCreateData.m_dwMountVnum != 0) )
+		{
+			//Override Pos
+			kCreateData.m_lPosX = oldPos.x;
+			kCreateData.m_lPosY = -oldPos.y;
+		}
+
+		rkChrMgr.DeleteInstance(dwVID);
+	}
+	
+
+	CInstanceBase* pNewInstance = rkChrMgr.CreateInstance(kCreateData);
+	if (!pNewInstance)
+		return NULL;
+
+	if (kCreateData.m_isMain)
+	{
+		IAbstractPlayer & rkPlayer = IAbstractPlayer::GetSingleton();
+		rkPlayer.SetMainCharacterIndex(dwVID);
+
+
+		m_lMainPosX=rkNetActorData.m_lCurX;
+		m_lMainPosY=rkNetActorData.m_lCurY;
+	}
+
+	DWORD dwClientCurTime=ELTimer_GetMSec();
+	DWORD dwElapsedTime=dwClientCurTime-rkNetActorData.m_dwClientSrcTime;
+
+	if (dwElapsedTime<rkNetActorData.m_dwDuration)
+	{
+		TPixelPosition kPPosDst;
+		kPPosDst.x=float(rkNetActorData.m_lDstX);
+		kPPosDst.y=float(rkNetActorData.m_lDstY);
+		kPPosDst.z=0;
+		pNewInstance->PushTCPState(rkNetActorData.m_dwServerSrcTime+dwElapsedTime, kPPosDst, rkNetActorData.m_fRot, CInstanceBase::FUNC_MOVE, 0);		
+	}
+	return pNewInstance;
+}
+
+void CNetworkActorManager::AppendActor(const SNetworkActorData& c_rkNetActorData)
+{
+	if (__IsMainActorVID(c_rkNetActorData.m_dwVID))
+	{
+		bool bChangeMountStatus = false;
+
+		CInstanceBase* pMainInstance = CPythonCharacterManager::Instance().GetInstancePtr(c_rkNetActorData.m_dwVID);
+		if( pMainInstance )
+		{
+			bool bIsMountingHorse = pMainInstance->IsMountingHorse();
+			bChangeMountStatus = (bIsMountingHorse && c_rkNetActorData.m_dwMountVnum == 0) || (!bIsMountingHorse && c_rkNetActorData.m_dwMountVnum != 0);
+		}
+
+		if( !bChangeMountStatus )
+		{
+			//__RemoveAllActors();
+			__RemoveDynamicActors();
+			__RemoveAllGroundItems();
+		}
+
+	}
+
+	SNetworkActorData& rkNetActorData=m_kNetActorDict[c_rkNetActorData.m_dwVID];
+	rkNetActorData=c_rkNetActorData;
+
+	if (__IsVisibleActor(rkNetActorData))
+	{
+		if (!__AppendCharacterManagerActor(rkNetActorData))
+			m_kNetActorDict.erase(c_rkNetActorData.m_dwVID);
+	}
+}
+
+void CNetworkActorManager::RemoveActor(DWORD dwVID)
+{
+	std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(dwVID);
+	if (m_kNetActorDict.end()==f)
+	{
+#ifdef _DEBUG		
+		TraceError("CNetworkActorManager::RemoveActor(dwVID=%d) - NOT EXIST VID", dwVID);
+#endif
+		return;
+	}
+
+	SNetworkActorData& rkNetActorData=f->second;
+	__RemoveCharacterManagerActor(rkNetActorData);
+
+	m_kNetActorDict.erase(f);
+}
+
+void CNetworkActorManager::UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData)
+{
+	std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(c_rkNetUpdateActorData.m_dwVID);
+	if (m_kNetActorDict.end()==f)
+	{
+#ifdef _DEBUG
+		TraceError("CNetworkActorManager::UpdateActor(dwVID=%d) - NOT EXIST VID", c_rkNetUpdateActorData.m_dwVID);
+#endif
+		return;
+	}
+
+	SNetworkActorData& rkNetActorData=f->second;
+
+	CInstanceBase* pkInstFind=__FindActor(rkNetActorData);
+	if (pkInstFind)
+	{
+		pkInstFind->ChangeArmor(c_rkNetUpdateActorData.m_dwArmor);		
+		pkInstFind->ChangeWeapon(c_rkNetUpdateActorData.m_dwWeapon);
+		pkInstFind->ChangeHair(c_rkNetUpdateActorData.m_dwHair);		
+		pkInstFind->ChangeGuild(c_rkNetUpdateActorData.m_dwGuildID);
+		pkInstFind->SetAffectFlagContainer(c_rkNetUpdateActorData.m_kAffectFlags);
+		pkInstFind->SetMoveSpeed(c_rkNetUpdateActorData.m_dwMovSpd);
+		pkInstFind->SetAttackSpeed(c_rkNetUpdateActorData.m_dwAtkSpd);
+		pkInstFind->SetAlignment(c_rkNetUpdateActorData.m_sAlignment);
+		pkInstFind->SetPKMode(c_rkNetUpdateActorData.m_byPKMode);
+		pkInstFind->SetStateFlags(c_rkNetUpdateActorData.m_dwStateFlags);
+
+		//if( c_rkNetUpdateActorData.m_dwMountVnum != 0 )
+		//{
+		//	pkInstFind->MountHorse(c_rkNetUpdateActorData.m_dwMountVnum);
+		//}
+		//else
+		//{
+		//	if( pkInstFind->IsMountingHorse() )
+		//	{
+		//		pkInstFind->DismountHorse();
+		//	}
+		//}
+	}
+
+	rkNetActorData.m_kAffectFlags=c_rkNetUpdateActorData.m_kAffectFlags;
+	rkNetActorData.m_dwGuildID=c_rkNetUpdateActorData.m_dwGuildID;
+	//rkNetActorData.m_dwLevel=c_rkNetUpdateActorData.m_dwLevel;
+	rkNetActorData.m_dwMovSpd=c_rkNetUpdateActorData.m_dwMovSpd;
+	rkNetActorData.m_dwAtkSpd=c_rkNetUpdateActorData.m_dwAtkSpd;
+	rkNetActorData.m_dwArmor=c_rkNetUpdateActorData.m_dwArmor;
+	rkNetActorData.m_dwWeapon=c_rkNetUpdateActorData.m_dwWeapon;
+	rkNetActorData.m_dwHair=c_rkNetUpdateActorData.m_dwHair;
+	rkNetActorData.m_sAlignment=c_rkNetUpdateActorData.m_sAlignment;
+	rkNetActorData.m_byPKMode=c_rkNetUpdateActorData.m_byPKMode;
+}
+
+void CNetworkActorManager::MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData)
+{
+	std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(c_rkNetMoveActorData.m_dwVID);
+	if (m_kNetActorDict.end()==f)
+	{
+#ifdef _DEBUG
+		TraceError("CNetworkActorManager::MoveActor(dwVID=%d) - NOT EXIST VID", c_rkNetMoveActorData.m_dwVID);
+#endif
+		return;
+	}
+
+	SNetworkActorData& rkNetActorData=f->second;
+
+	CInstanceBase* pkInstFind=__FindActor(rkNetActorData, c_rkNetMoveActorData.m_lPosX, c_rkNetMoveActorData.m_lPosY);
+	if (pkInstFind)
+	{
+		TPixelPosition kPPosDst;
+		kPPosDst.x=float(c_rkNetMoveActorData.m_lPosX);
+		kPPosDst.y=float(c_rkNetMoveActorData.m_lPosY);
+		kPPosDst.z=0.0f;
+
+		pkInstFind->PushTCPState(c_rkNetMoveActorData.m_dwTime, kPPosDst, 
+			c_rkNetMoveActorData.m_fRot, c_rkNetMoveActorData.m_dwFunc, c_rkNetMoveActorData.m_dwArg);	
+	}
+
+	rkNetActorData.SetDstPosition(c_rkNetMoveActorData.m_dwTime,
+		c_rkNetMoveActorData.m_lPosX, c_rkNetMoveActorData.m_lPosY, c_rkNetMoveActorData.m_dwDuration);
+	rkNetActorData.m_fRot=c_rkNetMoveActorData.m_fRot;		
+}
+
+void CNetworkActorManager::SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY)
+{
+	std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(dwVID);
+	if (m_kNetActorDict.end()==f)
+	{
+#ifdef _DEBUG
+		TraceError("CNetworkActorManager::SyncActor(dwVID=%d) - NOT EXIST VID", dwVID);
+#endif
+		return;
+	}
+
+	SNetworkActorData& rkNetActorData=f->second;
+
+	CInstanceBase* pkInstFind=__FindActor(rkNetActorData);
+	if (pkInstFind)
+	{
+		pkInstFind->NEW_SyncPixelPosition(lPosX, lPosY);			
+	}
+	
+	rkNetActorData.SetPosition(lPosX, lPosY);	
+}
+
+void CNetworkActorManager::SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID)
+{
+	std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(dwVictimVID);
+	if (m_kNetActorDict.end()==f)
+	{
+#ifdef _DEBUG
+		TraceError("CNetworkActorManager::SetActorOwner(dwOwnerVID=%d, dwVictimVID=%d) - NOT EXIST VID", dwOwnerVID, dwVictimVID);
+#endif
+		return;
+	}
+
+	SNetworkActorData& rkNetActorData=f->second;
+	rkNetActorData.m_dwOwnerVID=dwOwnerVID;	
+
+	CInstanceBase* pkInstFind=__FindActor(rkNetActorData);
+	if (pkInstFind)
+	{
+		pkInstFind->NEW_SetOwner(rkNetActorData.m_dwOwnerVID);	
+	}
+		
+	
+}

src/UserInterface/NetworkActorManager.h

@@ -0,0 +1,164 @@
+#pragma once
+
+#include "InstanceBase.h"
+
+struct SNetworkActorData
+{
+	std::string m_stName;
+	
+	CAffectFlagContainer	m_kAffectFlags;
+
+	BYTE	m_bType;
+	DWORD	m_dwVID;
+	DWORD	m_dwStateFlags;
+	DWORD	m_dwEmpireID;
+	DWORD	m_dwRace;
+	DWORD	m_dwMovSpd;
+	DWORD	m_dwAtkSpd;
+	FLOAT	m_fRot;
+	LONG	m_lCurX;
+	LONG	m_lCurY;
+	LONG	m_lSrcX;
+	LONG	m_lSrcY;
+	LONG	m_lDstX;
+	LONG	m_lDstY;
+	
+
+	DWORD	m_dwServerSrcTime;
+	DWORD	m_dwClientSrcTime;
+	DWORD	m_dwDuration;
+
+	DWORD	m_dwArmor;
+	DWORD	m_dwWeapon;
+	DWORD	m_dwHair;
+
+	DWORD	m_dwOwnerVID;
+
+	short	m_sAlignment;
+	BYTE	m_byPKMode;
+	DWORD	m_dwMountVnum;
+
+	DWORD	m_dwGuildID;
+	DWORD	m_dwLevel;
+	
+	SNetworkActorData();
+
+	void SetDstPosition(DWORD dwServerTime, LONG lDstX, LONG lDstY, DWORD dwDuration);
+	void SetPosition(LONG lPosX, LONG lPosY);
+	void UpdatePosition();	
+
+	// NETWORK_ACTOR_DATA_COPY
+	SNetworkActorData(const SNetworkActorData& src);
+	void operator=(const SNetworkActorData& src);
+	void __copy__(const SNetworkActorData& src);	
+	// END_OF_NETWORK_ACTOR_DATA_COPY
+};
+
+struct SNetworkMoveActorData
+{
+	DWORD	m_dwVID;
+	DWORD	m_dwTime;
+	LONG	m_lPosX;
+	LONG	m_lPosY;
+	float	m_fRot;
+	DWORD	m_dwFunc;
+	DWORD	m_dwArg;
+	DWORD	m_dwDuration;
+
+	SNetworkMoveActorData()
+	{
+		m_dwVID=0;
+		m_dwTime=0;
+		m_fRot=0.0f;
+		m_lPosX=0;
+		m_lPosY=0;
+		m_dwFunc=0;
+		m_dwArg=0;
+		m_dwDuration=0;
+	}
+};
+
+struct SNetworkUpdateActorData
+{
+	DWORD m_dwVID;
+	DWORD m_dwGuildID;
+	DWORD m_dwArmor;
+	DWORD m_dwWeapon;
+	DWORD m_dwHair;
+	DWORD m_dwMovSpd;
+	DWORD m_dwAtkSpd;
+	short m_sAlignment;
+	BYTE m_byPKMode;
+	DWORD m_dwMountVnum;
+	DWORD m_dwStateFlags; // <20><><EFBFBD><EFBFBD> Create <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̴<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	CAffectFlagContainer m_kAffectFlags;
+
+	SNetworkUpdateActorData()
+	{
+		m_dwGuildID=0;
+		m_dwVID=0;
+		m_dwArmor=0;
+		m_dwWeapon=0;
+		m_dwHair=0;
+		m_dwMovSpd=0;
+		m_dwAtkSpd=0;
+		m_sAlignment=0;
+		m_byPKMode=0;
+		m_dwMountVnum=0;
+		m_dwStateFlags=0;
+		m_kAffectFlags.Clear();
+	}
+};
+
+class CPythonCharacterManager;
+
+class CNetworkActorManager : public CReferenceObject
+{
+	public:
+		CNetworkActorManager();
+		virtual ~CNetworkActorManager();
+
+		void Destroy();
+
+		void SetMainActorVID(DWORD dwVID);
+
+		void RemoveActor(DWORD dwVID);
+		void AppendActor(const SNetworkActorData& c_rkNetActorData);
+		void UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData);
+		void MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData);
+
+		void SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY);
+		void SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID);
+
+		void Update();
+
+	protected:
+		void __OLD_Update();
+
+		void __UpdateMainActor();
+
+		bool __IsVisiblePos(LONG lPosX, LONG lPosY);
+		bool __IsVisibleActor(const SNetworkActorData& c_rkNetActorData);
+		bool __IsMainActorVID(DWORD dwVID);
+
+		void __RemoveAllGroundItems();
+		void __RemoveAllActors();
+		void __RemoveDynamicActors();
+		void __RemoveCharacterManagerActor(SNetworkActorData& rkNetActorData);
+
+		SNetworkActorData* __FindActorData(DWORD dwVID);
+
+		CInstanceBase* __AppendCharacterManagerActor(SNetworkActorData& rkNetActorData);
+		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData);
+		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData, LONG lDstX, LONG lDstY);
+
+		CPythonCharacterManager& __GetCharacterManager();
+
+	protected:
+		DWORD m_dwMainVID;
+
+		LONG m_lMainPosX;
+		LONG m_lMainPosY;
+
+		std::map<DWORD, SNetworkActorData> m_kNetActorDict;
+};

src/UserInterface/ProcessCRC.cpp

@@ -0,0 +1,130 @@
+#include "StdAfx.h"
+
+#include <tlhelp32.h>
+
+static BYTE abCRCMagicCube[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+static BYTE abCRCXorTable[8] = { 102, 30, 188, 44, 39, 201, 43, 5 };
+static BYTE bMagicCubeIdx = 0;
+
+const char * stristr(const char * big, const char * little)
+{
+	const char * t = big;
+	size_t len = strlen(little) - 1;
+
+	for (t = big; *t; ++t)
+		if (!_strnicmp(t, little, len))
+			return t;
+
+	return NULL;
+}
+
+bool GetProcessInformation(std::string & exeFileName, LPCVOID * ppvAddress)
+{
+	HANDLE hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId());
+	if (hModuleSnap != INVALID_HANDLE_VALUE) 
+	{		
+		std::string filename;
+
+		GetExcutedFileName(filename);
+
+		MODULEENTRY32 me32;
+		memset(&me32, 0, sizeof(me32));
+		me32.dwSize = sizeof(MODULEENTRY32);
+
+		BOOL bRet = Module32First(hModuleSnap, &me32);
+
+		while (bRet) 
+		{
+			if (stristr(me32.szExePath, filename.c_str()))
+			{
+				exeFileName = me32.szExePath;
+				*ppvAddress = me32.modBaseAddr;
+				CloseHandle(hModuleSnap);
+				return true;
+			}
+
+			ZeroMemory(&me32, sizeof(MODULEENTRY32));
+			me32.dwSize = sizeof(MODULEENTRY32);
+
+			bRet = Module32Next(hModuleSnap, &me32);
+		}
+
+		CloseHandle(hModuleSnap);
+	}
+
+	return false;
+}
+
+DWORD GetProcessMemoryCRC(LPCVOID c_pvBaseAddress)
+{
+	HANDLE hProcess = GetCurrentProcess();
+	char * pBuf = new char[1024*1024];
+	DWORD dwBytesRead;
+
+	BOOL bRet = ReadProcessMemory(hProcess, c_pvBaseAddress, pBuf, 1024*1024, &dwBytesRead);
+
+	if (!bRet && GetLastError() == ERROR_PARTIAL_COPY)
+		bRet = true;
+
+	if (bRet)
+	{
+		DWORD dwCRC = GetCRC32(pBuf, dwBytesRead);
+		delete [] pBuf;
+		return dwCRC;
+	}
+
+	delete [] pBuf;
+	return 0;
+}
+
+bool __GetExeCRC(DWORD & r_dwProcCRC, DWORD & r_dwFileCRC)
+{
+	std::string exeFileName;
+	LPCVOID c_pvBaseAddress;
+
+	GetExcutedFileName(exeFileName);
+
+	if (GetProcessInformation(exeFileName, &c_pvBaseAddress))
+		r_dwProcCRC = GetProcessMemoryCRC(c_pvBaseAddress);
+	else
+		r_dwProcCRC = 0;
+
+	r_dwFileCRC = GetFileCRC32(exeFileName.c_str());
+	return true;
+}
+
+void BuildProcessCRC()
+{
+	if (LocaleService_IsHONGKONG() || LocaleService_IsTAIWAN())
+	{
+		memset(abCRCMagicCube, 0, sizeof(abCRCMagicCube));
+		bMagicCubeIdx = 0;
+		return;
+	}
+	
+	DWORD dwProcCRC, dwFileCRC;
+
+	if (__GetExeCRC(dwProcCRC, dwFileCRC))
+	{
+		abCRCMagicCube[0] = BYTE(dwProcCRC & 0x000000ff);
+		abCRCMagicCube[1] = BYTE(dwFileCRC & 0x000000ff);
+		abCRCMagicCube[2] = BYTE( (dwProcCRC & 0x0000ff00) >> 8 );
+		abCRCMagicCube[3] = BYTE( (dwFileCRC & 0x0000ff00) >> 8 );
+		abCRCMagicCube[4] = BYTE( (dwProcCRC & 0x00ff0000) >> 16 );
+		abCRCMagicCube[5] = BYTE( (dwFileCRC & 0x00ff0000) >> 16 );
+		abCRCMagicCube[6] = BYTE( (dwProcCRC & 0xff000000) >> 24 );
+		abCRCMagicCube[7] = BYTE( (dwFileCRC & 0xff000000) >> 24 );
+
+		bMagicCubeIdx = 0;
+	}
+}
+
+BYTE GetProcessCRCMagicCubePiece()
+{
+	BYTE bPiece = BYTE(abCRCMagicCube[bMagicCubeIdx] ^ abCRCXorTable[bMagicCubeIdx]);
+
+	if (!(++bMagicCubeIdx & 7))
+		bMagicCubeIdx = 0;
+
+	return bPiece;
+}

src/UserInterface/ProcessCRC.h

@@ -0,0 +1,6 @@
+#pragma once
+
+extern bool GetExeCRC(DWORD & r_dwProcCRC, DWORD & r_dwFileCRC);
+
+extern void BuildProcessCRC();
+extern BYTE GetProcessCRCMagicCubePiece();

src/UserInterface/ProcessScanner.cpp

@@ -0,0 +1,142 @@
+#include "StdAfx.h"
+#include "ProcessScanner.h"
+
+#include <tlhelp32.h>
+
+static std::vector<CRCPair> gs_kVct_crcPair;
+static CRITICAL_SECTION gs_csData;
+static HANDLE gs_evReqExit=NULL;
+static HANDLE gs_evResExit=NULL;
+static HANDLE gs_hThread=NULL;
+
+void ScanProcessList(std::map<DWORD, DWORD>& rkMap_crcProc, std::vector<CRCPair>* pkVct_crcPair)
+{
+	SYSTEM_INFO si;
+	memset(&si, 0, sizeof(si));
+	GetSystemInfo(&si);
+
+	PROCESSENTRY32 pro;
+    pro.dwSize = sizeof(PROCESSENTRY32);
+
+    LPPROCESSENTRY32 Entry;
+    Entry = &pro;
+
+    HANDLE process = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
+
+    BOOL bOK = Process32First(process, Entry);
+
+    while(bOK)
+    {
+		HANDLE hProc = OpenProcess(PROCESS_VM_READ, FALSE, Entry->th32ProcessID);
+		if (hProc)
+		{
+			HANDLE hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, Entry->th32ProcessID);
+			if (hModuleSnap != INVALID_HANDLE_VALUE) 
+			{
+				MODULEENTRY32	me32;
+				memset(&me32, 0, sizeof(me32));
+				me32.dwSize = sizeof(MODULEENTRY32);
+
+				BOOL bRet = Module32First(hModuleSnap, &me32);
+				while (bRet) 
+				{
+					DWORD crcExtPath=GetCRC32((const char*)me32.szExePath, strlen(me32.szExePath));
+
+					std::map<DWORD, DWORD>::iterator f=rkMap_crcProc.find(crcExtPath);
+					if (rkMap_crcProc.end()==f)
+					{
+						DWORD crcProc=GetFileCRC32(me32.szExePath);
+						rkMap_crcProc.insert(std::make_pair(crcExtPath, crcProc));
+						pkVct_crcPair->push_back(std::make_pair(crcProc, (const char*)me32.szExePath));						
+					}
+					Sleep(1);
+						
+					ZeroMemory(&me32, sizeof(MODULEENTRY32));
+					me32.dwSize = sizeof(MODULEENTRY32);		
+					bRet = Module32Next(hModuleSnap, &me32);
+				}
+
+				CloseHandle(hModuleSnap);
+			}
+
+			CloseHandle(hProc);		
+		}
+
+	
+        bOK = Process32Next(process, Entry);
+    }
+    CloseHandle(process);
+}
+
+void ProcessScanner_ReleaseQuitEvent()
+{
+	SetEvent(gs_evReqExit);
+}
+
+void ProcessScanner_Destroy()
+{
+	ProcessScanner_ReleaseQuitEvent();
+
+	WaitForSingleObject(gs_evResExit, INFINITE);	
+	CloseHandle(gs_evReqExit);
+	CloseHandle(gs_evResExit);
+	DeleteCriticalSection(&gs_csData);
+}
+
+bool ProcessScanner_PopProcessQueue(std::vector<CRCPair>* pkVct_crcPair)
+{
+	EnterCriticalSection(&gs_csData);
+	*pkVct_crcPair=gs_kVct_crcPair;
+	gs_kVct_crcPair.clear();
+	LeaveCriticalSection(&gs_csData);
+
+	if (pkVct_crcPair->empty())
+		return false;
+
+	return true;	
+}
+
+void ProcessScanner_Thread(void* pv)
+{	
+	DWORD dwDelay=(rand()%10)*1000+1000*10;
+
+	std::map<DWORD, DWORD>	kMap_crcProc;
+	std::vector<CRCPair>	kVct_crcPair;
+	
+	while (WAIT_OBJECT_0 != WaitForSingleObject(gs_evReqExit, dwDelay))
+	{
+		kVct_crcPair.clear();
+		ScanProcessList(kMap_crcProc, &kVct_crcPair);
+
+		EnterCriticalSection(&gs_csData);
+		gs_kVct_crcPair.insert(gs_kVct_crcPair.end(), kVct_crcPair.begin(), kVct_crcPair.end());
+		LeaveCriticalSection(&gs_csData);				
+
+		dwDelay=(rand()%10)*1000+1000;
+	}
+
+	SetEvent(gs_evResExit);
+}
+
+
+bool ProcessScanner_Create()
+{
+	InitializeCriticalSection(&gs_csData);
+	gs_evReqExit=CreateEvent(NULL, FALSE, FALSE, "ProcessScanner_ReqExit");
+	gs_evResExit=CreateEvent(NULL, FALSE, FALSE, "ProcessScanner_ResExit");
+
+	gs_hThread=(HANDLE)_beginthread(ProcessScanner_Thread, 64*1024, NULL);
+	if (INVALID_HANDLE_VALUE==gs_hThread)
+	{
+		LogBox("CreateThread Error");
+		return false;
+	}
+
+	if (!SetThreadPriority(gs_hThread, THREAD_PRIORITY_LOWEST))
+	{
+		LogBox("SetThreadPriority Error");
+		return false;
+	}
+
+	return true;
+}

src/UserInterface/ProcessScanner.h

@@ -0,0 +1,9 @@
+#pragma once
+
+typedef std::pair<DWORD, std::string> CRCPair;
+
+void ProcessScanner_Destroy();
+bool ProcessScanner_Create();
+void ProcessScanner_ReleaseQuitEvent();
+
+bool ProcessScanner_PopProcessQueue(std::vector<CRCPair>* pkVct_crcPair);

src/UserInterface/PythonApplication.h

@@ -0,0 +1,440 @@
+#pragma once
+
+#include "../eterLib/MSApplication.h"
+#include "../eterLib/Input.h"
+#include "../eterLib/Profiler.h"
+#include "../eterLib/GrpDevice.h"
+#include "../eterLib/NetDevice.h"
+#include "../eterLib/GrpLightManager.h"
+#include "../EffectLib/EffectManager.h"
+#include "../gamelib/RaceManager.h"
+#include "../gamelib/ItemManager.h"
+#include "../gamelib/FlyingObjectManager.h"
+#include "../gamelib/GameEventManager.h"
+#include "../milesLib/SoundManager.h"
+
+#include "PythonEventManager.h"
+#include "PythonPlayer.h"
+#include "PythonNonPlayer.h"
+#include "PythonMiniMap.h"
+#include "PythonIME.h"
+#include "PythonItem.h"
+#include "PythonShop.h"
+#include "PythonExchange.h"
+#include "PythonChat.h"
+#include "PythonTextTail.h"
+#include "PythonSkill.h"
+#include "PythonSystem.h"
+//#include "PythonNetworkDatagram.h"
+#include "PythonNetworkStream.h"
+#include "PythonCharacterManager.h"
+#include "PythonQuest.h"
+#include "PythonMessenger.h"
+#include "PythonSafeBox.h"
+#include "PythonGuild.h"
+
+#include "GuildMarkDownloader.h"
+#include "GuildMarkUploader.h"
+
+#include "AccountConnector.h"
+
+#include "ServerStateChecker.h"
+#include "AbstractApplication.h"
+#include "MovieMan.h"
+
+class CPythonApplication : public CMSApplication, public CInputKeyboard, public IAbstractApplication
+{
+	public:
+		enum EDeviceState
+		{
+			DEVICE_STATE_FALSE,
+			DEVICE_STATE_SKIP,
+			DEVICE_STATE_OK,
+		};
+
+		enum ECursorMode
+		{
+			CURSOR_MODE_HARDWARE,
+			CURSOR_MODE_SOFTWARE,
+		};
+
+		enum ECursorShape
+		{
+			CURSOR_SHAPE_NORMAL,
+			CURSOR_SHAPE_ATTACK,
+			CURSOR_SHAPE_TARGET,
+			CURSOR_SHAPE_TALK,
+			CURSOR_SHAPE_CANT_GO,
+			CURSOR_SHAPE_PICK,
+
+			CURSOR_SHAPE_DOOR,
+			CURSOR_SHAPE_CHAIR,
+			CURSOR_SHAPE_MAGIC,				// Magic
+			CURSOR_SHAPE_BUY,				// Buy
+			CURSOR_SHAPE_SELL,				// Sell
+
+			CURSOR_SHAPE_CAMERA_ROTATE,		// Camera Rotate
+			CURSOR_SHAPE_HSIZE,				// Horizontal Size
+			CURSOR_SHAPE_VSIZE,				// Vertical Size
+			CURSOR_SHAPE_HVSIZE,			// Horizontal & Vertical Size
+
+			CURSOR_SHAPE_COUNT,
+
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̹<EFBFBD> <20><>ȯ<EFBFBD><C8AF> <20><><EFBFBD><EFBFBD> <20>ӽ<EFBFBD> enumerate
+			NORMAL = CURSOR_SHAPE_NORMAL,
+			ATTACK = CURSOR_SHAPE_ATTACK,
+			TARGET = CURSOR_SHAPE_TARGET,
+			CAMERA_ROTATE = CURSOR_SHAPE_CAMERA_ROTATE,
+			CURSOR_COUNT = CURSOR_SHAPE_COUNT,
+		};
+
+		enum EInfo
+		{
+			INFO_ACTOR,
+			INFO_EFFECT,
+			INFO_ITEM,
+			INFO_TEXTTAIL,
+		};
+
+		enum ECameraControlDirection
+		{
+			CAMERA_TO_POSITIVE = 1,
+			CAMERA_TO_NEGITIVE = -1,
+			CAMERA_STOP = 0,
+		};
+
+		enum
+		{
+			CAMERA_MODE_NORMAL = 0,
+			CAMERA_MODE_STAND = 1,
+			CAMERA_MODE_BLEND = 2,
+
+			EVENT_CAMERA_NUMBER = 101,
+		};
+
+		struct SCameraSpeed
+		{
+			float m_fUpDir;
+			float m_fViewDir;
+			float m_fCrossDir;
+
+			SCameraSpeed() : m_fUpDir(0.0f), m_fViewDir(0.0f), m_fCrossDir(0.0f) {}
+		};
+
+	public:
+		CPythonApplication();
+		virtual ~CPythonApplication();
+
+	public:
+		void ShowWebPage(const char* c_szURL, const RECT& c_rcWebPage);
+		void MoveWebPage(const RECT& c_rcWebPage);
+		void HideWebPage();
+
+		bool IsWebPageMode();
+
+	public:
+		void NotifyHack(const char* c_szFormat, ...);
+		void GetInfo(UINT eInfo, std::string* pstInfo);
+		void GetMousePosition(POINT* ppt);
+		
+		static CPythonApplication& Instance()
+		{
+			assert(ms_pInstance != NULL);
+			return *ms_pInstance;
+		}
+
+		void Loop();
+		void Destroy();
+		void Clear();
+		void Exit();
+		void Abort();
+
+		void SetMinFog(float fMinFog);
+		void SetFrameSkip(bool isEnable);
+		void SkipRenderBuffering(DWORD dwSleepMSec);
+
+		bool Create(PyObject* poSelf, const char* c_szName, int width, int height, int Windowed);
+		bool CreateDevice(int width, int height, int Windowed, int bit = 32, int frequency = 0);
+
+		void UpdateGame();
+		void RenderGame();
+
+		bool Process();
+
+		void UpdateClientRect();
+
+		bool CreateCursors();
+		void DestroyCursors();
+
+		void SafeSetCapture();
+		void SafeReleaseCapture();
+
+		BOOL SetCursorNum(int iCursorNum);
+		void SetCursorVisible(BOOL bFlag, bool bLiarCursorOn = false);
+		BOOL GetCursorVisible();
+		bool GetLiarCursorOn();
+		void SetCursorMode(int iMode);
+		int GetCursorMode();
+		int GetCursorNum() { return m_iCursorNum; }
+
+		void SetMouseHandler(PyObject * poMouseHandler);
+
+		int GetWidth();
+		int GetHeight();
+
+		void SetGlobalCenterPosition(LONG x, LONG y);
+		void SetCenterPosition(float fx, float fy, float fz);
+		void GetCenterPosition(TPixelPosition * pPixelPosition);
+		void SetCamera(float Distance, float Pitch, float Rotation, float fDestinationHeight);
+		void GetCamera(float * Distance, float * Pitch, float * Rotation, float * DestinationHeight);
+		void RotateCamera(int iDirection);
+		void PitchCamera(int iDirection);
+		void ZoomCamera(int iDirection);
+		void MovieRotateCamera(int iDirection);
+		void MoviePitchCamera(int iDirection);
+		void MovieZoomCamera(int iDirection);
+		void MovieResetCamera();
+		void SetViewDirCameraSpeed(float fSpeed);
+		void SetCrossDirCameraSpeed(float fSpeed);
+		void SetUpDirCameraSpeed(float fSpeed);
+		float GetRotation();
+		float GetPitch();
+
+		void SetFPS(int iFPS);
+		void SetServerTime(time_t tTime);
+		time_t GetServerTime();
+		time_t GetServerTimeStamp();
+		float GetGlobalTime();
+		float GetGlobalElapsedTime();
+
+		float GetFaceSpeed()		{ return m_fFaceSpd; }
+		float GetAveRenderTime()	{ return m_fAveRenderTime; }
+		DWORD GetCurRenderTime()	{ return m_dwCurRenderTime; }
+		DWORD GetCurUpdateTime()	{ return m_dwCurUpdateTime; }
+		DWORD GetUpdateFPS()		{ return m_dwUpdateFPS; }
+		DWORD GetRenderFPS()		{ return m_dwRenderFPS; }
+		DWORD GetLoad()			{ return m_dwLoad; }
+		DWORD GetFaceCount()	{ return m_dwFaceCount; }
+
+		void SetConnectData(const char * c_szIP, int iPort);
+		void GetConnectData(std::string & rstIP, int & riPort);
+
+		void RunIMEUpdate();
+		void RunIMETabEvent();
+		void RunIMEReturnEvent();
+		void RunPressExitKey();
+
+		void RunIMEChangeCodePage();
+		void RunIMEOpenCandidateListEvent();
+		void RunIMECloseCandidateListEvent();
+		void RunIMEOpenReadingWndEvent();
+		void RunIMECloseReadingWndEvent();
+
+		void EnableSpecialCameraMode();
+		void SetCameraSpeed(int iPercentage);
+
+		bool IsLockCurrentCamera();
+		void SetEventCamera(const SCameraSetting & c_rCameraSetting);
+		void BlendEventCamera(const SCameraSetting & c_rCameraSetting, float fBlendTime);
+		void SetDefaultCamera();
+
+		void SetCameraSetting(const SCameraSetting & c_rCameraSetting);
+		void GetCameraSetting(SCameraSetting * pCameraSetting);
+		void SaveCameraSetting(const char * c_szFileName);
+		bool LoadCameraSetting(const char * c_szFileName);
+
+		void SetForceSightRange(int iRange);
+	
+
+	public:
+		int OnLogoOpen(char* szName);
+		int OnLogoUpdate();
+		void OnLogoRender();
+		void OnLogoClose();
+
+	protected:
+		IGraphBuilder*			m_pGraphBuilder;			// Graph Builder
+		IBaseFilter*			m_pFilterSG;				// Sample Grabber <20><><EFBFBD><EFBFBD>
+		ISampleGrabber*			m_pSampleGrabber;			// <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD> ĸó<C4B8><C3B3> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>׷<EFBFBD><D7B7><EFBFBD>
+		IMediaControl*			m_pMediaCtrl;				// Media Control
+		IMediaEventEx*			m_pMediaEvent;				// Media Event
+		IVideoWindow*			m_pVideoWnd;				// Video Window
+		IBasicVideo*			m_pBasicVideo;
+		BYTE*					m_pCaptureBuffer;			// <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD><CCB9><EFBFBD><EFBFBD><EFBFBD> ĸó<C4B8><C3B3> <20><><EFBFBD><EFBFBD>
+		LONG					m_lBufferSize;				// Video <20><><EFBFBD><EFBFBD> ũ<><C5A9> <20><><EFBFBD><EFBFBD> 
+		CGraphicImageTexture*	m_pLogoTex;					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ؽ<EFBFBD><D8BD><EFBFBD>
+		bool					m_bLogoError;				// <20><><EFBFBD><EFBFBD> <20>б<EFBFBD> <20><><EFBFBD><EFBFBD>
+		bool					m_bLogoPlay;
+
+		int						m_nLeft, m_nRight, m_nTop, m_nBottom;
+
+
+	protected:
+		LRESULT WindowProcedure(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam);
+
+		void OnCameraUpdate();
+
+		void OnUIUpdate();
+		void OnUIRender();
+
+		void OnMouseUpdate();
+		void OnMouseRender();
+
+		void OnMouseWheel(int nLen);
+		void OnMouseMove(int x, int y);
+		void OnMouseMiddleButtonDown(int x, int y);
+		void OnMouseMiddleButtonUp(int x, int y);
+		void OnMouseLeftButtonDown(int x, int y);
+		void OnMouseLeftButtonUp(int x, int y);
+		void OnMouseLeftButtonDoubleClick(int x, int y);
+		void OnMouseRightButtonDown(int x, int y);
+		void OnMouseRightButtonUp(int x, int y);
+		void OnSizeChange(int width, int height);
+		void OnKeyDown(int iIndex);
+		void OnKeyUp(int iIndex);
+		void OnIMEKeyDown(int iIndex);
+
+		int CheckDeviceState();
+
+		BOOL __IsContinuousChangeTypeCursor(int iCursorNum);
+
+		void __UpdateCamera();
+
+		void __SetFullScreenWindow(HWND hWnd, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP);
+		void __MinimizeFullScreenWindow(HWND hWnd, DWORD dwWidth, DWORD dwHeight);
+
+
+	protected:
+		CTimer m_timer;
+
+		CLightManager				m_LightManager;
+		CSoundManager				m_SoundManager;
+		CFlyingManager				m_FlyingManager;
+		CRaceManager				m_RaceManager;
+		CGameEventManager			m_GameEventManager;
+		CItemManager				m_kItemMgr;
+		CMovieMan					m_MovieManager;
+
+		UI::CWindowManager			m_kWndMgr;
+		CEffectManager				m_kEftMgr;
+		CPythonCharacterManager		m_kChrMgr;
+
+		CServerStateChecker			m_kServerStateChecker;
+		CPythonGraphic				m_pyGraphic;
+		CPythonNetworkStream		m_pyNetworkStream;
+		//CPythonNetworkDatagram		m_pyNetworkDatagram;
+		CPythonPlayer				m_pyPlayer;
+		CPythonIME					m_pyIme;
+		CPythonItem					m_pyItem;
+		CPythonShop					m_pyShop;
+		CPythonExchange				m_pyExchange;
+		CPythonChat					m_pyChat;
+		CPythonTextTail				m_pyTextTail;
+		CPythonNonPlayer			m_pyNonPlayer;
+		CPythonMiniMap				m_pyMiniMap;
+		CPythonEventManager			m_pyEventManager;
+		CPythonBackground			m_pyBackground;
+		CPythonSkill				m_pySkill;
+		CPythonResource				m_pyRes;
+		CPythonQuest				m_pyQuest;
+		CPythonMessenger			m_pyManager;
+		CPythonSafeBox				m_pySafeBox;
+		CPythonGuild				m_pyGuild;
+
+		CGuildMarkManager			m_kGuildMarkManager;
+		CGuildMarkDownloader		m_kGuildMarkDownloader;
+		CGuildMarkUploader			m_kGuildMarkUploader;
+		CAccountConnector			m_kAccountConnector;
+
+		CGraphicDevice				m_grpDevice;
+		CNetworkDevice				m_netDevice;
+
+		CPythonSystem				m_pySystem;
+
+
+		PyObject *					m_poMouseHandler;
+		D3DXVECTOR3					m_v3CenterPosition;
+
+		unsigned int				m_iFPS;
+		float						m_fAveRenderTime;
+		DWORD						m_dwCurRenderTime;
+		DWORD						m_dwCurUpdateTime;
+		DWORD						m_dwLoad;
+		DWORD						m_dwWidth;
+		DWORD						m_dwHeight;
+
+	protected:
+		// Time
+		DWORD						m_dwLastIdleTime;
+		DWORD						m_dwStartLocalTime;
+		time_t						m_tServerTime;
+		time_t						m_tLocalStartTime;
+		float						m_fGlobalTime;
+		float						m_fGlobalElapsedTime;
+
+		/////////////////////////////////////////////////////////////
+		// Camera
+		SCameraSetting				m_DefaultCameraSetting;
+		SCameraSetting				m_kEventCameraSetting;
+
+		int							m_iCameraMode;
+		float						m_fBlendCameraStartTime;
+		float						m_fBlendCameraBlendTime;
+		SCameraSetting				m_kEndBlendCameraSetting;
+
+		float						m_fRotationSpeed;
+		float						m_fPitchSpeed;
+		float						m_fZoomSpeed;
+		float						m_fCameraRotateSpeed;
+		float						m_fCameraPitchSpeed;
+		float						m_fCameraZoomSpeed;
+
+		SCameraPos					m_kCmrPos;
+		SCameraSpeed				m_kCmrSpd;
+
+		BOOL						m_isSpecialCameraMode;
+		// Camera
+		/////////////////////////////////////////////////////////////
+
+		float						m_fFaceSpd;
+		DWORD						m_dwFaceSpdSum;
+		DWORD						m_dwFaceSpdCount;
+
+		DWORD						m_dwFaceAccCount;
+		DWORD						m_dwFaceAccTime;
+
+		DWORD						m_dwUpdateFPS;
+		DWORD						m_dwRenderFPS;
+		DWORD						m_dwFaceCount;
+
+		DWORD						m_dwLButtonDownTime;
+		DWORD						m_dwLButtonUpTime;
+
+		typedef std::map<int, HANDLE>		TCursorHandleMap;
+		TCursorHandleMap			m_CursorHandleMap;
+		HANDLE						m_hCurrentCursor;
+
+		BOOL						m_bCursorVisible;
+		bool						m_bLiarCursorOn;
+		int							m_iCursorMode;
+		bool						m_isWindowed;
+		bool						m_isFrameSkipDisable;
+
+		// Connect Data
+		std::string					m_strIP;
+		int							m_iPort;
+
+		static CPythonApplication*	ms_pInstance;
+
+		bool						m_isMinimizedWnd;
+		bool						m_isActivateWnd;
+		BOOL						m_isWindowFullScreenEnable;
+
+		DWORD						m_dwStickyKeysFlag;
+		DWORD						m_dwBufSleepSkipTime;
+		int							m_iForceSightRange;
+
+	protected:
+		int m_iCursorNum;
+		int m_iContinuousCursorNum;
+};

src/UserInterface/PythonApplicationCamera.cpp

@@ -0,0 +1,415 @@
+#include "StdAfx.h"
+#include "PythonApplication.h"
+
+#include "../eterbase/timer.h"
+#include "../eterlib/Camera.h"
+
+float BlendValueByLinear(float fElapsedTime, float fDuration, float fBeginValue, float fEndValue)
+{
+	if (fElapsedTime >= fDuration)
+		return fEndValue;
+
+	return (fEndValue - fBeginValue) * (fElapsedTime / fDuration) + fBeginValue;
+}
+
+void CPythonApplication::__UpdateCamera()
+{
+	//////////////////////
+	// Camera Setting
+	CCamera * pMainCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (!pMainCamera)
+		return;
+
+	if (CAMERA_MODE_BLEND == m_iCameraMode)
+	{
+		float fcurTime = CTimer::Instance().GetCurrentSecond();
+		float fElapsedTime = fcurTime - m_fBlendCameraStartTime;
+
+		float fxCenter = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.v3CenterPosition.x, m_kEndBlendCameraSetting.v3CenterPosition.x);
+		float fyCenter = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.v3CenterPosition.y, m_kEndBlendCameraSetting.v3CenterPosition.y);
+		float fzCenter = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.v3CenterPosition.z, m_kEndBlendCameraSetting.v3CenterPosition.z);
+
+		float fDistance = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.fZoom, m_kEndBlendCameraSetting.fZoom);
+		float fPitch = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.fPitch, m_kEndBlendCameraSetting.fPitch);
+		float fRotation = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.fRotation, m_kEndBlendCameraSetting.fRotation);
+
+		float fUpDir = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.kCmrPos.m_fUpDir, m_kEndBlendCameraSetting.kCmrPos.m_fUpDir);
+		float fViewDir = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.kCmrPos.m_fViewDir, m_kEndBlendCameraSetting.kCmrPos.m_fViewDir);
+		float fCrossDir = BlendValueByLinear(fElapsedTime, m_fBlendCameraBlendTime, m_kEventCameraSetting.kCmrPos.m_fCrossDir, m_kEndBlendCameraSetting.kCmrPos.m_fCrossDir);
+
+		// Temporary. Have to fix that this work in camera class. - [levites]
+		pMainCamera->Unlock();
+		m_pyGraphic.SetPositionCamera(fxCenter, fyCenter, fzCenter, fDistance, fPitch, fRotation);
+		pMainCamera->MoveVertical(fUpDir);
+		pMainCamera->MoveFront(fViewDir);
+		pMainCamera->MoveAlongCross(fCrossDir);
+		pMainCamera->Lock();
+	}
+	else if (CAMERA_MODE_STAND == m_iCameraMode)
+	{
+		float fDistance, fPitch, fRotation, fHeight;
+		GetCamera(&fDistance, &fPitch, &fRotation, &fHeight);
+		m_pyGraphic.SetPositionCamera(m_kEventCameraSetting.v3CenterPosition.x,
+									  m_kEventCameraSetting.v3CenterPosition.y,
+									  m_kEventCameraSetting.v3CenterPosition.z + pMainCamera->GetTargetHeight(),
+									  fDistance, fPitch, fRotation);
+	}
+	else if (CAMERA_MODE_NORMAL == m_iCameraMode)
+	{
+		float fDistance, fPitch, fRotation, fHeight;
+		GetCamera(&fDistance, &fPitch, &fRotation, &fHeight);
+		m_pyGraphic.SetPositionCamera(m_v3CenterPosition.x, m_v3CenterPosition.y, m_v3CenterPosition.z + pMainCamera->GetTargetHeight(), fDistance, fPitch, fRotation);
+	}
+
+	if (0.0f != m_fRotationSpeed)
+		pMainCamera->Roll(m_fRotationSpeed);
+	if (0.0f != m_fPitchSpeed)
+		pMainCamera->Pitch(m_fPitchSpeed);
+	if (0.0f != m_fZoomSpeed)
+		pMainCamera->Zoom(m_fZoomSpeed);
+
+	if (0.0f !=m_kCmrSpd.m_fViewDir)
+		m_kCmrPos.m_fViewDir+=m_kCmrSpd.m_fViewDir;
+	if (0.0f !=m_kCmrSpd.m_fCrossDir)
+		m_kCmrPos.m_fCrossDir+=m_kCmrSpd.m_fCrossDir;
+	if (0.0f !=m_kCmrSpd.m_fUpDir)
+		m_kCmrPos.m_fUpDir+=m_kCmrSpd.m_fUpDir;
+
+	if (0.0f != m_kCmrPos.m_fViewDir)
+		pMainCamera->MoveFront(m_kCmrPos.m_fViewDir);
+	if (0.0f != m_kCmrPos.m_fCrossDir)
+		pMainCamera->MoveAlongCross(m_kCmrPos.m_fCrossDir);
+	if (0.0f != m_kCmrPos.m_fUpDir)
+		pMainCamera->MoveVertical(m_kCmrPos.m_fUpDir);
+
+	//////////////////////
+
+	if (pMainCamera->IsDraging())
+		SkipRenderBuffering(3000);
+
+	//////////////////////
+	// Sound Setting
+	const D3DXVECTOR3 & c_rv3CameraDirection = pMainCamera->GetView();
+	const D3DXVECTOR3 & c_rv3CameraUp = pMainCamera->GetUp();
+	m_SoundManager.SetPosition(m_v3CenterPosition.x, m_v3CenterPosition.y, m_v3CenterPosition.z);	// Listener - ij<><C4B3><EFBFBD><EFBFBD> <20><>ġ
+	m_SoundManager.SetDirection(c_rv3CameraDirection.x, c_rv3CameraDirection.y, c_rv3CameraDirection.z, c_rv3CameraUp.x, c_rv3CameraUp.y, c_rv3CameraUp.z);
+	m_SoundManager.Update();
+	//////////////////////
+}
+
+void CPythonApplication::SetViewDirCameraSpeed(float fSpeed)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	m_kCmrSpd.m_fViewDir=fSpeed;
+}
+
+void CPythonApplication::SetCrossDirCameraSpeed(float fSpeed)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	m_kCmrSpd.m_fCrossDir=fSpeed;
+}
+
+void CPythonApplication::SetUpDirCameraSpeed(float fSpeed)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	m_kCmrSpd.m_fUpDir=fSpeed;
+}
+
+void CPythonApplication::SetCamera(float Distance, float Pitch, float Rotation, float fDestinationHeight)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	CCamera * pCurrentCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (!pCurrentCamera)
+		return;
+
+	D3DXVECTOR3 v3Target = pCurrentCamera->GetTarget();
+	m_pyGraphic.SetPositionCamera(v3Target.x, v3Target.y, v3Target.z, Distance, Pitch, Rotation);
+
+	CCamera * pMainCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (pMainCamera)
+		pMainCamera->SetTargetHeight(fDestinationHeight);
+}
+
+void CPythonApplication::GetCamera(float * Distance, float * Pitch, float * Rotation, float * DestinationHeight)
+{
+	CCamera * pCurrentCamera = CCameraManager::Instance().GetCurrentCamera();
+	*Distance			= pCurrentCamera->GetDistance();
+	*Pitch				= pCurrentCamera->GetPitch();
+	*Rotation			= pCurrentCamera->GetRoll();
+	*DestinationHeight	= pCurrentCamera->GetTarget().z;
+}
+
+void CPythonApplication::RotateCamera(int iDirection)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	float fDegree = m_fCameraRotateSpeed * float(iDirection);
+	m_fRotationSpeed = fDegree;
+}
+
+void CPythonApplication::PitchCamera(int iDirection)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	float fDegree = m_fCameraPitchSpeed * float(iDirection);
+	m_fPitchSpeed = fDegree;
+}
+
+void CPythonApplication::ZoomCamera(int iDirection)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	float fRatio = 1.0f + m_fCameraZoomSpeed * float(iDirection);
+	m_fZoomSpeed = fRatio;
+}
+
+void CPythonApplication::MovieRotateCamera(int iDirection)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	float fDegree = m_fCameraRotateSpeed * float(iDirection);
+	if (m_isSpecialCameraMode)
+	{
+		if (GetKeyState(VK_SCROLL) & 1)
+		{
+			SetCrossDirCameraSpeed(-fDegree * 6.0f);
+			return;
+		}
+	}
+	m_fRotationSpeed = fDegree;
+}
+
+void CPythonApplication::MoviePitchCamera(int iDirection)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	float fDegree = m_fCameraPitchSpeed * float(iDirection);
+	if (m_isSpecialCameraMode)
+	{
+		if (GetKeyState(VK_SCROLL) & 1)
+		{
+			SetViewDirCameraSpeed(-fDegree * 6.0f);
+			return;
+		}
+	}
+	m_fPitchSpeed = fDegree;
+}
+
+void CPythonApplication::MovieZoomCamera(int iDirection)
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	float fRatio = 1.0f + m_fCameraZoomSpeed * float(iDirection);
+	if (m_isSpecialCameraMode)
+	{
+		if (GetKeyState(VK_SCROLL) & 1)
+		{
+			SetUpDirCameraSpeed((1.0f - fRatio) * 200.0f);
+			return;
+		}
+	}
+	m_fZoomSpeed = fRatio;
+}
+
+void CPythonApplication::MovieResetCamera()
+{
+	if (IsLockCurrentCamera())
+		return;
+
+	if (m_isSpecialCameraMode)
+	{
+		SetCrossDirCameraSpeed(0.0f);
+		SetViewDirCameraSpeed(0.0f);
+		SetUpDirCameraSpeed(0.0f);
+
+		m_kCmrPos.m_fViewDir = 0;
+		m_kCmrPos.m_fCrossDir = 0;
+		m_kCmrPos.m_fUpDir = 0;
+	}
+}
+
+float CPythonApplication::GetRotation()
+{
+	return CCameraManager::Instance().GetCurrentCamera()->GetRoll();
+}
+
+float CPythonApplication::GetPitch()
+{
+	return CCameraManager::Instance().GetCurrentCamera()->GetPitch();
+}
+
+bool CPythonApplication::IsLockCurrentCamera()
+{
+	CCamera * pCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (!pCamera)
+		return false;
+
+	return pCamera->IsLock();
+}
+
+void CPythonApplication::SetEventCamera(const SCameraSetting & c_rCameraSetting)
+{
+	if (CCameraManager::DEFAULT_PERSPECTIVE_CAMERA == CCameraManager::Instance().GetCurrentCameraNum())
+	{
+		GetCameraSetting(&m_DefaultCameraSetting);
+	}
+
+	/////
+
+	CCameraManager::Instance().SetCurrentCamera(EVENT_CAMERA_NUMBER);
+	CCamera * pCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (!pCamera)
+		return;
+
+	SetCameraSetting(c_rCameraSetting);
+	m_kEventCameraSetting = c_rCameraSetting;
+	m_iCameraMode = CAMERA_MODE_STAND;
+}
+
+void CPythonApplication::BlendEventCamera(const SCameraSetting & c_rCameraSetting, float fBlendTime)
+{
+	m_iCameraMode = CAMERA_MODE_BLEND;
+	m_fBlendCameraStartTime = CTimer::Instance().GetCurrentSecond();
+	m_fBlendCameraBlendTime = fBlendTime;
+	m_kEndBlendCameraSetting = c_rCameraSetting;
+
+	CCamera * pCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (pCamera)
+		pCamera->Lock();
+}
+
+void CPythonApplication::SetDefaultCamera()
+{
+	m_iCameraMode = CAMERA_MODE_NORMAL;
+	m_fBlendCameraStartTime = 0.0f;
+	m_fBlendCameraBlendTime = 0.0f;
+
+	/////
+
+	CCamera * pCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (pCamera)
+		pCamera->Unlock();
+
+	if (CCameraManager::DEFAULT_PERSPECTIVE_CAMERA != CCameraManager::Instance().GetCurrentCameraNum())
+	{
+		CCameraManager::Instance().SetCurrentCamera(CCameraManager::DEFAULT_PERSPECTIVE_CAMERA);
+		SetCameraSetting(m_DefaultCameraSetting);
+	}
+}
+
+void CPythonApplication::SetCameraSetting(const SCameraSetting & c_rCameraSetting)
+{
+	CCamera * pCamera = CCameraManager::Instance().GetCurrentCamera();
+	if (!pCamera)
+		return;
+
+	m_pyGraphic.SetPositionCamera(	c_rCameraSetting.v3CenterPosition.x,
+									c_rCameraSetting.v3CenterPosition.y,
+									c_rCameraSetting.v3CenterPosition.z,
+									c_rCameraSetting.fZoom,
+									c_rCameraSetting.fPitch,
+									c_rCameraSetting.fRotation);
+
+	if (0.0f != c_rCameraSetting.kCmrPos.m_fViewDir)
+		pCamera->MoveFront(c_rCameraSetting.kCmrPos.m_fViewDir);
+	if (0.0f != c_rCameraSetting.kCmrPos.m_fCrossDir)
+		pCamera->MoveAlongCross(c_rCameraSetting.kCmrPos.m_fCrossDir);
+	if (0.0f != c_rCameraSetting.kCmrPos.m_fUpDir)
+		pCamera->MoveVertical(c_rCameraSetting.kCmrPos.m_fUpDir);
+
+	m_kCmrPos.m_fUpDir = 0.0f;
+	m_kCmrPos.m_fViewDir = 0.0f;
+	m_kCmrPos.m_fCrossDir = 0.0f;
+	m_kCmrSpd.m_fUpDir = 0.0f;
+	m_kCmrSpd.m_fViewDir = 0.0f;
+	m_kCmrSpd.m_fCrossDir = 0.0f;
+	m_fZoomSpeed = 0.0f;
+	m_fPitchSpeed = 0.0f;
+	m_fRotationSpeed = 0.0f;
+}
+
+void CPythonApplication::GetCameraSetting(SCameraSetting * pCameraSetting)
+{
+	pCameraSetting->v3CenterPosition = m_v3CenterPosition;
+	pCameraSetting->kCmrPos = m_kCmrPos;
+
+	if (CCameraManager::Instance().GetCurrentCamera())
+		pCameraSetting->v3CenterPosition.z += CCameraManager::Instance().GetCurrentCamera()->GetTargetHeight();
+
+	float fHeight;
+	GetCamera(&pCameraSetting->fZoom, &pCameraSetting->fPitch, &pCameraSetting->fRotation, &fHeight);
+}
+
+void CPythonApplication::SaveCameraSetting(const char * c_szFileName)
+{
+	SCameraSetting CameraSetting;
+	GetCameraSetting(&CameraSetting);
+
+	FILE * File = fopen(c_szFileName, "w");
+	SetFileAttributes(c_szFileName, FILE_ATTRIBUTE_NORMAL);
+
+	PrintfTabs(File, 0, "CenterPos %f %f %f\n", CameraSetting.v3CenterPosition.x, CameraSetting.v3CenterPosition.y, CameraSetting.v3CenterPosition.z);
+	PrintfTabs(File, 0, "CameraSetting %f %f %f\n", CameraSetting.fZoom, CameraSetting.fPitch, CameraSetting.fRotation);
+	PrintfTabs(File, 0, "CmrPos %f %f %f\n", CameraSetting.kCmrPos.m_fUpDir, CameraSetting.kCmrPos.m_fViewDir, CameraSetting.kCmrPos.m_fCrossDir);
+	PrintfTabs(File, 0, "Line \"x;%d|y;%d|z;%d|distance;%d|pitch;%d|rot;%d|up;%d|view;%d|cross;%d\"\n",
+												int(CameraSetting.v3CenterPosition.x),
+												int(CameraSetting.v3CenterPosition.y),
+												int(CameraSetting.v3CenterPosition.z),
+												int(CameraSetting.fZoom),
+												int(CameraSetting.fPitch),
+												int(CameraSetting.fRotation),
+												int(CameraSetting.kCmrPos.m_fUpDir),
+												int(CameraSetting.kCmrPos.m_fViewDir),
+												int(CameraSetting.kCmrPos.m_fCrossDir));
+
+	fclose(File);
+}
+
+bool CPythonApplication::LoadCameraSetting(const char * c_szFileName)
+{
+	CTextFileLoader TextFileLoader;
+	if (!TextFileLoader.Load(c_szFileName))
+		return false;
+
+	TextFileLoader.SetTop();
+
+	D3DXVECTOR3 v3CenterPosition;
+	CTokenVector * pCameraSetting;
+	CTokenVector * pCmrPos;
+	if (TextFileLoader.GetTokenVector3("centerpos", &v3CenterPosition))
+	if (TextFileLoader.GetTokenVector("camerasetting", &pCameraSetting))
+	if (TextFileLoader.GetTokenVector("cmrpos", &pCmrPos))
+	if (3 == pCameraSetting->size())
+	if (3 == pCmrPos->size())
+	{
+		SCameraSetting CameraSetting;
+		CameraSetting.v3CenterPosition = v3CenterPosition;
+
+		CameraSetting.fZoom					= atof(pCameraSetting->at(0).c_str());
+		CameraSetting.fPitch				= atof(pCameraSetting->at(1).c_str());
+		CameraSetting.fRotation				= atof(pCameraSetting->at(2).c_str());
+
+		CameraSetting.kCmrPos.m_fUpDir		= atof(pCmrPos->at(0).c_str());
+		CameraSetting.kCmrPos.m_fViewDir	= atof(pCmrPos->at(1).c_str());
+		CameraSetting.kCmrPos.m_fCrossDir	= atof(pCmrPos->at(2).c_str());
+
+		SetEventCamera(CameraSetting);
+		return true;
+	}
+
+	return false;
+}

src/UserInterface/PythonApplicationCursor.cpp

@@ -0,0 +1,165 @@
+#include "StdAfx.h"
+#include "PythonApplication.h"
+#include "resource.h"
+
+bool CPythonApplication::CreateCursors()
+{
+	NANOBEGIN
+	m_bCursorVisible = TRUE;
+	m_bLiarCursorOn = false;
+
+	int ResourceID[CURSOR_COUNT] =
+	{
+		IDC_CURSOR_NORMAL,
+		IDC_CURSOR_ATTACK,
+		IDC_CURSOR_ATTACK,
+		IDC_CURSOR_TALK,
+		IDC_CURSOR_NO,
+		IDC_CURSOR_PICK,
+
+		IDC_CURSOR_DOOR,
+		IDC_CURSOR_CHAIR,
+		IDC_CURSOR_CHAIR,			// Magic
+		IDC_CURSOR_BUY,				// Buy
+		IDC_CURSOR_SELL,			// Sell
+
+		IDC_CURSOR_CAMERA_ROTATE,	// Camera Rotate
+		IDC_CURSOR_HSIZE,			// Horizontal Size
+		IDC_CURSOR_VSIZE,			// Vertical Size
+		IDC_CURSOR_HVSIZE,			// Horizontal & Vertical Size
+	};
+
+	m_CursorHandleMap.clear();
+	
+	for (int i = 0; i < CURSOR_COUNT; ++i)
+	{
+		HANDLE hCursor = LoadImage(ms_hInstance, MAKEINTRESOURCE(ResourceID[i]), IMAGE_CURSOR, 32, 32, LR_VGACOLOR);
+
+		if (NULL == hCursor)
+			return false;
+
+		m_CursorHandleMap.insert(TCursorHandleMap::value_type(i, hCursor));
+	}
+
+	NANOEND
+	return true;
+}
+
+void CPythonApplication::DestroyCursors()
+{
+	TCursorHandleMap::iterator itor;
+	for (itor = m_CursorHandleMap.begin(); itor != m_CursorHandleMap.end(); ++itor)
+	{
+		DestroyCursor((HCURSOR) itor->second);
+	}
+}
+
+void CPythonApplication::SetCursorVisible(BOOL bFlag, bool bLiarCursorOn)
+{
+	m_bCursorVisible = bFlag;
+	m_bLiarCursorOn = bLiarCursorOn;
+	
+	if (CURSOR_MODE_HARDWARE == m_iCursorMode)
+	{
+		int iShowNum;
+		if (FALSE == m_bCursorVisible)
+		{
+			do
+			{
+				iShowNum = ShowCursor(m_bCursorVisible);
+			} while(iShowNum >= 0);
+		}
+		else
+		{
+			do
+			{
+				iShowNum = ShowCursor(m_bCursorVisible);
+			} while(iShowNum < 0);
+		}
+	}
+}
+
+BOOL CPythonApplication::GetCursorVisible()
+{
+	return m_bCursorVisible;
+}
+
+bool CPythonApplication::GetLiarCursorOn()
+{
+	return m_bLiarCursorOn;
+}
+
+int CPythonApplication::GetCursorMode()
+{
+	return m_iCursorMode;
+}
+
+BOOL CPythonApplication::__IsContinuousChangeTypeCursor(int iCursorNum)
+{
+	switch (iCursorNum)
+	{
+		case CURSOR_SHAPE_NORMAL:
+		case CURSOR_SHAPE_ATTACK:
+		case CURSOR_SHAPE_TARGET:
+		case CURSOR_SHAPE_MAGIC:
+		case CURSOR_SHAPE_BUY:
+		case CURSOR_SHAPE_SELL:
+			return TRUE;
+			break;
+	}
+
+	return FALSE;
+}
+
+BOOL CPythonApplication::SetCursorNum(int iCursorNum)
+{
+	if (CURSOR_SHAPE_NORMAL == iCursorNum)
+	{
+		if (!__IsContinuousChangeTypeCursor(m_iCursorNum))
+		{
+			iCursorNum = m_iContinuousCursorNum;
+		}
+	}
+	else
+	{
+		if (__IsContinuousChangeTypeCursor(m_iCursorNum))		// <20><><EFBFBD><EFBFBD> Ŀ<><C4BF><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ŀ<><C4BF><EFBFBD>϶<EFBFBD><CFB6><EFBFBD>
+		{
+			m_iContinuousCursorNum = m_iCursorNum;			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ŀ<><C4BF><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+		}
+	}
+
+	if (CURSOR_MODE_HARDWARE == m_iCursorMode)
+	{
+		TCursorHandleMap::iterator itor = m_CursorHandleMap.find(iCursorNum);
+		if (m_CursorHandleMap.end() == itor)
+			return FALSE;
+
+		HCURSOR hCursor = (HCURSOR)itor->second;
+
+		SetCursor(hCursor);
+		m_hCurrentCursor = hCursor;
+	}
+
+	m_iCursorNum = iCursorNum;
+
+	PyCallClassMemberFunc(m_poMouseHandler, "ChangeCursor", Py_BuildValue("(i)", m_iCursorNum));
+
+	return TRUE;
+}
+
+void CPythonApplication::SetCursorMode(int iMode)
+{
+	switch (iMode)
+	{
+		case CURSOR_MODE_HARDWARE:
+			m_iCursorMode = CURSOR_MODE_HARDWARE;
+			ShowCursor(true);
+			break;
+
+		case CURSOR_MODE_SOFTWARE:
+			m_iCursorMode = CURSOR_MODE_SOFTWARE;
+			SetCursor(NULL);
+			ShowCursor(false);
+			break;
+	}
+}

src/UserInterface/PythonApplicationEvent.cpp

@@ -0,0 +1,231 @@
+#include "StdAfx.h"
+#include "PythonApplication.h"
+#include "../eterlib/Camera.h"
+
+void CPythonApplication::OnCameraUpdate()
+{
+	if ( m_pyBackground.IsMapReady() )
+	{
+		CCamera* pkCameraMgr = CCameraManager::Instance().GetCurrentCamera();
+		if (pkCameraMgr)
+			pkCameraMgr->Update();
+	}
+}
+
+void CPythonApplication::OnUIUpdate()
+{
+	UI::CWindowManager& rkUIMgr=UI::CWindowManager::Instance();
+	rkUIMgr.Update();
+}
+
+void CPythonApplication::OnUIRender()
+{
+	UI::CWindowManager& rkUIMgr=UI::CWindowManager::Instance();
+	rkUIMgr.Render();
+}
+
+void CPythonApplication::OnSizeChange(int width, int height)
+{	
+}
+
+void CPythonApplication::OnMouseMiddleButtonDown(int x, int y)
+{
+	CCameraManager& rkCmrMgr=CCameraManager::Instance();
+	CCamera* pkCmrCur=rkCmrMgr.GetCurrentCamera();
+	if (pkCmrCur)
+		pkCmrCur->BeginDrag(x, y);
+
+	if ( !m_pyBackground.IsMapReady() )
+		return;
+
+	SetCursorNum(CAMERA_ROTATE);
+	if ( CURSOR_MODE_HARDWARE == GetCursorMode())
+		SetCursorVisible(FALSE, true);
+}
+
+void CPythonApplication::OnMouseMiddleButtonUp(int x, int y)
+{
+	CCameraManager& rkCmrMgr=CCameraManager::Instance();
+	CCamera* pkCmrCur=rkCmrMgr.GetCurrentCamera();
+	if (pkCmrCur)
+		pkCmrCur->EndDrag();
+
+	if ( !m_pyBackground.IsMapReady() )
+		return;
+
+	SetCursorNum(NORMAL);
+	if ( CURSOR_MODE_HARDWARE == GetCursorMode())
+		SetCursorVisible(TRUE);
+}
+
+void CPythonApplication::OnMouseWheel(int nLen)
+{
+	CCameraManager& rkCmrMgr=CCameraManager::Instance();
+	CCamera* pkCmrCur=rkCmrMgr.GetCurrentCamera();
+	if (pkCmrCur)
+		pkCmrCur->Wheel(nLen);
+}
+
+
+void CPythonApplication::OnMouseMove(int x, int y)
+{
+	CCameraManager& rkCmrMgr=CCameraManager::Instance();
+	CCamera* pkCmrCur=rkCmrMgr.GetCurrentCamera();
+	
+	POINT Point;
+	if (pkCmrCur)
+	{
+		if ( CPythonBackground::Instance().IsMapReady() && pkCmrCur->Drag(x, y, &Point) )
+		{
+			x = Point.x;
+			y = Point.y;
+			ClientToScreen(m_hWnd, &Point);
+
+			// 2004.07.26.myevan.<2E><>ö<EFBFBD><C3B6>HackShield<6C><64> <20>浹
+			SetCursorPos(Point.x, Point.y);
+
+		}
+	}
+	
+	RECT rcWnd;
+	GetClientRect(&rcWnd);
+	
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.SetResolution(rcWnd.right-rcWnd.left, rcWnd.bottom-rcWnd.top);
+
+	rkWndMgr.RunMouseMove(x, y);
+}
+
+void CPythonApplication::OnMouseLeftButtonDown(int x, int y)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunMouseLeftButtonDown(x, y);
+}
+
+void CPythonApplication::OnMouseLeftButtonUp(int x, int y)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunMouseLeftButtonUp(x, y);
+}
+
+void CPythonApplication::OnMouseLeftButtonDoubleClick(int x, int y)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunMouseLeftButtonDown(x, y);
+	rkWndMgr.RunMouseLeftButtonDoubleClick(x, y);
+}
+
+void CPythonApplication::OnMouseRightButtonDown(int x, int y)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunMouseRightButtonDown(x, y);
+}
+
+void CPythonApplication::OnMouseRightButtonUp(int x, int y)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunMouseRightButtonUp(x, y);
+}
+
+void CPythonApplication::OnKeyDown(int iIndex)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+
+	if (DIK_ESCAPE == iIndex)
+	{
+		rkWndMgr.RunPressEscapeKey();
+	}
+
+	rkWndMgr.RunKeyDown(iIndex);
+}
+
+void CPythonApplication::OnKeyUp(int iIndex)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunKeyUp(iIndex);
+}
+
+void CPythonApplication::RunIMEUpdate()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunIMEUpdate();
+}
+void CPythonApplication::RunIMETabEvent()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunIMETabEvent();
+}
+void CPythonApplication::RunIMEReturnEvent()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunIMEReturnEvent();
+}
+void CPythonApplication::OnIMEKeyDown(int iIndex)
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunIMEKeyDown(iIndex);
+}
+/////////////////////////////
+
+void CPythonApplication::RunIMEChangeCodePage()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunChangeCodePage();
+}
+void CPythonApplication::RunIMEOpenCandidateListEvent()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunOpenCandidate();
+}
+void CPythonApplication::RunIMECloseCandidateListEvent()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunCloseCandidate();
+}
+void CPythonApplication::RunIMEOpenReadingWndEvent()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunOpenReading();
+}
+void CPythonApplication::RunIMECloseReadingWndEvent()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunCloseReading();
+}
+
+/////////////////////////////
+void CPythonApplication::RunPressExitKey()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	rkWndMgr.RunPressExitKey();
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void CPythonApplication::OnMouseUpdate()
+{
+#ifdef _DEBUG
+	if (!m_poMouseHandler)
+	{
+		//assert(!" CPythonApplication::OnMouseUpdate - Mouse handler has not set!");
+		return;
+	}
+#endif _DEBUG
+
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+	long lx, ly;
+	rkWndMgr.GetMousePosition(lx, ly);
+	PyCallClassMemberFunc(m_poMouseHandler, "Update", Py_BuildValue("(ii)", lx, ly));
+}
+
+void CPythonApplication::OnMouseRender()
+{
+#ifdef _DEBUG
+	if (!m_poMouseHandler)
+	{
+		//assert(!" CPythonApplication::OnMouseRender - Mouse handler has not set!");
+		return;
+	}
+#endif _DEBUG
+
+	PyCallClassMemberFunc(m_poMouseHandler, "Render", Py_BuildValue("()"));
+}

src/UserInterface/PythonApplicationLogo.cpp

@@ -0,0 +1,242 @@
+#include "StdAfx.h"
+#include "PythonApplication.h"
+
+static bool bInitializedLogo = false;
+
+int CPythonApplication::OnLogoOpen(char* szName)
+{
+	m_pLogoTex = NULL;
+	m_pLogoTex = new CGraphicImageTexture();
+	m_pCaptureBuffer = NULL;
+	m_lBufferSize = 0;
+	m_bLogoError = true;
+	m_bLogoPlay = false;
+
+	m_pGraphBuilder = NULL;
+	m_pFilterSG = NULL;
+	m_pSampleGrabber = NULL;
+	m_pMediaCtrl = NULL;
+	m_pMediaEvent = NULL;
+	m_pVideoWnd = NULL;
+	m_pBasicVideo = NULL;
+
+	m_nLeft = 0; m_nRight = 0; m_nTop = 0; m_nBottom = 0;
+
+
+	// ó<><C3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1/1 ũ<><C5A9><EFBFBD><EFBFBD> <20>ؽ<EFBFBD><D8BD>ĸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>صд<D8B5>.
+	if(!m_pLogoTex->Create(1, 1, D3DFMT_A8R8G8B8)) { return 0; }
+
+	// Set GraphBuilder / SampleGrabber
+	if(FAILED(CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (VOID**)(&m_pGraphBuilder)))) { return 0; }
+	if(FAILED(CoCreateInstance(CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (VOID**)&m_pFilterSG))) { return 0; }
+	if(FAILED(m_pGraphBuilder->AddFilter(m_pFilterSG, L"SampleGrabber"))) { return 0; }
+
+	// Create Media Type
+	AM_MEDIA_TYPE mediaType;
+	ZeroMemory(&mediaType, sizeof(mediaType));
+	mediaType.majortype = MEDIATYPE_Video;
+	mediaType.subtype = MEDIASUBTYPE_RGB32;
+	if(FAILED(m_pFilterSG->QueryInterface(IID_ISampleGrabber, (VOID**) &m_pSampleGrabber))) { return 0; }
+	if(FAILED(m_pSampleGrabber->SetMediaType( &mediaType))) { return 0; }
+
+	// Render File
+	WCHAR wFileName[ MAX_PATH ];
+	MultiByteToWideChar(CP_ACP, 0, szName, -1, wFileName, MAX_PATH);
+	if(FAILED(m_pGraphBuilder->RenderFile(wFileName, NULL))) { return 0; }
+
+	IBaseFilter* pSrc;
+	m_pGraphBuilder->AddSourceFilter(wFileName, L"Source", &pSrc);
+
+	// Media Control
+	if(FAILED(m_pGraphBuilder->QueryInterface(IID_IMediaControl, (VOID**) &m_pMediaCtrl))) { return 0; }
+
+	// Video Window
+	if(FAILED(m_pGraphBuilder->QueryInterface(IID_IVideoWindow, (VOID**) &m_pVideoWnd))) { return 0; }
+	if(FAILED(m_pVideoWnd->put_MessageDrain((OAHWND)this->m_hWnd))) { return 0; }
+
+	// Basic Video
+	if(FAILED(m_pGraphBuilder->QueryInterface(IID_IBasicVideo, (VOID**)&m_pBasicVideo))) { return 0; }
+
+	// Media Event
+	if(FAILED(m_pGraphBuilder->QueryInterface(IID_IMediaEventEx, (VOID**) &m_pMediaEvent))) { return 0; }
+
+	// Window <20>Ⱥ<EFBFBD><C8BA>̰<EFBFBD>
+	m_pVideoWnd->SetWindowPosition( 3000, 3000, 0, 0 );
+	m_pVideoWnd->put_Visible(0);
+	m_pSampleGrabber->SetBufferSamples(TRUE);
+
+	m_pVideoWnd->put_Owner((OAHWND)m_hWnd);
+	m_pMediaEvent->SetNotifyWindow((OAHWND)m_hWnd, WM_APP + 1, 0);
+
+	bInitializedLogo = true;
+	
+	return 1;
+}
+
+int CPythonApplication::OnLogoUpdate()
+{
+	//OSVERSIONINFO osvi;
+	//ZeroMemory(&osvi, sizeof(osvi));
+	//osvi.dwOSVersionInfoSize = sizeof(osvi);
+	//GetVersionEx(&osvi);
+
+	//// windows xp <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> logo skip.
+	////	m_pSampleGrabber->GetCurrentBuffer(&m_lBufferSize,  (LONG*)m_pCaptureBuffer) fail <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+	//if (osvi.dwMajorVersion <= 5)
+	//{
+	//	return 0;
+	//}
+
+	if(m_pGraphBuilder == NULL || m_pFilterSG == NULL || m_pSampleGrabber == NULL || m_pMediaCtrl == NULL || m_pMediaEvent == NULL || m_pVideoWnd == NULL || false == bInitializedLogo)
+	{
+		return 0;
+	}
+
+	BYTE* pBuffer = m_pCaptureBuffer; LONG lBufferSize = m_lBufferSize;
+
+	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ȉ<EFBFBD><C889><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+	if(!m_bLogoPlay) { m_pMediaCtrl->Run(); m_bLogoPlay = true; }
+
+	// <20>о<EFBFBD><D0BE><EFBFBD> <20><><EFBFBD>۰<EFBFBD> 0<>ΰ<EFBFBD><CEB0><EFBFBD> <20><><EFBFBD>۸<EFBFBD> <20><><EFBFBD>Ҵ<EFBFBD>.
+	if( lBufferSize == 0  ) {
+		m_pSampleGrabber->GetCurrentBuffer(&m_lBufferSize, NULL);
+
+		SAFE_DELETE_ARRAY(m_pCaptureBuffer);
+		m_pCaptureBuffer = new BYTE[ m_lBufferSize ];
+		pBuffer = m_pCaptureBuffer;
+		lBufferSize = m_lBufferSize;
+	}
+	
+	// <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5>߿<EFBFBD> Update<74>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD>⿡ <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><><EFBFBD>찡 <20><><EFBFBD><EFBFBD>.
+	// <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD><CFB4><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴϹǷ<CFB9>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ߴ<EFBFBD><DFB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
+	if(FAILED(m_pSampleGrabber->GetCurrentBuffer(&m_lBufferSize,  (LONG*)m_pCaptureBuffer)))
+	{
+		m_bLogoError = true;
+
+		LPDIRECT3DTEXTURE8 tex = m_pLogoTex->GetD3DTexture();
+		D3DLOCKED_RECT rt;
+		ZeroMemory(&rt, sizeof(rt));
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20>ؽ<EFBFBD><D8BD>ĸ<EFBFBD> <20><><EFBFBD>İ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+		tex->LockRect(0, &rt, 0, 0);
+		BYTE* destb = static_cast<byte*>(rt.pBits);
+		for(int a = 0; a < 4; a+= 4)
+		{
+			BYTE* dest = &destb[a];
+			dest[0] = 0; dest[1] = 0; dest[2] = 0; dest[3] = 0xff;
+		}
+		tex->UnlockRect(0);
+
+		return 1;
+	}
+
+	m_bLogoError = false;
+
+	long lWidth, lHeight;
+	m_pBasicVideo->GetVideoSize(&lWidth, &lHeight);
+	
+	if(lWidth >= lHeight)
+	{
+		m_nLeft = 0; m_nRight = this->GetWidth();
+		m_nTop = (this->GetHeight() >> 1) - ((this->GetWidth() * lHeight / lWidth) >> 1);
+		m_nBottom = (this->GetHeight() >> 1) + ((this->GetWidth() * lHeight / lWidth) >> 1);
+	}
+	else
+	{
+		m_nTop = 0; m_nBottom = this->GetHeight();
+		m_nLeft = (this->GetWidth() >> 1) - ((this->GetHeight() * lWidth / lHeight) >> 1);
+		m_nRight = (this->GetWidth() >> 1) - ((this->GetHeight() * lWidth / lHeight) >> 1);
+	}
+
+
+
+	// ũ<>Ⱑ 1, <20><> <20>ؽ<EFBFBD><D8BD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>غ<EFBFBD> <20>ȵȰ<C8B5><C8B0><EFBFBD> <20>ٽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+	if(m_pLogoTex->GetWidth() == 1)
+	{
+		m_pLogoTex->Destroy(); m_pLogoTex->Create(lWidth, lHeight, D3DFMT_A8R8G8B8);
+		
+	}
+
+	// <20>غ<EFBFBD><D8BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ۿ<EFBFBD><DBBF><EFBFBD> <20>ؽ<EFBFBD><D8BD>ķ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؿ´<D8BF>.
+	LPDIRECT3DTEXTURE8 tex = m_pLogoTex->GetD3DTexture();
+	D3DLOCKED_RECT rt;
+	ZeroMemory(&rt, sizeof(rt));
+
+	tex->LockRect(0, &rt, 0, 0);
+	BYTE* destb = static_cast<byte*>(rt.pBits);
+	for(int a = 0; a < lBufferSize; a+= 4)
+	{
+		BYTE* src = &m_pCaptureBuffer[a]; BYTE* dest = &destb[a];
+		dest[0] = src[0]; dest[1] = src[1]; dest[2] = src[2]; dest[3] = 0xff;
+	}
+	tex->UnlockRect(0);
+
+	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> üũ (<28><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD>)
+	long evCode, param1, param2;
+	while(SUCCEEDED(m_pMediaEvent->GetEvent(&evCode, &param1, &param2, 0)))
+	{
+		switch(evCode)
+		{
+		case EC_COMPLETE:
+			return 0;
+		case EC_USERABORT:
+			return 0;
+		case EC_ERRORABORT:
+			return 0;
+		}
+
+		m_pMediaEvent->FreeEventParams(evCode, param1, param2);
+	}
+
+	if(GetAsyncKeyState(VK_ESCAPE) & 0x8000) { return 0; }
+
+	return 1;
+}
+
+void CPythonApplication::OnLogoRender()
+{
+	if(!m_pLogoTex->IsEmpty() && !m_bLogoError && true == bInitializedLogo)
+	{
+		STATEMANAGER.SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
+		STATEMANAGER.SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
+		m_pLogoTex->SetTextureStage(0);
+		CPythonGraphic::instance().RenderTextureBox(m_nLeft, m_nTop, m_nRight, m_nBottom, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f);
+	}
+}
+
+void CPythonApplication::OnLogoClose()
+{
+	// NOTE: LOGO <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20><> <20>ҷ<EFBFBD><D2B7><EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> OnLogoClose <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9><EFBFBD>ð<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+	if (false == bInitializedLogo)
+		return;
+
+	if(m_pCaptureBuffer != NULL)
+	{
+		delete[] m_pCaptureBuffer;
+		m_pCaptureBuffer = NULL;
+	}
+	if(m_pLogoTex != NULL)
+	{
+		m_pLogoTex->Destroy();
+		delete m_pLogoTex;
+		m_pLogoTex = NULL;
+	}
+
+	if(m_pMediaEvent != NULL)
+	{
+		m_pMediaEvent->SetNotifyWindow(NULL, 0, 0);
+		m_pMediaEvent->Release();
+		m_pMediaEvent = NULL;
+	}
+	if(m_pBasicVideo != NULL) m_pBasicVideo->Release(); m_pBasicVideo = NULL;
+	if(m_pVideoWnd != NULL) m_pVideoWnd->Release(); m_pVideoWnd = NULL;
+	if(m_pMediaCtrl != NULL) m_pMediaCtrl->Release(); m_pMediaCtrl = NULL;
+	if(m_pSampleGrabber != NULL) m_pSampleGrabber->Release(); m_pSampleGrabber = NULL;
+	if(m_pFilterSG != NULL) m_pFilterSG->Release(); m_pFilterSG = NULL;
+	if(m_pGraphBuilder != NULL) m_pGraphBuilder->Release(); m_pGraphBuilder = NULL;
+
+	STATEMANAGER.SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_POINT);
+	STATEMANAGER.SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_POINT);
+
+	
+}

src/UserInterface/PythonApplicationProcedure.cpp

@@ -0,0 +1,281 @@
+#include "StdAfx.h"
+#include "PythonApplication.h"
+#include "../eterlib/Camera.h"
+#include "../CWebBrowser/CWebBrowser.h"
+
+#include <winuser.h>
+
+static int gs_nMouseCaptureRef = 0;
+
+void CPythonApplication::SafeSetCapture()
+{
+	SetCapture(m_hWnd);
+	gs_nMouseCaptureRef++;
+}
+
+void CPythonApplication::SafeReleaseCapture()
+{
+	gs_nMouseCaptureRef--;
+	if (gs_nMouseCaptureRef==0)
+		ReleaseCapture();
+}
+
+void CPythonApplication::__SetFullScreenWindow(HWND hWnd, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
+{
+	DEVMODE DevMode;
+	DevMode.dmSize = sizeof(DevMode);
+	DevMode.dmBitsPerPel = dwBPP;
+	DevMode.dmPelsWidth = dwWidth;
+	DevMode.dmPelsHeight = dwHeight;
+	DevMode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
+
+	LONG Error = ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN);
+	if(Error == DISP_CHANGE_RESTART)
+	{
+		ChangeDisplaySettings(0,0);
+	}
+}
+
+void CPythonApplication::__MinimizeFullScreenWindow(HWND hWnd, DWORD dwWidth, DWORD dwHeight)
+{
+	ChangeDisplaySettings(0, 0);
+	SetWindowPos(hWnd, 0, 0, 0,
+				 dwWidth,
+				 dwHeight,
+				 SWP_SHOWWINDOW);
+	ShowWindow(hWnd, SW_MINIMIZE);
+}
+
+LRESULT CPythonApplication::WindowProcedure(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
+{
+	const int c_DoubleClickTime = 300;
+	const int c_DoubleClickBox = 5;
+	static int s_xDownPosition = 0;
+	static int s_yDownPosition = 0;	
+
+	switch (uiMsg)
+	{
+		case WM_ACTIVATEAPP:
+			{
+				m_isActivateWnd = (wParam == WA_ACTIVE) || (wParam == WA_CLICKACTIVE);
+
+				if (m_isActivateWnd)
+				{
+					m_SoundManager.RestoreVolume();
+
+					//////////////////
+
+					if (m_isWindowFullScreenEnable)
+					{
+						__SetFullScreenWindow(hWnd, m_dwWidth, m_dwHeight, m_pySystem.GetBPP());
+					}
+				}
+				else
+				{
+					m_SoundManager.SaveVolume();
+
+					//////////////////
+
+					if (m_isWindowFullScreenEnable)
+					{
+						__MinimizeFullScreenWindow(hWnd, m_dwWidth, m_dwHeight);
+					}
+				}
+			}
+			break;
+
+		case WM_INPUTLANGCHANGE:
+			return CPythonIME::Instance().WMInputLanguage(hWnd, uiMsg, wParam, lParam);
+			break;
+
+		case WM_IME_STARTCOMPOSITION:
+			return CPythonIME::Instance().WMStartComposition(hWnd, uiMsg, wParam, lParam);
+			break;
+
+		case WM_IME_COMPOSITION:
+			return CPythonIME::Instance().WMComposition(hWnd, uiMsg, wParam, lParam);
+			break;
+
+		case WM_IME_ENDCOMPOSITION:
+			return CPythonIME::Instance().WMEndComposition(hWnd, uiMsg, wParam, lParam);
+			break;
+
+		case WM_IME_NOTIFY:
+			return CPythonIME::Instance().WMNotify(hWnd, uiMsg, wParam, lParam);
+			break;
+
+		case WM_IME_SETCONTEXT:
+			lParam &= ~(ISC_SHOWUICOMPOSITIONWINDOW | ISC_SHOWUIALLCANDIDATEWINDOW);
+			break;
+
+		case WM_CHAR:
+			return CPythonIME::Instance().WMChar(hWnd, uiMsg, wParam, lParam);
+			break;
+
+		case WM_KEYDOWN:
+			OnIMEKeyDown(LOWORD(wParam));
+			break;
+
+		case WM_LBUTTONDOWN:
+			SafeSetCapture();
+
+			if (ELTimer_GetMSec() - m_dwLButtonDownTime < c_DoubleClickTime &&
+				abs(LOWORD(lParam) - s_xDownPosition) < c_DoubleClickBox &&
+				abs(HIWORD(lParam) - s_yDownPosition) < c_DoubleClickBox)
+			{
+				m_dwLButtonDownTime = 0;
+
+				OnMouseLeftButtonDoubleClick(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			}
+			else
+			{
+				m_dwLButtonDownTime = ELTimer_GetMSec();
+
+				OnMouseLeftButtonDown(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			}
+
+			s_xDownPosition = LOWORD(lParam);
+			s_yDownPosition = HIWORD(lParam);
+			return 0;
+
+		case WM_LBUTTONUP:
+			m_dwLButtonUpTime = ELTimer_GetMSec();
+
+			if (hWnd == GetCapture())
+			{
+				SafeReleaseCapture();
+				OnMouseLeftButtonUp(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			}
+			return 0;
+
+		case WM_MBUTTONDOWN:
+			SafeSetCapture();
+
+			UI::CWindowManager::Instance().RunMouseMiddleButtonDown(short(LOWORD(lParam)), short(HIWORD(lParam)));
+//			OnMouseMiddleButtonDown(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			break;
+
+		case WM_MBUTTONUP:
+			if (GetCapture() == hWnd)
+			{
+				SafeReleaseCapture();
+
+				UI::CWindowManager::Instance().RunMouseMiddleButtonUp(short(LOWORD(lParam)), short(HIWORD(lParam)));
+//				OnMouseMiddleButtonUp(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			}
+			break;
+
+		case WM_RBUTTONDOWN:
+			SafeSetCapture();
+			OnMouseRightButtonDown(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			return 0;
+
+		case WM_RBUTTONUP:
+			if (hWnd == GetCapture()) 
+			{
+				SafeReleaseCapture();
+
+				OnMouseRightButtonUp(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			}
+			return 0;
+
+		case 0x20a:
+			if (WebBrowser_IsVisible())
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD><CFB6><EFBFBD> <20><> <20>۵<EFBFBD> <20>ȵǵ<C8B5><C7B5><EFBFBD> ó<><C3B3>
+			}
+			else
+			{
+				OnMouseWheel(short(HIWORD(wParam)));
+			}
+			break;
+
+		case WM_SIZE:
+			switch (wParam)
+			{
+				case SIZE_RESTORED:
+				case SIZE_MAXIMIZED:
+					{
+						RECT rcWnd; 
+						GetClientRect(&rcWnd); 
+				
+						UINT uWidth=rcWnd.right-rcWnd.left; 
+						UINT uHeight=rcWnd.bottom-rcWnd.left; 
+						m_grpDevice.ResizeBackBuffer(uWidth, uHeight);				
+					}
+					break;
+			}
+
+			if (wParam==SIZE_MINIMIZED)
+				m_isMinimizedWnd=true;
+			else
+				m_isMinimizedWnd=false;
+
+			OnSizeChange(short(LOWORD(lParam)), short(HIWORD(lParam)));
+
+			break;
+
+		case WM_EXITSIZEMOVE:    
+			{
+				RECT rcWnd; 
+				GetClientRect(&rcWnd); 
+				
+				UINT uWidth=rcWnd.right-rcWnd.left; 
+				UINT uHeight=rcWnd.bottom-rcWnd.left; 
+				m_grpDevice.ResizeBackBuffer(uWidth, uHeight);				
+				OnSizeChange(short(LOWORD(lParam)), short(HIWORD(lParam)));
+			}
+			break; 
+
+		case WM_SYSKEYDOWN:
+			switch (LOWORD(wParam))
+			{
+				case VK_F10:
+					break;
+			}
+			break;
+
+		case WM_SYSKEYUP:
+			switch(LOWORD(wParam))
+			{
+				case 18:
+					return FALSE;
+					break;
+				case VK_F10:
+					break;
+			}
+			break;
+
+		case WM_SETCURSOR:
+			if (IsActive())
+			{
+				if (m_bCursorVisible && CURSOR_MODE_HARDWARE == m_iCursorMode)
+				{
+					SetCursor((HCURSOR) m_hCurrentCursor);
+					return 0;
+				}
+				else
+				{
+					SetCursor(NULL);
+					return 0;
+				}
+			}
+			break;
+
+		case WM_CLOSE:
+#ifdef _DEBUG
+			PostQuitMessage(0);
+#else	
+			RunPressExitKey();
+#endif
+			return 0;
+
+		case WM_DESTROY:
+			return 0;
+		default:
+			//Tracenf("%x msg %x", timeGetTime(), uiMsg);
+			break;
+	}	
+
+	return CMSApplication::WindowProcedure(hWnd, uiMsg, wParam, lParam);
+}

src/UserInterface/PythonApplicationWebPage.cpp

@@ -0,0 +1,46 @@
+#include "StdAfx.h"
+#include "PythonApplication.h"
+#include "../CWebBrowser/CWebBrowser.h"
+
+bool CPythonApplication::IsWebPageMode()
+{
+	return WebBrowser_IsVisible() ? true : false;
+}
+
+void CPythonApplication::ShowWebPage(const char* c_szURL, const RECT& c_rcWebPage)
+{
+	if (WebBrowser_IsVisible())
+		return;
+
+	m_grpDevice.EnableWebBrowserMode(c_rcWebPage);
+	if (!WebBrowser_Show(GetWindowHandle(), c_szURL, &c_rcWebPage))
+	{
+		TraceError("CREATE_WEBBROWSER_ERROR:%d", GetLastError());
+	}
+
+	SetCursorMode(CURSOR_MODE_HARDWARE);
+}
+
+void CPythonApplication::MoveWebPage(const RECT& c_rcWebPage)
+{
+	if (WebBrowser_IsVisible())
+	{
+		m_grpDevice.MoveWebBrowserRect(c_rcWebPage);
+		WebBrowser_Move(&c_rcWebPage);
+	}
+}
+
+void CPythonApplication::HideWebPage()
+{
+	if (WebBrowser_IsVisible())
+	{
+		WebBrowser_Hide();
+
+		m_grpDevice.DisableWebBrowserMode();	
+
+		if (m_pySystem.IsSoftwareCursor())
+			SetCursorMode(CURSOR_MODE_SOFTWARE);
+		else
+			SetCursorMode(CURSOR_MODE_HARDWARE);
+	}
+}

src/UserInterface/PythonBackground.cpp

@@ -0,0 +1,921 @@
+// PythonBackground.cpp: implementation of the CPythonBackground class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "../eterlib/CullingManager.h"
+#include "../eterlib/Camera.h"
+#include "../eterPack/EterPackManager.h"
+#include "../gamelib/MapOutDoor.h"
+#include "../gamelib/PropertyLoader.h"
+
+#include "PythonBackground.h"
+#include "PythonCharacterManager.h"
+#include "PythonNetworkStream.h"
+#include "PythonMiniMap.h"
+#include "PythonSystem.h"
+
+std::string g_strEffectName = "d:/ymir work/effect/etc/direction/direction_land.mse";
+
+DWORD CPythonBackground::GetRenderShadowTime()
+{
+	return m_dwRenderShadowTime;
+}
+
+bool CPythonBackground::SetVisiblePart(int eMapOutDoorPart, bool isVisible)
+{
+	if (!m_pkMap)
+		return false;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.SetVisiblePart(eMapOutDoorPart, isVisible);
+	return true;
+}
+
+void CPythonBackground::EnableTerrainOnlyForHeight()
+{
+	if (!m_pkMap)
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.EnableTerrainOnlyForHeight(TRUE);
+}
+
+bool CPythonBackground::SetSplatLimit(int iSplatNum)
+{
+	if (!m_pkMap)
+		return false;
+
+	CMapOutdoor& rkMap = GetMapOutdoorRef();
+	rkMap.SetSplatLimit(iSplatNum);
+	return true;
+}
+
+void CPythonBackground::CreateCharacterShadowTexture()
+{
+	if (!m_pkMap)
+		return;
+
+	CMapOutdoor& rkMap = GetMapOutdoorRef();
+	rkMap.CreateCharacterShadowTexture();
+}
+
+void CPythonBackground::ReleaseCharacterShadowTexture()
+{
+	if (!m_pkMap)
+		return;
+
+	CMapOutdoor& rkMap = GetMapOutdoorRef();
+	rkMap.ReleaseCharacterShadowTexture();
+}
+
+void CPythonBackground::RefreshShadowLevel()
+{
+	SetShadowLevel(CPythonSystem::Instance().GetShadowLevel());
+}
+
+bool CPythonBackground::SetShadowLevel(int eLevel)
+{
+	if (!m_pkMap)
+		return false;
+
+	if (m_eShadowLevel == eLevel)
+		return true;
+
+	CMapOutdoor& rkMap = GetMapOutdoorRef();
+
+	m_eShadowLevel = eLevel;
+
+	switch (m_eShadowLevel)
+	{
+		case SHADOW_NONE:
+			rkMap.SetDrawShadow(false);
+			rkMap.SetShadowTextureSize(512);
+			break;
+
+		case SHADOW_GROUND:
+			rkMap.SetDrawShadow(true);
+			rkMap.SetDrawCharacterShadow(false);
+			rkMap.SetShadowTextureSize(512);
+			break;
+
+		case SHADOW_GROUND_AND_SOLO:
+			rkMap.SetDrawShadow(true);
+			rkMap.SetDrawCharacterShadow(true);
+			rkMap.SetShadowTextureSize(512);
+			break;
+
+		case SHADOW_ALL:
+			rkMap.SetDrawShadow(true);	
+			rkMap.SetDrawCharacterShadow(true);
+			rkMap.SetShadowTextureSize(512);
+			break;
+
+		case SHADOW_ALL_HIGH:
+			rkMap.SetDrawShadow(true);	
+			rkMap.SetDrawCharacterShadow(true);
+			rkMap.SetShadowTextureSize(1024);
+			break;
+
+		case SHADOW_ALL_MAX:
+			rkMap.SetDrawShadow(true);	
+			rkMap.SetDrawCharacterShadow(true);
+			rkMap.SetShadowTextureSize(2048);
+			break;
+	}
+
+	return true;
+}
+
+void CPythonBackground::SelectViewDistanceNum(int eNum)
+{
+	if (!m_pkMap)
+		return;
+	
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+
+	if (!mc_pcurEnvironmentData)
+	{
+		TraceError("CPythonBackground::SelectViewDistanceNum(int eNum=%d) mc_pcurEnvironmentData is NULL", eNum);
+		return;
+	}
+
+	m_eViewDistanceNum = eNum;
+
+	TEnvironmentData * env = ((TEnvironmentData *) mc_pcurEnvironmentData);
+
+	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>⸦ <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD> reserve<76><65> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20>ʴ´<CAB4>.
+	if (env->bReserve)
+	{
+		env->m_fFogNearDistance = m_ViewDistanceSet[m_eViewDistanceNum].m_fFogStart;
+		env->m_fFogFarDistance = m_ViewDistanceSet[m_eViewDistanceNum].m_fFogEnd;
+		env->v3SkyBoxScale = m_ViewDistanceSet[m_eViewDistanceNum].m_v3SkyBoxScale;
+		rkMap.SetEnvironmentSkyBox();
+	}
+}
+
+void CPythonBackground::SetViewDistanceSet(int eNum, float fFarClip)
+{
+	if (!m_pkMap)
+		return;
+	
+	m_ViewDistanceSet[eNum].m_fFogStart		= fFarClip * 0.5f;//0.3333333f;
+	m_ViewDistanceSet[eNum].m_fFogEnd		= fFarClip * 0.7f;//0.6666667f;
+	
+	float fSkyBoxScale						= fFarClip * 0.6f;//0.5773502f;
+	m_ViewDistanceSet[eNum].m_v3SkyBoxScale	= D3DXVECTOR3(fSkyBoxScale, fSkyBoxScale, fSkyBoxScale);
+	m_ViewDistanceSet[eNum].m_fFarClip		= fFarClip;
+
+	if (eNum == m_eViewDistanceNum)
+		SelectViewDistanceNum(eNum);
+}
+
+float CPythonBackground::GetFarClip()
+{
+	if (!m_pkMap)
+		return 50000.0f;
+
+	if (m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip==0.0f)
+	{
+		TraceError("CPythonBackground::GetFarClip m_eViewDistanceNum=%d", m_eViewDistanceNum);
+		m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip=25600.0f;
+	}
+
+	return m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip;
+}
+
+void CPythonBackground::GetDistanceSetInfo(int * peNum, float * pfStart, float * pfEnd, float * pfFarClip)
+{
+	if (!m_pkMap)
+	{
+		*peNum = 4;
+		*pfStart= 10000.0f;
+		*pfEnd= 15000.0f;
+		*pfFarClip = 50000.0f;
+		return;
+	}
+	*peNum = m_eViewDistanceNum;
+	*pfStart = m_ViewDistanceSet[m_eViewDistanceNum].m_fFogStart;
+	*pfEnd= m_ViewDistanceSet[m_eViewDistanceNum].m_fFogEnd;
+	*pfFarClip = m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CPythonBackground::CPythonBackground()
+{
+	m_dwRenderShadowTime=0;
+	m_eViewDistanceNum=0;
+	m_eViewDistanceNum=0;
+	m_eViewDistanceNum=0;
+	m_eShadowLevel=SHADOW_NONE;
+	m_dwBaseX=0;
+	m_dwBaseY=0;
+	m_strMapName="";
+	m_iDayMode = DAY_MODE_LIGHT;
+	m_iXMasTreeGrade = 0;
+	m_bVisibleGuildArea = FALSE;
+
+	SetViewDistanceSet(4, 25600.0f);
+	SetViewDistanceSet(3, 25600.0f);
+	SetViewDistanceSet(2, 25600.0f);
+	SetViewDistanceSet(1, 25600.0f);
+	SetViewDistanceSet(0, 25600.0f);
+	Initialize();
+}
+
+CPythonBackground::~CPythonBackground()
+{
+	Tracen("CPythonBackground Clear");
+}
+
+void CPythonBackground::Initialize()
+{
+	std::string stAtlasInfoFileName (LocaleService_GetLocalePath());
+	stAtlasInfoFileName += "/AtlasInfo.txt";
+	SetAtlasInfoFileName(stAtlasInfoFileName.c_str());
+	CMapManager::Initialize();
+}
+
+void CPythonBackground::__CreateProperty()
+{
+	if (CEterPackManager::SEARCH_FILE_FIRST == CEterPackManager::Instance().GetSearchMode() &&
+		_access("property", 0) == 0)
+	{
+		m_PropertyManager.Initialize(NULL);
+
+		CPropertyLoader PropertyLoader;
+		PropertyLoader.SetPropertyManager(&m_PropertyManager);
+		PropertyLoader.Create("*.*", "Property");
+	}
+	else
+	{
+		m_PropertyManager.Initialize("pack/property");
+	}
+}
+
+//////////////////////////////////////////////////////////////////////
+// Normal Functions
+//////////////////////////////////////////////////////////////////////
+
+bool CPythonBackground::GetPickingPoint(D3DXVECTOR3 * v3IntersectPt)
+{
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	return rkMap.GetPickingPoint(v3IntersectPt);
+}
+
+bool CPythonBackground::GetPickingPointWithRay(const CRay & rRay, D3DXVECTOR3 * v3IntersectPt)
+{
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	return rkMap.GetPickingPointWithRay(rRay, v3IntersectPt);
+}
+
+bool CPythonBackground::GetPickingPointWithRayOnlyTerrain(const CRay & rRay, D3DXVECTOR3 * v3IntersectPt)
+{
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	return rkMap.GetPickingPointWithRayOnlyTerrain(rRay, v3IntersectPt);
+}
+
+BOOL CPythonBackground::GetLightDirection(D3DXVECTOR3 & rv3LightDirection)
+{
+	if (!mc_pcurEnvironmentData)
+		return FALSE;
+
+	rv3LightDirection.x = mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND].Direction.x;
+	rv3LightDirection.y = mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND].Direction.y;
+	rv3LightDirection.z = mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND].Direction.z;
+	return TRUE;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+void CPythonBackground::Destroy()
+{
+	CMapManager::Destroy();
+	m_SnowEnvironment.Destroy();
+	m_bVisibleGuildArea = FALSE;
+}
+
+void CPythonBackground::Create()
+{
+	static int s_isCreateProperty=false;
+
+	if (!s_isCreateProperty)
+	{
+		s_isCreateProperty=true;
+		__CreateProperty();
+	}
+
+	CMapManager::Create();
+
+	m_SnowEnvironment.Create();
+}
+
+struct FGetPortalID
+{
+	float m_fRequestX, m_fRequestY;
+	std::set<int> m_kSet_iPortalID;
+	FGetPortalID(float fRequestX, float fRequestY)
+	{
+		m_fRequestX=fRequestX;
+		m_fRequestY=fRequestY;
+	}
+	void operator () (CGraphicObjectInstance * pObject)
+	{
+		for (int i = 0; i < PORTAL_ID_MAX_NUM; ++i)
+		{
+			int iID = pObject->GetPortal(i);
+			if (0 == iID)
+				break;
+
+			m_kSet_iPortalID.insert(iID);
+		}
+	}
+};
+
+void CPythonBackground::Update(float fCenterX, float fCenterY, float fCenterZ)
+{
+	if (!IsMapReady())
+		return;
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t1=ELTimer_GetMSec();
+#endif
+	UpdateMap(fCenterX, fCenterY, fCenterZ);
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t2=ELTimer_GetMSec();
+#endif
+	UpdateAroundAmbience(fCenterX, fCenterY, fCenterZ);
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t3=ELTimer_GetMSec();
+#endif
+	m_SnowEnvironment.Update(D3DXVECTOR3(fCenterX, -fCenterY, fCenterZ));
+
+#ifdef __PERFORMANCE_CHECKER__
+	{
+		static FILE* fp=fopen("perf_bg_update.txt", "w");
+		if (t3-t1>5)
+		{
+			fprintf(fp, "BG.Total %d (Time %f)\n", t3-t1, ELTimer_GetMSec()/1000.0f);
+			fprintf(fp, "BG.UpdateMap %d\n", t2-t1);
+			fprintf(fp, "BG.UpdateAmb %d\n", t3-t2);
+			fflush(fp);
+		}
+	}
+#endif
+
+	// Portal Process
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	if (rkMap.IsEnablePortal())
+	{
+		CCullingManager & rkCullingMgr = CCullingManager::Instance();
+		FGetPortalID kGetPortalID(fCenterX, -fCenterY);
+
+		Vector3d aVector3d;
+		aVector3d.Set(fCenterX, -fCenterY, fCenterZ);
+
+		Vector3d toTop;
+		toTop.Set(0, 0, 25000.0f);
+
+		rkCullingMgr.ForInRay(aVector3d, toTop, &kGetPortalID);
+
+		std::set<int>::iterator itor = kGetPortalID.m_kSet_iPortalID.begin();
+		if (!__IsSame(kGetPortalID.m_kSet_iPortalID, m_kSet_iShowingPortalID))
+		{
+			ClearPortal();
+			std::set<int>::iterator itor=kGetPortalID.m_kSet_iPortalID.begin();
+			for (; itor!=kGetPortalID.m_kSet_iPortalID.end(); ++itor)
+			{
+				AddShowingPortalID(*itor);
+			}
+			RefreshPortal();
+
+			m_kSet_iShowingPortalID = kGetPortalID.m_kSet_iPortalID;
+		}
+	}
+
+	// Target Effect Process
+	{
+		std::map<DWORD, DWORD>::iterator itor = m_kMap_dwTargetID_dwChrID.begin();
+		for (; itor != m_kMap_dwTargetID_dwChrID.end(); ++itor)
+		{
+			DWORD dwTargetID = itor->first;
+			DWORD dwChrID = itor->second;
+
+			CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(dwChrID);
+
+			if (!pInstance)
+				continue;
+
+			TPixelPosition kPixelPosition;
+			pInstance->NEW_GetPixelPosition(&kPixelPosition);
+
+			CreateSpecialEffect(dwTargetID,
+								+kPixelPosition.x,
+								-kPixelPosition.y,
+								+kPixelPosition.z,
+								g_strEffectName.c_str());
+		}
+	}
+
+	// Reserve Target Effect
+	{
+		std::map<DWORD, SReserveTargetEffect>::iterator itor = m_kMap_dwID_kReserveTargetEffect.begin();
+		for (; itor != m_kMap_dwID_kReserveTargetEffect.end();)
+		{
+			DWORD dwID = itor->first;
+			SReserveTargetEffect & rReserveTargetEffect = itor->second;
+
+			float ilx = float(rReserveTargetEffect.ilx);
+			float ily = float(rReserveTargetEffect.ily);
+
+			float fHeight = rkMap.GetHeight(ilx, ily);
+			if (0.0f == fHeight)
+			{
+				++itor;
+				continue;
+			}
+
+			CreateSpecialEffect(dwID, ilx, ily, fHeight, g_strEffectName.c_str());
+
+			itor = m_kMap_dwID_kReserveTargetEffect.erase(itor);
+		}
+	}
+}
+
+bool CPythonBackground::__IsSame(std::set<int> & rleft, std::set<int> & rright)
+{
+	std::set<int>::iterator itor_l;
+	std::set<int>::iterator itor_r;
+
+	for (itor_l=rleft.begin(); itor_l!=rleft.end(); ++itor_l)
+	{
+		if (rright.end() == rright.find(*itor_l))
+			return false;
+	}
+
+	for (itor_r=rright.begin(); itor_r!=rright.end(); ++itor_r)
+	{
+		if (rleft.end() == rleft.find(*itor_r))
+			return false;
+	}
+
+	return true;
+}
+
+void CPythonBackground::Render()
+{
+	if (!IsMapReady())
+		return;	
+
+	m_SnowEnvironment.Deform();
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.Render();
+	if (m_bVisibleGuildArea)
+		rkMap.RenderMarkedArea();
+}
+
+void CPythonBackground::RenderSnow()
+{
+	m_SnowEnvironment.Render();
+}
+
+void CPythonBackground::RenderPCBlocker()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderPCBlocker();
+}
+
+void CPythonBackground::RenderCollision()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderCollision();
+}
+
+void CPythonBackground::RenderCharacterShadowToTexture()
+{
+	extern bool GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW;
+	if (GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW)
+		return;
+
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	DWORD t1=ELTimer_GetMSec();
+
+	if (m_eShadowLevel == SHADOW_ALL ||
+		m_eShadowLevel == SHADOW_ALL_HIGH ||
+		m_eShadowLevel == SHADOW_ALL_MAX ||
+		m_eShadowLevel == SHADOW_GROUND_AND_SOLO)
+	{
+		D3DXMATRIX matWorld;
+		STATEMANAGER.GetTransform(D3DTS_WORLD, &matWorld);
+
+		bool canRender=rkMap.BeginRenderCharacterShadowToTexture();
+		if (canRender)
+		{
+			CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+
+			if (m_eShadowLevel == SHADOW_GROUND_AND_SOLO)
+				rkChrMgr.RenderShadowMainInstance();
+			else
+				rkChrMgr.RenderShadowAllInstances();
+		}
+		rkMap.EndRenderCharacterShadowToTexture();
+
+		STATEMANAGER.SetTransform(D3DTS_WORLD, &matWorld);
+	}
+
+	DWORD t2=ELTimer_GetMSec();
+
+	m_dwRenderShadowTime=t2-t1;	
+}
+
+inline float Interpolate(float fStart, float fEnd, float fPercent)
+{
+	return fStart + (fEnd - fStart) * fPercent;
+}
+struct CollisionChecker
+{
+	bool isBlocked;
+	CInstanceBase* pInstance;
+	CollisionChecker(CInstanceBase* pInstance) : pInstance(pInstance), isBlocked(false) {}
+	void operator () (CGraphicObjectInstance* pOpponent)
+	{
+		if (isBlocked)
+			return;
+
+		if (!pOpponent)
+			return;
+
+		if (pInstance->IsBlockObject(*pOpponent))
+			isBlocked=true;
+	}
+};
+
+struct CollisionAdjustChecker
+{
+	bool isBlocked;
+	CInstanceBase* pInstance;
+	CollisionAdjustChecker(CInstanceBase* pInstance) : pInstance(pInstance), isBlocked(false) {}
+	void operator () (CGraphicObjectInstance* pOpponent)
+	{
+		if (!pOpponent)
+			return;
+
+		if (pInstance->AvoidObject(*pOpponent))
+			isBlocked=true;
+	}
+};
+
+bool CPythonBackground::CheckAdvancing(CInstanceBase * pInstance)
+{
+	if (!IsMapReady())
+		return true;
+
+	Vector3d center;
+	float radius;
+	pInstance->GetGraphicThingInstanceRef().GetBoundingSphere(center,radius);
+
+	CCullingManager & rkCullingMgr = CCullingManager::Instance();
+
+	CollisionAdjustChecker kCollisionAdjustChecker(pInstance);
+	rkCullingMgr.ForInRange(center, radius, &kCollisionAdjustChecker);
+	if (kCollisionAdjustChecker.isBlocked)
+	{
+		CollisionChecker kCollisionChecker(pInstance);
+		rkCullingMgr.ForInRange(center, radius, &kCollisionChecker);
+		if (kCollisionChecker.isBlocked)
+		{
+			pInstance->BlockMovement();
+			return true;
+		}
+		else
+		{
+			pInstance->NEW_MoveToDestPixelPositionDirection(pInstance->NEW_GetDstPixelPositionRef());
+		}
+		return false;
+	}
+	return false;
+}
+
+void CPythonBackground::RenderSky()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderSky();
+}
+
+void CPythonBackground::RenderCloud()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderCloud();
+}
+
+void CPythonBackground::RenderWater()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderWater();
+}
+
+void CPythonBackground::RenderEffect()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderEffect();
+}
+
+void CPythonBackground::RenderBeforeLensFlare()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderBeforeLensFlare();
+}
+
+void CPythonBackground::RenderAfterLensFlare()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RenderAfterLensFlare();
+}
+
+void CPythonBackground::ClearGuildArea()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.ClearGuildArea();
+}
+
+void CPythonBackground::RegisterGuildArea(int isx, int isy, int iex, int iey)
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.RegisterGuildArea(isx, isy, iex, iey);
+}
+
+void CPythonBackground::SetCharacterDirLight()
+{
+	if (!IsMapReady())
+		return;
+
+	if (!mc_pcurEnvironmentData)
+		return;
+
+	STATEMANAGER.SetLight(0, &mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_CHARACTER]);
+}
+
+void CPythonBackground::SetBackgroundDirLight()
+{
+	if (!IsMapReady())
+		return;
+	if (!mc_pcurEnvironmentData)
+		return;
+
+	STATEMANAGER.SetLight(0, &mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND]);
+}
+
+void CPythonBackground::GlobalPositionToLocalPosition(LONG& rGlobalX, LONG& rGlobalY)
+{
+	rGlobalX-=m_dwBaseX;
+	rGlobalY-=m_dwBaseY;
+}
+
+void CPythonBackground::LocalPositionToGlobalPosition(LONG& rLocalX, LONG& rLocalY)
+{
+	rLocalX+=m_dwBaseX;
+	rLocalY+=m_dwBaseY;
+}
+
+void CPythonBackground::RegisterDungeonMapName(const char * c_szMapName)
+{
+	m_kSet_strDungeonMapName.insert(c_szMapName);
+}
+
+CPythonBackground::TMapInfo* CPythonBackground::GlobalPositionToMapInfo(DWORD dwGlobalX, DWORD dwGlobalY)
+{
+	TMapInfoVector::iterator f = std::find_if(m_kVct_kMapInfo.begin(), m_kVct_kMapInfo.end(), FFindWarpMapName(dwGlobalX, dwGlobalY));
+	if (f == m_kVct_kMapInfo.end())
+		return NULL;
+
+	return &(*f);
+}
+
+void CPythonBackground::Warp(DWORD dwX, DWORD dwY)
+{
+	TMapInfo* pkMapInfo = GlobalPositionToMapInfo(dwX, dwY);
+	if (!pkMapInfo)
+	{
+		TraceError("NOT_FOUND_GLOBAL_POSITION(%d, %d)", dwX, dwY);
+		return;
+	}
+
+	RefreshShadowLevel();
+	TMapInfo & rMapInfo = *pkMapInfo;
+	assert( (dwX >= rMapInfo.m_dwBaseX) && (dwY >= rMapInfo.m_dwBaseY) );
+
+	if (!LoadMap(rMapInfo.m_strName, float(dwX - rMapInfo.m_dwBaseX), float(dwY - rMapInfo.m_dwBaseY), 0))
+	{
+		// LOAD_MAP_ERROR_HANDLING
+		PostQuitMessage(0);
+		// END_OF_LOAD_MAP_ERROR_HANDLING
+		return;
+	}
+
+	CPythonMiniMap::Instance().LoadAtlas();
+
+	m_dwBaseX=rMapInfo.m_dwBaseX;
+	m_dwBaseY=rMapInfo.m_dwBaseY;
+
+	m_strMapName = rMapInfo.m_strName;
+
+	SetXMaxTree(m_iXMasTreeGrade);
+
+	if (m_kSet_strDungeonMapName.end() != m_kSet_strDungeonMapName.find(m_strMapName))
+	{
+		EnableTerrainOnlyForHeight();
+
+		CMapOutdoor& rkMap=GetMapOutdoorRef();
+		rkMap.EnablePortal(TRUE);
+	}
+
+	m_kSet_iShowingPortalID.clear();
+	m_kMap_dwTargetID_dwChrID.clear();
+	m_kMap_dwID_kReserveTargetEffect.clear();
+}
+
+void CPythonBackground::VisibleGuildArea()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.VisibleMarkedArea();
+
+	m_bVisibleGuildArea = TRUE;
+}
+
+void CPythonBackground::DisableGuildArea()
+{
+	if (!IsMapReady())
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.DisableMarkedArea();
+
+	m_bVisibleGuildArea = FALSE;
+}
+
+const char * CPythonBackground::GetWarpMapName()
+{
+	return m_strMapName.c_str();
+}
+
+void CPythonBackground::ChangeToDay()
+{
+	m_iDayMode = DAY_MODE_LIGHT;
+}
+
+void CPythonBackground::ChangeToNight()
+{
+	m_iDayMode = DAY_MODE_DARK;
+}
+
+void CPythonBackground::EnableSnowEnvironment()
+{
+	m_SnowEnvironment.Enable();
+}
+
+void CPythonBackground::DisableSnowEnvironment()
+{
+	m_SnowEnvironment.Disable();
+}
+
+const D3DXVECTOR3 c_v3TreePos = D3DXVECTOR3(76500.0f, -60900.0f, 20215.0f);
+
+void CPythonBackground::SetXMaxTree(int iGrade)
+{
+	if (!m_pkMap)
+		return;
+
+	assert(iGrade >= 0 && iGrade <= 3);
+	m_iXMasTreeGrade = iGrade;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+
+	if ("map_n_snowm_01" != m_strMapName)
+	{
+		rkMap.XMasTree_Destroy();
+		return;
+	}
+
+	if (0 == iGrade)
+	{
+		rkMap.XMasTree_Destroy();
+		return;
+	}
+
+	//////////////////////////////////////////////////////////////////////
+
+	iGrade -= 1;
+	iGrade = max(iGrade, 0);
+	iGrade = min(iGrade, 2);
+
+	static std::string s_strTreeName[3] = {
+		"d:/ymir work/tree/christmastree1.spt",
+		"d:/ymir work/tree/christmastree2.spt",
+		"d:/ymir work/tree/christmastree3.spt"
+	};
+	static std::string s_strEffectName[3] = {
+		"d:/ymir work/effect/etc/christmas_tree/tree_1s.mse",
+		"d:/ymir work/effect/etc/christmas_tree/tree_2s.mse",
+		"d:/ymir work/effect/etc/christmas_tree/tree_3s.mse",
+	};
+	rkMap.XMasTree_Set(c_v3TreePos.x, c_v3TreePos.y, c_v3TreePos.z, s_strTreeName[iGrade].c_str(), s_strEffectName[iGrade].c_str());
+}
+
+void CPythonBackground::CreateTargetEffect(DWORD dwID, DWORD dwChrVID)
+{
+	m_kMap_dwTargetID_dwChrID.insert(std::make_pair(dwID, dwChrVID));
+}
+
+void CPythonBackground::CreateTargetEffect(DWORD dwID, long lx, long ly)
+{
+	if (m_kMap_dwTargetID_dwChrID.end() != m_kMap_dwTargetID_dwChrID.find(dwID))
+		return;
+
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+
+	DWORD dwBaseX;
+	DWORD dwBaseY;
+	rkMap.GetBaseXY(&dwBaseX, &dwBaseY);
+
+	int ilx = +(lx-int(dwBaseX));
+	int ily = -(ly-int(dwBaseY));
+
+	float fHeight = rkMap.GetHeight(float(ilx), float(ily));
+
+	if (0.0f == fHeight)
+	{
+		SReserveTargetEffect ReserveTargetEffect;
+		ReserveTargetEffect.ilx = ilx;
+		ReserveTargetEffect.ily = ily;
+		m_kMap_dwID_kReserveTargetEffect.insert(std::make_pair(dwID, ReserveTargetEffect));
+		return;
+	}
+
+	CreateSpecialEffect(dwID, ilx, ily, fHeight, g_strEffectName.c_str());
+}
+
+void CPythonBackground::DeleteTargetEffect(DWORD dwID)
+{
+	if (m_kMap_dwID_kReserveTargetEffect.end() != m_kMap_dwID_kReserveTargetEffect.find(dwID))
+	{
+		m_kMap_dwID_kReserveTargetEffect.erase(dwID);
+	}
+	if (m_kMap_dwTargetID_dwChrID.end() != m_kMap_dwTargetID_dwChrID.find(dwID))
+	{
+		m_kMap_dwTargetID_dwChrID.erase(dwID);
+	}
+
+	DeleteSpecialEffect(dwID);
+}
+
+void CPythonBackground::CreateSpecialEffect(DWORD dwID, float fx, float fy, float fz, const char * c_szFileName)
+{
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.SpecialEffect_Create(dwID, fx, fy, fz, c_szFileName);
+}
+
+void CPythonBackground::DeleteSpecialEffect(DWORD dwID)
+{
+	CMapOutdoor& rkMap=GetMapOutdoorRef();
+	rkMap.SpecialEffect_Delete(dwID);
+}

src/UserInterface/PythonBackground.h

@@ -0,0 +1,183 @@
+// PythonBackground.h: interface for the CPythonBackground class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_PYTHONBACKGROUND_H__A202CB18_9553_4CF3_8500_5D7062B55432__INCLUDED_)
+#define AFX_PYTHONBACKGROUND_H__A202CB18_9553_4CF3_8500_5D7062B55432__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include "../gamelib/MapManager.h"
+#include "../gamelib/TerrainDecal.h"
+#include "../gamelib/SnowEnvironment.h"
+
+class CInstanceBase;
+
+class CPythonBackground : public CMapManager, public CSingleton<CPythonBackground>  
+{
+public:
+	enum
+	{
+		SHADOW_NONE,
+		SHADOW_GROUND,
+		SHADOW_GROUND_AND_SOLO,
+		SHADOW_ALL,
+		SHADOW_ALL_HIGH,
+		SHADOW_ALL_MAX,
+	};
+
+	enum
+	{
+		DISTANCE0,
+		DISTANCE1,
+		DISTANCE2,
+		DISTANCE3,
+		DISTANCE4,
+		NUM_DISTANCE_SET
+	};
+
+	enum
+	{
+		DAY_MODE_LIGHT,
+		DAY_MODE_DARK,
+	};
+
+	typedef struct SVIEWDISTANCESET
+	{
+		float m_fFogStart;
+		float m_fFogEnd;
+		float m_fFarClip;
+		D3DXVECTOR3 m_v3SkyBoxScale;
+	} TVIEWDISTANCESET;
+
+public:
+	CPythonBackground();
+	virtual ~CPythonBackground();
+
+	void Initialize();
+
+	void Destroy();
+	void Create();
+
+	void GlobalPositionToLocalPosition(LONG& rGlobalX, LONG& rGlobalY);
+	void LocalPositionToGlobalPosition(LONG& rLocalX, LONG& rLocalY);
+
+	void EnableTerrainOnlyForHeight();
+	bool SetSplatLimit(int iSplatNum);
+	bool SetVisiblePart(int ePart, bool isVisible);
+	bool SetShadowLevel(int eLevel);
+	void RefreshShadowLevel();
+	void SelectViewDistanceNum(int eNum);
+	void SetViewDistanceSet(int eNum, float fFarClip);
+	float GetFarClip();
+
+	DWORD GetRenderShadowTime();
+	void GetDistanceSetInfo(int * peNum, float * pfStart, float * pfEnd, float * pfFarClip);
+
+	bool GetPickingPoint(D3DXVECTOR3 * v3IntersectPt);
+	bool GetPickingPointWithRay(const CRay & rRay, D3DXVECTOR3 * v3IntersectPt);
+	bool GetPickingPointWithRayOnlyTerrain(const CRay & rRay, D3DXVECTOR3 * v3IntersectPt);
+	BOOL GetLightDirection(D3DXVECTOR3 & rv3LightDirection);
+
+	void Update(float fCenterX, float fCenterY, float fCenterZ);
+
+	void CreateCharacterShadowTexture();
+	void ReleaseCharacterShadowTexture();
+	void Render();
+	void RenderSnow();
+	void RenderPCBlocker();
+	void RenderCollision();
+	void RenderCharacterShadowToTexture();
+	void RenderSky();
+	void RenderCloud();
+	void RenderWater();
+	void RenderEffect();
+	void RenderBeforeLensFlare();
+	void RenderAfterLensFlare();
+
+	bool CheckAdvancing(CInstanceBase * pInstance);
+
+	void SetCharacterDirLight();
+	void SetBackgroundDirLight();
+
+	void ChangeToDay();
+	void ChangeToNight();
+	void EnableSnowEnvironment();
+	void DisableSnowEnvironment();
+	void SetXMaxTree(int iGrade);
+
+	void ClearGuildArea();
+	void RegisterGuildArea(int isx, int isy, int iex, int iey);
+
+	void CreateTargetEffect(DWORD dwID, DWORD dwChrVID);
+	void CreateTargetEffect(DWORD dwID, long lx, long ly);
+	void DeleteTargetEffect(DWORD dwID);
+
+	void CreateSpecialEffect(DWORD dwID, float fx, float fy, float fz, const char * c_szFileName);
+	void DeleteSpecialEffect(DWORD dwID);
+
+	void Warp(DWORD dwX, DWORD dwY);
+
+	void VisibleGuildArea();
+	void DisableGuildArea();
+
+	void RegisterDungeonMapName(const char * c_szMapName);
+	TMapInfo* GlobalPositionToMapInfo(DWORD dwGlobalX, DWORD dwGlobalY);
+	const char* GetWarpMapName();
+
+protected:
+	void __CreateProperty();
+	bool __IsSame(std::set<int> & rleft, std::set<int> & rright);
+
+protected:
+	std::string m_strMapName;
+
+private:
+	CSnowEnvironment m_SnowEnvironment;
+
+	int m_iDayMode;
+	int m_iXMasTreeGrade;
+
+	int m_eShadowLevel;
+	int m_eViewDistanceNum;
+
+	BOOL m_bVisibleGuildArea;
+
+	DWORD m_dwRenderShadowTime;
+
+	DWORD m_dwBaseX;
+	DWORD m_dwBaseY;
+
+	TVIEWDISTANCESET m_ViewDistanceSet[NUM_DISTANCE_SET];
+
+	std::set<int> m_kSet_iShowingPortalID;
+	std::set<std::string> m_kSet_strDungeonMapName;
+	std::map<DWORD, DWORD> m_kMap_dwTargetID_dwChrID;
+
+	struct SReserveTargetEffect
+	{
+		int ilx;
+		int ily;
+	};
+	std::map<DWORD, SReserveTargetEffect> m_kMap_dwID_kReserveTargetEffect;
+
+	struct FFindWarpMapName
+	{
+		DWORD m_dwX, m_dwY;
+		FFindWarpMapName::FFindWarpMapName(DWORD dwX, DWORD dwY)
+		{
+			m_dwX = dwX;
+			m_dwY = dwY;
+		}
+		bool operator() (TMapInfo & rMapInfo)
+		{
+			if (m_dwX < rMapInfo.m_dwBaseX || m_dwX >= rMapInfo.m_dwEndX || m_dwY < rMapInfo.m_dwBaseY || m_dwY >= rMapInfo.m_dwEndY)
+				return false;
+			return true;
+		}
+	};
+};
+
+#endif // !defined(AFX_PYTHONBACKGROUND_H__A202CB18_9553_4CF3_8500_5D7062B55432__INCLUDED_)

src/UserInterface/PythonBackgroundModule.cpp

@@ -0,0 +1,619 @@
+#include "StdAfx.h"
+#include "PythonSystem.h"
+#include "PythonBackground.h"
+#include "../eterlib/StateManager.h"
+#include "../gamelib/MapOutDoor.h"
+
+PyObject * backgroundIsSoftwareTiling(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	return Py_BuildValue("i", rkBG.IsSoftwareTilingEnable());
+}
+
+PyObject * backgroundEnableSoftwareTiling(PyObject * poSelf, PyObject * poArgs)
+{
+	int nIsEnable;
+	if (!PyTuple_GetInteger(poArgs, 0, &nIsEnable))
+		return Py_BadArgument();
+
+	bool isEnable=nIsEnable ? true : false;
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.ReserveSoftwareTilingEnable(isEnable);
+
+	CPythonSystem& rkSystem=CPythonSystem::Instance();
+	rkSystem.SetSoftwareTiling(isEnable);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundEnableSnow(PyObject * poSelf, PyObject * poArgs)
+{
+	int nIsEnable;
+	if (!PyTuple_GetInteger(poArgs, 0, &nIsEnable))
+		return Py_BadArgument();
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	if (nIsEnable)
+		rkBG.EnableSnowEnvironment();
+	else
+		rkBG.DisableSnowEnvironment();
+
+	return Py_BuildNone();
+}
+
+PyObject * backgroundLoadMap(PyObject * poSelf, PyObject * poArgs)
+{
+	char * pszMapPathName;
+
+	if (!PyTuple_GetString(poArgs, 0, &pszMapPathName))
+		return Py_BadArgument();
+
+	float x, y, z;
+
+	if (!PyTuple_GetFloat(poArgs, 1, &x))
+		return Py_BadArgument();
+
+	if (!PyTuple_GetFloat(poArgs, 2, &y))
+		return Py_BadArgument();
+
+	if (!PyTuple_GetFloat(poArgs, 3, &z))
+		return Py_BadArgument();
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.LoadMap(pszMapPathName, x, y, z);
+
+//#ifdef _DEBUG
+//	CMapOutdoor& rkMap=rkBG.GetMapOutdoorRef();
+//	rkMap.EnablePortal(TRUE);
+//	rkBG.EnableTerrainOnlyForHeight();
+//#endif
+
+	return Py_BuildNone();
+}
+
+PyObject * backgroundDestroy(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.SetShadowLevel(CPythonBackground::SHADOW_NONE);
+	rkBG.Destroy();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRegisterEnvironmentData(PyObject * poSelf, PyObject * poArgs)
+{
+	int iIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
+		return Py_BadArgument();
+
+	char * pszEnvironmentFileName;
+	if (!PyTuple_GetString(poArgs, 1, &pszEnvironmentFileName))
+		return Py_BadArgument();
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+ 	if (!rkBG.RegisterEnvironmentData(iIndex, pszEnvironmentFileName))
+	{
+		TraceError("background.RegisterEnvironmentData(iIndex=%d, szEnvironmentFileName=%s)", iIndex, pszEnvironmentFileName);
+
+		// TODO:
+		// <20><><EFBFBD><EFBFBD>Ʈ ȯ<><C8AF> <20><><EFBFBD><EFBFBD> <20>۾<EFBFBD><DBBE><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	}
+
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetEnvironmentData(PyObject * poSelf, PyObject * poArgs)
+{
+	int iIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
+		return Py_BadArgument();
+
+	const TEnvironmentData * c_pEnvironmenData;
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	if (rkBG.GetEnvironmentData(iIndex, &c_pEnvironmenData))
+		rkBG.ResetEnvironmentDataPtr(c_pEnvironmenData);
+
+	return Py_BuildNone();
+}
+
+PyObject * backgroundGetCurrentMapName(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	return Py_BuildValue("s", rkBG.GetWarpMapName());
+}
+
+PyObject * backgroundGetPickingPoint(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	TPixelPosition kPPosPicked(0.0f, 0.0f, 0.0f);
+	if (rkBG.GetPickingPoint(&kPPosPicked))
+	{
+		kPPosPicked.y=-kPPosPicked.y;
+	}
+	return Py_BuildValue("fff", kPPosPicked.x, kPPosPicked.y, kPPosPicked.z);
+}
+
+PyObject * backgroundBeginEnvironment(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.BeginEnvironment();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundEndEnvironemt(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.EndEnvironment();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetCharacterDirLight(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG = CPythonBackground::Instance();
+	rkBG.SetCharacterDirLight();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetBackgroundDirLight(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG = CPythonBackground::Instance();
+	rkBG.SetBackgroundDirLight();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundInitialize(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.Create();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundUpdate(PyObject * poSelf, PyObject * poArgs)
+{
+	float fCameraX;
+	if (!PyTuple_GetFloat(poArgs, 0, &fCameraX))
+		return Py_BadArgument();
+
+	float fCameraY;
+	if (!PyTuple_GetFloat(poArgs, 1, &fCameraY))
+		return Py_BadArgument();
+
+	float fCameraZ;
+	if (!PyTuple_GetFloat(poArgs, 2, &fCameraZ))
+		return Py_BadArgument();
+
+	CPythonBackground::Instance().Update(fCameraX, fCameraY, fCameraZ);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRender(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().Render();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderPCBlocker(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderPCBlocker();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderCollision(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderCollision();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderSky(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderSky();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderCloud(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderCloud();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderWater(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderWater();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderEffect(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderEffect();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderBeforeLensFlare(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderBeforeLensFlare();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderAfterLensFlare(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderAfterLensFlare();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderCharacterShadowToTexture(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().RenderCharacterShadowToTexture();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRenderDungeon(PyObject * poSelf, PyObject * poArgs)
+{
+	assert(!"background.RenderDungeon() - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> <20>Լ<EFBFBD><D4BC>Դϴ<D4B4> - [levites]");
+	return Py_BuildNone();
+}
+
+PyObject * backgroundGetHeight(PyObject * poSelf, PyObject * poArgs)
+{
+	float fx;
+	if (!PyTuple_GetFloat(poArgs, 0, &fx))
+		return Py_BadArgument();
+
+	float fy;
+	if (!PyTuple_GetFloat(poArgs, 1, &fy))
+		return Py_BadArgument();
+
+	float fz = CPythonBackground::Instance().GetHeight(fx, fy);
+	return Py_BuildValue("f", fz);
+}
+
+PyObject * backgroundGetRenderedSplatNum(PyObject * poSelf, PyObject * poArgs)
+{
+	int iPatch;
+	int iSplat;
+	float fSplatRatio;
+
+	std::vector<int> & aTextureNumVector = CPythonBackground::Instance().GetRenderedSplatNum(&iPatch, &iSplat, &fSplatRatio);
+
+	char szOutput[MAX_PATH] = "";
+	int iOutput = 0;
+	for( std::vector<int>::iterator it = aTextureNumVector.begin(); it != aTextureNumVector.end(); it++ ) {
+		iOutput += snprintf(szOutput + iOutput, sizeof(szOutput) - iOutput, "%d ", *it);
+	}
+	//std::copy(aTextureNumVector.begin(),aTextureNumVector.end(),std::ostream_iterator<int>(ostr," "));
+
+	return Py_BuildValue("iifs", iPatch, iSplat, fSplatRatio, szOutput);
+}
+
+PyObject * backgroundGetRenderedGTINum(PyObject * poSelf, PyObject * poArgs)
+{
+	DWORD dwGraphicThingInstanceNum;
+	DWORD dwCRCNum;
+
+	/*CArea::TCRCWithNumberVector & rCRCWithNumberVector = */
+	CPythonBackground::Instance().GetRenderedGraphicThingInstanceNum(&dwGraphicThingInstanceNum, &dwCRCNum);
+
+/*
+	std::ostringstream ostr;
+
+	std::for_each(rCRCWithNumberVector.begin(),rCRCWithNumberVector.end(),std::ostream_iterator<CArea::TCRCWithNumberVector>(ostr," "));
+*/
+
+	return Py_BuildValue("ii", dwGraphicThingInstanceNum, dwCRCNum);
+}
+
+PyObject * backgroundGetRenderShadowTime(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	return Py_BuildValue("i", rkBG.GetRenderShadowTime());
+}
+
+PyObject * backgroundGetShadowMapcolor(PyObject * poSelf, PyObject * poArgs)
+{
+	float fx;
+	if (!PyTuple_GetFloat(poArgs, 0, &fx))
+		return Py_BadArgument();
+
+	float fy;
+	if (!PyTuple_GetFloat(poArgs, 1, &fy))
+		return Py_BadArgument();
+
+	DWORD dwColor = CPythonBackground::Instance().GetShadowMapColor(fx, fy);
+	return Py_BuildValue("i", dwColor);
+}
+
+PyObject * backgroundSetShadowLevel(PyObject * poSelf, PyObject * poArgs)
+{
+	int iLevel;
+
+	if (!PyTuple_GetInteger(poArgs, 0, &iLevel))
+		return Py_BadArgument();
+
+	CPythonBackground& rkBG = CPythonBackground::Instance();
+	rkBG.SetShadowLevel(iLevel);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetVisiblePart(PyObject * poSelf, PyObject * poArgs)
+{
+	int ePart;
+	if (!PyTuple_GetInteger(poArgs, 0, &ePart))
+		return Py_BadArgument();
+
+	int isVisible;
+	if (!PyTuple_GetInteger(poArgs, 1, &isVisible))
+		return Py_BadArgument();
+
+	if (ePart>=CMapOutdoor::PART_NUM)
+		return Py_BuildException("ePart(%d)<background.PART_NUM(%d)", ePart, CMapOutdoor::PART_NUM);
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.SetVisiblePart(ePart, isVisible ? true : false);
+
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetSpaltLimit(PyObject * poSelf, PyObject * poArgs)
+{
+	int iSplatNum;
+	if (!PyTuple_GetInteger(poArgs, 0, &iSplatNum))
+		return Py_BadArgument();
+
+	if (iSplatNum<0)
+		return Py_BuildException("background.SetSplatLimit(iSplatNum(%d)>=0)", iSplatNum);
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.SetSplatLimit(iSplatNum);
+
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSelectViewDistanceNum(PyObject * poSelf, PyObject * poArgs)
+{
+	int iNum;
+
+	if (!PyTuple_GetInteger(poArgs, 0, &iNum))
+		return Py_BadArgument();
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.SelectViewDistanceNum(iNum);
+
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetViewDistanceSet(PyObject * poSelf, PyObject * poArgs)
+{
+	int iNum;
+	if (!PyTuple_GetInteger(poArgs, 0, &iNum))
+		return Py_BadArgument();
+
+	float fFarClip;
+	if (!PyTuple_GetFloat(poArgs, 1, &fFarClip))
+		return Py_BadArgument();
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.SetViewDistanceSet(iNum, fFarClip);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundGetFarClip(PyObject * poSelf, PyObject * poArgs)
+{
+	float fFarClip = CPythonBackground::Instance().GetFarClip();
+	return Py_BuildValue("f", fFarClip);
+}
+
+PyObject * backgroundGetDistanceSetInfo(PyObject * poSelf, PyObject * poArgs)
+{
+	int iNum;
+	float fStart, fEnd, fFarClip;
+	CPythonBackground::Instance().GetDistanceSetInfo(&iNum, &fStart, &fEnd, &fFarClip);
+	return Py_BuildValue("ifff", iNum, fStart, fEnd, fFarClip);
+}
+
+PyObject * backgroundSetBGLoading(PyObject * poSelf, PyObject * poArgs)
+{
+	bool bBGLoading;
+	if (!PyTuple_GetBoolean(poArgs, 0, &bBGLoading))
+		return Py_BadArgument();
+
+	//CPythonBackground::Instance().BGLoadingEnable(bBGLoading);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetRenderSort(PyObject * poSelf, PyObject * poArgs)
+{
+	int eSort;
+	if (!PyTuple_GetInteger(poArgs, 0, &eSort))
+		return Py_BadArgument();
+
+	CPythonBackground::Instance().SetTerrainRenderSort((CMapOutdoor::ETerrainRenderSort) eSort);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetTransparentTree(PyObject * poSelf, PyObject * poArgs)
+{
+	int bTransparent;
+	if (!PyTuple_GetInteger(poArgs, 0, &bTransparent))
+		return Py_BadArgument();
+
+	CPythonBackground::Instance().SetTransparentTree(bTransparent ? true : false);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundGlobalPositionToLocalPosition(PyObject * poSelf, PyObject * poArgs)
+{
+	int iX;
+	if (!PyTuple_GetInteger(poArgs, 0, &iX))
+		return Py_BadArgument();
+
+	int iY;
+	if (!PyTuple_GetInteger(poArgs, 1, &iY))
+		return Py_BadArgument();
+
+	LONG lX=iX;
+	LONG lY=iY;	
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	rkBG.GlobalPositionToLocalPosition(lX, lY);
+
+	return Py_BuildValue("ii", lX, lY);
+}
+
+PyObject * backgroundGlobalPositionToMapInfo(PyObject * poSelf, PyObject * poArgs)
+{
+	int iX;
+	if (!PyTuple_GetInteger(poArgs, 0, &iX))
+		return Py_BadArgument();
+
+	int iY;
+	if (!PyTuple_GetInteger(poArgs, 1, &iY))
+		return Py_BadArgument();
+
+	CPythonBackground& rkBG=CPythonBackground::Instance();
+	CPythonBackground::TMapInfo* pkMapInfo=rkBG.GlobalPositionToMapInfo(iX, iY);
+	
+	if (pkMapInfo)
+		return Py_BuildValue("sii", pkMapInfo->m_strName.c_str(), pkMapInfo->m_dwBaseX, pkMapInfo->m_dwBaseY);
+	else
+		return Py_BuildValue("sii", "", 0, 0);
+}
+
+
+PyObject * backgroundWarpTest(PyObject * poSelf, PyObject * poArgs)
+{
+	int iX;
+	if (!PyTuple_GetInteger(poArgs, 0, &iX))
+		return Py_BadArgument();
+
+	int iY;
+	if (!PyTuple_GetInteger(poArgs, 1, &iY))
+		return Py_BadArgument();
+
+	CPythonBackground::Instance().Warp((DWORD)iX * 100 , (DWORD)iY * 100);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundSetXMasTree(PyObject * poSelf, PyObject * poArgs)
+{
+	int iGrade;
+	if (!PyTuple_GetInteger(poArgs, 0, &iGrade))
+		return Py_BadArgument();
+
+	CPythonBackground::Instance().SetXMaxTree(iGrade);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundRegisterDungeonMapName(PyObject * poSelf, PyObject * poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BadArgument();
+
+	CPythonBackground::Instance().RegisterDungeonMapName(szName);
+	return Py_BuildNone();
+}
+
+PyObject * backgroundVisibleGuildArea(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().VisibleGuildArea();
+	return Py_BuildNone();
+}
+
+PyObject * backgroundDisableGuildArea(PyObject * poSelf, PyObject * poArgs)
+{
+	CPythonBackground::Instance().DisableGuildArea();
+	return Py_BuildNone();
+}
+
+void initBackground()
+{
+	static PyMethodDef s_methods[] =
+	{
+		{ "IsSoftwareTiling",					backgroundIsSoftwareTiling,					METH_VARARGS }, 
+		{ "EnableSoftwareTiling",				backgroundEnableSoftwareTiling,				METH_VARARGS }, 
+		{ "EnableSnow",							backgroundEnableSnow,						METH_VARARGS }, 
+		{ "GlobalPositionToLocalPosition",		backgroundGlobalPositionToLocalPosition,	METH_VARARGS }, 
+		{ "GlobalPositionToMapInfo",			backgroundGlobalPositionToMapInfo,			METH_VARARGS }, 
+		{ "GetRenderShadowTime",				backgroundGetRenderShadowTime,				METH_VARARGS },
+		{ "LoadMap",							backgroundLoadMap,							METH_VARARGS },
+		{ "Destroy",							backgroundDestroy,							METH_VARARGS },
+		{ "RegisterEnvironmentData",			backgroundRegisterEnvironmentData,			METH_VARARGS },
+		{ "SetEnvironmentData",					backgroundSetEnvironmentData,				METH_VARARGS },
+		{ "GetCurrentMapName",					backgroundGetCurrentMapName,				METH_VARARGS },
+		{ "GetPickingPoint",					backgroundGetPickingPoint,					METH_VARARGS },
+
+		{ "BeginEnvironment",					backgroundBeginEnvironment,					METH_VARARGS },
+		{ "EndEnvironment",						backgroundEndEnvironemt,					METH_VARARGS },
+		{ "SetCharacterDirLight",				backgroundSetCharacterDirLight,				METH_VARARGS },
+		{ "SetBackgroundDirLight",				backgroundSetBackgroundDirLight,			METH_VARARGS },
+
+		{ "Initialize",							backgroundInitialize,						METH_VARARGS },
+		{ "Update",								backgroundUpdate,							METH_VARARGS },
+		{ "Render",								backgroundRender,							METH_VARARGS },
+		{ "RenderPCBlocker",					backgroundRenderPCBlocker,					METH_VARARGS },
+		{ "RenderCollision",					backgroundRenderCollision,					METH_VARARGS },
+		{ "RenderSky",							backgroundRenderSky,						METH_VARARGS },
+		{ "RenderCloud",						backgroundRenderCloud,						METH_VARARGS },
+		{ "RenderWater",						backgroundRenderWater,						METH_VARARGS },
+		{ "RenderEffect",						backgroundRenderEffect,						METH_VARARGS },
+		{ "RenderBeforeLensFlare",				backgroundRenderBeforeLensFlare,			METH_VARARGS },
+		{ "RenderAfterLensFlare",				backgroundRenderAfterLensFlare,				METH_VARARGS },
+		{ "RenderCharacterShadowToTexture",		backgroundRenderCharacterShadowToTexture,	METH_VARARGS },
+		{ "RenderDungeon",						backgroundRenderDungeon,					METH_VARARGS },
+		{ "GetHeight",							backgroundGetHeight,						METH_VARARGS },
+		
+		{ "SetShadowLevel",						backgroundSetShadowLevel,					METH_VARARGS },
+
+		{ "SetVisiblePart",						backgroundSetVisiblePart,					METH_VARARGS },
+		{ "GetShadowMapColor",					backgroundGetShadowMapcolor,				METH_VARARGS },
+		{ "SetSplatLimit",						backgroundSetSpaltLimit,					METH_VARARGS },
+		{ "GetRenderedSplatNum",				backgroundGetRenderedSplatNum,				METH_VARARGS },
+		{ "GetRenderedGraphicThingInstanceNum",	backgroundGetRenderedGTINum,				METH_VARARGS },
+		{ "SelectViewDistanceNum",				backgroundSelectViewDistanceNum,			METH_VARARGS },
+		{ "SetViewDistanceSet",					backgroundSetViewDistanceSet,				METH_VARARGS },
+		{ "GetFarClip",							backgroundGetFarClip,						METH_VARARGS },
+		{ "GetDistanceSetInfo",					backgroundGetDistanceSetInfo,				METH_VARARGS },
+		{ "SetBGLoading",						backgroundSetBGLoading,						METH_VARARGS },
+		{ "SetRenderSort",						backgroundSetRenderSort,					METH_VARARGS },
+		{ "SetTransparentTree",					backgroundSetTransparentTree,				METH_VARARGS },
+		{ "SetXMasTree",						backgroundSetXMasTree,						METH_VARARGS },
+		{ "RegisterDungeonMapName",				backgroundRegisterDungeonMapName,			METH_VARARGS },
+
+		{ "VisibleGuildArea",					backgroundVisibleGuildArea,					METH_VARARGS },
+		{ "DisableGuildArea",					backgroundDisableGuildArea,					METH_VARARGS },
+
+		{ "WarpTest",							backgroundWarpTest,							METH_VARARGS },
+
+		{ NULL, NULL, NULL },
+	};
+
+	PyObject * poModule = Py_InitModule("background", s_methods);
+
+	PyModule_AddIntConstant(poModule, "PART_SKY",				CMapOutdoor::PART_SKY);
+	PyModule_AddIntConstant(poModule, "PART_TREE",				CMapOutdoor::PART_TREE);
+	PyModule_AddIntConstant(poModule, "PART_CLOUD",				CMapOutdoor::PART_CLOUD);
+	PyModule_AddIntConstant(poModule, "PART_WATER",				CMapOutdoor::PART_WATER);
+	PyModule_AddIntConstant(poModule, "PART_OBJECT",			CMapOutdoor::PART_OBJECT);	
+	PyModule_AddIntConstant(poModule, "PART_TERRAIN",			CMapOutdoor::PART_TERRAIN);	
+
+	PyModule_AddIntConstant(poModule, "SKY_RENDER_MODE_DEFAULT",			CSkyObject::SKY_RENDER_MODE_DEFAULT);
+	PyModule_AddIntConstant(poModule, "SKY_RENDER_MODE_DIFFUSE",			CSkyObject::SKY_RENDER_MODE_DIFFUSE);
+	PyModule_AddIntConstant(poModule, "SKY_RENDER_MODE_TEXTURE",			CSkyObject::SKY_RENDER_MODE_TEXTURE);
+	PyModule_AddIntConstant(poModule, "SKY_RENDER_MODE_MODULATE",			CSkyObject::SKY_RENDER_MODE_MODULATE);
+	PyModule_AddIntConstant(poModule, "SKY_RENDER_MODE_MODULATE2X",			CSkyObject::SKY_RENDER_MODE_MODULATE2X);
+	PyModule_AddIntConstant(poModule, "SKY_RENDER_MODE_MODULATE4X",			CSkyObject::SKY_RENDER_MODE_MODULATE4X);
+
+	PyModule_AddIntConstant(poModule, "SHADOW_NONE", CPythonBackground::SHADOW_NONE);
+	PyModule_AddIntConstant(poModule, "SHADOW_GROUND", CPythonBackground::SHADOW_GROUND);
+	PyModule_AddIntConstant(poModule, "SHADOW_GROUND_AND_SOLO", CPythonBackground::SHADOW_GROUND_AND_SOLO);
+	PyModule_AddIntConstant(poModule, "SHADOW_ALL", CPythonBackground::SHADOW_ALL);
+	PyModule_AddIntConstant(poModule, "SHADOW_ALL_HIGH", CPythonBackground::SHADOW_ALL_HIGH);
+	PyModule_AddIntConstant(poModule, "SHADOW_ALL_MAX", CPythonBackground::SHADOW_ALL_MAX);
+
+	PyModule_AddIntConstant(poModule, "DISTANCE0", CPythonBackground::DISTANCE0);
+	PyModule_AddIntConstant(poModule, "DISTANCE1", CPythonBackground::DISTANCE1);
+	PyModule_AddIntConstant(poModule, "DISTANCE2", CPythonBackground::DISTANCE2);
+	PyModule_AddIntConstant(poModule, "DISTANCE3", CPythonBackground::DISTANCE3);
+	PyModule_AddIntConstant(poModule, "DISTANCE4", CPythonBackground::DISTANCE4);
+
+	PyModule_AddIntConstant(poModule, "DISTANCE_SORT", CMapOutdoor::DISTANCE_SORT);
+	PyModule_AddIntConstant(poModule, "TEXTURE_SORT", CMapOutdoor::TEXTURE_SORT);
+}

src/UserInterface/PythonCharacterManager.cpp

@@ -0,0 +1,965 @@
+#include "stdafx.h"
+#include "pythoncharactermanager.h"
+#include "PythonBackground.h"
+#include "PythonNonPlayer.h"
+#include "AbstractPlayer.h"
+#include "packet.h"
+
+#include "../eterLib/Camera.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Frame Process
+
+int CHAR_STAGE_VIEW_BOUND = 200*100;
+
+struct FCharacterManagerCharacterInstanceUpdate
+{
+	inline void operator () (const std::pair<DWORD,CInstanceBase *>& cr_Pair)
+	{
+		cr_Pair.second->Update();
+	}
+};
+
+void CPythonCharacterManager::AdjustCollisionWithOtherObjects(CActorInstance* pInst )
+{
+	if( !pInst->IsPC() )
+		return;
+
+	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+	for(CPythonCharacterManager::CharacterIterator i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd();++i)
+	{
+		CInstanceBase*  pkInstEach=*i;
+		CActorInstance* rkActorEach=pkInstEach->GetGraphicThingInstancePtr();
+
+		if (rkActorEach==pInst)
+			continue;
+
+		if( rkActorEach->IsPC() || rkActorEach->IsNPC() || rkActorEach->IsEnemy() )
+			continue;
+
+		if(pInst->TestPhysicsBlendingCollision(*rkActorEach) )
+		{
+			// NOTE : <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD>
+			// TODO : <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ݴ<EFBFBD> <20><> ó<><C3B3><EFBFBD>Ѵٸ<D1B4> physic movement<6E>Ÿ<EFBFBD><C5B8><EFBFBD> steping<6E>ؼ<EFBFBD> iterationó<6E><C3B3><EFBFBD>ؾ<EFBFBD> <20><>.
+			TPixelPosition curPos;
+			pInst->GetPixelPosition(&curPos);
+			pInst->SetBlendingPosition(curPos);
+			//Tracef("!!!!!! Collision Adjusted\n"); 
+			break;
+		}
+	}
+}
+
+
+void CPythonCharacterManager::EnableSortRendering(bool isEnable)
+{
+}
+
+void CPythonCharacterManager::InsertPVPKey(DWORD dwVIDSrc, DWORD dwVIDDst)
+{
+	CInstanceBase::InsertPVPKey(dwVIDSrc, dwVIDDst);
+
+	CInstanceBase* pkInstSrc=GetInstancePtr(dwVIDSrc);
+	if (pkInstSrc)
+		pkInstSrc->RefreshTextTail();
+
+	CInstanceBase* pkInstDst=GetInstancePtr(dwVIDDst);
+	if (pkInstDst)
+		pkInstDst->RefreshTextTail();
+}
+
+void CPythonCharacterManager::RemovePVPKey(DWORD dwVIDSrc, DWORD dwVIDDst)
+{
+	CInstanceBase::RemovePVPKey(dwVIDSrc, dwVIDDst);
+
+	CInstanceBase* pkInstSrc=GetInstancePtr(dwVIDSrc);
+	if (pkInstSrc)
+		pkInstSrc->RefreshTextTail();
+
+	CInstanceBase* pkInstDst=GetInstancePtr(dwVIDDst);
+	if (pkInstDst)
+		pkInstDst->RefreshTextTail();
+}
+
+void CPythonCharacterManager::ChangeGVG(DWORD dwSrcGuildID, DWORD dwDstGuildID)
+{
+	TCharacterInstanceMap::iterator itor;
+	for (itor = m_kAliveInstMap.begin(); itor != m_kAliveInstMap.end(); itor++)
+	{
+		CInstanceBase * pInstance = itor->second;
+
+		DWORD dwInstanceGuildID = pInstance->GetGuildID();
+		if (dwSrcGuildID == dwInstanceGuildID || dwDstGuildID == dwInstanceGuildID)
+		{
+			pInstance->RefreshTextTail();
+		}
+	}
+}
+
+void CPythonCharacterManager::ClearMainInstance()
+{
+	m_pkInstMain=NULL;
+}
+
+bool CPythonCharacterManager::SetMainInstance(DWORD dwVID)
+{
+	m_pkInstMain=GetInstancePtr(dwVID);
+
+	if (!m_pkInstMain)
+		return false;
+
+	return true;
+}
+
+CInstanceBase* CPythonCharacterManager::GetMainInstancePtr()
+{
+	return m_pkInstMain;
+}
+
+void CPythonCharacterManager::GetInfo(std::string* pstInfo)
+{
+	pstInfo->append("Actor: ");
+
+	CInstanceBase::GetInfo(pstInfo);
+
+	char szInfo[256];
+	sprintf(szInfo, "Container - Live %d, Dead %d", m_kAliveInstMap.size(), m_kDeadInstList.size());
+	pstInfo->append(szInfo);
+}
+
+
+bool CPythonCharacterManager::IsCacheMode()
+{
+	static bool s_isOldCacheMode=false;
+
+	bool isCacheMode=s_isOldCacheMode;
+	if (s_isOldCacheMode)
+	{
+		if (m_kAliveInstMap.size()<30)
+			isCacheMode=false;
+	}
+	else
+	{
+		if (m_kAliveInstMap.size()>40)
+			isCacheMode=true;
+	}
+	s_isOldCacheMode=isCacheMode;
+
+	return isCacheMode;
+}
+
+void CPythonCharacterManager::Update()
+{
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t1=timeGetTime();
+#endif
+	CInstanceBase::ResetPerformanceCounter();
+
+	CInstanceBase* pkInstMain=GetMainInstancePtr();
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t2=timeGetTime();
+#endif
+	DWORD dwDeadInstCount=0;
+	DWORD dwForceVisibleInstCount=0;
+
+	TCharacterInstanceMap::iterator i=m_kAliveInstMap.begin(); 
+	while (m_kAliveInstMap.end()!=i)
+	{
+		TCharacterInstanceMap::iterator c=i++;
+
+		CInstanceBase* pkInstEach=c->second;
+		pkInstEach->Update();
+
+		if (pkInstMain)
+		{
+			if (pkInstEach->IsForceVisible())
+			{
+				dwForceVisibleInstCount++;
+				continue;
+			}
+
+			int nDistance = int(pkInstEach->NEW_GetDistanceFromDestInstance(*pkInstMain));
+			if (nDistance > CHAR_STAGE_VIEW_BOUND + 10)
+			{
+				__DeleteBlendOutInstance(pkInstEach);
+				m_kAliveInstMap.erase(c);
+				dwDeadInstCount++;
+			}
+		}
+	}
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t3=timeGetTime();
+#endif
+	UpdateTransform();
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t4=timeGetTime();
+#endif
+
+	UpdateDeleting();
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t5=timeGetTime();
+#endif
+
+	__NEW_Pick();
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t6=timeGetTime();
+#endif
+
+#ifdef __PERFORMANCE_CHECKER__
+	{
+		static FILE* fp=fopen("perf_chrmgr_update.txt", "w");
+
+		if (t6-t1>1)
+		{
+			fprintf(fp, "CU.Total %d (Time %d, Alive %d, Dead %d)\n", 
+				t6-t1, ELTimer_GetMSec(),
+				m_kAliveInstMap.size(),
+				m_kDeadInstList.size());
+			fprintf(fp, "CU.Counter %d\n", t2-t1);
+			fprintf(fp, "CU.ForEach %d\n", t3-t2);
+			fprintf(fp, "CU.Trans %d\n", t4-t3);
+			fprintf(fp, "CU.Del %d\n", t5-t4);
+			fprintf(fp, "CU.Pick %d\n", t6-t5);
+			fprintf(fp, "CU.AI %d\n", m_kAliveInstMap.size());
+			fprintf(fp, "CU.DI %d\n", dwDeadInstCount);
+			fprintf(fp, "CU.FVI %d\n", dwForceVisibleInstCount);
+			fprintf(fp, "-------------------------------- \n");
+			fflush(fp);
+		}
+	}
+#endif
+}
+
+void CPythonCharacterManager::ShowPointEffect(DWORD ePoint, DWORD dwVID)
+{
+	CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetMainInstancePtr() : GetInstancePtr(dwVID);
+
+	if (!pkInstSel)
+		return;
+
+	switch (ePoint)
+	{
+		case POINT_LEVEL:
+			pkInstSel->LevelUp();
+			break;
+		case POINT_LEVEL_STEP:
+			pkInstSel->SkillUp();
+			break;
+	}
+}
+
+bool CPythonCharacterManager::RegisterPointEffect(DWORD ePoint, const char* c_szFileName)
+{
+	if (ePoint>=POINT_MAX_NUM)
+		return false;
+
+	CEffectManager& rkEftMgr=CEffectManager::Instance();
+	rkEftMgr.RegisterEffect2(c_szFileName, &m_adwPointEffect[ePoint]);
+
+	return true;
+}
+
+void CPythonCharacterManager::UpdateTransform()
+{
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t1=timeGetTime();
+	DWORD t2=timeGetTime();
+#endif
+
+	CInstanceBase * pMainInstance = GetMainInstancePtr();
+	if (pMainInstance)
+	{
+		CPythonBackground& rkBG=CPythonBackground::Instance();
+		for (TCharacterInstanceMap::iterator i = m_kAliveInstMap.begin(); i != m_kAliveInstMap.end(); ++i)
+		{
+			CInstanceBase * pSrcInstance = i->second;
+
+			pSrcInstance->CheckAdvancing();
+
+			// 2004.08.02.myevan.IsAttacked <20><> <20><><EFBFBD><EFBFBD> <20>׾<EFBFBD><D7BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> üũ<C3BC>ϹǷ<CFB9>, 
+			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ÿ<EFBFBD><C5B8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> IsPushing<6E>϶<EFBFBD><CFB6><EFBFBD> üũ<C3BC>ϵ<EFBFBD><CFB5><EFBFBD> <20>Ѵ<EFBFBD>
+			if (pSrcInstance->IsPushing())
+				rkBG.CheckAdvancing(pSrcInstance);
+		}
+#ifdef __PERFORMANCE_CHECKER__
+		t2=timeGetTime();
+#endif
+
+#ifdef __MOVIE_MODE__
+		if (!m_pkInstMain->IsMovieMode())
+		{
+			rkBG.CheckAdvancing(m_pkInstMain);
+		}
+#else
+		rkBG.CheckAdvancing(m_pkInstMain);
+#endif
+	}
+
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t3=timeGetTime();
+#endif
+
+	{
+		for (TCharacterInstanceMap::iterator itor = m_kAliveInstMap.begin(); itor != m_kAliveInstMap.end(); ++itor)
+		{
+			CInstanceBase * pInstance = itor->second;
+			pInstance->Transform();
+		}
+	}
+
+#ifdef __PERFORMANCE_CHECKER__
+	DWORD t4=timeGetTime();
+#endif
+
+#ifdef __PERFORMANCE_CHECKER__
+	{
+		static FILE* fp=fopen("perf_chrmgr_updatetransform.txt", "w");
+
+		if (t4-t1>5)
+		{
+			fprintf(fp, "CUT.Total %d (Time %f, Alive %d, Dead %d)\n", 
+				t4-t1, ELTimer_GetMSec()/1000.0f,
+				m_kAliveInstMap.size(),
+				m_kDeadInstList.size());
+			fprintf(fp, "CUT.ChkAdvInst %d\n", t2-t1);
+			fprintf(fp, "CUT.ChkAdvBG %d\n", t3-t2);
+			fprintf(fp, "CUT.Trans %d\n", t4-t3);
+
+			fprintf(fp, "-------------------------------- \n");
+			fflush(fp);
+		}
+
+		fflush(fp);
+	}
+#endif
+}
+void CPythonCharacterManager::UpdateDeleting()
+{
+	TCharacterInstanceList::iterator itor = m_kDeadInstList.begin();
+	for (; itor != m_kDeadInstList.end();)
+	{
+		CInstanceBase * pInstance = *itor;
+
+		if (pInstance->UpdateDeleting())
+		{
+			++itor;
+		}
+		else
+		{
+			CInstanceBase::Delete(pInstance);
+			itor = m_kDeadInstList.erase(itor);
+		}
+	}
+}
+
+struct FCharacterManagerCharacterInstanceDeform
+{
+	inline void operator () (const std::pair<DWORD,CInstanceBase *>& cr_Pair)
+	{
+		cr_Pair.second->Deform();
+		//pInstance->Update();
+	}
+};
+struct FCharacterManagerCharacterInstanceListDeform
+{
+	inline void operator () (CInstanceBase * pInstance)
+	{
+		pInstance->Deform();
+	}
+};
+
+void CPythonCharacterManager::Deform()
+{
+	std::for_each(m_kAliveInstMap.begin(), m_kAliveInstMap.end(), FCharacterManagerCharacterInstanceDeform());
+	std::for_each(m_kDeadInstList.begin(), m_kDeadInstList.end(), FCharacterManagerCharacterInstanceListDeform());
+}
+
+
+
+
+bool CPythonCharacterManager::OLD_GetPickedInstanceVID(DWORD* pdwPickedActorID)
+{
+	if (!m_pkInstPick)
+		return false;
+		
+	*pdwPickedActorID=m_pkInstPick->GetVirtualID();
+	return true;
+}
+
+CInstanceBase * CPythonCharacterManager::OLD_GetPickedInstancePtr()
+{
+	return m_pkInstPick;
+}
+
+D3DXVECTOR2 & CPythonCharacterManager::OLD_GetPickedInstPosReference()
+{
+	return m_v2PickedInstProjPos;
+}
+
+bool CPythonCharacterManager::IsRegisteredVID(DWORD dwVID)
+{
+	if (m_kAliveInstMap.end()==m_kAliveInstMap.find(dwVID))
+		return false;
+
+	return true;
+}
+
+bool CPythonCharacterManager::IsAliveVID(DWORD dwVID)
+{
+	return m_kAliveInstMap.find(dwVID)!=m_kAliveInstMap.end();
+}
+
+bool CPythonCharacterManager::IsDeadVID(DWORD dwVID)
+{
+	for (TCharacterInstanceList::iterator f=m_kDeadInstList.begin(); f!=m_kDeadInstList.end(); ++f)
+	{
+		if ((*f)->GetVirtualID()==dwVID)
+			return true;
+	}
+
+	return false;
+}
+
+struct LessCharacterInstancePtrRenderOrder
+{
+	bool operator() (CInstanceBase* pkLeft, CInstanceBase* pkRight)
+	{
+		return pkLeft->LessRenderOrder(pkRight);		
+	}
+};
+
+struct FCharacterManagerCharacterInstanceRender
+{
+	inline void operator () (const std::pair<DWORD,CInstanceBase *>& cr_Pair)
+	{
+		cr_Pair.second->Render();
+		cr_Pair.second->RenderTrace();
+	}
+};
+struct FCharacterInstanceRender
+{
+	inline void operator () (CInstanceBase * pInstance)
+	{
+		pInstance->Render();
+	}
+};
+struct FCharacterInstanceRenderTrace
+{
+	inline void operator () (CInstanceBase * pInstance)
+	{
+		pInstance->RenderTrace();
+	}
+};
+
+
+void CPythonCharacterManager::__RenderSortedAliveActorList()
+{
+	static std::vector<CInstanceBase*> s_kVct_pkInstAliveSort;
+	s_kVct_pkInstAliveSort.clear();
+
+	TCharacterInstanceMap& rkMap_pkInstAlive=m_kAliveInstMap;
+	TCharacterInstanceMap::iterator i;
+	for (i=rkMap_pkInstAlive.begin(); i!=rkMap_pkInstAlive.end(); ++i)
+		s_kVct_pkInstAliveSort.push_back(i->second);
+
+	std::sort(s_kVct_pkInstAliveSort.begin(), s_kVct_pkInstAliveSort.end(), LessCharacterInstancePtrRenderOrder());
+	std::for_each(s_kVct_pkInstAliveSort.begin(), s_kVct_pkInstAliveSort.end(), FCharacterInstanceRender());
+	std::for_each(s_kVct_pkInstAliveSort.begin(), s_kVct_pkInstAliveSort.end(), FCharacterInstanceRenderTrace());
+}
+
+void CPythonCharacterManager::__RenderSortedDeadActorList()
+{
+	static std::vector<CInstanceBase*> s_kVct_pkInstDeadSort;
+	s_kVct_pkInstDeadSort.clear();
+
+	TCharacterInstanceList& rkLst_pkInstDead=m_kDeadInstList;
+	TCharacterInstanceList::iterator i;
+	for (i=rkLst_pkInstDead.begin(); i!=rkLst_pkInstDead.end(); ++i)
+		s_kVct_pkInstDeadSort.push_back(*i);
+
+	std::sort(s_kVct_pkInstDeadSort.begin(), s_kVct_pkInstDeadSort.end(), LessCharacterInstancePtrRenderOrder());
+	std::for_each(s_kVct_pkInstDeadSort.begin(), s_kVct_pkInstDeadSort.end(), FCharacterInstanceRender());
+
+}
+
+void CPythonCharacterManager::Render()
+{
+	STATEMANAGER.SetTexture(0, NULL);	
+	STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1,	D3DTA_TEXTURE);
+	STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG2,	D3DTA_CURRENT);
+	STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP,	D3DTOP_MODULATE);
+	STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAARG1,	D3DTA_TEXTURE);
+	STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP,	D3DTOP_SELECTARG1);
+
+	STATEMANAGER.SetTexture(1, NULL);
+	STATEMANAGER.SetTextureStageState(1, D3DTSS_COLOROP,	D3DTOP_DISABLE);
+	STATEMANAGER.SetTextureStageState(1, D3DTSS_ALPHAOP,	D3DTOP_DISABLE);
+
+
+	__RenderSortedAliveActorList();
+	__RenderSortedDeadActorList();
+
+	CInstanceBase * pkPickedInst = OLD_GetPickedInstancePtr();
+	if (pkPickedInst)
+	{
+		const D3DXVECTOR3 & c_rv3Position = pkPickedInst->GetGraphicThingInstanceRef().GetPosition();
+		CPythonGraphic::Instance().ProjectPosition(c_rv3Position.x, c_rv3Position.y, c_rv3Position.z, &m_v2PickedInstProjPos.x, &m_v2PickedInstProjPos.y);
+	}
+}
+
+void CPythonCharacterManager::RenderShadowMainInstance()
+{
+	CInstanceBase* pkInstMain=GetMainInstancePtr();
+	if (pkInstMain)
+		pkInstMain->RenderToShadowMap();
+}
+
+struct FCharacterManagerCharacterInstanceRenderToShadowMap
+{
+	inline void operator () (const std::pair<DWORD,CInstanceBase *>& cr_Pair)
+	{
+		cr_Pair.second->RenderToShadowMap();
+	}
+};
+
+void CPythonCharacterManager::RenderShadowAllInstances()
+{
+	std::for_each(m_kAliveInstMap.begin(), m_kAliveInstMap.end(), FCharacterManagerCharacterInstanceRenderToShadowMap());
+}
+
+struct FCharacterManagerCharacterInstanceRenderCollision
+{
+	inline void operator () (const std::pair<DWORD,CInstanceBase *>& cr_Pair)
+	{
+		cr_Pair.second->RenderCollision();
+	}
+};
+
+void CPythonCharacterManager::RenderCollision()
+{
+ 	std::for_each(m_kAliveInstMap.begin(), m_kAliveInstMap.end(), FCharacterManagerCharacterInstanceRenderCollision());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Managing Process
+
+CInstanceBase * CPythonCharacterManager::CreateInstance(const CInstanceBase::SCreateData& c_rkCreateData)
+{
+	CInstanceBase * pCharacterInstance = RegisterInstance(c_rkCreateData.m_dwVID);
+	if (!pCharacterInstance)
+	{
+		TraceError("CPythonCharacterManager::CreateInstance: VID[%d] - ALREADY EXIST\n", c_rkCreateData);
+		return NULL;
+	}
+
+	if (!pCharacterInstance->Create(c_rkCreateData))
+	{
+		TraceError("CPythonCharacterManager::CreateInstance VID[%d] Race[%d]", c_rkCreateData.m_dwVID, c_rkCreateData.m_dwRace);
+		DeleteInstance(c_rkCreateData.m_dwVID);
+		return NULL;
+	}
+
+	if (c_rkCreateData.m_isMain)
+		SelectInstance(c_rkCreateData.m_dwVID);
+
+	return (pCharacterInstance);
+}
+
+CInstanceBase * CPythonCharacterManager::RegisterInstance(DWORD VirtualID)
+{
+	TCharacterInstanceMap::iterator itor = m_kAliveInstMap.find(VirtualID);
+
+	if (m_kAliveInstMap.end() != itor)
+	{
+		return NULL;
+	}
+
+	CInstanceBase * pCharacterInstance = CInstanceBase::New();
+	m_kAliveInstMap.insert(TCharacterInstanceMap::value_type(VirtualID, pCharacterInstance));
+
+	return (pCharacterInstance);
+}
+
+void CPythonCharacterManager::DeleteInstance(DWORD dwDelVID)
+{
+	TCharacterInstanceMap::iterator itor = m_kAliveInstMap.find(dwDelVID);
+
+	if (m_kAliveInstMap.end() == itor)
+	{
+		Tracef("DeleteCharacterInstance: no vid by %d\n", dwDelVID);
+		return;
+	}
+
+	CInstanceBase * pkInstDel = itor->second;
+
+	if (pkInstDel == m_pkInstBind)
+		m_pkInstBind = NULL;
+
+	if (pkInstDel == m_pkInstMain)
+		m_pkInstMain = NULL;
+
+	if (pkInstDel == m_pkInstPick)
+		m_pkInstPick = NULL;
+
+	CInstanceBase::Delete(pkInstDel);
+
+	m_kAliveInstMap.erase(itor);
+}
+
+void CPythonCharacterManager::__DeleteBlendOutInstance(CInstanceBase* pkInstDel)
+{
+	pkInstDel->DeleteBlendOut();
+	m_kDeadInstList.push_back(pkInstDel);	
+
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	rkPlayer.NotifyCharacterDead(pkInstDel->GetVirtualID());
+}
+
+void CPythonCharacterManager::DeleteInstanceByFade(DWORD dwVID)
+{
+	TCharacterInstanceMap::iterator f = m_kAliveInstMap.find(dwVID);
+	if (m_kAliveInstMap.end() == f)
+	{
+		return;
+	}
+	__DeleteBlendOutInstance(f->second);
+	m_kAliveInstMap.erase(f);	
+}
+
+void CPythonCharacterManager::SelectInstance(DWORD VirtualID)
+{
+	TCharacterInstanceMap::iterator itor = m_kAliveInstMap.find(VirtualID);
+
+	if (m_kAliveInstMap.end() == itor)
+	{
+		Tracef("SelectCharacterInstance: no vid by %d\n", VirtualID);
+		return;
+	}
+
+	m_pkInstBind = itor->second;
+}
+
+CInstanceBase * CPythonCharacterManager::GetInstancePtr(DWORD VirtualID)
+{
+	TCharacterInstanceMap::iterator itor = m_kAliveInstMap.find(VirtualID);
+
+	if (m_kAliveInstMap.end() == itor)
+		return NULL;
+
+	return itor->second;
+}
+
+CInstanceBase * CPythonCharacterManager::GetInstancePtrByName(const char *name)
+{
+	TCharacterInstanceMap::iterator itor;
+
+	for (itor = m_kAliveInstMap.begin(); itor != m_kAliveInstMap.end(); itor++)
+	{
+		CInstanceBase * pInstance = itor->second;
+
+		if (!strcmp(pInstance->GetNameString(), name))
+			return pInstance;
+	}
+
+	return NULL;
+}
+
+CInstanceBase * CPythonCharacterManager::GetSelectedInstancePtr()
+{
+	return m_pkInstBind;
+}
+
+CInstanceBase* CPythonCharacterManager::FindClickableInstancePtr()
+{
+	return NULL;
+}
+
+void CPythonCharacterManager::__UpdateSortPickedActorList()
+{
+	__UpdatePickedActorList();
+	__SortPickedActorList();
+}
+
+void CPythonCharacterManager::__UpdatePickedActorList()
+{
+	m_kVct_pkInstPicked.clear();
+
+	TCharacterInstanceMap::iterator i;
+	for (i=m_kAliveInstMap.begin(); i!=m_kAliveInstMap.end(); ++i)
+	{
+		CInstanceBase* pkInstEach=i->second;
+		// 2004.07.17.levites.isShow<6F><77> ViewFrustumCheck<63><6B> <20><><EFBFBD><EFBFBD>
+		if (pkInstEach->CanPickInstance())
+		{
+			if (pkInstEach->IsDead())
+			{
+				if (pkInstEach->IntersectBoundingBox())
+					m_kVct_pkInstPicked.push_back(pkInstEach);
+			}
+			else
+			{
+				if (pkInstEach->IntersectDefendingSphere())
+					m_kVct_pkInstPicked.push_back(pkInstEach);
+			}
+		}
+	}
+}
+
+struct CInstanceBase_SLessCameraDistance
+{
+	TPixelPosition m_kPPosEye;
+
+	bool operator() (CInstanceBase* pkInstLeft, CInstanceBase* pkInstRight)
+	{
+		int nLeftDeadPoint=pkInstLeft->IsDead();
+		int nRightDeadPoint=pkInstRight->IsDead();
+
+		if (nLeftDeadPoint<nRightDeadPoint)
+			return true;
+
+		if (pkInstLeft->CalculateDistanceSq3d(m_kPPosEye)<pkInstRight->CalculateDistanceSq3d(m_kPPosEye))
+			return true;
+
+		return false;
+	}
+};
+
+void CPythonCharacterManager::__SortPickedActorList()
+{
+	CCamera * pCamera = CCameraManager::Instance().GetCurrentCamera();
+	const D3DXVECTOR3& c_rv3EyePos=pCamera->GetEye();
+
+	CInstanceBase_SLessCameraDistance kLess;
+	kLess.m_kPPosEye=TPixelPosition(+c_rv3EyePos.x, -c_rv3EyePos.y, +c_rv3EyePos.z);
+
+	std::sort(m_kVct_pkInstPicked.begin(), m_kVct_pkInstPicked.end(), kLess);
+}
+
+void CPythonCharacterManager::__NEW_Pick()
+{
+	__UpdateSortPickedActorList();
+
+	CInstanceBase* pkInstMain=GetMainInstancePtr();
+
+#ifdef __MOVIE_MODE
+	if (pkInstMain)
+		if (pkInstMain->IsMovieMode())
+		{
+			if (m_pkInstPick)
+				m_pkInstPick->OnUnselected();
+			return;
+		}
+#endif
+
+	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> üũ
+	{
+		std::vector<CInstanceBase*>::iterator f;
+		for (f=m_kVct_pkInstPicked.begin(); f!=m_kVct_pkInstPicked.end(); ++f)
+		{
+			CInstanceBase* pkInstEach=*f;
+			if (pkInstEach!=pkInstMain && pkInstEach->IntersectBoundingBox())
+			{
+				if (m_pkInstPick)
+					if (m_pkInstPick!=pkInstEach)
+						m_pkInstPick->OnUnselected();
+
+				if (pkInstEach->CanPickInstance())
+				{
+					m_pkInstPick = pkInstEach;
+					m_pkInstPick->OnSelected();
+					return;
+				}
+			}
+		}
+	}
+
+	// <20><>ã<EFBFBD><C3A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	{
+		std::vector<CInstanceBase*>::iterator f;
+		for (f=m_kVct_pkInstPicked.begin(); f!=m_kVct_pkInstPicked.end(); ++f)
+		{
+			CInstanceBase* pkInstEach=*f;
+			if (pkInstEach!=pkInstMain)
+			{
+				if (m_pkInstPick)
+					if (m_pkInstPick!=pkInstEach)
+						m_pkInstPick->OnUnselected();
+
+				if (pkInstEach->CanPickInstance())
+				{
+					m_pkInstPick = pkInstEach;
+					m_pkInstPick->OnSelected();
+					return;
+				}
+			}
+		}
+	}
+
+	if (pkInstMain)
+	if (pkInstMain->CanPickInstance())
+	if (m_kVct_pkInstPicked.end() != std::find(m_kVct_pkInstPicked.begin(), m_kVct_pkInstPicked.end(), pkInstMain))
+	{
+		if (m_pkInstPick)
+			if (m_pkInstPick!=pkInstMain)
+				m_pkInstPick->OnUnselected();			
+
+		m_pkInstPick = pkInstMain;
+		m_pkInstPick->OnSelected();
+		return;
+	}
+
+	if (m_pkInstPick)
+	{
+		m_pkInstPick->OnUnselected();	
+		m_pkInstPick=NULL;
+	}
+}
+
+void CPythonCharacterManager::__OLD_Pick()
+{
+	for (TCharacterInstanceMap::iterator itor = m_kAliveInstMap.begin(); itor != m_kAliveInstMap.end(); ++itor)
+	{
+		CInstanceBase * pkInstEach = itor->second;
+
+		if (pkInstEach == m_pkInstMain)
+			continue;
+
+		if (pkInstEach->IntersectDefendingSphere())
+		{
+			if (m_pkInstPick)
+				if (m_pkInstPick!=pkInstEach)
+					m_pkInstPick->OnUnselected();	
+
+			m_pkInstPick = pkInstEach;
+			m_pkInstPick->OnSelected();
+
+			return;
+		}
+	}
+
+	if (m_pkInstPick)
+	{
+		m_pkInstPick->OnUnselected();	
+		m_pkInstPick=NULL;
+	}
+}
+
+int CPythonCharacterManager::PickAll()
+{
+	for (TCharacterInstanceMap::iterator itor = m_kAliveInstMap.begin(); itor != m_kAliveInstMap.end(); ++itor)
+	{
+		CInstanceBase * pInstance = itor->second;
+
+		if (pInstance->IntersectDefendingSphere())
+			return pInstance->GetVirtualID();
+	}
+
+	return -1;
+}
+
+CInstanceBase * CPythonCharacterManager::GetCloseInstance(CInstanceBase * pInstance)
+{
+	float fMinDistance = 10000.0f;
+	CInstanceBase * pCloseInstance = NULL;
+
+	TCharacterInstanceMap::iterator itor = m_kAliveInstMap.begin();
+	for (; itor != m_kAliveInstMap.end(); ++itor)
+	{
+		CInstanceBase * pTargetInstance = itor->second;
+
+		if (pTargetInstance == pInstance)
+			continue;
+
+		DWORD dwVirtualNumber = pTargetInstance->GetVirtualNumber();
+		if (CPythonNonPlayer::ON_CLICK_EVENT_BATTLE != CPythonNonPlayer::Instance().GetEventType(dwVirtualNumber))
+			continue;
+
+		float fDistance = pInstance->GetDistance(pTargetInstance);
+		if (fDistance < fMinDistance)
+		{
+			fMinDistance = fDistance;
+			pCloseInstance = pTargetInstance;
+		}
+	}
+
+	return pCloseInstance;
+}
+
+void CPythonCharacterManager::RefreshAllPCTextTail()
+{
+	CPythonCharacterManager::CharacterIterator itor = CharacterInstanceBegin();
+	CPythonCharacterManager::CharacterIterator itorEnd = CharacterInstanceEnd();
+	for (; itor != itorEnd; ++itor)
+	{
+		CInstanceBase * pInstance = *itor;
+		if (!pInstance->IsPC())
+			continue;
+
+		pInstance->RefreshTextTail();
+	}
+}
+
+void CPythonCharacterManager::RefreshAllGuildMark()
+{
+	CPythonCharacterManager::CharacterIterator itor = CharacterInstanceBegin();
+	CPythonCharacterManager::CharacterIterator itorEnd = CharacterInstanceEnd();
+	for (; itor != itorEnd; ++itor)
+	{
+		CInstanceBase * pInstance = *itor;
+		if (!pInstance->IsPC())
+			continue;
+
+		pInstance->ChangeGuild(pInstance->GetGuildID());
+		pInstance->RefreshTextTail();
+	}
+}
+
+void CPythonCharacterManager::DeleteAllInstances()
+{
+	DestroyAliveInstanceMap();
+	DestroyDeadInstanceList();
+}
+
+
+void CPythonCharacterManager::DestroyAliveInstanceMap()
+{
+	for (TCharacterInstanceMap::iterator i = m_kAliveInstMap.begin(); i != m_kAliveInstMap.end(); ++i)
+		CInstanceBase::Delete(i->second);
+
+	m_kAliveInstMap.clear();
+}
+
+void CPythonCharacterManager::DestroyDeadInstanceList()
+{
+	std::for_each(m_kDeadInstList.begin(), m_kDeadInstList.end(), CInstanceBase::Delete);
+	m_kDeadInstList.clear();
+}
+
+void CPythonCharacterManager::Destroy()
+{
+	DeleteAllInstances();
+
+	CInstanceBase::DestroySystem();
+
+	__Initialize();
+}
+
+void CPythonCharacterManager::__Initialize()
+{
+	memset(m_adwPointEffect, 0, sizeof(m_adwPointEffect));
+	m_pkInstMain = NULL;
+	m_pkInstBind = NULL;
+	m_pkInstPick = NULL;
+	m_v2PickedInstProjPos = D3DXVECTOR2(0.0f, 0.0f);
+}
+
+
+CPythonCharacterManager::CPythonCharacterManager()
+{
+	__Initialize();
+}
+
+CPythonCharacterManager::~CPythonCharacterManager()
+{
+	Destroy();
+}

src/UserInterface/PythonCharacterManager.h

@@ -0,0 +1,168 @@
+#pragma once
+
+#include "AbstractCharacterManager.h"
+#include "InstanceBase.h"
+#include "../GameLib/PhysicsObject.h"
+
+class CPythonCharacterManager : public CSingleton<CPythonCharacterManager>, public IAbstractCharacterManager, public IObjectManager
+{
+	public:
+		// Character List
+		typedef std::list<CInstanceBase *>			TCharacterInstanceList;
+		typedef std::map<DWORD, CInstanceBase *>	TCharacterInstanceMap;
+
+		class CharacterIterator;
+
+	public:
+		CPythonCharacterManager();
+		virtual ~CPythonCharacterManager();
+
+		virtual void AdjustCollisionWithOtherObjects(CActorInstance* pInst ); 
+
+		void EnableSortRendering(bool isEnable);
+
+		bool IsRegisteredVID(DWORD dwVID);
+		bool IsAliveVID(DWORD dwVID);
+		bool IsDeadVID(DWORD dwVID);
+		bool IsCacheMode();
+
+		bool OLD_GetPickedInstanceVID(DWORD* pdwPickedActorID);
+		CInstanceBase* OLD_GetPickedInstancePtr();
+		D3DXVECTOR2& OLD_GetPickedInstPosReference();
+
+		CInstanceBase* FindClickableInstancePtr();
+
+		void InsertPVPKey(DWORD dwVIDSrc, DWORD dwVIDDst);
+		void RemovePVPKey(DWORD dwVIDSrc, DWORD dwVIDDst);
+		void ChangeGVG(DWORD dwSrcGuildID, DWORD dwDstGuildID);
+
+		void GetInfo(std::string* pstInfo);
+
+		void ClearMainInstance();
+		bool SetMainInstance(DWORD dwVID);
+		CInstanceBase* GetMainInstancePtr();
+
+		void								SCRIPT_SetAffect(DWORD dwVID, DWORD eAffect, BOOL isVisible);
+		void								SetEmoticon(DWORD dwVID, DWORD eEmoticon);
+		bool								IsPossibleEmoticon(DWORD dwVID);
+		void								ShowPointEffect(DWORD dwVID, DWORD ePoint);
+		bool								RegisterPointEffect(DWORD ePoint, const char* c_szFileName);
+
+		// System
+		void								Destroy();
+
+		void								DeleteAllInstances();
+
+		bool								CreateDeviceObjects();
+		void								DestroyDeviceObjects();
+
+		void								Update();
+		void								Deform();
+		void								Render();
+		void								RenderShadowMainInstance();
+		void								RenderShadowAllInstances();
+		void								RenderCollision();
+
+		// Create/Delete Instance
+		CInstanceBase *						CreateInstance(const CInstanceBase::SCreateData& c_rkCreateData);
+		CInstanceBase *						RegisterInstance(DWORD VirtualID);
+
+		void								DeleteInstance(DWORD VirtualID);
+		void								DeleteInstanceByFade(DWORD VirtualID);
+		void								DeleteVehicleInstance(DWORD VirtualID);
+
+		void 								DestroyAliveInstanceMap();
+		void 								DestroyDeadInstanceList();
+
+		inline CharacterIterator			CharacterInstanceBegin() { return CharacterIterator(m_kAliveInstMap.begin());}
+		inline CharacterIterator			CharacterInstanceEnd() { return CharacterIterator(m_kAliveInstMap.end());}
+
+		// Access Instance
+		void								SelectInstance(DWORD VirtualID);
+		CInstanceBase *						GetSelectedInstancePtr();
+
+		CInstanceBase *						GetInstancePtr(DWORD VirtualID);
+		CInstanceBase *						GetInstancePtrByName(const char *name);
+
+		// Pick		
+		int									PickAll();
+		CInstanceBase *						GetCloseInstance(CInstanceBase * pInstance);
+
+		// Refresh TextTail
+		void								RefreshAllPCTextTail();
+		void								RefreshAllGuildMark();
+
+	protected:
+		void								UpdateTransform();
+		void								UpdateDeleting();
+
+	protected:
+		void __Initialize();
+
+		void __DeleteBlendOutInstance(CInstanceBase* pkInstDel);
+
+		void __OLD_Pick();
+		void __NEW_Pick();
+
+		void __UpdateSortPickedActorList();
+		void __UpdatePickedActorList();
+		void __SortPickedActorList();
+
+		void __RenderSortedAliveActorList();
+		void __RenderSortedDeadActorList();
+
+	protected:
+		CInstanceBase *						m_pkInstMain;
+		CInstanceBase *						m_pkInstPick;
+		CInstanceBase *						m_pkInstBind;
+		D3DXVECTOR2							m_v2PickedInstProjPos;
+
+		TCharacterInstanceMap				m_kAliveInstMap;
+		TCharacterInstanceList				m_kDeadInstList;
+
+		std::vector<CInstanceBase*>			m_kVct_pkInstPicked;
+
+		DWORD								m_adwPointEffect[POINT_MAX_NUM];
+
+	public:
+		class CharacterIterator
+		{
+		public:
+			CharacterIterator(){}
+			CharacterIterator(const TCharacterInstanceMap::iterator & it) : m_it(it) {}
+
+			inline CInstanceBase * operator * () {	return m_it->second; }
+
+			inline CharacterIterator & operator ++()
+			{
+				++m_it;
+				return *this;
+			}
+
+			inline CharacterIterator operator ++(int)
+			{
+				CharacterIterator new_it = *this;
+				++(*this);
+				return new_it;
+			}
+
+			inline CharacterIterator & operator = (const CharacterIterator & rhs)
+			{
+				m_it = rhs.m_it;
+				return (*this);
+			}
+
+			inline bool operator == (const CharacterIterator & rhs) const
+			{
+				return m_it == rhs.m_it;
+			}
+
+			inline bool operator != (const CharacterIterator & rhs) const
+			{
+				return m_it != rhs.m_it;
+			}
+
+			private:
+				TCharacterInstanceMap::iterator m_it;
+		};
+};

src/UserInterface/PythonCharacterManagerModule.cpp

@@ -0,0 +1,844 @@
+#include "StdAfx.h"
+#include "PythonCharacterManager.h"
+#include "PythonBackground.h"
+#include "InstanceBase.h"
+#include "../gamelib/RaceManager.h"
+
+//////////////////////////////////////////////////////////////////////////
+// RaceData <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+//////////////////////////////////////////////////////////////////////////
+
+PyObject * chrmgrSetEmpireNameMode(PyObject* poSelf, PyObject* poArgs)
+{
+	int	iEnable;
+	if (!PyTuple_GetInteger(poArgs, 0, &iEnable))
+		return Py_BadArgument();
+
+	CInstanceBase::SetEmpireNameMode(iEnable ? true : false);
+	CPythonCharacterManager::Instance().RefreshAllPCTextTail();
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterTitleName(PyObject* poSelf, PyObject* poArgs)
+{
+	int	iIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
+		return Py_BadArgument();
+	char * szTitleName;
+	if (!PyTuple_GetString(poArgs, 1, &szTitleName))
+		return Py_BadArgument();
+
+	CInstanceBase::RegisterTitleName(iIndex, szTitleName);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterNameColor(PyObject* poSelf, PyObject* poArgs)
+{	
+	int index;
+	if (!PyTuple_GetInteger(poArgs, 0, &index))
+		return Py_BadArgument();
+	
+	int ir;
+	if (!PyTuple_GetInteger(poArgs, 1, &ir))
+		return Py_BadArgument();
+	int ig;
+	if (!PyTuple_GetInteger(poArgs, 2, &ig))
+		return Py_BadArgument();
+	int ib;
+	if (!PyTuple_GetInteger(poArgs, 3, &ib))
+		return Py_BadArgument();
+
+	CInstanceBase::RegisterNameColor(index, ir, ig, ib);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterTitleColor(PyObject* poSelf, PyObject* poArgs)
+{
+	int	iIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
+		return Py_BadArgument();
+	int ir;
+	if (!PyTuple_GetInteger(poArgs, 1, &ir))
+		return Py_BadArgument();
+	int ig;
+	if (!PyTuple_GetInteger(poArgs, 2, &ig))
+		return Py_BadArgument();
+	int ib;
+	if (!PyTuple_GetInteger(poArgs, 3, &ib))
+		return Py_BadArgument();
+
+	CInstanceBase::RegisterTitleColor(iIndex, ir, ig, ib);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrGetPickedVID(PyObject* poSelf, PyObject* poArgs)
+{
+	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+
+	DWORD dwPickedActorID;
+	if (rkChrMgr.OLD_GetPickedInstanceVID(&dwPickedActorID))
+		return Py_BuildValue("i", dwPickedActorID);
+	else
+		return Py_BuildValue("i", -1);
+}
+
+PyObject * chrmgrGetVIDInfo(PyObject* poSelf, PyObject* poArgs)
+{
+	int	nVID;
+	if (!PyTuple_GetInteger(poArgs, 0, &nVID))
+		return Py_BadArgument();
+
+	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+
+	char szDetail[256]="";
+	CInstanceBase* pkInstBase=rkChrMgr.GetInstancePtr(nVID);
+	if (pkInstBase)
+	{
+		TPixelPosition kPPosInst;
+		pkInstBase->NEW_GetPixelPosition(&kPPosInst);
+
+		LONG xInst=kPPosInst.x;
+		LONG yInst=kPPosInst.y;
+
+		CPythonBackground& rkBG=CPythonBackground::Instance();
+		rkBG.LocalPositionToGlobalPosition(xInst, yInst);
+		sprintf(szDetail, "pos=(%d, %d)", xInst, yInst);
+	}	
+	
+
+	char szInfo[1024];	
+	sprintf(szInfo, "VID %d (isRegistered=%d, isAlive=%d, isDead=%d) %s", 
+		nVID,
+		rkChrMgr.IsRegisteredVID(nVID),
+		rkChrMgr.IsAliveVID(nVID),
+		rkChrMgr.IsDeadVID(nVID),
+		szDetail
+	);
+	
+	return Py_BuildValue("s", szInfo);
+}
+
+
+PyObject * chrmgrSetPathName(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szPathName;
+	if (!PyTuple_GetString(poArgs, 0, &szPathName))
+		return Py_BadArgument();
+
+	CRaceManager::Instance().SetPathName(szPathName);	
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrCreateRace(PyObject * poSelf, PyObject * poArgs)
+{
+	int	iRace;
+	if (!PyTuple_GetInteger(poArgs, 0, &iRace))
+		return Py_BadArgument();
+
+	CRaceManager::Instance().CreateRace(iRace);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrSelectRace(PyObject * poSelf, PyObject * poArgs)
+{
+	int	iRace;
+	if (!PyTuple_GetInteger(poArgs, 0, &iRace))
+		return Py_BadArgument();
+
+	CRaceManager::Instance().SelectRace(iRace);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterAttachingBoneName(PyObject * poSelf, PyObject * poArgs)
+{
+	int iPartIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iPartIndex))
+		return Py_BadArgument();
+	char * szBoneName;
+	if (!PyTuple_GetString(poArgs, 1, &szBoneName))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->RegisterAttachingBoneName(iPartIndex, szBoneName);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterMotionMode(PyObject* poSelf, PyObject* poArgs)
+{
+	int	iMotionIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMotionIndex))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->RegisterMotionMode(iMotionIndex);
+	return Py_BuildNone();
+}
+
+
+
+PyObject * chrmgrSetMotionRandomWeight(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMode))
+		return Py_BadArgument();
+
+	int iMotion;
+	if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
+		return Py_BadArgument();
+
+	int iSubMotion;
+	if (!PyTuple_GetInteger(poArgs, 2, &iSubMotion))
+		return Py_BadArgument();
+
+	int iPercentage;
+	if (!PyTuple_GetInteger(poArgs, 3, &iPercentage))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	if (!pRaceData->SetMotionRandomWeight(iMode, iMotion, iSubMotion, iPercentage))
+		Py_BuildException("Failed to SetMotionRandomWeight");
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterNormalAttack(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMode))
+		return Py_BadArgument();
+
+	int iMotion;
+	if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->RegisterNormalAttack(iMode, iMotion);
+	return Py_BuildNone();
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD>
+PyObject * chrmgrReserveComboAttack(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMode))
+		return Py_BadArgument();
+
+	int iCount;
+	if (!PyTuple_GetInteger(poArgs, 1, &iCount))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->ReserveComboAttack(iMode, 0, iCount);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterComboAttack(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMode))
+		return Py_BadArgument();
+
+	int iComboIndex;
+	if (!PyTuple_GetInteger(poArgs, 1, &iComboIndex))
+		return Py_BadArgument();
+
+	int iMotionIndex;
+	if (!PyTuple_GetInteger(poArgs, 2, &iMotionIndex))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->RegisterComboAttack(iMode, 0, iComboIndex, iMotionIndex);
+	return Py_BuildNone();
+}
+// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD>
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+PyObject * chrmgrReserveComboAttackNew(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMotionMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMotionMode))
+		return Py_BadArgument();
+
+	int iComboType;
+	if (!PyTuple_GetInteger(poArgs, 1, &iComboType))
+		return Py_BadArgument();
+
+	int iCount;
+	if (!PyTuple_GetInteger(poArgs, 2, &iCount))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->ReserveComboAttack(iMotionMode, iComboType, iCount);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterComboAttackNew(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMotionMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMotionMode))
+		return Py_BadArgument();
+
+	int iComboType;
+	if (!PyTuple_GetInteger(poArgs, 1, &iComboType))
+		return Py_BadArgument();
+
+	int iComboIndex;
+	if (!PyTuple_GetInteger(poArgs, 2, &iComboIndex))
+		return Py_BadArgument();
+
+	int iMotionIndex;
+	if (!PyTuple_GetInteger(poArgs, 3, &iMotionIndex))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->RegisterComboAttack(iMotionMode, iComboType, iComboIndex, iMotionIndex);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrLoadRaceData(PyObject* poSelf, PyObject* poArgs)
+{
+	char* szFileName;
+	if (!PyTuple_GetString(poArgs, 0, &szFileName))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
+	if (!pRaceData->LoadRaceData(c_szFullFileName))
+	{
+		TraceError("Failed to load race data : %s\n", c_szFullFileName);
+	}
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrLoadLocalRaceData(PyObject* poSelf, PyObject* poArgs)
+{
+	char* szFileName;
+	if (!PyTuple_GetString(poArgs, 0, &szFileName))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	if (!pRaceData->LoadRaceData(szFileName))
+	{
+		TraceError("Failed to load race data : %s\n", szFileName);
+	}
+
+	return Py_BuildNone();
+}
+
+/*
+PyObject * chrmgrRegisterMotion(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMode))
+		return Py_BadArgument();
+
+	int iMotion;
+	if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
+		return Py_BadArgument();
+
+	char* szFileName;
+	if (!PyTuple_GetString(poArgs, 2, &szFileName))
+		return Py_BadArgument();
+
+	int iWeight = 0;
+	PyTuple_GetInteger(poArgs, 3, &iWeight);
+	iWeight = MIN(100, iWeight);
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->NEW_RegisterMotion(iMode, iMotion, CRaceManager::Instance().GetFullPathFileName(szFileName), iWeight);
+	return Py_BuildNone();
+}
+*/
+
+PyObject * chrmgrRegisterCacheMotionData(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMode))
+		return Py_BadArgument();
+
+	int iMotion;
+	if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
+		return Py_BadArgument();
+
+	char * szFileName;
+	if (!PyTuple_GetString(poArgs, 2, &szFileName))
+		return Py_BadArgument();
+
+	int iWeight = 0;
+	PyTuple_GetInteger(poArgs, 3, &iWeight);
+	iWeight = MIN(100, iWeight);
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
+	CGraphicThing* pkMotionThing=pRaceData->RegisterMotionData(iMode, iMotion, c_szFullFileName, iWeight);
+
+	if (pkMotionThing)
+		CResourceManager::Instance().LoadStaticCache(pkMotionThing->GetFileName());
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterMotionData(PyObject* poSelf, PyObject* poArgs)
+{
+	int iMode;
+	if (!PyTuple_GetInteger(poArgs, 0, &iMode))
+		return Py_BadArgument();
+
+	int iMotion;
+	if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
+		return Py_BadArgument();
+
+	char * szFileName;
+	if (!PyTuple_GetString(poArgs, 2, &szFileName))
+		return Py_BadArgument();
+
+	int iWeight = 0;
+	PyTuple_GetInteger(poArgs, 3, &iWeight);
+	iWeight = MIN(100, iWeight);
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
+	pRaceData->RegisterMotionData(iMode, iMotion, c_szFullFileName, iWeight);
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterRaceSrcName(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BadArgument();
+
+	char * szSrcName;
+	if (!PyTuple_GetString(poArgs, 1, &szSrcName))
+		return Py_BadArgument();
+
+	CRaceManager::Instance().RegisterRaceSrcName(szName, szSrcName);
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterRaceName(PyObject* poSelf, PyObject* poArgs)
+{
+	int iRaceIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iRaceIndex))
+		return Py_BadArgument();
+
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 1, &szName))
+		return Py_BadArgument();
+
+	CRaceManager::Instance().RegisterRaceName(iRaceIndex, szName);
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrSetShapeModel(PyObject* poSelf, PyObject* poArgs)
+{
+	int eShape;
+	if (!PyTuple_GetInteger(poArgs, 0, &eShape))
+		return Py_BadArgument();
+
+	char * szFileName;
+	if (!PyTuple_GetString(poArgs, 1, &szFileName))
+		return Py_BadArgument();
+
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->SetShapeModel(eShape, szFileName);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrAppendShapeSkin(PyObject* poSelf, PyObject* poArgs)
+{
+	int eShape;
+	if (!PyTuple_GetInteger(poArgs, 0, &eShape))
+		return Py_BadArgument();
+
+	int ePart;
+	if (!PyTuple_GetInteger(poArgs, 1, &ePart))
+		return Py_BadArgument();
+
+	char * szSrcFileName;
+	if (!PyTuple_GetString(poArgs, 2, &szSrcFileName))
+		return Py_BadArgument();
+
+	char * szDstFileName;
+	if (!PyTuple_GetString(poArgs, 3, &szDstFileName))
+		return Py_BadArgument();
+
+	CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
+	if (!pRaceData)
+		return Py_BuildException("RaceData has not selected!");
+
+	pRaceData->AppendShapeSkin(eShape, ePart, szSrcFileName, szDstFileName);
+	return Py_BuildNone();
+}
+//////////////////////////////////////////////////////////////////////////
+// RaceData <20><><EFBFBD><EFBFBD> <20><>
+//////////////////////////////////////////////////////////////////////////
+
+PyObject * chrmgrSetMovingSpeed(PyObject* poSelf, PyObject* poArgs)
+{
+#ifndef _DISTRIBUTE
+	int	nMovSpd;
+	if (!PyTuple_GetInteger(poArgs, 0, &nMovSpd))
+		return Py_BadArgument();
+
+	if (nMovSpd<0)
+		return Py_BuildException("MovingSpeed < 0");
+	
+	CInstanceBase * pkInst = CPythonCharacterManager::Instance().GetSelectedInstancePtr();
+
+	if (!pkInst)
+		return Py_BuildException("MainCharacter has not selected!");
+
+	pkInst->SetMoveSpeed(nMovSpd);
+#endif
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterEffect(PyObject* poSelf, PyObject* poArgs)
+{
+	int eEftType;
+	if (!PyTuple_GetInteger(poArgs, 0, &eEftType))
+		return Py_BadArgument();
+
+	char * szBoneName;
+	if (!PyTuple_GetString(poArgs, 1, &szBoneName))
+		return Py_BadArgument();
+	
+	char * szPathName;
+	if (!PyTuple_GetString(poArgs, 2, &szPathName))
+		return Py_BadArgument();
+
+	CInstanceBase::RegisterEffect(eEftType, szBoneName, szPathName, false);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterCacheEffect(PyObject* poSelf, PyObject* poArgs)
+{
+	int eEftType;
+	if (!PyTuple_GetInteger(poArgs, 0, &eEftType))
+		return Py_BadArgument();
+
+	char * szBoneName;
+	if (!PyTuple_GetString(poArgs, 1, &szBoneName))
+		return Py_BadArgument();
+	
+	char * szPathName;
+	if (!PyTuple_GetString(poArgs, 2, &szPathName))
+		return Py_BadArgument();
+
+	CInstanceBase::RegisterEffect(eEftType, szBoneName, szPathName, true);
+
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrSetDustGap(PyObject* poSelf, PyObject* poArgs)
+{
+	int nGap;
+	if (!PyTuple_GetInteger(poArgs, 0, &nGap))
+		return Py_BadArgument();
+
+	CInstanceBase::SetDustGap(nGap);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrSetHorseDustGap(PyObject* poSelf, PyObject* poArgs)
+{
+	int nGap;
+	if (!PyTuple_GetInteger(poArgs, 0, &nGap))
+		return Py_BadArgument();
+
+	CInstanceBase::SetHorseDustGap(nGap);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrToggleDirectionLine(PyObject* poSelf, PyObject* poArgs)
+{
+	static bool s_isVisible=true;
+	CActorInstance::ShowDirectionLine(s_isVisible);
+
+	s_isVisible=!s_isVisible;
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrRegisterPointEffect(PyObject* poSelf, PyObject* poArgs)
+{
+	int iEft;
+	if (!PyTuple_GetInteger(poArgs, 0, &iEft))
+		return Py_BadArgument();
+
+	char * szFileName;
+	if (!PyTuple_GetString(poArgs, 1, &szFileName))
+		return Py_BadArgument();
+
+	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+	rkChrMgr.RegisterPointEffect(iEft, szFileName);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrShowPointEffect(PyObject* poSelf, PyObject* poArgs)
+{
+	int nVID;
+	if (!PyTuple_GetInteger(poArgs, 0, &nVID))
+		return Py_BadArgument();
+
+	int nEft;
+	if (!PyTuple_GetInteger(poArgs, 1, &nEft))
+		return Py_BadArgument();
+
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
+	rkChrMgr.ShowPointEffect(nEft, nVID >= 0 ? nVID : 0xffffffff);
+	return Py_BuildNone();
+}
+
+
+void CPythonCharacterManager::SCRIPT_SetAffect(DWORD dwVID, DWORD eState, BOOL isVisible)
+{
+	CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
+	if (!pkInstSel)
+		return;
+
+	pkInstSel->SCRIPT_SetAffect(eState, isVisible ? true : false);
+}
+
+PyObject * chrmgrSetAffect(PyObject* poSelf, PyObject* poArgs)
+{
+	int nVID;
+	if (!PyTuple_GetInteger(poArgs, 0, &nVID))
+		return Py_BadArgument();
+
+	int nEft;
+	if (!PyTuple_GetInteger(poArgs, 1, &nEft))
+		return Py_BadArgument();
+
+	int nVisible;
+	if (!PyTuple_GetInteger(poArgs, 2, &nVisible))
+		return Py_BadArgument();
+
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
+	rkChrMgr.SCRIPT_SetAffect(nVID >= 0 ? nVID : 0xffffffff, nEft, nVisible);
+	return Py_BuildNone();
+}
+
+void CPythonCharacterManager::SetEmoticon(DWORD dwVID, DWORD eState)
+{
+	CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
+	if (!pkInstSel)
+		return;
+	
+	pkInstSel->SetEmoticon(eState);
+}
+
+bool CPythonCharacterManager::IsPossibleEmoticon(DWORD dwVID)
+{
+	CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
+	if (!pkInstSel)
+		return false;
+	
+	return pkInstSel->IsPossibleEmoticon();
+}
+
+PyObject * chrmgrSetEmoticon(PyObject* poSelf, PyObject* poArgs)
+{
+	int nVID;
+	if (!PyTuple_GetInteger(poArgs, 0, &nVID))
+		return Py_BadArgument();
+	
+	int nEft;
+	if (!PyTuple_GetInteger(poArgs, 1, &nEft))
+		return Py_BadArgument();
+	
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
+	rkChrMgr.SetEmoticon(nVID >= 0 ? nVID : 0xffffffff, nEft);
+	return Py_BuildNone();
+}
+
+PyObject * chrmgrIsPossibleEmoticon(PyObject* poSelf, PyObject* poArgs)
+{	
+	int nVID;
+	if (!PyTuple_GetInteger(poArgs, 0, &nVID))
+		return Py_BadArgument();
+
+	CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
+	int result = rkChrMgr.IsPossibleEmoticon(nVID >= 0 ? nVID : 0xffffffff);
+
+	return Py_BuildValue("i", result);
+}
+
+void initchrmgr()
+{
+	static PyMethodDef s_methods[] =
+	{
+		// RaceData <20><><EFBFBD><EFBFBD>		
+		{ "SetEmpireNameMode",			chrmgrSetEmpireNameMode,				METH_VARARGS },
+		{ "GetVIDInfo",					chrmgrGetVIDInfo,						METH_VARARGS },
+		{ "GetPickedVID",				chrmgrGetPickedVID,						METH_VARARGS },
+		{ "SetShapeModel",				chrmgrSetShapeModel,					METH_VARARGS },
+		{ "AppendShapeSkin",			chrmgrAppendShapeSkin,					METH_VARARGS },
+		{ "SetPathName",				chrmgrSetPathName,						METH_VARARGS },
+		{ "LoadRaceData",				chrmgrLoadRaceData,						METH_VARARGS },
+		{ "LoadLocalRaceData",			chrmgrLoadLocalRaceData,				METH_VARARGS },
+		{ "CreateRace",					chrmgrCreateRace,						METH_VARARGS },
+		{ "SelectRace",					chrmgrSelectRace,						METH_VARARGS },
+		{ "RegisterAttachingBoneName",	chrmgrRegisterAttachingBoneName,		METH_VARARGS },
+		{ "RegisterMotionMode",			chrmgrRegisterMotionMode,				METH_VARARGS },
+		//{ "RegisterMotion",				chrmgrRegisterMotion,					METH_VARARGS },
+		{ "SetMotionRandomWeight",		chrmgrSetMotionRandomWeight,			METH_VARARGS },
+		{ "RegisterNormalAttack",		chrmgrRegisterNormalAttack,				METH_VARARGS },
+		{ "ReserveComboAttack",			chrmgrReserveComboAttack,				METH_VARARGS },
+		{ "RegisterComboAttack",		chrmgrRegisterComboAttack,				METH_VARARGS },
+		{ "ReserveComboAttackNew",		chrmgrReserveComboAttackNew,			METH_VARARGS },
+		{ "RegisterComboAttackNew",		chrmgrRegisterComboAttackNew,			METH_VARARGS },
+		{ "RegisterMotionData",			chrmgrRegisterMotionData,				METH_VARARGS },
+		{ "RegisterRaceName",			chrmgrRegisterRaceName,					METH_VARARGS },
+		{ "RegisterRaceSrcName",		chrmgrRegisterRaceSrcName,					METH_VARARGS },
+		{ "RegisterCacheMotionData",	chrmgrRegisterCacheMotionData,			METH_VARARGS },
+
+		// ETC
+		{ "SetAffect",					chrmgrSetAffect,						METH_VARARGS },
+		{ "SetEmoticon",				chrmgrSetEmoticon,						METH_VARARGS },
+		{ "IsPossibleEmoticon",			chrmgrIsPossibleEmoticon,				METH_VARARGS },
+		{ "RegisterEffect",				chrmgrRegisterEffect,					METH_VARARGS },
+		{ "RegisterCacheEffect",		chrmgrRegisterCacheEffect,				METH_VARARGS },
+		{ "RegisterPointEffect",		chrmgrRegisterPointEffect,				METH_VARARGS },
+		{ "ShowPointEffect",			chrmgrShowPointEffect,					METH_VARARGS },
+		{ "ToggleDirectionLine",		chrmgrToggleDirectionLine,				METH_VARARGS },
+		{ "SetMovingSpeed",				chrmgrSetMovingSpeed,					METH_VARARGS },
+		{ "SetDustGap",					chrmgrSetDustGap,						METH_VARARGS },
+		{ "SetHorseDustGap",			chrmgrSetHorseDustGap,					METH_VARARGS },
+
+		{ "RegisterTitleName",			chrmgrRegisterTitleName,				METH_VARARGS },
+		{ "RegisterNameColor",			chrmgrRegisterNameColor,				METH_VARARGS },
+		{ "RegisterTitleColor",			chrmgrRegisterTitleColor,				METH_VARARGS },
+
+		{ NULL,							NULL,									NULL },
+	};	
+
+	PyObject * poModule = Py_InitModule("chrmgr", s_methods);
+
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_MOB", CInstanceBase::NAMECOLOR_NORMAL_MOB);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_NPC", CInstanceBase::NAMECOLOR_NORMAL_NPC);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_PC", CInstanceBase::NAMECOLOR_NORMAL_PC);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_MOB", CInstanceBase::NAMECOLOR_EMPIRE_MOB);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_NPC", CInstanceBase::NAMECOLOR_EMPIRE_NPC);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_PC", CInstanceBase::NAMECOLOR_EMPIRE_PC);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_FUNC", CInstanceBase::NAMECOLOR_FUNC);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_PK", CInstanceBase::NAMECOLOR_PK);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_PVP", CInstanceBase::NAMECOLOR_PVP);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_PARTY", CInstanceBase::NAMECOLOR_PARTY);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_WARP", CInstanceBase::NAMECOLOR_WARP);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_WAYPOINT", CInstanceBase::NAMECOLOR_WAYPOINT);
+	PyModule_AddIntConstant(poModule, "NAMECOLOR_EXTRA", CInstanceBase::NAMECOLOR_EXTRA);
+	
+	PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_DISAPPEAR",		CInstanceBase::EFFECT_SPAWN_DISAPPEAR);
+	PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_APPEAR",		CInstanceBase::EFFECT_SPAWN_APPEAR);
+	PyModule_AddIntConstant(poModule, "EFFECT_DUST",				CInstanceBase::EFFECT_DUST);
+	PyModule_AddIntConstant(poModule, "EFFECT_HORSE_DUST",			CInstanceBase::EFFECT_HORSE_DUST);
+	PyModule_AddIntConstant(poModule, "EFFECT_STUN",				CInstanceBase::EFFECT_STUN);
+	PyModule_AddIntConstant(poModule, "EFFECT_HIT",					CInstanceBase::EFFECT_HIT);
+	PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACK",		CInstanceBase::EFFECT_FLAME_ATTACK);
+	PyModule_AddIntConstant(poModule, "EFFECT_FLAME_HIT",			CInstanceBase::EFFECT_FLAME_HIT);
+	PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACH",		CInstanceBase::EFFECT_FLAME_ATTACH);
+	PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACK",		CInstanceBase::EFFECT_ELECTRIC_ATTACK);
+	PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_HIT",		CInstanceBase::EFFECT_ELECTRIC_HIT);
+	PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACH",		CInstanceBase::EFFECT_ELECTRIC_ATTACH);
+	PyModule_AddIntConstant(poModule, "EFFECT_SELECT",				CInstanceBase::EFFECT_SELECT);
+	PyModule_AddIntConstant(poModule, "EFFECT_TARGET",				CInstanceBase::EFFECT_TARGET);
+	PyModule_AddIntConstant(poModule, "EFFECT_CRITICAL",			CInstanceBase::EFFECT_CRITICAL);
+
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGET",		CInstanceBase::EFFECT_DAMAGE_TARGET);
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_NOT_TARGET",	CInstanceBase::EFFECT_DAMAGE_NOT_TARGET);
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE",	CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE);
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE2",	CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE2);
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_POISON",		CInstanceBase::EFFECT_DAMAGE_POISON);
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_MISS",			CInstanceBase::EFFECT_DAMAGE_MISS);
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGETMISS",	CInstanceBase::EFFECT_DAMAGE_TARGETMISS);
+	PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_CRITICAL",		CInstanceBase::EFFECT_DAMAGE_CRITICAL);
+
+	PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP",				CInstanceBase::EFFECT_LEVELUP);
+	PyModule_AddIntConstant(poModule, "EFFECT_SKILLUP",				CInstanceBase::EFFECT_SKILLUP);
+	PyModule_AddIntConstant(poModule, "EFFECT_HPUP_RED",			CInstanceBase::EFFECT_HPUP_RED);
+	PyModule_AddIntConstant(poModule, "EFFECT_SPUP_BLUE",			CInstanceBase::EFFECT_SPUP_BLUE);
+	PyModule_AddIntConstant(poModule, "EFFECT_SPEEDUP_GREEN",		CInstanceBase::EFFECT_SPEEDUP_GREEN);
+	PyModule_AddIntConstant(poModule, "EFFECT_DXUP_PURPLE",			CInstanceBase::EFFECT_DXUP_PURPLE);
+	PyModule_AddIntConstant(poModule, "EFFECT_PENETRATE",			CInstanceBase::EFFECT_PENETRATE);
+	PyModule_AddIntConstant(poModule, "EFFECT_BLOCK",				CInstanceBase::EFFECT_BLOCK);
+	PyModule_AddIntConstant(poModule, "EFFECT_DODGE",				CInstanceBase::EFFECT_DODGE);
+	PyModule_AddIntConstant(poModule, "EFFECT_FIRECRACKER",			CInstanceBase::EFFECT_FIRECRACKER);
+	PyModule_AddIntConstant(poModule, "EFFECT_SPIN_TOP",			CInstanceBase::EFFECT_SPIN_TOP);
+
+	PyModule_AddIntConstant(poModule, "EFFECT_WEAPON",				CInstanceBase::EFFECT_WEAPON);
+
+	PyModule_AddIntConstant(poModule, "EFFECT_AFFECT",				CInstanceBase::EFFECT_AFFECT);
+	PyModule_AddIntConstant(poModule, "EFFECT_EMOTICON",			CInstanceBase::EFFECT_EMOTICON);
+	PyModule_AddIntConstant(poModule, "EFFECT_EMPIRE",				CInstanceBase::EFFECT_EMPIRE);
+
+	PyModule_AddIntConstant(poModule, "EFFECT_REFINED",				CInstanceBase::EFFECT_REFINED);
+
+	PyModule_AddIntConstant(poModule, "EFFECT_SUCCESS",				CInstanceBase::EFFECT_SUCCESS) ;
+	PyModule_AddIntConstant(poModule, "EFFECT_FAIL",				CInstanceBase::EFFECT_FAIL) ;
+	PyModule_AddIntConstant(poModule, "EFFECT_FR_SUCCESS",				CInstanceBase::EFFECT_FR_SUCCESS) ;	
+	PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_ON_14_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_ON_14_FOR_GERMANY );	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 14<31>϶<EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> )
+	PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_UNDER_15_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_UNDER_15_FOR_GERMANY );//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 15<31>϶<EFBFBD> ( <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> )
+	PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE1",				CInstanceBase::EFFECT_PERCENT_DAMAGE1);	
+	PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE2",				CInstanceBase::EFFECT_PERCENT_DAMAGE2);	
+	PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE3",				CInstanceBase::EFFECT_PERCENT_DAMAGE3);
+
+	// <20>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD> HP, SP
+	PyModule_AddIntConstant(poModule, "EFFECT_AUTO_HPUP",					CInstanceBase::EFFECT_AUTO_HPUP);
+	PyModule_AddIntConstant(poModule, "EFFECT_AUTO_SPUP",					CInstanceBase::EFFECT_AUTO_SPUP);
+
+	PyModule_AddIntConstant(poModule, "EFFECT_RAMADAN_RING_EQUIP",			CInstanceBase::EFFECT_RAMADAN_RING_EQUIP);
+	PyModule_AddIntConstant(poModule, "EFFECT_HALLOWEEN_CANDY_EQUIP",		CInstanceBase::EFFECT_HALLOWEEN_CANDY_EQUIP);
+	PyModule_AddIntConstant(poModule, "EFFECT_HAPPINESS_RING_EQUIP",		CInstanceBase::EFFECT_HAPPINESS_RING_EQUIP);
+	PyModule_AddIntConstant(poModule, "EFFECT_LOVE_PENDANT_EQUIP",		CInstanceBase::EFFECT_LOVE_PENDANT_EQUIP);
+	
+}

src/UserInterface/PythonChat.cpp

@@ -0,0 +1,833 @@
+#include "StdAfx.h"
+#include "PythonChat.h"
+
+#include "AbstractApplication.h"
+#include "PythonCharacterManager.h"
+#include "../eterbase/Timer.h"
+
+int CPythonChat::TChatSet::ms_iChatModeSize = CHAT_TYPE_MAX_NUM;
+
+const float c_fStartDisappearingTime = 5.0f;
+const int c_iMaxLineCount = 5;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+CDynamicPool<CPythonChat::SChatLine> CPythonChat::SChatLine::ms_kPool;
+
+void CPythonChat::SetChatColor(UINT eType, UINT r, UINT g, UINT b)
+{
+	if (eType>=CHAT_TYPE_MAX_NUM)
+		return;
+
+	DWORD dwColor=(0xff000000)|(r<<16)|(g<<8)|(b);
+	m_akD3DXClrChat[eType]=D3DXCOLOR(dwColor);	
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+CPythonChat::SChatLine* CPythonChat::SChatLine::New()
+{
+	return ms_kPool.Alloc();
+}
+
+void CPythonChat::SChatLine::Delete(CPythonChat::SChatLine* pkChatLine)
+{
+	pkChatLine->Instance.Destroy();
+	ms_kPool.Free(pkChatLine);
+}
+
+void CPythonChat::SChatLine::DestroySystem()
+{
+	ms_kPool.Destroy();	
+}
+
+void CPythonChat::SChatLine::SetColor(DWORD dwID, DWORD dwColor)
+{
+	assert(dwID < CHAT_LINE_COLOR_ARRAY_MAX_NUM);
+
+	if (dwID >= CHAT_LINE_COLOR_ARRAY_MAX_NUM)
+		return;
+
+	aColor[dwID] = dwColor;
+}
+
+void CPythonChat::SChatLine::SetColorAll(DWORD dwColor)
+{
+	for (int i = 0; i < CHAT_LINE_COLOR_ARRAY_MAX_NUM; ++i)
+		aColor[i] = dwColor;
+}
+
+D3DXCOLOR & CPythonChat::SChatLine::GetColorRef(DWORD dwID)
+{
+	assert(dwID < CHAT_LINE_COLOR_ARRAY_MAX_NUM);
+
+	if (dwID >= CHAT_LINE_COLOR_ARRAY_MAX_NUM)
+	{
+		static D3DXCOLOR color(1.0f, 0.0f, 0.0f, 1.0f);
+		return color;
+	}
+
+	return aColor[dwID];
+}
+
+CPythonChat::SChatLine::SChatLine()
+{
+	for (int i = 0; i < CHAT_LINE_COLOR_ARRAY_MAX_NUM; ++i)
+		aColor[i] = 0xff0000ff;
+}
+CPythonChat::SChatLine::~SChatLine() 
+{
+	Instance.Destroy();
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+int CPythonChat::CreateChatSet(DWORD dwID)
+{
+	m_ChatSetMap.insert(std::make_pair(dwID, TChatSet()));
+	return dwID;
+}
+
+void CPythonChat::UpdateViewMode(DWORD dwID)
+{
+	IAbstractApplication& rApp=IAbstractApplication::GetSingleton();
+
+	float fcurTime = rApp.GetGlobalTime();
+	//float felapsedTime = rApp.GetGlobalElapsedTime();
+
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
+	int iLineIndex = pLineList->size();
+	int iHeight = -(int(pLineList->size()+1) * pChatSet->m_iStep);
+
+	TChatLineList::iterator itor;
+	for (itor = pLineList->begin(); itor != pLineList->end();)
+	{
+		TChatLine * pChatLine = (*itor);
+
+		D3DXCOLOR & rColor = pChatLine->GetColorRef(dwID);
+
+		float fElapsedTime = (fcurTime - pChatLine->fAppendedTime);
+		if (fElapsedTime >= c_fStartDisappearingTime || iLineIndex >= c_iMaxLineCount)
+		{
+			rColor.a -= rColor.a / 10.0f;
+
+			if (rColor.a <= 0.1f)
+			{
+				itor = pLineList->erase(itor);
+			}
+			else
+			{
+				++itor;
+			}
+		}
+		else
+		{
+			++itor;
+		}
+
+		/////
+
+		iHeight += pChatSet->m_iStep;
+		--iLineIndex;
+
+		pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
+		pChatLine->Instance.SetColor(rColor);
+		pChatLine->Instance.Update();
+	}
+}
+
+void CPythonChat::UpdateEditMode(DWORD dwID)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	const int c_iAlphaLine = max(0, GetVisibleLineCount(dwID) - GetEditableLineCount(dwID) + 2);
+
+	int iLineIndex = 0;
+	float fAlpha = 0.0f;
+	float fAlphaStep = 0.0f;
+
+	if (c_iAlphaLine > 0)
+		fAlphaStep = 1.0f / float(c_iAlphaLine);
+
+	TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
+	int iHeight = -(int(pLineList->size()+1) * pChatSet->m_iStep);
+
+	for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
+	{
+		TChatLine * pChatLine = (*itor);
+
+		D3DXCOLOR & rColor = pChatLine->GetColorRef(dwID);
+
+		if (iLineIndex < c_iAlphaLine)
+		{
+			rColor.a += (fAlpha - rColor.a) / 10.0f;
+			fAlpha = fMIN(fAlpha+fAlphaStep, 1.0f);
+		}
+		else
+		{
+			rColor.a = fMIN(rColor.a+0.05f, 1.0f);
+		}
+
+		iHeight += pChatSet->m_iStep;
+		pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
+		pChatLine->Instance.SetColor(rColor);
+		pChatLine->Instance.Update();
+	}
+}
+
+void CPythonChat::UpdateLogMode(DWORD dwID)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
+	int iHeight = 0;
+
+	for (TChatLineList::reverse_iterator itor = pLineList->rbegin(); itor != pLineList->rend(); ++itor)
+	{
+		TChatLine * pChatLine = (*itor);
+
+		iHeight -= pChatSet->m_iStep;
+		pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
+		pChatLine->Instance.SetColor(pChatLine->GetColorRef(dwID));
+		pChatLine->Instance.Update();
+	}
+}
+
+void CPythonChat::Update(DWORD dwID)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	switch (pChatSet->m_iBoardState)
+	{
+		case BOARD_STATE_VIEW:
+			UpdateViewMode(dwID);
+			break;
+		case BOARD_STATE_EDIT:
+			UpdateEditMode(dwID);
+			break;
+		case BOARD_STATE_LOG:
+			UpdateLogMode(dwID);
+			break;
+	}
+
+	DWORD dwcurTime = CTimer::Instance().GetCurrentMillisecond();
+	for (TWaitChatList::iterator itor = m_WaitChatList.begin(); itor != m_WaitChatList.end();)
+	{
+		TWaitChat & rWaitChat = *itor;
+
+		if (rWaitChat.dwAppendingTime < dwcurTime)
+		{
+			AppendChat(rWaitChat.iType, rWaitChat.strChat.c_str());
+
+			itor = m_WaitChatList.erase(itor);
+		}
+		else
+		{
+			++itor;
+		}
+	}
+}
+
+void CPythonChat::Render(DWORD dwID)
+{
+	TChatLineList * pLineList = GetChatLineListPtr(dwID);
+	if (!pLineList)
+		return;
+
+	for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
+	{
+		CGraphicTextInstance & rInstance = (*itor)->Instance;
+		rInstance.Render();
+	}
+}
+
+
+void CPythonChat::SetBoardState(DWORD dwID, int iState)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_iBoardState = iState;
+	ArrangeShowingChat(dwID);
+}
+void CPythonChat::SetPosition(DWORD dwID, int ix, int iy)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_ix = ix;
+	pChatSet->m_iy = iy;
+}
+void CPythonChat::SetHeight(DWORD dwID, int iHeight)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_iHeight = iHeight;
+}
+void CPythonChat::SetStep(DWORD dwID, int iStep)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_iStep = iStep;
+}
+void CPythonChat::ToggleChatMode(DWORD dwID, int iMode)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_iMode[iMode] = 1 - pChatSet->m_iMode[iMode];
+// 	Tracef("ToggleChatMode : %d\n", iMode);
+	ArrangeShowingChat(dwID);
+}
+void CPythonChat::EnableChatMode(DWORD dwID, int iMode)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_iMode[iMode] = TRUE;
+// 	Tracef("EnableChatMode : %d\n", iMode);
+	ArrangeShowingChat(dwID);
+}
+void CPythonChat::DisableChatMode(DWORD dwID, int iMode)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_iMode[iMode] = FALSE;
+// 	Tracef("DisableChatMode : %d\n", iMode);
+	ArrangeShowingChat(dwID);
+}
+void CPythonChat::SetEndPos(DWORD dwID, float fPos)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	fPos = max(0.0f, fPos);
+	fPos = min(1.0f, fPos);
+	if (pChatSet->m_fEndPos != fPos)
+	{
+		pChatSet->m_fEndPos = fPos;
+		ArrangeShowingChat(dwID);
+	}
+}
+
+
+int CPythonChat::GetVisibleLineCount(DWORD dwID)
+{
+	TChatLineList * pLineList = GetChatLineListPtr(dwID);
+	if (!pLineList)
+		return 0;
+
+	return pLineList->size();
+}
+
+int CPythonChat::GetEditableLineCount(DWORD dwID)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return 0;
+
+	return pChatSet->m_iHeight / pChatSet->m_iStep + 1;
+}
+
+int CPythonChat::GetLineCount(DWORD dwID)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return 0;
+
+	int iCount = 0;
+	for (DWORD i = 0; i < m_ChatLineDeque.size(); ++i)
+	{
+		if (!pChatSet->CheckMode(m_ChatLineDeque[i]->iType))
+			continue;
+
+		++iCount;
+	}
+
+	return iCount;
+}
+
+int CPythonChat::GetLineStep(DWORD dwID)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return 0;
+
+	return pChatSet->m_iStep;
+}
+
+CPythonChat::TChatLineList * CPythonChat::GetChatLineListPtr(DWORD dwID)
+{
+	TChatSetMap::iterator itor = m_ChatSetMap.find(dwID);
+	if (m_ChatSetMap.end() == itor)
+		return NULL;
+
+	TChatSet & rChatSet = itor->second;
+	return &(rChatSet.m_ShowingChatLineList);
+}
+
+CPythonChat::TChatSet * CPythonChat::GetChatSetPtr(DWORD dwID)
+{
+	TChatSetMap::iterator itor = m_ChatSetMap.find(dwID);
+	if (m_ChatSetMap.end() == itor)
+		return NULL;
+
+	TChatSet & rChatSet = itor->second;
+	return &rChatSet;
+}
+
+void CPythonChat::ArrangeShowingChat(DWORD dwID)
+{
+	TChatSet * pChatSet = GetChatSetPtr(dwID);
+	if (!pChatSet)
+		return;
+
+	pChatSet->m_ShowingChatLineList.clear();
+
+	TChatLineDeque TempChatLineDeque;
+	for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
+	{
+		TChatLine * pChatLine = *itor;
+		if (pChatSet->CheckMode(pChatLine->iType))
+			TempChatLineDeque.push_back(pChatLine);
+	}
+
+	int icurLineCount = TempChatLineDeque.size();
+	int iVisibleLineCount = min(icurLineCount, (pChatSet->m_iHeight + pChatSet->m_iStep) / pChatSet->m_iStep);
+	int iEndLine = iVisibleLineCount + int(float(icurLineCount - iVisibleLineCount - 1) * pChatSet->m_fEndPos);
+
+	/////
+
+	int iHeight = 12;
+	for (int i = min(icurLineCount-1, iEndLine); i >= 0; --i)
+	{
+		if (!pChatSet->CheckMode(TempChatLineDeque[i]->iType))
+			continue;
+
+		if (pChatSet->m_iHeight + pChatSet->m_iStep <= iHeight)
+		{
+			break;
+		}
+
+		pChatSet->m_ShowingChatLineList.push_front(TempChatLineDeque[i]);
+
+		iHeight += pChatSet->m_iStep;
+	}
+}
+
+void CPythonChat::AppendChat(int iType, const char * c_szChat)
+{
+	// DEFAULT_FONT
+	//static CResource * s_pResource = CResourceManager::Instance().GetResourcePointer(g_strDefaultFontName.c_str());
+
+	CGraphicText* pkDefaultFont = static_cast<CGraphicText*>(DefaultFont_GetResource());
+	if (!pkDefaultFont)
+	{
+		TraceError("CPythonChat::AppendChat - CANNOT_FIND_DEFAULT_FONT");
+		return;
+	}
+	// END_OF_DEFAULT_FONT
+
+	IAbstractApplication& rApp=IAbstractApplication::GetSingleton();
+	SChatLine * pChatLine = SChatLine::New();
+	pChatLine->iType = iType;
+	pChatLine->Instance.SetValue(c_szChat);
+
+	// DEFAULT_FONT
+	pChatLine->Instance.SetTextPointer(pkDefaultFont);
+	// END_OF_DEFAULT_FONT
+
+	pChatLine->fAppendedTime = rApp.GetGlobalTime();
+	pChatLine->SetColorAll(GetChatColor(iType));
+
+	m_ChatLineDeque.push_back(pChatLine);
+	if (m_ChatLineDeque.size() > CHAT_LINE_MAX_NUM)
+	{
+		SChatLine * pChatLine = m_ChatLineDeque.front();
+		SChatLine::Delete(pChatLine);
+		m_ChatLineDeque.pop_front();
+	}
+
+	for (TChatSetMap::iterator itor = m_ChatSetMap.begin(); itor != m_ChatSetMap.end(); ++itor)
+	{
+		TChatSet * pChatSet = &(itor->second);
+		//pChatLine->SetColor(itor->first, GetChatColor(iType));
+
+		// Edit Mode <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>߱<EFBFBD> <20><><EFBFBD><EFBFBD> <20>߰<EFBFBD>
+		if (BOARD_STATE_EDIT == pChatSet->m_iBoardState)
+		{
+			ArrangeShowingChat(itor->first);
+		}
+		else// if (BOARD_STATE_VIEW == pChatSet->m_iBoardState)
+		{
+			pChatSet->m_ShowingChatLineList.push_back(pChatLine);
+			if (pChatSet->m_ShowingChatLineList.size() > CHAT_LINE_MAX_NUM)
+			{
+				pChatSet->m_ShowingChatLineList.pop_front();
+			}
+		}
+	}
+}
+
+void CPythonChat::AppendChatWithDelay(int iType, const char * c_szChat, int iDelay)
+{
+	TWaitChat WaitChat;
+	WaitChat.iType = iType;
+	WaitChat.strChat = c_szChat;
+	WaitChat.dwAppendingTime = CTimer::Instance().GetCurrentMillisecond() + iDelay;
+	m_WaitChatList.push_back(WaitChat);
+}
+
+DWORD CPythonChat::GetChatColor(int iType)
+{
+	if (iType<CHAT_TYPE_MAX_NUM)
+	{
+		return m_akD3DXClrChat[iType];
+	}
+
+	return D3DXCOLOR(0.0f, 0.0f, 1.0f, 1.0f);
+}
+
+void CPythonChat::IgnoreCharacter(const char * c_szName)
+{
+	TIgnoreCharacterSet::iterator itor = m_IgnoreCharacterSet.find(c_szName);
+	// NOTE : <20>̹<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̶<EFBFBD><CCB6><EFBFBD>..
+	if (m_IgnoreCharacterSet.end() != itor)
+	{
+		m_IgnoreCharacterSet.erase(itor);
+	}
+	// NOTE : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD>Ͷ<EFBFBD><CDB6><EFBFBD>..
+	else
+	{
+		m_IgnoreCharacterSet.insert(c_szName);
+	}
+}
+
+BOOL CPythonChat::IsIgnoreCharacter(const char * c_szName)
+{
+	TIgnoreCharacterSet::iterator itor = m_IgnoreCharacterSet.find(c_szName);
+
+	if (m_IgnoreCharacterSet.end() == itor)
+		return FALSE;
+
+	return TRUE;
+}
+
+CWhisper * CPythonChat::CreateWhisper(const char * c_szName)
+{
+	CWhisper * pWhisper = CWhisper::New();
+	m_WhisperMap.insert(TWhisperMap::value_type(c_szName, pWhisper));
+	return pWhisper;
+}
+
+void CPythonChat::AppendWhisper(int iType, const char * c_szName, const char * c_szChat)
+{
+	TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);
+
+	CWhisper * pWhisper;
+	if (itor == m_WhisperMap.end())
+	{
+		pWhisper = CreateWhisper(c_szName);
+	}
+	else
+	{
+		pWhisper = itor->second;
+	}
+
+	pWhisper->AppendChat(iType, c_szChat);
+}
+
+void CPythonChat::ClearWhisper(const char * c_szName)
+{
+	TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);
+
+	if (itor != m_WhisperMap.end())
+	{
+		CWhisper * pWhisper = itor->second;
+		CWhisper::Delete(pWhisper);
+		
+		m_WhisperMap.erase(itor);
+	}
+}
+
+BOOL CPythonChat::GetWhisper(const char * c_szName, CWhisper ** ppWhisper)
+{
+	TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);
+
+	if (itor == m_WhisperMap.end())
+		return FALSE;
+
+	*ppWhisper = itor->second;
+
+	return TRUE;
+}
+
+void CPythonChat::InitWhisper(PyObject * ppyObject)
+{
+	TWhisperMap::iterator itor = m_WhisperMap.begin();
+	for (; itor != m_WhisperMap.end(); ++itor)
+	{
+		std::string strName = itor->first;
+		PyCallClassMemberFunc(ppyObject, "MakeWhisperButton", Py_BuildValue("(s)", strName.c_str()));
+	}
+}
+
+void CPythonChat::__DestroyWhisperMap()
+{
+	TWhisperMap::iterator itor = m_WhisperMap.begin();
+	for (; itor != m_WhisperMap.end(); ++itor)
+	{
+		CWhisper::Delete(itor->second);
+	}
+	m_WhisperMap.clear();
+}
+
+void CPythonChat::Close()
+{
+	TChatSetMap::iterator itor = m_ChatSetMap.begin();
+	for (; itor != m_ChatSetMap.end(); ++itor)
+	{
+		TChatSet & rChatSet = itor->second;
+		TChatLineList * pLineList = &(rChatSet.m_ShowingChatLineList);
+		for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
+		{
+			TChatLine * pChatLine = (*itor);
+			pChatLine->fAppendedTime = 0.0f;
+		}
+	}
+}
+
+void CPythonChat::Destroy()
+{
+	__DestroyWhisperMap();	
+
+	m_ShowingChatLineList.clear();
+	m_ChatSetMap.clear();
+	m_ChatLineDeque.clear();
+
+	SChatLine::DestroySystem();
+	CWhisper::DestroySystem();
+
+	__Initialize();
+}
+
+void CPythonChat::__Initialize()
+{
+	m_akD3DXClrChat[CHAT_TYPE_TALKING]		= D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
+	m_akD3DXClrChat[CHAT_TYPE_INFO]			= D3DXCOLOR(1.0f, 0.785f, 0.785f, 1.0f);
+	m_akD3DXClrChat[CHAT_TYPE_NOTICE]		= D3DXCOLOR(1.0f, 0.902f, 0.730f, 1.0f);
+	m_akD3DXClrChat[CHAT_TYPE_PARTY]		= D3DXCOLOR(0.542f, 1.0f, 0.949f, 1.0f);
+	m_akD3DXClrChat[CHAT_TYPE_GUILD]		= D3DXCOLOR(0.906f, 0.847f, 1.0f, 1.0f);
+	m_akD3DXClrChat[CHAT_TYPE_COMMAND]		= D3DXCOLOR(0.658f, 1.0f, 0.835f, 1.0f);
+	m_akD3DXClrChat[CHAT_TYPE_SHOUT]		= D3DXCOLOR(0.658f, 1.0f, 0.835f, 1.0f);
+	m_akD3DXClrChat[CHAT_TYPE_WHISPER]		= D3DXCOLOR(0xff4AE14A);
+	m_akD3DXClrChat[CHAT_TYPE_BIG_NOTICE]	= D3DXCOLOR(1.0f, 0.902f, 0.730f, 1.0f);
+}
+
+CPythonChat::CPythonChat()
+{
+	__Initialize();
+}
+
+CPythonChat::~CPythonChat()
+{
+	assert(m_ChatLineDeque.empty());
+	assert(m_ShowingChatLineList.empty());
+	assert(m_ChatSetMap.empty());
+	assert(m_WhisperMap.empty());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+CDynamicPool<CWhisper> CWhisper::ms_kPool;
+
+CWhisper* CWhisper::New()
+{
+	return ms_kPool.Alloc();
+}
+
+void CWhisper::Delete(CWhisper* pkWhisper)
+{
+	pkWhisper->Destroy();
+	ms_kPool.Free(pkWhisper);
+}
+
+void CWhisper::DestroySystem()
+{
+	ms_kPool.Destroy();	
+
+	SChatLine::DestroySystem();	
+}
+
+void CWhisper::SetPosition(float fPosition)
+{
+	m_fcurPosition = fPosition;
+	__ArrangeChat();
+}
+
+void CWhisper::SetBoxSize(float fWidth, float fHeight)
+{
+	m_fWidth = fWidth;
+	m_fHeight = fHeight;
+
+	for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
+	{
+		TChatLine * pChatLine = *itor;
+		pChatLine->Instance.SetLimitWidth(fWidth);
+	}
+}
+
+void CWhisper::AppendChat(int iType, const char * c_szChat)
+{
+	// DEFAULT_FONT
+	//static CResource * s_pResource = CResourceManager::Instance().GetResourcePointer(g_strDefaultFontName.c_str());
+
+#if defined(LOCALE_SERVICE_YMIR) || defined(LOCALE_SERVICE_JAPAN) || defined(LOCALE_SERVICE_HONGKONG) || defined(LOCALE_SERVICE_TAIWAN) || defined(LOCALE_SERVICE_NEWCIBN)
+	CGraphicText* pkDefaultFont = static_cast<CGraphicText*>(DefaultFont_GetResource());
+#else
+	CGraphicText* pkDefaultFont = (iType == CPythonChat::WHISPER_TYPE_GM) ? static_cast<CGraphicText*>(DefaultItalicFont_GetResource()) : static_cast<CGraphicText*>(DefaultFont_GetResource());
+#endif
+
+	if (!pkDefaultFont)
+	{
+		TraceError("CWhisper::AppendChat - CANNOT_FIND_DEFAULT_FONT");
+		return;
+	}
+	// END_OF_DEFAULT_FONT
+
+	SChatLine * pChatLine = SChatLine::New();
+	pChatLine->Instance.SetValue(c_szChat);
+
+	// DEFAULT_FONT
+	pChatLine->Instance.SetTextPointer(pkDefaultFont);
+	// END_OF_DEFAULT_FONT
+
+	pChatLine->Instance.SetLimitWidth(m_fWidth);
+	pChatLine->Instance.SetMultiLine(TRUE);
+
+	switch(iType)
+	{
+		case CPythonChat::WHISPER_TYPE_SYSTEM:
+			pChatLine->Instance.SetColor(D3DXCOLOR(1.0f, 0.785f, 0.785f, 1.0f));
+			break;
+		case CPythonChat::WHISPER_TYPE_GM:
+			pChatLine->Instance.SetColor(D3DXCOLOR(1.0f, 0.632f, 0.0f, 1.0f));
+			break;
+		case CPythonChat::WHISPER_TYPE_CHAT:
+		default:
+			pChatLine->Instance.SetColor(0xffffffff);
+			break;
+	}
+
+	m_ChatLineDeque.push_back(pChatLine);
+
+	__ArrangeChat();
+}
+
+void CWhisper::__ArrangeChat()
+{
+	for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
+	{
+		TChatLine * pChatLine = *itor;
+		pChatLine->Instance.Update();
+	}
+}
+
+void CWhisper::Render(float fx, float fy)
+{
+	float fHeight = fy + m_fHeight;
+
+	int iViewCount = int(m_fHeight / m_fLineStep) - 1;
+	int iLineCount = int(m_ChatLineDeque.size());
+	int iStartLine = -1;
+	if (iLineCount > iViewCount)
+	{
+		iStartLine = int(float(iLineCount-iViewCount) * m_fcurPosition) + iViewCount - 1;
+	}
+	else if (!m_ChatLineDeque.empty())
+	{
+		iStartLine = iLineCount - 1;
+	}
+
+	RECT Rect = { fx, fy, fx+m_fWidth, fy+m_fHeight };
+
+	for (int i = iStartLine; i >= 0; --i)
+	{
+		assert(i >= 0 && i < int(m_ChatLineDeque.size()));
+		TChatLine * pChatLine = m_ChatLineDeque[i];
+
+		WORD wLineCount = pChatLine->Instance.GetTextLineCount();
+		fHeight -= wLineCount * m_fLineStep;
+
+		pChatLine->Instance.SetPosition(fx, fHeight);
+		pChatLine->Instance.Render(&Rect);
+
+		if (fHeight < fy)
+			break;
+	}
+}
+
+void CWhisper::__Initialize()
+{
+	m_fLineStep = 15.0f;
+	m_fWidth = 300.0f;
+	m_fHeight = 120.0f;
+	m_fcurPosition = 1.0f;
+}
+
+void CWhisper::Destroy()
+{
+	std::for_each(m_ChatLineDeque.begin(), m_ChatLineDeque.end(), SChatLine::Delete);
+	m_ChatLineDeque.clear();
+	m_ShowingChatLineList.clear();
+}
+
+CWhisper::CWhisper()
+{
+	__Initialize();
+}
+
+CWhisper::~CWhisper()
+{
+	Destroy();
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+CDynamicPool<CWhisper::SChatLine> CWhisper::SChatLine::ms_kPool;
+
+CWhisper::SChatLine* CWhisper::SChatLine::New()
+{
+	return ms_kPool.Alloc();
+}
+
+void CWhisper::SChatLine::Delete(CWhisper::SChatLine* pkChatLine)
+{
+	pkChatLine->Instance.Destroy();
+	ms_kPool.Free(pkChatLine);
+}
+
+void CWhisper::SChatLine::DestroySystem()
+{
+	ms_kPool.Destroy();	
+}

src/UserInterface/PythonChat.h

@@ -0,0 +1,234 @@
+#pragma once
+
+#include "Packet.h"
+#include "AbstractChat.h"
+
+class CWhisper
+{
+	public:
+		typedef struct SChatLine
+		{
+			CGraphicTextInstance Instance;
+
+			SChatLine()
+			{
+			}
+			~SChatLine()
+			{
+				Instance.Destroy();
+			}
+
+			static void DestroySystem();
+
+			static SChatLine* New();
+			static void Delete(SChatLine* pkChatLine);
+
+			static CDynamicPool<SChatLine> ms_kPool;
+		} TChatLine;
+
+		typedef std::deque<TChatLine*> TChatLineDeque;
+		typedef std::list<TChatLine*> TChatLineList;
+
+	public:
+		CWhisper();
+		~CWhisper();
+
+		void Destroy();
+
+		void SetPosition(float fPosition);
+		void SetBoxSize(float fWidth, float fHeight);
+		void AppendChat(int iType, const char* c_szChat);
+		void Render(float fx, float fy);
+
+	protected:
+		void __Initialize();
+		void __ArrangeChat();
+
+	protected:
+		float m_fLineStep;
+		float m_fWidth;
+		float m_fHeight;
+		float m_fcurPosition;
+
+		TChatLineDeque m_ChatLineDeque;
+		TChatLineList m_ShowingChatLineList;
+
+	public:
+		static void DestroySystem();
+
+		static CWhisper* New();
+		static void Delete(CWhisper* pkWhisper);
+
+		static CDynamicPool<CWhisper>		ms_kPool;
+};
+
+class CPythonChat : public CSingleton<CPythonChat>, public IAbstractChat
+{
+	public:
+		enum EWhisperType
+		{
+			WHISPER_TYPE_CHAT               = 0,
+			WHISPER_TYPE_NOT_EXIST          = 1,
+			WHISPER_TYPE_TARGET_BLOCKED     = 2,
+			WHISPER_TYPE_SENDER_BLOCKED     = 3,
+			WHISPER_TYPE_ERROR              = 4,
+			WHISPER_TYPE_GM                 = 5,
+			WHISPER_TYPE_SYSTEM             = 0xFF
+		};
+
+		enum EBoardState
+		{
+			BOARD_STATE_VIEW,
+			BOARD_STATE_EDIT,
+			BOARD_STATE_LOG,
+		};
+
+		enum
+		{
+			CHAT_LINE_MAX_NUM = 300,
+			CHAT_LINE_COLOR_ARRAY_MAX_NUM = 3,
+		};
+
+		typedef struct SChatLine
+		{
+			int iType;
+			float fAppendedTime;
+			D3DXCOLOR aColor[CHAT_LINE_COLOR_ARRAY_MAX_NUM];
+			CGraphicTextInstance Instance;
+
+			SChatLine();
+			virtual ~SChatLine();
+
+			void SetColor(DWORD dwID, DWORD dwColor);
+			void SetColorAll(DWORD dwColor);
+			D3DXCOLOR & GetColorRef(DWORD dwID);
+			static void DestroySystem();
+
+			static SChatLine* New();
+			static void Delete(SChatLine* pkChatLine);
+
+			static CDynamicPool<SChatLine> ms_kPool;
+		} TChatLine;
+
+		typedef struct SWaitChat
+		{
+			int iType;
+			std::string strChat;
+
+			DWORD dwAppendingTime;
+		} TWaitChat;
+
+		typedef std::deque<TChatLine*> TChatLineDeque;
+		typedef std::list<TChatLine*> TChatLineList;
+
+		typedef std::map<std::string, CWhisper*> TWhisperMap;
+		typedef std::set<std::string> TIgnoreCharacterSet;
+		typedef std::list<TWaitChat> TWaitChatList;
+
+		typedef struct SChatSet
+		{
+			int					m_ix;
+			int					m_iy;
+			int					m_iHeight;
+			int					m_iStep;
+			float				m_fEndPos;
+
+			int					m_iBoardState;
+			std::vector<int>	m_iMode;
+
+			TChatLineList		m_ShowingChatLineList;
+
+			bool CheckMode(DWORD dwType)
+			{
+				if (dwType >= m_iMode.size())
+					return false;
+
+				return m_iMode[dwType] ? true : false;
+			}
+
+			SChatSet()
+			{
+				m_iBoardState = BOARD_STATE_VIEW;
+
+				m_ix = 0;
+				m_iy = 0;
+				m_fEndPos = 1.0f;
+				m_iHeight = 0;
+				m_iStep = 15;
+
+				m_iMode.clear();
+				m_iMode.resize(ms_iChatModeSize, 1);
+			}
+
+			static int ms_iChatModeSize;
+		} TChatSet;
+
+		typedef std::map<int, TChatSet> TChatSetMap;
+
+	public:
+		CPythonChat();
+		virtual ~CPythonChat();
+
+		void SetChatColor(UINT eType, UINT r, UINT g, UINT b);
+
+		void Destroy();
+		void Close();
+
+		int CreateChatSet(DWORD dwID);
+		void Update(DWORD dwID);
+		void Render(DWORD dwID);
+		void RenderWhisper(const char * c_szName, float fx, float fy);
+
+		void SetBoardState(DWORD dwID, int iState);
+		void SetPosition(DWORD dwID, int ix, int iy);
+		void SetHeight(DWORD dwID, int iHeight);
+		void SetStep(DWORD dwID, int iStep);
+		void ToggleChatMode(DWORD dwID, int iMode);
+		void EnableChatMode(DWORD dwID, int iMode);
+		void DisableChatMode(DWORD dwID, int iMode);
+		void SetEndPos(DWORD dwID, float fPos);
+
+		int  GetVisibleLineCount(DWORD dwID);
+		int  GetEditableLineCount(DWORD dwID);
+		int  GetLineCount(DWORD dwID);
+		int  GetLineStep(DWORD dwID);
+
+		// Chat
+		void AppendChat(int iType, const char * c_szChat);
+		void AppendChatWithDelay(int iType, const char * c_szChat, int iDelay);
+		void ArrangeShowingChat(DWORD dwID);
+
+		// Ignore
+		void IgnoreCharacter(const char * c_szName);
+		BOOL IsIgnoreCharacter(const char * c_szName);
+
+		// Whisper
+		CWhisper * CreateWhisper(const char * c_szName);
+		void AppendWhisper(int iType, const char * c_szName, const char * c_szChat);
+		void ClearWhisper(const char * c_szName);
+		BOOL GetWhisper(const char * c_szName, CWhisper ** ppWhisper);
+		void InitWhisper(PyObject * ppyObject);
+
+	protected:
+		void __Initialize();
+		void __DestroyWhisperMap();
+
+		TChatLineList * GetChatLineListPtr(DWORD dwID);
+		TChatSet * GetChatSetPtr(DWORD dwID);
+
+		void UpdateViewMode(DWORD dwID);
+		void UpdateEditMode(DWORD dwID);
+		void UpdateLogMode(DWORD dwID);
+
+		DWORD GetChatColor(int iType);
+
+	protected:
+		TChatLineDeque						m_ChatLineDeque;
+		TChatLineList						m_ShowingChatLineList;
+		TChatSetMap							m_ChatSetMap;
+		TWhisperMap							m_WhisperMap;
+		TIgnoreCharacterSet					m_IgnoreCharacterSet;
+		TWaitChatList						m_WaitChatList;
+
+		D3DXCOLOR m_akD3DXClrChat[CHAT_TYPE_MAX_NUM];
+};

src/UserInterface/PythonChatModule.cpp

@@ -0,0 +1,520 @@
+#include "StdAfx.h"
+#include "PythonChat.h"
+#include "PythonItem.h"
+#include "../gamelib/ItemManager.h"
+
+PyObject * chatSetChatColor(PyObject* poSelf, PyObject* poArgs)
+{
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 0, &iType))
+		return Py_BuildException();
+
+	int r;
+	if (!PyTuple_GetInteger(poArgs, 1, &r))
+		return Py_BuildException();
+
+	int g;
+	if (!PyTuple_GetInteger(poArgs, 2, &g))
+		return Py_BuildException();
+
+	int b;
+	if (!PyTuple_GetInteger(poArgs, 3, &b))
+		return Py_BuildException();
+
+	CPythonChat::Instance().SetChatColor(iType, r, g, b);
+	return Py_BuildNone();
+}
+
+PyObject * chatClear(PyObject* poSelf, PyObject* poArgs)
+{
+	CPythonChat::Instance().Destroy();
+	return Py_BuildNone();
+}
+
+PyObject * chatClose(PyObject* poSelf, PyObject* poArgs)
+{
+	CPythonChat::Instance().Close();
+	return Py_BuildNone();
+}
+
+PyObject * chatCreateChatSet(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+
+	return Py_BuildValue("i", CPythonChat::Instance().CreateChatSet(iID));
+}
+
+PyObject * chatUpdate(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+
+	CPythonChat::Instance().Update(iID);
+	return Py_BuildNone();
+}
+
+PyObject * chatRender(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+
+	CPythonChat::Instance().Render(iID);
+	return Py_BuildNone();
+}
+
+PyObject * chatSetBoardState(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	int iState;
+	if (!PyTuple_GetInteger(poArgs, 1, &iState))
+		return Py_BuildException();
+
+	CPythonChat::Instance().SetBoardState(iID, iState);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatSetPosition(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	int ix;
+	if (!PyTuple_GetInteger(poArgs, 1, &ix))
+		return Py_BuildException();
+	int iy;
+	if (!PyTuple_GetInteger(poArgs, 2, &iy))
+		return Py_BuildException();
+
+	CPythonChat::Instance().SetPosition(iID, ix, iy);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatSetHeight(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	int iHeight;
+	if (!PyTuple_GetInteger(poArgs, 1, &iHeight))
+		return Py_BuildException();
+
+	CPythonChat::Instance().SetHeight(iID, iHeight);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatSetStep(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	int iStep;
+	if (!PyTuple_GetInteger(poArgs, 1, &iStep))
+		return Py_BuildException();
+
+	CPythonChat::Instance().SetStep(iID, iStep);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatToggleChatMode(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 1, &iType))
+		return Py_BuildException();
+
+	CPythonChat::Instance().ToggleChatMode(iID, iType);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatEnableChatMode(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 1, &iType))
+		return Py_BuildException();
+
+	CPythonChat::Instance().EnableChatMode(iID, iType);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatDisableChatMode(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 1, &iType))
+		return Py_BuildException();
+
+	CPythonChat::Instance().DisableChatMode(iID, iType);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatSetEndPos(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+	float fPos;
+	if (!PyTuple_GetFloat(poArgs, 1, &fPos))
+		return Py_BuildException();
+
+	CPythonChat::Instance().SetEndPos(iID, fPos);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatGetLineCount(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+
+	return Py_BuildValue("i", CPythonChat::Instance().GetLineCount(iID));
+}
+
+PyObject * chatGetVisibleLineCount(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+
+	return Py_BuildValue("i", CPythonChat::Instance().GetVisibleLineCount(iID));
+}
+
+PyObject * chatGetLineStep(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+
+	return Py_BuildValue("i", CPythonChat::Instance().GetLineStep(iID));
+}
+
+PyObject * chatAppendChat(PyObject* poSelf, PyObject* poArgs)
+{
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 0, &iType))
+		return Py_BuildException();
+
+	char * szChat;
+	if (!PyTuple_GetString(poArgs, 1, &szChat))
+		return Py_BuildException();
+
+	CPythonChat::Instance().AppendChat(iType, szChat);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatAppendChatWithDelay(PyObject* poSelf, PyObject* poArgs)
+{
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 0, &iType))
+		return Py_BuildException();
+
+	char * szChat;
+	if (!PyTuple_GetString(poArgs, 1, &szChat))
+		return Py_BuildException();
+
+	int iDelay;
+	if (!PyTuple_GetInteger(poArgs, 2, &iDelay))
+		return Py_BuildException();
+
+	CPythonChat::Instance().AppendChatWithDelay(iType, szChat, iDelay);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatArrangeShowingChat(PyObject* poSelf, PyObject* poArgs)
+{
+	int iID;
+	if (!PyTuple_GetInteger(poArgs, 0, &iID))
+		return Py_BuildException();
+
+	CPythonChat::Instance().ArrangeShowingChat(iID);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatIgnoreCharacter(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BuildException();
+
+	CPythonChat::Instance().IgnoreCharacter(szName);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatIsIgnoreCharacter(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BuildException();
+
+	CPythonChat::Instance().IsIgnoreCharacter(szName);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatCreateWhisper(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BuildException();
+
+	CPythonChat::Instance().CreateWhisper(szName);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatAppendWhisper(PyObject* poSelf, PyObject* poArgs)
+{
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 0, &iType))
+		return Py_BuildException();
+
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 1, &szName))
+		return Py_BuildException();
+
+	char * szChat;
+	if (!PyTuple_GetString(poArgs, 2, &szChat))
+		return Py_BuildException();
+
+	CPythonChat::Instance().AppendWhisper(iType, szName, szChat);
+	return Py_BuildNone();
+}
+
+PyObject * chatRenderWhisper(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BuildException();
+
+	float fx;
+	if (!PyTuple_GetFloat(poArgs, 1, &fx))
+		return Py_BuildException();
+
+	float fy;
+	if (!PyTuple_GetFloat(poArgs, 2, &fy))
+		return Py_BuildException();
+
+	CWhisper * pWhisper;
+	if (CPythonChat::Instance().GetWhisper(szName, &pWhisper))
+	{
+		pWhisper->Render(fx, fy);
+	}
+
+	return Py_BuildNone();
+}
+
+PyObject * chatSetWhisperBoxSize(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BuildException();
+
+	float fWidth;
+	if (!PyTuple_GetFloat(poArgs, 1, &fWidth))
+		return Py_BuildException();
+
+	float fHeight;
+	if (!PyTuple_GetFloat(poArgs, 2, &fHeight))
+		return Py_BuildException();
+
+	CWhisper * pWhisper;
+	if (CPythonChat::Instance().GetWhisper(szName, &pWhisper))
+	{
+		pWhisper->SetBoxSize(fWidth, fHeight);
+	}
+
+	return Py_BuildNone();
+}
+
+PyObject * chatSetWhisperPosition(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BuildException();
+
+	float fPosition;
+	if (!PyTuple_GetFloat(poArgs, 1, &fPosition))
+		return Py_BuildException();
+
+	CWhisper * pWhisper;
+	if (CPythonChat::Instance().GetWhisper(szName, &pWhisper))
+	{
+		pWhisper->SetPosition(fPosition);
+	}
+
+	return Py_BuildNone();
+}
+
+PyObject * chatClearWhisper(PyObject* poSelf, PyObject* poArgs)
+{
+	char * szName;
+	if (!PyTuple_GetString(poArgs, 0, &szName))
+		return Py_BuildException();
+
+	CPythonChat::Instance().ClearWhisper(szName);
+
+	return Py_BuildNone();
+}
+
+PyObject * chatInitWhisper(PyObject* poSelf, PyObject* poArgs)
+{
+	PyObject * poInterface;
+	if (!PyTuple_GetObject(poArgs, 0, &poInterface))
+		return Py_BuildException();
+
+	CPythonChat::Instance().InitWhisper(poInterface);
+	return Py_BuildNone();
+}
+
+PyObject * chatGetLinkFromHyperlink(PyObject * poSelf, PyObject * poArgs)
+{
+	char * szHyperlink;
+	
+	if (!PyTuple_GetString(poArgs, 0, &szHyperlink))
+		return Py_BuildException();
+
+	std::string stHyperlink(szHyperlink);
+	std::vector<std::string> results;
+
+	split_string(stHyperlink, ":", results, false);
+
+	// item:vnum:flag:socket0:socket1:socket2
+	if (0 == results[0].compare("item"))
+	{
+		if (results.size() < 6)
+			return Py_BuildValue("s", "");
+
+		CItemData * pItemData = NULL;
+
+		if (CItemManager::Instance().GetItemDataPointer(htoi(results[1].c_str()), &pItemData))
+		{
+			char buf[1024] = { 0 };
+			char itemlink[256];
+			int len;
+			bool isAttr = false;
+
+			len = snprintf(itemlink, sizeof(itemlink), "item:%x:%x:%x:%x:%x", 
+					htoi(results[1].c_str()),
+					htoi(results[2].c_str()),
+					htoi(results[3].c_str()),
+					htoi(results[4].c_str()),
+					htoi(results[5].c_str()));
+
+			if (results.size() >= 8)
+			{
+				for (int i = 6; i < results.size(); i += 2)
+				{
+					len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%d", 
+							htoi(results[i].c_str()),
+							atoi(results[i+1].c_str()));
+					isAttr = true;
+				}
+			}
+
+			if (isAttr)
+				//"item:<3A><>ȣ:<3A>÷<EFBFBD><C3B7><EFBFBD>:<3A><><EFBFBD><EFBFBD>0:<3A><><EFBFBD><EFBFBD>1:<3A><><EFBFBD><EFBFBD>2"
+				snprintf(buf, sizeof(buf), "|cffffc700|H%s|h[%s]|h|r", itemlink, pItemData->GetName());
+			else
+				snprintf(buf, sizeof(buf), "|cfff1e6c0|H%s|h[%s]|h|r", itemlink, pItemData->GetName());
+
+			return Py_BuildValue("s", buf);
+		}
+	}
+
+	return Py_BuildValue("s", "");
+}
+
+void initChat()
+{
+	static PyMethodDef s_methods[] = 
+	{
+		{ "SetChatColor",			chatSetChatColor,			METH_VARARGS },
+		{ "Clear",					chatClear,					METH_VARARGS },
+		{ "Close",					chatClose,					METH_VARARGS },
+
+		{ "CreateChatSet",			chatCreateChatSet,			METH_VARARGS },
+		{ "Update",					chatUpdate,					METH_VARARGS },
+		{ "Render",					chatRender,					METH_VARARGS },
+
+		{ "SetBoardState",			chatSetBoardState,			METH_VARARGS },
+		{ "SetPosition",			chatSetPosition,			METH_VARARGS },
+		{ "SetHeight",				chatSetHeight,				METH_VARARGS },
+		{ "SetStep",				chatSetStep,				METH_VARARGS },
+		{ "ToggleChatMode",			chatToggleChatMode,			METH_VARARGS },
+		{ "EnableChatMode",			chatEnableChatMode,			METH_VARARGS },
+		{ "DisableChatMode",		chatDisableChatMode,		METH_VARARGS },
+		{ "SetEndPos",				chatSetEndPos,				METH_VARARGS },
+
+		{ "GetLineCount",			chatGetLineCount,			METH_VARARGS },
+		{ "GetVisibleLineCount",	chatGetVisibleLineCount,	METH_VARARGS },
+		{ "GetLineStep",			chatGetLineStep,			METH_VARARGS },
+
+		// Chat
+		{ "AppendChat",				chatAppendChat,				METH_VARARGS },
+		{ "AppendChatWithDelay",	chatAppendChatWithDelay,	METH_VARARGS },
+		{ "ArrangeShowingChat",		chatArrangeShowingChat,		METH_VARARGS },
+
+		// Ignore
+		{ "IgnoreCharacter",		chatIgnoreCharacter,		METH_VARARGS },
+		{ "IsIgnoreCharacter",		chatIsIgnoreCharacter,		METH_VARARGS },
+
+		// Whisper
+		{ "CreateWhisper",			chatCreateWhisper,			METH_VARARGS },
+		{ "AppendWhisper",			chatAppendWhisper,			METH_VARARGS },
+		{ "RenderWhisper",			chatRenderWhisper,			METH_VARARGS },
+		{ "SetWhisperBoxSize",		chatSetWhisperBoxSize,		METH_VARARGS },
+		{ "SetWhisperPosition",		chatSetWhisperPosition,		METH_VARARGS },
+		{ "ClearWhisper",			chatClearWhisper,			METH_VARARGS },
+		{ "InitWhisper",			chatInitWhisper,			METH_VARARGS },
+
+		// Link
+		{ "GetLinkFromHyperlink",	chatGetLinkFromHyperlink,	METH_VARARGS },
+
+		{ NULL,						NULL,						NULL },
+	};
+
+	PyObject * poModule = Py_InitModule("chat", s_methods);
+
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_TALKING",		CHAT_TYPE_TALKING);
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_INFO",			CHAT_TYPE_INFO);
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_NOTICE",		CHAT_TYPE_NOTICE);
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_PARTY",		CHAT_TYPE_PARTY);
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_GUILD",		CHAT_TYPE_GUILD);
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_COMMAND",		CHAT_TYPE_COMMAND);
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_SHOUT",		CHAT_TYPE_SHOUT);
+	PyModule_AddIntConstant(poModule, "CHAT_TYPE_WHISPER",		CHAT_TYPE_WHISPER);
+	PyModule_AddIntConstant(poModule, "WHISPER_TYPE_CHAT",		CPythonChat::WHISPER_TYPE_CHAT);
+	PyModule_AddIntConstant(poModule, "WHISPER_TYPE_SYSTEM",	CPythonChat::WHISPER_TYPE_SYSTEM);
+	PyModule_AddIntConstant(poModule, "WHISPER_TYPE_GM",		CPythonChat::WHISPER_TYPE_GM);
+
+	PyModule_AddIntConstant(poModule, "BOARD_STATE_VIEW",		CPythonChat::BOARD_STATE_VIEW);
+	PyModule_AddIntConstant(poModule, "BOARD_STATE_EDIT",		CPythonChat::BOARD_STATE_EDIT);
+	PyModule_AddIntConstant(poModule, "BOARD_STATE_LOG",		CPythonChat::BOARD_STATE_LOG);
+
+	PyModule_AddIntConstant(poModule, "CHAT_SET_CHAT_WINDOW",	0);
+	PyModule_AddIntConstant(poModule, "CHAT_SET_LOG_WINDOW",	1);
+}

src/UserInterface/PythonEffectModule.cpp

@@ -0,0 +1,150 @@
+#include "StdAfx.h"
+#include "../EffectLib/EffectManager.h"
+#include "PythonCharacterManager.h"
+
+PyObject * effectRegisterEffect(PyObject * poSelf, PyObject * poArgs)
+{
+	char * szFileName;
+	if (!PyTuple_GetString(poArgs, 0, &szFileName))
+		return Py_BuildException();
+
+	CEffectManager::Instance().RegisterEffect(szFileName);
+	return Py_BuildNone();
+}
+
+PyObject * effectUpdate(PyObject * poSelf, PyObject * poArgs)
+{
+	CEffectManager::Instance().Update();
+	return Py_BuildNone();
+}
+
+PyObject * effectRender(PyObject * poSelf, PyObject * poArgs)
+{
+	CEffectManager::Instance().Render();
+	return Py_BuildNone();
+}
+
+PyObject * effectCreateEffect(PyObject * poSelf, PyObject * poArgs)
+{
+	char * szEffectName;
+	if (!PyTuple_GetString(poArgs, 0, &szEffectName))
+		return Py_BuildException();
+
+	CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetSelectedInstancePtr();
+	TPixelPosition PixelPosition;
+	pInstance->NEW_GetPixelPosition(&PixelPosition);
+	int iIndex = CEffectManager::Instance().CreateEffect(szEffectName, PixelPosition, D3DXVECTOR3(0.0f, 0.0f, 0.0f));
+
+	return Py_BuildValue("i", iIndex);
+}
+
+PyObject * effectDeleteEffect(PyObject * poSelf, PyObject * poArgs)
+{
+	int iIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
+		return Py_BuildException();
+
+	CEffectManager::Instance().DestroyEffectInstance(iIndex);
+
+	return Py_BuildNone();
+}
+
+PyObject * effectSetPosition(PyObject * poSelf, PyObject * poArgs)
+{
+	int iIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
+		return Py_BuildException();
+	float fx;
+	if (!PyTuple_GetFloat(poArgs, 1, &fx))
+		return Py_BuildException();
+	float fy;
+	if (!PyTuple_GetFloat(poArgs, 2, &fy))
+		return Py_BuildException();
+	float fz;
+	if (!PyTuple_GetFloat(poArgs, 3, &fz))
+		return Py_BuildException();
+
+	CEffectManager::Instance().SelectEffectInstance(iIndex);
+	CEffectManager::Instance().SetEffectInstancePosition(D3DXVECTOR3(fx, fy, fz));
+
+	return Py_BuildNone();
+}
+
+PyObject * effectRegisterIndexedFlyData(PyObject * poSelf, PyObject * poArgs)
+{
+	int iIndex;
+	if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
+		return Py_BuildException();
+	int iType;
+	if (!PyTuple_GetInteger(poArgs, 1, &iType))
+		return Py_BuildException();
+	char * szFlyDataName;
+	if (!PyTuple_GetString(poArgs, 2, &szFlyDataName))
+		return Py_BuildException();
+
+	CFlyingManager::Instance().RegisterIndexedFlyData(iIndex, iType, szFlyDataName);
+
+	return Py_BuildNone();
+}
+
+void initeffect()
+{
+	static PyMethodDef s_methods[] =
+	{
+		{ "RegisterEffect",				effectRegisterEffect,			METH_VARARGS },
+		{ "CreateEffect",				effectCreateEffect,				METH_VARARGS },
+		{ "DeleteEffect",				effectDeleteEffect,				METH_VARARGS },
+		{ "SetPosition",				effectSetPosition,				METH_VARARGS },
+
+		{ "RegisterIndexedFlyData",		effectRegisterIndexedFlyData,	METH_VARARGS },
+
+		{ "Update",						effectUpdate,					METH_VARARGS },
+		{ "Render",						effectRender,					METH_VARARGS },
+
+		{ NULL,							NULL,							NULL         },
+	};
+
+	PyObject * poModule = Py_InitModule("effect", s_methods);
+	PyModule_AddIntConstant(poModule, "INDEX_FLY_TYPE_NORMAL",			CFlyingManager::INDEX_FLY_TYPE_NORMAL);
+	PyModule_AddIntConstant(poModule, "INDEX_FLY_TYPE_FIRE_CRACKER",	CFlyingManager::INDEX_FLY_TYPE_FIRE_CRACKER);
+	PyModule_AddIntConstant(poModule, "INDEX_FLY_TYPE_AUTO_FIRE",		CFlyingManager::INDEX_FLY_TYPE_AUTO_FIRE);
+
+	enum
+	{
+		FLY_NONE,
+		FLY_EXP,
+		FLY_HP_MEDIUM,
+		FLY_HP_BIG,
+		FLY_SP_SMALL,
+		FLY_SP_MEDIUM,
+		FLY_SP_BIG,
+		FLY_FIREWORK1,
+		FLY_FIREWORK2,
+		FLY_FIREWORK3,
+		FLY_FIREWORK4,
+		FLY_FIREWORK5,
+		FLY_FIREWORK6,
+		FLY_FIREWORK_XMAS,
+		FLY_CHAIN_LIGHTNING,
+		FLY_HP_SMALL,
+		FLY_SKILL_MUYEONG,
+	};
+
+	PyModule_AddIntConstant(poModule, "FLY_NONE",				FLY_NONE);
+	PyModule_AddIntConstant(poModule, "FLY_EXP",				FLY_EXP);
+	PyModule_AddIntConstant(poModule, "FLY_HP_MEDIUM",			FLY_HP_MEDIUM);
+	PyModule_AddIntConstant(poModule, "FLY_HP_BIG",				FLY_HP_BIG);
+	PyModule_AddIntConstant(poModule, "FLY_SP_SMALL",			FLY_SP_SMALL);
+	PyModule_AddIntConstant(poModule, "FLY_SP_MEDIUM",			FLY_SP_MEDIUM);
+	PyModule_AddIntConstant(poModule, "FLY_SP_BIG",				FLY_SP_BIG);
+	PyModule_AddIntConstant(poModule, "FLY_FIREWORK1",			FLY_FIREWORK1);
+	PyModule_AddIntConstant(poModule, "FLY_FIREWORK2",			FLY_FIREWORK2);
+	PyModule_AddIntConstant(poModule, "FLY_FIREWORK3",			FLY_FIREWORK3);
+	PyModule_AddIntConstant(poModule, "FLY_FIREWORK4",			FLY_FIREWORK4);
+	PyModule_AddIntConstant(poModule, "FLY_FIREWORK5",			FLY_FIREWORK5);
+	PyModule_AddIntConstant(poModule, "FLY_FIREWORK6",			FLY_FIREWORK6);
+	PyModule_AddIntConstant(poModule, "FLY_FIREWORK_XMAS",		FLY_FIREWORK_XMAS);
+	PyModule_AddIntConstant(poModule, "FLY_CHAIN_LIGHTNING",	FLY_CHAIN_LIGHTNING);
+	PyModule_AddIntConstant(poModule, "FLY_HP_SMALL",			FLY_HP_SMALL);
+	PyModule_AddIntConstant(poModule, "FLY_SKILL_MUYEONG",		FLY_SKILL_MUYEONG);
+}