[ Dead Download Link ] [C++] Release Shoulder System Not Official [ We Need You ]

Roxas07 · June 5, 2015

Hello everybody , I share for you a tutoriel by me for install Shoulder System .

This is not the official System Shoulder so , do not use in live version, this system is stable but all risk's is yours.

https://www.youtube.com/watch?v=Hs3wzMCWCsI&feature=youtu.be

This system is made quickly by me, if you want New System who not exist or powerfull Game Files you can contact me

At my skype: roxasledieutoutpuissant

You can see more information of my market in my website: http://softyou.net

Summary:

I. Part Server:
-Implement new Part of the body player,
-Equipment Part of the player.
-Implement function equipment of item Sash.
-Communication for receive/send part of the Shoulder System.

II. Part Client:
-Implement new Part of the body player.
-Equipment Part of the player.
-Communication for receive/send part of the Shoulder System.
-Implement new Part MSM for all race.

Let's Start now !

1.Implement new Part of the body player:

-Open Header file on the folder Common/lenght.h.

-Search: enum EWearPositions .

-Add Before WEAR_MAX --> WEAR_SHOULDER, // 24 - Shoulder System

Like that:

enum EWearPositions
{
WEAR_BODY, // 0
WEAR_HEAD, // 1
WEAR_FOOTS, // 2
WEAR_WRIST, // 3
WEAR_WEAPON, // 4
WEAR_NECK, // 5
WEAR_EAR, // 6
WEAR_UNIQUE1, // 7
WEAR_UNIQUE2, // 8
WEAR_ARROW, // 9
WEAR_SHIELD, // 10
    WEAR_ABILITY1,  // 11
    WEAR_ABILITY2,  // 12
    WEAR_ABILITY3,  // 13
    WEAR_ABILITY4,  // 14
    WEAR_ABILITY5,  // 15
    WEAR_ABILITY6,  // 16
    WEAR_ABILITY7,  // 17
    WEAR_ABILITY8,  // 18
WEAR_COSTUME_BODY, // 19
WEAR_COSTUME_HAIR, // 20




WEAR_RING1, // 21 : ½Å±Ô ¹ÝÁö½½·Ô1 (¿ÞÂÊ)
WEAR_RING2, // 22 : ½Å±Ô ¹ÝÁö½½·Ô2 (¿À¸¥ÂÊ)




WEAR_BELT, // 23 : Belt System
WEAR_SHOULDER, // 24 : Etole
WEAR_MAX = 32 // 
};

- Now search on header file Lenght.h : enum EParts
- Add before PART_MAX_NUM, --> PART_WING,

Like that:

enum EParts
{
PART_MAIN,
PART_WEAPON,
PART_HEAD,
PART_HAIR,
PART_WING,
PART_MAX_NUM,
PART_WEAPON_SUB,
};

2. Equippment part of the body player

- Now go to your source of your game.
- Open Packet.h and search that --> enum ECharacterEquipmentPart
- Add before CHR_EQUIPPART_NUM --> CHR_EQUIPPART_WING,

Like that:

enum ECharacterEquipmentPart
{
CHR_EQUIPPART_ARMOR,
CHR_EQUIPPART_WEAPON,
CHR_EQUIPPART_HEAD,
CHR_EQUIPPART_HAIR,
CHR_EQUIPPART_WING,
CHR_EQUIPPART_NUM,
};

-Now we open char.cpp for packet communication.

-Search all [CHR_EQUIPPART_HAIR] = GetPart(PART_HAIR);
-Add after :

addPacket.awPart[CHR_EQUIPPART_WING] = GetPart(PART_WING);

Like that:

addPacket.awPart[CHR_EQUIPPART_ARMOR] = GetPart(PART_MAIN);
addPacket.awPart[CHR_EQUIPPART_WEAPON] = GetPart(PART_WEAPON);
addPacket.awPart[CHR_EQUIPPART_HEAD] = GetPart(PART_HEAD);
addPacket.awPart[CHR_EQUIPPART_HAIR] = GetPart(PART_HAIR);
addPacket.awPart[CHR_EQUIPPART_WING] = GetPart(PART_WING);

-Open char_item.cpp
-Search that function : bool CHARACTER::UseItemEx(LPITEM item, TItemPos DestCell)
-Search in that function:

case USE_SPECIAL:
 
 
switch (item->GetVnum())
{

and add this part of code:

//Å©¸®½º¸¶½º ¶õÁÖ
case 85001:
case 85002:
case 85003:
case 85004:
case 85005:
case 85006:
case 85007:
case 85008:
case 85010:
case 85011:
case 85012:
case 85013:
case 85014:
case 85015:
case 85016:
{
     if (!item->IsEquipped())
     {
         if (!CanEquipNow(item))
         {
             ChatPacket(CHAT_TYPE_INFO, "Vous ne pouvez pas vous équipez de cet objet.");
             return false;
         }
         else
         {
EquipItem(item);
             return item->EquipTo(this, WEAR_SHOULDER);
         }
     }
    else
     {
         if (!CanUnequipNow(item))
         {
             ChatPacket(CHAT_TYPE_INFO, "Vous ne pouvez pas vous équipez de cet objet.");
             return false;
         }
         else
         {
             return UnequipItem(item);
         }
     } 
}




- Now open item.cpp
- Search on this Class the function void CItem::ModifyPoints(bool bAdd)
- Search on this function : case ITEM_ARMOR:


after the break point add this part of my code:


case ITEM_USE: 






switch (this->GetVnum())
{
//Å©¸®½º¸¶½º ¶õÁÖ
case 85001:
case 85002:
case 85003:
case 85004:
case 85005:
case 85006:
case 85007:
case 85008:
case 85010:
case 85011:
case 85012:
case 85013:
case 85014:
case 85015:
case 85016:
{
if (bAdd)
{
m_pOwner->SetPart(PART_WING, this->GetVnum());




}
else
{
m_pOwner->SetPart(PART_WING, m_pOwner->GetOriginalPart(PART_WING));
} 
}
break;
}
break;

Now all of part server is implemented:

Lets start client part !

- Open your packet.h
- Search the enumeration and add CHR_EQUIPPART_WING, before CHR_EQUIPPART_NUM like that:

enum ECharacterEquipmentPart
{
CHR_EQUIPPART_ARMOR,
CHR_EQUIPPART_WEAPON,
CHR_EQUIPPART_HEAD,
CHR_EQUIPPART_HAIR,
CHR_EQUIPPART_WING,
CHR_EQUIPPART_NUM,
};

- Open RaceData.h in GameLib solution
- Add the PART_WING like that:

enum EParts
{
// Share index with server 
// ECharacterEquipmentPartµµ ¼öÁ¤ÇØÁÖ¼¼¿ä.
//ÆÐÅ¶ Å©±â°¡ º¯ÇÕ´Ï´Ù ¼¹ö¿Í »óÀÇÈÄ Ãß°¡ÇØÁÖ¼¼¿ä.
PART_MAIN,
PART_WEAPON,
PART_HEAD,
PART_WEAPON_LEFT,
PART_HAIR,
PART_WING,
PART_MAX_NUM,
};

On this Header file search the Structure SHair

struct SHair
{
std::string m_stModelFileName;
std::vector<SSkin> m_kVct_kSkin;
};

Add the Struc SWing after :

struct SWing
{
std::string m_stModelFileName;
std::vector<SSkin> m_kVct_kSkin;
};

On this header file search the void function SetHairSkin:

void SetHairSkin(UINT eHair, UINT ePart, const char* c_szModelFileName, const char* c_szSrcFileName, const char* c_szDstFileName);

Add after:

void SetWingSkin(UINT eWing, UINT ePart, const char* c_szModelFileName, const char* c_szSrcFileName, const char* c_szDstFileName);

Already in this header file search this function:

SHair* FindHair(UINT eHair);

Add after that the new function FindWing:

SWing* FindWing(UINT eWing);

Already in this header file XD search that variable:

std::map<DWORD, SHair> m_kMap_dwHairKey_kHair;

Add after :

std::map<DWORD, SWing> m_kMap_dwWingKey_kWing;

Now i'm too busy for explain other part so I share for you the cpp file:

RaceDateFile.cpp

#include "StdAfx.h"
#include "../eterLib/ResourceManager.h"

#include "RaceData.h"
#include "RaceMotionData.h"

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

BOOL CRaceData::LoadRaceData(const char * c_szFileName)
{
	CTextFileLoader TextFileLoader;
	if (!TextFileLoader.Load(c_szFileName))
		return FALSE;

	TextFileLoader.SetTop();

	TextFileLoader.GetTokenString("basemodelfilename", &m_strBaseModelFileName);
	TextFileLoader.GetTokenString("treefilename", &m_strTreeFileName);
	TextFileLoader.GetTokenString("attributefilename", &m_strAttributeFileName);
	TextFileLoader.GetTokenString("smokebonename", &m_strSmokeBoneName);
	TextFileLoader.GetTokenString("motionlistfilename", &m_strMotionListFileName);

	if (!m_strTreeFileName.empty())
	{
		CFileNameHelper::StringPath(m_strTreeFileName);
	}

	CTokenVector* pSmokeTokenVector;
	if (TextFileLoader.GetTokenVector("smokefilename", &pSmokeTokenVector))
	{
		if (pSmokeTokenVector->size()%2!=0)
		{
			TraceError("SmokeFileName ArgCount[%d]%2==0", pSmokeTokenVector->size());
			return FALSE;
		}

		UINT uLineCount=pSmokeTokenVector->size()/2;

		for (UINT uLine=0; uLine<uLineCount; ++uLine)
		{
			int eSmoke=atoi(pSmokeTokenVector->at(uLine*2+0).c_str());
			if (eSmoke<0 || eSmoke>=SMOKE_NUM)
			{
				TraceError("SmokeFileName SmokeNum[%d] OUT OF RANGE", eSmoke);
				return FALSE;
			}

			const std::string& c_rstrEffectFileName = pSmokeTokenVector->at(uLine*2+1);

			DWORD& rdwCRCEft=m_adwSmokeEffectID[eSmoke];
			if (!CEffectManager::Instance().RegisterEffect2(c_rstrEffectFileName.c_str(), &rdwCRCEft))
			{
				TraceError("CRaceData::RegisterEffect2(%s) ERROR", c_rstrEffectFileName.c_str());
				rdwCRCEft=0;
				return false;
			}
		}
	}

	if (TextFileLoader.SetChildNode("shapedata"))
	{
		std::string strPathName;
		DWORD dwShapeDataCount = 0;
		if (TextFileLoader.GetTokenString("pathname", &strPathName) &&
			TextFileLoader.GetTokenDoubleWord("shapedatacount", &dwShapeDataCount))
		{
			for (DWORD i = 0; i < dwShapeDataCount; ++i)
			{
				if (!TextFileLoader.SetChildNode("shapedata", i))
				{
					continue;
				}

				/////////////////////////
				// Temporary - ÀÌº¥Æ®¸¦ À§ÇÑ ÀÓ½Ã ±â´É
				TextFileLoader.GetTokenString("specialpath", &strPathName);
				/////////////////////////

				DWORD dwShapeIndex;
				if (!TextFileLoader.GetTokenDoubleWord("shapeindex", &dwShapeIndex))
				{
					continue;
				}

				// LOCAL_PATH_SUPPORT
				std::string strModel;				
				if (TextFileLoader.GetTokenString("model", &strModel))
				{
					SetShapeModel(dwShapeIndex, (strPathName + strModel).c_str());
				}
				else
				{					
					if (!TextFileLoader.GetTokenString("local_model", &strModel))					
						continue;

					SetShapeModel(dwShapeIndex, strModel.c_str());
				}
				// END_OF_LOCAL_PATH_SUPPORT

				

				std::string strSourceSkin;
				std::string strTargetSkin;

				// LOCAL_PATH_SUPPORT
				if (TextFileLoader.GetTokenString("local_sourceskin", &strSourceSkin) &&
					TextFileLoader.GetTokenString("local_targetskin", &strTargetSkin))
				{
					AppendShapeSkin(dwShapeIndex, 0, strSourceSkin.c_str(), strTargetSkin.c_str());
				}
				// END_OF_LOCAL_PATH_SUPPORT

				if (TextFileLoader.GetTokenString("sourceskin", &strSourceSkin) &&
					TextFileLoader.GetTokenString("targetskin", &strTargetSkin))
				{
					AppendShapeSkin(dwShapeIndex, 0, (strPathName + strSourceSkin).c_str(), (strPathName + strTargetSkin).c_str());
				}

				if (TextFileLoader.GetTokenString("sourceskin2", &strSourceSkin) &&
					TextFileLoader.GetTokenString("targetskin2", &strTargetSkin))
				{
					AppendShapeSkin(dwShapeIndex, 0, (strPathName + strSourceSkin).c_str(), (strPathName + strTargetSkin).c_str());
				}

				TextFileLoader.SetParentNode();
			}
		}

		TextFileLoader.SetParentNode();
	}

	if (TextFileLoader.SetChildNode("hairdata"))
	{
		std::string strPathName;
		DWORD dwHairDataCount = 0;
		if (TextFileLoader.GetTokenString("pathname", &strPathName) &&
			TextFileLoader.GetTokenDoubleWord("hairdatacount", &dwHairDataCount))
		{

			for (DWORD i = 0; i < dwHairDataCount; ++i)
			{
				if (!TextFileLoader.SetChildNode("hairdata", i))
				{
					continue;
				}

				/////////////////////////
				// Temporary - ÀÌº¥Æ®¸¦ À§ÇÑ ÀÓ½Ã ±â´É
				TextFileLoader.GetTokenString("specialpath", &strPathName);
				/////////////////////////

				DWORD dwShapeIndex;
				if (!TextFileLoader.GetTokenDoubleWord("hairindex", &dwShapeIndex))
				{
					continue;
				}
				
				std::string strModel;
				std::string strSourceSkin;
				std::string strTargetSkin;
				if (TextFileLoader.GetTokenString("model", &strModel) &&
					TextFileLoader.GetTokenString("sourceskin", &strSourceSkin) &&
					TextFileLoader.GetTokenString("targetskin", &strTargetSkin))
				{
					SetHairSkin(dwShapeIndex, 0, (strPathName + strModel).c_str(), (strPathName + strSourceSkin).c_str(), (strPathName + strTargetSkin).c_str());
				}

				TextFileLoader.SetParentNode();
			}
		}

		TextFileLoader.SetParentNode();
	}

	if (TextFileLoader.SetChildNode("wingdata"))
	{
		std::string strPathName;
		DWORD dwWingDataCount = 0;
		if (TextFileLoader.GetTokenString("pathname", &strPathName) &&
			TextFileLoader.GetTokenDoubleWord("wingdatacount", &dwWingDataCount))
		{

			for (DWORD i = 0; i < dwWingDataCount; ++i)
			{
				if (!TextFileLoader.SetChildNode("wingdata", i))
				{
					continue;
				}

				/////////////////////////
				// Temporary - ÀÌº¥Æ®¸¦ À§ÇÑ ÀÓ½Ã ±â´É
				TextFileLoader.GetTokenString("specialpath", &strPathName);
				/////////////////////////

				DWORD dwShapeIndex;
				if (!TextFileLoader.GetTokenDoubleWord("wingindex", &dwShapeIndex))
				{
					continue;
				}

				std::string strModel;
				std::string strSourceSkin;
				std::string strTargetSkin;
				if (TextFileLoader.GetTokenString("model", &strModel) &&
					TextFileLoader.GetTokenString("sourceskin", &strSourceSkin) &&
					TextFileLoader.GetTokenString("targetskin", &strTargetSkin))
				{
					SetWingSkin(dwShapeIndex, 0, (strPathName + strModel).c_str(), (strPathName + strSourceSkin).c_str(), (strPathName + strTargetSkin).c_str());
				}

				TextFileLoader.SetParentNode();
			}
		}

		TextFileLoader.SetParentNode();
	}

	if (TextFileLoader.SetChildNode("attachingdata"))
	{
		if (!NRaceData::LoadAttachingData(TextFileLoader, &m_AttachingDataVector))
			return FALSE;

		TextFileLoader.SetParentNode();
	}

	return TRUE;
}

NetworkActorManager.h:

#pragma once
#include "InstanceBase.h"

struct SNetworkActorData
{
	std::string m_stName;
	
	CAffectFlagContainer	m_kAffectFlags;

	BYTE	m_bType;
	DWORD	m_dwVID;
	DWORD	m_dwStateFlags;
	DWORD	m_dwEmpireID;
	DWORD	m_dwRace;
	DWORD	m_dwMovSpd;
	DWORD	m_dwAtkSpd;
	FLOAT	m_fRot;
	LONG	m_lCurX;
	LONG	m_lCurY;
	LONG	m_lSrcX;
	LONG	m_lSrcY;
	LONG	m_lDstX;
	LONG	m_lDstY;
	

	DWORD	m_dwServerSrcTime;
	DWORD	m_dwClientSrcTime;
	DWORD	m_dwDuration;

	DWORD	m_dwArmor;
	DWORD	m_dwWeapon;
	DWORD	m_dwHair;
	DWORD	m_dwWing;

	DWORD	m_dwOwnerVID;

	short	m_sAlignment;
	BYTE	m_byPKMode;
	DWORD	m_dwMountVnum;

	DWORD	m_dwGuildID;
	DWORD	m_dwLevel;
	
	SNetworkActorData();

	void SetDstPosition(DWORD dwServerTime, LONG lDstX, LONG lDstY, DWORD dwDuration);
	void SetPosition(LONG lPosX, LONG lPosY);
	void UpdatePosition();	

	// NETWORK_ACTOR_DATA_COPY
	SNetworkActorData(const SNetworkActorData& src);
	void operator=(const SNetworkActorData& src);
	void __copy__(const SNetworkActorData& src);	
	// END_OF_NETWORK_ACTOR_DATA_COPY
};

struct SNetworkMoveActorData
{
	DWORD	m_dwVID;
	DWORD	m_dwTime;
	LONG	m_lPosX;
	LONG	m_lPosY;
	float	m_fRot;
	DWORD	m_dwFunc;
	DWORD	m_dwArg;
	DWORD	m_dwDuration;

	SNetworkMoveActorData()
	{
		m_dwVID=0;
		m_dwTime=0;
		m_fRot=0.0f;
		m_lPosX=0;
		m_lPosY=0;
		m_dwFunc=0;
		m_dwArg=0;
		m_dwDuration=0;
	}
};

struct SNetworkUpdateActorData
{
	DWORD m_dwVID;
	DWORD m_dwGuildID;
	DWORD m_dwArmor;
	DWORD m_dwWeapon;
	DWORD m_dwHair;
	DWORD m_dwWing;
	DWORD m_dwMovSpd;
	DWORD m_dwAtkSpd;
	short m_sAlignment;
	BYTE m_byPKMode;
	DWORD m_dwMountVnum;
	DWORD m_dwStateFlags; // º»·¡ Create ¶§¸¸ ¾²ÀÌ´Â º¯¼öÀÓ
	CAffectFlagContainer m_kAffectFlags;

	SNetworkUpdateActorData()
	{
		m_dwGuildID=0;
		m_dwVID=0;
		m_dwArmor=0;
		m_dwWeapon=0;
		m_dwHair=0;
		m_dwMovSpd=0;
		m_dwAtkSpd=0;
		m_sAlignment=0;
		m_byPKMode=0;
		m_dwMountVnum=0;
		m_dwStateFlags=0;
		m_kAffectFlags.Clear();
	}
};

class CPythonCharacterManager;

class CNetworkActorManager : public CReferenceObject
{
	public:
		CNetworkActorManager();
		virtual ~CNetworkActorManager();

		void Destroy();

		void SetMainActorVID(DWORD dwVID);

		void RemoveActor(DWORD dwVID);
		void AppendActor(const SNetworkActorData& c_rkNetActorData);
		void UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData);
		void MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData);

		void SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY);
		void SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID);

		void Update();

	protected:
		void __OLD_Update();

		void __UpdateMainActor();

		bool __IsVisiblePos(LONG lPosX, LONG lPosY);
		bool __IsVisibleActor(const SNetworkActorData& c_rkNetActorData);
		bool __IsMainActorVID(DWORD dwVID);

		void __RemoveAllGroundItems();
		void __RemoveAllActors();
		void __RemoveDynamicActors();
		void __RemoveCharacterManagerActor(SNetworkActorData& rkNetActorData);

		SNetworkActorData* __FindActorData(DWORD dwVID);

		CInstanceBase* __AppendCharacterManagerActor(SNetworkActorData& rkNetActorData);
		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData);
		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData, LONG lDstX, LONG lDstY);

		CPythonCharacterManager& __GetCharacterManager();

	protected:
		DWORD m_dwMainVID;

		LONG m_lMainPosX;
		LONG m_lMainPosY;

		std::map<DWORD, SNetworkActorData> m_kNetActorDict;
};

