Autor Topic: New HealtBar Ogocx Season 6 (Visto 1671 veces)

Hi Guys Today i'am share with you my modification on source main on the Ogocx X601

Old HealtBar

New HealtBar

source and download fix hp missing in right corner

Now Sources

HealtBar.cpp

Code: [Select]

#include "stdafx.h"
#include "HealthBar.h"
#include "Util.h"
#include "Interface.h"
#include "AntiHack.h"
#include "MenuWindow.h"
#include "Patente.h"

CHealthBar gHealthBar;

CHealthBar::CHealthBar()
{
    ClearNewHealthBar();
}

CHealthBar::~CHealthBar()
{

}

void CHealthBar::Init()
{
    SetCompleteHook(0xE8, 0x005B96E8, &this->DrawNewHealthBar);
}

void CHealthBar::ClearNewHealthBar()
{
    for (int n = 0; n < MAX_MAIN_VIEWPORT; n++)
    {
        gNewHealthBar[n].index = 0xFFFF;
        gNewHealthBar[n].type = 0;
        gNewHealthBar[n].rate = 0;
        gNewHealthBar[n].rate2 = 0;
    }
}

void CHealthBar::InsertNewHealthBar(WORD index, BYTE type, BYTE rate, BYTE rate2)
{
    for (int n = 0; n < MAX_MAIN_VIEWPORT; n++)
    {
        if (gNewHealthBar[n].index == 0xFFFF)
        {
            gNewHealthBar[n].index = index;
            gNewHealthBar[n].type = type;
            gNewHealthBar[n].rate = rate;
            gNewHealthBar[n].rate2 = rate2;
            return;
        }
    }
}

NEW_HEALTH_BAR* CHealthBar::GetNewHealthBar(WORD index, BYTE type)
{
    for (int n = 0; n < MAX_MAIN_VIEWPORT; n++)
    {
        if (gNewHealthBar[n].index != 0xFFFF)
        {
            if (gNewHealthBar[n].index == index && gNewHealthBar[n].type == type)
            {
                return &gNewHealthBar[n];
            }
        }
    }

    return 0;
}

void CHealthBar::DrawNewHealthBar()
{
    ((void(*)())0x005BA770)(); // Chama a função original para desenhar a barra de saúde

    if (gMenuWindow.m_HealthBarDisabled == 0)
    {
        int PosX, PosY, LifeProgress, ShieldProgress;
        float LifeBarWidth = 80.0f;
        char MonsterName[50];
        vec3_t Angle;

        for (int n = 0; n < MAX_MAIN_VIEWPORT; n++)
        {
            DWORD ViewportAddress = ((DWORD(__thiscall*)(void*, DWORD))0x0096A4C0)(((void* (*)())0x00402BC0)(), n);

            if (!ViewportAddress || *(BYTE*)(ViewportAddress + 0x30C) == 0)
            {
                continue;
            }

            NEW_HEALTH_BAR* lpNewHealthBar = gHealthBar.GetNewHealthBar(*(WORD*)(ViewportAddress + 0x7E), *(BYTE*)(ViewportAddress + 0x320));
            char* name = (char*)(ViewportAddress + 0x38);

            if (lpNewHealthBar == 0 || !name)
            {
                continue;
            }

            int LifePercent = lpNewHealthBar->rate / 10;
            int ShieldPercent = lpNewHealthBar->rate2 / 10;

            Angle[0] = *(float*)(ViewportAddress + 0x404);
            Angle[1] = *(float*)(ViewportAddress + 0x408);
            Angle[2] = *(float*)(ViewportAddress + 0x40C) + *(float*)(ViewportAddress + 0x3E8) + 100.0f;

            pGetPosFromAngle(&Angle, &PosX, &PosY);

            PosX -= (int)floor(LifeBarWidth / 2.0);
            PosY -= 16;

            // Ajuste a largura da caixa de fundo preta para coincidir com a barra de saúde
            float backgroundWidth = LifeBarWidth + 8.0f; // Ajustado para LifeBarWidth + 8.0f

            // Desenhe o fundo da barra de vida
            pSetBlend(true);
            glColor4f(0.0, 0.0, 0.0, 0.5); // Ajuste a opacidade da caixa preta grande
            pDrawBarForm((float)(PosX - 4), (float)(PosY - 10), backgroundWidth, 20.0f, 0.0f, 0);
            pGLSwitchBlend();
            pGLSwitch();

            // Desenhe a barra de vida
            glColor3f(0.2f, 0.0, 0.0); // Vermelho escuro
            pDrawBarForm((float)PosX, (float)PosY, LifeBarWidth, 5.0f, 0.0, 0);

            glColor3f(0.19607843f, 0.039215688f, 0.0);
            pDrawBarForm((float)(PosX + 2), (float)(PosY + 2), LifeBarWidth - 4.0f, 1.0f, 0.0, 0);

            if (LifePercent > 10)
            {
                LifeProgress = 10;
            }
            else
            {
                LifeProgress = LifePercent;
            }

            if (ShieldPercent > 10)
            {
                ShieldProgress = 10;
            }
            else
            {
                ShieldProgress = ShieldPercent;
            }

            glColor3f(0.98039216f, 0.039215688f, 0.0); // Vermelho brilhante
            for (int i = 0; i < LifeProgress; i++)
            {
                pDrawBarForm((float)(i * 8 + PosX + 0), (float)(PosY + 2), 8.0, 2.0, 0.0, 0);
            }

            if (ShieldPercent > 0)
            {
                glColor3f(0.98039216f, 0.5f, 0.0); // Amarelo brilhante para escudo
                for (int i = 0; i < ShieldProgress; i++)
                {
                    pDrawBarForm((float)(i * 8 + PosX + 0), (float)(PosY + 6), 8.0, 2.0, 0.0, 0);
                }
            }

            // Desenhe o nome do monstro
            wsprintf(MonsterName, "%s", name);

            // Estimativa da largura e altura do texto
            int textWidth = strlen(MonsterName) * 10; // Ajuste o multiplicador conforme a largura média dos caracteres
            int textHeight = 20; // Ajuste conforme a altura do texto

            // Calcule a posição centralizada do texto
            int textPosX = PosX + (int)(LifeBarWidth / 2 - textWidth / 7); // Corrigido para centralizar horizontalmente
            int textPosY = PosY - 8 + (int)(20 / 2 - textHeight / 2); // Ajusta a posição vertical para centralizar

            // Defina a cor do texto (branco claro)
            pSetTextColor(pTextThis(), 0xFF, 0xE6, 0xD2, 0xFF); // Cor do texto

            // Desenhe o texto
            pDrawText(pTextThis(), textPosX, textPosY, MonsterName, 0, 0, 1, 0); // Ajuste as coordenadas e parâmetros conforme necessário

            pGLSwitch();
        }

        pGLSwitch();
        glColor3f(1.0, 1.0, 1.0);
    }

    gPatente.MainProc();

    if (gAntiHack.LicenseChecked)
    {
        gInterface.m_Lua.Generic_Call("MainPlayerDraw", ">");
    }
}

