Custom Ancient - Increase Limit of ItemSetOption.bmd (Season 6 - 1.04e)

[Goten]

Esta fonte é para aumentar o limite de itens de acc de 64 para um total máximo de 255!
Você precisa usar o ItemSetOption.bmd da Season8 para que tudo funcione sem problemas na Season6.

Veja a imagem abaixo:


Add SItemOption.cpp

// SItemOption.cpp: implementation of the CSItemOption class.
//
//////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include "SItemOption.h"
#include "CustomMessage.h"
#include "Offset.h"
#include "Util.h"
#include "Defines.h"

ITEM_SETOPTION_INFO gItemSetOption[MAX_ITEM_SETOPTION];

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSItemOption::CSItemOption()
{

}

CSItemOption::~CSItemOption()
{

}

void WzXor(BYTE *Buffer, int Size)
{
	BYTE Key[3] = { 0xFC, 0xCF, 0xAB };

	for (int i = 0; i < Size; ++i)
	{
		Buffer[i] ^= Key[i % 3];
	}
}

void CSItemOption::Load()
{
	SetCompleteHook(0xE9, 0x004E8990, &CSItemOption::LoadSetType);
	SetCompleteHook(0xE9, 0x004E8B80, &CSItemOption::LoadSetOption);
	SetCompleteHook(0xE9, 0x004E9210, &CSItemOption::InitSetOptionName);
	SetCompleteHook(0xE9, 0x004EC410, &CSItemOption::InitSetOptionsTooltip);
	SetCompleteHook(0xE9, 0x004EB910, &CSItemOption::InitInfoTooltip);
}

bool CSItemOption::LoadSetType(char * path)
{
	char ErrorBuff[255] = { 0 };

	FILE * hFile = fopen(path, "rb");

	if (hFile)
	{
		DWORD Checksum = 0;

		BYTE * Buffer = new BYTE[sizeof(this->m_ItemSetType)];

		fread(Buffer, sizeof(this->m_ItemSetType), 1, hFile);

		fread(&Checksum, 4, 1, hFile);

		fclose(hFile);

		BYTE * FixBuffer = Buffer;

		int BlockSize = sizeof(ITEM_SETTYPE_INFO);

		for (int i = 0; i < MAX_ITEM; ++i)
		{
			WzXor(FixBuffer, BlockSize);
			memcpy(&this->m_ItemSetType[i], FixBuffer, BlockSize);
			FixBuffer += BlockSize;
		}

		delete[] Buffer;
	}
	else
	{
		sprintf(ErrorBuff, "%s - File not exist.", path);
		MessageBoxA(*(HWND*)MAIN_WINDOW, ErrorBuff, 0, 0);
		SendMessageA(*(HWND*)MAIN_WINDOW, 2u, 0, 0);
	}

	return 1;
}

bool CSItemOption::LoadSetOption(char * path)
{
	char ErrorBuff[255] = { 0 };

	FILE * hFile = fopen(path, "rb");

	memset(gItemSetOption, 0, sizeof(gItemSetOption));

	if (hFile)
	{
		DWORD Checksum = 0;

		BYTE * Buffer = new BYTE[sizeof(gItemSetOption)];

		fread(Buffer, sizeof(gItemSetOption), 1, hFile);

		fread(&Checksum, 4, 1, hFile);

		fclose(hFile);

		BYTE * FixBuffer = Buffer;

		int BlockSize = sizeof(ITEM_SETOPTION_INFO);

		for (int i = 0; i < MAX_ITEM_SETOPTION; ++i)
		{
			WzXor(FixBuffer, BlockSize);
			memcpy(&gItemSetOption[i], FixBuffer, BlockSize);
			FixBuffer += BlockSize;
		}

		delete[] Buffer;
	}
	else
	{
		sprintf(ErrorBuff, "%s - File not exist.", path);
		MessageBoxA(*(HWND*)MAIN_WINDOW, ErrorBuff, 0, 0);
		SendMessageA(*(HWND*)MAIN_WINDOW, 2u, 0, 0);
	}
	return 1;
}

