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

reestructuració

Browse Source
This commit is contained in:
Sergio
2026-04-17 17:15:38 +02:00
parent 55caef3210
commit 5fec0110b3
66 changed files with 221 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
source/game/defaults.hpp Normal file
View File

@@ -0,0 +1,61 @@
#pragma once
#include <SDL3/SDL.h>
#include "core/locale/lang.h"
#include "utils/utils.h"
// Tamaño de bloque
constexpr int BLOCK = 8;
constexpr int HALF_BLOCK = BLOCK / 2;
// Tamaño de la pantalla virtual
constexpr int GAMECANVAS_WIDTH = 256;
constexpr int GAMECANVAS_HEIGHT = 192;
// Zona de juego
constexpr int PLAY_AREA_TOP = (0 * BLOCK);
constexpr int PLAY_AREA_BOTTOM = GAMECANVAS_HEIGHT - (4 * BLOCK);
constexpr int PLAY_AREA_LEFT = (0 * BLOCK);
constexpr int PLAY_AREA_RIGHT = GAMECANVAS_WIDTH - (0 * BLOCK);
constexpr int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT;
constexpr int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP;
constexpr int PLAY_AREA_CENTER_X = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2);
constexpr int PLAY_AREA_CENTER_FIRST_QUARTER_X = (PLAY_AREA_WIDTH / 4);
constexpr int PLAY_AREA_CENTER_THIRD_QUARTER_X = (PLAY_AREA_WIDTH / 4) * 3;
constexpr int PLAY_AREA_CENTER_Y = PLAY_AREA_TOP + (PLAY_AREA_HEIGHT / 2);
constexpr int PLAY_AREA_FIRST_QUARTER_Y = PLAY_AREA_HEIGHT / 4;
constexpr int PLAY_AREA_THIRD_QUARTER_Y = (PLAY_AREA_HEIGHT / 4) * 3;
// Anclajes de pantalla
constexpr int GAMECANVAS_CENTER_X = GAMECANVAS_WIDTH / 2;
constexpr int GAMECANVAS_FIRST_QUARTER_X = GAMECANVAS_WIDTH / 4;
constexpr int GAMECANVAS_THIRD_QUARTER_X = (GAMECANVAS_WIDTH / 4) * 3;
constexpr int GAMECANVAS_CENTER_Y = GAMECANVAS_HEIGHT / 2;
constexpr int GAMECANVAS_FIRST_QUARTER_Y = GAMECANVAS_HEIGHT / 4;
constexpr int GAMECANVAS_THIRD_QUARTER_Y = (GAMECANVAS_HEIGHT / 4) * 3;
// Secciones del programa
constexpr int SECTION_PROG_LOGO = 0;
constexpr int SECTION_PROG_INTRO = 1;
constexpr int SECTION_PROG_TITLE = 2;
constexpr int SECTION_PROG_GAME = 3;
constexpr int SECTION_PROG_QUIT = 4;
// Subsecciones
constexpr int SUBSECTION_GAME_PLAY_1P = 0;
constexpr int SUBSECTION_GAME_PLAY_2P = 1;
constexpr int SUBSECTION_GAME_PAUSE = 2;
constexpr int SUBSECTION_GAME_GAMEOVER = 3;
constexpr int SUBSECTION_TITLE_1 = 3;
constexpr int SUBSECTION_TITLE_2 = 4;
constexpr int SUBSECTION_TITLE_3 = 5;
constexpr int SUBSECTION_TITLE_INSTRUCTIONS = 6;
// Ningun tipo
constexpr int NO_KIND = 0;
// Colores
const color_t bgColor = {0x27, 0x27, 0x36};
const color_t noColor = {0xFF, 0xFF, 0xFF};
const color_t shdwTxtColor = {0x43, 0x43, 0x4F};

781
source/game/entities/balloon.cpp Normal file
View File

@@ -0,0 +1,781 @@
#include "game/entities/balloon.h"
#include <math.h> // for abs
#include "core/rendering/animatedsprite.h" // for AnimatedSprite
#include "core/rendering/movingsprite.h" // for MovingSprite
#include "core/rendering/sprite.h" // for Sprite
#include "core/rendering/texture.h" // for Texture
#include "game/defaults.hpp" // for PLAY_AREA_LEFT, PLAY_AREA_RIGHT, PLAY_AR...
// Constructor
Balloon::Balloon(float x, float y, Uint8 kind, float velx, float speed, Uint16 creationtimer, Texture *texture, std::vector<std::string> *animation, SDL_Renderer *renderer) {
sprite = new AnimatedSprite(texture, renderer, "", animation);
disable();
enabled = true;
switch (kind) {
case BALLOON_1:
// Alto y ancho del objeto
width = BALLOON_WIDTH_1;
height = BALLOON_WIDTH_1;
size = BALLOON_SIZE_1;
power = 1;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = 0;
maxVelY = 3.0f;
gravity = 0.09f;
defaultVelY = 2.6f;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_1;
// Amenaza que genera el globo
menace = 1;
break;
case BALLOON_2:
// Alto y ancho del objeto
width = BALLOON_WIDTH_2;
height = BALLOON_WIDTH_2;
size = BALLOON_SIZE_2;
power = 3;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = 0;
maxVelY = 3.0f;
gravity = 0.10f;
defaultVelY = 3.5f;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_2;
// Amenaza que genera el globo
menace = 2;
break;
case BALLOON_3:
// Alto y ancho del objeto
width = BALLOON_WIDTH_3;
height = BALLOON_WIDTH_3;
size = BALLOON_SIZE_3;
power = 7;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = 0;
maxVelY = 3.0f;
gravity = 0.10f;
defaultVelY = 4.50f;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_3;
// Amenaza que genera el globo
menace = 4;
break;
case BALLOON_4:
// Alto y ancho del objeto
width = BALLOON_WIDTH_4;
height = BALLOON_WIDTH_4;
size = BALLOON_SIZE_4;
power = 15;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = 0;
maxVelY = 3.0f;
gravity = 0.10f;
defaultVelY = 4.95f;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_4;
// Amenaza que genera el globo
menace = 8;
break;
case HEXAGON_1:
// Alto y ancho del objeto
width = BALLOON_WIDTH_1;
height = BALLOON_WIDTH_1;
size = BALLOON_SIZE_1;
power = 1;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = abs(velx) * 2;
maxVelY = abs(velx) * 2;
gravity = 0.00f;
defaultVelY = abs(velx) * 2;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_1;
// Amenaza que genera el globo
menace = 1;
break;
case HEXAGON_2:
// Alto y ancho del objeto
width = BALLOON_WIDTH_2;
height = BALLOON_WIDTH_2;
size = BALLOON_SIZE_2;
power = 3;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = abs(velx) * 2;
maxVelY = abs(velx) * 2;
gravity = 0.00f;
defaultVelY = abs(velx) * 2;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_2;
// Amenaza que genera el globo
menace = 2;
break;
case HEXAGON_3:
// Alto y ancho del objeto
width = BALLOON_WIDTH_3;
height = BALLOON_WIDTH_3;
size = BALLOON_SIZE_3;
power = 7;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = abs(velx) * 2;
maxVelY = abs(velx) * 2;
gravity = 0.00f;
defaultVelY = abs(velx) * 2;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_3;
// Amenaza que genera el globo
menace = 4;
break;
case HEXAGON_4:
// Alto y ancho del objeto
width = BALLOON_WIDTH_4;
height = BALLOON_WIDTH_4;
size = BALLOON_SIZE_4;
power = 15;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = abs(velx) * 2;
maxVelY = abs(velx) * 2;
gravity = 0.00f;
defaultVelY = abs(velx) * 2;
// Puntos que da el globo al ser destruido
score = BALLOON_SCORE_4;
// Amenaza que genera el globo
menace = 8;
break;
case POWER_BALL:
// Alto y ancho del objeto
width = BALLOON_WIDTH_4;
height = BALLOON_WIDTH_4;
size = 4;
power = 0;
// Inicializa los valores de velocidad y gravedad
this->velX = velx;
velY = 0;
maxVelY = 3.0f;
gravity = 0.10f;
defaultVelY = 4.95f;
// Puntos que da el globo al ser destruido
score = 0;
// Amenaza que genera el globo
menace = 0;
// Añade rotación al sprite
sprite->setRotate(false);
sprite->setRotateSpeed(0);
if (velX > 0.0f) {
sprite->setRotateAmount(2.0);
} else {
sprite->setRotateAmount(-2.0);
}
break;
default:
break;
}
// Posición inicial
posX = x;
posY = y;
// 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};
// Alto y ancho del sprite
sprite->setWidth(width);
sprite->setHeight(height);
// Posición X,Y del sprite
sprite->setPosX((int)posX);
sprite->setPosY((int)posY);
// Tamaño del circulo de colisión
collider.r = width / 2;
// Alinea el circulo de colisión con el objeto
updateColliders();
// Inicializa variables
stopped = true;
stoppedCounter = 0;
blinking = false;
visible = true;
invulnerable = true;
beingCreated = true;
creationCounter = creationtimer;
creationCounterIni = creationtimer;
popping = false;
// Actualiza valores
beingCreated = creationCounter == 0 ? false : true;
invulnerable = beingCreated == false ? false : true;
counter = 0;
travelY = 1.0f;
this->speed = speed;
// Tipo
this->kind = kind;
}
// Destructor
Balloon::~Balloon() {
delete sprite;
}
// Centra el globo en la posición X
void Balloon::allignTo(int x) {
posX = float(x - (width / 2));
if (posX < PLAY_AREA_LEFT)
posX = PLAY_AREA_LEFT + 1;
else if ((posX + width) > PLAY_AREA_RIGHT)
posX = float(PLAY_AREA_RIGHT - width - 1);
// Posición X,Y del sprite
sprite->setPosX(getPosX());
sprite->setPosY(getPosY());
// Alinea el circulo de colisión con el objeto
updateColliders();
}
// Pinta el globo en la pantalla
void Balloon::render() {
if ((visible) && (enabled)) {
if (bouncing.enabled) {
if (kind != POWER_BALL) {
// Aplica desplazamiento para el zoom
sprite->setPosX(getPosX() + bouncing.despX);
sprite->setPosY(getPosY() + bouncing.despY);
sprite->render();
sprite->setPosX(getPosX() - bouncing.despX);
sprite->setPosY(getPosY() - bouncing.despY);
}
} else if (isBeingCreated()) {
// Aplica alpha blending
sprite->getTexture()->setAlpha(255 - (int)((float)creationCounter * (255.0f / (float)creationCounterIni)));
sprite->render();
if (kind == POWER_BALL) {
Sprite *sp = new Sprite(sprite->getRect(), sprite->getTexture(), sprite->getRenderer());
sp->setSpriteClip(407, 0, 37, 37);
sp->render();
delete sp;
}
sprite->getTexture()->setAlpha(255);
} else {
sprite->render();
if (kind == POWER_BALL and !popping) {
Sprite *sp = new Sprite(sprite->getRect(), sprite->getTexture(), sprite->getRenderer());
sp->setSpriteClip(407, 0, 37, 37);
sp->render();
delete sp;
}
}
}
}
// Actualiza la posición y estados del globo
void Balloon::move() {
// Comprueba si se puede mover
if (!isStopped()) {
// Lo mueve a izquierda o derecha
posX += (velX * speed);
// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
if ((posX < PLAY_AREA_LEFT) || (posX + width > PLAY_AREA_RIGHT)) {
// Corrige posición
posX -= (velX * speed);
// Invierte sentido
velX = -velX;
// Invierte la rotación
sprite->switchRotate();
// Activa el efecto de rebote
if (kind != POWER_BALL) {
bounceStart();
}
}
// Mueve el globo hacia arriba o hacia abajo
posY += (velY * speed);
// Si se sale por arriba
if (posY < PLAY_AREA_TOP) {
// Corrige
posY = PLAY_AREA_TOP;
// Invierte sentido
velY = -velY;
// Activa el efecto de rebote
if (kind != POWER_BALL) {
bounceStart();
}
}
// Si el globo se sale por la parte inferior
if (posY + height > PLAY_AREA_BOTTOM) {
// Corrige
posY = PLAY_AREA_BOTTOM - height;
// Invierte colocando una velocidad por defecto
velY = -defaultVelY;
// Activa el efecto de rebote
if (kind != POWER_BALL) {
bounceStart();
}
}
/*
Para aplicar la gravedad, el diseño original la aplicaba en cada iteración del bucle
Al añadir el modificador de velocidad se reduce la distancia que recorre el objeto y por
tanto recibe mas gravedad. Para solucionarlo se va a aplicar la gravedad cuando se haya
recorrido una distancia igual a la velocidad en Y, que era el cálculo inicial
*/
// Incrementa la variable que calcula la distancia acumulada en Y
travelY += speed;
// Si la distancia acumulada en Y es igual a la velocidad, se aplica la gravedad
if (travelY >= 1.0f) {
// Quita el excedente
travelY -= 1.0f;
// Aplica la gravedad al objeto sin pasarse de una velocidad máxima
velY += gravity;
// Al parecer esta asignación se quedó sin hacer y ahora el juego no funciona
// correctamente si se aplica, así que se deja sin efecto
// velY = std::min(velY, maxVelY);
}
// Actualiza la posición del sprite
sprite->setPosX(getPosX());
sprite->setPosY(getPosY());
}
}
// Deshabilita el globo y pone a cero todos los valores
void Balloon::disable() {
beingCreated = false;
blinking = false;
collider.r = 0;
collider.x = 0;
collider.y = 0;
counter = 0;
creationCounter = 0;
creationCounterIni = 0;
defaultVelY = 0.0f;
enabled = false;
gravity = 0.0f;
height = 0;
invulnerable = false;
kind = 0;
maxVelY = 0.0f;
menace = 0;
popping = false;
posX = 0.0f;
posY = 0.0f;
power = 0;
score = 0;
size = 0;
speed = 0;
stopped = false;
stoppedCounter = 0;
travelY = 0;
velX = 0.0f;
velY = 0.0f;
visible = false;
width = 0;
sprite->clear();
}
// Explosiona el globo
void Balloon::pop() {
setPopping(true);
sprite->disableRotate();
setStop(true);
setStoppedTimer(2000);
setInvulnerable(true);
menace = 0;
}
// Actualiza al globo a su posicion, animación y controla los contadores
void Balloon::update() {
if (enabled) {
sprite->MovingSprite::update();
move();
updateAnimation();
updateColliders();
updateState();
updateBounce();
counter++;
}
}
// Actualiza los estados del globo
void Balloon::updateState() {
// Si está explotando
if (isPopping()) {
setInvulnerable(true);
setStop(true);
if (sprite->animationIsCompleted()) {
disable();
}
}
// Si se está creando
if (isBeingCreated()) {
// Actualiza el valor de las variables
setStop(true);
setInvulnerable(true);
// Todavia tiene tiempo en el contador
if (creationCounter > 0) {
// Desplaza lentamente el globo hacia abajo y hacia un lado
if (creationCounter % 10 == 0) {
posY++;
posX += velX;
// Comprueba no se salga por los laterales
if ((posX < PLAY_AREA_LEFT) || (posX > (PLAY_AREA_RIGHT - width))) {
// Corrige y cambia el sentido de la velocidad
posX -= velX;
velX = -velX;
}
// Actualiza la posición del sprite
sprite->setPosX(getPosX());
sprite->setPosY(getPosY());
// Actualiza la posición del circulo de colisión
updateColliders();
}
creationCounter--;
}
// El contador ha llegado a cero
else {
setBeingCreated(false);
setStop(false);
setVisible(true);
setInvulnerable(false);
if (kind == POWER_BALL) {
sprite->setRotate(true);
}
}
}
// Solo comprueba el estado detenido cuando no se está creando
else if (isStopped()) {
// Si es una powerball deja de rodar
if (kind == POWER_BALL) {
sprite->setRotate(false);
}
// Reduce el contador
if (stoppedCounter > 0) {
stoppedCounter--;
}
// Quitarles el estado "detenido" si no estan explosionando
else if (!isPopping()) {
// Si es una powerball vuelve a rodar
if (kind == POWER_BALL) {
sprite->setRotate(true);
}
setStop(false);
}
}
}
// Establece la animación correspondiente al estado
void Balloon::updateAnimation() {
std::string creatingAnimation = "blue";
std::string normalAnimation = "orange";
if (kind == POWER_BALL) {
creatingAnimation = "powerball";
normalAnimation = "powerball";
} else if (getClass() == HEXAGON_CLASS) {
creatingAnimation = "red";
normalAnimation = "green";
}
// Establece el frame de animación
if (isPopping()) {
sprite->setCurrentAnimation("pop");
} else if (isBeingCreated()) {
sprite->setCurrentAnimation(creatingAnimation);
} else {
sprite->setCurrentAnimation(normalAnimation);
}
sprite->animate();
}
// Comprueba si el globo está habilitado
bool Balloon::isEnabled() {
return enabled;
}
// Obtiene del valor de la variable
float Balloon::getPosX() {
return posX;
}
// Obtiene del valor de la variable
float Balloon::getPosY() {
return posY;
}
// Obtiene del valor de la variable
float Balloon::getVelY() {
return velY;
}
// Obtiene del valor de la variable
int Balloon::getWidth() {
return width;
}
// Obtiene del valor de la variable
int Balloon::getHeight() {
return height;
}
// Establece el valor de la variable
void Balloon::setVelY(float velY) {
this->velY = velY;
}
// Establece el valor de la variable
void Balloon::setSpeed(float speed) {
this->speed = speed;
}
// Obtiene del valor de la variable
int Balloon::getKind() {
return kind;
}
// Obtiene del valor de la variable
Uint8 Balloon::getSize() {
return size;
}
// Obtiene la clase a la que pertenece el globo
Uint8 Balloon::getClass() {
if ((kind >= BALLOON_1) && (kind <= BALLOON_4)) {
return BALLOON_CLASS;
}
else if ((kind >= HEXAGON_1) && (kind <= HEXAGON_4)) {
return HEXAGON_CLASS;
}
return BALLOON_CLASS;
}
// Establece el valor de la variable
void Balloon::setStop(bool state) {
stopped = state;
}
// Obtiene del valor de la variable
bool Balloon::isStopped() {
return stopped;
}
// Establece el valor de la variable
void Balloon::setBlink(bool value) {
blinking = value;
}
// Obtiene del valor de la variable
bool Balloon::isBlinking() {
return blinking;
}
// Establece el valor de la variable
void Balloon::setVisible(bool value) {
visible = value;
}
// Obtiene del valor de la variable
bool Balloon::isVisible() {
return visible;
}
// Establece el valor de la variable
void Balloon::setInvulnerable(bool value) {
invulnerable = value;
}
// Obtiene del valor de la variable
bool Balloon::isInvulnerable() {
return invulnerable;
}
// Establece el valor de la variable
void Balloon::setBeingCreated(bool value) {
beingCreated = value;
}
// Obtiene del valor de la variable
bool Balloon::isBeingCreated() {
return beingCreated;
}
// Establece el valor de la variable
void Balloon::setPopping(bool value) {
popping = value;
}
// Obtiene del valor de la variable
bool Balloon::isPopping() {
return popping;
}
// Establece el valor de la variable
void Balloon::setStoppedTimer(Uint16 time) {
stoppedCounter = time;
}
// Obtiene del valor de la variable
Uint16 Balloon::getStoppedTimer() {
return stoppedCounter;
}
// Obtiene del valor de la variable
Uint16 Balloon::getScore() {
return score;
}
// Obtiene el circulo de colisión
circle_t &Balloon::getCollider() {
return collider;
}
// Alinea el circulo de colisión con la posición del objeto globo
void Balloon::updateColliders() {
collider.x = Uint16(posX + collider.r);
collider.y = posY + collider.r;
}
// Obtiene le valor de la variable
Uint8 Balloon::getMenace() {
if (isEnabled()) {
return menace;
} else {
return 0;
}
}
// Obtiene le valor de la variable
Uint8 Balloon::getPower() {
return power;
}
void Balloon::bounceStart() {
bouncing.enabled = true;
bouncing.zoomW = 1;
bouncing.zoomH = 1;
sprite->setZoomW(bouncing.zoomW);
sprite->setZoomH(bouncing.zoomH);
bouncing.despX = 0;
bouncing.despY = 0;
}
void Balloon::bounceStop() {
bouncing.enabled = false;
bouncing.counter = 0;
bouncing.zoomW = 1.0f;
bouncing.zoomH = 1.0f;
sprite->setZoomW(bouncing.zoomW);
sprite->setZoomH(bouncing.zoomH);
bouncing.despX = 0.0f;
bouncing.despY = 0.0f;
}
void Balloon::updateBounce() {
if (bouncing.enabled) {
bouncing.zoomW = bouncing.w[bouncing.counter / bouncing.speed];
bouncing.zoomH = bouncing.h[bouncing.counter / bouncing.speed];
sprite->setZoomW(bouncing.zoomW);
sprite->setZoomH(bouncing.zoomH);
bouncing.despX = (sprite->getSpriteClip().w - (sprite->getSpriteClip().w * bouncing.zoomW));
bouncing.despY = (sprite->getSpriteClip().h - (sprite->getSpriteClip().h * bouncing.zoomH));
bouncing.counter++;
if ((bouncing.counter / bouncing.speed) > (MAX_BOUNCE - 1)) {
bounceStop();
}
}
}

