port 2V2-b: GamePhase dispatch consumes the Entergame burst

PythonNetworkStreamPhaseGame/PhaseGameActor/PhaseGameItem/Command,
NetworkActorManager and PythonChat/PythonChatModule are ported verbatim and
dispatched at runtime; the 2V0 chat stub module is removed and initChat()
runs before initnet() as in 40250. InstanceBase, PythonCharacterManager and
GameLib ActorInstance/RaceData/RaceManager compile but stay TODO until
2V2-c/d wire them.

Units not ported yet get their singletons from PythonBoot's GameSingletons
(CPythonApplication member order) and platform/pending stand-ins generated
by platform_stub.py pending; const char* stand-ins return "".

port.login_flow's fake server now sends the CInputLogin::Entergame order
(actor insert, NPC positions, PHASE_GAME, land list, time, channel, greet
notice, ping) and a TraceError observer asserts no unknown packet header.
port.login_live passes against the real server for 10 s of game phase.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

extension/src/port/UserInterface/InstanceBase.h

@@ -658,7 +658,7 @@ class CInstanceBase
 		bool					NEW_GetInstanceVectorInCircleRange(float fSkillDistance, std::vector<CInstanceBase*>* pkVct_pkInst);
 
 		void					NEW_SetOwner(DWORD dwOwnerVID);
-		void					NEW_SyncPixelPosition(long & nPPosX, long & nPPosY);
+		void					NEW_SyncPixelPosition(LONG & nPPosX, LONG & nPPosY); // PORT: 40250 Win32 long is 32-bit.
 		void					NEW_SyncCurrentPixelPosition();
 
 		void					NEW_SetPixelPosition(const TPixelPosition& c_rkPPosDst);
@@ -1129,4 +1129,4 @@ inline int RaceToSex(int race)
 
 	}
 	return 0;
-}
+}

extension/src/port/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) // PORT: 40250 Win32 long is 32-bit.
+{
+	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;
+
+	// 걷고 있을때는 무조건 멈추게 해야 한다
+	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();
+}

extension/src/port/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.항상 보이기 플래그
+	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) // 거리제한 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);	
+	}
+		
+	
+}

extension/src/port/UserInterface/Packet.h

@@ -2319,8 +2319,9 @@ typedef struct SPacketGCShopSign
 typedef struct SPacketGCTime
 {
     BYTE        bHeader;
-    time_t      time;
+    LONG        time; // PORT: _USE_32BIT_TIME_T in 40250 Win32; wire time is 32 bits on LP64.
 } TPacketGCTime;
+static_assert(sizeof(TPacketGCTime) == 5);
 
 enum
 {

extension/src/port/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 : 일단 기존위치로 원복
+			// TODO : 향후 조금더 잘 처리한다면 physic movement거리를 steping해서 iteration처리해야 함.
+			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 일 경우 죽었을때도 체크하므로, 
+			// 실질적으로 거리가 변경되는 IsPushing일때만 체크하도록 한다
+			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.m_dwVID); // PORT: MSVC accepted a struct through varargs; pass the intended VID.
+		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를 ViewFrustumCheck로 변경
+		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
+
+	// 정밀한 체크
+	{
+		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;
+				}
+			}
+		}
+	}
+
+	// 못찾겠으면 걍 순서대로
+	{
+		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();
+}

extension/src/port/UserInterface/PythonChat.cpp

@@ -0,0 +1,834 @@
+#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 를 억지로 끼워 맞추기 위해 추가
+		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 : 이미 차단 중이라면..
+	if (m_IgnoreCharacterSet.end() != itor)
+	{
+		m_IgnoreCharacterSet.erase(itor);
+	}
+	// NOTE : 차단이 되지 않은 캐릭터라면..
+	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;
+	}
+
+	// PORT: RECT holds the 32-bit Win32 LONG, so static_cast<long> would narrow here.
+	RECT Rect = { static_cast<LONG>(fx), static_cast<LONG>(fy), static_cast<LONG>(fx+m_fWidth), static_cast<LONG>(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();	
+}

extension/src/port/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:%I64d", 
+							htoi(results[i].c_str()),
+							atoi(results[i+1].c_str()));
+					isAttr = true;
+				}
+			}
+
+			if (isAttr)
+				//"item:번호:플래그:소켓0:소켓1:소켓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);
+}

extension/src/port/UserInterface/PythonNetworkStreamCommand.cpp

