🎮 GUÍA INICIAL: SISTEMA DE FPS 120 VARIABLE PARA MU ONLINE (Main 5.2)

[Dakosmu]

🎮 GUÍA INICIAL: SISTEMA DE FPS 120 VARIABLE PARA MU ONLINE (Main 5.2)

Este tutorial explica cómo integrar un sistema de FPS variable basado en

Código [Seleccionar] Expandir

std::chrono

para sources de MU Online. Ideal para modernizar el rendimiento sin romper la velocidad del juego.

Introducción

En un source estándar de MU Online, el código asume una base fija de 25 FPS. Si intentas ejecutar el juego a 60 FPS o 140 FPS sin este sistema, las animaciones y físicas se acelerarán de forma descontrolada. Este sistema utiliza un speedNormalizer para compensar la velocidad extra y mantener la lógica intacta.1. Requisitos y Archivos Necesarios

Para comenzar, debes agregar o reemplazar los siguientes archivos en tu proyecto de Visual Studio:

• steady_clock.h / .cpp: El motor principal (normalización, sleep, cálculos de tiempo).
• CGMProtect.h / .cpp: Gestión del límite de FPS (ajust_fps_render).
• Time/Timer.h + .cpp: Clase CTimer para medir tiempo real entre frames.

⚠ NO copies los archivos

Código [Seleccionar] Expandir

CGMFrame.h ni

Código [Seleccionar] Expandir

NewUIMainFrameWindow.cpp completos, ya que son específicos de cada source. Solo extrae las líneas indicadas más adelante.

2. Guía de Integración Paso a Paso

• Configuración de Archivos: Copia
  
  Código [Seleccionar] Expandir
  steady_clock.h y
  
  Código [Seleccionar] Expandir
  steady_clock.cpp a la raíz de tu proyecto. Ajusta los includes según tus archivos locales (ej:
  
  Código [Seleccionar] Expandir
  ZzzOpenglUtil.h).
• Definición del Límite de FPS: En tu clase
  
  Código [Seleccionar] Expandir
  CGMProtect, añade la variable para el límite de renderizado:
  
  Código [Seleccionar] Expandir
  // En CGMProtect.h (Sección pública)
BYTE ajust_fps_render;// En CGMProtect.cpp (Constructor o Carga)
ajust_fps_render = 60; // Valor por defecto

• Implementación del Timer: Crea la carpeta
  
  Código [Seleccionar] Expandir
  Time/ y asegura que tu clase
  
  Código [Seleccionar] Expandir
  CTimer tenga el método
  
  Código [Seleccionar] Expandir
  GetTimeElapsed().
• Modificación del Loop Principal: En tu bucle de renderizado (WinMain o MainFrame), inserta estas llamadas en el orden exacto:
  
  Código [Seleccionar] Expandir
  // 1. INICIO: Captura el tick actual
auto thread_tick = gsteady_clock->GetthreadTime();// 2. DENTRO: Actualiza información tras el rendergsteady_clock->LoadInformationFps();// 3. FINAL: Controla el delay para el FPS límite
gsteady_clock->thread_sleep(thread_tick);

  Invertir este orden romperá el cálculo de delta y la fluidez del juego.

3. Reemplazo de Lógica y Animaciones
Debes sustituir los contadores fijos (basados en frames) por macros que escalen con el tiempo real.Tabla de Conversión de Código:

Código [Seleccionar] Expandir

Código Original (25 FPS fijo)Reemplazo Sugerido (FPS Variable)AlphaValue -= 5;AlphaValue -= timefac(5.0);Scale *= 0.95f;Scale *= timepow(0.95);Velocity *= 0.98f;Velocity *= timepow(0.98);if (++timer > 25)static CheckerTime t(1.0f); if(t.now())if (Frame % 5 == 0)if (rand_fps_check(5))

Para temporizadores precisos, usa

Código [Seleccionar] Expandir

CheckerTime timer(1.0f);. Esto garantiza que el evento ocurra cada 1 segundo exacto sin importar si el usuario corre a 25 o 144 FPS.

4. Referencia de Macros Técnicas
Usa estas constantes en tus archivos

Código [Seleccionar] Expandir

.cpp para un ajuste fino:

• Código [Seleccionar] Expandir
  #define REFERENCE_FPS 25.0
• Código [Seleccionar] Expandir
  FPS_ANIMATION_FACTOR: Factor de velocidad actual.
• Código [Seleccionar] Expandir
  DeltaT: Tiempo real entre frames en segundos.
• Código [Seleccionar] Expandir
  timefac(x): Escala valores lineales.
• Código [Seleccionar] Expandir
  timepow(x): Escala valores exponenciales (impulsos/fricción).

¿Cómo verificar que funciona?

• A 25 FPS, el juego debe verse idéntico al original.
• A 60+ FPS, las animaciones deben mantener la misma velocidad pero con mayor suavidad.
• Código [Seleccionar] Expandir
  CheckNormalizer() debe ser
  
  Código [Seleccionar] Expandir
  true solo cerca de los 25 FPS.