bool CSItemOption::InitSetOptionName(char * Buffer, int ItemID, int AncientOption)
{
	int SetType = AncientOption % 4;

	if (SetType <= 0)
		return 0;

	BYTE SetIndex = this->GetSetIndexbyItem(ItemID, SetType);

	if (SetIndex >= 255 || SetIndex <= 0)
	{
		return 0;
	}

	memcpy(Buffer, this->GetSetOptionInfo(SetIndex)->name, 32);

	Buffer[strlen(Buffer)] = 32;
	Buffer[strlen(Buffer) + 1] = 0;

	return 1;
}

int CSItemOption::InitSetOptionsTooltip(ObjectItem * lpItem, int CurrentLine, char a4)
{
	tooltiparray * TooltipLine = (tooltiparray*)NewAddressData3;
	int * LineColor = (int*)NewAddressData1;
	int * LineWeight = (int*)NewAddressData2;
	int NextLine = CurrentLine;
	int UsedPath = 0;
	bool Checked = 0;

	if ((lpItem->AncientOption % 4) != 1 && (lpItem->AncientOption % 4) != 2)
	{
		return CurrentLine;
	}

	BYTE SetIndex = this->GetSetIndexbyItem(lpItem->ItemID, lpItem->AncientOption % 4);
	
	ITEM_SETOPTION_INFO* lpInfo = this->GetSetOptionInfo(SetIndex);
	
	lpCharObj lpObj = &*(ObjectCharacter*)(*(DWORD*)MAIN_CHARACTER_STRUCT);
	
	if (lpInfo == 0 || lpObj == 0)
	{
		return CurrentLine;
	}

	char SaveName[128] = { 0 };
	
	memcpy(SaveName, TooltipLine[0], 100);

	int SetCount = this->GetCountSetPath(lpItem->ItemID, lpItem->AncientOption % 4);
	
	int CheckItemTable[INVENTORY_WEAR_SIZE] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
	
	for (int n = 0; n < INVENTORY_WEAR_SIZE; n++)
	{
		lpItemObj lpEquipment = &lpObj->pEquipment[n];
	
		Checked = 0;
	
		for (int i = 0; i < INVENTORY_WEAR_SIZE; i++)
		{
			if (lpEquipment->ItemID == CheckItemTable[i])
			{
				Checked = 1;
				break;
			}
		}
	
		if (Checked != 1)
		{
			if (this->GetSetIndexbyItem(lpEquipment->ItemID, lpEquipment->AncientOption % 4) == SetIndex)
			{
				CheckItemTable[n] = lpEquipment->ItemID;
				UsedPath++;
			}
		}
	}

	wsprintf(TooltipLine[NextLine], "[%s] %s", lpInfo->name, gCustomMessage.GetMessageB(159));
	LineColor[NextLine] = TEXT_GOLD;
	LineWeight[NextLine++] = 1;
	
	//wsprintf(TooltipLine[NextLine++], "\n");
	
	for (int n = 0; n <= 12; n++)
	{
		if (lpInfo->option[n] != -1 && lpInfo->value[n] != -1)
		{
			wsprintf(TooltipLine[NextLine], gCustomMessage.GetMessageB(this->GetAncientTextIndex(lpInfo->option[n])), lpInfo->value[n]);
	
			if ((UsedPath > n || UsedPath >= SetCount) && UsedPath > 1)
				LineColor[NextLine] = TEXT_GREEN;
			else
				LineColor[NextLine] = TEXT_GRAY;
	
			LineWeight[NextLine++] = 0;
		}
	}
	
	for (int n = 0; n < 5; n++)
	{
		if (lpInfo->fulloption[n] != -1 && lpInfo->fullvalue[n] != -1)
		{
			wsprintf(TooltipLine[NextLine], gCustomMessage.GetMessageB(this->GetAncientTextIndex(lpInfo->fulloption[n])), lpInfo->fullvalue[n]);
	
			if (UsedPath >= n && UsedPath >= SetCount)
				LineColor[NextLine] = TEXT_GREEN;
			else
				LineColor[NextLine] = TEXT_GRAY;
	
			LineWeight[NextLine++] = 0;
		}
	}

	if (NextLine > 28)
	{
		memcpy(TooltipLine[0], SaveName, 100);
		LineColor[0] = TEXT_GREENBLUE;
	}

	//wsprintf(TooltipLine[NextLine++], "\n");
	//wsprintf(TooltipLine[NextLine++], "\n");

	return NextLine;
}

