[Release]Shiningsystem OHNE Python

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

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

#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