pass
https://www.muserverfiles.com/

Este código MODELSKINFIX es para la base SSEMu y Muemu - Season 6


En esta publicación, compartiremos un fragmento de código que permite la carga de modelos de piel en la base SSEMu y Muemu para la Season 6. Este código incluye la configuración de modelos y texturas personalizadas que enriquecerán la experiencia del usuario.

Esta línea define una constante llamada MODELSKINFIX que se utiliza para ajustar el índice de los modelos de piel.
Carga de Modelos y Texturas:

La sección principal del código se encuentra dentro de la función LoadModels(), donde se cargan diferentes modelos de piel y sus respectivas texturas.
Se verifica si un botón del menú está activado (MenuButtons[12] == 1) y, si es así, se procede a cargar varios modelos de piel desde una carpeta específica.
Carga de Múltiples Modelos:

El código utiliza un bucle para cargar múltiples modelos de piel (Skin1, Skin2, etc.) y sus texturas asociadas. Esto permite que los jugadores cambien la apariencia de sus personajes en el juego.
Cada modelo se carga con un índice que se incrementa en base a MODELSKINFIX, lo que permite una fácil identificación y gestión de los modelos.
Interacción con la Interfaz de Usuario:

El código también incluye lógica para manejar la interacción del usuario con la interfaz gráfica del juego.
Se dibujan botones que permiten al usuario navegar entre diferentes modelos de piel (siguiente y anterior) y se actualiza la apariencia del personaje según la selección del usuario.
Cambio de Piel:

Si el usuario selecciona un modelo de piel, el código actualiza la apariencia del personaje utilizando la función SetChangeSkin(), que aplica el modelo seleccionado.
Resumen
En resumen, este código permite la personalización de la apariencia de los personajes en un juego basado en SSEMu y Muemu al cargar modelos de piel y texturas personalizadas. Facilita la interacción del jugador con la interfaz para seleccionar diferentes skins, mejorando la experiencia de juego.




