[Release]Shiningsystem OHNE Python

[Therulas]

[Release]Shiningsystem OHNE Python



Wie man hier sieht ist es Tabgetrennt möglich mehrere Shinings zugleich auf ein Gegenstand zu legen. Das derzeitige Maximum ist auf 3 konfiguriert. Aber natürlich nach Belieben ins unermessliche erweiterbar.
Das System ist sowohl mit Rüstungen als auch Waffen ausgiebig getestet und ebenfalls für den Lykaner funktional.

Ich habe versucht einiges an Code zu kommentieren um euch evtl. auch verstehen zu lassen was ihr da einbaut.

GameLib:

 Spoiler

Sucht nach:

BOOL CItemData::IsEquipment() const

Unter die Funktion:

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

Sucht nach:

	ITEM_SOCKET_MAX_NUM = 3,

Darunter:

#ifdef ENABLE_SHINING_SYSTEM
	ITEM_SHINING_MAX_COUNT = 3,
#endif


Sucht nach:

void SetItemTableData(TItemTable* pItemTable);

Darunter:

#ifdef ENABLE_SHINING_SYSTEM
	typedef struct SItemShiningTable {
		char szShinings[ITEM_SHINING_MAX_COUNT][256];
	} TItemShiningTable;

	void SetItemShiningTableData(BYTE bIndex, const char* szEffectname);
	CItemData::TItemShiningTable GetItemShiningTable() { return m_ItemShiningTable; }
#endif


Sucht nach:

	TItemTable m_ItemTable;

Darunter:

#ifdef ENABLE_SHINING_SYSTEM
	TItemShiningTable m_ItemShiningTable;
#endif

Sucht nach:

bool CItemManager::LoadItemTable(const char* c_szFileName)

Ganz unter der Funktion:

#ifdef ENABLE_SHINING_SYSTEM
bool CItemManager::Loa******ngTable(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::Loa******ngTable(%s) - Loa******ngTable 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

UserInterface:

 Spoiler

Sucht in der Funktion

void CInstanceBase::SetArmor(DWORD dwArmor)

nach:

__GetRefinedEffect(pItemData);

Darunter:

#ifdef ENABLE_SHINING_SYSTEM
			__GetShiningEffect(pItemData);
#endif


unter:

__ClearArmorRefineEffect();

das hier:

#ifdef ENABLE_SHINING_SYSTEM
			__ClearArmorShiningEffect();
#endif



Sucht in der Funktion

bool CInstanceBase::SetWeapon(DWORD eWeapon)

nach:

__GetRefinedEffect(pItemData);

und darunter:

#ifdef ENABLE_SHINING_SYSTEM
		__GetShiningEffect(pItemData);
#endif

unter:

__ClearWeaponRefineEffect();

das hier:


#ifdef ENABLE_SHINING_SYSTEM
		__ClearWeaponShiningEffect();
#endif



Sucht nach:

	m_swordRefineEffectRight = 0;
	m_swordRefineEffectLeft = 0;
	m_armorRefineEffect = 0;

darunter:

#ifdef ENABLE_SHINING_SYSTEM
	__ClearWeaponShiningEffect(false);
#endif

Nun ein ganz großer Block, einfach ganz am Ende der InstanceBase.cpp adden.

#ifdef ENABLE_SHINING_SYSTEM
//This method checks if the item has shinings and will attach them.
//Weapons are heaving special checks for two sided weapons like daggers or fans while mounting.
//Every itemtype is supported. If no explicit logic is implemented it will be attached to "Bip01".
void CInstanceBase::__GetShiningEffect(CItemData* pItem)
{
	//Set this to true if you want to hide the refine effect if there's a shining for this item.
	bool removeRefineEffect = false;

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

	if (pItem->GetType() == CItemData::ITEM_TYPE_WEAPON)
	{
		if (removeRefineEffect)
		{
			__ClearWeaponRefineEffect();
		}

		for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
		{
			if (strcmp(shiningTable.szShinings[i], ""))
			{
				//Check for double sided weapons or fan which is attached on both sides when mounted.
#ifdef ENABLE_WOLFMAN
				bool twoSidedWeapon = pItem->GetSubType() == CItemData::WEAPON_DAGGER || (IsMountingHorse() && pItem->GetSubType() == CItemData::WEAPON_FAN) || pItem->GetSubType() == CItemData::WEAPON_CLAW;
#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");
				}

				__AttachWeaponShiningEffect(i, shiningTable.szShinings[i], "PART_WEAPON");
			}
		}
	}
	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 (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 (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)
{
	for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
	{
		if (detaching)
		{
			__DetachEffect(m_armorShiningEffects[i]);
		}

		m_armorShiningEffects[i] = 0;
	}
}
#endif

Sucht nach:

UINT	__GetRefinedEffect(CItemData* pItem);

darunter:

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



Sucht nach:

		DWORD					m_swordRefineEffectRight;
		DWORD					m_swordRefineEffectLeft;
		DWORD					m_armorRefineEffect;

darunter:

#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];
#endif

In "bool LoadLocaleData(const char* localePath)" unter:

char szItemDesc[256];

einfügen:

#ifdef ENABLE_SHINING_SYSTEM
	char szShiningTable[256];
#endif

Unter:

snprintf(szItemDesc,	sizeof(szItemDesc),	"%s/item_desc.txt",	localePath);

das hier:

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



Zu guter Letzt das hier suchen:

	if(!rkItemMgr.LoadItemDesc(szItemDesc))
	{
		Tracenf("LoadLocaleData - LoadItemDesc(%s) Error", szItemDesc);
	}


darunter:

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

In der ItemData.h könnt ihr nun "ITEM_SHINING_MAX_COUNT = 3," anpassen wenn ihr noch mehr Shinings setzen wollt.

Und natürlich das Define dort machen wo ihr eure defines macht.



Das ganze Stammt von Sanii soll das ganze in diesem Forum auch für ihn Releasen er ist zufaul



Das ganze wurde für Heraion gecodet und er stellt es für euch bereit.

Wenn ihr Unser Projekt unterstützen wollt nehmt das in eure Signatur:

[VegaS ♆]

Originally Posted by Therulas

	for (int i = 0; i < CItemData::ITEM_SHINING_MAX_COUNT; i++)
	{
		// ..................
		m_weaponShiningEffects[0][i] = 0;
		m_weaponShiningEffects[1][i] = 0;
	}

The idea isn't so bad, but some things isn't too good, like this one.
When you can use memset (is useful for intializing a section of memory to some value), without a loop for nothing.

memset(m_weaponShiningEffects, 0, sizeof(m_weaponShiningEffects));

[LxR'EsoZiaL]

Wieso sollte man sowas ohne Python schreiben?

Python hat dafür sehr schöne und einfache Tuple Funktionen, mit einer TXT macht man das nur unnötig fett und umständlich. Schön sieht das dann auch nicht aus.

[ThaRielFliege]

Originally Posted by LxR'EsoZiaL

Wieso sollte man sowas ohne Python schreiben?

Python hat dafür sehr schöne und einfache Tuple Funktionen, mit einer TXT macht man das nur unnötig fett und umständlich. Schön sieht das dann auch nicht aus.

Weiß nicht was an einer Datei abändern umständlich und Fett sein sollte.
Ich weiß schon warum du die Kuh als Profilbild hast. (no Hate hab dich lieb)

[szymex1]

Does it work with costume?