HealtBar.h

Code: [Select]

#pragma once

#include "Lua.h"

struct NEW_HEALTH_BAR
{
	WORD index;
	BYTE type;
	BYTE rate;
	BYTE rate2; // Adicionando rate2 aqui
};

struct VAngle
{
	float X;
	float Y;
	float Z;
};

class CHealthBar {
public:
    CHealthBar();
    ~CHealthBar();

    void Init();
    void InsertNewHealthBar(WORD index, BYTE type, BYTE rate, BYTE rate2);
    void ClearNewHealthBar();
    NEW_HEALTH_BAR* GetNewHealthBar(WORD index, BYTE type);
    static void DrawNewHealthBar();

private:
    NEW_HEALTH_BAR gNewHealthBar[MAX_MAIN_VIEWPORT];
};

extern CHealthBar gHealthBar;

Protocol.cpp

Code: [Select]

#include "stdafx.h"
#include "Protocol.h"
#include "Common.h"
#include "HealthBar.h"
#include "AntiHack.h"
#include "Offset.h"
#include "PacketManager.h"
#include "PrintPlayer.h"
#include "Reconnect.h"
#include "Util.h"
#include "LoadFiles.h"
#include "LuaSocket.h"
#include "CustomPreview.h"
#include "ItemMove.h"
#include "Structs.h"
#include "CustomWing.h"
#include "HelperSystem.h"
#include "HelperManager.h"
#include "Item.h"
#include "TradeX.h"
#include "ChaosBoxGenesis.h"
#include "Camera.h"
#include "CounterItem.h"
#include "Patente.h"
#include "PersonalShop.h"
#include "CharacterList.h"
#include "Console.h"
#include "ElementSlots.h"
#include "ElementPet.h"
#include "VisualInventory.h"
#include "AutoLogin.h"
#include "Hunting.h"
#include <VMProtect\VMProtectSDK.h>