#define MODELSKINFIX 8000


    if (gProtect.m_MainInfo.MenuButtons[12] == 1)
    {

        //===Test Load SKin
        pLoadModel(2000 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin1", -1);
        pLoadTexture(2000 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2001 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin2", -1);
        pLoadTexture(2001 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2002 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin3", -1);
        pLoadTexture(2002 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2003 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin4", -1);
        pLoadTexture(2003 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2004 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin5", -1);
        pLoadTexture(2004 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2005 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin6", -1);
        pLoadTexture(2005 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2006 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin7", -1);
        pLoadTexture(2006 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2007 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin8", -1);
        pLoadTexture(2007 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2008 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin9", -1);
        pLoadTexture(2008 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2009 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin10", -1);
        pLoadTexture(2009 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2010 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin11", -1);
        pLoadTexture(2010 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2011 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin12", -1);
        pLoadTexture(2011 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2012 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin13", -1);
        pLoadTexture(2012 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2013 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin19", -1);
        pLoadTexture(2013 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2014 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin21", -1);
        pLoadTexture(2014 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2015 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin22", -1);
        pLoadTexture(2015 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2016 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin23", -1);
        pLoadTexture(2016 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2017 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin24", -1);
        pLoadTexture(2017 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2018 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Skin25", -1);
        pLoadTexture(2018 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);

        // ----
        pLoadModel(2019 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Bigmoon", -1);
        pLoadTexture(2019 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);

        // ----
        pLoadModel(2020 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Doflamingo", -1);
        pLoadTexture(2020 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);
        // ----
        pLoadModel(2021 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "Shirohige", -1);
        pLoadTexture(2021 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);

        // ----
        pLoadModel(2022 + MODELSKINFIX, "Data\\Custom\\Bmd\\Skin\\", "skinsbakugo", -1);
        pLoadTexture(2022 + MODELSKINFIX, "Custom\\Bmd\\Skin\\", 0x2901, 0x2600, 1);

    }
    gInterface.DrawGUI(eWindow_SkinModelNext, StartX + (CuaSoW)-40, StartY + 80);
    if (gInterface.IsWorkZone(eWindow_SkinModelNext))
    {
        DWORD Color = eGray150;
        gInterface.DrawColoredGUI(eWindow_SkinModelNext, gInterface.Data[eWindow_SkinModelNext].X, gInterface.Data[eWindow_SkinModelNext].Y, Color);
        if (GetTickCount() - gInterface.Data[eTIME].EventTick > 300) //Click
        {
            if (GetKeyState(1) & 0x8000)
            {
                gInterface.Data[eTIME].EventTick = GetTickCount();
                if (NumberSelect < (gInterface.m_SkinModelData.size() - 1) && NumberSelect != -1)
                {
                    NumberSelect += 1;
                    character.SetChangeSkin(gInterface.m_SkinModelData[NumberSelect].SkinIndex + MODELSKINFIX);
                    CacheSkinSet = true;
                    SkinModelGetInfo();
                }


            }
        }
    }
    if (gInterface.IsWorkZone(eWindow_SkinModelPREV))
    {
        DWORD Color = eGray150;
        gInterface.DrawColoredGUI(eWindow_SkinModelPREV, gInterface.Data[eWindow_SkinModelPREV].X, gInterface.Data[eWindow_SkinModelPREV].Y, Color);
        if (GetTickCount() - gInterface.Data[eTIME].EventTick > 300) //Click
        {
            if (GetKeyState(1) & 0x8000)
            {
                //character.SetChangeSkin(-1); //<<<<<
                gInterface.Data[eTIME].EventTick = GetTickCount();
                if (NumberSelect > 0 && NumberSelect != -1)
                {
                    NumberSelect -= 1;
                    character.SetChangeSkin(gInterface.m_SkinModelData[NumberSelect].SkinIndex + MODELSKINFIX);
                    CacheSkinSet = true;
                    SkinModelGetInfo();

                }


            }
        }
    }
    if (NumberSelect == -1 && ((int(__cdecl*)(int)) 0x57D9A0)(oHero1) != 400)
    {
        character.SetChangeSkin(gInterface.m_SkinModelData[0].SkinIndex + MODELSKINFIX);
        NumberSelect = 0;
        SkinModelGetInfo();

    }

V 0.2


#include "stdafx.h"
#include "layout.h"
#include "Interface.h"
#include "Central.h"
#include "Defines.h"
#include <windows.h>

// Inicializa o gLayout e as variáveis de drag dentro da classe
CLayout::CLayout()
{

}

CLayout gLayout;

void CLayout::UpdateLayoutPanelWindow()
{
    // Variável estática para controlar o estado da tecla F4
    static bool isF4Pressed = false;
    bool currentF4State = (GetAsyncKeyState(VK_F4) & 0x8000) != 0;

    if (currentF4State && !isF4Pressed)
    {
        // Alterna a flag de exibição do painel
        gInterface.Data[eLayout_MAIN].OnShow = !gInterface.Data[eLayout_MAIN].OnShow;
        isF4Pressed = true;
    }
    else if (!currentF4State)
    {
        isF4Pressed = false;
    }
}

// Variáveis globais existentes...
bool   m_isDragging = false;
POINT  m_dragStartPoint;
float m_windowPosX((MAX_WIN_WIDTH - 230.0f) / 2);
float m_windowPosY((MAX_WIN_HEIGHT - 240.0f) / 2);

void CLayout::DrawLayoutPanelWindow()
{
    // Verifica se o painel deve ser exibido
    if (!gInterface.Data[eLayout_MAIN].OnShow)
        return;

    // Garante foco do cursor (certifique-se de que a variável esteja declarada corretamente)
    pSetCursorFocus = true;

    // Dimensões fixas do painel
    const float MainWidth = 230.0f;
    const float MainHeight = 240.0f;

    // Lógica para drag and drop: se o mouse estiver sobre o painel ou se já estiver sendo arrastado
    if (pCheckMouseOver(m_windowPosX, m_windowPosY, MainWidth, MainHeight) || m_isDragging)
    {
        // Se o botão esquerdo está pressionado
        if (GetAsyncKeyState(VK_LBUTTON) & 0x8000)
        {
            if (!m_isDragging)
            {
                // Inicia o arraste: registra a posição corrente do cursor
                m_isDragging = true;
                m_dragStartPoint.x = pCursorX;
                m_dragStartPoint.y = pCursorY;
            }
            else
            {
                // Atualiza a posição com base na variação do cursor
                float deltaX = pCursorX - m_dragStartPoint.x;
                float deltaY = pCursorY - m_dragStartPoint.y;

                m_windowPosX += deltaX;
                m_windowPosY += deltaY;

                // Limita para não ultrapassar a borda esquerda e direita
                if (m_windowPosX < 0)
                    m_windowPosX = 0;
                else if (m_windowPosX > MAX_WIN_WIDTH - MainWidth)
                    m_windowPosX = MAX_WIN_WIDTH - MainWidth;

                // Limita para não ultrapassar a borda superior e inferior
                if (m_windowPosY < 0)
                    m_windowPosY = 0;
                else if (m_windowPosY > MAX_WIN_HEIGHT - MainHeight)
                    m_windowPosY = MAX_WIN_HEIGHT - MainHeight;

                // Atualiza o ponto de referência para o próximo cálculo
                m_dragStartPoint.x = pCursorX;
                m_dragStartPoint.y = pCursorY;
            }
        }
        else
        {
            // Se o botão não está pressionado, encerra o drag
            m_isDragging = false;
        }
    }
    else
    {
        m_isDragging = false;
    }

    // Desenha o painel flutuante na posição atual
    gCentral.PrintDropBox(m_windowPosX, m_windowPosY, MainWidth, MainHeight, 0, 0);

    // DWORD Color é mantido aqui para eventuais usos gráficos
    DWORD Color = eGray100;
}


#pragma once
#ifndef LAYOUT_H
#define LAYOUT_H

#include <windows.h>

class CLayout
{
public:
    CLayout();

    // Atualiza o estado do painel (toggle F4 e drag and drop)
    void UpdateLayoutPanelWindow();

    // Desenha o painel flutuante na posição atual
    void DrawLayoutPanelWindow();
};

extern CLayout gLayout;

#endif // LAYOUT_H



redits Primary to My T-LEGENDARY and:

X-Team
MuEmu
T-LEGENDARY

Window movable - Tela flutuante press F4


Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión






#include "stdafx.h"
#include "layout.h"
#include "Interface.h"
#include "Central.h"
#include "Defines.h"
#include <windows.h>

// Inicializa o gLayout e as variáveis de drag dentro da classe
CLayout::CLayout()
    : m_isDragging(false)
    // Inicializa o painel centralizado (ou ajuste conforme sua necessidade)
    , m_windowPosX((MAX_WIN_WIDTH - 230.0f) / 2)
    , m_windowPosY((MAX_WIN_HEIGHT - 240.0f) / 2)
{
}

CLayout gLayout;

void CLayout::UpdateLayoutPanelWindow()
{
    // Variável estática para acompanhar se a tecla F4 está pressionada
    static bool isF4Pressed = false;

    // Verifica o estado atual da tecla F4. O bit de ordem alta (0x8000) indica que a tecla está pressionada.
    bool currentF4State = (GetAsyncKeyState(VK_F4) & 0x8000) != 0;

    // Se F4 acabou de ser pressionada (transição de não pressionada para pressionada)
    if (currentF4State && !isF4Pressed)
    {
        // Alterna a flag de exibição
        gInterface.Data[eLayout_MAIN].OnShow = !gInterface.Data[eLayout_MAIN].OnShow;
        isF4Pressed = true;
    }
    // Reseta o estado quando a tecla for solta
    else if (!currentF4State)
    {
        isF4Pressed = false;
    }
}

void CLayout::DrawLayoutPanelWindow()
{
    // Se o painel não estiver ativo, não desenha nada

    if (!gInterface.Data[eLayout_MAIN].OnShow)
    {
        return;
    }

    pSetCursorFocus = true; // Certifique-se de que esta variável está corretamente declarada.

    float MainWidth = 230.0f;
    float MainHeight = 240.0f;

    // Lógica para arrastar a janela
    // Usamos m_windowPosX e m_windowPosY (posição atual do painel) para permitir o drag
    if (pCheckMouseOver(m_windowPosX, m_windowPosY, MainWidth, MainHeight) || m_isDragging)
    {
        // Se o botão esquerdo do mouse estiver pressionado...
        if (GetAsyncKeyState(VK_LBUTTON) & 0x8000)
        {
            if (!m_isDragging)
            {
                // Inicia o arraste: armazena o ponto de início do arraste (posição atual do cursor)
                m_isDragging = true;
                m_dragStartPoint.x = pCursorX;
                m_dragStartPoint.y = pCursorY;
            }
            else
            {
                // Calcula a variação (delta) do movimento do mouse
                float deltaX = pCursorX - m_dragStartPoint.x;
                float deltaY = pCursorY - m_dragStartPoint.y;

                m_windowPosX += deltaX;
                m_windowPosY += deltaY;

                // Limita a posição X para que o painel não ultrapasse as bordas da tela
                if (m_windowPosX < 0)
                    m_windowPosX = 0;
                else if (m_windowPosX > MAX_WIN_WIDTH - MainWidth)
                    m_windowPosX = MAX_WIN_WIDTH - MainWidth;

                // Limita a posição Y
                if (m_windowPosY < 0)
                    m_windowPosY = 0;
                else if (m_windowPosY > MAX_WIN_HEIGHT - MainHeight)
                    m_windowPosY = MAX_WIN_HEIGHT - MainHeight;

                // Atualiza o ponto de arraste para a próxima verificação
                m_dragStartPoint.x = pCursorX;
                m_dragStartPoint.y = pCursorY;
            }
        }
        else
        {
            // Se o botão não estiver pressionado, interrompe o arraste
            m_isDragging = false;
        }
    }
    else
    {
        m_isDragging = false;
    }

    // Exibe o painel flutuante na posição atual (m_windowPosX, m_windowPosY)
    gCentral.PrintDropBox(m_windowPosX, m_windowPosY, MainWidth, MainHeight, 0, 0);

    DWORD Color = eGray100; // Exemplo para uso em elementos gráficos adicionais
}



#pragma once
#ifndef LAYOUT_H
#define LAYOUT_H

#include <windows.h>

class CLayout
{
public:
    CLayout();

    // Atualiza o estado do painel (toggle F4 e drag and drop)
    void UpdateLayoutPanelWindow();

    // Desenha o painel flutuante na posição atual
    void DrawLayoutPanelWindow();

private:
    // Variáveis para controle do drag and drop
    bool   m_isDragging;
    POINT  m_dragStartPoint;
    float  m_windowPosX;
    float  m_windowPosY;
};

extern CLayout gLayout;

#endif // LAYOUT_H




gLayout.UpdateLayoutPanelWindow();
gLayout.DrawLayoutPanelWindow();



Creditos
Credits Primary to My T-LEGENDARY and:

X-Team
MuEmu
T-LEGENDARY

https://mega.nz/file/MuMiDaDS#ZbgHd_OeZxxAdIv6gdIoP09Dl_ef8Dw7Jfq93AuNS70
https://mega.nz/file/lrNmFDwb#KB6awAfwVnMtTurQ0oAMOZcIqyFT3BQJRCEG1-Bp08g

Regalo
Disfrutenlo

CREDITOS: takumi12

NewUIMuHelper.h
Spoiler for Hiden:
#pragma once
#include "NewUIBase.h"
#include "NewUIManager.h"
#include "NewUIButton.h"

namespace SEASON3B
{
    class CNewUIMuHelper : public CNewUIObj
    {
    public:
        enum IMAGE_LIST
        {
            IMAGE_BASE_WINDOW_BACK = CNewUIMessageBoxMng::IMAGE_MSGBOX_BACK,
            IMAGE_BASE_WINDOW_TOP = CNewUIMyInventory::IMAGE_INVENTORY_BACK_TOP,
            IMAGE_BASE_WINDOW_LEFT = CNewUIMyInventory::IMAGE_INVENTORY_BACK_LEFT,
            IMAGE_BASE_WINDOW_RIGHT = CNewUIMyInventory::IMAGE_INVENTORY_BACK_RIGHT,
            IMAGE_BASE_WINDOW_BOTTOM = CNewUIMyInventory::IMAGE_INVENTORY_BACK_BOTTOM,
            IMAGE_BASE_WINDOW_BTN_EXIT = CNewUIMyInventory::IMAGE_INVENTORY_EXIT_BTN,
            IMAGE_TABLE_TOP_LEFT = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_TOP_LEFT,
            IMAGE_TABLE_TOP_RIGHT = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_TOP_RIGHT,
            IMAGE_TABLE_BOTTOM_LEFT = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_BOTTOM_LEFT,
            IMAGE_TABLE_BOTTOM_RIGHT = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_BOTTOM_RIGHT,
            IMAGE_TABLE_TOP_PIXEL = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_TOP_PIXEL,
            IMAGE_TABLE_BOTTOM_PIXEL = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_BOTTOM_PIXEL,
            IMAGE_TABLE_LEFT_PIXEL = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_LEFT_PIXEL,
            IMAGE_TABLE_RIGHT_PIXEL = CNewUIInventoryCtrl::IMAGE_ITEM_TABLE_RIGHT_PIXEL,
            IMAGE_WINDOW_TAB_BTN = CNewUIGuildInfoWindow::IMAGE_GUILDINFO_TAB_BUTTON,
            IMAGE_MACROUI_HELPER_RAGEMINUS = BITMAP_INTERFACE_MACROUI_BEGIN,
            IMAGE_MACROUI_HELPER_OPTIONBUTTON = BITMAP_INTERFACE_MACROUI_BEGIN + 1,
            IMAGE_MACROUI_HELPER_INPUTNUMBER = BITMAP_INTERFACE_MACROUI_BEGIN + 2,
            IMAGE_MACROUI_HELPER_INPUTSTRING = BITMAP_INTERFACE_MACROUI_BEGIN + 3,
            IMAGE_CHAINFO_BTN_STAT = BITMAP_INTERFACE_NEW_CHAINFO_WINDOW_BEGIN + 1,
            IMAGE_CLEARNESS_BTN = BITMAP_CURSEDTEMPLE_BEGIN + 4,
            IMAGE_IGS_BUTTON = BITMAP_IGS_MSGBOX_BUTTON,
        };
        // ... (resto del código)
    };
}

NewUIMuHelper.cpp

#include "stdafx.h"
#include "NewUISystem.h"

#include "NewUIMuHelper.h"


SEASON3B::CNewUIMuHelper::CNewUIMuHelper()
{
m_pNewUIMng = NULL;
m_Pos.x = m_Pos.y = 0;
m_ButtonList.clear();
m_iNumCurOpenTab = 0;
}

SEASON3B::CNewUIMuHelper::~CNewUIMuHelper()
{
Release();
}

bool SEASON3B::CNewUIMuHelper::Create(CNewUIManager* pNewUIMng, int x, int y)
{
if (NULL == pNewUIMng)
return false;

m_pNewUIMng = pNewUIMng;
m_pNewUIMng->AddUIObj(SEASON3B::INTERFACE_MUHELPER, this);

SetPos(x, y);

LoadImages();

InitButtons();

InitCheckBox();

InitImage();

InitText();

Show(false);

return true;
}

void SEASON3B::CNewUIMuHelper::Release()
{
UnloadImages();

if (m_pNewUIMng)
{
m_pNewUIMng->RemoveUIObj(this);
m_pNewUIMng = NULL;
}
}

void SEASON3B::CNewUIMuHelper::SetPos(int x, int y)
{
m_Pos.x = x;
m_Pos.y = y;
}

void SEASON3B::CNewUIMuHelper::InitButtons()
{
std::list<unicode::t_string> ltext;
ltext.push_back(GlobalText[3500]);
ltext.push_back(GlobalText[3501]);
ltext.push_back(GlobalText[3590]);

m_TabBtn.CreateRadioGroup(3, IMAGE_WINDOW_TAB_BTN, TRUE);
m_TabBtn.ChangeRadioText(ltext);
m_TabBtn.ChangeRadioButtonInfo(true, m_Pos.x + 10.f, m_Pos.y + 48.f, 56, 22);
m_TabBtn.ChangeFrame(m_iNumCurOpenTab);

InsertButton(IMAGE_CHAINFO_BTN_STAT, m_Pos.x + 56, m_Pos.y + 78, 16, 15, 0, 0, 0, 0, "", "", 0, 0);
InsertButton(IMAGE_MACROUI_HELPER_RAGEMINUS, m_Pos.x + 56, m_Pos.y + 97, 16, 15, 0, 0, 0, 0, "", "", 1, 0);
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 132, m_Pos.y + 191, 38, 24, 1, 0, 1, 1, GlobalText[3502], "", 2, 0); //-- skill 2
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 132, m_Pos.y + 243, 38, 24, 1, 0, 1, 1, GlobalText[3502], "", 3, 0); //-- skill 3
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 132, m_Pos.y + 84, 38, 24, 1, 0, 1, 1, GlobalText[3502], "", 4, 0); //-- Buff
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 132, m_Pos.y + 79, 38, 24, 1, 0, 1, 1, GlobalText[3502], "", 5, 0); //-- potion
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 132, m_Pos.y + 84, 38, 24, 1, 0, 1, 1, GlobalText[3502], "", 6, 0); //-- potion
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 17, m_Pos.y + 234, 38, 24, 1, 0, 1, 1, GlobalText[3502], "", 7, 0); //-- potion
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 17, m_Pos.y + 234, 38, 24, 1, 0, 1, 1, GlobalText[3502], "", 8, 0); //-- potion
InsertButton(IMAGE_CHAINFO_BTN_STAT, m_Pos.x + 56, m_Pos.y + 78, 16, 15, 0, 0, 0, 0, "", "", 9, 1);
InsertButton(IMAGE_MACROUI_HELPER_RAGEMINUS, m_Pos.x + 56, m_Pos.y + 97, 16, 15, 0, 0, 0, 0, "", "", 10, 1);
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 132, m_Pos.y + 208, 38, 24, 1, 0, 1, 1, GlobalText[3505], "", 11, 1); //-- Buff
InsertButton(IMAGE_CLEARNESS_BTN, m_Pos.x + 132, m_Pos.y + 309, 38, 24, 1, 0, 1, 1, GlobalText[3506], "", 12, 1); //-- Buff
//--
InsertButton(IMAGE_IGS_BUTTON, m_Pos.x + 120, m_Pos.y + 388, 52, 26, 1, 0, 1, 1, GlobalText[3503], "", 13, -1);
InsertButton(IMAGE_IGS_BUTTON, m_Pos.x + 65, m_Pos.y + 388, 52, 26, 1, 0, 1, 1, GlobalText[3504], "", 14, -1);
InsertButton(IMAGE_BASE_WINDOW_BTN_EXIT, m_Pos.x + 20, m_Pos.y + 388, 36, 29, 0, 0, 0, 0, "", GlobalText[388], 15, -1);

RegisterBtnCharacter(0xFF, 0);
RegisterBtnCharacter(0xFF, 1);
RegisterBtnCharacter(0xFF, 2);
RegisterBtnCharacter(0xFF, 9);
RegisterBtnCharacter(0xFF, 10);
RegisterBtnCharacter(0xFF, 11);
RegisterBtnCharacter(0xFF, 12);
RegisterBtnCharacter(0xFF, 13);
RegisterBtnCharacter(0xFF, 15);
RegisterBtnCharacter(0xFF, 14);

RegisterBtnCharacter(Dark_Knight, 3);
RegisterBtnCharacter(Dark_Knight, 6);

RegisterBtnCharacter(Dark_Wizard, 3);
RegisterBtnCharacter(Dark_Wizard, 6);
RegisterBtnCharacter(Dark_Wizard, 7);

RegisterBtnCharacter(Magic_Gladiator, 3);
RegisterBtnCharacter(Magic_Gladiator, 6);
RegisterBtnCharacter(Dark_Lord, 6);

RegisterBtnCharacter(Rage_Fighter, 3);
RegisterBtnCharacter(Rage_Fighter, 6);

RegisterBtnCharacter(Fairy_Elf, 3);
RegisterBtnCharacter(Fairy_Elf, 4);
RegisterBtnCharacter(Fairy_Elf, 8);

RegisterBtnCharacter(Summoner, 3);
RegisterBtnCharacter(Summoner, 5);
}

void SEASON3B::CNewUIMuHelper::InitCheckBox()
{
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 79, m_Pos.y + 80, 15, 15, 0, GlobalText[3507], 0, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 18, m_Pos.y + 122, 15, 15, 0, GlobalText[3508], 1, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 18, m_Pos.y + 137, 15, 15, 0, GlobalText[3509], 2, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 94, m_Pos.y + 174, 15, 15, 0, GlobalText[3510], 3, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 94, m_Pos.y + 191, 15, 15, 0, GlobalText[3511], 4, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 94, m_Pos.y + 226, 15, 15, 0, GlobalText[3510], 5, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 94, m_Pos.y + 243, 15, 15, 0, GlobalText[3511], 6, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 18, m_Pos.y + 226, 15, 15, 0, GlobalText[3512], 7, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 25, m_Pos.y + 276, 15, 15, 0, GlobalText[3513], 8, 0);

InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 60, m_Pos.y + 218, 15, 15, 0, GlobalText[3514], 9, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 15, m_Pos.y + 218, 15, 15, 0, GlobalText[3515], 10, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 79, m_Pos.y + 97, 15, 15, 0, GlobalText[3516], 11, 0);
InsertCheckBox(BITMAP_OPTION_BEGIN + 5, m_Pos.x + 79, m_Pos.y + 97, 15, 15, 0, GlobalText[3517], 12, 0);

InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 79, m_Pos.y + 80, 15, 15, 0, GlobalText[3518], 13, 1);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 17, m_Pos.y + 125, 15, 15, 0, GlobalText[3519], 14, 1);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 17, m_Pos.y + 152, 15, 15, 0, GlobalText[3520], 15, 1);

InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 22, m_Pos.y + 170, 15, 15, 0, GlobalText[3521], 16, 1);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 85, m_Pos.y + 170, 15, 15, 0, GlobalText[3522], 17, 1);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 22, m_Pos.y + 185, 15, 15, 0, GlobalText[3523], 18, 1);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 85, m_Pos.y + 185, 15, 15, 0, GlobalText[3524], 19, 1);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 22, m_Pos.y + 200, 15, 15, 0, GlobalText[3525], 20, 1);
//--
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 18, m_Pos.y + 80, 15, 15, 0, GlobalText[3591], 21, 2);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 18, m_Pos.y + 97, 15, 15, 0, GlobalText[3592], 23, 2);
InsertCheckBox(BITMAP_OPTION_BEGIN+5, m_Pos.x + 18, m_Pos.y + 125, 15, 15, 0, GlobalText[3594], 22, 2);

RegisterBoxCharacter(0xFF, 0);
RegisterBoxCharacter(0xFF, 1);
RegisterBoxCharacter(0xFF, 2);
RegisterBoxCharacter(0xFF, 3);
RegisterBoxCharacter(0xFF, 4);
RegisterBoxCharacter(0xFF, 8);
RegisterBoxCharacter(0xFF, 13);
RegisterBoxCharacter(0xFF, 14);
RegisterBoxCharacter(0xFF, 15);
RegisterBoxCharacter(0xFF, 16);
RegisterBoxCharacter(0xFF, 17);
RegisterBoxCharacter(0xFF, 19);
RegisterBoxCharacter(0xFF, 18);
RegisterBoxCharacter(0xFF, 20);
RegisterBoxCharacter(0xFF, 21);
RegisterBoxCharacter(0xFF, 23);
RegisterBoxCharacter(0xFF, 22);

RegisterBoxCharacter(Dark_Knight, 5);
RegisterBoxCharacter(Dark_Knight, 6);
RegisterBoxCharacter(Dark_Knight, 7);

RegisterBoxCharacter(Dark_Wizard, 5);
RegisterBoxCharacter(Dark_Wizard, 6);
RegisterBoxCharacter(Dark_Wizard, 10);

RegisterBoxCharacter(Magic_Gladiator, 5);
RegisterBoxCharacter(Magic_Gladiator, 6);

RegisterBoxCharacter(Dark_Lord, 9);

RegisterBoxCharacter(Fairy_Elf, 11);
RegisterBoxCharacter(Fairy_Elf, 5);
RegisterBoxCharacter(Fairy_Elf, 6);
RegisterBoxCharacter(Fairy_Elf, 10);

RegisterBoxCharacter(Summoner, 5);
RegisterBoxCharacter(Summoner, 6);
RegisterBoxCharacter(Summoner, 12);

RegisterBoxCharacter(Rage_Fighter, 5);
RegisterBoxCharacter(Rage_Fighter, 6);
}

void SEASON3B::CNewUIMuHelper::InitImage()
{
InsertTexture(BITMAP_INTERFACE_NEW_SKILLICON_BEGIN + 4, m_Pos.x + 17, m_Pos.y + 171, 32, 38, 0, 0);
InsertTexture(BITMAP_INTERFACE_NEW_SKILLICON_BEGIN + 4, m_Pos.x + 61, m_Pos.y + 171, 32, 38, 1, 0);
InsertTexture(BITMAP_INTERFACE_NEW_SKILLICON_BEGIN + 4, m_Pos.x + 61, m_Pos.y + 222, 32, 38, 2, 0);
InsertTexture(BITMAP_INTERFACE_NEW_SKILLICON_BEGIN + 4, m_Pos.x + 21, m_Pos.y + 293, 32, 38, 3, 0);
InsertTexture(BITMAP_INTERFACE_NEW_SKILLICON_BEGIN + 4, m_Pos.x + 55, m_Pos.y + 293, 32, 38, 4, 0);
InsertTexture(BITMAP_INTERFACE_NEW_SKILLICON_BEGIN + 4, m_Pos.x + 89, m_Pos.y + 293, 32, 38, 5, 0);

InsertTexture(IMAGE_MACROUI_HELPER_INPUTNUMBER, m_Pos.x + 135, m_Pos.y + 137, 28, 15, 6, 0);
InsertTexture(IMAGE_MACROUI_HELPER_INPUTNUMBER, m_Pos.x + 135, m_Pos.y + 174, 28, 15, 7, 0);
InsertTexture(IMAGE_MACROUI_HELPER_INPUTNUMBER, m_Pos.x + 135, m_Pos.y + 226, 28, 15, 8, 0);
InsertTexture(IMAGE_MACROUI_HELPER_INPUTSTRING, m_Pos.x + 34, m_Pos.y + 216, 93, 15, 9, 1);


RegisterTextureCharacter(0xFF, 0);
RegisterTextureCharacter(0xFF, 1);
RegisterTextureCharacter(0xFF, 3);
RegisterTextureCharacter(0xFF, 4);
RegisterTextureCharacter(0xFF, 5);
RegisterTextureCharacter(0xFF, 6);
RegisterTextureCharacter(0xFF, 7);
RegisterTextureCharacter(0xFF, 9);


RegisterTextureCharacter(Dark_Knight, 2);
RegisterTextureCharacter(Dark_Knight, 8);
RegisterTextureCharacter(Dark_Wizard, 2);
RegisterTextureCharacter(Dark_Wizard, 8);
RegisterTextureCharacter(Fairy_Elf, 2);
RegisterTextureCharacter(Fairy_Elf, 8);
RegisterTextureCharacter(Magic_Gladiator, 2);
RegisterTextureCharacter(Magic_Gladiator, 8);
RegisterTextureCharacter(Summoner, 2);
RegisterTextureCharacter(Summoner, 8);
RegisterTextureCharacter(Rage_Fighter, 2);
RegisterTextureCharacter(Rage_Fighter, 8);
}

void SEASON3B::CNewUIMuHelper::InitText()
{
InsertText(m_Pos.x + 18, m_Pos.y + 78, GlobalText[3526], 1, 0);
InsertText(m_Pos.x + 18, m_Pos.y + 83, "________", 2, 0);
InsertText(m_Pos.x + 113, m_Pos.y + 141, GlobalText[3527], 3, 0);
InsertText(m_Pos.x + 162, m_Pos.y + 141, GlobalText[3528], 4, 0);
InsertText(m_Pos.x + 18, m_Pos.y + 160, GlobalText[3529], 5, 0);
InsertText(m_Pos.x + 59, m_Pos.y + 160, GlobalText[3530], 7, 0);
InsertText(m_Pos.x + 162, m_Pos.y + 178, GlobalText[3527], 8, 0);
InsertText(m_Pos.x + 59, m_Pos.y + 212, GlobalText[3531], 9, 0);

InsertText(m_Pos.x + 162, m_Pos.y + 230, GlobalText[3527], 10, 0);
InsertText(m_Pos.x + 18, m_Pos.y + 78, GlobalText[3532], 11, 1);
InsertText(m_Pos.x + 18, m_Pos.y + 83, "________", 12, 1);

RegisterTextCharacter(0xFF, 1);
RegisterTextCharacter(0xFF, 2);
RegisterTextCharacter(0xFF, 3);
RegisterTextCharacter(0xFF, 4);
RegisterTextCharacter(0xFF, 5);
RegisterTextCharacter(0xFF, 7);
RegisterTextCharacter(0xFF, 8);
RegisterTextCharacter(0xFF, 11);
RegisterTextCharacter(0xFF, 12);

RegisterTextCharacter(Dark_Knight, 9);
RegisterTextCharacter(Dark_Knight, 10);
RegisterTextCharacter(Dark_Wizard, 9);
RegisterTextCharacter(Dark_Wizard, 10);
RegisterTextCharacter(Fairy_Elf, 9);
RegisterTextCharacter(Fairy_Elf, 10);
RegisterTextCharacter(Magic_Gladiator, 9);
RegisterTextCharacter(Magic_Gladiator, 10);
RegisterTextCharacter(Summoner, 9);
RegisterTextCharacter(Summoner, 10);
RegisterTextCharacter(Rage_Fighter, 9);
RegisterTextCharacter(Rage_Fighter, 10);
}

bool SEASON3B::CNewUIMuHelper::Update()
{
if (IsVisible())
{
int iNumCurOpenTab = m_TabBtn.UpdateMouseEvent();

if (iNumCurOpenTab == RADIOGROUPEVENT_NONE)
return true;

m_iNumCurOpenTab = iNumCurOpenTab;
}
return true;
}

bool SEASON3B::CNewUIMuHelper::UpdateMouseEvent()
{
/*switch (m_iNumCurOpenTab)
{
case TAB_GATE_MANAGING:
UpdateGateManagingTab();
break;
case TAB_STATUE_MANAGING:
UpdateStatueManagingTab();
break;
case TAB_TAX_MANAGING:
UpdateTaxManagingTab();
break;
}

if (true == BtnProcess())
return false;*/

POINT ptExitBtn1 = { m_Pos.x + 169, m_Pos.y + 7 };
POINT ptExitBtn2 = { m_Pos.x + 13, m_Pos.y + 391 };

if (SEASON3B::IsRelease(VK_LBUTTON) && CheckMouseIn(ptExitBtn1.x, ptExitBtn1.y, 13, 12))
{
g_pNewUISystem->Hide(SEASON3B::INTERFACE_MUHELPER);
}

int Identificador = UpdateMouseBtnList();

if (Identificador == 15)
{
g_pNewUISystem->Hide(SEASON3B::INTERFACE_MUHELPER);
return false;
}

UpdateMouseBoxList();


if (CheckMouseIn(m_Pos.x, m_Pos.y, WINDOW_WIDTH, WINDOW_HEIGHT))
return false;
return true;
}

bool SEASON3B::CNewUIMuHelper::UpdateKeyEvent()
{
if (IsVisible())
{
if (SEASON3B::IsPress(VK_ESCAPE) == true)
{
g_pNewUISystem->Hide(SEASON3B::INTERFACE_MUHELPER);
//PlayBuffer(SOUND_CLICK01);

return false;
}
}
return true;
}

float SEASON3B::CNewUIMuHelper::GetLayerDepth()
{
return 3.4;
}

float SEASON3B::CNewUIMuHelper::GetKeyEventOrder()
{
return 3.4;
}

bool SEASON3B::CNewUIMuHelper::Render()
{
EnableAlphaTest();
glColor4f(1.f, 1.f, 1.f, 1.f);

DWORD TextColor = g_pRenderText->GetTextColor();

g_pRenderText->SetFont(g_hFont);
g_pRenderText->SetTextColor(0xFFFFFFFF);

g_pRenderText->SetBgColor(0);


RenderImage(IMAGE_BASE_WINDOW_BACK, m_Pos.x, m_Pos.y, float(WINDOW_WIDTH), float(WINDOW_HEIGHT));
RenderImage(IMAGE_BASE_WINDOW_TOP, m_Pos.x, m_Pos.y, float(WINDOW_WIDTH), 64.f);
RenderImage(IMAGE_BASE_WINDOW_LEFT, m_Pos.x, m_Pos.y + 64.f, 21.f, float(WINDOW_HEIGHT) - 64.f - 45.f);
RenderImage(IMAGE_BASE_WINDOW_RIGHT, m_Pos.x + float(WINDOW_WIDTH) - 21.f, m_Pos.y + 64.f, 21.f, float(WINDOW_HEIGHT) - 64.f - 45.f);
RenderImage(IMAGE_BASE_WINDOW_BOTTOM, m_Pos.x, m_Pos.y + float(WINDOW_HEIGHT) - 45.f, float(WINDOW_WIDTH), 45.f);


g_pRenderText->SetFont(g_hFontBold);

g_pRenderText->RenderText(m_Pos.x, m_Pos.y + 13, GlobalText[3536], 190, 0, RT3_SORT_CENTER);

RenderBack(m_Pos.x + 12, m_Pos.y + 340, 165, 46);

g_pRenderText->SetFont(g_hFont);
g_pRenderText->RenderText(m_Pos.x + 20, m_Pos.y + 347, GlobalText[3537], 0, 0, RT3_SORT_CENTER);

g_pRenderText->SetTextColor(0xFF00B4FF);
g_pRenderText->RenderText(m_Pos.x + 20, m_Pos.y + 365, GlobalText[3538], 0, 0, RT3_SORT_CENTER);

g_pRenderText->SetTextColor(TextColor);

int sTapIndex = m_iNumCurOpenTab;

m_TabBtn.Render();

if (sTapIndex)
{
if (sTapIndex == 1)
{
RenderBack(m_Pos.x + 12, m_Pos.y + 73, 68, 50);
RenderBack(m_Pos.x + 75, m_Pos.y + 73, 102, 50);
RenderBack(m_Pos.x + 12, m_Pos.y + 120, 165, 30);
RenderBack(m_Pos.x + 12, m_Pos.y + 147, 165, 195);
RenderBack(m_Pos.x + 16, m_Pos.y + 235, 158, 74);

RenderImage(BITMAP_INTERFACE_CRYWOLF_BEGIN + 34, m_Pos.x + 29, m_Pos.y + 92, 15, 19, 0.f, 0.f, 15.f / 16.f, 19.f / 32.f);
}
else
{
RenderBack(m_Pos.x + 12, m_Pos.y + 73, 165, 50);
RenderBack(m_Pos.x + 12, m_Pos.y + 120, 165, 222);
}

}
else
{
RenderBack(m_Pos.x + 12, m_Pos.y + 73, 68, 50);
RenderBack(m_Pos.x + 75, m_Pos.y + 73, 102, 50);
RenderBack(m_Pos.x + 12, m_Pos.y + 120, 165, 39);
RenderBack(m_Pos.x + 12, m_Pos.y + 156, 165, 120);
RenderBack(m_Pos.x + 12, m_Pos.y + 273, 165, 69);

RenderImage(BITMAP_INTERFACE_CRYWOLF_BEGIN + 33, m_Pos.x + 29, m_Pos.y + 92, 15, 19, 0.f, 0.f, 15.f / 16.f, 19.f / 32.f);
}

RenderBtnList();
RenderBoxList();
RenderTextureList();
RenderTextList();
DisableAlphaBlend();

return true;
}

void SEASON3B::CNewUIMuHelper::RenderBack(int x, int y, int width, int height)
{
EnableAlphaTest();
glColor4f(0.0, 0.0, 0.0, 0.4f);
RenderColor(x+3.f, y+2.f, width-7.f, height-7, 0.0, 0);
EndRenderColor();

RenderImage(IMAGE_TABLE_TOP_LEFT, x, y, 14.0, 14.0);
RenderImage(IMAGE_TABLE_TOP_RIGHT, (x + width) - 14.f, y, 14.0, 14.0);
RenderImage(IMAGE_TABLE_BOTTOM_LEFT, x, (y + height) - 14.f, 14.0, 14.0);
RenderImage(IMAGE_TABLE_BOTTOM_RIGHT, (x + width) - 14.f, (y + height) - 14.f, 14.0, 14.0);
RenderImage(IMAGE_TABLE_TOP_PIXEL, x + 6.f, y, (width - 12.f), 14.0);
RenderImage(IMAGE_TABLE_RIGHT_PIXEL, (x + width) - 14.f, y + 6.f, 14.0, (height - 14.f));
RenderImage(IMAGE_TABLE_BOTTOM_PIXEL, x + 6.f, (y + height) - 14.f, (width - 12.f), 14.0);
RenderImage(IMAGE_TABLE_LEFT_PIXEL, x, (y + 6.f), 14.0, (height - 14.f));
}

void SEASON3B::CNewUIMuHelper::LoadImages()
{
LoadBitmap("Interface\\MacroUI\\MacroUI_RangeMinus.tga", IMAGE_MACROUI_HELPER_RAGEMINUS, GL_LINEAR, GL_CLAMP, 1, 0);
LoadBitmap("Interface\\MacroUI\\MacroUI_OptionButton.tga", IMAGE_MACROUI_HELPER_OPTIONBUTTON, GL_LINEAR, GL_CLAMP, 1, 0);
LoadBitmap("Interface\\MacroUI\\MacroUI_InputNumber.tga", IMAGE_MACROUI_HELPER_INPUTNUMBER, GL_LINEAR, GL_CLAMP, 1, 0);
LoadBitmap("Interface\\MacroUI\\MacroUI_InputString.tga", IMAGE_MACROUI_HELPER_INPUTSTRING, GL_LINEAR, GL_CLAMP, 1, 0);
//--
LoadBitmap("Interface\\InGameShop\\Ingame_Bt03.tga", IMAGE_IGS_BUTTON, GL_LINEAR, GL_CLAMP, 1, 0);

}

void SEASON3B::CNewUIMuHelper::UnloadImages()
{
DeleteBitmap(IMAGE_MACROUI_HELPER_RAGEMINUS);
DeleteBitmap(IMAGE_MACROUI_HELPER_OPTIONBUTTON);
DeleteBitmap(IMAGE_MACROUI_HELPER_INPUTNUMBER);
DeleteBitmap(IMAGE_MACROUI_HELPER_INPUTSTRING);
//--
DeleteBitmap(IMAGE_IGS_BUTTON);
}

//===============================================================================================================
//===============================================================================================================

void SEASON3B::CNewUIMuHelper::RegisterButton(int Identificador, CButtonTap button)
{
m_ButtonList.insert(std::pair<int, CButtonTap>(Identificador, button));
}

void SEASON3B::CNewUIMuHelper::RegisterBtnCharacter(BYTE class_character, int Identificador)
{
cButtonMap::iterator li = m_ButtonList.find(Identificador);

if (li != m_ButtonList.end())
{
CButtonTap* cBTN = &li->second;
if (class_character >= 0 && class_character < max_class_s6+2)
{
cBTN->class_character[class_character] = TRUE;
}
else
{
memset(cBTN->class_character, 1, sizeof(cBTN->class_character));
}
}
}

void SEASON3B::CNewUIMuHelper::InsertButton(int imgindex, int x, int y, int sx, int sy, bool overflg, bool isimgwidth, bool bClickEffect, bool MoveTxt, unicode::t_string btname, unicode::t_string tooltiptext, int Identificador, int iNumTab)
{
CButtonTap cBTN;
CNewUIButton* button = new CNewUIButton();

button->ChangeButtonImgState(1, imgindex, overflg, isimgwidth, bClickEffect);
button->ChangeButtonInfo(x, y, sx, sy);

button->ChangeText(btname);
button->ChangeToolTipText(tooltiptext, TRUE);

if (MoveTxt)
{
button->MoveTextPos(0, -1);
}

cBTN.btn = button;
cBTN.iNumTab = iNumTab;
memset(cBTN.class_character, 0, sizeof(cBTN.class_character));

RegisterButton(Identificador, cBTN);
}

void SEASON3B::CNewUIMuHelper::RenderBtnList()
{
cButtonMap::iterator li = m_ButtonList.begin();

for (; li != m_ButtonList.end(); li++)
{
CButtonTap* cBTN = &li->second;

if ((cBTN->class_character[(0xF & Hero->Class)]) && (cBTN->iNumTab == m_iNumCurOpenTab || cBTN->iNumTab == -1))
{
cBTN->btn->Render();
}
}
}

int SEASON3B::CNewUIMuHelper::UpdateMouseBtnList()
{
int Identificador = -1;

cButtonMap::iterator li = m_ButtonList.begin();

for (; li != m_ButtonList.end(); li++)
{
CButtonTap* cBTN = &li->second;

if ((cBTN->class_character[(0xF & Hero->Class)]) && (cBTN->iNumTab == m_iNumCurOpenTab || cBTN->iNumTab == -1))
{
if (cBTN->btn->UpdateMouseEvent())
{
return li->first;
}
}
}
return Identificador;
}

//===============================================================================================================
//===============================================================================================================

void SEASON3B::CNewUIMuHelper::RegisterBoxCharacter(BYTE class_character, int Identificador)
{
cCheckBoxMap::iterator li = m_CheckBoxList.find(Identificador);

if (li != m_CheckBoxList.end())
{
CheckBoxTap* cBOX = &li->second;

if (class_character >= 0 && class_character < max_class_s6 + 2)
{
cBOX->class_character[class_character] = TRUE;
}
else
{
memset(cBOX->class_character, 1, sizeof(cBOX->class_character));
}
}
}

void SEASON3B::CNewUIMuHelper::RegisterCheckBox(int Identificador, CheckBoxTap button)
{
m_CheckBoxList.insert(std::pair<int, CheckBoxTap>(Identificador, button));
}

void SEASON3B::CNewUIMuHelper::InsertCheckBox(int imgindex, int x, int y, int sx, int sy, bool overflg, unicode::t_string btname, int Identificador, int iNumTab)
{
CheckBoxTap cBOX;

CNewUICheckBox* cbox = new CNewUICheckBox;

cbox->CheckBoxImgState(imgindex);
cbox->CheckBoxInfo(x, y, sx, sy);

cbox->ChangeText(btname);
cbox->RegisterBoxState(overflg);

cBOX.box = cbox;
cBOX.iNumTab = iNumTab;
memset(cBOX.class_character, 0, sizeof(cBOX.class_character));

RegisterCheckBox(Identificador, cBOX);
}

void SEASON3B::CNewUIMuHelper::RenderBoxList()
{
cCheckBoxMap::iterator li = m_CheckBoxList.begin();

for (; li != m_CheckBoxList.end(); li++)
{
CheckBoxTap* cBOX = &li->second;

if ((cBOX->class_character[(0xF & Hero->Class)]) && (cBOX->iNumTab == m_iNumCurOpenTab || cBOX->iNumTab == -1))
{
cBOX->box->Render();
}
}
}

int SEASON3B::CNewUIMuHelper::UpdateMouseBoxList()
{
int Identificador = -1;

cCheckBoxMap::iterator li = m_CheckBoxList.begin();

for (; li != m_CheckBoxList.end(); li++)
{
CheckBoxTap* cBOX = &li->second;

if ((cBOX->class_character[(0xF & Hero->Class)]) && (cBOX->iNumTab == m_iNumCurOpenTab || cBOX->iNumTab == -1))
{
if (cBOX->box->UpdateMouseEvent())
{
return li->first;
}
}
}
return Identificador;
}

//===============================================================================================================
//===============================================================================================================

void SEASON3B::CNewUIMuHelper::RenderTextureList()
{
cTextureMap::iterator li = m_TextureList.begin();

for (; li != m_TextureList.end(); li++)
{
cTexture* cImage = &li->second;

if ((cImage->class_character[(0xF & Hero->Class)]) && (cImage->iNumTab == m_iNumCurOpenTab || cImage->iNumTab == -1))
{
RenderImage(cImage->s_ImgIndex, cImage->m_Pos.x, cImage->m_Pos.y, cImage->m_Size.x, cImage->m_Size.y);
}
}
}

int SEASON3B::CNewUIMuHelper::UpdateTextureList()
{
int Identificador = -1;

cTextureMap::iterator li = m_TextureList.begin();

for (; li != m_TextureList.end(); li++)
{
cTexture* cImage = &li->second;

if ((cImage->class_character[(0xF & Hero->Class)]) && (cImage->iNumTab == m_iNumCurOpenTab || cImage->iNumTab == -1))
{
if (CheckMouseIn(cImage->m_Pos.x, cImage->m_Pos.y, cImage->m_Size.x, cImage->m_Size.y))
{
return li->first;
}
}
}

return Identificador;
}

void SEASON3B::CNewUIMuHelper::RegisterTextureCharacter(BYTE class_character, int Identificador)
{
cTextureMap::iterator li = m_TextureList.find(Identificador);

if (li != m_TextureList.end())
{
cTexture* cImage = &li->second;

if (class_character >= 0 && class_character < max_class_s6 + 2)
{
cImage->class_character[class_character] = TRUE;
}
else
{
memset(cImage->class_character, 1, sizeof(cImage->class_character));
}
}
}

void SEASON3B::CNewUIMuHelper::RegisterTexture(int Identificador, cTexture button)
{
m_TextureList.insert(std::pair<int, cTexture>(Identificador, button));
}

void SEASON3B::CNewUIMuHelper::InsertTexture(int imgindex, int x, int y, int sx, int sy, int Identificador, int iNumTab)
{
cTexture cImage;

cImage.s_ImgIndex = imgindex;
cImage.m_Pos.x = x;
cImage.m_Pos.y = y;
cImage.m_Size.x = sx;
cImage.m_Size.y = sy;
cImage.iNumTab = iNumTab;

memset(cImage.class_character, 0, sizeof(cImage.class_character));

RegisterTexture(Identificador, cImage);
}

//===============================================================================================================
//===============================================================================================================

void SEASON3B::CNewUIMuHelper::RenderTextList()
{
cTextNameMap::iterator li = m_TextNameList.begin();

for (; li != m_TextNameList.end(); li++)
{
cTextName* cImage = &li->second;

if ((cImage->class_character[(0xF & Hero->Class)]) && (cImage->iNumTab == m_iNumCurOpenTab || cImage->iNumTab == -1))
{
g_pRenderText->RenderText(cImage->m_Pos.x, cImage->m_Pos.y, cImage->m_Name.c_str());
}
}
}

void SEASON3B::CNewUIMuHelper::RegisterTextCharacter(BYTE class_character, int Identificador)
{
cTextNameMap::iterator li = m_TextNameList.find(Identificador);

if (li != m_TextNameList.end())
{
cTextName* cImage = &li->second;

if (class_character >= 0 && class_character < max_class_s6 + 2)
{
cImage->class_character[class_character] = TRUE;
}
else
{
memset(cImage->class_character, 1, sizeof(cImage->class_character));
}
}
}

void SEASON3B::CNewUIMuHelper::RegisterTextur(int Identificador, cTextName button)
{
m_TextNameList.insert(std::pair<int, cTextName>(Identificador, button));
}

void SEASON3B::CNewUIMuHelper::InsertText(int x, int y, unicode::t_string Name, int Identificador, int iNumTab)
{
cTextName cText;

cText.m_Pos.x = x;
cText.m_Pos.y = y;
cText.m_Name = Name;
cText.iNumTab = iNumTab;

memset(cText.class_character, 0, sizeof(cText.class_character));
RegisterTextur(Identificador, cText);
}


Spoiler for Hiden:
#include "stdafx.h"
#include "NewUISystem.h"
#include "NewUIMuHelper.h"


Mu Server Season 18 Epi 19

Aquí tienes el contenido reformateado en BBCode, sin etiquetas HTML y manteniendo la estructura que solicitaste:







Ahora está correctamente formateado en BBCode. Puedes copiar y pegar esto directamente en tu foro.

[Main 5.2] Source Render Party List v2

bool CNewUIPartyListWindow::Render()
{
if (!m_bActive)
return true;

EnableAlphaTest();
glColor4f(1.f, 1.f, 1.f, 1.f);

g_pRenderText->SetFont(g_hFont);
g_pRenderText->SetTextColor(255, 255, 255, 255);
g_pRenderText->SetBgColor(0, 0, 0, 0);

for (int i = 0; i < PartyNumber; i++)
{
int iVal = i * m_iVal;

switch (Party[i].cClass)
{
case 0:RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW1, m_Pos.x - 32, (m_Pos.y - 2) + iVal, 103, 26, 0.f, (64.f / 256.f) * 1, 1.0, 64.f / 256.f, 1, 1, 0); break;
case 1:RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW1, m_Pos.x - 32, (m_Pos.y - 2) + iVal, 103, 26, 0.f, (64.f / 256.f) * 2, 1.0, 64.f / 256.f, 1, 1, 0); break;
case 2:RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW1, m_Pos.x - 32, (m_Pos.y - 2) + iVal, 103, 26, 0.f, (64.f / 256.f) * 3, 1.0, 64.f / 256.f, 1, 1, 0); break;
case 3:RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW2, m_Pos.x - 32, (m_Pos.y - 2) + iVal, 103, 26, 0.f, 0.f, 1.0, 64.f / 256.f, 1, 1, 0); break;
case 4:RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW2, m_Pos.x - 32, (m_Pos.y - 2) + iVal, 103, 26, 0.f, (64.f / 256.f) * 1, 1.0, 64.f / 256.f, 1, 1, 0); break;
case 5:RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW2, m_Pos.x - 32, (m_Pos.y - 2) + iVal, 103, 26, 0.f, (64.f / 256.f) * 2, 1.0, 64.f / 256.f, 1, 1, 0); break;
case 6:RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW2, m_Pos.x - 32, (m_Pos.y - 2) + iVal, 103, 26, 0.f, (64.f / 256.f) * 3, 1.0, 64.f / 256.f, 1, 1, 0); break;
}

RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP_NEW1, m_Pos.x - 33, (m_Pos.y - 7) + iVal, 150, 37, 0.f, 0.f, 1.0, 64.f / 256.f, 1, 1, 0);
}
for (int i = 0; i < PartyNumber; i++)
{
int iVal = i * m_iVal;

char pClass[255];

if (i == 0)
{
if (Party[i].index == -1)
{
g_pRenderText->SetTextColor(RGBA(128, 75, 11, 255));
}
else
{
g_pRenderText->SetTextColor(RGBA(255, 148, 22, 255));
}
RenderImage(IMAGE_PARTY_LIST_FLAG, m_Pos.x + 77, m_Pos.y + 6, 9, 10);
g_pRenderText->RenderText(m_Pos.x + 5, m_Pos.y + 3 + iVal, Party[i].Name, m_iLimitUserIDHeight[0], 0, RT3_SORT_LEFT);
}
else
{
if (Party[i].index == -1)
{
g_pRenderText->SetTextColor(RGBA(128, 128, 128, 255));
}
else
{
g_pRenderText->SetTextColor(RGBA(255, 255, 255, 255));
}
g_pRenderText->RenderText(m_Pos.x + 5, m_Pos.y + 3 + iVal, Party[i].Name, m_iLimitUserIDHeight[1], 0, RT3_SORT_LEFT);
}

int iStepHP = min(10, Party[i].stepHP);
float fLife = ((float)iStepHP / (float)10) * (float)PARTY_LIST_HP_BAR_WIDTH;

int iHP = (Party[i].currHP * 66) / Party[i].maxHP;
RenderBitmap(SEASON3B::CNewUIPartyInfoWindow::IMAGE_UI_BARHP, m_Pos.x + 4, m_Pos.y + 5 + iVal, 70, 19, 0.f, 0.f, 1.0, 64.f / 256.f, 1, 1, 0);
RenderImage(SEASON3B::CNewUIPartyInfoWindow::IMAGE_PARTY_HPBAR, m_Pos.x + 6, (m_Pos.y + 13) + iVal, iHP, 3);
if (!strcmp(Party[0].Name, Hero->ID) || !strcmp(Party[i].Name, Hero->ID))
{
m_BtnPartyExit[i].Render();
}
}