ActorInstanceData.cpp:

#include "StdAfx.h"
#include "ActorInstance.h"
#include "RaceManager.h"
#include "ItemManager.h"
#include "RaceData.h"

#include "../eterlib/ResourceManager.h"
#include "../etergrnlib/util.h"

DWORD CActorInstance::GetVirtualID()
{
	return m_dwSelfVID;
}

void CActorInstance::SetVirtualID(DWORD dwVID)
{
	m_dwSelfVID = dwVID;
}

void CActorInstance::UpdateAttribute()
{
	if (!m_pAttributeInstance)
		return;

	if (!m_bNeedUpdateCollision)
		return;

	m_bNeedUpdateCollision = FALSE;

	const CStaticCollisionDataVector & c_rkVec_ColliData = m_pAttributeInstance->GetObjectPointer()->GetCollisionDataVector();
	UpdateCollisionData(&c_rkVec_ColliData);

	m_pAttributeInstance->RefreshObject(GetTransform());
	UpdateHeightInstance(m_pAttributeInstance);

	//BOOL isHeightData = m_pAttributeInstance->IsEmpty();
}

void CActorInstance::__CreateAttributeInstance(CAttributeData * pData)
{
	m_pAttributeInstance = CAttributeInstance::New();
	m_pAttributeInstance->Clear();
	m_pAttributeInstance->SetObjectPointer(pData);
	if (pData->IsEmpty())
	{
		m_pAttributeInstance->Clear();
		CAttributeInstance::Delete(m_pAttributeInstance);
	}
}

DWORD CActorInstance::GetRace()
{
	return m_eRace;
}

bool CActorInstance::SetRace(DWORD eRace)
{
	CRaceData * pRaceData;
	if (!CRaceManager::Instance().GetRaceDataPointer(eRace, &pRaceData))
	{
		m_eRace = 0;
		m_pkCurRaceData = NULL;
		return false;
	}

	m_eRace = eRace;
	m_pkCurRaceData = pRaceData;

	CAttributeData * pAttributeData = pRaceData->GetAttributeDataPtr();
	if (pAttributeData)
	{
		__CreateAttributeInstance(pAttributeData);
	}

	memset(m_adwPartItemID, 0, sizeof(m_adwPartItemID));

	// Setup Graphic ResourceData
	__ClearAttachingEffect();

	CGraphicThingInstance::Clear();

	//NOTE : PC¸¸ Partº°·Î ´Ù »ý¼ºÇÏ°Ô ÇØÁØ´Ù.
	if (IsPC())
	{
		CGraphicThingInstance::ReserveModelThing(CRaceData::PART_MAX_NUM);
		CGraphicThingInstance::ReserveModelInstance(CRaceData::PART_MAX_NUM);
	}
	else
	{
		CGraphicThingInstance::ReserveModelThing(1);
		CGraphicThingInstance::ReserveModelInstance(1);
	}


	CRaceData::TMotionModeDataIterator itor;

	if (pRaceData->CreateMotionModeIterator(itor))
	{
		do
		{
			WORD wMotionMode = itor->first;
			CRaceData::TMotionModeData * pMotionModeData = itor->second;

			CRaceData::TMotionVectorMap::iterator itorMotion = pMotionModeData->MotionVectorMap.begin();
			for (; itorMotion != pMotionModeData->MotionVectorMap.end(); ++itorMotion)
			{
				WORD wMotionIndex = itorMotion->first;
				const CRaceData::TMotionVector & c_rMotionVector = itorMotion->second;
				CRaceData::TMotionVector::const_iterator it;
				DWORD i;
				for (i = 0, it = c_rMotionVector.begin(); it != c_rMotionVector.end(); ++i, ++it)
				{
					DWORD dwMotionKey = MAKE_RANDOM_MOTION_KEY(wMotionMode, wMotionIndex, i);
					CGraphicThingInstance::RegisterMotionThing(dwMotionKey, it->pMotion);
				}
			}
		} while (pRaceData->NextMotionModeIterator(itor));
	}

	return true;
}

void CActorInstance::SetHair(DWORD eHair)
{
	m_eHair = eHair;

	CRaceData * pRaceData;

	if (!CRaceManager::Instance().GetRaceDataPointer(m_eRace, &pRaceData))
		return;

	CRaceData::SHair* pkHair = pRaceData->FindHair(eHair);
	if (pkHair)
	{
		if (!pkHair->m_stModelFileName.empty())
		{
			CGraphicThing * pkHairThing = (CGraphicThing *)CResourceManager::Instance().GetResourcePointer(pkHair->m_stModelFileName.c_str());
			RegisterModelThing(CRaceData::PART_HAIR, pkHairThing);
			SetModelInstance(CRaceData::PART_HAIR, CRaceData::PART_HAIR, 0, CRaceData::PART_MAIN);
		}

		const std::vector<CRaceData::SSkin>& c_rkVct_kSkin = pkHair->m_kVct_kSkin;
		std::vector<CRaceData::SSkin>::const_iterator i;
		for (i = c_rkVct_kSkin.begin(); i != c_rkVct_kSkin.end(); ++i)
		{
			const CRaceData::SSkin& c_rkSkinItem = *i;

			CResource * pkRes = CResourceManager::Instance().GetResourcePointer(c_rkSkinItem.m_stDstFileName.c_str());

			if (pkRes)
				SetMaterialImagePointer(CRaceData::PART_HAIR, c_rkSkinItem.m_stSrcFileName.c_str(), static_cast<CGraphicImage*>(pkRes));
		}
	}
}

