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

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. Click Here To Register...]

Add SItemOption.cpp

Código:

---


// 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

Código:

---

#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