vibe3_physics/source/main.cpp

#include <SDL3/SDL_error.h>    // for SDL_GetError
#include <SDL3/SDL_events.h>   // for SDL_EventType, SDL_PollEvent, SDL_Event
#include <SDL3/SDL_init.h>     // for SDL_Init, SDL_Quit, SDL_INIT_VIDEO
#include <SDL3/SDL_keycode.h>  // for SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5
#include <SDL3/SDL_render.h>   // for SDL_SetRenderDrawColor, SDL_CreateRend...
#include <SDL3/SDL_stdinc.h>   // for Uint64
#include <SDL3/SDL_timer.h>    // for SDL_GetTicks
#include <SDL3/SDL_video.h>    // for SDL_CreateWindow, SDL_DestroyWindow

#include <array>     // for array
#include <cstdlib>   // for rand, srand
#include <ctime>     // for time
#include <iostream>  // for basic_ostream, char_traits, operator<<
#include <memory>    // for unique_ptr, shared_ptr, make_shared
#include <string>    // for operator+, string, to_string
#include <vector>    // for vector

#include "ball.h"              // for Ball
#include "defines.h"           // for SCREEN_WIDTH, SCREEN_HEIGHT, WINDOW_SIZE
#include "external/dbgtxt.h"   // for dbg_init, dbg_print
#include "external/texture.h"  // for Texture

// Variables globales
SDL_Window *window = nullptr;
SDL_Renderer *renderer = nullptr;
std::shared_ptr<Texture> texture = nullptr;
std::vector<std::unique_ptr<Ball>> balls;
std::array<int, 8> test = {1, 10, 100, 500, 1000, 10000, 50000, 100000};

bool should_exit = false;  // Controla si la aplicación debe cerrarse
// ticks eliminado - reemplazado por delta time system
int scenario = 0;           // Escenario actual basado en el número de bolas
std::string text;           // Texto a mostrar en pantalla
int text_pos = 0;           // Posición del texto en la pantalla
bool show_text = true;      // Determina si el texto se debe mostrar
Uint64 text_init_time = 0;  // Temporizador para mostrar el texto

// Variables para contador de FPS
Uint64 fps_last_time = 0;         // Último tiempo para cálculo de FPS
int fps_frame_count = 0;          // Contador de frames
int fps_current = 0;              // FPS actuales calculados
std::string fps_text = "FPS: 0";  // Texto del contador de FPS

// Variables para V-Sync
bool vsync_enabled = true;            // Estado inicial del V-Sync (activado por defecto)
std::string vsync_text = "VSYNC ON";  // Texto del estado V-Sync

// Variables para Delta Time
Uint64 last_frame_time = 0;  // Tiempo del último frame en milisegundos
float delta_time = 0.0f;     // Tiempo transcurrido desde el último frame en segundos

// Variables para Debug Display
bool show_debug = false;  // Debug display desactivado por defecto

// Variable para direcci\u00f3n de gravedad
GravityDirection current_gravity = GravityDirection::DOWN;  // Gravedad inicial hacia abajo

// Sistema de temas de colores (enum movido a defines.h)

ColorTheme current_theme = ColorTheme::SUNSET;
std::string theme_names[] = {"SUNSET", "OCEAN", "NEON", "FOREST"};

struct ThemeColors {
        // Colores de fondo (superior -> inferior)
        float bg_top_r, bg_top_g, bg_top_b;
        float bg_bottom_r, bg_bottom_g, bg_bottom_b;

        // Paletas de colores para bolas (RGB 0-255)
        int ball_colors[8][3];  // 8 colores por tema
};

