SHINING BUG SASH

Kid0 · September 10, 2016

How can I fix this bug ?!

Edited August 26, 2022 by Metin2 Dev
Core X - External 2 Internal

pollux · September 10, 2016

You have to edit the alpha layer via photoshop of your texture and then set a specular in your item_proto clientside.

Legend · September 10, 2016

Paste your InstanceBase.cpp

Kid0 · September 10, 2016

#include "StdAfx.h"
#include "InstanceBase.h"
#include "PythonBackground.h"
#include "PythonNonPlayer.h"
#include "PythonPlayer.h"
#include "PythonCharacterManager.h"
#include "AbstractPlayer.h"
#include "AbstractApplication.h"
#include "packet.h"

#include "../eterlib/StateManager.h"
#include "../gamelib/ItemManager.h"
#include "Locale_inc.h"

#include "PythonShining.h"
#include "PythonMounts.h"

BOOL HAIR_COLOR_ENABLE=FALSE;
BOOL USE_ARMOR_SPECULAR=FALSE;
BOOL RIDE_HORSE_ENABLE=TRUE;
const float c_fDefaultRotationSpeed = 1200.0f;
const float c_fDefaultHorseRotationSpeed = 300.0f;

TMapShiningVectorByVNum g_mapShiningVectorByVNum;
TMapMountLevelByVNum g_mapMountLevelByVNum;

bool IsWall(unsigned race)
{
   switch (race)
   {
       case 14201:
       case 14202:
       case 14203:
       case 14204:
           return true;
           break;
   }
   return false;
}

//////////////////////////////////////////////////////////////////////////////////////

CInstanceBase::SHORSE::SHORSE()
{
__Initialize();
}

CInstanceBase::SHORSE::~SHORSE()
{
assert(m_pkActor==NULL);
}

void CInstanceBase::SHORSE::__Initialize()
{
m_isMounting=false;
m_pkActor=NULL;
}

void CInstanceBase::SHORSE::SetAttackSpeed(UINT uAtkSpd)
{
if (!IsMounting())
return;

CActorInstance& rkActor=GetActorRef();
rkActor.SetAttackSpeed(uAtkSpd/100.0f);
}

void CInstanceBase::SHORSE::SetMoveSpeed(UINT uMovSpd)
{
   if (!IsMounting())
       return;

CActorInstance& rkActor=GetActorRef();
rkActor.SetMoveSpeed(uMovSpd/100.0f);
}

void CInstanceBase::SHORSE::Create(const TPixelPosition& c_rkPPos, UINT eRace, UINT eHitEffect)
{
assert(NULL==m_pkActor && "CInstanceBase::SHORSE::Create - ALREADY MOUNT");

m_pkActor=new CActorInstance;

   CActorInstance& rkActor=GetActorRef();
   rkActor.SetEventHandler(CActorInstance::IEventHandler::GetEmptyPtr());
   if (!rkActor.SetRace(eRace))
   {
       delete m_pkActor;
       m_pkActor=NULL;
       return;
   }

   rkActor.SetShape(0);
   rkActor.SetBattleHitEffect(eHitEffect);
   rkActor.SetAlphaValue(0.0f);
   rkActor.BlendAlphaValue(1.0f, 0.5f);
   rkActor.SetMoveSpeed(1.0f);
   rkActor.SetAttackSpeed(1.0f);
   rkActor.SetMotionMode(CRaceMotionData::MODE_GENERAL);
   rkActor.Stop();
   rkActor.RefreshActorInstance();

rkActor.SetCurPixelPosition(c_rkPPos);

m_isMounting=true;
}

void CInstanceBase::SHORSE::Destroy()
{
   if (m_pkActor)
   {
       m_pkActor->Destroy();
       delete m_pkActor;
   }

__Initialize();
}

CActorInstance& CInstanceBase::SHORSE::GetActorRef()
{
assert(NULL!=m_pkActor && "CInstanceBase::SHORSE::GetActorRef");
return *m_pkActor;
}

CActorInstance* CInstanceBase::SHORSE::GetActorPtr()
{
return m_pkActor;
}

UINT CInstanceBase::SHORSE::GetLevel()
{
   if (m_pkActor)
   {
       DWORD mount = m_pkActor->GetRace();

       TMapMountLevelByVNum::iterator it = g_mapMountLevelByVNum.find(mount);
       if (it == g_mapMountLevelByVNum.end())
           return 0;

       return it->second;
   }
   return 0;
}

bool CInstanceBase::SHORSE::CanUseSkill()
{
   // ¸¶»ó½ºÅ³Àº ¸»ÀÇ ·¹º§ÀÌ 3 ÀÌ»óÀÌ¾î¾ß¸¸ ÇÔ.
   if (IsMounting())
       return 2 < GetLevel();

return true;
}

bool CInstanceBase::SHORSE::CanAttack()
{
   if (IsMounting())
       if (GetLevel()<=1)
           return false;

   return true;
}

bool CInstanceBase::SHORSE::IsMounting()
{
   return m_isMounting;
}

void CInstanceBase::SHORSE::Deform()
{
if (!IsMounting())
return;

CActorInstance& rkActor=GetActorRef();
rkActor.INSTANCEBASE_Deform();
}

void CInstanceBase::SHORSE::Render()
{
if (!IsMounting())
return;

CActorInstance& rkActor=GetActorRef();
rkActor.Render();
}

void CInstanceBase::__AttachHorseSaddle()
{
   if (!IsMountingHorse())
       return;
   m_kHorse.m_pkActor->AttachModelInstance(CRaceData::PART_MAIN, "saddle", m_GraphicThingInstance, CRaceData::PART_MAIN);
}

void CInstanceBase::__DetachHorseSaddle()
{
   if (!IsMountingHorse())
       return;
   m_kHorse.m_pkActor->DetachModelInstance(CRaceData::PART_MAIN, m_GraphicThingInstance, CRaceData::PART_MAIN);
}

//////////////////////////////////////////////////////////////////////////////////////

void CInstanceBase::BlockMovement()
{
m_GraphicThingInstance.BlockMovement();
}

bool CInstanceBase::IsBlockObject(const CGraphicObjectInstance& c_rkBGObj)
{
return m_GraphicThingInstance.IsBlockObject(c_rkBGObj);
}

bool CInstanceBase::AvoidObject(const CGraphicObjectInstance& c_rkBGObj)
{
return m_GraphicThingInstance.AvoidObject(c_rkBGObj);
}

///////////////////////////////////////////////////////////////////////////////////

bool __ArmorVnumToShape(int iVnum, DWORD * pdwShape)
{
*pdwShape = iVnum;

/////////////////////////////////////////

if (0 == iVnum || 1 == iVnum)
return false;

if (!USE_ARMOR_SPECULAR)
return false;

   CItemData * pItemData;
   if (!CItemManager::Instance().GetItemDataPointer(iVnum, &pItemData))
       return false;

   enum
   {
       SHAPE_VALUE_SLOT_INDEX = 3,
   };

*pdwShape = pItemData->GetValue(SHAPE_VALUE_SLOT_INDEX);

return true;
}

// 2004.07.05.myevan.±Ã½ÅÅº¿µ ³¢ÀÌ´Â ¹®Á¦
class CActorInstanceBackground : public IBackground
{
   public:
       CActorInstanceBackground() {}
       virtual ~CActorInstanceBackground() {}
       bool IsBlock(int x, int y)
       {
           CPythonBackground& rkBG=CPythonBackground::Instance();
           return rkBG.isAttrOn(x, y, CTerrainImpl::ATTRIBUTE_BLOCK);
       }
};

static CActorInstanceBackground gs_kActorInstBG;

bool CInstanceBase::LessRenderOrder(CInstanceBase* pkInst)
{
   int nMainAlpha=(__GetAlphaValue() < 1.0f) ? 1 : 0;
   int nTestAlpha=(pkInst->__GetAlphaValue() < 1.0f) ? 1 : 0;
   if (nMainAlpha < nTestAlpha)
       return true;
   if (nMainAlpha > nTestAlpha)
       return false;

   if (GetRace()<pkInst->GetRace())
       return true;
   if (GetRace()>pkInst->GetRace())
       return false;

if (GetShape()<pkInst->GetShape())
return true;

if (GetShape()>pkInst->GetShape())
return false;

   UINT uLeftLODLevel=__LessRenderOrder_GetLODLevel();
   UINT uRightLODLevel=pkInst->__LessRenderOrder_GetLODLevel();
   if (uLeftLODLevel<uRightLODLevel)
       return true;
   if (uLeftLODLevel>uRightLODLevel)
       return false;

if (m_awPart[CRaceData::PART_WEAPON]<pkInst->m_awPart[CRaceData::PART_WEAPON])
return true;

return false;
}

UINT CInstanceBase::__LessRenderOrder_GetLODLevel()
{
   CGrannyLODController* pLODCtrl=m_GraphicThingInstance.GetLODControllerPointer(0);
   if (!pLODCtrl)
       return 0;

return pLODCtrl->GetLODLevel();
}

bool CInstanceBase::__Background_GetWaterHeight(const TPixelPosition& c_rkPPos, float* pfHeight)
{
   long lHeight;
   if (!CPythonBackground::Instance().GetWaterHeight(int(c_rkPPos.x), int(c_rkPPos.y), &lHeight))
       return false;

*pfHeight = float(lHeight);

return true;
}

bool CInstanceBase::__Background_IsWaterPixelPosition(const TPixelPosition& c_rkPPos)
{
return CPythonBackground::Instance().isAttrOn(c_rkPPos.x, c_rkPPos.y, CTerrainImpl::ATTRIBUTE_WATER);
}

const float PC_DUST_RANGE = 2000.0f;
const float NPC_DUST_RANGE = 1000.0f;

DWORD CInstanceBase::ms_dwUpdateCounter=0;
DWORD CInstanceBase::ms_dwRenderCounter=0;
DWORD CInstanceBase::ms_dwDeformCounter=0;

CDynamicPool<CInstanceBase> CInstanceBase::ms_kPool;

bool CInstanceBase::__IsInDustRange()
{
if (!__IsExistMainInstance())
return false;

CInstanceBase* pkInstMain=__GetMainInstancePtr();

float fDistance=NEW_GetDistanceFromDestInstance(*pkInstMain);

   if (IsPC())
   {
       if (fDistance<=PC_DUST_RANGE)
           return true;
   }

if (fDistance<=NPC_DUST_RANGE)
return true;

return false;
}

void CInstanceBase::__EnableSkipCollision()
{
   if (__IsMainInstance())
   {
       TraceError("CInstanceBase::__EnableSkipCollision - ÀÚ½ÅÀº Ãæµ¹°Ë»ç½ºÅµÀÌ µÇ¸é ¾ÈµÈ´Ù!!");
       return;
   }
   m_GraphicThingInstance.EnableSkipCollision();
}

void CInstanceBase::__DisableSkipCollision()
{
m_GraphicThingInstance.DisableSkipCollision();
}

DWORD CInstanceBase::__GetShadowMapColor(float x, float y)
{
CPythonBackground& rkBG=CPythonBackground::Instance();
return rkBG.GetShadowMapColor(x, y);
}

float CInstanceBase::__GetBackgroundHeight(float x, float y)
{
CPythonBackground& rkBG=CPythonBackground::Instance();
return rkBG.GetHeight(x, y);
}

#ifdef __MOVIE_MODE__

BOOL CInstanceBase::IsMovieMode()
{
if (IsAffect(AFFECT_INVISIBILITY))
return true;

return false;
}

#endif

BOOL CInstanceBase::IsInvisibility()
{
if (IsAffect(AFFECT_INVISIBILITY))
return true;

return false;
}

BOOL CInstanceBase::IsParalysis()
{
return m_GraphicThingInstance.IsParalysis();
}

BOOL CInstanceBase::IsGameMaster()
{
   if (m_kAffectFlagContainer.IsSet(AFFECT_YMIR))
       return true;
   return false;
}

BOOL CInstanceBase::IsVIP()
{
   if (m_kAffectFlagContainer.IsSet(AFFECT_VIP))
       return true;
   return false;
}

BOOL CInstanceBase::IsSameEmpire(CInstanceBase& rkInstDst)
{
if (0 == rkInstDst.m_dwEmpireID)
return TRUE;

if (IsGameMaster())
return TRUE;

   if (IsVIP())
       return TRUE;

   if (rkInstDst.IsGameMaster())
       return TRUE;

   if (rkInstDst.IsVIP())
       return TRUE;

   if (rkInstDst.m_dwEmpireID==m_dwEmpireID)
       return TRUE;

return FALSE;
}

