jailers/jaildoctors_dilemma
5
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Pull Requests Activity

canvi de pc enmig de la enfangà

Browse Source
This commit is contained in:
Sergio
2025-02-25 13:18:56 +01:00
parent 817140825a
commit c9da5135b2
29 changed files with 878 additions and 1042 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
source/animated_sprite.cpp
View File

@@ -82,7 +82,7 @@ void AnimatedSprite::animate()
// Si alcanza el final de la animación, reinicia el contador de la animación // Si alcanza el final de la animación, reinicia el contador de la animación
// en función de la variable loop y coloca el nuevo frame // en función de la variable loop y coloca el nuevo frame
if (animations_[current_animation_].current_frame >= (int)animations_[current_animation_].frames.size()) if (animations_[current_animation_].current_frame >= static_cast<int>(animations_[current_animation_].frames.size()))
{ {
if (animations_[current_animation_].loop == -1) if (animations_[current_animation_].loop == -1)
{ // Si no hay loop, deja el último frame { // Si no hay loop, deja el último frame
@@ -247,4 +247,21 @@ void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer &so
// Pone un valor por defecto // Pone un valor por defecto
setWidth(frame_width); setWidth(frame_width);
setHeight(frame_height); setHeight(frame_height);
}
// Establece el frame actual de la animación
void AnimatedSprite::setCurrentAnimationFrame(int num)
{
// Descarta valores fuera de rango
if (num < 0 || num >= static_cast<int>(animations_[current_animation_].frames.size()))
{
num = 0;
}
// Cambia el valor de la variable
animations_[current_animation_].current_frame = num;
animations_[current_animation_].counter = 0;
// Escoge el frame correspondiente de la animación
setClip(animations_[current_animation_].frames[animations_[current_animation_].current_frame]);
} }

6
source/animated_sprite.h
View File

@@ -63,4 +63,10 @@ public:
// Reinicia la animación // Reinicia la animación
void resetAnimation(); void resetAnimation();
// Establece el frame actual de la animación
void setCurrentAnimationFrame(int num);
// Obtiene el numero de frames de la animación actual
int getCurrentAnimationSize() { return static_cast<int>(animations_[current_animation_].frames.size()); }
}; };

28
source/asset.cpp
View File

@@ -118,10 +118,18 @@ std::string Asset::getTypeName(AssetType type) const
{ {
switch (type) switch (type)
{ {
case AssetType::DATA:
return "DATA";
break;
case AssetType::BITMAP: case AssetType::BITMAP:
return "BITMAP"; return "BITMAP";
break; break;
case AssetType::ANIMATION:
return "ANIMATION";
break;
case AssetType::MUSIC: case AssetType::MUSIC:
return "MUSIC"; return "MUSIC";
break; break;
@@ -134,24 +142,12 @@ std::string Asset::getTypeName(AssetType type) const
return "FONT"; return "FONT";
break; break;
case AssetType::LANG: case AssetType::ROOM:
return "LANG"; return "ROOM";
break; break;
case AssetType::DATA: case AssetType::TILEMAP:
return "DATA"; return "TILEMAP";
break;
case AssetType::ANIMATION:
return "ANIMATION";
break;
case AssetType::PALETTE:
return "PALETTE";
break;
case AssetType::ITEM:
return "ITEM";
break; break;
default: default:

7
source/asset.h
View File

@@ -6,15 +6,14 @@
enum class AssetType : int enum class AssetType : int
{ {
DATA,
BITMAP, BITMAP,
ANIMATION,
MUSIC, MUSIC,
SOUND, SOUND,
FONT, FONT,
LANG,
DATA,
ROOM, ROOM,
ENEMY, TILEMAP,
ITEM,
MAX_ASSET_TYPE MAX_ASSET_TYPE
}; };

58
source/debug.cpp
View File

@@ -5,7 +5,7 @@
#include "texture.h" // Para Texture #include "texture.h" // Para Texture
#include "utils.h" #include "utils.h"
#include "screen.h" #include "screen.h"
#include "asset.h" #include "resource.h"
// [SINGLETON] // [SINGLETON]
Debug *Debug::debug_ = nullptr; Debug *Debug::debug_ = nullptr;
@@ -32,19 +32,11 @@ Debug *Debug::get()
Debug::Debug() Debug::Debug()
// Copia la dirección de los objetos // Copia la dirección de los objetos
: screen_(Screen::get()), : screen_(Screen::get()),
renderer_(Screen::get()->getRenderer()), renderer_(Screen::get()->getRenderer())
asset_(Asset::get())
{ {
// Reserva memoria para los punteros // Reserva memoria para los punteros
texture_ = new Texture(renderer_, asset_->get("debug.png")); texture_ = Resource::get()->getTexture("debug.png");
text_ = new Text(asset_->get("debug.txt"), texture_, renderer_); text_ = Resource::get()->getText("debug.txt");
}
// Destructor
Debug::~Debug()
{
delete texture_;
delete text_;
} }
// Actualiza las variables // Actualiza las variables
@@ -83,46 +75,4 @@ void Debug::setPos(SDL_Point p)
{ {
x_ = p.x; x_ = p.x;
y_ = p.y; y_ = p.y;
}
// Añade un texto para mostrar
void Debug::add(std::string text)
{
slot_.push_back(text);
}
// Borra la información de debug
void Debug::clear()
{
slot_.clear();
}
// Añade un texto para mostrar en el apartado log
void Debug::addToLog(std::string text)
{
log_.push_back(text);
}
// Borra la información de debug del apartado log
void Debug::clearLog()
{
log_.clear();
}
// Establece el valor de la variable
void Debug::setEnabled(bool value)
{
enabled_ = value;
}
// Obtiene el valor de la variable
bool Debug::getEnabled()
{
return enabled_;
}
// Cambia el valor de la variable
void Debug::switchEnabled()
{
enabled_ = !enabled_;
} }

40
source/debug.h
View File

@@ -4,6 +4,7 @@
#include <SDL2/SDL_render.h> // Para SDL_Renderer #include <SDL2/SDL_render.h> // Para SDL_Renderer
#include <string> // Para string #include <string> // Para string
#include <vector> // Para vector #include <vector> // Para vector
#include <memory>
class Asset; class Asset;
class Screen; class Screen;
class Text; class Text;
@@ -17,11 +18,10 @@ private:
static Debug *debug_; static Debug *debug_;
// Objetos y punteros // Objetos y punteros
Screen *screen_; // Objeto encargado de dibujar en pantalla Screen *screen_; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
Asset *asset_; // Objeto con los ficheros de recursos std::shared_ptr<Text> text_; // Objeto encargado de escribir texto en pantalla
Text *text_; // Objeto encargado de escribir texto en pantalla std::shared_ptr<Texture> texture_; // Textura para el texto
Texture *texture_; // Textura para el texto
// Variables // Variables
std::vector<std::string> slot_; // Vector con los textos a escribir std::vector<std::string> slot_; // Vector con los textos a escribir
@@ -34,7 +34,7 @@ private:
Debug(); Debug();
// Destructor // Destructor
~Debug(); ~Debug() = default;
public: public:
// [SINGLETON] Crearemos el objeto con esta función estática // [SINGLETON] Crearemos el objeto con esta función estática
@@ -55,24 +55,14 @@ public:
// Establece la posición donde se colocará la información de debug // Establece la posición donde se colocará la información de debug
void setPos(SDL_Point p); void setPos(SDL_Point p);
// Añade un texto para mostrar // Getters
void add(std::string text); bool getEnabled() { return enabled_; }
// Borra la información de debug // Setters
void clear(); void add(std::string text) { slot_.push_back(text); }
void clear() { slot_.clear(); }
// Añade un texto para mostrar en el apartado log void addToLog(std::string text) { log_.push_back(text); }
void addToLog(std::string text); void clearLog() { log_.clear(); }
void setEnabled(bool value) { enabled_ = value; }
// Borra la información de debug del apartado log void switchEnabled() { enabled_ = !enabled_; }
void clearLog();
// Establece el valor de la variable
void setEnabled(bool value);
// Obtiene el valor de la variable
bool getEnabled();
// Cambia el valor de la variable
void switchEnabled();
}; };

16
source/demo.cpp
View File

@@ -42,8 +42,8 @@ Demo::Demo()
// Crea los objetos // Crea los objetos
itemTracker = std::make_unique<ItemTracker>(); itemTracker = std::make_unique<ItemTracker>();
scoreboard = std::make_unique<Scoreboard>(&board); scoreboard = std::make_unique<Scoreboard>(&board);
room = std::make_shared<Room>(resource->getRoom(currentRoom), itemTracker, &board.items, false); room = std::make_shared<Room>(resource->getRoom(currentRoom), itemTracker, &board.items, false);
text = resource->getText("smb2.txt"); text = resource->getText("smb2.txt");
// Inicializa el resto de variables // Inicializa el resto de variables
counter = 0; counter = 0;
@@ -137,7 +137,7 @@ void Demo::renderRoomName()
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF); SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_RenderFillRect(renderer, &rect); SDL_RenderFillRect(renderer, &rect);
text->writeDX(TXT_CENTER | TXT_COLOR, GAMECANVAS_CENTER_X, 16 * 8 + 4, room->getName(), 1, room->getBGColor()); text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, 16 * 8 + 4, room->getName(), 1, room->getBGColor());
} }
// Recarga todas las texturas // Recarga todas las texturas
@@ -177,21 +177,19 @@ bool Demo::changeRoom(std::string file)
{ {
// En las habitaciones los limites tienen la cadena del fichero o un 0 en caso de no limitar con nada // En las habitaciones los limites tienen la cadena del fichero o un 0 en caso de no limitar con nada
if (file != "0") if (file != "0")
{
// Verifica que exista el fichero que se va a cargar // Verifica que exista el fichero que se va a cargar
if (asset->get(file) != "") if (asset->get(file) != "")
{ {
// Elimina la habitación actual // Crea un objeto habitación a partir del fichero
delete room; room = std::make_shared<Room>(resource->getRoom(file), itemTracker, &board.items, false);
room = nullptr;
// Crea un objeto habitación nuevo a partir del fichero
room = new Room(resource->getRoom(file), itemTracker, &board.items, false);
// Pone el color del marcador en función del color del borde de la habitación // Pone el color del marcador en función del color del borde de la habitación
setScoreBoardColor(); setScoreBoardColor();
return true; return true;
} }
}
return false; return false;
} }

4
source/demo.h
View File

@@ -24,14 +24,14 @@ private:
// Objetos y punteros // Objetos y punteros
Screen *screen; // Objeto encargado de manejar el renderizador Screen *screen; // Objeto encargado de manejar el renderizador
SDL_Renderer *renderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
std::shared_ptr<Room> room; // Objeto encargado de gestionar cada habitación del juego
Resource *resource; // Objeto con los recursos Resource *resource; // Objeto con los recursos
Asset *asset; // Objeto con la ruta a todos los ficheros de recursos Asset *asset; // Objeto con la ruta a todos los ficheros de recursos
Input *input; // Objeto pata gestionar la entrada Input *input; // Objeto pata gestionar la entrada
Debug *debug; // Objeto para gestionar la información de debug
std::shared_ptr<Room> room; // Objeto encargado de gestionar cada habitación del juego
std::shared_ptr<Text> text; // Objeto para los textos del juego std::shared_ptr<Text> text; // Objeto para los textos del juego
std::unique_ptr<Scoreboard> scoreboard; // Objeto encargado de gestionar el marcador std::unique_ptr<Scoreboard> scoreboard; // Objeto encargado de gestionar el marcador
std::unique_ptr<ItemTracker> itemTracker; // Lleva el control de los objetos recogidos std::unique_ptr<ItemTracker> itemTracker; // Lleva el control de los objetos recogidos
Debug *debug; // Objeto para gestionar la información de debug
// Variables // Variables
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa

252
source/director.cpp
View File