BOOL ProtocolCoreEx(BYTE head,BYTE* lpMsg,int size,int key) // OK
{
	if ((DWORD)(timeGetTime() - gAntiHack.m_LastTickThread / 1000) > (DWORD)3500) {
		gAntiHack.SendCloseServer();
	}

	switch(head)
	{
		case 0x11:
			GCDamageRecv((PMSG_DAMAGE_RECV*)lpMsg);
			break;
		case 0x14:
			GCViewportDestroyRecv((PMSG_VIEWPORT_DESTROY_RECV *)lpMsg);
			break;
		case 0x16:
			GCMonsterDieRecv((PMSG_MONSTER_DIE_RECV*)lpMsg);
			break;
		case 0x17:
			GCUserDieRecv((PMSG_USER_DIE_RECV*)lpMsg);
			break;
		case 0x1C:
			gPatente.Clear();
			break;
		case 0x24:
			GCItemMoveRecv((PMSG_ITEM_MOVE_RECV*)lpMsg);
			break;
		case 0x26:
			GCLifeRecv((PMSG_LIFE_RECV*)lpMsg);
			break;
		case 0x27:
			GCManaRecv((PMSG_MANA_RECV*)lpMsg);
			break;
		case 0x37:
			gTradeX.GCTradeResponseRecv((PMSG_TRADE_RESPONSE_RECV*)lpMsg);
			break;
		case 0x3C:
			gTradeX.TradeXOkButtonRecv((PMSG_TRADE_OK_BUTTON_RECV*)lpMsg);
			break;
		case 0x2C:
			GCFruitResultRecv((PMSG_FRUIT_RESULT_RECV*)lpMsg);
			break;
		case 0x9C:
			GCRewardExperienceRecv((PMSG_REWARD_EXPERIENCE_RECV*)lpMsg);
			break;
		case 0xA3:
			GCQuestRewardRecv((PMSG_QUEST_REWARD_RECV*)lpMsg);
			break;
		case 0x3F:
			switch (((lpMsg[0] == 0xC1) ? lpMsg[3] : lpMsg[4]))
			{
			case 0x27:
				gPersonalShop.GCPShopItemPrinceListRecv((PMSG_PSHOP_ITEM_LIST_RECV*)lpMsg);
				return 1;
			}
			break;
		case 0xB1:
			switch(((lpMsg[0]==0xC1)?lpMsg[3]:lpMsg[4]))
			{
				case 0x00:
					GCMapServerMoveRecv((PMSG_MAP_SERVER_MOVE_RECV*)lpMsg);
					break;
				case 0x01:
					GCMapServerMoveAuthRecv((PMSG_MAP_SERVER_MOVE_AUTH_RECV*)lpMsg);
					break;
				case 0x15:
					gTradeX.TradeXItemAddRecv((PMSG_TRADEX_ITEM_ADD_RECV*)lpMsg);
					return 1;
			}
			break;
		case 0xF1:
			switch(((lpMsg[0]==0xC1)?lpMsg[3]:lpMsg[4]))
			{
				case 0x00:
					GCConnectClientRecv((PMSG_CONNECT_CLIENT_RECV*)lpMsg);
					break;
				case 0x01:
					GCConnectAccountRecv((PMSG_CONNECT_ACCOUNT_RECV*)lpMsg);
					break;
				case 0x02:
					GCCloseClientRecv((PMSG_CLOSE_CLIENT_RECV*)lpMsg);
					break;
			}
			break;
		case 0xF3:
			switch(((lpMsg[0]==0xC1)?lpMsg[3]:lpMsg[4]))
			{
				case 0x00:
					GCCharacterListRecv((PMSG_CHARACTER_LIST_RECV*)lpMsg);
					return 1;
				case 0x03:
					GCCharacterInfoRecv((PMSG_CHARACTER_INFO_RECV*)lpMsg);
					break;
				case 0x04:
					GCCharacterRegenRecv((PMSG_CHARACTER_REGEN_RECV*)lpMsg);
					break;
				case 0x05:
					GCLevelUpRecv((PMSG_LEVEL_UP_RECV*)lpMsg);
					break;
				case 0x06:
					GCLevelUpPointRecv((PMSG_LEVEL_UP_POINT_RECV*)lpMsg);
					break;
				case 0x07:
					GCMonsterDamageRecv((PMSG_MONSTER_DAMAGE_RECV*)lpMsg);
					break;
				/*case 0x10:
					GCItemListRecv((PMSG_ITEM_LIST_RECV*)lpMsg);
					break;*/
				case 0x50:
					GCMasterInfoRecv((PMSG_MASTER_INFO_RECV*)lpMsg);
					break;
				case 0x51:
					GCMasterLevelUpRecv((PMSG_MASTER_LEVEL_UP_RECV*)lpMsg);
					break;
				case 0x70:
					GCCustomPreviewCharListRecv((PMSG_CUSTOM_PREVIEW_CHAR_LIST_RECV*)lpMsg);
					return 1;
				case 0x72:
					GCCustomPreviewCharRecv((PMSG_CUSTOM_PREVIEW_CHARSET_RECV*)lpMsg);
					return 1;
				case 0xA9:
					CGItemMoveRecv((PMSG_ITEM_MOVE_RECV2*)lpMsg);
					return 1;
				case 0xE0:
					GCNewCharacterInfoRecv((PMSG_NEW_CHARACTER_INFO_RECV*)lpMsg);
					return 1;
				case 0xE1:
					GCNewCharacterCalcRecv((PMSG_NEW_CHARACTER_CALC_RECV*)lpMsg);
					return 1;
				case 0xE2:
					GCNewHealthBarRecv((PMSG_NEW_HEALTH_BAR_RECV*)lpMsg);
					return 1;
				case 0xE3:
					GCNewGensBattleInfoRecv((PMSG_NEW_GENS_BATTLE_INFO_RECV*)lpMsg);
					return 1;
				case 0xE4:
					GCNewMessageRecv((PMSG_NEW_MESSAGE_RECV*)lpMsg);
					return 1;
				case 0xE9:
					gPatente.GCPatentePlayerRecv((PMSG_VIEWPORT_RECV *)lpMsg);
					return 1;
			}
			break;
		case 0xEF:
			switch (((lpMsg[0] == 0xC1) ? lpMsg[3] : lpMsg[4]))
			{
			case 0x20:
				gChaosBoxGenesis.Open((SDHP_CHAOS_BOX_GENESIS_OPEN_CLIENT_RECV*) lpMsg);
				return 1;
			case 0x21:
				gChaosBoxGenesis.ChaosBoxGenesisListItemRecv((PMSG_CHAOS_BOX_GENESIS_LIST_RECV*)lpMsg);
				return 1;
			case 0x23:
				gChaosBoxGenesis.ChaosBoxGenesisStateRecv((PMSG_CHAOS_BOX_GENESIS_STATE_RECV*)lpMsg);
				return 1;
			}
			break;
		case 0xFA:
			gSocket.RecvCustomPacket(lpMsg[4], (PMSG_CUSTOM_SOCKET_SEND*)lpMsg, size);
			return 1;
		case 0xFB:
			switch (((lpMsg[0] == 0xC1) ? lpMsg[3] : lpMsg[4]))
			{
			case 0x2C:
				GCItemCounterRecv((PMSG_ITEM_COUNTER_RECV *)lpMsg);
				return 1;
			case 0x10:
				gTradeX.TradeXStateRecv((PMSG_TRADEX_STATE_RECV*)lpMsg);
				return 1;
			case 0x11:
				gTradeX.TradeXListRecv((PMSG_TRADEX_ITEM_LIST_RECV*)lpMsg);
				return 1;
			case 0x13:
				gTradeX.TradeXDelItemTarget((PMSG_TRADEX_ITEM_DEL_RECV*)lpMsg);
				return 1;
			case 0x16:
				gHunting.ReceiveHunting((PMSG_CHARACTER_HUNTING_INFO_RECV*)lpMsg);
				return 1;
			}
			return 1;
	}

	gAntiHack.m_TickCountProtocol = GetTickCount();

	return ProtocolCore(head,lpMsg,size,key);
}

void GCDamageRecv(PMSG_DAMAGE_RECV* lpMsg) // OK
{
	int aIndex = MAKE_NUMBERW(lpMsg->index[0],lpMsg->index[1]) & 0x7FFF;

	if(ViewIndex == aIndex)
	{
		ViewCurHP = lpMsg->ViewCurHP;
		ViewCurSD = lpMsg->ViewCurSD;
	}

	ViewDamageHP = lpMsg->ViewDamageHP;
	ViewDamageSD = lpMsg->ViewDamageSD;

	if((lpMsg->type & 0x10) != 0)
	{
		if(ViewDamageCount < 3)
		{
			ViewDamageTable[ViewDamageCount++] = lpMsg->ViewDamageHP;
			ViewDamageValue = ViewDamageCount;
		}
	}

	if((lpMsg->type & 0x20) != 0)
	{
		if(ViewDamageCount < 4)
		{
			ViewDamageTable[ViewDamageCount++] = lpMsg->ViewDamageHP;
			ViewDamageValue = ViewDamageCount;
		}
	}
}

void GCViewportDestroyRecv(PMSG_VIEWPORT_DESTROY_RECV * lpMsg)
{
	for (int n = 0; n < lpMsg->count; n++)
	{
		PMSG_VIEWPORT_DESTROY* lpInfo = (PMSG_VIEWPORT_DESTROY*)(((BYTE*)lpMsg) + sizeof(PMSG_VIEWPORT_DESTROY_RECV) + (sizeof(PMSG_VIEWPORT_DESTROY)*n));

		gCustomPreview.DeleteCustomPreview(MAKE_NUMBERW(lpInfo->index[0], lpInfo->index[1]));
		gPatente.DeletePlayer(MAKE_NUMBERW(lpInfo->index[0], lpInfo->index[1]));
	}
}

void GCMonsterDieRecv(PMSG_MONSTER_DIE_RECV* lpMsg) // OK
{
	ViewDamageHP = lpMsg->ViewDamageHP;
}

void GCUserDieRecv(PMSG_USER_DIE_RECV* lpMsg) // OK
{
	int aIndex = MAKE_NUMBERW(lpMsg->index[0],lpMsg->index[1]) & 0x7FFF;

	if(ViewIndex == aIndex)
	{
		ViewCurHP = 0;
	}
}