DWORD CInstanceBase::GetEmpireID()
{
return m_dwEmpireID;
}

DWORD CInstanceBase::GetGuildID()
{
return m_dwGuildID;
}

int CInstanceBase::GetAlignment()
{
return m_sAlignment;
}

UINT CInstanceBase::GetAlignmentGrade()
{
   if (m_sAlignment >= 12000)
       return 0;
   else if (m_sAlignment >= 8000)
       return 1;
   else if (m_sAlignment >= 4000)
       return 2;
   else if (m_sAlignment >= 1000)
       return 3;
   else if (m_sAlignment >= 0)
       return 4;
   else if (m_sAlignment > -4000)
       return 5;
   else if (m_sAlignment > -8000)
       return 6;
   else if (m_sAlignment > -12000)
       return 7;

return 8;
}

int CInstanceBase::GetAlignmentType()
{
   switch (GetAlignmentGrade())
   {
       case 0:
       case 1:
       case 2:
       case 3:
       {
           return ALIGNMENT_TYPE_WHITE;
           break;
       }

       case 5:
       case 6:
       case 7:
       case 8:
       {
           return ALIGNMENT_TYPE_DARK;
           break;
       }
   }

return ALIGNMENT_TYPE_NORMAL;
}

BYTE CInstanceBase::GetPKMode()
{
return m_byPKMode;
}

bool CInstanceBase::IsKiller()
{
return m_isKiller;
}

bool CInstanceBase::IsPartyMember()
{
return m_isPartyMember;
}

BOOL CInstanceBase::IsInSafe()
{
   const TPixelPosition& c_rkPPosCur=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
   if (CPythonBackground::Instance().isAttrOn(c_rkPPosCur.x, c_rkPPosCur.y, CTerrainImpl::ATTRIBUTE_BANPK))
       return TRUE;

return FALSE;
}

float CInstanceBase::CalculateDistanceSq3d(const TPixelPosition& c_rkPPosDst)
{
const TPixelPosition& c_rkPPosSrc=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
return SPixelPosition_CalculateDistanceSq3d(c_rkPPosSrc, c_rkPPosDst);
}

void CInstanceBase::OnSelected()
{
#ifdef __MOVIE_MODE__
if (!__IsExistMainInstance())
return;
#endif

if (IsStoneDoor())
return;

if (IsDead())
return;

   if (IsEnemy())
   {
       __AttachSelectEffectMonster();
   }

   if (IsPC() || IsNPC())
   {
       if (m_dwEmpireID == 1) // Shinshoo
       {
           __AttachSelectEffectShinsoo();
       }
       else if (m_dwEmpireID == 2) // chunjo
       {
           __AttachSelectEffectChunjo();
       }
       else if (m_dwEmpireID == 3)//Jinnos
       {
           __AttachSelectEffectJinnos();
       }
       else
       {
           __AttachSelectEffectMonster();
       }
   }
}

void CInstanceBase::OnUnselected()
{
//__DetachSelectEffect();

   if (IsPC() || IsNPC())
   {
       if (m_dwEmpireID == 1) //Shinsoo
       {
           __DetachSelectEffectShinsoo();
       }
       else if (m_dwEmpireID == 2)//Chunjo
       {
           __DetachSelectEffectChunjo();
       }
       else if (m_dwEmpireID == 3)//Jinnnos
       {
           __DetachSelectEffectJinnos();
       }
       else
       {
           __DetachSelectEffectMonster();
       }
   }
   if (IsEnemy())
   {
       __DetachSelectEffectMonster();
   }
}

void CInstanceBase::OnTargeted()
{
#ifdef __MOVIE_MODE__
if (!__IsExistMainInstance())
return;
#endif

if (IsStoneDoor())
return;

if (IsDead())
return;

   if (IsEnemy())
   {
       __AttachTargetEffectMonster();
   }

   if (IsPC() || IsNPC())
   {
       if (m_dwEmpireID == 1) //Shinsoo
       {
           __AttachTargetEffectShinsoo();
       }
       else if (m_dwEmpireID == 2)//Chunjo
       {
           __AttachTargetEffectChunjo();
       }
       else if (m_dwEmpireID == 3)//Jinnnos
       {
           __AttachTargetEffectJinnos();
       }
       else
       {
           __AttachTargetEffectMonster();
       }
   }
}

void CInstanceBase::OnUntargeted()
{

   if (IsPC() || IsNPC())
   {
       if (m_dwEmpireID == 1) //Shinsoo
       {
           __DetachTargetEffectShinsoo();
       }
       else if (m_dwEmpireID == 2)//Chunjo
       {
           __DetachTargetEffectChunjo();
       }
       else if (m_dwEmpireID == 3)//Jinnnos
       {
           __DetachTargetEffectJinnos();
       }
       else
       {
           __DetachTargetEffectMonster();
       }
   }
   if (IsEnemy())
   {
       __DetachTargetEffectMonster();
   }
}

void CInstanceBase::DestroySystem()
{
ms_kPool.Clear();
}

void CInstanceBase::CreateSystem(UINT uCapacity)
{
ms_kPool.Create(uCapacity);

memset(ms_adwCRCAffectEffect, 0, sizeof(ms_adwCRCAffectEffect));

ms_fDustGap=250.0f;
ms_fHorseDustGap=500.0f;
}

CInstanceBase* CInstanceBase::New()
{
return ms_kPool.Alloc();
}

void CInstanceBase::Delete(CInstanceBase* pkInst)
{
pkInst->Destroy();
ms_kPool.Free(pkInst);
}

void CInstanceBase::SetMainInstance()
{
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();

DWORD dwVID=GetVirtualID();
rkChrMgr.SetMainInstance(dwVID);

m_GraphicThingInstance.SetMainInstance();
}

CInstanceBase* CInstanceBase::__GetMainInstancePtr()
{
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
return rkChrMgr.GetMainInstancePtr();
}

void CInstanceBase::__ClearMainInstance()
{
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
rkChrMgr.ClearMainInstance();
}

/* ½ÇÁ¦ ÇÃ·¹ÀÌ¾î Ä³¸¯ÅÍÀÎÁö Á¶»ç.*/
bool CInstanceBase::__IsMainInstance()
{
if (this==__GetMainInstancePtr())
return true;

return false;
}

bool CInstanceBase::__IsExistMainInstance()
{
   if(__GetMainInstancePtr())
       return true;
   else
       return false;
}

bool CInstanceBase::__MainCanSeeHiddenThing()
{
   return false;
//   CInstanceBase * pInstance = __GetMainInstancePtr();
//   return pInstance->IsAffect(AFFECT_GAMJI);
}

float CInstanceBase::__GetBowRange()
{
float fRange = 2500.0f - 100.0f;

   if (__IsMainInstance())
   {
       IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
       fRange += float(rPlayer.GetStatus(POINT_BOW_DISTANCE));
   }

return fRange;
}

CInstanceBase* CInstanceBase::__FindInstancePtr(DWORD dwVID)
{
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
return rkChrMgr.GetInstancePtr(dwVID);
}

bool CInstanceBase::__FindRaceType(DWORD dwRace, BYTE* pbType)
{
CPythonNonPlayer& rkNonPlayer=CPythonNonPlayer::Instance();
return rkNonPlayer.GetInstanceType(dwRace, pbType);
}

bool CInstanceBase::Create(const SCreateData& c_rkCreateData)
{
IAbstractApplication::GetSingleton().SkipRenderBuffering(300);

SetInstanceType(c_rkCreateData.m_bType);

if (!SetRace(c_rkCreateData.m_dwRace))
return false;

SetVirtualID(c_rkCreateData.m_dwVID);

if (c_rkCreateData.m_isMain)
SetMainInstance();

   if (IsGuildWall())
   {
       unsigned center_x;
       unsigned center_y;

       c_rkCreateData.m_kAffectFlags.ConvertToPosition(&center_x, &center_y);

       float center_z = __GetBackgroundHeight(center_x, center_y);
       NEW_SetPixelPosition(TPixelPosition(float(c_rkCreateData.m_lPosX), float(c_rkCreateData.m_lPosY), center_z));
   }
   else
   {
       SCRIPT_SetPixelPosition(float(c_rkCreateData.m_lPosX), float(c_rkCreateData.m_lPosY));
   }

if (0 != c_rkCreateData.m_dwMountVnum)
MountHorse(c_rkCreateData.m_dwMountVnum);

SetArmor(c_rkCreateData.m_dwArmor);

   if (IsPC())
   {
       SetHair(c_rkCreateData.m_dwHair);
       SetAcce(c_rkCreateData.m_dwAcce);
       SetWeapon(c_rkCreateData.m_dwWeapon);
   }

__Create_SetName(c_rkCreateData);

   if (GetInstanceType() == CActorInstance::TYPE_ENEMY)
       m_dwLevel = CPythonNonPlayer::Instance().GetMobLevel(GetRace());
   else
       m_dwLevel = c_rkCreateData.m_dwLevel;
   m_dwGuildID = c_rkCreateData.m_dwGuildID;
   m_dwEmpireID = c_rkCreateData.m_dwEmpireID;

SetVirtualNumber(c_rkCreateData.m_dwRace);
SetRotation(c_rkCreateData.m_fRot);

SetAlignment(c_rkCreateData.m_sAlignment);
SetPKMode(c_rkCreateData.m_byPKMode);

   SetMoveSpeed(c_rkCreateData.m_dwMovSpd);
   SetAttackSpeed(c_rkCreateData.m_dwAtkSpd);

   // NOTE : Dress ¸¦ ÀÔ°í ÀÖÀ¸¸é Alpha ¸¦ ³ÖÁö ¾Ê´Â´Ù.
   if (!IsWearingDress())
   {
       // NOTE : ¹Ýµå½Ã Affect ¼ÂÆÃ ÀÂÊ¿¡ ÀÖ¾î¾ß ÇÔ
       m_GraphicThingInstance.SetAlphaValue(0.0f);
       m_GraphicThingInstance.BlendAlphaValue(1.0f, 0.5f);
   }

   if (!IsGuildWall())
   {
       SetAffectFlagContainer(c_rkCreateData.m_kAffectFlags);
   }

   // NOTE : ¹Ýµå½Ã Affect ¼ÂÆÃ ÈÄ¿¡ ÇØ¾ß ÇÔ
   AttachTextTail();
   RefreshTextTail();

   if (c_rkCreateData.m_dwStateFlags & ADD_CHARACTER_STATE_SPAWN)
   {
       if (IsAffect(AFFECT_SPAWN))
           __AttachEffect(EFFECT_SPAWN_APPEAR);

       if (IsPC())
       {
           Refresh(CRaceMotionData::NAME_WAIT, true);
       }
       else
       {
           Refresh(CRaceMotionData::NAME_SPAWN, false);
       }
   }
   else
   {
       Refresh(CRaceMotionData::NAME_WAIT, true);
   }

__AttachEmpireEffect(c_rkCreateData.m_dwEmpireID);

RegisterBoundingSphere();

if (c_rkCreateData.m_dwStateFlags & ADD_CHARACTER_STATE_DEAD)
m_GraphicThingInstance.DieEnd();

SetStateFlags(c_rkCreateData.m_dwStateFlags);

m_GraphicThingInstance.SetBattleHitEffect(ms_adwCRCAffectEffect[EFFECT_HIT]);

   if (!IsPC())
   {
       DWORD dwBodyColor = CPythonNonPlayer::Instance().GetMonsterColor(c_rkCreateData.m_dwRace);
       if (0 != dwBodyColor)
       {
           SetModulateRenderMode();
           SetAddColor(dwBodyColor);
       }
   }

__AttachHorseSaddle();

   // ±æµå ½Éº¼À» À§ÇÑ ÀÓ½Ã ÄÚµå, ÀûÁ¤ À§Ä¡¸¦ Ã£´Â Áß
   const int c_iGuildSymbolRace = 14200;
   if (c_iGuildSymbolRace == GetRace())
   {
       std::string strFileName = GetGuildSymbolFileName(m_dwGuildID);
       if (IsFile(strFileName.c_str()))
           m_GraphicThingInstance.ChangeMaterial(strFileName.c_str());
   }

return true;
}

