Jump to content

Gran Aporte "SISTEMA SHINING COMPLETO"

Pegasus

By Pegasus
in Programming

 Share

Recommended Posts

  • Popular Post
Pegasus Collaborator

Pegasus

Posted
  • Popular Post
Posted

Buenas noches zoneros y zoneras:

 

En esta ocasion os traigo el sistema Shining completo y reparado para alas y skin de armas ya que veo que no esta publico en ningun foro. 

Bueno los archivos que vamos a precisar son los siguientes:

 

Parte del Src Client o Binario como lo conozcan:

De la carpeta UserInterface:

-.PythonAplication.cpp

-.Locale_inc.h

-.Instancebase.h

-.Instancebase.cpp

De la carpeta GameLib:

-.ItemData.h

-.ItemData.cpp

-.ItemManager.cpp

-.ItemManager.h

 

Bueno sabiendo ya todo lo que vamos a precisar vamos con la guia 

UserInterface/PythonApplication.cpp

Buscamos esta linea:

snprintf(szSkillDescFileName, sizeof(szSkillDescFileName), "%s/skilldesc.txt", localePath);

Damos un enter y pegamos la siguiente:

#ifdef ENABLE_SHINING_SYSTEM
	snprintf(szShiningTable, sizeof(szShiningTable), "%s/shiningtable.txt", localePath);
#endif

Buscamos esta linea:

char szItemDesc[256];

Damos un enter y pegamos la siguiente:

#ifdef ENABLE_SHINING_SYSTEM
	char szShiningTable[256];
#endif

Buscamos esta linea:

	if (!rkSkillMgr.RegisterSkillTable("data/common/skilltable.txt"))
	{
		TraceError("Error while loading skilltable.txt.");
		return false;
	}

Damos un enter y pegamos la siguiente:

#ifdef ENABLE_SHINING_SYSTEM
	if (!rkItemMgr.LoadShiningTable(szShiningTable))
	{
		Tracenf("LoadLocaleData - LoadShiningTable(%s) Error", szShiningTable);
	}
#endif

  

UserInterface/Locale_inc.h

Aca agregaremos el siguiente define:

#define ENABLE_SHINING_SYSTEM
UserInterface/InstanceBase.h

Aca buscamos la siguiente linea:

		DWORD					m_armorRefineEffect;

Pulsamos un enter y agregamos la siguiente linea:

#ifdef ENABLE_SHINING_SYSTEM
		//2-Dimensions for Left & Right sided effects
		DWORD					m_weaponShiningEffects[2][CItemData::ITEM_SHINING_MAX_COUNT];
		DWORD					m_armorShiningEffects[CItemData::ITEM_SHINING_MAX_COUNT];
		DWORD					m_acceShiningEffects[CItemData::ITEM_SHINING_MAX_COUNT];
#endif

Aca quiero aclarar una cosa:

Si en vuestro sistema de estolas de envez de llevar acce lleva sash cambian la linea anterior por esta:

#ifdef ENABLE_SHINING_SYSTEM
		//2-Dimensions for Left & Right sided effects
		DWORD					m_weaponShiningEffects[2][CItemData::ITEM_SHINING_MAX_COUNT];
		DWORD					m_armorShiningEffects[CItemData::ITEM_SHINING_MAX_COUNT];
		DWORD					m_sashShiningEffects[CItemData::ITEM_SHINING_MAX_COUNT];
#endif

Ahora buscamos la siguiente linea:

		UINT	__GetRefinedEffect(CItemData* pItem);

Pulsamos un enter y agregamos la siguiente:

#ifdef ENABLE_SHINING_SYSTEM
		void	__GetShiningEffect(CItemData* pItem);
		void	__ClearWeaponShiningEffect(bool detaching = true);
		void	__ClearArmorShiningEffect(bool detaching = true);
		void	__ClearAcceShiningEffect(bool detaching = true);
		void	__AttachAcceShiningEffect(int effectIndex, const char* effectFileName, const char* boneName = "Bip01 Spine2");
		void	__AttachWeaponShiningEffect(int effectIndex, const char* effectFileName, const char* boneName = "Bip01");
		void	__AttachArmorShiningEffect(int effectIndex, const char* effectFileName, const char* boneName = "Bip01");
#endif

Aca quiero explicar 1 cosa:

Aca es lo mismo que en la anterior linea, si ustedes de envez de usar acce usan sash remplazan la linea por esta:

#ifdef ENABLE_SHINING_SYSTEM
		void	__GetShiningEffect(CItemData* pItem);
		void	__ClearWeaponShiningEffect(bool detaching = true);
		void	__ClearArmorShiningEffect(bool detaching = true);
		void	__ClearSashShiningEffect(bool detaching = true);
		void	__AttachSashShiningEffect(int effectIndex, const char* effectFileName, const char* boneName = "Bip01 Spine2");
		void	__AttachWeaponShiningEffect(int effectIndex, const char* effectFileName, const char* boneName = "Bip01");
		void	__AttachArmorShiningEffect(int effectIndex, const char* effectFileName, const char* boneName = "Bip01");
#endif
UserInterface/InstanceBase.cpp

Buscamos la siguiente funcion 

void CInstanceBase::SetArmor(DWORD dwArmor)
{
...
}

Y dentro de esta funcion buscamos lo siguiente

			__GetRefinedEffect(pItemData);

Pulsamos un enter y agregamos la siguiente linea:

#ifdef ENABLE_SHINING_SYSTEM
			__GetShiningEffect(pItemData);
#endif

Quedando asi:

			__GetRefinedEffect(pItemData);
#ifdef ENABLE_SHINING_SYSTEM
			__GetShiningEffect(pItemData);
#endif

Ahora dentro de la misma funcion buscamos la siguiente linea:

			__ClearArmorRefineEffect();

Pulsamos un enter y  agregamos lo siguiente:

#ifdef ENABLE_SHINING_SYSTEM
			__ClearArmorShiningEffect();
#endif
UserInterface/InstanceBase.cpp

Aca buscamos la siguiente funcion:

void CInstanceBase::SetAcce					"Recuerden que si su sistema de estolas no es acce lo cambian por Sash"
{
....
}

Dentro de esta funcion buscamos lo siguiente:

		ClearAcceEffect();

Pulsamos un enter y agregamos la siguiente linea:

#ifdef ENABLE_SHINING_SYSTEM
		__ClearAcceShiningEffect();
#endif

Luego dentro de la misma funcion mas abajo buscamos lo siguiente:

	CItemManager::Instance().GetItemDataPointer(dwAcce, &pItemData);			"Si no usan acce lo cambian por sash"

Pulsamos enter y mas abajo pegamos lo siguiente:

#ifdef ENABLE_SHINING_SYSTEM
	if (pItemData)
		__GetShiningEffect(pItemData);
#endif
  
Quedando asi:

  
	CItemManager::Instance().GetItemDataPointer(dwAcce, &pItemData);
	
#ifdef ENABLE_SHINING_SYSTEM
	if (pItemData)
		__GetShiningEffect(pItemData);
#endif
	
	m_GraphicThingInstance.AttachAcce(pItemData, fSpecular);
UserInterface/InstanceBase.cpp

"Ahora atentos en la siguiente funcion ya que si no lo hacen bien no funcionara en las armas ni en las skin"

Buscamos la siguiente funcion:

bool CInstanceBase::SetWeapon(DWORD eWeapon)
{
...
}

Dentro de esta funcion buscamos la siguiente linea:

		__GetRefinedEffect(pItemData);

Pulsamos un enter y agregamos lo siguiente:

#ifdef ENABLE_SHINING_SYSTEM
		__GetShiningEffect(pItemData);
#endif

