Source Custom Option Window MuEmu – SSeMu

Estructura General

Inclusiones de Archivos:

#include "stdafx.h"
#include "CustomOptionWindow.h"
#include "Import.h"
#include "Defines.h"
#include "TMemory.h"
#include "Util.h"
#include "Offset.h"
#include "Interface.h"
#include "CustomMessage.h"
#include "CustomFog.h"
#include "CustomDisableSystem.h"
#include "Common.h"
#include "CustomFont.h"
#include "CChatEx.h"
#include "Font.h"
#include "WindowsStruct.h"
//#include "InterfaceBase.h"

Estas líneas incluyen varios archivos de encabezado que probablemente contienen definiciones y declaraciones necesarias para el funcionamiento del código.

Definiciones de Variables:

CHAR ReturnedString1[20];
CHAR ReturnedString2[20];
CHAR ReturnedString3[20];
CHAR ReturnedString4[20];
//int FontSize = GetPrivateProfileIntA("FontConfig", "Main_Font_Height", 13, "./Settings.ini");;
int dword_10407904;
int dword_10407908;
int dword_1040790C;
int dword_10407910;
int dword_10407914;
int Resolucion;
int TickCount;
float flt_1040F5CC;
int dword_1040F5E8;
float flt_1040F5D0;
float flt_1040F5D4;
float flt_1040F5D8;
int dword_1040F5E0;

Aquí se definen varias variables, algunas de las cuales parecen ser cadenas de caracteres y otras enteros que probablemente se utilizan para almacenar configuraciones o estados dentro del juego.

Clase COptionWindow:
- Constructor y Destructor:
```
COptionWindow::COptionWindow(void) { }
COptionWindow::~COptionWindow(void) { }
          
```
  Estos son métodos que se llaman al crear y destruir instancias de la clase COptionWindow.

Métodos Clave

CheckButtonPressed:
```
bool COptionWindow::CheckButtonPressed(int x, int y, int w, int h) {
    return pCheckMouseOver(x, y, w, h) && *(BYTE*)0x8793386;
}
    
```
Este método verifica si un botón específico ha sido presionado, comprobando si el ratón está sobre las coordenadas del botón y si un byte específico en memoria (probablemente relacionado con el estado del juego) es verdadero.
Main:
```
void COptionWindow::Main() {
    SetCompleteHook(0xE8, 0x00848CB6, &COptionWindow::SetButtonInfo);
    // Más ganchos...
}
    
```
Este método establece varios «hooks» (ganchos) en direcciones de memoria específicas, lo que sugiere que el código está interceptando o extendiendo la funcionalidad de otras partes del juego.
Renderización:
- RenderFrame y RenderContents: Estos métodos son responsables de dibujar la interfaz gráfica del menú de opciones, incluyendo el marco y el contenido, como texto y botones.
```
void COptionWindow::RenderFrame(int a1) {
    // Lógica de renderizado...
    RenderBitmap(0x9920, StartX - 120, StartY - 30, Width, Height, 0.0, 0.0, 1.0, 1.0, 1, 1, 0.80000001);
}
    
```
Utilizan funciones como RenderBitmap para dibujar elementos gráficos en la pantalla.

Configuración de Resoluciones y Fuentes:

ResolutionInGame:

void COptionWindow::ResolutionInGame(int a1, int a2) {
    // Ajuste de resolución...
    SetWindowPos(pGameWindow, 0, 0, 0, a1, a2 + 30, 0x116u);
}

Este método ajusta la resolución del juego y la posición de la ventana en la pantalla.

FontSizeInGame:

int COptionWindow::FontSizeInGame(int a1) {
    // Establecer tamaño de fuente...
    WritePrivateProfileStringA("FontConfig", "FontHeight", "10", ".\\Settings.ini");
}

Este método establece el tamaño de la fuente y guarda la configuración en un archivo INI.

Funcionalidad de los Botones

Cada botón en el menú tiene una funcionalidad específica, como activar o desactivar efectos visuales (por ejemplo, «Fog», «Glow», etc.). La lógica para cada botón incluye:

Dibujo del botón:

if (!Fog) {
    pDrawButton(31593, v17 - 145, v16 - 70, 15, 15, 0, 0);
}

Verificación de clics:

if (gOptionWindow.CheckButtonPressed(v17 - 145, v16 - 70, 15, 15) && GetTickCount() >= gOptionWindow.Delay_AntiLag + 250) {
    // Lógica de clic...
}

Descargar Archivos Completo Aqui

CustomOptionWindow.cpp

CustomOptionWindow.h

Resumen

El código es un sistema de menú para un juego que permite a los jugadores ajustar varias opciones gráficas y de sonido. Utiliza técnicas de programación de bajo nivel, como hooks y manipulación directa de la memoria, lo que es común en el desarrollo de mods o extensiones para juegos.