Cevaplanmadı Remove System Collision mobs

Hi I'm having trouble removing mob collisions.
Some help? I leave files so you can see how I have it on

https://gyazo.com/4904766ca40782b5931c7014aa7caab4


[CODE lang="cpp" title="InstanceBase.cpp"]#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 "Locale_inc.h"
#include "PythonSystem.h"

#include "../eterlib/StateManager.h"
#include "../gamelib/ItemManager.h"
#include "../gameLib/RaceManager.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 = 1500.0f;


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:estroy()
{
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)
return 0;
else
return 3;

return 0;
}

bool CInstanceBase::SHORSE::IsNewMount()
{
if (!m_pkActor)
return false;
else
return true;

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

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:eform()
{
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:ART_MAIN, "saddle", m_GraphicThingInstance, CRaceData:ART_MAIN);
}

void CInstanceBase::__DetachHorseSaddle()
{
if (!IsMountingHorse())
return;
m_kHorse.m_pkActor->DetachModelInstance(CRaceData:ART_MAIN, m_GraphicThingInstance, CRaceData:ART_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;
}

DWORD __GetHairVnum(DWORD dwShape)
{
CItemData * pItemData;
if (!CItemManager::Instance().GetItemDataPointer(CPythonPlayer::Instance().GetItemIndex(TItemPos(INVENTORY, c_Costume_Slot_Hair)), &pItemData))
return dwShape;

return pItemData->GetIndex();
}

// 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:ART_WEAPON]<pkInst->m_awPart[CRaceData:ART_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()
{
m_GraphicThingInstance.EnableSkipCollision();
}

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

bool CInstanceBase::__CanSkipCollision()
{
return m_GraphicThingInstance.CanSkipCollision();
}

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()
{
#ifdef ENABLE_CANSEEHIDDENTHING_FOR_GM
if (IsAffect(AFFECT_INVISIBILITY) && !__MainCanSeeHiddenThing())
return true;
#else
if (IsAffect(AFFECT_INVISIBILITY))
return true;
#endif

return false;
}

#endif

BOOL CInstanceBase::IsInvisibility()
{
#ifdef ENABLE_CANSEEHIDDENTHING_FOR_GM
if (IsAffect(AFFECT_INVISIBILITY) && !__MainCanSeeHiddenThing())
return true;
#else
if (IsAffect(AFFECT_INVISIBILITY))
return true;
#endif

return false;
}

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

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

BOOL CInstanceBase::IsPoison()
{
if (m_kAffectFlagContainer.IsSet(AFFECT_POISON) && !IsStone())
return true;
return false;
}

BOOL CInstanceBase::IsStuned()
{
if (m_kAffectFlagContainer.IsSet(AFFECT_STUN) && !IsStone())
return true;
return false;
}

BOOL CInstanceBase::IsSlowed()
{
if (m_kAffectFlagContainer.IsSet(AFFECT_SLOW) && !IsStone())
return true;
return false;
}

BOOL CInstanceBase::IsBleed()
{
if (m_kAffectFlagContainer.IsSet(AFFECT_BLEEDING) && !IsStone())
return true;
return false;
}

BOOL CInstanceBase::IsSameEmpire(CInstanceBase& rkInstDst)
{

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

if (IsGameMaster())
return TRUE;

if (rkInstDst.IsGameMaster())
return TRUE;

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

return FALSE;
}

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

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

#if defined(ENABLE_SHOW_MOB_INFO)
DWORD CInstanceBase::GetAIFlag()
{
return m_dwAIFlag;
}
#endif

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

UINT CInstanceBase::GetAlignmentGrade()
{
#ifdef ENABLE_ALIGN_RENEWAL
if (m_sAlignment >= 30000)
return 0;
else if (m_sAlignment >= 25000)
return 1;
else if (m_sAlignment >= 18000)
return 2;
else if (m_sAlignment >= 12000)
return 3;
else if (m_sAlignment >= 8000)
return 4;
else if (m_sAlignment >= 4000)
return 5;
else if (m_sAlignment >= 1000)
return 6;
else if (m_sAlignment >= 0)
return 7;
else if (m_sAlignment > -4000)
return 8;
else if (m_sAlignment > -8000)
return 9;
else if (m_sAlignment > -12000)
return 10;

return 11;
#else
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;
#endif
}

int CInstanceBase::GetAlignmentType()
{
#ifdef ENABLE_ALIGN_RENEWAL
switch (GetAlignmentGrade())
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
{
return ALIGNMENT_TYPE_WHITE;
break;
}

case 8:
case 9:
case 10:
case 11:
{
return ALIGNMENT_TYPE_DARK;
break;
}
}

return ALIGNMENT_TYPE_NORMAL;
#else
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;
#endif
}

#ifdef ENABLE_TITLE_SYSTEM
int CInstanceBase::GetPrestige()
{
return m_sPrestige;
}

UINT CInstanceBase::GetPrestigeGrade()
{
int pTitle_vegas[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };

if (m_sPrestige == pTitle_vegas[1])
return 0;
else if (m_sPrestige == pTitle_vegas[2])
return 1;
else if (m_sPrestige == pTitle_vegas[3])
return 2;
else if (m_sPrestige == pTitle_vegas[4])
return 3;
else if (m_sPrestige == pTitle_vegas[5])
return 4;
else if (m_sPrestige == pTitle_vegas[6])
return 5;
else if (m_sPrestige == pTitle_vegas[7])
return 6;
else if (m_sPrestige == pTitle_vegas[8])
return 7;
else if (m_sPrestige == pTitle_vegas[9])
return 8;
else if (m_sPrestige == pTitle_vegas[10])
return 9;
else if (m_sPrestige == pTitle_vegas[11])
return 10;
else if (m_sPrestige == pTitle_vegas[12])
return 11;
else if (m_sPrestige == pTitle_vegas[13])
return 12;
else if (m_sPrestige == pTitle_vegas[14])
return 13;
else if (m_sPrestige == pTitle_vegas[15])
return 14;
else if (m_sPrestige == pTitle_vegas[16])
return 15;
else if (m_sPrestige == pTitle_vegas[17])
return 16;
else if (m_sPrestige == pTitle_vegas[18])
return 17;
else if (m_sPrestige == pTitle_vegas[19])
return 18;
else if (m_sPrestige == pTitle_vegas[20])
return 19;
else if (m_sPrestige == pTitle_vegas[0])
return 20;
}
#endif

#ifdef ENABLE_REBIRTH
int CInstanceBase::GetRebirth()
{
return m_sRebirth;
}
#endif

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;

__AttachSelectEffect();
}

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

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

if (IsStoneDoor())
return;

if (IsDead())
return;

__AttachTargetEffect();
}

void CInstanceBase::OnUntargeted()
{
__DetachTargetEffect();
}

void CInstanceBase:estroySystem()
{
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:elete(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();
}

/* ½ÇÁ¦ Ç÷¹À̾î ij¸¯ÅÍÀÎÁö Á¶»ç.*/
bool CInstanceBase::__IsMainInstance()
{
if (this==__GetMainInstancePtr())
return true;

return false;
}

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

bool CInstanceBase::__MainCanSeeHiddenThing()
{
#ifdef ENABLE_CANSEEHIDDENTHING_FOR_GM
CInstanceBase * pInstance = __GetMainInstancePtr();
return (pInstance) ? TRUE == pInstance->IsGameMaster() : false;
#else
return false;
#endif
}

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, int* pbType)
{
CPythonNonPlayer& rkNonPlayer=CPythonNonPlayer::Instance();
return rkNonPlayer.GetInstanceType(dwRace, pbType);
}

void CInstanceBase::SetBodyColor (DWORD dwRace, DWORD dwBodyColor)
{
SetModulateRenderMode();
SetAddColor (dwBodyColor);
}

void CInstanceBase::ChangeStoneLook (DWORD eRace, DWORD eShape)
{
if (eRace != m_dwRace)
{
m_dwOriginalRace = m_dwRace;
}

m_dwRace = eRace;

if (!m_GraphicThingInstance.SetRace (eRace))
{
return;
}

m_GraphicThingInstance.SetShape (eShape, 0.0f);

DWORD eSmoke;
if (m_kAffectFlagContainer.IsSet (STONE_SMOKE8))
{
eSmoke = 3;
}
else if (m_kAffectFlagContainer.IsSet (STONE_SMOKE5) | m_kAffectFlagContainer.IsSet (STONE_SMOKE6) | m_kAffectFlagContainer.IsSet (STONE_SMOKE7))
{
eSmoke = 2;
}
else if (m_kAffectFlagContainer.IsSet (STONE_SMOKE2) | m_kAffectFlagContainer.IsSet (STONE_SMOKE3) | m_kAffectFlagContainer.IsSet (STONE_SMOKE4))
{
eSmoke = 1;
}
else
{
eSmoke = 0;
}

__StoneSmoke_Destroy();
__StoneSmoke_Create (eSmoke);

m_GraphicThingInstance.RefreshActorInstance();
Refresh (CRaceMotionData::NAME_SPAWN, false);
}

bool CInstanceBase::Create(const SCreateData& c_rkCreateData)
{
IAbstractApplication::GetSingleton().SkipRenderBuffering(300);
SetInstanceType(c_rkCreateData.m_bType);
m_GraphicThingInstance.SetOriginalRace(c_rkCreateData.m_dwRace);

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

#ifdef ENABLE_NEW_PET_SYSTEM
if (c_rkCreateData.m_dwRace == 34041 || c_rkCreateData.m_dwRace == 34045 || c_rkCreateData.m_dwRace == 34049 || c_rkCreateData.m_dwRace == 34053 || c_rkCreateData.m_dwRace == 34057 || c_rkCreateData.m_dwRace == 34061 || c_rkCreateData.m_dwRace == 34036 || c_rkCreateData.m_dwRace == 34064 || c_rkCreateData.m_dwRace == 34073 || c_rkCreateData.m_dwRace == 34120 || c_rkCreateData.m_dwRace == 34075 || c_rkCreateData.m_dwRace == 34080 || c_rkCreateData.m_dwRace == 34082)
{
if (c_rkCreateData.m_dwLevel >= 81)
SetRace(c_rkCreateData.m_dwRace + 1);
}
#endif

#ifdef ENABLE_SUPPORT_SHAMAN_SYSTEM
int i=0;
if(c_rkCreateData.m_dwRace == 34077)
{
SetInstanceType(CActorInstance::TYPE_PC);
SetRace(3);
i=1;
}
#endif

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, c_rkCreateData.m_dwCostumEvo);