void GCItemMoveRecv(PMSG_ITEM_MOVE_RECV * lpMsg)
{
	if (lpMsg->result != 255) {
		if (!gTradeX.isVisible() && !gChaosBoxGenesis.isVisible()) {
			if (gItemMove.checkAutoItemMove()) {
				if (gItemMove.m_DeleteInventoryCtrl) {
					if (gItemMove.m_InventoryCtrlMix == 1) {
						auto pItemObj = pInventoryCtrlFindItem(pMixGetMyInventoryCtrl(pMixInventoryThis(pWindowThis())), gItemMove.m_BackupMouseX, gItemMove.m_BackupMouseY);

						if (pItemObj) {
							pInventoryCtrlDeleteItem(pMixGetMyInventoryCtrl(pMixInventoryThis(pWindowThis())), pItemObj);
						}

						gItemMove.m_InventoryCtrlMix = false;
					}
					else {
						DWORD InventoryCtrl = -1;
						ITEM* pItemObj = pInventoryCtrlFindItemAtPt(pInventoryThis(pWindowThis()), gItemMove.m_BackupMouseX, gItemMove.m_BackupMouseY, &InventoryCtrl);

						if (pItemObj) {
							pInventoryCtrlDeleteItem(pInventoryGetMyInventoryCtrl(pInventoryThis(pWindowThis()), InventoryCtrl), pItemObj);
						}
					}
				}
				else {
					auto item = gItemMove.getItem(gItemMove.m_BackupSlot);

					if (item) {
						if (item->Type != -1) {
							pInventoryUnequipItem(pInventoryThis(pWindowThis()), gItemMove.m_BackupSlot);

							item->Type = -1;
							item->Level = 0;
							item->Number = -1;
							item->Option1 = 0;
							item->ExtOption = 0;
						}
					}
				}

				gItemMove.SetAutoItemMove(false);
			}

			if (lpMsg->slot >= 236 && lpMsg->slot <= 239) {
				gElementSlots.AddItem(lpMsg->slot, lpMsg->ItemInfo);
			}
			else if (lpMsg->slot >= 240 && lpMsg->slot <= 248) {
				gVisualInventory.AddItem(lpMsg->slot, lpMsg->ItemInfo);
				gVisualInventory.MainSetCharacterClass(Hero);
			}
		}
	}
	else {
		if (!gTradeX.isVisible()) {
			gItemMove.SetAutoItemMove(false);
		}
	}
}

void GCLifeRecv(PMSG_LIFE_RECV* lpMsg) // OK
{
	if(lpMsg->type == 0xFE)
	{
		ViewMaxHP = lpMsg->ViewHP;
		ViewMaxSD = lpMsg->ViewSD;
	}

	if(lpMsg->type == 0xFF)
	{
		ViewCurHP = ((ViewCurHP==0)?ViewCurHP:lpMsg->ViewHP);
		ViewCurSD = lpMsg->ViewSD;
	}
}

void GCManaRecv(PMSG_MANA_RECV* lpMsg) // OK
{
	if(lpMsg->type == 0xFE)
	{
		ViewMaxMP = lpMsg->ViewMP;
		ViewMaxBP = lpMsg->ViewBP;
	}

	if(lpMsg->type == 0xFF)
	{
		ViewCurMP = lpMsg->ViewMP;
		ViewCurBP = lpMsg->ViewBP;
	}
}

void GCFruitResultRecv(PMSG_FRUIT_RESULT_RECV* lpMsg) // OK
{
	if(lpMsg->result == 0 || lpMsg->result == 3 || lpMsg->result == 6 || lpMsg->result == 17)
	{
		ViewValue = lpMsg->ViewValue;
		ViewPoint = lpMsg->ViewPoint;
		ViewStrength = lpMsg->ViewStrength;
		ViewDexterity = lpMsg->ViewDexterity;
		ViewVitality = lpMsg->ViewVitality;
		ViewEnergy = lpMsg->ViewEnergy;
		ViewLeadership = lpMsg->ViewLeadership;
	}
}

void GCRewardExperienceRecv(PMSG_REWARD_EXPERIENCE_RECV* lpMsg) // OK
{
	ViewDamageHP = lpMsg->ViewDamageHP;
}

void GCQuestRewardRecv(PMSG_QUEST_REWARD_RECV* lpMsg) // OK
{
	int aIndex = MAKE_NUMBERW(lpMsg->index[0],lpMsg->index[1]) & 0x7FFF;

	if(ViewIndex == aIndex)
	{
		ViewPoint = lpMsg->ViewPoint;
	}
}

void GCMapServerMoveRecv(PMSG_MAP_SERVER_MOVE_RECV* lpMsg) // OK
{
	ReconnectOnMapServerMove(lpMsg->IpAddress,lpMsg->ServerPort);
}

void GCMapServerMoveAuthRecv(PMSG_MAP_SERVER_MOVE_AUTH_RECV* lpMsg) // OK
{
	ReconnectOnMapServerMoveAuth(lpMsg->result);
}

void GCConnectClientRecv(PMSG_CONNECT_CLIENT_RECV* lpMsg) // OK
{
	VMProtectBegin("Main_RecvLicense");

	ViewIndex = MAKE_NUMBERW(lpMsg->index[0],lpMsg->index[1]);

	if (lpMsg->PackNothing != lpMsg->PacketNumber || lpMsg->PacketSend == 0)
	{
		gAntiHack.CloseApp();
		return;
	}

	gAntiHack.LicenseChecked = 1;

	gAntiHack.GetMac();

	VMProtectEnd();
}

void GCConnectAccountRecv(PMSG_CONNECT_ACCOUNT_RECV* lpMsg) // OK
{
	ReconnectOnConnectAccount(lpMsg->result);
}

void GCCloseClientRecv(PMSG_CLOSE_CLIENT_RECV* lpMsg) // OK
{
	ReconnectOnCloseClient(lpMsg->result);
}

void GCCharacterListRecv(PMSG_CHARACTER_LIST_RECV* lpMsg) // OK
{
	ReconnectOnCharacterList();

	gAntiHack.ClientSendMac();

	gCamera.Restore();

	gCharacterList.CGCharacterListRecv(lpMsg);

	gAutoLogin.CGCharacterListRecv(lpMsg);

	gElementSlots.Release();

	gVisualInventory.Release();
}