@@ -381,15 +381,15 @@ bool Director::setFileList()
#endif #endif
// Texto // Texto
Asset::get()->add(prefix + "/data/font/smb2.png", AssetType::FONT); Asset::get()->add(prefix + "/data/font/smb2.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT); Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
Asset::get()->add(prefix + "/data/font/debug.png", AssetType::FONT); Asset::get()->add(prefix + "/data/font/debug.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/font/debug.txt", AssetType::FONT); Asset::get()->add(prefix + "/data/font/debug.txt", AssetType::FONT);
Asset::get()->add(prefix + "/data/font/gauntlet.png", AssetType::FONT); Asset::get()->add(prefix + "/data/font/gauntlet.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/font/gauntlet.txt", AssetType::FONT); Asset::get()->add(prefix + "/data/font/gauntlet.txt", AssetType::FONT);
Asset::get()->add(prefix + "/data/font/subatomic.png", AssetType::FONT); Asset::get()->add(prefix + "/data/font/subatomic.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/font/subatomic.txt", AssetType::FONT); Asset::get()->add(prefix + "/data/font/subatomic.txt", AssetType::FONT);
Asset::get()->add(prefix + "/data/font/8bithud.png", AssetType::FONT); Asset::get()->add(prefix + "/data/font/8bithud.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/font/8bithud.txt", AssetType::FONT); Asset::get()->add(prefix + "/data/font/8bithud.txt", AssetType::FONT);
// Shaders // Shaders
@@ -471,194 +471,194 @@ bool Director::setFileList()
Asset::get()->add(prefix + "/data/room/60.room", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/60.room", AssetType::ROOM);
// Tilemaps // Tilemaps
Asset::get()->add(prefix + "/data/room/01.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/01.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/02.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/02.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/03.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/03.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/04.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/04.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/05.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/05.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/06.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/06.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/07.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/07.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/08.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/08.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/09.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/09.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/10.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/10.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/11.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/11.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/12.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/12.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/13.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/13.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/14.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/14.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/15.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/15.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/16.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/16.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/17.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/17.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/18.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/18.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/19.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/19.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/20.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/20.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/21.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/21.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/22.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/22.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/23.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/23.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/24.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/24.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/25.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/25.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/26.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/26.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/27.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/27.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/28.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/28.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/29.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/29.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/30.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/30.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/31.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/31.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/32.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/32.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/33.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/33.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/34.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/34.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/35.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/35.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/36.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/36.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/37.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/37.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/38.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/38.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/39.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/39.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/40.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/40.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/41.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/41.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/42.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/42.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/43.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/43.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/44.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/44.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/45.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/45.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/46.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/46.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/47.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/47.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/48.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/48.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/49.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/49.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/50.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/50.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/51.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/51.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/52.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/52.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/53.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/53.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/54.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/54.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/55.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/55.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/56.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/56.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/57.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/57.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/58.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/58.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/59.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/59.tmx", AssetType::TILEMAP);
Asset::get()->add(prefix + "/data/room/60.tmx", AssetType::ROOM); Asset::get()->add(prefix + "/data/room/60.tmx", AssetType::TILEMAP);
// Tilesets // Tilesets
Asset::get()->add(prefix + "/data/tilesets/standard.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/tilesets/standard.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/tilesets/standard_zxarne.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/tilesets/standard_zxarne.png", AssetType::BITMAP);
// Enemigos // Enemigos
Asset::get()->add(prefix + "/data/enemies/abad_bell.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/abad_bell.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/abad_bell.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/abad_bell.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/abad.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/abad.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/abad.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/abad.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/amstrad_cs.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/amstrad_cs.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/amstrad_cs.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/amstrad_cs.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/flying_arounder.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/flying_arounder.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/flying_arounder.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/flying_arounder.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/stopped_arounder.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/stopped_arounder.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/stopped_arounder.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/stopped_arounder.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/walking_arounder.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/walking_arounder.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/walking_arounder.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/walking_arounder.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/arounders_door.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/arounders_door.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/arounders_door.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/arounders_door.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/arounders_machine.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/arounders_machine.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/arounders_machine.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/arounders_machine.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/bat.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/bat.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/bat.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/bat.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/batman_bell.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/batman_bell.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/batman_bell.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/batman_bell.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/batman_fire.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/batman_fire.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/batman_fire.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/batman_fire.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/batman.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/batman.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/batman.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/batman.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/bell.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/bell.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/bell.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/bell.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/bin.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/bin.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/bin.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/bin.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/bird.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/bird.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/bird.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/bird.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/breakout.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/breakout.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/breakout.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/breakout.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/bry.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/bry.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/bry.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/bry.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/chip.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/chip.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/chip.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/chip.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/code.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/code.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/code.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/code.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/congo.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/congo.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/congo.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/congo.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/crosshair.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/crosshair.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/crosshair.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/crosshair.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/demon.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/demon.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/demon.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/demon.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/dimallas.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/dimallas.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/dimallas.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/dimallas.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/floppy.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/floppy.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/floppy.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/floppy.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/dong.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/dong.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/dong.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/dong.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/guitar.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/guitar.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/guitar.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/guitar.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/heavy.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/heavy.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/heavy.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/heavy.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/jailer_#1.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/jailer_#1.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/jailer_#1.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/jailer_#1.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/jailer_#2.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/jailer_#2.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/jailer_#2.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/jailer_#2.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/jailer_#3.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/jailer_#3.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/jailer_#3.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/jailer_#3.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/jailbattle_alien.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/jailbattle_alien.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/jailbattle_alien.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/jailbattle_alien.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/jailbattle_human.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/jailbattle_human.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/jailbattle_human.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/jailbattle_human.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/jeannine.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/jeannine.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/jeannine.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/jeannine.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/lamp.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/lamp.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/lamp.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/lamp.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/lord_abad.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/lord_abad.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/lord_abad.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/lord_abad.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/matatunos.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/matatunos.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/matatunos.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/matatunos.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/mummy.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/mummy.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/mummy.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/mummy.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/paco.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/paco.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/paco.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/paco.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/elsa.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/elsa.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/elsa.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/elsa.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/qvoid.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/qvoid.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/qvoid.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/qvoid.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/robot.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/robot.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/robot.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/robot.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/sam.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/sam.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/sam.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/sam.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/shock.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/shock.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/shock.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/shock.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/sigmasua.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/sigmasua.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/sigmasua.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/sigmasua.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/spark.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/spark.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/spark.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/spark.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/special/aerojailer.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/special/aerojailer.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/special/aerojailer.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/special/aerojailer.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/special/arounder.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/special/arounder.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/special/arounder.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/special/arounder.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/special/pepe_rosita_job.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/special/pepe_rosita_job.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/special/pepe_rosita_job.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/special/pepe_rosita_job.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/special/shooting_star.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/special/shooting_star.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/special/shooting_star.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/special/shooting_star.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/spider.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/spider.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/spider.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/spider.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/tree_thing.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/tree_thing.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/tree_thing.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/tree_thing.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/tuno.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/tuno.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/tuno.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/tuno.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/tv_panel.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/tv_panel.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/tv_panel.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/tv_panel.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/tv.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/tv.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/tv.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/tv.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/upv_student.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/upv_student.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/upv_student.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/upv_student.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/wave.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/wave.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/wave.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/wave.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/enemies/z80.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/enemies/z80.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/enemies/z80.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/enemies/z80.png", AssetType::BITMAP);
// Jugador // Jugador
Asset::get()->add(prefix + "/data/player/player.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/player/player.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/player/player.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/player/player.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/player/player2.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/player/player2.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/player/player2.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/player/player2.ani", AssetType::ANIMATION);
Asset::get()->add(prefix + "/data/player/player_game_over.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/player/player_game_over.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/player/player_game_over.ani", AssetType::DATA); Asset::get()->add(prefix + "/data/player/player_game_over.ani", AssetType::ANIMATION);
// Items // Items
Asset::get()->add(prefix + "/data/items/items.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/items/items.png", AssetType::BITMAP);
@@ -728,7 +728,7 @@ bool Director::setFileList()
// Credits // Credits
Asset::get()->add(prefix + "/data/credits/shine.png", AssetType::BITMAP); Asset::get()->add(prefix + "/data/credits/shine.png", AssetType::BITMAP);
Asset::get()->add(prefix + "/data/credits/shine.ani", AssetType::BITMAP); Asset::get()->add(prefix + "/data/credits/shine.ani", AssetType::ANIMATION);
return Asset::get()->check(); return Asset::get()->check();
} }

105
source/enemy.cpp
View File

@@ -1,4 +1,5 @@
#include "enemy.h" #include "enemy.h"
#include <SDL2/SDL.h>
#include <stdlib.h> // Para rand #include <stdlib.h> // Para rand
#include <algorithm> // Para min #include <algorithm> // Para min
#include "animated_sprite.h" // Para AnimatedSprite #include "animated_sprite.h" // Para AnimatedSprite
@@ -8,112 +9,102 @@
Enemy::Enemy(enemy_t enemy) Enemy::Enemy(enemy_t enemy)
{ {
// Crea objetos // Crea objetos
sprite = new AnimatedSprite(enemy.renderer, enemy.animation); sprite_ = std::make_shared<AnimatedSprite>(falta_la_textura, enemy.animation);
// Obten el resto de valores // Obten el resto de valores
x1 = enemy.x1; x1_ = enemy.x1;
x2 = enemy.x2; x2_ = enemy.x2;
y1 = enemy.y1; y1_ = enemy.y1;
y2 = enemy.y2; y2_ = enemy.y2;
palette = enemy.palette; palette_ = enemy.palette;
colorString = enemy.color; color_string_ = enemy.color;
color = stringToColor(palette, colorString); color_ = stringToColor(palette_, color_string_);
sprite->setPosX(enemy.x); sprite_->setPosX(enemy.x);
sprite->setPosY(enemy.y); sprite_->setPosY(enemy.y);
sprite->setVelX(enemy.vx); sprite_->setVelX(enemy.vx);
sprite->setVelY(enemy.vy); sprite_->setVelY(enemy.vy);
sprite->setWidth(enemy.w); sprite_->setWidth(enemy.w);
sprite->setHeight(enemy.h); sprite_->setHeight(enemy.h);
doFlip = enemy.flip; should_flip_ = enemy.flip;
mirror = enemy.mirror; should_mirror_ = enemy.mirror;
if (doFlip)
{
if (enemy.vx < 0.0f)
{
sprite->setFlipH(true);
}
}
sprite->setFlipV(mirror);
collider = getRect(); const SDL_RendererFlip flip = (should_flip_ && enemy.vx < 0.0f) ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
const SDL_RendererFlip mirror = should_mirror_ ? SDL_FLIP_VERTICAL : SDL_FLIP_NONE;
sprite_->setFlip(static_cast<SDL_RendererFlip>(flip | mirror));
collider_ = getRect();
// Coloca un frame al azar o el designado // Coloca un frame al azar o el designado
if (enemy.frame == -1) if (enemy.frame == -1)
{ {
sprite->setCurrentFrame(rand() % sprite->getNumFrames()); sprite_->setCurrentAnimationFrame(rand() % sprite_->getCurrentAnimationSize());
} }
else else
{ {
sprite->setCurrentFrame(std::min(enemy.frame, sprite->getNumFrames() - 1)); sprite_->setCurrentAnimationFrame(enemy.frame);
} }
} }
// Destructor
Enemy::~Enemy()
{
delete sprite;
}
// Pinta el enemigo en pantalla // Pinta el enemigo en pantalla
void Enemy::render() void Enemy::render()
{ {
sprite->getTexture()->setColor(color.r, color.g, color.b); sprite_->getTexture()->setColor(color_.r, color_.g, color_.b);
sprite->render(); sprite_->render();
sprite->getTexture()->setColor(255, 255, 255); sprite_->getTexture()->setColor(255, 255, 255);
} }
// Actualiza las variables del objeto // Actualiza las variables del objeto
void Enemy::update() void Enemy::update()
{ {
sprite->update(); sprite_->update();
checkPath(); checkPath();
collider = getRect(); collider_ = getRect();
} }
// Comprueba si ha llegado al limite del recorrido para darse media vuelta // Comprueba si ha llegado al limite del recorrido para darse media vuelta
void Enemy::checkPath() void Enemy::checkPath()
{ {
if (sprite->getPosX() > x2 || sprite->getPosX() < x1) if (sprite_->getPosX() > x2_ || sprite_->getPosX() < x1_)
{ {
// Recoloca // Recoloca
if (sprite->getPosX() > x2) if (sprite_->getPosX() > x2_)
{ {
sprite->setPosX(x2); sprite_->setPosX(x2_);
} }
else else
{ {
sprite->setPosX(x1); sprite_->setPosX(x1_);
} }
// Cambia el sentido // Cambia el sentido
sprite->setVelX(sprite->getVelX() * (-1)); sprite_->setVelX(sprite_->getVelX() * (-1));
// Invierte el sprite // Invierte el sprite
if (doFlip) if (should_flip_)
{ {
sprite->flipH(); sprite_->flip();
} }
} }
if (sprite->getPosY() > y2 || sprite->getPosY() < y1) if (sprite_->getPosY() > y2_ || sprite_->getPosY() < y1_)
{ {
// Recoloca // Recoloca
if (sprite->getPosY() > y2) if (sprite_->getPosY() > y2_)
{ {
sprite->setPosY(y2); sprite_->setPosY(y2_);
} }
else else
{ {
sprite->setPosY(y1); sprite_->setPosY(y1_);
} }
// Cambia el sentido // Cambia el sentido
sprite->setVelY(sprite->getVelY() * (-1)); sprite_->setVelY(sprite_->getVelY() * (-1));
// Invierte el sprite // Invierte el sprite
if (doFlip) if (should_flip_)
{ {
sprite->flipH(); sprite_->flip();
} }
} }
} }
@@ -121,24 +112,24 @@ void Enemy::checkPath()
// Devuelve el rectangulo que contiene al enemigo // Devuelve el rectangulo que contiene al enemigo
SDL_Rect Enemy::getRect() SDL_Rect Enemy::getRect()
{ {
return sprite->getRect(); return sprite_->getRect();
} }
// Obtiene el rectangulo de colision del enemigo // Obtiene el rectangulo de colision del enemigo
SDL_Rect &Enemy::getCollider() SDL_Rect &Enemy::getCollider()
{ {
return collider; return collider_;
} }
// Recarga la textura // Recarga la textura
void Enemy::reLoadTexture() void Enemy::reLoadTexture()
{ {
sprite->getTexture()->reLoad(); sprite_->getTexture()->reLoad();
} }
// Asigna la paleta // Asigna la paleta
void Enemy::setPalette(Palette pal) void Enemy::setPalette(Palette pal)
{ {
palette = pal; palette_ = pal;
color = stringToColor(palette, colorString); color_ = stringToColor(palette_, color_string_);
} }

27
source/enemy.h
View File

