Aplicar formato automático con clang-format a todo el código fuente
- Reformatear archivos .cpp y .h según configuración Google personalizada - Mejorar consistencia en indentación y espaciado - Reorganizar includes y declaraciones de clases - Mantener funcionalidad existente sin cambios 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
@@ -1,14 +1,16 @@
|
||||
#include "ball.h"
|
||||
|
||||
#include <stdlib.h> // for rand
|
||||
|
||||
#include <cmath> // for fabs
|
||||
|
||||
#include "defines.h" // for BALL_SIZE, Color, SCREEN_HEIGHT, GRAVITY_FORCE
|
||||
class Texture;
|
||||
|
||||
// Constructor
|
||||
Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture)
|
||||
: sprite_(std::make_unique<Sprite>(texture)),
|
||||
pos_({x, 0.0f, BALL_SIZE, BALL_SIZE})
|
||||
{
|
||||
pos_({x, 0.0f, BALL_SIZE, BALL_SIZE}) {
|
||||
// Convertir velocidades de píxeles/frame a píxeles/segundo (multiplicar por 60)
|
||||
vx_ = vx * 60.0f;
|
||||
vy_ = vy * 60.0f;
|
||||
@@ -24,55 +26,45 @@ Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> te
|
||||
}
|
||||
|
||||
// Actualiza la lógica de la clase
|
||||
void Ball::update(float deltaTime)
|
||||
{
|
||||
if (stopped_)
|
||||
{
|
||||
void Ball::update(float deltaTime) {
|
||||
if (stopped_) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Aplica la gravedad a la velocidad (píxeles/segundo²)
|
||||
if (!on_floor_)
|
||||
{
|
||||
if (!on_floor_) {
|
||||
vy_ += gravity_force_ * deltaTime;
|
||||
}
|
||||
|
||||
// Actualiza la posición en función de la velocidad (píxeles/segundo)
|
||||
pos_.x += vx_ * deltaTime;
|
||||
if (!on_floor_)
|
||||
{
|
||||
if (!on_floor_) {
|
||||
pos_.y += vy_ * deltaTime;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// Si está en el suelo, mantenerla ahí
|
||||
pos_.y = SCREEN_HEIGHT - pos_.h;
|
||||
}
|
||||
|
||||
// Comprueba las colisiones con el lateral izquierdo
|
||||
if (pos_.x < 0)
|
||||
{
|
||||
if (pos_.x < 0) {
|
||||
pos_.x = 0;
|
||||
vx_ = -vx_;
|
||||
}
|
||||
|
||||
// Comprueba las colisiones con el lateral derecho
|
||||
if (pos_.x + pos_.w > SCREEN_WIDTH)
|
||||
{
|
||||
if (pos_.x + pos_.w > SCREEN_WIDTH) {
|
||||
pos_.x = SCREEN_WIDTH - pos_.w;
|
||||
vx_ = -vx_;
|
||||
}
|
||||
|
||||
// Comprueba las colisiones con la parte superior
|
||||
if (pos_.y < 0)
|
||||
{
|
||||
if (pos_.y < 0) {
|
||||
pos_.y = 0;
|
||||
vy_ = -vy_;
|
||||
}
|
||||
|
||||
// Comprueba las colisiones con la parte inferior
|
||||
if (pos_.y + pos_.h > SCREEN_HEIGHT)
|
||||
{
|
||||
if (pos_.y + pos_.h > SCREEN_HEIGHT) {
|
||||
pos_.y = SCREEN_HEIGHT - pos_.h;
|
||||
vy_ = -vy_ * loss_;
|
||||
if (std::fabs(vy_) < 6.0f) // Convertir 0.1f frame-based a 6.0f time-based
|
||||
@@ -83,8 +75,7 @@ void Ball::update(float deltaTime)
|
||||
}
|
||||
|
||||
// Aplica rozamiento al rodar por el suelo
|
||||
if (on_floor_)
|
||||
{
|
||||
if (on_floor_) {
|
||||
// Convertir rozamiento de frame-based a time-based
|
||||
// 0.97f por frame equivale a pow(0.97f, 60 * deltaTime)
|
||||
float friction_factor = pow(0.97f, 60.0f * deltaTime);
|
||||
@@ -103,17 +94,14 @@ void Ball::update(float deltaTime)
|
||||
}
|
||||
|
||||
// Pinta la clase
|
||||
void Ball::render()
|
||||
{
|
||||
void Ball::render() {
|
||||
sprite_->setColor(color_.r, color_.g, color_.b);
|
||||
sprite_->render();
|
||||
}
|
||||
|
||||
// Modifica la velocidad (convierte de frame-based a time-based)
|
||||
void Ball::modVel(float vx, float vy)
|
||||
{
|
||||
if (stopped_)
|
||||
{
|
||||
void Ball::modVel(float vx, float vy) {
|
||||
if (stopped_) {
|
||||
vx_ = vx_ + (vx * 60.0f); // Convertir a píxeles/segundo
|
||||
}
|
||||
vy_ = vy_ + (vy * 60.0f); // Convertir a píxeles/segundo
|
||||
@@ -122,7 +110,6 @@ void Ball::modVel(float vx, float vy)
|
||||
}
|
||||
|
||||
// Cambia la gravedad (usa la versión convertida)
|
||||
void Ball::switchGravity()
|
||||
{
|
||||
void Ball::switchGravity() {
|
||||
gravity_force_ = gravity_force_ == 0.0f ? (GRAVITY_FORCE * 60.0f * 60.0f) : 0.0f;
|
||||
}
|
||||
@@ -1,14 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
#include <SDL3/SDL_rect.h> // for SDL_FRect
|
||||
|
||||
#include <memory> // for shared_ptr, unique_ptr
|
||||
|
||||
#include "defines.h" // for Color
|
||||
#include "external/sprite.h" // for Sprite
|
||||
class Texture;
|
||||
|
||||
class Ball
|
||||
{
|
||||
private:
|
||||
class Ball {
|
||||
private:
|
||||
std::unique_ptr<Sprite> sprite_; // Sprite para pintar la clase
|
||||
SDL_FRect pos_; // Posición y tamaño de la pelota
|
||||
float vx_, vy_; // Velocidad
|
||||
@@ -18,7 +19,7 @@ private:
|
||||
bool stopped_; // Indica si la pelota ha terminado de moverse;
|
||||
float loss_; // Coeficiente de rebote. Pérdida de energía en cada rebote
|
||||
|
||||
public:
|
||||
public:
|
||||
// Constructor
|
||||
Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture);
|
||||
|
||||
|
||||
@@ -11,7 +11,6 @@ constexpr float GRAVITY_FORCE = 0.2f;
|
||||
// DEMO_SPEED eliminado - ya no se usa con delta time
|
||||
constexpr Uint64 TEXT_DURATION = 2000;
|
||||
|
||||
struct Color
|
||||
{
|
||||
struct Color {
|
||||
int r, g, b;
|
||||
};
|
||||
46
source/external/dbgtxt.h
vendored
46
source/external/dbgtxt.h
vendored
@@ -1,24 +1,20 @@
|
||||
#pragma once
|
||||
|
||||
namespace
|
||||
{
|
||||
SDL_Texture *dbg_tex = nullptr;
|
||||
SDL_Renderer *dbg_ren = nullptr;
|
||||
}
|
||||
namespace {
|
||||
SDL_Texture* dbg_tex = nullptr;
|
||||
SDL_Renderer* dbg_ren = nullptr;
|
||||
} // namespace
|
||||
|
||||
void dbg_init(SDL_Renderer *renderer)
|
||||
{
|
||||
void dbg_init(SDL_Renderer* renderer) {
|
||||
dbg_ren = renderer;
|
||||
Uint8 font[448] = {0x42, 0x4D, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x18, 0xF3, 0x83, 0x83, 0xCF, 0x83, 0x87, 0x00, 0x00, 0xF3, 0x39, 0x39, 0xCF, 0x79, 0xF3, 0x00, 0x00, 0x01, 0xF9, 0x39, 0xCF, 0x61, 0xF9, 0x00, 0x00, 0x33, 0xF9, 0x03, 0xE7, 0x87, 0x81, 0x00, 0x00, 0x93, 0x03, 0x3F, 0xF3, 0x1B, 0x39, 0x00, 0x00, 0xC3, 0x3F, 0x9F, 0x39, 0x3B, 0x39, 0x00, 0x41, 0xE3, 0x03, 0xC3, 0x01, 0x87, 0x83, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xE7, 0x01, 0xC7, 0x81, 0x01, 0x83, 0x00, 0x00, 0xE7, 0x1F, 0x9B, 0xE7, 0x1F, 0x39, 0x00, 0x00, 0xE7, 0x8F, 0x39, 0xE7, 0x87, 0xF9, 0x00, 0x00, 0xC3, 0xC7, 0x39, 0xE7, 0xC3, 0xC3, 0x00, 0x00, 0x99, 0xE3, 0x39, 0xE7, 0xF1, 0xE7, 0x00, 0x00, 0x99, 0xF1, 0xB3, 0xC7, 0x39, 0xF3, 0x00, 0x00, 0x99, 0x01, 0xC7, 0xE7, 0x83, 0x81, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x83, 0xE7, 0x83, 0xEF, 0x39, 0x39, 0x00, 0x00, 0x39, 0xE7, 0x39, 0xC7, 0x11, 0x11, 0x00, 0x00, 0xF9, 0xE7, 0x39, 0x83, 0x01, 0x83, 0x00, 0x00, 0x83, 0xE7, 0x39, 0x11, 0x01, 0xC7, 0x00, 0x00, 0x3F, 0xE7, 0x39, 0x39, 0x29, 0x83, 0x00, 0x00, 0x33, 0xE7, 0x39, 0x39, 0x39, 0x11, 0x00, 0x00, 0x87, 0x81, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x39, 0x83, 0x3F, 0x85, 0x31, 0x00, 0x00, 0x39, 0x31, 0x39, 0x3F, 0x33, 0x23, 0x00, 0x00, 0x29, 0x21, 0x39, 0x03, 0x21, 0x07, 0x00, 0x00, 0x01, 0x01, 0x39, 0x39, 0x39, 0x31, 0x00, 0x00, 0x01, 0x09, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x11, 0x19, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x39, 0x39, 0x83, 0x03, 0x83, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xC1, 0x39, 0x81, 0x83, 0x31, 0x01, 0x00, 0x00, 0x99, 0x39, 0xE7, 0x39, 0x23, 0x3F, 0x00, 0x00, 0x39, 0x39, 0xE7, 0xF9, 0x07, 0x3F, 0x00, 0x00, 0x31, 0x01, 0xE7, 0xF9, 0x0F, 0x3F, 0x00, 0x00, 0x3F, 0x39, 0xE7, 0xF9, 0x27, 0x3F, 0x00, 0x00, 0x9F, 0x39, 0xE7, 0xF9, 0x33, 0x3F, 0x00, 0x00, 0xC1, 0x39, 0x81, 0xF9, 0x39, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x03, 0xC3, 0x07, 0x01, 0x3F, 0x00, 0x00, 0x39, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0x01, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x39, 0x03, 0x3F, 0x39, 0x03, 0x03, 0x00, 0x00, 0x39, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x93, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0xC7, 0x03, 0xC3, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00};
|
||||
|
||||
// Cargar surface del bitmap font
|
||||
SDL_Surface* font_surface = SDL_LoadBMP_IO(SDL_IOFromMem(font, 448), 1);
|
||||
if (font_surface != nullptr)
|
||||
{
|
||||
if (font_surface != nullptr) {
|
||||
// Crear una nueva surface de 32 bits con canal alpha
|
||||
SDL_Surface* rgba_surface = SDL_CreateSurface(font_surface->w, font_surface->h, SDL_PIXELFORMAT_RGBA8888);
|
||||
if (rgba_surface != nullptr)
|
||||
{
|
||||
if (rgba_surface != nullptr) {
|
||||
// Obtener píxeles de ambas surfaces
|
||||
Uint8* src_pixels = (Uint8*)font_surface->pixels;
|
||||
Uint32* dst_pixels = (Uint32*)rgba_surface->pixels;
|
||||
@@ -27,10 +23,8 @@ void dbg_init(SDL_Renderer *renderer)
|
||||
int height = font_surface->h;
|
||||
|
||||
// Procesar cada píxel
|
||||
for (int y = 0; y < height; y++)
|
||||
{
|
||||
for (int x = 0; x < width; x++)
|
||||
{
|
||||
for (int y = 0; y < height; y++) {
|
||||
for (int x = 0; x < width; x++) {
|
||||
int byte_index = y * font_surface->pitch + (x / 8);
|
||||
int bit_index = 7 - (x % 8);
|
||||
|
||||
@@ -40,8 +34,7 @@ void dbg_init(SDL_Renderer *renderer)
|
||||
if (is_white) // Fondo blanco original -> transparente
|
||||
{
|
||||
dst_pixels[y * width + x] = 0x00000000; // Transparente
|
||||
}
|
||||
else // Texto negro original -> blanco opaco
|
||||
} else // Texto negro original -> blanco opaco
|
||||
{
|
||||
dst_pixels[y * width + x] = 0xFFFFFFFF; // Blanco opaco
|
||||
}
|
||||
@@ -55,31 +48,24 @@ void dbg_init(SDL_Renderer *renderer)
|
||||
}
|
||||
|
||||
// Configurar filtro nearest neighbor para píxel perfect del texto
|
||||
if (dbg_tex != nullptr)
|
||||
{
|
||||
if (dbg_tex != nullptr) {
|
||||
SDL_SetTextureScaleMode(dbg_tex, SDL_SCALEMODE_NEAREST);
|
||||
// Configurar blend mode para transparencia normal
|
||||
SDL_SetTextureBlendMode(dbg_tex, SDL_BLENDMODE_BLEND);
|
||||
}
|
||||
}
|
||||
|
||||
void dbg_print(int x, int y, const char *text, Uint8 r, Uint8 g, Uint8 b)
|
||||
{
|
||||
void dbg_print(int x, int y, const char* text, Uint8 r, Uint8 g, Uint8 b) {
|
||||
int cc = 0;
|
||||
SDL_SetTextureColorMod(dbg_tex, r, g, b);
|
||||
SDL_FRect src = {0, 0, 8, 8};
|
||||
SDL_FRect dst = {static_cast<float>(x), static_cast<float>(y), 8, 8};
|
||||
while (text[cc] != 0)
|
||||
{
|
||||
if (text[cc] != 32)
|
||||
{
|
||||
if (text[cc] >= 65)
|
||||
{
|
||||
while (text[cc] != 0) {
|
||||
if (text[cc] != 32) {
|
||||
if (text[cc] >= 65) {
|
||||
src.x = ((text[cc] - 65) % 6) * 8;
|
||||
src.y = ((text[cc] - 65) / 6) * 8;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
src.x = ((text[cc] - 22) % 6) * 8;
|
||||
src.y = ((text[cc] - 22) / 6) * 8;
|
||||
}
|
||||
|
||||
16
source/external/sprite.cpp
vendored
16
source/external/sprite.cpp
vendored
@@ -1,4 +1,5 @@
|
||||
#include "sprite.h"
|
||||
|
||||
#include "texture.h" // for Texture
|
||||
|
||||
// Constructor
|
||||
@@ -8,33 +9,28 @@ Sprite::Sprite(std::shared_ptr<Texture> texture)
|
||||
clip_{0.0f, 0.0f, 0.0f, 0.0f} {}
|
||||
|
||||
// Establece la posición del sprite
|
||||
void Sprite::setPos(SDL_FPoint pos)
|
||||
{
|
||||
void Sprite::setPos(SDL_FPoint pos) {
|
||||
pos_.x = pos.x;
|
||||
pos_.y = pos.y;
|
||||
}
|
||||
|
||||
// Pinta el sprite
|
||||
void Sprite::render()
|
||||
{
|
||||
void Sprite::render() {
|
||||
texture_->render(&clip_, &pos_);
|
||||
}
|
||||
|
||||
// Establece el rectangulo de la textura que se va a pintar
|
||||
void Sprite::setClip(SDL_FRect clip)
|
||||
{
|
||||
void Sprite::setClip(SDL_FRect clip) {
|
||||
clip_ = clip;
|
||||
}
|
||||
|
||||
// Establece el tamaño del sprite
|
||||
void Sprite::setSize(float w, float h)
|
||||
{
|
||||
void Sprite::setSize(float w, float h) {
|
||||
pos_.w = w;
|
||||
pos_.h = h;
|
||||
}
|
||||
|
||||
// Modulación de color
|
||||
void Sprite::setColor(int r, int g, int b)
|
||||
{
|
||||
void Sprite::setColor(int r, int g, int b) {
|
||||
texture_->setColor(r, g, b);
|
||||
}
|
||||
8
source/external/sprite.h
vendored
8
source/external/sprite.h
vendored
@@ -1,17 +1,17 @@
|
||||
#pragma once
|
||||
|
||||
#include <SDL3/SDL_rect.h> // for SDL_FRect, SDL_FPoint
|
||||
|
||||
#include <memory> // for shared_ptr
|
||||
class Texture;
|
||||
|
||||
class Sprite
|
||||
{
|
||||
private:
|
||||
class Sprite {
|
||||
private:
|
||||
std::shared_ptr<Texture> texture_; // Textura con los gráficos del sprite
|
||||
SDL_FRect pos_; // Posición y tamaño del sprite
|
||||
SDL_FRect clip_; // Parte de la textura que se va a dibujar
|
||||
|
||||
public:
|
||||
public:
|
||||
// Constructor
|
||||
explicit Sprite(std::shared_ptr<Texture> texture);
|
||||
|
||||
|
||||
66
source/external/texture.cpp
vendored
66
source/external/texture.cpp
vendored
@@ -1,55 +1,55 @@
|
||||
#define STB_IMAGE_IMPLEMENTATION
|
||||
#include "texture.h"
|
||||
|
||||
#include <SDL3/SDL_error.h> // Para SDL_GetError
|
||||
#include <SDL3/SDL_log.h> // Para SDL_Log
|
||||
#include <SDL3/SDL_pixels.h> // Para SDL_PixelFormat
|
||||
#include <SDL3/SDL_surface.h> // Para SDL_CreateSurfaceFrom, SDL_DestroySurface
|
||||
#include <stdio.h> // Para NULL
|
||||
#include <stdlib.h> // Para exit
|
||||
|
||||
#include <iostream> // Para basic_ostream, char_traits, operator<<
|
||||
#include <string> // Para operator<<, string
|
||||
|
||||
#include "stb_image.h" // Para stbi_failure_reason, stbi_image_free
|
||||
|
||||
Texture::Texture(SDL_Renderer *renderer)
|
||||
: renderer_(renderer), texture_(nullptr), width_(0), height_(0) {}
|
||||
: renderer_(renderer),
|
||||
texture_(nullptr),
|
||||
width_(0),
|
||||
height_(0) {}
|
||||
|
||||
Texture::Texture(SDL_Renderer *renderer, const std::string &file_path)
|
||||
: renderer_(renderer), texture_(nullptr), width_(0), height_(0)
|
||||
{
|
||||
: renderer_(renderer),
|
||||
texture_(nullptr),
|
||||
width_(0),
|
||||
height_(0) {
|
||||
loadFromFile(file_path);
|
||||
}
|
||||
|
||||
Texture::~Texture()
|
||||
{
|
||||
Texture::~Texture() {
|
||||
free();
|
||||
}
|
||||
|
||||
// Carga la imagen desde una ruta especificada
|
||||
bool Texture::loadFromFile(const std::string &file_path)
|
||||
{
|
||||
bool Texture::loadFromFile(const std::string &file_path) {
|
||||
const std::string filename = file_path.substr(file_path.find_last_of("\\/") + 1);
|
||||
int req_format = STBI_rgb_alpha;
|
||||
int width, height, orig_format;
|
||||
unsigned char *data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
|
||||
if (data == nullptr)
|
||||
{
|
||||
if (data == nullptr) {
|
||||
SDL_Log("Error al cargar la imagen: %s", stbi_failure_reason());
|
||||
exit(1);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
std::cout << "Imagen cargada: " << filename.c_str() << std::endl;
|
||||
}
|
||||
|
||||
int pitch;
|
||||
SDL_PixelFormat pixel_format;
|
||||
if (req_format == STBI_rgb)
|
||||
{
|
||||
if (req_format == STBI_rgb) {
|
||||
pitch = 3 * width; // 3 bytes por pixel * pixels por línea
|
||||
pixel_format = SDL_PIXELFORMAT_RGB24;
|
||||
}
|
||||
else
|
||||
{ // STBI_rgb_alpha (RGBA)
|
||||
} else { // STBI_rgb_alpha (RGBA)
|
||||
pitch = 4 * width;
|
||||
pixel_format = SDL_PIXELFORMAT_RGBA32;
|
||||
}
|
||||
@@ -62,20 +62,14 @@ bool Texture::loadFromFile(const std::string &file_path)
|
||||
|
||||
// Crea la superficie de la imagen desde los datos cargados
|
||||
SDL_Surface *loaded_surface = SDL_CreateSurfaceFrom(width, height, pixel_format, (void *)data, pitch);
|
||||
if (loaded_surface == nullptr)
|
||||
{
|
||||
if (loaded_surface == nullptr) {
|
||||
std::cout << "No se pudo cargar la imagen " << file_path << std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// Crea la textura desde los píxeles de la superficie
|
||||
new_texture = SDL_CreateTextureFromSurface(renderer_, loaded_surface);
|
||||
if (new_texture == nullptr)
|
||||
{
|
||||
if (new_texture == nullptr) {
|
||||
std::cout << "No se pudo crear la textura desde " << file_path << "! Error de SDL: " << SDL_GetError() << std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// Obtiene las dimensiones de la imagen
|
||||
width_ = loaded_surface->w;
|
||||
height_ = loaded_surface->h;
|
||||
@@ -95,10 +89,8 @@ bool Texture::loadFromFile(const std::string &file_path)
|
||||
}
|
||||
|
||||
// Libera la textura si existe
|
||||
void Texture::free()
|
||||
{
|
||||
if (texture_ != nullptr)
|
||||
{
|
||||
void Texture::free() {
|
||||
if (texture_ != nullptr) {
|
||||
SDL_DestroyTexture(texture_);
|
||||
texture_ = nullptr;
|
||||
width_ = 0;
|
||||
@@ -107,25 +99,21 @@ void Texture::free()
|
||||
}
|
||||
|
||||
// Renderiza la textura en pantalla
|
||||
void Texture::render(SDL_FRect *src, SDL_FRect *dst)
|
||||
{
|
||||
void Texture::render(SDL_FRect *src, SDL_FRect *dst) {
|
||||
SDL_RenderTexture(renderer_, texture_, src, dst);
|
||||
}
|
||||
|
||||
// Obtiene el ancho de la imagen
|
||||
int Texture::getWidth()
|
||||
{
|
||||
int Texture::getWidth() {
|
||||
return width_;
|
||||
}
|
||||
|
||||
// Obtiene la altura de la imagen
|
||||
int Texture::getHeight()
|
||||
{
|
||||
int Texture::getHeight() {
|
||||
return height_;
|
||||
}
|
||||
|
||||
// Modula el color de la textura
|
||||
void Texture::setColor(int r, int g, int b)
|
||||
{
|
||||
void Texture::setColor(int r, int g, int b) {
|
||||
SDL_SetTextureColorMod(texture_, r, g, b);
|
||||
}
|
||||
|
||||
10
source/external/texture.h
vendored
10
source/external/texture.h
vendored
@@ -2,11 +2,11 @@
|
||||
|
||||
#include <SDL3/SDL_rect.h> // Para SDL_FRect
|
||||
#include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture
|
||||
|
||||
#include <string> // Para std::string
|
||||
|
||||
class Texture
|
||||
{
|
||||
private:
|
||||
class Texture {
|
||||
private:
|
||||
SDL_Renderer *renderer_;
|
||||
SDL_Texture *texture_;
|
||||
|
||||
@@ -14,7 +14,7 @@ private:
|
||||
int width_;
|
||||
int height_;
|
||||
|
||||
public:
|
||||
public:
|
||||
// Inicializa las variables
|
||||
explicit Texture(SDL_Renderer *renderer);
|
||||
Texture(SDL_Renderer *renderer, const std::string &file_path);
|
||||
@@ -39,5 +39,5 @@ public:
|
||||
void setColor(int r, int g, int b);
|
||||
|
||||
// Getter para batch rendering
|
||||
SDL_Texture* getSDLTexture() const { return texture_; }
|
||||
SDL_Texture *getSDLTexture() const { return texture_; }
|
||||
};
|
||||
|
||||
176
source/main.cpp
176
source/main.cpp
@@ -6,6 +6,7 @@
|
||||
#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
|
||||
@@ -13,9 +14,10 @@
|
||||
#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 "external/dbgtxt.h" // for dbg_init, dbg_print
|
||||
#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
|
||||
@@ -72,47 +74,41 @@ struct ThemeColors {
|
||||
|
||||
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}, // Bolas sunset
|
||||
{255, 99, 71}, {255, 165, 0}, {255, 192, 203}, {220, 20, 60}}
|
||||
},
|
||||
{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}, // Bolas ocean
|
||||
{70, 130, 180}, {0, 206, 209}, {240, 248, 255}, {64, 224, 208}}
|
||||
},
|
||||
{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}, // Bolas neon
|
||||
{255, 20, 147}, {0, 255, 127}, {138, 43, 226}, {255, 69, 0}}
|
||||
},
|
||||
{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}, // Bolas forest
|
||||
{210, 180, 140}, {160, 82, 45}, {218, 165, 32}, {50, 205, 50}}
|
||||
}
|
||||
};
|
||||
{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()
|
||||
{
|
||||
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)];
|
||||
ThemeColors &theme = themes[static_cast<int>(current_theme)];
|
||||
|
||||
float top_r = theme.bg_top_r;
|
||||
float top_g = theme.bg_top_g;
|
||||
@@ -150,8 +146,7 @@ void renderGradientBackground()
|
||||
}
|
||||
|
||||
// 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)
|
||||
{
|
||||
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)
|
||||
@@ -200,8 +195,7 @@ void addSpriteToBatch(float x, float y, float w, float h, Uint8 r, Uint8 g, Uint
|
||||
}
|
||||
|
||||
// Establece el texto en pantalla mostrando el número de bolas actuales
|
||||
void setText()
|
||||
{
|
||||
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);
|
||||
@@ -211,17 +205,15 @@ void setText()
|
||||
}
|
||||
|
||||
// Inicializa las bolas según el escenario seleccionado
|
||||
void initBalls(int value)
|
||||
{
|
||||
void initBalls(int value) {
|
||||
balls.clear();
|
||||
for (int i = 0; i < test.at(value); ++i)
|
||||
{
|
||||
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)];
|
||||
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],
|
||||
@@ -232,10 +224,8 @@ void initBalls(int value)
|
||||
}
|
||||
|
||||
// Aumenta la velocidad vertical de las bolas "hacia arriba"
|
||||
void pushUpBalls()
|
||||
{
|
||||
for (auto &ball : balls)
|
||||
{
|
||||
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;
|
||||
@@ -244,17 +234,14 @@ void pushUpBalls()
|
||||
}
|
||||
|
||||
// Cambia la gravedad de todas las bolas
|
||||
void switchBallsGravity()
|
||||
{
|
||||
for (auto &ball : balls)
|
||||
{
|
||||
void switchBallsGravity() {
|
||||
for (auto &ball : balls) {
|
||||
ball->switchGravity();
|
||||
}
|
||||
}
|
||||
|
||||
// Alterna el estado del V-Sync
|
||||
void toggleVSync()
|
||||
{
|
||||
void toggleVSync() {
|
||||
vsync_enabled = !vsync_enabled;
|
||||
vsync_text = vsync_enabled ? "VSYNC ON" : "VSYNC OFF";
|
||||
|
||||
@@ -263,13 +250,11 @@ void toggleVSync()
|
||||
}
|
||||
|
||||
// Calcula el delta time entre frames
|
||||
void calculateDeltaTime()
|
||||
{
|
||||
void calculateDeltaTime() {
|
||||
Uint64 current_time = SDL_GetTicks();
|
||||
|
||||
// En el primer frame, inicializar el tiempo anterior
|
||||
if (last_frame_time == 0)
|
||||
{
|
||||
if (last_frame_time == 0) {
|
||||
last_frame_time = current_time;
|
||||
delta_time = 1.0f / 60.0f; // Asumir 60 FPS para el primer frame
|
||||
return;
|
||||
@@ -287,36 +272,26 @@ void calculateDeltaTime()
|
||||
}
|
||||
|
||||
// Inicializa SDL y configura los componentes principales
|
||||
bool init()
|
||||
{
|
||||
bool init() {
|
||||
bool success = true;
|
||||
|
||||
// Inicializa SDL
|
||||
if (!SDL_Init(SDL_INIT_VIDEO))
|
||||
{
|
||||
if (!SDL_Init(SDL_INIT_VIDEO)) {
|
||||
std::cout << "¡SDL no se pudo inicializar! Error de SDL: " << SDL_GetError() << std::endl;
|
||||
success = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// Crear ventana principal
|
||||
window = SDL_CreateWindow(WINDOW_CAPTION, SCREEN_WIDTH * WINDOW_SIZE, SCREEN_HEIGHT * WINDOW_SIZE, SDL_WINDOW_OPENGL);
|
||||
if (window == nullptr)
|
||||
{
|
||||
if (window == nullptr) {
|
||||
std::cout << "¡No se pudo crear la ventana! Error de SDL: " << SDL_GetError() << std::endl;
|
||||
success = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// Crear renderizador
|
||||
renderer = SDL_CreateRenderer(window, nullptr);
|
||||
if (renderer == nullptr)
|
||||
{
|
||||
if (renderer == nullptr) {
|
||||
std::cout << "¡No se pudo crear el renderizador! Error de SDL: " << SDL_GetError() << std::endl;
|
||||
success = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// Establecer color inicial del renderizador
|
||||
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
|
||||
|
||||
@@ -340,31 +315,25 @@ bool init()
|
||||
}
|
||||
|
||||
// Limpia todos los recursos y cierra SDL
|
||||
void close()
|
||||
{
|
||||
void close() {
|
||||
SDL_DestroyRenderer(renderer);
|
||||
SDL_DestroyWindow(window);
|
||||
SDL_Quit();
|
||||
}
|
||||
|
||||
// Verifica los eventos en la cola
|
||||
void checkEvents()
|
||||
{
|
||||
void checkEvents() {
|
||||
SDL_Event event;
|
||||
while (SDL_PollEvent(&event) != 0)
|
||||
{
|
||||
while (SDL_PollEvent(&event) != 0) {
|
||||
// Evento de salida
|
||||
if (event.type == SDL_EVENT_QUIT)
|
||||
{
|
||||
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)
|
||||
{
|
||||
if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0) {
|
||||
switch (event.key.key) {
|
||||
case SDLK_ESCAPE:
|
||||
should_exit = true;
|
||||
break;
|
||||
@@ -456,8 +425,7 @@ void checkEvents()
|
||||
}
|
||||
|
||||
// Actualiza la lógica del juego
|
||||
void update()
|
||||
{
|
||||
void update() {
|
||||
// Calcular FPS
|
||||
fps_frame_count++;
|
||||
Uint64 current_time = SDL_GetTicks();
|
||||
@@ -470,21 +438,18 @@ void update()
|
||||
}
|
||||
|
||||
// ¡DELTA TIME! Actualizar física siempre, usando tiempo transcurrido
|
||||
for (auto &ball : balls)
|
||||
{
|
||||
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)
|
||||
{
|
||||
if (show_text) {
|
||||
show_text = !(SDL_GetTicks() - text_init_time > TEXT_DURATION);
|
||||
}
|
||||
}
|
||||
|
||||
// Renderiza el contenido en la pantalla
|
||||
void render()
|
||||
{
|
||||
void render() {
|
||||
// Renderizar fondo degradado en lugar de color sólido
|
||||
renderGradientBackground();
|
||||
|
||||
@@ -493,8 +458,7 @@ void render()
|
||||
batch_indices.clear();
|
||||
|
||||
// Recopilar datos de todas las bolas para batch rendering
|
||||
for (auto &ball : balls)
|
||||
{
|
||||
for (auto &ball : balls) {
|
||||
// En lugar de ball->render(), obtener datos para batch
|
||||
SDL_FRect pos = ball->getPosition();
|
||||
Color color = ball->getColor();
|
||||
@@ -502,15 +466,11 @@ void render()
|
||||
}
|
||||
|
||||
// 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 (!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)
|
||||
{
|
||||
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
|
||||
@@ -527,15 +487,11 @@ void render()
|
||||
{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]);
|
||||
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)
|
||||
{
|
||||
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
|
||||
@@ -545,8 +501,7 @@ void render()
|
||||
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())
|
||||
{
|
||||
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);
|
||||
@@ -572,16 +527,13 @@ void render()
|
||||
}
|
||||
|
||||
// Función principal
|
||||
int main(int argc, char *args[])
|
||||
{
|
||||
if (!init())
|
||||
{
|
||||
int main(int argc, char *args[]) {
|
||||
if (!init()) {
|
||||
std::cout << "Ocurrió un error durante la inicialización." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
while (!should_exit)
|
||||
{
|
||||
while (!should_exit) {
|
||||
// 1. Calcular delta time antes de actualizar la lógica
|
||||
calculateDeltaTime();
|
||||
|
||||
|
||||
Reference in New Issue
Block a user