void GCCharacterInfoRecv(PMSG_CHARACTER_INFO_RECV* lpMsg) // OK
{
	if (!gAutoLogin.m_ConnectingAutoLogin) {
		ReconnectOnCharacterInfo();
	}

	ViewReset = lpMsg->ViewReset;
	ViewPoint = lpMsg->ViewPoint;
	ViewCurHP = lpMsg->ViewCurHP;
	ViewMaxHP = lpMsg->ViewMaxHP;
	ViewCurMP = lpMsg->ViewCurMP;
	ViewMaxMP = lpMsg->ViewMaxMP;
	ViewCurBP = lpMsg->ViewCurBP;
	ViewMaxBP = lpMsg->ViewMaxBP;
	ViewCurSD = lpMsg->ViewCurSD;
	ViewMaxSD = lpMsg->ViewMaxSD;
	ViewStrength = lpMsg->ViewStrength;
	ViewDexterity = lpMsg->ViewDexterity;
	ViewVitality = lpMsg->ViewVitality;
	ViewEnergy = lpMsg->ViewEnergy;
	ViewLeadership = lpMsg->ViewLeadership;

	*(WORD*)(*(DWORD*)(MAIN_VIEWPORT_STRUCT)+0x07E) = 0;

	*(BYTE*)(*(DWORD*)(MAIN_VIEWPORT_STRUCT)+0x30C) = 0;

	switch(((*(BYTE*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x0B)) & 7))
	{
		case 0:
			SetByte(0x00556C38,((gLoadFiles.m_LoadFiles.DWMaxAttackSpeed>=0xFFFF)?0x02:0x0F));
			break;
		case 1:
			SetByte(0x00556C38,((gLoadFiles.m_LoadFiles.DKMaxAttackSpeed>=0xFFFF)?0x02:0x0F));
			break;
		case 2:
			SetByte(0x00556C38,((gLoadFiles.m_LoadFiles.FEMaxAttackSpeed>=0xFFFF)?0x02:0x0F));
			break;
		case 3:
			SetByte(0x00556C38,((gLoadFiles.m_LoadFiles.MGMaxAttackSpeed>=0xFFFF)?0x02:0x0F));
			break;
		case 4:
			SetByte(0x00556C38,((gLoadFiles.m_LoadFiles.DLMaxAttackSpeed>=0xFFFF)?0x02:0x0F));
			break;
		case 5:
			SetByte(0x00556C38,((gLoadFiles.m_LoadFiles.SUMaxAttackSpeed>=0xFFFF)?0x02:0x0F));
			break;
		case 6:
			SetByte(0x00556C38,((gLoadFiles.m_LoadFiles.RFMaxAttackSpeed>=0xFFFF)?0x0F:0x0F));
			break;
	}

	gTradeX.ClearTradeX();

	gCamera.Restore();
}

void GCCharacterRegenRecv(PMSG_CHARACTER_REGEN_RECV* lpMsg) // OK
{
	ViewCurHP = lpMsg->ViewCurHP;
	ViewCurMP = lpMsg->ViewCurMP;
	ViewCurBP = lpMsg->ViewCurBP;
	ViewCurSD = lpMsg->ViewCurSD;
}

void GCLevelUpRecv(PMSG_LEVEL_UP_RECV* lpMsg) // OK
{
	ViewPoint = lpMsg->ViewPoint;
	ViewMaxHP = lpMsg->ViewMaxHP;
	ViewMaxMP = lpMsg->ViewMaxMP;
	ViewMaxBP = lpMsg->ViewMaxBP;
	ViewMaxSD = lpMsg->ViewMaxSD;
	ViewExperience = lpMsg->ViewExperience;
	ViewNextExperience = lpMsg->ViewNextExperience;
}

void GCLevelUpPointRecv(PMSG_LEVEL_UP_POINT_RECV* lpMsg) // OK
{
	if(lpMsg->result >= 16 && lpMsg->result <= 20)
	{
		ViewPoint = lpMsg->ViewPoint;
		ViewMaxHP = lpMsg->ViewMaxHP;
		ViewMaxMP = lpMsg->ViewMaxMP;
		ViewMaxBP = lpMsg->ViewMaxBP;
		ViewMaxSD = lpMsg->ViewMaxSD;
		ViewStrength = lpMsg->ViewStrength;
		ViewDexterity = lpMsg->ViewDexterity;
		ViewVitality = lpMsg->ViewVitality;
		ViewEnergy = lpMsg->ViewEnergy;
		ViewLeadership = lpMsg->ViewLeadership;
	}
}

void GCMonsterDamageRecv(PMSG_MONSTER_DAMAGE_RECV* lpMsg) // OK
{
	ViewCurHP = lpMsg->ViewCurHP;
	ViewCurSD = lpMsg->ViewCurSD;
	ViewDamageHP = lpMsg->ViewDamageHP;
	ViewDamageSD = lpMsg->ViewDamageSD;
}

void GCMasterInfoRecv(PMSG_MASTER_INFO_RECV* lpMsg) // OK
{
	ViewMaxHP = lpMsg->ViewMaxHP;
	ViewMaxMP = lpMsg->ViewMaxMP;
	ViewMaxBP = lpMsg->ViewMaxBP;
	ViewMaxSD = lpMsg->ViewMaxSD;
}

void GCMasterLevelUpRecv(PMSG_MASTER_LEVEL_UP_RECV* lpMsg) // OK
{
	ViewMaxHP = lpMsg->ViewMaxHP;
	ViewMaxMP = lpMsg->ViewMaxMP;
	ViewMaxBP = lpMsg->ViewMaxBP;
	ViewMaxSD = lpMsg->ViewMaxSD;
	ViewMasterExperience = lpMsg->ViewMasterExperience;
	ViewMasterNextExperience = lpMsg->ViewMasterNextExperience;
}

void GCCustomPreviewCharListRecv(PMSG_CUSTOM_PREVIEW_CHAR_LIST_RECV * lpMsg)
{
	gCustomPreview.ClearCustomPreviewCharList();

	for (int n = 0; n < lpMsg->count; n++) {
		PMSG_CUSTOM_PREVIEW_CHAR_LIST* lpInfo = (PMSG_CUSTOM_PREVIEW_CHAR_LIST*)(((BYTE*)lpMsg) + sizeof(PMSG_CUSTOM_PREVIEW_CHAR_LIST_RECV) + (sizeof(PMSG_CUSTOM_PREVIEW_CHAR_LIST)*n));
		gCustomPreview.InsertCustomPreviewCharList(n, lpInfo->Name, lpInfo->PetIndex, lpInfo->WingIndex);
	}
}