DisableAlphaBlend();

return true;
}

enum IMAGES add: (And of course, you can use your own TGA image files as replacements.)

LoadBitmap("Interface\\SPK\\PartyBarNew_1.tga", IMAGE_UI_BARHP_NEW1, GL_LINEAR);
LoadBitmap("Interface\\SPK\\PartyBarNew_2.tga", IMAGE_UI_BARHP_NEW2, GL_LINEAR);

Don't forget to free resources after loading images into the game.
DELETEBITMAP(IMAGE);

IMAGE_UI_BARHP_NEW1 = BITMAP_CHECK_BTN_BANK_01 + 31,
IMAGE_UI_BARHP_NEW2,

struct PARTY_t
Add -> BYTE cClass;

Find: void ReceivePartyList(const BYTE* ReceiveBuffer)
Add-> p->cClass = Data2->cClass;

Go to GS Src, search Packet 0x42 then add Class in there!

Result:
Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión


Link:
Descargar Aqui


Creditos
SPK

Hello everyone
Es un largo tiempo desde que he lanzado algo para la comunidad, así que aquí hay un regalo de Navidad tardío.

Full unlimited premium update 31 para ti.

Images:
Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión

Los visitantes no pueden visualizar imágenes en los mensajes, por favor Regístrate o Inicia Sesión