void CInstanceBase::__Create_SetName(const SCreateData& c_rkCreateData)
{
   if (IsGoto())
   {
       SetNameString("", 0);
       return;
   }
   if (IsWarp())
   {
       __Create_SetWarpName(c_rkCreateData);
       return;
   }

SetNameString(c_rkCreateData.m_stName.c_str(), c_rkCreateData.m_stName.length());
}

void CInstanceBase::__Create_SetWarpName(const SCreateData& c_rkCreateData)
{
   const char * c_szName;
   if (CPythonNonPlayer::Instance().GetName(c_rkCreateData.m_dwRace, &c_szName))
   {
       std::string strName = c_szName;
       int iFindingPos = strName.find_first_of(" ", 0);
       if (iFindingPos > 0)
       {
           strName.resize(iFindingPos);
       }
       SetNameString(strName.c_str(), strName.length());
   }
   else
   {
       SetNameString(c_rkCreateData.m_stName.c_str(), c_rkCreateData.m_stName.length());
   }
}

void CInstanceBase::SetNameString(const char* c_szName, int len)
{
   m_stName.assign(c_szName, len);
   if (GetInstanceType() == CActorInstance::TYPE_ENEMY &&
       IS_SET(CPythonNonPlayer::Instance().GetMobAIFlag(GetRace()), CPythonNonPlayer::AIFLAG_AGGRESSIVE))
       m_stName.append("*");
}

bool CInstanceBase::SetRace(DWORD eRace)
{
m_dwRace = eRace;

if (!m_GraphicThingInstance.SetRace(eRace))
return false;

if (!__FindRaceType(m_dwRace, &m_eRaceType))
m_eRaceType=CActorInstance::TYPE_PC;

return true;
}

BOOL CInstanceBase::__IsChangableWeapon(int iWeaponID)
{
   // µå·¹½º ÀÔ°í ÀÖÀ»¶§´Â ºÎÄÉ¿ÜÀÇ Àåºñ´Â ³ª¿ÀÁö ¾Ê°Ô..
   if (IsWearingDress())
   {
       const int c_iBouquets[] =
       {
           50201,   // Bouquet for Assassin
           50202,   // Bouquet for Shaman
           50203,
           50204,
           0, // #0000545: [M2CN] ¿þµù µå·¹½º¿Í Àåºñ Âø¿ë ¹®Á¦
       };

       for (int i = 0; c_iBouquets != 0; ++i)
           if (iWeaponID == c_iBouquets)
               return true;

       return false;
   }
   else
       return true;
}

BOOL CInstanceBase::IsWearingDress()
{
const int c_iWeddingDressShape = 201;
return c_iWeddingDressShape == m_eShape;
}

BOOL CInstanceBase::IsHoldingPickAxe()
{
   const int c_iPickAxeStart = 29101;
   const int c_iPickAxeEnd = 29110;
   return m_awPart[CRaceData::PART_WEAPON] >= c_iPickAxeStart && m_awPart[CRaceData::PART_WEAPON] <= c_iPickAxeEnd;
}

BOOL CInstanceBase::IsMountingHorse()
{
return m_kHorse.IsMounting();
}

void CInstanceBase::MountHorse(UINT eRace)
{
m_kHorse.Destroy();
m_kHorse.Create(m_GraphicThingInstance.NEW_GetCurPixelPositionRef(), eRace, ms_adwCRCAffectEffect[EFFECT_HIT]);

SetMotionMode(CRaceMotionData::MODE_HORSE);
SetRotationSpeed(c_fDefaultHorseRotationSpeed);

   m_GraphicThingInstance.MountHorse(m_kHorse.GetActorPtr());
   m_GraphicThingInstance.Stop();
   m_GraphicThingInstance.RefreshActorInstance();
}

void CInstanceBase::DismountHorse()
{
m_kHorse.Destroy();
}

void CInstanceBase::GetInfo(std::string* pstInfo)
{
   char szInfo[256];
   sprintf(szInfo, "Inst - UC %d, RC %d Pool - %d ",
       ms_dwUpdateCounter,
       ms_dwRenderCounter,
       ms_kPool.GetCapacity()
   );

pstInfo->append(szInfo);
}

void CInstanceBase::ResetPerformanceCounter()
{
   ms_dwUpdateCounter=0;
   ms_dwRenderCounter=0;
   ms_dwDeformCounter=0;
}

bool CInstanceBase::NEW_IsLastPixelPosition()
{
return m_GraphicThingInstance.IsPushing();
}

const TPixelPosition& CInstanceBase::NEW_GetLastPixelPositionRef()
{
return m_GraphicThingInstance.NEW_GetLastPixelPositionRef();
}

void CInstanceBase::NEW_SetDstPixelPositionZ(FLOAT z)
{
m_GraphicThingInstance.NEW_SetDstPixelPositionZ(z);
}

void CInstanceBase::NEW_SetDstPixelPosition(const TPixelPosition& c_rkPPosDst)
{
m_GraphicThingInstance.NEW_SetDstPixelPosition(c_rkPPosDst);
}

void CInstanceBase::NEW_SetSrcPixelPosition(const TPixelPosition& c_rkPPosSrc)
{
m_GraphicThingInstance.NEW_SetSrcPixelPosition(c_rkPPosSrc);
}

const TPixelPosition& CInstanceBase::NEW_GetCurPixelPositionRef()
{
return m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
}

const TPixelPosition& CInstanceBase::NEW_GetDstPixelPositionRef()
{
return m_GraphicThingInstance.NEW_GetDstPixelPositionRef();
}

const TPixelPosition& CInstanceBase::NEW_GetSrcPixelPositionRef()
{
return m_GraphicThingInstance.NEW_GetSrcPixelPositionRef();
}

/////////////////////////////////////////////////////////////////////////////////////////////////
void CInstanceBase::OnSyncing()
{
m_GraphicThingInstance.__OnSyncing();
}

void CInstanceBase::OnWaiting()
{
m_GraphicThingInstance.__OnWaiting();
}

void CInstanceBase::OnMoving()
{
m_GraphicThingInstance.__OnMoving();
}

void CInstanceBase::ChangeGuild(DWORD dwGuildID)
{
m_dwGuildID=dwGuildID;

   DetachTextTail();
   AttachTextTail();
   RefreshTextTail();
}

DWORD CInstanceBase::GetPart(CRaceData::EParts part)
{
assert(part >= 0 && part < CRaceData::PART_MAX_NUM);
return m_awPart[part];
}

DWORD CInstanceBase::GetShape()
{
return m_eShape;
}

bool CInstanceBase::CanAct()
{
return m_GraphicThingInstance.CanAct();
}

bool CInstanceBase::CanMove()
{
return m_GraphicThingInstance.CanMove();
}

bool CInstanceBase::CanUseSkill()
{
if (IsPoly())
return false;

if (IsWearingDress())
return false;

if (IsHoldingPickAxe())
return false;

if (!m_kHorse.CanUseSkill())
return false;

if (!m_GraphicThingInstance.CanUseSkill())
return false;

return true;
}

bool CInstanceBase::CanAttack()
{
if (!m_kHorse.CanAttack())
return false;

if (IsWearingDress())
return false;

   if (IsHoldingPickAxe())
       return false;

   return m_GraphicThingInstance.CanAttack();
}

bool CInstanceBase::CanFishing()
{
return m_GraphicThingInstance.CanFishing();
}

BOOL CInstanceBase::IsBowMode()
{
return m_GraphicThingInstance.IsBowMode();
}

BOOL CInstanceBase::IsHandMode()
{
return m_GraphicThingInstance.IsHandMode();
}

BOOL CInstanceBase::IsFishingMode()
{
if (CRaceMotionData::MODE_FISHING == m_GraphicThingInstance.GetMotionMode())
return true;

return false;
}

BOOL CInstanceBase::IsFishing()
{
return m_GraphicThingInstance.IsFishing();
}

BOOL CInstanceBase::IsDead()
{
return m_GraphicThingInstance.IsDead();
}

BOOL CInstanceBase::IsStun()
{
return m_GraphicThingInstance.IsStun();
}

BOOL CInstanceBase::IsSleep()
{
return m_GraphicThingInstance.IsSleep();
}

BOOL CInstanceBase::__IsSyncing()
{
return m_GraphicThingInstance.__IsSyncing();
}

void CInstanceBase::NEW_SetOwner(DWORD dwVIDOwner)
{
m_GraphicThingInstance.SetOwner(dwVIDOwner);
}

float CInstanceBase::GetLocalTime()
{
return m_GraphicThingInstance.GetLocalTime();
}

void CInstanceBase::PushUDPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
{
}

DWORD ELTimer_GetServerFrameMSec();

void CInstanceBase::PushTCPStateExpanded(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg, UINT uTargetVID)
{
   SCommand kCmdNew;
   kCmdNew.m_kPPosDst = c_rkPPosDst;
   kCmdNew.m_dwChkTime = dwCmdTime+100;
   kCmdNew.m_dwCmdTime = dwCmdTime;
   kCmdNew.m_fDstRot = fDstRot;
   kCmdNew.m_eFunc = eFunc;
   kCmdNew.m_uArg = uArg;
   kCmdNew.m_uTargetVID = uTargetVID;
   m_kQue_kCmdNew.push_back(kCmdNew);
}

void CInstanceBase::PushTCPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
{
   if (__IsMainInstance())
   {
       //assert(!"CInstanceBase::PushTCPState ÇÃ·¹ÀÌ¾î ÀÚ½Å¿¡°Ô ÀÌµ¿ÆÐÅ¶Àº ¿À¸é ¾ÈµÈ´Ù!");
       TraceError("CInstanceBase::PushTCPState ÇÃ·¹ÀÌ¾î ÀÚ½Å¿¡°Ô ÀÌµ¿ÆÐÅ¶Àº ¿À¸é ¾ÈµÈ´Ù!");
       return;
   }

   int nNetworkGap=ELTimer_GetServerFrameMSec()-dwCmdTime;

   m_nAverageNetworkGap=(m_nAverageNetworkGap*70+nNetworkGap*30)/100;

   /*
   if (m_dwBaseCmdTime == 0)
   {
       m_dwBaseChkTime = ELTimer_GetFrameMSec()-nNetworkGap;
       m_dwBaseCmdTime = dwCmdTime;

       Tracenf("VID[%d] ³×Æ®¿÷°¸ [%d]", GetVirtualID(), nNetworkGap);
   }
   */

//m_dwBaseChkTime-m_dwBaseCmdTime+ELTimer_GetServerMSec();

   SCommand kCmdNew;
   kCmdNew.m_kPPosDst = c_rkPPosDst;
   kCmdNew.m_dwChkTime = dwCmdTime+m_nAverageNetworkGap;//m_dwBaseChkTime + (dwCmdTime - m_dwBaseCmdTime);// + nNetworkGap;
   kCmdNew.m_dwCmdTime = dwCmdTime;
   kCmdNew.m_fDstRot = fDstRot;
   kCmdNew.m_eFunc = eFunc;
   kCmdNew.m_uArg = uArg;
   m_kQue_kCmdNew.push_back(kCmdNew);

//int nApplyGap=kCmdNew.m_dwChkTime-ELTimer_GetServerFrameMSec();

//if (nApplyGap<-500 || nApplyGap>500)
// Tracenf("VID[%d] NAME[%s] ³×Æ®¿÷°¸ [cur:%d ave:%d] ÀÛµ¿½Ã°£ (%d)", GetVirtualID(), GetNameString(), nNetworkGap, m_nAverageNetworkGap, nApplyGap);
}

/*
CInstanceBase::TStateQueue::iterator CInstanceBase::FindSameState(TStateQueue& rkQuekStt, DWORD dwCmdTime, UINT eFunc, UINT uArg)
{
   TStateQueue::iterator i=rkQuekStt.begin();
   while (rkQuekStt.end()!=i)
   {
       SState& rkSttEach=*i;
       if (rkSttEach.m_dwCmdTime==dwCmdTime)
           if (rkSttEach.m_eFunc==eFunc)
               if (rkSttEach.m_uArg==uArg)
                   break;
       ++i;
   }

return i;
}
*/