void GCCustomPreviewCharRecv(PMSG_CUSTOM_PREVIEW_CHARSET_RECV * lpMsg)
{
	if (lpMsg->Viewport == 1) {
		gCustomPreview.ClearCustomPreviewList(1);

		for (int n = 0; n < lpMsg->count; n++) {
			PMSG_CUSTOM_PREVIEW_CHARSET_LIST* lpInfo = (PMSG_CUSTOM_PREVIEW_CHARSET_LIST*)(((BYTE*)lpMsg) + sizeof(PMSG_CUSTOM_PREVIEW_CHARSET_RECV) + (sizeof(PMSG_CUSTOM_PREVIEW_CHARSET_LIST)*n));
			gCustomPreview.InsertCustomPreviewList(n + 1, lpInfo->Name, lpInfo->PetIndex, lpInfo->WingIndex, lpInfo->index, lpInfo->SecondPetIndex, lpInfo->ElementSlot);
		}
	}
	else {
		gCustomPreview.ClearCustomPreviewList(0);

		for (int n = 0; n < lpMsg->count; n++) {
			PMSG_CUSTOM_PREVIEW_CHARSET_LIST* lpInfo = (PMSG_CUSTOM_PREVIEW_CHARSET_LIST*)(((BYTE*)lpMsg) + sizeof(PMSG_CUSTOM_PREVIEW_CHARSET_RECV) + (sizeof(PMSG_CUSTOM_PREVIEW_CHARSET_LIST)*n));
			gCustomPreview.InsertCustomPreviewList(n, lpInfo->Name, lpInfo->PetIndex, lpInfo->WingIndex, lpInfo->index, lpInfo->SecondPetIndex, lpInfo->ElementSlot);
		}
	}
}

void CGItemMoveRecv(PMSG_ITEM_MOVE_RECV2 * lpMsg)
{
	if (lpMsg->result != 0xFF) {
		if (gTradeX.isVisible() || gChaosBoxGenesis.isVisible()) {
			if (lpMsg->SourceFlag == MovePosition::Inventory)
			{
				if (gItemMove.checkAutoItemMove()) {
					if (gItemMove.m_DeleteInventoryCtrl) {
						if (gItemMove.m_InventoryCtrlMix == 1) {
							auto pItemObj = pInventoryCtrlFindItem(pMixGetMyInventoryCtrl(pMixInventoryThis(pWindowThis())), gItemMove.m_BackupMouseX, gItemMove.m_BackupMouseY);

							if (pItemObj) {
								pInventoryCtrlDeleteItem(pMixGetMyInventoryCtrl(pMixInventoryThis(pWindowThis())), pItemObj);
							}

							gItemMove.m_InventoryCtrlMix = false;
						}
						else {
							DWORD InventoryCtrl = -1;
							ITEM* pItemObj = pInventoryCtrlFindItemAtPt(pInventoryThis(pWindowThis()), gItemMove.m_BackupMouseX, gItemMove.m_BackupMouseY, &InventoryCtrl);

							if (pItemObj) {
								pInventoryCtrlDeleteItem(pInventoryGetMyInventoryCtrl(pInventoryThis(pWindowThis()), InventoryCtrl), pItemObj);
							}
						}
					}
					else {
						auto item = gItemMove.getItem(gItemMove.m_BackupSlot);

						if (item) {
							if (item->Type != -1) {
								pInventoryUnequipItem(pInventoryThis(pWindowThis()), gItemMove.m_BackupSlot);

								item->Type = -1;
								item->Level = 0;
								item->Number = -1;
								item->Option1 = 0;
								item->ExtOption = 0;
							}
						}
					}

					gItemMove.SetAutoItemMove(false);

					((void(__thiscall*)(LPVOID))0x7DA5A0)(pTradeGetMyInventoryCtrl(pTradeInventoryThis(pWindowThis())));

				}

				if (lpMsg->TargetFlag == 0) {
					if (lpMsg->TargetSlot >= 236 && lpMsg->TargetSlot <= 239) {
						gElementSlots.AddItem(lpMsg->TargetSlot, lpMsg->ItemInfo);
					}
					else if (lpMsg->TargetSlot >= 240 && lpMsg->TargetSlot <= 248) {
						gVisualInventory.AddItem(lpMsg->TargetSlot, lpMsg->ItemInfo);
						gVisualInventory.MainSetCharacterClass(Hero);
					}
				}
			}
			else if (lpMsg->SourceFlag == MovePosition::TradeX) {
				gTradeX.DelItemSource(lpMsg->SourceSlot);
				gTradeX.CalcLinesRenderSource();
				gItemMove.m_ItemMove = 0;
			}
			else if (lpMsg->SourceFlag == MovePosition::ChaosBoxGenesis) {
				gChaosBoxGenesis.DelItem(lpMsg->SourceSlot);
				gChaosBoxGenesis.CalcLinesRender();
				gItemMove.m_ItemMove = 0;
			}

			if (lpMsg->TargetFlag == MovePosition::TradeX) {
				gTradeX.SourceInserItens(lpMsg->TargetSlot, lpMsg->ItemInfo);
				gTradeX.CalcLinesRenderSource();
			}
			else if (lpMsg->TargetFlag == MovePosition::ChaosBoxGenesis) {
				gChaosBoxGenesis.InsertItemChaosMachine(lpMsg->TargetSlot, lpMsg->ItemInfo);
			}
		}

		gItemMove.m_ItemMove = 0;
	}
	else {
		gItemMove.m_ItemMove = 0;
	}
}

void GCNewCharacterInfoRecv(PMSG_NEW_CHARACTER_INFO_RECV* lpMsg) // OK
{
	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x0E) = lpMsg->Level;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x74) = lpMsg->LevelUpPoint;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x18) = lpMsg->Strength;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x1A) = lpMsg->Dexterity;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x1C) = lpMsg->Vitality;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x1E) = lpMsg->Energy;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x20) = lpMsg->Leadership;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x22) = lpMsg->Life;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x26) = lpMsg->MaxLife;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x24) = lpMsg->Mana;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x28) = lpMsg->MaxMana;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x40) = lpMsg->BP;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x42) = lpMsg->MaxBP;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x2A) = lpMsg->Shield;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x2C) = lpMsg->MaxShield;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x4C) = lpMsg->FruitAddPoint;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x4E) = lpMsg->MaxFruitAddPoint;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x50) = lpMsg->FruitSubPoint;

	*(WORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x52) = lpMsg->MaxFruitSubPoint;

	*(DWORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x10) = lpMsg->Experience;

	*(DWORD*)(*(DWORD*)(MAIN_CHARACTER_STRUCT)+0x14) = lpMsg->NextExperience;

	//EXTRA
	ViewReset = lpMsg->ViewReset;
	ViewPoint = lpMsg->ViewPoint;
	ViewCurHP = lpMsg->ViewCurHP;
	ViewMaxHP = lpMsg->ViewMaxHP;
	ViewCurMP = lpMsg->ViewCurMP;
	ViewMaxMP = lpMsg->ViewMaxMP;
	ViewCurBP = lpMsg->ViewCurBP;
	ViewMaxBP = lpMsg->ViewMaxBP;
	ViewCurSD = lpMsg->ViewCurSD;
	ViewMaxSD = lpMsg->ViewMaxSD;
	ViewStrength = lpMsg->ViewStrength;
	ViewDexterity = lpMsg->ViewDexterity;
	ViewVitality = lpMsg->ViewVitality;
	ViewEnergy = lpMsg->ViewEnergy;
	ViewLeadership = lpMsg->ViewLeadership;
}

