PDA

View Full Version : |Source| Custom Ancient - Increase Limit of ItemSetOption.bmd (Season 6 - 1.04e)



Goten
24/04/2020, 12:46 PM
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:
[Only registered and activated users can see links]

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