@@ -0,0 +1,557 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "PythonNonPlayer.h"
+#include "AbstractApplication.h"
+#include "AbstractPlayer.h"
+#include "AbstractCharacterManager.h"
+#include "AbstractChat.h"
+#include "InstanceBase.h"
+
+#define ishan(ch)		(((ch) & 0xE0) > 0x90)
+#define ishanasc(ch)	(isascii(ch) || ishan(ch))
+#define ishanalp(ch)	(isalpha(ch) || ishan(ch))
+#define isnhdigit(ch)	(!ishan(ch) && isdigit(ch))
+#define isnhspace(ch)	(!ishan(ch) && isspace(ch))
+
+#define LOWER(c)		(((c) >= 'A' && (c) <= 'Z') ? ((c) + ('a' - 'A')) : (c))
+#define UPPER(c)		(((c) >= 'a' && (c) <= 'z') ? ((c) + ('A' - 'a')) : (c))
+
+void SkipSpaces(char **string)
+{
+    for (; **string != '\0' && isnhspace((unsigned char) **string); ++(*string));
+}
+
+char *OneArgument(char *argument, char *first_arg)
+{
+    char mark = FALSE;
+
+    if (!argument)
+    {
+        *first_arg = '\0';
+        return NULL;
+    }
+
+    SkipSpaces(&argument);
+
+    while (*argument)
+    {
+        if (*argument == '\"')
+        {
+            mark = !mark;
+            ++argument;
+            continue;
+        }
+
+        if (!mark && isnhspace((unsigned char) *argument))
+            break;
+
+		*(first_arg++) = LOWER(*argument);
+		++argument;
+    }
+
+    *first_arg = '\0';
+
+    SkipSpaces(&argument);
+    return (argument);
+}
+
+void AppendMonsterList(const CPythonNonPlayer::TMobTableList & c_rMobTableList, const char * c_szHeader, int iType)
+{
+	DWORD dwMonsterCount = 0;
+	std::string strMonsterList = c_szHeader;
+
+	CPythonNonPlayer::TMobTableList::const_iterator itor = c_rMobTableList.begin();
+	for (; itor!=c_rMobTableList.end(); ++itor)
+	{
+		const CPythonNonPlayer::TMobTable * c_pMobTable = *itor;
+		if (iType == c_pMobTable->bRank)
+		{
+			if (dwMonsterCount != 0)
+				strMonsterList += ", ";
+			strMonsterList += c_pMobTable->szLocaleName;
+			if (++dwMonsterCount > 5)
+				break;
+		}
+	}
+	if (dwMonsterCount > 0)
+	{
+		IAbstractChat& rkChat=IAbstractChat::GetSingleton();
+		rkChat.AppendChat(CHAT_TYPE_INFO, strMonsterList.c_str());
+	}
+}
+
+bool CPythonNetworkStream::ClientCommand(const char * c_szCommand)
+{
+	return false;
+}
+
+bool SplitToken(const char * c_szLine, CTokenVector * pstTokenVector, const char * c_szDelimeter = " ")
+{
+	pstTokenVector->reserve(10);
+	pstTokenVector->clear();
+
+	std::string stToken;
+	std::string strLine = c_szLine;
+
+	DWORD basePos = 0;
+
+	do
+	{
+		int beginPos = strLine.find_first_not_of(c_szDelimeter, basePos);
+		if (beginPos < 0)
+			return false;
+
+		int endPos;
+
+		if (strLine[beginPos] == '"')
+		{
+			++beginPos;
+			endPos = strLine.find_first_of("\"", beginPos);
+
+			if (endPos < 0)
+				return false;
+			
+			basePos = endPos + 1;
+		}
+		else
+		{
+			endPos = strLine.find_first_of(c_szDelimeter, beginPos);
+			basePos = endPos;
+		}
+
+		pstTokenVector->push_back(strLine.substr(beginPos, endPos - beginPos));
+
+		// 추가 코드. 맨뒤에 탭이 있는 경우를 체크한다. - [levites]
+		if (int(strLine.find_first_not_of(c_szDelimeter, basePos)) < 0)
+			break;
+	} while (basePos < strLine.length());
+
+	return true;
+}
+
+void CPythonNetworkStream::ServerCommand(char * c_szCommand)
+{
+	// #0000811: [M2EU] 콘솔창 기능 차단 
+	if (strcmpi(c_szCommand, "ConsoleEnable") == 0)
+		return;
+
+	if (m_apoPhaseWnd[PHASE_WINDOW_GAME])
+	{
+		bool isTrue;
+		if (PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
+			"BINARY_ServerCommand_Run", 
+			Py_BuildValue("(s)", c_szCommand),
+			&isTrue
+		))
+		{
+			if (isTrue)
+				return;
+		}
+	}
+	else if (m_poSerCommandParserWnd)
+	{
+		bool isTrue;
+		if (PyCallClassMemberFunc(m_poSerCommandParserWnd, 
+			"BINARY_ServerCommand_Run", 
+			Py_BuildValue("(s)", c_szCommand),
+			&isTrue
+		))
+		{
+			if (isTrue)
+				return;
+		}
+	}
+
+	CTokenVector TokenVector;
+	if (!SplitToken(c_szCommand, &TokenVector))
+		return;
+	if (TokenVector.empty())
+		return;
+
+	const char * szCmd = TokenVector[0].c_str();
+	
+	if (!strcmpi(szCmd, "quit"))
+	{
+		PostQuitMessage(0);
+	}
+	else if (!strcmpi(szCmd, "BettingMoney"))
+	{
+		if (2 != TokenVector.size())
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+			return;
+		}
+
+		//UINT uMoney= atoi(TokenVector[1].c_str());		
+		
+	}
+	// GIFT NOTIFY
+	else if (!strcmpi(szCmd, "gift"))
+	{
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "Gift_Show", Py_BuildValue("()")); 	
+	}
+	// CUBE
+	else if (!strcmpi(szCmd, "cube"))
+	{
+		if (TokenVector.size() < 2)
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+			return;
+		}
+
+		if ("open" == TokenVector[1])
+		{
+			if (3 > TokenVector.size())
+			{
+				TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+				return;
+			}
+
+			DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Open", Py_BuildValue("(i)", npcVNUM));
+		}
+		else if ("close" == TokenVector[1])
+		{
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Close", Py_BuildValue("()"));
+		}
+		else if ("info" == TokenVector[1])
+		{
+			if (5 != TokenVector.size())
+			{
+				TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+				return;
+			}
+
+			UINT gold = atoi(TokenVector[2].c_str());
+			UINT itemVnum = atoi(TokenVector[3].c_str());
+			UINT count = atoi(TokenVector[4].c_str());
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_UpdateInfo", Py_BuildValue("(iii)", gold, itemVnum, count));
+		}
+		else if ("success" == TokenVector[1])
+		{
+			if (4 != TokenVector.size())
+			{
+				TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+				return;
+			}
+
+			UINT itemVnum = atoi(TokenVector[2].c_str());
+			UINT count = atoi(TokenVector[3].c_str());
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Succeed", Py_BuildValue("(ii)", itemVnum, count));
+		}
+		else if ("fail" == TokenVector[1])
+		{
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_Failed", Py_BuildValue("()"));
+		}
+		else if ("r_list" == TokenVector[1])
+		{
+			// result list (/cube r_list npcVNUM resultCount resultText)
+			// 20383 4 72723,1/72725,1/72730.1/50001,5 <- 이런식으로 "/" 문자로 구분된 리스트를 줌
+			if (5 != TokenVector.size())
+			{
+				TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, 5);
+				return;
+			}
+
+			DWORD npcVNUM = (DWORD)atoi(TokenVector[2].c_str());
+
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_ResultList", Py_BuildValue("(is)", npcVNUM, TokenVector[4].c_str()));
+		}
+		else if ("m_info" == TokenVector[1])
+		{
+			// material list (/cube m_info requestStartIndex resultCount MaterialText)
+			// ex) requestStartIndex: 0, resultCount : 5 - 해당 NPC가 만들수 있는 아이템 중 0~4번째에 해당하는 아이템을 만드는 데 필요한 모든 재료들이 MaterialText에 들어있음
+			// 위 예시처럼 아이템이 다수인 경우 구분자 "@" 문자를 사용
+			// 0 5 125,1|126,2|127,2|123,5&555,5&555,4/120000 <- 이런식으로 서버에서 클라로 리스트를 줌
+
+			if (5 != TokenVector.size())
+			{
+				TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, 5);
+				return;
+			}
+
+			UINT requestStartIndex = (UINT)atoi(TokenVector[2].c_str());
+			UINT resultCount = (UINT)atoi(TokenVector[3].c_str());
+
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Cube_MaterialInfo", Py_BuildValue("(iis)", requestStartIndex, resultCount, TokenVector[4].c_str()));
+		}
+	}
+	// CUEBE_END
+	else if (!strcmpi(szCmd, "ObserverCount"))
+	{
+		if (2 != TokenVector.size())
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+			return;
+		}
+
+		UINT uObserverCount= atoi(TokenVector[1].c_str());				
+
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
+			"BINARY_BettingGuildWar_UpdateObserverCount", 
+			Py_BuildValue("(i)", uObserverCount)
+		);
+	}
+	else if (!strcmpi(szCmd, "ObserverMode"))
+	{		
+		if (2 != TokenVector.size())
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+			return;
+		}
+
+		UINT uMode= atoi(TokenVector[1].c_str());
+		
+		IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+		rkPlayer.SetObserverMode(uMode ? true : false);
+
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
+			"BINARY_BettingGuildWar_SetObserverMode", 
+			Py_BuildValue("(i)", uMode)
+		);
+	}
+	else if (!strcmpi(szCmd, "ObserverTeamInfo"))
+	{		
+	}
+	else if (!strcmpi(szCmd, "StoneDetect"))
+	{
+		if (4 != TokenVector.size())
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+			return;
+		}
+
+		// vid distance(1-3) angle(0-360)
+		DWORD dwVID = atoi(TokenVector[1].c_str());
+		BYTE byDistance = atoi(TokenVector[2].c_str());
+		float fAngle = atof(TokenVector[3].c_str());
+		fAngle = fmod(540.0f - fAngle, 360.0f);
+		Tracef("StoneDetect [VID:%d] [Distance:%d] [Angle:%d->%f]\n", dwVID, byDistance, atoi(TokenVector[3].c_str()), fAngle);
+
+		IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();
+
+		CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(dwVID);
+		if (!pInstance)
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Not Exist Instance", c_szCommand);
+			return;
+		}
+
+		TPixelPosition PixelPosition;
+		D3DXVECTOR3 v3Rotation(0.0f, 0.0f, fAngle);
+		pInstance->NEW_GetPixelPosition(&PixelPosition);
+
+		PixelPosition.y *= -1.0f;
+
+		switch (byDistance)
+		{
+			case 0:
+				CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/firecracker/find_out.mse");
+				CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/firecracker/find_out.mse", PixelPosition, v3Rotation);
+				break;
+			case 1:
+				CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/compass/appear_small.mse");
+				CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/compass/appear_small.mse", PixelPosition, v3Rotation);
+				break;
+			case 2:
+				CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/compass/appear_middle.mse");
+				CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/compass/appear_middle.mse", PixelPosition, v3Rotation);
+				break;
+			case 3:
+				CEffectManager::Instance().RegisterEffect("d:/ymir work/effect/etc/compass/appear_large.mse");
+				CEffectManager::Instance().CreateEffect("d:/ymir work/effect/etc/compass/appear_large.mse", PixelPosition, v3Rotation);
+				break;
+			default:
+				TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Distance", c_szCommand);
+				break;
+		}
+
+#ifdef _DEBUG
+		IAbstractChat& rkChat=IAbstractChat::GetSingleton();
+		rkChat.AppendChat(CHAT_TYPE_INFO, c_szCommand);
+#endif
+	}
+	else if (!strcmpi(szCmd, "StartStaminaConsume"))
+	{
+		if (3 != TokenVector.size())
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %s", c_szCommand);
+			return;
+		}
+
+		DWORD dwConsumePerSec = atoi(TokenVector[1].c_str());
+		DWORD dwCurrentStamina = atoi(TokenVector[2].c_str());
+
+		IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
+		rPlayer.StartStaminaConsume(dwConsumePerSec, dwCurrentStamina);
+	}
+	
+	else if (!strcmpi(szCmd, "StopStaminaConsume"))
+	{
+		if (2 != TokenVector.size())
+		{
+			TraceError("CPythonNetworkStream::ServerCommand(c_szCommand=%s) - Strange Parameter Count : %d", c_szCommand, TokenVector.size());
+			return;
+		}
+
+		DWORD dwCurrentStamina = atoi(TokenVector[1].c_str());
+
+		IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
+		rPlayer.StopStaminaConsume(dwCurrentStamina);
+	}
+	else if (!strcmpi(szCmd, "sms"))
+	{
+		IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
+		rPlayer.SetMobileFlag(TRUE);
+	}
+	else if (!strcmpi(szCmd, "nosms"))
+	{
+		IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
+		rPlayer.SetMobileFlag(FALSE);
+	}
+	else if (!strcmpi(szCmd, "mobile_auth"))
+	{
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnMobileAuthority", Py_BuildValue("()"));
+	}
+	else if (!strcmpi(szCmd, "messenger_auth"))
+	{
+		const std::string & c_rstrName = TokenVector[1].c_str();
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnMessengerAddFriendQuestion", Py_BuildValue("(s)", c_rstrName.c_str()));
+	}
+	else if (!strcmpi(szCmd, "combo"))
+	{
+		int iFlag = atoi(TokenVector[1].c_str());
+		IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
+		rPlayer.SetComboSkillFlag(iFlag);
+		m_bComboSkillFlag = iFlag ? true : false;
+	}
+	else if (!strcmpi(szCmd, "setblockmode"))
+	{
+		int iFlag = atoi(TokenVector[1].c_str());
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnBlockMode", Py_BuildValue("(i)", iFlag));
+	}
+	// Emotion Start
+	else if (!strcmpi(szCmd, "french_kiss"))
+	{
+		int iVID1 = atoi(TokenVector[1].c_str());
+		int iVID2 = atoi(TokenVector[2].c_str());
+
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance1 = rkChrMgr.GetInstancePtr(iVID1);
+		CInstanceBase * pInstance2 = rkChrMgr.GetInstancePtr(iVID2);
+		if (pInstance1 && pInstance2)
+			pInstance1->ActDualEmotion(*pInstance2, CRaceMotionData::NAME_FRENCH_KISS_START, CRaceMotionData::NAME_FRENCH_KISS_START);
+	}
+	else if (!strcmpi(szCmd, "kiss"))
+	{
+		int iVID1 = atoi(TokenVector[1].c_str());
+		int iVID2 = atoi(TokenVector[2].c_str());
+
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance1 = rkChrMgr.GetInstancePtr(iVID1);
+		CInstanceBase * pInstance2 = rkChrMgr.GetInstancePtr(iVID2);
+		if (pInstance1 && pInstance2)
+			pInstance1->ActDualEmotion(*pInstance2, CRaceMotionData::NAME_KISS_START, CRaceMotionData::NAME_KISS_START);
+	}
+	else if (!strcmpi(szCmd, "slap"))
+	{
+		int iVID1 = atoi(TokenVector[1].c_str());
+		int iVID2 = atoi(TokenVector[2].c_str());
+
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance1 = rkChrMgr.GetInstancePtr(iVID1);
+		CInstanceBase * pInstance2 = rkChrMgr.GetInstancePtr(iVID2);
+		if (pInstance1 && pInstance2)
+			pInstance1->ActDualEmotion(*pInstance2, CRaceMotionData::NAME_SLAP_HURT_START, CRaceMotionData::NAME_SLAP_HIT_START);
+	}
+	else if (!strcmpi(szCmd, "clap"))
+	{
+		int iVID = atoi(TokenVector[1].c_str());
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
+		if (pInstance)
+			pInstance->ActEmotion(CRaceMotionData::NAME_CLAP);
+	}
+	else if (!strcmpi(szCmd, "cheer1"))
+	{
+		int iVID = atoi(TokenVector[1].c_str());
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
+		if (pInstance)
+			pInstance->ActEmotion(CRaceMotionData::NAME_CHEERS_1);
+	}
+	else if (!strcmpi(szCmd, "cheer2"))
+	{
+		int iVID = atoi(TokenVector[1].c_str());
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
+		if (pInstance)
+			pInstance->ActEmotion(CRaceMotionData::NAME_CHEERS_2);
+	}
+	else if (!strcmpi(szCmd, "dance1"))
+	{
+		int iVID = atoi(TokenVector[1].c_str());
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
+		if (pInstance)
+			pInstance->ActEmotion(CRaceMotionData::NAME_DANCE_1);
+	}
+	else if (!strcmpi(szCmd, "dance2"))
+	{
+		int iVID = atoi(TokenVector[1].c_str());
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
+		if (pInstance)
+			pInstance->ActEmotion(CRaceMotionData::NAME_DANCE_2);
+	}
+	else if (!strcmpi(szCmd, "dig_motion"))
+	{
+		int iVID = atoi(TokenVector[1].c_str());
+		IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+		CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
+		if (pInstance)
+			pInstance->ActEmotion(CRaceMotionData::NAME_DIG);
+	}
+	// Emotion End
+	else
+	{
+		static std::map<std::string, int> s_emotionDict;
+
+		static bool s_isFirst = true;
+		if (s_isFirst)
+		{
+			s_isFirst = false;
+
+			s_emotionDict["dance3"] = CRaceMotionData::NAME_DANCE_3;
+			s_emotionDict["dance4"] = CRaceMotionData::NAME_DANCE_4;
+			s_emotionDict["dance5"] = CRaceMotionData::NAME_DANCE_5;
+			s_emotionDict["dance6"] = CRaceMotionData::NAME_DANCE_6;
+			s_emotionDict["congratulation"] = CRaceMotionData::NAME_CONGRATULATION;
+			s_emotionDict["forgive"] = CRaceMotionData::NAME_FORGIVE;
+			s_emotionDict["angry"] = CRaceMotionData::NAME_ANGRY;
+			s_emotionDict["attractive"] = CRaceMotionData::NAME_ATTRACTIVE;
+			s_emotionDict["sad"] = CRaceMotionData::NAME_SAD;
+			s_emotionDict["shy"] = CRaceMotionData::NAME_SHY;
+			s_emotionDict["cheerup"] = CRaceMotionData::NAME_CHEERUP;
+			s_emotionDict["banter"] = CRaceMotionData::NAME_BANTER;
+			s_emotionDict["joy"] = CRaceMotionData::NAME_JOY;
+		}
+
+		std::map<std::string, int>::iterator f = s_emotionDict.find(szCmd);
+		if (f == s_emotionDict.end())
+		{
+			TraceError("Unknown Server Command %s | %s", c_szCommand, szCmd);
+		}
+		else
+		{
+			int emotionIndex = f->second;
+
+			int iVID = atoi(TokenVector[1].c_str());
+			IAbstractCharacterManager & rkChrMgr = IAbstractCharacterManager::GetSingleton();
+			CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(iVID);
+
+			if (pInstance)
+				pInstance->ActEmotion(emotionIndex);
+		}		
+	}
+}