BOOL CInstanceBase::__CanProcessNetworkStatePacket()
{
   if (m_GraphicThingInstance.IsDead())
       return FALSE;
   if (m_GraphicThingInstance.IsKnockDown())
       return FALSE;
   if (m_GraphicThingInstance.IsUsingSkill())
       if (!m_GraphicThingInstance.CanCancelSkill())
           return FALSE;

return TRUE;
}

BOOL CInstanceBase::__IsEnableTCPProcess(UINT eCurFunc)
{
   if (m_GraphicThingInstance.IsActEmotion())
   {
       return FALSE;
   }

   if (!m_bEnableTCPState)
   {
       if (FUNC_EMOTION != eCurFunc)
       {
           return FALSE;
       }
   }

return TRUE;
}

void CInstanceBase::StateProcess()
{
   while (1)
   {
       if (m_kQue_kCmdNew.empty())
           return;

DWORD dwDstChkTime = m_kQue_kCmdNew.front().m_dwChkTime;
DWORD dwCurChkTime = ELTimer_GetServerFrameMSec();

if (dwCurChkTime < dwDstChkTime)
return;

SCommand kCmdTop = m_kQue_kCmdNew.front();
m_kQue_kCmdNew.pop_front();

       TPixelPosition kPPosDst = kCmdTop.m_kPPosDst;
       //DWORD dwCmdTime = kCmdTop.m_dwCmdTime;
       FLOAT fRotDst = kCmdTop.m_fDstRot;
       UINT eFunc = kCmdTop.m_eFunc;
       UINT uArg = kCmdTop.m_uArg;
       UINT uVID = GetVirtualID();
       UINT uTargetVID = kCmdTop.m_uTargetVID;

TPixelPosition kPPosCur;
NEW_GetPixelPosition(&kPPosCur);

       /*
       if (IsPC())
           Tracenf("%d cmd: vid=%d[%s] func=%d arg=%d curPos=(%f, %f) dstPos=(%f, %f) rot=%f (time %d)",
           ELTimer_GetMSec(),
           uVID, m_stName.c_str(), eFunc, uArg,
           kPPosCur.x, kPPosCur.y,
           kPPosDst.x, kPPosDst.y, fRotDst, dwCmdTime-m_dwBaseCmdTime);
       */

TPixelPosition kPPosDir = kPPosDst - kPPosCur;
float fDirLen = (float)sqrt(kPPosDir.x * kPPosDir.x + kPPosDir.y * kPPosDir.y);

//Tracenf("°Å¸® %f", fDirLen);

       if (!__CanProcessNetworkStatePacket())
       {
           Lognf(0, "vid=%d ¿òÁ÷ÀÏ ¼ö ¾ø´Â »óÅÂ¶ó ½ºÅµ IsDead=%d, IsKnockDown=%d", uVID, m_GraphicThingInstance.IsDead(), m_GraphicThingInstance.IsKnockDown());
           return;
       }

       if (!__IsEnableTCPProcess(eFunc))
       {
           return;
       }

       switch (eFunc)
       {
           case FUNC_WAIT:
           {
               //Tracenf("%s (%f, %f) -> (%f, %f) ³²Àº°Å¸® %f", GetNameString(), kPPosCur.x, kPPosCur.y, kPPosDst.x, kPPosDst.y, fDirLen);
               if (fDirLen > 1.0f)
               {
                   //NEW_GetSrcPixelPositionRef() = kPPosCur;
                   //NEW_GetDstPixelPositionRef() = kPPosDst;
                   NEW_SetSrcPixelPosition(kPPosCur);
                   NEW_SetDstPixelPosition(kPPosDst);

__EnableSkipCollision();

m_fDstRot = fRotDst;
m_isGoing = TRUE;

m_kMovAfterFunc.eFunc = FUNC_WAIT;

if (!IsWalking())
StartWalking();

                   //Tracen("¸ñÇ¥Á¤Áö");
               }
               else
               {
                   //Tracen("ÇöÀç Á¤Áö");

m_isGoing = FALSE;

if (!IsWaiting())
EndWalking();

                   SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
                   SetAdvancingRotation(fRotDst);
                   SetRotation(fRotDst);
               }
               break;
           }

           case FUNC_MOVE:
           {
               //NEW_GetSrcPixelPositionRef() = kPPosCur;
               //NEW_GetDstPixelPositionRef() = kPPosDst;
               NEW_SetSrcPixelPosition(kPPosCur);
               NEW_SetDstPixelPosition(kPPosDst);
               m_fDstRot = fRotDst;
               m_isGoing = TRUE;
               __EnableSkipCollision();
               //m_isSyncMov = TRUE;

m_kMovAfterFunc.eFunc = FUNC_MOVE;

               if (!IsWalking())
               {
                   //Tracen("°È°í ÀÖÁö ¾Ê¾Æ °È±â ½ÃÀÛ");
                   StartWalking();
               }
               else
               {
                   //Tracen("ÀÌ¹Ì °È´ÂÁß ");
               }
               break;
           }

           case FUNC_COMBO:
           {
               if (fDirLen >= 50.0f)
               {
                   NEW_SetSrcPixelPosition(kPPosCur);
                   NEW_SetDstPixelPosition(kPPosDst);
                   m_fDstRot=fRotDst;
                   m_isGoing = TRUE;
                   __EnableSkipCollision();

m_kMovAfterFunc.eFunc = FUNC_COMBO;
m_kMovAfterFunc.uArg = uArg;

                   if (!IsWalking())
                       StartWalking();
               }
               else
               {
                   //Tracen("´ë±â °ø°Ý Á¤Áö");

m_isGoing = FALSE;

if (IsWalking())
EndWalking();

                   SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
                   RunComboAttack(fRotDst, uArg);
               }
               break;
           }

           case FUNC_ATTACK:
           {
               if (fDirLen>=50.0f)
               {
                   //NEW_GetSrcPixelPositionRef() = kPPosCur;
                   //NEW_GetDstPixelPositionRef() = kPPosDst;
                   NEW_SetSrcPixelPosition(kPPosCur);
                   NEW_SetDstPixelPosition(kPPosDst);
                   m_fDstRot = fRotDst;
                   m_isGoing = TRUE;
                   __EnableSkipCollision();
                   //m_isSyncMov = TRUE;

m_kMovAfterFunc.eFunc = FUNC_ATTACK;

if (!IsWalking())
StartWalking();

                   //Tracen("³Ê¹« ¸Ö¾î¼ ÀÌµ¿ ÈÄ °ø°Ý");
               }
               else
               {
                   //Tracen("³ë¸» °ø°Ý Á¤Áö");

m_isGoing = FALSE;

if (IsWalking())
EndWalking();

SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
BlendRotation(fRotDst);

RunNormalAttack(fRotDst);

                   //Tracen("°¡±õ±â ¶§¹®¿¡ ¿öÇÁ °ø°Ý");
               }
               break;
           }

           case FUNC_MOB_SKILL:
           {
               if (fDirLen >= 50.0f)
               {
                   NEW_SetSrcPixelPosition(kPPosCur);
                   NEW_SetDstPixelPosition(kPPosDst);
                   m_fDstRot = fRotDst;
                   m_isGoing = TRUE;
                   __EnableSkipCollision();

m_kMovAfterFunc.eFunc = FUNC_MOB_SKILL;
m_kMovAfterFunc.uArg = uArg;

                   if (!IsWalking())
                       StartWalking();
               }
               else
               {
                   m_isGoing = FALSE;

if (IsWalking())
EndWalking();

SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
BlendRotation(fRotDst);

                   m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_SPECIAL_1 + uArg);
               }
               break;
           }

           case FUNC_EMOTION:
           {
               if (fDirLen>100.0f)
               {
                   NEW_SetSrcPixelPosition(kPPosCur);
                   NEW_SetDstPixelPosition(kPPosDst);
                   m_fDstRot = fRotDst;
                   m_isGoing = TRUE;

if (__IsMainInstance())
__EnableSkipCollision();

                   m_kMovAfterFunc.eFunc = FUNC_EMOTION;
                   m_kMovAfterFunc.uArg = uArg;
                   m_kMovAfterFunc.uArgExpanded = uTargetVID;
                   m_kMovAfterFunc.kPosDst = kPPosDst;

                   if (!IsWalking())
                       StartWalking();
               }
               else
               {
                   __ProcessFunctionEmotion(uArg, uTargetVID, kPPosDst);
               }
               break;
           }

           default:
           {
               if (eFunc & FUNC_SKILL)
               {
                   if (fDirLen >= 50.0f)
                   {
                       //NEW_GetSrcPixelPositionRef() = kPPosCur;
                       //NEW_GetDstPixelPositionRef() = kPPosDst;
                       NEW_SetSrcPixelPosition(kPPosCur);
                       NEW_SetDstPixelPosition(kPPosDst);
                       m_fDstRot = fRotDst;
                       m_isGoing = TRUE;
                       //m_isSyncMov = TRUE;
                       __EnableSkipCollision();

m_kMovAfterFunc.eFunc = eFunc;
m_kMovAfterFunc.uArg = uArg;

if (!IsWalking())
StartWalking();

                       //Tracen("³Ê¹« ¸Ö¾î¼ ÀÌµ¿ ÈÄ °ø°Ý");
                   }
                   else
                   {
                       //Tracen("½ºÅ³ Á¤Áö");

m_isGoing = FALSE;

if (IsWalking())
EndWalking();

                       SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
                       SetAdvancingRotation(fRotDst);
                       SetRotation(fRotDst);

                       NEW_UseSkill(0, eFunc & 0x7f, uArg&0x0f, (uArg>>4) ? true : false);
                       //Tracen("°¡±õ±â ¶§¹®¿¡ ¿öÇÁ °ø°Ý");
                   }
               }
               break;
           }
       }
   }
}