#ifdef ENABLE_SUPPORT_SHAMAN_SYSTEM
if (IsPC() || i == 1 )
#else
if (IsPC())
#endif
{
SetHair(c_rkCreateData.m_dwHair);
SetWeapon(c_rkCreateData.m_dwWeapon, c_rkCreateData.m_dwArrowType, c_rkCreateData.m_dwWeaponRareLv);
#ifdef ENABLE_SASH_SYSTEM
SetSash(c_rkCreateData.m_dwSash);
#endif
}

#ifdef ENABLE_SUPPORT_SHAMAN_SYSTEM
if (i==1)
SetSupportShaman(c_rkCreateData.is_support_shaman);
#endif

__Create_SetName(c_rkCreateData);

#ifdef ENABLE_SKILL_COLOR_SYSTEM
ChangeSkillColor(*c_rkCreateData.m_dwSkillColor);
#endif

m_dwLevel = c_rkCreateData.m_dwLevel;
#if defined(ENABLE_SHOW_MOB_INFO)
m_dwAIFlag = c_rkCreateData.m_dwAIFlag;
#endif
m_dwGuildID = c_rkCreateData.m_dwGuildID;
m_dwEmpireID = c_rkCreateData.m_dwEmpireID;

#ifdef ENABLE_GUILD_LEADER_SYSTEM
m_bMemberType = c_rkCreateData.m_bMemberType;
#endif

DWORD dwRank = CPythonNonPlayer::instance().GetMobRank(m_dwRace);
m_GraphicThingInstance.SetRank(dwRank);

SetVirtualNumber(c_rkCreateData.m_dwRace);
SetRotation(c_rkCreateData.m_fRot);
SetLevelText(c_rkCreateData.m_dwLevel);
SetAlignment(c_rkCreateData.m_sAlignment);
#ifdef ENABLE_TITLE_SYSTEM
SetPrestige(c_rkCreateData.m_sPrestige);
#endif
#ifdef ENABLE_REBIRTH
SetRebirth(c_rkCreateData.m_sRebirth);
#endif
SetPKMode(c_rkCreateData.m_byPKMode);

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

#ifdef ENABLE_AUTO_HUNT_SYSTEM
m_bAutoHuntStaus = c_rkCreateData.m_bAutoHuntStaus;
#endif

if (!IsPC())
{
#ifdef ENABLE_MOB_SCALE_SYSTEM
float fx, fy, fz = 1.0f;
if (CPythonNonPlayer::Instance().GetScale(c_rkCreateData.m_dwRace, fx, fy, fz))
{
m_GraphicThingInstance.SetScale(fx, fy, fz, true);
}
#endif
#ifdef ENABLE_PET_SYSTEM
if (m_dwRace >= 34001 && m_dwRace <= 34999)
{
float scale = c_rkCreateData.m_dwLevel * 0.009f + 0.65f;
m_GraphicThingInstance.SetScale(scale, scale, scale, true);
}
#endif
#ifdef ENABLE_NEW_PET_SYSTEM
if (IsNewPet())
{
float scale = c_rkCreateData.m_dwLevel * 0.006f + 0.78f;
if (c_rkCreateData.m_dwLevel == 120)
scale = 2.0f;
m_GraphicThingInstance.SetScale(scale, scale, scale, true);
}
#endif
}

if (i == 1 || IsMount() || IsSupportShaman())
{
m_GraphicThingInstance.SetScale(0.5, 0.5, 0.5, true);
}

// 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();

#ifdef ENABLE_BOSS_EFFECT_SYSTEM
if (IsBoss())
{
if (CPythonSystem::Instance().IsShowBossEffect())
__AttachEffectBoss();
}
#endif


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());
}

#ifdef ENABLE_CANSEEHIDDENTHING_FOR_GM
if (IsAffect(AFFECT_INVISIBILITY) && __MainCanSeeHiddenThing())
m_GraphicThingInstance.BlendAlphaValue(0.5f, 0.5f);
#endif

return true;
}

#ifdef ENABLE_SKILL_COLOR_SYSTEM
void CInstanceBase::ChangeSkillColor(const DWORD *dwSkillColor)
{
DWORD skill[CRaceMotionData::SKILL_NUM][ESkillColorLength::MAX_EFFECT_COUNT];
memset(skill, 0, sizeof(skill));
for (int i = 0; i < 9; ++i) //8=anzahl der jobs k?per,mental,..
{
for (int t = 0; t < ESkillColorLength::MAX_SKILL_COUNT; ++t)
{
for (int x = 0; x < ESkillColorLength::MAX_EFFECT_COUNT; ++x)
{
skill[i * 10 + i*(ESkillColorLength::MAX_SKILL_COUNT - 1) + t + 1][x] = *(dwSkillColor++);
}
}
dwSkillColor -= ESkillColorLength::MAX_SKILL_COUNT*ESkillColorLength::MAX_EFFECT_COUNT;
}

//TraceError("ChangeSkillcolor: %i, %i, %i, %i, %i : %i, %i, %i, %i, %i : %i, %i, %i, %i, %i : %i, %i, %i, %i, %i", skill[0][0], skill[0][1], skill[0][2], skill[0][3], skill[0][4], skill[0][5], skill[1][0], skill[1][1], skill[1][2], skill[1][3], skill[1][4], skill[1][5], skill[2][0], skill[2][1], skill[2][2], skill[2][3], skill[2][4], skill[2][5], skill[3][0], skill[3][1], skill[3][2], skill[3][3], skill[3][4], skill[3][5]);

m_GraphicThingInstance.ChangeSkillColor(*skill);
}
#endif

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);
}


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

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:ART_WEAPON] >= c_iPickAxeStart && m_awPart[CRaceData:ART_WEAPON] <= c_iPickAxeEnd;
}