void CActorInstance::SetWing(DWORD eWing)
{
	m_eWing = eWing;

	CRaceData * pRaceData;

	if (!CRaceManager::Instance().GetRaceDataPointer(m_eRace, &pRaceData))
		return;

	CRaceData::SWing* pkWing = pRaceData->FindWing(eWing);
	if (pkWing)
	{
		if (!pkWing->m_stModelFileName.empty())
		{
			CGraphicThing * pkWingThing = (CGraphicThing *)CResourceManager::Instance().GetResourcePointer(pkWing->m_stModelFileName.c_str());
			RegisterModelThing(CRaceData::PART_WING, pkWingThing);
			SetModelInstance(CRaceData::PART_WING, CRaceData::PART_WING, 0, CRaceData::PART_MAIN);
		}

		const std::vector<CRaceData::SSkin>& c_rkVct_kSkin = pkWing->m_kVct_kSkin;
		std::vector<CRaceData::SSkin>::const_iterator i;
		for (i = c_rkVct_kSkin.begin(); i != c_rkVct_kSkin.end(); ++i)
		{
			const CRaceData::SSkin& c_rkSkinItem = *i;

			CResource * pkRes = CResourceManager::Instance().GetResourcePointer(c_rkSkinItem.m_stDstFileName.c_str());

			if (pkRes)
				SetMaterialImagePointer(CRaceData::PART_WING, c_rkSkinItem.m_stSrcFileName.c_str(), static_cast<CGraphicImage*>(pkRes));
		}
	}
}




void CActorInstance::SetShape(DWORD eShape, float fSpecular)
{
	m_eShape = eShape;

	CRaceData * pRaceData;
	if (!CRaceManager::Instance().GetRaceDataPointer(m_eRace, &pRaceData))
		return;

	CRaceData::SShape* pkShape = pRaceData->FindShape(eShape);
	if (pkShape)
	{
		CResourceManager& rkResMgr = CResourceManager::Instance();

		if (pkShape->m_stModelFileName.empty())
		{
			CGraphicThing* pModelThing = pRaceData->GetBaseModelThing();
			RegisterModelThing(0, pModelThing);
		}
		else
		{
			CGraphicThing* pModelThing = (CGraphicThing *)rkResMgr.GetResourcePointer(pkShape->m_stModelFileName.c_str());
			RegisterModelThing(0, pModelThing);
		}

		{
			std::string stLODModelFileName;

			char szLODModelFileNameEnd[256];
			for (UINT uLODIndex = 1; uLODIndex <= 3; ++uLODIndex)
			{
				sprintf(szLODModelFileNameEnd, "_lod_%.2d.gr2", uLODIndex);
				stLODModelFileName = CFileNameHelper::NoExtension(pkShape->m_stModelFileName) + szLODModelFileNameEnd;
				if (!rkResMgr.IsFileExist(stLODModelFileName.c_str()))
					break;

				CGraphicThing* pLODModelThing = (CGraphicThing *)rkResMgr.GetResourcePointer(stLODModelFileName.c_str());
				if (!pLODModelThing)
					break;

				RegisterLODThing(0, pLODModelThing);
			}
		}

		SetModelInstance(0, 0, 0);

		const std::vector<CRaceData::SSkin>& c_rkVct_kSkin = pkShape->m_kVct_kSkin;
		std::vector<CRaceData::SSkin>::const_iterator i;
		for (i = c_rkVct_kSkin.begin(); i != c_rkVct_kSkin.end(); ++i)
		{
			const CRaceData::SSkin& c_rkSkinItem = *i;

			CResource * pkRes = CResourceManager::Instance().GetResourcePointer(c_rkSkinItem.m_stDstFileName.c_str());

			if (pkRes)
			{
				if (fSpecular > 0.0f)
				{
					SMaterialData kMaterialData;
					kMaterialData.pImage = static_cast<CGraphicImage*>(pkRes);
					kMaterialData.isSpecularEnable = TRUE;
					kMaterialData.fSpecularPower = fSpecular;
					kMaterialData.bSphereMapIndex = 0;
					SetMaterialData(c_rkSkinItem.m_ePart, c_rkSkinItem.m_stSrcFileName.c_str(), kMaterialData);
				}
				else
				{
					SetMaterialImagePointer(c_rkSkinItem.m_ePart, c_rkSkinItem.m_stSrcFileName.c_str(), static_cast<CGraphicImage*>(pkRes));
				}
			}
		}
	}
	else
	{
		if (pRaceData->IsTree())
		{
			__CreateTree(pRaceData->GetTreeFileName());
		}
		else
		{
			CGraphicThing* pModelThing = pRaceData->GetBaseModelThing();
			RegisterModelThing(0, pModelThing);

			CGraphicThing* pLODModelThing = pRaceData->GetLODModelThing();
			RegisterLODThing(0, pLODModelThing);

			SetModelInstance(0, 0, 0);
		}
	}

	// Attaching Objects
	for (DWORD i = 0; i < pRaceData->GetAttachingDataCount(); ++i)
	{
		const NRaceData::TAttachingData * c_pAttachingData;
		if (!pRaceData->GetAttachingDataPointer(i, &c_pAttachingData))
			continue;

		switch (c_pAttachingData->dwType)
		{
		case NRaceData::ATTACHING_DATA_TYPE_EFFECT:
			if (c_pAttachingData->isAttaching)
			{
				AttachEffectByName(0, c_pAttachingData->strAttachingBoneName.c_str(), c_pAttachingData->pEffectData->strFileName.c_str());
			}
			else
			{
				AttachEffectByName(0, 0, c_pAttachingData->pEffectData->strFileName.c_str());
			}
			break;
		}
	}
}

void CActorInstance::ChangeMaterial(const char * c_szFileName)
{
	CRaceData * pRaceData;
	if (!CRaceManager::Instance().GetRaceDataPointer(m_eRace, &pRaceData))
		return;

	CRaceData::SShape* pkShape = pRaceData->FindShape(m_eShape);
	if (!pkShape)
		return;

	const std::vector<CRaceData::SSkin>& c_rkVct_kSkin = pkShape->m_kVct_kSkin;
	if (c_rkVct_kSkin.empty())
		return;

	std::vector<CRaceData::SSkin>::const_iterator i = c_rkVct_kSkin.begin();
	const CRaceData::SSkin& c_rkSkinItem = *i;

	std::string dstFileName = "d:/ymir work/npc/guild_symbol/guild_symbol.dds";
	dstFileName = c_szFileName;

	CResource * pkRes = CResourceManager::Instance().GetResourcePointer(dstFileName.c_str());
	if (!pkRes)
		return;

	SetMaterialImagePointer(c_rkSkinItem.m_ePart, c_rkSkinItem.m_stSrcFileName.c_str(), static_cast<CGraphicImage*>(pkRes));
}
/*
void CActorInstance::SetPart(DWORD dwPartIndex, DWORD dwItemID)
{
if (dwPartIndex>=CRaceData::PART_MAX_NUM)
return;

if (!m_pkCurRaceData)
{
assert(m_pkCurRaceData);
return;
}

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

RegisterModelThing(dwPartIndex, pItemData->GetModelThing());
for (DWORD i = 0; i < pItemData->GetLODModelThingCount(); ++i)
{
CGraphicThing * pThing;
if (!pItemData->GetLODModelThingPointer(i, &pThing))
continue;

RegisterLODThing(dwPartIndex, pThing);
}
SetModelInstance(dwPartIndex, dwPartIndex, 0);

m_adwPartItemID[dwPartIndex] = dwItemID;
}
*/

DWORD CActorInstance::GetPartItemID(DWORD dwPartIndex)
{
	if (dwPartIndex >= CRaceData::PART_MAX_NUM)
	{
		TraceError("CActorInstance::GetPartIndex(dwPartIndex=%d/CRaceData::PART_MAX_NUM=%d)", dwPartIndex, CRaceData::PART_MAX_NUM);
		return 0;
	}

	return m_adwPartItemID[dwPartIndex];
}

void CActorInstance::SetSpecularInfo(BOOL bEnable, int iPart, float fAlpha)
{
	CRaceData * pkRaceData;
	if (!CRaceManager::Instance().GetRaceDataPointer(m_eRace, &pkRaceData))
		return;

	CRaceData::SShape * pkShape = pkRaceData->FindShape(m_eShape);
	if (pkShape->m_kVct_kSkin.empty())
		return;

	std::string filename = pkShape->m_kVct_kSkin[0].m_stSrcFileName.c_str();
	CFileNameHelper::ChangeDosPath(filename);

	CGraphicThingInstance::SetSpecularInfo(iPart, filename.c_str(), bEnable, fAlpha);
}

void CActorInstance::SetSpecularInfoForce(BOOL bEnable, int iPart, float fAlpha)
{
	CGraphicThingInstance::SetSpecularInfo(iPart, NULL, bEnable, fAlpha);
}

ActorInstanceAttach.cpp:

#include "StdAfx.h"
#include "../EffectLib/EffectManager.h"

#include "ActorInstance.h"
#include "ItemData.h"
#include "ItemManager.h"
#include "RaceData.h"
#include "WeaponTrace.h"

BOOL USE_WEAPON_SPECULAR = TRUE;

BOOL USE_VIETNAM_CONVERT_WEAPON_VNUM = FALSE;

DWORD Vietnam_ConvertWeaponVnum(DWORD vnum)
{
	DWORD base = vnum / 10 * 10;
	DWORD rest = vnum % 10;
	switch (base)
	{
	case  10:base = 5000; break;
	case  20:base = 5010; break;
	case  30:base = 5020; break;
	case  40:base = 5030; break;
	case  50:base = 5030; break;
	case  60:base = 5040; break;
	case  70:base = 5040; break;
	case  80:base = 5050; break;
	case  90:base = 5050; break;
	case 100:base = 5060; break;
	case 110:base = 5060; break;
	case 120:base = 5070; break;
	case 130:base = 5070; break;
	case 140:base = 5080; break;
	case 150:base = 5080; break;
	case 160:base = 5090; break;
	case 170:base = 5090; break;
	case 180:base = 5100; break;
	case 190:base = 5100; break;
	case 200:base = 5110; break;
	case 210:base = 5110; break;
	case 220:base = 5120; break;
	case 230:base = 5120; break;
	case 240:base = 5130; break;
	case 250:base = 5130; break;
	case 260:base = 5140; break;
	case 270:base = 5140; break;
	case 280:base = 5150; break;
	case 290:base = 5150; break;
	case 1000:base = 5000; break;
	case 1010:base = 5010; break;
	case 1020:base = 5020; break;
	case 1030:base = 5030; break;
	case 1040:base = 5040; break;
	case 1050:base = 5050; break;
	case 1060:base = 5060; break;
	case 1070:base = 5070; break;
	case 1080:base = 5080; break;
	case 1090:base = 5090; break;
	case 1100:base = 5100; break;
	case 1110:base = 5110; break;
	case 1120:base = 5120; break;
	case 1130:base = 5130; break;
	case 1140:base = 5140; break;
	case 1150:base = 5150; break;
	case 1160:base = 5150; break;
	case 1170:base = 5150; break;
	case 3000:base = 5000; break;
	case 3010:base = 5010; break;
	case 3020:base = 5020; break;
	case 3030:base = 5030; break;
	case 3040:base = 5040; break;
	case 3050:base = 5050; break;
	case 3060:base = 5060; break;
	case 3070:base = 5070; break;
	case 3080:base = 5080; break;
	case 3090:base = 5090; break;
	case 3100:base = 5100; break;
	case 3110:base = 5100; break;
	case 3120:base = 5110; break;
	case 3130:base = 5110; break;
	case 3140:base = 5120; break;
	case 3150:base = 5120; break;
	case 3160:base = 5130; break;
	case 3170:base = 5130; break;
	case 3180:base = 5140; break;
	case 3190:base = 5140; break;
	case 3200:base = 5150; break;
	case 3210:base = 5150; break;
	}
	return base + rest;
}


DWORD CActorInstance::AttachSmokeEffect(DWORD eSmoke)
{
	if (!m_pkCurRaceData)
		return 0;

	DWORD dwSmokeEffectID = m_pkCurRaceData->GetSmokeEffectID(eSmoke);

	return AttachEffectByID(0, m_pkCurRaceData->GetSmokeBone().c_str(), dwSmokeEffectID);
}

bool CActorInstance::__IsLeftHandWeapon(DWORD type)
{
	if (CItemData::WEAPON_DAGGER == type || (CItemData::WEAPON_FAN == type && __IsMountingHorse()))
		return true;
	else if (CItemData::WEAPON_BOW == type)
		return true;
	else
		return false;
}

bool CActorInstance::__IsRightHandWeapon(DWORD type)
{
	if (CItemData::WEAPON_DAGGER == type || (CItemData::WEAPON_FAN == type && __IsMountingHorse()))
		return true;
	else if (CItemData::WEAPON_BOW == type)
		return false;
	else
		return true;
}

bool CActorInstance::__IsWeaponTrace(DWORD weaponType)
{
	switch (weaponType)
	{
	case CItemData::WEAPON_BELL:
	case CItemData::WEAPON_FAN:
	case CItemData::WEAPON_BOW:
		return false;
	default:
		return true;

	}
}