Ahora buscamos la siguiente linea:

		__ClearWeaponRefineEffect();

Pulsamos un enter y agregamos lo siguiente:

#ifdef ENABLE_SHINING_SYSTEM
		__ClearWeaponShiningEffect();
#endif

"AHORA MUY ATENTOS AL CODIGO QUE PONDRE EN PANTALLA DEBERAN DE HACERLO TAL CUAL LO DEJO ACA" "CON LOS CORCHETES TAL CUAL ESTAN EN LA FUNCION"

MI CODIGO

	CItemData * pItemData;
	if (CItemManager::Instance().GetItemDataPointer(eWeapon, &pItemData))
	{								---------------------------ESTOS CORCHETES DEBERAN DE AGREGARLOS TAL CUAL PUSE ACA
		__GetRefinedEffect(pItemData);
#ifdef ENABLE_SHINING_SYSTEM
		__GetShiningEffect(pItemData);
#endif
	}								---------------------------ESTOS CORCHETES DEBERAN DE AGREGARLOS TAL CUAL PUSE ACA
	else
	{								---------------------------ESTOS CORCHETES DEBERAN DE AGREGARLOS TAL CUAL PUSE ACA
		__ClearWeaponRefineEffect();
#ifdef ENABLE_SHINING_SYSTEM
		__ClearWeaponShiningEffect();
#endif
  }								---------------------------ESTOS CORCHETES DEBERAN DE AGREGARLOS TAL CUAL PUSE ACA
	
	return true;
}
UserInterface/Instancebase.cpp

Ahora buscamos esta funcion

void CInstanceBase::__Initialize()
{
.....
}

Y dentro de ella vamos a buscar la siguiente linea:

	m_armorRefineEffect = 0;

Pulsamos enter y agregamos la siguiente linea:

#ifdef ENABLE_SHINING_SYSTEM
	__ClearWeaponShiningEffect(false);
#endif
UserInterface/InstanceBase.cpp

Ahora agregamos todo este bloque completo al final del archivo