ThemeColors themes[4] = {
    // SUNSET: Naranjas, rojos, amarillos, rosas
    {180.0f / 255.0f, 140.0f / 255.0f, 100.0f / 255.0f,  // Fondo superior (naranja suave)
        40.0f / 255.0f,
        20.0f / 255.0f,
        60.0f / 255.0f,  // Fondo inferior (púrpura oscuro)
        {{255, 140, 0}, {255, 69, 0}, {255, 215, 0}, {255, 20, 147}, {255, 99, 71}, {255, 165, 0}, {255, 192, 203}, {220, 20, 60}}},
    // OCEAN: Azules, cianes, verdes agua, blancos
    {100.0f / 255.0f, 150.0f / 255.0f, 200.0f / 255.0f,  // Fondo superior (azul cielo)
        20.0f / 255.0f,
        40.0f / 255.0f,
        80.0f / 255.0f,  // Fondo inferior (azul marino)
        {{0, 191, 255}, {0, 255, 255}, {32, 178, 170}, {176, 224, 230}, {70, 130, 180}, {0, 206, 209}, {240, 248, 255}, {64, 224, 208}}},
    // NEON: Cian, magenta, verde lima, amarillo vibrante
    {20.0f / 255.0f, 20.0f / 255.0f, 40.0f / 255.0f,  // Fondo superior (negro azulado)
        0.0f / 255.0f,
        0.0f / 255.0f,
        0.0f / 255.0f,  // Fondo inferior (negro)
        {{0, 255, 255}, {255, 0, 255}, {50, 205, 50}, {255, 255, 0}, {255, 20, 147}, {0, 255, 127}, {138, 43, 226}, {255, 69, 0}}},
    // FOREST: Verdes, marrones, amarillos otoño
    {144.0f / 255.0f, 238.0f / 255.0f, 144.0f / 255.0f,  // Fondo superior (verde claro)
        101.0f / 255.0f,
        67.0f / 255.0f,
        33.0f / 255.0f,  // Fondo inferior (marrón tierra)
        {{34, 139, 34}, {107, 142, 35}, {154, 205, 50}, {255, 215, 0}, {210, 180, 140}, {160, 82, 45}, {218, 165, 32}, {50, 205, 50}}}};

// Variables para Batch Rendering
std::vector<SDL_Vertex> batch_vertices;
std::vector<int> batch_indices;

// Función para renderizar fondo degradado
void renderGradientBackground() {
    // Crear quad de pantalla completa con degradado
    SDL_Vertex bg_vertices[4];

    // Obtener colores del tema actual
    ThemeColors &theme = themes[static_cast<int>(current_theme)];

    float top_r = theme.bg_top_r;
    float top_g = theme.bg_top_g;
    float top_b = theme.bg_top_b;

    float bottom_r = theme.bg_bottom_r;
    float bottom_g = theme.bg_bottom_g;
    float bottom_b = theme.bg_bottom_b;

    // Vértice superior izquierdo
    bg_vertices[0].position = {0, 0};
    bg_vertices[0].tex_coord = {0.0f, 0.0f};
    bg_vertices[0].color = {top_r, top_g, top_b, 1.0f};

    // Vértice superior derecho
    bg_vertices[1].position = {SCREEN_WIDTH, 0};
    bg_vertices[1].tex_coord = {1.0f, 0.0f};
    bg_vertices[1].color = {top_r, top_g, top_b, 1.0f};

    // Vértice inferior derecho
    bg_vertices[2].position = {SCREEN_WIDTH, SCREEN_HEIGHT};
    bg_vertices[2].tex_coord = {1.0f, 1.0f};
    bg_vertices[2].color = {bottom_r, bottom_g, bottom_b, 1.0f};

    // Vértice inferior izquierdo
    bg_vertices[3].position = {0, SCREEN_HEIGHT};
    bg_vertices[3].tex_coord = {0.0f, 1.0f};
    bg_vertices[3].color = {bottom_r, bottom_g, bottom_b, 1.0f};

    // Índices para 2 triángulos
    int bg_indices[6] = {0, 1, 2, 2, 3, 0};

    // Renderizar sin textura (nullptr)
    SDL_RenderGeometry(renderer, nullptr, bg_vertices, 4, bg_indices, 6);
}