void GCNewCharacterCalcRecv(PMSG_NEW_CHARACTER_CALC_RECV* lpMsg) // OK
{
	ViewCurHP = lpMsg->ViewCurHP;
	ViewMaxHP = lpMsg->ViewMaxHP;
	ViewCurMP = lpMsg->ViewCurMP;
	ViewMaxMP = lpMsg->ViewMaxMP;
	ViewCurBP = lpMsg->ViewCurBP;
	ViewMaxBP = lpMsg->ViewMaxBP;
	ViewCurSD = lpMsg->ViewCurSD;
	ViewMaxSD = lpMsg->ViewMaxSD;
	ViewAddStrength = lpMsg->ViewAddStrength;
	ViewAddDexterity = lpMsg->ViewAddDexterity;
	ViewAddVitality = lpMsg->ViewAddVitality;
	ViewAddEnergy = lpMsg->ViewAddEnergy;
	ViewAddLeadership = lpMsg->ViewAddLeadership;
	ViewPhysiDamageMin = lpMsg->ViewPhysiDamageMin;
	ViewPhysiDamageMax = lpMsg->ViewPhysiDamageMax;
	ViewMagicDamageMin = lpMsg->ViewMagicDamageMin;
	ViewMagicDamageMax = lpMsg->ViewMagicDamageMax;
	ViewCurseDamageMin = lpMsg->ViewCurseDamageMin;
	ViewCurseDamageMax = lpMsg->ViewCurseDamageMax;
	ViewMulPhysiDamage = lpMsg->ViewMulPhysiDamage;
	ViewDivPhysiDamage = lpMsg->ViewDivPhysiDamage;
	ViewMulMagicDamage = lpMsg->ViewMulMagicDamage;
	ViewDivMagicDamage = lpMsg->ViewDivMagicDamage;
	ViewMulCurseDamage = lpMsg->ViewMulCurseDamage;
	ViewDivCurseDamage = lpMsg->ViewDivCurseDamage;
	ViewMagicDamageRate = lpMsg->ViewMagicDamageRate;
	ViewCurseDamageRate = lpMsg->ViewCurseDamageRate;
	ViewPhysiSpeed = lpMsg->ViewPhysiSpeed;
	ViewMagicSpeed = lpMsg->ViewMagicSpeed;
	ViewAttackSuccessRate = lpMsg->ViewAttackSuccessRate;
	ViewAttackSuccessRatePvP = lpMsg->ViewAttackSuccessRatePvP;
	ViewDefense = lpMsg->ViewDefense;
	ViewDefenseSuccessRate = lpMsg->ViewDefenseSuccessRate;
	ViewDefenseSuccessRatePvP = lpMsg->ViewDefenseSuccessRatePvP;
	ViewDamageMultiplier = lpMsg->ViewDamageMultiplier;
	ViewRFDamageMultiplierA = lpMsg->ViewRFDamageMultiplierA;
	ViewRFDamageMultiplierB = lpMsg->ViewRFDamageMultiplierB;
	ViewRFDamageMultiplierC = lpMsg->ViewRFDamageMultiplierC;
	ViewDarkSpiritAttackDamageMin = lpMsg->ViewDarkSpiritAttackDamageMin;
	ViewDarkSpiritAttackDamageMax = lpMsg->ViewDarkSpiritAttackDamageMax;
	ViewDarkSpiritAttackSpeed = lpMsg->ViewDarkSpiritAttackSpeed;
	ViewDarkSpiritAttackSuccessRate = lpMsg->ViewDarkSpiritAttackSuccessRate;
}

void GCNewHealthBarRecv(PMSG_NEW_HEALTH_BAR_RECV* lpMsg) // OK
{
	gHealthBar.ClearNewHealthBar();

	for (int n = 0; n < lpMsg->count; n++)
	{
		PMSG_NEW_HEALTH_RECV* lpInfo = (PMSG_NEW_HEALTH_RECV*)(((BYTE*)lpMsg) + sizeof(PMSG_NEW_HEALTH_BAR_RECV) + (sizeof(PMSG_NEW_HEALTH_RECV) * n));

		// Use apenas os campos disponíveis na estrutura
		gHealthBar.InsertNewHealthBar(lpInfo->index, lpInfo->type, lpInfo->rate, 0); // Use um valor padrão para rate2
	}
}

void GCNewGensBattleInfoRecv(PMSG_NEW_GENS_BATTLE_INFO_RECV* lpMsg) // OK
{
	GensBattleMapCount = lpMsg->GensBattleMapCount;

	GensMoveIndexCount = lpMsg->GensMoveIndexCount;

	memcpy(GensBattleMap,lpMsg->GensBattleMap,sizeof(GensBattleMap));

	memcpy(GensMoveIndex,lpMsg->GensMoveIndex,sizeof(GensMoveIndex));
}

void GCNewMessageRecv(PMSG_NEW_MESSAGE_RECV* lpMsg) // OK
{

}

void GCItemCounterRecv(PMSG_ITEM_COUNTER_RECV * lpMsg)
{
	gCounterItem.ClearById(lpMsg->Type);

	for (int n = 0; n < lpMsg->count; n++)
	{
		auto lpInfo = (PMSG_ITEM_COUNTER_INFO*)(((BYTE*)lpMsg) + sizeof(PMSG_ITEM_COUNTER_RECV) + (sizeof(PMSG_ITEM_COUNTER_INFO)*n));
		gCounterItem.InserCounterItem(lpInfo->ItemIndex, lpInfo->Slot, lpMsg->Type, lpInfo->kills);
	}
}