void CSItemOption::RemoveDuplicatesUnsorted(int arr[][3], int Length)
{
	for (int i = 0; i < Length; i++)
	{
		for (int j = i + 1; j < Length;)
		{
			if (arr[i][1] == arr[j][1])
			{
				for (int k = j; k < Length; k++)
				{
					arr[k][0] = arr[k + 1][0];
					arr[k][1] = arr[k + 1][1];
					arr[k][2] = arr[k + 1][2];
				}
				Length--;
			}
			else
			{
				j++;
			}
		}
	}
}

void CSItemOption::InitInfoTooltip(int PosX, int PosY)
{
	if (this->unknow39812 && (this->unknow39816[144] > 0 || this->unknow39816[145] > 0))
	{
		tooltiparray * TooltipLine = (tooltiparray*)NewAddressData3;
		int * LineColor = (int*)NewAddressData1;
		int * LineWeight = (int*)NewAddressData2;

		int Line = 1;

		wsprintf(TooltipLine[0], "\n");
		LineColor[0] = 0;
		LineWeight[0] = 0;

		wsprintf(TooltipLine[1], "\n");
		LineColor[1] = 0;
		LineWeight[Line++] = 0;

		wsprintf(TooltipLine[Line], "\n");
		LineColor[Line] = 0;
		LineWeight[Line++] = 0;
		
		lpCharObj lpObj = &*(ObjectCharacter*)(*(DWORD*)MAIN_CHARACTER_STRUCT);

		int CheckItemTable[INVENTORY_WEAR_SIZE][3] = { {-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1},{-1,-1,-1},{-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1} };
		int UsedPath[INVENTORY_WEAR_SIZE] = { 0,0,0,0,0,0,0,0,0,0,0,0 };

		for (int n = 0; n < INVENTORY_WEAR_SIZE; n++)
		{
			lpItemObj lpEquipment = &lpObj->pEquipment[n];

			if ((lpEquipment->AncientOption % 4) == 1 || (lpEquipment->AncientOption % 4) == 2)
			{
				BYTE SetIndex = this->GetSetIndexbyItem(lpEquipment->ItemID, lpEquipment->AncientOption % 4);

				if (SetIndex != CheckItemTable[n][1])
				{
					CheckItemTable[n][0] = lpEquipment->ItemID;
					CheckItemTable[n][1] = SetIndex;
					CheckItemTable[n][2] = (lpEquipment->AncientOption % 4);
				}
			}
		}

		this->RemoveDuplicatesUnsorted(CheckItemTable, INVENTORY_WEAR_SIZE);

		for (int o = 0; o < 3; o++)
		{
			int TempChecked[INVENTORY_WEAR_SIZE] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };

			for (int n = 0; n < INVENTORY_WEAR_SIZE; n++)
			{
				//int SetCount = this->GetCountSetPath(CheckItemTable[o][0], CheckItemTable[o][2]);

				lpItemObj lpEquipment = &lpObj->pEquipment[n];

				bool Checked = false;

				for (int i = 0; i < INVENTORY_WEAR_SIZE; i++)
				{
					if (lpEquipment->ItemID == TempChecked[i])
					{
						Checked = true;
						break;
					}
				}

				if (Checked != true)
				{
					if (this->GetSetIndexbyItem(lpEquipment->ItemID, lpEquipment->AncientOption % 4) == CheckItemTable[o][1])
					{
						TempChecked[n] = lpEquipment->ItemID;
						UsedPath[o]++;
					}
				}
			}
		}		

		for (int o = 0; o < 3; o++)
		{
			if (CheckItemTable[o][1] <= 0 || CheckItemTable[o][1] >= 255)
			{
				continue;
			}

			ITEM_SETOPTION_INFO* lpInfo = this->GetSetOptionInfo(CheckItemTable[o][1]);

			lpCharObj lpObj = &*(ObjectCharacter*)(*(DWORD*)MAIN_CHARACTER_STRUCT);

			if (lpInfo == 0 )
			{
				continue;
			}

			int SetCount = this->GetCountSetPath(CheckItemTable[o][0], CheckItemTable[o][2]);

			if (UsedPath[o] < 2)
			{
				continue;
			}

			wsprintf(TooltipLine[Line], "%s - %s", lpInfo->name, gCustomMessage.GetMessageB(159));
			LineColor[Line] = TEXT_GOLD;
			LineWeight[Line++] = 1;

			for (int n = 0; n < 12; n++)
			{
				if (lpInfo->option[n] != -1 && lpInfo->value[n] != -1)
				{
					if ((UsedPath[o] > n || UsedPath[o] >= SetCount) && UsedPath[o] > 1)
					{
						wsprintf(TooltipLine[Line], gCustomMessage.GetMessageB(this->GetAncientTextIndex(lpInfo->option[n])), lpInfo->value[n]);
						LineColor[Line] = TEXT_BLUE;
						LineWeight[Line++] = 0;
					}
				}
			}

			for (int n = 0; n < 5; n++)
			{
				if (lpInfo->fulloption[n] != -1 && lpInfo->fullvalue[n] != -1)
				{			
					if (UsedPath[o] >= n && UsedPath[o] >= SetCount)
					{
						wsprintf(TooltipLine[Line], gCustomMessage.GetMessageB(this->GetAncientTextIndex(lpInfo->fulloption[n])), lpInfo->fullvalue[n]);
						LineColor[Line] = TEXT_BLUE;
						LineWeight[Line++] = 0;
					}
				}
			}

			wsprintf(TooltipLine[Line++], "\n");
		}

		pMultiLineTooltip(PosX + 95, PosY + 40, Line, 120, 3, 0, 1);
	}
}

