jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

migrant a SDL3

Browse Source
This commit is contained in:
Sergio
2025-03-27 08:14:37 +01:00
parent a9c869baf6
commit d2286905dc
83 changed files with 570 additions and 541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
CMakeLists.txt
View File

@@ -6,12 +6,6 @@ project(coffee_crisis_arcade_edition VERSION 2.00)
# Establece las políticas
cmake_policy(SET CMP0072 NEW)
# Configuración de compilador para MinGW en Windows, si es necesario
if(WIN32 AND NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
set(CMAKE_CXX_COMPILER "g++")
set(CMAKE_C_COMPILER "gcc")
endif()
# Establecer estándar de C++
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -31,49 +25,43 @@ if(NOT SOURCES)
message(FATAL_ERROR "No se encontraron archivos fuente en ${DIR_SOURCES}. Verifica que el directorio existe y contiene archivos .cpp.")
endif()
# Configuración de SDL3
find_package(SDL3 REQUIRED)
if(SDL3_FOUND)
message(STATUS "SDL3 encontrado: ${SDL3_INCLUDE_DIRS}")
include_directories(${SDL3_INCLUDE_DIRS})
link_directories(${SDL3_LIBDIR})
else()
message(FATAL_ERROR "SDL3 no encontrado")
endif()
# Configuración de SDL3 (usando el método recomendado)
find_package(SDL3 REQUIRED CONFIG REQUIRED COMPONENTS SDL3)
message(STATUS "SDL3 encontrado: ${SDL3_INCLUDE_DIRS}")
# Incluye rutas de SDL3 obtenidas con pkg-config
include_directories(/usr/local/include /usr/local/include/SDL3)
link_directories(/usr/local/lib)
# Definir las bibliotecas comunes
set(LIBS SDL2)
# Configuración común de salida de ejecutables en el directorio raíz
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
# Incluye los directorios si es necesario (SDL3::SDL3 ya incluye la información necesaria)
include_directories(${SDL3_INCLUDE_DIRS})
# Añadir ejecutable principal
add_executable(${PROJECT_NAME} ${SOURCES})
# Enlazar la librería SDL3
target_link_libraries(${PROJECT_NAME} PRIVATE SDL3::SDL3)
# Configuración común de salida de ejecutables en el directorio raíz
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
# Añadir definiciones de compilación dependiendo del tipo de build
target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:DEBUG>:DEBUG VERBOSE>)
# Enlazar bibliotecas
target_link_libraries(${PROJECT_NAME} ${LIBS})
# Configuración específica para cada plataforma
if(WIN32)
target_compile_definitions(${PROJECT_NAME} PRIVATE WINDOWS_BUILD)
target_link_libraries(${PROJECT_NAME} mingw32 opengl32 gdi32 winmm imm32 ole32 version)
target_link_libraries(${PROJECT_NAME} PRIVATE mingw32 opengl32)
elseif(APPLE)
set(LIBS ${LIBS} "-framework OpenGL")
target_compile_definitions(${PROJECT_NAME} PRIVATE MACOS_BUILD)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
# Configurar compilación para Apple Silicon
set(CMAKE_OSX_ARCHITECTURES "arm64")
elseif(UNIX AND NOT APPLE)
set(LIBS ${LIBS} GL)
target_compile_definitions(${PROJECT_NAME} PRIVATE LINUX_BUILD)
target_link_libraries(${PROJECT_NAME} ${LIBS})
# Por ejemplo, si necesitas enlazar OpenGL:
find_package(OpenGL REQUIRED)
if(OPENGL_FOUND)
message(STATUS "OpenGL encontrado: ${OPENGL_LIBRARIES}")
target_link_libraries(${PROJECT_NAME} PRIVATE ${OPENGL_LIBRARIES})
else()
message(FATAL_ERROR "OpenGL no encontrado")
endif()
endif()
# Añadir OpenGL a las bibliotecas enlazadas

4
source/animated_sprite.cpp
View File