250
source/game/entities/balloon.h Normal file
View File

@@ -0,0 +1,250 @@
#pragma once
#include <SDL3/SDL.h>
#include <string> // for string
#include <vector> // for vector
#include "utils/utils.h" // for circle_t
class AnimatedSprite;
class Texture;
// Cantidad de elementos del vector con los valores de la deformación del globo al rebotar
constexpr int MAX_BOUNCE = 10;
// Tipos de globo
constexpr int BALLOON_1 = 1;
constexpr int BALLOON_2 = 2;
constexpr int BALLOON_3 = 3;
constexpr int BALLOON_4 = 4;
constexpr int HEXAGON_1 = 5;
constexpr int HEXAGON_2 = 6;
constexpr int HEXAGON_3 = 7;
constexpr int HEXAGON_4 = 8;
constexpr int POWER_BALL = 9;
// Puntos de globo
constexpr int BALLOON_SCORE_1 = 50;
constexpr int BALLOON_SCORE_2 = 100;
constexpr int BALLOON_SCORE_3 = 200;
constexpr int BALLOON_SCORE_4 = 400;
// Tamaños de globo
constexpr int BALLOON_SIZE_1 = 1;
constexpr int BALLOON_SIZE_2 = 2;
constexpr int BALLOON_SIZE_3 = 3;
constexpr int BALLOON_SIZE_4 = 4;
// Clases de globo
constexpr int BALLOON_CLASS = 0;
constexpr int HEXAGON_CLASS = 1;
// Velocidad del globo
constexpr float BALLOON_VELX_POSITIVE = 0.7f;
constexpr float BALLOON_VELX_NEGATIVE = -0.7f;
// Índice para las animaciones de los globos
constexpr int BALLOON_MOVING_ANIMATION = 0;
constexpr int BALLOON_POP_ANIMATION = 1;
constexpr int BALLOON_BORN_ANIMATION = 2;
// Cantidad posible de globos
constexpr int MAX_BALLOONS = 100;
// Velocidades a las que se mueven los globos
constexpr float BALLOON_SPEED_1 = 0.60f;
constexpr float BALLOON_SPEED_2 = 0.70f;
constexpr float BALLOON_SPEED_3 = 0.80f;
constexpr float BALLOON_SPEED_4 = 0.90f;
constexpr float BALLOON_SPEED_5 = 1.00f;
// Tamaño de los globos
constexpr int BALLOON_WIDTH_1 = 8;
constexpr int BALLOON_WIDTH_2 = 13;
constexpr int BALLOON_WIDTH_3 = 21;
constexpr int BALLOON_WIDTH_4 = 37;
// PowerBall
constexpr int POWERBALL_SCREENPOWER_MINIMUM = 10;
constexpr int POWERBALL_COUNTER = 8;
// Clase Balloon
class Balloon {
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
};
// Objetos y punteros
AnimatedSprite *sprite; // Sprite del objeto globo
// Variables
float posX; // Posición en el eje X
float posY; // Posición en el eje Y
Uint8 width; // Ancho
Uint8 height; // Alto
float velX; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
float velY; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
float gravity; // Aceleración en el eje Y. Modifica la velocidad
float defaultVelY; // Velocidad inicial que tienen al rebotar contra el suelo
float maxVelY; // Máxima velocidad que puede alcanzar el objeto en el eje Y
bool beingCreated; // Indica si el globo se está creando
bool blinking; // Indica si el globo está intermitente
bool enabled; // Indica si el globo esta activo
bool invulnerable; // Indica si el globo es invulnerable
bool popping; // Indica si el globo está explotando
bool stopped; // Indica si el globo está parado
bool visible; // Indica si el globo es visible
circle_t collider; // Circulo de colisión del objeto
Uint16 creationCounter; // Temporizador para controlar el estado "creandose"
Uint16 creationCounterIni; // Valor inicial para el temporizador para controlar el estado "creandose"
Uint16 score; // Puntos que da el globo al ser destruido
Uint16 stoppedCounter; // 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 travelY; // 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
// Alinea el circulo de colisión con la posición del objeto globo
void updateColliders();
// Activa el efecto
void bounceStart();
// Detiene el efecto
void bounceStop();
// Aplica el efecto
void updateBounce();
// Actualiza los estados del globo
void updateState();
// Establece la animación correspondiente
void updateAnimation();
// Establece el valor de la variable
void setBeingCreated(bool value);
public:
// Constructor
Balloon(float x, float y, Uint8 kind, float velx, float speed, Uint16 creationtimer, Texture *texture, std::vector<std::string> *animation, SDL_Renderer *renderer);
// Destructor
~Balloon();
// Centra el globo en la posición X
void allignTo(int x);
// Pinta el globo en la pantalla
void render();
// Actualiza la posición y estados del globo
void move();
// Deshabilita el globo y pone a cero todos los valores
void disable();
// Explosiona el globo
void pop();
// Actualiza al globo a su posicion, animación y controla los contadores
void update();
// Comprueba si el globo está habilitado
bool isEnabled();
// Obtiene del valor de la variable
float getPosX();
// Obtiene del valor de la variable
float getPosY();
// Obtiene del valor de la variable
float getVelY();
// Obtiene del valor de la variable
int getWidth();
// Obtiene del valor de la variable
int getHeight();
// Establece el valor de la variable
void setVelY(float velY);
// Establece el valor de la variable
void setSpeed(float speed);
// Obtiene del valor de la variable
int getKind();
// Obtiene del valor de la variable
Uint8 getSize();
// Obtiene la clase a la que pertenece el globo
Uint8 getClass();
// Establece el valor de la variable
void setStop(bool value);
// Obtiene del valor de la variable
bool isStopped();
// Establece el valor de la variable
void setBlink(bool value);
// Obtiene del valor de la variable
bool isBlinking();
// Establece el valor de la variable
void setVisible(bool value);
// Obtiene del valor de la variable
bool isVisible();
// Establece el valor de la variable
void setInvulnerable(bool value);
// Obtiene del valor de la variable
bool isInvulnerable();
// Obtiene del valor de la variable
bool isBeingCreated();
// Establece el valor de la variable
void setPopping(bool value);
// Obtiene del valor de la variable
bool isPopping();
// Establece el valor de la variable
void setStoppedTimer(Uint16 time);
// Obtiene del valor de la variable
Uint16 getStoppedTimer();
// Obtiene del valor de la variable
Uint16 getScore();
// Obtiene el circulo de colisión
circle_t &getCollider();
// Obtiene le valor de la variable
Uint8 getMenace();
// Obtiene le valor de la variable
Uint8 getPower();
};

184
source/game/entities/bullet.cpp Normal file
View File