BOOL CInstanceBase::IsNewMount()
{
return m_kHorse.IsNewMount();
}

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:ismountHorse()
{
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:ART_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:ushUDPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
{
}

DWORD ELTimer_GetServerFrameMSec();

void CInstanceBase:ushTCPStateExpanded(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:ushTCPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
{
/*if (__IsMainInstance())
{
TraceError("CInstanceBase:ushTCPState Ç÷¹À̾î Àڽſ¡°Ô À̵¿ÆÐŶÀº ¿À¸é ¾ÈµÈ´Ù!");
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();

if (IsPet())
{
if (CPythonSystem::instance().IsHidePets())
{
if (!IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, true);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, true);
}
}
else
{
if (IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, false);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, false);
}
}
}

if (IsMount())
{
if (CPythonSystem::instance().IsHideMounts())
{
if (!IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, true);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, true);
}
}
else
{
if (IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, false);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, false);
}
}
}

if (IsSupportShaman())
{
if (CPythonSystem::instance().IsHideShamans())
{
if (!IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, true);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, true);
}
}
else
{
if (IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, false);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, false);
}
}
}

if (IsOfflineShop())
{
if (CPythonSystem::Instance().GetShowOfflineShopFlag() == false)
{
if (!IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, true);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, true);
}
}
else
{
if (IsAffect(AFFECT_INVISIBILITY))
{
__SetAffect(AFFECT_INVISIBILITY, false);
m_kAffectFlagContainer.Set(AFFECT_INVISIBILITY, false);
}
}
}

AttackProcess();
MovementProcess();

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

if (IsAffect(AFFECT_INVISIBILITY) || IsAffect(AFFECT_EUNHYEONG))
m_GraphicThingInstance.HideAllAttachingEffect();

__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:eform()
{
// 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();
}

#ifdef ENABLE_TITLE_SYSTEM
void CInstanceBase::SetPrestige(short sPrestige)
{
m_sPrestige = sPrestige;
RefreshTextTailTitle();
}
#endif

#ifdef ENABLE_REBIRTH
void CInstanceBase::SetRebirth(short sRebirth)
{
m_sRebirth = sRebirth;
AttachTextTail();
}
#endif

void CInstanceBase::SetLevelText(int sLevel)
{
m_dwLevel = sLevel;
UpdateTextTailLevel(sLevel);
}

#ifdef ENABLE_PET_SYSTEM
void CInstanceBase::UpdatePetScale(DWORD m_dwLevel)
{
if (IsPet())
{
if (m_dwLevel == 81)
ChangeRace(GetRace() + 1, 0);

float scale = m_dwLevel * 0.009f + 0.40f;
m_GraphicThingInstance.SetScale(scale, scale, scale, true);

}

}

void CInstanceBase::ChangeRace(DWORD eRace, DWORD eShape)
{

if (eRace != m_dwRace)
{
m_dwOriginalRace = m_dwRace;
}
m_dwRace = eRace;

if (!m_GraphicThingInstance.SetRace(eRace))
{
return;
}
m_GraphicThingInstance.SetShape(eShape, 0.0f);


m_GraphicThingInstance.RefreshActorInstance();
Refresh(CRaceMotionData::NAME_WAIT, false);

}
#endif

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

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;
}

DWORD CInstanceBase::GetOriginalRace()
{
return m_dwOriginalRace;
}

DWORD CInstanceBase::GetLevel()
{
return m_dwLevel;
}

#ifdef ENABLE_SUPPORT_SHAMAN_SYSTEM
void CInstanceBase::SetSupportShaman(bool bTrue)
{
is_support_shaman = bTrue;
}

bool CInstanceBase::IsSupportShaman()
{
return is_support_shaman;
}
#endif

#ifdef ENABLE_GUILD_LEADER_SYSTEM
BYTE CInstanceBase::GetGuildMemberType()
{
return m_bMemberType;
}
#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;
}

void CInstanceBase::SetOriginalRace (DWORD race)
{
m_dwOriginalRace = race;
m_GraphicThingInstance.SetOriginalRace (race);
}

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

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

#ifdef ENABLE_BLOOD_DUNGEON
bool CInstanceBase::IsRonarkMap()
{
const std::string& c_rstrMapFileName = CPythonBackground::Instance().GetWarpMapName();
return c_rstrMapFileName == "zency_ronark";
}
#endif

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

#ifdef WJ_EXTENDED_PET_SYSTEM
if (rkInstVictim.GetInstanceType() == CActorInstance::TYPE_PET)
return false;
#endif

#ifdef ENABLE_MOUNT_SYSTEM
if (rkInstVictim.GetInstanceType() == CActorInstance::TYPE_MOUNT)
return false;
#endif

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

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

if (rkInstVictim.IsSupportShaman())
return false;

if (rkInstVictim.IsPet())
return false;

if (rkInstVictim.IsMount())
return false;

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;

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

if (rkInstVictim.IsEnemy())
return true;

if (rkInstVictim.IsSupportShaman())
return false;

if (rkInstVictim.IsPet())
return false;

if (rkInstVictim.IsMount())
return false;
}
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;
}
#ifdef ENABLE_CANSEEHIDDENTHING_FOR_GM
if (IsAffect(AFFECT_REVIVE_INVISIBILITY) && !__MainCanSeeHiddenThing())
return false;
#else
if (IsAffect(AFFECT_REVIVE_INVISIBILITY))
return false;
#endif
#ifdef ENABLE_CANSEEHIDDENTHING_FOR_GM
if (IsAffect(AFFECT_INVISIBILITY) && !__MainCanSeeHiddenThing())
return false;
#else
if (IsAffect(AFFECT_INVISIBILITY))
return false;
#endif
}

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;
#ifdef ENABLE_VIEW_TARGET_PLAYER_HP
if (rkInstVictim.IsPC())
return true;
#endif

return false;
}

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

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

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

#ifdef ENABLE_NEW_PET_SYSTEM
BOOL CInstanceBase::IsNewPet()
{
return m_GraphicThingInstance.IsNewPet();
}
#endif

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

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

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

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

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 || vnum == 20388) // ³ª¹«¹®
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;
if (GetRace() == 20143)
return TRUE;

return FALSE;
}

BOOL CInstanceBase::IsBoss()
{
if (GetRace() == 791 || GetRace() == 1304 || GetRace() == 2191 || GetRace() == 2206 || GetRace() == 2207)
return TRUE;
if (GetRace() == 1191 || GetRace() == 1192 || GetRace() == 1306 || GetRace() == 1307 || GetRace() == 2291)
return TRUE;
if (GetRace() == 2306 || GetRace() == 2307 || GetRace() == 2598 || GetRace() == 3090 || GetRace() == 3091)
return TRUE;
if (GetRace() == 3190 || GetRace() == 3191 || GetRace() == 3290 || GetRace() == 3291 || GetRace() == 3390)
return TRUE;
if (GetRace() == 3391 || GetRace() == 3490 || GetRace() == 3491 || GetRace() == 3590 || GetRace() == 3591)
return TRUE;
if (GetRace() == 3690 || GetRace() == 3691 || GetRace() == 3790 || GetRace() == 3791 || GetRace() == 3890)
return TRUE;
if (GetRace() == 3891 || GetRace() == 5001 || GetRace() == 5002 || GetRace() == 5004 || GetRace() == 5161)
return TRUE;
if (GetRace() == 5162 || GetRace() == 5163 || GetRace() == 6091 || GetRace() == 6191 || GetRace() == 6390)
return TRUE;
if (GetRace() == 792 || GetRace() == 2091 || GetRace() == 2491 || GetRace() == 2495 || GetRace() == 2597)
return TRUE;
if (GetRace() == 591 || GetRace() == 6391 || GetRace() == 6421 || GetRace() == 4204 || GetRace() == 4209)
return TRUE;
if (GetRace() == 4210 || GetRace() == 3596)
return TRUE;
if (GetRace() >= 191 && GetRace() <= 194)
return TRUE;
if (GetRace() >= 491 && GetRace() <= 494)
return TRUE;
if (GetRace() >= 531 && GetRace() <= 534)
return TRUE;
if (GetRace() >= 691 && GetRace() <= 693)
return TRUE;
if (GetRace() >= 991 && GetRace() <= 993)
return TRUE;
if (GetRace() >= 1091 && GetRace() <= 1095)
return TRUE;
if (GetRace() >= 1901 && GetRace() <= 1903)
return TRUE;
if (GetRace() >= 2492 && GetRace() <= 2494)
return TRUE;
return FALSE;
}

BOOL CInstanceBase::IsOfflineShop()
{
if (GetRace() >= 30000 && GetRace() <= 30014)
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()
{

#ifdef RENDER_TARGET_SYSTEM
if (IsAlwaysRender())
return true;
#endif
if (!__IsInViewFrustum())
return false;
#ifdef ENABLE_CANSEEHIDDENTHING_FOR_GM
if (IsAffect(AFFECT_INVISIBILITY) && !__MainCanSeeHiddenThing())
return false;
#else
if (IsAffect(AFFECT_INVISIBILITY))
return false;
#endif

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;

float fSpecularPower = 0.0f;

m_awPart[CRaceData:ART_HAIR] = eHair;
m_GraphicThingInstance.SetHair(eHair, fSpecularPower);
}

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

if (IsPC()==false)
return;

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

SetHair(eHair);

//int type = m_GraphicThingInstance.GetMotionMode();

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

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

SetShape(dwArmor);
}

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

m_eShape = eShape;
}

#ifdef ENABLE_SASH_SYSTEM
void CInstanceBase::SetSash(DWORD dwSash)
{
if (!IsPC())
return;

if (IsPoly())
return;

if (dwSash == 0) {
m_awPart[CRaceData:ART_SASH] = 0;
m_GraphicThingInstance.AttachSash(0, 0.0f);
ClearSashEffect();
return;
}

dwSash += 85000;
ClearSashEffect();

float fSpecular = 65.0f;
if (dwSash > 87000)
{
dwSash -= 2000;
fSpecular += 35;

m_dwSashEffect = EFFECT_REFINED + EFFECT_SASH;
__EffectContainer_AttachEffect(m_dwSashEffect);
}

//fSpecular /= 100.0f;
m_awPart[CRaceData:ART_SASH] = dwSash;

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

m_GraphicThingInstance.AttachSash(pItemData, fSpecular);
#ifdef ENABLE_OBJ_SCALLING
DWORD dwRace = GetRace(), dwPos = RaceToJob(dwRace), dwSex = RaceToSex(dwRace);
dwPos += 1;
if (dwSex == 0)
dwPos += 5;

float fScaleX, fScaleY, fScaleZ, fPositionX, fPositionY, fPositionZ;
if (pItemData->GetItemScale(dwPos, fScaleX, fScaleY, fScaleZ, fPositionX, fPositionY, fPositionZ))
{
m_GraphicThingInstance.SetScale(fScaleX, fScaleY, fScaleZ, true);
if (m_kHorse.IsMounting())
fPositionZ += 10.0f;

m_GraphicThingInstance.SetScalePosition(fPositionX, fPositionY, fPositionZ);
}
#endif
}

void CInstanceBase::ChangeSash(DWORD dwSash)
{
if (!IsPC())
return;

SetSash(dwSash);
}

void CInstanceBase::ClearSashEffect()
{
if (!m_dwSashEffect)
return;

__EffectContainer_DetachEffect(m_dwSashEffect);
m_dwSashEffect = 0;
}
#endif

DWORD CInstanceBase::GetWeaponType()
{
DWORD dwWeapon = GetPart(CRaceData:ART_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:ART_WEAPON];

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

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

__AttachHorseSaddle();
}
*/

void CInstanceBase::__ClearWeaponRefineEffect()
{
if (m_swordRefineEffectRight)
{
__DetachEffect(m_swordRefineEffectRight);
m_swordRefineEffectRight = 0;
}
if (m_swordRefineEffectLeft)
{
__DetachEffect(m_swordRefineEffectLeft);
m_swordRefineEffectLeft = 0;
}
}

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

#ifdef ENABLE_WEAPON_RARITY_SYSTEM
DWORD CInstanceBase::GetRareLevel(DWORD iPoints)
{
if (iPoints >= 0 && iPoints < 150)
return 0;
else if (iPoints >= 150 && iPoints < 250)
return 1;
else if (iPoints >= 250 && iPoints < 500)
return 2;
else if (iPoints >= 500 && iPoints < 1750)
return 3;
else if (iPoints >= 1750 && iPoints < 2000)
return 4;
else if (iPoints >= 2000 && iPoints < 2500)
return 5;
else if (iPoints >= 2500 && iPoints < 3250)
return 6;
else if (iPoints >= 3250)
return 7;

return 0;
}

DWORD CInstanceBase::__DetermineRarityLevel(DWORD dwType, DWORD dwWeaponRarePts, bool isDagger)
{
switch (dwType)
{
case CItemData::WEAPON_TWO_HANDED:
case CItemData::WEAPON_SWORD:
switch (GetRareLevel(dwWeaponRarePts)) // real, instead of pts
{
case 1:
case 2:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_SWORD_SPECIAL1;

case 3:
case 4:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_SWORD_SPECIAL2;

case 5:
case 6:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_SWORD_SPECIAL3;

case 7:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_SWORD_SPECIAL4;

default:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_SWORD_SPECIAL1;
}

break;

case CItemData::WEAPON_DAGGER:
switch (GetRareLevel(dwWeaponRarePts))
{
case 1:
case 2:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LDAGGER_SPECIAL1;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL1;

case 3:
case 4:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LDAGGER_SPECIAL2;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL2;

case 5:
case 6:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LDAGGER_SPECIAL3;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL3;

case 7:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LDAGGER_SPECIAL4;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL4;

default:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LDAGGER_SPECIAL1;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL1;
}
break;

case CItemData::WEAPON_FAN:
switch (GetRareLevel(dwWeaponRarePts))
{
case 1:
case 2:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_FAN_SPECIAL1;

case 3:
case 4:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_FAN_SPECIAL2;

case 5:
case 6:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_FAN_SPECIAL3;

case 7:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_FAN_SPECIAL4;

default:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_FAN_SPECIAL1;
}
break;

case CItemData::WEAPON_BELL:
switch (GetRareLevel(dwWeaponRarePts))
{
case 1:
case 2:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL1;

case 3:
case 4:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL2;

case 5:
case 6:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL3;

case 7:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL4;

default:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DAGGER_SPECIAL1;
}
break;

case CItemData::WEAPON_BOW:
switch (GetRareLevel(dwWeaponRarePts))
{
case 1:
case 2:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_BOW_SPECIAL1;

case 3:
case 4:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_BOW_SPECIAL2;

case 5:
case 6:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_BOW_SPECIAL3;

case 7:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_BOW_SPECIAL4;

default:
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_BOW_SPECIAL1;
}
break;

case CItemData::WEAPON_CLAW:
switch (GetRareLevel(dwWeaponRarePts))
{
case 1:
case 2:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LCLAW_SPECIAL1;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DCLAW_SPECIAL1;

case 3:
case 4:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LCLAW_SPECIAL2;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DCLAW_SPECIAL2;

case 5:
case 6:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LCLAW_SPECIAL3;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DCLAW_SPECIAL3;

case 7:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LCLAW_SPECIAL4;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DCLAW_SPECIAL4;

default:
if (isDagger)
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_LCLAW_SPECIAL1;
else
return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_DCLAW_SPECIAL1;
}
break;

default:
break;
}

return EFFECT_REFINED + EFFECT_SPECIAL_REFINED_SWORD_SPECIAL1;
}
#endif

UINT CInstanceBase::__GetRefinedEffect(CItemData* pItem, DWORD dwWeaponRarePts, DWORD m_dwCostumEvo)
{
auto 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) //ÇöÀç Á¦·Ãµµ 7 ÀÌ»ó¸¸ ÀÌÆåÆ®°¡ ÀÖ½À´Ï´Ù.
return 0;
switch(pItem->GetSubType())
{
case CItemData::WEAPON_SWORD:
#ifdef ENABLE_WEAPON_RARITY_SYSTEM
if (pItem->IsFlag(CItemData::ITEM_FLAG_ITEM_RARE_ABILITY) && dwWeaponRarePts >= 150)
{
m_swordRefineEffectRight = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts);
break;
}
#endif
m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SWORD_REFINED7+refine-7;
break;

case CItemData::WEAPON_DAGGER:
#ifdef ENABLE_WEAPON_RARITY_SYSTEM
if (pItem->IsFlag(CItemData::ITEM_FLAG_ITEM_RARE_ABILITY) && dwWeaponRarePts >= 150)
{
m_swordRefineEffectRight = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts);
m_swordRefineEffectLeft = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts, true);
break;
}
#endif
m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
m_swordRefineEffectLeft = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7_LEFT+refine-7;
break;

case CItemData::WEAPON_FAN:
#ifdef ENABLE_WEAPON_RARITY_SYSTEM
if (pItem->IsFlag(CItemData::ITEM_FLAG_ITEM_RARE_ABILITY) && dwWeaponRarePts >= 150)
{
m_swordRefineEffectRight = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts);
break;
}
#endif
m_swordRefineEffectRight = 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:
#ifdef ENABLE_WEAPON_RARITY_SYSTEM
if (pItem->IsFlag(CItemData::ITEM_FLAG_ITEM_RARE_ABILITY) && dwWeaponRarePts >= 150)
{
m_swordRefineEffectRight = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts);
break;
}
#endif
m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
break;

