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

.

Browse Source
This commit is contained in:
Sergio
2024-10-23 18:29:52 +02:00
parent 95478134dd
commit 6e2f80d8ce
26 changed files with 232 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
source/asset.cpp
View File

@@ -28,34 +28,19 @@ Asset *Asset::get()
return Asset::asset_;
}
// Constructor
Asset::Asset(const std::string &executable_path)
: executable_path_(executable_path.substr(0, executable_path.find_last_of("\\/")))
{
longest_name_ = 0;
}
// Añade un elemento a la lista
void Asset::add(const std::string &file, AssetType type, bool required, bool absolute)
{
AssetItem ai;
ai.file = absolute ? file : executable_path_ + file;
ai.type = type;
ai.required = required;
file_list_.push_back(ai);
longest_name_ = SDL_max(longest_name_, getFileName(file).size());
file_list_.emplace_back(absolute ? file : executable_path_ + file, type, required);
longest_name_ = std::max(longest_name_, static_cast<int>(file_list_.back().file.size()));
}
// Devuelve el fichero de un elemento de la lista a partir de una cadena
// Devuelve la ruta completa a un fichero a partir de una cadena
std::string Asset::get(const std::string &text) const
{
for (const auto &f : file_list_)
{
const size_t last_index = f.file.find_last_of("/") + 1;
const std::string file = f.file.substr(last_index, std::string::npos);
if (file == text)
if (getFileName(f.file) == text)
{
return f.file;
}

17
source/asset.h
View File

@@ -2,6 +2,7 @@
#include <string> // for string, basic_string
#include <vector> // for vector
#include "utils.h"
enum class AssetType : int
{
@@ -27,14 +28,17 @@ private:
// Estructura para definir un item
struct AssetItem
{
std::string file; // Ruta del fichero desde la raiz del directorio
enum AssetType type; // Indica el tipo de recurso
std::string file; // Ruta del fichero desde la raíz del directorio
AssetType type; // Indica el tipo de recurso
bool required; // Indica si es un fichero que debe de existir
// bool absolute; // Indica si la ruta que se ha proporcionado es una ruta absoluta
// Constructor
AssetItem(const std::string &filePath, AssetType assetType, bool isRequired)
: file(filePath), type(assetType), required(isRequired) {}
};
// Variables
int longest_name_; // Contiene la longitud del nombre de fichero mas largo
int longest_name_ = 0; // Contiene la longitud del nombre de fichero mas largo
std::vector<AssetItem> file_list_; // Listado con todas las rutas a los ficheros
std::string executable_path_; // Ruta al ejecutable
@@ -45,7 +49,8 @@ private:
std::string getTypeName(AssetType type) const;
// Constructor
explicit Asset(const std::string &executable_path);
explicit Asset(const std::string &executable_path)
: executable_path_(getPath(executable_path)) {}
// Destructor
~Asset() = default;
@@ -63,7 +68,7 @@ public:
// Añade un elemento a la lista
void add(const std::string &file, AssetType type, bool required = true, bool absolute = false);
// Devuelve un elemento de la lista a partir de una cadena
// Devuelve la ruta completa a un fichero a partir de una cadena
std::string get(const std::string &text) const;
// Comprueba que existen todos los elementos

5
source/background.cpp
View File

@@ -20,11 +20,6 @@ Background::Background()
grass_texture_(Resource::get()->getTexture("game_grass.png")),
gradients_texture_(Resource::get()->getTexture("game_sky_colors.png")),
gradient_number_(0),
alpha_(0),
clouds_speed_(0),
transition_(0),
counter_(0),
rect_({0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2}),
src_rect_({0, 0, 320, 240}),
dst_rect_({0, 0, 320, 240}),

10
source/background.h
View File

@@ -74,11 +74,11 @@ private:
SDL_Rect gradient_rect_[4]; // Vector con las coordenadas de los 4 degradados para el cielo
SDL_Rect top_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de arriba
SDL_Rect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
int gradient_number_; // Indica el número de degradado de fondo que se va a dibujar
int alpha_; // Transparencia entre los dos degradados
float clouds_speed_; // Velocidad a la que se desplazan las nubes
float transition_; // Nivel de transición del fondo 0..1
int counter_; // Contador interno
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_Rect rect_; // Tamaño del objeto fondo
SDL_Rect src_rect_; // Parte del objeto fondo que se va a dibujará en pantalla
SDL_Rect dst_rect_; // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla

25
source/balloon.cpp
View File

@@ -13,17 +13,10 @@ Balloon::Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16
pos_y_(y),
vel_x_(vel_x),
being_created_(creation_timer > 0),
blinking_(false),
enabled_(true),
invulnerable_(creation_timer > 0),
stopped_(true),
visible_(true),
creation_counter_(creation_timer),
creation_counter_ini_(creation_timer),
stopped_counter_(0),
kind_(kind),
counter_(0),
travel_y_(1.0f),
speed_(speed)
{
@@ -227,23 +220,9 @@ Balloon::Balloon(float x, float y, Uint8 kind, float vel_x, float speed, Uint16
break;
}
// Valores para el efecto de rebote
bouncing_.enabled = false;
bouncing_.counter = 0;
bouncing_.speed = 2;
bouncing_.zoomW = 1.0f;
bouncing_.zoomH = 1.0f;
bouncing_.despX = 0.0f;
bouncing_.despY = 0.0f;
bouncing_.w = {1.10f, 1.05f, 1.00f, 0.95f, 0.90f, 0.95f, 1.00f, 1.02f, 1.05f, 1.02f};
bouncing_.h = {0.90f, 0.95f, 1.00f, 1.05f, 1.10f, 1.05f, 1.00f, 0.98f, 0.95f, 0.98f};
// Configura el sprite
sprite_->setPos({static_cast<int>(pos_x_), static_cast<int>(pos_y_), width_, height_});
// Tamaño del circulo de colisión
collider_.r = width_ / 2;
// Alinea el circulo de colisión con el objeto
updateColliders();
}
@@ -726,8 +705,8 @@ Circle &Balloon::getCollider()
// Alinea el circulo de colisión con la posición del objeto globo
void Balloon::updateColliders()
{
collider_.x = Uint16(pos_x_ + collider_.r);
collider_.y = pos_y_ + collider_.r;
collider_.x = static_cast<int>(pos_x_ + collider_.r);
collider_.y = static_cast<int>(pos_y_ + collider_.r);
}
// Obtiene le valor de la variable

40
source/balloon.h
View File

@@ -74,15 +74,19 @@ private:
// Estructura para las variables para el efecto de los rebotes
struct Bouncing
{
bool enabled; // Si el efecto está activo
Uint8 counter; // Countador para el efecto
Uint8 speed; // Velocidad a la que transcurre el efecto
float zoomW; // Zoom aplicado a la anchura
float zoomH; // Zoom aplicado a la altura
float despX; // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
float despY; // Desplazamiento de pixeles en el eje Y antes de pintar el objeto con zoom
std::vector<float> w; // Vector con los valores de zoom para el ancho del globo
std::vector<float> h; // Vector con los valores de zoom para el alto del globo
bool enabled = false; // Si el efecto está activo
Uint8 counter = 0; // Countador para el efecto
Uint8 speed = 2; // Velocidad a la que transcurre el efecto
float zoomW = 1.0f; // Zoom aplicado a la anchura
float zoomH = 1.0f; // Zoom aplicado a la altura
float despX = 0.0f; // Desplazamiento de pixeles en el eje X antes de pintar el objeto con zoom
float despY = 0.0f; // Desplazamiento de pixeles en el eje Y antes de pintar el objeto con zoom
std::vector<float> w = {1.10f, 1.05f, 1.00f, 0.95f, 0.90f, 0.95f, 1.00f, 1.02f, 1.05f, 1.02f}; // Vector con los valores de zoom para el ancho del globo
std::vector<float> h = {0.90f, 0.95f, 1.00f, 1.05f, 1.10f, 1.05f, 1.00f, 0.98f, 0.95f, 0.98f}; // Vector con los valores de zoom para el alto del globo
// Constructor por defecto
Bouncing() {}
};
// Objetos y punteros
@@ -99,24 +103,24 @@ private:
float default_vel_y_; // Velocidad inicial que tienen al rebotar contra el suelo
float max_vel_y_; // Máxima velocidad que puede alcanzar el objeto en el eje Y
bool being_created_; // Indica si el globo se está creando
bool blinking_; // Indica si el globo está intermitente
bool enabled_; // Indica si el globo esta activo
bool blinking_ = false; // Indica si el globo está intermitente
bool enabled_ = true; // Indica si el globo esta activo
bool invulnerable_; // Indica si el globo es invulnerable
bool stopped_; // Indica si el globo está parado
bool visible_; // Indica si el globo es visible
Circle collider_; // Circulo de colisión del objeto
bool stopped_ = true; // Indica si el globo está parado
bool visible_ = true; // Indica si el globo es visible
Circle collider_ = Circle(0, 0, width_ / 2); // Circulo de colisión del objeto
Uint16 creation_counter_; // Temporizador para controlar el estado "creandose"
Uint16 creation_counter_ini_; // Valor inicial para el temporizador para controlar el estado "creandose"
Uint16 score_; // Puntos que da el globo al ser destruido
Uint16 stopped_counter_; // Contador para controlar el estado "parado"
Uint16 stopped_counter_ = 0; // Contador para controlar el estado "parado"
Uint8 kind_; // Tipo de globo
Uint8 menace_; // Cantidad de amenaza que genera el globo
Uint32 counter_; // Contador interno
float travel_y_; // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
Uint32 counter_ = 0; // Contador interno
float travel_y_ = 1.0f; // Distancia que ha de recorrer el globo en el eje Y antes de que se le aplique la gravedad
float speed_; // Velocidad a la que se mueven los globos
Uint8 size_; // Tamaño del globo
Uint8 power_; // Cantidad de poder que alberga el globo
Bouncing bouncing_; // Contiene las variables para el efecto de rebote
Bouncing bouncing_ = Bouncing(); // Contiene las variables para el efecto de rebote
// Alinea el circulo de colisión con la posición del objeto globo
void updateColliders();

14
source/game.cpp
View File

@@ -87,15 +87,18 @@ Game::Game(int player_id, int current_stage, bool demo)
SDL_SetTextureBlendMode(canvas_, SDL_BLENDMODE_BLEND);
// Crea los dos jugadores
players_.emplace_back(std::make_unique<Player>(1, (param.game.play_area.first_quarter_x * ((0 * 2) + 1)) - 11, param.game.play_area.rect.h - 30, demo_.enabled, &param.game.play_area.rect, player_textures_[0], player_animations_));
{
const int y = param.game.play_area.rect.h - 30;
players_.emplace_back(std::make_unique<Player>(1, param.game.play_area.first_quarter_x - 15, y, demo_.enabled, param.game.play_area.rect, player_textures_[0], player_animations_));
players_.back()->setScoreBoardPanel(SCOREBOARD_LEFT_PANEL);
players_.back()->setName(lang::getText(53));
players_.back()->setController(getController(players_.back()->getId()));
players_.emplace_back(std::make_unique<Player>(2, (param.game.play_area.first_quarter_x * ((1 * 2) + 1)) - 11, param.game.play_area.rect.h - 30, demo_.enabled, &param.game.play_area.rect, player_textures_[1], player_animations_));
players_.emplace_back(std::make_unique<Player>(2, param.game.play_area.third_quarter_x - 15, y, demo_.enabled, param.game.play_area.rect, player_textures_[1], player_animations_));
players_.back()->setScoreBoardPanel(SCOREBOARD_RIGHT_PANEL);
players_.back()->setName(lang::getText(54));
players_.back()->setController(getController(players_.back()->getId()));
}
// Activa el jugador que coincide con el "player_id"
{
@@ -1132,7 +1135,7 @@ ItemType Game::dropItem()
// Crea un objeto item
void Game::createItem(ItemType type, float x, float y)
{
items_.emplace_back(std::make_unique<Item>(type, x, y, &(param.game.play_area.rect), item_textures_[static_cast<int>(type) - 1], item_animations_[static_cast<int>(type) - 1]));
items_.emplace_back(std::make_unique<Item>(type, x, y, param.game.play_area.rect, item_textures_[static_cast<int>(type) - 1], item_animations_[static_cast<int>(type) - 1]));
}
// Vacia el vector de items
@@ -1327,8 +1330,9 @@ void Game::updateBalloonDeployCounter()
// Actualiza el juego
void Game::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
constexpr int TICKS_SPEED = 15;
if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();

1
source/game.h
View File

@@ -93,7 +93,6 @@ private:
static constexpr int GAME_COMPLETED_END_ = 700;
static constexpr int GAME_OVER_COUNTER_ = 350;
static constexpr int TIME_STOPPED_COUNTER_ = 300;
static constexpr int TICKS_SPEED_ = 15;
// Porcentaje de aparición de los objetos
static constexpr int ITEM_POINTS_1_DISK_ODDS_ = 10;

5
source/hiscore_table.cpp
View File

@@ -61,8 +61,9 @@ HiScoreTable::~HiScoreTable()
// Actualiza las variables
void HiScoreTable::update()
{
// Actualiza las variables
if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
constexpr int TICKS_SPEED = 15;
if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();

1
source/hiscore_table.h
View File

@@ -26,7 +26,6 @@ class HiScoreTable
private:
// Constantes
static constexpr Uint16 COUNTER_END_ = 800; // Valor final para el contador
static constexpr Uint32 TICKS_SPEED_ = 15; // Velocidad a la que se repiten los bucles del programa
// Objetos y punteros
SDL_Renderer *renderer_; // El renderizador de la ventana

27
source/instructions.cpp
View File

@@ -25,32 +25,22 @@ struct JA_Music_t; // lines 22-22
// Constructor
Instructions::Instructions()
: renderer_(Screen::get()->getRenderer()),
texture_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
text_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
tiled_bg_(std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::STATIC)),
fade_(std::make_unique<Fade>())
{
// Copia los punteros
renderer_ = Screen::get()->getRenderer();
// Crea objetos
text_ = std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"));
tiled_bg_ = std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::STATIC);
fade_ = std::make_unique<Fade>();
// Crea un backbuffer para el renderizador
backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
// Crea una textura para el texto fijo
texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
// Inicializa variables
section::name = section::Name::INSTRUCTIONS;
ticks_ = 0;
ticks_speed_ = 15;
counter_ = 0;
counter_end_ = 700;
view_ = {0, 0, param.game.width, param.game.height};
sprite_pos_ = {0, 0};
item_space_ = 2;
// Inicializa objetos
fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
@@ -214,8 +204,9 @@ void Instructions::fillBackbuffer()
// Actualiza las variables
void Instructions::update()
{
// Actualiza las variables
if (SDL_GetTicks() - ticks_ > ticks_speed_)
constexpr int TICKS_SPEED = 15;
if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();

19
source/instructions.h
View File

@@ -30,24 +30,23 @@ class Instructions
{
private:
// Objetos y punteros
SDL_Renderer *renderer_; // El renderizador de la ventana
SDL_Texture *texture_; // Textura fija con el texto
SDL_Texture *backbuffer_; // Textura para usar como backbuffer
std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
std::vector<std::unique_ptr<Sprite>> sprites_; // Vector con los sprites de los items
std::unique_ptr<Text> text_; // Objeto para escribir texto
std::unique_ptr<TiledBG> tiled_bg_; // Objeto para dibujar el mosaico animado de fondo
std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
SDL_Renderer *renderer_; // El renderizador de la ventana
SDL_Texture *texture_; // Textura fija con el texto
SDL_Texture *backbuffer_; // Textura para usar como backbuffer
// Variables
int counter_; // Contador
int counter_end_; // Valor final para el contador
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
int counter_ = 0; // Contador
int counter_end_ = 700; // Valor final para el contador
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
SDL_Rect view_; // Vista del backbuffer que se va amostrar por pantalla
SDL_Point sprite_pos_; // Posición del primer sprite
int item_space_; // Espacio entre los items
SDL_Point sprite_pos_ = {0, 0}; // Posición del primer sprite
int item_space_ = 2; // Espacio entre los items
// Actualiza las variables
void update();

12
source/intro.cpp
View File

@@ -21,17 +21,13 @@ struct JA_Music_t; // lines 19-19
// Constructor
Intro::Intro()
: texture_(Resource::get()->getTexture("intro.png"))
: texture_(Resource::get()->getTexture("intro.png")),
text_(std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt")))
{
// Reserva memoria para los objetos
text_ = std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt"));
// Inicializa variables
section::name = section::Name::INTRO;
section::options = section::Options::NONE;
ticks_ = 0;
ticks_speed_ = 15;
scene_ = 1;
// Inicializa los bitmaps de la intro
constexpr int totalBitmaps = 6;
@@ -372,7 +368,9 @@ void Intro::updateScenes()
// Actualiza las variables del objeto
void Intro::update()
{
if (SDL_GetTicks() - ticks_ > ticks_speed_)
constexpr int TICKS_SPEED = 15;
if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();

5
source/intro.h
View File

@@ -26,9 +26,8 @@ private:
std::vector<std::unique_ptr<Writer>> texts_; // Textos de la intro
// Variables
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
Uint8 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
int scene_; // Indica que escena está activa
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
int scene_ = 1; // Indica que escena está activa
// Actualiza las variables del objeto
void update();

35
source/item.cpp
View File

@@ -5,27 +5,26 @@
class Texture;
// Constructor
Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
accel_x_(0.0f),
floor_collision_(false),
type_(type),
enabled_(true),
play_area_(play_area),
time_to_live_(600)
play_area_(play_area)
{
if (type == ItemType::COFFEE_MACHINE)
switch (type)
{
case ItemType::COFFEE_MACHINE:
{
width_ = 28;
height_ = 37;
pos_x_ = (((int)x + (play_area->w / 2)) % (play_area->w - width_ - 5)) + 2;
pos_x_ = ((static_cast<int>(x) + (play_area.w / 2)) % (play_area.w - width_ - 5)) + 2;
pos_y_ = -height_;
vel_x_ = 0.0f;
vel_y_ = -0.1f;
accel_y_ = 0.1f;
collider_.r = 10;
break;
}
else
default:
{
width_ = 20;
height_ = 20;
@@ -35,6 +34,8 @@ Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr
vel_y_ = -4.0f;
accel_y_ = 0.2f;
collider_.r = width_ / 2;
break;
}
}
sprite_->setPosX(pos_x_);
@@ -45,20 +46,20 @@ Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr
// Centra el objeto en la posición X
void Item::allignTo(int x)
{
pos_x_ = float(x - (width_ / 2));
pos_x_ = static_cast<float>(x - (width_ / 2));
if (pos_x_ < param.game.play_area.rect.x)
{
pos_x_ = param.game.play_area.rect.x + 1;
}
else if ((pos_x_ + width_) > play_area_->w)
else if (pos_x_ + width_ > play_area_.w)
{
pos_x_ = float(play_area_->w - width_ - 1);
pos_x_ = static_cast<float>(play_area_.w - width_ - 1);
}
// Posición X,Y del sprite
sprite_->setPosX(int(pos_x_));
sprite_->setPosY(int(pos_y_));
sprite_->setPosX(pos_x_);
sprite_->setPosY(pos_y_);
// Alinea el circulo de colisión con el objeto
shiftColliders();
@@ -94,7 +95,7 @@ void Item::move()
vel_y_ += accel_y_;
// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_->w))
if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_.w))
{
// Corregir posición
pos_x_ -= vel_x_;
@@ -114,14 +115,14 @@ void Item::move()
}
// Si el objeto se sale por la parte inferior
if (pos_y_ + height_ > play_area_->h)
if (pos_y_ + height_ > play_area_.h)
{
// Detiene el objeto
vel_y_ = 0;
vel_x_ = 0;
accel_x_ = 0;
accel_y_ = 0;
pos_y_ = play_area_->h - height_;
pos_y_ = play_area_.h - height_;
if (type_ == ItemType::COFFEE_MACHINE)
{
floor_collision_ = true;

12
source/item.h
View File

@@ -35,14 +35,14 @@ private:
int height_; // Alto del objeto
float vel_x_; // Velocidad en el eje X
float vel_y_; // Velocidad en el eje Y
float accel_x_; // Aceleración en el eje X
float accel_x_ = 0.0f; // Aceleración en el eje X
float accel_y_; // Aceleración en el eje Y
bool floor_collision_; // Indica si el objeto colisiona con el suelo
bool floor_collision_ = false; // Indica si el objeto colisiona con el suelo
ItemType type_; // Especifica el tipo de objeto que es
bool enabled_; // Especifica si el objeto está habilitado
bool enabled_ = true; // Especifica si el objeto está habilitado
Circle collider_; // Circulo de colisión del objeto
SDL_Rect *play_area_; // Rectangulo con la zona de juego
Uint16 time_to_live_; // Temporizador con el tiempo que el objeto está presente
SDL_Rect play_area_; // Rectangulo con la zona de juego
Uint16 time_to_live_ = 600; // Temporizador con el tiempo que el objeto está presente
// Alinea el circulo de colisión con la posición del objeto
void shiftColliders();
@@ -58,7 +58,7 @@ private:
public:
// Constructor
Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);
// Destructor
~Item() = default;

3
source/logo.cpp
View File

@@ -165,7 +165,8 @@ void Logo::updateTextureColors()
// Actualiza las variables
void Logo::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
constexpr int TICKS_SPEED = 15;
if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
{
// Actualiza el contador de ticks

1
source/logo.h
View File

@@ -21,7 +21,6 @@ class Logo
{
private:
// Constantes
static constexpr Uint32 TICKS_SPEED = 15; // Velocidad a la que se repiten los bucles del programa
static constexpr int SHOW_SINCE_SPRITE_COUNTER_MARK = 70; // Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998"
static constexpr int INIT_FADE_COUNTER_MARK = 300; // Tiempo del contador cuando inicia el fade a negro
static constexpr int END_LOGO_COUNTER_MARK = 400; // Tiempo del contador para terminar el logo

76
source/player.cpp
View File

@@ -11,26 +11,18 @@
#include "options.h"
// Constructor
Player::Player(int id, float x, int y, bool demo, SDL_Rect *play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
: player_sprite_(std::make_unique<AnimatedSprite>(texture[0], animations[0])),
power_sprite_(std::make_unique<AnimatedSprite>(texture[1], animations[1])),
enter_name_(std::make_unique<EnterName>()),
play_area_(play_area),
id_(id),
pos_x_(x),
pos_y_(y),
play_area_(play_area),
default_pos_x_(x),
default_pos_y_(y),
status_playing_(PlayerStatus::WAITING),
scoreboard_panel_(0),
name_(std::string()),
controller_index_(0),
demo_(demo)
{
// Reserva memoria para los objetos
// Configura objetos
power_sprite_->getTexture()->setAlpha(224);
// Establece los offsets para el sprite de PowerUp
power_up_desp_x_ = (power_sprite_->getWidth() - player_sprite_->getWidth()) / 2;
power_sprite_->setPosY(y - (power_sprite_->getHeight() - player_sprite_->getHeight()));
@@ -46,25 +38,21 @@ void Player::init()
pos_x_ = default_pos_x_;
pos_y_ = default_pos_y_;
status_walking_ = PlayerStatus::WALKING_STOP;
status_firing_ = PlayerStatus::FIRING_NO;
status_firing_ = PlayerStatus::FIRING_NONE;
status_playing_ = PlayerStatus::WAITING;
invulnerable_ = true;
invulnerable_counter_ = PLAYER_INVULNERABLE_COUNTER;
invulnerable_counter_ = INVULNERABLE_COUNTER_;
power_up_ = false;
power_up_counter_ = PLAYER_POWERUP_COUNTER;
power_up_counter_ = POWERUP_COUNTER_;
extra_hit_ = false;
coffees_ = 0;
input_ = true;
continue_ticks_ = 0;
continue_counter_ = 10;
enter_name_ticks_ = 0;
enter_name_counter_ = param.game.enter_name_seconds;
width_ = 30;
height_ = 30;
collider_.r = 9;
shiftColliders();
vel_x_ = 0;
vel_y_ = 0;
base_speed_ = 1.5;
score_ = 0;
score_multiplier_ = 1.0f;
cooldown_ = 10;
@@ -107,14 +95,14 @@ void Player::setInputPlaying(InputType input)
{
case InputType::LEFT:
{
vel_x_ = -base_speed_;
vel_x_ = -BASE_SPEED_;
setWalkingStatus(PlayerStatus::WALKING_LEFT);
break;
}
case InputType::RIGHT:
{
vel_x_ = base_speed_;
vel_x_ = BASE_SPEED_;
setWalkingStatus(PlayerStatus::WALKING_RIGHT);
break;
}
@@ -186,7 +174,7 @@ void Player::move()
pos_x_ += vel_x_;
// Si el jugador abandona el area de juego por los laterales
if ((pos_x_ < param.game.play_area.rect.x - 5) || (pos_x_ + width_ > play_area_->w + 5))
if ((pos_x_ < param.game.play_area.rect.x - 5) || (pos_x_ + WIDTH_ > play_area_.w + 5))
{
// Restaura su posición
pos_x_ -= vel_x_;
@@ -203,7 +191,7 @@ void Player::move()
player_sprite_->update();
// Si el cadaver abandona el area de juego por los laterales
if ((player_sprite_->getPosX() < param.game.play_area.rect.x) || (player_sprite_->getPosX() + width_ > play_area_->w))
if ((player_sprite_->getPosX() < param.game.play_area.rect.x) || (player_sprite_->getPosX() + WIDTH_ > play_area_.w))
{
// Restaura su posición
const float vx = player_sprite_->getVelX();
@@ -226,7 +214,7 @@ void Player::render()
{
if (power_up_ && isPlaying())
{
if (power_up_counter_ > (PLAYER_POWERUP_COUNTER / 4) || power_up_counter_ % 20 > 4)
if (power_up_counter_ > (POWERUP_COUNTER_ / 4) || power_up_counter_ % 20 > 4)
{
power_sprite_->render();
}
@@ -261,7 +249,7 @@ void Player::setAnimation()
// Establece la animación a partir de las cadenas
if (isPlaying())
{
if (status_firing_ == PlayerStatus::FIRING_NO)
if (status_firing_ == PlayerStatus::FIRING_NONE)
{ // No esta disparando
player_sprite_->setCurrentAnimation(a_walking);
player_sprite_->setFlip(flip_walk);
@@ -301,13 +289,13 @@ int Player::getPosY() const
// Obtiene el valor de la variable
int Player::getWidth() const
{
return width_;
return WIDTH_;
}
// Obtiene el valor de la variable
int Player::getHeight() const
{
return height_;
return HEIGHT_;
}
// Indica si el jugador puede disparar
@@ -336,7 +324,7 @@ void Player::updateCooldown()
}
else
{
setFiringStatus(PlayerStatus::FIRING_NO);
setFiringStatus(PlayerStatus::FIRING_NONE);
}
}
@@ -459,8 +447,8 @@ void Player::setStatusPlaying(PlayerStatus value)
{
case PlayerStatus::PLAYING:
{
status_playing_ = PlayerStatus::PLAYING;
init();
status_playing_ = PlayerStatus::PLAYING;
setScoreboardMode(ScoreboardMode::SCORE);
break;
}
@@ -556,7 +544,7 @@ bool Player::isInvulnerable() const
void Player::setInvulnerable(bool value)
{
invulnerable_ = value;
invulnerable_counter_ = invulnerable_ ? PLAYER_INVULNERABLE_COUNTER : 0;
invulnerable_counter_ = invulnerable_ ? INVULNERABLE_COUNTER_ : 0;
}
// Obtiene el valor de la variable
@@ -599,7 +587,7 @@ bool Player::isPowerUp() const
void Player::setPowerUp()
{
power_up_ = true;
power_up_counter_ = PLAYER_POWERUP_COUNTER;
power_up_counter_ = POWERUP_COUNTER_;
}
// Obtiene el valor de la variable
@@ -654,18 +642,6 @@ void Player::removeExtraHit()
extra_hit_ = coffees_ == 0 ? false : true;
}
// Habilita la entrada de ordenes
void Player::enableInput()
{
input_ = true;
}
// Deshabilita la entrada de ordenes
void Player::disableInput()
{
input_ = false;
}
// Devuelve el número de cafes actuales
int Player::getCoffees() const
{
@@ -681,8 +657,8 @@ Circle &Player::getCollider()
// Actualiza el circulo de colisión a la posición del jugador
void Player::shiftColliders()
{
collider_.x = int(pos_x_ + (width_ / 2));
collider_.y = int(pos_y_ + (height_ / 2));
collider_.x = static_cast<int>(pos_x_ + (WIDTH_ / 2));
collider_.y = static_cast<int>(pos_y_ + (HEIGHT_ / 2));
}
// Pone las texturas del jugador
@@ -703,9 +679,8 @@ void Player::updateContinueCounter()
{
if (status_playing_ == PlayerStatus::CONTINUE)
{
constexpr Uint32 ticks_speed = 1000;
if (SDL_GetTicks() - continue_ticks_ > ticks_speed)
constexpr int TICKS_SPEED = 1000;
if (SDL_GetTicks() - continue_ticks_ > TICKS_SPEED)
{
decContinueCounter();
}
@@ -717,9 +692,8 @@ void Player::updateEnterNameCounter()
{
if (status_playing_ == PlayerStatus::ENTERING_NAME)
{
constexpr Uint32 ticks_speed = 1000;
if (SDL_GetTicks() - enter_name_ticks_ > ticks_speed)
constexpr int TICKS_SPEED = 1000;
if (SDL_GetTicks() - enter_name_ticks_ > TICKS_SPEED)
{
decEnterNameCounter();
}

71
source/player.h
View File

@@ -23,7 +23,7 @@ enum class PlayerStatus
FIRING_UP,
FIRING_LEFT,
FIRING_RIGHT,
FIRING_NO,
FIRING_NONE,
PLAYING,
CONTINUE,
@@ -35,54 +35,55 @@ enum class PlayerStatus
};
// Variables del jugador
constexpr int PLAYER_INVULNERABLE_COUNTER = 200;
constexpr int PLAYER_POWERUP_COUNTER = 1500;
// Clase Player
class Player
{
private:
// Constantes
static constexpr int POWERUP_COUNTER_ = 1500; // Duración del estado PowerUp
static constexpr int INVULNERABLE_COUNTER_ = 200; // Duración del estado invulnerable
static constexpr int WIDTH_ = 30; // Anchura
static constexpr int HEIGHT_ = 30; // Altura
static constexpr float BASE_SPEED_ = 1.5f; // Velocidad base del jugador
// Objetos y punteros
std::unique_ptr<AnimatedSprite> player_sprite_; // Sprite para dibujar el jugador
std::unique_ptr<AnimatedSprite> power_sprite_; // Sprite para dibujar el aura del jugador con el poder a tope
std::unique_ptr<EnterName> enter_name_; // Clase utilizada para introducir el nombre
SDL_Rect *play_area_; // Rectangulo con la zona de juego
// Variables
int id_; // Numero de identificación para el jugador. Player1 = 1, Player2 = 2
float pos_x_; // Posicion en el eje X
int pos_y_; // Posicion en el eje Y
SDL_Rect play_area_; // Rectangulo con la zona de juego
float pos_x_ = 0.0f; // Posicion en el eje X
int pos_y_ = 0; // Posicion en el eje Y
float default_pos_x_; // Posición inicial para el jugador
int default_pos_y_; // Posición inicial para el jugador
int width_; // Anchura
int height_; // Altura
float vel_x_; // Cantidad de pixeles a desplazarse en el eje X
int vel_y_; // Cantidad de pixeles a desplazarse en el eje Y
float base_speed_; // Velocidad base del jugador
int cooldown_; // Contador durante el cual no puede disparar
int score_; // Puntos del jugador
float score_multiplier_; // Multiplicador de puntos
PlayerStatus status_walking_; // Estado del jugador al moverse
PlayerStatus status_firing_; // Estado del jugador al disparar
PlayerStatus status_playing_; // Estado del jugador en el juego
bool invulnerable_; // Indica si el jugador es invulnerable
int invulnerable_counter_; // Contador para la invulnerabilidad
bool extra_hit_; // Indica si el jugador tiene un toque extra
int coffees_; // Indica cuantos cafes lleva acumulados
bool power_up_; // Indica si el jugador tiene activo el modo PowerUp
int power_up_counter_; // Temporizador para el modo PowerUp
int power_up_desp_x_; // Desplazamiento del sprite de PowerUp respecto al sprite del jugador
bool input_; // Indica si puede recibir ordenes de entrada
Circle collider_; // Circulo de colisión del jugador
int continue_counter_; // Contador para poder continuar
Uint32 continue_ticks_; // Variable para poder cambiar el contador de continue en función del tiempo
int scoreboard_panel_; // Panel del marcador asociado al jugador
float vel_x_ = 0.0f; // Cantidad de pixeles a desplazarse en el eje X
int vel_y_ = 0.0f; // Cantidad de pixeles a desplazarse en el eje Y
int cooldown_ = 10; // Contador durante el cual no puede disparar
int score_ = 0; // Puntos del jugador
float score_multiplier_ = 1.0f; // Multiplicador de puntos
PlayerStatus status_walking_ = PlayerStatus::WALKING_STOP; // Estado del jugador al moverse
PlayerStatus status_firing_ = PlayerStatus::FIRING_NONE; // Estado del jugador al disparar
PlayerStatus status_playing_ = PlayerStatus::WAITING; // Estado del jugador en el juego
bool invulnerable_ = true; // Indica si el jugador es invulnerable
int invulnerable_counter_ = INVULNERABLE_COUNTER_; // Contador para la invulnerabilidad
bool extra_hit_ = false; // Indica si el jugador tiene un toque extra
int coffees_ = 0; // Indica cuantos cafes lleva acumulados
bool power_up_ = false; // Indica si el jugador tiene activo el modo PowerUp
int power_up_counter_ = POWERUP_COUNTER_; // Temporizador para el modo PowerUp
int power_up_desp_x_ = 0; // Desplazamiento del sprite de PowerUp respecto al sprite del jugador
Circle collider_ = Circle(0, 0, 9); // Circulo de colisión del jugador
int continue_counter_ = 10; // Contador para poder continuar
Uint32 continue_ticks_ = 0; // Variable para poder cambiar el contador de continue en función del tiempo
int scoreboard_panel_ = 0; // Panel del marcador asociado al jugador
std::string name_; // Nombre del jugador
std::string record_name_; // Nombre del jugador para la tabla de mejores puntuaciones
int controller_index_; // Indice del array de mandos que utilizará para moverse
int controller_index_ = 0; // Indice del array de mandos que utilizará para moverse
bool demo_; // Para que el jugador sepa si está en el modo demostración
int enter_name_counter_; // Contador para poner nombre
Uint32 enter_name_ticks_; // Variable para poder cambiar el contador de poner nombre en función del tiempo
Uint32 enter_name_ticks_ = 0; // Variable para poder cambiar el contador de poner nombre en función del tiempo
// Actualiza el circulo de colisión a la posición del jugador
void shiftColliders();
@@ -113,7 +114,7 @@ private:
public:
// Constructor
Player(int id, float x, int y, bool demo, SDL_Rect *play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations);
Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations);
// Destructor
~Player() = default;
@@ -256,12 +257,6 @@ public:
// Quita el toque extra al jugador
void removeExtraHit();
// Habilita la entrada de ordenes
void enableInput();
// Deshabilita la entrada de ordenes
void disableInput();
// Devuelve el número de cafes actuales
int getCoffees() const;

4
source/scoreboard.cpp
View File

@@ -98,7 +98,9 @@ std::string Scoreboard::updateScoreText(int num)
// Actualiza el contador
void Scoreboard::updateCounter()
{
if (SDL_GetTicks() - ticks_ > SCOREBOARD_TICK_SPEED_)
constexpr int TICKS_SPEED = 100;
if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
{
ticks_ = SDL_GetTicks();
counter_++;

3
source/scoreboard.h
View File

@@ -42,9 +42,6 @@ struct Panel
class Scoreboard
{
private:
// Constantes
static constexpr int SCOREBOARD_TICK_SPEED_ = 100;
// [SINGLETON] Objeto scoreboard privado para Don Melitón
static Scoreboard *scoreboard_;

5
source/title.cpp
View File

@@ -54,8 +54,9 @@ Title::~Title()
// Actualiza las variables del objeto
void Title::update()
{
// Calcula la lógica de los objetos
if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
constexpr int TICKS_SPEED = 15;
if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
{
// Actualiza el contador de ticks_
ticks_ = SDL_GetTicks();

3
source/title.h
View File

@@ -43,9 +43,6 @@ constexpr bool ALLOW_TITLE_ANIMATION_SKIP = true;
class Title
{
private:
// Constantes
static constexpr Uint32 TICKS_SPEED_ = 15; // Velocidad a la que se repiten los bucles del programa
// Objetos y punteros
std::unique_ptr<Text> text1_; // Objeto de texto para poder escribir textos en pantalla
std::unique_ptr<Text> text2_; // Objeto de texto para poder escribir textos en pantalla

9
source/utils.cpp
View File

@@ -274,8 +274,15 @@ bool saveDemoFile(const std::string &file_path, const DemoData &dd)
}
#endif // RECORDING
// Obtiene el nombre de un fichero a partir de una ruta
// Obtiene el nombre de un fichero a partir de una ruta completa
std::string getFileName(const std::string &path)
{
return std::filesystem::path(path).filename().string();
}
// Obtiene la ruta eliminando el nombre del fichero
std::string getPath(const std::string &full_path)
{
std::filesystem::path path(full_path);
return path.parent_path().string();
}

10
source/utils.h
View File

@@ -47,6 +47,13 @@ extern Overrides overrides;
struct Circle
{
int x, y, r;
// Constructor por defecto
Circle() : x(0), y(0), r(0) {}
// Constructor
Circle(int xCoord, int yCoord, int radius)
: x(xCoord), y(yCoord), r(radius) {}
};
// Estructura para definir un color
@@ -319,6 +326,9 @@ bool saveDemoFile(const std::string &file_path, const DemoData &dd);
// Obtiene el nombre de un fichero a partir de una ruta
std::string getFileName(const std::string &path);
// Obtiene la ruta eliminando el nombre del fichero
std::string getPath(const std::string &full_path);
// Colores
extern const Color bg_color;
extern const Color no_color;