@@ -0,0 +1,184 @@
#include "game/entities/bullet.h"
#include "core/rendering/sprite.h" // for Sprite
#include "game/defaults.hpp" // for NO_KIND, PLAY_AREA_LEFT, PLAY_AREA_RIGHT, PLAY_A...
class Texture;
// Constructor
Bullet::Bullet(int x, int y, int kind, bool poweredUp, int owner, Texture *texture, SDL_Renderer *renderer) {
sprite = new Sprite({x, y, 10, 10}, texture, renderer);
// Posición inicial del objeto
posX = x;
posY = y;
// Alto y ancho del objeto
width = 10;
height = 10;
// Velocidad inicial en el eje Y
velY = -3;
// Tipo de bala
this->kind = kind;
// Identificador del dueño del objeto
this->owner = owner;
// Valores especificos según el tipo
switch (kind) {
case BULLET_UP:
// Establece la velocidad inicial
velX = 0;
// Rectangulo con los gráficos del objeto
if (!poweredUp) {
sprite->setSpriteClip(0 * width, 0, sprite->getWidth(), sprite->getHeight());
} else {
sprite->setSpriteClip((0 + 3) * width, 0, sprite->getWidth(), sprite->getHeight());
}
break;
case BULLET_LEFT:
// Establece la velocidad inicial
velX = -2;
// Rectangulo con los gráficos del objeto
if (!poweredUp) {
sprite->setSpriteClip(1 * width, 0, sprite->getWidth(), sprite->getHeight());
} else {
sprite->setSpriteClip((1 + 3) * width, 0, sprite->getWidth(), sprite->getHeight());
}
break;
case BULLET_RIGHT:
// Establece la velocidad inicial
velX = 2;
// Rectangulo con los gráficos del objeto
if (!poweredUp) {
sprite->setSpriteClip(2 * width, 0, sprite->getWidth(), sprite->getHeight());
} else {
sprite->setSpriteClip((2 + 3) * width, 0, sprite->getWidth(), sprite->getHeight());
}
break;
default:
break;
}
// Establece el tamaño del circulo de colisión
collider.r = width / 2;
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
// Destructor
Bullet::~Bullet() {
delete sprite;
}
// Pinta el objeto en pantalla
void Bullet::render() {
sprite->render();
}
// Actualiza la posición y estado del objeto en horizontal
Uint8 Bullet::move() {
// Variable con el valor de retorno
Uint8 msg = BULLET_MOVE_OK;
// Mueve el objeto a su nueva posición
posX += velX;
// Si el objeto se sale del area de juego por los laterales
if ((posX < PLAY_AREA_LEFT - width) || (posX > PLAY_AREA_RIGHT)) {
// Se deshabilita
kind = NO_KIND;
// Mensaje de salida
msg = BULLET_MOVE_OUT;
}
// Mueve el objeto a su nueva posición en vertical
posY += int(velY);
// Si el objeto se sale del area de juego por la parte superior
if (posY < PLAY_AREA_TOP - height) {
// Se deshabilita
kind = NO_KIND;
// Mensaje de salida
msg = BULLET_MOVE_OUT;
}
// Actualiza la posición del sprite
sprite->setPosX(posX);
sprite->setPosY(posY);
// Alinea el circulo de colisión con el objeto
shiftColliders();
return msg;
}
// Comprueba si el objeto está habilitado
bool Bullet::isEnabled() {
if (kind == NO_KIND) {
return false;
} else {
return true;
}
}
// Deshabilita el objeto
void Bullet::disable() {
kind = NO_KIND;
}
// Obtiene el valor de la variable
int Bullet::getPosX() {
return posX;
}
// Obtiene el valor de la variable
int Bullet::getPosY() {
return posY;
}
// Establece el valor de la variable
void Bullet::setPosX(int x) {
posX = x;
}
// Establece el valor de la variable
void Bullet::setPosY(int y) {
posY = y;
}
// Obtiene el valor de la variable
int Bullet::getVelY() {
return velY;
}
// Obtiene el valor de la variable
int Bullet::getKind() {
return kind;
}
// Obtiene el valor de la variable
int Bullet::getOwner() {
return owner;
}
// Obtiene el circulo de colisión
circle_t &Bullet::getCollider() {
return collider;
}
// Alinea el circulo de colisión con el objeto
void Bullet::shiftColliders() {
collider.x = posX + collider.r;
collider.y = posY + collider.r;
}

80
source/game/entities/bullet.h Normal file
View File

@@ -0,0 +1,80 @@
#pragma once
#include <SDL3/SDL.h>
#include "utils/utils.h" // for circle_t
class Sprite;
class Texture;
// Tipos de bala
constexpr int BULLET_UP = 1;
constexpr int BULLET_LEFT = 2;
constexpr int BULLET_RIGHT = 3;
// Tipos de retorno de la función move de la bala
constexpr int BULLET_MOVE_OK = 0;
constexpr int BULLET_MOVE_OUT = 1;
// Clase Bullet
class Bullet {
private:
// Objetos y punteros
Sprite *sprite; // Sprite con los graficos y métodos de pintado
// Variables
int posX; // Posición en el eje X
int posY; // Posición en el eje Y
Uint8 width; // Ancho del objeto
Uint8 height; // Alto del objeto
int velX; // Velocidad en el eje X
int velY; // Velocidad en el eje Y
int kind; // Tipo de objeto
int owner; // Identificador del dueño del objeto
circle_t collider; // Circulo de colisión del objeto
// Alinea el circulo de colisión con el objeto
void shiftColliders();
public:
// Constructor
Bullet(int x, int y, int kind, bool poweredUp, int owner, Texture *texture, SDL_Renderer *renderer);
// Destructor
~Bullet();
// Pinta el objeto en pantalla
void render();
// Actualiza la posición y estado del objeto
Uint8 move();
// Comprueba si el objeto está habilitado
bool isEnabled();
// Deshabilita el objeto
void disable();
// Obtiene el valor de la variable
int getPosX();
// Obtiene el valor de la variable
int getPosY();
// Establece el valor de la variable
void setPosX(int x);
// Establece el valor de la variable
void setPosY(int y);
// Obtiene el valor de la variable
int getVelY();
// Obtiene el valor de la variable
int getKind();
// Obtiene el valor de la variable
int getOwner();
// Obtiene el circulo de colisión
circle_t &getCollider();
};

200
source/game/entities/item.cpp Normal file
View File

@@ -0,0 +1,200 @@
#include "game/entities/item.h"
#include <stdlib.h> // for rand
#include "core/rendering/animatedsprite.h" // for AnimatedSprite
#include "game/defaults.hpp" // for PLAY_AREA_LEFT, PLAY_AREA_RIGHT, PLAY_AR...
class Texture;
// Constructor
Item::Item(Uint8 kind, float x, float y, Texture *texture, std::vector<std::string> *animation, SDL_Renderer *renderer) {
sprite = new AnimatedSprite(texture, renderer, "", animation);
this->kind = kind;
enabled = true;
timeToLive = 600;
accelX = 0.0f;
floorCollision = false;
if (kind == ITEM_COFFEE_MACHINE) {
width = 23;
height = 29;
posX = (((int)x + (PLAY_AREA_WIDTH / 2)) % (PLAY_AREA_WIDTH - width - 5)) + 2;
posY = PLAY_AREA_TOP - height;
velX = 0.0f;
velY = -0.1f;
accelY = 0.1f;
collider.r = 10;
} else {
width = 16;
height = 16;
posX = x;
posY = y;
velX = -1.0f + ((rand() % 5) * 0.5f);
velY = -4.0f;
accelY = 0.2f;
collider.r = width / 2;
}
sprite->setPosX(posX);
sprite->setPosY(posY);
shiftColliders();
}
// Destructor
Item::~Item() {
delete sprite;
}
// Centra el objeto en la posición X
void Item::allignTo(int x) {
posX = float(x - (width / 2));
if (posX < PLAY_AREA_LEFT) {
posX = PLAY_AREA_LEFT + 1;
} else if ((posX + width) > PLAY_AREA_RIGHT) {
posX = float(PLAY_AREA_RIGHT - width - 1);
}
// Posición X,Y del sprite
sprite->setPosX(int(posX));
sprite->setPosY(int(posY));
// Alinea el circulo de colisión con el objeto
shiftColliders();
}
// Pinta el objeto en la pantalla
void Item::render() {
if (enabled) {
if (timeToLive > 200) {
sprite->render();
} else if (timeToLive % 20 > 10) {
sprite->render();
}
}
}
// Actualiza la posición y estados del objeto
void Item::move() {
floorCollision = false;
// Calcula la nueva posición
posX += velX;
posY += velY;
// Aplica las aceleraciones a la velocidad
velX += accelX;
velY += accelY;
// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
if ((posX < PLAY_AREA_LEFT) || (posX + width > PLAY_AREA_RIGHT)) {
// Corregir posición
posX -= velX;
// Invertir sentido
velX = -velX;
}
// Si se sale por arriba rebota (excepto la maquina de café)
if ((posY < PLAY_AREA_TOP) && !(kind == ITEM_COFFEE_MACHINE)) {
// Corrige
posY -= velY;
// Invierte el sentido
velY = -velY;
}
// Si el objeto se sale por la parte inferior
if (posY + height > PLAY_AREA_BOTTOM) {
// Corrige
posY -= velY;
// Detiene el objeto
velY = 0;
velX = 0;
accelX = 0;
accelY = 0;
posY = PLAY_AREA_BOTTOM - height;
if (kind == ITEM_COFFEE_MACHINE) {
floorCollision = true;
}
}
// Actualiza la posición del sprite
sprite->setPosX(int(posX));
sprite->setPosY(int(posY));
shiftColliders();
}
// Pone a cero todos los valores del objeto
void Item::disable() {
enabled = false;
}
// Actualiza el objeto a su posicion, animación y controla los contadores
void Item::update() {
move();
sprite->animate();
updateTimeToLive();
checkTimeToLive();
}
// Actualiza el contador
void Item::updateTimeToLive() {
if (timeToLive > 0) {
timeToLive--;
}
}
// Comprueba si el objeto sigue vivo
void Item::checkTimeToLive() {
if (timeToLive == 0)
disable();
}
// Obtiene del valor de la variable
float Item::getPosX() {
return posX;
}
// Obtiene del valor de la variable
float Item::getPosY() {
return posY;
}
// Obtiene del valor de la variable
int Item::getWidth() {
return width;
}
// Obtiene del valor de la variable
int Item::getHeight() {
return height;
}
// Obtiene del valor de la variable
int Item::getClass() {
return kind;
}
// Obtiene el valor de la variable
bool Item::isEnabled() {
return enabled;
}
// Obtiene el circulo de colisión
circle_t &Item::getCollider() {
return collider;
}
// Alinea el circulo de colisión con la posición del objeto
void Item::shiftColliders() {
collider.x = int(posX + (width / 2));
collider.y = int(posY + (height / 2));
}
// Informa si el objeto ha colisionado con el suelo
bool Item::isOnFloor() {
return floorCollision;
}

96
source/game/entities/item.h Normal file
View File

@@ -0,0 +1,96 @@
#pragma once
#include <SDL3/SDL.h>
#include <string> // for string
#include <vector> // for vector
#include "utils/utils.h" // for circle_t
class AnimatedSprite;
class Texture;
// Tipos de objetos
constexpr int ITEM_POINTS_1_DISK = 1;
constexpr int ITEM_POINTS_2_GAVINA = 2;
constexpr int ITEM_POINTS_3_PACMAR = 3;
constexpr int ITEM_CLOCK = 4;
constexpr int ITEM_COFFEE = 5;
constexpr int ITEM_COFFEE_MACHINE = 6;
// Clase Item
class Item {
private:
// Objetos y punteros
AnimatedSprite *sprite; // Sprite con los graficos del objeto
// Variables
float posX; // Posición X del objeto
float posY; // Posición Y del objeto
Uint8 width; // Ancho del objeto
Uint8 height; // Alto del objeto
float velX; // Velocidad en el eje X
float velY; // Velocidad en el eje Y
float accelX; // Aceleración en el eje X
float accelY; // Aceleración en el eje Y
bool floorCollision; // Indica si el objeto colisiona con el suelo
Uint8 kind; // Especifica el tipo de objeto que es
bool enabled; // Especifica si el objeto está habilitado
circle_t collider; // Circulo de colisión del objeto
// Alinea el circulo de colisión con la posición del objeto
void shiftColliders();
// Actualiza la posición y estados del objeto
void move();
public:
Uint16 timeToLive; // Temporizador con el tiempo que el objeto está presente
// Constructor
Item(Uint8 kind, float x, float y, Texture *texture, std::vector<std::string> *animation, SDL_Renderer *renderer);
// Destructor
~Item();
// Centra el objeto en la posición X
void allignTo(int x);
// Pinta el objeto en la pantalla
void render();
// Pone a cero todos los valores del objeto
void disable();
// Actualiza al objeto a su posicion, animación y controla los contadores
void update();
// Actualiza el contador
void updateTimeToLive();
// Comprueba si el objeto sigue vivo
void checkTimeToLive();
// Obtiene del valor de la variable
float getPosX();
// Obtiene del valor de la variable
float getPosY();
// Obtiene del valor de la variable
int getWidth();
// Obtiene del valor de la variable
int getHeight();
// Obtiene del valor de la variable
int getClass();
// Obtiene el valor de la variable
bool isEnabled();
// Obtiene el circulo de colisión
circle_t &getCollider();
// Informa si el objeto ha colisionado con el suelo
bool isOnFloor();
};

530
source/game/entities/player.cpp Normal file
View File

@@ -0,0 +1,530 @@
#include "game/entities/player.h"
#include <stdlib.h> // for rand
#include "core/input/input.h" // for inputs_e
#include "core/rendering/animatedsprite.h" // for AnimatedSprite
#include "core/rendering/texture.h" // for Texture
#include "game/defaults.hpp" // for PLAY_AREA_LEFT, PLAY_AREA_RIGHT
// Constructor
Player::Player(float x, int y, SDL_Renderer *renderer, std::vector<Texture *> texture, std::vector<std::vector<std::string> *> animations) {
// Copia los punteros
this->renderer = renderer;
// Reserva memoria para los objetos
headSprite = new AnimatedSprite(texture[0], renderer, "", animations[0]);
bodySprite = new AnimatedSprite(texture[1], renderer, "", animations[1]);
legsSprite = new AnimatedSprite(texture[2], renderer, "", animations[2]);
deathSprite = new AnimatedSprite(texture[3], renderer, "", animations[3]);
fireSprite = new AnimatedSprite(texture[4], renderer, "", animations[4]);
fireSprite->getTexture()->setAlpha(224);
// Establece la posición inicial del jugador
posX = x;
posY = y;
init();
}
// Destructor
Player::~Player() {
delete headSprite;
delete bodySprite;
delete legsSprite;
delete deathSprite;
delete fireSprite;
}
// Iniciador
void Player::init() {
// Inicializa variables de estado
alive = true;
deathCounter = DEATH_COUNTER;
statusWalking = PLAYER_STATUS_WALKING_STOP;
statusFiring = PLAYER_STATUS_FIRING_NO;
invulnerable = false;
invulnerableCounter = PLAYER_INVULNERABLE_COUNTER;
powerUp = false;
powerUpCounter = PLAYER_POWERUP_COUNTER;
extraHit = false;
coffees = 0;
input = true;
// Establece la altura y el ancho del jugador
width = 24;
height = 24;
// Establece el tamaño del circulo de colisión
collider.r = 7;
// Actualiza la posición del circulo de colisión
shiftColliders();
// Establece la velocidad inicial
velX = 0;
velY = 0;
// Establece la velocidad base
baseSpeed = 1.5;
// Establece la puntuación inicial
score = 0;
// Establece el multiplicador de puntos inicial
scoreMultiplier = 1.0f;
// Inicia el contador para la cadencia de disparo
cooldown = 10;
// Establece la posición del sprite
legsSprite->setPosX(posX);
legsSprite->setPosY(posY);
bodySprite->setPosX(posX);
bodySprite->setPosY(posY);
headSprite->setPosX(posX);
headSprite->setPosY(posY);
// Selecciona un frame para pintar
legsSprite->setCurrentAnimation("stand");
bodySprite->setCurrentAnimation("stand");
headSprite->setCurrentAnimation("stand");
}
// Actua en consecuencia de la entrada recibida
void Player::setInput(Uint8 input) {
switch (input) {
case input_left:
velX = -baseSpeed;
setWalkingStatus(PLAYER_STATUS_WALKING_LEFT);
break;
case input_right:
velX = baseSpeed;
setWalkingStatus(PLAYER_STATUS_WALKING_RIGHT);
break;
case input_fire_center:
setFiringStatus(PLAYER_STATUS_FIRING_UP);
break;
case input_fire_left:
setFiringStatus(PLAYER_STATUS_FIRING_LEFT);
break;
case input_fire_right:
setFiringStatus(PLAYER_STATUS_FIRING_RIGHT);
break;
default:
velX = 0;
setWalkingStatus(PLAYER_STATUS_WALKING_STOP);
break;
}
}
// Mueve el jugador a la posición y animación que le corresponde
void Player::move() {
if (isAlive()) {
// Mueve el jugador a derecha o izquierda
posX += velX;
// Si el jugador abandona el area de juego por los laterales
if ((posX < PLAY_AREA_LEFT - 5) || (posX + width > PLAY_AREA_RIGHT + 5)) { // Restaura su posición
posX -= velX;
}
// Actualiza la posición del sprite
legsSprite->setPosX(getPosX());
legsSprite->setPosY(posY);
bodySprite->setPosX(getPosX());
bodySprite->setPosY(posY);
headSprite->setPosX(getPosX());
headSprite->setPosY(posY);
fireSprite->setPosX(getPosX() - 2);
fireSprite->setPosY(posY - 8);
} else {
deathSprite->update();
// Si el cadaver abandona el area de juego por los laterales
if ((deathSprite->getPosX() < PLAY_AREA_LEFT) || (deathSprite->getPosX() + width > PLAY_AREA_RIGHT)) { // Restaura su posición
const float vx = deathSprite->getVelX();
deathSprite->setPosX(deathSprite->getPosX() - vx);
// Rebota
deathSprite->setVelX(-vx);
}
}
}
// Pinta el jugador en pantalla
void Player::render() {
if (isAlive()) {
if (invulnerable) {
if ((invulnerableCounter % 10) > 4) {
if (powerUp) {
fireSprite->render();
}
legsSprite->render();
bodySprite->render();
headSprite->render();
}
} else {
if (powerUp) {
fireSprite->render();
}
legsSprite->render();
bodySprite->render();
headSprite->render();
}
} else {
deathSprite->render();
}
}
// Establece el estado del jugador cuando camina
void Player::setWalkingStatus(Uint8 status) {
// Si cambiamos de estado, reiniciamos la animación
if (statusWalking != status) {
statusWalking = status;
// legsSprite->setCurrentFrame(0);
}
}
// Establece el estado del jugador cuando dispara
void Player::setFiringStatus(Uint8 status) {
// Si cambiamos de estado, reiniciamos la animación
if (statusFiring != status) {
statusFiring = status;
}
}
// Establece la animación correspondiente al estado
void Player::setAnimation() {
// Crea cadenas de texto para componer el nombre de la animación
std::string aBodyCoffees = "";
std::string aHeadCoffees = "";
if (coffees > 0) {
aBodyCoffees = coffees == 1 ? "_1C" : "_2C";
aHeadCoffees = "_1C";
}
const std::string aPowerUp = powerUp ? "_pwr" : "";
const std::string aWalking = statusWalking == PLAYER_STATUS_WALKING_STOP ? "stand" : "walk";
const std::string aFiring = statusFiring == PLAYER_STATUS_FIRING_UP ? "centershoot" : "sideshoot";
const SDL_FlipMode flipWalk = statusWalking == PLAYER_STATUS_WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_FlipMode flipFire = statusFiring == PLAYER_STATUS_FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
// Establece la animación a partir de las cadenas
legsSprite->setCurrentAnimation(aWalking);
legsSprite->setFlip(flipWalk);
if (statusFiring == PLAYER_STATUS_FIRING_NO) { // No esta disparando
bodySprite->setCurrentAnimation(aWalking + aBodyCoffees + aPowerUp);
bodySprite->setFlip(flipWalk);
headSprite->setCurrentAnimation(aWalking + aHeadCoffees + aPowerUp);
headSprite->setFlip(flipWalk);
} else { // Está disparando
bodySprite->setCurrentAnimation(aFiring + aBodyCoffees + aPowerUp);
bodySprite->setFlip(flipFire);
headSprite->setCurrentAnimation(aFiring + aHeadCoffees + aPowerUp);
headSprite->setFlip(flipFire);
}
// Actualiza las animaciones de los sprites
legsSprite->animate();
bodySprite->animate();
headSprite->animate();
fireSprite->animate();
fireSprite->setFlip(flipWalk);
}
// Obtiene el valor de la variable
int Player::getPosX() {
return int(posX);
}
// Obtiene el valor de la variable
int Player::getPosY() {
return posY;
}
// Obtiene el valor de la variable
int Player::getWidth() {
return width;
}
// Obtiene el valor de la variable
int Player::getHeight() {
return height;
}
// Indica si el jugador puede disparar
bool Player::canFire() {
// Si el contador a llegado a cero, podemos disparar. En caso contrario decrementamos el contador
if (cooldown > 0) {
return false;
} else {
return true;
}
}
// Establece el valor de la variable
void Player::setFireCooldown(int time) {
cooldown = time;
}
// Actualiza el valor de la variable
void Player::updateCooldown() {
if (cooldown > 0) {
cooldown--;
if (powerUp) {
cooldown--;
}
} else {
setFiringStatus(PLAYER_STATUS_FIRING_NO);
}
}
// Actualiza al jugador a su posicion, animación y controla los contadores
void Player::update() {
move();
setAnimation();
shiftColliders();
updateCooldown();
updatePowerUpCounter();
updateInvulnerableCounter();
updateDeathCounter();
updatePowerUpHeadOffset();
}
// Obtiene la puntuación del jugador
Uint32 Player::getScore() {
return score;
}
// Asigna un valor a la puntuación del jugador
void Player::setScore(Uint32 score) {
this->score = score;
}
// Incrementa la puntuación del jugador
void Player::addScore(Uint32 score) {
this->score += score;
}
// Obtiene el valor de la variable
bool Player::isAlive() {
return alive;
}
// Establece el valor de la variable
void Player::setAlive(bool value) {
alive = value;
if (!value) {
deathSprite->setPosX(headSprite->getRect().x);
deathSprite->setPosY(headSprite->getRect().y);
deathSprite->setAccelY(0.2f);
deathSprite->setVelY(-6.6f);
deathSprite->setVelX(3.3f);
if (rand() % 2 == 0) {
deathSprite->setVelX(-3.3f);
}
}
}
// Obtiene el valor de la variable
float Player::getScoreMultiplier() {
return scoreMultiplier;
}
// Establece el valor de la variable
void Player::setScoreMultiplier(float value) {
scoreMultiplier = value;
}
// Aumenta el valor de la variable hasta un máximo
void Player::incScoreMultiplier() {
if (scoreMultiplier < 5.0f) {
scoreMultiplier += 0.1f;
} else {
scoreMultiplier = 5.0f;
}
}
// Decrementa el valor de la variable hasta un mínimo
void Player::decScoreMultiplier() {
if (scoreMultiplier > 1.0f) {
scoreMultiplier -= 0.1f;
} else {
scoreMultiplier = 1.0f;
}
}
// Obtiene el valor de la variable
bool Player::isInvulnerable() {
return invulnerable;
}
// Establece el valor de la variable
void Player::setInvulnerable(bool value) {
invulnerable = value;
}
// Obtiene el valor de la variable
Uint16 Player::getInvulnerableCounter() {
return invulnerableCounter;
}
// Establece el valor de la variable
void Player::setInvulnerableCounter(Uint16 value) {
invulnerableCounter = value;
}
// Actualiza el valor de la variable
void Player::updateInvulnerableCounter() {
if (invulnerable) {
if (invulnerableCounter > 0) {
invulnerableCounter--;
} else {
invulnerable = false;
invulnerableCounter = PLAYER_INVULNERABLE_COUNTER;
}
}
}
// Actualiza el valor de la variable
void Player::updateDeathCounter() {
if (!alive) {
if (deathCounter > 0) {
deathCounter--;
}
}
}
// Obtiene el valor de la variable
bool Player::isPowerUp() {
return powerUp;
}
// Establece el valor de la variable
void Player::setPowerUp(bool value) {
powerUp = value;
}
// Obtiene el valor de la variable
Uint16 Player::getPowerUpCounter() {
return powerUpCounter;
}
// Establece el valor de la variable
void Player::setPowerUpCounter(Uint16 value) {
powerUpCounter = value;
}
// Actualiza el valor de la variable
void Player::updatePowerUpCounter() {
if ((powerUpCounter > 0) && (powerUp)) {
powerUpCounter--;
} else {
powerUp = false;
powerUpCounter = PLAYER_POWERUP_COUNTER;
}
}
// Obtiene el valor de la variable
bool Player::hasExtraHit() {
return extraHit;
}
// Concede un toque extra al jugador
void Player::giveExtraHit() {
extraHit = true;
coffees++;
if (coffees > 2) {
coffees = 2;
}
}
// Quita el toque extra al jugador
void Player::removeExtraHit() {
if (coffees > 0) {
coffees--;
}
if (coffees == 0) {
extraHit = false;
}
invulnerable = true;
invulnerableCounter = PLAYER_INVULNERABLE_COUNTER;
}
// Habilita la entrada de ordenes
void Player::enableInput() {
input = true;
}
// Deshabilita la entrada de ordenes
void Player::disableInput() {
input = false;
}
// Devuelve el numero de cafes actuales
Uint8 Player::getCoffees() {
return coffees;
}
// Obtiene el circulo de colisión
circle_t &Player::getCollider() {
return collider;
}
// Actualiza el circulo de colisión a la posición del jugador
void Player::shiftColliders() {
collider.x = int(posX + (width / 2));
collider.y = int(posY + (height / 2));
}
// Obtiene el puntero a la textura con los gráficos de la animación de morir
Texture *Player::getDeadTexture() {
return deathSprite->getTexture();
;
}
// Obtiene el valor de la variable
Uint16 Player::getDeathCounter() {
return deathCounter;
}
// Actualiza el valor de la variable
void Player::updatePowerUpHeadOffset() {
if (!powerUp) {
// powerUpHeadOffset = 0;
} else {
// powerUpHeadOffset = 96;
if (powerUpCounter < 300) {
if (powerUpCounter % 10 > 4) {
// powerUpHeadOffset = 96;
fireSprite->setEnabled(false);
} else {
// powerUpHeadOffset = 0;
fireSprite->setEnabled(true);
}
}
}
}
// Pone las texturas del jugador
void Player::setPlayerTextures(std::vector<Texture *> texture) {
headSprite->setTexture(texture[0]);
bodySprite->setTexture(texture[1]);
legsSprite->setTexture(texture[2]);
deathSprite->setTexture(texture[3]);
fireSprite->setTexture(texture[4]);
}

217
source/game/entities/player.h Normal file
View File

@@ -0,0 +1,217 @@
#pragma once
#include <SDL3/SDL.h>
#include <string> // for string
#include <vector> // for vector
#include "utils/utils.h" // for circle_t
class AnimatedSprite;
class Texture;
// Contadores
constexpr int DEATH_COUNTER = 350;
// Estados del jugador
constexpr int PLAYER_STATUS_WALKING_LEFT = 0;
constexpr int PLAYER_STATUS_WALKING_RIGHT = 1;
constexpr int PLAYER_STATUS_WALKING_STOP = 2;
constexpr int PLAYER_STATUS_FIRING_UP = 0;
constexpr int PLAYER_STATUS_FIRING_LEFT = 1;
constexpr int PLAYER_STATUS_FIRING_RIGHT = 2;
constexpr int PLAYER_STATUS_FIRING_NO = 3;
// Variables del jugador
constexpr int PLAYER_INVULNERABLE_COUNTER = 200;
constexpr int PLAYER_POWERUP_COUNTER = 1500;
// Clase Player
class Player {
private:
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
AnimatedSprite *headSprite; // Sprite para dibujar la cabeza
AnimatedSprite *bodySprite; // Sprite para dibujar el cuerpo
AnimatedSprite *legsSprite; // Sprite para dibujar las piernas
AnimatedSprite *deathSprite; // Sprite para dibujar el jugador derrotado
AnimatedSprite *fireSprite; // Sprite para dibujar el aura del jugador con el poder a tope
// Variables
float posX; // Posicion en el eje X
int posY; // Posicion en el eje Y
Uint8 width; // Anchura
Uint8 height; // Altura
float velX; // Cantidad de pixeles a desplazarse en el eje X
int velY; // Cantidad de pixeles a desplazarse en el eje Y
float baseSpeed; // Velocidad base del jugador
int cooldown; // Contador durante el cual no puede disparar
Uint32 score; // Puntos del jugador
float scoreMultiplier; // Multiplicador de puntos
Uint8 statusWalking; // Estado del jugador
Uint8 statusFiring; // Estado del jugador
bool alive; // Indica si el jugador está vivo
Uint16 deathCounter; // Contador para la animación de morirse
bool invulnerable; // Indica si el jugador es invulnerable
Uint16 invulnerableCounter; // Contador para la invulnerabilidad
bool extraHit; // Indica si el jugador tiene un toque extra
Uint8 coffees; // Indica cuantos cafes lleva acumulados
bool powerUp; // Indica si el jugador tiene activo el modo PowerUp
Uint16 powerUpCounter; // Temporizador para el modo PowerUp
bool input; // Indica si puede recibir ordenes de entrada
circle_t collider; // Circulo de colisión del jugador
// Actualiza el circulo de colisión a la posición del jugador
void shiftColliders();
// Actualiza el valor de la variable
void updateInvulnerableCounter();
// Actualiza el valor de la variable
void updateDeathCounter();
// Actualiza el valor de la variable
void updatePowerUpHeadOffset();
public:
// Constructor
Player(float x, int y, SDL_Renderer *renderer, std::vector<Texture *> texture, std::vector<std::vector<std::string> *> animations);
// Destructor
~Player();
// Iniciador
void init();
// Actualiza al jugador a su posicion, animación y controla los contadores
void update();
// Pinta el jugador en pantalla
void render();
// Pone las texturas del jugador
void setPlayerTextures(std::vector<Texture *> texture);
// Actua en consecuencia de la entrada recibida
void setInput(Uint8 input);
// Mueve el jugador a la posición y animación que le corresponde
void move();
// Establece el estado del jugador
void setWalkingStatus(Uint8 status);
// Establece el estado del jugador
void setFiringStatus(Uint8 status);
// Establece la animación correspondiente al estado
void setAnimation();
// Obtiene el valor de la variable
int getPosX();
// Obtiene el valor de la variable
int getPosY();
// Obtiene el valor de la variable
int getWidth();
// Obtiene el valor de la variable
int getHeight();
// Indica si el jugador puede disparar
bool canFire();
// Establece el valor de la variable
void setFireCooldown(int time);
// Actualiza el valor de la variable
void updateCooldown();
// Obtiene la puntuación del jugador
Uint32 getScore();
// Asigna un valor a la puntuación del jugador
void setScore(Uint32 score);
// Incrementa la puntuación del jugador
void addScore(Uint32 score);
// Obtiene el valor de la variable
bool isAlive();
// Establece el valor de la variable
void setAlive(bool value);
// Obtiene el valor de la variable
float getScoreMultiplier();
// Establece el valor de la variable
void setScoreMultiplier(float value);
// Aumenta el valor de la variable hasta un máximo
void incScoreMultiplier();
// Decrementa el valor de la variable hasta un mínimo
void decScoreMultiplier();
// Obtiene el valor de la variable
bool isInvulnerable();
// Establece el valor de la variable
void setInvulnerable(bool value);
// Obtiene el valor de la variable
Uint16 getInvulnerableCounter();
// Establece el valor de la variable
void setInvulnerableCounter(Uint16 value);
// Obtiene el valor de la variable
bool isPowerUp();
// Establece el valor de la variable
void setPowerUp(bool value);
// Obtiene el valor de la variable
Uint16 getPowerUpCounter();
// Establece el valor de la variable
void setPowerUpCounter(Uint16 value);
// Actualiza el valor de la variable
void updatePowerUpCounter();
// Obtiene el valor de la variable
bool hasExtraHit();
// Concede un toque extra al jugador
void giveExtraHit();
// Quita el toque extra al jugador
void removeExtraHit();
// Habilita la entrada de ordenes
void enableInput();
// Deshabilita la entrada de ordenes
void disableInput();
// Devuelve el numero de cafes actuales
Uint8 getCoffees();
// Obtiene el circulo de colisión
circle_t &getCollider();
// Obtiene el puntero a la textura con los gráficos de la animación de morir
Texture *getDeadTexture();
// Obtiene el valor de la variable
Uint16 getDeathCounter();
};

3326
source/game/game.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

565
source/game/game.h Normal file
View File

@@ -0,0 +1,565 @@
#pragma once
#include <SDL3/SDL.h>
#include <string> // for string, basic_string
#include <vector> // for vector
#include "utils/utils.h" // for demoKeys_t, color_t
class Asset;
class Balloon;
class Bullet;
class Fade;
class Input;
class Item;
class Lang;
class Menu;
class MovingSprite;
class Player;
class Screen;
class SmartSprite;
class Sprite;
class Text;
class Texture;
struct JA_Music_t;
struct JA_Sound_t;
// Cantidad de elementos a escribir en los ficheros de datos
constexpr int TOTAL_SCORE_DATA = 3;
constexpr int TOTAL_DEMO_DATA = 2000;
// Contadores
constexpr int STAGE_COUNTER = 200;
constexpr int SHAKE_COUNTER = 10;
constexpr int HELP_COUNTER = 1000;
constexpr int GAME_COMPLETED_START_FADE = 500;
constexpr int GAME_COMPLETED_END = 700;
// Formaciones enemigas
constexpr int NUMBER_OF_ENEMY_FORMATIONS = 100;
constexpr int MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION = 50;
// Porcentaje de aparición de los objetos
constexpr int ITEM_POINTS_1_DISK_ODDS = 10;
constexpr int ITEM_POINTS_2_GAVINA_ODDS = 6;
constexpr int ITEM_POINTS_3_PACMAR_ODDS = 3;
constexpr int ITEM_CLOCK_ODDS = 5;
constexpr int ITEM_COFFEE_ODDS = 5;
constexpr int ITEM_POWER_BALL_ODDS = 0;
constexpr int ITEM_COFFEE_MACHINE_ODDS = 4;
// Valores para las variables asociadas a los objetos
constexpr int TIME_STOPPED_COUNTER = 300;
// Clase Game
class Game {
private:
struct enemyInits_t {
int x; // Posición en el eje X donde crear al enemigo
int y; // Posición en el eje Y donde crear al enemigo
float velX; // Velocidad inicial en el eje X
Uint8 kind; // Tipo de enemigo
Uint16 creationCounter; // Temporizador para la creación del enemigo
};
struct enemyFormation_t // Contiene la información de una formación enemiga
{
Uint8 numberOfEnemies; // Cantidad de enemigos que forman la formación
enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
};
struct enemyPool_t {
enemyFormation_t *set[10]; // Conjunto de formaciones enemigas
};
struct stage_t // Contiene todas las variables relacionadas con una fase
{
enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase
Uint16 currentPower; // Cantidad actual de poder
Uint16 powerToComplete; // Cantidad de poder que se necesita para completar la fase
Uint8 maxMenace; // Umbral máximo de amenaza de la fase
Uint8 minMenace; // Umbral mínimo de amenaza de la fase
Uint8 number; // Numero de fase
};
struct effect_t {
bool flash; // Indica si se ha de pintar la pantalla de blanco
bool shake; // Indica si se ha de agitar la pantalla
Uint8 shakeCounter; // Contador para medir el tiempo que dura el efecto
};
// Estado para el efecto de agitación intensa (muerte del jugador)
struct deathShake_t {
bool active; // Indica si el efecto está activo
Uint8 step; // Paso actual del efecto (0-7)
Uint32 lastStepTicks; // Ticks del último paso
};
// Fases de la secuencia de muerte del jugador
enum class DeathPhase { None,
Shaking,
Waiting,
Done };
// Estado de la secuencia de muerte del jugador
struct deathSequence_t {
DeathPhase phase; // Fase actual
Uint32 phaseStartTicks; // Ticks del inicio de la fase actual
Player *player; // Jugador que está muriendo
};
struct helper_t {
bool needCoffee; // Indica si se necesitan cafes
bool needCoffeeMachine; // Indica si se necesita PowerUp
bool needPowerBall; // Indica si se necesita una PowerBall
int counter; // Contador para no dar ayudas consecutivas
int itemPoints1Odds; // Probabilidad de aparición del objeto
int itemPoints2Odds; // Probabilidad de aparición del objeto
int itemPoints3Odds; // Probabilidad de aparición del objeto
int itemClockOdds; // Probabilidad de aparición del objeto
int itemCoffeeOdds; // Probabilidad de aparición del objeto
int itemCoffeeMachineOdds; // Probabilidad de aparición del objeto
};
struct demo_t {
bool enabled; // Indica si está activo el modo demo
bool recording; // Indica si está activado el modo para grabar la demo
Uint16 counter; // Contador para el modo demo
demoKeys_t keys; // Variable con las pulsaciones de teclas del modo demo
demoKeys_t dataFile[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la demo
};
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
Screen *screen; // Objeto encargado de dibujar en pantalla
Asset *asset; // Objeto que gestiona todos los ficheros de recursos
Lang *lang; // Objeto para gestionar los textos en diferentes idiomas
Input *input; // Manejador de entrada
section_t *section; // Seccion actual dentro del juego
std::vector<Player *> players; // Vector con los jugadores
std::vector<Balloon *> balloons; // Vector con los globos
std::vector<Bullet *> bullets; // Vector con las balas
std::vector<Item *> items; // Vector con los items
std::vector<SmartSprite *> smartSprites; // Vector con los smartsprites
Texture *bulletTexture; // Textura para las balas
std::vector<Texture *> itemTextures; // Vector con las texturas de los items
std::vector<Texture *> balloonTextures; // Vector con las texturas de los globos
std::vector<Texture *> player1Textures; // Vector con las texturas del jugador
std::vector<Texture *> player2Textures; // Vector con las texturas del jugador
std::vector<std::vector<Texture *>> playerTextures; // Vector con todas las texturas de los jugadores;
Texture *gameBuildingsTexture; // Textura con los edificios de fondo
Texture *gameCloudsTexture; // Textura con las nubes de fondo
Texture *gameGrassTexture; // Textura con la hierba del suelo
Texture *gamePowerMeterTexture; // Textura con el marcador de poder de la fase
Texture *gameSkyColorsTexture; // Textura con los diferentes colores de fondo del juego
Texture *gameTextTexture; // Textura para los sprites con textos
Texture *gameOverTexture; // Textura para la pantalla de game over
Texture *gameOverEndTexture; // Textura para la pantalla de game over de acabar el juego
std::vector<std::vector<std::string> *> itemAnimations; // Vector con las animaciones de los items
std::vector<std::vector<std::string> *> playerAnimations; // Vector con las animaciones del jugador
std::vector<std::vector<std::string> *> balloonAnimations; // Vector con las animaciones de los globos
Text *text; // Fuente para los textos del juego
Text *textBig; // Fuente de texto grande
Text *textScoreBoard; // Fuente para el marcador del juego
Text *textNokia2; // Otra fuente de texto para mensajes
Text *textNokiaBig2; // Y la versión en grande
Menu *gameOverMenu; // Menú de la pantalla de game over
Menu *pauseMenu; // Menú de la pantalla de pausa
Fade *fade; // Objeto para renderizar fades
SDL_Event *eventHandler; // Manejador de eventos
MovingSprite *clouds1A; // Sprite para las nubes superiores
MovingSprite *clouds1B; // Sprite para las nubes superiores
MovingSprite *clouds2A; // Sprite para las nubes inferiores
MovingSprite *clouds2B; // Sprite para las nubes inferiores
SmartSprite *n1000Sprite; // Sprite con el texto 1.000
SmartSprite *n2500Sprite; // Sprite con el texto 2.500
SmartSprite *n5000Sprite; // Sprite con el texto 5.000
Sprite *buildingsSprite; // Sprite con los edificios de fondo
Sprite *skyColorsSprite; // Sprite con los graficos del degradado de color de fondo
Sprite *grassSprite; // Sprite para la hierba
Sprite *powerMeterSprite; // Sprite para el medidor de poder de la fase
Sprite *gameOverSprite; // Sprite para dibujar los graficos del game over
Sprite *gameOverEndSprite; // Sprite para dibujar los graficos del game over de acabar el juego
JA_Sound_t *balloonSound; // Sonido para la explosión del globo
JA_Sound_t *bulletSound; // Sonido para los disparos
JA_Sound_t *playerCollisionSound; // Sonido para la colisión del jugador con un enemigo
JA_Sound_t *hiScoreSound; // Sonido para cuando se alcanza la máxima puntuación
JA_Sound_t *itemDropSound; // Sonido para cuando se genera un item
JA_Sound_t *itemPickUpSound; // Sonido para cuando se recoge un item
JA_Sound_t *coffeeOutSound; // Sonido para cuando el jugador pierde el café al recibir un impacto
JA_Sound_t *stageChangeSound; // Sonido para cuando se cambia de fase
JA_Sound_t *bubble1Sound; // Sonido para cuando el jugador muere
JA_Sound_t *bubble2Sound; // Sonido para cuando el jugador muere
JA_Sound_t *bubble3Sound; // Sonido para cuando el jugador muere
JA_Sound_t *bubble4Sound; // Sonido para cuando el jugador muere
JA_Sound_t *clockSound; // Sonido para cuando se detiene el tiempo con el item reloj
JA_Sound_t *powerBallSound; // Sonido para cuando se explota una Power Ball
JA_Sound_t *coffeeMachineSound; // Sonido para cuando la máquina de café toca el suelo
JA_Music_t *gameMusic; // Musica de fondo
// Variables
int numPlayers; // Numero de jugadores
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint8 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
Uint32 hiScore; // Puntuación máxima
bool hiScoreAchieved; // Indica si se ha superado la puntuación máxima
std::string hiScoreName; // Nombre del jugador que ostenta la máxima puntuación
stage_t stage[10]; // Variable con los datos de cada pantalla
Uint8 currentStage; // Indica la fase actual
Uint8 stageBitmapCounter; // Contador para el tiempo visible del texto de Stage
float stageBitmapPath[STAGE_COUNTER]; // Vector con los puntos Y por donde se desplaza el texto
float getReadyBitmapPath[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
Uint16 deathCounter; // Contador para la animación de muerte del jugador
Uint8 menaceCurrent; // Nivel de amenaza actual
Uint8 menaceThreshold; // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el numero de globos
bool timeStopped; // Indica si el tiempo está detenido
Uint16 timeStoppedCounter; // Temporizador para llevar la cuenta del tiempo detenido
Uint32 counter; // Contador para el juego
Uint32 scoreDataFile[TOTAL_SCORE_DATA]; // Datos del fichero de puntos
SDL_Rect skyColorsRect[4]; // Vector con las coordenadas de los 4 colores de cielo
Uint16 balloonsPopped; // Lleva la cuenta de los globos explotados
Uint8 lastEnemyDeploy; // Guarda cual ha sido la última formación desplegada para no repetir;
int enemyDeployCounter; // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
float enemySpeed; // Velocidad a la que se mueven los enemigos
float defaultEnemySpeed; // Velocidad base de los enemigos, sin incrementar
effect_t effect; // Variable para gestionar los efectos visuales
deathShake_t deathShake; // Variable para gestionar el efecto de agitación intensa
deathSequence_t deathSequence; // Variable para gestionar la secuencia de muerte
helper_t helper; // Variable para gestionar las ayudas
bool powerBallEnabled; // Indica si hay una powerball ya activa
Uint8 powerBallCounter; // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
bool coffeeMachineEnabled; // Indica si hay una máquina de café en el terreno de juego
bool gameCompleted; // Indica si se ha completado la partida, llegando al final de la ultima pantalla
int gameCompletedCounter; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
Uint8 difficulty; // Dificultad del juego
float difficultyScoreMultiplier; // Multiplicador de puntos en función de la dificultad
color_t difficultyColor; // Color asociado a la dificultad
struct options_t *options; // Variable con todas las variables de las opciones del programa
Uint8 onePlayerControl; // Variable para almacenar el valor de las opciones
enemyFormation_t enemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas
enemyPool_t enemyPool[10]; // Variable con los diferentes conjuntos de formaciones enemigas
Uint8 lastStageReached; // Contiene el numero de la última pantalla que se ha alcanzado
demo_t demo; // Variable con todas las variables relacionadas con el modo demo
int totalPowerToCompleteGame; // La suma del poder necesario para completar todas las fases
int cloudsSpeed; // Velocidad a la que se desplazan las nubes
int pauseCounter; // Contador para salir del menu de pausa y volver al juego
bool leavingPauseMenu; // Indica si esta saliendo del menu de pausa para volver al juego
bool pauseInitialized; // Indica si la pausa ha sido inicializada
bool gameOverInitialized; // Indica si el game over ha sido inicializado
int gameOverPostFade; // Opción a realizar cuando termina el fundido del game over
#ifdef PAUSE
bool pause;
#endif
// Actualiza el juego
void update();
// Dibuja el juego
void render();
// Comprueba los eventos que hay en cola
void checkEvents();
// Inicializa las variables necesarias para la sección 'Game'
void init();
// Carga los recursos necesarios para la sección 'Game'
void loadMedia();
// Carga el fichero de puntos
bool loadScoreFile();
// Carga el fichero de datos para la demo
bool loadDemoFile();
// Guarda el fichero de puntos
bool saveScoreFile();
// Guarda el fichero de datos para la demo
bool saveDemoFile();
// Inicializa las formaciones enemigas
void initEnemyFormations();
// Inicializa los conjuntos de formaciones
void initEnemyPools();
// Inicializa las fases del juego
void initGameStages();
// Crea una formación de enemigos
void deployEnemyFormation();
// Aumenta el poder de la fase
void increaseStageCurrentPower(Uint8 power);
// Establece el valor de la variable
void setHiScore(Uint32 score);
// Actualiza el valor de HiScore en caso necesario
void updateHiScore();
// Transforma un valor numérico en una cadena de 6 cifras
std::string updateScoreText(Uint32 num);
// Pinta el marcador en pantalla usando un objeto texto
void renderScoreBoard();
// Actualiza las variables del jugador
void updatePlayers();
// Dibuja a los jugadores
void renderPlayers();
// Actualiza las variables de la fase
void updateStage();
// Actualiza el estado de muerte
void updateDeath();
// Renderiza el fade final cuando se acaba la partida
void renderDeathFade(int counter);
// Actualiza los globos
void updateBalloons();
// Pinta en pantalla todos los globos activos
void renderBalloons();
// Crea un globo nuevo en el vector de globos
Uint8 createBalloon(float x, int y, Uint8 kind, float velx, float speed, Uint16 stoppedcounter);
// Crea una PowerBall
void createPowerBall();
// Establece la velocidad de los globos
void setBalloonSpeed(float speed);
// Incrementa la velocidad de los globos
void incBalloonSpeed();
// Decrementa la velocidad de los globos
void decBalloonSpeed();
// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
void updateBalloonSpeed();
// Explosiona un globo. Lo destruye y crea otros dos si es el caso
void popBalloon(Balloon *balloon);
// Explosiona un globo. Lo destruye
void destroyBalloon(Balloon *balloon);
// Explosiona todos los globos
void popAllBalloons();
// Destruye todos los globos
void destroyAllBalloons();
// Detiene todos los globos
void stopAllBalloons(Uint16 time);
// Pone en marcha todos los globos
void startAllBalloons();
// Obtiene el numero de globos activos
Uint8 countBalloons();
// Vacia el vector de globos
void freeBalloons();
// Comprueba la colisión entre el jugador y los globos activos
bool checkPlayerBalloonCollision(Player *player);
// Comprueba la colisión entre el jugador y los items
void checkPlayerItemCollision(Player *player);
// Comprueba la colisión entre las balas y los globos
void checkBulletBalloonCollision();
// Mueve las balas activas
void moveBullets();
// Pinta las balas activas
void renderBullets();
// Crea un objeto bala
void createBullet(int x, int y, Uint8 kind, bool poweredUp, int owner);
// Vacia el vector de balas
void freeBullets();
// Actualiza los items
void updateItems();
// Pinta los items activos
void renderItems();
// Devuelve un item en función del azar
Uint8 dropItem();
// Crea un objeto item
void createItem(Uint8 kind, float x, float y);
// Vacia el vector de items
void freeItems();
// Crea un objeto SmartSprite
void createItemScoreSprite(int x, int y, SmartSprite *sprite);
// Vacia el vector de smartsprites
void freeSmartSprites();
// Dibuja el efecto de flash
void renderFlashEffect();
// Actualiza el efecto de agitar la pantalla
void updateShakeEffect();
// Crea un SmartSprite para arrojar el item café al recibir un impacto
void throwCoffee(int x, int y);
// Actualiza los SmartSprites
void updateSmartSprites();
// Pinta los SmartSprites activos
void renderSmartSprites();
// Acciones a realizar cuando el jugador muere
void killPlayer(Player *player);
// Calcula y establece el valor de amenaza en funcion de los globos activos
void evaluateAndSetMenace();
// Obtiene el valor de la variable
Uint8 getMenace();
// Establece el valor de la variable
void setTimeStopped(bool value);
// Obtiene el valor de la variable
bool isTimeStopped();
// Establece el valor de la variable
void setTimeStoppedCounter(Uint16 value);
// Incrementa el valor de la variable
void incTimeStoppedCounter(Uint16 value);
// Actualiza la variable EnemyDeployCounter
void updateEnemyDeployCounter();
// Actualiza y comprueba el valor de la variable
void updateTimeStoppedCounter();
// Gestiona el nivel de amenaza
void updateMenace();
// Actualiza el fondo
void updateBackground();
// Dibuja el fondo
void renderBackground();
// Gestiona la entrada durante el juego
void checkGameInput();
// Pinta diferentes mensajes en la pantalla
void renderMessages();
// Habilita el efecto del item de detener el tiempo
void enableTimeStopItem();
// Deshabilita el efecto del item de detener el tiempo
void disableTimeStopItem();
// Inicia el efecto de agitación intensa de la pantalla
void shakeScreen();
// Actualiza el efecto de agitación intensa
void updateDeathShake();
// Indica si el efecto de agitación intensa está activo
bool isDeathShaking();
// Actualiza la secuencia de muerte del jugador
void updateDeathSequence();
// Actualiza las variables del menu de pausa del juego
void updatePausedGame();
// Dibuja el menu de pausa del juego
void renderPausedGame();
// Inicializa el estado de pausa del juego
void enterPausedGame();
// Actualiza los elementos de la pantalla de game over
void updateGameOverScreen();
// Dibuja los elementos de la pantalla de game over
void renderGameOverScreen();
// Inicializa el estado de game over
void enterGameOverScreen();
// Comprueba los eventos de la pantalla de game over
void checkGameOverEvents();
// Indica si se puede crear una powerball
bool canPowerBallBeCreated();
// Calcula el poder actual de los globos en pantalla
int calculateScreenPower();
// Inicializa las variables que contienen puntos de ruta para mover objetos
void initPaths();
// Actualiza el tramo final de juego, una vez completado
void updateGameCompleted();
// Actualiza las variables de ayuda
void updateHelper();
// Comprueba si todos los jugadores han muerto
bool allPlayersAreDead();
// Elimina todos los objetos contenidos en vectores
void deleteAllVectorObjects();
// Recarga las texturas
void reloadTextures();
// Establece la máxima puntuación desde fichero o desde las puntuaciones online
void setHiScore();
public:
// Constructor
Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *screen, Asset *asset, Lang *lang, Input *input, bool demo, options_t *options, section_t *section);
// Destructor
~Game();
// Bucle para el juego
void run();
// Ejecuta un frame del juego
void iterate();
// Indica si el juego ha terminado
bool hasFinished() const;
// Procesa un evento
void handleEvent(SDL_Event *event);
};

283
source/game/scenes/instructions.cpp Normal file
View File

@@ -0,0 +1,283 @@
#include "game/scenes/instructions.h"
#include <SDL3/SDL.h>
#include <algorithm> // for max
#include <iostream> // for char_traits, basic_ostream, operator<<
#include <string> // for basic_string
#include "core/audio/jail_audio.hpp" // for JA_StopMusic
#include "core/input/input.h" // for Input, REPEAT_FALSE, inputs_e
#include "core/locale/lang.h" // for Lang
#include "core/rendering/screen.h" // for Screen
#include "core/rendering/sprite.h" // for Sprite
#include "core/rendering/text.h" // for Text, TXT_CENTER, TXT_COLOR, TXT_SHADOW
#include "core/rendering/texture.h" // for Texture
#include "core/resources/asset.h" // for Asset
#include "core/resources/resource.h"
#include "game/defaults.hpp" // for shdwTxtColor, GAMECANVAS_CENTER_X, GAME...
#include "utils/utils.h" // for color_t, section_t
// Constructor
Instructions::Instructions(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, Lang *lang, section_t *section) {
// Copia los punteros
this->renderer = renderer;
this->screen = screen;
this->asset = asset;
this->input = input;
this->lang = lang;
this->section = section;
// Texturas (handles compartidos de Resource)
Resource *R = Resource::get();
itemTextures.push_back(R->getTexture("item_points1_disk.png"));
itemTextures.push_back(R->getTexture("item_points2_gavina.png"));
itemTextures.push_back(R->getTexture("item_points3_pacmar.png"));
itemTextures.push_back(R->getTexture("item_clock.png"));
itemTextures.push_back(R->getTexture("item_coffee.png"));
itemTextures.push_back(R->getTexture("item_coffee_machine.png"));
eventHandler = new SDL_Event();
sprite = new Sprite(0, 0, 16, 16, itemTextures[0], renderer);
text = R->getText("smb2");
// Crea un backbuffer para el renderizador
backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
if (backbuffer != nullptr) {
SDL_SetTextureScaleMode(backbuffer, Texture::currentScaleMode);
} else {
std::cout << "Error: textTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
}
// Inicializa variables
ticks = 0;
ticksSpeed = 15;
manualQuit = false;
counter = 0;
counterEnd = 600;
finished = false;
quitRequested = false;
}
// Destructor
Instructions::~Instructions() {
// itemTextures y text son propiedad de Resource — no liberar.
itemTextures.clear();
delete sprite;
delete eventHandler;
SDL_DestroyTexture(backbuffer);
}
// Actualiza las variables
void Instructions::update() {
// Bombea el stream de música: si no se llama, el buffer se vacía y la
// música se corta hasta que volvamos a una escena que sí lo haga.
JA_Update();
// Comprueba las entradas
checkInput();
// Actualiza las variables
if (SDL_GetTicks() - ticks > ticksSpeed) {
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
if (mode == m_auto) { // Modo automático
counter++;
if (counter == counterEnd) {
finished = true;
}
} else { // Modo manual
++counter %= 60000;
if (manualQuit) {
finished = true;
}
}
}
}
// Pinta en pantalla
void Instructions::render() {
// Pinta en pantalla
SDL_Rect window = {0, 0, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT};
SDL_Rect srcRect = {0, 0, 16, 16};
const color_t orangeColor = {0xFF, 0x7A, 0x00};
const SDL_Rect destRect1 = {60, 88 + (16 * 0), 16, 16}; // Disquito
const SDL_Rect destRect2 = {60, 88 + (16 * 1), 16, 16}; // Gavineixon
const SDL_Rect destRect3 = {60, 88 + (16 * 2), 16, 16}; // Pacmar
const SDL_Rect destRect4 = {60, 88 + (16 * 3), 16, 16}; // Time Stopper
const SDL_Rect destRect5 = {60, 88 + (16 * 4), 16, 16}; // Coffee
// Pinta en el backbuffer el texto y los sprites
SDL_SetRenderTarget(renderer, backbuffer);
SDL_SetRenderDrawColor(renderer, bgColor.r, bgColor.g, bgColor.b, 255);
SDL_RenderClear(renderer);
// Escribe el texto
text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, 8, lang->getText(11), 1, orangeColor, 1, shdwTxtColor);
text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, 24, lang->getText(12), 1, noColor, 1, shdwTxtColor);
text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, 34, lang->getText(13), 1, noColor, 1, shdwTxtColor);
text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, 48, lang->getText(14), 1, noColor, 1, shdwTxtColor);
text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, 58, lang->getText(15), 1, noColor, 1, shdwTxtColor);
text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, 75, lang->getText(16), 1, orangeColor, 1, shdwTxtColor);
text->writeShadowed(84, 92, lang->getText(17), shdwTxtColor);
text->writeShadowed(84, 108, lang->getText(18), shdwTxtColor);
text->writeShadowed(84, 124, lang->getText(19), shdwTxtColor);
text->writeShadowed(84, 140, lang->getText(20), shdwTxtColor);
text->writeShadowed(84, 156, lang->getText(21), shdwTxtColor);
if ((mode == m_manual) && (counter % 50 > 14)) {
text->writeDX(TXT_CENTER | TXT_COLOR | TXT_SHADOW, GAMECANVAS_CENTER_X, GAMECANVAS_HEIGHT - 12, lang->getText(22), 1, orangeColor, 1, shdwTxtColor);
}
// Disquito
sprite->setTexture(itemTextures[0]);
sprite->setPos(destRect1);
srcRect.y = 16 * (((counter + 12) / 36) % 2);
sprite->setSpriteClip(srcRect);
sprite->render();
// Gavineixon
sprite->setTexture(itemTextures[1]);
sprite->setPos(destRect2);
srcRect.y = 16 * (((counter + 9) / 36) % 2);
sprite->setSpriteClip(srcRect);
sprite->render();
// Pacmar
sprite->setTexture(itemTextures[2]);
sprite->setPos(destRect3);
srcRect.y = 16 * (((counter + 6) / 36) % 2);
sprite->setSpriteClip(srcRect);
sprite->render();
// Time Stopper
sprite->setTexture(itemTextures[3]);
sprite->setPos(destRect4);
srcRect.y = 16 * (((counter + 3) / 36) % 2);
sprite->setSpriteClip(srcRect);
sprite->render();
// Coffee
sprite->setTexture(itemTextures[4]);
sprite->setPos(destRect5);
srcRect.y = 16 * (((counter + 0) / 36) % 2);
sprite->setSpriteClip(srcRect);
sprite->render();
// Cambia el destino de renderizado
SDL_SetRenderTarget(renderer, nullptr);
// Prepara para empezar a dibujar en la textura de juego
screen->start();
// Limpia la pantalla
screen->clean(bgColor);
// Establece la ventana del backbuffer
if (mode == m_auto) {
window.y = std::max(8, GAMECANVAS_HEIGHT - counter + 100);
} else {
window.y = 0;
}
// Copia el backbuffer al renderizador
SDL_FRect fWindow = {(float)window.x, (float)window.y, (float)window.w, (float)window.h};
SDL_RenderTexture(renderer, backbuffer, nullptr, &fWindow);
// Vuelca el contenido del renderizador en pantalla
screen->blit();
}
// Comprueba los eventos
void Instructions::checkEvents() {
#ifndef __EMSCRIPTEN__
// Comprueba los eventos que hay en la cola
while (SDL_PollEvent(eventHandler) != 0) {
// Evento de salida de la aplicación
if (eventHandler->type == SDL_EVENT_QUIT) {
quitRequested = true;
finished = true;
break;
}
}
#endif
}
// Comprueba las entradas
void Instructions::checkInput() {
#ifndef __EMSCRIPTEN__
if (input->checkInput(input_exit, REPEAT_FALSE)) {
quitRequested = true;
finished = true;
} else
#endif
if (input->checkInput(input_window_fullscreen, REPEAT_FALSE)) {
screen->toggleVideoMode();
}
else if (input->checkInput(input_window_dec_size, REPEAT_FALSE)) {
screen->decWindowZoom();
}
else if (input->checkInput(input_window_inc_size, REPEAT_FALSE)) {
screen->incWindowZoom();
}
else if (input->checkInput(input_pause, REPEAT_FALSE) || input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_fire_left, REPEAT_FALSE) || input->checkInput(input_fire_center, REPEAT_FALSE) || input->checkInput(input_fire_right, REPEAT_FALSE)) {
if (mode == m_auto) {
finished = true;
} else {
if (counter > 30) {
manualQuit = true;
}
}
}
}
// Bucle para la pantalla de instrucciones (compatibilidad)
void Instructions::run(mode_e mode) {
start(mode);
while (!finished) {
update();
checkEvents();
render();
}
// Aplica los cambios de sección según el resultado
if (quitRequested) {
section->name = SECTION_PROG_QUIT;
} else {
section->name = SECTION_PROG_TITLE;
section->subsection = (mode == m_auto) ? SUBSECTION_TITLE_1 : SUBSECTION_TITLE_3;
}
}
// Inicia las instrucciones (sin bucle)
void Instructions::start(mode_e mode) {
this->mode = mode;
finished = false;
quitRequested = false;
manualQuit = false;
counter = 0;
ticks = 0;
}
// Indica si las instrucciones han terminado
bool Instructions::hasFinished() const {
return finished;
}
// Indica si se ha solicitado salir de la aplicación
bool Instructions::isQuitRequested() const {
return quitRequested;
}