extension/src/port/UserInterface/PythonNetworkStreamPhaseGameActor.cpp

@@ -0,0 +1,454 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "NetworkActorManager.h"
+#include "PythonBackground.h"
+
+#include "PythonApplication.h"
+#include "AbstractPlayer.h"
+#include "../GameLib/ActorInstance.h"
+
+
+
+
+
+void CPythonNetworkStream::__GlobalPositionToLocalPosition(LONG& rGlobalX, LONG& rGlobalY)
+{
+	CPythonBackground&rkBgMgr=CPythonBackground::Instance();
+	rkBgMgr.GlobalPositionToLocalPosition(rGlobalX, rGlobalY);
+}
+
+void CPythonNetworkStream::__LocalPositionToGlobalPosition(LONG& rLocalX, LONG& rLocalY)
+{
+	CPythonBackground&rkBgMgr=CPythonBackground::Instance();
+	rkBgMgr.LocalPositionToGlobalPosition(rLocalX, rLocalY);
+}
+
+bool CPythonNetworkStream::__CanActMainInstance()
+{
+	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
+	CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
+	if (!pkInstMain)
+		return false;
+
+	return pkInstMain->CanAct();
+}
+
+void CPythonNetworkStream::__ClearNetworkActorManager()
+{
+	m_rokNetActorMgr->Destroy();
+}
+
+void __SetWeaponPower(IAbstractPlayer& rkPlayer, DWORD dwWeaponID)
+{
+	DWORD minPower=0;
+	DWORD maxPower=0;
+	DWORD minMagicPower=0;
+	DWORD maxMagicPower=0;
+	DWORD addPower=0;
+
+	CItemData* pkWeapon;
+	if (CItemManager::Instance().GetItemDataPointer(dwWeaponID, &pkWeapon))
+	{
+		if (pkWeapon->GetType()==CItemData::ITEM_TYPE_WEAPON)
+		{
+			minPower=pkWeapon->GetValue(3);
+			maxPower=pkWeapon->GetValue(4);
+			minMagicPower=pkWeapon->GetValue(1);
+			maxMagicPower=pkWeapon->GetValue(2);
+			addPower=pkWeapon->GetValue(5);
+		}
+	}
+
+	rkPlayer.SetWeaponPower(minPower, maxPower, minMagicPower, maxMagicPower, addPower);
+}
+
+//테이블에서 이름이 "." 인 것들
+//차후에 서버에서 보내주지 않게 되면 없어질 함수..(서버님께 꼭!!협박; )
+bool IsInvisibleRace(WORD raceNum)
+{
+	switch(raceNum)
+	{
+	case 20025:
+	case 20038:
+	case 20039:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static SNetworkActorData s_kNetActorData;
+
+
+bool CPythonNetworkStream::RecvCharacterAppendPacket()
+{
+	TPacketGCCharacterAdd chrAddPacket;
+	if (!Recv(sizeof(chrAddPacket), &chrAddPacket))
+		return false;
+
+	__GlobalPositionToLocalPosition(chrAddPacket.x, chrAddPacket.y);
+
+	SNetworkActorData kNetActorData;
+	kNetActorData.m_bType=chrAddPacket.bType;
+	kNetActorData.m_dwMovSpd=chrAddPacket.bMovingSpeed;
+	kNetActorData.m_dwAtkSpd=chrAddPacket.bAttackSpeed;
+	kNetActorData.m_dwRace=chrAddPacket.wRaceNum;
+	
+	kNetActorData.m_dwStateFlags=chrAddPacket.bStateFlag;
+	kNetActorData.m_dwVID=chrAddPacket.dwVID;
+	kNetActorData.m_fRot=chrAddPacket.angle;
+
+	kNetActorData.m_stName="";
+
+	kNetActorData.m_stName="";
+	kNetActorData.m_kAffectFlags.CopyData(0, sizeof(chrAddPacket.dwAffectFlag[0]), &chrAddPacket.dwAffectFlag[0]);
+	kNetActorData.m_kAffectFlags.CopyData(32, sizeof(chrAddPacket.dwAffectFlag[1]), &chrAddPacket.dwAffectFlag[1]);
+	
+	kNetActorData.SetPosition(chrAddPacket.x, chrAddPacket.y);
+
+	kNetActorData.m_sAlignment=0;/*chrAddPacket.sAlignment*/;	
+	kNetActorData.m_byPKMode=0;/*chrAddPacket.bPKMode*/;	
+	kNetActorData.m_dwGuildID=0;/*chrAddPacket.dwGuild*/;
+	kNetActorData.m_dwEmpireID=0;/*chrAddPacket.bEmpire*/;
+	kNetActorData.m_dwArmor=0;/*chrAddPacket.awPart[CHR_EQUIPPART_ARMOR]*/;
+	kNetActorData.m_dwWeapon=0;/*chrAddPacket.awPart[CHR_EQUIPPART_WEAPON]*/;
+	kNetActorData.m_dwHair=0;/*chrAddPacket.awPart[CHR_EQUIPPART_HAIR]*/;	
+	kNetActorData.m_dwMountVnum=0;/*chrAddPacket.dwMountVnum*/;	
+
+	kNetActorData.m_dwLevel = 0; // 몬스터 레벨 표시 안함
+
+	if(kNetActorData.m_bType != CActorInstance::TYPE_PC && 
+		kNetActorData.m_bType != CActorInstance::TYPE_NPC)
+	{
+		const char * c_szName;
+		CPythonNonPlayer& rkNonPlayer=CPythonNonPlayer::Instance();
+		if (rkNonPlayer.GetName(kNetActorData.m_dwRace, &c_szName))
+			kNetActorData.m_stName = c_szName;
+		//else
+		//	kNetActorData.m_stName=chrAddPacket.name;
+
+		__RecvCharacterAppendPacket(&kNetActorData);
+	}
+	else
+	{
+		s_kNetActorData = kNetActorData;
+	}
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvCharacterAdditionalInfo()
+{
+	TPacketGCCharacterAdditionalInfo chrInfoPacket;
+	if (!Recv(sizeof(chrInfoPacket), &chrInfoPacket))
+		return false;
+
+	
+	SNetworkActorData kNetActorData = s_kNetActorData;
+	if (IsInvisibleRace(kNetActorData.m_dwRace))
+		return true;
+
+	if(kNetActorData.m_dwVID == chrInfoPacket.dwVID)
+	{
+		kNetActorData.m_stName = chrInfoPacket.name;
+		kNetActorData.m_dwGuildID = chrInfoPacket.dwGuildID;
+		kNetActorData.m_dwLevel = chrInfoPacket.dwLevel;
+		kNetActorData.m_sAlignment=chrInfoPacket.sAlignment;	
+		kNetActorData.m_byPKMode=chrInfoPacket.bPKMode;	
+		kNetActorData.m_dwGuildID=chrInfoPacket.dwGuildID;
+		kNetActorData.m_dwEmpireID=chrInfoPacket.bEmpire;
+		kNetActorData.m_dwArmor=chrInfoPacket.awPart[CHR_EQUIPPART_ARMOR];
+		kNetActorData.m_dwWeapon=chrInfoPacket.awPart[CHR_EQUIPPART_WEAPON];
+		kNetActorData.m_dwHair=chrInfoPacket.awPart[CHR_EQUIPPART_HAIR];	
+		kNetActorData.m_dwMountVnum=chrInfoPacket.dwMountVnum;
+
+		__RecvCharacterAppendPacket(&kNetActorData);
+	}
+	else
+	{
+		TraceError("TPacketGCCharacterAdditionalInfo name=%s vid=%d race=%d Error",chrInfoPacket.name,chrInfoPacket.dwVID,kNetActorData.m_dwRace);
+	}
+	return true;
+}
+
+bool CPythonNetworkStream::RecvCharacterAppendPacketNew()
+{
+	TraceError("TPacketGCCharacterAdd2\264\302 \276\262\301\366 \276\312\264\302 \306\320\305\266\300\324\264\317\264\331.");
+	TPacketGCCharacterAdd2 chrAddPacket;
+	if (!Recv(sizeof(chrAddPacket), &chrAddPacket))
+		return false;
+	if(IsInvisibleRace(chrAddPacket.wRaceNum))
+		return true;
+
+	__GlobalPositionToLocalPosition(chrAddPacket.x, chrAddPacket.y);
+
+	SNetworkActorData kNetActorData;
+	kNetActorData.m_dwLevel = 0;
+	kNetActorData.m_bType=chrAddPacket.bType;
+	kNetActorData.m_dwGuildID=chrAddPacket.dwGuild;
+	kNetActorData.m_dwEmpireID=chrAddPacket.bEmpire;	
+	kNetActorData.m_dwMovSpd=chrAddPacket.bMovingSpeed;
+	kNetActorData.m_dwAtkSpd=chrAddPacket.bAttackSpeed;
+	kNetActorData.m_dwRace=chrAddPacket.wRaceNum;
+	kNetActorData.m_dwArmor=chrAddPacket.awPart[CHR_EQUIPPART_ARMOR];
+	kNetActorData.m_dwWeapon=chrAddPacket.awPart[CHR_EQUIPPART_WEAPON];
+	kNetActorData.m_dwHair=chrAddPacket.awPart[CHR_EQUIPPART_HAIR];
+	kNetActorData.m_dwStateFlags=chrAddPacket.bStateFlag;
+	kNetActorData.m_dwVID=chrAddPacket.dwVID;
+	kNetActorData.m_dwMountVnum=chrAddPacket.dwMountVnum;
+	kNetActorData.m_fRot=chrAddPacket.angle;
+	kNetActorData.m_kAffectFlags.CopyData(0, sizeof(chrAddPacket.dwAffectFlag[0]), &chrAddPacket.dwAffectFlag[0]);
+	kNetActorData.m_kAffectFlags.CopyData(32, sizeof(chrAddPacket.dwAffectFlag[1]), &chrAddPacket.dwAffectFlag[1]);
+	kNetActorData.SetPosition(chrAddPacket.x, chrAddPacket.y);
+	kNetActorData.m_sAlignment=chrAddPacket.sAlignment;
+	kNetActorData.m_byPKMode=chrAddPacket.bPKMode;
+	kNetActorData.m_stName=chrAddPacket.name;
+	__RecvCharacterAppendPacket(&kNetActorData);
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvCharacterUpdatePacket()
+{
+	TPacketGCCharacterUpdate chrUpdatePacket;
+	if (!Recv(sizeof(chrUpdatePacket), &chrUpdatePacket))
+		return false;
+
+	SNetworkUpdateActorData kNetUpdateActorData;
+	kNetUpdateActorData.m_dwGuildID=chrUpdatePacket.dwGuildID;
+	kNetUpdateActorData.m_dwMovSpd=chrUpdatePacket.bMovingSpeed;
+	kNetUpdateActorData.m_dwAtkSpd=chrUpdatePacket.bAttackSpeed;
+	kNetUpdateActorData.m_dwArmor=chrUpdatePacket.awPart[CHR_EQUIPPART_ARMOR];
+	kNetUpdateActorData.m_dwWeapon=chrUpdatePacket.awPart[CHR_EQUIPPART_WEAPON];
+	kNetUpdateActorData.m_dwHair=chrUpdatePacket.awPart[CHR_EQUIPPART_HAIR];
+	kNetUpdateActorData.m_dwVID=chrUpdatePacket.dwVID;	
+	kNetUpdateActorData.m_kAffectFlags.CopyData(0, sizeof(chrUpdatePacket.dwAffectFlag[0]), &chrUpdatePacket.dwAffectFlag[0]);
+	kNetUpdateActorData.m_kAffectFlags.CopyData(32, sizeof(chrUpdatePacket.dwAffectFlag[1]), &chrUpdatePacket.dwAffectFlag[1]);
+	kNetUpdateActorData.m_sAlignment=chrUpdatePacket.sAlignment;
+	kNetUpdateActorData.m_byPKMode=chrUpdatePacket.bPKMode;
+	kNetUpdateActorData.m_dwStateFlags=chrUpdatePacket.bStateFlag;
+	kNetUpdateActorData.m_dwMountVnum=chrUpdatePacket.dwMountVnum;
+	__RecvCharacterUpdatePacket(&kNetUpdateActorData);
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvCharacterUpdatePacketNew()
+{
+	TPacketGCCharacterUpdate2 chrUpdatePacket;
+	if (!Recv(sizeof(chrUpdatePacket), &chrUpdatePacket))
+		return false;
+
+	SNetworkUpdateActorData kNetUpdateActorData;
+	kNetUpdateActorData.m_dwGuildID=chrUpdatePacket.dwGuildID;
+	kNetUpdateActorData.m_dwMovSpd=chrUpdatePacket.bMovingSpeed;
+	kNetUpdateActorData.m_dwAtkSpd=chrUpdatePacket.bAttackSpeed;
+	kNetUpdateActorData.m_dwArmor=chrUpdatePacket.awPart[CHR_EQUIPPART_ARMOR];
+	kNetUpdateActorData.m_dwWeapon=chrUpdatePacket.awPart[CHR_EQUIPPART_WEAPON];
+	kNetUpdateActorData.m_dwHair=chrUpdatePacket.awPart[CHR_EQUIPPART_HAIR];
+	kNetUpdateActorData.m_dwVID=chrUpdatePacket.dwVID;
+	kNetUpdateActorData.m_kAffectFlags.CopyData(0, sizeof(chrUpdatePacket.dwAffectFlag[0]), &chrUpdatePacket.dwAffectFlag[0]);
+	kNetUpdateActorData.m_kAffectFlags.CopyData(32, sizeof(chrUpdatePacket.dwAffectFlag[1]), &chrUpdatePacket.dwAffectFlag[1]);
+	kNetUpdateActorData.m_sAlignment=chrUpdatePacket.sAlignment;
+	kNetUpdateActorData.m_byPKMode=chrUpdatePacket.bPKMode;
+	kNetUpdateActorData.m_dwStateFlags=chrUpdatePacket.bStateFlag;
+	kNetUpdateActorData.m_dwMountVnum=chrUpdatePacket.dwMountVnum;
+	__RecvCharacterUpdatePacket(&kNetUpdateActorData);
+
+	return true;
+}
+
+void CPythonNetworkStream::__RecvCharacterAppendPacket(SNetworkActorData * pkNetActorData)
+{
+	// NOTE : 카메라가 땅에 묻히는 문제의 해결을 위해 메인 캐릭터가 지형에 올려지기
+	//        전에 맵을 업데이트 해 높이를 구할 수 있도록 해놓아야 합니다.
+	//        단, 게임이 들어갈때가 아닌 이미 캐릭터가 추가 된 이후에만 합니다.
+	//        헌데 이동인데 왜 Move로 안하고 Append로 하는지..? - [levites]
+	IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton();
+	if (rkPlayer.IsMainCharacterIndex(pkNetActorData->m_dwVID))
+	{
+		rkPlayer.SetRace(pkNetActorData->m_dwRace);
+
+		__SetWeaponPower(rkPlayer, pkNetActorData->m_dwWeapon);
+
+		if (rkPlayer.NEW_GetMainActorPtr())
+		{
+			CPythonBackground::Instance().Update(pkNetActorData->m_lCurX, pkNetActorData->m_lCurY, 0.0f);
+			CPythonCharacterManager::Instance().Update();
+
+			// NOTE : 사귀 타워일 경우 GOTO 로 이동시에도 맵 이름을 출력하도록 처리
+			{
+				std::string strMapName = CPythonBackground::Instance().GetWarpMapName();
+				if (strMapName == "metin2_map_deviltower1")
+					__ShowMapName(pkNetActorData->m_lCurX, pkNetActorData->m_lCurY);
+			}
+		}
+		else
+		{
+			__ShowMapName(pkNetActorData->m_lCurX, pkNetActorData->m_lCurY);
+		}
+	}
+
+	m_rokNetActorMgr->AppendActor(*pkNetActorData);
+
+	if (GetMainActorVID()==pkNetActorData->m_dwVID)
+	{
+		rkPlayer.SetTarget(0);
+		if (m_bComboSkillFlag)
+			rkPlayer.SetComboSkillFlag(m_bComboSkillFlag);
+
+		__SetGuildID(pkNetActorData->m_dwGuildID);
+		//CPythonApplication::Instance().SkipRenderBuffering(10000);
+	}
+}
+
+void CPythonNetworkStream::__RecvCharacterUpdatePacket(SNetworkUpdateActorData * pkNetUpdateActorData)
+{
+	m_rokNetActorMgr->UpdateActor(*pkNetUpdateActorData);
+
+	IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton();
+	if (rkPlayer.IsMainCharacterIndex(pkNetUpdateActorData->m_dwVID))
+	{
+		__SetGuildID(pkNetUpdateActorData->m_dwGuildID);
+		__SetWeaponPower(rkPlayer, pkNetUpdateActorData->m_dwWeapon);
+
+		__RefreshStatus();
+		__RefreshAlignmentWindow();
+		__RefreshEquipmentWindow();
+		__RefreshInventoryWindow();
+	}
+	else
+	{
+		rkPlayer.NotifyCharacterUpdate(pkNetUpdateActorData->m_dwVID);
+	}
+}
+
+bool CPythonNetworkStream::RecvCharacterDeletePacket()
+{
+	TPacketGCCharacterDelete chrDelPacket;
+
+	if (!Recv(sizeof(chrDelPacket), &chrDelPacket))
+	{
+		TraceError("CPythonNetworkStream::RecvCharacterDeletePacket - Recv Error");
+		return false;
+	}
+
+	m_rokNetActorMgr->RemoveActor(chrDelPacket.dwVID);
+
+	// 캐릭터가 사라질때 개인 상점도 없애줍니다.
+	// Key Check 를 하기때문에 없어도 상관은 없습니다.
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
+		"BINARY_PrivateShop_Disappear", 
+		Py_BuildValue("(i)", chrDelPacket.dwVID)
+	);
+
+	return true;
+}
+
+
+bool CPythonNetworkStream::RecvCharacterMovePacket()
+{
+	TPacketGCMove kMovePacket;
+	if (!Recv(sizeof(TPacketGCMove), &kMovePacket))
+	{
+		Tracen("CPythonNetworkStream::RecvCharacterMovePacket - PACKET READ ERROR");
+		return false;
+	}
+
+	__GlobalPositionToLocalPosition(kMovePacket.lX, kMovePacket.lY);
+
+	SNetworkMoveActorData kNetMoveActorData;
+	kNetMoveActorData.m_dwArg=kMovePacket.bArg;
+	kNetMoveActorData.m_dwFunc=kMovePacket.bFunc;
+	kNetMoveActorData.m_dwTime=kMovePacket.dwTime;
+	kNetMoveActorData.m_dwVID=kMovePacket.dwVID;
+	kNetMoveActorData.m_fRot=kMovePacket.bRot*5.0f;
+	kNetMoveActorData.m_lPosX=kMovePacket.lX;
+	kNetMoveActorData.m_lPosY=kMovePacket.lY;
+	kNetMoveActorData.m_dwDuration=kMovePacket.dwDuration;
+
+	m_rokNetActorMgr->MoveActor(kNetMoveActorData);
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvOwnerShipPacket()
+{
+	TPacketGCOwnership kPacketOwnership;
+
+	if (!Recv(sizeof(kPacketOwnership), &kPacketOwnership))
+		return false;
+
+	m_rokNetActorMgr->SetActorOwner(kPacketOwnership.dwOwnerVID, kPacketOwnership.dwVictimVID);
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvSyncPositionPacket()
+{
+	TPacketGCSyncPosition kPacketSyncPos;
+	if (!Recv(sizeof(kPacketSyncPos), &kPacketSyncPos))
+		return false;
+
+	TPacketGCSyncPositionElement kSyncPos;
+
+	UINT uSyncPosCount=(kPacketSyncPos.wSize-sizeof(kPacketSyncPos))/sizeof(kSyncPos);
+	for (UINT iSyncPos=0; iSyncPos<uSyncPosCount; ++iSyncPos)
+	{		
+		if (!Recv(sizeof(TPacketGCSyncPositionElement), &kSyncPos))
+			return false;
+
+#ifdef __MOVIE_MODE__
+		return true;
+#endif __MOVIE_MODE__
+
+		//Tracenf("CPythonNetworkStream::RecvSyncPositionPacket %d (%d, %d)", kSyncPos.dwVID, kSyncPos.lX, kSyncPos.lY);
+
+		__GlobalPositionToLocalPosition(kSyncPos.lX, kSyncPos.lY);
+		m_rokNetActorMgr->SyncActor(kSyncPos.dwVID, kSyncPos.lX, kSyncPos.lY);
+
+		/*
+		CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
+		CInstanceBase * pkChrInst = rkChrMgr.GetInstancePtr(kSyncPos.dwVID);
+
+		if (pkChrInst)
+		{			
+			pkChrInst->NEW_SyncPixelPosition(kSyncPos.lX, kSyncPos.lY);		
+		}
+		*/
+}
+
+	return true;
+}
+
+
+/*
+bool CPythonNetworkStream::RecvCharacterAppendPacket()
+{
+	TPacketGCCharacterAdd chrAddPacket;
+
+	if (!Recv(sizeof(chrAddPacket), &chrAddPacket))
+		return false;
+
+	__GlobalPositionToLocalPosition(chrAddPacket.lX, chrAddPacket.lY);
+
+	SNetworkActorData kNetActorData;
+	kNetActorData.m_dwGuildID=chrAddPacket.dwGuild;
+	kNetActorData.m_dwEmpireID=chrAddPacket.bEmpire;
+	kNetActorData.m_dwMovSpd=chrAddPacket.bMovingSpeed;
+	kNetActorData.m_dwAtkSpd=chrAddPacket.bAttackSpeed;
+	kNetActorData.m_dwRace=chrAddPacket.wRaceNum;
+	kNetActorData.m_dwShape=chrAddPacket.parts[CRaceData::PART_MAIN];
+	kNetActorData.m_dwStateFlags=chrAddPacket.bStateFlag;
+	kNetActorData.m_dwVID=chrAddPacket.dwVID;
+	kNetActorData.m_dwWeapon=chrAddPacket.parts[CRaceData::PART_WEAPON];
+	kNetActorData.m_fRot=chrAddPacket.angle;
+	kNetActorData.m_kAffectFlags.CopyData(0, sizeof(chrAddPacket.dwAffectFlag[0]), &chrAddPacket.dwAffectFlag[0]);
+	kNetActorData.m_kAffectFlags.CopyData(32, sizeof(chrAddPacket.dwAffectFlag[1]), &chrAddPacket.dwAffectFlag[1]);
+	kNetActorData.SetPosition(chrAddPacket.lX, chrAddPacket.lY);
+	kNetActorData.m_stName=chrAddPacket.name;
+	__RecvCharacterAppendPacket(&kNetActorData);
+	return true;
+}
+*/
+

extension/src/port/UserInterface/PythonNetworkStreamPhaseGameItem.cpp

@@ -0,0 +1,940 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "PythonItem.h"
+#include "PythonShop.h"
+#include "PythonExchange.h"
+#include "PythonSafeBox.h"
+#include "PythonCharacterManager.h"
+
+#include "AbstractPlayer.h"
+
+//////////////////////////////////////////////////////////////////////////
+// SafeBox
+
+bool CPythonNetworkStream::SendSafeBoxMoneyPacket(BYTE byState, DWORD dwMoney)
+{
+	assert(!"CPythonNetworkStream::SendSafeBoxMoneyPacket - \273\347\277\353\307\317\301\366 \276\312\264\302 \307\324\274\366");
+	return false;
+
+//	TPacketCGSafeboxMoney kSafeboxMoney;
+//	kSafeboxMoney.bHeader = HEADER_CG_SAFEBOX_MONEY;
+//	kSafeboxMoney.bState = byState;
+//	kSafeboxMoney.dwMoney = dwMoney;
+//	if (!Send(sizeof(kSafeboxMoney), &kSafeboxMoney))
+//		return false;
+//
+//	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendSafeBoxCheckinPacket(TItemPos InventoryPos, BYTE bySafeBoxPos)
+{
+	__PlayInventoryItemDropSound(InventoryPos);
+
+	TPacketCGSafeboxCheckin kSafeboxCheckin;
+	kSafeboxCheckin.bHeader = HEADER_CG_SAFEBOX_CHECKIN;
+	kSafeboxCheckin.ItemPos = InventoryPos;
+	kSafeboxCheckin.bSafePos = bySafeBoxPos;
+	if (!Send(sizeof(kSafeboxCheckin), &kSafeboxCheckin))
+		return false;
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendSafeBoxCheckoutPacket(BYTE bySafeBoxPos, TItemPos InventoryPos)
+{
+	__PlaySafeBoxItemDropSound(bySafeBoxPos);
+
+	TPacketCGSafeboxCheckout kSafeboxCheckout;
+	kSafeboxCheckout.bHeader = HEADER_CG_SAFEBOX_CHECKOUT;
+	kSafeboxCheckout.bSafePos = bySafeBoxPos;
+	kSafeboxCheckout.ItemPos = InventoryPos;
+	if (!Send(sizeof(kSafeboxCheckout), &kSafeboxCheckout))
+		return false;
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendSafeBoxItemMovePacket(BYTE bySourcePos, BYTE byTargetPos, BYTE byCount)
+{
+	__PlaySafeBoxItemDropSound(bySourcePos);
+
+	TPacketCGItemMove kItemMove;
+	kItemMove.header = HEADER_CG_SAFEBOX_ITEM_MOVE;
+	kItemMove.pos = TItemPos(INVENTORY, bySourcePos);
+	kItemMove.num = byCount;
+	kItemMove.change_pos = TItemPos(INVENTORY, byTargetPos);
+	if (!Send(sizeof(kItemMove), &kItemMove))
+		return false;
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::RecvSafeBoxSetPacket()
+{
+	TPacketGCItemSet2 kItemSet;
+	if (!Recv(sizeof(kItemSet), &kItemSet))
+		return false;
+
+	TItemData kItemData;
+	kItemData.vnum	= kItemSet.vnum;
+	kItemData.count = kItemSet.count;
+	kItemData.flags = kItemSet.flags;
+	kItemData.anti_flags = kItemSet.anti_flags;
+	for (int isocket=0; isocket<ITEM_SOCKET_SLOT_MAX_NUM; ++isocket)
+		kItemData.alSockets[isocket] = kItemSet.alSockets[isocket];
+	for (int iattr=0; iattr<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++iattr)
+		kItemData.aAttr[iattr] = kItemSet.aAttr[iattr];
+
+	CPythonSafeBox::Instance().SetItemData(kItemSet.Cell.cell, kItemData);
+
+	__RefreshSafeboxWindow();
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvSafeBoxDelPacket()
+{
+	TPacketGCItemDel kItemDel;
+	if (!Recv(sizeof(kItemDel), &kItemDel))
+		return false;
+
+	CPythonSafeBox::Instance().DelItemData(kItemDel.pos);
+
+	__RefreshSafeboxWindow();
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvSafeBoxWrongPasswordPacket()
+{
+	TPacketGCSafeboxWrongPassword kSafeboxWrongPassword;
+
+	if (!Recv(sizeof(kSafeboxWrongPassword), &kSafeboxWrongPassword))
+		return false;
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnSafeBoxError", Py_BuildValue("()"));
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvSafeBoxSizePacket()
+{
+	TPacketGCSafeboxSize kSafeBoxSize;
+	if (!Recv(sizeof(kSafeBoxSize), &kSafeBoxSize))
+		return false;
+
+	CPythonSafeBox::Instance().OpenSafeBox(kSafeBoxSize.bSize);
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenSafeboxWindow", Py_BuildValue("(i)", kSafeBoxSize.bSize));
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvSafeBoxMoneyChangePacket()
+{
+	TPacketGCSafeboxMoneyChange kMoneyChange;
+	if (!Recv(sizeof(kMoneyChange), &kMoneyChange))
+		return false;
+
+	CPythonSafeBox::Instance().SetMoney(kMoneyChange.dwMoney);
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSafeboxMoney", Py_BuildValue("()"));
+
+	return true;
+}
+
+// SafeBox
+//////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////
+// Mall
+bool CPythonNetworkStream::SendMallCheckoutPacket(BYTE byMallPos, TItemPos InventoryPos)
+{
+	__PlayMallItemDropSound(byMallPos);
+
+	TPacketCGMallCheckout kMallCheckoutPacket;
+	kMallCheckoutPacket.bHeader = HEADER_CG_MALL_CHECKOUT;
+	kMallCheckoutPacket.bMallPos = byMallPos;
+	kMallCheckoutPacket.ItemPos = InventoryPos;
+	if (!Send(sizeof(kMallCheckoutPacket), &kMallCheckoutPacket))
+		return false;
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::RecvMallOpenPacket()
+{
+	TPacketGCMallOpen kMallOpen;
+	if (!Recv(sizeof(kMallOpen), &kMallOpen))
+		return false;
+
+	CPythonSafeBox::Instance().OpenMall(kMallOpen.bSize);
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenMallWindow", Py_BuildValue("(i)", kMallOpen.bSize));
+
+	return true;
+}
+bool CPythonNetworkStream::RecvMallItemSetPacket()
+{
+	TPacketGCItemSet2 kItemSet;
+	if (!Recv(sizeof(kItemSet), &kItemSet))
+		return false;
+
+	TItemData kItemData;
+	kItemData.vnum = kItemSet.vnum;
+	kItemData.count = kItemSet.count;
+	kItemData.flags = kItemSet.flags;
+	kItemData.anti_flags = kItemSet.anti_flags;
+	for (int isocket=0; isocket<ITEM_SOCKET_SLOT_MAX_NUM; ++isocket)
+		kItemData.alSockets[isocket] = kItemSet.alSockets[isocket];
+	for (int iattr=0; iattr<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++iattr)
+		kItemData.aAttr[iattr] = kItemSet.aAttr[iattr];
+
+	CPythonSafeBox::Instance().SetMallItemData(kItemSet.Cell.cell, kItemData);
+
+	__RefreshMallWindow();
+
+	return true;
+}
+bool CPythonNetworkStream::RecvMallItemDelPacket()
+{
+	TPacketGCItemDel kItemDel;
+	if (!Recv(sizeof(kItemDel), &kItemDel))
+		return false;
+
+	CPythonSafeBox::Instance().DelMallItemData(kItemDel.pos);
+
+	__RefreshMallWindow();
+	Tracef(" >> CPythonNetworkStream::RecvMallItemDelPacket\n");
+
+	return true;
+}
+// Mall
+//////////////////////////////////////////////////////////////////////////
+
+// Item
+// Recieve
+bool CPythonNetworkStream::RecvItemSetPacket()
+{
+	TPacketGCItemSet packet_item_set;
+
+	if (!Recv(sizeof(TPacketGCItemSet), &packet_item_set))
+		return false;
+
+	TItemData kItemData;
+	kItemData.vnum	= packet_item_set.vnum;
+	kItemData.count	= packet_item_set.count;
+	kItemData.flags = 0;
+	for (int i=0; i<ITEM_SOCKET_SLOT_MAX_NUM; ++i)
+		kItemData.alSockets[i]=packet_item_set.alSockets[i];
+	for (int j=0; j<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
+		kItemData.aAttr[j]=packet_item_set.aAttr[j];
+
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	
+	rkPlayer.SetItemData(packet_item_set.Cell, kItemData);
+	
+	__RefreshInventoryWindow();
+	return true;
+}
+
+bool CPythonNetworkStream::RecvItemSetPacket2()
+{
+	TPacketGCItemSet2 packet_item_set;
+
+	if (!Recv(sizeof(TPacketGCItemSet2), &packet_item_set))
+		return false;
+
+	TItemData kItemData;
+	kItemData.vnum	= packet_item_set.vnum;
+	kItemData.count	= packet_item_set.count;
+	kItemData.flags = packet_item_set.flags;
+	kItemData.anti_flags = packet_item_set.anti_flags;
+
+	for (int i=0; i<ITEM_SOCKET_SLOT_MAX_NUM; ++i)
+		kItemData.alSockets[i]=packet_item_set.alSockets[i];
+	for (int j=0; j<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
+		kItemData.aAttr[j]=packet_item_set.aAttr[j];
+
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	rkPlayer.SetItemData(packet_item_set.Cell, kItemData);
+
+	if (packet_item_set.highlight)
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Highlight_Item", Py_BuildValue("(ii)", packet_item_set.Cell.window_type, packet_item_set.Cell.cell));
+
+	__RefreshInventoryWindow();
+	return true;
+}
+
+
+bool CPythonNetworkStream::RecvItemUsePacket()
+{
+	TPacketGCItemUse packet_item_use;
+
+	if (!Recv(sizeof(TPacketGCItemUse), &packet_item_use))
+		return false;
+
+	__RefreshInventoryWindow();
+	return true;
+}
+
+bool CPythonNetworkStream::RecvItemUpdatePacket()
+{
+	TPacketGCItemUpdate packet_item_update;
+
+	if (!Recv(sizeof(TPacketGCItemUpdate), &packet_item_update))
+		return false;
+
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	rkPlayer.SetItemCount(packet_item_update.Cell, packet_item_update.count);
+	for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
+		rkPlayer.SetItemMetinSocket(packet_item_update.Cell, i, packet_item_update.alSockets[i]);
+	for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
+		rkPlayer.SetItemAttribute(packet_item_update.Cell, j, packet_item_update.aAttr[j].bType, packet_item_update.aAttr[j].sValue);
+
+	__RefreshInventoryWindow();
+	return true;
+}
+
+bool CPythonNetworkStream::RecvItemGroundAddPacket()
+{
+	TPacketGCItemGroundAdd packet_item_ground_add;
+
+	if (!Recv(sizeof(TPacketGCItemGroundAdd), &packet_item_ground_add))
+		return false;
+
+	__GlobalPositionToLocalPosition(packet_item_ground_add.lX, packet_item_ground_add.lY);
+
+	CPythonItem::Instance().CreateItem(packet_item_ground_add.dwVID, 
+									   packet_item_ground_add.dwVnum,
+									   packet_item_ground_add.lX,
+									   packet_item_ground_add.lY,
+									   packet_item_ground_add.lZ);
+	return true;
+}
+
+
+bool CPythonNetworkStream::RecvItemOwnership()
+{
+	TPacketGCItemOwnership p;
+
+	if (!Recv(sizeof(TPacketGCItemOwnership), &p))
+		return false;
+
+	CPythonItem::Instance().SetOwnership(p.dwVID, p.szName);
+	return true;
+}
+
+bool CPythonNetworkStream::RecvItemGroundDelPacket()
+{
+	TPacketGCItemGroundDel	packet_item_ground_del;
+
+	if (!Recv(sizeof(TPacketGCItemGroundDel), &packet_item_ground_del))
+		return false;
+
+	CPythonItem::Instance().DeleteItem(packet_item_ground_del.vid);
+	return true;
+}
+
+bool CPythonNetworkStream::RecvQuickSlotAddPacket()
+{
+	TPacketGCQuickSlotAdd packet_quick_slot_add;
+
+	if (!Recv(sizeof(TPacketGCQuickSlotAdd), &packet_quick_slot_add))
+		return false;
+
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	rkPlayer.AddQuickSlot(packet_quick_slot_add.pos, packet_quick_slot_add.slot.Type, packet_quick_slot_add.slot.Position);
+
+	__RefreshInventoryWindow();
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvQuickSlotDelPacket()
+{
+	TPacketGCQuickSlotDel packet_quick_slot_del;
+
+	if (!Recv(sizeof(TPacketGCQuickSlotDel), &packet_quick_slot_del))
+		return false;
+
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	rkPlayer.DeleteQuickSlot(packet_quick_slot_del.pos);
+
+	__RefreshInventoryWindow();
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvQuickSlotMovePacket()
+{
+	TPacketGCQuickSlotSwap packet_quick_slot_swap;
+
+	if (!Recv(sizeof(TPacketGCQuickSlotSwap), &packet_quick_slot_swap))
+		return false;
+
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	rkPlayer.MoveQuickSlot(packet_quick_slot_swap.pos, packet_quick_slot_swap.change_pos);
+
+	__RefreshInventoryWindow();
+
+	return true;
+}
+
+
+
+bool CPythonNetworkStream::SendShopEndPacket()
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGShop packet_shop;
+	packet_shop.header = HEADER_CG_SHOP;
+	packet_shop.subheader = SHOP_SUBHEADER_CG_END;
+
+	if (!Send(sizeof(packet_shop), &packet_shop))
+	{
+		Tracef("SendShopEndPacket Error\n");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendShopBuyPacket(BYTE bPos)
+{
+	if (!__CanActMainInstance())
+		return true;
+	
+	TPacketCGShop PacketShop;
+	PacketShop.header = HEADER_CG_SHOP;
+	PacketShop.subheader = SHOP_SUBHEADER_CG_BUY;
+
+	if (!Send(sizeof(TPacketCGShop), &PacketShop))
+	{
+		Tracef("SendShopBuyPacket Error\n");
+		return false;
+	}
+
+	BYTE bCount=1;
+	if (!Send(sizeof(BYTE), &bCount))
+	{
+		Tracef("SendShopBuyPacket Error\n");
+		return false;
+	}
+
+	if (!Send(sizeof(BYTE), &bPos))
+	{
+		Tracef("SendShopBuyPacket Error\n");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendShopSellPacket(BYTE bySlot)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGShop PacketShop;
+	PacketShop.header = HEADER_CG_SHOP;
+	PacketShop.subheader = SHOP_SUBHEADER_CG_SELL;
+
+	if (!Send(sizeof(TPacketCGShop), &PacketShop))
+	{
+		Tracef("SendShopSellPacket Error\n");
+		return false;
+	}
+	if (!Send(sizeof(BYTE), &bySlot))
+	{
+		Tracef("SendShopAddSellPacket Error\n");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendShopSellPacketNew(BYTE bySlot, BYTE byCount)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGShop PacketShop;
+	PacketShop.header = HEADER_CG_SHOP;
+	PacketShop.subheader = SHOP_SUBHEADER_CG_SELL2;
+
+	if (!Send(sizeof(TPacketCGShop), &PacketShop))
+	{
+		Tracef("SendShopSellPacket Error\n");
+		return false;
+	}
+	if (!Send(sizeof(BYTE), &bySlot))
+	{
+		Tracef("SendShopAddSellPacket Error\n");
+		return false;
+	}
+	if (!Send(sizeof(BYTE), &byCount))
+	{
+		Tracef("SendShopAddSellPacket Error\n");
+		return false;
+	}
+
+	Tracef(" SendShopSellPacketNew(bySlot=%d, byCount=%d)\n", bySlot, byCount);
+
+	return SendSequence();
+}
+
+// Send
+bool CPythonNetworkStream::SendItemUsePacket(TItemPos pos)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	if (__IsEquipItemInSlot(pos))
+	{
+		if (CPythonExchange::Instance().isTrading())
+		{
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_EXCHANGE"));
+			return true;
+		}
+
+		if (CPythonShop::Instance().IsOpen())
+		{
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_SHOP"));
+			return true;
+		}
+
+		if (__IsPlayerAttacking())
+			return true;
+	}
+
+	__PlayInventoryItemUseSound(pos);
+
+	TPacketCGItemUse itemUsePacket;
+	itemUsePacket.header = HEADER_CG_ITEM_USE;
+	itemUsePacket.pos = pos;
+
+	if (!Send(sizeof(TPacketCGItemUse), &itemUsePacket))
+	{
+		Tracen("SendItemUsePacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendItemUseToItemPacket(TItemPos source_pos, TItemPos target_pos)
+{
+	if (!__CanActMainInstance())
+		return true;	
+
+	TPacketCGItemUseToItem itemUseToItemPacket;
+	itemUseToItemPacket.header = HEADER_CG_ITEM_USE_TO_ITEM;
+	itemUseToItemPacket.source_pos = source_pos;
+	itemUseToItemPacket.target_pos = target_pos;
+
+	if (!Send(sizeof(TPacketCGItemUseToItem), &itemUseToItemPacket))
+	{
+		Tracen("SendItemUseToItemPacket Error");
+		return false;
+	}
+
+#ifdef _DEBUG
+	Tracef(" << SendItemUseToItemPacket(src=%d, dst=%d)\n", source_pos, target_pos);
+#endif
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendItemDropPacket(TItemPos pos, DWORD elk)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGItemDrop itemDropPacket;
+	itemDropPacket.header = HEADER_CG_ITEM_DROP;
+	itemDropPacket.pos = pos;
+	itemDropPacket.elk = elk;
+
+	if (!Send(sizeof(TPacketCGItemDrop), &itemDropPacket))
+	{
+		Tracen("SendItemDropPacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendItemDropPacketNew(TItemPos pos, DWORD elk, DWORD count)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGItemDrop2 itemDropPacket;
+	itemDropPacket.header = HEADER_CG_ITEM_DROP2;
+	itemDropPacket.pos = pos;
+	itemDropPacket.gold = elk;
+	itemDropPacket.count = count;
+
+	if (!Send(sizeof(itemDropPacket), &itemDropPacket))
+	{
+		Tracen("SendItemDropPacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::__IsEquipItemInSlot(TItemPos uSlotPos)
+{
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	return rkPlayer.IsEquipItemInSlot(uSlotPos);
+}
+
+void CPythonNetworkStream::__PlayInventoryItemUseSound(TItemPos uSlotPos)
+{
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	DWORD dwItemID=rkPlayer.GetItemIndex(uSlotPos);
+
+	CPythonItem& rkItem=CPythonItem::Instance();
+	rkItem.PlayUseSound(dwItemID);
+}
+
+void CPythonNetworkStream::__PlayInventoryItemDropSound(TItemPos uSlotPos)
+{
+	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+	DWORD dwItemID=rkPlayer.GetItemIndex(uSlotPos);
+
+	CPythonItem& rkItem=CPythonItem::Instance();
+	rkItem.PlayDropSound(dwItemID);
+}
+
+//void CPythonNetworkStream::__PlayShopItemDropSound(UINT uSlotPos)
+//{
+//	DWORD dwItemID;
+//	CPythonShop& rkShop=CPythonShop::Instance();
+//	if (!rkShop.GetSlotItemID(uSlotPos, &dwItemID))
+//		return;
+//	
+//	CPythonItem& rkItem=CPythonItem::Instance();
+//	rkItem.PlayDropSound(dwItemID);
+//}
+
+void CPythonNetworkStream::__PlaySafeBoxItemDropSound(UINT uSlotPos)
+{
+	DWORD dwItemID;
+	CPythonSafeBox& rkSafeBox=CPythonSafeBox::Instance();
+	if (!rkSafeBox.GetSlotItemID(uSlotPos, &dwItemID))
+		return;
+
+	CPythonItem& rkItem=CPythonItem::Instance();
+	rkItem.PlayDropSound(dwItemID);
+}
+
+void CPythonNetworkStream::__PlayMallItemDropSound(UINT uSlotPos)
+{
+	DWORD dwItemID;
+	CPythonSafeBox& rkSafeBox=CPythonSafeBox::Instance();
+	if (!rkSafeBox.GetSlotMallItemID(uSlotPos, &dwItemID))
+		return;
+
+	CPythonItem& rkItem=CPythonItem::Instance();
+	rkItem.PlayDropSound(dwItemID);
+}
+
+bool CPythonNetworkStream::SendItemMovePacket(TItemPos pos, TItemPos change_pos, BYTE num)
+{	
+	if (!__CanActMainInstance())
+		return true;
+	
+	if (__IsEquipItemInSlot(pos))
+	{
+		if (CPythonExchange::Instance().isTrading())
+		{
+			if (pos.IsEquipCell() || change_pos.IsEquipCell())
+			{
+				PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_EXCHANGE"));
+				return true;
+			}
+		}
+
+		if (CPythonShop::Instance().IsOpen())
+		{
+			if (pos.IsEquipCell() || change_pos.IsEquipCell())
+			{
+				PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_SHOP"));
+				return true;
+			}
+		}
+
+		if (__IsPlayerAttacking())
+			return true;
+	}
+
+	__PlayInventoryItemDropSound(pos);
+
+	TPacketCGItemMove	itemMovePacket;
+	itemMovePacket.header = HEADER_CG_ITEM_MOVE;
+	itemMovePacket.pos = pos;
+	itemMovePacket.change_pos = change_pos;
+	itemMovePacket.num = num;
+
+	if (!Send(sizeof(TPacketCGItemMove), &itemMovePacket))
+	{
+		Tracen("SendItemMovePacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendItemPickUpPacket(DWORD vid)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGItemPickUp	itemPickUpPacket;
+	itemPickUpPacket.header = HEADER_CG_ITEM_PICKUP;
+	itemPickUpPacket.vid = vid;
+
+	if (!Send(sizeof(TPacketCGItemPickUp), &itemPickUpPacket))
+	{
+		Tracen("SendItemPickUpPacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+
+bool CPythonNetworkStream::SendQuickSlotAddPacket(BYTE wpos, BYTE type, BYTE pos)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGQuickSlotAdd quickSlotAddPacket;
+
+	quickSlotAddPacket.header		= HEADER_CG_QUICKSLOT_ADD;
+	quickSlotAddPacket.pos			= wpos;
+	quickSlotAddPacket.slot.Type	= type;
+	quickSlotAddPacket.slot.Position = pos;
+
+	if (!Send(sizeof(TPacketCGQuickSlotAdd), &quickSlotAddPacket))
+	{
+		Tracen("SendQuickSlotAddPacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendQuickSlotDelPacket(BYTE pos)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGQuickSlotDel quickSlotDelPacket;
+
+	quickSlotDelPacket.header = HEADER_CG_QUICKSLOT_DEL;
+	quickSlotDelPacket.pos = pos;
+
+	if (!Send(sizeof(TPacketCGQuickSlotDel), &quickSlotDelPacket))
+	{
+		Tracen("SendQuickSlotDelPacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendQuickSlotMovePacket(BYTE pos, BYTE change_pos)
+{
+	if (!__CanActMainInstance())
+		return true;
+
+	TPacketCGQuickSlotSwap quickSlotSwapPacket;
+
+	quickSlotSwapPacket.header = HEADER_CG_QUICKSLOT_SWAP;
+	quickSlotSwapPacket.pos = pos;
+	quickSlotSwapPacket.change_pos = change_pos;
+
+	if (!Send(sizeof(TPacketCGQuickSlotSwap), &quickSlotSwapPacket))
+	{
+		Tracen("SendQuickSlotSwapPacket Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::RecvSpecialEffect()
+{
+	TPacketGCSpecialEffect kSpecialEffect;
+	if (!Recv(sizeof(kSpecialEffect), &kSpecialEffect))
+		return false;
+
+	DWORD effect = -1;
+	bool bPlayPotionSound = false;	//포션을 먹을 경우는 포션 사운드를 출력하자.!!
+	bool bAttachEffect = true;		//캐리터에 붙는 어태치 이펙트와 일반 이펙트 구분.!!
+	switch (kSpecialEffect.type)
+	{
+		case SE_HPUP_RED:
+			effect = CInstanceBase::EFFECT_HPUP_RED;
+			bPlayPotionSound = true;
+			break;
+		case SE_SPUP_BLUE:
+			effect = CInstanceBase::EFFECT_SPUP_BLUE;
+			bPlayPotionSound = true;
+			break;
+		case SE_SPEEDUP_GREEN:
+			effect = CInstanceBase::EFFECT_SPEEDUP_GREEN;
+			bPlayPotionSound = true;
+			break;
+		case SE_DXUP_PURPLE:
+			effect = CInstanceBase::EFFECT_DXUP_PURPLE;
+			bPlayPotionSound = true;
+			break;
+		case SE_CRITICAL:
+			effect = CInstanceBase::EFFECT_CRITICAL;
+			break;
+		case SE_PENETRATE:
+			effect = CInstanceBase::EFFECT_PENETRATE;
+			break;
+		case SE_BLOCK:
+			effect = CInstanceBase::EFFECT_BLOCK;
+			break;
+		case SE_DODGE:
+			effect = CInstanceBase::EFFECT_DODGE;
+			break;
+		case SE_CHINA_FIREWORK:
+			effect = CInstanceBase::EFFECT_FIRECRACKER;
+			bAttachEffect = false;
+			break;
+		case SE_SPIN_TOP:
+			effect = CInstanceBase::EFFECT_SPIN_TOP;
+			bAttachEffect = false;
+			break;
+		case SE_SUCCESS :
+			effect = CInstanceBase::EFFECT_SUCCESS ;
+			bAttachEffect = false ;
+			break ;
+		case SE_FAIL :
+			effect = CInstanceBase::EFFECT_FAIL ;
+			break ;
+		case SE_FR_SUCCESS:
+			effect = CInstanceBase::EFFECT_FR_SUCCESS;
+			bAttachEffect = false ;
+			break;
+		case SE_LEVELUP_ON_14_FOR_GERMANY:	//레벨업 14일때 ( 독일전용 )
+			effect = CInstanceBase::EFFECT_LEVELUP_ON_14_FOR_GERMANY;
+			bAttachEffect = false ;
+			break;
+		case SE_LEVELUP_UNDER_15_FOR_GERMANY: //레벨업 15일때 ( 독일전용 )
+			effect = CInstanceBase::EFFECT_LEVELUP_UNDER_15_FOR_GERMANY;
+			bAttachEffect = false ;
+			break;
+		case SE_PERCENT_DAMAGE1:
+			effect = CInstanceBase::EFFECT_PERCENT_DAMAGE1;
+			break;
+		case SE_PERCENT_DAMAGE2:
+			effect = CInstanceBase::EFFECT_PERCENT_DAMAGE2;
+			break;
+		case SE_PERCENT_DAMAGE3:
+			effect = CInstanceBase::EFFECT_PERCENT_DAMAGE3;
+			break;
+		case SE_AUTO_HPUP:
+			effect = CInstanceBase::EFFECT_AUTO_HPUP;
+			break;
+		case SE_AUTO_SPUP:
+			effect = CInstanceBase::EFFECT_AUTO_SPUP;
+			break;
+		case SE_EQUIP_RAMADAN_RING:
+			effect = CInstanceBase::EFFECT_RAMADAN_RING_EQUIP;
+			break;
+		case SE_EQUIP_HALLOWEEN_CANDY:
+			effect = CInstanceBase::EFFECT_HALLOWEEN_CANDY_EQUIP;
+			break;
+		case SE_EQUIP_HAPPINESS_RING:
+ 			effect = CInstanceBase::EFFECT_HAPPINESS_RING_EQUIP;
+			break;
+		case SE_EQUIP_LOVE_PENDANT:
+			effect = CInstanceBase::EFFECT_LOVE_PENDANT_EQUIP;
+			break;
+
+		
+		default:
+			TraceError("%d \264\302 \276\370\264\302 \275\272\306\344\274\310 \300\314\306\345\306\256 \271\370\310\243\300\324\264\317\264\331.TPacketGCSpecialEffect",kSpecialEffect.type);
+			break;
+	}
+
+	if (bPlayPotionSound)
+	{		
+		IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
+		if(rkPlayer.IsMainCharacterIndex(kSpecialEffect.vid))
+		{
+			CPythonItem& rkItem=CPythonItem::Instance();
+			rkItem.PlayUsePotionSound();
+		}
+	}
+
+	if (-1 != effect)
+	{
+		CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kSpecialEffect.vid);
+		if (pInstance)
+		{
+			if(bAttachEffect)
+				pInstance->AttachSpecialEffect(effect);
+			else
+				pInstance->CreateSpecialEffect(effect);
+		}
+	}
+
+	return true;
+}
+
+
+bool CPythonNetworkStream::RecvSpecificEffect()
+{
+	TPacketGCSpecificEffect kSpecificEffect;
+	if (!Recv(sizeof(kSpecificEffect), &kSpecificEffect))
+		return false;
+
+	CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kSpecificEffect.vid);
+	//EFFECT_TEMP
+	if (pInstance)
+	{
+		CInstanceBase::RegisterEffect(CInstanceBase::EFFECT_TEMP, "", kSpecificEffect.effect_file, false);
+		pInstance->AttachSpecialEffect(CInstanceBase::EFFECT_TEMP);
+	}
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvDragonSoulRefine()
+{
+	TPacketGCDragonSoulRefine kDragonSoul;
+
+	if (!Recv(sizeof(kDragonSoul), &kDragonSoul))
+		return false;
+	
+	
+	switch (kDragonSoul.bSubType)
+	{
+	case DS_SUB_HEADER_OPEN:
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_Open", Py_BuildValue("()"));
+		break;
+	case DS_SUB_HEADER_REFINE_FAIL:
+	case DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE:
+	case DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL:
+	case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY:
+	case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL:
+	case DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL:
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_RefineFail", Py_BuildValue("(iii)", 
+			kDragonSoul.bSubType, kDragonSoul.Pos.window_type, kDragonSoul.Pos.cell));
+		break;
+	case DS_SUB_HEADER_REFINE_SUCCEED:
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_RefineSucceed", 
+				Py_BuildValue("(ii)", kDragonSoul.Pos.window_type, kDragonSoul.Pos.cell));
+		break;
+	}
+
+	return true;
+}

extension/src/port/UserInterface/StdAfx.h

@@ -44,4 +44,5 @@ enum
 // Listed here as 40250 lists them; only the ported ones are defined.
 void initpack();
 void initapp();
+void initChat();
 void initnet();