void CActorInstance::AttachWeapon(DWORD dwItemIndex, DWORD dwParentPartIndex, DWORD dwPartIndex)
{
	if (dwPartIndex >= CRaceData::PART_MAX_NUM)
		return;

	m_adwPartItemID[dwPartIndex] = dwItemIndex;

	if (USE_VIETNAM_CONVERT_WEAPON_VNUM)
		dwItemIndex = Vietnam_ConvertWeaponVnum(dwItemIndex);

	CItemData * pItemData;
	if (!CItemManager::Instance().GetItemDataPointer(dwItemIndex, &pItemData))
	{
		RegisterModelThing(dwPartIndex, NULL);
		SetModelInstance(dwPartIndex, dwPartIndex, 0);

		RegisterModelThing(CRaceData::PART_WEAPON_LEFT, NULL);
		SetModelInstance(CRaceData::PART_WEAPON_LEFT, CRaceData::PART_WEAPON_LEFT, 0);

		RefreshActorInstance();
		return;
	}

	__DestroyWeaponTrace();
	//¾ç¼Õ¹«±â(ÀÚ°´ ÀÌµµ·ù) ¿Þ¼Õ,¿À¸¥¼Õ ¸ðµÎ¿¡ ÀåÂø.
	if (__IsRightHandWeapon(pItemData->GetWeaponType()))
		AttachWeapon(dwParentPartIndex, CRaceData::PART_WEAPON, pItemData);
	if (__IsLeftHandWeapon(pItemData->GetWeaponType()))
		AttachWeapon(dwParentPartIndex, CRaceData::PART_WEAPON_LEFT, pItemData);
}

void CActorInstance::AttachWing(DWORD dwItemIndex, DWORD dwParentPartIndex, DWORD dwPartIndex)
{
	if (dwPartIndex >= CRaceData::PART_MAX_NUM)
		return;

	m_adwPartItemID[dwPartIndex] = dwItemIndex;


	CItemData * pItemData;
	if (!CItemManager::Instance().GetItemDataPointer(dwItemIndex, &pItemData))
	{
		RegisterModelThing(dwPartIndex, NULL);
		SetModelInstance(dwPartIndex, dwPartIndex, 0);

		RegisterModelThing(CRaceData::PART_WING, NULL);
		SetModelInstance(CRaceData::PART_WING, CRaceData::PART_WING, 0);

		RefreshActorInstance();
		return;
	}

	AttachWing(dwParentPartIndex, CRaceData::PART_WING, pItemData);

}


BOOL CActorInstance::GetAttachingBoneName(DWORD dwPartIndex, const char ** c_pszBoneName)
{
	return m_pkCurRaceData->GetAttachingBoneName(dwPartIndex, c_pszBoneName);
}

void CActorInstance::AttachWing(DWORD dwParentPartIndex, DWORD dwPartIndex, CItemData * pItemData)
{
	//	assert(m_pkCurRaceData);
	if (!pItemData)
		return;

	const char * szBoneName;
	if (!GetAttachingBoneName(dwPartIndex, &szBoneName))
		return;

	// NOTE : (ÀÌµµ·ùÃ³¸®)´ÜµµÀÏ °æ¿ì ÇüÅÂ°¡ ´Ù¸¥ °ÍÀ¸·Î ¾ò´Â´Ù. ¾øÀ» °æ¿ì µðÆúÆ®¸¦ ¸®ÅÏ
	if (CRaceData::PART_WING == dwPartIndex)
	{
		RegisterModelThing(dwPartIndex, pItemData->GetSubModelThing());
	}
	else
	{
		RegisterModelThing(dwPartIndex, pItemData->GetModelThing());
	}

	for (DWORD i = 0; i < pItemData->GetLODModelThingCount(); ++i)
	{
		CGraphicThing * pThing;

		if (!pItemData->GetLODModelThingPointer(i, &pThing))
			continue;

		RegisterLODThing(dwPartIndex, pThing);
	}

	SetModelInstance(dwPartIndex, dwPartIndex, 0);
	AttachModelInstance(dwParentPartIndex, szBoneName, dwPartIndex);


}

void CActorInstance::AttachWeapon(DWORD dwParentPartIndex, DWORD dwPartIndex, CItemData * pItemData)
{
	//	assert(m_pkCurRaceData);
	if (!pItemData)
		return;

	const char * szBoneName;
	if (!GetAttachingBoneName(dwPartIndex, &szBoneName))
		return;

	// NOTE : (ÀÌµµ·ùÃ³¸®)´ÜµµÀÏ °æ¿ì ÇüÅÂ°¡ ´Ù¸¥ °ÍÀ¸·Î ¾ò´Â´Ù. ¾øÀ» °æ¿ì µðÆúÆ®¸¦ ¸®ÅÏ
	if (CRaceData::PART_WEAPON_LEFT == dwPartIndex)
	{
		RegisterModelThing(dwPartIndex, pItemData->GetSubModelThing());
	}
	else
	{
		RegisterModelThing(dwPartIndex, pItemData->GetModelThing());
	}

	for (DWORD i = 0; i < pItemData->GetLODModelThingCount(); ++i)
	{
		CGraphicThing * pThing;

		if (!pItemData->GetLODModelThingPointer(i, &pThing))
			continue;

		RegisterLODThing(dwPartIndex, pThing);
	}

	SetModelInstance(dwPartIndex, dwPartIndex, 0);
	AttachModelInstance(dwParentPartIndex, szBoneName, dwPartIndex);

	// 20041208.myevan.¹«±â½ºÆåÅ§·¯(°ª¿ÊÀº SetShape¿¡¼ Á÷Á¢ ÇØÁØ´Ù.)
	if (USE_WEAPON_SPECULAR)
	{
		SMaterialData kMaterialData;
		kMaterialData.pImage = NULL;
		kMaterialData.isSpecularEnable = TRUE;
		kMaterialData.fSpecularPower = pItemData->GetSpecularPowerf();
		kMaterialData.bSphereMapIndex = 1;
		SetMaterialData(dwPartIndex, NULL, kMaterialData);
	}

	// Weapon Trace
	if (__IsWeaponTrace(pItemData->GetWeaponType()))
	{
		CWeaponTrace * pWeaponTrace = CWeaponTrace::New();
		pWeaponTrace->SetWeaponInstance(this, dwPartIndex, szBoneName);
		m_WeaponTraceVector.push_back(pWeaponTrace);
	}
}

void  CActorInstance::DettachEffect(DWORD dwEID)
{
	std::list<TAttachingEffect>::iterator i = m_AttachingEffectList.begin();

	while (i != m_AttachingEffectList.end())
	{
		TAttachingEffect & rkAttEft = (*i);

		if (rkAttEft.dwEffectIndex == dwEID)
		{
			i = m_AttachingEffectList.erase(i);
			CEffectManager::Instance().DestroyEffectInstance(dwEID);
		}
		else
		{
			++i;
		}
	}
}

DWORD CActorInstance::AttachEffectByName(DWORD dwParentPartIndex, const char * c_pszBoneName, const char * c_pszEffectName)
{
	std::string str;
	DWORD dwCRC;
	StringPath(c_pszEffectName, str);
	dwCRC = GetCaseCRC32(str.c_str(), str.length());

	return AttachEffectByID(dwParentPartIndex, c_pszBoneName, dwCRC);
}

DWORD CActorInstance::AttachEffectByID(DWORD dwParentPartIndex, const char * c_pszBoneName, DWORD dwEffectID, const D3DXVECTOR3 * c_pv3Position)
{
	TAttachingEffect ae;
	ae.iLifeType = EFFECT_LIFE_INFINITE;
	ae.dwEndTime = 0;
	ae.dwModelIndex = dwParentPartIndex;
	ae.dwEffectIndex = CEffectManager::Instance().GetEmptyIndex();
	ae.isAttaching = TRUE;
	if (c_pv3Position)
	{
		D3DXMatrixTranslation(&ae.matTranslation, c_pv3Position->x, c_pv3Position->y, c_pv3Position->z);
	}
	else
	{
		D3DXMatrixIdentity(&ae.matTranslation);
	}
	CEffectManager& rkEftMgr = CEffectManager::Instance();
	rkEftMgr.CreateEffectInstance(ae.dwEffectIndex, dwEffectID);

	if (c_pszBoneName)
	{
		int iBoneIndex;

		if (!FindBoneIndex(dwParentPartIndex, c_pszBoneName, &iBoneIndex))
		{
			ae.iBoneIndex = -1;
			//Tracef("Cannot get Bone Indexn");
			//assert(false && "Cannot get Bone Index");
		}
		else
		{
			ae.iBoneIndex = iBoneIndex;
		}
	}
	else
	{
		ae.iBoneIndex = -1;
	}

	m_AttachingEffectList.push_back(ae);

	return ae.dwEffectIndex;
}

void CActorInstance::RefreshActorInstance()
{
	if (!m_pkCurRaceData)
	{
		TraceError("void CActorInstance::RefreshActorInstance() - m_pkCurRaceData=NULL");
		return;
	}

	// This is Temporary place before making the weapon detection system
	// Setup Collison Detection Data
	m_BodyPointInstanceList.clear();
	//m_AttackingPointInstanceList.clear();
	m_DefendingPointInstanceList.clear();

	// Base
	for (DWORD i = 0; i < m_pkCurRaceData->GetAttachingDataCount(); ++i)
	{
		const NRaceData::TAttachingData * c_pAttachingData;

		if (!m_pkCurRaceData->GetAttachingDataPointer(i, &c_pAttachingData))
			continue;

		switch (c_pAttachingData->dwType)
		{
		case NRaceData::ATTACHING_DATA_TYPE_COLLISION_DATA:
		{
															  const NRaceData::TCollisionData * c_pCollisionData = c_pAttachingData->pCollisionData;

															  TCollisionPointInstance PointInstance;
															  if (NRaceData::COLLISION_TYPE_ATTACKING == c_pCollisionData->iCollisionType)
																  continue;

															  if (!CreateCollisionInstancePiece(CRaceData::PART_MAIN, c_pAttachingData, &PointInstance))
																  continue;

															  switch (c_pCollisionData->iCollisionType)
															  {
															  case NRaceData::COLLISION_TYPE_ATTACKING:
																  //m_AttackingPointInstanceList.push_back(PointInstance);
																  break;
															  case NRaceData::COLLISION_TYPE_DEFENDING:
																  m_DefendingPointInstanceList.push_back(PointInstance);
																  break;
															  case NRaceData::COLLISION_TYPE_BODY:
																  m_BodyPointInstanceList.push_back(PointInstance);
																  break;
															  }
		}
			break;

		case NRaceData::ATTACHING_DATA_TYPE_EFFECT:
			//				if (!m_bEffectInitialized)
			//				{
			//					DWORD dwCRC;
			//					StringPath(c_pAttachingData->pEffectData->strFileName);
			//					dwCRC = GetCaseCRC32(c_pAttachingData->pEffectData->strFileName.c_str(),c_pAttachingData->pEffectData->strFileName.length());
			//
			//					TAttachingEffect ae;
			//					ae.iLifeType = EFFECT_LIFE_INFINITE;
			//					ae.dwEndTime = 0;
			//					ae.dwModelIndex = 0;
			//					ae.dwEffectIndex = CEffectManager::Instance().GetEmptyIndex();
			//					ae.isAttaching = TRUE;
			//					CEffectManager::Instance().CreateEffectInstance(ae.dwEffectIndex, dwCRC);
			//
			//					if (c_pAttachingData->isAttaching)
			//					{
			//						int iBoneIndex;
			//						if (!FindBoneIndex(0,c_pAttachingData->strAttachingBoneName.c_str(), &iBoneIndex))
			//						{
			//							Tracef("Cannot get Bone Indexn");
			//							assert(false/*Cannot get Bone Index*/);
			//						}
			//
			//						ae.iBoneIndex = iBoneIndex;
			//					}
			//					else
			//					{
			//						ae.iBoneIndex = -1;
			//					}
			//
			//					m_AttachingEffectList.push_back(ae);
			//				}

			if (c_pAttachingData->isAttaching)
			{
				AttachEffectByName(0, c_pAttachingData->strAttachingBoneName.c_str(), c_pAttachingData->pEffectData->strFileName.c_str());
			}
			else
			{
				AttachEffectByName(0, 0, c_pAttachingData->pEffectData->strFileName.c_str());
			}
			break;

		case NRaceData::ATTACHING_DATA_TYPE_OBJECT:
			break;

		default:
			assert(false/*NOT_IMPLEMENTED*/);
			break;
		}
	}

	for (DWORD j = 0; j < CRaceData::PART_MAX_NUM; ++j)
	{
		if (0 == m_adwPartItemID[j])
			continue;

		CItemData * pItemData;
		if (!CItemManager::Instance().GetItemDataPointer(m_adwPartItemID[j], &pItemData))
			return;

		for (DWORD k = 0; k < pItemData->GetAttachingDataCount(); ++k)
		{
			const NRaceData::TAttachingData * c_pAttachingData;

			if (!pItemData->GetAttachingDataPointer(k, &c_pAttachingData))
				continue;

			switch (c_pAttachingData->dwType)
			{
			case NRaceData::ATTACHING_DATA_TYPE_COLLISION_DATA:
			{
																  const NRaceData::TCollisionData * c_pCollisionData = c_pAttachingData->pCollisionData;

																  // FIXME : Ã¹¹øÂ° ÀÎÀÚ´Â PartÀÇ ¹øÈ£´Ù.
																  //         Base´Â ¹«Á¶°Ç 0ÀÎ°¡? - [levites]
																  TCollisionPointInstance PointInstance;
																  if (NRaceData::COLLISION_TYPE_ATTACKING == c_pCollisionData->iCollisionType)
																	  continue;
																  if (!CreateCollisionInstancePiece(j, c_pAttachingData, &PointInstance))
																	  continue;

																  switch (c_pCollisionData->iCollisionType)
																  {
																  case NRaceData::COLLISION_TYPE_ATTACKING:
																	  //m_AttackingPointInstanceList.push_back(PointInstance);
																	  break;
																  case NRaceData::COLLISION_TYPE_DEFENDING:
																	  m_DefendingPointInstanceList.push_back(PointInstance);
																	  break;
																  case NRaceData::COLLISION_TYPE_BODY:
																	  m_BodyPointInstanceList.push_back(PointInstance);
																	  break;
																  }
			}
				break;

			case NRaceData::ATTACHING_DATA_TYPE_EFFECT:
				if (!m_bEffectInitialized)
				{
					DWORD dwCRC;
					StringPath(c_pAttachingData->pEffectData->strFileName);
					dwCRC = GetCaseCRC32(c_pAttachingData->pEffectData->strFileName.c_str(), c_pAttachingData->pEffectData->strFileName.length());

					TAttachingEffect ae;
					ae.iLifeType = EFFECT_LIFE_INFINITE;
					ae.dwEndTime = 0;
					ae.dwModelIndex = j;
					ae.dwEffectIndex = CEffectManager::Instance().GetEmptyIndex();
					ae.isAttaching = TRUE;
					CEffectManager::Instance().CreateEffectInstance(ae.dwEffectIndex, dwCRC);

					int iBoneIndex;
					if (!FindBoneIndex(j, c_pAttachingData->strAttachingBoneName.c_str(), &iBoneIndex))
					{
						Tracef("Cannot get Bone Indexn");
						assert(false/*Cannot get Bone Index*/);
					}
					Tracef("Creating %p %d %dn", this, j, k);

					ae.iBoneIndex = iBoneIndex;

					m_AttachingEffectList.push_back(ae);
				}
				break;

			case NRaceData::ATTACHING_DATA_TYPE_OBJECT:
				break;

			default:
				assert(false/*NOT_IMPLEMENTED*/);
				break;
			}
		}
	}

	m_bEffectInitialized = true;
}