76
source/game/scenes/instructions.h Normal file
View File

@@ -0,0 +1,76 @@
#pragma once
#include <SDL3/SDL.h>
#include <vector> // for vector
class Asset;
class Input;
class Lang;
class Screen;
class Sprite;
class Text;
class Texture;
struct section_t;
enum mode_e {
m_manual,
m_auto
};
// Clase Instructions
class Instructions {
private:
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
Screen *screen; // Objeto encargado de dibujar en pantalla
std::vector<Texture *> itemTextures; // Vector con las texturas de los items
SDL_Event *eventHandler; // Manejador de eventos
SDL_Texture *backbuffer; // Textura para usar como backbuffer
Sprite *sprite; // Sprite con la textura de las instrucciones
Asset *asset; // Objeto que gestiona todos los ficheros de recursos
Input *input; // Objeto pata gestionar la entrada
Lang *lang; // Objeto para gestionar los textos en diferentes idiomas
Text *text; // Objeto para escribir texto
section_t *section; // Estado del bucle principal para saber si continua o se sale
// Variables
Uint16 counter; // Contador
Uint16 counterEnd; // Valor final para el contador
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
bool manualQuit; // Indica si se quiere salir del modo manual
mode_e mode; // Modo en el que se van a ejecutar las instrucciones
bool finished; // Indica si las instrucciones han terminado
bool quitRequested; // Indica si se ha solicitado salir de la aplicación
// Comprueba las entradas
void checkInput();
public:
// Constructor
Instructions(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, Lang *lang, section_t *section);
// Destructor
~Instructions();
// Bucle principal
void run(mode_e mode);
// Inicia las instrucciones (sin bucle)
void start(mode_e mode);
// Actualiza las variables
void update();
// Pinta en pantalla
void render();
// Comprueba los eventos
void checkEvents();
// Indica si las instrucciones han terminado
bool hasFinished() const;
// Indica si se ha solicitado salir de la aplicación
bool isQuitRequested() const;
};