@@ -4,6 +4,7 @@
#include <SDL2/SDL_render.h> // Para SDL_Renderer #include <SDL2/SDL_render.h> // Para SDL_Renderer
#include <string> // Para basic_string, string #include <string> // Para basic_string, string
#include "utils.h" // Para palette_e, color_t #include "utils.h" // Para palette_e, color_t
#include <memory> // Para shared_ptr
class AnimatedSprite; class AnimatedSprite;
struct animatedSprite_t; struct animatedSprite_t;
@@ -12,7 +13,7 @@ struct enemy_t
{ {
SDL_Renderer *renderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
animatedSprite_t *animation; // Puntero a las animaciones del enemigo animatedSprite_t *animation; // Puntero a las animaciones del enemigo
std::string animationString; // Ruta al fichero con la animación std::string animation_path; // Ruta al fichero con la animación
int w; // Anchura del enemigo int w; // Anchura del enemigo
int h; // Altura del enemigo int h; // Altura del enemigo
float x; // Posición inicial en el eje X float x; // Posición inicial en el eje X
@@ -34,19 +35,19 @@ class Enemy
{ {
private: private:
// Objetos y punteros // Objetos y punteros
AnimatedSprite *sprite; // Sprite del enemigo std::shared_ptr<AnimatedSprite> sprite_; // Sprite del enemigo
// Variables // Variables
Color color; // Color del enemigo Color color_; // Color del enemigo
std::string colorString; // Color del enemigo en formato texto std::string color_string_; // Color del enemigo en formato texto
Palette palette; // Paleta de colores Palette palette_; // Paleta de colores
int x1; // Limite izquierdo de la ruta en el eje X int x1_; // Limite izquierdo de la ruta en el eje X
int x2; // Limite derecho de la ruta en el eje X int x2_; // Limite derecho de la ruta en el eje X
int y1; // Limite superior de la ruta en el eje Y int y1_; // Limite superior de la ruta en el eje Y
int y2; // Limite inferior de la ruta en el eje Y int y2_; // Limite inferior de la ruta en el eje Y
SDL_Rect collider; // Caja de colisión SDL_Rect collider_; // Caja de colisión
bool doFlip; // Indica si el enemigo hace flip al terminar su ruta bool should_flip_; // Indica si el enemigo hace flip al terminar su ruta
bool mirror; // Indica si el enemigo se dibuja volteado verticalmente bool should_mirror_; // Indica si el enemigo se dibuja volteado verticalmente
// Comprueba si ha llegado al limite del recorrido para darse media vuelta // Comprueba si ha llegado al limite del recorrido para darse media vuelta
void checkPath(); void checkPath();
@@ -56,7 +57,7 @@ public:
Enemy(enemy_t enemy); Enemy(enemy_t enemy);
// Destructor // Destructor
~Enemy(); ~Enemy() = default;
// Pinta el enemigo en pantalla // Pinta el enemigo en pantalla
void render(); void render();

65
source/game.cpp
View File

@@ -32,7 +32,8 @@ Game::Game()
asset_(Asset::get()), asset_(Asset::get()),
input_(Input::get()), input_(Input::get()),
resource_(Resource::get()), resource_(Resource::get()),
debug_(Debug::get()) debug_(Debug::get()),
cheevos_(Cheevos::get())
{ {
// Inicia algunas variables // Inicia algunas variables
board_.iniClock = SDL_GetTicks(); board_.iniClock = SDL_GetTicks();
@@ -50,19 +51,18 @@ Game::Game()
#endif #endif
// Crea los objetos // Crea los objetos
cheevos_ = Cheevos::get(); scoreboard_ = std::make_shared<Scoreboard>(&board_);
scoreboard_ = new Scoreboard(&board_); item_tracker_ = std::make_shared<ItemTracker>();
item_tracker_ = new ItemTracker(); room_tracker_ = std::make_shared<RoomTracker>();
room_tracker_ = new RoomTracker(); room_ = std::make_shared<Room>(resource_->getRoom(current_room_), item_tracker_, &board_.items, false);
room_ = new Room(resource_->getRoom(current_room_), item_tracker_, &board_.items, false);
const std::string playerPNG = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png"; const std::string playerPNG = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png";
const std::string playerANI = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani"; const std::string playerANI = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani";
const player_t player = {spawn_point_, playerPNG, playerANI, room_}; const player_t player = {spawn_point_, playerPNG, playerANI, room_};
player_ = new Player(player); player_ = std::make_shared<Player>(player);
text_ = new Text(resource_->getOffset("smb2.txt"), resource_->getTexture("smb2.png"), renderer_); text_ = resource_->getText("smb2.txt");
music_ = JA_LoadMusic(asset_->get("game.ogg").c_str()); music_ = resource_->getMusic("game.ogg");
death_sound_ = JA_LoadSound(asset_->get("death.wav").c_str()); death_sound_ = JA_LoadSound(asset_->get("death.wav").c_str());
stats_ = new Stats(asset_->get("stats.csv"), asset_->get("stats_buffer.csv")); stats_ = std::make_shared<Stats>(asset_->get("stats.csv"), asset_->get("stats_buffer.csv"));
// Crea la textura para poner el nombre de la habitación // Crea la textura para poner el nombre de la habitación
room_name_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, text_->getCharacterSize() * 2); room_name_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, text_->getCharacterSize() * 2);
@@ -111,18 +111,7 @@ Game::Game()
Game::~Game() Game::~Game()
{ {
// Libera la memoria de los objetos // Libera la memoria de los objetos
delete scoreboard_;
delete item_tracker_;
delete room_tracker_;
delete room_;
delete player_;
delete text_;
delete stats_;
SDL_DestroyTexture(room_name_texture_); SDL_DestroyTexture(room_name_texture_);
JA_DeleteMusic(music_);
JA_DeleteSound(death_sound_);
} }
// Comprueba los eventos de la cola // Comprueba los eventos de la cola
@@ -146,7 +135,7 @@ void Game::checkEvents()
break; break;
case SDL_SCANCODE_R: case SDL_SCANCODE_R:
resource_->reLoad(); resource_->reload();
break; break;
case SDL_SCANCODE_W: case SDL_SCANCODE_W:
@@ -292,9 +281,9 @@ void Game::render()
// Pasa la información de debug // Pasa la información de debug
void Game::updateDebugInfo() void Game::updateDebugInfo()
{ {
debug_->add("X = " + std::to_string(static_cast<int>(player_->x)) + ", Y = " + std::to_string(static_cast<int>(player_->y))); debug_->add("X = " + std::to_string(static_cast<int>(player_->x_)) + ", Y = " + std::to_string(static_cast<int>(player_->y_)));
debug_->add("VX = " + std::to_string(player_->vx).substr(0, 4) + ", VY = " + std::to_string(player_->vy).substr(0, 4)); debug_->add("VX = " + std::to_string(player_->vx_).substr(0, 4) + ", VY = " + std::to_string(player_->vy_).substr(0, 4));
debug_->add("STATE = " + std::to_string(player_->state)); debug_->add("STATE = " + std::to_string(player_->state_));
} }
// Pone la información de debug en pantalla // Pone la información de debug en pantalla
@@ -346,12 +335,8 @@ bool Game::changeRoom(std::string file)
// Verifica que exista el fichero que se va a cargar // Verifica que exista el fichero que se va a cargar
if (asset_->get(file) != "") if (asset_->get(file) != "")
{ {
// Elimina la habitación actual
delete room_;
room_ = nullptr;
// Crea un objeto habitación nuevo a partir del fichero // Crea un objeto habitación nuevo a partir del fichero
room_ = new Room(resource_->getRoom(file), item_tracker_, &board_.items, board_.jail_is_open); room_ = std::make_shared<Room>(resource_->getRoom(file), item_tracker_, &board_.items, board_.jail_is_open);
// Pone el nombre de la habitación en la textura // Pone el nombre de la habitación en la textura
fillRoomNameTexture(); fillRoomNameTexture();
@@ -448,10 +433,6 @@ void Game::killPlayer()
// Invalida el logro de pasarse el juego sin morir // Invalida el logro de pasarse el juego sin morir
cheevos_->invalidate(11); cheevos_->invalidate(11);
// Destruye la habitacion y el jugador
delete room_;
delete this->player_;
// Sonido // Sonido
JA_PlaySound(death_sound_); JA_PlaySound(death_sound_);
@@ -459,11 +440,11 @@ void Game::killPlayer()
setBlackScreen(); setBlackScreen();
// Crea la nueva habitación y el nuevo jugador // Crea la nueva habitación y el nuevo jugador
room_ = new Room(resource_->getRoom(current_room_), item_tracker_, &board_.items, board_.jail_is_open); room_ = std::make_shared<Room>(resource_->getRoom(current_room_), item_tracker_, &board_.items, board_.jail_is_open);
const std::string playerPNG = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png"; const std::string playerPNG = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.png" : "player.png";
const std::string playerANI = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani"; const std::string playerANI = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani";
const player_t player = {spawn_point_, playerPNG, playerANI, room_}; const player_t player = {spawn_point_, playerPNG, playerANI, room_};
player_ = new Player(player); player_ = std::make_shared<Player>(player);
// Pone los objetos en pausa mientras esta la habitación en negro // Pone los objetos en pausa mientras esta la habitación en negro
room_->pause(); room_->pause();
@@ -558,10 +539,9 @@ bool Game::checkEndGame()
int Game::getTotalItems() int Game::getTotalItems()
{ {
int items = 0; int items = 0;
std::vector<res_room_t> *rooms = new std::vector<res_room_t>; auto rooms = resource_->getRooms();
rooms = resource_->getAllRooms();
for (auto room : *rooms) for (auto room : rooms)
{ {
items += room.room->items.size(); items += room.room->items.size();
} }
@@ -632,10 +612,9 @@ void Game::checkRestoringJail()
// Inicializa el diccionario de las estadísticas // Inicializa el diccionario de las estadísticas
void Game::initStats() void Game::initStats()
{ {
std::vector<res_room_t> *rooms = new std::vector<res_room_t>; auto rooms = resource_->getRooms();
rooms = resource_->getAllRooms();
for (auto room : *rooms) for (auto room : rooms)
{ {
stats_->addDictionary(room.room->number, room.room->name); stats_->addDictionary(room.room->number, room.room->name);
} }
@@ -655,7 +634,7 @@ void Game::fillRoomNameTexture()
SDL_RenderClear(renderer_); SDL_RenderClear(renderer_);
// Escribe el texto en la textura // Escribe el texto en la textura
text_->writeDX(TXT_CENTER | TXT_COLOR, GAMECANVAS_CENTER_X, text_->getCharacterSize() / 2, room_->getName(), 1, room_->getBGColor()); text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, text_->getCharacterSize() / 2, room_->getName(), 1, room_->getBGColor());
// Deja el renderizador por defecto // Deja el renderizador por defecto
SDL_SetRenderTarget(renderer_, nullptr); SDL_SetRenderTarget(renderer_, nullptr);

30
source/game.h
View File

@@ -27,21 +27,21 @@ class Game
{ {
private: private:
// Objetos y punteros // Objetos y punteros
Screen *screen_; // Objeto encargado de manejar el renderizador Screen *screen_; // Objeto encargado de manejar el renderizador
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
Room *room_; // Objeto encargado de gestionar cada habitación del juego Asset *asset_; // Objeto con la ruta a todos los ficheros de recursos
Player *player_; // Objeto con el jugador Input *input_; // Objeto pata gestionar la entrada
ItemTracker *item_tracker_; // Lleva el control de los objetos recogidos Resource *resource_; // Objeto con los recursos
RoomTracker *room_tracker_; // Lleva el control de las habitaciones visitadas Debug *debug_; // Objeto para gestionar la información de debug
Asset *asset_; // Objeto con la ruta a todos los ficheros de recursos Cheevos *cheevos_; // Objeto encargado de gestionar los logros del juego
Input *input_; // Objeto pata gestionar la entrada std::shared_ptr<Room> room_; // Objeto encargado de gestionar cada habitación del juego
Text *text_; // Objeto para los textos del juego std::shared_ptr<Player> player_; // Objeto con el jugador
Scoreboard *scoreboard_; // Objeto encargado de gestionar el marcador std::shared_ptr<ItemTracker> item_tracker_; // Lleva el control de los objetos recogidos
Cheevos *cheevos_; // Objeto encargado de gestionar los logros del juego std::shared_ptr<RoomTracker> room_tracker_; // Lleva el control de las habitaciones visitadas
Resource *resource_; // Objeto con los recursos std::shared_ptr<Text> text_; // Objeto para los textos del juego
Debug *debug_; // Objeto para gestionar la información de debug std::shared_ptr<Scoreboard> scoreboard_; // Objeto encargado de gestionar el marcador
Stats *stats_; // Objeto encargado de gestionar las estadísticas std::shared_ptr<Stats> stats_; // Objeto encargado de gestionar las estadísticas
SDL_Texture *room_name_texture_; // Textura para escribir el nombre de la habitación SDL_Texture *room_name_texture_; // Textura para escribir el nombre de la habitación
// Variables // Variables
JA_Music_t *music_; // Musica que suena durante el juego JA_Music_t *music_; // Musica que suena durante el juego

1
source/game_over.h
View File

@@ -5,6 +5,7 @@
#include <SDL2/SDL_stdinc.h> // Para Uint32 #include <SDL2/SDL_stdinc.h> // Para Uint32
#include <vector> // Para vector #include <vector> // Para vector
#include "utils.h" // Para color_t #include "utils.h" // Para color_t
#include <memory> // Para shared_ptr
class AnimatedSprite; class AnimatedSprite;
class Asset; class Asset;
class Input; class Input;

31
source/item.cpp
View File

@@ -5,13 +5,13 @@
// Constructor // Constructor
Item::Item(item_t item) Item::Item(item_t item)
{ {
const int itemSize = 8; constexpr int ITEMSIZE = 8;
// Crea objetos; // Crea objetos;
sprite = new Sprite(item.x, item.y, itemSize, itemSize, item.texture, item.renderer); sprite = std::make_shared<Sprite>(item.texture, item.x, item.y, ITEMSIZE, ITEMSIZE);
// Inicia variables // Inicia variables
sprite->setClip((item.tile % 10) * itemSize, (item.tile / 10) * itemSize, itemSize, itemSize); sprite->setClip((item.tile % 10) * ITEMSIZE, (item.tile / 10) * ITEMSIZE, ITEMSIZE, ITEMSIZE);
collider = sprite->getRect(); collider = sprite->getRect();
colorChangeSpeed = 4; colorChangeSpeed = 4;
counter = item.counter * colorChangeSpeed; counter = item.counter * colorChangeSpeed;
@@ -26,12 +26,6 @@ Item::Item(item_t item)
color.push_back(c); color.push_back(c);
} }
// Destructor
Item::~Item()
{
delete sprite;
}
// Pinta el objeto en pantalla // Pinta el objeto en pantalla
void Item::render() void Item::render()
{ {
@@ -41,30 +35,13 @@ void Item::render()
sprite->getTexture()->setColor(255, 255, 255); sprite->getTexture()->setColor(255, 255, 255);
} }
// Actualiza las variables del objeto
void Item::update()
{
counter++;
}
// Obtiene el rectangulo de colision del objeto
SDL_Rect &Item::getCollider()
{
return collider;
}
// Obtiene su ubicación // Obtiene su ubicación
SDL_Point Item::getPos() SDL_Point Item::getPos()
{ {
const SDL_Point p = {sprite->getPosX(), sprite->getPosY()}; const SDL_Point p = {sprite->getX(), sprite->getY()};
return p; return p;
} }
// Recarga la textura
void Item::reLoadTexture()
{
sprite->getTexture()->reLoad();
}
// Asigna los colores del objeto // Asigna los colores del objeto
void Item::setColors(Color col1, Color col2) void Item::setColors(Color col1, Color col2)

17
source/item.h
View File

@@ -5,13 +5,15 @@
#include <string> // Para basic_string, string #include <string> // Para basic_string, string
#include <vector> // Para vector #include <vector> // Para vector
#include "utils.h" // Para color_t #include "utils.h" // Para color_t
class Sprite; #include <memory> // Para shared_ptr
#include "sprite.h"
#include "texture.h"
class Texture; class Texture;
struct item_t struct item_t
{ {
SDL_Renderer *renderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
Texture *texture; // Textura con los gráficos del item std::shared_ptr<Texture> texture; // Textura con los gráficos del item
std::string tileSetFile; // Ruta al fichero con los gráficos del item std::string tileSetFile; // Ruta al fichero con los gráficos del item
int x; // Posición del item en pantalla int x; // Posición del item en pantalla
int y; // Posición del item en pantalla int y; // Posición del item en pantalla
@@ -28,7 +30,7 @@ class Item
{ {
private: private:
// Objetos y punteros // Objetos y punteros
Sprite *sprite; // Sprite del objeto std::shared_ptr<Sprite> sprite; // Sprite del objeto
// Variables // Variables
std::vector<Color> color; // Vector con los colores del objeto std::vector<Color> color; // Vector con los colores del objeto
@@ -41,23 +43,24 @@ public:
Item(item_t item); Item(item_t item);
// Destructor // Destructor
~Item(); ~Item() = default;
// Pinta el objeto en pantalla // Pinta el objeto en pantalla
void render(); void render();
// Actualiza las variables del objeto // Actualiza las variables del objeto
void update(); void update() { counter++; }
// Obtiene el rectangulo de colision del objeto // Obtiene el rectangulo de colision del objeto
SDL_Rect &getCollider(); SDL_Rect &getCollider() { return collider; }
// Obtiene su ubicación // Obtiene su ubicación
SDL_Point getPos(); SDL_Point getPos();
// Recarga la textura // Recarga la textura
void reLoadTexture(); void reLoadTexture() { sprite->getTexture()->reLoad(); }
// Asigna los colores del objeto // Asigna los colores del objeto
void setColors(Color col1, Color col2); void setColors(Color col1, Color col2);
}; };

97
source/moving_sprite.cpp
View File

@@ -78,42 +78,6 @@ void MovingSprite::render()
texture_->render(pos_.x, pos_.y, &clip_, zoom_w_, zoom_h_, rotate_.angle, rotate_.center, flip_); texture_->render(pos_.x, pos_.y, &clip_, zoom_w_, zoom_h_, rotate_.angle, rotate_.center, flip_);
} }
// Establece el valor de la variable
void MovingSprite::setZoomW(float value)
{
zoom_w_ = value;
}
// Establece el valor de la variable
void MovingSprite::setZoomH(float value)
{
zoom_h_ = value;
}
// Establece el valor de la variable
void MovingSprite::setAngle(double value)
{
rotate_.angle = value;
}
// Establece el valor de la variable
void MovingSprite::setRotatingCenter(SDL_Point *point)
{
rotate_.center = point;
}
// Incrementa el valor del ángulo
void MovingSprite::updateAngle()
{
rotate_.angle += rotate_.amount;
}
// Obtiene el valor de la variable
bool MovingSprite::isRotating() const
{
return rotate_.enabled;
}
// Establece la rotacion // Establece la rotacion
void MovingSprite::rotate() void MovingSprite::rotate()
{ {
@@ -135,43 +99,6 @@ void MovingSprite::setRotate(bool enable)
rotate_.counter = 0; rotate_.counter = 0;
} }
// Establece el valor de la variable
void MovingSprite::setRotateSpeed(int value)
{
rotate_.speed = std::max(1, value);
}
// Establece el valor de la variable
void MovingSprite::setRotateAmount(double value)
{
rotate_.amount = value;
}
// Cambia el sentido de la rotación
void MovingSprite::switchRotate()
{
rotate_.amount *= -1;
}
// Establece el valor de la variable
void MovingSprite::setFlip(SDL_RendererFlip flip)
{
flip_ = flip;
}
// Gira el sprite horizontalmente
void MovingSprite::flip()
{
flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL;
}
// Obtiene el valor de la variable
SDL_RendererFlip MovingSprite::getFlip()
{
return flip_;
}
// Establece la posición y_ el tamaño del objeto // Establece la posición y_ el tamaño del objeto
void MovingSprite::setPos(SDL_Rect rect) void MovingSprite::setPos(SDL_Rect rect)
{ {
@@ -203,28 +130,4 @@ void MovingSprite::setPosY(float value)
{ {
y_ = value; y_ = value;
pos_.y = static_cast<int>(y_); pos_.y = static_cast<int>(y_);
}
// Establece el valor de la variable
void MovingSprite::setVelX(float value)
{
vx_ = value;
}
// Establece el valor de la variable
void MovingSprite::setVelY(float value)
{
vy_ = value;
}
// Establece el valor de la variable
void MovingSprite::setAccelX(float value)
{
ax_ = value;
}
// Establece el valor de la variable
void MovingSprite::setAccelY(float value)
{
ay_ = value;
} }

32
source/moving_sprite.h
View File

@@ -38,7 +38,7 @@ protected:
SDL_RendererFlip flip_; // Indica como se voltea el sprite SDL_RendererFlip flip_; // Indica como se voltea el sprite
// Incrementa el valor del ángulo // Incrementa el valor del ángulo
void updateAngle(); void updateAngle() { rotate_.angle += rotate_.amount; }
// Mueve el sprite // Mueve el sprite
void move(); void move();
@@ -73,40 +73,40 @@ public:
float getAccelY() const { return ay_; } float getAccelY() const { return ay_; }
// Establece la variable // Establece la variable
void setVelX(float value); void setVelX(float value) { vx_ = value; }
void setVelY(float value); void setVelY(float value) { vy_ = value; }
void setAccelX(float value); void setAccelX(float value) { ax_ = value; }
void setAccelY(float value); void setAccelY(float value) { ay_ = value; }
// Obten el valor de la variable // Obten el valor de la variable
bool isRotating() const; bool isRotating() const { return rotate_.enabled; }
// Establece el valor de la variable // Establece el valor de la variable
void setZoomW(float value); void setZoomW(float value) { zoom_w_ = value; }
void setZoomH(float value); void setZoomH(float value) { zoom_h_ = value; }
// Establece el valor de la variable // Establece el valor de la variable
void setAngle(double vaue); void setAngle(double value) { rotate_.angle = value; }
void setRotatingCenter(SDL_Point *point); void setRotatingCenter(SDL_Point *point) { rotate_.center = point; }
// Activa o desactiva el efecto de rotación // Activa o desactiva el efecto de rotación
void setRotate(bool enable); void setRotate(bool enable);
// Establece el valor de la variable // Establece el valor de la variable
void setRotateSpeed(int value); void setRotateSpeed(int value) { rotate_.speed = std::max(1, value); }
void setRotateAmount(double value); void setRotateAmount(double value) { rotate_.amount = value; }
// Cambia el sentido de la rotación // Cambia el sentido de la rotación
void switchRotate(); void switchRotate() { rotate_.amount *= -1; }
// Establece el valor de la variable // Establece el valor de la variable
void setFlip(SDL_RendererFlip flip); void setFlip(SDL_RendererFlip flip) { flip_ = flip; }
// Gira el sprite horizontalmente // Gira el sprite horizontalmente
void flip(); void flip() { flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL; }
// Obtiene el valor de la variable // Obtiene el valor de la variable
SDL_RendererFlip getFlip(); SDL_RendererFlip getFlip() { return flip_; }
// Establece la posición y_ el tamaño del objeto // Establece la posición y_ el tamaño del objeto
void setPos(SDL_Rect rect); void setPos(SDL_Rect rect);

280
source/notifier.cpp
View File

@@ -1,20 +1,24 @@
#include "notifier.h" #include "notifier.h"
#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND #include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
#include <string> // Para basic_string, string, char_traits #include <SDL2/SDL_pixels.h> // Para SDL_PIXELFORMAT_RGBA8888
#include "jail_audio.h" // Para JA_DeleteSound, JA_LoadSound, JA_Pla... #include <string> // Para string
#include "sprite.h" // Para Sprite #include <algorithm>
#include "text.h" // Para Text #include <vector>
#include "texture.h" // Para Texture #include "jail_audio.h" // Para JA_DeleteSound, JA_LoadSound, JA_Pla...
#include "screen.h" #include "screen.h" // Para Screen
#include "sprite.h" // Para Sprite
#include "text.h" // Para Text
#include "texture.h" // Para Texture
#include "resource.h"
#include "options.h" #include "options.h"
// [SINGLETON] // [SINGLETON]
Notifier *Notifier::notifier_ = nullptr; Notifier *Notifier::notifier_ = nullptr;
// [SINGLETON] Crearemos el objeto con esta función estática // [SINGLETON] Crearemos el objeto con esta función estática
void Notifier::init(std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile) void Notifier::init(const std::string &icon_file, std::shared_ptr<Text> text)
{ {
Notifier::notifier_ = new Notifier(iconFile, bitmapFile, textFile, soundFile); Notifier::notifier_ = new Notifier(icon_file, text);
} }
// [SINGLETON] Destruiremos el objeto con esta función estática // [SINGLETON] Destruiremos el objeto con esta función estática
@@ -30,45 +34,21 @@ Notifier *Notifier::get()
} }
// Constructor // Constructor
Notifier::Notifier(std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile) Notifier::Notifier(std::string icon_file, std::shared_ptr<Text> text)
{ : renderer_(Screen::get()->getRenderer()),
// Inicializa variables icon_texture_(!icon_file.empty() ? std::make_unique<Texture>(renderer_, icon_file) : nullptr),
renderer_ = Screen::get()->getRenderer(); text_(text),
bg_color_ = options.notifications.color; bg_color_(options.notifications.color),
wait_time_ = 300; wait_time_(150),
stack_(false),
// Crea objetos has_icons_(!icon_file.empty()) {}
icon_texture_ = new Texture(renderer_, iconFile);
text_texture_ = new Texture(renderer_, bitmapFile);
text_ = new Text(textFile, text_texture_, renderer_);
sound_ = JA_LoadSound(soundFile.c_str());
}
// Destructor
Notifier::~Notifier()
{
// Libera la memoria de los objetos
delete text_texture_;
delete icon_texture_;
delete text_;
JA_DeleteSound(sound_);
for (auto notification : notifications_)
{
delete notification.sprite;
delete notification.texture;
}
}
// Dibuja las notificaciones por pantalla // Dibuja las notificaciones por pantalla
void Notifier::render() void Notifier::render()
{ {
if (active()) for (int i = (int)notifications_.size() - 1; i >= 0; --i)
{ {
for (auto it = notifications_.rbegin(); it != notifications_.rend(); ++it) notifications_[i].sprite->render();
{
it->sprite->render();
}
} }
} }
@@ -80,7 +60,7 @@ void Notifier::update()
// Si la notificación anterior está "saliendo", no hagas nada // Si la notificación anterior está "saliendo", no hagas nada
if (i > 0) if (i > 0)
{ {
if (notifications_[i - 1].state == ns_rising) if (notifications_[i - 1].state == NotificationStatus::RISING)
{ {
break; break;
} }
@@ -93,24 +73,25 @@ void Notifier::update()
{ {
if (options.notifications.sound) if (options.notifications.sound)
{ {
if (notifications_[i].state == ns_rising) if (notifications_[i].state == NotificationStatus::RISING)
{ // Reproduce el sonido de la notificación {
JA_PlaySound(sound_); // Reproduce el sonido de la notificación
JA_PlaySound(Resource::get()->getSound("notify.wav"));
} }
} }
} }
// Comprueba los estados // Comprueba los estados
if (notifications_[i].state == ns_rising) if (notifications_[i].state == NotificationStatus::RISING)
{ {
const float step = ((float)notifications_[i].counter / notifications_[i].travelDist); const float step = ((float)notifications_[i].counter / notifications_[i].travel_dist);
const int alpha = 255 * step; const int alpha = 255 * step;
if (options.notifications.getVerticalPosition() == "UPPER") if (options.notifications.getVerticalPosition() == "TOP")
{ {
notifications_[i].rect.y++; notifications_[i].rect.y++;
} }
else if (options.notifications.getVerticalPosition() == "BOTTOM") else
{ {
notifications_[i].rect.y--; notifications_[i].rect.y--;
} }
@@ -118,43 +99,43 @@ void Notifier::update()
if (notifications_[i].rect.y == notifications_[i].y) if (notifications_[i].rect.y == notifications_[i].y)
{ {
notifications_[i].state = ns_stay; notifications_[i].state = NotificationStatus::STAY;
notifications_[i].texture->setAlpha(255); notifications_[i].texture->setAlpha(255);
notifications_[i].counter = 0; notifications_[i].counter = 0;
} }
} }
else if (notifications_[i].state == ns_stay) else if (notifications_[i].state == NotificationStatus::STAY)
{ {
if (notifications_[i].counter == wait_time_) if (notifications_[i].counter == wait_time_)
{ {
notifications_[i].state = ns_vanishing; notifications_[i].state = NotificationStatus::VANISHING;
notifications_[i].counter = 0; notifications_[i].counter = 0;
} }
} }
else if (notifications_[i].state == ns_vanishing) else if (notifications_[i].state == NotificationStatus::VANISHING)
{ {
const float step = (notifications_[i].counter / (float)notifications_[i].travelDist); const float step = (notifications_[i].counter / (float)notifications_[i].travel_dist);
const int alpha = 255 * (1 - step); const int alpha = 255 * (1 - step);
if (options.notifications.getVerticalPosition() == "UPPER") if (options.notifications.getVerticalPosition() == "TOP")
{ {
notifications_[i].rect.y--; notifications_[i].rect.y--;
} }
else if (options.notifications.getVerticalPosition() == "BOTTOM") else
{ {
notifications_[i].rect.y++; notifications_[i].rect.y++;
} }
notifications_[i].texture->setAlpha(alpha); notifications_[i].texture->setAlpha(alpha);
if (notifications_[i].rect.y == notifications_[i].y - notifications_[i].travelDist) if (notifications_[i].rect.y == notifications_[i].y - notifications_[i].travel_dist)
{ {
notifications_[i].state = ns_finished; notifications_[i].state = NotificationStatus::FINISHED;
} }
} }
notifications_[i].sprite->setRect(notifications_[i].rect); notifications_[i].sprite->setPosition(notifications_[i].rect);
} }
clearFinishedNotifications(); clearFinishedNotifications();
@@ -165,87 +146,95 @@ void Notifier::clearFinishedNotifications()
{ {
for (int i = (int)notifications_.size() - 1; i >= 0; --i) for (int i = (int)notifications_.size() - 1; i >= 0; --i)
{ {
if (notifications_[i].state == ns_finished) if (notifications_[i].state == NotificationStatus::FINISHED)
{ {
delete notifications_[i].sprite;
delete notifications_[i].texture;
notifications_.erase(notifications_.begin() + i); notifications_.erase(notifications_.begin() + i);
} }
} }
} }
// Muestra una notificación de texto por pantalla; void Notifier::show(std::vector<std::string> texts, int icon, const std::string &code)
void Notifier::show(std::string text1, std::string text2, int icon)
{ {
// Si no hay texto, acaba
if (texts.empty())
{
return;
}
// Si las notificaciones no se apilan, elimina las anteriores
if (!stack_)
{
clearNotifications();
}
// Elimina las cadenas vacías
texts.erase(std::remove_if(texts.begin(), texts.end(), [](const std::string &s)
{ return s.empty(); }),
texts.end());
// Encuentra la cadena más larga
std::string longest;
for (const auto &text : texts)
{
if (text.length() > longest.length())
longest = text;
}
// Inicializa variables // Inicializa variables
const int iconSize = 16; constexpr int icon_size = 16;
const int padding = text_->getCharacterSize(); constexpr int padding_out = 1;
const int iconSpace = icon >= 0 ? iconSize + padding : 0; const auto padding_in_h = text_->getCharacterSize();
const std::string txt = text1.length() > text2.length() ? text1 : text2; const auto padding_in_v = text_->getCharacterSize() / 2;
const int width = text_->lenght(txt) + (padding * 2) + iconSpace; const int icon_space = icon >= 0 ? icon_size + padding_in_h : 0;
const int height = (text_->getCharacterSize() * 2) + (padding * 2); const int width = text_->lenght(longest) + (padding_in_h * 2) + icon_space;
const int height = (text_->getCharacterSize() * texts.size()) + (padding_in_v * 2);
const auto shape = NotificationShape::SQUARED;
// Posición horizontal // Posición horizontal
int despH = 0; auto desp_h = 0;
if (options.notifications.getHorizontalPosition() == "LEFT") if (options.notifications.getHorizontalPosition() == "LEFT")
{ {
despH = padding; desp_h = padding_out;
} }
else if (options.notifications.getHorizontalPosition() == "CENTER") else if (options.notifications.getHorizontalPosition() == "CENTER")
{ {
despH = (options.game.width - width) / 2; desp_h = ((param.game.width / 2) - (width / 2));
} }
else if (options.notifications.getHorizontalPosition() == "RIGHT") else
{ {
despH = options.game.width - width - padding; desp_h = param.game.width - width - padding_out;
} }
// Posición vertical // Posición vertical
int despV = 0; const int desp_v = (param.notification.pos_v == NotifyPosition::TOP) ? padding_out : (param.game.height - height - padding_out);
if (options.notifications.getVerticalPosition() == "UPPER")
{
despV = padding;
}
else
{
despV = options.game.height - height - padding;
}
const int travelDist = height + padding;
// Offset // Offset
int offset = 0; const auto travel_dist = height + padding_out;
if (options.notifications.getVerticalPosition() == "UPPER") auto offset = 0;
if (param.notification.pos_v == NotifyPosition::TOP)
{ {
offset = static_cast<int>(notifications_.size()) > 0 ? notifications_.back().y + travelDist : despV; offset = !notifications_.empty() ? notifications_.back().y + travel_dist : desp_v;
} }
else else
{ {
offset = static_cast<int>(notifications_.size()) > 0 ? notifications_.back().y - travelDist : despV; offset = !notifications_.empty() ? notifications_.back().y - travel_dist : desp_v;
} }
// Crea la notificacion // Crea la notificacion
notification_t n; Notification n;
// Inicializa variables // Inicializa variables
n.code = code;
n.y = offset; n.y = offset;
n.travelDist = travelDist; n.travel_dist = travel_dist;
n.counter = 0; n.texts = texts;
n.state = ns_rising; n.shape = shape;
n.text1 = text1; auto y_pos = offset + (param.notification.pos_v == NotifyPosition::TOP ? -travel_dist : travel_dist);
n.text2 = text2; n.rect = {desp_h, y_pos, width, height};
if (options.notifications.getVerticalPosition() == "UPPER")
{
n.rect = {despH, offset - travelDist, width, height};
}
else
{
n.rect = {despH, offset + travelDist, width, height};
}
// Crea la textura // Crea la textura
n.texture = new Texture(renderer_); n.texture = std::make_shared<Texture>(renderer_);
n.texture->createBlank(renderer_, width, height, SDL_TEXTUREACCESS_TARGET); n.texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
n.texture->setBlendMode(SDL_BLENDMODE_BLEND); n.texture->setBlendMode(SDL_BLENDMODE_BLEND);
// Prepara para dibujar en la textura // Prepara para dibujar en la textura
@@ -254,49 +243,78 @@ void Notifier::show(std::string text1, std::string text2, int icon)
// Dibuja el fondo de la notificación // Dibuja el fondo de la notificación
SDL_SetRenderDrawColor(renderer_, bg_color_.r, bg_color_.g, bg_color_.b, 255); SDL_SetRenderDrawColor(renderer_, bg_color_.r, bg_color_.g, bg_color_.b, 255);
SDL_Rect rect; SDL_Rect rect;
rect = {4, 0, width - (4 * 2), height}; if (shape == NotificationShape::ROUNDED)
SDL_RenderFillRect(renderer_, &rect); {
rect = {4, 0, width - (4 * 2), height};
SDL_RenderFillRect(renderer_, &rect);
rect = {4 / 2, 1, width - 4, height - 2}; rect = {4 / 2, 1, width - 4, height - 2};
SDL_RenderFillRect(renderer_, &rect); SDL_RenderFillRect(renderer_, &rect);
rect = {1, 4 / 2, width - 2, height - 4}; rect = {1, 4 / 2, width - 2, height - 4};
SDL_RenderFillRect(renderer_, &rect); SDL_RenderFillRect(renderer_, &rect);
rect = {0, 4, width, height - (4 * 2)}; rect = {0, 4, width, height - (4 * 2)};
SDL_RenderFillRect(renderer_, &rect); SDL_RenderFillRect(renderer_, &rect);
}
else if (shape == NotificationShape::SQUARED)
{
SDL_RenderClear(renderer_);
}
// Dibuja el icono de la notificación // Dibuja el icono de la notificación
if (icon >= 0) if (has_icons_ && icon >= 0 && texts.size() >= 2)
{ {
Sprite *sp = new Sprite({0, 0, iconSize, iconSize}, icon_texture_, renderer_); auto sp = std::make_unique<Sprite>(icon_texture_, (SDL_Rect){0, 0, icon_size, icon_size});
sp->setPos({padding, padding, iconSize, iconSize}); sp->setPosition({padding_in_h, padding_in_v, icon_size, icon_size});
sp->setClip({iconSize * (icon % 10), iconSize * (icon / 10), iconSize, iconSize}); sp->setSpriteClip({icon_size * (icon % 10), icon_size * (icon / 10), icon_size, icon_size});
sp->render(); sp->render();
delete sp;
} }
// Escribe el texto de la notificación // Escribe el texto de la notificación
Color color = {255, 255, 255}; const Color color{255, 255, 255};
if (text2 != "") int iterator = 0;
{ // Dos lineas de texto for (const auto &text : texts)
text_->writeColored(padding + iconSpace, padding, text1, color); {
text_->writeColored(padding + iconSpace, padding + text_->getCharacterSize() + 1, text2, color); text_->writeColored(padding_in_h + icon_space, padding_in_v + iterator * (text_->getCharacterSize() + 1), text, color);
} ++iterator;
else
{ // Una linea de texto
text_->writeColored(padding + iconSpace, (height / 2) - (text_->getCharacterSize() / 2), text1, color);
} }
// Deja de dibujar en la textura // Deja de dibujar en la textura
SDL_SetRenderTarget(renderer_, nullptr); SDL_SetRenderTarget(renderer_, nullptr);
// Crea el sprite de la notificación // Crea el sprite de la notificación
n.sprite = new Sprite(n.rect, n.texture, renderer_); n.sprite = std::make_shared<Sprite>(n.texture, n.rect);
// Deja la notificación invisible // Deja la notificación invisible
n.texture->setAlpha(0); n.texture->setAlpha(0);
// Añade la notificación a la lista // Añade la notificación a la lista
notifications_.push_back(n); notifications_.emplace_back(n);
}
// Indica si hay notificaciones activas
bool Notifier::isActive() { return !notifications_.empty(); }
// Finaliza y elimnina todas las notificaciones activas
void Notifier::clearNotifications()
{
for (auto &notification : notifications_)
{
notification.state = NotificationStatus::FINISHED;
}
clearFinishedNotifications();
}
// Obtiene los códigos de las notificaciones
std::vector<std::string> Notifier::getCodes()
{
std::vector<std::string> codes;
for (const auto &notification : notifications_)
{
codes.emplace_back(notification.code);
}
return codes;
} }

92
source/notifier.h
View File

@@ -2,13 +2,13 @@
#include <SDL2/SDL_rect.h> // Para SDL_Rect #include <SDL2/SDL_rect.h> // Para SDL_Rect
#include <SDL2/SDL_render.h> // Para SDL_Renderer #include <SDL2/SDL_render.h> // Para SDL_Renderer
#include <string> // Para basic_string, string #include <memory> // Para shared_ptr
#include <string> // Para string, basic_string
#include <vector> // Para vector #include <vector> // Para vector
#include "utils.h" // Para color_t #include "utils.h" // Para Color
class Sprite; class Sprite; // lines 9-9
class Text; class Text; // lines 10-10
class Texture; class Texture; // lines 11-11
struct JA_Sound_t;
class Notifier class Notifier
{ {
@@ -16,64 +16,69 @@ private:
// [SINGLETON] Objeto notifier // [SINGLETON] Objeto notifier
static Notifier *notifier_; static Notifier *notifier_;
enum notification_state_e enum class NotificationStatus
{ {
ns_rising, RISING,
ns_stay, STAY,
ns_vanishing, VANISHING,
ns_finished FINISHED,
}; };
enum notification_position_e enum class NotificationShape
{ {
upperLeft, ROUNDED,
upperCenter, SQUARED,
upperRight,
middleLeft,
middleRight,
bottomLeft,
bottomCenter,
bottomRight
}; };
struct notification_t struct Notification
{ {
std::string text1; std::shared_ptr<Texture> texture;
std::string text2; std::shared_ptr<Sprite> sprite;
std::vector<std::string> texts;
int counter; int counter;
notification_state_e state; NotificationStatus state;
notification_position_e position; NotificationShape shape;
Texture *texture;
Sprite *sprite;
SDL_Rect rect; SDL_Rect rect;
int y; int y;
int travelDist; int travel_dist;
std::string code; // Permite asignar un código a la notificación
// Constructor
explicit Notification()
: texture(nullptr), sprite(nullptr), texts(), counter(0), state(NotificationStatus::RISING),
shape(NotificationShape::SQUARED), rect{0, 0, 0, 0}, y(0), travel_dist(0), code("") {}
}; };
// Objetos y punteros // Objetos y punteros
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
Texture *text_texture_; // Textura para la fuente de las notificaciones
Texture *icon_texture_; // Textura para los iconos de las notificaciones std::shared_ptr<Texture> icon_texture_; // Textura para los iconos de las notificaciones
Text *text_; // Objeto para dibujar texto std::shared_ptr<Text> text_; // Objeto para dibujar texto
// Variables // Variables
Color bg_color_; // Color de fondo de las notificaciones Color bg_color_; // Color de fondo de las notificaciones
int wait_time_; // Tiempo que se ve la notificación int wait_time_; // Tiempo que se ve la notificación
std::vector<notification_t> notifications_; // La lista de notificaciones activas std::vector<Notification> notifications_; // La lista de notificaciones activas
JA_Sound_t *sound_; // Sonido a reproducir cuando suena la notificación bool stack_; // Indica si las notificaciones se apilan
bool has_icons_; // Indica si el notificador tiene textura para iconos
// Elimina las notificaciones finalizadas // Elimina las notificaciones finalizadas
void clearFinishedNotifications(); void clearFinishedNotifications();
// Finaliza y elimnina todas las notificaciones activas
void clearNotifications();
// [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos notifier desde fuera
// Constructor // Constructor
Notifier(std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile); Notifier(std::string icon_file, std::shared_ptr<Text> text);
// Destructor // Destructor
~Notifier(); ~Notifier() = default;
public: public:
// [SINGLETON] Crearemos el objeto con esta función estática // [SINGLETON] Crearemos el objeto con esta función estática
static void init(std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile); static void init(const std::string &icon_file, std::shared_ptr<Text> text);
// [SINGLETON] Destruiremos el objeto con esta función estática // [SINGLETON] Destruiremos el objeto con esta función estática
static void destroy(); static void destroy();
@@ -87,9 +92,12 @@ public:
// Actualiza el estado de las notificaiones // Actualiza el estado de las notificaiones
void update(); void update();
// Muestra una notificación de texto por pantalla; // Muestra una notificación de texto por pantalla
void show(std::string text1 = "", std::string text2 = "", int icon = -1); void show(std::vector<std::string> texts, int icon = -1, const std::string &code = std::string());
// Getters // Indica si hay notificaciones activas
bool active() const { return !notifications_.empty(); } bool isActive();
// Obtiene los códigos de las notificaciones
std::vector<std::string> getCodes();
}; };

2
source/options.cpp
View File

@@ -3,6 +3,8 @@
#include "screen.h" #include "screen.h"
#include <fstream> // Para basic_ofstream, basic_ifstream #include <fstream> // Para basic_ofstream, basic_ifstream
#include <iostream> // Para basic_ostream, operator<<, cout #include <iostream> // Para basic_ostream, operator<<, cout
#include <unordered_map> // Para unordered_map
#include <functional> // Para std::function
// Variables // Variables
Options options; Options options;

513
source/player.cpp
View File

@@ -25,86 +25,84 @@ Player::Player(player_t player)
debug_(Debug::get()) debug_(Debug::get())
{ {
// Crea objetos // Crea objetos
sprite_ = new AnimatedSprite(renderer_, resource_->getAnimation(player.animation)); sprite_ = std::make_shared<AnimatedSprite>(resource_->getAnimation(player.animation));
// Inicializa variables // Inicializa variables
reLoadPalette(); reLoadPalette();
onBorder = false; is_on_border_ = false;
border = BORDER_TOP; border_ = BORDER_TOP;
autoMovement = false; auto_movement_ = false;
alive = true; is_alive_ = true;
maxFallHeight = BLOCK * 4; is_paused_ = false;
paused = false;
jumpIni = player.spawn.jumpIni; jump_init_pos_ = player.spawn.jump_init_pos;
state = player.spawn.state; state_ = player.spawn.state;
prevState = state; previous_state_ = state_;
x = player.spawn.x; x_ = player.spawn.x;
y = player.spawn.y; y_ = player.spawn.y;
vx = player.spawn.vx; vx_ = player.spawn.vx;
vy = player.spawn.vy; vy_ = player.spawn.vy;
w = 8; w_ = 8;
h = 16; h_ = 16;
maxVY = 1.2f;
sprite_->setPosX(player.spawn.x); sprite_->setPosX(player.spawn.x);
sprite_->setPosY(player.spawn.y); sprite_->setPosY(player.spawn.y);
sprite_->setWidth(8); sprite_->setWidth(8);
sprite_->setHeight(16); sprite_->setHeight(16);
sprite_->setFlipH(player.spawn.flipH); sprite_->setFlip(player.spawn.flip);
sprite_->setCurrentAnimation("walk"); sprite_->setCurrentAnimation("walk");
sprite_->animate(); sprite_->update();
lastPosition = getRect(); last_position_ = getRect();
colliderBox = getRect(); collider_box_ = getRect();
const SDL_Point p = {0, 0}; const SDL_Point p = {0, 0};
colliderPoints.insert(colliderPoints.end(), {p, p, p, p, p, p, p, p}); collider_points_.insert(collider_points_.end(), {p, p, p, p, p, p, p, p});
underFeet.insert(underFeet.end(), {p, p}); under_feet_.insert(under_feet_.end(), {p, p});
feet.insert(feet.end(), {p, p}); feet_.insert(feet_.end(), {p, p});
jumpSound.push_back(JA_LoadSound(asset_->get("jump1.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump1.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump2.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump2.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump3.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump3.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump4.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump4.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump5.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump5.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump6.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump6.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump7.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump7.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump8.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump8.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump9.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump9.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump10.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump10.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump11.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump11.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump12.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump12.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump13.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump13.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump14.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump14.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump15.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump15.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump16.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump16.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump17.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump17.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump18.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump18.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump19.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump19.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump20.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump20.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump21.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump21.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump22.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump22.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump23.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump23.wav").c_str()));
jumpSound.push_back(JA_LoadSound(asset_->get("jump24.wav").c_str())); jumping_sound_.push_back(JA_LoadSound(asset_->get("jump24.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump11.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump11.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump12.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump12.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump13.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump13.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump14.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump14.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump15.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump15.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump16.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump16.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump17.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump17.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump18.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump18.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump19.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump19.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump20.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump20.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump21.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump21.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump22.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump22.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump23.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump23.wav").c_str()));
fallSound.push_back(JA_LoadSound(asset_->get("jump24.wav").c_str())); falling_sound_.push_back(JA_LoadSound(asset_->get("jump24.wav").c_str()));
jumpCounter = 0; jumping_counter_ = 0;
fallCounter = 0; falling_counter_ = 0;
#ifdef DEBUG #ifdef DEBUG
rx = {0, 0, 0, 0}; rx = {0, 0, 0, 0};
@@ -114,21 +112,10 @@ Player::Player(player_t player)
#endif #endif
} }
// Destructor
Player::~Player()
{
delete sprite_;
for (auto s : jumpSound)
{
JA_DeleteSound(s);
}
}
// Pinta el jugador en pantalla // Pinta el jugador en pantalla
void Player::render() void Player::render()
{ {
sprite_->getTexture()->setColor(color.r, color.g, color.b); sprite_->getTexture()->setColor(color_.r, color_.g, color_.b);
sprite_->render(); sprite_->render();
#ifdef DEBUG #ifdef DEBUG
@@ -167,7 +154,7 @@ void Player::render()
// Actualiza las variables del objeto // Actualiza las variables del objeto
void Player::update() void Player::update()
{ {
if (paused) if (is_paused_)
{ // Si está en modo pausa no se actualiza nada { // Si está en modo pausa no se actualiza nada
return; return;
} }
@@ -184,45 +171,45 @@ void Player::update()
void Player::checkInput() void Player::checkInput()
{ {
// Solo comprueba las entradas de dirección cuando está sobre una superficie // Solo comprueba las entradas de dirección cuando está sobre una superficie
if (state != s_standing) if (state_ != s_standing)
{ {
return; return;
} }
if (!autoMovement) if (!auto_movement_)
{ // Comprueba las entradas de desplazamiento lateral solo en el caso de no estar enganchado a una superficie automatica { // Comprueba las entradas de desplazamiento lateral solo en el caso de no estar enganchado a una superficie automatica
if (input_->checkInput(input_left)) if (input_->checkInput(input_left))
{ {
vx = -0.6f; vx_ = -0.6f;
sprite_->setFlipH(true); sprite_->setFlip(SDL_FLIP_HORIZONTAL);
} }
else if (input_->checkInput(input_right)) else if (input_->checkInput(input_right))
{ {
vx = 0.6f; vx_ = 0.6f;
sprite_->setFlipH(false); sprite_->setFlip(SDL_FLIP_NONE);
} }
else else
{ // No se pulsa ninguna dirección { // No se pulsa ninguna dirección
vx = 0.0f; vx_ = 0.0f;
if (isOnAutoSurface()) if (isOnAutoSurface())
{ // Si deja de moverse sobre una superficie se engancha { // Si deja de moverse sobre una superficie se engancha
autoMovement = true; auto_movement_ = true;
} }
} }
} }
else else
{ // El movimiento lo proporciona la superficie { // El movimiento lo proporciona la superficie
vx = 0.6f * room_->getAutoSurfaceDirection(); vx_ = 0.6f * room_->getAutoSurfaceDirection();
if (vx > 0.0f) if (vx_ > 0.0f)
{ {
sprite_->setFlipH(false); sprite_->setFlip(SDL_FLIP_NONE);
} }
else else
{ {
sprite_->setFlipH(true); sprite_->setFlip(SDL_FLIP_HORIZONTAL);
} }
} }
@@ -236,9 +223,9 @@ void Player::checkInput()
if (isOnFloor() || isOnAutoSurface()) if (isOnFloor() || isOnAutoSurface())
{ {
setState(s_jumping); setState(s_jumping);
vy = -maxVY; vy_ = -MAX_VY_;
jumpIni = y; jump_init_pos_ = y_;
jumpCounter = 0; jumping_counter_ = 0;
} }
} }
} }
@@ -246,45 +233,45 @@ void Player::checkInput()
// Indica si el jugador esta en uno de los cuatro bordes de la pantalla // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
bool Player::getOnBorder() bool Player::getOnBorder()
{ {
return onBorder; return is_on_border_;
} }
// Indica en cual de los cuatro bordes se encuentra // Indica en cual de los cuatro bordes se encuentra
int Player::getBorder() int Player::getBorder()
{ {
return border; return border_;
} }
// Comprueba si está situado en alguno de los cuatro bordes de la habitación // Comprueba si está situado en alguno de los cuatro bordes de la habitación
void Player::checkBorders() void Player::checkBorders()
{ {
if (x < PLAY_AREA_LEFT) if (x_ < PLAY_AREA_LEFT)
{ {
border = BORDER_LEFT; border_ = BORDER_LEFT;
onBorder = true; is_on_border_ = true;
} }
else if (x > PLAY_AREA_RIGHT - w) else if (x_ + w_ > PLAY_AREA_RIGHT)
{ {
border = BORDER_RIGHT; border_ = BORDER_RIGHT;
onBorder = true; is_on_border_ = true;
} }
else if (y < PLAY_AREA_TOP) else if (y_ < PLAY_AREA_TOP)
{ {
border = BORDER_TOP; border_ = BORDER_TOP;
onBorder = true; is_on_border_ = true;
} }
else if (y > PLAY_AREA_BOTTOM - h) else if (y_ + h_ > PLAY_AREA_BOTTOM)
{ {
border = BORDER_BOTTOM; border_ = BORDER_BOTTOM;
onBorder = true; is_on_border_ = true;
} }
else else
{ {
onBorder = false; is_on_border_ = false;
} }
} }
@@ -292,37 +279,37 @@ void Player::checkBorders()
void Player::checkState() void Player::checkState()
{ {
// Actualiza las variables en función del estado // Actualiza las variables en función del estado
if (state == s_falling) if (state_ == s_falling)
{ {
vx = 0.0f; vx_ = 0.0f;
vy = maxVY; vy_ = MAX_VY_;
fallCounter++; falling_counter_++;
playFallSound(); playFallSound();
} }
else if (state == s_standing) else if (state_ == s_standing)
{ {
if (prevState == s_falling && fallCounter > maxFallHeight) if (previous_state_ == s_falling && falling_counter_ > MAX_FALLING_HEIGHT_)
{ // Si cae de muy alto, el jugador muere { // Si cae de muy alto, el jugador muere
alive = false; is_alive_ = false;
} }
vy = 0.0f; vy_ = 0.0f;
jumpCounter = 0; jumping_counter_ = 0;
fallCounter = 0; falling_counter_ = 0;
if (!isOnFloor() && !isOnAutoSurface() && !isOnDownSlope()) if (!isOnFloor() && !isOnAutoSurface() && !isOnDownSlope())
{ {
setState(s_falling); setState(s_falling);
vx = 0.0f; vx_ = 0.0f;
vy = maxVY; vy_ = MAX_VY_;
fallCounter++; falling_counter_++;
playFallSound(); playFallSound();
} }
} }
else if (state == s_jumping) else if (state_ == s_jumping)
{ {
fallCounter = 0; falling_counter_ = 0;
jumpCounter++; jumping_counter_++;
playJumpSound(); playJumpSound();
} }
} }
@@ -330,41 +317,41 @@ void Player::checkState()
// Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla // Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
void Player::switchBorders() void Player::switchBorders()
{ {
if (border == BORDER_TOP) if (border_ == BORDER_TOP)
{ {
y = PLAY_AREA_BOTTOM - h - 0 - BLOCK; y_ = PLAY_AREA_BOTTOM - h_ - 0 - BLOCK;
setState(s_standing); setState(s_standing);
} }
else if (border == BORDER_BOTTOM) else if (border_ == BORDER_BOTTOM)
{ {
y = PLAY_AREA_TOP + 0; y_ = PLAY_AREA_TOP + 0;
setState(s_standing); setState(s_standing);
} }
else if (border == BORDER_RIGHT) else if (border_ == BORDER_RIGHT)
{ {
x = PLAY_AREA_LEFT + 0; x_ = PLAY_AREA_LEFT + 0;
} }
if (border == BORDER_LEFT) if (border_ == BORDER_LEFT)
{ {
x = PLAY_AREA_RIGHT - w - 0; x_ = PLAY_AREA_RIGHT - w_ - 0;
} }
onBorder = false; is_on_border_ = false;
} }
// Aplica gravedad al jugador // Aplica gravedad al jugador
void Player::applyGravity() void Player::applyGravity()
{ {
const float gf = 0.035f; constexpr float GF = 0.035f;
// La gravedad solo se aplica cuando el jugador esta saltando // La gravedad solo se aplica cuando el jugador esta saltando
// Nunca mientras cae o esta de pie // Nunca mientras cae o esta de pie
if (state == s_jumping) if (state_ == s_jumping)
{ {
vy += gf; vy_ += GF;
if (vy > maxVY) if (vy_ > MAX_VY_)
{ {
vy = maxVY; vy_ = MAX_VY_;
} }
} }
} }
@@ -372,36 +359,36 @@ void Player::applyGravity()
// Obtiene el rectangulo que delimita al jugador // Obtiene el rectangulo que delimita al jugador
SDL_Rect Player::getRect() SDL_Rect Player::getRect()
{ {
return {(int)x, (int)y, w, h}; return {static_cast<int>(x_), static_cast<int>(y_), w_, h_};
} }
// Obtiene el rectangulo de colision del jugador // Obtiene el rectangulo de colision del jugador
SDL_Rect &Player::getCollider() SDL_Rect &Player::getCollider()
{ {
colliderBox = getRect(); collider_box_ = getRect();
return colliderBox; return collider_box_;
} }
// Recalcula la posición del jugador y su animación // Recalcula la posición del jugador y su animación
void Player::move() void Player::move()
{ {
lastPosition = {(int)x, (int)y}; // Guarda la posicion actual antes de modificarla last_position_ = {static_cast<int>(x_), static_cast<int>(y_)}; // Guarda la posicion actual antes de modificarla
applyGravity(); // Aplica gravedad al jugador applyGravity(); // Aplica gravedad al jugador
checkState(); // Comprueba el estado del jugador checkState(); // Comprueba el estado del jugador
#ifdef DEBUG #ifdef DEBUG
debugColor = {0, 255, 0}; debugColor = {0, 255, 0};
#endif #endif
// Se mueve hacia la izquierda // Se mueve hacia la izquierda
if (vx < 0.0f) if (vx_ < 0.0f)
{ {
// Crea el rectangulo de proyección en el eje X para ver si colisiona // Crea el rectangulo de proyección en el eje X para ver si colisiona
SDL_Rect proj; SDL_Rect proj;
proj.x = (int)(x + vx); proj.x = static_cast<int>(x_ + vx_);
proj.y = (int)y; proj.y = static_cast<int>(y_);
proj.h = h; proj.h = h_;
proj.w = ceil(abs(vx)); // Para evitar que tenga un ancho de 0 pixels proj.w = ceil(abs(vx_)); // Para evitar que tenga un ancho de 0 pixels
#ifdef DEBUG #ifdef DEBUG
rx = proj; rx = proj;
@@ -412,41 +399,43 @@ void Player::move()
// Calcula la nueva posición // Calcula la nueva posición
if (pos == -1) if (pos == -1)
{ // Si no hay colisión {
x += vx; // Si no hay colisión
x_ += vx_;
} }
else else
{ // Si hay colisión lo mueve hasta donde no colisiona {
x = pos + 1; // Si hay colisión lo mueve hasta donde no colisiona
x_ = pos + 1;
} }
// Si ha tocado alguna rampa mientras camina (sin saltar), asciende // Si ha tocado alguna rampa mientras camina (sin saltar), asciende
if (state != s_jumping) if (state_ != s_jumping)
{ {
v_line_t leftSide = {(int)x, (int)y + h - 2, (int)y + h - 1}; // Comprueba solo los dos pixels de abajo v_line_t leftSide = {static_cast<int>(x_), static_cast<int>(y_) + h_ - 2, static_cast<int>(y_) + h_ - 1}; // Comprueba solo los dos pixels de abajo
const int ly = room_->checkLeftSlopes(&leftSide); const int ly = room_->checkLeftSlopes(&leftSide);
if (ly > -1) if (ly > -1)
{ {
y = ly - h; y_ = ly - h_;
} }
} }
// Si está bajando la rampa, recoloca al jugador // Si está bajando la rampa, recoloca al jugador
if (isOnDownSlope() && state != s_jumping) if (isOnDownSlope() && state_ != s_jumping)
{ {
y += 1; y_ += 1;
} }
} }
// Se mueve hacia la derecha // Se mueve hacia la derecha
else if (vx > 0.0f) else if (vx_ > 0.0f)
{ {
// Crea el rectangulo de proyección en el eje X para ver si colisiona // Crea el rectangulo de proyección en el eje X para ver si colisiona
SDL_Rect proj; SDL_Rect proj;
proj.x = (int)x + w; proj.x = static_cast<int>(x_) + w_;
proj.y = (int)y; proj.y = static_cast<int>(y_);
proj.h = h; proj.h = h_;
proj.w = ceil(vx); // Para evitar que tenga un ancho de 0 pixels proj.w = ceil(vx_); // Para evitar que tenga un ancho de 0 pixels
#ifdef DEBUG #ifdef DEBUG
rx = proj; rx = proj;
@@ -457,57 +446,59 @@ void Player::move()
// Calcula la nueva posición // Calcula la nueva posición
if (pos == -1) if (pos == -1)
{ // Si no hay colisión {
x += vx; // Si no hay colisión
x_ += vx_;
} }
else else
{ // Si hay colisión lo mueve hasta donde no colisiona {
x = pos - w; // Si hay colisión lo mueve hasta donde no colisiona
x_ = pos - w_;
} }
// Si ha tocado alguna rampa mientras camina (sin saltar), asciende // Si ha tocado alguna rampa mientras camina (sin saltar), asciende
if (state != s_jumping) if (state_ != s_jumping)
{ {
v_line_t rightSide = {(int)x + w - 1, (int)y + h - 2, (int)y + h - 1}; // Comprueba solo los dos pixels de abajo v_line_t rightSide = {static_cast<int>(x_) + w_ - 1, static_cast<int>(y_) + h_ - 2, static_cast<int>(y_) + h_ - 1}; // Comprueba solo los dos pixels de abajo
const int ry = room_->checkRightSlopes(&rightSide); const int ry = room_->checkRightSlopes(&rightSide);
if (ry > -1) if (ry > -1)
{ {
y = ry - h; y_ = ry - h_;
} }
} }
// Si está bajando la rampa, recoloca al jugador // Si está bajando la rampa, recoloca al jugador
if (isOnDownSlope() && state != s_jumping) if (isOnDownSlope() && state_ != s_jumping)
{ {
y += 1; y_ += 1;
} }
} }
// Si ha salido del suelo, el jugador cae // Si ha salido del suelo, el jugador cae
if (state == s_standing && !isOnFloor()) if (state_ == s_standing && !isOnFloor())
{ {
setState(s_falling); setState(s_falling);
// Deja de estar enganchado a la superficie automatica // Deja de estar enganchado a la superficie automatica
autoMovement = false; auto_movement_ = false;
} }
// Si ha salido de una superficie automatica, detiene el movimiento automatico // Si ha salido de una superficie automatica, detiene el movimiento automatico
if (state == s_standing && isOnFloor() && !isOnAutoSurface()) if (state_ == s_standing && isOnFloor() && !isOnAutoSurface())
{ {
// Deja de estar enganchado a la superficie automatica // Deja de estar enganchado a la superficie automatica
autoMovement = false; auto_movement_ = false;
} }
// Se mueve hacia arriba // Se mueve hacia arriba
if (vy < 0.0f) if (vy_ < 0.0f)
{ {
// Crea el rectangulo de proyección en el eje Y para ver si colisiona // Crea el rectangulo de proyección en el eje Y para ver si colisiona
SDL_Rect proj; SDL_Rect proj;
proj.x = (int)x; proj.x = static_cast<int>(x_);
proj.y = (int)(y + vy); proj.y = static_cast<int>(y_ + vy_);
proj.h = ceil(abs(vy)); // Para evitar que tenga una altura de 0 pixels proj.h = ceil(abs(vy_)); // Para evitar que tenga una altura de 0 pixels
proj.w = w; proj.w = w_;
#ifdef DEBUG #ifdef DEBUG
ry = proj; ry = proj;
@@ -518,25 +509,27 @@ void Player::move()
// Calcula la nueva posición // Calcula la nueva posición
if (pos == -1) if (pos == -1)
{ // Si no hay colisión {
y += vy; // Si no hay colisión
y_ += vy_;
} }
else else
{ // Si hay colisión lo mueve hasta donde no colisiona y entra en caída {
y = pos + 1; // Si hay colisión lo mueve hasta donde no colisiona y entra en caída
y_ = pos + 1;
setState(s_falling); setState(s_falling);
} }
} }
// Se mueve hacia abajo // Se mueve hacia abajo
else if (vy > 0.0f) else if (vy_ > 0.0f)
{ {
// Crea el rectangulo de proyección en el eje Y para ver si colisiona // Crea el rectangulo de proyección en el eje Y para ver si colisiona
SDL_Rect proj; SDL_Rect proj;
proj.x = (int)x; proj.x = static_cast<int>(x_);
proj.y = (int)y + h; proj.y = static_cast<int>(y_) + h_;
proj.h = ceil(vy); // Para evitar que tenga una altura de 0 pixels proj.h = ceil(vy_); // Para evitar que tenga una altura de 0 pixels
proj.w = w; proj.w = w_;
#ifdef DEBUG #ifdef DEBUG
ry = proj; ry = proj;
@@ -545,24 +538,27 @@ void Player::move()
// Comprueba la colisión con las superficies normales y las automáticas // Comprueba la colisión con las superficies normales y las automáticas
const int pos = std::max(room_->checkTopSurfaces(&proj), room_->checkAutoSurfaces(&proj)); const int pos = std::max(room_->checkTopSurfaces(&proj), room_->checkAutoSurfaces(&proj));
if (pos > -1) if (pos > -1)
{ // Si hay colisión lo mueve hasta donde no colisiona y pasa a estar sobre la superficie {
y = pos - h; // Si hay colisión lo mueve hasta donde no colisiona y pasa a estar sobre la superficie
y_ = pos - h_;
setState(s_standing); setState(s_standing);
// Deja de estar enganchado a la superficie automatica // Deja de estar enganchado a la superficie automatica
autoMovement = false; auto_movement_ = false;
} }
else else
{ // Si no hay colisión con los muros, comprueba la colisión con las rampas {
if (state != s_jumping) // Si no hay colisión con los muros, comprueba la colisión con las rampas
if (state_ != s_jumping)
{ // Las rampas no se miran si se está saltando { // Las rampas no se miran si se está saltando
v_line_t leftSide = {proj.x, proj.y, proj.y + proj.h - 1}; v_line_t leftSide = {proj.x, proj.y, proj.y + proj.h - 1};
v_line_t rightSide = {proj.x + proj.w - 1, proj.y, proj.y + proj.h - 1}; v_line_t rightSide = {proj.x + proj.w - 1, proj.y, proj.y + proj.h - 1};
const int p = std::max(room_->checkRightSlopes(&rightSide), room_->checkLeftSlopes(&leftSide)); const int p = std::max(room_->checkRightSlopes(&rightSide), room_->checkLeftSlopes(&leftSide));
if (p > -1) if (p > -1)
{ // No está saltando y hay colisión con una rampa {
// No está saltando y hay colisión con una rampa
// Calcula la nueva posición // Calcula la nueva posición
y = p - h; y_ = p - h_;
setState(s_standing); setState(s_standing);
#ifdef DEBUG #ifdef DEBUG
debugColor = {255, 255, 0}; debugColor = {255, 255, 0};
@@ -570,25 +566,27 @@ void Player::move()
#endif #endif
} }
else else
{ // No está saltando y no hay colisón con una rampa {
// No está saltando y no hay colisón con una rampa
// Calcula la nueva posición // Calcula la nueva posición
y += vy; y_ += vy_;
#ifdef DEBUG #ifdef DEBUG
debugColor = {255, 0, 0}; debugColor = {255, 0, 0};
#endif #endif
} }
} }
else else
{ // Esta saltando y no hay colisión con los muros {
// Esta saltando y no hay colisión con los muros
// Calcula la nueva posición // Calcula la nueva posición
y += vy; y_ += vy_;
} }
} }
} }
// Actualiza la posición del sprite // Actualiza la posición del sprite
sprite_->setPosX(x); sprite_->setPosX(x_);
sprite_->setPosY(y); sprite_->setPosY(y_);
#ifdef DEBUG #ifdef DEBUG
debug_->add("RECT_X: " + std::to_string(rx.x) + "," + std::to_string(rx.y) + "," + std::to_string(rx.w) + "," + std::to_string(rx.h)); debug_->add("RECT_X: " + std::to_string(rx.x) + "," + std::to_string(rx.y) + "," + std::to_string(rx.w) + "," + std::to_string(rx.h));
@@ -599,24 +597,25 @@ void Player::move()
// Establece la animación del jugador // Establece la animación del jugador
void Player::animate() void Player::animate()
{ {
if (vx != 0) if (vx_ != 0)
{ {
sprite_->animate(); sprite_->update();
} }
} }
// Comprueba si ha finalizado el salto al alcanzar la altura de inicio // Comprueba si ha finalizado el salto al alcanzar la altura de inicio
void Player::checkJumpEnd() void Player::checkJumpEnd()
{ {
if (state == s_jumping) if (state_ == s_jumping)
{ {
if (vy > 0) if (vy_ > 0)
{ {
if (y >= jumpIni) if (y_ >= jump_init_pos_)
{ // Si alcanza la altura de salto inicial, pasa al estado de caída {
// Si alcanza la altura de salto inicial, pasa al estado de caída
setState(s_falling); setState(s_falling);
vy = maxVY; vy_ = MAX_VY_;
jumpCounter = 0; jumping_counter_ = 0;
} }
} }
} }
@@ -625,9 +624,9 @@ void Player::checkJumpEnd()
// Calcula y reproduce el sonido de salto // Calcula y reproduce el sonido de salto
void Player::playJumpSound() void Player::playJumpSound()
{ {
if (jumpCounter % 4 == 0) if (jumping_counter_ % 4 == 0)
{ {
JA_PlaySound(jumpSound[jumpCounter / 4]); JA_PlaySound(jumping_sound_[jumping_counter_ / 4]);
} }
#ifdef DEBUG #ifdef DEBUG
@@ -638,9 +637,9 @@ void Player::playJumpSound()
// Calcula y reproduce el sonido de caer // Calcula y reproduce el sonido de caer
void Player::playFallSound() void Player::playFallSound()
{ {
if (fallCounter % 4 == 0) if (falling_counter_ % 4 == 0)
{ {
JA_PlaySound(fallSound[std::min((fallCounter / 4), (int)fallSound.size() - 1)]); JA_PlaySound(falling_sound_[std::min((falling_counter_ / 4), (int)falling_sound_.size() - 1)]);
} }
#ifdef DEBUG #ifdef DEBUG
@@ -658,15 +657,15 @@ bool Player::isOnFloor()
updateFeet(); updateFeet();
// Comprueba las superficies // Comprueba las superficies
for (auto f : underFeet) for (auto f : under_feet_)
{ {
onFloor |= room_->checkTopSurfaces(&f); onFloor |= room_->checkTopSurfaces(&f);
onFloor |= room_->checkAutoSurfaces(&f); onFloor |= room_->checkAutoSurfaces(&f);
} }
// Comprueba las rampas // Comprueba las rampas
onSlopeL = room_->checkLeftSlopes(&underFeet[0]); onSlopeL = room_->checkLeftSlopes(&under_feet_[0]);
onSlopeR = room_->checkRightSlopes(&underFeet[1]); onSlopeR = room_->checkRightSlopes(&under_feet_[1]);
#ifdef DEBUG #ifdef DEBUG
if (onFloor) if (onFloor)
@@ -696,7 +695,7 @@ bool Player::isOnAutoSurface()
updateFeet(); updateFeet();
// Comprueba las superficies // Comprueba las superficies
for (auto f : underFeet) for (auto f : under_feet_)
{ {
onAutoSurface |= room_->checkAutoSurfaces(&f); onAutoSurface |= room_->checkAutoSurfaces(&f);
} }
@@ -720,12 +719,12 @@ bool Player::isOnDownSlope()
// Cuando el jugador baja una escalera, se queda volando // Cuando el jugador baja una escalera, se queda volando
// Hay que mirar otro pixel más por debajo // Hay que mirar otro pixel más por debajo
underFeet[0].y += 1; under_feet_[0].y += 1;
underFeet[1].y += 1; under_feet_[1].y += 1;
// Comprueba las rampas // Comprueba las rampas
onSlope |= room_->checkLeftSlopes(&underFeet[0]); onSlope |= room_->checkLeftSlopes(&under_feet_[0]);
onSlope |= room_->checkRightSlopes(&underFeet[1]); onSlope |= room_->checkRightSlopes(&under_feet_[1]);
#ifdef DEBUG #ifdef DEBUG
if (onSlope) if (onSlope)
@@ -746,7 +745,7 @@ bool Player::checkKillingTiles()
// Comprueba si hay contacto // Comprueba si hay contacto
bool check = false; bool check = false;
for (auto c : colliderPoints) for (auto c : collider_points_)
{ {
check |= (room_->getTile(c) == t_kill); check |= (room_->getTile(c) == t_kill);
} }
@@ -754,7 +753,7 @@ bool Player::checkKillingTiles()
// Mata al jugador si hay colisión // Mata al jugador si hay colisión
if (check) if (check)
{ {
alive = false; is_alive_ = false;
} }
return check; return check;
@@ -765,13 +764,13 @@ playerSpawn_t Player::getSpawnParams()
{ {
playerSpawn_t params; playerSpawn_t params;
params.x = x; params.x = x_;
params.y = y; params.y = y_;
params.vx = vx; params.vx = vx_;
params.vy = vy; params.vy = vy_;
params.jumpIni = jumpIni; params.jump_init_pos = jump_init_pos_;
params.state = state; params.state = state_;
params.flipH = sprite_->getFlipH(); params.flip = sprite_->getFlip();
return params; return params;
} }
@@ -785,60 +784,54 @@ void Player::reLoadTexture()
// Recarga la paleta // Recarga la paleta
void Player::reLoadPalette() void Player::reLoadPalette()
{ {
color = stringToColor(options.video.palette, "white"); color_ = stringToColor(options.video.palette, "white");
if (options.cheats.infinite_lives == Cheat::CheatState::ENABLED) if (options.cheats.infinite_lives == Cheat::CheatState::ENABLED)
{ {
color = stringToColor(options.video.palette, "green"); color_ = stringToColor(options.video.palette, "yellow");
}
{
color = stringToColor(options.video.palette, "yellow");
} }
if (options.cheats.invincible == Cheat::CheatState::ENABLED) if (options.cheats.invincible == Cheat::CheatState::ENABLED)
{ {
color = stringToColor(options.video.palette, "green"); color_ = stringToColor(options.video.palette, "cyan");
}
{
color = stringToColor(options.video.palette, "cyan");
} }
} }
// Establece el valor de la variable // Establece el valor de la variable
void Player::setRoom(Room *room) void Player::setRoom(std::shared_ptr<Room> room)
{ {
this->room_ = room; room_ = room;
} }
// Actualiza los puntos de colisión // Actualiza los puntos de colisión
void Player::updateColliderPoints() void Player::updateColliderPoints()
{ {
const SDL_Rect rect = getRect(); const SDL_Rect rect = getRect();
colliderPoints[0] = {rect.x, rect.y}; collider_points_[0] = {rect.x, rect.y};
colliderPoints[1] = {rect.x + 7, rect.y}; collider_points_[1] = {rect.x + 7, rect.y};
colliderPoints[2] = {rect.x + 7, rect.y + 7}; collider_points_[2] = {rect.x + 7, rect.y + 7};
colliderPoints[3] = {rect.x, rect.y + 7}; collider_points_[3] = {rect.x, rect.y + 7};
colliderPoints[4] = {rect.x, rect.y + 8}; collider_points_[4] = {rect.x, rect.y + 8};
colliderPoints[5] = {rect.x + 7, rect.y + 8}; collider_points_[5] = {rect.x + 7, rect.y + 8};
colliderPoints[6] = {rect.x + 7, rect.y + 15}; collider_points_[6] = {rect.x + 7, rect.y + 15};
colliderPoints[7] = {rect.x, rect.y + 15}; collider_points_[7] = {rect.x, rect.y + 15};
} }
// Actualiza los puntos de los pies // Actualiza los puntos de los pies
void Player::updateFeet() void Player::updateFeet()
{ {
const SDL_Point p = {(int)x, (int)y}; const SDL_Point p = {static_cast<int>(x_), static_cast<int>(y_)};
underFeet[0] = {p.x, p.y + h}; under_feet_[0] = {p.x, p.y + h_};
underFeet[1] = {p.x + 7, p.y + h}; under_feet_[1] = {p.x + 7, p.y + h_};
feet[0] = {p.x, p.y + h - 1}; feet_[0] = {p.x, p.y + h_ - 1};
feet[1] = {p.x + 7, p.y + h - 1}; feet_[1] = {p.x + 7, p.y + h_ - 1};
} }
// Cambia el estado del jugador // Cambia el estado del jugador
void Player::setState(state_e value) void Player::setState(state_e value)
{ {
prevState = state; previous_state_ = state_;
state = value; state_ = value;
checkState(); checkState();
} }
@@ -846,17 +839,17 @@ void Player::setState(state_e value)
// Comprueba si el jugador esta vivo // Comprueba si el jugador esta vivo
bool Player::isAlive() bool Player::isAlive()
{ {
return alive; return is_alive_;
} }
// Pone el jugador en modo pausa // Pone el jugador en modo pausa
void Player::pause() void Player::pause()
{ {
paused = true; is_paused_ = true;
} }
// Quita el modo pausa del jugador // Quita el modo pausa del jugador
void Player::resume() void Player::resume()
{ {
paused = false; is_paused_ = false;
} }

79
source/player.h
View File

@@ -4,6 +4,7 @@
#include <SDL2/SDL_render.h> // Para SDL_Renderer #include <SDL2/SDL_render.h> // Para SDL_Renderer
#include <string> // Para basic_string, string #include <string> // Para basic_string, string
#include <vector> // Para vector #include <vector> // Para vector
#include <memory> // Para shared_ptr
#include "utils.h" // Para color_t #include "utils.h" // Para color_t
class AnimatedSprite; class AnimatedSprite;
class Asset; class Asset;
@@ -26,9 +27,9 @@ struct playerSpawn_t
float y; float y;
float vx; float vx;
float vy; float vy;
int jumpIni; int jump_init_pos;
state_e state; state_e state;
bool flipH; SDL_RendererFlip flip;
}; };
struct player_t struct player_t
@@ -36,48 +37,50 @@ struct player_t
playerSpawn_t spawn; playerSpawn_t spawn;
std::string png; std::string png;
std::string animation; std::string animation;
Room *room; std::shared_ptr<Room> room;
}; };
class Player class Player
{ {
public: public:
// Constantes
static const int MAX_FALLING_HEIGHT_ = BLOCK * 4; // Altura maxima permitida de caída.
static const float MAX_VY_ = 1.2f; // Velocidad máxima que puede alcanzar al desplazarse en vertical
// Objetos y punteros // Objetos y punteros
SDL_Renderer *renderer_; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
Input *input_; // Objeto para gestionar la entrada Input *input_; // Objeto para gestionar la entrada
Resource *resource_; // Objeto con los recursos Resource *resource_; // Objeto con los recursos
Asset *asset_; // Objeto con la ruta a todos los ficheros de recursos Asset *asset_; // Objeto con la ruta a todos los ficheros de recursos
Room *room_; // Objeto encargado de gestionar cada habitación del juego Debug *debug_; // Objeto para gestionar la información de debug
AnimatedSprite *sprite_; // Sprite del jugador std::shared_ptr<Room> room_; // Objeto encargado de gestionar cada habitación del juego
Debug *debug_; // Objeto para gestionar la información de debug std::shared_ptr<AnimatedSprite> sprite_; // Sprite del jugador
// Variables // Variables
float x; // Posición del jugador en el eje X float x_; // Posición del jugador en el eje X
float y; // Posición del jugador en el eje Y float y_; // Posición del jugador en el eje Y
float vx; // Velocidad/desplazamiento del jugador en el eje X float vx_; // Velocidad/desplazamiento del jugador en el eje X
float vy; // Velocidad/desplazamiento del jugador en el eje Y float vy_; // Velocidad/desplazamiento del jugador en el eje Y
int w; // Ancho del jugador int w_; // Ancho del jugador
int h; // ALto del jugador int h_; // ALto del jugador
Color color; // Color del jugador Color color_; // Color del jugador
SDL_Rect colliderBox; // Caja de colisión con los enemigos u objetos SDL_Rect collider_box_; // Caja de colisión con los enemigos u objetos
std::vector<SDL_Point> colliderPoints; // Puntos de colisión con el mapa std::vector<SDL_Point> collider_points_; // Puntos de colisión con el mapa
std::vector<SDL_Point> underFeet; // Contiene los puntos que hay bajo cada pie del jugador std::vector<SDL_Point> under_feet_; // Contiene los puntos que hay bajo cada pie del jugador
std::vector<SDL_Point> feet; // Contiene los puntos que hay en el pie del jugador std::vector<SDL_Point> feet_; // Contiene los puntos que hay en el pie del jugador
state_e state; // Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo state_e state_; // Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
state_e prevState; // Estado previo en el que se encontraba el jugador state_e previous_state_; // Estado previo en el que se encontraba el jugador
bool onBorder; // Indica si el jugador esta en uno de los cuatro bordes de la pantalla bool is_on_border_; // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
int border; // Indica en cual de los cuatro bordes se encuentra int border_; // Indica en cual de los cuatro bordes se encuentra
bool autoMovement; // Indica si esta siendo arrastrado por una superficie automatica bool auto_movement_; // Indica si esta siendo arrastrado por una superficie automatica
bool paused; // Indica si el jugador esta en modo pausa bool is_paused_; // Indica si el jugador esta en modo pausa
SDL_Rect lastPosition; // Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento SDL_Rect last_position_; // Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento
int jumpIni; // Valor del eje Y en el que se inicia el salto int jump_init_pos_; // Valor del eje Y en el que se inicia el salto
float maxVY; // Velocidad máxima que puede alcanzar al desplazarse en vertical std::vector<JA_Sound_t *> jumping_sound_; // Vecor con todos los sonidos del salto
std::vector<JA_Sound_t *> jumpSound; // Vecor con todos los sonidos del salto std::vector<JA_Sound_t *> falling_sound_; // Vecor con todos los sonidos de la caída
std::vector<JA_Sound_t *> fallSound; // Vecor con todos los sonidos de la caída int jumping_counter_; // Cuenta el tiempo de salto
int jumpCounter; // Cuenta el tiempo de salto int falling_counter_; // Cuenta el tiempo de caida
int fallCounter; // Cuenta el tiempo de caida bool is_alive_; // Indica si el jugador esta vivo o no
bool alive; // Indica si el jugador esta vivo o no
int maxFallHeight; // Altura maxima permitida de caída.
#ifdef DEBUG #ifdef DEBUG
SDL_Rect rx; // Rectangulo de desplazamiento para el modo debug SDL_Rect rx; // Rectangulo de desplazamiento para el modo debug
@@ -142,7 +145,7 @@ public:
Player(player_t player); Player(player_t player);
// Destructor // Destructor
~Player(); ~Player() = default;
// Pinta el enemigo en pantalla // Pinta el enemigo en pantalla
void render(); void render();
@@ -175,7 +178,7 @@ public:
void reLoadPalette(); void reLoadPalette();
// Establece el valor de la variable // Establece el valor de la variable
void setRoom(Room *room); void setRoom(std::shared_ptr<Room> room);
// Comprueba si el jugador esta vivo // Comprueba si el jugador esta vivo
bool isAlive(); bool isAlive();

13
source/resource.cpp
View File

@@ -5,7 +5,6 @@
#include <utility> // Para pair #include <utility> // Para pair
#include "asset.h" // Para Asset, AssetType #include "asset.h" // Para Asset, AssetType
#include "jail_audio.h" // Para JA_LoadMusic, JA_LoadSound #include "jail_audio.h" // Para JA_LoadMusic, JA_LoadSound
#include "lang.h" // Para getText
#include "screen.h" // Para Screen #include "screen.h" // Para Screen
#include "text.h" // Para Text, loadTextFile #include "text.h" // Para Text, loadTextFile
struct JA_Music_t; // lines 10-10 struct JA_Music_t; // lines 10-10
@@ -47,7 +46,6 @@ void Resource::clear()
text_files_.clear(); text_files_.clear();
texts_.clear(); texts_.clear();
animations_.clear(); animations_.clear();
demos_.clear();
} }
// Carga todos los recursos // Carga todos los recursos
@@ -59,10 +57,7 @@ void Resource::load()
loadTextures(); loadTextures();
loadTextFiles(); loadTextFiles();
loadAnimations(); loadAnimations();
loadDemoData();
addPalettes();
createText(); createText();
createTextures();
std::cout << "\n** RESOURCES LOADED" << std::endl; std::cout << "\n** RESOURCES LOADED" << std::endl;
} }
@@ -193,6 +188,12 @@ std::shared_ptr<room_t> Resource::getRoom(const std::string &name)
throw std::runtime_error("Habitación no encontrada: " + name); throw std::runtime_error("Habitación no encontrada: " + name);
} }
// Obtiene todas las habitaciones
std::vector<ResourceRoom> &Resource::getRooms()
{
return rooms_;
}
// Carga los sonidos // Carga los sonidos
void Resource::loadSounds() void Resource::loadSounds()
{ {
@@ -275,7 +276,7 @@ void Resource::loadTileMaps()
for (const auto &l : list) for (const auto &l : list)
{ {
auto name = getFileName(l); auto name = getFileName(l);
tile_maps_.emplace_back(ResourceTileMap(name, std::make_shared<std::vector<int>>(loadRoomTileFile(l)))); tile_maps_.emplace_back(ResourceTileMap(name, loadRoomTileFile(l)));
} }
} }