// Función para añadir un sprite al batch
void addSpriteToBatch(float x, float y, float w, float h, Uint8 r, Uint8 g, Uint8 b) {
    int vertex_index = static_cast<int>(batch_vertices.size());

    // Crear 4 vértices para el quad (2 triángulos)
    SDL_Vertex vertices[4];

    // Convertir colores de Uint8 (0-255) a float (0.0-1.0)
    float rf = r / 255.0f;
    float gf = g / 255.0f;
    float bf = b / 255.0f;

    // Vértice superior izquierdo
    vertices[0].position = {x, y};
    vertices[0].tex_coord = {0.0f, 0.0f};
    vertices[0].color = {rf, gf, bf, 1.0f};

    // Vértice superior derecho
    vertices[1].position = {x + w, y};
    vertices[1].tex_coord = {1.0f, 0.0f};
    vertices[1].color = {rf, gf, bf, 1.0f};

    // Vértice inferior derecho
    vertices[2].position = {x + w, y + h};
    vertices[2].tex_coord = {1.0f, 1.0f};
    vertices[2].color = {rf, gf, bf, 1.0f};

    // Vértice inferior izquierdo
    vertices[3].position = {x, y + h};
    vertices[3].tex_coord = {0.0f, 1.0f};
    vertices[3].color = {rf, gf, bf, 1.0f};

    // Añadir vértices al batch
    for (int i = 0; i < 4; i++) {
        batch_vertices.push_back(vertices[i]);
    }

    // Añadir índices para 2 triángulos (6 índices por sprite)
    // Triángulo 1: 0,1,2
    batch_indices.push_back(vertex_index + 0);
    batch_indices.push_back(vertex_index + 1);
    batch_indices.push_back(vertex_index + 2);

    // Triángulo 2: 2,3,0
    batch_indices.push_back(vertex_index + 2);
    batch_indices.push_back(vertex_index + 3);
    batch_indices.push_back(vertex_index + 0);
}

// Establece el texto en pantalla mostrando el número de bolas actuales
void setText() {
    const std::string TEXT_NUMBER = test[scenario] == 1 ? " PELOTA" : " PELOTAS";
    text = std::to_string(test[scenario]) + TEXT_NUMBER;
    const int TEXT_SIZE = static_cast<int>(text.size() * 8);
    text_pos = SCREEN_WIDTH / 2 - TEXT_SIZE / 2;
    text_init_time = SDL_GetTicks();
    show_text = true;
}

// Inicializa las bolas según el escenario seleccionado
void initBalls(int value) {
    balls.clear();

    // Resetear gravedad al estado por defecto (DOWN) al cambiar escenario
    current_gravity = GravityDirection::DOWN;
    for (int i = 0; i < test.at(value); ++i) {
        const int SIGN = ((rand() % 2) * 2) - 1;                             // Genera un signo aleatorio (+ o -)
        const float X = (rand() % (SCREEN_WIDTH / 2)) + (SCREEN_WIDTH / 4);  // Posición inicial en X
        const float VX = (((rand() % 20) + 10) * 0.1f) * SIGN;               // Velocidad en X
        const float VY = ((rand() % 60) - 30) * 0.1f;                        // Velocidad en Y
        // Seleccionar color de la paleta del tema actual
        ThemeColors &theme = themes[static_cast<int>(current_theme)];
        int color_index = rand() % 8;  // 8 colores por tema
        const Color COLOR = {theme.ball_colors[color_index][0],
            theme.ball_colors[color_index][1],
            theme.ball_colors[color_index][2]};
        balls.emplace_back(std::make_unique<Ball>(X, VX, VY, COLOR, texture, current_gravity));
    }
    setText();  // Actualiza el texto
}

// Aumenta la velocidad vertical de las bolas "hacia arriba"
void pushUpBalls() {
    for (auto &ball : balls) {
        const int SIGNO = ((rand() % 2) * 2) - 1;
        const float VX = (((rand() % 20) + 10) * 0.1f) * SIGNO;
        const float VY = ((rand() % 40) * 0.1f) + 5;
        ball->modVel(VX, -VY);  // Modifica la velocidad de la bola
    }
}

// Cambia la gravedad de todas las bolas
void switchBallsGravity() {
    for (auto &ball : balls) {
        ball->switchGravity();
    }
}