void CActorInstance::SetWeaponTraceTexture(const char * szTextureName)
{
	std::vector<CWeaponTrace*>::iterator it;
	for (it = m_WeaponTraceVector.begin(); it != m_WeaponTraceVector.end(); ++it)
	{
		(*it)->SetTexture(szTextureName);
	}
}

void CActorInstance::UseTextureWeaponTrace()
{
	for_each(
		m_WeaponTraceVector.begin(),
		m_WeaponTraceVector.end(),
		std::void_mem_fun(&CWeaponTrace::UseTexture)
		);
}

void CActorInstance::UseAlphaWeaponTrace()
{
	for_each(
		m_WeaponTraceVector.begin(),
		m_WeaponTraceVector.end(),
		std::void_mem_fun(&CWeaponTrace::UseAlpha)
		);
}

void CActorInstance::UpdateAttachingInstances()
{
	CEffectManager& rkEftMgr = CEffectManager::Instance();

	std::list<TAttachingEffect>::iterator it;
	DWORD dwCurrentTime = CTimer::Instance().GetCurrentMillisecond();
	for (it = m_AttachingEffectList.begin(); it != m_AttachingEffectList.end()
	{
		if (EFFECT_LIFE_WITH_MOTION == it->iLifeType)
		{
			++it;
			continue;
		}

		if ((EFFECT_LIFE_NORMAL == it->iLifeType && it->dwEndTime < dwCurrentTime) ||
			!rkEftMgr.IsAliveEffect(it->dwEffectIndex))
		{
			rkEftMgr.DestroyEffectInstance(it->dwEffectIndex);
			it = m_AttachingEffectList.erase(it);
		}
		else
		{
			if (it->isAttaching)
			{
				rkEftMgr.SelectEffectInstance(it->dwEffectIndex);

				if (it->iBoneIndex == -1)
				{
					D3DXMATRIX matTransform;
					matTransform = it->matTranslation;
					matTransform *= m_worldMatrix;
					rkEftMgr.SetEffectInstanceGlobalMatrix(matTransform);
				}
				else
				{
					D3DXMATRIX * pBoneMat;
					if (GetBoneMatrix(it->dwModelIndex, it->iBoneIndex, &pBoneMat))
					{
						D3DXMATRIX matTransform;
						matTransform = *pBoneMat;
						matTransform *= it->matTranslation;
						matTransform *= m_worldMatrix;
						rkEftMgr.SetEffectInstanceGlobalMatrix(matTransform);
					}
					else
					{
						//TraceError("GetBoneMatrix(modelIndex(%d), boneIndex(%d)).NOT_FOUND_BONE", 
						//	it->dwModelIndex, it->iBoneIndex);
					}
				}
			}

			++it;
		}
	}
}

void CActorInstance::ShowAllAttachingEffect()
{
	std::list<TAttachingEffect>::iterator it;
	for (it = m_AttachingEffectList.begin(); it != m_AttachingEffectList.end(); ++it)
	{
		CEffectManager::Instance().SelectEffectInstance(it->dwEffectIndex);
		CEffectManager::Instance().ShowEffect();
	}
}

void CActorInstance::HideAllAttachingEffect()
{
	std::list<TAttachingEffect>::iterator it;
	for (it = m_AttachingEffectList.begin(); it != m_AttachingEffectList.end(); ++it)
	{
		CEffectManager::Instance().SelectEffectInstance(it->dwEffectIndex);
		CEffectManager::Instance().HideEffect();
	}
}

void CActorInstance::__ClearAttachingEffect()
{
	m_bEffectInitialized = false;

	std::list<TAttachingEffect>::iterator it;
	for (it = m_AttachingEffectList.begin(); it != m_AttachingEffectList.end(); ++it)
	{
		CEffectManager::Instance().DestroyEffectInstance(it->dwEffectIndex);
	}
	m_AttachingEffectList.clear();
}

PythonNetworkStreamPhaseGameActor.cpp

#include "StdAfx.h"
#include "PythonNetworkStream.h"
#include "NetworkActorManager.h"
#include "PythonBackground.h"

#include "PythonApplication.h"
#include "AbstractPlayer.h"
#include "../gamelib/ActorInstance.h"





void CPythonNetworkStream::__GlobalPositionToLocalPosition(LONG& rGlobalX, LONG& rGlobalY)
{
	CPythonBackground&rkBgMgr=CPythonBackground::Instance();
	rkBgMgr.GlobalPositionToLocalPosition(rGlobalX, rGlobalY);
}

void CPythonNetworkStream::__LocalPositionToGlobalPosition(LONG& rLocalX, LONG& rLocalY)
{
	CPythonBackground&rkBgMgr=CPythonBackground::Instance();
	rkBgMgr.LocalPositionToGlobalPosition(rLocalX, rLocalY);
}

bool CPythonNetworkStream::__CanActMainInstance()
{
	CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
	CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
	if (!pkInstMain)
		return false;

	return pkInstMain->CanAct();
}

void CPythonNetworkStream::__ClearNetworkActorManager()
{
	m_rokNetActorMgr->Destroy();
}

void __SetWeaponPower(IAbstractPlayer& rkPlayer, DWORD dwWeaponID)
{
	DWORD minPower=0;
	DWORD maxPower=0;
	DWORD minMagicPower=0;
	DWORD maxMagicPower=0;
	DWORD addPower=0;

	CItemData* pkWeapon;
	if (CItemManager::Instance().GetItemDataPointer(dwWeaponID, &pkWeapon))
	{
		if (pkWeapon->GetType()==CItemData::ITEM_TYPE_WEAPON)
		{
			minPower=pkWeapon->GetValue(3);
			maxPower=pkWeapon->GetValue(4);
			minMagicPower=pkWeapon->GetValue(1);
			maxMagicPower=pkWeapon->GetValue(2);
			addPower=pkWeapon->GetValue(5);
		}
	}

	rkPlayer.SetWeaponPower(minPower, maxPower, minMagicPower, maxMagicPower, addPower);
}

//Å×ÀÌºí¿¡¼ ÀÌ¸§ÀÌ "." ÀÎ °Íµé
//Â÷ÈÄ¿¡ ¼¹ö¿¡¼ º¸³»ÁÖÁö ¾Ê°Ô µÇ¸é ¾ø¾îÁú ÇÔ¼ö..(¼¹ö´Ô²² ²À!!Çù¹Ú; )
bool IsInvisibleRace(WORD raceNum)
{
	switch(raceNum)
	{
	case 20025:
	case 20038:
	case 20039:
		return true;
	default:
		return false;
	}
}

static SNetworkActorData s_kNetActorData;


bool CPythonNetworkStream::RecvCharacterAppendPacket()
{
	TPacketGCCharacterAdd chrAddPacket;
	if (!Recv(sizeof(chrAddPacket), &chrAddPacket))
		return false;

	__GlobalPositionToLocalPosition(chrAddPacket.x, chrAddPacket.y);

	SNetworkActorData kNetActorData;
	kNetActorData.m_bType=chrAddPacket.bType;
	kNetActorData.m_dwMovSpd=chrAddPacket.bMovingSpeed;
	kNetActorData.m_dwAtkSpd=chrAddPacket.bAttackSpeed;
	kNetActorData.m_dwRace=chrAddPacket.wRaceNum;
	
	kNetActorData.m_dwStateFlags=chrAddPacket.bStateFlag;
	kNetActorData.m_dwVID=chrAddPacket.dwVID;
	kNetActorData.m_fRot=chrAddPacket.angle;

	kNetActorData.m_stName="";

	kNetActorData.m_stName="";
	kNetActorData.m_kAffectFlags.CopyData(0, sizeof(chrAddPacket.dwAffectFlag[0]), &chrAddPacket.dwAffectFlag[0]);
	kNetActorData.m_kAffectFlags.CopyData(32, sizeof(chrAddPacket.dwAffectFlag[1]), &chrAddPacket.dwAffectFlag[1]);
	
	kNetActorData.SetPosition(chrAddPacket.x, chrAddPacket.y);

	kNetActorData.m_sAlignment=0;/*chrAddPacket.sAlignment*/;	
	kNetActorData.m_byPKMode=0;/*chrAddPacket.bPKMode*/;	
	kNetActorData.m_dwGuildID=0;/*chrAddPacket.dwGuild*/;
	kNetActorData.m_dwEmpireID=0;/*chrAddPacket.bEmpire*/;
	kNetActorData.m_dwArmor=0;/*chrAddPacket.awPart[CHR_EQUIPPART_ARMOR]*/;
	kNetActorData.m_dwWeapon=0;/*chrAddPacket.awPart[CHR_EQUIPPART_WEAPON]*/;
	kNetActorData.m_dwHair=0;/*chrAddPacket.awPart[CHR_EQUIPPART_HAIR]*/;	
	kNetActorData.m_dwWing = 0;
	kNetActorData.m_dwMountVnum=0;/*chrAddPacket.dwMountVnum*/;	

	kNetActorData.m_dwLevel = 0; // ¸ó½ºÅÍ ·¹º§ Ç¥½Ã ¾ÈÇÔ

	if(kNetActorData.m_bType != CActorInstance::TYPE_PC && 
		kNetActorData.m_bType != CActorInstance::TYPE_NPC)
	{
		const char * c_szName;
		CPythonNonPlayer& rkNonPlayer=CPythonNonPlayer::Instance();
		if (rkNonPlayer.GetName(kNetActorData.m_dwRace, &c_szName))
			kNetActorData.m_stName = c_szName;
		//else
		//	kNetActorData.m_stName=chrAddPacket.name;

		__RecvCharacterAppendPacket(&kNetActorData);
	}
	else
	{
		s_kNetActorData = kNetActorData;
	}

	return true;
}

bool CPythonNetworkStream::RecvCharacterAdditionalInfo()
{
	TPacketGCCharacterAdditionalInfo chrInfoPacket;
	if (!Recv(sizeof(chrInfoPacket), &chrInfoPacket))
		return false;

	
	SNetworkActorData kNetActorData = s_kNetActorData;
	if (IsInvisibleRace(kNetActorData.m_dwRace))
		return true;

	if(kNetActorData.m_dwVID == chrInfoPacket.dwVID)
	{
		kNetActorData.m_stName = chrInfoPacket.name;
		kNetActorData.m_dwGuildID = chrInfoPacket.dwGuildID;
		kNetActorData.m_dwLevel = chrInfoPacket.dwLevel;
		kNetActorData.m_sAlignment=chrInfoPacket.sAlignment;	
		kNetActorData.m_byPKMode=chrInfoPacket.bPKMode;	
		kNetActorData.m_dwGuildID=chrInfoPacket.dwGuildID;
		kNetActorData.m_dwEmpireID=chrInfoPacket.bEmpire;
		kNetActorData.m_dwArmor=chrInfoPacket.awPart[CHR_EQUIPPART_ARMOR];
		kNetActorData.m_dwWeapon=chrInfoPacket.awPart[CHR_EQUIPPART_WEAPON];
		kNetActorData.m_dwHair=chrInfoPacket.awPart[CHR_EQUIPPART_HAIR];	
		kNetActorData.m_dwWing = chrInfoPacket.awPart[CHR_EQUIPPART_WING];

		kNetActorData.m_dwMountVnum=chrInfoPacket.dwMountVnum;

		__RecvCharacterAppendPacket(&kNetActorData);
	}
	else
	{
		TraceError("TPacketGCCharacterAdditionalInfo name=%s vid=%d race=%d Error",chrInfoPacket.name,chrInfoPacket.dwVID,kNetActorData.m_dwRace);
	}
	return true;
}

bool CPythonNetworkStream::RecvCharacterAppendPacketNew()
{
	TraceError("TPacketGCCharacterAdd2´Â ¾²Áö ¾Ê´Â ÆÐÅ¶ÀÔ´Ï´Ù.");
	TPacketGCCharacterAdd2 chrAddPacket;
	if (!Recv(sizeof(chrAddPacket), &chrAddPacket))
		return false;
	if(IsInvisibleRace(chrAddPacket.wRaceNum))
		return true;

	__GlobalPositionToLocalPosition(chrAddPacket.x, chrAddPacket.y);

	SNetworkActorData kNetActorData;
	kNetActorData.m_dwLevel = 0;
	kNetActorData.m_bType=chrAddPacket.bType;
	kNetActorData.m_dwGuildID=chrAddPacket.dwGuild;
	kNetActorData.m_dwEmpireID=chrAddPacket.bEmpire;	
	kNetActorData.m_dwMovSpd=chrAddPacket.bMovingSpeed;
	kNetActorData.m_dwAtkSpd=chrAddPacket.bAttackSpeed;
	kNetActorData.m_dwRace=chrAddPacket.wRaceNum;
	kNetActorData.m_dwArmor=chrAddPacket.awPart[CHR_EQUIPPART_ARMOR];
	kNetActorData.m_dwWeapon=chrAddPacket.awPart[CHR_EQUIPPART_WEAPON];
	kNetActorData.m_dwHair=chrAddPacket.awPart[CHR_EQUIPPART_HAIR];
	kNetActorData.m_dwWing = chrAddPacket.awPart[CHR_EQUIPPART_WING];
	kNetActorData.m_dwStateFlags=chrAddPacket.bStateFlag;
	kNetActorData.m_dwVID=chrAddPacket.dwVID;
	kNetActorData.m_dwMountVnum=chrAddPacket.dwMountVnum;
	kNetActorData.m_fRot=chrAddPacket.angle;
	kNetActorData.m_kAffectFlags.CopyData(0, sizeof(chrAddPacket.dwAffectFlag[0]), &chrAddPacket.dwAffectFlag[0]);
	kNetActorData.m_kAffectFlags.CopyData(32, sizeof(chrAddPacket.dwAffectFlag[1]), &chrAddPacket.dwAffectFlag[1]);
	kNetActorData.SetPosition(chrAddPacket.x, chrAddPacket.y);
	kNetActorData.m_sAlignment=chrAddPacket.sAlignment;
	kNetActorData.m_byPKMode=chrAddPacket.bPKMode;
	kNetActorData.m_stName=chrAddPacket.name;
	__RecvCharacterAppendPacket(&kNetActorData);

	return true;
}

bool CPythonNetworkStream::RecvCharacterUpdatePacket()
{
	TPacketGCCharacterUpdate chrUpdatePacket;
	if (!Recv(sizeof(chrUpdatePacket), &chrUpdatePacket))
		return false;

	SNetworkUpdateActorData kNetUpdateActorData;
	kNetUpdateActorData.m_dwGuildID=chrUpdatePacket.dwGuildID;
	kNetUpdateActorData.m_dwMovSpd=chrUpdatePacket.bMovingSpeed;
	kNetUpdateActorData.m_dwAtkSpd=chrUpdatePacket.bAttackSpeed;
	kNetUpdateActorData.m_dwArmor=chrUpdatePacket.awPart[CHR_EQUIPPART_ARMOR];
	kNetUpdateActorData.m_dwWeapon=chrUpdatePacket.awPart[CHR_EQUIPPART_WEAPON];
	kNetUpdateActorData.m_dwHair=chrUpdatePacket.awPart[CHR_EQUIPPART_HAIR];
	kNetUpdateActorData.m_dwWing = chrUpdatePacket.awPart[CHR_EQUIPPART_WING];
	kNetUpdateActorData.m_dwVID=chrUpdatePacket.dwVID;	
	kNetUpdateActorData.m_kAffectFlags.CopyData(0, sizeof(chrUpdatePacket.dwAffectFlag[0]), &chrUpdatePacket.dwAffectFlag[0]);
	kNetUpdateActorData.m_kAffectFlags.CopyData(32, sizeof(chrUpdatePacket.dwAffectFlag[1]), &chrUpdatePacket.dwAffectFlag[1]);
	kNetUpdateActorData.m_sAlignment=chrUpdatePacket.sAlignment;
	kNetUpdateActorData.m_byPKMode=chrUpdatePacket.bPKMode;
	kNetUpdateActorData.m_dwStateFlags=chrUpdatePacket.bStateFlag;
	kNetUpdateActorData.m_dwMountVnum=chrUpdatePacket.dwMountVnum;
	__RecvCharacterUpdatePacket(&kNetUpdateActorData);

	return true;
}

bool CPythonNetworkStream::RecvCharacterUpdatePacketNew()
{
	TPacketGCCharacterUpdate2 chrUpdatePacket;
	if (!Recv(sizeof(chrUpdatePacket), &chrUpdatePacket))
		return false;

	SNetworkUpdateActorData kNetUpdateActorData;
	kNetUpdateActorData.m_dwGuildID=chrUpdatePacket.dwGuildID;
	kNetUpdateActorData.m_dwMovSpd=chrUpdatePacket.bMovingSpeed;
	kNetUpdateActorData.m_dwAtkSpd=chrUpdatePacket.bAttackSpeed;
	kNetUpdateActorData.m_dwArmor=chrUpdatePacket.awPart[CHR_EQUIPPART_ARMOR];
	kNetUpdateActorData.m_dwWeapon=chrUpdatePacket.awPart[CHR_EQUIPPART_WEAPON];
	kNetUpdateActorData.m_dwHair=chrUpdatePacket.awPart[CHR_EQUIPPART_HAIR];
	kNetUpdateActorData.m_dwWing = chrUpdatePacket.awPart[CHR_EQUIPPART_WING];
	kNetUpdateActorData.m_dwVID=chrUpdatePacket.dwVID;
	kNetUpdateActorData.m_kAffectFlags.CopyData(0, sizeof(chrUpdatePacket.dwAffectFlag[0]), &chrUpdatePacket.dwAffectFlag[0]);
	kNetUpdateActorData.m_kAffectFlags.CopyData(32, sizeof(chrUpdatePacket.dwAffectFlag[1]), &chrUpdatePacket.dwAffectFlag[1]);
	kNetUpdateActorData.m_sAlignment=chrUpdatePacket.sAlignment;
	kNetUpdateActorData.m_byPKMode=chrUpdatePacket.bPKMode;
	kNetUpdateActorData.m_dwStateFlags=chrUpdatePacket.bStateFlag;
	kNetUpdateActorData.m_dwMountVnum=chrUpdatePacket.dwMountVnum;
	__RecvCharacterUpdatePacket(&kNetUpdateActorData);

	return true;
}

void CPythonNetworkStream::__RecvCharacterAppendPacket(SNetworkActorData * pkNetActorData)
{
	// NOTE : Ä«¸Þ¶ó°¡ ¶¥¿¡ ¹¯È÷´Â ¹®Á¦ÀÇ ÇØ°áÀ» À§ÇØ ¸ÞÀÎ Ä³¸¯ÅÍ°¡ ÁöÇü¿¡ ¿Ã·ÁÁö±â
	//        Àü¿¡ ¸ÊÀ» ¾÷µ¥ÀÌÆ® ÇØ ³ôÀÌ¸¦ ±¸ÇÒ ¼ö ÀÖµµ·Ï ÇØ³õ¾Æ¾ß ÇÕ´Ï´Ù.
	//        ´Ü, °ÔÀÓÀÌ µé¾î°¥¶§°¡ ¾Æ´Ñ ÀÌ¹Ì Ä³¸¯ÅÍ°¡ Ãß°¡ µÈ ÀÌÈÄ¿¡¸¸ ÇÕ´Ï´Ù.
	//        Çåµ¥ ÀÌµ¿ÀÎµ¥ ¿Ö Move·Î ¾ÈÇÏ°í Append·Î ÇÏ´ÂÁö..? - [levites]
	IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton();
	if (rkPlayer.IsMainCharacterIndex(pkNetActorData->m_dwVID))
	{
		rkPlayer.SetRace(pkNetActorData->m_dwRace);

		__SetWeaponPower(rkPlayer, pkNetActorData->m_dwWeapon);

		if (rkPlayer.NEW_GetMainActorPtr())
		{
			CPythonBackground::Instance().Update(pkNetActorData->m_lCurX, pkNetActorData->m_lCurY, 0.0f);
			CPythonCharacterManager::Instance().Update();

			// NOTE : »ç±Í Å¸¿öÀÏ °æ¿ì GOTO ·Î ÀÌµ¿½Ã¿¡µµ ¸Ê ÀÌ¸§À» Ãâ·ÂÇÏµµ·Ï Ã³¸®
			{
				std::string strMapName = CPythonBackground::Instance().GetWarpMapName();
				if (strMapName == "metin2_map_deviltower1")
					__ShowMapName(pkNetActorData->m_lCurX, pkNetActorData->m_lCurY);
			}
		}
		else
		{
			__ShowMapName(pkNetActorData->m_lCurX, pkNetActorData->m_lCurY);
		}
	}

	m_rokNetActorMgr->AppendActor(*pkNetActorData);

	if (GetMainActorVID()==pkNetActorData->m_dwVID)
	{
		rkPlayer.SetTarget(0);
		if (m_bComboSkillFlag)
			rkPlayer.SetComboSkillFlag(m_bComboSkillFlag);

		__SetGuildID(pkNetActorData->m_dwGuildID);
		//CPythonApplication::Instance().SkipRenderBuffering(10000);
	}
}

void CPythonNetworkStream::__RecvCharacterUpdatePacket(SNetworkUpdateActorData * pkNetUpdateActorData)
{
	m_rokNetActorMgr->UpdateActor(*pkNetUpdateActorData);

	IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton();
	if (rkPlayer.IsMainCharacterIndex(pkNetUpdateActorData->m_dwVID))
	{
		__SetGuildID(pkNetUpdateActorData->m_dwGuildID);
		__SetWeaponPower(rkPlayer, pkNetUpdateActorData->m_dwWeapon);

		__RefreshStatus();
		__RefreshAlignmentWindow();
		__RefreshEquipmentWindow();
		__RefreshInventoryWindow();
	}
	else
	{
		rkPlayer.NotifyCharacterUpdate(pkNetUpdateActorData->m_dwVID);
	}
}

bool CPythonNetworkStream::RecvCharacterDeletePacket()
{
	TPacketGCCharacterDelete chrDelPacket;

	if (!Recv(sizeof(chrDelPacket), &chrDelPacket))
	{
		TraceError("CPythonNetworkStream::RecvCharacterDeletePacket - Recv Error");
		return false;
	}

	m_rokNetActorMgr->RemoveActor(chrDelPacket.dwVID);

	// Ä³¸¯ÅÍ°¡ »ç¶óÁú¶§ °³ÀÎ »óÁ¡µµ ¾ø¾ÖÁÝ´Ï´Ù.
	// Key Check ¸¦ ÇÏ±â¶§¹®¿¡ ¾ø¾îµµ »ó°üÀº ¾ø½À´Ï´Ù.
	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], 
		"BINARY_PrivateShop_Disappear", 
		Py_BuildValue("(i)", chrDelPacket.dwVID)
	);

	return true;
}