FPS Variable, Sistema FPS, std::chrono, Source MU, C++, Desarrollo de juegos, GameMaster Source, Optimización de frames, Normalización de animaciones, Guía de integración, Programación MU, steady_clock, CTimer, Delta Time MU

[Dakosmu]

Defines de Configuración y Referencia

• Código [Seleccionar] Expandir
  #define REFERENCE_FPS 25.0 — Define los FPS base del source original de MU.
• Código [Seleccionar] Expandir
  #define FPS_ANIMATION_FACTOR (gsteady_clock->GetNormalizerFps()) — Es el factor dinámico que ajusta la velocidad de las animaciones.
• Código [Seleccionar] Expandir
  #define checkNormalizer (gsteady_clock->CheckNormalizer()) — Macro para validar si el juego corre a la velocidad estándar.
• Código [Seleccionar] Expandir
  #define rand_fps_check(ref) (gsteady_clock->rand_calc_check(ref)) — Reemplaza chequeos probabilísticos (como
  Código [Seleccionar] Expandir
  Frame % X) ajustándolos al FPS actual.
• Código [Seleccionar] Expandir
  #define gsteady_clock (csteady_clock::Instance()) — Define el acceso a la instancia única del motor de tiempo.

Variables Globales Externas
Estas variables deben estar declaradas como

Código [Seleccionar] Expandir

extern para que puedas usarlas en cualquier parte de tu código:

• Código [Seleccionar] Expandir
  extern double DeltaT; — Almacena el tiempo real transcurrido entre frames en segundos.
• Código [Seleccionar] Expandir
  extern float WorldTime; — Representa el
  Código [Seleccionar] Expandir
  timeGetTime() capturado específicamente para el frame actual.

Funciones de Soporte (Prototipos)
Asegúrate de que estas funciones estén declaradas en tu header para que las macros como

Código [Seleccionar] Expandir

timefac o

Código [Seleccionar] Expandir

timepow funcionen correctamente:

• Código [Seleccionar] Expandir
  DWORD standlimit(DWORD x); — Ajusta límites de contadores (ticks) según el FPS configurado.
• Código [Seleccionar] Expandir
  double timepow(double x); — Función para escalar factores exponenciales (útil en fricción o decaimiento de velocidad).
• Código [Seleccionar] Expandir
  double timefac(double x); — Función para escalar factores lineales (movimientos simples).
• Código [Seleccionar] Expandir
  double timeNormalizer(double x); — Realiza una normalización general basada en el tiempo transcurrido.

Sin estos defines, las macros utilizadas en el Paso 5 y el Paso 6 (como

Código [Seleccionar] Expandir

timefac o

Código [Seleccionar] Expandir

standlimit) generarán errores de compilación por símbolos no encontrados.

[Dakosmu]

Para que el sistema compile y funcione correctamente, asegúrate de que tu archivo

Código [Seleccionar] Expandir

steady_clock.h incluya la estructura completa de la clase y las macros de utilidad.

Aquí tienes los elementos técnicos que completan el código según la guía:1. Definición de la Clase csteady_clock
Es vital tener la declaración de la clase que maneja la lógica central:

Código [Seleccionar] Expandir

class csteady_clock {
public:
static csteady_clock* Instance(); // Singleton para gsteady_clock double GetNormalizerFps();        // Retorna FPS_ANIMATION_FACTOR [cite: 82]
bool CheckNormalizer();           // Retorna checkNormalizer [cite: 83]
bool rand_calc_check(int ref);    // Lógica para rand_fps_check [cite: 84, 93]

// Métodos para el Loop Principal (Paso 4)
std::chrono::steady_clock::time_point GetthreadTime(); [cite: 46]
void LoadInformationFps();                             [cite: 48]
void thread_sleep(std::chrono::steady_clock::time_point tick); [cite: 50]
};2. La Clase CheckerTime
Esta clase es la que permite reemplazar los contadores manuales por tiempo real:

Código [Seleccionar] Expandir

class CheckerTime {
public:
CheckerTime(float seconds); // Inicializa con el tiempo de espera
bool now();                 // Retorna true si ya pasó el tiempo
float work_duration();      // Retorna el progreso (0.0 a 1.0)
private:
// ... lógica interna basada en std::chrono
};
3. Macros de Utilidad (Matemáticas)
Estas macros son las que usarás en el día a día para adaptar tu código existente:

• Código [Seleccionar] Expandir
  #define timefac(x)           (gsteady_clock->timefac(x)) — Para valores lineales como
  Código [Seleccionar] Expandir
  Position += Speed;
• Código [Seleccionar] Expandir
  #define timepow(x)           (gsteady_clock->timepow(x)) — Para valores exponenciales como
  Código [Seleccionar] Expandir
  Scale *= 0.95;
• Código [Seleccionar] Expandir
  #define standlimit(x)        (gsteady_clock->standlimit(x)) — Para ajustar límites de ciclos (ej: 250 ticks).
• Código [Seleccionar] Expandir
  #define timeNormalizer(x)    (gsteady_clock->timeNormalizer(x)) — Normalización general de valores.

Con estos elementos y los mencionados anteriormente, tienes el 100% de la interfaz necesaria para que el sistema de FPS variable sea totalmente funcional en tu source.