@@ -156,8 +156,8 @@ void AnimatedSprite::resetAnimation()
// Carga la animación desde un vector de cadenas
void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source)
{
int frame_width = 1;
int frame_height = 1;
float frame_width = 1;
float frame_height = 1;
int frames_per_row = 1;
int max_tiles = 1;

1
source/animated_sprite.h
View File

@@ -1,5 +1,6 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <memory> // Para shared_ptr
#include <string> // Para string

1
source/asset.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <string> // Para string, basic_string
#include <vector> // Para vector

30
source/background.cpp
View File

@@ -57,11 +57,11 @@ Background::Background()
const float TOP_CLOUDS_Y = base_ - 165;
const float BOTTOM_CLOUDS_Y = base_ - 101;
top_clouds_sprite_a_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){0, TOP_CLOUDS_Y, rect_.w, top_clouds_texture_->getHeight()});
top_clouds_sprite_b_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){rect_.w, TOP_CLOUDS_Y, rect_.w, top_clouds_texture_->getHeight()});
top_clouds_sprite_a_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){0, TOP_CLOUDS_Y, rect_.w, static_cast<float>(top_clouds_texture_->getHeight())});
top_clouds_sprite_b_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){rect_.w, TOP_CLOUDS_Y, rect_.w, static_cast<float>(top_clouds_texture_->getHeight())});
bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){0, BOTTOM_CLOUDS_Y, rect_.w, bottom_clouds_texture_->getHeight()});
bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){rect_.w, BOTTOM_CLOUDS_Y, rect_.w, bottom_clouds_texture_->getHeight()});
bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){0, BOTTOM_CLOUDS_Y, rect_.w, static_cast<float>(bottom_clouds_texture_->getHeight())});
bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){rect_.w, BOTTOM_CLOUDS_Y, rect_.w, static_cast<float>(bottom_clouds_texture_->getHeight())});
buildings_sprite_ = std::make_unique<Sprite>(buildings_texture_);
gradient_sprite_ = std::make_unique<Sprite>(gradients_texture_, 0, 0, rect_.w, rect_.h);
@@ -337,21 +337,21 @@ void Background::updateClouds()
// Precalcula el vector con el recorrido del sol
void Background::createSunPath()
{
constexpr int CENTER_X = 170;
const int center_y = base_ - 80;
constexpr int RADIUS = 120;
constexpr float CENTER_X = 170;
const float center_y = base_ - 80;
constexpr float RADIUS = 120;
// Generar puntos de la curva desde 90 a 180 grados
for (double theta = M_PI / 2; theta <= M_PI; theta += 0.01)
{
int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
int y = center_y - static_cast<int>(RADIUS * sin(theta));
float x = CENTER_X + (RADIUS * cos(theta));
float y = center_y - (RADIUS * sin(theta));
sun_path_.push_back({x, y});
}
// Agregar puntos en línea recta después de la curva
constexpr int EXTRA_PIXELS = 40;
SDL_Point last_point = sun_path_.back();
SDL_FPoint last_point = sun_path_.back();
for (int i = 1; i <= EXTRA_PIXELS; ++i)
{
sun_path_.push_back({last_point.x, last_point.y + i});
@@ -361,15 +361,15 @@ void Background::createSunPath()
// Precalcula el vector con el recorrido de la luna
void Background::createMoonPath()
{
constexpr int CENTER_X = 100;
const int center_y = base_ - 50;
constexpr int RADIUS = 140;
constexpr float CENTER_X = 100;
const float center_y = base_ - 50;
constexpr float RADIUS = 140;
// Generar puntos de la curva desde 0 a 90 grados
for (double theta = 0; theta <= M_PI / 2; theta += 0.01)
{
int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
int y = center_y - static_cast<int>(RADIUS * sin(theta));
float x = CENTER_X + (RADIUS * cos(theta));
float y = center_y - (RADIUS * sin(theta));
moon_path_.push_back({x, y});
}
}

41
source/background.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_Point
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_FPoint
#include <SDL3/SDL_render.h> // Para SDL_Texture, SDL_Renderer
#include <stddef.h> // Para size_t
#include <memory> // Para unique_ptr, shared_ptr
@@ -71,25 +72,25 @@ private:
SDL_Texture *color_texture_; // Textura para atenuar el fondo
// Variables
SDL_FRect gradient_rect_[4]; // Vector con las coordenadas de los 4 degradados para el cielo
SDL_FRect top_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de arriba
SDL_FRect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
int gradient_number_ = 0; // Indica el número de degradado de fondo que se va a dibujar
int alpha_ = 0; // Transparencia entre los dos degradados
float clouds_speed_ = 0; // Velocidad a la que se desplazan las nubes
float transition_ = 0; // Nivel de transición del fondo 0..1
int counter_ = 0; // Contador interno
SDL_FRect rect_; // Tamaño del objeto fondo
SDL_FRect src_rect_; // Parte del objeto fondo que se va a dibujará en pantalla
SDL_FRect dst_rect_; // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
int base_; // Linea de fondo coincidente con el area inferior de la zona de juego
Color attenuate_color_; // Color para atenuar el fondo
int alpha_color_text_; // Alpha para atenuar el fondo
int alpha_color_text_temp_; // Valor temporal para hacer la transición de alpha
std::vector<SDL_Point> sun_path_; // Vector con el recorrido del sol
std::vector<SDL_Point> moon_path_; // Vector con el recorrido de la luna
size_t sun_index_ = 0; // Posición del vector del recorrido del sol
size_t moon_index_ = 0; // Posición del vector del recorrido de la luna
SDL_FRect gradient_rect_[4]; // Vector con las coordenadas de los 4 degradados para el cielo
SDL_FRect top_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de arriba
SDL_FRect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
int gradient_number_ = 0; // Indica el número de degradado de fondo que se va a dibujar
int alpha_ = 0; // Transparencia entre los dos degradados
float clouds_speed_ = 0; // Velocidad a la que se desplazan las nubes
float transition_ = 0; // Nivel de transición del fondo 0..1
int counter_ = 0; // Contador interno
SDL_FRect rect_; // Tamaño del objeto fondo
SDL_FRect src_rect_; // Parte del objeto fondo que se va a dibujará en pantalla
SDL_FRect dst_rect_; // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
int base_; // Linea de fondo coincidente con el area inferior de la zona de juego
Color attenuate_color_; // Color para atenuar el fondo
int alpha_color_text_; // Alpha para atenuar el fondo
int alpha_color_text_temp_; // Valor temporal para hacer la transición de alpha
std::vector<SDL_FPoint> sun_path_; // Vector con el recorrido del sol
std::vector<SDL_FPoint> moon_path_; // Vector con el recorrido de la luna
size_t sun_index_ = 0; // Posición del vector del recorrido del sol
size_t moon_index_ = 0; // Posición del vector del recorrido de la luna
// Dibuja el gradiente de fondo
void renderGradient();

2
source/balloon.cpp
View File

@@ -117,7 +117,7 @@ void Balloon::render()
// Renderiza la estrella
if (!invulnerable_)
{
SDL_Point p = {24, 24};
SDL_FPoint p = {24.0f, 24.0f};
sprite_->setRotatingCenter(p);
sprite_->render();
}

5
source/balloon.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_stdinc.h> // Para Uint8, Uint16, Uint32
@@ -90,8 +91,8 @@ private:
// Variables
float x_; // Posición en el eje X
float y_; // Posición en el eje Y
Uint8 w_; // Ancho
Uint8 h_; // Alto
float w_; // Ancho
float h_; // Alto
float vx_; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
float vy_; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
float gravity_; // Aceleración en el eje Y. Modifica la velocidad

1
source/balloon_formations.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include "balloon.h" // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
#include <vector>

20
source/balloon_manager.cpp
View File

@@ -216,19 +216,19 @@ void BalloonManager::createPowerBall()
{
if (can_deploy_balloons_)
{
constexpr int values = 6;
constexpr int pos_y = -BALLOON_SIZE[4];
constexpr int creation_time = 0;
constexpr int VALUES = 6;
constexpr float POS_Y = -BALLOON_SIZE[4];
constexpr int CREATION_TIME = 0;
const auto left = param.game.play_area.rect.x;
const auto center = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
const auto right = param.game.play_area.rect.w - BALLOON_SIZE[4];
const float LEFT = param.game.play_area.rect.x;
const float CENTER = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
const float RIGHT = param.game.play_area.rect.w - BALLOON_SIZE[4];
const auto luck = rand() % values;
const int x[values] = {left, left, center, center, right, right};
const float vx[values] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
const int LUCK = rand() % VALUES;
const float POS_X[VALUES] = {LEFT, LEFT, CENTER, CENTER, RIGHT, RIGHT};
const float VEL_X[VALUES] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
balloons_.emplace_back(std::make_unique<Balloon>(x[luck], pos_y, BalloonType::POWERBALL, BalloonSize::SIZE4, vx[luck], balloon_speed_, creation_time, play_area_, balloon_textures_[4], balloon_animations_[4]));
balloons_.emplace_back(std::make_unique<Balloon>(POS_X[LUCK], POS_Y, BalloonType::POWERBALL, BalloonSize::SIZE4, VEL_X[LUCK], balloon_speed_, CREATION_TIME, play_area_, balloon_textures_[4], balloon_animations_[4]));
balloons_.back()->setInvulnerable(true);
power_ball_enabled_ = true;

1
source/balloon_manager.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <memory> // Para shared_ptr, unique_ptr

2
source/bullet.cpp
View File

@@ -6,7 +6,7 @@
class Texture; // lines 5-5
// Constructor
Bullet::Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture)
Bullet::Bullet(float x, float y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture)
: sprite_(std::make_unique<Sprite>(texture, SDL_FRect{x, y, BULLET_WIDTH_, BULLET_HEIGHT_})),
pos_x_(x),
pos_y_(y),

19
source/bullet.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_stdinc.h> // Para Uint8
#include <memory> // Para shared_ptr, unique_ptr
@@ -27,17 +28,17 @@ class Bullet
{
private:
// Constantes
static constexpr int BULLET_WIDTH_ = 12;
static constexpr int BULLET_HEIGHT_ = 12;
static constexpr int BULLET_VEL_Y_ = -3;
static constexpr int BULLET_VEL_X_LEFT_ = -2;
static constexpr int BULLET_VEL_X_RIGHT_ = 2;
static constexpr float BULLET_WIDTH_ = 12.0f;
static constexpr float BULLET_HEIGHT_ = 12.0f;
static constexpr float BULLET_VEL_Y_ = -3.0f;
static constexpr float BULLET_VEL_X_LEFT_ = -2.0f;
static constexpr float BULLET_VEL_X_RIGHT_ = 2.0f;
std::unique_ptr<Sprite> sprite_; // Sprite con los gráficos y métodos de pintado
int pos_x_; // Posición en el eje X
int pos_y_; // Posición en el eje Y
int vel_x_; // Velocidad en el eje X
float pos_x_; // Posición en el eje X
float pos_y_; // Posición en el eje Y
float vel_x_; // Velocidad en el eje X
BulletType bullet_type_; // Tipo de objeto
int owner_; // Identificador del dueño del objeto
@@ -48,7 +49,7 @@ private:
public:
// Constructor
Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
Bullet(float x, float y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
// Destructor
~Bullet() = default;

8
source/credits.cpp
View File

@@ -408,11 +408,11 @@ void Credits::updateBlackRects()
if (counter_ % 4 == 0)
{
// Incrementa la altura del rectangulo superior
top_black_rect_.h = std::min(static_cast<int>(top_black_rect_.h) + 1, param.game.game_area.center_y - 1);
top_black_rect_.h = std::min(top_black_rect_.h + 1, param.game.game_area.center_y - 1);
// Incrementa la altura y modifica la posición del rectangulo inferior
++bottom_black_rect_.h;
bottom_black_rect_.y = std::max(static_cast<int>(bottom_black_rect_.y) - 1, param.game.game_area.center_y + 1);
bottom_black_rect_.y = std::max(bottom_black_rect_.y - 1, param.game.game_area.center_y + 1);
--current_step;
setVolume(static_cast<int>(initial_volume_ * current_step / steps_));
@@ -426,11 +426,11 @@ void Credits::updateBlackRects()
constexpr int SPEED = 2;
// Si los rectangulos izquierdo y derecho no han llegado al centro
// Incrementa la anchura del rectangulo situado a la izquierda
left_black_rect_.w = std::min(static_cast<int>(left_black_rect_.w) + SPEED, param.game.game_area.center_x);
left_black_rect_.w = std::min(left_black_rect_.w + SPEED, param.game.game_area.center_x);
// Incrementa la anchura y modifica la posición del rectangulo situado a la derecha
right_black_rect_.w += SPEED;
right_black_rect_.x = std::max(static_cast<int>(right_black_rect_.x) - SPEED, param.game.game_area.center_x);
right_black_rect_.x = std::max(right_black_rect_.x - SPEED, param.game.game_area.center_x);
--current_step;
setVolume(static_cast<int>(initial_volume_ * current_step / steps_));

23
source/credits.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Texture
@@ -28,17 +29,17 @@ private:
std::vector<std::shared_ptr<Player>> players_; // Vector con los jugadores
// Variables
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint32 counter_ = 0; // Contador para la lógica de la clase
Uint32 counter_pre_fade_ = 0; // Contador para activar el fundido final
Uint32 counter_prevent_endless_ = 0; // Contador para evitar que el juego se quede para siempre en los creditos
int black_bars_size_ = (param.game.game_area.rect.h - PLAY_AREA_HEIGHT) / 2; // Tamaño de las barras negras
int mini_logo_final_pos_ = 0; // Ubicación donde se detiene el minilogo
bool fading_ = false; // Indica si se está realizando el fade final
bool want_to_pass_ = false; // Indica si el jugador quiere saltarse los titulos de crédito
bool mini_logo_on_position_ = false; // Indica si el minilogo ya se ha quedado en su posición
int initial_volume_ = options.audio.music.volume; // Volumen actual al crear el objeto
int steps_ = 0; // Cantidad de pasos a dar para ir reduciendo el audio
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint32 counter_ = 0; // Contador para la lógica de la clase
Uint32 counter_pre_fade_ = 0; // Contador para activar el fundido final
Uint32 counter_prevent_endless_ = 0; // Contador para evitar que el juego se quede para siempre en los creditos
float black_bars_size_ = (param.game.game_area.rect.h - PLAY_AREA_HEIGHT) / 2; // Tamaño de las barras negras
int mini_logo_final_pos_ = 0; // Ubicación donde se detiene el minilogo
bool fading_ = false; // Indica si se está realizando el fade final
bool want_to_pass_ = false; // Indica si el jugador quiere saltarse los titulos de crédito
bool mini_logo_on_position_ = false; // Indica si el minilogo ya se ha quedado en su posición
int initial_volume_ = options.audio.music.volume; // Volumen actual al crear el objeto
int steps_ = 0; // Cantidad de pasos a dar para ir reduciendo el audio
// Rectangulos
SDL_FRect credits_rect_src_ = param.game.game_area.rect; // Rectangulo con el texto de los créditos (origen)

1
source/define_buttons.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_events.h> // Para SDL_ControllerButtonEvent
#include <SDL3/SDL.h> // Para SDL_GamepadButton

98
source/director.cpp
View File

@@ -1,47 +1,47 @@
// IWYU pragma: no_include <bits/chrono.h>
#include "director.h"
#include <SDL3/SDL.h> // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
#include <SDL3/SDL_audio.h> // Para AUDIO_S16
#include <SDL3/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
#include <SDL3/SDL_error.h> // Para SDL_GetError
#include <SDL3/SDL_events.h> // Para SDL_DISABLE
#include <SDL3/SDL.h> // Para SDL_GAMEPAD_BUTTON_B, SDL_CO...
#include <SDL3/SDL_hints.h> // Para SDL_SetHint, SDL_HINT_RENDER_DR...
#include <SDL3/SDL_mouse.h> // Para SDL_ShowCursor
#include <SDL3/SDL_scancode.h> // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
#include <SDL3/SDL_stdinc.h> // Para Uint32, SDL_bool
#include <errno.h> // Para errno, EEXIST, EACCES, ENAMETOO...
#include <stdio.h> // Para printf, perror
#include <sys/stat.h> // Para mkdir, stat, S_IRWXU
#include <unistd.h> // Para getuid
#include <algorithm> // Para min
#include <chrono> // Para chrono
#include <cstdlib> // Para exit, EXIT_FAILURE, size_t, rand
#include <iostream> // Para basic_ostream, operator<<, basi...
#include <memory> // Para make_unique, unique_ptr
#include <stdexcept> // Para runtime_error
#include <string> // Para operator+, char_traits, allocator
#include <vector> // Para vector
#include "asset.h" // Para Asset, AssetType
#include "credits.h" // Para Credits
#include "game.h" // Para Game, GAME_MODE_DEMO_OFF, GAME_...
#include "hiscore_table.h" // Para HiScoreTable
#include "input.h" // Para Input, InputAction
#include "instructions.h" // Para Instructions
#include "intro.h" // Para Intro
#include "jail_audio.h" // Para JA_SetMusicVolume, JA_SetSoundV...
#include "lang.h" // Para Code, loadFromFile
#include "logo.h" // Para Logo
#include "manage_hiscore_table.h" // Para ManageHiScoreTable
#include "notifier.h" // Para Notifier
#include "on_screen_help.h" // Para OnScreenHelp
#include "options.h" // Para Options, options, OptionsContro...
#include "param.h" // Para Param, ParamGame, param, loadPa...
#include "resource.h" // Para Resource
#include "screen.h" // Para Screen
#include "section.h" // Para Name, Options, name, options
#include "title.h" // Para Title
#include "utils.h" // Para Overrides, overrides
#include <SDL3/SDL.h> // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
#include <SDL3/SDL_audio.h> // Para AUDIO_S16
#include <SDL3/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
#include <SDL3/SDL_error.h> // Para SDL_GetError
#include <SDL3/SDL_events.h> // Para SDL_DISABLE
#include <SDL3/SDL.h> // Para SDL_GAMEPAD_BUTTON_B, SDL_CO...
#include <SDL3/SDL_hints.h> // Para SDL_SetHint, SDL_HINT_RENDER_DR...
#include <SDL3/SDL_mouse.h> // Para SDL_ShowCursor
#include <SDL3/SDL_scancode.h> // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
#include <SDL3/SDL_stdinc.h> // Para Uint32, SDL_bool
#include <errno.h> // Para errno, EEXIST, EACCES, ENAMETOO...
#include <stdio.h> // Para printf, perror
#include <sys/stat.h> // Para mkdir, stat, S_IRWXU
#include <unistd.h> // Para getuid
#include <algorithm> // Para min
#include <chrono> // Para chrono
#include <cstdlib> // Para exit, EXIT_FAILURE, size_t, rand
#include <iostream> // Para basic_ostream, operator<<, basi...
#include <memory> // Para make_unique, unique_ptr
#include <stdexcept> // Para runtime_error
#include <string> // Para operator+, char_traits, allocator
#include <vector> // Para vector
#include "asset.h" // Para Asset, AssetType
#include "credits.h" // Para Credits
#include "game.h" // Para Game, GAME_MODE_DEMO_OFF, GAME_...
#include "hiscore_table.h" // Para HiScoreTable
#include "input.h" // Para Input, InputAction
#include "instructions.h" // Para Instructions
#include "intro.h" // Para Intro
#include "jail_audio.h" // Para JA_SetMusicVolume, JA_SetSoundV...
#include "lang.h" // Para Code, loadFromFile
#include "logo.h" // Para Logo
#include "manage_hiscore_table.h" // Para ManageHiScoreTable
#include "notifier.h" // Para Notifier
#include "on_screen_help.h" // Para OnScreenHelp
#include "options.h" // Para Options, options, OptionsContro...
#include "param.h" // Para Param, ParamGame, param, loadPa...
#include "resource.h" // Para Resource
#include "screen.h" // Para Screen
#include "section.h" // Para Name, Options, name, options
#include "title.h" // Para Title
#include "utils.h" // Para Overrides, overrides
#ifndef _WIN32
#include <pwd.h> // Para getpwuid, passwd
@@ -296,7 +296,7 @@ bool Director::initSDL()
else
{
// Obtiene información sobre la pantalla
auto DM= SDL_GetCurrentDisplayMode(0);
auto DM = SDL_GetCurrentDisplayMode(0);
// Calcula el máximo factor de zoom que se puede aplicar a la pantalla
options.video.window.max_zoom = std::min(DM->w / param.game.width, DM->h / param.game.height);
@@ -327,14 +327,14 @@ bool Director::initSDL()
else
{
// Crea un renderizador para la ventana. El vsync se activa en funcion de las opciones
Uint32 flags = 0;
//Uint32 flags = 0;
if (options.video.v_sync)
{
//flags = SDL_RENDERER_PRESENTVSYNC;
// flags = SDL_RENDERER_PRESENTVSYNC;
}
// La aceleración se activa según el define
//flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
// flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
renderer_ = SDL_CreateRenderer(window_, nullptr);
@@ -347,7 +347,7 @@ bool Director::initSDL()
{
SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
SDL_SetRenderLogicalPresentation(renderer_, param.game.width, param.game.height, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
SDL_SetWindowFullscreen(window_, static_cast<Uint32>(options.video.mode));
SDL_SetWindowFullscreen(window_, static_cast<Uint32>(options.video.fullscreen));
SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
}
}
@@ -799,9 +799,9 @@ std::string Director::getLangFile(lang::Code code)
#ifdef ARCADE
// Apaga el sistema
void Director::shutdownSystem(bool shouldShutdown)
void Director::shutdownSystem(bool should_shutdown)
{
if (shouldShutdown)
if (should_shutdown)
{
#ifdef _WIN32
// Apaga el sistema en Windows

3
source/director.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_render.h> // Para SDL_Renderer
#include <SDL3/SDL_video.h> // Para SDL_Window
@@ -74,7 +75,7 @@ private:
std::string getLangFile(lang::Code code);
#ifdef ARCADE
// Apaga el sistema
void shutdownSystem(bool shouldShutdown);
void shutdownSystem(bool should_shutdown);
#endif
// Inicializa todo

1
source/enter_name.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <string>
#include <array>

1
source/explosions.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <memory> // Para unique_ptr, shared_ptr
#include <string> // Para string

1
source/fade.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture

2
source/game.cpp
View File

@@ -314,7 +314,7 @@ void Game::updateGameStateGameOver()
if (game_over_counter_ == GAME_OVER_COUNTER_)
{
createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_text_game_over"));
JA_FadeOutMusic(1000);
/*JA_FadeOutMusic(1000);*/
balloon_manager_->setSounds(true);
}

3
source/game.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture
#include <SDL3/SDL_stdinc.h> // Para Uint32, Uint8
@@ -159,7 +160,7 @@ private:
Demo demo_; // Variable con todas las variables relacionadas con el modo demo
GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
Helper helper_; // Variable para gestionar las ayudas
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
bool coffee_machine_enabled_ = false; // Indica si hay una máquina de café en el terreno de juego
bool hi_score_achieved_ = false; // Indica si se ha superado la puntuación máxima
bool paused_ = false; // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)

6
source/game_logo.cpp
View File

@@ -247,8 +247,8 @@ bool GameLogo::hasFinished() const
// Calcula el desplazamiento vertical inicial
int GameLogo::getInitialVerticalDesp()
{
auto desp_up = y_;
auto desp_down = param.game.height - y_;
const float OFFSET_UP = y_;
const float OFFSET_DOWN = param.game.height - y_;
return std::max(desp_up, desp_down);
return std::max(OFFSET_UP, OFFSET_DOWN);
}

5
source/game_logo.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <memory> // Para unique_ptr, shared_ptr
#include "animated_sprite.h" // Para AnimatedSprite
@@ -61,8 +62,8 @@ private:
std::unique_ptr<Sprite> arcade_edition_sprite_; // Sprite con los graficos de "Arcade Edition"
// Variables
int x_; // Posición donde dibujar el logo
int y_; // Posición donde dibujar el logo
float x_; // Posición donde dibujar el logo
float y_; // Posición donde dibujar el logo
float zoom_ = 1.0f; // Zoom aplicado al texto "ARCADE EDITION"
int post_finished_counter_ = 1; // Contador final una vez terminada las animaciones de los logos

1
source/global_events.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_events.h>

10
source/global_inputs.cpp
View File

@@ -10,7 +10,7 @@
#include "notifier.h" // Para Notifier
#include "on_screen_help.h" // Para OnScreenHelp
#include "options.h" // Para Options, options, OptionsGame, OptionsV...
#include "screen.h" // Para Screen, ScreenVideoMode
#include "screen.h" // Para Screen
#include "section.h" // Para Name, name, Options, options, AttractMode
#include "utils.h" // Para boolToOnOff
@@ -79,7 +79,7 @@ namespace globalInputs
{
options.video.integer_scale = !options.video.integer_scale;
SDL_SetRenderLogicalPresentation(Screen::get()->getRenderer(), param.game.width, param.game.height, options.video.integer_scale ? SDL_LOGICAL_PRESENTATION_INTEGER_SCALE : SDL_LOGICAL_PRESENTATION_LETTERBOX);
Screen::get()->setVideoMode();
Screen::get()->setFullscreenMode();
Notifier::get()->show({lang::getText(134) + " " + boolToOnOff(options.video.integer_scale)});
}
@@ -180,9 +180,9 @@ namespace globalInputs
// Comprueba el teclado para cambiar entre pantalla completa y ventana
if (Input::get()->checkInput(InputAction::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{
Screen::get()->toggleVideoMode();
const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? lang::getText(132) : lang::getText(133);
Notifier::get()->show({mode});
Screen::get()->toggleFullscreen();
const std::string MODE = options.video.fullscreen ? lang::getText(133) : lang::getText(132);
Notifier::get()->show({MODE});
return;
}

3
source/global_inputs.h
View File

@@ -1,3 +1,6 @@
#pragma once
#include <SDL3/SDL.h>
namespace globalInputs
{
extern int service_pressed_counter;

2
source/hiscore_table.cpp
View File

@@ -123,7 +123,7 @@ void HiScoreTable::render()
background_->render();
// Establece la ventana del backbuffer
view_area_.y = std::max(0, param.game.height - counter_ + 100);
view_area_.y = std::max(0.0f, param.game.height - counter_ + 100);
// Copia el backbuffer al renderizador
SDL_RenderTexture(renderer_, backbuffer_, nullptr, &view_area_);

3
source/hiscore_table.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture
@@ -43,7 +44,7 @@ private:
// Variables
Uint16 counter_ = 0; // Contador
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
Uint64 ticks_; // Contador de ticks para ajustar la velocidad del programa
SDL_FRect view_area_; // Parte de la textura que se muestra en pantalla
FadeMode fade_mode_; // Modo de fade a utilizar
Color background_fade_color_; // Color de atenuación del fondo

2
source/input.cpp
View File

@@ -296,7 +296,7 @@ std::string Input::getControllerName(int controller_index) const { return num_ga
int Input::getNumControllers() const { return num_gamepads_; }
// Obtiene el indice del controlador a partir de un event.id
int Input::getJoyIndex(int id) const
int Input::getJoyIndex(SDL_JoystickID id) const
{
for (int i = 0; i < num_joysticks_; ++i)
{

2
source/input.h
View File

@@ -148,7 +148,7 @@ public:
std::string getControllerName(int controller_index) const;
// Obtiene el indice del controlador a partir de un event.id
int getJoyIndex(int id) const;
int getJoyIndex(SDL_JoystickID id) const;
// Muestra por consola los controles asignados
void printBindings(InputDeviceToUse device = InputDeviceToUse::KEYBOARD, int controller_index = 0) const;

34
source/instructions.cpp
View File

@@ -78,7 +78,7 @@ void Instructions::iniSprites()
for (int i = 0; i < (int)item_textures_.size(); ++i)
{
auto sprite = std::make_unique<Sprite>(item_textures_[i], 0, 0, param.game.item_size, param.game.item_size);
sprite->setPosition((SDL_Point){sprite_pos_.x, sprite_pos_.y + ((param.game.item_size + item_space_) * i)});
sprite->setPosition((SDL_FPoint){sprite_pos_.x, sprite_pos_.y + ((param.game.item_size + item_space_) * i)});
sprites_.push_back(std::move(sprite));
}
}
@@ -302,44 +302,44 @@ std::vector<Line> Instructions::initializeLines(int height)
// Método para mover las líneas con suavizado
bool Instructions::moveLines(std::vector<Line> &lines, int width, float duration, Uint32 startDelay)
{
Uint32 currentTime = SDL_GetTicks();
bool allLinesOffScreen = true;
Uint32 current_time = SDL_GetTicks();
bool all_lines_off_screen = true;
for (auto &line : lines)
{
// Establecer startTime en el primer cuadro de animación
if (line.startTime == 0)
{
line.startTime = currentTime + line.y * startDelay;
line.startTime = current_time + line.y * startDelay;
}
float elapsedTime = (currentTime - line.startTime) / 1000.0f; // Convertir a segundos
if (elapsedTime < 0)
float elapsed_time = (current_time - line.startTime) / 1000.0f; // Convertir a segundos
if (elapsed_time < 0)
{
allLinesOffScreen = false; // Si aún no se debe mover esta línea, no están todas fuera de pantalla
all_lines_off_screen = false; // Si aún no se debe mover esta línea, no están todas fuera de pantalla
continue;
}
if (elapsedTime >= duration)
if (elapsed_time >= duration)
{
continue; // Si la línea ha salido de los límites, no la muevas más
}
float t = elapsedTime / duration;
float smoothFactor = easeInOutQuint(t);
line.x = line.direction * smoothFactor * width;
allLinesOffScreen = false; // Si alguna línea aún se está moviendo, no están todas fuera de pantalla
float t = elapsed_time / duration;
float smooth_factor = easeInOutQuint(t);
line.x = line.direction * smooth_factor * width;
all_lines_off_screen = false; // Si alguna línea aún se está moviendo, no están todas fuera de pantalla
}
return allLinesOffScreen;
return all_lines_off_screen;
}
// Método para renderizar las líneas
void Instructions::renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines)
{
for (const auto &line : lines)
for (const auto &LINE : lines)
{
SDL_FRect srcRect = {0, line.y, 320, 1};
SDL_FRect dstRect = {static_cast<int>(line.x), line.y, 320, 1};
SDL_FRect srcRect = {0, static_cast<float>(LINE.y), 320, 1};
SDL_FRect dstRect = {static_cast<float>(LINE.x), static_cast<float>(LINE.y), 320, 1};
SDL_RenderTexture(renderer, texture, &srcRect, &dstRect);
}
}
@@ -357,7 +357,7 @@ void Instructions::updateMusic()
void Instructions::updateBackbuffer()
{
// Establece la ventana del backbuffer
view_.y = std::max(0, param.game.height - counter_ + 100);
view_.y = std::max(0.0f, param.game.height - counter_ + 100);
// Verifica si view_.y == 0 y gestiona el temporizador
if (view_.y == 0)

9
source/instructions.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_Point, SDL_FRect
#include <SDL3/SDL_rect.h> // Para SDL_FPoint, SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Texture, SDL_Renderer
#include <SDL3/SDL_stdinc.h> // Para Uint32
#include <memory> // Para unique_ptr, shared_ptr
@@ -54,10 +55,10 @@ private:
// Variables
int counter_ = 0; // Contador para manejar el progreso en la pantalla de instrucciones
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
SDL_FRect view_; // Vista del backbuffer que se va a mostrar por pantalla
SDL_Point sprite_pos_ = {0, 0}; // Posición del primer sprite en la lista
int item_space_ = 2; // Espacio entre los items en pantalla
SDL_FPoint sprite_pos_ = {0, 0}; // Posición del primer sprite en la lista
float item_space_ = 2.0; // Espacio entre los items en pantalla
std::vector<Line> lines_; // Vector que contiene las líneas animadas en la pantalla
bool all_lines_off_screen_ = false; // Indica si todas las líneas han salido de la pantalla
Uint32 start_delay_time_ = 0; // Tiempo de inicio del retraso para mover las líneas

18
source/intro.cpp
View File

@@ -308,10 +308,10 @@ void Intro::initSprites()
// Constantes
auto texture = Resource::get()->getTexture(TEXTURE_LIST.front());
const int SPRITE_WIDTH = texture->getWidth();
const int SPRITE_HEIGHT = texture->getHeight();
const int X_DEST = param.game.game_area.center_x - SPRITE_WIDTH / 2;
const int Y_DEST = param.game.game_area.first_quarter_y - (SPRITE_HEIGHT / 4);
const float SPRITE_WIDTH = texture->getWidth();
const float SPRITE_HEIGHT = texture->getHeight();
const float X_DEST = param.game.game_area.center_x - SPRITE_WIDTH / 2;
const float Y_DEST = param.game.game_area.first_quarter_y - (SPRITE_HEIGHT / 4);
// Inicializa los sprites con las imagenes
constexpr int TOTAL_SPRITES = 6;
@@ -333,11 +333,11 @@ void Intro::initSprites()
sprites_.at(5)->addPath(X_DEST, -SPRITE_WIDTH, PathType::HORIZONTAL, Y_DEST, 80, easeInElastic, 0);
// Constantes
const int BORDER = 4;
const int SHADOW_SPRITE_WIDTH = SPRITE_WIDTH + BORDER;
const int SHADOW_SPRITE_HEIGHT = SPRITE_HEIGHT + BORDER;
const int S_X_DEST = X_DEST - BORDER / 2;
const int S_Y_DEST = Y_DEST - BORDER / 2;
const float BORDER = 4;
const float SHADOW_SPRITE_WIDTH = SPRITE_WIDTH + BORDER;
const float SHADOW_SPRITE_HEIGHT = SPRITE_HEIGHT + BORDER;
const float S_X_DEST = X_DEST - BORDER / 2;
const float S_Y_DEST = Y_DEST - BORDER / 2;
// Crea las texturas para las imágenes traseras
std::vector<std::shared_ptr<Texture>> shadow_textures;

3
source/intro.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_stdinc.h> // Para Uint32, Uint8
#include <memory> // Para unique_ptr
@@ -35,7 +36,7 @@ private:
std::unique_ptr<TiledBG> tiled_bg_;
// Variables
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
int scene_ = 0; // Indica que escena está activa
IntroState state_ = IntroState::SCENES; // Estado
IntroPostState post_state_ = IntroPostState::STOP_BG; // Estado

1
source/item.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_stdinc.h> // Para Uint16

4
source/jail_audio.cpp
View File

@@ -89,7 +89,7 @@ Uint32 JA_UpdateCallback(void *userdata, SDL_TimerID timerID, Uint32 interval)
{
if (current_music->times != 0)
{
if (SDL_GetAudioStreamAvailable(current_music->stream) < (current_music->length / 2))
if (SDL_GetAudioStreamAvailable(current_music->stream) < static_cast<int>(current_music->length / 2))
SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length);
if (current_music->times > 0)
current_music->times--;
@@ -108,7 +108,7 @@ Uint32 JA_UpdateCallback(void *userdata, SDL_TimerID timerID, Uint32 interval)
{
if (channels[i].times != 0)
{
if (SDL_GetAudioStreamAvailable(channels[i].stream) < (channels[i].sound->length / 2))
if (SDL_GetAudioStreamAvailable(channels[i].stream) < static_cast<int>(channels[i].sound->length / 2))
SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
if (channels[i].times > 0)
channels[i].times--;

13
source/jail_shader.cpp
View File

@@ -1,5 +1,5 @@
#include "jail_shader.h"
#include <SDL3/SDL_rect.h> // Para SDL_Point
#include <SDL3/SDL_rect.h> // Para SDL_FPoint
#include <SDL3/SDL_stdinc.h> // Para SDL_bool
#include <cstring> // Para strncmp
#include <iostream> // Para basic_ostream, operator<<, endl, cout
@@ -25,7 +25,7 @@ namespace shader
GLuint programId = 0;
SDL_Texture *backBuffer = nullptr;
SDL_Point win_size = {320 * 4, 256 * 4};
SDL_Point tex_size = {320, 256};
SDL_FPoint tex_size = {320, 256};
bool usingOpenGL = false;
#ifndef __APPLE__
@@ -157,12 +157,13 @@ namespace shader
shader::backBuffer = texturaBackBuffer;
SDL_GetWindowSize(ventana, &win_size.x, &win_size.y);
int acceso;
SDL_QueryTexture(texturaBackBuffer, nullptr, &acceso, &tex_size.x, &tex_size.y);
if (acceso != SDL_TEXTUREACCESS_TARGET)
//int acceso;
SDL_GetTextureSize(texturaBackBuffer, &tex_size.x, &tex_size.y);
// SDL_QueryTexture(texturaBackBuffer, nullptr, &acceso, &tex_size.x, &tex_size.y);
/*if (acceso != SDL_TEXTUREACCESS_TARGET)
{
throw std::runtime_error("ERROR FATAL: La textura debe tener definido SDL_TEXTUREACCESS_TARGET.");
}
}*/
const auto RENDER_NAME = SDL_GetRendererName(renderer);

1
source/jail_shader.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_render.h> // Para SDL_Texture
#include <SDL3/SDL_video.h> // Para SDL_Window

6
source/lang.cpp
View File

@@ -23,9 +23,9 @@ namespace lang
while (std::getline(rfile, line))
{
// Almacena solo las lineas que no empiezan por # o no esten vacias
const bool test1 = line.substr(0, 1) != "#";
const bool test2 = !line.empty();
if (test1 && test2)
const bool TEST1 = line.substr(0, 1) != "#";
const bool TEST2 = !line.empty();
if (TEST1 && TEST2)
{
texts.push_back(line);
}

1
source/lang.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <string> // Para string

8
source/logo.cpp
View File

@@ -24,7 +24,11 @@ Logo::Logo()
section::name = section::Name::LOGO;
dest_.x = param.game.game_area.center_x - jail_texture_->getWidth() / 2;
dest_.y = param.game.game_area.center_y - jail_texture_->getHeight() / 2;
since_sprite_->setPosition({(param.game.width - since_texture_->getWidth()) / 2, 83 + jail_texture_->getHeight() + 5, since_texture_->getWidth(), since_texture_->getHeight()});
since_sprite_->setPosition(SDL_FRect{
static_cast<float>((param.game.width - since_texture_->getWidth()) / 2),
static_cast<float>(83 + jail_texture_->getHeight() + 5),
static_cast<float>(since_texture_->getWidth()),
static_cast<float>(since_texture_->getHeight())});
since_sprite_->setY(dest_.y + jail_texture_->getHeight() + 5);
since_sprite_->setSpriteClip(0, 0, since_texture_->getWidth(), since_texture_->getHeight());
since_texture_->setColor(0x00, 0x00, 0x00);
@@ -181,7 +185,7 @@ void Logo::render()
void Logo::run()
{
// Detiene la música
JA_FadeOutMusic(300);
/*JA_FadeOutMusic(300);*/
while (section::name == section::Name::LOGO)
{

7
source/logo.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_Point
#include <SDL3/SDL_rect.h> // Para SDL_FPoint
#include <SDL3/SDL_stdinc.h> // Para Uint32
#include <memory> // Para shared_ptr, unique_ptr
#include <vector> // Para vector
@@ -36,8 +37,8 @@ private:
// Variables
std::vector<Color> color_; // Vector con los colores para el fade
int counter_ = 0; // Contador
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
SDL_Point dest_; // Posición X donde dibujar el logo
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
SDL_FPoint dest_; // Posición X donde dibujar el logo
// Actualiza las variables
void update();

58
source/manage_hiscore_table.cpp
View File

@@ -1,6 +1,6 @@
#include "manage_hiscore_table.h"
#include <SDL3/SDL_error.h> // Para SDL_GetError
#include <SDL3/SDL_rwops.h> // Para SDL_RWread, SDL_RWwrite, SDL_RWFromFile
#include <SDL3/SDL.h> // Para SDL_RWread, SDL_WriteIO, SDL_RWFromFile
#include <algorithm> // Para find_if, sort
#include <iostream> // Para basic_ostream, operator<<, cout, endl
#include <iterator> // Para distance
@@ -70,9 +70,9 @@ void ManageHiScoreTable::sort()
struct
{
bool operator()(const HiScoreEntry &a, const HiScoreEntry &b) const { return a.score > b.score; }
} scoreDescendingComparator;
} score_descending_comparator;
std::sort(table_.begin(), table_.end(), scoreDescendingComparator);
std::sort(table_.begin(), table_.end(), score_descending_comparator);
}
// Carga la tabla desde un fichero
@@ -80,44 +80,44 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
{
clear();
auto success = true;
auto file = SDL_RWFromFile(file_path.c_str(), "rb");
auto file = SDL_IOFromFile(file_path.c_str(), "rb");
if (file)
{
table_.clear(); // Limpia la tabla actual
// Lee el número de entradas en la tabla
int tableSize = 0;
SDL_RWread(file, &tableSize, sizeof(int), 1);
int table_size = 0;
SDL_ReadIO(file, &table_size, sizeof(int));
// Lee los datos de cada entrada
for (int i = 0; i < tableSize; ++i)
for (int i = 0; i < table_size; ++i)
{
HiScoreEntry entry;
// Lee la puntuación
SDL_RWread(file, &entry.score, sizeof(int), 1);
SDL_ReadIO(file, &entry.score, sizeof(int));
// Lee el tamaño del nombre y luego el nombre
int nameSize = 0;
SDL_RWread(file, &nameSize, sizeof(int), 1);
int name_size = 0;
SDL_ReadIO(file, &name_size, sizeof(int));
std::vector<char> nameBuffer(nameSize + 1);
SDL_RWread(file, nameBuffer.data(), nameSize, 1);
nameBuffer[nameSize] = '\0'; // Asegurar el fin de la cadena
entry.name = std::string(nameBuffer.data());
std::vector<char> name_buffer(name_size + 1);
SDL_ReadIO(file, name_buffer.data(), name_size);
name_buffer[name_size] = '\0'; // Asegurar el fin de la cadena
entry.name = std::string(name_buffer.data());
// Lee el valor de one_credit_complete
int occValue = 0;
SDL_RWread(file, &occValue, sizeof(int), 1);
entry.one_credit_complete = (occValue != 0);
int occ_value = 0;
SDL_ReadIO(file, &occ_value, sizeof(int));
entry.one_credit_complete = (occ_value != 0);
// Añade la entrada a la tabla
table_.push_back(entry);
}
std::cout << "Reading file: " << getFileName(file_path) << std::endl;
SDL_RWclose(file);
SDL_CloseIO(file);
}
else
{
@@ -131,34 +131,34 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
bool ManageHiScoreTable::saveToFile(const std::string &file_path)
{
auto success = true;
auto file = SDL_RWFromFile(file_path.c_str(), "w+b");
auto file = SDL_IOFromFile(file_path.c_str(), "w+b");
if (file)
{
// Guarda el número de entradas en la tabla
int tableSize = static_cast<int>(table_.size());
SDL_RWwrite(file, &tableSize, sizeof(int), 1);
int table_size = static_cast<int>(table_.size());
SDL_WriteIO(file, &table_size, sizeof(int));
// Guarda los datos de cada entrada
for (int i = 0; i < tableSize; ++i)
for (int i = 0; i < table_size; ++i)
{
const HiScoreEntry &entry = table_.at(i);
// Guarda la puntuación
SDL_RWwrite(file, &entry.score, sizeof(int), 1);
SDL_WriteIO(file, &entry.score, sizeof(int));
// Guarda el tamaño del nombre y luego el nombre
int nameSize = static_cast<int>(entry.name.size());
SDL_RWwrite(file, &nameSize, sizeof(int), 1);
SDL_RWwrite(file, entry.name.c_str(), nameSize, 1);
int name_size = static_cast<int>(entry.name.size());
SDL_WriteIO(file, &name_size, sizeof(int));
SDL_WriteIO(file, entry.name.c_str(), name_size);
// Guarda el valor de one_credit_complete como un entero (0 o 1)
int occValue = entry.one_credit_complete ? 1 : 0;
SDL_RWwrite(file, &occValue, sizeof(int), 1);
int occ_value = entry.one_credit_complete ? 1 : 0;
SDL_WriteIO(file, &occ_value, sizeof(int));
}
std::cout << "Writing file: " << getFileName(file_path) << std::endl;
SDL_RWclose(file);
SDL_CloseIO(file);
}
else
{

1
source/manage_hiscore_table.h
View File

@@ -1,5 +1,6 @@
#pragma once
#include <SDL3/SDL.h>
#include <string> // Para string
#include <vector> // Para vector

8
source/mouse.cpp
View File

@@ -10,14 +10,12 @@ namespace Mouse
void handleEvent(const SDL_Event &event)
{
if (event.type == SDL_MOUSEMOTION)
if (event.type == SDL_EVENT_MOUSE_MOTION)
{
last_mouse_move_time = SDL_GetTicks();
if (!cursor_visible)
{
#ifndef ARCADE
SDL_ShowCursor(SDL_ENABLE);
#endif
SDL_ShowCursor();
cursor_visible = true;
}
}
@@ -28,7 +26,7 @@ namespace Mouse
Uint32 current_time = SDL_GetTicks();
if (cursor_visible && (current_time - last_mouse_move_time > cursor_hide_time))
{
SDL_ShowCursor(SDL_DISABLE);
SDL_HideCursor();
cursor_visible = false;
}
}

1
source/mouse.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_events.h> // Para SDL_Event
#include <SDL3/SDL_stdinc.h> // Para Uint32

2
source/moving_sprite.cpp
View File

@@ -2,7 +2,7 @@
#include "texture.h" // Para Texture
// Constructor
MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, Rotate rotate, float zoom_w, float zoom_h, SDL_RendererFlip flip)
MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, Rotate rotate, float zoom_w, float zoom_h, SDL_FlipMode flip)
: Sprite(texture, pos),
x_(pos.x),
y_(pos.y),

39
source/moving_sprite.h
View File

@@ -1,7 +1,8 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_Point
#include <SDL3/SDL_render.h> // Para SDL_RendererFlip
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_FPoint
#include <SDL3/SDL_render.h> // Para SDL_FlipMode
#include <memory> // Para shared_ptr
#include <algorithm>
#include "sprite.h" // Para Sprite
@@ -13,19 +14,19 @@ class MovingSprite : public Sprite
public:
struct Rotate
{
bool enabled; // Indica si ha de rotar
int counter; // Contador
int speed; // Velocidad de giro
double angle; // Angulo para dibujarlo
float amount; // Cantidad de grados a girar en cada iteración
SDL_Point center; // Centro de rotación
bool enabled; // Indica si ha de rotar
int counter; // Contador
int speed; // Velocidad de giro
double angle; // Angulo para dibujarlo
float amount; // Cantidad de grados a girar en cada iteración
SDL_FPoint center; // Centro de rotación
Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center({0, 0}) {}
Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center({0.0f, 0.0f}) {}
};
protected:
float x_; // Posición en el eje X
float y_; // Posición en el eje Y
float x_ = 0.0f; // Posición en el eje X
float y_ = 0.0f; // Posición en el eje Y
float vx_ = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
float vy_ = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
@@ -33,10 +34,10 @@ protected:
float ax_ = 0.0f; // Aceleración en el eje X. Variación de la velocidad
float ay_ = 0.0f; // Aceleración en el eje Y. Variación de la velocidad
Rotate rotate_; // Variables usada para controlar la rotación del sprite
float zoom_w_; // Zoom aplicado a la anchura
float zoom_h_; // Zoom aplicado a la altura
SDL_RendererFlip flip_; // Indica como se voltea el sprite
Rotate rotate_; // Variables usada para controlar la rotación del sprite
float zoom_w_; // Zoom aplicado a la anchura
float zoom_h_; // Zoom aplicado a la altura
SDL_FlipMode flip_; // Indica como se voltea el sprite
// Incrementa el valor del ángulo
void updateAngle() { rotate_.angle += rotate_.amount; }
@@ -49,7 +50,7 @@ protected:
public:
// Constructor
MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, MovingSprite::Rotate rotate, float zoom_w, float zoom_h, SDL_RendererFlip flip);
MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, MovingSprite::Rotate rotate, float zoom_w, float zoom_h, SDL_FlipMode flip);
MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos);
explicit MovingSprite(std::shared_ptr<Texture> texture);
@@ -88,7 +89,7 @@ public:
// Establece el valor de la variable
void setAngle(double value) { rotate_.angle = value; }
void setRotatingCenter(SDL_Point point) { rotate_.center = point; }
void setRotatingCenter(SDL_FPoint point) { rotate_.center = point; }
// Activa o desactiva el efecto de rotación
void setRotate(bool enable);
@@ -101,13 +102,13 @@ public:
void switchRotate() { rotate_.amount *= -1; }
// Establece el valor de la variable
void setFlip(SDL_RendererFlip flip) { flip_ = flip; }
void setFlip(SDL_FlipMode flip) { flip_ = flip; }
// Gira el sprite horizontalmente
void flip() { flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL; }
// Obtiene el valor de la variable
SDL_RendererFlip getFlip() { return flip_; }
SDL_FlipMode getFlip() { return flip_; }
// Establece la posición y_ el tamaño del objeto
void setPos(SDL_FRect rect);

96
source/notifier.cpp
View File

@@ -181,60 +181,60 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
}
// Inicializa variables
constexpr int icon_size = 16;
constexpr int padding_out = 1;
const auto padding_in_h = text_->getCharacterSize();
const auto padding_in_v = text_->getCharacterSize() / 2;
const int icon_space = icon >= 0 ? icon_size + padding_in_h : 0;
const int width = text_->lenght(longest) + (padding_in_h * 2) + icon_space;
const int height = (text_->getCharacterSize() * texts.size()) + (padding_in_v * 2);
const auto shape = NotificationShape::SQUARED;
constexpr int ICON_SIZE = 16;
constexpr int PADDING_OUT = 1;
const float PADDING_IN_H = text_->getCharacterSize();
const float PADDING_IN_V = text_->getCharacterSize() / 2;
const int ICON_SPACE = icon >= 0 ? ICON_SIZE + PADDING_IN_H : 0;
const float WIDTH = text_->lenght(longest) + (PADDING_IN_H * 2) + ICON_SPACE;
const float HEIGHT = (text_->getCharacterSize() * texts.size()) + (PADDING_IN_V * 2);
const auto SHAPE = NotificationShape::SQUARED;
// Posición horizontal
auto desp_h = 0;
if (param.notification.pos_h == NotifyPosition::LEFT)
float desp_h = 0;
switch (param.notification.pos_h)
{
desp_h = padding_out;
}
else if (param.notification.pos_h == NotifyPosition::MIDDLE)
{
desp_h = ((param.game.width / 2) - (width / 2));
}
else
{
desp_h = param.game.width - width - padding_out;
case NotifyPosition::LEFT:
desp_h = PADDING_OUT;
break;
case NotifyPosition::MIDDLE:
desp_h = ((param.game.width / 2) - (WIDTH / 2));
break;
case NotifyPosition::RIGHT:
desp_h = param.game.width - WIDTH - PADDING_OUT;
break;
default:
desp_h = 0;
break;
}
// Posición vertical
const int desp_v = (param.notification.pos_v == NotifyPosition::TOP) ? padding_out : (param.game.height - height - padding_out);
const int DESP_V = (param.notification.pos_v == NotifyPosition::TOP) ? PADDING_OUT : (param.game.height - HEIGHT - PADDING_OUT);
// Offset
const auto travel_dist = height + padding_out;
auto offset = 0;
if (param.notification.pos_v == NotifyPosition::TOP)
{
offset = !notifications_.empty() ? notifications_.back().y + travel_dist : desp_v;
}
else
{
offset = !notifications_.empty() ? notifications_.back().y - travel_dist : desp_v;
}
const auto TRAVEL_DIST = HEIGHT + PADDING_OUT;
auto OFFSET = notifications_.empty()
? DESP_V
: notifications_.back().y + (param.notification.pos_v == NotifyPosition::TOP ? TRAVEL_DIST : -TRAVEL_DIST);
// Crea la notificacion
Notification n;
// Inicializa variables
n.code = code;
n.y = offset;
n.travel_dist = travel_dist;
n.y = OFFSET;
n.travel_dist = TRAVEL_DIST;
n.texts = texts;
n.shape = shape;
auto y_pos = offset + (param.notification.pos_v == NotifyPosition::TOP ? -travel_dist : travel_dist);
n.rect = {desp_h, y_pos, width, height};
n.shape = SHAPE;
const float POS_Y = OFFSET + (param.notification.pos_v == NotifyPosition::TOP ? -TRAVEL_DIST : TRAVEL_DIST);
n.rect = {desp_h, POS_Y, WIDTH, HEIGHT};
// Crea la textura
n.texture = std::make_shared<Texture>(renderer_);
n.texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
n.texture->createBlank(WIDTH, HEIGHT, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
n.texture->setBlendMode(SDL_BLENDMODE_BLEND);
// Prepara para dibujar en la textura
@@ -243,22 +243,22 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
// Dibuja el fondo de la notificación
SDL_SetRenderDrawColor(renderer_, bg_color_.r, bg_color_.g, bg_color_.b, 255);
SDL_FRect rect;
if (shape == NotificationShape::ROUNDED)
if (SHAPE == NotificationShape::ROUNDED)
{
rect = {4, 0, width - (4 * 2), height};
rect = {4, 0, WIDTH - (4 * 2), HEIGHT};
SDL_RenderFillRect(renderer_, &rect);
rect = {4 / 2, 1, width - 4, height - 2};
rect = {4 / 2, 1, WIDTH - 4, HEIGHT - 2};
SDL_RenderFillRect(renderer_, &rect);
rect = {1, 4 / 2, width - 2, height - 4};
rect = {1, 4 / 2, WIDTH - 2, HEIGHT - 4};
SDL_RenderFillRect(renderer_, &rect);
rect = {0, 4, width, height - (4 * 2)};
rect = {0, 4, WIDTH, HEIGHT - (4 * 2)};
SDL_RenderFillRect(renderer_, &rect);
}
else if (shape == NotificationShape::SQUARED)
else if (SHAPE == NotificationShape::SQUARED)
{
SDL_RenderClear(renderer_);
}
@@ -266,9 +266,13 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
// Dibuja el icono de la notificación
if (has_icons_ && icon >= 0 && texts.size() >= 2)
{
auto sp = std::make_unique<Sprite>(icon_texture_, (SDL_FRect){0, 0, icon_size, icon_size});
sp->setPosition({padding_in_h, padding_in_v, icon_size, icon_size});
sp->setSpriteClip({icon_size * (icon % 10), icon_size * (icon / 10), icon_size, icon_size});
auto sp = std::make_unique<Sprite>(icon_texture_, (SDL_FRect){0, 0, ICON_SIZE, ICON_SIZE});
sp->setPosition({PADDING_IN_H, PADDING_IN_V, ICON_SIZE, ICON_SIZE});
sp->setSpriteClip(SDL_FRect{
static_cast<float>(ICON_SIZE * (icon % 10)),
static_cast<float>(ICON_SIZE * (icon / 10)),
ICON_SIZE,
ICON_SIZE});
sp->render();
}
@@ -277,7 +281,7 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
int iterator = 0;
for (const auto &text : texts)
{
text_->writeColored(padding_in_h + icon_space, padding_in_v + iterator * (text_->getCharacterSize() + 1), text, color);
text_->writeColored(PADDING_IN_H + ICON_SPACE, PADDING_IN_V + iterator * (text_->getCharacterSize() + 1), text, color);
++iterator;
}

1
source/notifier.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Renderer

4
source/on_screen_help.cpp
View File

@@ -15,8 +15,8 @@ OnScreenHelp *OnScreenHelp::onScreenHelp = nullptr;
// Constantes evaluables en tiempo de compilación
constexpr int ICONSIZE = 16;
constexpr SDL_Point PADDING = {8, 8};
constexpr SDL_Point DESP = {ICONSIZE + 4, 5};
constexpr SDL_FPoint PADDING = {8, 8};
constexpr SDL_FPoint DESP = {ICONSIZE + 4, 5};
constexpr SDL_FRect CONTROLLER_UP = {16, 0, ICONSIZE, ICONSIZE};
constexpr SDL_FRect CONTROLLER_DOWN = {48, 0, ICONSIZE, ICONSIZE};

1
source/on_screen_help.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Texture

56
source/options.cpp
View File

@@ -1,14 +1,14 @@
#include "options.h"
#include <SDL3/SDL_gamecontroller.h> // Para SDL_GameControllerButton
#include <algorithm> // Para clamp
#include <fstream> // Para basic_ostream, operator<<, basi...
#include <iostream> // Para cout
#include <utility> // Para swap
#include <vector> // Para vector
#include "input.h" // Para InputDeviceToUse
#include "lang.h" // Para Code
#include "screen.h" // Para ScreenVideoMode, ScreenFilter
#include "utils.h" // Para boolToString, stringToBool, get...
#include <SDL3/SDL.h> // Para SDL_GamepadButton
#include <algorithm> // Para clamp
#include <fstream> // Para basic_ostream, operator<<, basi...
#include <iostream> // Para cout
#include <utility> // Para swap
#include <vector> // Para vector
#include "input.h" // Para InputDeviceToUse
#include "lang.h" // Para Code
#include "screen.h" // Para ScreenFilter
#include "utils.h" // Para boolToString, stringToBool, get...
// Variables
Options options;
@@ -21,10 +21,10 @@ void initOptions()
{
// Opciones de video
#ifdef ANBERNIC
options.video.mode = ScreenVideoMode::WINDOW;
options.video.mode = false;
options.video.window.size = 3;
#else
options.video.mode = ScreenVideoMode::WINDOW;
options.video.fullscreen = false;
options.video.window.zoom = 2;
#endif
options.video.filter = ScreenFilter::NEAREST;
@@ -98,13 +98,6 @@ bool loadOptionsFile(std::string file_path)
}
// Normaliza los valores
const bool a = options.video.mode == ScreenVideoMode::WINDOW;
const bool b = options.video.mode == ScreenVideoMode::FULLSCREEN;
if (!(a || b))
{
options.video.mode = ScreenVideoMode::WINDOW;
}
options.video.window.zoom = std::clamp(options.video.window.zoom, 1, 4);
if (options.game.language != lang::Code::en_UK &&
@@ -132,11 +125,10 @@ bool saveOptionsFile(std::string file_path)
// Opciones de video
file << "## VIDEO\n";
file << "## video.mode [" << static_cast<int>(ScreenVideoMode::WINDOW) << ": window, " << static_cast<int>(ScreenVideoMode::FULLSCREEN) << ": fullscreen]\n";
file << "## video.filter [" << static_cast<int>(ScreenFilter::NEAREST) << ": nearest, " << static_cast<int>(ScreenFilter::LINEAL) << ": lineal]\n";
file << "\n";
file << "video.mode=" << static_cast<int>(options.video.mode) << "\n";
file << "video.fullscreen=" << boolToString(options.video.fullscreen) << "\n";
file << "video.window.size=" << options.video.window.zoom << "\n";
file << "video.filter=" << static_cast<int>(options.video.filter) << "\n";
file << "video.v_sync=" << boolToString(options.video.v_sync) << "\n";
@@ -200,7 +192,7 @@ bool setOptions(const std::string &var, const std::string &value)
// Opciones de video
if (var == "video.mode")
{
options.video.mode = static_cast<ScreenVideoMode>(std::stoi(value));
options.video.fullscreen = stringToBool(value);
}
else if (var == "video.window.size")
{
@@ -282,23 +274,23 @@ bool setOptions(const std::string &var, const std::string &value)
}
else if (var == "controller.0.button.fire_left")
{
options.controllers.at(0).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(0).buttons.at(0) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.0.button.fire_center")
{
options.controllers.at(0).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(0).buttons.at(1) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.0.button.fire_right")
{
options.controllers.at(0).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(0).buttons.at(2) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.0.button.start")
{
options.controllers.at(0).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(0).buttons.at(3) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.0.button.service")
{
options.controllers.at(0).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(0).buttons.at(4) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.1.name")
{
@@ -314,23 +306,23 @@ bool setOptions(const std::string &var, const std::string &value)
}
else if (var == "controller.1.button.fire_left")
{
options.controllers.at(1).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(1).buttons.at(0) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.1.button.fire_center")
{
options.controllers.at(1).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(1).buttons.at(1) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.1.button.fire_right")
{
options.controllers.at(1).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(1).buttons.at(2) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.1.button.start")
{
options.controllers.at(1).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(1).buttons.at(3) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
else if (var == "controller.1.button.service")
{
options.controllers.at(1).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
options.controllers.at(1).buttons.at(4) = static_cast<SDL_GamepadButton>(std::stoi(value));
}
// Lineas vacias o que empiezan por comentario

52
source/options.h
View File

@@ -1,13 +1,12 @@
#pragma once
#include <SDL3/SDL.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
#include <SDL3/SDL.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
#include <SDL3/SDL_stdinc.h> // Para Uint32
#include <string> // Para string
#include <vector> // Para vector
#include "input.h" // Para InputAction, InputDeviceToUse
#include "manage_hiscore_table.h" // Para HiScoreEntry
enum class ScreenFilter : int; // lines 8-8
enum class ScreenVideoMode : Uint32; // lines 9-9
namespace lang
{
enum class Code : int;
@@ -22,48 +21,48 @@ enum class GameDifficulty
};
// Estructura para las opciones de la ventana
struct OptionsWindow
struct WindowOptions
{
int zoom = 1; // Contiene el valor por el que se multiplica el tamaño de la ventana
int max_zoom = 1; // Tamaño máximo para que el tamaño de la ventana no sea mayor que el tamaño de la pantalla
};
// Estructura con opciones para el video
struct OptionsVideo
struct VideoOptions
{
OptionsWindow window; // Opciones para la ventana del programa
ScreenVideoMode mode; // Contiene el valor del modo de pantalla completa
WindowOptions window; // Opciones para la ventana del programa
ScreenFilter filter; // Filtro usado para el escalado de la imagen
bool fullscreen; // Contiene el valor del modo de pantalla completa
bool v_sync; // Indica si se quiere usar vsync o no
bool integer_scale; // Indica si se va a usar el escalado entero
bool shaders; // Indica si se van a usar shaders para los filtros de video
};
// Estructura para las opciones de musica
struct OptionsMusic
struct MusicOptions
{
bool enabled; // Indica si la musica suena o no
int volume; // Volumen al que suena la música
};
// Estructura para las opciones de sonido
struct OptionsSound
struct SoundOptions
{
bool enabled; // Indica si los sonidos suenan o no
int volume; // Volumen al que suenan los sonidos
};
// Estructura para las opciones de audio
struct OptionsAudio
struct AudioOptions
{
OptionsMusic music; // Opciones para la música
OptionsSound sound; // Opciones para los efectos de sonido
MusicOptions music; // Opciones para la música
SoundOptions sound; // Opciones para los efectos de sonido
bool enabled; // Indica si el audio está activo o no
int volume; // Volumen al que suenan el audio
};
// Estructura para las opciones del juego
struct OptionsGame
struct GameOptions
{
GameDifficulty difficulty; // Dificultad del juego
lang::Code language; // Idioma usado en el juego
@@ -80,35 +79,36 @@ struct OptionsGame
};
// Estructura para los controles del juego
struct OptionsController
struct GamepadOptions
{
int index; // Indice en el vector de mandos
int player_id; // Jugador asociado al mando
InputDeviceToUse type; // Indica si se utilizará teclado o mando o ambos
std::string name; // Nombre del dispositivo
bool plugged; // Indica si el mando se encuentra conectado
std::vector<InputAction> inputs; // Listado de inputs
std::vector<SDL_GameControllerButton> buttons; // Listado de botones asignados a cada input
int index; // Indice en el vector de mandos
int player_id; // Jugador asociado al mando
InputDeviceToUse type; // Indica si se utilizará teclado o mando o ambos
std::string name; // Nombre del dispositivo
bool plugged; // Indica si el mando se encuentra conectado
std::vector<InputAction> inputs; // Listado de inputs
std::vector<SDL_GamepadButton> buttons; // Listado de botones asignados a cada input
// Constructor por defecto
OptionsController()
GamepadOptions()
: index(-1), player_id(-1), type(InputDeviceToUse::CONTROLLER), name(""), plugged(false),
inputs{InputAction::FIRE_LEFT, InputAction::FIRE_CENTER, InputAction::FIRE_RIGHT, InputAction::START, InputAction::SERVICE},
buttons{SDL_CONTROLLER_BUTTON_X, SDL_CONTROLLER_BUTTON_Y, SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_START, SDL_CONTROLLER_BUTTON_BACK} {}
buttons{SDL_GAMEPAD_BUTTON_WEST, SDL_GAMEPAD_BUTTON_NORTH, SDL_GAMEPAD_BUTTON_EAST, SDL_GAMEPAD_BUTTON_START, SDL_GAMEPAD_BUTTON_BACK} {}
};
// Estructura con todas las opciones de configuración del programa
struct Options
{
OptionsGame game; // Opciones para el propio juego
OptionsVideo video; // Opciones relativas a la clase screen
OptionsAudio audio; // Opciones para el audio
std::vector<OptionsController> controllers; // Opciones con las asignaciones del mando para cada jugador
GameOptions game; // Opciones para el propio juego
VideoOptions video; // Opciones relativas a la clase screen
AudioOptions audio; // Opciones para el audio
std::vector<GamepadOptions> controllers; // Opciones con las asignaciones del mando para cada jugador
};
// Variables
extern Options options;
// Inicializa las opciones del programa
void initOptions();
// Carga el fichero de configuración

2
source/param.cpp
View File

@@ -360,7 +360,7 @@ void precalculateZones()
param.game.play_area.third_quarter_y = param.game.play_area.rect.h / 4 * 3;
// gameArea
param.game.game_area.rect = {0, 0, param.game.width, param.game.height};
param.game.game_area.rect = {0, 0, static_cast<float>(param.game.width), static_cast<float>(param.game.height)};
param.game.game_area.center_x = param.game.game_area.rect.w / 2;
param.game.game_area.first_quarter_x = param.game.game_area.rect.w / 4;
param.game.game_area.third_quarter_x = param.game.game_area.rect.w / 4 * 3;

17
source/param.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_stdinc.h> // Para Uint32
@@ -9,11 +10,11 @@
// param.game
struct ParamGame
{
int width; // Ancho de la resolucion nativa del juego
int height; // Alto de la resolucion nativa del juego
int item_size; // Tamaño de los items del juego
int coffee_machine_w; // Ancho de la máquina de café
int coffee_machine_h; // Alto de la máquina de café
float width; // Ancho de la resolucion nativa del juego
float height; // Alto de la resolucion nativa del juego
float item_size; // Tamaño de los items del juego
float coffee_machine_w; // Ancho de la máquina de café
float coffee_machine_h; // Alto de la máquina de café
Zone play_area; // Rectangulo con la posición de la zona de juego
Zone game_area; // Rectangulo con las dimensiones del juego
int enter_name_seconds; // Duración en segundos para introducir el nombre al finalizar la partida
@@ -23,12 +24,12 @@ struct ParamGame
// param.fade
struct ParamFade
{
int num_squares_width; // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
int num_squares_height; // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
float num_squares_width; // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
float num_squares_height; // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
int random_squares_delay; // Duración entre cada pintado de cuadrados
int random_squares_mult; // Cantidad de cuadrados que se pintaran cada vez
int post_duration; // Duración final del fade
int venetian_size; // Altura de los rectangulos para FadeType::VENETIAN
float venetian_size; // Altura de los rectangulos para FadeType::VENETIAN
};
// param.title

10
source/path_sprite.cpp
View File

@@ -5,9 +5,9 @@
#include <utility> // Para move
// Devuelve un vector con los puntos que conforman la ruta
std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction)
std::vector<SDL_FPoint> createPath(float start, float end, PathType type, float fixed_pos, int steps, const std::function<double(double)> &easingFunction)
{
std::vector<SDL_Point> v;
std::vector<SDL_FPoint> v;
v.reserve(steps);
for (int i = 0; i < steps; ++i)
@@ -23,10 +23,10 @@ std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_p
switch (type)
{
case PathType::HORIZONTAL:
v.emplace_back(SDL_Point{static_cast<int>(value), fixed_pos});
v.emplace_back(SDL_FPoint{static_cast<float>(value), fixed_pos});
break;
case PathType::VERTICAL:
v.emplace_back(SDL_Point{fixed_pos, static_cast<int>(value)});
v.emplace_back(SDL_FPoint{fixed_pos, static_cast<float>(value)});
break;
default:
break;
@@ -93,7 +93,7 @@ void PathSprite::addPath(int start, int end, PathType type, int fixed_pos, int s
}
// Añade un recorrido
void PathSprite::addPath(std::vector<SDL_Point> spots, int waiting_counter)
void PathSprite::addPath(std::vector<SDL_FPoint> spots, int waiting_counter)
{
paths_.emplace_back(std::move(spots), waiting_counter);
}

19
source/path_sprite.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_Point
#include <SDL3/SDL_rect.h> // Para SDL_FPoint
#include <functional> // Para function
#include <memory> // Para shared_ptr
#include <vector> // Para vector
@@ -23,19 +24,19 @@ enum class PathCentered
// Estructuras
struct Path
{
std::vector<SDL_Point> spots; // Puntos por los que se desplazará el sprite
int waiting_counter; // Tiempo de espera una vez en el destino
bool on_destination = false; // Indica si ha llegado al destino
bool finished = false; // Indica si ha terminado de esperarse
int counter = 0; // Contador interno
std::vector<SDL_FPoint> spots; // Puntos por los que se desplazará el sprite
int waiting_counter; // Tiempo de espera una vez en el destino
bool on_destination = false; // Indica si ha llegado al destino
bool finished = false; // Indica si ha terminado de esperarse
int counter = 0; // Contador interno
// Constructor
Path(const std::vector<SDL_Point> &spots_init, int waiting_counter_init)
Path(const std::vector<SDL_FPoint> &spots_init, int waiting_counter_init)
: spots(spots_init), waiting_counter(waiting_counter_init) {}
};
// Devuelve un vector con los puntos que conforman la ruta
std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction);
std::vector<SDL_FPoint> createPath(float start, float end, PathType type, float fixed_pos, int steps, const std::function<double(double)> &easingFunction);
// Clase PathSprite
class PathSprite : public Sprite
@@ -69,7 +70,7 @@ public:
// Añade un recorrido
void addPath(Path path, bool centered = false);
void addPath(std::vector<SDL_Point> spots, int waiting_counter = 0);
void addPath(std::vector<SDL_FPoint> spots, int waiting_counter = 0);
void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter = 0);
// Habilita el objeto

24
source/player.cpp
View File

@@ -350,34 +350,34 @@ void Player::setAnimation()
case PlayerState::CREDITS:
{
// Crea cadenas de texto para componer el nombre de la animación
const std::string a_walking = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
const std::string a_firing = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
const std::string a_cooling = firing_state_ == PlayerState::COOLING_UP ? "centershoot" : "sideshoot";
const std::string WALKING_ANIMATION = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
const std::string FIRING_ANIMATION = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
const std::string COOLING_ANIMATION = firing_state_ == PlayerState::COOLING_UP ? "centershoot" : "sideshoot";
const SDL_RendererFlip flip_walk = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_RendererFlip flip_fire = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_RendererFlip flip_cooling = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_WALK = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_FIRE = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode FLIP_COOLING = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
// Establece la animación a partir de las cadenas
if (firing_state_ == PlayerState::FIRING_NONE)
{
// No esta disparando
player_sprite_->setCurrentAnimation(a_walking);
player_sprite_->setFlip(flip_walk);
player_sprite_->setCurrentAnimation(WALKING_ANIMATION);
player_sprite_->setFlip(FLIP_WALK);
}
else if (isCooling())
{
// Acaba de disparar
player_sprite_->setCurrentAnimation(a_walking + "-" + a_cooling + "-cooldown");
player_sprite_->setFlip(flip_cooling);
player_sprite_->setCurrentAnimation(WALKING_ANIMATION + "-" + COOLING_ANIMATION + "-cooldown");
player_sprite_->setFlip(FLIP_COOLING);
}
else
{
// Está disparando
player_sprite_->setCurrentAnimation(a_walking + "-" + a_firing);
player_sprite_->setCurrentAnimation(WALKING_ANIMATION + "-" + FIRING_ANIMATION);
// Si dispara de lado, invierte el sprite segun hacia donde dispara
// Si dispara recto, invierte el sprite segun hacia donde camina
player_sprite_->setFlip(a_firing == "centershoot" ? flip_walk : flip_fire);
player_sprite_->setFlip(FIRING_ANIMATION == "centershoot" ? FLIP_WALK : FLIP_FIRE);
}
break;
}

1
source/player.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_stdinc.h> // Para Uint32

1
source/resource.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <memory> // Para shared_ptr
#include <string> // Para string

38
source/scoreboard.cpp
View File

@@ -57,7 +57,11 @@ Scoreboard::Scoreboard()
// Recalcula las anclas de los elementos
recalculateAnchors();
power_meter_sprite_->setPosition({slot4_2_.x - 20, slot4_2_.y, 40, 7});
power_meter_sprite_->setPosition(SDL_FRect{
static_cast<float>(slot4_2_.x - 20),
static_cast<float>(slot4_2_.y),
40,
7});
// Crea la textura de fondo
background_ = nullptr;
@@ -259,7 +263,7 @@ void Scoreboard::fillPanelTextures()
// ENTER NAME
{
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
SDL_FRect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
SDL_FRect rect = {enter_name_pos_.x, enter_name_pos_.y, 5.0f, 7.0f};
// Recorre todos los slots de letras del nombre
for (size_t j = 0; j < MAX_NAME_LENGHT; ++j)
@@ -273,7 +277,7 @@ void Scoreboard::fillPanelTextures()
if (j >= selector_pos_[i])
{
SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 255);
SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
SDL_RenderLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
}
// Dibuja la letra
@@ -364,28 +368,28 @@ void Scoreboard::recalculateAnchors()
}
// Constantes para definir las zonas del panel_: 4 filas y 1 columna
const int row_size = rect_.h / 4;
const int text_height = 7;
const int ROW_SIZE = rect_.h / 4;
const int TEXT_HEIGHT = 7;
// Filas
const int row1 = (row_size * 0) + (text_height / 2);
const int row2 = (row_size * 1) + (text_height / 2) - 1;
const int row3 = (row_size * 2) + (text_height / 2) - 2;
const int row4 = (row_size * 3) + (text_height / 2) - 3;
const float ROW1 = (ROW_SIZE * 0) + (TEXT_HEIGHT / 2);
const float ROW2 = (ROW_SIZE * 1) + (TEXT_HEIGHT / 2) - 1;
const float ROW3 = (ROW_SIZE * 2) + (TEXT_HEIGHT / 2) - 2;
const float ROW4 = (ROW_SIZE * 3) + (TEXT_HEIGHT / 2) - 3;
// Columna
const int col = panel_width / 2;
const float COL = panel_width / 2;
// Slots de 4
slot4_1_ = {col, row1};
slot4_2_ = {col, row2};
slot4_3_ = {col, row3};
slot4_4_ = {col, row4};
slot4_1_ = {COL, ROW1};
slot4_2_ = {COL, ROW2};
slot4_3_ = {COL, ROW3};
slot4_4_ = {COL, ROW4};
// Primer cuadrado para poner el nombre de record
const int enter_name_lenght = text_scoreboard_->lenght(std::string(MAX_NAME_LENGHT, 'A'));
enter_name_pos_.x = col - (enter_name_lenght / 2);
enter_name_pos_.y = row4;
enter_name_pos_.x = COL - (enter_name_lenght / 2);
enter_name_pos_.y = ROW4;
// Recoloca los sprites
if (power_meter_sprite_)
@@ -436,7 +440,7 @@ void Scoreboard::renderSeparator()
{
// Dibuja la linea que separa el marcador de la zona de juego
SDL_SetRenderDrawColor(renderer_, separator_color.r, separator_color.g, separator_color.b, 255);
SDL_RenderDrawLine(renderer_, 0, 0, rect_.w, 0);
SDL_RenderLine(renderer_, 0, 0, rect_.w, 0);
}
// Inicializa el vector de colores para el nombre

9
source/scoreboard.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_Point, SDL_FRect
#include <SDL3/SDL_rect.h> // Para SDL_FPoint, SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Texture, SDL_Renderer
#include <SDL3/SDL_stdinc.h> // Para Uint32
#include <SDL3/SDL_timer.h> // Para SDL_GetTicks
@@ -72,14 +73,14 @@ private:
std::string hi_score_name_ = std::string(); // Nombre del jugador con la máxima puntuación
Color color_ = Color(); // Color del marcador
SDL_FRect rect_ = {0, 0, 320, 40}; // Posición y dimensiones del marcador
Uint32 ticks_ = SDL_GetTicks(); // Variable donde almacenar el valor de SDL_GetTiks()
Uint64 ticks_ = SDL_GetTicks(); // Variable donde almacenar el valor de SDL_GetTiks()
int time_counter_ = 0; // Contador de segundos
int loop_counter_ = 0; // Contador de bucle
std::vector<Color> name_colors_; // Colores para destacar el nombre una vez introducido
// Puntos predefinidos para colocar elementos en los paneles
SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;
SDL_Point enter_name_pos_;
SDL_FPoint slot4_1_, slot4_2_, slot4_3_, slot4_4_;
SDL_FPoint enter_name_pos_;
// Recalcula las anclas de los elementos
void recalculateAnchors();

25
source/screen.cpp
View File

@@ -6,7 +6,6 @@
#include <iterator> // Para istreambuf_iterator, operator==
#include <string> // Para allocator, char_traits, operator+, to_s...
#include "asset.h" // Para Asset
#include "dbgtxt.h" // Para dbg_print
#include "global_inputs.h" // Para service_pressed_counter
#include "jail_shader.h" // Para init, render
#include "mouse.h" // Para updateCursorVisibility
@@ -90,26 +89,22 @@ void Screen::renderScreen()
}
// Establece el modo de video
void Screen::setVideoMode(ScreenVideoMode mode)
void Screen::setFullscreenMode(bool mode)
{
// Actualiza las opciones
options.video.mode = mode;
options.video.fullscreen = mode;
// Configura el modo de pantalla
Uint32 flags = SDL_GetWindowFlags(window_);
if (flags != static_cast<Uint32>(options.video.mode))
{
SDL_SetWindowFullscreen(window_, static_cast<bool>(options.video.mode));
}
SDL_SetWindowFullscreen(window_, options.video.fullscreen);
initShaders();
}
// Camibia entre pantalla completa y ventana
void Screen::toggleVideoMode()
void Screen::toggleFullscreen()
{
options.video.mode = options.video.mode == ScreenVideoMode::WINDOW ? ScreenVideoMode::FULLSCREEN : ScreenVideoMode::WINDOW;
setVideoMode();
options.video.fullscreen = !options.video.fullscreen;
setFullscreenMode();
}
// Cambia el tamaño de la ventana
@@ -122,7 +117,7 @@ void Screen::setWindowZoom(int zoom)
// Reduce el tamaño de la ventana
bool Screen::decWindowZoom()
{
if (options.video.mode == ScreenVideoMode::WINDOW)
if (!options.video.fullscreen)
{
const int PREVIOUS_ZOOM = options.video.window.zoom;
--options.video.window.zoom;
@@ -141,7 +136,7 @@ bool Screen::decWindowZoom()
// Aumenta el tamaño de la ventana
bool Screen::incWindowZoom()
{
if (options.video.mode == ScreenVideoMode::WINDOW)
if (!options.video.fullscreen)
{
const int PREVIOUS_ZOOM = options.video.window.zoom;
++options.video.window.zoom;
@@ -245,7 +240,7 @@ void Screen::adjustWindowSize()
options.video.window.max_zoom = getMaxZoom();
// Establece el nuevo tamaño
if (options.video.mode == ScreenVideoMode::WINDOW)
if (!options.video.fullscreen)
{
const int WIDTH = param.game.width * options.video.window.zoom;
const int HEIGHT = param.game.height * options.video.window.zoom;
@@ -259,7 +254,7 @@ void Screen::adjustWindowSize()
const int NEW_POS_X = old_pos_x + (old_width - WIDTH) / 2;
const int NEW_POS_Y = old_pos_y + (old_height - HEIGHT) / 2;
SDL_FRect viewport = {0, 0, WIDTH, HEIGHT};
SDL_Rect viewport = {0, 0, WIDTH, HEIGHT};
SDL_SetRenderViewport(renderer_, &viewport);
SDL_SetWindowPosition(window_, std::max(NEW_POS_X, WINDOWS_DECORATIONS_), std::max(NEW_POS_Y, 0));

13
source/screen.h
View File

@@ -1,7 +1,8 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_blendmode.h> // Para SDL_BlendMode
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_Point
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_FPoint
#include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture
#include <SDL3/SDL_stdinc.h> // Para Uint32
#include <SDL3/SDL_video.h> // Para SDL_Window
@@ -16,12 +17,6 @@ enum class ScreenFilter : int
LINEAL = 1,
};
enum class ScreenVideoMode : bool
{
WINDOW = false,
FULLSCREEN = true,
};
class Screen
{
private:
@@ -239,10 +234,10 @@ public:
void render();
// Establece el modo de video
void setVideoMode(ScreenVideoMode mode = options.video.mode);
void setFullscreenMode(bool mode = options.video.fullscreen);
// Cambia entre pantalla completa y ventana
void toggleVideoMode();
void toggleFullscreen();
// Cambia el tamaño de la ventana
void setWindowZoom(int size);

1
source/section.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
namespace section
{

1
source/smart_sprite.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <memory> // Para shared_ptr
#include "animated_sprite.h" // Para SpriteAnimated

8
source/sprite.cpp
View File

@@ -2,7 +2,7 @@
#include "texture.h" // Para Texture
// Constructor
Sprite::Sprite(std::shared_ptr<Texture> texture, int x, int y, int w, int h)
Sprite::Sprite(std::shared_ptr<Texture> texture, float x, float y, float w, float h)
: texture_(texture),
pos_((SDL_FRect){x, y, w, h}),
sprite_clip_((SDL_FRect){0, 0, pos_.w, pos_.h}) {}
@@ -14,7 +14,7 @@ Sprite::Sprite(std::shared_ptr<Texture> texture, SDL_FRect rect)
Sprite::Sprite(std::shared_ptr<Texture> texture)
: texture_(texture),
pos_({0, 0, texture_->getWidth(), texture_->getHeight()}),
pos_(SDL_FRect{0, 0, static_cast<float>(texture_->getWidth()), static_cast<float>(texture_->getHeight())}),
sprite_clip_(pos_) {}
// Muestra el sprite por pantalla
@@ -24,14 +24,14 @@ void Sprite::render()
}
// Establece la posición del objeto
void Sprite::setPosition(int x, int y)
void Sprite::setPosition(float x, float y)
{
pos_.x = x;
pos_.y = y;
}
// Establece la posición del objeto
void Sprite::setPosition(SDL_Point p)
void Sprite::setPosition(SDL_FPoint p)
{
pos_.x = p.x;
pos_.y = p.y;

31
source/sprite.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_Point
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_FPoint
#include <memory> // Para shared_ptr
class Texture;
@@ -16,7 +17,7 @@ protected:
public:
// Constructor
Sprite(std::shared_ptr<Texture>, int x, int y, int w, int h);
Sprite(std::shared_ptr<Texture>, float x, float y, float w, float h);
Sprite(std::shared_ptr<Texture>, SDL_FRect rect);
explicit Sprite(std::shared_ptr<Texture>);
@@ -30,39 +31,39 @@ public:
virtual void clear();
// Obtiene la posición y el tamaño
int getX() const { return pos_.x; }
int getY() const { return pos_.y; }
int getWidth() const { return pos_.w; }
int getHeight() const { return pos_.h; }
float getX() const { return pos_.x; }
float getY() const { return pos_.y; }
float getWidth() const { return pos_.w; }
float getHeight() const { return pos_.h; }
// Devuelve el rectangulo donde está el sprite
SDL_FRect getPosition() const { return pos_; }
SDL_FRect &getRect() { return pos_; }
// Establece la posición y el tamaño
void setX(int x) { pos_.x = x; }
void setY(int y) { pos_.y = y; }
void setWidth(int w) { pos_.w = w; }
void setHeight(int h) { pos_.h = h; }
void setX(float x) { pos_.x = x; }
void setY(float y) { pos_.y = y; }
void setWidth(float w) { pos_.w = w; }
void setHeight(float h) { pos_.h = h; }
// Establece la posición del objeto
void setPosition(int x, int y);
void setPosition(SDL_Point p);
void setPosition(float x, float y);
void setPosition(SDL_FPoint p);
void setPosition(SDL_FRect r) { pos_ = r; }
// Establece el nivel de zoom
void setZoom(float zoom) { zoom_ = zoom; }
// Aumenta o disminuye la posición
void incX(int value) { pos_.x += value; }
void incY(int value) { pos_.y += value; }
void incX(float value) { pos_.x += value; }
void incY(float value) { pos_.y += value; }
// Obtiene el rectangulo que se dibuja de la textura
SDL_FRect getSpriteClip() const { return sprite_clip_; }
// Establece el rectangulo que se dibuja de la textura
void setSpriteClip(SDL_FRect rect) { sprite_clip_ = rect; }
void setSpriteClip(int x, int y, int w, int h) { sprite_clip_ = (SDL_FRect){x, y, w, h}; }
void setSpriteClip(float x, float y, float w, float h) { sprite_clip_ = (SDL_FRect){x, y, w, h}; }
// Obtiene un puntero a la textura
std::shared_ptr<Texture> getTexture() const { return texture_; }

1
source/stage.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <vector>

1
source/tabe.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_stdinc.h> // Para Uint32

6
source/text.cpp
View File

@@ -96,7 +96,7 @@ Text::Text(std::shared_ptr<Texture> texture, const std::string &text_file)
}
// Crea los objetos
sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, box_width_, box_height_});
sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
// Inicializa variables
fixed_width_ = false;
@@ -116,7 +116,7 @@ Text::Text(std::shared_ptr<Texture> texture, std::shared_ptr<TextFile> text_file
}
// Crea los objetos
sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, box_width_, box_height_});
sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
// Inicializa variables
fixed_width_ = false;
@@ -148,7 +148,7 @@ void Text::write2X(int x, int y, const std::string &text, int kerning)
for (size_t i = 0; i < text.length(); ++i)
{
auto index = static_cast<size_t>(text[i]);
SDL_FRect rect = {offset_[index].x, offset_[index].y, box_width_, box_height_};
SDL_FRect rect = {static_cast<float>(offset_[index].x), static_cast<float>(offset_[index].y), static_cast<float>(box_width_), static_cast<float>(box_height_)};
sprite_->getTexture()->render(x + shift, y, &rect, 2.0f, 2.0f);
shift += (offset_[index].w + kerning) * 2;
}

1
source/text.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_stdinc.h> // Para Uint8
#include <memory> // Para unique_ptr, shared_ptr

32
source/texture.cpp
View File

@@ -75,11 +75,10 @@ bool Texture::loadFromFile(const std::string &file_path)
printWithDots("Image : ", getFileName(file_path), "[ LOADED ]");
}
int depth, pitch;
Uint32 pixel_format;
int pitch;
SDL_PixelFormat pixel_format;
// STBI_rgb_alpha (RGBA)
depth = 32;
pitch = 4 * width;
pixel_format = SDL_PIXELFORMAT_RGBA32;
@@ -87,41 +86,42 @@ bool Texture::loadFromFile(const std::string &file_path)
unloadTexture();
// La textura final
SDL_Texture *newTexture = nullptr;
SDL_Texture *new_texture = nullptr;
// Carga la imagen desde una ruta específica
auto loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom(static_cast<void *>(data), width, height, depth, pitch, pixel_format);
if (loadedSurface == nullptr)
/*auto loaded_surface = SDL_CreateRGBSurfaceWithFormatFrom(static_cast<void *>(data), width, height, depth, pitch, pixel_format);*/
auto loaded_surface = SDL_CreateSurfaceFrom(width, height, pixel_format, static_cast<void *>(data), pitch);
if (loaded_surface == nullptr)
{
std::cout << "Unable to load image " << file_path << std::endl;
}
else
{
// Crea la textura desde los pixels de la surface
newTexture = SDL_CreateTextureFromSurface(renderer_, loadedSurface);
if (newTexture == nullptr)
new_texture = SDL_CreateTextureFromSurface(renderer_, loaded_surface);
if (new_texture == nullptr)
{
std::cout << "Unable to create texture from " << file_path << "! SDL Error: " << SDL_GetError() << std::endl;
}
else
{
// Obtiene las dimensiones de la imagen
width_ = loadedSurface->w;
height_ = loadedSurface->h;
width_ = loaded_surface->w;
height_ = loaded_surface->h;
}
// Elimina la textura cargada
SDL_FreeSurface(loadedSurface);
SDL_DestroySurface(loaded_surface);
}
// Return success
stbi_image_free(data);
texture_ = newTexture;
texture_ = new_texture;
return texture_ != nullptr;
}
// Crea una textura en blanco
bool Texture::createBlank(int width, int height, SDL_PixelFormatEnum format, SDL_TextureAccess access)
bool Texture::createBlank(int width, int height, SDL_PixelFormat format, SDL_TextureAccess access)
{
// Crea una textura sin inicializar
texture_ = SDL_CreateTexture(renderer_, format, access, width, height);
@@ -174,10 +174,10 @@ void Texture::setAlpha(Uint8 alpha)
}
// Renderiza la textura en un punto específico
void Texture::render(int x, int y, SDL_FRect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_RendererFlip flip)
void Texture::render(int x, int y, SDL_FRect *clip, float zoomW, float zoomH, double angle, SDL_FPoint *center, SDL_FlipMode flip)
{
// Establece el destino de renderizado en la pantalla
SDL_FRect renderQuad = {x, y, width_, height_};
SDL_FRect renderQuad = {static_cast<float>(x), static_cast<float>(y), static_cast<float>(width_), static_cast<float>(height_)};
// Obtiene las dimesiones del clip de renderizado
if (clip != nullptr)
@@ -198,7 +198,7 @@ void Texture::render(int x, int y, SDL_FRect *clip, float zoomW, float zoomH, do
}
// Renderiza a pantalla
SDL_RenderCopyEx(renderer_, texture_, clip, &renderQuad, angle, center, flip);
SDL_RenderTextureRotated(renderer_, texture_, clip, &renderQuad, angle, center, flip);
}
// Establece la textura como objetivo de renderizado

7
source/texture.h
View File

@@ -1,8 +1,9 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_blendmode.h> // Para SDL_BlendMode
#include <SDL3/SDL_pixels.h> // Para SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
#include <SDL3/SDL_rect.h> // Para SDL_Point, SDL_FRect
#include <SDL3/SDL_rect.h> // Para SDL_FPoint, SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
#include <SDL3/SDL_stdinc.h> // Para Uint8, Uint16, Uint32
#include <memory> // Para shared_ptr
@@ -62,7 +63,7 @@ public:
bool loadFromFile(const std::string &path);
// Crea una textura en blanco
bool createBlank(int width, int height, SDL_PixelFormatEnum format = SDL_PIXELFORMAT_RGBA8888, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
bool createBlank(int width, int height, SDL_PixelFormat format = SDL_PIXELFORMAT_RGBA8888, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
// Establece el color para la modulacion
void setColor(Uint8 red, Uint8 green, Uint8 blue);
@@ -75,7 +76,7 @@ public:
void setAlpha(Uint8 alpha);
// Renderiza la textura en un punto específico
void render(int x, int y, SDL_FRect *clip = nullptr, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_Point *center = nullptr, SDL_RendererFlip flip = SDL_FLIP_NONE);
void render(int x, int y, SDL_FRect *clip = nullptr, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_FPoint *center = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);
// Establece la textura como objetivo de renderizado
void setAsRenderTarget(SDL_Renderer *renderer);

1
source/tiled_bg.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect
#include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture

6
source/title.cpp
View File

@@ -143,11 +143,11 @@ void Title::checkEvents()
SDL_Event event;
while (SDL_PollEvent(&event))
{
if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0)
{
bool should_reset = false;
switch (event.key.keysym.sym)
switch (event.key.key)
{
case SDLK_1: // Redefine los botones del mando #0
should_reset = define_buttons_->enable(0);
@@ -204,7 +204,7 @@ void Title::checkInput()
if ((state_ == TitleState::LOGO_FINISHED || ALLOW_TITLE_ANIMATION_SKIP) && !fade_->isEnabled())
{
JA_PlaySound(Resource::get()->getSound("game_start.wav"));
JA_FadeOutMusic(1500);
/*JA_FadeOutMusic(1500);*/
switch (controller.player_id)
{
case 1:

3
source/title.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_stdinc.h> // Para Uint32
#include <memory> // Para unique_ptr, shared_ptr
@@ -54,7 +55,7 @@ private:
// Variable
int counter_ = 0; // Temporizador para la pantalla de titulo
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint64 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
section::Name next_section_; // Indica cual es la siguiente sección a cargar cuando termine el contador del titulo
section::Options selection_ = section::Options::TITLE_TIME_OUT; // Opción elegida en el titulo
int num_controllers_; // Número de mandos conectados

55
source/utils.cpp
View File

@@ -1,14 +1,15 @@
#define _USE_MATH_DEFINES
#include "utils.h"
#include <SDL3/SDL_rwops.h> // Para SDL_RWFromFile, SDL_RWclose, SDL_RWread
#include <stddef.h> // Para size_t
#include <algorithm> // Para min, clamp, find_if_not, find, transform
#include <cctype> // Para tolower, isspace
#include <cmath> // Para pow, sin, M_PI, cos
#include <compare> // Para operator<
#include <filesystem> // Para path
#include <iostream> // Para basic_ostream, cout, basic_ios, endl, ios
#include <stdexcept> // Para runtime_error
#include <string> // Para basic_string, string, char_traits, opera...
#include <SDL3/SDL.h> // Para SDL_IOFromFile, SDL_CloseIO, SDL_RIO
#include <stddef.h> // Para size_t
#include <algorithm> // Para min, clamp, find_if_not, find, transform
#include <cctype> // Para tolower, isspace
#include <cmath> // Para pow, sin, M_PI, cos
#include <compare> // Para operator<
#include <filesystem> // Para path
#include <iostream> // Para basic_ostream, cout, basic_ios, endl, ios
#include <stdexcept> // Para runtime_error
#include <string> // Para basic_string, string, char_traits, opera...
#include "lang.h"
// Variables
@@ -72,11 +73,11 @@ bool checkCollision(const Circle &a, const Circle &b)
bool checkCollision(const Circle &a, const SDL_FRect &b)
{
// Encuentra el punto más cercano en el rectángulo
int cX = std::clamp(a.x, b.x, b.x + b.w);
int cY = std::clamp(a.y, b.y, b.y + b.h);
float cX = std::clamp(static_cast<float>(a.x), b.x, b.x + b.w);
float cY = std::clamp(static_cast<float>(a.y), b.y, b.y + b.h);
// Si el punto más cercano está dentro del círculo
return distanceSquared(a.x, a.y, cX, cY) < a.r * a.r;
return distanceSquared(static_cast<float>(a.x), static_cast<float>(a.y), cX, cY) < static_cast<float>(a.r) * a.r;
}
// Detector de colisiones entre dos rectangulos
@@ -98,7 +99,7 @@ bool checkCollision(const SDL_FRect &a, const SDL_FRect &b)
}
// Detector de colisiones entre un punto y un rectangulo
bool checkCollision(const SDL_Point &p, const SDL_FRect &r)
bool checkCollision(const SDL_FPoint &p, const SDL_FRect &r)
{
if (p.x < r.x || p.x > r.x + r.w)
return false;
@@ -149,14 +150,14 @@ void DrawCircle(SDL_Renderer *renderer, int32_t centerX, int32_t centerY, int32_
while (x >= y)
{
// Each of the following renders an octant of the circle
SDL_RenderDrawPoint(renderer, centerX + x, centerY - y);
SDL_RenderDrawPoint(renderer, centerX + x, centerY + y);
SDL_RenderDrawPoint(renderer, centerX - x, centerY - y);
SDL_RenderDrawPoint(renderer, centerX - x, centerY + y);
SDL_RenderDrawPoint(renderer, centerX + y, centerY - x);
SDL_RenderDrawPoint(renderer, centerX + y, centerY + x);
SDL_RenderDrawPoint(renderer, centerX - y, centerY - x);
SDL_RenderDrawPoint(renderer, centerX - y, centerY + x);
SDL_RenderPoint(renderer, centerX + x, centerY - y);
SDL_RenderPoint(renderer, centerX + x, centerY + y);
SDL_RenderPoint(renderer, centerX - x, centerY - y);
SDL_RenderPoint(renderer, centerX - x, centerY + y);
SDL_RenderPoint(renderer, centerX + y, centerY - x);
SDL_RenderPoint(renderer, centerX + y, centerY + x);
SDL_RenderPoint(renderer, centerX - y, centerY - x);
SDL_RenderPoint(renderer, centerX - y, centerY + x);
if (error <= 0)
{
@@ -317,7 +318,7 @@ DemoData loadDemoDataFromFile(const std::string &file_path)
DemoData dd;
// Indicador de éxito en la carga
auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
auto file = SDL_IOFromFile(file_path.c_str(), "r+b");
if (!file)
{
std::cerr << "Error: Fichero no encontrado " << file_path << std::endl;
@@ -331,12 +332,12 @@ DemoData loadDemoDataFromFile(const std::string &file_path)
for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
{
DemoKeys dk = DemoKeys();
SDL_RWread(file, &dk, sizeof(DemoKeys), 1);
SDL_ReadIO(file, &dk, sizeof(DemoKeys));
dd.push_back(dk);
}
// Cierra el fichero
SDL_RWclose(file);
SDL_CloseIO(file);
}
return dd;
@@ -347,7 +348,7 @@ DemoData loadDemoDataFromFile(const std::string &file_path)
bool saveDemoFile(const std::string &file_path, const DemoData &dd)
{
auto success = true;
auto file = SDL_RWFromFile(file_path.c_str(), "w+b");
auto file = SDL_IOFromFile(file_path.c_str(), "w+b");
if (file)
{
@@ -366,7 +367,7 @@ bool saveDemoFile(const std::string &file_path, const DemoData &dd)
std::cout << "Writing file " << getFileName(file_path).c_str() << std::endl;
}
// Cierra el fichero
SDL_RWclose(file);
SDL_CloseIO(file);
}
else
{

19
source/utils.h
View File

@@ -1,6 +1,7 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_Point
#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_FPoint
#include <SDL3/SDL_render.h> // Para SDL_Renderer
#include <SDL3/SDL_stdinc.h> // Para Uint8
#include <stdint.h> // Para int32_t
@@ -116,13 +117,13 @@ struct Demo
// Posiciones dentro de un rectangulo
struct Zone
{
SDL_FRect rect; // Rectangulo que define la zona
int center_x; // Anclaje al 50% del eje X
int first_quarter_x; // Anclaje al 25% del eje X
int third_quarter_x; // Anclaje al 75% del eje X
int center_y; // Anclaje al 50% del eje Y
int first_quarter_y; // Anclaje al 25% del eje Y
int third_quarter_y; // Anclaje al 75% del eje X
SDL_FRect rect; // Rectangulo que define la zona
float center_x; // Anclaje al 50% del eje X
float first_quarter_x; // Anclaje al 25% del eje X
float third_quarter_x; // Anclaje al 75% del eje X
float center_y; // Anclaje al 50% del eje Y
float first_quarter_y; // Anclaje al 25% del eje Y
float third_quarter_y; // Anclaje al 75% del eje X
};
// Obtiene un color del vector de colores imitando al Coche Fantástico
@@ -141,7 +142,7 @@ bool checkCollision(const Circle &a, const SDL_FRect &b);
bool checkCollision(const SDL_FRect &a, const SDL_FRect &b);
// Detector de colisiones entre un punto y un rectangulo
bool checkCollision(const SDL_Point &p, const SDL_FRect &r);
bool checkCollision(const SDL_FPoint &p, const SDL_FRect &r);
// Convierte una cadena en un valor booleano
bool stringToBool(const std::string &str);

1
source/writer.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include <SDL3/SDL.h>
#include <memory> // Para shared_ptr
#include <string> // Para string