#ifdef ENABLE_SHINING_SYSTEM
void CInstanceBase::__GetShiningEffect(CItemData* pItem)
{
	bool removeRefineEffect = true;

	CItemData::TItemShiningTable shiningTable = pItem->GetItemShiningTable();

	if (pItem->GetType() == CItemData::ITEM_TYPE_WEAPON)
	{
		__ClearWeaponShiningEffect();
		if (removeRefineEffect)
		{
			bool bRemove = false;
			for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
				if (strcmp(shiningTable.szShinings[i], ""))
					bRemove = true;
			if (bRemove)
				__ClearWeaponRefineEffect();
		}

		for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
		{
			if (strcmp(shiningTable.szShinings[i], ""))
			{
#ifdef ENABLE_WOLFMAN_CHARACTER
				bool twoSidedWeapon = pItem->GetSubType() == CItemData::WEAPON_DAGGER || pItem->GetSubType() == CItemData::WEAPON_CLAW || (IsMountingHorse() && pItem->GetSubType() == CItemData::WEAPON_FAN);
#else
				bool twoSidedWeapon = pItem->GetSubType() == CItemData::WEAPON_DAGGER || (IsMountingHorse() && pItem->GetSubType() == CItemData::WEAPON_FAN);
#endif
				if (twoSidedWeapon)
				{
					__AttachWeaponShiningEffect(i, shiningTable.szShinings[i], "PART_WEAPON_LEFT");
				}

				if (pItem->GetSubType() == CItemData::WEAPON_BOW)
					__AttachWeaponShiningEffect(i, shiningTable.szShinings[i], "PART_WEAPON_LEFT");
				else
					__AttachWeaponShiningEffect(i, shiningTable.szShinings[i], "PART_WEAPON");
			}
		}
	}
#ifdef ENABLE_COSTUME_SYSTEM
	else if (pItem->GetType() == CItemData::ITEM_TYPE_COSTUME)
	{
#ifdef ENABLE_ACCE_SYSTEM
		if (pItem->GetSubType() == CItemData::COSTUME_ACCE)
		{
			for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
			{
				if (strcmp(shiningTable.szShinings[i], ""))
				{
					__AttachAcceShiningEffect(i, shiningTable.szShinings[i], "Bip01 Spine2");
				}
			}
		}
#endif
		else if (pItem->GetSubType() == CItemData::COSTUME_BODY)
		{
			if (removeRefineEffect)
			{
				__ClearArmorRefineEffect();
			}

			for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
			{
				if (strcmp(shiningTable.szShinings[i], ""))
				{
					__AttachArmorShiningEffect(i, shiningTable.szShinings[i]);
				}
			}
		}
#ifdef ENABLE_WEAPON_COSTUME_SYSTEM
		else if (pItem->GetSubType() == CItemData::COSTUME_WEAPON)
		{
			__ClearWeaponShiningEffect();
			if (removeRefineEffect)
			{
				__ClearWeaponRefineEffect();
			}

			for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
			{
				if (strcmp(shiningTable.szShinings[i], ""))
				{
					bool twoSidedWeapon = pItem->GetValue(3) == CItemData::WEAPON_DAGGER || (IsMountingHorse() && pItem->GetValue(3) == CItemData::WEAPON_FAN);
					if (twoSidedWeapon)
					{
						__AttachWeaponShiningEffect(i, shiningTable.szShinings[i], "PART_WEAPON_LEFT");
					}

					if (pItem->GetValue(3) == CItemData::WEAPON_BOW)
						__AttachWeaponShiningEffect(i, shiningTable.szShinings[i], "PART_WEAPON_LEFT");
					else
						__AttachWeaponShiningEffect(i, shiningTable.szShinings[i], "PART_WEAPON");
				}
			}
		}
#endif
	}
#endif
	else
	{
		if (removeRefineEffect)
		{
			__ClearArmorRefineEffect();
		}

		for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
		{
			if (strcmp(shiningTable.szShinings[i], ""))
			{
				__AttachArmorShiningEffect(i, shiningTable.szShinings[i]);
			}
		}
	}
}

//Attaching the shining effect. 
//BoneName can be "PART_WEAPON" or "PART_WEAPON_LEFT" to get the attaching bone name dynamically.
//If boneName is not given "Bip01" is used as boneName.
void CInstanceBase::__AttachWeaponShiningEffect(int effectIndex, const char* effectFileName, const char* boneName)
{
	if (IsAffect(AFFECT_INVISIBILITY))
	{
		return;
	}

	if (effectIndex >= CItemData::ITEM_SHINING_MAX_COUNT)
	{
		return;
	}

	CEffectManager::Instance().RegisterEffect(effectFileName, false, false);

	if (!strcmp(boneName, "PART_WEAPON"))
	{
		const char* c_szRightBoneName;
		m_GraphicThingInstance.GetAttachingBoneName(CRaceData::PART_WEAPON, &c_szRightBoneName);

		if (c_szRightBoneName == NULL)
			return;

		if (strcmp(c_szRightBoneName, ""))
		{
			m_weaponShiningEffects[0][effectIndex] = m_GraphicThingInstance.AttachEffectByName(0, c_szRightBoneName, effectFileName);
		}
	}
	else if (!strcmp(boneName, "PART_WEAPON_LEFT"))
	{
		const char* c_szLeftBoneName;
		m_GraphicThingInstance.GetAttachingBoneName(CRaceData::PART_WEAPON_LEFT, &c_szLeftBoneName);

		if (c_szLeftBoneName == NULL)
			return;

		if (strcmp(c_szLeftBoneName, ""))
		{
			m_weaponShiningEffects[1][effectIndex] = m_GraphicThingInstance.AttachEffectByName(0, c_szLeftBoneName, effectFileName);
		}
	}
	else
	{
		Tracef("Invalid partname for getting attaching bone name. %s - %s", effectFileName, boneName);
	}
}