BYTE CSItemOption::GetSetIndexbyItem(int itemindex, int type)
{
	if (itemindex < 0 || itemindex >= MAX_ITEM)
	{
		return 0;
	}

	int origin = (type - 1);

	if (origin < 0 || origin >= 2)
	{
		return 0;
	}

	return this->m_ItemSetType[itemindex].set[origin];
}

int CSItemOption::GetCountSetPath(int itemindex, int type)
{
	if (itemindex < 0 || itemindex >= MAX_ITEM)
	{
		return 0;
	}

	int origin = (type - 1);

	if (origin < 0 || origin >= 2)
	{
		return 0;
	}

	int Count = 0;

	int Type1 = this->GetSetIndexbyItem(itemindex, type);

	for (int n = 0; n < MAX_ITEM; n++)
	{
		if (this->m_ItemSetType[n].set[origin] == Type1)
		{
			Count++;
		}
	}

	return Count;
}

ITEM_SETOPTION_INFO* CSItemOption::GetSetOptionInfo(int index)
{
	if (index < 1 || index > MAX_ITEM_SETOPTION)
	{
		return 0;
	}

	return &gItemSetOption[index];
}

int CSItemOption::GetAncientTextIndex(BYTE OptionIndex)
{
	int Index = OptionIndex + 168;

	switch (OptionIndex)
	{
	case SET_ITEM_OPTION_ADD_STRENGTH:
	case SET_ITEM_OPTION_ADD_DEXTERITY:
	case SET_ITEM_OPTION_ADD_ENERGY:
	case SET_ITEM_OPTION_ADD_VITALITY:
	case SET_ITEM_OPTION_ADD_LEADERSHIP:
	case SET_ITEM_OPTION_ADD_MIN_PHYSI_DAMAGE:
	case SET_ITEM_OPTION_ADD_MAX_PHYSI_DAMAGE:
		Index = OptionIndex + 950;
		break;
	case SET_ITEM_OPTION_MUL_MAGIC_DAMAGE:
		Index = 632;
		break;
	case SET_ITEM_OPTION_ADD_PHYSI_DAMAGE:
	case SET_ITEM_OPTION_MUL_ATTACK_SUCCESS_RATE:
	case SET_ITEM_OPTION_ADD_DEFENSE:
	case SET_ITEM_OPTION_ADD_MAX_LIFE:
	case SET_ITEM_OPTION_ADD_MAX_MANA:
	case SET_ITEM_OPTION_ADD_MAX_BP:
	case SET_ITEM_OPTION_ADD_BP_RECOVERY:
	case SET_ITEM_OPTION_ADD_CRITICAL_DAMAGE_RATE:
	case SET_ITEM_OPTION_ADD_CRITICAL_DAMAGE:
	case SET_ITEM_OPTION_ADD_EXCELLENT_DAMAGE_RATE:
	case SET_ITEM_OPTION_ADD_EXCELLENT_DAMAGE:
	case SET_ITEM_OPTION_ADD_SKILL_DAMAGE:
	case SET_ITEM_OPTION_ADD_DOUBLE_DAMAGE_RATE:
		Index = OptionIndex + 949;
		break;
	case SET_ITEM_OPTION_ADD_IGNORE_DEFENSE_RATE:
		Index = 970;
		break;
	case SET_ITEM_OPTION_MUL_SHIELD_DEFENSE:
		Index = 984;
		break;
	case SET_ITEM_OPTION_MUL_TWO_HAND_PHYSI_DAMAGE:
		Index = 983;
		break;
	case SET_ITEM_OPTION_ADD_PHYSI_DAMAGE_BY_STRENGTH:
	case SET_ITEM_OPTION_ADD_PHYSI_DAMAGE_BY_DEXTERITY:
	case SET_ITEM_OPTION_ADD_DEFENSE_BY_DEXTERITY:
	case SET_ITEM_OPTION_ADD_DEFENSE_BY_VITALITY:
	case SET_ITEM_OPTION_ADD_MAGIC_DAMAGE_BY_ENERGY:
	case SET_ITEM_OPTION_ADD_ICE_DAMAGE:
	case SET_ITEM_OPTION_ADD_POISON_DAMAGE:
	case SET_ITEM_OPTION_ADD_LIGHTNING_DAMAGE:
	case SET_ITEM_OPTION_ADD_FIRE_DAMAGE:
	case SET_ITEM_OPTION_ADD_EARTH_DAMAGE:
	case SET_ITEM_OPTION_ADD_WIND_DAMAGE:
	case SET_ITEM_OPTION_ADD_WATER_DAMAGE:
		Index = OptionIndex + 947;
		break;
	default:
		return Index;
	}

	return Index;
}