416
source/game/scenes/intro.cpp Normal file
View File

@@ -0,0 +1,416 @@
#include "game/scenes/intro.h"
#include <SDL3/SDL.h>
#include <string> // for basic_string
#include "core/audio/jail_audio.hpp" // for JA_StopMusic, JA_DeleteMusic, JA_LoadMusic
#include "core/input/input.h" // for Input, REPEAT_FALSE, inputs_e
#include "core/locale/lang.h" // for Lang
#include "core/rendering/screen.h" // for Screen
#include "core/rendering/smartsprite.h" // for SmartSprite
#include "core/rendering/text.h" // for Text
#include "core/rendering/texture.h" // for Texture
#include "core/rendering/writer.h" // for Writer
#include "core/resources/asset.h" // for Asset
#include "core/resources/resource.h"
#include "game/defaults.hpp" // for GAMECANVAS_CENTER_X, GAMECANVAS_FIRST_QU...
#include "utils/utils.h" // for section_t, color_t
// Constructor
Intro::Intro(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, Lang *lang, section_t *section) {
// Copia los punteros
this->renderer = renderer;
this->screen = screen;
this->lang = lang;
this->asset = asset;
this->input = input;
this->section = section;
// Reserva memoria para los objetos
eventHandler = new SDL_Event();
texture = Resource::get()->getTexture("intro.png");
text = Resource::get()->getText("nokia");
music = Resource::get()->getMusic("intro.ogg");
// Inicializa variables
section->name = SECTION_PROG_INTRO;
section->subsection = 0;
ticks = 0;
ticksSpeed = 15;
scene = 1;
// Inicializa los bitmaps de la intro
const int totalBitmaps = 6;
for (int i = 0; i < totalBitmaps; ++i) {
SmartSprite *ss = new SmartSprite(texture, renderer);
ss->setWidth(128);
ss->setHeight(96);
ss->setEnabledCounter(20);
ss->setDestX(GAMECANVAS_CENTER_X - 64);
ss->setDestY(GAMECANVAS_FIRST_QUARTER_Y - 24);
bitmaps.push_back(ss);
}
bitmaps[0]->setPosX(-128);
bitmaps[0]->setPosY(GAMECANVAS_FIRST_QUARTER_Y - 24);
bitmaps[0]->setVelX(0.0f);
bitmaps[0]->setVelY(0.0f);
bitmaps[0]->setAccelX(0.6f);
bitmaps[0]->setAccelY(0.0f);
bitmaps[0]->setSpriteClip(0, 0, 128, 96);
bitmaps[1]->setPosX(GAMECANVAS_WIDTH);
bitmaps[1]->setPosY(GAMECANVAS_FIRST_QUARTER_Y - 24);
bitmaps[1]->setVelX(-1.0f);
bitmaps[1]->setVelY(0.0f);
bitmaps[1]->setAccelX(-0.3f);
bitmaps[1]->setAccelY(0.0f);
bitmaps[1]->setSpriteClip(128, 0, 128, 96);
bitmaps[2]->setPosX(GAMECANVAS_CENTER_X - 64);
bitmaps[2]->setPosY(-96);
bitmaps[2]->setVelX(0.0f);
bitmaps[2]->setVelY(3.0f);
bitmaps[2]->setAccelX(0.1f);
bitmaps[2]->setAccelY(0.3f);
bitmaps[2]->setSpriteClip(0, 96, 128, 96);
bitmaps[2]->setEnabledCounter(250);
bitmaps[3]->setPosX(GAMECANVAS_CENTER_X - 64);
bitmaps[3]->setPosY(GAMECANVAS_HEIGHT);
bitmaps[3]->setVelX(0.0f);
bitmaps[3]->setVelY(-0.7f);
bitmaps[3]->setAccelX(0.0f);
bitmaps[3]->setAccelY(0.0f);
bitmaps[3]->setSpriteClip(128, 96, 128, 96);
bitmaps[4]->setPosX(GAMECANVAS_CENTER_X - 64);
bitmaps[4]->setPosY(-96);
bitmaps[4]->setVelX(0.0f);
bitmaps[4]->setVelY(3.0f);
bitmaps[4]->setAccelX(0.1f);
bitmaps[4]->setAccelY(0.3f);
bitmaps[4]->setSpriteClip(0, 192, 128, 96);
bitmaps[5]->setPosX(GAMECANVAS_WIDTH);
bitmaps[5]->setPosY(GAMECANVAS_FIRST_QUARTER_Y - 24);
bitmaps[5]->setVelX(-0.7f);
bitmaps[5]->setVelY(0.0f);
bitmaps[5]->setAccelX(0.0f);
bitmaps[5]->setAccelY(0.0f);
bitmaps[5]->setSpriteClip(128, 192, 128, 96);
// Inicializa los textos de la intro
const int totalTexts = 9;
for (int i = 0; i < totalTexts; ++i) {
Writer *w = new Writer(text);
w->setPosX(BLOCK * 0);
w->setPosY(GAMECANVAS_HEIGHT - (BLOCK * 6));
w->setKerning(-1);
w->setEnabled(false);
w->setEnabledCounter(180);
texts.push_back(w);
}
// Un dia qualsevol de l'any 2000
texts[0]->setCaption(lang->getText(27));
texts[0]->setSpeed(8);
// Tot esta tranquil a la UPV
texts[1]->setCaption(lang->getText(28));
texts[1]->setSpeed(8);
// Fins que un desaprensiu...
texts[2]->setCaption(lang->getText(29));
texts[2]->setSpeed(12);
// HEY! ME ANE A FERME UN CORTAET...
texts[3]->setCaption(lang->getText(30));
texts[3]->setSpeed(8);
// UAAAAAAAAAAAAA!!!
texts[4]->setCaption(lang->getText(31));
texts[4]->setSpeed(1);
// Espera un moment...
texts[5]->setCaption(lang->getText(32));
texts[5]->setSpeed(16);
// Si resulta que no tinc solt!
texts[6]->setCaption(lang->getText(33));
texts[6]->setSpeed(2);
// MERDA DE MAQUINA!
texts[7]->setCaption(lang->getText(34));
texts[7]->setSpeed(3);
// Blop... blop... blop...
texts[8]->setCaption(lang->getText(35));
texts[8]->setSpeed(16);
for (auto text : texts) {
text->center(GAMECANVAS_CENTER_X);
}
JA_PlayMusic(music, 0);
}
// Destructor
Intro::~Intro() {
delete eventHandler;
// texture, text, music son propiedad de Resource — no liberar aquí.
for (auto bitmap : bitmaps) {
delete bitmap;
}
for (auto t : texts) {
delete t;
}
}
// Carga los recursos (ya no carga nada, se mantiene por si hay callers)
bool Intro::loadMedia() {
return true;
}
// Comprueba los eventos
void Intro::checkEvents() {
#ifndef __EMSCRIPTEN__
// Comprueba los eventos que hay en la cola
while (SDL_PollEvent(eventHandler) != 0) {
// Evento de salida de la aplicación
if (eventHandler->type == SDL_EVENT_QUIT) {
section->name = SECTION_PROG_QUIT;
break;
}
}
#endif
}
// Comprueba las entradas
void Intro::checkInput() {
#ifndef __EMSCRIPTEN__
if (input->checkInput(input_exit, REPEAT_FALSE)) {
section->name = SECTION_PROG_QUIT;
} else
#endif
if (input->checkInput(input_window_fullscreen, REPEAT_FALSE)) {
screen->toggleVideoMode();
}
else if (input->checkInput(input_window_dec_size, REPEAT_FALSE)) {
screen->decWindowZoom();
}
else if (input->checkInput(input_window_inc_size, REPEAT_FALSE)) {
screen->incWindowZoom();
}
else if (input->checkInput(input_pause, REPEAT_FALSE) || input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_fire_left, REPEAT_FALSE) || input->checkInput(input_fire_center, REPEAT_FALSE) || input->checkInput(input_fire_right, REPEAT_FALSE)) {
JA_StopMusic();
section->name = SECTION_PROG_TITLE;
section->subsection = SUBSECTION_TITLE_1;
}
}
// Actualiza las escenas de la intro
void Intro::updateScenes() {
switch (scene) {
case 1:
// Primera imagen - UPV
if (!bitmaps[0]->hasFinished()) {
bitmaps[0]->setEnabled(true);
}
// Primer texto de la primera imagen
if (bitmaps[0]->hasFinished() && !texts[0]->hasFinished()) {
texts[0]->setEnabled(true);
}
// Segundo texto de la primera imagen
if (texts[0]->hasFinished() && !texts[1]->hasFinished()) {
texts[0]->setEnabled(false);
texts[1]->setEnabled(true);
}
// Tercer texto de la primera imagen
if (texts[1]->hasFinished() && !texts[2]->hasFinished()) {
texts[1]->setEnabled(false);
texts[2]->setEnabled(true);
}
// Fin de la primera escena
if (texts[2]->hasFinished()) {
bitmaps[0]->setEnabled(false);
texts[2]->setEnabled(false);
scene++;
}
break;
case 2:
// Segunda imagen - Máquina
if (!bitmaps[1]->hasFinished()) {
bitmaps[1]->setEnabled(true);
}
// Primer texto de la segunda imagen
if (bitmaps[1]->hasFinished() && !texts[3]->hasFinished()) {
texts[3]->setEnabled(true);
}
// Fin de la segunda escena
if (texts[3]->hasFinished()) {
bitmaps[1]->setEnabled(false);
texts[3]->setEnabled(false);
scene++;
}
break;
case 3:
// Tercera imagen junto con primer texto - GRITO
if (!bitmaps[2]->hasFinished() && !texts[4]->hasFinished()) {
bitmaps[2]->setEnabled(true);
texts[4]->setEnabled(true);
}
// Fin de la tercera escena
if (bitmaps[2]->hasFinished() && texts[4]->hasFinished()) {
bitmaps[2]->setEnabled(false);
texts[4]->setEnabled(false);
scene++;
}
break;
case 4:
// Cuarta imagen junto con primer texto - Reflexión
if (!bitmaps[3]->hasFinished() && !texts[5]->hasFinished()) {
bitmaps[3]->setEnabled(true);
texts[5]->setEnabled(true);
}
// Segundo texto de la cuarta imagen
if (texts[5]->hasFinished() && !texts[6]->hasFinished()) {
texts[5]->setEnabled(false);
texts[6]->setEnabled(true);
}
// Fin de la cuarta escena
if (bitmaps[3]->hasFinished() && texts[6]->hasFinished()) {
bitmaps[3]->setEnabled(false);
texts[6]->setEnabled(false);
scene++;
}
break;
case 5:
// Quinta imagen - Patada
if (!bitmaps[4]->hasFinished()) {
bitmaps[4]->setEnabled(true);
}
// Primer texto de la quinta imagen
if (bitmaps[4]->hasFinished() && !texts[7]->hasFinished()) {
texts[7]->setEnabled(true);
}
// Fin de la quinta escena
if (bitmaps[4]->hasFinished() && texts[7]->hasFinished()) {
bitmaps[4]->setEnabled(false);
texts[7]->setEnabled(false);
scene++;
}
break;
case 6:
// Sexta imagen junto con texto - Globos de café
if (!bitmaps[5]->hasFinished() && !texts[8]->hasFinished()) {
bitmaps[5]->setEnabled(true);
texts[8]->setEnabled(true);
}
// Acaba el último texto
if (bitmaps[5]->hasFinished() && texts[8]->hasFinished()) {
bitmaps[5]->setEnabled(false);
texts[8]->setEnabled(false);
JA_StopMusic();
section->name = SECTION_PROG_TITLE;
section->subsection = SUBSECTION_TITLE_1;
}
break;
default:
break;
}
}
// Actualiza las variables del objeto
void Intro::update() {
JA_Update();
checkInput();
if (SDL_GetTicks() - ticks > ticksSpeed) {
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
// Actualiza los objetos
for (auto bitmap : bitmaps) {
bitmap->update();
}
for (auto text : texts) {
text->update();
}
// Actualiza las escenas de la intro
updateScenes();
}
}
// Dibuja el objeto en pantalla
void Intro::render() {
// Prepara para empezar a dibujar en la textura de juego
screen->start();
// Limpia la pantalla
screen->clean(bgColor);
// Dibuja los objetos
for (auto bitmap : bitmaps) {
bitmap->render();
}
for (auto text : texts) {
text->render();
}
// Vuelca el contenido del renderizador en pantalla
screen->blit();
}
// Bucle principal
void Intro::run() {
JA_PlayMusic(music, 0);
while (section->name == SECTION_PROG_INTRO) {
iterate();
}
}
// Ejecuta un frame
void Intro::iterate() {
update();
render();
}
// Procesa un evento individual
void Intro::handleEvent(SDL_Event *event) {
// SDL_EVENT_QUIT ya lo maneja Director
}