3
source/resource.h
View File

@@ -192,6 +192,9 @@ public:
// Obtiene la habitación a partir de un nombre // Obtiene la habitación a partir de un nombre
std::shared_ptr<room_t> getRoom(const std::string &name); std::shared_ptr<room_t> getRoom(const std::string &name);
// Obtiene todas las habitaciones
std::vector<ResourceRoom> &getRooms();
// Recarga todos los recursos // Recarga todos los recursos
void reload(); void reload();
}; };

8
source/room.cpp
View File

@@ -275,7 +275,7 @@ bool setEnemy(enemy_t *enemy, std::string var, std::string value)
if (var == "animation") if (var == "animation")
{ {
enemy->animationString = value; enemy->animation_path = value;
} }
else if (var == "width") else if (var == "width")
@@ -404,7 +404,7 @@ bool setItem(item_t *item, std::string var, std::string value)
} }
// Constructor // Constructor
Room::Room(room_t *room, ItemTracker *itemTracker, int *itemsPicked, bool jailEnabled) Room::Room(std::shared_ptr<room_t> room, std::shared_ptr<ItemTracker> itemTracker, int *itemsPicked, bool jailEnabled)
: screen(Screen::get()), : screen(Screen::get()),
renderer(Screen::get()->getRenderer()), renderer(Screen::get()->getRenderer()),
asset(Asset::get()), asset(Asset::get()),
@@ -427,7 +427,7 @@ Room::Room(room_t *room, ItemTracker *itemTracker, int *itemsPicked, bool jailEn
autoSurfaceDirection = room->autoSurfaceDirection; autoSurfaceDirection = room->autoSurfaceDirection;
textureA = room->textureA; textureA = room->textureA;
textureB = room->textureB; textureB = room->textureB;
tileMap = *room->tileMap; tileMap = room->tileMap;
texture = (options.video.palette == Palette::ZXSPECTRUM) ? textureA : textureB; texture = (options.video.palette == Palette::ZXSPECTRUM) ? textureA : textureB;
this->jailEnabled = jailEnabled; this->jailEnabled = jailEnabled;
@@ -566,7 +566,7 @@ void Room::fillMapTexture()
{ {
clip.x = (tileMap[index] % tileSetWidth) * tileSize; clip.x = (tileMap[index] % tileSetWidth) * tileSize;
clip.y = (tileMap[index] / tileSetWidth) * tileSize; clip.y = (tileMap[index] / tileSetWidth) * tileSize;
texture->render(renderer, x * tileSize, y * tileSize, &clip); texture->render(x * tileSize, y * tileSize, &clip);
#ifdef DEBUG #ifdef DEBUG
// **** // ****

67
source/room.h
View File

@@ -7,6 +7,7 @@
#include "enemy.h" // Para enemy_t #include "enemy.h" // Para enemy_t
#include "item.h" // Para item_t #include "item.h" // Para item_t
#include "utils.h" // Para h_line_t, color_t, d_line_t, v_line_t #include "utils.h" // Para h_line_t, color_t, d_line_t, v_line_t
#include <memory> // Para shared_ptr
class Asset; class Asset;
class Debug; class Debug;
class ItemTracker; class ItemTracker;
@@ -28,30 +29,30 @@ enum tile_e
struct aTile_t struct aTile_t
{ {
Sprite *sprite; // Sprite para dibujar el tile std::shared_ptr<Sprite> sprite; // Sprite para dibujar el tile
int xcOrig; // Poicion X donde se encuentra el primer tile de la animacion en la tilesheet int xcOrig; // Poicion X donde se encuentra el primer tile de la animacion en la tilesheet
}; };
struct room_t struct room_t
{ {
std::string number; // Numero de la habitación std::string number; // Numero de la habitación
std::string name; // Nombre de la habitación std::string name; // Nombre de la habitación
std::string bgColor; // Color de fondo de la habitación std::string bgColor; // Color de fondo de la habitación
std::string borderColor; // Color del borde de la pantalla std::string borderColor; // Color del borde de la pantalla
std::string itemColor1; // Color 1 para los items de la habitación std::string itemColor1; // Color 1 para los items de la habitación
std::string itemColor2; // Color 2 para los items de la habitación std::string itemColor2; // Color 2 para los items de la habitación
std::string roomUp; // Identificador de la habitación que se encuentra arriba std::string roomUp; // Identificador de la habitación que se encuentra arriba
std::string roomDown; // Identificador de la habitación que se encuentra abajp std::string roomDown; // Identificador de la habitación que se encuentra abajp
std::string roomLeft; // Identificador de la habitación que se encuentra a la izquierda std::string roomLeft; // Identificador de la habitación que se encuentra a la izquierda
std::string roomRight; // Identificador de la habitación que se encuentra a la derecha std::string roomRight; // Identificador de la habitación que se encuentra a la derecha
std::string tileSetFile; // Imagen con los graficos para la habitación std::string tileSetFile; // Imagen con los graficos para la habitación
std::string tileMapFile; // Fichero con el mapa de indices de tile std::string tileMapFile; // Fichero con el mapa de indices de tile
std::vector<int> *tileMap; // Indice de los tiles a dibujar en la habitación std::vector<int> tileMap; // Indice de los tiles a dibujar en la habitación
int autoSurfaceDirection; // Sentido en el que arrastran las superficies automáticas de la habitación int autoSurfaceDirection; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<enemy_t> enemies; // Listado con los enemigos de la habitación std::vector<enemy_t> enemies; // Listado con los enemigos de la habitación
std::vector<item_t> items; // Listado con los items que hay en la habitación std::vector<item_t> items; // Listado con los items que hay en la habitación
Texture *textureA; // Textura con los graficos de la habitación std::shared_ptr<Texture> textureA; // Textura con los graficos de la habitación
Texture *textureB; // Textura con los graficos de la habitación std::shared_ptr<Texture> textureB; // Textura con los graficos de la habitación
}; };
// Carga las variables desde un fichero de mapa // Carga las variables desde un fichero de mapa
@@ -73,18 +74,18 @@ class Room
{ {
private: private:
// Objetos y punteros // Objetos y punteros
Screen *screen; // Objeto encargado de dibujar en pantalla Screen *screen; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
Asset *asset; // Objeto con la ruta a todos los ficheros de recursos Asset *asset; // Objeto con la ruta a todos los ficheros de recursos
Debug *debug; // Objeto para gestionar la información de debug Debug *debug; // Objeto para gestionar la información de debug
std::vector<Enemy *> enemies; // Listado con los enemigos de la habitación std::vector<Enemy *> enemies; // Listado con los enemigos de la habitación
std::vector<Item *> items; // Listado con los items que hay en la habitación std::vector<Item *> items; // Listado con los items que hay en la habitación
Texture *texture; // Textura con los graficos de la habitación std::shared_ptr<Texture> texture; // Textura con los graficos de la habitación
Texture *textureA; // Textura con los graficos de la habitación std::shared_ptr<Texture> textureA; // Textura con los graficos de la habitación
Texture *textureB; // Textura con los graficos de la habitación std::shared_ptr<Texture> textureB; // Textura con los graficos de la habitación
ItemTracker *itemTracker; // Lleva el control de los objetos recogidos std::shared_ptr<ItemTracker> itemTracker; // Lleva el control de los objetos recogidos
SDL_Texture *mapTexture; // Textura para dibujar el mapa de la habitación SDL_Texture *mapTexture; // Textura para dibujar el mapa de la habitación
int *itemsPicked; // Puntero a la cantidad de items recogidos que lleva el juego int *itemsPicked; // Puntero a la cantidad de items recogidos que lleva el juego
// Variables // Variables
std::string number; // Numero de la habitación std::string number; // Numero de la habitación
@@ -159,7 +160,7 @@ private:
public: public:
// Constructor // Constructor
Room(room_t *room, ItemTracker *itemTracker, int *itemsPicked, bool jailEnabled); Room(std::shared_ptr<room_t> room, std::shared_ptr<ItemTracker> itemTracker, int *itemsPicked, bool jailEnabled);
// Destructor // Destructor
~Room(); ~Room();

19
source/scoreboard.cpp
View File

@@ -9,6 +9,7 @@
#include "options.h" #include "options.h"
#include "screen.h" #include "screen.h"
#include "asset.h" #include "asset.h"
#include "resource.h"
class Asset; class Asset;
// Constructor // Constructor
@@ -21,9 +22,9 @@ Scoreboard::Scoreboard(board_t *board)
// Reserva memoria para los objetos // Reserva memoria para los objetos
itemTexture = resource->getTexture("items.png"); itemTexture = resource->getTexture("items.png");
const std::string playerANI = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani"; const std::string playerANI = options.cheats.alternate_skin == Cheat::CheatState::ENABLED ? "player2.ani" : "player.ani";
sprite = new AnimatedSprite(renderer, resource->getAnimation(playerANI)); sprite = std::make_shared<AnimatedSprite>(falta_la_textura, resource->getAnimation(playerANI));
sprite->setCurrentAnimation("walk_menu"); sprite->setCurrentAnimation("walk_menu");
text = new Text(resource->getOffset("smb2.txt"), resource->getTexture("smb2.png"), renderer); text = Resource::get()->getText("smb2.txt");
// Inicializa las variables // Inicializa las variables
counter = 0; counter = 0;
@@ -41,13 +42,6 @@ Scoreboard::Scoreboard(board_t *board)
} }
} }
// Destructor
Scoreboard::~Scoreboard()
{
delete sprite;
delete text;
}
// Pinta el objeto en pantalla // Pinta el objeto en pantalla
void Scoreboard::render() void Scoreboard::render()
{ {
@@ -63,7 +57,7 @@ void Scoreboard::render()
// Dibuja las vidas // Dibuja las vidas
const int desp = (counter / 40) % 8; const int desp = (counter / 40) % 8;
const int frame = desp % 4; const int frame = desp % 4;
sprite->setCurrentFrame(frame); sprite->setCurrentAnimationFrame(frame);
sprite->setPosY(line2); sprite->setPosY(line2);
for (int i = 0; i < board->lives; ++i) for (int i = 0; i < board->lives; ++i)
{ {
@@ -79,7 +73,7 @@ void Scoreboard::render()
const Color c = board->color; const Color c = board->color;
SDL_Rect clip = {0, 8, 8, 8}; SDL_Rect clip = {0, 8, 8, 8};
itemTexture->setColor(c.r, c.g, c.b); itemTexture->setColor(c.r, c.g, c.b);
itemTexture->render(renderer, 20 * BLOCK, line2, &clip); itemTexture->render(20 * BLOCK, line2, &clip);
} }
// Escribe los textos // Escribe los textos
@@ -105,7 +99,8 @@ void Scoreboard::update()
updateItemsColor(); updateItemsColor();
if (!paused) if (!paused)
{ // Si está en pausa no se actualiza el reloj {
// Si está en pausa no se actualiza el reloj
clock = getTime(); clock = getTime();
} }
} }