case CItemData::WEAPON_BOW:
#ifdef ENABLE_WEAPON_RARITY_SYSTEM
if (pItem->IsFlag(CItemData::ITEM_FLAG_ITEM_RARE_ABILITY) && dwWeaponRarePts >= 150)
{
m_swordRefineEffectRight = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts);
break;
}
#endif
m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_BOW_REFINED7+refine-7;
break;

case CItemData::WEAPON_CLAW:
#ifdef ENABLE_WEAPON_RARITY_SYSTEM
if (pItem->IsFlag(CItemData::ITEM_FLAG_ITEM_RARE_ABILITY) && dwWeaponRarePts >= 150)
{
m_swordRefineEffectRight = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts);
m_swordRefineEffectLeft = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts, true);
break;
}
#endif
m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
m_swordRefineEffectLeft = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7_LEFT+refine-7;
break;
default:
#ifdef ENABLE_WEAPON_RARITY_SYSTEM
if (pItem->IsFlag(CItemData::ITEM_FLAG_ITEM_RARE_ABILITY) && dwWeaponRarePts >= 150)
{
m_swordRefineEffectRight = __DetermineRarityLevel(pItem->GetSubType(), dwWeaponRarePts);
break;
}
#endif
m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SWORD_REFINED7+refine-7;
}

if (m_swordRefineEffectRight)
m_swordRefineEffectRight = __AttachEffect(m_swordRefineEffectRight);
if (m_swordRefineEffectLeft)
m_swordRefineEffectLeft = __AttachEffect(m_swordRefineEffectLeft);
break;
case CItemData::ITEM_TYPE_ARMOR:
__ClearArmorRefineEffect();

// ¡Æ¨Ï¢¯E ¨¡?E¡© AI¨¡a¨¡¢ç
if (pItem->GetSubType() == CItemData::ARMOR_BODY)
{
DWORD vnum = pItem->GetIndex();
// color armors [blue shining] - DEFAULT
if (vnum >= 12010 && vnum <= 12019 || //Blaustahlpanzer
vnum >= 12020 && vnum <= 12029 || //Blauer Drachenanzug
vnum >= 12030 && vnum <= 12039 || //Auraplattenpanzer
vnum >= 12040 && vnum <= 12049 ||
vnum >= 21080 && vnum <= 21089) //Kleidung des Drachen
{
__AttachEffect(EFFECT_REFINED + EFFECT_BODYARMOR_SPECIAL); //effect 19 bubble
__AttachEffect(EFFECT_REFINED + EFFECT_BODYARMOR_SPECIAL2); //effect 20 blue shining
}

#ifdef ENABLE_VERSION_162_ENABLED
if (20000 >= vnum && vnum <= 20759)
{
__AttachEffect(EFFECT_REFINED + EFFECT_BODYARMOR_SPECIAL3);
break;
}

if (20760 >= vnum && vnum <= 20959)
{
__AttachEffect(EFFECT_REFINED + EFFECT_BODYARMOR_SPECIAL3);
break;
}

if (21210 >= vnum && vnum <= 21305)
{
__AttachEffect(EFFECT_REFINED + EFFECT_BODYARMOR_SPECIAL4);
break;
}
#endif
}

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

#ifdef ENABLE_COSTUME_EVOLUTION_SYSTEM
if (pItem->GetSubType() == CItemData::COSTUME_BODY)
{
__ClearArmorRefineEffect();
if (m_dwCostumEvo == 1)
__AttachEffect(EFFECT_REFINED + EFFECT_COSTUME_SYSTEM_SPECIAL1);
else if (m_dwCostumEvo == 2)
__AttachEffect(EFFECT_REFINED + EFFECT_COSTUME_SYSTEM_SPECIAL2);
else if (m_dwCostumEvo == 3)
__AttachEffect(EFFECT_REFINED + EFFECT_COSTUME_SYSTEM_SPECIAL3);
else if (m_dwCostumEvo == 4)
__AttachEffect(EFFECT_REFINED + EFFECT_COSTUME_SYSTEM_SPECIAL4);
else if (m_dwCostumEvo == 5)
__AttachEffect(EFFECT_REFINED + EFFECT_COSTUME_SYSTEM_SPECIAL5);
else if (m_dwCostumEvo == 6)
__AttachEffect(EFFECT_REFINED + EFFECT_COSTUME_SYSTEM_SPECIAL6);
else if (m_dwCostumEvo == 7)
__AttachEffect(EFFECT_REFINED + EFFECT_COSTUME_SYSTEM_SPECIAL7);
}
break;
#endif
}
return 0;
}

#ifdef ENABLE_QUIVER_SYSTEM
bool CInstanceBase::SetWeapon(DWORD eWeapon, DWORD eArrow, DWORD dwWeaponRareLv)
#else
bool CInstanceBase::SetWeapon(DWORD eWeapon)
#endif
{
if (IsPoly())
return false;

if (__IsShapeAnimalWear())
return false;

#ifdef ENABLE_QUIVER_SYSTEM
m_awPart[CRaceData:ART_QUIVER] = eArrow;
#endif

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

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

//Weapon Effect
CItemData * pItemData;
if (CItemManager::Instance().GetItemDataPointer(eWeapon, &pItemData))
if (CPythonSystem::Instance().IsShowRefineEffect())
__GetRefinedEffect(pItemData, dwWeaponRareLv, m_dwCostumEvo);
else
__ClearWeaponRefineEffect();

return true;
}