bool CPythonNetworkStream::RecvCharacterMovePacket()
{
	TPacketGCMove kMovePacket;
	if (!Recv(sizeof(TPacketGCMove), &kMovePacket))
	{
		Tracen("CPythonNetworkStream::RecvCharacterMovePacket - PACKET READ ERROR");
		return false;
	}

	__GlobalPositionToLocalPosition(kMovePacket.lX, kMovePacket.lY);

	SNetworkMoveActorData kNetMoveActorData;
	kNetMoveActorData.m_dwArg=kMovePacket.bArg;
	kNetMoveActorData.m_dwFunc=kMovePacket.bFunc;
	kNetMoveActorData.m_dwTime=kMovePacket.dwTime;
	kNetMoveActorData.m_dwVID=kMovePacket.dwVID;
	kNetMoveActorData.m_fRot=kMovePacket.bRot*5.0f;
	kNetMoveActorData.m_lPosX=kMovePacket.lX;
	kNetMoveActorData.m_lPosY=kMovePacket.lY;
	kNetMoveActorData.m_dwDuration=kMovePacket.dwDuration;

	m_rokNetActorMgr->MoveActor(kNetMoveActorData);

	return true;
}

bool CPythonNetworkStream::RecvOwnerShipPacket()
{
	TPacketGCOwnership kPacketOwnership;

	if (!Recv(sizeof(kPacketOwnership), &kPacketOwnership))
		return false;

	m_rokNetActorMgr->SetActorOwner(kPacketOwnership.dwOwnerVID, kPacketOwnership.dwVictimVID);

	return true;
}