9
source/scoreboard.h
View File

@@ -5,6 +5,7 @@
#include <string> // Para basic_string, string #include <string> // Para basic_string, string
#include <vector> // Para vector #include <vector> // Para vector
#include "utils.h" // Para color_t #include "utils.h" // Para color_t
#include <memory> // Para shared_ptr
class AnimatedSprite; class AnimatedSprite;
class Asset; class Asset;
class Resource; class Resource;
@@ -34,13 +35,13 @@ private:
}; };
// Objetos y punteros // Objetos y punteros
AnimatedSprite *sprite; // Sprite para mostrar las vidas en el marcador
SDL_Renderer *renderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
Resource *resource; // Objeto con los recursos Resource *resource; // Objeto con los recursos
Asset *asset; // Objeto con la ruta a todos los ficheros de recursos Asset *asset; // Objeto con la ruta a todos los ficheros de recursos
Text *text; // Objeto para escribir texto Text *text; // Objeto para escribir texto
Texture *itemTexture; // Textura con los graficos para las vidas std::shared_ptr<AnimatedSprite> sprite; // Sprite para mostrar las vidas en el marcador
board_t *board; // Contiene las variables a mostrar en el marcador std::shared_ptr<Texture> itemTexture; // Textura con los graficos para las vidas
std::shared_ptr<board_t> board; // Contiene las variables a mostrar en el marcador
// Variables // Variables
std::vector<Color> color; // Vector con los colores del objeto std::vector<Color> color; // Vector con los colores del objeto
@@ -63,7 +64,7 @@ public:
Scoreboard(board_t *board); Scoreboard(board_t *board);
// Destructor // Destructor
~Scoreboard(); ~Scoreboard() = default;
// Pinta el objeto en pantalla // Pinta el objeto en pantalla
void render(); void render();