Jump to content

Roxas07

Banned
 View Profile  See their activity

  • Posts

    101

  • Joined

  • Last visited

  • Days Won

    9

  • Feedback

    0%

 Content Type 

Forums

Store

Third Party - Providers Directory

Feature Plan

Release Notes

Docs

Events

Posts posted by Roxas07

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

    in Temporary

    Posted

    How resize model gr2 (item_scale.txt)?

     

    try this model:

    http://softyou.net/produit/wing1.gr2

     

    Of course this system is not the official and don't work like the official.

     

    I simply add a skeleton to the model sash .

    And I edit some part of playersettingmodule.py

     

    for example:

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

    so I change the bone name "equip_right_hand" .

    • Love 1

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

    in Temporary

    Posted

    Up,

     

    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;		
}
    • Love 2

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

    in Temporary

    Posted

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

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

    in Temporary

    Posted

    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

    • Love 2

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

    in Temporary

    Posted

    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
    • Love 3

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

    in Temporary

    Posted

    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.

     

     

     
     
    • Love 2

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

    in Temporary

    Posted · Edited by Metin2 Dev
    Core X - External 2 Internal

    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 : Ä«¸Þ¶ó°¡ ¶¥¿¡ ¹¯È÷´Â ¹®Á¦ÀÇ ÇØ°áÀ» À§ÇØ ¸ÞÀΠij¸¯ÅÍ°¡ ÁöÇü¿¡ ¿Ã·ÁÁö±â
	//        Àü¿¡ ¸ÊÀ» ¾÷µ¥ÀÌÆ® ÇØ ³ôÀ̸¦ ±¸ÇÒ ¼ö ÀÖµµ·Ï Çسõ¾Æ¾ß ÇÕ´Ï´Ù.
	//        ´Ü, °ÔÀÓÀÌ µé¾î°¥¶§°¡ ¾Æ´Ñ ÀÌ¹Ì Ä³¸¯ÅÍ°¡ Ãß°¡ µÈ ÀÌÈÄ¿¡¸¸ ÇÕ´Ï´Ù.
	//        Çåµ¥ À̵¿Àε¥ ¿Ö 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);

	// ij¸¯ÅÍ°¡ »ç¶óÁú¶§ °³ÀÎ »óÁ¡µµ ¾ø¾ÖÁÝ´Ï´Ù.
	// 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:
     
     
    WT48bA5.jpg
     
     
    DGB42x7.jpg
     
     yeYqwY0.jpg

     

    ITmQTSw.jpg
    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 :D

    • Metin2 Dev 2
    • Love 22
×
×
  • Create New...

Important Information

Terms of Use / Privacy Policy / Guidelines / We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.