#ifdef ENABLE_QUIVER_SYSTEM
void CInstanceBase::ChangeWeapon(DWORD eWeapon, DWORD eArrow, DWORD dwWeaponRarity)
#else
void CInstanceBase::ChangeWeapon(DWORD eWeapon)
#endif
{
CItemData * pItemData;

m_awPart[CRaceData:ART_QUIVER] = eArrow;

if (CItemManager::Instance().GetItemDataPointer(eWeapon, &pItemData))
{
if (!m_kHorse.IsMounting())
{
if (pItemData->GetType() == CItemData::ITEM_TYPE_WEAPON && pItemData->GetSubType() == CItemData::WEAPON_BOW)
{
if (eArrow == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_BOW);
}
#if defined(ENABLE_COSTUME_WEAPON_SYSTEM)
else if (pItemData->GetType() == CItemData::ITEM_TYPE_COSTUME && pItemData->GetValue(3) == CItemData::WEAPON_BOW)
{
if (eArrow == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_BOW);
}
#endif
}
else
{
if (pItemData->GetType() == CItemData::ITEM_TYPE_WEAPON && pItemData->GetSubType() == CItemData::WEAPON_BOW)
{
if (eArrow == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW);
}
#if defined(ENABLE_COSTUME_WEAPON_SYSTEM)
else if (pItemData->GetType() == CItemData::ITEM_TYPE_COSTUME && pItemData->GetValue(3) == CItemData::WEAPON_BOW)
{
if (eArrow == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW);
}
#endif
}
}
else
{
if (IsWearingDress())
{
SetMotionMode(CRaceMotionData::MODE_WEDDING_DRESS);
}
else
{
if (!m_kHorse.IsMounting())
SetMotionMode(CRaceMotionData::MODE_GENERAL);
else
SetMotionMode(CRaceMotionData::MODE_HORSE);
}
}

if (eWeapon == m_GraphicThingInstance.GetPartItemID(CRaceData:ART_WEAPON))
return;

#ifdef ENABLE_QUIVER_SYSTEM
if (SetWeapon(eWeapon, eArrow, dwWeaponRarity))
#else
if (SetWeapon(eWeapon))
#endif
RefreshState(CRaceMotionData::NAME_WAIT, true);
}

bool CInstanceBase::ChangeArmor(DWORD dwArmor, DWORD m_dwCostumEvo)
{
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:ART_HAIR);
#ifdef ENABLE_SASH_SYSTEM
DWORD dwSash = GetPart(CRaceData:ART_SASH);
#endif
DWORD eWeapon = GetPart(CRaceData:ART_WEAPON);
#ifdef ENABLE_QUIVER_SYSTEM
DWORD eArrow = GetPart(CRaceData:ART_QUIVER);
#endif
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, m_dwCostumEvo);
SetHair(eHair);
#ifdef ENABLE_SASH_SYSTEM
SetSash(dwSash);
#endif
#ifdef ENABLE_QUIVER_SYSTEM
SetWeapon(eWeapon, eArrow, m_dwWeaponRareLv);
#else
SetWeapon(eWeapon);
#endif

SetRotation(fRot);
SetAdvancingRotation(fAdvRot);

__AttachHorseSaddle();

RefreshState(CRaceMotionData::NAME_WAIT, TRUE);

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

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

return true;
}

#ifdef ENABLE_COSTUME_EVOLUTION_SYSTEM
void CInstanceBase::SetCostumEvo(DWORD dwCostumEvo)
{
m_dwCostumEvo = dwCostumEvo;
}
#endif

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:ART_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())
#ifdef ENABLE_QUIVER_SYSTEM
{
if (m_awPart[CRaceData:ART_QUIVER] == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW);
}
#else
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW);
#endif
#ifdef ENABLE_QUIVER_SYSTEM
else
{
if (m_awPart[CRaceData:ART_QUIVER] == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_BOW);
}
#else
SetMotionMode(CRaceMotionData::MODE_BOW);
#endif
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;
case CItemData::WEAPON_CLAW:
if (m_kHorse.IsMounting())
SetMotionMode(CRaceMotionData::MODE_HORSE_CLAW);
else
SetMotionMode(CRaceMotionData::MODE_CLAW);
break;
default:
if (m_kHorse.IsMounting())
SetMotionMode(CRaceMotionData::MODE_HORSE);
else
SetMotionMode(CRaceMotionData::MODE_GENERAL);
break;
}
}
#endif
else if (byItemType == CItemData::ITEM_TYPE_WEAPON)
{
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);
break;
case CItemData::WEAPON_DAGGER:
SetMotionMode(CRaceMotionData::MODE_HORSE_DUALHAND_SWORD);
break;
case CItemData::WEAPON_FAN:
SetMotionMode(CRaceMotionData::MODE_HORSE_FAN);
break;
case CItemData::WEAPON_BELL:
SetMotionMode(CRaceMotionData::MODE_HORSE_BELL);
break;
case CItemData::WEAPON_BOW:
#ifdef ENABLE_QUIVER_SYSTEM
{
if (m_awPart[CRaceData:ART_QUIVER] == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW);
}
#else
SetMotionMode(CRaceMotionData::MODE_HORSE_BOW);
#endif
break;
case CItemData::WEAPON_CLAW:
SetMotionMode(CRaceMotionData::MODE_HORSE_CLAW);
break;

case CItemData::WEAPON_ARROW:
case CItemData::WEAPON_QUIVER:

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);
break;
case CItemData::WEAPON_DAGGER:
SetMotionMode(CRaceMotionData::MODE_DUALHAND_SWORD);
break;
case CItemData::WEAPON_BOW:
#ifdef ENABLE_QUIVER_SYSTEM
{
if (m_awPart[CRaceData:ART_QUIVER] == CItemData::WEAPON_QUIVER)
SetMotionMode(CRaceMotionData::MODE_BOW_SPECIAL);
else
SetMotionMode(CRaceMotionData::MODE_BOW);
}
#else
SetMotionMode(CRaceMotionData::MODE_BOW);
#endif
break;
case CItemData::WEAPON_FAN:
SetMotionMode(CRaceMotionData::MODE_FAN);
break;
case CItemData::WEAPON_BELL:
SetMotionMode(CRaceMotionData::MODE_BELL);
break;
case CItemData::WEAPON_CLAW:
SetMotionMode(CRaceMotionData::MODE_CLAW);
break;
case CItemData::WEAPON_ARROW:
#ifdef ENABLE_QUIVER_SYSTEM
case CItemData::WEAPON_QUIVER:
#endif
default:
SetMotionMode(CRaceMotionData::MODE_GENERAL);
break;
}
}
}

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

RefreshActorInstance();
}

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

m_GraphicThingInstance.RegisterBoundingSphere();
}

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

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

void CInstanceBase:estroy()
{
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;
}

#ifdef ENABLE_NEW_GYEONGGONG_SKILL
void CInstanceBase::__Assassin_Initialize()
{
m_kAssassin.m_dwGyeongGongEffect = 0;
}
#endif

float CInstanceBase::GetBaseHeight()
{
CActorInstance* pkHorse = m_kHorse.GetActorPtr();
if (!m_kHorse.IsMounting() || !pkHorse)
return 0.0f;

DWORD dwHorseVnum = m_kHorse.m_pkActor->GetRace();
if ((dwHorseVnum >= 20101 && dwHorseVnum <= 20109) ||
(dwHorseVnum == 20029 || dwHorseVnum == 20030))
return 100.0f;

float fRaceHeight = CRaceManager::instance().GetRaceHeight(dwHorseVnum);
if (fRaceHeight == 0.0f)
return 100.0f;
else
return fRaceHeight;
}

void CInstanceBase::__Initialize()
{
__Warrior_Initialize();
#ifdef ENABLE_NEW_GYEONGGONG_SKILL
__Assassin_Initialize();
#endif
__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_dwOriginalRace = 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;

m_swordRefineEffectRight = 0;
m_swordRefineEffectLeft = 0;
m_armorRefineEffect = 0;
#ifdef ENABLE_SASH_SYSTEM
m_dwSashEffect = 0;
#endif

m_sAlignment = 0;
#ifdef ENABLE_TITLE_SYSTEM
m_sPrestige = 0;
#endif
#ifdef ENABLE_REBIRTH
m_sRebirth = 0;
#endif
m_byPKMode = 0;
m_isKiller = false;
m_isPartyMember = false;

m_bEnableTCPState = TRUE;

m_stName = "";

#ifdef ENABLE_SUPPORT_SHAMAN_SYSTEM
is_support_shaman = false;
#endif

#if defined(ENABLE_SHOW_MOB_INFO)
m_dwAIFlag = 0;
#endif

#ifdef ENABLE_COSTUME_EVOLUTION_SYSTEM
m_dwCostumEvo = 0;
#endif

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;
#ifdef RENDER_TARGET_SYSTEM
m_IsAlwaysRender = false;
#endif
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);
}

#ifdef RENDER_TARGET_SYSTEM
bool CInstanceBase::IsAlwaysRender()
{
return m_IsAlwaysRender;
}

void CInstanceBase::SetAlwaysRender(bool val)
{
m_IsAlwaysRender = val;
}
#endif
[/CODE]

[CODE lang="cpp" title="ActorInstanceCollisionDetection.cpp"]#include "StdAfx.h"
#include "../eterLib/GrpMath.h"
#include "ActorInstance.h"
#include "../UserInterface/PythonBackground.h"
#include "../gamelib/ItemManager.h"
#include "../UserInterface/AbstractPlayer.h"

void CActorInstance::__InitializeCollisionData()
{
m_canSkipCollision=false;
}

void CActorInstance::EnableSkipCollision()
{
m_canSkipCollision=true;
}