// Cambia la direcci\u00f3n de gravedad de todas las bolas
void changeGravityDirection(GravityDirection new_direction) {
    current_gravity = new_direction;
    for (auto &ball : balls) {
        ball->setGravityDirection(new_direction);
    }
}

// Convierte dirección de gravedad a texto para debug
std::string gravityDirectionToString(GravityDirection direction) {
    switch (direction) {
        case GravityDirection::DOWN: return "DOWN";
        case GravityDirection::UP: return "UP";
        case GravityDirection::LEFT: return "LEFT";
        case GravityDirection::RIGHT: return "RIGHT";
        default: return "UNKNOWN";
    }
}

// Alterna el estado del V-Sync
void toggleVSync() {
    vsync_enabled = !vsync_enabled;
    vsync_text = vsync_enabled ? "VSYNC ON" : "VSYNC OFF";

    // Aplicar el cambio de V-Sync al renderizador
    SDL_SetRenderVSync(renderer, vsync_enabled ? 1 : 0);
}

// Calcula el delta time entre frames
void calculateDeltaTime() {
    Uint64 current_time = SDL_GetTicks();

    // En el primer frame, inicializar el tiempo anterior
    if (last_frame_time == 0) {
        last_frame_time = current_time;
        delta_time = 1.0f / 60.0f;  // Asumir 60 FPS para el primer frame
        return;
    }

    // Calcular delta time en segundos
    delta_time = (current_time - last_frame_time) / 1000.0f;
    last_frame_time = current_time;

    // Limitar delta time para evitar saltos grandes (pausa larga, depuración, etc.)
    if (delta_time > 0.05f)  // Máximo 50ms (20 FPS mínimo)
    {
        delta_time = 1.0f / 60.0f;  // Usar 60 FPS como fallback
    }
}

// Inicializa SDL y configura los componentes principales
bool init() {
    bool success = true;

    // Inicializa SDL
    if (!SDL_Init(SDL_INIT_VIDEO)) {
        std::cout << "¡SDL no se pudo inicializar! Error de SDL: " << SDL_GetError() << std::endl;
        success = false;
    } else {
        // Crear ventana principal
        window = SDL_CreateWindow(WINDOW_CAPTION, SCREEN_WIDTH * WINDOW_SIZE, SCREEN_HEIGHT * WINDOW_SIZE, SDL_WINDOW_OPENGL);
        if (window == nullptr) {
            std::cout << "¡No se pudo crear la ventana! Error de SDL: " << SDL_GetError() << std::endl;
            success = false;
        } else {
            // Crear renderizador
            renderer = SDL_CreateRenderer(window, nullptr);
            if (renderer == nullptr) {
                std::cout << "¡No se pudo crear el renderizador! Error de SDL: " << SDL_GetError() << std::endl;
                success = false;
            } else {
                // Establecer color inicial del renderizador
                SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);

                // Establecer tamaño lógico para el renderizado
                SDL_SetRenderLogicalPresentation(renderer, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);

                // Configurar V-Sync inicial
                SDL_SetRenderVSync(renderer, vsync_enabled ? 1 : 0);
            }
        }
    }

    // Inicializar otros componentes
    texture = std::make_shared<Texture>(renderer, "data/ball.png");
    // ticks eliminado - delta time system se inicializa automáticamente
    srand(static_cast<unsigned>(time(nullptr)));
    dbg_init(renderer);
    initBalls(scenario);

    return success;
}

// Limpia todos los recursos y cierra SDL
void close() {
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
}