void CInstanceBase::MovementProcess()
{
TPixelPosition kPPosCur;
NEW_GetPixelPosition(&kPPosCur);

// ·»´õ¸µ ÁÂÇ¥°èÀÌ¹Ç·Î y¸¦ -ÈÇØ¼ ´õÇÑ´Ù.

   TPixelPosition kPPosNext;
   {
       const D3DXVECTOR3 & c_rkV3Mov = m_GraphicThingInstance.GetMovementVectorRef();

       kPPosNext.x = kPPosCur.x + (+c_rkV3Mov.x);
       kPPosNext.y = kPPosCur.y + (-c_rkV3Mov.y);
       kPPosNext.z = kPPosCur.z + (+c_rkV3Mov.z);
   }

   TPixelPosition kPPosDeltaSC = kPPosCur - NEW_GetSrcPixelPositionRef();
   TPixelPosition kPPosDeltaSN = kPPosNext - NEW_GetSrcPixelPositionRef();
   TPixelPosition kPPosDeltaSD = NEW_GetDstPixelPositionRef() - NEW_GetSrcPixelPositionRef();

   float fCurLen = sqrtf(kPPosDeltaSC.x * kPPosDeltaSC.x + kPPosDeltaSC.y * kPPosDeltaSC.y);
   float fNextLen = sqrtf(kPPosDeltaSN.x * kPPosDeltaSN.x + kPPosDeltaSN.y * kPPosDeltaSN.y);
   float fTotalLen = sqrtf(kPPosDeltaSD.x * kPPosDeltaSD.x + kPPosDeltaSD.y * kPPosDeltaSD.y);
   float fRestLen = fTotalLen - fCurLen;

   if (__IsMainInstance())
   {
       if (m_isGoing && IsWalking())
       {
           float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(NEW_GetSrcPixelPositionRef(), NEW_GetDstPixelPositionRef());

SetAdvancingRotation(fDstRot);

           if (fRestLen<=0.0)
           {
               if (IsWalking())
                   EndWalking();

//Tracen("¸ñÇ¥ µµ´Þ Á¤Áö");

m_isGoing = FALSE;

BlockMovement();

               if (FUNC_EMOTION == m_kMovAfterFunc.eFunc)
               {
                   DWORD dwMotionNumber = m_kMovAfterFunc.uArg;
                   DWORD dwTargetVID = m_kMovAfterFunc.uArgExpanded;
                   __ProcessFunctionEmotion(dwMotionNumber, dwTargetVID, m_kMovAfterFunc.kPosDst);
                   m_kMovAfterFunc.eFunc = FUNC_WAIT;
                   return;
               }
           }
       }
   }
   else
   {
       if (m_isGoing && IsWalking())
       {
           float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(NEW_GetSrcPixelPositionRef(), NEW_GetDstPixelPositionRef());

SetAdvancingRotation(fDstRot);

           // ¸¸¾à ·»ÅÏ½Ã°¡ ´Ê¾î ³Ê¹« ¸¹ÀÌ ÀÌµ¿Çß´Ù¸é..
           if (fRestLen < -100.0f)
           {
               NEW_SetSrcPixelPosition(kPPosCur);

               float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(kPPosCur, NEW_GetDstPixelPositionRef());
               SetAdvancingRotation(fDstRot);
               //Tracenf("VID %d ¿À¹ö ¹æÇâ¼³Á¤ (%f, %f) %f rest %f", GetVirtualID(), kPPosCur.x, kPPosCur.y, fDstRot, fRestLen);

               // ÀÌµ¿ÁßÀÌ¶ó¸é ´ÙÀ½¹ø¿¡ ¸ØÃß°Ô ÇÑ´Ù
               if (FUNC_MOVE == m_kMovAfterFunc.eFunc)
               {
                   m_kMovAfterFunc.eFunc = FUNC_WAIT;
               }
           }
           // µµÂøÇß´Ù¸é...
           else if (fCurLen <= fTotalLen && fTotalLen <= fNextLen)
           {
               if (m_GraphicThingInstance.IsDead() || m_GraphicThingInstance.IsKnockDown())
               {
                   __DisableSkipCollision();

//Tracen("»ç¸Á »óÅÂ¶ó µ¿ÀÛ ½ºÅµ");

m_isGoing = FALSE;

                   //Tracen("Çàµ¿ ºÒ´É »óÅÂ¶ó ÀÌÈÄ µ¿ÀÛ ½ºÅµ");
               }
               else
               {
                   switch (m_kMovAfterFunc.eFunc)
                   {
                       case FUNC_ATTACK:
                       {
                           if (IsWalking())
                               EndWalking();

__DisableSkipCollision();
m_isGoing = FALSE;

                           BlockMovement();
                           SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
                           SetAdvancingRotation(m_fDstRot);
                           SetRotation(m_fDstRot);

                           RunNormalAttack(m_fDstRot);
                           break;
                       }

                       case FUNC_COMBO:
                       {
                           if (IsWalking())
                               EndWalking();

__DisableSkipCollision();
m_isGoing = FALSE;

                           BlockMovement();
                           SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
                           RunComboAttack(m_fDstRot, m_kMovAfterFunc.uArg);
                           break;
                       }

                       case FUNC_EMOTION:
                       {
                           m_isGoing = FALSE;
                           m_kMovAfterFunc.eFunc = FUNC_WAIT;
                           __DisableSkipCollision();
                           BlockMovement();

                           DWORD dwMotionNumber = m_kMovAfterFunc.uArg;
                           DWORD dwTargetVID = m_kMovAfterFunc.uArgExpanded;
                           __ProcessFunctionEmotion(dwMotionNumber, dwTargetVID, m_kMovAfterFunc.kPosDst);
                           break;
                       }

                       case FUNC_MOVE:
                       {
                           break;
                       }

                       case FUNC_MOB_SKILL:
                       {
                           if (IsWalking())
                               EndWalking();

__DisableSkipCollision();
m_isGoing = FALSE;

                           BlockMovement();
                           SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
                           SetAdvancingRotation(m_fDstRot);
                           SetRotation(m_fDstRot);

                           m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_SPECIAL_1 + m_kMovAfterFunc.uArg);
                           break;
                       }

                       default:
                       {
                           if (m_kMovAfterFunc.eFunc & FUNC_SKILL)
                           {
                               SetAdvancingRotation(m_fDstRot);
                               BlendRotation(m_fDstRot);
                               NEW_UseSkill(0, m_kMovAfterFunc.eFunc & 0x7f, m_kMovAfterFunc.uArg&0x0f, (m_kMovAfterFunc.uArg>>4) ? true : false);
                           }
                           else
                           {
                               //Tracenf("VID %d ½ºÅ³ °ø°Ý (%f, %f) rot %f", GetVirtualID(), NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y, m_fDstRot);

__DisableSkipCollision();
m_isGoing = FALSE;

                               BlockMovement();
                               SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
                               SetAdvancingRotation(m_fDstRot);
                               BlendRotation(m_fDstRot);
                               if (!IsWaiting())
                               {
                                   EndWalking();
                               }

                               //Tracenf("VID %d Á¤Áö (%f, %f) rot %f IsWalking %d", GetVirtualID(), NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y, m_fDstRot, IsWalking());
                           }
                           break;
                       }
                   }

}
}

   if (IsWalking() || m_GraphicThingInstance.IsUsingMovingSkill())
   {
       float fRotation = m_GraphicThingInstance.GetRotation();
       float fAdvancingRotation = m_GraphicThingInstance.GetAdvancingRotation();
       int iDirection = GetRotatingDirection(fRotation, fAdvancingRotation);

       if (DEGREE_DIRECTION_SAME != m_iRotatingDirection)
       {
           if (DEGREE_DIRECTION_LEFT == iDirection)
           {
               fRotation = fmodf(fRotation + m_fRotSpd*m_GraphicThingInstance.GetSecondElapsed(), 360.0f);
           }
           else if (DEGREE_DIRECTION_RIGHT == iDirection)
           {
               fRotation = fmodf(fRotation - m_fRotSpd*m_GraphicThingInstance.GetSecondElapsed() + 360.0f, 360.0f);
           }

           if (m_iRotatingDirection != GetRotatingDirection(fRotation, fAdvancingRotation))
           {
               m_iRotatingDirection = DEGREE_DIRECTION_SAME;
               fRotation = fAdvancingRotation;
           }

m_GraphicThingInstance.SetRotation(fRotation);
}

       if (__IsInDustRange())
       {
           float fDustDistance = NEW_GetDistanceFromDestPixelPosition(m_kPPosDust);
           if (IsMountingHorse())
           {
               if (fDustDistance > ms_fHorseDustGap)
               {
                   NEW_GetPixelPosition(&m_kPPosDust);
                   __AttachEffect(EFFECT_HORSE_DUST);
               }
           }
           else
           {
               if (fDustDistance > ms_fDustGap)
               {
                   NEW_GetPixelPosition(&m_kPPosDust);
                   __AttachEffect(EFFECT_DUST);
               }
           }
       }
   }
}

void CInstanceBase::__ProcessFunctionEmotion(DWORD dwMotionNumber, DWORD dwTargetVID, const TPixelPosition & c_rkPosDst)
{
if (IsWalking())
EndWalkingWithoutBlending();

__EnableChangingTCPState();
SCRIPT_SetPixelPosition(c_rkPosDst.x, c_rkPosDst.y);

   CInstanceBase * pTargetInstance = CPythonCharacterManager::Instance().GetInstancePtr(dwTargetVID);
   if (pTargetInstance)
   {
       pTargetInstance->__EnableChangingTCPState();

if (pTargetInstance->IsWalking())
pTargetInstance->EndWalkingWithoutBlending();

WORD wMotionNumber1 = HIWORD(dwMotionNumber);
WORD wMotionNumber2 = LOWORD(dwMotionNumber);

int src_job = RaceToJob(GetRace());
int dst_job = RaceToJob(pTargetInstance->GetRace());

       NEW_LookAtDestInstance(*pTargetInstance);
       m_GraphicThingInstance.InterceptOnceMotion(wMotionNumber1 + dst_job);
       m_GraphicThingInstance.SetRotation(m_GraphicThingInstance.GetTargetRotation());
       m_GraphicThingInstance.SetAdvancingRotation(m_GraphicThingInstance.GetTargetRotation());

       pTargetInstance->NEW_LookAtDestInstance(*this);
       pTargetInstance->m_GraphicThingInstance.InterceptOnceMotion(wMotionNumber2 + src_job);
       pTargetInstance->m_GraphicThingInstance.SetRotation(pTargetInstance->m_GraphicThingInstance.GetTargetRotation());
       pTargetInstance->m_GraphicThingInstance.SetAdvancingRotation(pTargetInstance->m_GraphicThingInstance.GetTargetRotation());

       if (pTargetInstance->__IsMainInstance())
       {
           IAbstractPlayer & rPlayer=IAbstractPlayer::GetSingleton();
           rPlayer.EndEmotionProcess();
       }
   }

   if (__IsMainInstance())
   {
       IAbstractPlayer & rPlayer=IAbstractPlayer::GetSingleton();
       rPlayer.EndEmotionProcess();
   }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Update & Deform & Render

int g_iAccumulationTime = 0;

void CInstanceBase::Update()
{
++ms_dwUpdateCounter;

   StateProcess();
   m_GraphicThingInstance.PhysicsProcess();
   m_GraphicThingInstance.RotationProcess();
   m_GraphicThingInstance.ComboProcess();
   m_GraphicThingInstance.AccumulationMovement();

   if (m_GraphicThingInstance.IsMovement())
   {
       TPixelPosition kPPosCur;
       NEW_GetPixelPosition(&kPPosCur);

       DWORD dwCurTime=ELTimer_GetFrameMSec();
       //if (m_dwNextUpdateHeightTime<dwCurTime)
       {
           m_dwNextUpdateHeightTime=dwCurTime;
           kPPosCur.z = __GetBackgroundHeight(kPPosCur.x, kPPosCur.y);
           NEW_SetPixelPosition(kPPosCur);
       }

       // SetMaterialColor
       {
           DWORD dwMtrlColor=__GetShadowMapColor(kPPosCur.x, kPPosCur.y);
           m_GraphicThingInstance.SetMaterialColor(dwMtrlColor);
       }
   }

m_GraphicThingInstance.UpdateAdvancingPointInstance();

AttackProcess();
MovementProcess();

   m_GraphicThingInstance.MotionProcess(IsPC());
   if (IsMountingHorse())
   {
       m_kHorse.m_pkActor->HORSE_MotionProcess(FALSE);
   }

   __ComboProcess();

   ProcessDamage();

}

void CInstanceBase::Transform()
{
   if (__IsSyncing())
   {
       //OnSyncing();
   }
   else
   {
       if (IsWalking() || m_GraphicThingInstance.IsUsingMovingSkill())
       {
           const D3DXVECTOR3& c_rv3Movment=m_GraphicThingInstance.GetMovementVectorRef();

           float len=(c_rv3Movment.x*c_rv3Movment.x)+(c_rv3Movment.y*c_rv3Movment.y);
           if (len>1.0f)
               OnMoving();
           else
               OnWaiting();
       }
   }

m_GraphicThingInstance.INSTANCEBASE_Transform();
}

void CInstanceBase::Deform()
{
   // 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
   if (!__CanRender())
       return;

++ms_dwDeformCounter;

m_GraphicThingInstance.INSTANCEBASE_Deform();

m_kHorse.Deform();
}

void CInstanceBase::RenderTrace()
{
if (!__CanRender())
return;

m_GraphicThingInstance.RenderTrace();
}

void CInstanceBase::Render()
{
   // 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
   if (!__CanRender())
       return;

++ms_dwRenderCounter;

   m_kHorse.Render();
   m_GraphicThingInstance.Render();

   if (CActorInstance::IsDirLine())
   {
       if (NEW_GetDstPixelPositionRef().x != 0.0f)
       {
           static CScreen s_kScreen;

           STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1,   D3DTA_DIFFUSE);
           STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);
           STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
           STATEMANAGER.SaveRenderState(D3DRS_ZENABLE, FALSE);
           STATEMANAGER.SetRenderState(D3DRS_FOGENABLE, FALSE);
           STATEMANAGER.SetRenderState(D3DRS_LIGHTING, FALSE);

           TPixelPosition px;
           m_GraphicThingInstance.GetPixelPosition(&px);
           D3DXVECTOR3 kD3DVt3Cur(px.x, px.y, px.z);
           //D3DXVECTOR3 kD3DVt3Cur(NEW_GetSrcPixelPositionRef().x, -NEW_GetSrcPixelPositionRef().y, NEW_GetSrcPixelPositionRef().z);
           D3DXVECTOR3 kD3DVt3Dest(NEW_GetDstPixelPositionRef().x, -NEW_GetDstPixelPositionRef().y, NEW_GetDstPixelPositionRef().z);

           //printf("%s %f\n", GetNameString(), kD3DVt3Cur.y - kD3DVt3Dest.y);
           //float fdx = NEW_GetDstPixelPositionRef().x - NEW_GetSrcPixelPositionRef().x;
           //float fdy = NEW_GetDstPixelPositionRef().y - NEW_GetSrcPixelPositionRef().y;

           s_kScreen.SetDiffuseColor(0.0f, 0.0f, 1.0f);
           s_kScreen.RenderLine3d(kD3DVt3Cur.x, kD3DVt3Cur.y, px.z, kD3DVt3Dest.x, kD3DVt3Dest.y, px.z);
           STATEMANAGER.RestoreRenderState(D3DRS_ZENABLE);
           STATEMANAGER.SetRenderState(D3DRS_FOGENABLE, TRUE);
           STATEMANAGER.SetRenderState(D3DRS_LIGHTING, TRUE);
       }
   }
}