void CActorInstance:isableSkipCollision()
{
m_canSkipCollision=false;
}

bool CActorInstance::CanSkipCollision()
{
return m_canSkipCollision;
}

void CActorInstance::UpdatePointInstance()
{
TCollisionPointInstanceListIterator itor;
for (itor = m_DefendingPointInstanceList.begin(); itor != m_DefendingPointInstanceList.end(); ++itor)
UpdatePointInstance(&(*itor));
}

void CActorInstance::UpdatePointInstance(TCollisionPointInstance * pPointInstance)
{
if (!pPointInstance)
{
assert(!"CActorInstance::UpdatePointInstance - pPointInstance is NULL"); // ·¹ÆÛ·±½º·Î ±³Ã¼ÇϽÿÀ
return;
}

D3DXMATRIX matBone;

if (pPointInstance->isAttached)
{
if (pPointInstance->dwModelIndex>=m_LODControllerVector.size())
{
//Tracenf("CActorInstance::UpdatePointInstance - rInstance.dwModelIndex=%d >= m_LODControllerVector.size()=%d",
// pPointInstance->dwModelIndex>m_LODControllerVector.size());
return;
}

CGrannyLODController* pGrnLODController=m_LODControllerVector[pPointInstance->dwModelIndex];
if (!pGrnLODController)
{
//Tracenf("CActorInstance::UpdatePointInstance - m_LODControllerVector[pPointInstance->dwModelIndex=%d] is NULL", pPointInstance->dwModelIndex);
return;
}

CGrannyModelInstance * pModelInstance = pGrnLODController->GetModelInstance();
if (!pModelInstance)
{
//Tracenf("CActorInstance::UpdatePointInstance - pGrnLODController->GetModelInstance() is NULL");
return;
}

D3DXMATRIX * pmatBone = (D3DXMATRIX *)pModelInstance->GetBoneMatrixPointer(pPointInstance->dwBoneIndex);
matBone = *(D3DXMATRIX *)pModelInstance->GetCompositeBoneMatrixPointer(pPointInstance->dwBoneIndex);
matBone._41 = pmatBone->_41;
matBone._42 = pmatBone->_42;
matBone._43 = pmatBone->_43;
matBone *= m_worldMatrix;
}
else
{
matBone = m_worldMatrix;
}

// Update Collsion Sphere
CSphereCollisionInstanceVector::const_iterator sit = pPointInstance->c_pCollisionData->SphereDataVector.begin();
CDynamicSphereInstanceVector::iterator dit=pPointInstance->SphereInstanceVector.begin();
for (;sit!=pPointInstance->c_pCollisionData->SphereDataVector.end();++sit,++dit)
{
const TSphereData & c = sit->GetAttribute();//c_pCollisionData->SphereDataVector[j].GetAttribute();

D3DXMATRIX matPoint;
D3DXMatrixTranslation(&matPoint, c.v3Position.x, c.v3Position.y, c.v3Position.z);
matPoint = matPoint * matBone;

dit->v3LastPosition = dit->v3Position;
dit->v3Position.x = matPoint._41;
dit->v3Position.y = matPoint._42;
dit->v3Position.z = matPoint._43;
}
}

void CActorInstance::UpdateAdvancingPointInstance()
{
// ¸»À» ÅÀÀ» °æ¿ì »ç¶÷Àº À̵¿°ªÀ» °¡Áö°í ÀÖÁö ¾Ê±â ¶§¹®¿¡ ¸»·Î ºÎÅÍ ¾ò¾î¿Í¾ß ÇÑ´Ù - [levites]
D3DXVECTOR3 v3Movement = m_v3Movement;
if (m_pkHorse)
v3Movement = m_pkHorse->m_v3Movement;

// ¸»Àº ¾÷µ¥ÀÌÆ® ÇÏÁö ¾Ê¾Æµµ µÈ´Ù - [levites]
if (m_pkHorse)
m_pkHorse->UpdateAdvancingPointInstance();

D3DXMATRIX matPoint;
D3DXMATRIX matCenter;

TCollisionPointInstanceListIterator itor = m_BodyPointInstanceList.begin();
for (; itor != m_BodyPointInstanceList.end(); ++itor)
{
TCollisionPointInstance & rInstance = *itor;

if (rInstance.isAttached)
{
if (rInstance.dwModelIndex>=m_LODControllerVector.size())
{
Tracenf("CActorInstance::UpdateAdvancingPointInstance - rInstance.dwModelIndex=%d >= m_LODControllerVector.size()=%d",
rInstance.dwModelIndex, m_LODControllerVector.size());
continue;
}

CGrannyLODController* pGrnLODController=m_LODControllerVector[rInstance.dwModelIndex];
if (!pGrnLODController)
{
Tracenf("CActorInstance::UpdateAdvancingPointInstance - m_LODControllerVector[rInstance.dwModelIndex=%d] is NULL", rInstance.dwModelIndex);
continue;
}

CGrannyModelInstance * pModelInstance = pGrnLODController->GetModelInstance();
if (!pModelInstance)
{
//Tracenf("CActorInstance::UpdateAdvancingPointInstance - pGrnLODController->GetModelInstance() is NULL");
continue;
}

matCenter = *(D3DXMATRIX *)pModelInstance->GetBoneMatrixPointer(rInstance.dwBoneIndex);
matCenter *= m_worldMatrix;
}
else
{
matCenter = m_worldMatrix;
}

// Update Collision Sphere
const NRaceData::TCollisionData * c_pCollisionData = rInstance.c_pCollisionData;
if (c_pCollisionData)
{
for (DWORD j = 0; j < c_pCollisionData->SphereDataVector.size(); ++j)
{
const TSphereData & c = c_pCollisionData->SphereDataVector[j].GetAttribute();
CDynamicSphereInstance & rSphereInstance = rInstance.SphereInstanceVector[j];

D3DXMatrixTranslation(&matPoint, c.v3Position.x, c.v3Position.y, c.v3Position.z);
matPoint = matPoint * matCenter;

rSphereInstance.v3LastPosition.x = matPoint._41;
rSphereInstance.v3LastPosition.y = matPoint._42;
rSphereInstance.v3LastPosition.z = matPoint._43;
rSphereInstance.v3Position = rSphereInstance.v3LastPosition;
rSphereInstance.v3Position += v3Movement;
}
}
}
}

bool CActorInstance::CheckCollisionDetection(const CDynamicSphereInstanceVector * c_pAttackingSphereVector, D3DXVECTOR3 * pv3Position)
{
if (!c_pAttackingSphereVector)
{
assert(!"CActorInstance::CheckCollisionDetection - c_pAttackingSphereVector is NULL"); // ·¹ÆÛ·±½º·Î ±³Ã¼ÇϽÿÀ
return false;
}

TCollisionPointInstanceListIterator itor;
for (itor = m_DefendingPointInstanceList.begin(); itor != m_DefendingPointInstanceList.end(); ++itor)
{
const CDynamicSphereInstanceVector * c_pDefendingSphereVector = &(*itor).SphereInstanceVector;

for (DWORD i = 0; i < c_pAttackingSphereVector->size(); ++i)
for (DWORD j = 0; j < c_pDefendingSphereVector->size(); ++j)
{
const CDynamicSphereInstance & c_rAttackingSphere = c_pAttackingSphereVector->at(i);
const CDynamicSphereInstance & c_rDefendingSphere = c_pDefendingSphereVector->at(j);

if (DetectCollisionDynamicSphereVSDynamicSphere(c_rAttackingSphere, c_rDefendingSphere))
{
// FIXME : µÎ ¿øÀÇ ±³Á¡À» ã¾Æ³»´Â ½ÄÀ¸·Î ¹Ù²ã¾ß ÇÑ´Ù.
*pv3Position = (c_rAttackingSphere.v3Position + c_rDefendingSphere.v3Position) / 2.0f;
return true;
}
}
}

return false;
}

bool CActorInstance::CreateCollisionInstancePiece(DWORD dwAttachingModelIndex, const NRaceData::TAttachingData * c_pAttachingData, TCollisionPointInstance * pPointInstance)
{
if (!c_pAttachingData)
{
assert(!"CActorInstance::CreateCollisionInstancePiece - c_pAttachingData is NULL"); // ·¹ÆÛ·±½º·Î ±³Ã¼ÇϽÿÀ
return false;
}

if (!c_pAttachingData->pCollisionData)
{
assert(!"CActorInstance::CreateCollisionInstancePiece - c_pAttachingData->pCollisionData is NULL"); // ·¹ÆÛ·±½º·Î ±³Ã¼ÇϽÿÀ
return false;
}

if (!pPointInstance)
{
assert(!"CActorInstance::CreateCollisionInstancePiece - pPointInstance is NULL"); // ·¹ÆÛ·±½º·Î ±³Ã¼ÇϽÿÀ
return false;
}

pPointInstance->dwModelIndex = dwAttachingModelIndex;
pPointInstance->isAttached = FALSE;
pPointInstance->dwBoneIndex = 0;
pPointInstance->c_pCollisionData = c_pAttachingData->pCollisionData;

if (c_pAttachingData->isAttaching)
{
int iAttachingBoneIndex;

CGrannyModelInstance * pModelInstance = m_LODControllerVector[dwAttachingModelIndex]->GetModelInstance();

if (pModelInstance && pModelInstance->GetBoneIndexByName(c_pAttachingData->strAttachingBoneName.c_str(),
&iAttachingBoneIndex))
{
pPointInstance->isAttached = TRUE;
pPointInstance->dwBoneIndex = iAttachingBoneIndex;
}
else
{
//TraceError("CActorInstance::CreateCollisionInstancePiece: Cannot get matrix of bone %s ModelInstance 0x%p", c_pAttachingData->strAttachingBoneName.c_str(), pModelInstance);
pPointInstance->isAttached = TRUE;
pPointInstance->dwBoneIndex = 0;
}
}


const CSphereCollisionInstanceVector & c_rSphereDataVector = c_pAttachingData->pCollisionData->SphereDataVector;

pPointInstance->SphereInstanceVector.clear();
pPointInstance->SphereInstanceVector.reserve(c_rSphereDataVector.size());

CSphereCollisionInstanceVector::const_iterator it;
CDynamicSphereInstance dsi;

dsi.v3LastPosition = D3DXVECTOR3(0.0f,0.0f,0.0f);
dsi.v3Position = D3DXVECTOR3(0.0f,0.0f,0.0f);
for (it = c_rSphereDataVector.begin(); it!=c_rSphereDataVector.end(); ++it)
{
const TSphereData & c_rSphereData = it->GetAttribute();
dsi.fRadius = c_rSphereData.fRadius;
pPointInstance->SphereInstanceVector.push_back(dsi);
}

return true;
}

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

