𝗔𝗿𝗲𝘀

Buenas noches zoneros y zoneras hoy os traigo este set que no he visto publico en ningun foro ni en turkmmo ni en dev ni aca asi que ahora os lo traigo aqui para que le saquen provecho

Aca os dejo algunas fotos:

Aca el link:

Espero que le saquen provecho para este veranico

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

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