Watch videos about all updates on my youtube channel: https://www.youtube.com/@louisemulator

CHANGELOG:
UPDATE 12:
JULY 2018
- Custom NPC move
- CustomCommandInfo (v2)
- Custom RankUser OverHead
- Custom Party Icon(s4/s6)
- Trade Value
- Party Disable PK
- New Anti SpeedHack Skill System
- Update TvtEvent new requistes
- Add Auto Heal Skill in /Attack
- Add Global Password System
- Option to show Rankuser in all places
- Option to Hide Reset in Rankuser
- Option to Hide MReset in Rankuser
- Option to Change MReset name in Rankuser
- Disable Party HpBar option
- Increase CustomShops to 100
- Fixes in custom buy vip windows
- Others fixes

UPDATE 13:
AUGUST
- GS and GSCS new interface
- MasterReset remove fixed resets
- Command Start Invasion
- Command Start Custom Arena
- Custom Quest Command (v2)
- Custom EventTime (v2)
- Custom Npc Quest
- Custom Npc Name up to 100
- Custom Pick (v2)
- Add Custom Pick Excelent
- Add Custom Pick Socket
- Add Custom Pick SetItem
- Enable Lucky item trade
- Disable Duel Restore HP
- Disable Duel Restore SD
- Require Reset/MResets to enter in room
- Add Reset/MasterReset Requisite on Create Character
- Fixes in MapServerMove
- Other fixes

... (continúa con el resto del changelog)

UPDATE 31:
- Chaos Mix item log
- Character Start Gate by map
- Command /make /drop updated
- Experience rate option
- Gate/Move check Level+Master level
- Guild Alliance Disable PK Option
- Item plus remove level amount option
- Max Level 65000
- New Admin commands
- Required item level check master level option
- Server log utf-8 option
- Fix remove iron skill when reset master skill tree(S8)
- Fix total points in the skill tree, over 255 (S6)
- Fix Life Stone drop in the common GS
- Fix EventItemBag stack drop
- Fix Castle siege icon change when get the crown
- Fix item info close client in widescreen (S6)
- Fix menu icon type 1 when shows item info window

Downloads:
Server: https://www.4shared.com/s/foo1c5JDFjq

Cliente: https://www.4shared.com/rar/YN3azJpdea/ClientS8_Base.html

Mu editor update 31+: https://www.4shared.com/s/fd43gjTHwiq

:beer :beer :beer

Créditos:
X-team
MuEmu
louis
Haziel
Smiley
Mentor
Hugo
Hinetworks
Emershow
MyHeart