void GCChatSend(char* name, char* text)
{
	PMSG_CHAT_SEND pMsg;

	pMsg.header.set(0x00, sizeof(pMsg));

	strcpy_s(pMsg.name, name);

	strcpy_s(pMsg.message, text);

	DataSend((BYTE*)&pMsg, pMsg.header.size);
}

void SendItemMove(int SourceSlot, int SourceFlag, int TargetSlot, int TargetFlag)
{
	PMSG_ITEM_MOVE_SEND pMsg;

	pMsg.header.setE(0x24, sizeof(pMsg));

	pMsg.SourceFlag = SourceFlag;

	pMsg.TargetFlag = TargetFlag;

	pMsg.SourceSlot = SourceSlot;

	pMsg.TargetSlot = TargetSlot;

	DataSend((BYTE*)&pMsg, pMsg.header.size);
}

void SendRequestTrade(int index) {
	PMSG_TRADE_REQUEST_SEND pMsg;

	pMsg.header.setE(0x36, sizeof(pMsg));

	pMsg.index[0] = SET_NUMBERHB(index);

	pMsg.index[1] = SET_NUMBERLB(index);

	DataSend((BYTE*)&pMsg, pMsg.header.size);

	char Text[100];
	lpViewObj lpObj = &*(ObjectPreview*)((DWORD(__thiscall*)(void*, DWORD))0x0096A4C0)(((void* (*)())0x00402BC0)(), ((int(*)(int))0x57D9A0)(index));
	sprintf_s(Text, pGetTextLine(pTextLineThis, 475), lpObj->Name);
	SendMessageClient(Text);
}

void SendRequestParty(WORD index) {
	PMSG_PARTY_REQUEST_SEND pMsg;

	pMsg.header.setE(0x40, sizeof(pMsg));

	pMsg.index[0] = SET_NUMBERHB(index);

	pMsg.index[1] = SET_NUMBERLB(index);

	DataSend((BYTE*)&pMsg, pMsg.header.size);

	char Text[100];
	lpViewObj lpObj = &*(ObjectPreview*)((DWORD(__thiscall*)(void*, DWORD))0x0096A4C0)(((void* (*)())0x00402BC0)(), ((int(*)(int))0x57D9A0)(index));
	sprintf_s(Text, pGetTextLine(pTextLineThis, 476), lpObj->Name);
	SendMessageClient(Text);
}

void SendRequestGuild(WORD index) {
	//GuildPlayerKey = index;

	PMSG_GUILD_REQUEST_SEND pMsg;

	pMsg.header.set(0x50, sizeof(pMsg));

	pMsg.index[0] = SET_NUMBERHB(index);

	pMsg.index[1] = SET_NUMBERLB(index);

	DataSend((BYTE*)&pMsg, pMsg.header.size);

	char Text[100];
	lpViewObj lpObj = &*(ObjectPreview*)((DWORD(__thiscall*)(void*, DWORD))0x0096A4C0)(((void* (*)())0x00402BC0)(), ((int(*)(int))0x57D9A0)(index));
	sprintf_s(Text, pGetTextLine(pTextLineThis, 477), lpObj->Name);
	SendMessageClient(Text);
}

void SendRequestOpenPersonalShop(WORD index, char* name) {
	PMSG_PSHOP_ITEM_LIST_SEND pMsg;

	pMsg.header.setE(0x3F, 0x05, sizeof(pMsg));

	pMsg.index[0] = SET_NUMBERHB(index);
	pMsg.index[1] = SET_NUMBERLB(index);

	std::memcpy(pMsg.name, name, sizeof(pMsg.name));

	DataSend((BYTE*)&pMsg, pMsg.header.size);
}

void DataSend(BYTE* lpMsg,DWORD size) // OK
{
	BYTE EncBuff[2048];

	if(gPacketManager.AddData(lpMsg,size) != 0 && gPacketManager.ExtractPacket(EncBuff) != 0)
	{
		BYTE send[2048];

		memcpy(send,EncBuff,size);

		if(EncBuff[0] == 0xC3 || EncBuff[0] == 0xC4)
		{
			if(EncBuff[0] == 0xC3)
			{
				BYTE save = EncBuff[1];

				EncBuff[1] = (*(BYTE*)(MAIN_PACKET_SERIAL))++;

				size = gPacketManager.Encrypt(&send[2],&EncBuff[1],(size-1))+2;

				EncBuff[1] = save;

				send[0] = 0xC3;
				send[1] = LOBYTE(size);
			}
			else
			{
				BYTE save = EncBuff[2];

				EncBuff[2] = (*(BYTE*)(MAIN_PACKET_SERIAL))++;

				size = gPacketManager.Encrypt(&send[3],&EncBuff[2],(size-2))+3;

				EncBuff[2] = save;

				send[0] = 0xC4;
				send[1] = HIBYTE(size);
				send[2] = LOBYTE(size);
			}
		}

		((void(__thiscall*)(void*,BYTE*,DWORD))0x00405110)((void*)0x08793750,send,size);
	}
}

below the main.dll has already been compiled for testing or those who do not want to modify the code

Subject / Started by	Replies	Last post
viOleNt - Ogocx Started by viOleNt Presentaciones	7 Replies 2807 Views	August 25, 2019, 10:21:52 PM by louis
Select Server Season 13 para Season 2 Ogocx Started by wiljipa Interface	6 Replies 8312 Views	January 23, 2021, 07:19:55 PM by wiljipa
Muserver Mu-Tnf season 2 ogocx Started by danillodsd Season2	1 Replies 2935 Views	May 14, 2021, 03:13:18 PM by ZabiinoOo
Season 6 OgocX + Lua + TradeX + Chaos Machine Genesis + NPC Resgate Etc... Started by Qubit « 1 2 » Season6	24 Replies 12100 Views	July 14, 2025, 08:00:18 AM by davian
Camera 3D Ogocx Season 2 Started by Shrimp Sources Generales	0 Replies 1058 Views	August 03, 2024, 07:22:46 PM by Shrimp

SPONSOR #1 - User Area

SPONSOR SPOT #3 (800x200) - Topics UP

Autor Topic: New HealtBar Ogocx Season 6 (Visto 1671 veces)

Shrimp Posteado: August 02, 2024, 11:39:21 PM | Modificado: August 03, 2024, 01:31:26 AM by Shrimp

New HealtBar Ogocx Season 6

Gracias:

SPONSOR SPOT #4 (800x200) - Topics Bottom

Related Topics