72
source/game/scenes/intro.h Normal file
View File

@@ -0,0 +1,72 @@
#pragma once
#include <SDL3/SDL.h>
#include <vector> // for vector
class Asset;
class Input;
class Lang;
class Screen;
class SmartSprite;
class Text;
class Texture;
class Writer;
struct JA_Music_t;
struct section_t;
// Clase Intro
class Intro {
private:
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
Screen *screen; // Objeto encargado de dibujar en pantalla
Texture *texture; // Textura con los graficos
SDL_Event *eventHandler; // Manejador de eventos
Asset *asset; // Objeto que gestiona todos los ficheros de recursos
Lang *lang; // Objeto para gestionar los textos en diferentes idiomas
Input *input; // Objeto pata gestionar la entrada
std::vector<SmartSprite *> bitmaps; // Vector con los sprites inteligentes para los dibujos de la intro
std::vector<Writer *> texts; // Textos de la intro
Text *text; // Textos de la intro
section_t *section; // Estado del bucle principal para saber si continua o se sale
// Variables
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint8 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
JA_Music_t *music; // Musica para la intro
int scene; // Indica que escena está activa
// Actualiza las variables del objeto
void update();
// Dibuja el objeto en pantalla
void render();
// Carga los recursos
bool loadMedia();
// Comprueba los eventos
void checkEvents();
// Comprueba las entradas
void checkInput();
// Actualiza las escenas de la intro
void updateScenes();
public:
// Constructor
Intro(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, Lang *lang, section_t *section);
// Destructor
~Intro();
// Bucle principal
void run();
// Ejecuta un frame
void iterate();
// Procesa un evento
void handleEvent(SDL_Event *event);
};

164
source/game/scenes/logo.cpp Normal file
View File

@@ -0,0 +1,164 @@
#include "game/scenes/logo.h"
#include <SDL3/SDL.h>
#include <algorithm> // for min
#include <string> // for basic_string
#include "core/audio/jail_audio.hpp" // for JA_StopMusic
#include "core/input/input.h" // for Input, REPEAT_FALSE, inputs_e
#include "core/rendering/screen.h" // for Screen
#include "core/rendering/sprite.h" // for Sprite
#include "core/rendering/texture.h" // for Texture
#include "core/resources/asset.h" // for Asset
#include "core/resources/resource.h"
#include "game/defaults.hpp" // for bgColor, SECTION_PROG_LOGO, SECTION_PROG...
#include "utils/utils.h" // for section_t, color_t
// Valores de inicialización y fin
constexpr int INIT_FADE = 100;
constexpr int END_LOGO = 200;
// Constructor
Logo::Logo(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, section_t *section) {
// Copia la dirección de los objetos
this->renderer = renderer;
this->screen = screen;
this->asset = asset;
this->input = input;
this->section = section;
// Reserva memoria para los punteros
eventHandler = new SDL_Event();
texture = Resource::get()->getTexture("logo.png");
sprite = new Sprite(14, 75, 226, 44, texture, renderer);
// Inicializa variables
counter = 0;
section->name = SECTION_PROG_LOGO;
section->subsection = 0;
ticks = 0;
ticksSpeed = 15;
JA_StopMusic();
}
// Destructor
Logo::~Logo() {
// texture es propiedad de Resource — no liberar aquí.
delete sprite;
delete eventHandler;
}
// Comprueba si ha terminado el logo
void Logo::checkLogoEnd() {
if (counter >= END_LOGO + 20) {
section->name = SECTION_PROG_INTRO;
section->subsection = 0;
}
}
// Comprueba los eventos
void Logo::checkEvents() {
#ifndef __EMSCRIPTEN__
// Comprueba los eventos que hay en la cola
while (SDL_PollEvent(eventHandler) != 0) {
// Evento de salida de la aplicación
if (eventHandler->type == SDL_EVENT_QUIT) {
section->name = SECTION_PROG_QUIT;
break;
}
}
#endif
}
// Comprueba las entradas
void Logo::checkInput() {
#ifndef __EMSCRIPTEN__
if (input->checkInput(input_exit, REPEAT_FALSE)) {
section->name = SECTION_PROG_QUIT;
} else
#endif
if (input->checkInput(input_window_fullscreen, REPEAT_FALSE)) {
screen->toggleVideoMode();
}
else if (input->checkInput(input_window_dec_size, REPEAT_FALSE)) {
screen->decWindowZoom();
}
else if (input->checkInput(input_window_inc_size, REPEAT_FALSE)) {
screen->incWindowZoom();
}
else if (input->checkInput(input_pause, REPEAT_FALSE) || input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_fire_left, REPEAT_FALSE) || input->checkInput(input_fire_center, REPEAT_FALSE) || input->checkInput(input_fire_right, REPEAT_FALSE)) {
section->name = SECTION_PROG_TITLE;
section->subsection = SUBSECTION_TITLE_1;
}
}
// Dibuja el fade
void Logo::renderFade() {
// Dibuja el fade
if (counter >= INIT_FADE) {
const float step = (float)(counter - INIT_FADE) / (float)(END_LOGO - INIT_FADE);
const int alpha = std::min((int)(255 * step), 255);
SDL_SetRenderDrawColor(renderer, bgColor.r, bgColor.g, bgColor.b, alpha);
SDL_RenderFillRect(renderer, nullptr);
}
}
// Actualiza las variables del objeto
void Logo::update() {
JA_Update();
checkInput();
if (SDL_GetTicks() - ticks > ticksSpeed) {
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
// Actualiza el contador
counter++;
// Comprueba si ha terminado el logo
checkLogoEnd();
}
}
// Dibuja el objeto en pantalla
void Logo::render() {
// Prepara para empezar a dibujar en la textura de juego
screen->start();
// Limpia la pantalla
screen->clean({238, 238, 238});
// Dibuja los objetos
sprite->render();
// Dibuja el fade
renderFade();
// Vuelca el contenido del renderizador en pantalla
screen->blit();
}
// Bucle para el logo del juego
void Logo::run() {
JA_StopMusic();
while (section->name == SECTION_PROG_LOGO) {
iterate();
}
}
// Ejecuta un frame
void Logo::iterate() {
update();
render();
}
// Procesa un evento individual
void Logo::handleEvent(SDL_Event *event) {
// SDL_EVENT_QUIT ya lo maneja Director
}

62
source/game/scenes/logo.h Normal file
View File

@@ -0,0 +1,62 @@
#pragma once
#include <SDL3/SDL.h>
class Asset;
class Input;
class Screen;
class Sprite;
class Texture;
struct section_t;
// Clase Logo
class Logo {
private:
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
Screen *screen; // Objeto encargado de dibujar en pantalla
Asset *asset; // Objeto que gestiona todos los ficheros de recursos
Input *input; // Objeto pata gestionar la entrada
Texture *texture; // Textura con los graficos
SDL_Event *eventHandler; // Manejador de eventos
Sprite *sprite; // Sprite con la textura del logo
section_t *section; // Estado del bucle principal para saber si continua o se sale
// Variables
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
int counter; // Contador
// Actualiza las variables del objeto
void update();
// Dibuja el objeto en pantalla
void render();
// Comprueba si ha terminado el logo
void checkLogoEnd();
// Comprueba los eventos
void checkEvents();
// Comprueba las entradas
void checkInput();
// Dibuja el fade
void renderFade();
public:
// Constructor
Logo(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input, section_t *section);
// Destructor
~Logo();
// Bucle principal
void run();
// Ejecuta un frame
void iterate();
// Procesa un evento
void handleEvent(SDL_Event *event);
};

1129
source/game/scenes/title.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

165
source/game/scenes/title.h Normal file
View File