Add SItemOption.h

#pragma once

#include "Defines.h"
#include "Object.h"
#include "Item.h"

#define MAX_ITEM_SETOPTION 254

typedef char tooltiparray[100];

#pragma pack(push, 1)
struct ITEM_SETTYPE_INFO //4
{
	BYTE set[2];
	BYTE mix[2];
};
#pragma pack(pop)

#pragma pack(push, 1)
struct ITEM_SETOPTION_INFO //(size: 110 x 64)
{
	/*+0*/		char name[64];
	/*+64*/		char option[12];
	/*+76*/		char value[12];
	/*+88*/		char unknown88;
	/*+89*/		char unknown89;
	/*+90*/		char unknown90;
	/*+91*/		char unknown91;
	/*+92*/		char unknown92;
	/*+93*/		char fulloption[5];
	/*+98*/		char fullvalue[5];
	/*+103*/	char Class[7];
};
#pragma pack(pop)

#pragma pack(push,1)
class CSItemOption
{
public:
	CSItemOption();
	virtual ~CSItemOption();

private:
	ITEM_SETTYPE_INFO m_ItemSetType[MAX_ITEM];  //?
	//BYTE gap[4];  //?
	ITEM_SETOPTION_INFO m_ItemSetOption[64];//32772 Not Enough Memory
	BYTE unknow39812;
	BYTE unknow39813;
	BYTE ViewSet;
	BYTE unknow39815;
	BYTE unknow39816[220];

public:
	bool InitSetOptionName(char * Buffer, int ItemID, int AncientOption);
	int InitSetOptionsTooltip(ObjectItem * lpItem, int CurrentLine, char a4);
	void InitInfoTooltip(int PosX, int PosY);
	BYTE GetSetIndexbyItem(int itemindex, int type);
	int GetCountSetPath(int itemindex, int type);
	ITEM_SETOPTION_INFO* GetSetOptionInfo(int index);
	int GetAncientTextIndex(BYTE OptionIndex);
	bool LoadSetType(char * path);
	bool LoadSetOption(char * path);
	void RemoveDuplicatesUnsorted(int arr[][3], int Length);
	static void Load();
};
#pragma pack(pop)

extern ITEM_SETOPTION_INFO gItemSetOption[MAX_ITEM_SETOPTION];

//int s = sizeof(CSItemOption);

Créditos:
myheart