BOOL CActorInstance::__SplashAttackProcess(CActorInstance & rVictim)
{
D3DXVECTOR3 v3Distance(rVictim.m_x - m_x, rVictim.m_z - m_z, rVictim.m_z - m_z);
float fDistance = D3DXVec3LengthSq(&v3Distance);
if (fDistance >= 1000.0f*1000.0f)
return FALSE;

// Check Distance
if (!__IsInSplashTime())
return FALSE;

const CRaceMotionData::TMotionAttackingEventData * c_pAttackingEvent = m_kSplashArea.c_pAttackingEvent;
const NRaceData::TAttackData & c_rAttackData = c_pAttackingEvent->AttackData;
THittedInstanceMap & rHittedInstanceMap = m_kSplashArea.HittedInstanceMap;

// NOTE : ÀÌ¹Ì ¶§·È´Ù¸é ¶§¸± ¼ö ¾øÀ½
if (rHittedInstanceMap.end() != rHittedInstanceMap.find(&rVictim))
{
return FALSE;
}

// NOTE : Snipe ¸ðµåÀÌ°í..
if (NRaceData::ATTACK_TYPE_SNIPE == c_rAttackData.iAttackType)
{
// Target ÀÌ PC ¶ó¸é..
if (__IsFlyTargetPC())
// ´Ù¸¥ °´Ã¼´Â ¶§¸± ¼ö ¾ø´Ù
if (!__IsSameFlyTarget(&rVictim))
return FALSE;

/*
if (IsFlyTargetObject())
{
CActorInstance * pActorInstance = (CActorInstance *)m_kFlyTarget.GetFlyTarget();

// NOTE : Target ÀÌ PC À϶§´Â ÇÑ¸í¸¸ ¶§¸± ¼ö ÀÖ´Ù.
if (pActorInstance->IsPC())
if (&rVictim != pActorInstance)
return FALSE;
}
*/
}

D3DXVECTOR3 v3HitPosition;
if (rVictim.CheckCollisionDetection(&m_kSplashArea.SphereInstanceVector, &v3HitPosition))
{
rHittedInstanceMap.insert(make_pair(&rVictim, GetLocalTime()+c_rAttackData.fInvisibleTime));

int iCurrentHitCount = rHittedInstanceMap.size();
int iMaxHitCount = (0 == c_rAttackData.iHitLimitCount ? 16 : c_rAttackData.iHitLimitCount);
//Tracef(" ------------------- Splash Hit : %d\n", iCurrentHitCount);

if (iCurrentHitCount > iMaxHitCount)
{
//Tracef(" ------------------- OVER FLOW :: Splash Hit Count : %d\n", iCurrentHitCount);
return FALSE;
}

NEW_SetAtkPixelPosition(NEW_GetCurPixelPositionRef());
__ProcessDataAttackSuccess(c_rAttackData, rVictim, v3HitPosition, m_kSplashArea.uSkill, m_kSplashArea.isEnableHitProcess);
return TRUE;
}

return FALSE;
}

BOOL CActorInstance::__NormalAttackProcess(CActorInstance & rVictim)
{
// Check Distance
// NOTE - ÀÏ´Ü ±ÙÁ¢ üũ¸¸ ÇÏ°í ÀÖÀ½
D3DXVECTOR3 v3Distance(rVictim.m_x - m_x, rVictim.m_z - m_z, rVictim.m_z - m_z);
float fDistance = D3DXVec3LengthSq(&v3Distance);

extern bool IS_HUGE_RACE(unsigned int vnum);
if (IS_HUGE_RACE(rVictim.GetRace()))
{
if (fDistance >= 500.0f*500.0f)
return FALSE;
}
else
{
if (fDistance >= 300.0f*300.0f)
return FALSE;
}

if (!isValidAttacking())
return FALSE;

const float c_fAttackRadius = 20.0f;
const NRaceData::TMotionAttackData * pad = m_pkCurRaceMotionData->GetMotionAttackDataPointer();

const float motiontime = GetAttackingElapsedTime();

NRaceData::THitDataContainer::const_iterator itorHitData = pad->HitDataContainer.begin();
for (; itorHitData != pad->HitDataContainer.end(); ++itorHitData)
{
const NRaceData::THitData & c_rHitData = *itorHitData;

// NOTE : ÀÌ¹Ì ¸Â¾Ò´ÂÁö üũ
THitDataMap::iterator itHitData = m_HitDataMap.find(&c_rHitData);
if (itHitData != m_HitDataMap.end())
{
THittedInstanceMap & rHittedInstanceMap = itHitData->second;

THittedInstanceMap::iterator itInstance;
if ((itInstance=rHittedInstanceMap.find(&rVictim)) != rHittedInstanceMap.end())
{
if (pad->iMotionType==NRaceData::MOTION_TYPE_COMBO || itInstance->second > GetLocalTime())
continue;
}
}

NRaceData::THitTimePositionMap::const_iterator range_start, range_end;
range_start = c_rHitData.mapHitPosition.lower_bound(motiontime-CTimer::Instance().GetElapsedSecond());
range_end = c_rHitData.mapHitPosition.upper_bound(motiontime);
float c = cosf(D3DXToRadian(GetRotation()));
float s = sinf(D3DXToRadian(GetRotation()));

for(;range_start!=range_end;++range_start)
{
const CDynamicSphereInstance& dsiSrc=range_start->second;

CDynamicSphereInstance dsi;
dsi = dsiSrc;
dsi.fRadius = c_fAttackRadius;
{
D3DXVECTOR3 v3SrcDir=dsiSrc.v3Position-dsiSrc.v3LastPosition;
v3SrcDir*=__GetReachScale();

const D3DXVECTOR3& v3Src = dsiSrc.v3LastPosition+v3SrcDir;
D3DXVECTOR3& v3Dst = dsi.v3Position;
v3Dst.x = v3Src.x * c - v3Src.y * s;
v3Dst.y = v3Src.x * s + v3Src.y * c;
v3Dst += GetPosition();
}
{
const D3DXVECTOR3& v3Src = dsiSrc.v3LastPosition;
D3DXVECTOR3& v3Dst = dsi.v3LastPosition;
v3Dst.x = v3Src.x * c - v3Src.y * s;
v3Dst.y = v3Src.x * s + v3Src.y * c;
v3Dst += GetPosition();
}


TCollisionPointInstanceList::iterator cpit;
for(cpit = rVictim.m_DefendingPointInstanceList.begin(); cpit!=rVictim.m_DefendingPointInstanceList.end();++cpit)
{
int index = 0;
const CDynamicSphereInstanceVector & c_DefendingSphereVector = cpit->SphereInstanceVector;
CDynamicSphereInstanceVector::const_iterator dsit;
for(dsit = c_DefendingSphereVector.begin(); dsit!= c_DefendingSphereVector.end();++dsit, ++index)
{
const CDynamicSphereInstance& sub = *dsit;
if (DetectCollisionDynamicZCylinderVSDynamicZCylinder(dsi, sub))
{
THitDataMap::iterator itHitData = m_HitDataMap.find(&c_rHitData);
if (itHitData == m_HitDataMap.end())
{
THittedInstanceMap HittedInstanceMap;
HittedInstanceMap.insert(make_pair(&rVictim, GetLocalTime()+pad->fInvisibleTime));
//HittedInstanceMap.insert(make_pair(&rVictim, GetLocalTime()+HIT_COOL_TIME));
m_HitDataMap.insert(make_pair(&c_rHitData, HittedInstanceMap));

//Tracef(" ----------- First Hit\n");
}
else
{
itHitData->second.insert(make_pair(&rVictim, GetLocalTime()+pad->fInvisibleTime));
//itHitData->second.insert(make_pair(&rVictim, GetLocalTime()+HIT_COOL_TIME));

//Tracef(" ----------- Next Hit : %d\n", itHitData->second.size());

int iCurrentHitCount = itHitData->second.size();
// NOTE : º¸Åë °ø°ÝÀº 16¸íÀÌ ÇÑ°è
if (NRaceData::MOTION_TYPE_COMBO == pad->iMotionType || NRaceData::MOTION_TYPE_NORMAL == pad->iMotionType)
{
if (iCurrentHitCount > 16)
{
//Tracef(" Type NORMAL :: Overflow - Can't process, skip\n");
return FALSE;
}
}
else
{
if (iCurrentHitCount > pad->iHitLimitCount)
{
//Tracef(" Type SKILL :: Overflow - Can't process, skip\n");
return FALSE;
}
}
}

D3DXVECTOR3 v3HitPosition = (GetPosition() + rVictim.GetPosition()) *0.5f;

// #0000780: [M2KR] ¼ö·æ Ÿ°Ý±¸ ¹®Á¦
extern bool IS_HUGE_RACE(unsigned int vnum);
if (IS_HUGE_RACE(rVictim.GetRace()))
{
v3HitPosition = (GetPosition() + sub.v3Position) * 0.5f;
}

__ProcessDataAttackSuccess(*pad, rVictim, v3HitPosition, m_kCurMotNode.uSkill);
return TRUE;
}
}
}
}
}

return FALSE;
}