// Verifica los eventos en la cola
void checkEvents() {
    SDL_Event event;
    while (SDL_PollEvent(&event) != 0) {
        // Evento de salida
        if (event.type == SDL_EVENT_QUIT) {
            should_exit = true;
            break;
        }

        // Procesar eventos de teclado
        if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0) {
            switch (event.key.key) {
                case SDLK_ESCAPE:
                    should_exit = true;
                    break;

                case SDLK_SPACE:
                    pushUpBalls();
                    break;

                case SDLK_G:
                    switchBallsGravity();
                    break;

                // Controles de direcci\u00f3n de gravedad con teclas de cursor
                case SDLK_UP:
                    changeGravityDirection(GravityDirection::UP);
                    break;

                case SDLK_DOWN:
                    changeGravityDirection(GravityDirection::DOWN);
                    break;

                case SDLK_LEFT:
                    changeGravityDirection(GravityDirection::LEFT);
                    break;

                case SDLK_RIGHT:
                    changeGravityDirection(GravityDirection::RIGHT);
                    break;

                case SDLK_V:
                    toggleVSync();
                    break;

                case SDLK_H:
                    show_debug = !show_debug;
                    break;

                case SDLK_T:
                    // Ciclar al siguiente tema
                    current_theme = static_cast<ColorTheme>((static_cast<int>(current_theme) + 1) % 4);
                    initBalls(scenario);  // Regenerar bolas con nueva paleta
                    break;

                case SDLK_F1:
                    current_theme = ColorTheme::SUNSET;
                    initBalls(scenario);
                    break;

                case SDLK_F2:
                    current_theme = ColorTheme::OCEAN;
                    initBalls(scenario);
                    break;

                case SDLK_F3:
                    current_theme = ColorTheme::NEON;
                    initBalls(scenario);
                    break;

                case SDLK_F4:
                    current_theme = ColorTheme::FOREST;
                    initBalls(scenario);
                    break;

                case SDLK_1:
                    scenario = 0;
                    initBalls(scenario);
                    break;

                case SDLK_2:
                    scenario = 1;
                    initBalls(scenario);
                    break;

                case SDLK_3:
                    scenario = 2;
                    initBalls(scenario);
                    break;

                case SDLK_4:
                    scenario = 3;
                    initBalls(scenario);
                    break;

                case SDLK_5:
                    scenario = 4;
                    initBalls(scenario);
                    break;

                case SDLK_6:
                    scenario = 5;
                    initBalls(scenario);
                    break;

                case SDLK_7:
                    scenario = 6;
                    initBalls(scenario);
                    break;

                case SDLK_8:
                    scenario = 7;
                    initBalls(scenario);
                    break;
            }
        }
    }
}

// Actualiza la lógica del juego
void update() {
    // Calcular FPS
    fps_frame_count++;
    Uint64 current_time = SDL_GetTicks();
    if (current_time - fps_last_time >= 1000)  // Actualizar cada segundo
    {
        fps_current = fps_frame_count;
        fps_frame_count = 0;
        fps_last_time = current_time;
        fps_text = "FPS: " + std::to_string(fps_current);
    }

    // ¡DELTA TIME! Actualizar física siempre, usando tiempo transcurrido
    for (auto &ball : balls) {
        ball->update(delta_time);  // Pasar delta time a cada pelota
    }

    // Actualizar texto (sin cambios en la lógica)
    if (show_text) {
        show_text = !(SDL_GetTicks() - text_init_time > TEXT_DURATION);
    }
}