bool CPythonNetworkStream::RecvSyncPositionPacket()
{
	TPacketGCSyncPosition kPacketSyncPos;
	if (!Recv(sizeof(kPacketSyncPos), &kPacketSyncPos))
		return false;

	TPacketGCSyncPositionElement kSyncPos;

	UINT uSyncPosCount=(kPacketSyncPos.wSize-sizeof(kPacketSyncPos))/sizeof(kSyncPos);
	for (UINT iSyncPos=0; iSyncPos<uSyncPosCount; ++iSyncPos)
	{		
		if (!Recv(sizeof(TPacketGCSyncPositionElement), &kSyncPos))
			return false;

#ifdef __MOVIE_MODE__
		return true;
#endif __MOVIE_MODE__

		//Tracenf("CPythonNetworkStream::RecvSyncPositionPacket %d (%d, %d)", kSyncPos.dwVID, kSyncPos.lX, kSyncPos.lY);

		__GlobalPositionToLocalPosition(kSyncPos.lX, kSyncPos.lY);
		m_rokNetActorMgr->SyncActor(kSyncPos.dwVID, kSyncPos.lX, kSyncPos.lY);

		/*
		CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
		CInstanceBase * pkChrInst = rkChrMgr.GetInstancePtr(kSyncPos.dwVID);

		if (pkChrInst)
		{			
			pkChrInst->NEW_SyncPixelPosition(kSyncPos.lX, kSyncPos.lY);		
		}
		*/
}

	return true;
}


/*
bool CPythonNetworkStream::RecvCharacterAppendPacket()
{
	TPacketGCCharacterAdd chrAddPacket;

	if (!Recv(sizeof(chrAddPacket), &chrAddPacket))
		return false;

	__GlobalPositionToLocalPosition(chrAddPacket.lX, chrAddPacket.lY);

	SNetworkActorData kNetActorData;
	kNetActorData.m_dwGuildID=chrAddPacket.dwGuild;
	kNetActorData.m_dwEmpireID=chrAddPacket.bEmpire;
	kNetActorData.m_dwMovSpd=chrAddPacket.bMovingSpeed;
	kNetActorData.m_dwAtkSpd=chrAddPacket.bAttackSpeed;
	kNetActorData.m_dwRace=chrAddPacket.wRaceNum;
	kNetActorData.m_dwShape=chrAddPacket.parts[CRaceData::PART_MAIN];
	kNetActorData.m_dwStateFlags=chrAddPacket.bStateFlag;
	kNetActorData.m_dwVID=chrAddPacket.dwVID;
	kNetActorData.m_dwWeapon=chrAddPacket.parts[CRaceData::PART_WEAPON];
	kNetActorData.m_fRot=chrAddPacket.angle;
	kNetActorData.m_kAffectFlags.CopyData(0, sizeof(chrAddPacket.dwAffectFlag[0]), &chrAddPacket.dwAffectFlag[0]);
	kNetActorData.m_kAffectFlags.CopyData(32, sizeof(chrAddPacket.dwAffectFlag[1]), &chrAddPacket.dwAffectFlag[1]);
	kNetActorData.SetPosition(chrAddPacket.lX, chrAddPacket.lY);
	kNetActorData.m_stName=chrAddPacket.name;
	__RecvCharacterAppendPacket(&kNetActorData);
	return true;
}
*/

In ItemData.cpp search the Getter function :

BOOL CItemData::IsEquipment() const

Replace the function by that:

BOOL CItemData::IsEquipment() const
{
	switch (GetType())
	{
		case ITEM_TYPE_USE:
			if (GetSubType() == ITEM_TYPE_SPECIAL){
				switch (m_ItemTable.dwVnum){
				case 85001:
				case 85002:
				case 85003:
				case 85004:
				case 85005:
				case 85006:
				case 85007:
				case 85008:
				case 85009:
				case 85010:
				case 85011:
				case 85012:
				case 85013:
				case 85014:
				case 85015:
				case 85016:
					return TRUE;

				}

			}
			break;
		case ITEM_TYPE_WEAPON:
		case ITEM_TYPE_ARMOR:
			return TRUE;
			break;
	}

	return FALSE;
}

And now open PythonCharacterModule.cpp

replace the function :

PyObject * chrCreateInstance(PyObject* poSelf, PyObject* poArgs)

by that:

PyObject * chrCreateInstance(PyObject* poSelf, PyObject* poArgs)
{
    int iVirtualID;
    if (!PyTuple_GetInteger(poArgs, 0, &iVirtualID))
        return Py_BuildException();


    if (PyTuple_Size(poArgs)==2)
    {
        PyObject* poDict=PyTuple_GetItem(poArgs, 1);
        if (!PyDict_Check(poDict))
            return Py_BuildException();


        CInstanceBase::SCreateData kCreateData;
        kCreateData.m_bType=CActorInstance::TYPE_PC;
        kCreateData.m_dwLevel = 0;
        kCreateData.m_dwGuildID=0;
        kCreateData.m_dwEmpireID=0;
        kCreateData.m_dwVID=iVirtualID;
        kCreateData.m_dwMountVnum=0;
        kCreateData.m_dwRace=0;
        kCreateData.m_fRot=CInstanceBase::DIR_NORTH;
        kCreateData.m_lPosX=0;
        kCreateData.m_lPosY=0;
        kCreateData.m_stName="NONAME";
        kCreateData.m_dwStateFlags=0;
        kCreateData.m_dwMovSpd=100;
        kCreateData.m_dwAtkSpd=100;
        kCreateData.m_sAlignment=0;
        kCreateData.m_byPKMode=0;
        kCreateData.m_kAffectFlags.Clear();
        kCreateData.m_dwArmor=8;
        kCreateData.m_dwWeapon=0;
        kCreateData.m_dwHair=0;
        kCreateData.m_dwWing = 0;
        kCreateData.m_isMain=false;


        PyObject* poHorse=PyDict_GetItemString(poDict, "horse");
        if (poHorse)
            kCreateData.m_dwMountVnum=PyLong_AsLong(poHorse);


        PyObject* poX=PyDict_GetItemString(poDict, "x");
        if (poX)
            kCreateData.m_lPosX=PyLong_AsLong(poX);


        PyObject* poY=PyDict_GetItemString(poDict, "y");
        if (poY)
            kCreateData.m_lPosX=PyLong_AsLong(poY);


        CPythonCharacterManager::Instance().CreateInstance(kCreateData);
    }
    else
    {
        CPythonCharacterManager::Instance().RegisterInstance(iVirtualID);
    }


    return Py_BuildNone();
}

In NetworkActorManager.cpp

search this function:

void CNetworkActorManager::UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData)

and replace it by:

void CNetworkActorManager::UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData)
{
	std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(c_rkNetUpdateActorData.m_dwVID);
	if (m_kNetActorDict.end()==f)
	{
#ifdef _DEBUG
		TraceError("CNetworkActorManager::UpdateActor(dwVID=%d) - NOT EXIST VID", c_rkNetUpdateActorData.m_dwVID);
#endif
		return;
	}

	SNetworkActorData& rkNetActorData=f->second;

	CInstanceBase* pkInstFind=__FindActor(rkNetActorData);
	if (pkInstFind)
	{
		pkInstFind->ChangeArmor(c_rkNetUpdateActorData.m_dwArmor);		
		pkInstFind->ChangeWeapon(c_rkNetUpdateActorData.m_dwWeapon);
		pkInstFind->ChangeHair(c_rkNetUpdateActorData.m_dwHair);		
		pkInstFind->ChangeWing(c_rkNetUpdateActorData.m_dwWing);
		pkInstFind->ChangeGuild(c_rkNetUpdateActorData.m_dwGuildID);
		pkInstFind->SetAffectFlagContainer(c_rkNetUpdateActorData.m_kAffectFlags);
		pkInstFind->SetMoveSpeed(c_rkNetUpdateActorData.m_dwMovSpd);
		pkInstFind->SetAttackSpeed(c_rkNetUpdateActorData.m_dwAtkSpd);
		pkInstFind->SetAlignment(c_rkNetUpdateActorData.m_sAlignment);
		pkInstFind->SetPKMode(c_rkNetUpdateActorData.m_byPKMode);
		pkInstFind->SetStateFlags(c_rkNetUpdateActorData.m_dwStateFlags);

		//if( c_rkNetUpdateActorData.m_dwMountVnum != 0 )
		//{
		//	pkInstFind->MountHorse(c_rkNetUpdateActorData.m_dwMountVnum);
		//}
		//else
		//{
		//	if( pkInstFind->IsMountingHorse() )
		//	{
		//		pkInstFind->DismountHorse();
		//	}
		//}
	}

	rkNetActorData.m_kAffectFlags=c_rkNetUpdateActorData.m_kAffectFlags;
	rkNetActorData.m_dwGuildID=c_rkNetUpdateActorData.m_dwGuildID;
	//rkNetActorData.m_dwLevel=c_rkNetUpdateActorData.m_dwLevel;
	rkNetActorData.m_dwMovSpd=c_rkNetUpdateActorData.m_dwMovSpd;
	rkNetActorData.m_dwAtkSpd=c_rkNetUpdateActorData.m_dwAtkSpd;
	rkNetActorData.m_dwArmor=c_rkNetUpdateActorData.m_dwArmor;
	rkNetActorData.m_dwWeapon=c_rkNetUpdateActorData.m_dwWeapon;
	rkNetActorData.m_dwHair=c_rkNetUpdateActorData.m_dwHair;
        rkNetActorData.m_dwWing=c_rkNetUpdateActorData.m_dwWing;
	rkNetActorData.m_sAlignment=c_rkNetUpdateActorData.m_sAlignment;
	rkNetActorData.m_byPKMode=c_rkNetUpdateActorData.m_byPKMode;
}

void CNetworkActorManager::MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData)
{
	std::map<DWORD, SNetworkActorData>::iterator f=m_kNetActorDict.find(c_rkNetMoveActorData.m_dwVID);
	if (m_kNetActorDict.end()==f)
	{
#ifdef _DEBUG
		TraceError("CNetworkActorManager::MoveActor(dwVID=%d) - NOT EXIST VID", c_rkNetMoveActorData.m_dwVID);
#endif
		return;
	}

	SNetworkActorData& rkNetActorData=f->second;

	CInstanceBase* pkInstFind=__FindActor(rkNetActorData, c_rkNetMoveActorData.m_lPosX, c_rkNetMoveActorData.m_lPosY);
	if (pkInstFind)
	{
		TPixelPosition kPPosDst;
		kPPosDst.x=float(c_rkNetMoveActorData.m_lPosX);
		kPPosDst.y=float(c_rkNetMoveActorData.m_lPosY);
		kPPosDst.z=0.0f;

		pkInstFind->PushTCPState(c_rkNetMoveActorData.m_dwTime, kPPosDst, 
			c_rkNetMoveActorData.m_fRot, c_rkNetMoveActorData.m_dwFunc, c_rkNetMoveActorData.m_dwArg);	
	}

	rkNetActorData.SetDstPosition(c_rkNetMoveActorData.m_dwTime,
		c_rkNetMoveActorData.m_lPosX, c_rkNetMoveActorData.m_lPosY, c_rkNetMoveActorData.m_dwDuration);
	rkNetActorData.m_fRot=c_rkNetMoveActorData.m_fRot;		
}

-PythonCharacterModule.cpp

Search :

PyModule_AddIntConstant(poModule, "PART_HEAD", CRaceData::PART_HEAD);

Add after that

PyModule_AddIntConstant(poModule, "PART_WING", CRaceData::PART_WING);

In playersettingmodule.py of root

Add on all LoadRace

chrmgr.RegisterAttachingBoneName(chr.PART_WING, "equip_right_hand")

equip_right_hand is an example you can add other Bone for attach the Sash item.

And now MSM code , you need add it on all msm of race character:

Group WingData
{
	PathName	"d:/Ymir Work/item/wing/"	
	WingDataCount 			10

	Group WingData00
	{	
		WingIndex			19465
		Model				"wing1.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData01
	{	
		WingIndex			19466
		Model				"acce_01_85_002.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData02
	{	
		WingIndex			19467
		Model				"acce_01_85_003.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData03
	{	
		WingIndex			19468
		Model				"acce_01_85_003.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData04
	{	
		WingIndex			19469
		Model				"acce_01_85_004.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData05
	{	
		WingIndex			19470
		Model				"acce_02_85_005.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData06
	{	
		WingIndex			19471
		Model				"acce_02_85_006.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData07
	{	
		WingIndex			19472
		Model				"acce_02_85_007.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData08
	{	
		WingIndex			19473
		Model				"acce_02_85_008.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}
	Group WingData09
	{	
		WingIndex			85001
		Model				"wing1.gr2"
		SourceSkin			"wingtexture.dds"
		TargetSkin			"wingtexture.dds"
	}	
}

Now the result Ingame:

Ah yes I forgot the uiscript file and root file

The link:

http://softyou.net/produit/sash_system.tgz

Model link:

http://softyou.net/produit/UpdateSash.tgz

This system is made quickly, if you want New System who not exist or Game Files you can contact me

At my skype: roxasledieutoutpuissant

You can see more information of my market in my website: http://softyou.net

Have a fun

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

Xynjo · June 5, 2015

thanks you its rlly nice release !!! yee

Roxas07 · June 5, 2015

No problem if you need perfect files go to my other post of my market:

Shisui · June 5, 2015

Can you edit your post and add spoilers?

It will be easy 2read and understand.

M&M · June 5, 2015

Nice job next quest = wolfman

Roxas07 · June 5, 2015

You can add the msm part for Wolfman

Roxas07 · June 5, 2015

Up, I prepare the combinaison System of the sash system, this system of combinaison is not free.

Follow my market post :

AlexxD · June 5, 2015

This isn't complete man.. You created the codes for Attach wings on players, but void codes for compiling the new launcher?

Take a look on that.. Also, good work. Thanks for post it, but take a look on it.

Roxas07 · June 5, 2015

Up I forgot something:

-PythonCharacterModule.cpp

Search :

PyModule_AddIntConstant(poModule, "PART_HEAD", CRaceData::PART_HEAD);

Add after that

PyModule_AddIntConstant(poModule, "PART_WING", CRaceData::PART_WING);

In playersettingmodule.py of root

Add on all LoadRace

chrmgr.RegisterAttachingBoneName(chr.PART_WING, "equip_right_hand")

equip_right_hand is an example you can add other Bone for attach the Sash item.

ahynoa · June 5, 2015

help

0605 12:25:27254 :: Failed to load script file : UIScript/CostumeWindow.py

0605 12:25:27255 ::

ui.py(line:2778) LoadScriptFile

system.py(line:192) execfile

system.py(line:163) Run

UIScript/CostumeWindow.py(line:6) <module>

LoadScriptFile!!!!!!!!!!!!!! - <type 'exceptions.AttributeError'>:'module' object has no attribute 'COSTUME_MOUNT_SLOT_START'

0605 12:25:27255 :: ============================================================================================================

0605 12:25:27255 :: Abort!!!!

0605 12:25:27255 ::

uiInventory.py(line:68) __LoadWindow

ui.py(line:2795) LoadScriptFile

exception.py(line:36) Abort

CostumeWindow.LoadWindow.LoadObject - <type 'exceptions.SystemExit'>:

0605 12:25:27255 :: ============================================================================================================

0605 12:25:27255 :: Abort!!!!

Roxas07 · June 5, 2015

Open PythonItemModule.cpp

replace the Costume Part slot

by that:

#ifdef ENABLE_COSTUME_SYSTEM
PyModule_AddIntConstant(poModule, "ITEM_TYPE_COSTUME", CItemData::ITEM_TYPE_COSTUME);


// Item Sub Type
PyModule_AddIntConstant(poModule, "COSTUME_TYPE_BODY", CItemData::COSTUME_BODY);
PyModule_AddIntConstant(poModule, "COSTUME_TYPE_HAIR", CItemData::COSTUME_HAIR);
PyModule_AddIntConstant(poModule, "COSTUME_TYPE_MOUNT", CItemData::USE_SPECIAL);


// ÀÎº¥Åä¸® ¹× ÀåºñÃ¢¿¡¼ÀÇ ½½·Ô ¹øÈ£
PyModule_AddIntConstant(poModule, "COSTUME_SLOT_START", c_Costume_Slot_Start);
PyModule_AddIntConstant(poModule, "COSTUME_SLOT_COUNT", c_Costume_Slot_Count);
PyModule_AddIntConstant(poModule, "COSTUME_SLOT_BODY", c_Costume_Slot_Body);
PyModule_AddIntConstant(poModule, "COSTUME_SLOT_HAIR", c_Costume_Slot_Hair);
PyModule_AddIntConstant(poModule, "COSTUME_MOUNT_SLOT_START", c_Costume_Mount_Slot_Start);
PyModule_AddIntConstant(poModule, "COSTUME_MOUNT_SLOT_COUNT", c_Costume_Mount_Slot_Count);
PyModule_AddIntConstant(poModule, "COSTUME_SLOT_MOUNT", c_Costume_Mount_Slot_Shoulder);
PyModule_AddIntConstant(poModule, "COSTUME_MOUNT_SLOT_END", c_Costume_Mount_Slot_End);
PyModule_AddIntConstant(poModule, "COSTUME_SLOT_END", c_Costume_Slot_End);
#endif

Open GameType.h

add after the #ifdef ENABLE_COSTUME_SYSTEM #endinf that:

#ifdef ENABLE_MOUNT_COSTUME_SYSTEM
const DWORD c_Costume_Mount_Slot_Start = c_Equipment_Start + 24; // [ÁÖÀÇ] ¼ýÀÚ(19) ÇÏµåÄÚµù ÁÖÀÇ. ÇöÀç ¼¹ö¿¡¼ ÄÚ½ºÃõ ½½·ÔÀº 19ºÎÅÍÀÓ. ¼¹ö common/length.h ÆÄÀÏÀÇ EWearPositions ¿°ÅÇü Âü°í.
const DWORD c_Costume_Mount_Slot_Shoulder = c_Costume_Slot_Start + 0;
const DWORD c_Costume_Mount_Slot_Count = 1;
const DWORD c_Costume_Mount_Slot_End = c_Costume_Mount_Slot_Start + c_Costume_Mount_Slot_Count;
#endif

AlexxD · June 5, 2015

InstantBase.cpp part?

*playersettingmodule.py = SetWing module syserr*

Xynjo · June 5, 2015

#pragma once
#include "InstanceBase.h"

struct SNetworkActorData
{
	std::string m_stName;
	
	CAffectFlagContainer	m_kAffectFlags;

	BYTE	m_bType;
	DWORD	m_dwVID;
	DWORD	m_dwStateFlags;
	DWORD	m_dwEmpireID;
	DWORD	m_dwRace;
	DWORD	m_dwMovSpd;
	DWORD	m_dwAtkSpd;
	FLOAT	m_fRot;
	LONG	m_lCurX;
	LONG	m_lCurY;
	LONG	m_lSrcX;
	LONG	m_lSrcY;
	LONG	m_lDstX;
	LONG	m_lDstY;
	

	DWORD	m_dwServerSrcTime;
	DWORD	m_dwClientSrcTime;
	DWORD	m_dwDuration;

	DWORD	m_dwArmor;
	DWORD	m_dwWeapon;
	DWORD	m_dwHair;
	DWORD	m_dwWing;

	DWORD	m_dwOwnerVID;

	short	m_sAlignment;
	BYTE	m_byPKMode;
	DWORD	m_dwMountVnum;

	DWORD	m_dwGuildID;
	DWORD	m_dwLevel;
	
	SNetworkActorData();

	void SetDstPosition(DWORD dwServerTime, LONG lDstX, LONG lDstY, DWORD dwDuration);
	void SetPosition(LONG lPosX, LONG lPosY);
	void UpdatePosition();	

	// NETWORK_ACTOR_DATA_COPY
	SNetworkActorData(const SNetworkActorData& src);
	void operator=(const SNetworkActorData& src);
	void __copy__(const SNetworkActorData& src);	
	// END_OF_NETWORK_ACTOR_DATA_COPY
};

struct SNetworkMoveActorData
{
	DWORD	m_dwVID;
	DWORD	m_dwTime;
	LONG	m_lPosX;
	LONG	m_lPosY;
	float	m_fRot;
	DWORD	m_dwFunc;
	DWORD	m_dwArg;
	DWORD	m_dwDuration;

	SNetworkMoveActorData()
	{
		m_dwVID=0;
		m_dwTime=0;
		m_fRot=0.0f;
		m_lPosX=0;
		m_lPosY=0;
		m_dwFunc=0;
		m_dwArg=0;
		m_dwDuration=0;
	}
};

struct SNetworkUpdateActorData
{
	DWORD m_dwVID;
	DWORD m_dwGuildID;
	DWORD m_dwArmor;
	DWORD m_dwWeapon;
	DWORD m_dwHair;
	DWORD m_dwWing;
	DWORD m_dwMovSpd;
	DWORD m_dwAtkSpd;
	short m_sAlignment;
	BYTE m_byPKMode;
	DWORD m_dwMountVnum;
	DWORD m_dwStateFlags; // º»·¡ Create ¶§¸¸ ¾²ÀÌ´Â º¯¼öÀÓ
	CAffectFlagContainer m_kAffectFlags;

	SNetworkUpdateActorData()
	{
		m_dwGuildID=0;
		m_dwVID=0;
		m_dwArmor=0;
		m_dwWeapon=0;
		m_dwHair=0;
		m_dwMovSpd=0;
		m_dwAtkSpd=0;
		m_sAlignment=0;
		m_byPKMode=0;
		m_dwMountVnum=0;
		m_dwStateFlags=0;
		m_kAffectFlags.Clear();
	}
};

class CPythonCharacterManager;

class CNetworkActorManager : public CReferenceObject
{
	public:
		CNetworkActorManager();
		virtual ~CNetworkActorManager();

		void Destroy();

		void SetMainActorVID(DWORD dwVID);

		void RemoveActor(DWORD dwVID);
		void AppendActor(const SNetworkActorData& c_rkNetActorData);
		void UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData);
		void MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData);

		void SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY);
		void SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID);

		void Update();

	protected:
		void __OLD_Update();

		void __UpdateMainActor();

		bool __IsVisiblePos(LONG lPosX, LONG lPosY);
		bool __IsVisibleActor(const SNetworkActorData& c_rkNetActorData);
		bool __IsMainActorVID(DWORD dwVID);

		void __RemoveAllGroundItems();
		void __RemoveAllActors();
		void __RemoveDynamicActors();
		void __RemoveCharacterManagerActor(SNetworkActorData& rkNetActorData);

		SNetworkActorData* __FindActorData(DWORD dwVID);

		CInstanceBase* __AppendCharacterManagerActor(SNetworkActorData& rkNetActorData);
		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData);
		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData, LONG lDstX, LONG lDstY);

		CPythonCharacterManager& __GetCharacterManager();

	protected:
		DWORD m_dwMainVID;

		LONG m_lMainPosX;
		LONG m_lMainPosY;

		std::map<DWORD, SNetworkActorData> m_kNetActorDict;
};

WHERE I PUT THIS ? -.-

Roxas07 · June 5, 2015

In NetworkActorManager.h

Roxas07 · June 5, 2015

InstantBase.cpp part?

*playersettingmodule.py = SetWing module syserr*

Add void SetWing(DWORD eWing); in InstanceBase.h

AlexxD · June 5, 2015

At least, if you add SetWing to InstantBase.cpp then armor will not shown on you. Even shoulder.. you're 'nude', on metin.

EisTee · June 5, 2015

When i want compile the binary src there come me this error https://metin2.download/picture/r3F9504x09DVmF8K988YXgTtGTP6KMUj/.gif

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

Roxas07 · June 5, 2015

I rewrite the post, wait a moment please.

Roxas07 · June 5, 2015

At least, if you add SetWing to InstantBase.cpp then armor will not shown on you. Even shoulder.. you're 'nude', on metin.

Open WeaponTrace.h and add

bool SetWingInstance(CGraphicThingInstance * pInstance, DWORD dwModelIndex, const char * c_szBoneName);

Open WeaponTrace.cpp and add

bool CWeaponTrace::SetWingInstance(CGraphicThingInstance * pInstance, DWORD dwModelIndex, const char * c_szBoneName)
{
pInstance->Update();
pInstance->DeformNoSkin();


D3DXVECTOR3 v3Min;
D3DXVECTOR3 v3Max;
if (!pInstance->GetBoundBox(dwModelIndex, &v3Min, &v3Max))
return false;


m_iBoneIndex = 0;
m_dwModelInstanceIndex = dwModelIndex;


m_pInstance = pInstance;
D3DXMATRIX * pmat;
pInstance->GetBoneMatrix(dwModelIndex, 0, &pmat);
D3DXVECTOR3 v3Bone(pmat->_41, pmat->_42, pmat->_43);


m_fLength =
sqrtf(
fMAX(
D3DXVec3LengthSq(&(v3Bone - v3Min)),
D3DXVec3LengthSq(&(v3Bone - v3Max))
)
);


return true;
}

Do not forgot the playermodulesetting.py part

Roxas07 · June 5, 2015

Do not forgot to add WEAR_SHOULDER on the ItemData.h file

                 enum EWearPositions
		{
			WEAR_BODY,          // 0
			WEAR_HEAD,          // 1
			WEAR_FOOTS,         // 2
			WEAR_WRIST,         // 3
			WEAR_WEAPON,        // 4
			WEAR_NECK,          // 5
			WEAR_EAR,           // 6
			WEAR_UNIQUE1,       // 7
			WEAR_UNIQUE2,       // 8
			WEAR_ARROW,         // 9
			WEAR_SHIELD,        // 10
			WEAR_SHOULDER,
			WEAR_MAX_NUM,
		};

Shisui · June 5, 2015

Thanks for adding spoilers and releasing this as well.

Good luck.

Roxas07 · June 5, 2015

No problem Shisui

Xynjo · June 5, 2015

i have problem only in files of packpage race msm code and add patch : ((

who has some free time and a desire to help? Teamviewer Thanks

Edited June 5, 2015 by Xynjo

Roxas07 · June 6, 2015

Tomorrow I share for you all GR2 for resolv scalling problem.

phayara · June 6, 2015

Only 40% complete but thank you.

Kind Regards,

Accelerator

Sign In

[ Dead Download Link ] [C++] Release Shoulder System Not Official [ We Need You ]

Recommended Posts

Roxas07 257

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Popular Posts

Roxas07

Roxas07

EisTee

Xynjo 3

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

Shisui 536

Link to comment

Share on other sites

M&M 24

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

AlexxD 161

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

ahynoa 15

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

AlexxD 161

Link to comment

Share on other sites

Xynjo 3

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

AlexxD 161

Link to comment

Share on other sites

EisTee 5

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

Shisui 536

Link to comment

Share on other sites

Roxas07 257

Link to comment

Share on other sites

Xynjo 3

Link to comment

Share on other sites