BOOL CActorInstance::AttackingProcess(CActorInstance & rVictim)
{
if (rVictim.__isInvisible())
return FALSE;

if (__SplashAttackProcess(rVictim))
return TRUE;

if (__NormalAttackProcess(rVictim))
return TRUE;

return FALSE;
}

BOOL CActorInstance::TestPhysicsBlendingCollision(CActorInstance & rVictim)
{
if (rVictim.IsDead())
return FALSE;

TPixelPosition kPPosLast;
GetBlendingPosition( &kPPosLast );

D3DXVECTOR3 v3Distance = D3DXVECTOR3(rVictim.m_x - kPPosLast.x, rVictim.m_y - kPPosLast.y, rVictim.m_z - kPPosLast.z);
float fDistance = D3DXVec3LengthSq(&v3Distance);
if (fDistance > 800.0f*800.0f)
return FALSE;

// NOTE : °ø°Ý ÁßÀ϶§´Â Defending Sphere·Î Collision Check¸¦ ÇÕ´Ï´Ù.
// NOTE : Wait·Î ºí·»µù µÇ´Â µµÁß¿¡ ¶Õ°í µé¾î°¡´Â ¹®Á¦°¡ ÀÖ¾î¼.. - [levites]
TCollisionPointInstanceList * pMainList;
TCollisionPointInstanceList * pVictimList;
if (isAttacking() || IsWaiting())
{
pMainList = &m_DefendingPointInstanceList;
pVictimList = &rVictim.m_DefendingPointInstanceList;
}
else
{
pMainList = &m_BodyPointInstanceList;
pVictimList = &rVictim.m_BodyPointInstanceList;
}

TPixelPosition kPDelta;
m_PhysicsObject.GetLastPosition(&kPDelta);

D3DXVECTOR3 prevLastPosition, prevPosition;
const int nSubCheckCount = 50;

TCollisionPointInstanceListIterator itorMain = pMainList->begin();
TCollisionPointInstanceListIterator itorVictim = pVictimList->begin();
for (; itorMain != pMainList->end(); ++itorMain)
{
for (; itorVictim != pVictimList->end(); ++itorVictim)
{
CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
CDynamicSphereInstanceVector & c_rVictimSphereVector = (*itorVictim).SphereInstanceVector;

for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
{
CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector;
//adjust main sphere center
prevLastPosition = c_rMainSphere.v3LastPosition;
prevPosition = c_rMainSphere.v3Position;

c_rMainSphere.v3LastPosition = prevPosition;

for( int i = 1; i <= nSubCheckCount; ++ i )
{
c_rMainSphere.v3Position = prevPosition + (float)(i/(float)nSubCheckCount) * kPDelta;

for (DWORD j = 0; j < c_rVictimSphereVector.size(); ++j)
{
CDynamicSphereInstance & c_rVictimSphere = c_rVictimSphereVector[j];

if (DetectCollisionDynamicSphereVSDynamicSphere(c_rMainSphere, c_rVictimSphere))
{
BOOL bResult = GetVector3Distance(c_rMainSphere.v3Position, c_rVictimSphere.v3Position) <= GetVector3Distance(c_rMainSphere.v3LastPosition, c_rVictimSphere.v3Position);

c_rMainSphere.v3LastPosition = prevLastPosition;
c_rMainSphere.v3Position = prevPosition;

return bResult;
}
}
}

//restore
c_rMainSphere.v3LastPosition = prevLastPosition;
c_rMainSphere.v3Position = prevPosition;
}
}
}

return FALSE;
}

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

return FALSE;
}

BOOL CActorInstance::TestActorCollision(CActorInstance & rVictim)
{
/*
if (m_pkHorse)
{
if (m_pkHorse->TestActorCollision(rVictim))
return TRUE;

return FALSE;
}
*/

if (rVictim.IsDead() || rVictim.IsPet() || rVictim.IsMount())
return FALSE;
if (IsInSafe(rVictim) && rVictim.GetRace() != 20375)
return FALSE;
if (IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rVictim.GetVirtualID()))
return FALSE;

// Check Distance
// NOTE : Àû´çÈ÷ ¸Ö¸é üũ ¾ÈÇÔ
// ÇÁ·¹ÀÓ ½ºÅµ½Ã³ª ´ë»ó ¿ÀºêÁ§Æ®ÀÇ Å©±â°¡ Ŭ°æ¿ì ¹®Á¦°¡ »ý±æ ¿©Áö°¡ ÀÖÀ½
// ij¸¯ÅÍ°¡ ÀÚ½ÅÀÇ Body Sphere Radius º¸´Ù ´õ Å©°Ô À̵¿Çß´ÂÁö¸¦ üũÇÏ°í,
// ¸¸¾à ±×·¸Áö ¾Ê´Ù¸é °Å¸®·Î üũÇؼ °É·¯ÁØ´Ù.
D3DXVECTOR3 v3Distance = D3DXVECTOR3(rVictim.m_x - m_x, rVictim.m_y - m_y, rVictim.m_z - m_z);
float fDistance = D3DXVec3LengthSq(&v3Distance);
if (fDistance > 800.0f*800.0f)
return FALSE;

// NOTE : °ø°Ý ÁßÀ϶§´Â Defending Sphere·Î Collision Check¸¦ ÇÕ´Ï´Ù.
// NOTE : Wait·Î ºí·»µù µÇ´Â µµÁß¿¡ ¶Õ°í µé¾î°¡´Â ¹®Á¦°¡ ÀÖ¾î¼.. - [levites]
TCollisionPointInstanceList * pMainList;
TCollisionPointInstanceList * pVictimList;
if (isAttacking() || IsWaiting())
{
pMainList = &m_DefendingPointInstanceList;
pVictimList = &rVictim.m_DefendingPointInstanceList;
}
else
{
pMainList = &m_BodyPointInstanceList;
pVictimList = &rVictim.m_BodyPointInstanceList;
}

TCollisionPointInstanceListIterator itorMain = pMainList->begin();
TCollisionPointInstanceListIterator itorVictim = pVictimList->begin();
for (; itorMain != pMainList->end(); ++itorMain)
for (; itorVictim != pVictimList->end(); ++itorVictim)
{
const CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
const CDynamicSphereInstanceVector & c_rVictimSphereVector = (*itorVictim).SphereInstanceVector;

for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
for (DWORD j = 0; j < c_rVictimSphereVector.size(); ++j)
{
const CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector;
const CDynamicSphereInstance & c_rVictimSphere = c_rVictimSphereVector[j];

if (DetectCollisionDynamicSphereVSDynamicSphere(c_rMainSphere, c_rVictimSphere))
{
if (GetVector3Distance(c_rMainSphere.v3Position, c_rVictimSphere.v3Position) <=
GetVector3Distance(c_rMainSphere.v3LastPosition, c_rVictimSphere.v3Position))
{
return TRUE;
}
return FALSE;
}
}
}

return FALSE;
}

bool CActorInstance::AvoidObject(const CGraphicObjectInstance& c_rkBGObj)
{
#ifdef __MOVIE_MODE__
if (IsMovieMode())
return false;
#endif

if (this==&c_rkBGObj)
return false;

if (!__TestObjectCollision(&c_rkBGObj))
return false;

__AdjustCollisionMovement(&c_rkBGObj);
return true;
}

bool CActorInstance::IsBlockObject(const CGraphicObjectInstance& c_rkBGObj)
{
if (this==&c_rkBGObj)
return false;

if (!__TestObjectCollision(&c_rkBGObj))
return false;

return true;
}

void CActorInstance::BlockMovement()
{
if (m_pkHorse)
{
m_pkHorse->__InitializeMovement();
return;
}

__InitializeMovement();
}

BOOL CActorInstance::__TestObjectCollision(const CGraphicObjectInstance * c_pObjectInstance)
{
if (m_pkHorse)
{
if (m_pkHorse->__TestObjectCollision(c_pObjectInstance))
return TRUE;

return FALSE;
}

if (m_canSkipCollision)
return FALSE;

if (m_v3Movement.x == 0.0f && m_v3Movement.y == 0.0f && m_v3Movement.z == 0.0f)
return FALSE;

TCollisionPointInstanceListIterator itorMain = m_BodyPointInstanceList.begin();
for (; itorMain != m_BodyPointInstanceList.end(); ++itorMain)
{
const CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
{
const CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector;

if (c_pObjectInstance->MovementCollisionDynamicSphere(c_rMainSphere))
{
//const D3DXVECTOR3 & c_rv3Position = c_pObjectInstance->GetPosition();
//if (GetVector3Distance(c_rMainSphere.v3Position, c_rv3Position) <
// GetVector3Distance(c_rMainSphere.v3LastPosition, c_rv3Position))
{
return TRUE;
}

//return FALSE;
}
}
}

return FALSE;
}


bool CActorInstance::TestCollisionWithDynamicSphere(const CDynamicSphereInstance & dsi)
{
TCollisionPointInstanceListIterator itorMain = m_BodyPointInstanceList.begin();
for (; itorMain != m_BodyPointInstanceList.end(); ++itorMain)
{
const CDynamicSphereInstanceVector & c_rMainSphereVector = (*itorMain).SphereInstanceVector;
for (DWORD i = 0; i < c_rMainSphereVector.size(); ++i)
{
const CDynamicSphereInstance & c_rMainSphere = c_rMainSphereVector;

if (DetectCollisionDynamicSphereVSDynamicSphere(c_rMainSphere, dsi))
{
return true;
}
}
}

return false;
}
[/CODE]

I don't know if I have posted it on the correct site, if not, please move it.