// Renderiza el contenido en la pantalla
void render() {
    // Renderizar fondo degradado en lugar de color sólido
    renderGradientBackground();

    // Limpiar batches del frame anterior
    batch_vertices.clear();
    batch_indices.clear();

    // Recopilar datos de todas las bolas para batch rendering
    for (auto &ball : balls) {
        // En lugar de ball->render(), obtener datos para batch
        SDL_FRect pos = ball->getPosition();
        Color color = ball->getColor();
        addSpriteToBatch(pos.x, pos.y, pos.w, pos.h, color.r, color.g, color.b);
    }

    // Renderizar todas las bolas en una sola llamada
    if (!batch_vertices.empty()) {
        SDL_RenderGeometry(renderer, texture->getSDLTexture(), batch_vertices.data(), static_cast<int>(batch_vertices.size()), batch_indices.data(), static_cast<int>(batch_indices.size()));
    }

    if (show_text) {
        dbg_print(text_pos, 8, text.c_str(), 255, 255, 255);

        // Mostrar nombre del tema en castellano debajo del número de pelotas
        std::string theme_names_es[] = {"ATARDECER", "OCEANO", "NEON", "BOSQUE"};
        std::string theme_name = theme_names_es[static_cast<int>(current_theme)];
        int theme_text_width = static_cast<int>(theme_name.length() * 8);  // 8 píxeles por carácter
        int theme_x = (SCREEN_WIDTH - theme_text_width) / 2;               // Centrar horizontalmente

        // Colores acordes a cada tema
        int theme_colors[][3] = {
            {255, 140, 60},  // ATARDECER: Naranja cálido
            {80, 200, 255},  // OCEANO: Azul océano
            {255, 60, 255},  // NEON: Magenta brillante
            {100, 255, 100}  // BOSQUE: Verde natural
        };
        int theme_idx = static_cast<int>(current_theme);
        dbg_print(theme_x, 24, theme_name.c_str(), theme_colors[theme_idx][0], theme_colors[theme_idx][1], theme_colors[theme_idx][2]);
    }

    // Debug display (solo si está activado con tecla H)
    if (show_debug) {
        // Mostrar contador de FPS en esquina superior derecha
        int fps_text_width = static_cast<int>(fps_text.length() * 8);  // 8 píxeles por carácter
        int fps_x = SCREEN_WIDTH - fps_text_width - 8;                 // 8 píxeles de margen
        dbg_print(fps_x, 8, fps_text.c_str(), 255, 255, 0);            // Amarillo para distinguir

        // Mostrar estado V-Sync en esquina superior izquierda
        dbg_print(8, 8, vsync_text.c_str(), 0, 255, 255);  // Cian para distinguir

        // Debug: Mostrar valores de la primera pelota (si existe)
        if (!balls.empty()) {
            // Línea 1: Gravedad (solo números enteros)
            int grav_int = static_cast<int>(balls[0]->getGravityForce());
            std::string grav_text = "GRAV " + std::to_string(grav_int);
            dbg_print(8, 24, grav_text.c_str(), 255, 0, 255);  // Magenta para debug

            // Línea 2: Velocidad Y (solo números enteros)
            int vy_int = static_cast<int>(balls[0]->getVelocityY());
            std::string vy_text = "VY " + std::to_string(vy_int);
            dbg_print(8, 32, vy_text.c_str(), 255, 0, 255);  // Magenta para debug

            // Línea 3: Estado superficie
            std::string surface_text = balls[0]->isOnSurface() ? "SURFACE YES" : "SURFACE NO";
            dbg_print(8, 40, surface_text.c_str(), 255, 0, 255);  // Magenta para debug

            // Línea 4: Coeficiente de rebote (loss)
            float loss_val = balls[0]->getLossCoefficient();
            std::string loss_text = "LOSS " + std::to_string(loss_val).substr(0, 4);  // Solo 2 decimales
            dbg_print(8, 48, loss_text.c_str(), 255, 0, 255);  // Magenta para debug

            // Línea 5: Dirección de gravedad
            std::string gravity_dir_text = "GRAVITY " + gravityDirectionToString(current_gravity);
            dbg_print(8, 56, gravity_dir_text.c_str(), 255, 255, 0);  // Amarillo para dirección
        }

        // Debug: Mostrar tema actual
        std::string theme_names[] = {"SUNSET", "OCEAN", "NEON", "FOREST"};
        std::string theme_text = "THEME " + theme_names[static_cast<int>(current_theme)];
        dbg_print(8, 64, theme_text.c_str(), 255, 255, 128);  // Amarillo claro para tema
    }

    SDL_RenderPresent(renderer);
}

// Función principal
int main(int argc, char *args[]) {
    if (!init()) {
        std::cout << "Ocurrió un error durante la inicialización." << std::endl;
        return 1;
    }

    while (!should_exit) {
        // 1. Calcular delta time antes de actualizar la lógica
        calculateDeltaTime();

        // 2. Actualizar lógica del juego con delta time
        update();

        // 3. Procesar eventos de entrada
        checkEvents();

        // 4. Renderizar la escena
        render();
    }

    close();

    return 0;
}