@@ -0,0 +1,165 @@
#pragma once
#include <SDL3/SDL.h>
#include <vector> // for vector
#include "game/scenes/instructions.h" // for mode_e
#include "utils/utils.h" // for input_t, options_t, section_t
class AnimatedSprite;
class Asset;
class Fade;
class Game;
class Input;
class Lang;
class Menu;
class Screen;
class SmartSprite;
class Sprite;
class Text;
class Texture;
struct JA_Music_t;
struct JA_Sound_t;
// Textos
constexpr const char *TEXT_COPYRIGHT = "@2020 JailDesigner (v2.3.4)";
// Contadores
constexpr int TITLE_COUNTER = 800;
// Cantidad de eventos de la pantalla de título
constexpr int TITLE_TOTAL_EVENTS = 2;
class Title {
private:
struct menu_t {
Menu *title; // Menu de la pantalla de título
Menu *options; // Menú de la pantalla de opciones
Menu *playerSelect; // Menu para elegir jugador
Menu *active; // Menu activo (de momento para la pantalla del titulo)
bool keyPressed; // Variable para evitar la repetición de teclas en los menus
};
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
Screen *screen; // Objeto encargado de dibujar en pantalla
Asset *asset; // Objeto que gestiona todos los ficheros de recursos
Input *input; // Objeto para leer las entradas de teclado o mando
Lang *lang; // Objeto para gestionar los textos en diferentes idiomas
Instructions *instructions; // Objeto para la sección de las instrucciones
Game *demoGame; // Objeto para lanzar la demo del juego
SDL_Event *eventHandler; // Manejador de eventos
section_t *section; // Indicador para el bucle del titulo
Texture *dustTexture; // Textura con los graficos del polvo
Texture *coffeeTexture; // Textura con los graficos de la palabra coffee
Texture *crisisTexture; // Textura con los graficos de la plabra crisis
Texture *gradientTexture; // Textura con los graficos para el degradado del fondo del titulo
SDL_Rect backgroundWindow; // Ventana visible para la textura de fondo del titulo
SDL_Texture *background; // Textura dibujar el fondo del titulo
AnimatedSprite *dustBitmapL; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
AnimatedSprite *dustBitmapR; // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
SmartSprite *coffeeBitmap; // Sprite con la palabra COFFEE para la pantalla de titulo
SmartSprite *crisisBitmap; // Sprite con la palabra CRISIS para la pantalla de titulo
Sprite *gradient; // Sprite para dibujar el degradado del titulo
Text *text1; // Objeto de texto para poder escribir textos en pantalla
Text *text2; // Objeto de texto para poder escribir textos en pantalla
Fade *fade; // Objeto para realizar fundidos en pantalla
// Variable
JA_Music_t *titleMusic; // Musica para el titulo
JA_Sound_t *crashSound; // Sonido con el impacto del título
int backgroundCounter; // Temporizador para el fondo de tiles de la pantalla de titulo
int counter; // Temporizador para la pantalla de titulo
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint8 backgroundMode; // Variable para almacenar el tipo de efecto que hará el fondo de la pantalla de titulo
float sin[360]; // Vector con los valores del seno precalculados
bool menuVisible; // Indicador para saber si se muestra el menu del titulo o la frase intermitente
bool demo; // Indica si el modo demo estará activo
section_t nextSection; // Indica cual es la siguiente sección a cargar cuando termine el contador del titulo
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
Uint8 postFade; // Opción a realizar cuando termina el fundido
menu_t menu; // Variable con todos los objetos menus y sus variables
struct options_t *options; // Variable con todas las variables de las opciones del programa
options_t optionsPrevious; // Variable de respaldo para las opciones
std::vector<input_t> availableInputDevices; // Vector con todos los metodos de control disponibles
std::vector<int> deviceIndex; // Indice para el jugador [i] del vector de dispositivos de entrada disponibles
// Variables para la vibración del título (SUBSECTION_TITLE_2)
int vibrationStep; // Paso actual de la vibración
int vibrationCoffeeBaseX; // Posición X base del bitmap Coffee
int vibrationCrisisBaseX; // Posición X base del bitmap Crisis
bool vibrationInitialized; // Indica si se han capturado las posiciones base
// Variables para sub-estados delegados (instrucciones y demo)
bool instructionsActive; // Indica si las instrucciones están activas
bool demoGameActive; // Indica si el juego demo está activo
mode_e instructionsMode; // Modo de las instrucciones activas
bool demoThenInstructions; // Indica si tras la demo hay que mostrar instrucciones
// Inicializa los valores
void init();
// Actualiza las variables del objeto
void update();
// Dibuja el objeto en pantalla
void render();
// Comprueba los eventos
void checkEvents();
// Comprueba las entradas
void checkInput();
// Actualiza el tileado de fondo
void updateBG();
// Cambia el valor de la variable de modo de pantalla completa
void switchFullScreenModeVar();
// Actualiza los elementos de los menus
void updateMenuLabels();
// Aplica las opciones de menu seleccionadas
void applyOptions();
// Ejecuta la parte donde se muestran las instrucciones
void runInstructions(mode_e mode);
// Ejecuta el juego en modo demo
void runDemoGame();
// Modifica las opciones para los controles de los jugadores
bool updatePlayerInputs(int numPlayer);
// Crea el mosaico de fondo del titulo
void createTiledBackground();
// Comprueba cuantos mandos hay conectados para gestionar el menu de opciones
void checkInputDevices();
// Recarga las texturas
void reLoadTextures();
public:
// Constructor
Title(SDL_Renderer *renderer, Screen *screen, Input *input, Asset *asset, options_t *options, Lang *lang, section_t *section);
// Destructor
~Title();
// Bucle para el titulo del juego
void run();
// Ejecuta un frame
void iterate();
// Procesa un evento
void handleEvent(SDL_Event *event);
};

898
source/game/ui/menu.cpp Normal file
View File

@@ -0,0 +1,898 @@
#include "game/ui/menu.h"
#include <algorithm> // for max, min
#include <fstream> // for char_traits, basic_ifstream, basic_istream
#include <sstream> // for basic_stringstream
#include "core/audio/jail_audio.hpp" // for JA_LoadSound, JA_PlaySound, JA_DeleteSound
#include "core/input/input.h" // for Input, REPEAT_FALSE, inputs_e
#include "core/rendering/text.h" // for Text
#include "core/resources/asset.h" // for Asset
#include "core/resources/resource_helper.h"
// Constructor
Menu::Menu(SDL_Renderer *renderer, Asset *asset, Input *input, std::string file) {
// Copia punteros
this->renderer = renderer;
this->asset = asset;
this->input = input;
// Inicializa punteros
soundMove = nullptr;
soundAccept = nullptr;
soundCancel = nullptr;
// Inicializa variables
name = "";
selector.index = 0;
selector.previousIndex = 0;
itemSelected = MENU_NO_OPTION;
x = 0;
y = 0;
w = 0;
rectBG.rect = {0, 0, 0, 0};
rectBG.color = {0, 0, 0};
rectBG.a = 0;
backgroundType = MENU_BACKGROUND_SOLID;
isCenteredOnX = false;
isCenteredOnY = false;
areElementsCenteredOnX = false;
centerX = 0;
centerY = 0;
widestItem = 0;
colorGreyed = {128, 128, 128};
defaultActionWhenCancel = 0;
font_png = "";
font_txt = "";
// Selector
selector.originY = 0;
selector.targetY = 0;
selector.despY = 0;
selector.originH = 0;
selector.targetH = 0;
selector.incH = 0;
selector.y = 0.0f;
selector.h = 0.0f;
selector.numJumps = 8;
selector.moving = false;
selector.resizing = false;
selector.rect = {0, 0, 0, 0};
selector.color = {0, 0, 0};
selector.itemColor = {0, 0, 0};
selector.a = 255;
// Inicializa las variables desde un fichero. Si no se pasa fichero, el
// llamante (p.ej. Resource::preloadAll) usará loadFromBytes después —
// y ese método ya llama a setSelectorItemColors() y reset() al final.
if (file != "") {
load(file);
setSelectorItemColors();
reset();
}
}
Menu::~Menu() {
renderer = nullptr;
asset = nullptr;
input = nullptr;
if (soundMove) {
JA_DeleteSound(soundMove);
}
if (soundAccept) {
JA_DeleteSound(soundAccept);
}
if (soundCancel) {
JA_DeleteSound(soundCancel);
}
if (text != nullptr) {
delete text;
}
}
// Parser compartido (recibe cualquier istream)
bool Menu::parseFromStream(std::istream &file, const std::string &filename) {
bool success = true;
bool textAllocated = false;
std::string line;
(void)filename;
while (std::getline(file, line)) {
if (line == "[item]") {
item_t item;
item.label = "";
item.hPaddingDown = 1;
item.selectable = true;
item.greyed = false;
item.linkedDown = false;
item.visible = true;
item.line = false;
do {
std::getline(file, line);
int pos = line.find("=");
if (!setItem(&item, line.substr(0, pos), line.substr(pos + 1, line.length()))) {
success = false;
}
} while (line != "[/item]");
addItem(item);
} else {
int pos = line.find("=");
if (!setVars(line.substr(0, pos), line.substr(pos + 1, line.length()))) {
success = false;
}
// Crea el objeto text tan pronto como se pueda. Necesario para añadir items.
// Carga via ResourceHelper para que funcione tanto con pack como con filesystem.
if (font_png != "" && font_txt != "" && !textAllocated) {
auto pngBytes = ResourceHelper::loadFile(asset->get(font_png));
auto txtBytes = ResourceHelper::loadFile(asset->get(font_txt));
text = new Text(pngBytes, txtBytes, renderer);
textAllocated = true;
}
}
}
return success;
}
// Carga la configuración del menu desde un archivo de texto
bool Menu::load(std::string file_path) {
const std::string filename = file_path.substr(file_path.find_last_of("\\/") + 1);
std::ifstream file(file_path);
if (!file.good()) {
return false;
}
return parseFromStream(file, filename);
}
// Carga el menu desde bytes en memoria
bool Menu::loadFromBytes(const std::vector<uint8_t> &bytes, const std::string &nameForLogs) {
if (bytes.empty()) return false;
std::string content(reinterpret_cast<const char *>(bytes.data()), bytes.size());
std::stringstream ss(content);
bool ok = parseFromStream(ss, nameForLogs);
setSelectorItemColors();
reset();
return ok;
}
// Asigna variables a partir de dos cadenas
bool Menu::setItem(item_t *item, std::string var, std::string value) {
// Indicador de éxito en la asignación
bool success = true;
if (var == "text") {
item->label = value;
}
else if (var == "hPaddingDown") {
item->hPaddingDown = std::stoi(value);
}
else if (var == "selectable") {
item->selectable = value == "true" ? true : false;
}
else if (var == "greyed") {
item->greyed = value == "true" ? true : false;
}
else if (var == "linkedDown") {
item->linkedDown = value == "true" ? true : false;
}
else if (var == "visible") {
item->visible = value == "true" ? true : false;
}
else if (var == "line") {
item->line = value == "true" ? true : false;
}
else if ((var == "") || (var == "[/item]")) {
}
else {
success = false;
}
return success;
}
// Asigna variables a partir de dos cadenas
bool Menu::setVars(std::string var, std::string value) {
// Indicador de éxito en la asignación
bool success = true;
if (var == "font_png") {
font_png = value;
}
else if (var == "font_txt") {
font_txt = value;
}
else if (var == "sound_cancel") {
auto bytes = ResourceHelper::loadFile(asset->get(value));
if (!bytes.empty()) soundCancel = JA_LoadSound(bytes.data(), (uint32_t)bytes.size());
}
else if (var == "sound_accept") {
auto bytes = ResourceHelper::loadFile(asset->get(value));
if (!bytes.empty()) soundAccept = JA_LoadSound(bytes.data(), (uint32_t)bytes.size());
}
else if (var == "sound_move") {
auto bytes = ResourceHelper::loadFile(asset->get(value));
if (!bytes.empty()) soundMove = JA_LoadSound(bytes.data(), (uint32_t)bytes.size());
}
else if (var == "name") {
name = value;
}
else if (var == "x") {
x = std::stoi(value);
}
else if (var == "centerX") {
centerX = std::stoi(value);
}
else if (var == "centerY") {
centerY = std::stoi(value);
}
else if (var == "y") {
y = std::stoi(value);
}
else if (var == "backgroundType") {
backgroundType = std::stoi(value);
}
else if (var == "backgroundColor") {
// Se introducen los valores separados por comas en un vector
std::stringstream ss(value);
std::string tmp;
getline(ss, tmp, ',');
rectBG.color.r = std::stoi(tmp);
getline(ss, tmp, ',');
rectBG.color.g = std::stoi(tmp);
getline(ss, tmp, ',');
rectBG.color.b = std::stoi(tmp);
getline(ss, tmp, ',');
rectBG.a = std::stoi(tmp);
}
else if (var == "selector_color") {
// Se introducen los valores separados por comas en un vector
std::stringstream ss(value);
std::string tmp;
getline(ss, tmp, ',');
selector.color.r = std::stoi(tmp);
getline(ss, tmp, ',');
selector.color.g = std::stoi(tmp);
getline(ss, tmp, ',');
selector.color.b = std::stoi(tmp);
getline(ss, tmp, ',');
selector.a = std::stoi(tmp);
}
else if (var == "selector_text_color") {
// Se introducen los valores separados por comas en un vector
std::stringstream ss(value);
std::string tmp;
getline(ss, tmp, ',');
selector.itemColor.r = std::stoi(tmp);
getline(ss, tmp, ',');
selector.itemColor.g = std::stoi(tmp);
getline(ss, tmp, ',');
selector.itemColor.b = std::stoi(tmp);
}
else if (var == "areElementsCenteredOnX") {
areElementsCenteredOnX = value == "true" ? true : false;
}
else if (var == "isCenteredOnX") {
isCenteredOnX = value == "true" ? true : false;
}
else if (var == "isCenteredOnY") {
isCenteredOnY = value == "true" ? true : false;
}
else if (var == "defaultActionWhenCancel") {
defaultActionWhenCancel = std::stoi(value);
}
else if (var == "") {
}
else {
success = false;
}
return success;
}
// Carga los ficheros de audio
void Menu::loadAudioFile(std::string file, int sound) {
switch (sound) {
case SOUND_ACCEPT:
soundAccept = JA_LoadSound(file.c_str());
break;
case SOUND_CANCEL:
soundCancel = JA_LoadSound(file.c_str());
break;
case SOUND_MOVE:
soundMove = JA_LoadSound(file.c_str());
break;
default:
break;
}
}
// Obtiene el nombre del menu
std::string Menu::getName() {
return name;
}
// Obtiene el valor de la variable
int Menu::getItemSelected() {
// Al llamar a esta funcion, se obtiene el valor y se borra
const int temp = itemSelected;
itemSelected = MENU_NO_OPTION;
return temp;
}
// Actualiza la posicion y el estado del selector
void Menu::updateSelector() {
if (selector.moving) {
// Calcula el desplazamiento en Y
selector.y += selector.despY;
if (selector.despY > 0) // Va hacia abajo
{
if (selector.y > selector.targetY) // Ha llegado al destino
{
selector.originY = selector.y = selector.targetY;
selector.moving = false;
}
}
else if (selector.despY < 0) // Va hacia arriba
{
if (selector.y < selector.targetY) // Ha llegado al destino
{
selector.originY = selector.y = selector.targetY;
selector.moving = false;
}
}
selector.rect.y = int(selector.y);
// Actualiza el color del item
selector.itemColorIndex++;
selector.itemColorIndex = std::min(selector.numJumps - 1, selector.itemColorIndex);
selector.itemColor = selector.jumpItemColors[selector.itemColorIndex];
selector.previousItemColor = selector.jumpItemColors[selector.numJumps - 1 - selector.itemColorIndex];
} else {
selector.rect.y = int(selector.y);
selector.itemColorIndex = 0;
selector.itemColor = selector.jumpItemColors[selector.numJumps - 1];
selector.previousItemColor = selector.jumpItemColors[0];
}
if (selector.resizing) {
// Calcula el incremento en H
selector.h += selector.incH;
if (selector.incH > 0) // Crece
{
if (selector.h > selector.targetH) // Ha llegado al destino
{
// selector.originH = selector.targetH = selector.rect.h = getSelectorHeight(selector.index);
selector.originH = selector.h = selector.targetH;
selector.resizing = false;
}
}
else if (selector.incH < 0) // Decrece
{
if (selector.h < selector.targetH) // Ha llegado al destino
{
// selector.originH = selector.targetH = selector.rect.h = getSelectorHeight(selector.index);
selector.originH = selector.h = selector.targetH;
selector.resizing = false;
}
}
selector.rect.h = int(selector.h);
} else {
selector.rect.h = getSelectorHeight(selector.index);
}
}
// Coloca el selector en una posición específica
void Menu::setSelectorPos(int index) {
if (index < (int)item.size()) {
selector.index = index;
selector.rect.y = selector.y = selector.originY = selector.targetY = item[selector.index].rect.y;
selector.rect.w = rectBG.rect.w;
selector.rect.x = rectBG.rect.x;
selector.originH = selector.targetH = selector.rect.h = getSelectorHeight(selector.index);
selector.moving = false;
selector.resizing = false;
}
}
// Obtiene la anchura del elemento más ancho del menu
int Menu::getWidestItem() {
int result = 0;
// Obtenemos la anchura del item mas ancho
for (auto &i : item) {
result = std::max(result, i.rect.w);
}
return result;
}
// Deja el menu apuntando al primer elemento
void Menu::reset() {
itemSelected = MENU_NO_OPTION;
selector.index = 0;
selector.originY = selector.targetY = selector.y = item[0].rect.y;
selector.originH = selector.targetH = item[0].rect.h;
selector.moving = false;
selector.resizing = false;
// Si el primer elemento no es seleccionable, incrementa el selector
if (!item[selector.index].selectable) {
increaseSelectorIndex();
setSelectorPos(selector.index);
}
}
// Actualiza el menu para recolocarlo correctamente y establecer el tamaño
void Menu::reorganize() {
setRectSize();
if (isCenteredOnX) {
centerMenuOnX(centerX);
}
if (isCenteredOnY) {
centerMenuOnY(centerY);
}
if (areElementsCenteredOnX) {
centerMenuElementsOnX();
}
}
// Deja el menu apuntando al siguiente elemento
bool Menu::increaseSelectorIndex() {
// Guarda el indice actual antes de modificarlo
selector.previousIndex = selector.index;
// Obten las coordenadas del elemento actual
selector.y = selector.originY = item[selector.index].rect.y;
selector.h = selector.originH = getSelectorHeight(selector.index);
// Calcula cual es el siguiente elemento
++selector.index %= item.size();
while (!item[selector.index].selectable) {
++selector.index %= item.size();
}
// Establece las coordenadas y altura de destino
selector.targetY = item[selector.index].rect.y;
selector.despY = (selector.targetY - selector.originY) / selector.numJumps;
selector.targetH = getSelectorHeight(selector.index);
selector.incH = (selector.targetH - selector.originH) / selector.numJumps;
selector.moving = true;
if (selector.incH != 0) {
selector.resizing = true;
}
return true;
}
// Deja el menu apuntando al elemento anterior
bool Menu::decreaseSelectorIndex() {
// Guarda el indice actual antes de modificarlo
selector.previousIndex = selector.index;
// Obten las coordenadas del elemento actual
selector.y = selector.originY = item[selector.index].rect.y;
selector.h = selector.originH = getSelectorHeight(selector.index);
// Calcula cual es el siguiente elemento
if (selector.index == 0) {
selector.index = item.size() - 1;
} else {
selector.index--;
}
while (!item[selector.index].selectable) {
if (selector.index == 0) {
selector.index = item.size() - 1;
} else {
selector.index--;
}
}
// Establece las coordenadas y altura de destino
selector.targetY = item[selector.index].rect.y;
selector.despY = (selector.targetY - selector.originY) / selector.numJumps;
selector.targetH = getSelectorHeight(selector.index);
selector.incH = (selector.targetH - selector.originH) / selector.numJumps;
selector.moving = true;
if (selector.incH != 0) {
selector.resizing = true;
}
return true;
}
// Actualiza la logica del menu
void Menu::update() {
checkInput();
updateSelector();
}
// Pinta el menu en pantalla
void Menu::render() {
// Rendereritza el fondo del menu
if (backgroundType == MENU_BACKGROUND_SOLID) {
SDL_FRect fBG = {(float)rectBG.rect.x, (float)rectBG.rect.y, (float)rectBG.rect.w, (float)rectBG.rect.h};
SDL_SetRenderDrawColor(renderer, rectBG.color.r, rectBG.color.g, rectBG.color.b, rectBG.a);
SDL_RenderFillRect(renderer, &fBG);
}
// Renderiza el rectangulo del selector
const SDL_FRect fTemp = {(float)selector.rect.x, (float)(selector.rect.y - 1), (float)selector.rect.w, (float)(selector.rect.h + 1)};
SDL_SetRenderDrawColor(renderer, selector.color.r, selector.color.g, selector.color.b, selector.a);
SDL_RenderFillRect(renderer, &fTemp);
// Renderiza el borde del fondo
if (backgroundType == MENU_BACKGROUND_SOLID) {
SDL_FRect fBGBorder = {(float)rectBG.rect.x, (float)rectBG.rect.y, (float)rectBG.rect.w, (float)rectBG.rect.h};
SDL_SetRenderDrawColor(renderer, rectBG.color.r, rectBG.color.g, rectBG.color.b, 255);
SDL_RenderRect(renderer, &fBGBorder);
}
// Crea una linea por si hay que dibujarla entre los items
h_line_t line;
line.x1 = selector.rect.x + (selector.rect.w / 6);
line.x2 = line.x1 + ((selector.rect.w / 6) * 4);
// Renderiza el texto
for (int i = 0; i < (int)item.size(); ++i) {
if (item[i].visible) {
// Comprueba si ha de dibujar una linea en el elemento del menu
if (item[i].line) {
line.y = item[i].rect.y + item[i].rect.h + (item[i].hPaddingDown / 2) - 1;
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 64);
SDL_RenderLine(renderer, line.x1, line.y, line.x2, line.y);
}
// Dibuja el elemento
if (item[i].greyed) { // Tiene prioridad si el elemento es gris
text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, colorGreyed);
}
else if (i == selector.index) { // A continuación si tiene el indice
const color_t color = {selector.itemColor.r, selector.itemColor.g, selector.itemColor.b};
text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, color);
}
else if (i == selector.previousIndex) { // O si lo ha tenido
const color_t color = {selector.previousItemColor.r, selector.previousItemColor.g, selector.previousItemColor.b};
text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, color);
}
else if (item[i].selectable) { // O si simplemente es un elemento normal
text->write(item[i].rect.x, item[i].rect.y, item[i].label);
}
else { // Si no es seleccionable
if ((item[i].linkedUp) && (i == selector.index + 1)) { // Si el elemento está enlazado con el elemento superior se pinta del color del selector
const color_t color = {selector.itemColor.r, selector.itemColor.g, selector.itemColor.b};
text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, color);
} else { // Si no está enlazado con el elemento superior se pinta con el color normal
text->write(item[i].rect.x, item[i].rect.y, item[i].label);
}
}
}
}
}
// Establece el rectangulo de fondo del menu y el selector
void Menu::setRectSize(int w, int h) {
// Establece el ancho
if (w == 0) { // Si no se pasa un valor, se busca si hay uno prefijado
if (this->w == 0) { // Si no hay prefijado, coge el item mas ancho
rectBG.rect.w = findWidth() + text->getCharacterSize();
} else { // Si hay prefijado, coge ese
rectBG.rect.w = this->w;
}
} else { // Si se pasa un valor, se usa y se prefija
rectBG.rect.w = w;
this->w = w;
}
// Establece el alto
if (h == 0) { // Si no se pasa un valor, se busca de manera automatica
rectBG.rect.h = findHeight() + text->getCharacterSize();
} else { // Si se pasa un valor, se aplica
rectBG.rect.h = h;
}
// La posición X es la del menú menos medio caracter
if (this->w != 0) { // Si el ancho esta prefijado, la x coinccide
rectBG.rect.x = x;
} else { // Si el ancho es automatico, se le da un poco de margen
rectBG.rect.x = x - (text->getCharacterSize() / 2);
}
// La posición Y es la del menu menos la altura de medio caracter
rectBG.rect.y = y - (text->getCharacterSize() / 2);
// Establecemos los valores del rectangulo del selector a partir de los valores del rectangulo de fondo
setSelectorPos(selector.index);
}
// Establece el color del rectangulo de fondo
void Menu::setBackgroundColor(color_t color, int alpha) {
rectBG.color = color;
rectBG.a = alpha;
}
// Establece el color del rectangulo del selector
void Menu::setSelectorColor(color_t color, int alpha) {
selector.color = color;
selector.a = alpha;
}
// Establece el color del texto del selector
void Menu::setSelectorTextColor(color_t color) {
selector.itemColor = color;
}
// Centra el menu respecto un punto en el eje X
void Menu::centerMenuOnX(int value) {
isCenteredOnX = true;
if (value != 0) {
centerX = value;
} else if (centerX == 0) {
return;
}
// Establece la nueva posición centrada en funcion del elemento más ancho o del ancho fijo del menu
if (w != 0) { // Si se ha definido un ancho fijo
x = (centerX) - (w / 2);
} else { // Si se actua en función del elemento más ancho
x = (centerX) - (findWidth() / 2);
}
// Actualiza el rectangulo de fondo y del selector
rectBG.rect.x = x;
selector.rect.x = x;
// Reposiciona los elementos del menu
for (auto &i : item) {
i.rect.x = x;
}
// Recalcula el rectangulo de fondo
setRectSize();
// Vuelve a centrar los elementos si fuera el caso
if (areElementsCenteredOnX) {
centerMenuElementsOnX();
}
}
// Centra el menu respecto un punto en el eje Y
void Menu::centerMenuOnY(int value) {
isCenteredOnY = true;
centerY = value;
// Establece la nueva posición centrada en funcion del elemento más ancho
y = (value) - (findHeight() / 2);
// Reposiciona los elementos del menu
replaceElementsOnY();
// Recalcula el rectangulo de fondo
setRectSize();
}
// Centra los elementos del menu en el eje X
void Menu::centerMenuElementsOnX() {
areElementsCenteredOnX = true;
for (auto &i : item) {
i.rect.x = (centerX - (i.rect.w / 2));
}
}
// Añade un item al menu
void Menu::addItem(item_t temp) {
// item_t temp;
if (item.empty()) { // Si es el primer item coge la posición en el eje Y del propio menu
temp.rect.y = y;
} else { // En caso contrario, coge la posición en el eje Y a partir del último elemento
temp.rect.y = item.back().rect.y + item.back().rect.h + item.back().hPaddingDown;
}
temp.rect.x = x;
item.push_back(temp);
setItemCaption(item.size() - 1, temp.label);
if (item.size() > 1) {
if (item[item.size() - 2].linkedDown) {
item.back().linkedUp = true;
}
}
centerX = x + (findWidth() / 2);
reorganize();
}
// Cambia el texto de un item
void Menu::setItemCaption(int index, std::string text) {
item[index].label = text;
item[index].rect.w = this->text->lenght(item[index].label);
item[index].rect.h = this->text->getCharacterSize();
reorganize();
}
// Establece el indice del itemm que se usará por defecto al cancelar el menu
void Menu::setDefaultActionWhenCancel(int item) {
defaultActionWhenCancel = item;
}
// Gestiona la entrada de teclado y mando durante el menu
void Menu::checkInput() {
if (input->checkInput(input_up, REPEAT_FALSE)) {
if (decreaseSelectorIndex()) {
if (soundMove) {
JA_PlaySound(soundMove);
}
}
}
if (input->checkInput(input_down, REPEAT_FALSE)) {
if (increaseSelectorIndex()) {
if (soundMove) {
JA_PlaySound(soundMove);
}
}
}
if (input->checkInput(input_accept, REPEAT_FALSE)) {
itemSelected = selector.index;
if (soundAccept) {
JA_PlaySound(soundAccept);
}
}
if (input->checkInput(input_cancel, REPEAT_FALSE)) {
itemSelected = defaultActionWhenCancel;
if (soundCancel) {
JA_PlaySound(soundCancel);
}
}
}
// Calcula el ancho del menu
int Menu::findWidth() {
return getWidestItem();
}
// Calcula el alto del menu
int Menu::findHeight() {
int height = 0;
// Obtenemos la altura de la suma de alturas de los items
for (auto &i : item) {
height += i.rect.h + i.hPaddingDown;
}
return height - item.back().hPaddingDown;
}
// Recoloca los elementos del menu en el eje Y
void Menu::replaceElementsOnY() {
item[0].rect.y = y;
for (int i = 1; i < (int)item.size(); i++) {
item[i].rect.y = item[i - 1].rect.y + item[i - 1].rect.h + item[i - 1].hPaddingDown;
}
}
// Establece el estado seleccionable de un item
void Menu::setSelectable(int index, bool value) {
item[index].selectable = value;
}
// Establece el estado agrisado de un item
void Menu::setGreyed(int index, bool value) {
item[index].greyed = value;
}
// Establece el estado de enlace de un item
void Menu::setLinkedDown(int index, bool value) {
item[index].linkedDown = value;
}
// Establece el estado de visibilidad de un item
void Menu::setVisible(int index, bool value) {
item[index].visible = value;
}
// Calcula la altura del selector
int Menu::getSelectorHeight(int value) {
if (item[value].linkedDown) {
return item[value].rect.h + item[value].hPaddingDown + item[value + 1].rect.h;
} else {
return item[value].rect.h;
}
}
// Establece el nombre del menu
void Menu::setName(std::string name) {
this->name = name;
}
// Establece la posición del menu
void Menu::setPos(int x, int y) {
this->x = x;
this->y = y;
}
// Establece el tipo de fondo del menu
void Menu::setBackgroundType(int value) {
backgroundType = value;
}
// Establece la fuente de texto que se utilizará
void Menu::setText(std::string font_png, std::string font_txt) {
if (!text) {
text = new Text(asset->get(font_png), asset->get(font_txt), renderer);
}
}
// Calcula los colores del selector para el degradado
void Menu::setSelectorItemColors() {
const color_t colorFrom = {255, 255, 255};
const color_t colorTo = selector.itemColor;
for (int i = 0; i < selector.numJumps; ++i) {
const float step = ((float)i / (selector.numJumps - 1));
const int r = colorFrom.r + ((colorTo.r - colorFrom.r) * step);
const int g = colorFrom.g + ((colorTo.g - colorFrom.g) * step);
const int b = colorFrom.b + ((colorTo.b - colorFrom.b) * step);
selector.jumpItemColors[i].r = r;
selector.jumpItemColors[i].g = g;
selector.jumpItemColors[i].b = b;
}
selector.itemColorIndex = 0;
}

