jaildesigner-jailgames/jaildoctors_dilemma
1
0
Fork 2
Code Issues 1 Pull Requests Projects Releases 20 Wiki Activity

canvi de pc

Browse Source
This commit is contained in:
Sergio
2025-02-27 07:37:39 +01:00
parent e6fd4225a2
commit c6474cb2da
26 changed files with 903 additions and 991 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/credits.cpp
View File

@@ -255,7 +255,7 @@ void Credits::updateCounter()
void Credits::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks_ > ticks_speed_)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();

1
source/credits.h
View File

@@ -38,7 +38,6 @@ private:
bool counter_enabled_ = true; // Indica si esta activo el contador
int sub_counter_ = 0; // Contador secundario
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticks_speed_ = 15; // Velocidad a la que se repiten los bucles del programa
std::vector<captions_t> texts_; // Vector con los textos
// Actualiza las variables

5
source/defines.h
View File

@@ -7,7 +7,10 @@
// Textos
constexpr const char *WINDOW_CAPTION = "JailDoctor's Dilemma";
constexpr const char *TEXT_COPYRIGHT = "@2022 JailDesigner";
constexpr const char *VERSION = "0.7";
constexpr const char *VERSION = "1.09";
// Velocidad del juego
constexpr Uint32 GAME_SPEED = 1000 / 60;
// Tamaño de bloque
constexpr int BLOCK = 8;

121
source/demo.cpp
View File