//Attaching the armor shining effect. 
//If boneName is not given "Bip01" is used as boneName.
void CInstanceBase::__AttachArmorShiningEffect(int effectIndex, const char* effectFileName, const char* boneName)
{
	if (IsAffect(AFFECT_INVISIBILITY))
	{
		return;
	}

	if (effectIndex >= CItemData::ITEM_SHINING_MAX_COUNT)
	{
		return;
	}

	if (!strcmp(boneName, ""))
	{
		Tracef("Empty bone name for attaching armor shining. Effect Index: %i, EffectFileName: %s", effectIndex, effectFileName);
		return;
	}

	CEffectManager::Instance().RegisterEffect(effectFileName, false, false);
	m_armorShiningEffects[effectIndex] = m_GraphicThingInstance.AttachEffectByName(0, boneName, effectFileName);
}

//Clears all weapon shining effects. Left & Right if set.
void CInstanceBase::__ClearWeaponShiningEffect(bool detaching)
{
	for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
	{
		if (m_weaponShiningEffects[0][i])
		{
			if (detaching)
			{
				__DetachEffect(m_weaponShiningEffects[0][i]);
			}

			m_weaponShiningEffects[0][i] = 0;
		}

		if (m_weaponShiningEffects[1][i])
		{
			if (detaching)
			{
				__DetachEffect(m_weaponShiningEffects[1][i]);
			}

			m_weaponShiningEffects[1][i] = 0;
		}
	}
}
//Clears all armor shining effects.
void CInstanceBase::__ClearArmorShiningEffect(bool detaching)
{
	if (detaching)
	{
		for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
		{
			if (m_armorShiningEffects[i])
			{
				__DetachEffect(m_armorShiningEffects[i]);
			}
		}
	}
	memset(&m_armorShiningEffects, 0, sizeof(m_armorShiningEffects));
}
#endif

#ifdef ENABLE_SHINING_SYSTEM
#ifdef ENABLE_ACCE_SYSTEM
void CInstanceBase::__AttachAcceShiningEffect(int effectIndex, const char* effectFileName, const char* boneName)
{
	if (IsAffect(AFFECT_INVISIBILITY))
	{
		return;
	}

	if (effectIndex >= CItemData::ITEM_SHINING_MAX_COUNT)
	{
		return;
	}

	if (!strcmp(boneName, ""))
	{
		Tracef("Empty bone name for attaching armor shining. Effect Index: %i, EffectFileName: %s", effectIndex, effectFileName);
		return;
	}

	CEffectManager::Instance().RegisterEffect(effectFileName, false, false);
	m_acceShiningEffects[effectIndex] = m_GraphicThingInstance.AttachEffectByName(0, boneName, effectFileName);
}
#ifdef ENABLE_ACCE_SYSTEM
void CInstanceBase::__ClearAcceShiningEffect(bool detaching)
{
	for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
	{
		if (detaching)
		{
			__DetachEffect(m_acceShiningEffects[i]);
		}

		m_acceShiningEffects[i] = 0;
	}
}
#endif
#endif
#endif
UserInterface/InstanceBase.cpp

"Ahora os voy a explicar algo"

En el caso de que vuestro sistema de estolas no lleve el define acce, deberan de cambiar el codigo del sistema en las partes que llevan acce por sash

"Por ejemplo en el bloque que agregan en InstanceBase.cpp"

Ese lleva ACCE como Define, ustedes deberan de agregar el define de su sistema de estolas
GameLib/ItemManager.h

Aca buscan la siguiente linea:

		bool			LoadItemTable(const char* c_szFileName);

Pulsan enter y agregan lo siguiente:

#ifdef ENABLE_SHINING_SYSTEM
		bool			LoadShiningTable(const char* c_szFileName);
#endif
GameLib/ItemManager.cpp