234
source/game/ui/menu.h Normal file
View File

@@ -0,0 +1,234 @@
#pragma once
#include <SDL3/SDL.h>
#include <cstdint>
#include <string> // for string, basic_string
#include <vector> // for vector
#include "utils/utils.h" // for color_t
class Asset;
class Input;
class Text;
struct JA_Sound_t;
// Tipos de fondos para el menú
constexpr int MENU_BACKGROUND_TRANSPARENT = 0;
constexpr int MENU_BACKGROUND_SOLID = 1;
// Tipos de archivos de audio
constexpr int SOUND_ACCEPT = 0;
constexpr int SOUND_MOVE = 1;
constexpr int SOUND_CANCEL = 2;
// Opciones de menú
constexpr int MENU_NO_OPTION = -1;
// Clase Menu
class Menu {
private:
struct rectangle_t {
SDL_Rect rect; // Rectangulo
color_t color; // Color
int a; // Transparencia
};
struct item_t {
std::string label; // Texto
SDL_Rect rect; // Rectangulo que delimita el elemento
int hPaddingDown; // Espaciado bajo el elemento
bool selectable; // Indica si se puede seleccionar
bool greyed; // Indica si ha de aparecer con otro color mas oscuro
bool linkedDown; // Indica si el elemento actual y el siguiente se tratan como uno solo. Afecta al selector
bool linkedUp; // Indica si el elemento actual y el anterior se tratan como uno solo. Afecta al selector
bool visible; // Indica si el elemento es visible
bool line; // Indica si el elemento lleva una linea a continuación
};
struct selector_t {
float originY; // Coordenada de origen
float targetY; // Coordenada de destino
float despY; // Cantidad de pixeles que se desplaza el selector en cada salto: (target - origin) / numJumps
bool moving; // Indica si el selector está avanzando hacia el destino
float originH; // Altura de origen
float targetH; // Altura de destino
float incH; // Cantidad de pixels que debe incrementar o decrementar el selector en cada salto
bool resizing; // Indica si el selector está cambiando de tamaño
float y; // Coordenada actual, usado para el desplazamiento
float h; // Altura actual, usado para el cambio de tamaño
int numJumps; // Numero de pasos preestablecido para llegar al destino
int index; // Elemento del menu que tiene el foco
int previousIndex; // Elemento que tenia el foco previamente
color_t previousItemColor; // Color del item nque tenia el foco previamente
SDL_Rect rect; // Rectangulo del selector
color_t color; // Color del selector
color_t itemColor; // Color del item
color_t jumpItemColors[8]; // Transición de colores para el item seleccionado
int itemColorIndex; // Indice del color de transición para el item seleccionado
int a; // Cantidad de transparencia para el rectangulo del selector
};
// Objetos y punteros
SDL_Renderer *renderer; // Puntero al renderizador de la ventana
Asset *asset; // Objeto para gestionar los ficheros de recursos
Text *text; // Texto para poder escribir los items del menu
Input *input; // Gestor de eventos de entrada de teclado o gamepad
// Variables
std::string name; // Nombre del menu
int x; // Posición en el eje X de la primera letra del primer elemento
int y; // Posición en el eje Y de la primera letra del primer elemento
int h; // Altura del menu
int w; // Anchura del menu
int itemSelected; // Índice del item del menu que ha sido seleccionado
int defaultActionWhenCancel; // Indice del item del menu que se selecciona cuando se cancela el menu
int backgroundType; // Tipo de fondo para el menu
int centerX; // Centro del menu en el eje X
int centerY; // Centro del menu en el eje Y
bool isCenteredOnX; // Variable para saber si el menu debe estar centrado respecto a un punto en el eje X
bool isCenteredOnY; // Variable para saber si el menu debe estar centrado respecto a un punto en el eje Y
bool areElementsCenteredOnX; // Variable para saber si los elementos van centrados en el eje X
int widestItem; // Anchura del elemento más ancho
JA_Sound_t *soundAccept; // Sonido al aceptar o elegir una opción del menu
JA_Sound_t *soundCancel; // Sonido al cancelar el menu
JA_Sound_t *soundMove; // Sonido al mover el selector
color_t colorGreyed; // Color para los elementos agrisados
rectangle_t rectBG; // Rectangulo de fondo del menu
std::vector<item_t> item; // Estructura para cada elemento del menu
selector_t selector; // Variables para pintar el selector del menu
std::string font_png;
std::string font_txt;
// Carga la configuración del menu desde un archivo de texto
bool load(std::string file_path);
// Parser compartido (recibe cualquier istream)
bool parseFromStream(std::istream &file, const std::string &filename);
// Asigna variables a partir de dos cadenas
bool setVars(std::string var, std::string value);
// Asigna variables a partir de dos cadenas
bool setItem(item_t *item, std::string var, std::string value);
// Actualiza el menu para recolocarlo correctamente y establecer el tamaño
void reorganize();
// Deja el menu apuntando al siguiente elemento
bool increaseSelectorIndex();
// Deja el menu apuntando al elemento anterior
bool decreaseSelectorIndex();
// Actualiza la posicion y el estado del selector
void updateSelector();
// Obtiene la anchura del elemento más ancho del menu
int getWidestItem();
// Gestiona la entrada de teclado y mando durante el menu
void checkMenuInput(Menu *menu);
// Calcula el ancho del menu
int findWidth();
// Calcula el alto del menu
int findHeight();
// Recoloca los elementos del menu en el eje Y
void replaceElementsOnY();
// Calcula la altura del selector
int getSelectorHeight(int value);
// Calcula los colores del selector para el degradado
void setSelectorItemColors();
public:
// Constructor
Menu(SDL_Renderer *renderer, Asset *asset, Input *input, std::string file = "");
// Destructor
~Menu();
// Carga el menu desde bytes en memoria
bool loadFromBytes(const std::vector<uint8_t> &bytes, const std::string &nameForLogs = "");
// Carga los ficheros de audio
void loadAudioFile(std::string file, int sound);
// Obtiene el nombre del menu
std::string getName();
// Obtiene el valor de la variable
int getItemSelected();
// Deja el menu apuntando al primer elemento
void reset();
// Gestiona la entrada de teclado y mando durante el menu
void checkInput();
// Actualiza la logica del menu
void update();
// Pinta el menu en pantalla
void render();
// Establece el color del rectangulo de fondo
void setBackgroundColor(color_t color, int alpha);
// Establece el color del rectangulo del selector
void setSelectorColor(color_t color, int alpha);
// Establece el color del texto del selector
void setSelectorTextColor(color_t color);
// Centra el menu respecto a un punto en el eje X
void centerMenuOnX(int value = 0);
// Centra el menu respecto a un punto en el eje Y
void centerMenuOnY(int value);
// Centra los elementos del menu en el eje X
void centerMenuElementsOnX();
// Añade un item al menu
void addItem(item_t item);
// Cambia el texto de un item
void setItemCaption(int index, std::string text);
// Establece el indice del item que se usará por defecto al cancelar el menu
void setDefaultActionWhenCancel(int item);
// Coloca el selector en una posición específica
void setSelectorPos(int index);
// Establece el estado seleccionable de un item
void setSelectable(int index, bool value);
// Establece el estado agrisado de un item
void setGreyed(int index, bool value);
// Establece el estado de enlace de un item
void setLinkedDown(int index, bool value);
// Establece el estado de visibilidad de un item
void setVisible(int index, bool value);
// Establece el nombre del menu
void setName(std::string name);
// Establece la posición del menu
void setPos(int x, int y);
// Establece el tipo de fondo del menu
void setBackgroundType(int value);
// Establece la fuente de texto que se utilizará
void setText(std::string font_png, std::string font_txt);
// Establece el rectangulo de fondo del menu
void setRectSize(int w = 0, int h = 0);
};