@@ -19,43 +19,42 @@
// Constructor
Demo::Demo()
: screen(Screen::get()),
renderer(Screen::get()->getRenderer()),
resource(Resource::get()),
asset(Asset::get()),
input(Input::get()),
debug(Debug::get())
: screen_(Screen::get()),
renderer_(Screen::get()->getRenderer()),
resource_(Resource::get()),
asset_(Asset::get()),
input_(Input::get()),
debug_(Debug::get())
{
// Inicia algunas variables
board.ini_clock = SDL_GetTicks();
rooms.push_back("04.room");
rooms.push_back("54.room");
rooms.push_back("20.room");
rooms.push_back("09.room");
rooms.push_back("05.room");
rooms.push_back("11.room");
rooms.push_back("31.room");
rooms.push_back("44.room");
board_.ini_clock = SDL_GetTicks();
rooms_.push_back("04.room");
rooms_.push_back("54.room");
rooms_.push_back("20.room");
rooms_.push_back("09.room");
rooms_.push_back("05.room");
rooms_.push_back("11.room");
rooms_.push_back("31.room");
rooms_.push_back("44.room");
roomIndex = 0;
currentRoom = rooms[roomIndex];
room_index_ = 0;
current_room_ = rooms_[room_index_];
// Crea los objetos
ItemTracker::init();
scoreboard = std::make_shared<Scoreboard>(&board);
room = std::make_shared<Room>(resource->getRoom(currentRoom), &board.items, false);
text = resource->getText("smb2");
scoreboard_ = std::make_shared<Scoreboard>(&board_);
room_ = std::make_shared<Room>(resource_->getRoom(current_room_), &board_.items, false);
text_ = resource_->getText("smb2");
// Inicializa el resto de variables
counter = 0;
roomTime = 400;
ticks = 0;
ticksSpeed = 15;
board.lives = 9;
board.items = 0;
board.rooms = 1;
board.jail_is_open = false;
board.music = true;
counter_ = 0;
room_time_ = 400;
ticks_ = 0;
board_.lives = 9;
board_.items = 0;
board_.rooms = 1;
board_.jail_is_open = false;
board_.music = true;
setScoreBoardColor();
options.section.section = Section::DEMO;
@@ -99,21 +98,21 @@ void Demo::run()
void Demo::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks > ticksSpeed)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
ticks_ = SDL_GetTicks();
// Comprueba las entradas
checkInput();
// Actualiza los objetos
room->update();
scoreboard->update();
screen->updateFX();
room_->update();
scoreboard_->update();
screen_->updateFX();
checkRoomChange();
screen->update();
screen_->update();
}
}
@@ -121,18 +120,18 @@ void Demo::update()
void Demo::render()
{
// Prepara para dibujar el frame
screen->start();
screen_->start();
// Dibuja los elementos del juego en orden
room->renderMap();
room->renderEnemies();
room->renderItems();
room_->renderMap();
room_->renderEnemies();
room_->renderItems();
renderRoomName();
scoreboard->render();
screen->renderFX();
scoreboard_->render();
screen_->renderFX();
// Actualiza la pantalla
screen->render();
screen_->render();
}
// Escribe el nombre de la pantalla
@@ -141,10 +140,10 @@ void Demo::renderRoomName()
// Texto en el centro de la pantalla
SDL_Rect rect = {0, 16 * BLOCK, PLAY_AREA_WIDTH, BLOCK * 2};
Color color = stringToColor(options.video.palette, "white");
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_RenderFillRect(renderer, &rect);
SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
SDL_RenderFillRect(renderer_, &rect);
text->writeDX(TEXT_CENTER | TEXT_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
@@ -154,9 +153,9 @@ void Demo::reLoadTextures()
{
std::cout << "** RELOAD REQUESTED" << std::endl;
}
room->reLoadTexture();
scoreboard->reLoadTexture();
text->reLoadTexture();
room_->reLoadTexture();
scoreboard_->reLoadTexture();
text_->reLoadTexture();
}
// Cambia la paleta
@@ -172,8 +171,8 @@ void Demo::switchPalette()
options.video.palette = Palette::ZXSPECTRUM;
}
room->reLoadPalette();
scoreboard->reLoadPalette();
room_->reLoadPalette();
scoreboard_->reLoadPalette();
// Pone el color del marcador en función del color del borde de la habitación
setScoreBoardColor();
@@ -186,10 +185,10 @@ bool Demo::changeRoom(std::string file)
if (file != "0")
{
// Verifica que exista el fichero que se va a cargar
if (asset->get(file) != "")
if (asset_->get(file) != "")
{
// Crea un objeto habitación a partir del fichero
room = std::make_shared<Room>(resource->getRoom(file), &board.items, false);
room_ = std::make_shared<Room>(resource_->getRoom(file), &board_.items, false);
// Pone el color del marcador en función del color del borde de la habitación
setScoreBoardColor();
@@ -204,19 +203,19 @@ bool Demo::changeRoom(std::string file)
// Comprueba si se ha de cambiar de habitación
void Demo::checkRoomChange()
{
counter++;
if (counter == roomTime)
counter_++;
if (counter_ == room_time_)
{
counter = 0;
roomIndex++;
if (roomIndex == (int)rooms.size())
counter_ = 0;
room_index_++;
if (room_index_ == (int)rooms_.size())
{
options.section.section = Section::LOGO;
options.section.subsection = Subsection::LOGO_TO_TITLE;
}
else
{
changeRoom(rooms[roomIndex]);
changeRoom(rooms_[room_index_]);
}
}
}
@@ -225,13 +224,13 @@ void Demo::checkRoomChange()
void Demo::setScoreBoardColor()
{
// Obtiene el color del borde
const Color color = room->getBorderColor();
const Color color = room_->getBorderColor();
// Si el color es negro lo cambia a blanco
const Color black_color = stringToColor(options.video.palette, "black");
board.color = colorAreEqual(color, black_color) ? stringToColor(options.video.palette, "white") : color;
board_.color = colorAreEqual(color, black_color) ? stringToColor(options.video.palette, "white") : color;
// Si el color es negro brillante lo cambia a blanco
const Color bright_blac_color = stringToColor(options.video.palette, "bright_black");
board.color = colorAreEqual(color, bright_blac_color) ? stringToColor(options.video.palette, "white") : color;
board_.color = colorAreEqual(color, bright_blac_color) ? stringToColor(options.video.palette, "white") : color;
}

33
source/demo.h
View File

@@ -19,25 +19,24 @@ class Demo
{
private:
// Objetos y punteros
Screen *screen; // Objeto encargado de manejar el renderizador
SDL_Renderer *renderer; // El renderizador de la ventana
Resource *resource; // Objeto con los recursos
Asset *asset; // Objeto con la ruta a todos los ficheros de recursos
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<Scoreboard> scoreboard; // Objeto encargado de gestionar el marcador
Screen *screen_; // Objeto encargado de manejar el renderizador
SDL_Renderer *renderer_; // El renderizador de la ventana
Resource *resource_; // Objeto con los recursos
Asset *asset_; // Objeto con la ruta a todos los ficheros de recursos
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<Scoreboard> scoreboard_; // Objeto encargado de gestionar el marcador
// Variables
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
std::string currentRoom; // Fichero de la habitación actual
ScoreboardData board; // Estructura con los datos del marcador
int counter; // Contador para el modo demo
int roomTime; // Tiempo que se muestra cada habitacion
int roomIndex; // Indice para el vector de habitaciones
std::vector<std::string> rooms; // Listado con los mapas de la demo
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
std::string current_room_; // Fichero de la habitación actual
ScoreboardData board_; // Estructura con los datos del marcador
int counter_; // Contador para el modo demo
int room_time_; // Tiempo que se muestra cada habitacion
int room_index_; // Indice para el vector de habitaciones
std::vector<std::string> rooms_; // Listado con los mapas de la demo
// Actualiza el juego, las variables, comprueba la entrada, etc.
void update();

5
source/director.cpp
View File

@@ -83,7 +83,6 @@ Director::Director(int argc, const char *argv[])
Input::init(Asset::get()->get("gamecontrollerdb.txt"));
initInput();
Debug::init();
title_music_ = Resource::get()->getMusic("title.ogg");
Cheevos::init(Asset::get()->get("cheevos.bin"));
}
@@ -746,10 +745,6 @@ void Director::runLoadingScreen()
// Ejecuta la seccion de juego con el titulo y los menus
void Director::runTitle()
{
if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
{
JA_PlayMusic(title_music_);
}
auto title = std::make_unique<Title>();
title->run();
}

1
source/director.h
View File

@@ -13,7 +13,6 @@ private:
SDL_Renderer *renderer_; // El renderizador de la ventana
// Variables
JA_Music_t *title_music_; // Musica del titulo
std::string executable_path_; // Path del ejecutable
std::string system_folder_; // Carpeta del sistema donde guardar datos

341
source/ending.cpp
View File

@@ -23,25 +23,24 @@
// Constructor
Ending::Ending()
: screen(Screen::get()),
renderer(Screen::get()->getRenderer()),
resource(Resource::get()),
asset(Asset::get()),
input(Input::get())
: screen_(Screen::get()),
renderer_(Screen::get()->getRenderer()),
resource_(Resource::get()),
asset_(Asset::get()),
input_(Input::get())
{
// Reserva memoria para los punteros a objetos
text = resource->getText("smb2");
music = resource->getMusic("ending1.ogg");
text_ = resource_->getText("smb2");
music = resource_->getMusic("ending1.ogg");
// Inicializa variables
counter = -1;
preCounter = 0;
coverCounter = 0;
counter_ = -1;
pre_counter_ = 0;
cover_counter_ = 0;
options.section.section = Section::ENDING;
options.section.subsection = Subsection::NONE;
ticks = 0;
ticksSpeed = 15;
scene = 0;
ticks_ = 0;
current_scene_ = 0;
// Inicializa los textos
iniTexts();
@@ -53,18 +52,18 @@ Ending::Ending()
iniScenes();
// Cambia el color del borde
screen->setBorderColor(stringToColor(options.video.palette, "black"));
screen_->setBorderColor(stringToColor(options.video.palette, "black"));
// Crea la textura para cubrir el rexto
coverTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT + 8);
if (coverTexture == nullptr)
cover_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT + 8);
if (cover_texture_ == nullptr)
{
if (options.console)
{
std::cout << "Error: canvasTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
}
}
SDL_SetTextureBlendMode(coverTexture, SDL_BLENDMODE_BLEND);
SDL_SetTextureBlendMode(cover_texture_, SDL_BLENDMODE_BLEND);
// Rellena la textura para la cortinilla
fillCoverTexture();
@@ -74,17 +73,17 @@ Ending::Ending()
Ending::~Ending()
{
// Libera la memoria de los objetos
SDL_DestroyTexture(coverTexture);
SDL_DestroyTexture(cover_texture_);
}
// Actualiza el objeto
void Ending::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks > ticksSpeed)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
ticks_ = SDL_GetTicks();
// Comprueba las entradas
checkInput();
@@ -101,7 +100,7 @@ void Ending::update()
// Actualiza el volumen de la musica
updateMusicVolume();
screen->update();
screen_->update();
}
}
@@ -109,22 +108,22 @@ void Ending::update()
void Ending::render()
{
// Prepara para empezar a dibujar en la textura de juego
screen->start();
screen_->start();
// Limpia la pantalla
screen->clean(stringToColor(options.video.palette, "black"));
screen_->clean(stringToColor(options.video.palette, "black"));
// Dibuja las imagenes de la escena
spritePics[scene].sprite->render();
spritePics[scene].coverSprite->render();
sprite_pics_[current_scene_].sprite->render();
sprite_pics_[current_scene_].cover_sprite->render();
// Dibuja los textos de la escena
for (auto ti : scenes[scene].textIndex)
for (auto ti : scenes_[current_scene_].text_index)
{
if (counter > ti.trigger)
if (counter_ > ti.trigger)
{
spriteTexts[ti.index].sprite->render();
spriteTexts[ti.index].coverSprite->render();
sprite_texts_[ti.index].sprite->render();
sprite_texts_[ti.index].cover_sprite->render();
}
}
@@ -132,7 +131,7 @@ void Ending::render()
renderCoverTexture();
// Vuelca el contenido del renderizador en pantalla
screen->render();
screen_->render();
}
// Comprueba el manejador de eventos
@@ -155,7 +154,7 @@ void Ending::checkInput()
void Ending::iniTexts()
{
// Vector con los textos
std::vector<textAndPos_t> texts;
std::vector<TextAndPosition> texts;
// Escena #0
texts.push_back({"HE FINALLY MANAGED", 32});
@@ -187,66 +186,66 @@ void Ending::iniTexts()
texts.push_back({"WERE BORN...", 158});
// Crea los sprites
spriteTexts.clear();
sprite_texts_.clear();
for (auto t : texts)
{
endingTexture_t st;
const int width = text->lenght(t.caption, 1) + 2 + 2;
const int height = text->getCharacterSize() + 2 + 2;
EndingTexture st;
const int width = text_->lenght(t.caption, 1) + 2 + 2;
const int height = text_->getCharacterSize() + 2 + 2;
Color c = stringToColor(options.video.palette, "black");
// Crea la texture
st.texture = std::make_shared<Texture>(renderer);
st.texture = std::make_shared<Texture>(renderer_);
st.texture->createBlank(width, height);
st.texture->setAsRenderTarget(renderer);
st.texture->setAsRenderTarget(renderer_);
st.texture->setBlendMode(SDL_BLENDMODE_BLEND);
text->writeDX(TEXT_STROKE, 2, 2, t.caption, 1, c, 2, c);
text_->writeDX(TEXT_STROKE, 2, 2, t.caption, 1, c, 2, c);
// Crea el sprite
st.sprite = std::make_shared<Sprite>(st.texture, 0, 0, st.texture->getWidth(), st.texture->getHeight());
st.sprite->setPosition((GAMECANVAS_WIDTH - st.texture->getWidth()) / 2, t.pos);
// Crea la coverTexture
st.coverTexture = std::make_shared<Texture>(renderer);
st.coverTexture->createBlank(width, height + 8);
st.coverTexture->setAsRenderTarget(renderer);
st.coverTexture->setBlendMode(SDL_BLENDMODE_BLEND);
st.cover_texture = std::make_shared<Texture>(renderer_);
st.cover_texture->createBlank(width, height + 8);
st.cover_texture->setAsRenderTarget(renderer_);
st.cover_texture->setBlendMode(SDL_BLENDMODE_BLEND);
// Rellena la coverTexture con color transparente
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
// Los primeros 8 pixels crea una malla
c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
for (int i = 0; i < width; i += 2)
{
SDL_RenderDrawPoint(renderer, i, 0);
SDL_RenderDrawPoint(renderer, i, 2);
SDL_RenderDrawPoint(renderer, i, 4);
SDL_RenderDrawPoint(renderer, i, 6);
SDL_RenderDrawPoint(renderer_, i, 0);
SDL_RenderDrawPoint(renderer_, i, 2);
SDL_RenderDrawPoint(renderer_, i, 4);
SDL_RenderDrawPoint(renderer_, i, 6);
SDL_RenderDrawPoint(renderer, i + 1, 5);
SDL_RenderDrawPoint(renderer, i + 1, 7);
SDL_RenderDrawPoint(renderer_, i + 1, 5);
SDL_RenderDrawPoint(renderer_, i + 1, 7);
}
// El resto se rellena de color sólido
SDL_Rect rect = {0, 8, width, height};
c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer, &rect);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer_, &rect);
// Crea el sprite
st.coverSprite = std::make_shared<Sprite>(st.coverTexture, 0, 0, st.coverTexture->getWidth(), st.coverTexture->getHeight() - 8);
st.coverSprite->setPosition((GAMECANVAS_WIDTH - st.coverTexture->getWidth()) / 2, t.pos);
st.coverSprite->setClip(0, 8, -1, -1);
st.cover_sprite = std::make_shared<Sprite>(st.cover_texture, 0, 0, st.cover_texture->getWidth(), st.cover_texture->getHeight() - 8);
st.cover_sprite->setPosition((GAMECANVAS_WIDTH - st.cover_texture->getWidth()) / 2, t.pos);
st.cover_sprite->setClip(0, 8, -1, -1);
// Inicializa variables
st.clipDesp = 8;
st.clipHeight = height;
st.clip_desp = 8;
st.clip_height = height;
spriteTexts.push_back(st);
sprite_texts_.push_back(st);
}
}
@@ -254,7 +253,7 @@ void Ending::iniTexts()
void Ending::iniPics()
{
// Vector con las rutas y la posición
std::vector<textAndPos_t> pics;
std::vector<TextAndPosition> pics;
if (options.video.palette == Palette::ZXSPECTRUM)
{
@@ -274,14 +273,14 @@ void Ending::iniPics()
}
// Crea los sprites
spritePics.clear();
sprite_pics_.clear();
for (auto p : pics)
{
endingTexture_t sp;
EndingTexture sp;
// Crea la texture
sp.texture = resource->getTexture(p.caption);
sp.texture = resource_->getTexture(p.caption);
const int width = sp.texture->getWidth();
const int height = sp.texture->getHeight();
@@ -290,45 +289,45 @@ void Ending::iniPics()
sp.sprite->setPosition((GAMECANVAS_WIDTH - width) / 2, p.pos);
// Crea la coverTexture
sp.coverTexture = std::make_shared<Texture>(renderer);
sp.coverTexture->createBlank(width, height + 8);
sp.coverTexture->setAsRenderTarget(renderer);
sp.coverTexture->setBlendMode(SDL_BLENDMODE_BLEND);
sp.cover_texture = std::make_shared<Texture>(renderer_);
sp.cover_texture->createBlank(width, height + 8);
sp.cover_texture->setAsRenderTarget(renderer_);
sp.cover_texture->setBlendMode(SDL_BLENDMODE_BLEND);
// Rellena la coverTexture con color transparente
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
// Los primeros 8 pixels crea una malla
Color c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
for (int i = 0; i < width; i += 2)
{
SDL_RenderDrawPoint(renderer, i, 0);
SDL_RenderDrawPoint(renderer, i, 2);
SDL_RenderDrawPoint(renderer, i, 4);
SDL_RenderDrawPoint(renderer, i, 6);
SDL_RenderDrawPoint(renderer_, i, 0);
SDL_RenderDrawPoint(renderer_, i, 2);
SDL_RenderDrawPoint(renderer_, i, 4);
SDL_RenderDrawPoint(renderer_, i, 6);
SDL_RenderDrawPoint(renderer, i + 1, 5);
SDL_RenderDrawPoint(renderer, i + 1, 7);
SDL_RenderDrawPoint(renderer_, i + 1, 5);
SDL_RenderDrawPoint(renderer_, i + 1, 7);
}
// El resto se rellena de color sólido
SDL_Rect rect = {0, 8, width, height};
c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer, &rect);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer_, &rect);
// Crea el sprite
sp.coverSprite = std::make_shared<Sprite>(sp.coverTexture, 0, 0, sp.coverTexture->getWidth(), sp.coverTexture->getHeight() - 8);
sp.coverSprite->setPosition((GAMECANVAS_WIDTH - sp.coverTexture->getWidth()) / 2, p.pos);
sp.coverSprite->setClip(0, 8, -1, -1);
sp.cover_sprite = std::make_shared<Sprite>(sp.cover_texture, 0, 0, sp.cover_texture->getWidth(), sp.cover_texture->getHeight() - 8);
sp.cover_sprite->setPosition((GAMECANVAS_WIDTH - sp.cover_texture->getWidth()) / 2, p.pos);
sp.cover_sprite->setClip(0, 8, -1, -1);
// Inicializa variables
sp.clipDesp = 8;
sp.clipHeight = height;
sp.clip_desp = 8;
sp.clip_height = height;
spritePics.push_back(sp);
sprite_pics_.push_back(sp);
}
}
@@ -340,79 +339,79 @@ void Ending::iniScenes()
const int lapse = 80;
// Crea el contenedor
scene_t sc;
SceneData sc;
// Inicializa el vector
scenes.clear();
scenes_.clear();
// Crea la escena #0
sc.counterEnd = 1000;
sc.pictureIndex = 0;
sc.textIndex.clear();
sc.counter_end = 1000;
sc.picture_index = 0;
sc.text_index.clear();
trigger = 85 * 2;
trigger += lapse;
sc.textIndex.push_back({0, trigger});
sc.text_index.push_back({0, trigger});
trigger += lapse;
sc.textIndex.push_back({1, trigger});
sc.text_index.push_back({1, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({2, trigger});
sc.text_index.push_back({2, trigger});
trigger += lapse;
sc.textIndex.push_back({3, trigger});
scenes.push_back(sc);
sc.text_index.push_back({3, trigger});
scenes_.push_back(sc);
// Crea la escena #1
sc.counterEnd = 1400;
sc.pictureIndex = 1;
sc.textIndex.clear();
sc.counter_end = 1400;
sc.picture_index = 1;
sc.text_index.clear();
trigger = 140 * 2;
trigger += lapse;
sc.textIndex.push_back({4, trigger});
sc.text_index.push_back({4, trigger});
trigger += lapse;
sc.textIndex.push_back({5, trigger});
sc.text_index.push_back({5, trigger});
trigger += lapse;
sc.textIndex.push_back({6, trigger});
sc.text_index.push_back({6, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({7, trigger});
sc.text_index.push_back({7, trigger});
trigger += lapse;
sc.textIndex.push_back({8, trigger});
sc.text_index.push_back({8, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({9, trigger});
scenes.push_back(sc);
sc.text_index.push_back({9, trigger});
scenes_.push_back(sc);
// Crea la escena #2
sc.counterEnd = 1000;
sc.pictureIndex = 2;
sc.textIndex.clear();
sc.counter_end = 1000;
sc.picture_index = 2;
sc.text_index.clear();
trigger = 148 / 2;
trigger += lapse;
sc.textIndex.push_back({10, trigger});
sc.text_index.push_back({10, trigger});
trigger += lapse;
sc.textIndex.push_back({11, trigger});
scenes.push_back(sc);
sc.text_index.push_back({11, trigger});
scenes_.push_back(sc);
// Crea la escena #3
sc.counterEnd = 800;
sc.pictureIndex = 3;
sc.textIndex.clear();
sc.counter_end = 800;
sc.picture_index = 3;
sc.text_index.clear();
trigger = 87 / 2;
trigger += lapse;
sc.textIndex.push_back({12, trigger});
sc.text_index.push_back({12, trigger});
trigger += lapse / 2;
sc.textIndex.push_back({13, trigger});
scenes.push_back(sc);
sc.text_index.push_back({13, trigger});
scenes_.push_back(sc);
// Crea la escena #4
sc.counterEnd = 1000;
sc.pictureIndex = 4;
sc.textIndex.clear();
sc.counter_end = 1000;
sc.picture_index = 4;
sc.text_index.clear();
trigger = 91 * 2;
trigger += lapse;
sc.textIndex.push_back({14, trigger});
sc.text_index.push_back({14, trigger});
trigger += lapse * 2;
sc.textIndex.push_back({15, trigger});
sc.text_index.push_back({15, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({16, trigger});
scenes.push_back(sc);
sc.text_index.push_back({16, trigger});
scenes_.push_back(sc);
}
// Bucle principal
@@ -435,80 +434,80 @@ void Ending::run()
void Ending::updateCounters()
{
// Incrementa el contador
if (preCounter < 200)
if (pre_counter_ < 200)
{
preCounter++;
pre_counter_++;
}
else
{
counter++;
counter_++;
}
if (counter > scenes[scene].counterEnd - 100)
if (counter_ > scenes_[current_scene_].counter_end - 100)
{
coverCounter++;
cover_counter_++;
}
}
// Actualiza las cortinillas de los elementos
void Ending::updateSpriteCovers()
{ // Actualiza la cortinilla de los textos
if (counter % 4 == 0)
if (counter_ % 4 == 0)
{
for (auto ti : scenes[scene].textIndex)
for (auto ti : scenes_[current_scene_].text_index)
{
if (counter > ti.trigger)
if (counter_ > ti.trigger)
{
if (spriteTexts[ti.index].clipDesp > 0)
if (sprite_texts_[ti.index].clip_desp > 0)
{
spriteTexts[ti.index].clipDesp -= 2;
sprite_texts_[ti.index].clip_desp -= 2;
}
else if (spriteTexts[ti.index].clipHeight > 0)
else if (sprite_texts_[ti.index].clip_height > 0)
{
spriteTexts[ti.index].clipHeight -= 2;
spriteTexts[ti.index].coverSprite->setY(spriteTexts[ti.index].coverSprite->getY() + 2);
sprite_texts_[ti.index].clip_height -= 2;
sprite_texts_[ti.index].cover_sprite->setY(sprite_texts_[ti.index].cover_sprite->getY() + 2);
}
spriteTexts[ti.index].coverSprite->setClip(0, spriteTexts[ti.index].clipDesp, spriteTexts[ti.index].coverSprite->getWidth(), spriteTexts[ti.index].clipHeight);
sprite_texts_[ti.index].cover_sprite->setClip(0, sprite_texts_[ti.index].clip_desp, sprite_texts_[ti.index].cover_sprite->getWidth(), sprite_texts_[ti.index].clip_height);
}
}
}
// Actualiza la cortinilla de las imagenes
if (counter % 2 == 0)
if (counter_ % 2 == 0)
{
if (spritePics[scene].clipDesp > 0)
if (sprite_pics_[current_scene_].clip_desp > 0)
{
spritePics[scene].clipDesp -= 2;
sprite_pics_[current_scene_].clip_desp -= 2;
}
else if (spritePics[scene].clipHeight > 0)
else if (sprite_pics_[current_scene_].clip_height > 0)
{
spritePics[scene].clipHeight -= 2;
if (spritePics[scene].clipHeight < 0)
sprite_pics_[current_scene_].clip_height -= 2;
if (sprite_pics_[current_scene_].clip_height < 0)
{
spritePics[scene].clipHeight = 0;
sprite_pics_[current_scene_].clip_height = 0;
}
spritePics[scene].coverSprite->setY(spritePics[scene].coverSprite->getY() + 2);
sprite_pics_[current_scene_].cover_sprite->setY(sprite_pics_[current_scene_].cover_sprite->getY() + 2);
}
spritePics[scene].coverSprite->setClip(0, spritePics[scene].clipDesp, spritePics[scene].coverSprite->getWidth(), spritePics[scene].clipHeight);
sprite_pics_[current_scene_].cover_sprite->setClip(0, sprite_pics_[current_scene_].clip_desp, sprite_pics_[current_scene_].cover_sprite->getWidth(), sprite_pics_[current_scene_].clip_height);
}
}
// Comprueba si se ha de cambiar de escena
void Ending::checkChangeScene()
{
if (counter > scenes[scene].counterEnd)
if (counter_ > scenes_[current_scene_].counter_end)
{
scene++;
counter = 0;
coverCounter = 0;
if (scene == 5)
current_scene_++;
counter_ = 0;
cover_counter_ = 0;
if (current_scene_ == 5)
{
// Termina el bucle
options.section.section = Section::ENDING2;
// Mantiene los valores anteriores
scene = 4;
coverCounter = 100;
current_scene_ = 4;
cover_counter_ = 100;
}
}
}
@@ -517,49 +516,49 @@ void Ending::checkChangeScene()
void Ending::fillCoverTexture()
{
// Rellena la textura que cubre el texto con color transparente
SDL_SetRenderTarget(renderer, coverTexture);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderTarget(renderer_, cover_texture_);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
// Los primeros 8 pixels crea una malla
const Color color = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
for (int i = 0; i < 256; i += 2)
{
SDL_RenderDrawPoint(renderer, i + 0, GAMECANVAS_HEIGHT + 0);
SDL_RenderDrawPoint(renderer, i + 1, GAMECANVAS_HEIGHT + 1);
SDL_RenderDrawPoint(renderer, i + 0, GAMECANVAS_HEIGHT + 2);
SDL_RenderDrawPoint(renderer, i + 1, GAMECANVAS_HEIGHT + 3);
SDL_RenderDrawPoint(renderer_, i + 0, GAMECANVAS_HEIGHT + 0);
SDL_RenderDrawPoint(renderer_, i + 1, GAMECANVAS_HEIGHT + 1);
SDL_RenderDrawPoint(renderer_, i + 0, GAMECANVAS_HEIGHT + 2);
SDL_RenderDrawPoint(renderer_, i + 1, GAMECANVAS_HEIGHT + 3);
SDL_RenderDrawPoint(renderer, i, GAMECANVAS_HEIGHT + 4);
SDL_RenderDrawPoint(renderer, i, GAMECANVAS_HEIGHT + 6);
SDL_RenderDrawPoint(renderer_, i, GAMECANVAS_HEIGHT + 4);
SDL_RenderDrawPoint(renderer_, i, GAMECANVAS_HEIGHT + 6);
}
// El resto se rellena de color sólido
SDL_Rect rect = {0, 0, 256, GAMECANVAS_HEIGHT};
SDL_RenderFillRect(renderer, &rect);
SDL_RenderFillRect(renderer_, &rect);
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, nullptr);
}
// Dibuja la cortinilla de cambio de escena
void Ending::renderCoverTexture()
{
if (coverCounter > 0)
if (cover_counter_ > 0)
{ // Dibuja la textura que cubre el texto
const int offset = std::min(coverCounter, 100);
SDL_Rect srcRect = {0, 200 - (coverCounter * 2), 256, offset * 2};
const int offset = std::min(cover_counter_, 100);
SDL_Rect srcRect = {0, 200 - (cover_counter_ * 2), 256, offset * 2};
SDL_Rect dstRect = {0, 0, 256, offset * 2};
SDL_RenderCopy(renderer, coverTexture, &srcRect, &dstRect);
SDL_RenderCopy(renderer_, cover_texture_, &srcRect, &dstRect);
}
}
// Actualiza el volumen de la musica
void Ending::updateMusicVolume()
{
if (scene == 4 && coverCounter > 0)
if (current_scene_ == 4 && cover_counter_ > 0)
{
const float step = (100.0f - coverCounter) / 100.0f;
const float step = (100.0f - cover_counter_) / 100.0f;
const int volume = 128 * step;
JA_SetVolume(volume);
}

51
source/ending.h
View File

@@ -18,17 +18,17 @@ class Ending
{
private:
// Estructuras
struct endingTexture_t // Estructura con dos texturas y sprites, uno para mostrar y el otro hace de cortinilla
struct EndingTexture // Estructura con dos texturas y sprites, uno para mostrar y el otro hace de cortinilla
{
std::shared_ptr<Texture> texture; // Textura a mostrar
std::shared_ptr<Sprite> sprite; // Sprite para mostrar la textura
std::shared_ptr<Texture> coverTexture; // Textura que cubre a la otra textura
std::shared_ptr<Sprite> coverSprite; // Sprite para mostrar la textura que cubre a la otra textura
int clipDesp; // Desplazamiento del spriteClip de la textura de cobertura
int clipHeight; // Altura del spriteClip de la textura de cobertura
std::shared_ptr<Texture> cover_texture; // Textura que cubre a la otra textura
std::shared_ptr<Sprite> cover_sprite; // Sprite para mostrar la textura que cubre a la otra textura
int clip_desp; // Desplazamiento del spriteClip de la textura de cobertura
int clip_height; // Altura del spriteClip de la textura de cobertura
};
struct textAndPos_t // Estructura con un texto y su posición en el eje Y
struct TextAndPosition // Estructura con un texto y su posición en el eje Y
{
std::string caption; // Texto
int pos; // Posición
@@ -40,32 +40,31 @@ private:
int trigger;
};
struct scene_t // Estructura para crear cada una de las escenas del final
struct SceneData // Estructura para crear cada una de las escenas del final
{
std::vector<asdhk> textIndex; // Indices del vector de textos a mostrar y su disparador
int pictureIndex; // Indice del vector de imagenes a mostrar
int counterEnd; // Valor del contador en el que finaliza la escena
std::vector<asdhk> text_index; // Indices del vector de textos a mostrar y su disparador
int picture_index; // Indice del vector de imagenes a mostrar
int counter_end; // Valor del contador en el que finaliza la escena
};
// Objetos y punteros
Screen *screen; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer; // El renderizador de la ventana
Resource *resource; // Objeto con los recursos
Asset *asset; // Objeto con los ficheros de recursos
Input *input; // Objeto pata gestionar la entrada
std::shared_ptr<Text> text; // Objeto para escribir texto en pantalla
SDL_Texture *coverTexture; // Textura para cubrir el texto
Screen *screen_; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer_; // El renderizador de la ventana
Resource *resource_; // Objeto con los recursos
Asset *asset_; // Objeto con los ficheros de recursos
Input *input_; // Objeto pata gestionar la entrada
std::shared_ptr<Text> text_; // Objeto para escribir texto en pantalla
SDL_Texture *cover_texture_; // Textura para cubrir el texto
// Variables
int counter; // Contador
int preCounter; // Contador previo
int coverCounter; // Contador para la cortinilla
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
std::vector<endingTexture_t> spriteTexts; // Vector con los sprites de texto con su cortinilla
std::vector<endingTexture_t> spritePics; // Vector con los sprites de texto con su cortinilla
int scene; // Escena actual
std::vector<scene_t> scenes; // Vector con los textos e imagenes de cada escena
int counter_; // Contador
int pre_counter_; // Contador previo
int cover_counter_; // Contador para la cortinilla
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
std::vector<EndingTexture> sprite_texts_; // Vector con los sprites de texto con su cortinilla
std::vector<EndingTexture> sprite_pics_; // Vector con los sprites de texto con su cortinilla
int current_scene_; // Escena actual
std::vector<SceneData> scenes_; // Vector con los textos e imagenes de cada escena
JA_Music_t *music; // Musica que suena durante el final
// Actualiza el objeto

331
source/ending2.cpp
View File

@@ -21,40 +21,37 @@
// Constructor
Ending2::Ending2()
: screen(Screen::get()),
renderer(Screen::get()->getRenderer()),
resource(Resource::get()),
asset(Asset::get()),
input(Input::get())
: screen_(Screen::get()),
renderer_(Screen::get()->getRenderer()),
resource_(Resource::get()),
asset_(Asset::get()),
input_(Input::get())
{
// Reserva memoria para los punteros a objetos
text = resource->getText("smb2");
music = resource->getMusic("ending2.ogg");
text_ = resource_->getText("smb2");
music_ = resource_->getMusic("ending2.ogg");
// Inicializa variables
counterEnabled = false;
preCounter = 0;
postCounter = 0;
postCounterEnabled = false;
counter_enabled_ = false;
pre_counter_ = 0;
post_counter_ = 0;
post_counter_enabled_ = false;
options.section.section = Section::ENDING2;
options.section.subsection = Subsection::NONE;
ticks = 0;
ticksSpeed = 15;
distSpriteText = 8;
distSpriteSprite = 0;
despSpeed = -0.2f;
firstCol = GAMECANVAS_FIRST_QUARTER_X + (GAMECANVAS_WIDTH / 16);
secondCol = GAMECANVAS_THIRD_QUARTER_X - (GAMECANVAS_WIDTH / 16);
ticks_ = 0;
dist_sprite_text_ = 8;
dist_sprite_sprite_ = 0;
sprite_desp_speed_ = -0.2f;
// Inicializa el vector de colores
const std::vector<std::string> color_list = {"white", "yellow", "cyan", "green", "magenta", "red", "blue", "black"};
for (auto color : color_list)
{
colors.push_back(stringToColor(options.video.palette, color));
colors_.push_back(stringToColor(options.video.palette, color));
}
// Cambia el color del borde
screen->setBorderColor(stringToColor(options.video.palette, "black"));
screen_->setBorderColor(stringToColor(options.video.palette, "black"));
// Inicializa la lista de sprites
iniSpriteList();
@@ -76,10 +73,10 @@ Ending2::Ending2()
void Ending2::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks > ticksSpeed)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
ticks_ = SDL_GetTicks();
// Comprueba las entradas
checkInput();
@@ -87,7 +84,7 @@ void Ending2::update()
// Actualiza los contadores
updateCounters();
if (counterEnabled)
if (counter_enabled_)
{
// Actualiza los sprites
updateSprites();
@@ -105,7 +102,7 @@ void Ending2::update()
// Actualiza el volumen de la musica
updateMusicVolume();
screen->update();
screen_->update();
}
}
@@ -113,10 +110,10 @@ void Ending2::update()
void Ending2::render()
{
// Prepara para empezar a dibujar en la textura de juego
screen->start();
screen_->start();
// Limpia la pantalla
screen->clean(stringToColor(options.video.palette, "black"));
screen_->clean(stringToColor(options.video.palette, "black"));
// Dibuja los sprites
renderSprites();
@@ -127,7 +124,7 @@ void Ending2::render()
// Dibuja los sprites con el texto del final
renderTexts();
const std::string txt = std::to_string(postCounter);
const std::string txt = std::to_string(post_counter_);
// text->write(0, 192 - 8, txt);
// Dibuja la cuadricula
@@ -147,24 +144,24 @@ void Ending2::render()
{
// Dibuja una trama arriba y abajo
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xFF);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0xFF);
for (int i = 0; i < 256; i += 2)
{
SDL_RenderDrawPoint(renderer, i + 0, 0);
SDL_RenderDrawPoint(renderer, i + 1, 1);
SDL_RenderDrawPoint(renderer, i + 0, 2);
SDL_RenderDrawPoint(renderer, i + 1, 3);
SDL_RenderDrawPoint(renderer_, i + 0, 0);
SDL_RenderDrawPoint(renderer_, i + 1, 1);
SDL_RenderDrawPoint(renderer_, i + 0, 2);
SDL_RenderDrawPoint(renderer_, i + 1, 3);
SDL_RenderDrawPoint(renderer, i, 4);
SDL_RenderDrawPoint(renderer, i, 6);
SDL_RenderDrawPoint(renderer_, i, 4);
SDL_RenderDrawPoint(renderer_, i, 6);
SDL_RenderDrawPoint(renderer, i + 0, 191);
SDL_RenderDrawPoint(renderer, i + 1, 190);
SDL_RenderDrawPoint(renderer, i + 0, 189);
SDL_RenderDrawPoint(renderer, i + 1, 188);
SDL_RenderDrawPoint(renderer_, i + 0, 191);
SDL_RenderDrawPoint(renderer_, i + 1, 190);
SDL_RenderDrawPoint(renderer_, i + 0, 189);
SDL_RenderDrawPoint(renderer_, i + 1, 188);
SDL_RenderDrawPoint(renderer, i, 187);
SDL_RenderDrawPoint(renderer, i, 185);
SDL_RenderDrawPoint(renderer_, i, 187);
SDL_RenderDrawPoint(renderer_, i, 185);
}
// SDL_RenderDrawLine(renderer, 0, 1, 255, 1);
// SDL_RenderDrawLine(renderer, 0, 3, 255, 3);
@@ -173,7 +170,7 @@ void Ending2::render()
}
// Vuelca el contenido del renderizador en pantalla
screen->render();
screen_->render();
}
// Comprueba el manejador de eventos
@@ -195,7 +192,7 @@ void Ending2::checkInput()
// Bucle principal
void Ending2::run()
{
JA_PlayMusic(music);
JA_PlayMusic(music_);
while (options.section.section == Section::ENDING2)
{
@@ -212,21 +209,21 @@ void Ending2::run()
void Ending2::updateCounters()
{
// Incrementa el contador
if (preCounter < 200)
if (pre_counter_ < 200)
{
preCounter++;
pre_counter_++;
}
else
{
counterEnabled = true;
counter_enabled_ = true;
}
if (postCounterEnabled)
if (post_counter_enabled_)
{
postCounter++;
post_counter_++;
}
if (postCounter > 600)
if (post_counter_ > 600)
{
options.section.section = Section::LOGO;
options.section.subsection = Subsection::LOGO_TO_INTRO;
@@ -237,100 +234,100 @@ void Ending2::updateCounters()
void Ending2::iniSpriteList()
{
// Reinicia el vector
spriteList.clear();
sprite_list_.clear();
// Añade los valores
spriteList.push_back("bin");
spriteList.push_back("floppy");
spriteList.push_back("bird");
spriteList.push_back("chip");
spriteList.push_back("jeannine");
spriteList.push_back("spark");
spriteList.push_back("code");
spriteList.push_back("paco");
spriteList.push_back("elsa");
spriteList.push_back("z80");
sprite_list_.push_back("bin");
sprite_list_.push_back("floppy");
sprite_list_.push_back("bird");
sprite_list_.push_back("chip");
sprite_list_.push_back("jeannine");
sprite_list_.push_back("spark");
sprite_list_.push_back("code");
sprite_list_.push_back("paco");
sprite_list_.push_back("elsa");
sprite_list_.push_back("z80");
spriteList.push_back("bell");
spriteList.push_back("dong");
sprite_list_.push_back("bell");
sprite_list_.push_back("dong");
spriteList.push_back("amstrad_cs");
spriteList.push_back("breakout");
sprite_list_.push_back("amstrad_cs");
sprite_list_.push_back("breakout");
spriteList.push_back("flying_arounder");
spriteList.push_back("stopped_arounder");
spriteList.push_back("walking_arounder");
spriteList.push_back("arounders_door");
spriteList.push_back("arounders_machine");
sprite_list_.push_back("flying_arounder");
sprite_list_.push_back("stopped_arounder");
sprite_list_.push_back("walking_arounder");
sprite_list_.push_back("arounders_door");
sprite_list_.push_back("arounders_machine");
spriteList.push_back("abad");
spriteList.push_back("abad_bell");
spriteList.push_back("lord_abad");
sprite_list_.push_back("abad");
sprite_list_.push_back("abad_bell");
sprite_list_.push_back("lord_abad");
spriteList.push_back("bat");
spriteList.push_back("batman_bell");
spriteList.push_back("batman_fire");
spriteList.push_back("batman");
sprite_list_.push_back("bat");
sprite_list_.push_back("batman_bell");
sprite_list_.push_back("batman_fire");
sprite_list_.push_back("batman");
spriteList.push_back("demon");
spriteList.push_back("heavy");
spriteList.push_back("dimallas");
spriteList.push_back("guitar");
sprite_list_.push_back("demon");
sprite_list_.push_back("heavy");
sprite_list_.push_back("dimallas");
sprite_list_.push_back("guitar");
spriteList.push_back("jailbattle_alien");
spriteList.push_back("jailbattle_human");
sprite_list_.push_back("jailbattle_alien");
sprite_list_.push_back("jailbattle_human");
spriteList.push_back("jailer_#1");
spriteList.push_back("jailer_#2");
spriteList.push_back("jailer_#3");
spriteList.push_back("bry");
spriteList.push_back("upv_student");
sprite_list_.push_back("jailer_#1");
sprite_list_.push_back("jailer_#2");
sprite_list_.push_back("jailer_#3");
sprite_list_.push_back("bry");
sprite_list_.push_back("upv_student");
spriteList.push_back("lamp");
spriteList.push_back("robot");
spriteList.push_back("congo");
spriteList.push_back("crosshair");
spriteList.push_back("tree_thing");
sprite_list_.push_back("lamp");
sprite_list_.push_back("robot");
sprite_list_.push_back("congo");
sprite_list_.push_back("crosshair");
sprite_list_.push_back("tree_thing");
spriteList.push_back("matatunos");
spriteList.push_back("tuno");
sprite_list_.push_back("matatunos");
sprite_list_.push_back("tuno");
spriteList.push_back("mummy");
spriteList.push_back("sam");
sprite_list_.push_back("mummy");
sprite_list_.push_back("sam");
spriteList.push_back("qvoid");
spriteList.push_back("sigmasua");
sprite_list_.push_back("qvoid");
sprite_list_.push_back("sigmasua");
spriteList.push_back("tv_panel");
spriteList.push_back("tv");
sprite_list_.push_back("tv_panel");
sprite_list_.push_back("tv");
spriteList.push_back("spider");
spriteList.push_back("shock");
spriteList.push_back("wave");
sprite_list_.push_back("spider");
sprite_list_.push_back("shock");
sprite_list_.push_back("wave");
spriteList.push_back("player");
sprite_list_.push_back("player");
}
// Carga todos los sprites desde una lista
void Ending2::loadSprites()
{
// Inicializa variables
maxSpriteWidth = 0;
maxSpriteHeight = 0;
sprite_max_width_ = 0;
sprite_max_height_ = 0;
// Carga los sprites
for (auto sl : spriteList)
for (auto sl : sprite_list_)
{
sprites.emplace_back(std::make_shared<AnimatedSprite>(resource->getTexture(sl + ".png"), resource->getAnimation(sl + ".ani")));
maxSpriteWidth = std::max(sprites.back()->getWidth(), maxSpriteWidth);
maxSpriteHeight = std::max(sprites.back()->getHeight(), maxSpriteHeight);
sprites_.emplace_back(std::make_shared<AnimatedSprite>(resource_->getTexture(sl + ".png"), resource_->getAnimation(sl + ".ani")));
sprite_max_width_ = std::max(sprites_.back()->getWidth(), sprite_max_width_);
sprite_max_height_ = std::max(sprites_.back()->getHeight(), sprite_max_height_);
}
}
// Actualiza los sprites
void Ending2::updateSprites()
{
for (auto sprite : sprites)
for (auto sprite : sprites_)
{
sprite->update();
}
@@ -339,7 +336,7 @@ void Ending2::updateSprites()
// Actualiza los sprites de texto
void Ending2::updateTextSprites()
{
for (auto sprite : spriteTexts)
for (auto sprite : sprite_texts_)
{
sprite->update();
}
@@ -348,16 +345,16 @@ void Ending2::updateTextSprites()
// Actualiza los sprites de texto del final
void Ending2::updateTexts()
{
if (texts.back()->getPosY() > GAMECANVAS_CENTER_Y)
if (texts_.back()->getPosY() > GAMECANVAS_CENTER_Y)
{
for (auto sprite : texts)
for (auto sprite : texts_)
{
sprite->update();
}
}
else
{
postCounterEnabled = true;
post_counter_enabled_ = true;
}
}
@@ -365,7 +362,7 @@ void Ending2::updateTexts()
void Ending2::renderSprites()
{
const Color color = stringToColor(options.video.palette, "red");
for (auto sprite : sprites)
for (auto sprite : sprites_)
{
const bool a = sprite->getRect().y + sprite->getRect().h > 0;
const bool b = sprite->getRect().y < GAMECANVAS_HEIGHT;
@@ -378,15 +375,15 @@ void Ending2::renderSprites()
// Pinta el ultimo elemento de otro color
const Color c = stringToColor(options.video.palette, "white");
sprites.back()->getTexture()->setColor(c.r, c.g, c.b);
sprites.back()->render();
sprites_.back()->getTexture()->setColor(c.r, c.g, c.b);
sprites_.back()->render();
}
// Dibuja los sprites con el texto
void Ending2::renderSpriteTexts()
{
const Color color = stringToColor(options.video.palette, "white");
for (auto sprite : spriteTexts)
for (auto sprite : sprite_texts_)
{
const bool a = sprite->getRect().y + sprite->getRect().h > 0;
const bool b = sprite->getRect().y < GAMECANVAS_HEIGHT;
@@ -401,7 +398,7 @@ void Ending2::renderSpriteTexts()
// Dibuja los sprites con el texto del final
void Ending2::renderTexts()
{
for (auto sprite : texts)
for (auto sprite : texts_)
{
const bool a = sprite->getRect().y + sprite->getRect().h > 0;
const bool b = sprite->getRect().y < GAMECANVAS_HEIGHT;
@@ -415,58 +412,58 @@ void Ending2::renderTexts()
// Coloca los sprites en su sito
void Ending2::placeSprites()
{
for (int i = 0; i < (int)sprites.size(); ++i)
for (int i = 0; i < (int)sprites_.size(); ++i)
{
const int x = i % 2 == 0 ? firstCol : secondCol;
const int y = (i / 1) * (maxSpriteHeight + distSpriteText + text->getCharacterSize() + distSpriteSprite) + GAMECANVAS_HEIGHT + 40;
const int w = sprites[i]->getWidth();
const int h = sprites[i]->getHeight();
const int x = i % 2 == 0 ? FIRST_COL_ : SECOND_COL_;
const int y = (i / 1) * (sprite_max_height_ + dist_sprite_text_ + text_->getCharacterSize() + dist_sprite_sprite_) + GAMECANVAS_HEIGHT + 40;
const int w = sprites_[i]->getWidth();
const int h = sprites_[i]->getHeight();
const int dx = -(w / 2);
const int dy = i % 1 == 0 ? maxSpriteHeight - h : (int)(maxSpriteHeight * 1.5f) - h;
const int dy = i % 1 == 0 ? sprite_max_height_ - h : (int)(sprite_max_height_ * 1.5f) - h;
sprites[i]->setPosition({x + dx, y + dy, w, h});
sprites[i]->setVelY(despSpeed);
sprites_[i]->setPosition({x + dx, y + dy, w, h});
sprites_[i]->setVelY(sprite_desp_speed_);
}
// Recoloca el último sprite, que es el del jugador
const int w = sprites.back()->getWidth();
const int w = sprites_.back()->getWidth();
const int x = GAMECANVAS_CENTER_X - (w / 2);
const int y = sprites.back()->getPosY() + maxSpriteHeight * 2;
sprites.back()->setPosX(x);
sprites.back()->setPosY(y);
sprites.back()->setCurrentAnimation("walk");
const int y = sprites_.back()->getPosY() + sprite_max_height_ * 2;
sprites_.back()->setPosX(x);
sprites_.back()->setPosY(y);
sprites_.back()->setCurrentAnimation("walk");
}
// Crea los sprites con las texturas con los textos
void Ending2::createSpriteTexts()
{
// Crea los sprites de texto a partir de la lista
for (int i = 0; i < (int)spriteList.size(); ++i)
for (int i = 0; i < (int)sprite_list_.size(); ++i)
{
// Calcula constantes
std::string txt = spriteList[i];
std::string txt = sprite_list_[i];
std::replace(txt.begin(), txt.end(), '_', ' ');
txt = txt == "player" ? "JAILDOCTOR" : txt; // Reemplaza el texto
const int w = text->lenght(txt, 1);
const int h = text->getCharacterSize();
const int x = i % 2 == 0 ? firstCol : secondCol;
const int w = text_->lenght(txt, 1);
const int h = text_->getCharacterSize();
const int x = i % 2 == 0 ? FIRST_COL_ : SECOND_COL_;
const int dx = -(w / 2);
const int y = sprites[i]->getPosY() + sprites[i]->getHeight() + distSpriteText;
const int y = sprites_[i]->getPosY() + sprites_[i]->getHeight() + dist_sprite_text_;
// Cambia la posición del último sprite
const int X = (i == (int)spriteList.size() - 1) ? GAMECANVAS_CENTER_X - (w / 2) : x + dx;
const int X = (i == (int)sprite_list_.size() - 1) ? GAMECANVAS_CENTER_X - (w / 2) : x + dx;
// Crea la textura
auto texture = std::make_shared<Texture>(renderer);
auto texture = std::make_shared<Texture>(renderer_);
texture->createBlank(w, h);
texture->setAsRenderTarget(renderer);
texture->setAsRenderTarget(renderer_);
texture->setBlendMode(SDL_BLENDMODE_BLEND);
text->write(0, 0, txt);
text_->write(0, 0, txt);
// Crea el sprite
SDL_Rect pos = {X, y, w, h};
spriteTexts.emplace_back(std::make_shared<MovingSprite>(texture, pos));
spriteTexts.back()->setVelY(despSpeed);
sprite_texts_.emplace_back(std::make_shared<MovingSprite>(texture, pos));
sprite_texts_.back()->setVelY(sprite_desp_speed_);
}
}
@@ -481,28 +478,28 @@ void Ending2::createTexts()
for (int i = 0; i < (int)list.size(); ++i)
{
// Calcula constantes
const int w = text->lenght(list[i], 1);
const int h = text->getCharacterSize();
const int w = text_->lenght(list[i], 1);
const int h = text_->getCharacterSize();
const int x = GAMECANVAS_CENTER_X;
const int dx = -(w / 2);
const int y = GAMECANVAS_HEIGHT + (text->getCharacterSize() * (i * 2));
const int y = GAMECANVAS_HEIGHT + (text_->getCharacterSize() * (i * 2));
// Crea la textura
auto texture = std::make_shared<Texture>(renderer);
auto texture = std::make_shared<Texture>(renderer_);
texture->createBlank(w, h);
texture->setAsRenderTarget(renderer);
texture->setAsRenderTarget(renderer_);
texture->setBlendMode(SDL_BLENDMODE_BLEND);
text->write(0, 0, list[i]);
text_->write(0, 0, list[i]);
// Crea el sprite
SDL_Rect pos = {x + dx, y, w, h};
texts.emplace_back(std::make_shared<MovingSprite>(texture, pos));
texts.back()->setVelY(despSpeed);
texts_.emplace_back(std::make_shared<MovingSprite>(texture, pos));
texts_.back()->setVelY(sprite_desp_speed_);
}
// Crea los últimos textos
// El primer texto va a continuación del ultimo spriteText
const int start = spriteTexts.back()->getPosY() + text->getCharacterSize() * 15;
const int start = sprite_texts_.back()->getPosY() + text_->getCharacterSize() * 15;
list.clear();
list.push_back("THANK YOU");
list.push_back("FOR PLAYING!");
@@ -511,23 +508,23 @@ void Ending2::createTexts()
for (int i = 0; i < (int)list.size(); ++i)
{
// Calcula constantes
const int w = text->lenght(list[i], 1);
const int h = text->getCharacterSize();
const int w = text_->lenght(list[i], 1);
const int h = text_->getCharacterSize();
const int x = GAMECANVAS_CENTER_X;
const int dx = -(w / 2);
const int y = start + (text->getCharacterSize() * (i * 2));
const int y = start + (text_->getCharacterSize() * (i * 2));
// Crea la textura
auto texture = std::make_shared<Texture>(renderer);
auto texture = std::make_shared<Texture>(renderer_);
texture->createBlank(w, h);
texture->setAsRenderTarget(renderer);
texture->setAsRenderTarget(renderer_);
texture->setBlendMode(SDL_BLENDMODE_BLEND);
text->write(0, 0, list[i]);
text_->write(0, 0, list[i]);
// Crea el sprite
SDL_Rect pos = {x + dx, y, w, h};
texts.emplace_back(std::make_shared<MovingSprite>(texture, pos));
texts.back()->setVelY(despSpeed);
texts_.emplace_back(std::make_shared<MovingSprite>(texture, pos));
texts_.back()->setVelY(sprite_desp_speed_);
}
}
@@ -535,21 +532,21 @@ void Ending2::createTexts()
void Ending2::updateFinalFade()
{
// La variable step va de 0 a 40 en el tramo de postCounter que va de 500 a 540. Al dividirlo por 40, va de 0.0f a 1.0f
const float step = std::min(std::max(postCounter, 500) - 500, 40) / 40.0f;
const int index = (colors.size() - 1) * step;
const float step = std::min(std::max(post_counter_, 500) - 500, 40) / 40.0f;
const int index = (colors_.size() - 1) * step;
for (auto t : texts)
for (auto t : texts_)
{
t->getTexture()->setColor(colors[index].r, colors[index].g, colors[index].b);
t->getTexture()->setColor(colors_[index].r, colors_[index].g, colors_[index].b);
}
}
// Actualiza el volumen de la musica
void Ending2::updateMusicVolume()
{
if (postCounter > 0)
if (post_counter_ > 0)
{
const float step = (600.0f - postCounter) / 600.0f;
const float step = (600.0f - post_counter_) / 600.0f;
const int volume = 128 * step;
JA_SetVolume(volume);
}

52
source/ending2.h
View File

@@ -6,6 +6,7 @@
#include <string> // for string
#include <vector> // for vector
#include "utils.h" // for Color
#include "defines.h" // for GAMECANVAS_FIRST_QUARTER_X, GAMECANVAS_THIRD_QUARTER_X, GAMECANVAS_WIDTH
class AnimatedSprite; // lines 9-9
class Asset; // lines 10-10
class Input; // lines 11-11
@@ -18,34 +19,35 @@ struct JA_Music_t; // lines 16-16
class Ending2
{
private:
// Constantes
static constexpr int FIRST_COL_ = GAMECANVAS_FIRST_QUARTER_X + (GAMECANVAS_WIDTH / 16); // Primera columna por donde desfilan los sprites
static constexpr int SECOND_COL_ = GAMECANVAS_THIRD_QUARTER_X - (GAMECANVAS_WIDTH / 16); // Segunda columna por donde desfilan los sprites
// Objetos y punteros
Screen *screen; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer; // El renderizador de la ventana
Resource *resource; // Objeto con los recursos
Asset *asset; // Objeto con los ficheros de recursos
Input *input; // Objeto pata gestionar la entrada
std::shared_ptr<Text> text; // Objeto para escribir texto en pantalla
std::vector<std::shared_ptr<AnimatedSprite>> sprites; // Vector con todos los sprites a dibujar
std::vector<std::shared_ptr<MovingSprite>> spriteTexts; // Vector con los sprites de texto de los sprites
std::vector<std::shared_ptr<MovingSprite>> texts; // Vector con los sprites de texto
Screen *screen_; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer_; // El renderizador de la ventana
Resource *resource_; // Objeto con los recursos
Asset *asset_; // Objeto con los ficheros de recursos
Input *input_; // Objeto pata gestionar la entrada
std::shared_ptr<Text> text_; // Objeto para escribir texto en pantalla
std::vector<std::shared_ptr<AnimatedSprite>> sprites_; // Vector con todos los sprites a dibujar
std::vector<std::shared_ptr<MovingSprite>> sprite_texts_; // Vector con los sprites de texto de los sprites
std::vector<std::shared_ptr<MovingSprite>> texts_; // Vector con los sprites de texto
// Variables
bool counterEnabled; // Indica si está el contador habilitado
int preCounter; // Contador previo
int postCounter; // Contador posterior
bool postCounterEnabled; // Indica si está habilitado el contador
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
JA_Music_t *music; // Musica que suena durante el final
std::vector<std::string> spriteList; // Lista con todos los sprites a dibujar
std::vector<Color> colors; // Vector con los colores para el fade
int maxSpriteWidth; // El valor de ancho del sprite mas ancho
int maxSpriteHeight; // El valor de alto del sprite mas alto
int distSpriteText; // Distancia entre el sprite y el texto que lo acompaña
int distSpriteSprite; // Distancia entre dos sprites de la misma columna
float despSpeed; // Velocidad de desplazamiento de los sprites
int firstCol; // Primera columna por donde desfilan los sprites
int secondCol; // Segunda columna por donde desfilan los sprites
bool counter_enabled_; // Indica si está el contador habilitado
int pre_counter_; // Contador previo
int post_counter_; // Contador posterior
bool post_counter_enabled_; // Indica si está habilitado el contador
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
JA_Music_t *music_; // Musica que suena durante el final
std::vector<std::string> sprite_list_; // Lista con todos los sprites a dibujar
std::vector<Color> colors_; // Vector con los colores para el fade
int sprite_max_width_; // El valor de ancho del sprite mas ancho
int sprite_max_height_; // El valor de alto del sprite mas alto
int dist_sprite_text_; // Distancia entre el sprite y el texto que lo acompaña
int dist_sprite_sprite_; // Distancia entre dos sprites de la misma columna
float sprite_desp_speed_; // Velocidad de desplazamiento de los sprites
// Actualiza el objeto
void update();

13
source/game.cpp
View File

@@ -41,13 +41,13 @@ Game::Game()
current_room_ = "03.room";
const int x = 25;
const int y = 13;
spawn_point_ = {x * 8, y * 8, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
spawn_point_ = PlayerSpawn(x * 8, y * 8, 0, 0, 0, PlayerState::STANDING, SDL_FLIP_HORIZONTAL);
debug_->setEnabled(false);
#else
current_room_ = "03.room";
const int x = 25;
const int y = 13;
spawn_point_ = {x * 8, y * 8, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
spawn_point_ = PlayerSpawn(x * 8, y * 8, 0, 0, 0, PlayerState::STANDING, SDL_FLIP_HORIZONTAL);
#endif
// Crea los objetos
@@ -57,7 +57,7 @@ Game::Game()
room_ = std::make_shared<Room>(resource_->getRoom(current_room_), &board_.items, false);
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 player_t player = {spawn_point_, playerPNG, playerANI, room_};
const PlayerData player(spawn_point_, playerPNG, playerANI, room_);
player_ = std::make_shared<Player>(player);
text_ = resource_->getText("smb2");
music_ = resource_->getMusic("game.ogg");
@@ -85,7 +85,6 @@ Game::Game()
// Inicializa el resto de variables
ticks_ = 0;
ticks_speed_ = 15;
board_.lives = 9;
#ifdef DEBUG
board_.lives = 9;
@@ -217,7 +216,7 @@ void Game::run()
void Game::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks_ > ticks_speed_)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();
@@ -283,7 +282,7 @@ 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("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(static_cast<int>(player_->state_)));
}
// Pone la información de debug en pantalla
@@ -443,7 +442,7 @@ void Game::killPlayer()
room_ = std::make_shared<Room>(resource_->getRoom(current_room_), &board_.items, board_.jail_is_open);
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 player_t player = {spawn_point_, playerPNG, playerANI, room_};
const PlayerData player(spawn_point_, playerPNG, playerANI, room_);
player_ = std::make_shared<Player>(player);
// Pone los objetos en pausa mientras esta la habitación en negro

3
source/game.h
View File

@@ -46,9 +46,8 @@ private:
// Variables
JA_Music_t *music_; // Musica que suena durante el juego
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
std::string current_room_; // Fichero de la habitación actual
playerSpawn_t spawn_point_; // Lugar de la habitación donde aparece el jugador
PlayerSpawn spawn_point_; // Lugar de la habitación donde aparece el jugador
JA_Sound_t *death_sound_; // Sonido a reproducir cuando muere el jugador
ScoreboardData board_; // Estructura con los datos del marcador
bool paused_; // Indica si el juego se encuentra en pausa

111
source/game_over.cpp
View File

@@ -18,50 +18,46 @@
// Constructor
GameOver::GameOver()
: screen(Screen::get()),
renderer(Screen::get()->getRenderer()),
resource(Resource::get()),
asset(Asset::get()),
input(Input::get())
: screen_(Screen::get()),
renderer_(Screen::get()->getRenderer()),
resource_(Resource::get()),
asset_(Asset::get()),
input_(Input::get())
{
// Reserva memoria para los punteros a objetos
text = resource->getText("smb2");
playerSprite = std::make_shared<AnimatedSprite>(resource->getTexture("player_game_over.png"), resource->getAnimation("player_game_over.ani"));
tvSprite = std::make_shared<AnimatedSprite>(resource->getTexture("tv.png"), resource->getAnimation("tv.ani"));
music = resource->getMusic("game_over.ogg");
text_ = resource_->getText("smb2");
player_sprite_ = std::make_shared<AnimatedSprite>(resource_->getTexture("player_game_over.png"), resource_->getAnimation("player_game_over.ani"));
tv_sprite_ = std::make_shared<AnimatedSprite>(resource_->getTexture("tv.png"), resource_->getAnimation("tv.ani"));
music_ = resource_->getMusic("game_over.ogg");
// Inicializa variables
preCounter = 0;
counter = 0;
pre_counter_ = 0;
counter_ = 0;
options.section.section = Section::GAME_OVER;
options.section.subsection = Subsection::NONE;
ticks = 0;
ticksSpeed = 15;
endSection = 400;
iniFade = 310;
fadeLenght = 20;
playerSprite->setPosX(GAMECANVAS_CENTER_X + 10);
playerSprite->setPosY(30);
tvSprite->setPosX(GAMECANVAS_CENTER_X - tvSprite->getWidth() - 10);
tvSprite->setPosY(30);
ticks_ = 0;
player_sprite_->setPosX(GAMECANVAS_CENTER_X + 10);
player_sprite_->setPosY(30);
tv_sprite_->setPosX(GAMECANVAS_CENTER_X - tv_sprite_->getWidth() - 10);
tv_sprite_->setPosY(30);
// Inicializa el vector de colores
const std::vector<std::string> colorList = {"white", "yellow", "cyan", "green", "magenta", "red", "blue", "black"};
for (auto cl : colorList)
{
colors.push_back(stringToColor(options.video.palette, cl));
colors_.push_back(stringToColor(options.video.palette, cl));
}
color = colors.back();
color_ = colors_.back();
}
// Actualiza el objeto
void GameOver::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks > ticksSpeed)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
ticks_ = SDL_GetTicks();
// Comprueba las entradas
checkInput();
@@ -73,44 +69,41 @@ void GameOver::update()
updateCounters();
// Actualiza los dos sprites
playerSprite->update();
tvSprite->update();
player_sprite_->update();
tv_sprite_->update();
screen->update();
screen_->update();
}
}
// Dibuja el final en pantalla
void GameOver::render()
{
const int y = 32;
constexpr int Y = 32;
// Prepara para empezar a dibujar en la textura de juego
screen->start();
// Limpia la pantalla
screen->clean();
screen_->start();
screen_->clean();
// Escribe el texto de GAME OVER
text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, y, "G A M E O V E R", 1, color);
text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y, "G A M E O V E R", 1, color_);
// Dibuja los sprites
playerSprite->setPosY(y + 30);
tvSprite->setPosY(y + 30);
player_sprite_->setPosY(Y + 30);
tv_sprite_->setPosY(Y + 30);
renderSprites();
// Escribe el texto con las habitaciones y los items
const std::string itemsTxt = std::to_string(options.stats.items / 100) + std::to_string((options.stats.items % 100) / 10) + std::to_string(options.stats.items % 10);
const std::string roomsTxt = std::to_string(options.stats.rooms / 100) + std::to_string((options.stats.rooms % 100) / 10) + std::to_string(options.stats.rooms % 10);
text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, y + 80, "ITEMS: " + itemsTxt, 1, color);
text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, y + 90, "ROOMS: " + roomsTxt, 1, color);
text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 80, "ITEMS: " + itemsTxt, 1, color_);
text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 90, "ROOMS: " + roomsTxt, 1, color_);
// Escribe el texto con "Tu peor pesadilla"
text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, y + 110, "YOUR WORST NIGHTMARE IS", 1, color);
text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, y + 120, options.stats.worst_nightmare, 1, color);
text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 110, "YOUR WORST NIGHTMARE IS", 1, color_);
text_->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 120, options.stats.worst_nightmare, 1, color_);
// Vuelca el contenido del renderizador en pantalla
screen->render();
screen_->render();
}
// Comprueba el manejador de eventos
@@ -143,53 +136,53 @@ void GameOver::run()
// Actualiza el color usado para renderizar los textos e imagenes
void GameOver::updateColor()
{
const int half = endSection / 2;
const int half = COUNTER_SECTION_END_ / 2;
if (counter < half)
if (counter_ < half)
{
const float step = std::min(counter, fadeLenght) / (float)fadeLenght;
const int index = (colors.size() - 1) - int((colors.size() - 1) * step);
color = colors[index];
const float step = std::min(counter_, COUNTER_FADE_LENGHT_) / (float)COUNTER_FADE_LENGHT_;
const int index = (colors_.size() - 1) - int((colors_.size() - 1) * step);
color_ = colors_[index];
}
else
{
const float step = std::min(std::max(counter, iniFade) - iniFade, fadeLenght) / (float)fadeLenght;
const int index = (colors.size() - 1) * step;
color = colors[index];
const float step = std::min(std::max(counter_, COUNTER_INIT_FADE_) - COUNTER_INIT_FADE_, COUNTER_FADE_LENGHT_) / (float)COUNTER_FADE_LENGHT_;
const int index = (colors_.size() - 1) * step;
color_ = colors_[index];
}
}
// Dibuja los sprites
void GameOver::renderSprites()
{
playerSprite->getTexture()->setColor(color.r, color.g, color.b);
playerSprite->render();
player_sprite_->getTexture()->setColor(color_.r, color_.g, color_.b);
player_sprite_->render();
tvSprite->getTexture()->setColor(color.r, color.g, color.b);
tvSprite->render();
tv_sprite_->getTexture()->setColor(color_.r, color_.g, color_.b);
tv_sprite_->render();
}
// Actualiza los contadores
void GameOver::updateCounters()
{
// Actualiza el contador
if (preCounter < 50)
if (pre_counter_ < 50)
{
preCounter++;
pre_counter_++;
}
else
{
counter++;
counter_++;
}
// Hace sonar la música
if (counter == 1)
if (counter_ == 1)
{
JA_PlayMusic(music, 0);
JA_PlayMusic(music_, 0);
}
// Comprueba si ha terminado la sección
else if (counter == endSection)
else if (counter_ == COUNTER_SECTION_END_)
{
options.section.section = Section::LOGO;
options.section.subsection = Subsection::LOGO_TO_TITLE;

37
source/game_over.h
View File

@@ -16,27 +16,28 @@ struct JA_Music_t; // lines 15-15
class GameOver
{
private:
// Constantes
static constexpr int COUNTER_SECTION_END_ = 400; // Contador: cuando acaba la sección
static constexpr int COUNTER_INIT_FADE_ = 310; // Contador: cuando emiepza el fade
static constexpr int COUNTER_FADE_LENGHT_ = 20; // Contador: duración del fade
// Objetos y punteros
Screen *screen; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer; // El renderizador de la ventana
Resource *resource; // Objeto con los recursos
Asset *asset; // Objeto con los ficheros de recursos
Input *input; // Objeto pata gestionar la entrada
std::shared_ptr<Text> text; // Objeto para escribir texto en pantalla
std::shared_ptr<AnimatedSprite> playerSprite; // Sprite con el jugador
std::shared_ptr<AnimatedSprite> tvSprite; // Sprite con el televisor
Screen *screen_; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer_; // El renderizador de la ventana
Resource *resource_; // Objeto con los recursos
Asset *asset_; // Objeto con los ficheros de recursos
Input *input_; // Objeto pata gestionar la entrada
std::shared_ptr<Text> text_; // Objeto para escribir texto en pantalla
std::shared_ptr<AnimatedSprite> player_sprite_; // Sprite con el jugador
std::shared_ptr<AnimatedSprite> tv_sprite_; // Sprite con el televisor
// Variables
int preCounter; // Contador previo
int counter; // Contador
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
std::vector<Color> colors; // Vector con los colores para el fade
Color color; // Color usado para el texto y los sprites
int endSection; // Contador: cuando acaba la sección
int iniFade; // Contador: cuando emiepza el fade
int fadeLenght; // Contador: duración del fade
JA_Music_t *music; // Musica que suena durante el juego
int pre_counter_ = 0; // Contador previo
int counter_ = 0; // Contador
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
std::vector<Color> colors_; // Vector con los colores para el fade
Color color_; // Color usado para el texto y los sprites
JA_Music_t *music_; // Musica que suena durante el juego
// Actualiza el objeto
void update();

8
source/item_tracker.cpp
View File

@@ -46,12 +46,12 @@ void ItemTracker::addItem(const std::string &name, SDL_Point pos)
// Primero busca si ya hay una entrada con ese nombre
if (const int index = findByName(name); index != -1)
{
list.at(index).pos.push_back(pos);
item_list_.at(index).pos.push_back(pos);
}
// En caso contrario crea la entrada
else
{
list.emplace_back(name, pos);
item_list_.emplace_back(name, pos);
}
}
}
@@ -61,7 +61,7 @@ int ItemTracker::findByName(std::string name)
{
int i = 0;
for (const auto &l : list)
for (const auto &l : item_list_)
{
if (l.name == name)
{
@@ -78,7 +78,7 @@ int ItemTracker::findByPos(int index, SDL_Point pos)
{
int i = 0;
for (const auto &l : list[index].pos)
for (const auto &l : item_list_[index].pos)
{
if ((l.x == pos.x) && (l.y == pos.y))
{

4
source/item_tracker.h
View File

@@ -10,7 +10,7 @@ struct ItemTrackerData
std::vector<SDL_Point> pos; // Lista de objetos cogidos de la habitación
// Constructor
ItemTrackerData(const std::string& name, const SDL_Point& position)
ItemTrackerData(const std::string &name, const SDL_Point &position)
: name(name)
{
pos.push_back(position);
@@ -24,7 +24,7 @@ private:
static ItemTracker *item_tracker_;
// Variables
std::vector<ItemTrackerData> list; // Lista con todos los objetos recogidos
std::vector<ItemTrackerData> item_list_; // Lista con todos los objetos recogidos
// Busca una entrada en la lista por nombre
int findByName(std::string name);

2
source/loading_screen.cpp
View File

@@ -187,7 +187,7 @@ void LoadingScreen::renderBorder()
void LoadingScreen::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks_ > ticks_speed_)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
ticks_ = SDL_GetTicks();
checkInput();

1
source/loading_screen.h
View File

@@ -30,7 +30,6 @@ private:
int pre_counter_ = 0; // Contador previo para realizar una pausa inicial
int counter_ = 0; // Contador
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticks_speed_ = 15; // Velocidad a la que se repiten los bucles del programa
int load_counter_ = 0; // Contador para controlar las cargas
bool loading_first_part_ = true; // Para saber en que parte de la carga se encuentra
JA_Music_t *loading_sound1_; // Sonidos para imitar la carga tipo spectrum

19
source/logo.cpp
View File

@@ -13,6 +13,7 @@
#include "sprite.h" // for Sprite
#include "texture.h" // for Texture
#include "utils.h" // for Color, stringToColor
#include "defines.h"
// Constructor
Logo::Logo()
@@ -153,43 +154,43 @@ void Logo::updateTextureColors()
since_1998_texture_->setColor(color_[7].r, color_[7].g, color_[7].b);
}
else if (counter_ == init_fade_ + inc * 0)
else if (counter_ == INIT_FADE_ + inc * 0)
{
jailgames_texture_->setColor(color_[6].r, color_[6].g, color_[6].b);
since_1998_texture_->setColor(color_[6].r, color_[6].g, color_[6].b);
}
else if (counter_ == init_fade_ + inc * 1)
else if (counter_ == INIT_FADE_ + inc * 1)
{
jailgames_texture_->setColor(color_[5].r, color_[5].g, color_[5].b);
since_1998_texture_->setColor(color_[5].r, color_[5].g, color_[5].b);
}
else if (counter_ == init_fade_ + inc * 2)
else if (counter_ == INIT_FADE_ + inc * 2)
{
jailgames_texture_->setColor(color_[4].r, color_[4].g, color_[4].b);
since_1998_texture_->setColor(color_[4].r, color_[4].g, color_[4].b);
}
else if (counter_ == init_fade_ + inc * 3)
else if (counter_ == INIT_FADE_ + inc * 3)
{
jailgames_texture_->setColor(color_[3].r, color_[3].g, color_[3].b);
since_1998_texture_->setColor(color_[3].r, color_[3].g, color_[3].b);
}
else if (counter_ == init_fade_ + inc * 4)
else if (counter_ == INIT_FADE_ + inc * 4)
{
jailgames_texture_->setColor(color_[2].r, color_[2].g, color_[2].b);
since_1998_texture_->setColor(color_[2].r, color_[2].g, color_[2].b);
}
else if (counter_ == init_fade_ + inc * 5)
else if (counter_ == INIT_FADE_ + inc * 5)
{
jailgames_texture_->setColor(color_[1].r, color_[1].g, color_[1].b);
since_1998_texture_->setColor(color_[1].r, color_[1].g, color_[1].b);
}
else if (counter_ == init_fade_ + inc * 6)
else if (counter_ == INIT_FADE_ + inc * 6)
{
jailgames_texture_->setColor(color_[0].r, color_[0].g, color_[0].b);
since_1998_texture_->setColor(color_[0].r, color_[0].g, color_[0].b);
@@ -200,7 +201,7 @@ void Logo::updateTextureColors()
void Logo::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks_ > ticks_speed_)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();
@@ -220,7 +221,7 @@ void Logo::update()
screen_->update();
// Comprueba si ha terminado el logo
if (counter_ == end_logo_ + post_logo_)
if (counter_ == END_LOGO_ + POST_LOGO_)
{
endSection();
}

9
source/logo.h
View File

@@ -15,6 +15,11 @@ class Texture; // lines 13-13
class Logo
{
private:
// Constantes
static constexpr int INIT_FADE_ = 300; // Tiempo del contador cuando inicia el fade a negro
static constexpr int END_LOGO_ = 400; // Tiempo del contador para terminar el logo
static constexpr int POST_LOGO_ = 20; // Tiempo que dura el logo con el fade al maximo
// Objetos y punteros
Screen *screen_; // Objeto encargado de dibujar en pantalla
SDL_Renderer *renderer_; // El renderizador de la ventana
@@ -30,10 +35,6 @@ private:
std::vector<Color> color_; // Vector con los colores para el fade
int counter_ = 0; // Contador
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticks_speed_ = 15; // Velocidad a la que se repiten los bucles del programa
int init_fade_ = 300; // Tiempo del contador cuando inicia el fade a negro
int end_logo_ = 400; // Tiempo del contador para terminar el logo
int post_logo_ = 20; // Tiempo que dura el logo con el fade al maximo
// Actualiza las variables
void update();

346
source/player.cpp
View File

@@ -16,106 +16,38 @@
#include "screen.h"
// Constructor
Player::Player(player_t player)
Player::Player(PlayerData player)
: renderer_(Screen::get()->getRenderer()),
input_(Input::get()),
resource_(Resource::get()),
asset_(Asset::get()),
debug_(Debug::get()),
room_(player.room)
{
// Crea objetos
sprite_ = std::make_shared<AnimatedSprite>(resource_->getTexture(player.png), resource_->getAnimation(player.animation));
// Inicializa algunas variables
initSprite(player.texture, player.animation);
setColor();
applySpawnValues(player.spawn);
placeSprite();
initSounds();
// Inicializa variables
reLoadPalette();
is_on_border_ = false;
border_ = BORDER_TOP;
auto_movement_ = false;
is_alive_ = true;
is_paused_ = false;
jump_init_pos_ = player.spawn.jump_init_pos;
state_ = player.spawn.state;
previous_state_ = state_;
x_ = player.spawn.x;
y_ = player.spawn.y;
vx_ = player.spawn.vx;
vy_ = player.spawn.vy;
w_ = 8;
h_ = 16;
sprite_->setPosX(player.spawn.x);
sprite_->setPosY(player.spawn.y);
sprite_->setWidth(8);
sprite_->setHeight(16);
sprite_->setFlip(player.spawn.flip);
sprite_->setCurrentAnimation("walk");
sprite_->update();
last_position_ = getRect();
collider_box_ = getRect();
const SDL_Point p = {0, 0};
collider_points_.insert(collider_points_.end(), {p, p, p, p, p, p, p, p});
under_feet_.insert(under_feet_.end(), {p, p});
feet_.insert(feet_.end(), {p, p});
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump1.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump2.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump3.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump4.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump5.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump6.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump7.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump8.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump9.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump10.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump11.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump12.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump13.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump14.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump15.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump16.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump17.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump18.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump19.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump20.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump21.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump22.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump23.wav").c_str()));
jumping_sound_.push_back(JA_LoadSound(asset_->get("jump24.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump11.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump12.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump13.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump14.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump15.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump16.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump17.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump18.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump19.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump20.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump21.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump22.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump23.wav").c_str()));
falling_sound_.push_back(JA_LoadSound(asset_->get("jump24.wav").c_str()));
jumping_counter_ = 0;
falling_counter_ = 0;
collider_points_.resize(collider_points_.size() + 8, {0, 0});
under_feet_.resize(under_feet_.size() + 2, {0, 0});
feet_.resize(feet_.size() + 2, {0, 0});
#ifdef DEBUG
rx = {0, 0, 0, 0};
ry = {0, 0, 0, 0};
debugColor = {0, 255, 0};
debugPoint = {0, 0};
debug_rect_x_ = {0, 0, 0, 0};
debug_rect_y_ = {0, 0, 0, 0};
debug_color_ = {0, 255, 0};
debug_point_ = {0, 0};
#endif
}
// Pinta el jugador en pantalla
void Player::render()
{
sprite_->getTexture()->setColor(color_.r, color_.g, color_.b);
sprite_->render();
#ifdef DEBUG
@@ -127,7 +59,7 @@ void Player::render()
SDL_RenderDrawPoint(renderer_, under_feet_[1].x, under_feet_[1].y);
// Pinta rectangulo del jugador
SDL_SetRenderDrawColor(renderer_, debugColor.r, debugColor.g, debugColor.b, 192);
SDL_SetRenderDrawColor(renderer_, debug_color_.r, debug_color_.g, debug_color_.b, 192);
SDL_Rect rect = getRect();
SDL_RenderFillRect(renderer_, &rect);
SDL_SetRenderDrawColor(renderer_, 0, 255, 255, 255);
@@ -137,16 +69,16 @@ void Player::render()
SDL_SetRenderDrawColor(renderer_, 255, 0, 0, 255);
if (vx_ != 0.0f)
{
SDL_RenderFillRect(renderer_, &rx);
SDL_RenderFillRect(renderer_, &debug_rect_x_);
}
if (vy_ != 0.0f)
{
SDL_RenderFillRect(renderer_, &ry);
SDL_RenderFillRect(renderer_, &debug_rect_y_);
}
// Pinta el punto de debug
SDL_SetRenderDrawColor(renderer_, rand() % 256, rand() % 256, rand() % 256, 255);
SDL_RenderDrawPoint(renderer_, debugPoint.x, debugPoint.y);
SDL_RenderDrawPoint(renderer_, debug_point_.x, debug_point_.y);
}
#endif
}
@@ -154,24 +86,22 @@ void Player::render()
// Actualiza las variables del objeto
void Player::update()
{
if (is_paused_)
{ // Si está en modo pausa no se actualiza nada
return;
}
if (!is_paused_)
{
checkInput(); // Comprueba las entradas y modifica variables
move(); // Recalcula la posición del jugador
animate(); // Establece la animación del jugador
checkBorders(); // Comprueba si está situado en alguno de los cuatro bordes de la habitación
checkJumpEnd(); // Comprueba si ha finalizado el salto al alcanzar la altura de inicio
checkKillingTiles(); // Comprueba que el jugador no toque ningun tile de los que matan
checkKillingTiles(); // Comprueba que el jugador no toque ningun tile de los que matan}
}
}
// Comprueba las entradas y modifica variables
void Player::checkInput()
{
// Solo comprueba las entradas de dirección cuando está sobre una superficie
if (state_ != s_standing)
if (state_ != PlayerState::STANDING)
{
return;
}
@@ -223,7 +153,7 @@ void Player::checkInput()
if (isOnFloor() || isOnAutoSurface())
{
setState(s_jumping);
setState(PlayerState::JUMPING);
vy_ = -MAX_VY_;
jump_init_pos_ = y_;
jumping_counter_ = 0;
@@ -231,18 +161,6 @@ void Player::checkInput()
}
}
// Indica si el jugador esta en uno de los cuatro bordes de la pantalla
bool Player::getOnBorder()
{
return is_on_border_;
}
// Indica en cual de los cuatro bordes se encuentra
int Player::getBorder()
{
return border_;
}
// Comprueba si está situado en alguno de los cuatro bordes de la habitación
void Player::checkBorders()
{
@@ -252,7 +170,7 @@ void Player::checkBorders()
is_on_border_ = true;
}
else if (x_ + w_ > PLAY_AREA_RIGHT)
else if (x_ + WIDTH_ > PLAY_AREA_RIGHT)
{
border_ = BORDER_RIGHT;
is_on_border_ = true;
@@ -264,7 +182,7 @@ void Player::checkBorders()
is_on_border_ = true;
}
else if (y_ + h_ > PLAY_AREA_BOTTOM)
else if (y_ + HEIGHT_ > PLAY_AREA_BOTTOM)
{
border_ = BORDER_BOTTOM;
is_on_border_ = true;
@@ -280,7 +198,7 @@ void Player::checkBorders()
void Player::checkState()
{
// Actualiza las variables en función del estado
if (state_ == s_falling)
if (state_ == PlayerState::FALLING)
{
vx_ = 0.0f;
vy_ = MAX_VY_;
@@ -288,9 +206,9 @@ void Player::checkState()
playFallSound();
}
else if (state_ == s_standing)
else if (state_ == PlayerState::STANDING)
{
if (previous_state_ == s_falling && falling_counter_ > MAX_FALLING_HEIGHT_)
if (previous_state_ == PlayerState::FALLING && falling_counter_ > MAX_FALLING_HEIGHT_)
{ // Si cae de muy alto, el jugador muere
is_alive_ = false;
}
@@ -299,7 +217,7 @@ void Player::checkState()
falling_counter_ = 0;
if (!isOnFloor() && !isOnAutoSurface() && !isOnDownSlope())
{
setState(s_falling);
setState(PlayerState::FALLING);
vx_ = 0.0f;
vy_ = MAX_VY_;
falling_counter_++;
@@ -307,7 +225,7 @@ void Player::checkState()
}
}
else if (state_ == s_jumping)
else if (state_ == PlayerState::JUMPING)
{
falling_counter_ = 0;
jumping_counter_++;
@@ -320,13 +238,13 @@ void Player::switchBorders()
{
if (border_ == BORDER_TOP)
{
y_ = PLAY_AREA_BOTTOM - h_ - 0 - BLOCK;
setState(s_standing);
y_ = PLAY_AREA_BOTTOM - HEIGHT_ - 0 - BLOCK;
setState(PlayerState::STANDING);
}
else if (border_ == BORDER_BOTTOM)
{
y_ = PLAY_AREA_TOP + 0;
setState(s_standing);
setState(PlayerState::STANDING);
}
else if (border_ == BORDER_RIGHT)
{
@@ -334,7 +252,7 @@ void Player::switchBorders()
}
if (border_ == BORDER_LEFT)
{
x_ = PLAY_AREA_RIGHT - w_ - 0;
x_ = PLAY_AREA_RIGHT - WIDTH_ - 0;
}
is_on_border_ = false;
@@ -347,7 +265,7 @@ void Player::applyGravity()
// La gravedad solo se aplica cuando el jugador esta saltando
// Nunca mientras cae o esta de pie
if (state_ == s_jumping)
if (state_ == PlayerState::JUMPING)
{
vy_ += GF;
if (vy_ > MAX_VY_)
@@ -357,19 +275,6 @@ void Player::applyGravity()
}
}
// Obtiene el rectangulo que delimita al jugador
SDL_Rect Player::getRect()
{
return {static_cast<int>(x_), static_cast<int>(y_), w_, h_};
}
// Obtiene el rectangulo de colision del jugador
SDL_Rect &Player::getCollider()
{
collider_box_ = getRect();
return collider_box_;
}
// Recalcula la posición del jugador y su animación
void Player::move()
{
@@ -378,7 +283,7 @@ void Player::move()
checkState(); // Comprueba el estado del jugador
#ifdef DEBUG
debugColor = {0, 255, 0};
debug_color_ = {0, 255, 0};
#endif
// Se mueve hacia la izquierda
@@ -388,11 +293,11 @@ void Player::move()
SDL_Rect proj;
proj.x = static_cast<int>(x_ + vx_);
proj.y = static_cast<int>(y_);
proj.h = h_;
proj.h = HEIGHT_;
proj.w = ceil(abs(vx_)); // Para evitar que tenga un ancho de 0 pixels
#ifdef DEBUG
rx = proj;
debug_rect_x_ = proj;
#endif
// Comprueba la colisión con las superficies
@@ -411,18 +316,18 @@ void Player::move()
}
// Si ha tocado alguna rampa mientras camina (sin saltar), asciende
if (state_ != s_jumping)
if (state_ != PlayerState::JUMPING)
{
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
v_line_t leftSide = {static_cast<int>(x_), static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
const int ly = room_->checkLeftSlopes(&leftSide);
if (ly > -1)
{
y_ = ly - h_;
y_ = ly - HEIGHT_;
}
}
// Si está bajando la rampa, recoloca al jugador
if (isOnDownSlope() && state_ != s_jumping)
if (isOnDownSlope() && state_ != PlayerState::JUMPING)
{
y_ += 1;
}
@@ -433,13 +338,13 @@ void Player::move()
{
// Crea el rectangulo de proyección en el eje X para ver si colisiona
SDL_Rect proj;
proj.x = static_cast<int>(x_) + w_;
proj.x = static_cast<int>(x_) + WIDTH_;
proj.y = static_cast<int>(y_);
proj.h = h_;
proj.h = HEIGHT_;
proj.w = ceil(vx_); // Para evitar que tenga un ancho de 0 pixels
#ifdef DEBUG
rx = proj;
debug_rect_x_ = proj;
#endif
// Comprueba la colisión
@@ -454,38 +359,38 @@ void Player::move()
else
{
// Si hay colisión lo mueve hasta donde no colisiona
x_ = pos - w_;
x_ = pos - WIDTH_;
}
// Si ha tocado alguna rampa mientras camina (sin saltar), asciende
if (state_ != s_jumping)
if (state_ != PlayerState::JUMPING)
{
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
v_line_t rightSide = {static_cast<int>(x_) + WIDTH_ - 1, static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
const int ry = room_->checkRightSlopes(&rightSide);
if (ry > -1)
{
y_ = ry - h_;
y_ = ry - HEIGHT_;
}
}
// Si está bajando la rampa, recoloca al jugador
if (isOnDownSlope() && state_ != s_jumping)
if (isOnDownSlope() && state_ != PlayerState::JUMPING)
{
y_ += 1;
}
}
// Si ha salido del suelo, el jugador cae
if (state_ == s_standing && !isOnFloor())
if (state_ == PlayerState::STANDING && !isOnFloor())
{
setState(s_falling);
setState(PlayerState::FALLING);
// Deja de estar enganchado a la superficie automatica
auto_movement_ = false;
}
// Si ha salido de una superficie automatica, detiene el movimiento automatico
if (state_ == s_standing && isOnFloor() && !isOnAutoSurface())
if (state_ == PlayerState::STANDING && isOnFloor() && !isOnAutoSurface())
{
// Deja de estar enganchado a la superficie automatica
auto_movement_ = false;
@@ -499,10 +404,10 @@ void Player::move()
proj.x = static_cast<int>(x_);
proj.y = static_cast<int>(y_ + vy_);
proj.h = ceil(abs(vy_)); // Para evitar que tenga una altura de 0 pixels
proj.w = w_;
proj.w = WIDTH_;
#ifdef DEBUG
ry = proj;
debug_rect_y_ = proj;
#endif
// Comprueba la colisión
@@ -518,7 +423,7 @@ void Player::move()
{
// Si hay colisión lo mueve hasta donde no colisiona y entra en caída
y_ = pos + 1;
setState(s_falling);
setState(PlayerState::FALLING);
}
}
@@ -528,12 +433,12 @@ void Player::move()
// Crea el rectangulo de proyección en el eje Y para ver si colisiona
SDL_Rect proj;
proj.x = static_cast<int>(x_);
proj.y = static_cast<int>(y_) + h_;
proj.y = static_cast<int>(y_) + HEIGHT_;
proj.h = ceil(vy_); // Para evitar que tenga una altura de 0 pixels
proj.w = w_;
proj.w = WIDTH_;
#ifdef DEBUG
ry = proj;
debug_rect_y_ = proj;
#endif
// Comprueba la colisión con las superficies normales y las automáticas
@@ -541,8 +446,8 @@ void Player::move()
if (pos > -1)
{
// Si hay colisión lo mueve hasta donde no colisiona y pasa a estar sobre la superficie
y_ = pos - h_;
setState(s_standing);
y_ = pos - HEIGHT_;
setState(PlayerState::STANDING);
// Deja de estar enganchado a la superficie automatica
auto_movement_ = false;
@@ -550,7 +455,7 @@ void Player::move()
else
{
// Si no hay colisión con los muros, comprueba la colisión con las rampas
if (state_ != s_jumping)
if (state_ != PlayerState::JUMPING)
{ // 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 rightSide = {proj.x + proj.w - 1, proj.y, proj.y + proj.h - 1};
@@ -559,11 +464,11 @@ void Player::move()
{
// No está saltando y hay colisión con una rampa
// Calcula la nueva posición
y_ = p - h_;
setState(s_standing);
y_ = p - HEIGHT_;
setState(PlayerState::STANDING);
#ifdef DEBUG
debugColor = {255, 255, 0};
debugPoint = {(int)x_ + (w_ / 2), p};
debug_color_ = {255, 255, 0};
debug_point_ = {(int)x_ + (WIDTH_ / 2), p};
#endif
}
else
@@ -572,7 +477,7 @@ void Player::move()
// Calcula la nueva posición
y_ += vy_;
#ifdef DEBUG
debugColor = {255, 0, 0};
debug_color_ = {255, 0, 0};
#endif
}
}
@@ -585,13 +490,12 @@ void Player::move()
}
}
// Actualiza la posición del sprite
sprite_->setPosX(x_);
sprite_->setPosY(y_);
placeSprite(); // Coloca el sprite en la nueva posición
collider_box_ = getRect(); // Actualiza el rectangulo de colisión
#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_Y: " + std::to_string(ry.x) + "," + std::to_string(ry.y) + "," + std::to_string(ry.w) + "," + std::to_string(ry.h));
debug_->add("RECT_X: " + std::to_string(debug_rect_x_.x) + "," + std::to_string(debug_rect_x_.y) + "," + std::to_string(debug_rect_x_.w) + "," + std::to_string(debug_rect_x_.h));
debug_->add("RECT_Y: " + std::to_string(debug_rect_y_.x) + "," + std::to_string(debug_rect_y_.y) + "," + std::to_string(debug_rect_y_.w) + "," + std::to_string(debug_rect_y_.h));
#endif
}
@@ -607,14 +511,14 @@ void Player::animate()
// Comprueba si ha finalizado el salto al alcanzar la altura de inicio
void Player::checkJumpEnd()
{
if (state_ == s_jumping)
if (state_ == PlayerState::JUMPING)
{
if (vy_ > 0)
{
if (y_ >= jump_init_pos_)
{
// Si alcanza la altura de salto inicial, pasa al estado de caída
setState(s_falling);
setState(PlayerState::FALLING);
vy_ = MAX_VY_;
jumping_counter_ = 0;
}
@@ -760,46 +664,23 @@ bool Player::checkKillingTiles()
return check;
}
// Obtiene algunos parametros del jugador
playerSpawn_t Player::getSpawnParams()
// Establece el color del jugador
void Player::setColor()
{
playerSpawn_t params;
params.x = x_;
params.y = y_;
params.vx = vx_;
params.vy = vy_;
params.jump_init_pos = jump_init_pos_;
params.state = state_;
params.flip = sprite_->getFlip();
return params;
}
// Recarga la textura
void Player::reLoadTexture()
{
sprite_->getTexture()->reLoad();
}
// Recarga la paleta
void Player::reLoadPalette()
{
color_ = stringToColor(options.video.palette, "white");
if (options.cheats.infinite_lives == Cheat::CheatState::ENABLED)
{
color_ = stringToColor(options.video.palette, "yellow");
}
if (options.cheats.invincible == Cheat::CheatState::ENABLED)
{
color_ = stringToColor(options.video.palette, "cyan");
}
}
else if (options.cheats.infinite_lives == Cheat::CheatState::ENABLED)
{
color_ = stringToColor(options.video.palette, "yellow");
}
else
{
color_ = stringToColor(options.video.palette, "white");
}
// Establece el valor de la variable
void Player::setRoom(std::shared_ptr<Room> room)
{
room_ = room;
sprite_->getTexture()->setColor(color_.r, color_.g, color_.b);
}
// Actualiza los puntos de colisión
@@ -821,15 +702,15 @@ void Player::updateFeet()
{
const SDL_Point p = {static_cast<int>(x_), static_cast<int>(y_)};
under_feet_[0] = {p.x, p.y + h_};
under_feet_[1] = {p.x + 7, p.y + h_};
under_feet_[0] = {p.x, p.y + HEIGHT_};
under_feet_[1] = {p.x + 7, p.y + HEIGHT_};
feet_[0] = {p.x, p.y + h_ - 1};
feet_[1] = {p.x + 7, p.y + h_ - 1};
feet_[0] = {p.x, p.y + HEIGHT_ - 1};
feet_[1] = {p.x + 7, p.y + HEIGHT_ - 1};
}
// Cambia el estado del jugador
void Player::setState(state_e value)
void Player::setState(PlayerState value)
{
previous_state_ = state_;
state_ = value;
@@ -837,20 +718,49 @@ void Player::setState(state_e value)
checkState();
}
// Comprueba si el jugador esta vivo
bool Player::isAlive()
// Inicializa los sonidos de salto y caida
void Player::initSounds()
{
return is_alive_;
jumping_sound_.clear();
falling_sound_.clear();
for (int i = 1; i <= 24; ++i)
{
std::string soundFile = "jump" + std::to_string(i) + ".wav";
jumping_sound_.push_back(Resource::get()->getSound(soundFile));
if (i >= 11)
{
falling_sound_.push_back(Resource::get()->getSound(soundFile));
}
}
}
// Pone el jugador en modo pausa
void Player::pause()
// Coloca el sprite en la posición del jugador
void Player::placeSprite()
{
is_paused_ = true;
sprite_->setPosX(x_);
sprite_->setPosY(y_);
}
// Quita el modo pausa del jugador
void Player::resume()
// Aplica los valores de spawn al jugador
void Player::applySpawnValues(const PlayerSpawn &spawn)
{
is_paused_ = false;
x_ = spawn.x;
y_ = spawn.y;
vx_ = spawn.vx;
vy_ = spawn.vy;
jump_init_pos_ = spawn.jump_init_pos;
state_ = spawn.state;
sprite_->setFlip(spawn.flip);
}
// Inicializa el sprite del jugador
void Player::initSprite(const std::string &png, const std::string &animation)
{
sprite_ = std::make_shared<AnimatedSprite>(png, animation);
sprite_->setWidth(WIDTH_);
sprite_->setHeight(HEIGHT_);
sprite_->setCurrentAnimation("walk");
// sprite_->update();
}

109
source/player.h
View File

@@ -8,7 +8,7 @@
#include "utils.h" // Para color_t
#include "defines.h" // Para BLOCK
#include "room.h"
class AnimatedSprite;
#include "animated_sprite.h"
class Asset;
class Debug;
class Input;
@@ -16,43 +16,55 @@ class Resource;
class Room;
struct JA_Sound_t;
enum state_e
enum class PlayerState
{
s_standing,
s_jumping,
s_falling
STANDING,
JUMPING,
FALLING,
};
struct playerSpawn_t
struct PlayerSpawn
{
float x;
float y;
float vx;
float vy;
int jump_init_pos;
state_e state;
PlayerState state;
SDL_RendererFlip flip;
// Constructor por defecto
PlayerSpawn() : x(0), y(0), vx(0), vy(0), jump_init_pos(0), state(PlayerState::STANDING), flip(SDL_FLIP_NONE) {}
// Constructor
PlayerSpawn(float x, float y, float vx, float vy, int jump_init_pos, PlayerState state, SDL_RendererFlip flip)
: x(x), y(y), vx(vx), vy(vy), jump_init_pos(jump_init_pos), state(state), flip(flip) {}
};
struct player_t
struct PlayerData
{
playerSpawn_t spawn;
std::string png;
PlayerSpawn spawn;
std::shared_ptr< texture;
std::string animation;
std::shared_ptr<Room> room;
// Constructor
PlayerData(PlayerSpawn spawn, std::string png, std::string animation, std::shared_ptr<Room> room)
: spawn(spawn), texture(png), animation(animation), room(room) {}
};
class Player
{
public:
// Constantes
static constexpr int WIDTH_ = 8; // Ancho del jugador
static constexpr int HEIGHT_ = 16; // ALto del jugador
static constexpr int MAX_FALLING_HEIGHT_ = BLOCK * 4; // Altura maxima permitida de caída.
static constexpr float MAX_VY_ = 1.2f; // Velocidad máxima que puede alcanzar al desplazarse en vertical
// Objetos y punteros
SDL_Renderer *renderer_; // El renderizador de la ventana
Input *input_; // Objeto para gestionar la entrada
Resource *resource_; // Objeto con los recursos
Asset *asset_; // Objeto con la ruta a todos los ficheros de recursos
Debug *debug_; // Objeto para gestionar la información de debug
std::shared_ptr<Room> room_; // Objeto encargado de gestionar cada habitación del juego
@@ -63,32 +75,30 @@ public:
float y_; // Posición del jugador en el eje Y
float vx_; // Velocidad/desplazamiento del jugador en el eje X
float vy_; // Velocidad/desplazamiento del jugador en el eje Y
int w_; // Ancho del jugador
int h_; // ALto del jugador
Color color_; // Color del jugador
SDL_Rect collider_box_; // Caja de colisión con los enemigos u objetos
std::vector<SDL_Point> collider_points_; // Puntos de colisión con el mapa
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
state_e state_; // Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
state_e previous_state_; // Estado previo en el que se encontraba el jugador
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
bool auto_movement_; // Indica si esta siendo arrastrado por una superficie automatica
bool is_paused_; // Indica si el jugador esta en modo pausa
PlayerState state_; // Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
PlayerState previous_state_; // Estado previo en el que se encontraba el jugador
bool is_on_border_ = false; // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
bool is_alive_ = true; // Indica si el jugador esta vivo o no
bool is_paused_ = false; // Indica si el jugador esta en modo pausa
bool auto_movement_ = false; // Indica si esta siendo arrastrado por una superficie automatica
int border_ = BORDER_TOP; // Indica en cual de los cuatro bordes se encuentra
SDL_Rect last_position_; // Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento
int jump_init_pos_; // Valor del eje Y en el que se inicia el salto
std::vector<JA_Sound_t *> jumping_sound_; // Vecor con todos los sonidos del salto
std::vector<JA_Sound_t *> falling_sound_; // Vecor con todos los sonidos de la caída
int jumping_counter_; // Cuenta el tiempo de salto
int falling_counter_; // Cuenta el tiempo de caida
bool is_alive_; // Indica si el jugador esta vivo o no
int jumping_counter_ = 0; // Cuenta el tiempo de salto
int falling_counter_ = 0; // Cuenta el tiempo de caida
#ifdef DEBUG
SDL_Rect rx; // Rectangulo de desplazamiento para el modo debug
SDL_Rect ry; // Rectangulo de desplazamiento para el modo debug
Color debugColor; // Color del recuadro de debug del jugador
SDL_Point debugPoint; // Punto para debug
SDL_Rect debug_rect_x_; // Rectangulo de desplazamiento para el modo debug
SDL_Rect debug_rect_y_; // Rectangulo de desplazamiento para el modo debug
Color debug_color_; // Color del recuadro de debug del jugador
SDL_Point debug_point_; // Punto para debug
#endif
// Comprueba las entradas y modifica variables
@@ -100,9 +110,6 @@ public:
// Comprueba el estado del jugador
void checkState();
// Asigna velocidad negativa en el eje Y al jugador
void jump();
// Aplica gravedad al jugador
void applyGravity();
@@ -140,11 +147,23 @@ public:
void updateFeet();
// Cambia el estado del jugador
void setState(state_e value);
void setState(PlayerState value);
// Inicializa los sonidos de salto y caida
void initSounds();
// Coloca el sprite en la posición del jugador
void placeSprite();
// Aplica los valores de spawn al jugador
void applySpawnValues(const PlayerSpawn &spawn);
// Inicializa el sprite del jugador
void initSprite(const std::string &png, const std::string &animation);
public:
// Constructor
Player(player_t player);
Player(PlayerData player);
// Destructor
~Player() = default;
@@ -156,38 +175,38 @@ public:
void update();
// Indica si el jugador esta en uno de los cuatro bordes de la pantalla
bool getOnBorder();
bool getOnBorder() { return is_on_border_; }
// Indica en cual de los cuatro bordes se encuentra
int getBorder();
int getBorder() { return border_; }
// Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
void switchBorders();
// Obtiene el rectangulo que delimita al jugador
SDL_Rect getRect();
SDL_Rect getRect() { return {static_cast<int>(x_), static_cast<int>(y_), WIDTH_, HEIGHT_}; }
// Obtiene el rectangulo de colision del jugador
SDL_Rect &getCollider();
SDL_Rect &getCollider() { return collider_box_; }
// Obtiene algunos parametros del jugador
playerSpawn_t getSpawnParams();
// Obtiene el estado de reaparición del jugador
PlayerSpawn getSpawnParams() { return {x_, y_, vx_, vy_, jump_init_pos_, state_, sprite_->getFlip()}; }
// Recarga la textura
void reLoadTexture();
void reLoadTexture() { sprite_->getTexture()->reLoad(); }
// Recarga la paleta
void reLoadPalette();
// Establece el color del jugador
void setColor();
// Establece el valor de la variable
void setRoom(std::shared_ptr<Room> room);
// Establece la habitación en la que se encuentra el jugador
void setRoom(std::shared_ptr<Room> room) { room_ = room; }
// Comprueba si el jugador esta vivo
bool isAlive();
bool isAlive() { return is_alive_; }
// Pone el jugador en modo pausa
void pause();
void pause() { is_paused_ = true; }
// Quita el modo pausa del jugador
void resume();
void resume() { is_paused_ = false; }
};

2
source/title.cpp
View File

@@ -213,7 +213,7 @@ void Title::renderInfo()
void Title::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks_ > ticks_speed_)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();

1
source/title.h
View File

@@ -48,7 +48,6 @@ private:
int counter_ = 0; // Contador
std::string long_text_; // Texto que aparece en la parte inferior del titulo
Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticks_speed_ = 15; // Velocidad a la que se repiten los bucles del programa
std::vector<letter_t> letters_; // Vector con las letras de la marquesina
int marquee_speed_ = 3; // Velocidad de desplazamiento de la marquesina
bool show_cheevos_ = false; // Indica si se muestra por pantalla el listado de logros