Ahora buscan la siguiente funcion

bool CItemManager::LoadItemTable(const char* c_szFileName)
{
...
}

Y debajo de la funcion completa pulsan enter y agregan el siguiente bloque

#ifdef ENABLE_SHINING_SYSTEM
bool CItemManager::LoadShiningTable(const char* szShiningTable)
{
	CMappedFile File;
	LPCVOID pData;

	if (!CEterPackManager::Instance().Get(File, szShiningTable, &pData))
		return false;

	CMemoryTextFileLoader textFileLoader;
	textFileLoader.Bind(File.Size(), pData);

	CTokenVector TokenVector;
	for (DWORD i = 0; i < textFileLoader.GetLineCount(); ++i)
	{
		if (!textFileLoader.SplitLine(i, &TokenVector, "\t"))
			continue;

		if (TokenVector.size() > (1 + CItemData::ITEM_SHINING_MAX_COUNT))
		{
			TraceError("CItemManager::LoadShiningTable(%s) - LoadShiningTable in %d\n - RowSize: %d MaxRowSize: %d", szShiningTable, i, TokenVector.size(), CItemData::ITEM_SHINING_MAX_COUNT);
		}

		const std::string & c_rstrID = TokenVector[0];
		DWORD dwItemVNum = atoi(c_rstrID.c_str());

		CItemData * pItemData = MakeItemData(dwItemVNum);
		if (pItemData)
		{
			for (BYTE i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
			{
				if (i < (TokenVector.size()-1))
				{
					const std::string & c_rstrEffectPath = TokenVector[i + 1];
					pItemData->SetItemShiningTableData(i, c_rstrEffectPath.c_str());
				}
				else
				{
					pItemData->SetItemShiningTableData(i, "");
				}
			}
		}
	}

	return true;
}
#endif
GameLib/ItemData.h

Buscan la siguiente linea:

			ITEM_SOCKET_MAX_NUM = 3,

Pulsan un enter y agregan la siguiente debajo

#ifdef ENABLE_SHINING_SYSTEM
	ITEM_SHINING_MAX_COUNT = 3,
#endif

Ahora buscan la siguiente linea:

		void SetItemTableData(TItemTable * pItemTable);

Pulsan enter y debajo agregan la siguiente:

#ifdef ENABLE_SHINING_SYSTEM
		typedef struct SItemShiningTable {
			char szShinings[ITEM_SHINING_MAX_COUNT][256];
		public:
			//Checking if any shining is set for this item.
			bool Any() const
			{
				for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
				{
					if (strcmp(szShinings[i], ""))
					{
						return true;
					}
				}
				return false;
			}
		} TItemShiningTable;
		void SetItemShiningTableData(BYTE bIndex, const char* szEffectname);
		CItemData::TItemShiningTable GetItemShiningTable() { return m_ItemShiningTable; }
#endif
    
Ahora buscan la siguiente linea:
    
		TItemTable m_ItemTable;

Pulsan enter y debajo pegan la siguiente:
    
#ifdef ENABLE_SHINING_SYSTEM
		TItemShiningTable m_ItemShiningTable;
#endif
GameLib/ItemData.cpp

Ahora buscan la siguiente funcion:

BOOL CItemData::IsEquipment() const
{
....
}

Debajo de la funcion agregan lo siguiente:

#ifdef ENABLE_SHINING_SYSTEM
void CItemData::SetItemShiningTableData(BYTE bIndex, const char* szEffectname)
{
	sprintf(m_ItemShiningTable.szShinings[bIndex], szEffectname);
}
#endif

Ahora buscan la siguiente funcion:

void CItemData::Clear()
{
.....
}

Dentro de esa misma funcion buscan la siguiente linea:

	memset(&m_ItemTable, 0, sizeof(m_ItemTable));

Pulsan un enter y agregan la siguiente linea:

#ifdef ENABLE_SHINING_SYSTEM
	memset(&m_ItemShiningTable, 0, sizeof(m_ItemShiningTable));
#endif

  

Parte del cliente

Va a su locale y agregan el archivo que os dejare debajo

"Como funciona el sistema y que hago para implementar un arma, ala o efecto de armadura"

Bueno para implementar todo el mundo ya conoce como se implementa una arma o estola.

Agregan la parte de la db luego item_list.txt, item_proto 

"Pero aca si usan arma 3D en el archivo haran lo siguiente"

61202	"D:/ymir work/effect/plechito/weapons/dark_cult_set/bell_glow.mse"

El 61202 es el vnum del arma, armadura o ala que llevara el efecto

Y al lado va la ruta del mse "Asegurese que el efecto esta completo

Y ya eso es todo

 

Y eso seria todo

 

Adjunto foto de como funciona el sistema correctamente

 

0626_001019.jpg

 

Si lo hacen tal cual le explique en la guia el sistema le funcionara correctamente. 

 

Adjunte foto cuando metan el sistema, no cuesta nada.

 

Archivo parte del cliente

Debes iniciar sesión para ver el contenido del enlace en esta publicación.

Link to comment
Share on other sites
Kronixer™ Apprentice

Kronixer™

Posted
Posted
hace 1 hora, TrafalgarLow dijo:

Buen Aporte, Pero esta en turkmmon pero como la mayoria no conoce ese foro Buen APORTE al traerlo

Hijo si es buen aporte, pero si no te haz dado cuenta turkmmo ahora para poder acceder debes usar vpn muchos no saben como, entonces no reproches que esta alla agradece que esta aca y listo 

Link to comment
Share on other sites
Pegasus Collaborator

Pegasus

Posted
  • Author
Posted
hace 5 horas, TrafalgarLow dijo:

Buen Aporte, Pero esta en turkmmon pero como la mayoria no conoce ese foro Buen APORTE al traerlo

Pero el que esta en turkmmo esta todo dañado al igual que en el dev. "Revisa el codigo y lo veras" Yo aca lo traigo reparado en todos los sentidos tanto para las skin al igual que como para las alas

Link to comment
Share on other sites
TrafalgarLaw Apprentice

TrafalgarLaw

Posted
Posted
hace 7 horas, Kronixer™ dijo:

Hijo si es buen aporte, pero si no te haz dado cuenta turkmmo ahora para poder acceder debes usar vpn muchos no saben como, entonces no reproches que esta alla agradece que esta aca y listo 

bro no reproche nadaXD de hecho por eso dije que es bueno que lo haya traido aca 

Link to comment
Share on other sites
ChuchoGamer Contributor

ChuchoGamer

Posted
Posted
hace 7 horas, Pegasus dijo:

De nada, publica foto de como te quedó☺️

Debes iniciar sesión para ver el contenido del enlace en esta publicación.

Debes iniciar sesión para ver el contenido del enlace en esta publicación.

Debes iniciar sesión para ver el contenido del enlace en esta publicación.

Debes iniciar sesión para ver el contenido del enlace en esta publicación.

Debes iniciar sesión para ver el contenido del enlace en esta publicación.

 

ai estan las fotos en esos link 

Link to comment
Share on other sites
  • 2 weeks later...
Pegasus Collaborator

Pegasus

Posted
  • Author
Posted
hace 9 minutos, ChuchoGamer dijo:

Yo meti este sistema como le puedo hacer para que agarren las animadas como atuendos de armas ya que las puse pero no se ven y se las paso en armas normales si se ven y nose si debo modificar los codigos o nose alguien me puede explicar 

Debes de adaptar parte del codigo a tu sistema costume. En el instancebase.cpp

Link to comment
Share on other sites
  • 4 months later...
  • 2 weeks later...

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

×
 Share
Go to topic listing

  • Recently Browsing   0 members

    • No registered users viewing this page.
×
×
  • Create New...