void CInstanceBase::RenderToShadowMap()
{
if (IsDoor())
return;

if (IsBuilding())
return;

if (!__CanRender())
return;

if (!__IsExistMainInstance())
return;

CInstanceBase* pkInstMain=__GetMainInstancePtr();

const float SHADOW_APPLY_DISTANCE = 2500.0f;

   float fDistance=NEW_GetDistanceFromDestInstance(*pkInstMain);
   if (fDistance>=SHADOW_APPLY_DISTANCE)
       return;

m_GraphicThingInstance.RenderToShadowMap();
}

void CInstanceBase::RenderCollision()
{
m_GraphicThingInstance.RenderCollisionData();
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Setting & Getting Data

void CInstanceBase::SetVirtualID(DWORD dwVirtualID)
{
m_GraphicThingInstance.SetVirtualID(dwVirtualID);
}

void CInstanceBase::SetVirtualNumber(DWORD dwVirtualNumber)
{
m_dwVirtualNumber = dwVirtualNumber;
}

void CInstanceBase::SetInstanceType(int iInstanceType)
{
m_GraphicThingInstance.SetActorType(iInstanceType);
}

void CInstanceBase::SetAlignment(short sAlignment)
{
m_sAlignment = sAlignment;
RefreshTextTailTitle();
}

void CInstanceBase::SetPKMode(BYTE byPKMode)
{
if (m_byPKMode == byPKMode)
return;

m_byPKMode = byPKMode;

   if (__IsMainInstance())
   {
       IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
       rPlayer.NotifyChangePKMode();
   }
}

void CInstanceBase::SetKiller(bool bFlag)
{
if (m_isKiller == bFlag)
return;

m_isKiller = bFlag;
RefreshTextTail();
}

void CInstanceBase::SetPartyMemberFlag(bool bFlag)
{
m_isPartyMember = bFlag;
}

void CInstanceBase::SetStateFlags(DWORD dwStateFlags)
{
   if (dwStateFlags & ADD_CHARACTER_STATE_KILLER)
       SetKiller(TRUE);
   else
       SetKiller(FALSE);

   if (dwStateFlags & ADD_CHARACTER_STATE_PARTY)
       SetPartyMemberFlag(TRUE);
   else
       SetPartyMemberFlag(FALSE);
}

void CInstanceBase::SetComboType(UINT uComboType)
{
m_GraphicThingInstance.SetComboType(uComboType);
}

const char * CInstanceBase::GetNameString()
{
return m_stName.c_str();
}

DWORD CInstanceBase::GetRace()
{
return m_dwRace;
}

#ifdef ENABLE_NEW_EXCHANGE_WINDOW
DWORD CInstanceBase::GetLevel()
{
return m_dwLevel;
}
#endif

bool CInstanceBase::IsConflictAlignmentInstance(CInstanceBase& rkInstVictim)
{
if (PK_MODE_PROTECT == rkInstVictim.GetPKMode())
return false;

   switch (GetAlignmentType())
   {
       case ALIGNMENT_TYPE_NORMAL:
       case ALIGNMENT_TYPE_WHITE:
           if (ALIGNMENT_TYPE_DARK == rkInstVictim.GetAlignmentType())
               return true;
           break;
       case ALIGNMENT_TYPE_DARK:
           if (GetAlignmentType() != rkInstVictim.GetAlignmentType())
               return true;
           break;
   }

return false;
}

void CInstanceBase::SetDuelMode(DWORD type)
{
m_dwDuelMode = type;
}

DWORD CInstanceBase::GetDuelMode()
{
return m_dwDuelMode;
}

bool CInstanceBase::IsAttackableInstance(CInstanceBase& rkInstVictim)
{
   if (__IsMainInstance())
   {
       CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
       if(rkPlayer.IsObserverMode())
           return false;
   }

if (GetVirtualID() == rkInstVictim.GetVirtualID())
return false;

   if (IsStone())
   {
       if (rkInstVictim.IsPC())
           return true;
   }
   else if (IsPC())
   {
       if (rkInstVictim.IsStone())
           return true;

       if (rkInstVictim.IsPC())
       {
           if (GetDuelMode())
           {
               switch(GetDuelMode())
               {
               case DUEL_CANNOTATTACK:
                   return false;
               case DUEL_START:
                   if(__FindDUELKey(GetVirtualID(),rkInstVictim.GetVirtualID()))
                       return true;
                   else
                       return false;
               }
           }
           if (PK_MODE_GUILD == GetPKMode())
               if (GetGuildID() == rkInstVictim.GetGuildID())
                   return false;

           if (rkInstVictim.IsKiller())
               if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
                   return true;

           if (PK_MODE_PROTECT != GetPKMode())
           {
               if (PK_MODE_FREE == GetPKMode())
               {
                   if (PK_MODE_PROTECT != rkInstVictim.GetPKMode())
                       if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
                           return true;
               }
               if (PK_MODE_GUILD == GetPKMode())
               {
                   if (PK_MODE_PROTECT != rkInstVictim.GetPKMode())
                       if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
                           if (GetGuildID() != rkInstVictim.GetGuildID())
                               return true;
               }
           }

           if (IsSameEmpire(rkInstVictim))
           {
               if (IsPVPInstance(rkInstVictim))
                   return true;

               if (PK_MODE_REVENGE == GetPKMode())
                   if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
                       if (IsConflictAlignmentInstance(rkInstVictim))
                           return true;
           }
           else
           {
               return true;
           }
       }

if (rkInstVictim.IsEnemy())
return true;

       if (rkInstVictim.IsWoodenDoor())
           return true;
   }
   else if (IsEnemy())
   {
       if (rkInstVictim.IsPC())
           return true;

       if (rkInstVictim.IsBuilding())
           return true;

   }
   else if (IsPoly())
   {
       if (rkInstVictim.IsPC())
           return true;

       if (rkInstVictim.IsEnemy())
           return true;
   }
   return false;
}

bool CInstanceBase::IsTargetableInstance(CInstanceBase& rkInstVictim)
{
return rkInstVictim.CanPickInstance();
}

// 2004. 07. 07. [levites] - ½ºÅ³ »ç¿ëÁß Å¸°ÙÀÌ ¹Ù²î´Â ¹®Á¦ ÇØ°áÀ» À§ÇÑ ÄÚµå
bool CInstanceBase::CanChangeTarget()
{
return m_GraphicThingInstance.CanChangeTarget();
}

// 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
bool CInstanceBase::CanPickInstance()
{
if (!__IsInViewFrustum())
return false;

   if (IsDoor())
   {
       if (IsDead())
           return false;
   }

   if (IsPC())
   {
       if (IsAffect(AFFECT_EUNHYEONG))
       {
           if (!__MainCanSeeHiddenThing())
               return false;
       }
       if (IsAffect(AFFECT_REVIVE_INVISIBILITY))
           return false;
       if (IsAffect(AFFECT_INVISIBILITY))
           return false;
   }

if (IsDead())
return false;

return true;
}

bool CInstanceBase::CanViewTargetHP(CInstanceBase& rkInstVictim)
{
   if (rkInstVictim.IsStone())
       return true;
   if (rkInstVictim.IsWoodenDoor())
       return true;
   if (rkInstVictim.IsEnemy())
       return true;

return false;
}

BOOL CInstanceBase::IsPoly()
{
return m_GraphicThingInstance.IsPoly();
}

BOOL CInstanceBase::IsPC()
{
return m_GraphicThingInstance.IsPC();
}

BOOL CInstanceBase::IsNPC()
{
return m_GraphicThingInstance.IsNPC();
}

BOOL CInstanceBase::IsEnemy()
{
return m_GraphicThingInstance.IsEnemy();
}

BOOL CInstanceBase::IsStone()
{
return m_GraphicThingInstance.IsStone();
}

BOOL CInstanceBase::IsGuildWall() //IsBuilding ±æµå°Ç¹°ÀüÃ¼ IsGuildWallÀº ´ãÀåº®¸¸(¹®Àº Á¦¿Ü)
{
return IsWall(m_dwRace);
}

BOOL CInstanceBase::IsResource()
{
   switch (m_dwVirtualNumber)
   {
       case 20047:
       case 20048:
       case 20049:
       case 20050:
       case 20051:
       case 20052:
       case 20053:
       case 20054:
       case 20055:
       case 20056:
       case 20057:
       case 20058:
       case 20059:
       case 30301:
       case 30302:
       case 30303:
       case 30304:
       case 30305:
           return TRUE;
   }

return FALSE;
}

BOOL CInstanceBase::IsWarp()
{
return m_GraphicThingInstance.IsWarp();
}

BOOL CInstanceBase::IsGoto()
{
return m_GraphicThingInstance.IsGoto();
}

BOOL CInstanceBase::IsObject()
{
return m_GraphicThingInstance.IsObject();
}

BOOL CInstanceBase::IsBuilding()
{
return m_GraphicThingInstance.IsBuilding();
}

BOOL CInstanceBase::IsDoor()
{
return m_GraphicThingInstance.IsDoor();
}

BOOL CInstanceBase::IsWoodenDoor()
{
   if (m_GraphicThingInstance.IsDoor())
   {
       int vnum = GetVirtualNumber();
       if (vnum == 13000) // ³ª¹«¹®
           return true;
       else if (vnum >= 30111 && vnum <= 30119) // »ç±Í¹®
           return true;
       else
           return false;
   }
   else
   {
       return false;
   }
}

BOOL CInstanceBase::IsStoneDoor()
{
return m_GraphicThingInstance.IsDoor() && 13001 == GetVirtualNumber();
}

BOOL CInstanceBase::IsFlag()
{
   if (GetRace() == 20035)
       return TRUE;
   if (GetRace() == 20036)
       return TRUE;
   if (GetRace() == 20037)
       return TRUE;

return FALSE;
}

BOOL CInstanceBase::IsForceVisible()
{
if (IsAffect(AFFECT_SHOW_ALWAYS))
return TRUE;

if (IsObject() || IsBuilding() || IsDoor() )
return TRUE;

return FALSE;
}

int CInstanceBase::GetInstanceType()
{
return m_GraphicThingInstance.GetActorType();
}

DWORD CInstanceBase::GetVirtualID()
{
return m_GraphicThingInstance.GetVirtualID();
}

DWORD CInstanceBase::GetVirtualNumber()
{
return m_dwVirtualNumber;
}

// 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
bool CInstanceBase::__IsInViewFrustum()
{
return m_GraphicThingInstance.isShow();
}

bool CInstanceBase::__CanRender()
{
   if (!__IsInViewFrustum())
       return false;
   if (IsAffect(AFFECT_INVISIBILITY))
       return false;

return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Graphic Control

bool CInstanceBase::IntersectBoundingBox()
{
float u, v, t;
return m_GraphicThingInstance.Intersect(&u, &v, &t);
}

bool CInstanceBase::IntersectDefendingSphere()
{
return m_GraphicThingInstance.IntersectDefendingSphere();
}

float CInstanceBase::GetDistance(CInstanceBase * pkTargetInst)
{
   TPixelPosition TargetPixelPosition;
   pkTargetInst->m_GraphicThingInstance.GetPixelPosition(&TargetPixelPosition);
   return GetDistance(TargetPixelPosition);
}

float CInstanceBase::GetDistance(const TPixelPosition & c_rPixelPosition)
{
TPixelPosition PixelPosition;
m_GraphicThingInstance.GetPixelPosition(&PixelPosition);

float fdx = PixelPosition.x - c_rPixelPosition.x;
float fdy = PixelPosition.y - c_rPixelPosition.y;

return sqrtf((fdx*fdx) + (fdy*fdy));
}

CActorInstance& CInstanceBase::GetGraphicThingInstanceRef()
{
return m_GraphicThingInstance;
}

CActorInstance* CInstanceBase::GetGraphicThingInstancePtr()
{
return &m_GraphicThingInstance;
}

void CInstanceBase::RefreshActorInstance()
{
m_GraphicThingInstance.RefreshActorInstance();
}

void CInstanceBase::Refresh(DWORD dwMotIndex, bool isLoop)
{
RefreshState(dwMotIndex, isLoop);
}

void CInstanceBase::RestoreRenderMode()
{
m_GraphicThingInstance.RestoreRenderMode();
}

void CInstanceBase::SetAddRenderMode()
{
m_GraphicThingInstance.SetAddRenderMode();
}

void CInstanceBase::SetModulateRenderMode()
{
m_GraphicThingInstance.SetModulateRenderMode();
}

void CInstanceBase::SetRenderMode(int iRenderMode)
{
m_GraphicThingInstance.SetRenderMode(iRenderMode);
}

void CInstanceBase::SetAddColor(const D3DXCOLOR & c_rColor)
{
m_GraphicThingInstance.SetAddColor(c_rColor);
}

void CInstanceBase::__SetBlendRenderingMode()
{
m_GraphicThingInstance.SetBlendRenderMode();
}

void CInstanceBase::__SetAlphaValue(float fAlpha)
{
m_GraphicThingInstance.SetAlphaValue(fAlpha);
}

float CInstanceBase::__GetAlphaValue()
{
return m_GraphicThingInstance.GetAlphaValue();
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Part

void CInstanceBase::SetHair(DWORD eHair)
{
if (!HAIR_COLOR_ENABLE)
return;

   if (IsPC()==false)
       return;
   m_awPart[CRaceData::PART_HAIR] = eHair;
   m_GraphicThingInstance.SetHair(eHair);
}

void CInstanceBase::ChangeHair(DWORD eHair)
{
if (!HAIR_COLOR_ENABLE)
return;

if (IsPC()==false)
return;

if (GetPart(CRaceData::PART_HAIR)==eHair)
return;

SetHair(eHair);

//int type = m_GraphicThingInstance.GetMotionMode();

RefreshState(CRaceMotionData::NAME_WAIT, true);
//RefreshState(type, true);
}

void CInstanceBase::SetArmor(DWORD dwArmor)
{
   DWORD dwShape;
   if (__ArmorVnumToShape(dwArmor, &dwShape))
   {
       CItemData * pItemData;
       if (CItemManager::Instance().GetItemDataPointer(dwArmor, &pItemData))
       {
           float fSpecularPower=pItemData->GetSpecularPowerf();
           SetShape(dwShape, fSpecularPower);
           __GetRefinedEffect(pItemData);
           return;
       }
       else
           __ClearArmorRefineEffect();
   }

SetShape(dwArmor);
}

void CInstanceBase::SetAcce(DWORD eAcce)
{
   if (IsPC() == false)
       return;

   __ClearAcceRefineEffect();
   float fSpecular = 0.0f;
   int iAcce = (eAcce > 100) ? (int)(eAcce - 100) : (int)(eAcce);
   if (eAcce > 100)
   {
       fSpecular = 100.0f;
       m_acceEffect = EFFECT_REFINED+EFFECT_ACCE_SPECIAL;
       __EffectContainer_AttachEffect(m_acceEffect);
   }

   m_awPart[CRaceData::PART_ACCE] = iAcce;
   m_GraphicThingInstance.SetAcce(iAcce, fSpecular);
}

void CInstanceBase::ChangeAcce(DWORD eAcce)
{
   if (IsPC() == false)
       return;

   SetAcce(eAcce);
}

void CInstanceBase::SetShape(DWORD eShape, float fSpecular)
{
   if (IsPoly())
   {
       m_GraphicThingInstance.SetShape(0);
   }
   else
   {
       m_GraphicThingInstance.SetShape(eShape, fSpecular);
   }

m_eShape = eShape;
}

DWORD CInstanceBase::GetWeaponType()
{
   DWORD dwWeapon = GetPart(CRaceData::PART_WEAPON);
   CItemData * pItemData;
   if (!CItemManager::Instance().GetItemDataPointer(dwWeapon, &pItemData))
       return CItemData::WEAPON_NONE;

#ifdef ENABLE_COSTUME_WEAPON_SYSTEM
   if (pItemData->GetType() == CItemData::ITEM_TYPE_COSTUME)
       return pItemData->GetValue(3);
#endif
   return pItemData->GetWeaponType();
}

/*
void CInstanceBase::SetParts(const WORD * c_pParts)
{
if (IsPoly())
return;

if (__IsShapeAnimalWear())
return;

UINT eWeapon=c_pParts[CRaceData::PART_WEAPON];

if (__IsChangableWeapon(eWeapon) == false)
eWeapon = 0;

   if (eWeapon != m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON))
   {
       m_GraphicThingInstance.AttachPart(CRaceData::PART_MAIN, CRaceData::PART_WEAPON, eWeapon);
       m_awPart[CRaceData::PART_WEAPON] = eWeapon;
   }

__AttachHorseSaddle();
}
*/

void CInstanceBase::__ClearWeaponRefineEffect()
{
   for (std::vector<DWORD>::iterator it = this->m_vecWeaponEffects.begin();
       it != this->m_vecWeaponEffects.end();
       ++it)
   {
       this->__DetachEffect(*it);
   }
}

void CInstanceBase::__ClearAcceRefineEffect()
{
   if (m_acceEffect)
   {
       __EffectContainer_DetachEffect(EFFECT_REFINED+EFFECT_ACCE_SPECIAL);
       m_acceEffect = 0;
   }
}

void CInstanceBase::__ClearArmorRefineEffect()
{
   if (m_armorRefineEffect)
   {
       __DetachEffect(m_armorRefineEffect);
       m_armorRefineEffect = 0;
   }
}

UINT CInstanceBase::__GetRefinedEffect(CItemData* pItem)
{
TMapShiningVectorByVNum::iterator itShining;

   DWORD refine = max(pItem->GetRefine() + pItem->GetSocketCount(),CItemData::ITEM_SOCKET_MAX_NUM) - CItemData::ITEM_SOCKET_MAX_NUM;
   switch (pItem->GetType())
   {
   case CItemData::ITEM_TYPE_WEAPON:
       __ClearWeaponRefineEffect();
       if (refine >= 7)
       {
           DWORD dwRight = 0;
           DWORD dwLeft = 0;

           switch(pItem->GetSubType())
           {
           case CItemData::WEAPON_DAGGER:
               dwRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
               dwLeft = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7_LEFT+refine-7;
               break;
           case CItemData::WEAPON_FAN:
               dwRight = EFFECT_REFINED+EFFECT_FANBELL_REFINED7+refine-7;
               break;
           case CItemData::WEAPON_ARROW:
#ifdef ENABLE_QUIVER_SYSTEM
           case CItemData::WEAPON_QUIVER:
#endif
           case CItemData::WEAPON_BELL:
               dwRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
               break;
           case CItemData::WEAPON_BOW:
               dwRight = EFFECT_REFINED+EFFECT_BOW_REFINED7+refine-7;
               break;
           default:
               dwRight = EFFECT_REFINED+EFFECT_SWORD_REFINED7+refine-7;
           }

           if (dwRight > 0)
               this->m_vecWeaponEffects.push_back(this->__AttachEffect(dwRight));
           if (dwLeft > 0)
               this->m_vecWeaponEffects.push_back(this->__AttachEffect(dwLeft));
       }

       itShining = g_mapShiningVectorByVNum.find(pItem->GetIndex());
       if (itShining != g_mapShiningVectorByVNum.end())
       {
           for (std::vector<DWORD>::iterator it = itShining->second.begin(); it != itShining->second.end(); ++it)
           {
               const char* c_szBoneName;
               if (m_swordRefineEffectRight && this->m_GraphicThingInstance.GetAttachingBoneName(CRaceData::PART_WEAPON, &c_szBoneName))
                   this->m_vecWeaponEffects.push_back(this->m_GraphicThingInstance.AttachEffectByID(0, c_szBoneName, *it));
               if (m_swordRefineEffectLeft && this->m_GraphicThingInstance.GetAttachingBoneName(CRaceData::PART_WEAPON_LEFT, &c_szBoneName))
                   this->m_vecWeaponEffects.push_back(this->m_GraphicThingInstance.AttachEffectByID(0, c_szBoneName, *it));
           }
       }
       break;
   case CItemData::ITEM_TYPE_ARMOR:
       __ClearArmorRefineEffect();

       // °©¿Ê Æ¯È ÀÌÆåÆ®
       if (pItem->GetSubType() == CItemData::ARMOR_BODY)
       {
           DWORD vnum = pItem->GetIndex();

           if (12010 <= vnum && vnum <= 12049)
           {
               __AttachEffect(EFFECT_REFINED+EFFECT_BODYARMOR_SPECIAL);
               __AttachEffect(EFFECT_REFINED+EFFECT_BODYARMOR_SPECIAL2);
           }
           // New Armor Effect ( Level 120 ) BEGIN
           if (vnum == 20019 || // Krieger
               vnum == 20029 ||
               vnum == 20039 ||
               vnum == 20049 ||
               vnum == 20269 || // Ninja
               vnum == 20279 ||
               vnum == 20289 ||
               vnum == 20299 ||
               vnum == 20519 || // Sura
               vnum == 20529 ||
               vnum == 20539 ||
               vnum == 20549 ||
               vnum == 20769 || // Shamane
               vnum == 20779 ||
               vnum == 20789 ||
               vnum == 20799)
           {
               __AttachEffect(EFFECT_REFINED + EFFECT_NEW_ARMORS); //effect 19 NEW EFFECT
           }
       }

       itShining = g_mapShiningVectorByVNum.find(pItem->GetIndex());
       if (itShining != g_mapShiningVectorByVNum.end())
       {
           for (std::vector<DWORD>::iterator it = itShining->second.begin(); it != itShining->second.end(); ++it)
           {
               this->m_GraphicThingInstance.AttachEffectByID(0, "Bip01", *it);
           }
       }

if (refine < 7) //ÇöÀç Á¦·Ãµµ 7 ÀÌ»ó¸¸ ÀÌÆåÆ®°¡ ÀÖ½À´Ï´Ù.
return 0;

       if (pItem->GetSubType() == CItemData::ARMOR_BODY)
       {
           m_armorRefineEffect = EFFECT_REFINED+EFFECT_BODYARMOR_REFINED7+refine-7;
           __AttachEffect(m_armorRefineEffect);
       }
       break;
   }
   return 0;
}

bool CInstanceBase::SetWeapon(DWORD eWeapon)
{
   if (IsPoly())
       return false;

   if (__IsShapeAnimalWear())
       return false;

   if (__IsChangableWeapon(eWeapon) == false)
       eWeapon = 0;

   m_GraphicThingInstance.AttachWeapon(eWeapon);
   m_awPart[CRaceData::PART_WEAPON] = eWeapon;

   //Weapon Effect
   CItemData * pItemData;
   if (CItemManager::Instance().GetItemDataPointer(eWeapon, &pItemData))
   {
#ifdef ENABLE_COSTUME_WEAPON_SYSTEM
       if (pItemData->GetType() == CItemData::ITEM_TYPE_COSTUME)
           __ClearWeaponRefineEffect();
#endif
       __GetRefinedEffect(pItemData);
   }
   else
       __ClearWeaponRefineEffect();

return true;
}

void CInstanceBase::ChangeWeapon(DWORD eWeapon)
{
   CItemData * pItemData;
   if (eWeapon == m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON))
       return;

   if (SetWeapon(eWeapon))
       RefreshState(CRaceMotionData::NAME_WAIT, true);
}

bool CInstanceBase::ChangeArmor(DWORD dwArmor)
{
DWORD eShape;
__ArmorVnumToShape(dwArmor, &eShape);

if (GetShape()==eShape)
return false;

CAffectFlagContainer kAffectFlagContainer;
kAffectFlagContainer.CopyInstance(m_kAffectFlagContainer);

   DWORD dwVID = GetVirtualID();
   DWORD dwRace = GetRace();
   DWORD eHair = GetPart(CRaceData::PART_HAIR);
   DWORD eAcce = GetPart(CRaceData::PART_ACCE);
   DWORD eWeapon = GetPart(CRaceData::PART_WEAPON);
   float fRot = GetRotation();
   float fAdvRot = GetAdvancingRotation();

if (IsWalking())
EndWalking();

   // 2004.07.25.myevan.ÀÌÆåÆ® ¾È ºÙ´Â ¹®Á¦
   //////////////////////////////////////////////////////
   __ClearAffects();
   //////////////////////////////////////////////////////

   if (!SetRace(dwRace))
   {
       TraceError("CPythonCharacterManager::ChangeArmor - SetRace VID[%d] Race[%d] ERROR", dwVID, dwRace);
       return false;
   }

   SetArmor(dwArmor);
   SetHair(eHair);
   SetAcce(eAcce);
   SetWeapon(eWeapon);

SetRotation(fRot);
SetAdvancingRotation(fAdvRot);

__AttachHorseSaddle();

RefreshState(CRaceMotionData::NAME_WAIT, TRUE);

   // 2004.07.25.myevan.ÀÌÆåÆ® ¾È ºÙ´Â ¹®Á¦
   /////////////////////////////////////////////////
   SetAffectFlagContainer(kAffectFlagContainer);
   /////////////////////////////////////////////////

CActorInstance::IEventHandler& rkEventHandler=GetEventHandlerRef();
rkEventHandler.OnChangeShape();

return true;
}

bool CInstanceBase::__IsShapeAnimalWear()
{
   if (100 == GetShape() ||
       101 == GetShape() ||
       102 == GetShape() ||
       103 == GetShape())
       return true;

return false;
}

DWORD CInstanceBase::__GetRaceType()
{
return m_eRaceType;
}

void CInstanceBase::RefreshState(DWORD dwMotIndex, bool isLoop)
{
DWORD dwPartItemID = m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON);

BYTE byItemType = 0xff;
BYTE bySubType = 0xff;

CItemManager & rkItemMgr = CItemManager::Instance();
CItemData * pItemData;

   if (rkItemMgr.GetItemDataPointer(dwPartItemID, &pItemData))
   {
       byItemType = pItemData->GetType();
       bySubType = pItemData->GetWeaponType();
   }

   if (IsPoly())
   {
       SetMotionMode(CRaceMotionData::MODE_GENERAL);
   }
   else if (IsWearingDress())
   {
       SetMotionMode(CRaceMotionData::MODE_WEDDING_DRESS);
   }
   else if (IsHoldingPickAxe())
   {
       if (m_kHorse.IsMounting())
       {
           SetMotionMode(CRaceMotionData::MODE_HORSE);
       }
       else
       {
           SetMotionMode(CRaceMotionData::MODE_GENERAL);
       }
   }
   else if (CItemData::ITEM_TYPE_ROD == byItemType)
   {
       if (m_kHorse.IsMounting())
       {
           SetMotionMode(CRaceMotionData::MODE_HORSE);
       }
       else
       {
           SetMotionMode(CRaceMotionData::MODE_FISHING);
       }
   }
#ifdef ENABLE_COSTUME_WEAPON_SYSTEM
   else if (byItemType == CItemData::ITEM_TYPE_COSTUME)
   {
       switch (pItemData->GetValue(3))
       {
           case CItemData::WEAPON_SWORD:
               if (m_kHorse.IsMounting())
                   SetMotionMode(CRaceMotionData::MODE_HORSE_ONEHAND_SWORD);
               else
                   SetMotionMode(CRaceMotionData::MODE_ONEHAND_SWORD);
               break;
           case CItemData::WEAPON_DAGGER:
               if (m_kHorse.IsMounting())
                   SetMotionMode(CRaceMotionData::MODE_HORSE_DUALHAND_SWORD);
               else
                   SetMotionMode(CRaceMotionData::MODE_DUALHAND_SWORD);
               break;
           case CItemData::WEAPON_BOW:
               if (m_kHorse.IsMounting())
                   SetMotionMode(CRaceMotionData::MODE_HORSE_BOW);
               else
                   SetMotionMode(CRaceMotionData::MODE_BOW);
               break;
           case CItemData::WEAPON_TWO_HANDED:
               if (m_kHorse.IsMounting())
                   SetMotionMode(CRaceMotionData::MODE_HORSE_TWOHAND_SWORD);
               else
                   SetMotionMode(CRaceMotionData::MODE_TWOHAND_SWORD);
               break;
           case CItemData::WEAPON_BELL:
               if (m_kHorse.IsMounting())
                   SetMotionMode(CRaceMotionData::MODE_HORSE_BELL);
               else
                   SetMotionMode(CRaceMotionData::MODE_BELL);
               break;
           case CItemData::WEAPON_FAN:
               if (m_kHorse.IsMounting())
                   SetMotionMode(CRaceMotionData::MODE_HORSE_FAN);
               else
                   SetMotionMode(CRaceMotionData::MODE_FAN);
               break;
           default:
                   if (m_kHorse.IsMounting())
                       SetMotionMode(CRaceMotionData::MODE_HORSE);
                   else
                       SetMotionMode(CRaceMotionData::MODE_GENERAL);
               break;
       }
   }
#endif
   else if (m_kHorse.IsMounting())
   {
       switch (bySubType)
       {
       case CItemData::WEAPON_SWORD:
           SetMotionMode(CRaceMotionData::MODE_HORSE_ONEHAND_SWORD);
           break;

       case CItemData::WEAPON_TWO_HANDED:
           SetMotionMode(CRaceMotionData::MODE_HORSE_TWOHAND_SWORD); // Only Warrior
           break;

       case CItemData::WEAPON_DAGGER:
           SetMotionMode(CRaceMotionData::MODE_HORSE_DUALHAND_SWORD); // Only Assassin
           break;

       case CItemData::WEAPON_FAN:
           SetMotionMode(CRaceMotionData::MODE_HORSE_FAN); // Only Shaman
           break;

       case CItemData::WEAPON_BELL:
           SetMotionMode(CRaceMotionData::MODE_HORSE_BELL); // Only Shaman
           break;

       case CItemData::WEAPON_BOW:
           SetMotionMode(CRaceMotionData::MODE_HORSE_BOW); // Only Shaman
           break;

       default:
           SetMotionMode(CRaceMotionData::MODE_HORSE);
           break;
       }
   }
   else
   {
       switch (bySubType)
       {
       case CItemData::WEAPON_SWORD:
           SetMotionMode(CRaceMotionData::MODE_ONEHAND_SWORD);
           break;

       case CItemData::WEAPON_TWO_HANDED:
           SetMotionMode(CRaceMotionData::MODE_TWOHAND_SWORD); // Only Warrior
           break;

       case CItemData::WEAPON_DAGGER:
           SetMotionMode(CRaceMotionData::MODE_DUALHAND_SWORD); // Only Assassin
           break;

       case CItemData::WEAPON_BOW:
           SetMotionMode(CRaceMotionData::MODE_BOW);
           break;

       case CItemData::WEAPON_FAN:
           SetMotionMode(CRaceMotionData::MODE_FAN); // Only Shaman
           break;

       case CItemData::WEAPON_BELL:
           SetMotionMode(CRaceMotionData::MODE_BELL); // Only Shaman
           break;

       case CItemData::WEAPON_ARROW:
       default:
           SetMotionMode(CRaceMotionData::MODE_GENERAL);
           break;
       }
   }

   if (isLoop)
       m_GraphicThingInstance.InterceptLoopMotion(dwMotIndex);
   else
       m_GraphicThingInstance.InterceptOnceMotion(dwMotIndex);

RefreshActorInstance();
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Device

void CInstanceBase::RegisterBoundingSphere()
{
   // Stone ÀÏ °æ¿ì DeforomNoSkin À» ÇÏ¸é
   // ³«ÇÏÇÏ´Â ¾Ö´Ï¸ÞÀÌ¼Ç °°Àº °æ¿ì ¾Ö´Ï¸ÞÀÌ¼ÇÀÌ
   // ¹Ù¿îµå ¹Ú½º¿¡ ¿µÇâÀ» ¹ÌÃÄ ÄÃ¸µÀÌ Á¦´ë·Î ÀÌ·ç¾îÁöÁö ¾Ê´Â´Ù.
   if (!IsStone())
   {
       m_GraphicThingInstance.DeformNoSkin();
   }

m_GraphicThingInstance.RegisterBoundingSphere();
}

bool CInstanceBase::CreateDeviceObjects()
{
return m_GraphicThingInstance.CreateDeviceObjects();
}

void CInstanceBase::DestroyDeviceObjects()
{
m_GraphicThingInstance.DestroyDeviceObjects();
}

void CInstanceBase::Destroy()
{
   DetachTextTail();

   DismountHorse();

   m_kQue_kCmdNew.clear();

   __EffectContainer_Destroy();
   __StoneSmoke_Destroy();

   if (__IsMainInstance())
       __ClearMainInstance();

   m_GraphicThingInstance.Destroy();

   __Initialize();
}

void CInstanceBase::__InitializeRotationSpeed()
{
SetRotationSpeed(c_fDefaultRotationSpeed);
}

void CInstanceBase::__Warrior_Initialize()
{
m_kWarrior.m_dwGeomgyeongEffect=0;
}

void CInstanceBase::__Initialize()
{
   __Warrior_Initialize();
   __StoneSmoke_Inialize();
   __EffectContainer_Initialize();
   __InitializeRotationSpeed();

SetEventHandler(CActorInstance::IEventHandler::GetEmptyPtr());

m_kAffectFlagContainer.Clear();

   m_dwLevel = 0;
   m_dwGuildID = 0;
   m_dwEmpireID = 0;

   m_eType = 0;
   m_eRaceType = 0;
   m_eShape = 0;
   m_dwRace = 0;
   m_dwVirtualNumber = 0;

   m_dwBaseCmdTime=0;
   m_dwBaseChkTime=0;
   m_dwSkipTime=0;

m_GraphicThingInstance.Initialize();

m_dwAdvActorVID=0;
m_dwLastDmgActorVID=0;

m_nAverageNetworkGap=0;
m_dwNextUpdateHeightTime=0;

// Moving by keyboard
m_iRotatingDirection = DEGREE_DIRECTION_SAME;

   // Moving by mouse
   m_isTextTail = FALSE;
   m_isGoing = FALSE;
   NEW_SetSrcPixelPosition(TPixelPosition(0, 0, 0));
   NEW_SetDstPixelPosition(TPixelPosition(0, 0, 0));

m_kPPosDust = TPixelPosition(0, 0, 0);

m_kQue_kCmdNew.clear();

m_dwLastComboIndex = 0;

   this->m_vecWeaponEffects.clear();
   m_armorRefineEffect = 0;
   m_acceEffect = 0;

   m_sAlignment = 0;
   m_byPKMode = 0;
   m_isKiller = false;
   m_isPartyMember = false;

m_bEnableTCPState = TRUE;

m_stName = "";

   memset(m_awPart, 0, sizeof(m_awPart));
   memset(m_adwCRCAffectEffect, 0, sizeof(m_adwCRCAffectEffect));
   //memset(m_adwCRCEmoticonEffect, 0, sizeof(m_adwCRCEmoticonEffect));
   memset(&m_kMovAfterFunc, 0, sizeof(m_kMovAfterFunc));

   m_bDamageEffectType = false;
   m_dwDuelMode = DUEL_NONE;
   m_dwEmoticonTime = 0;
}

CInstanceBase::CInstanceBase()
{
__Initialize();
}

CInstanceBase::~CInstanceBase()
{
Destroy();
}

void CInstanceBase::GetBoundBox(D3DXVECTOR3 * vtMin, D3DXVECTOR3 * vtMax)
{
m_GraphicThingInstance.GetBoundBox(vtMin, vtMax);
}

void CInstanceBase::SetLevel(DWORD lvl)
{
m_dwLevel = lvl;
}

Sign In

SHINING BUG SASH

Recommended Posts

Kid0 8

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

pollux 802

Link to comment

Share on other sites

Legend 185

Link to comment

Share on other sites

Kid0 8

Link to comment

Share on other sites

Please sign in to comment

Announcements

Similar Content

Activity

Gamer Set

Calculate critical and penetration percentage

Auto Potion refill event

Fish bonus

Calculate critical and penetration percentage

Voooxy aka m2core.tech scammer

Can't change .exe name

communication between the core

Voooxy aka m2core.tech scammer

Recently Browsing

Community

My Activity Streams

Store

Tools

Important Information