JailDoctor/jdd_opendingux
1
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Issues Pull Requests Projects Releases Wiki Activity

linter

Browse Source
This commit is contained in:
Sergio
2025-10-27 18:35:53 +01:00
parent b1dca32a5b
commit 3179a08dac
63 changed files with 686 additions and 693 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
source/game/gameplay/cheevos.cpp
View File

@@ -1,13 +1,14 @@
#include "game/gameplay/cheevos.hpp"
#include <SDL3/SDL.h>
#include <stddef.h> // Para NULL
#include <cstddef> // Para NULL
#include <fstream> // Para basic_ostream, operator<<, basic_ofstream
#include <iostream> // Para cout, cerr
#include <utility>
#include "game/options.hpp" // Para Options, options
#include "game/ui/notifier.hpp" // Para Notifier
#include "game/options.hpp" // Para Options, options
#include "game/ui/notifier.hpp" // Para Notifier
// [SINGLETON]
Cheevos* Cheevos::cheevos = nullptr;
@@ -23,13 +24,13 @@ void Cheevos::destroy() {
}
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
Cheevos* Cheevos::get() {
auto Cheevos::get() -> Cheevos* {
return Cheevos::cheevos;
}
// Constructor
Cheevos::Cheevos(const std::string& file)
: file_(file) {
Cheevos::Cheevos(std::string file)
: file_(std::move(file)) {
init();
loadFromFile();
}
@@ -57,7 +58,7 @@ void Cheevos::init() {
}
// Busca un logro por id y devuelve el indice
int Cheevos::find(int id) {
auto Cheevos::find(int id) -> int {
for (int i = 0; i < (int)cheevos_list_.size(); ++i) {
if (cheevos_list_[i].id == id) {
return i;
@@ -103,7 +104,7 @@ void Cheevos::loadFromFile() {
// El fichero no existe
if (!file) {
if (Options::console) {
std::cout << "Warning: Unable to open " << file_ << "! Creating new file..." << std::endl;
std::cout << "Warning: Unable to open " << file_ << "! Creating new file..." << '\n';
}
// Crea el fichero en modo escritura (binario)
@@ -111,7 +112,7 @@ void Cheevos::loadFromFile() {
if (new_file) {
if (Options::console) {
std::cout << "New " << file_ << " created!" << std::endl;
std::cout << "New " << file_ << " created!" << '\n';
}
// Guarda la información
@@ -120,14 +121,14 @@ void Cheevos::loadFromFile() {
}
} else {
if (Options::console) {
std::cerr << "Error: Unable to create " << file_ << "!" << std::endl;
std::cerr << "Error: Unable to create " << file_ << "!" << '\n';
}
}
}
// El fichero existe
else {
if (Options::console) {
std::cout << "Reading " << file_ << std::endl;
std::cout << "Reading " << file_ << '\n';
}
// Carga los datos
@@ -143,21 +144,21 @@ void Cheevos::saveToFile() {
SDL_IOStream* file = SDL_IOFromFile(this->file_.c_str(), "w+b");
if (file != nullptr) {
// Guarda la información
for (int i = 0; i < (int)cheevos_list_.size(); ++i) {
SDL_WriteIO(file, &cheevos_list_[i].completed, sizeof(bool));
for (auto& i : cheevos_list_) {
SDL_WriteIO(file, &i.completed, sizeof(bool));
}
// Cierra el fichero
SDL_CloseIO(file);
} else {
if (Options::console) {
std::cout << "Error: Unable to save file! " << SDL_GetError() << std::endl;
std::cout << "Error: Unable to save file! " << SDL_GetError() << '\n';
}
}
}
// Devuelve el número total de logros desbloqueados
int Cheevos::getTotalUnlockedAchievements() {
auto Cheevos::getTotalUnlockedAchievements() -> int {
int count = 0;
for (const auto& cheevo : cheevos_list_) {
if (cheevo.completed) {

19
source/game/gameplay/cheevos.hpp
View File

@@ -1,6 +1,7 @@
#pragma once
#include <string> // Para string
#include <utility>
#include <vector> // Para vector
// Struct para los logros
@@ -20,10 +21,10 @@ struct Achievement {
obtainable(true) {}
// Constructor parametrizado
Achievement(int id, const std::string& caption, const std::string& description, int icon, bool completed = false, bool obtainable = true)
Achievement(int id, std::string caption, std::string description, int icon, bool completed = false, bool obtainable = true)
: id(id),
caption(caption),
description(description),
caption(std::move(caption)),
description(std::move(description)),
icon(icon),
completed(completed),
obtainable(obtainable) {}
@@ -43,7 +44,7 @@ class Cheevos {
void init();
// Busca un logro por id y devuelve el índice
int find(int id);
auto find(int id) -> int;
// Carga el estado de los logros desde un fichero
void loadFromFile();
@@ -52,7 +53,7 @@ class Cheevos {
void saveToFile();
// Constructor
explicit Cheevos(const std::string& file);
explicit Cheevos(std::string file);
// Destructor
~Cheevos();
@@ -65,7 +66,7 @@ class Cheevos {
static void destroy();
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
static Cheevos* get();
static auto get() -> Cheevos*;
// Desbloquea un logro
void unlock(int id);
@@ -80,11 +81,11 @@ class Cheevos {
void enable(bool value) { enabled_ = value; }
// Lista los logros
const std::vector<Achievement>& list() const { return cheevos_list_; }
[[nodiscard]] auto list() const -> const std::vector<Achievement>& { return cheevos_list_; }
// Devuelve el número total de logros desbloqueados
int getTotalUnlockedAchievements();
auto getTotalUnlockedAchievements() -> int;
// Devuelve el número total de logros
int size() { return cheevos_list_.size(); }
auto size() -> int { return cheevos_list_.size(); }
};

8
source/game/gameplay/item_tracker.cpp
View File

@@ -14,12 +14,12 @@ void ItemTracker::destroy() {
}
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
ItemTracker* ItemTracker::get() {
auto ItemTracker::get() -> ItemTracker* {
return ItemTracker::item_tracker;
}
// Comprueba si el objeto ya ha sido cogido
bool ItemTracker::hasBeenPicked(const std::string& name, SDL_FPoint pos) {
auto ItemTracker::hasBeenPicked(const std::string& name, SDL_FPoint pos) -> bool {
// Primero busca si ya hay una entrada con ese nombre
if (const int INDEX = findByName(name); INDEX != -1) {
// Luego busca si existe ya una entrada con esa posición
@@ -47,7 +47,7 @@ void ItemTracker::addItem(const std::string& name, SDL_FPoint pos) {
}
// Busca una entrada en la lista por nombre
int ItemTracker::findByName(const std::string& name) {
auto ItemTracker::findByName(const std::string& name) -> int {
int i = 0;
for (const auto& l : item_list_) {
@@ -61,7 +61,7 @@ int ItemTracker::findByName(const std::string& name) {
}
// Busca una entrada en la lista por posición
int ItemTracker::findByPos(int index, SDL_FPoint pos) {
auto ItemTracker::findByPos(int index, SDL_FPoint pos) -> int {
int i = 0;
for (const auto& l : item_list_[index].pos) {

13
source/game/gameplay/item_tracker.hpp
View File

@@ -3,6 +3,7 @@
#include <SDL3/SDL.h>
#include <string> // Para string, basic_string
#include <utility>
#include <vector> // Para vector
struct ItemTrackerData {
@@ -10,8 +11,8 @@ struct ItemTrackerData {
std::vector<SDL_FPoint> pos; // Lista de objetos cogidos de la habitación
// Constructor
ItemTrackerData(const std::string& name, const SDL_FPoint& position)
: name(name) {
ItemTrackerData(std::string name, const SDL_FPoint& position)
: name(std::move(name)) {
pos.push_back(position);
}
};
@@ -25,10 +26,10 @@ class ItemTracker {
std::vector<ItemTrackerData> item_list_; // Lista con todos los objetos recogidos
// Busca una entrada en la lista por nombre
int findByName(const std::string& name);
auto findByName(const std::string& name) -> int;
// Busca una entrada en la lista por posición
int findByPos(int index, SDL_FPoint pos);
auto findByPos(int index, SDL_FPoint pos) -> int;
// Constructor
ItemTracker() = default;
@@ -44,10 +45,10 @@ class ItemTracker {
static void destroy();
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
static ItemTracker* get();
static auto get() -> ItemTracker*;
// Comprueba si el objeto ya ha sido cogido
bool hasBeenPicked(const std::string& name, SDL_FPoint pos);
auto hasBeenPicked(const std::string& name, SDL_FPoint pos) -> bool;
// Añade el objeto a la lista de objetos cogidos
void addItem(const std::string& name, SDL_FPoint pos);

83
source/game/gameplay/room.cpp
View File

@@ -5,6 +5,7 @@
#include <fstream> // Para basic_ostream, operator<<, basic_istream
#include <iostream> // Para cout, cerr
#include <sstream> // Para basic_stringstream
#include <utility>
#include "core/rendering/screen.hpp" // Para Screen
#include "core/rendering/surface.hpp" // Para Surface
@@ -19,7 +20,7 @@
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
// Carga las variables y texturas desde un fichero de mapa de tiles
std::vector<int> loadRoomTileFile(const std::string& file_path, bool verbose) {
auto loadRoomTileFile(const std::string& file_path, bool verbose) -> std::vector<int> {
std::vector<int> tile_map_file;
const std::string FILENAME = file_path.substr(file_path.find_last_of("\\/") + 1);
std::ifstream file(file_path);
@@ -47,14 +48,14 @@ std::vector<int> loadRoomTileFile(const std::string& file_path, bool verbose) {
// Cierra el fichero
if (verbose) {
std::cout << "TileMap loaded: " << FILENAME.c_str() << std::endl;
std::cout << "TileMap loaded: " << FILENAME.c_str() << '\n';
}
file.close();
}
else { // El fichero no se puede abrir
if (verbose) {
std::cout << "Warning: Unable to open " << FILENAME.c_str() << " file" << std::endl;
std::cout << "Warning: Unable to open " << FILENAME.c_str() << " file" << '\n';
}
}
@@ -62,8 +63,8 @@ std::vector<int> loadRoomTileFile(const std::string& file_path, bool verbose) {
}
// Parsea una línea en key y value separados por '='
std::pair<std::string, std::string> parseKeyValue(const std::string& line) {
int pos = line.find("=");
auto parseKeyValue(const std::string& line) -> std::pair<std::string, std::string> {
int pos = line.find('=');
std::string key = line.substr(0, pos);
std::string value = line.substr(pos + 1, line.length());
return {key, value};
@@ -72,12 +73,12 @@ std::pair<std::string, std::string> parseKeyValue(const std::string& line) {
// Muestra un warning de parámetro desconocido
void logUnknownParameter(const std::string& file_name, const std::string& key, bool verbose) {
if (verbose) {
std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << key.c_str() << "\"" << std::endl;
std::cout << "Warning: file " << file_name.c_str() << "\n, unknown parameter \"" << key.c_str() << "\"" << '\n';
}
}
// Carga un bloque [enemy]...[/enemy] desde un archivo
EnemyData loadEnemyFromFile(std::ifstream& file, const std::string& file_name, bool verbose) {
auto loadEnemyFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> EnemyData {
EnemyData enemy;
enemy.flip = false;
enemy.mirror = false;
@@ -97,7 +98,7 @@ EnemyData loadEnemyFromFile(std::ifstream& file, const std::string& file_name, b
}
// Carga un bloque [item]...[/item] desde un archivo
ItemData loadItemFromFile(std::ifstream& file, const std::string& file_name, bool verbose) {
auto loadItemFromFile(std::ifstream& file, const std::string& file_name, bool verbose) -> ItemData {
ItemData item;
item.counter = 0;
item.color1 = stringToColor("yellow");
@@ -117,14 +118,14 @@ ItemData loadItemFromFile(std::ifstream& file, const std::string& file_name, boo
}
// Carga las variables desde un fichero de mapa
RoomData loadRoomFile(const std::string& file_path, bool verbose) {
auto loadRoomFile(const std::string& file_path, bool verbose) -> RoomData {
RoomData room;
room.item_color1 = "yellow";
room.item_color2 = "magenta";
room.conveyor_belt_direction = 1;
const std::string FILE_NAME = file_path.substr(file_path.find_last_of("\\/") + 1);
room.number = FILE_NAME.substr(0, FILE_NAME.find_last_of("."));
room.number = FILE_NAME.substr(0, FILE_NAME.find_last_of('.'));
std::ifstream file(file_path);
@@ -152,20 +153,20 @@ RoomData loadRoomFile(const std::string& file_path, bool verbose) {
// Cierra el fichero
if (verbose) {
std::cout << "Room loaded: " << FILE_NAME.c_str() << std::endl;
std::cout << "Room loaded: " << FILE_NAME.c_str() << '\n';
}
file.close();
}
// El fichero no se puede abrir
else {
std::cout << "Warning: Unable to open " << FILE_NAME.c_str() << " file" << std::endl;
std::cout << "Warning: Unable to open " << FILE_NAME.c_str() << " file" << '\n';
}
return room;
}
// Asigna variables a una estructura RoomData
bool setRoom(RoomData* room, const std::string& key, const std::string& value) {
auto setRoom(RoomData* room, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
@@ -200,7 +201,7 @@ bool setRoom(RoomData* room, const std::string& key, const std::string& value) {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << std::endl;
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
@@ -208,7 +209,7 @@ bool setRoom(RoomData* room, const std::string& key, const std::string& value) {
}
// Asigna variables a una estructura EnemyData
bool setEnemy(EnemyData* enemy, const std::string& key, const std::string& value) {
auto setEnemy(EnemyData* enemy, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
@@ -251,7 +252,7 @@ bool setEnemy(EnemyData* enemy, const std::string& key, const std::string& value
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << std::endl;
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
@@ -259,7 +260,7 @@ bool setEnemy(EnemyData* enemy, const std::string& key, const std::string& value
}
// Asigna variables a una estructura ItemData
bool setItem(ItemData* item, const std::string& key, const std::string& value) {
auto setItem(ItemData* item, const std::string& key, const std::string& value) -> bool {
// Indicador de éxito en la asignación
bool success = true;
@@ -280,7 +281,7 @@ bool setItem(ItemData* item, const std::string& key, const std::string& value) {
success = false;
}
} catch (const std::exception& e) {
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << std::endl;
std::cerr << "Error al asignar la clave " << key << " con valor " << value << ": " << e.what() << '\n';
success = false;
}
@@ -289,7 +290,7 @@ bool setItem(ItemData* item, const std::string& key, const std::string& value) {
// Constructor
Room::Room(const std::string& room_path, std::shared_ptr<ScoreboardData> data)
: data_(data) {
: data_(std::move(std::move(data))) {
auto room = Resource::get()->getRoom(room_path);
initializeRoom(*room);
@@ -482,19 +483,19 @@ void Room::update() {
// Actualiza los tiles animados
updateAnimatedTiles();
for (auto enemy : enemies_) {
for (const auto& enemy : enemies_) {
// Actualiza los enemigos
enemy->update();
}
for (auto item : items_) {
for (const auto& item : items_) {
// Actualiza los items
item->update();
}
}
// Devuelve la cadena del fichero de la habitación contigua segun el borde
std::string Room::getRoom(RoomBorder border) {
auto Room::getRoom(RoomBorder border) -> std::string {
switch (border) {
case RoomBorder::TOP:
return upper_room_;
@@ -519,13 +520,13 @@ std::string Room::getRoom(RoomBorder border) {
}
// Devuelve el tipo de tile que hay en ese pixel
TileType Room::getTile(SDL_FPoint point) {
auto Room::getTile(SDL_FPoint point) -> TileType {
const int POS = ((point.y / TILE_SIZE) * MAP_WIDTH) + (point.x / TILE_SIZE);
return getTile(POS);
}
// Devuelve el tipo de tile que hay en ese indice
TileType Room::getTile(int index) {
auto Room::getTile(int index) -> TileType {
// const bool onRange = (index > -1) && (index < mapWidth * mapHeight);
const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size());
@@ -565,14 +566,14 @@ TileType Room::getTile(int index) {
}
// Indica si hay colision con un enemigo a partir de un rectangulo
bool Room::enemyCollision(SDL_FRect& rect) {
auto Room::enemyCollision(SDL_FRect& rect) -> bool {
return std::ranges::any_of(enemies_, [&rect](const auto& enemy) {
return checkCollision(rect, enemy->getCollider());
});
}
// Indica si hay colision con un objeto a partir de un rectangulo
bool Room::itemCollision(SDL_FRect& rect) {
auto Room::itemCollision(SDL_FRect& rect) -> bool {
for (int i = 0; i < static_cast<int>(items_.size()); ++i) {
if (checkCollision(rect, items_.at(i)->getCollider())) {
ItemTracker::get()->addItem(name_, items_.at(i)->getPos());
@@ -588,7 +589,7 @@ bool Room::itemCollision(SDL_FRect& rect) {
}
// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
int Room::getSlopeHeight(SDL_FPoint p, TileType slope) {
auto Room::getSlopeHeight(SDL_FPoint p, TileType slope) -> int {
// Calcula la base del tile
int base = ((p.y / TILE_SIZE) * TILE_SIZE) + TILE_SIZE;
#ifdef _DEBUG
@@ -618,7 +619,7 @@ int Room::getSlopeHeight(SDL_FPoint p, TileType slope) {
}
// Helper: recopila tiles inferiores (muros sin muro debajo)
std::vector<int> Room::collectBottomTiles() {
auto Room::collectBottomTiles() -> std::vector<int> {
std::vector<int> tile;
// Busca todos los tiles de tipo muro que no tengan debajo otro muro
@@ -640,7 +641,7 @@ std::vector<int> Room::collectBottomTiles() {
}
// Helper: recopila tiles superiores (muros o pasables sin muro encima)
std::vector<int> Room::collectTopTiles() {
auto Room::collectTopTiles() -> std::vector<int> {
std::vector<int> tile;
// Busca todos los tiles de tipo muro o pasable que no tengan encima un muro
@@ -867,7 +868,7 @@ void Room::setRightSlopes() {
// Calcula las superficies automaticas
// Helper: recopila tiles animados (para superficies automaticas/conveyor belts)
std::vector<int> Room::collectAnimatedTiles() {
auto Room::collectAnimatedTiles() -> std::vector<int> {
std::vector<int> tile;
// Busca todos los tiles de tipo animado
@@ -943,7 +944,7 @@ void Room::renderAnimatedTiles() {
}
// Comprueba las colisiones
int Room::checkRightSurfaces(SDL_FRect* rect) {
auto Room::checkRightSurfaces(SDL_FRect* rect) -> int {
for (const auto& s : right_walls_) {
if (checkCollision(s, *rect)) {
return s.x;
@@ -954,7 +955,7 @@ int Room::checkRightSurfaces(SDL_FRect* rect) {
}
// Comprueba las colisiones
int Room::checkLeftSurfaces(SDL_FRect* rect) {
auto Room::checkLeftSurfaces(SDL_FRect* rect) -> int {
for (const auto& s : left_walls_) {
if (checkCollision(s, *rect)) {
return s.x;
@@ -965,7 +966,7 @@ int Room::checkLeftSurfaces(SDL_FRect* rect) {
}
// Comprueba las colisiones
int Room::checkTopSurfaces(SDL_FRect* rect) {
auto Room::checkTopSurfaces(SDL_FRect* rect) -> int {
for (const auto& s : top_floors_) {
if (checkCollision(s, *rect)) {
return s.y;
@@ -976,7 +977,7 @@ int Room::checkTopSurfaces(SDL_FRect* rect) {
}
// Comprueba las colisiones
int Room::checkBottomSurfaces(SDL_FRect* rect) {
auto Room::checkBottomSurfaces(SDL_FRect* rect) -> int {
for (const auto& s : bottom_floors_) {
if (checkCollision(s, *rect)) {
return s.y;
@@ -987,7 +988,7 @@ int Room::checkBottomSurfaces(SDL_FRect* rect) {
}
// Comprueba las colisiones
int Room::checkAutoSurfaces(SDL_FRect* rect) {
auto Room::checkAutoSurfaces(SDL_FRect* rect) -> int {
for (const auto& s : conveyor_belt_floors_) {
if (checkCollision(s, *rect)) {
return s.y;
@@ -998,21 +999,21 @@ int Room::checkAutoSurfaces(SDL_FRect* rect) {
}
// Comprueba las colisiones
bool Room::checkTopSurfaces(SDL_FPoint* p) {
auto Room::checkTopSurfaces(SDL_FPoint* p) -> bool {
return std::ranges::any_of(top_floors_, [&](const auto& s) {
return checkCollision(s, *p);
});
}
// Comprueba las colisiones
bool Room::checkAutoSurfaces(SDL_FPoint* p) {
auto Room::checkAutoSurfaces(SDL_FPoint* p) -> bool {
return std::ranges::any_of(conveyor_belt_floors_, [&](const auto& s) {
return checkCollision(s, *p);
});
}
// Comprueba las colisiones
int Room::checkLeftSlopes(const LineVertical* line) {
auto Room::checkLeftSlopes(const LineVertical* line) -> int {
for (const auto& slope : left_slopes_) {
const auto P = checkCollision(slope, *line);
if (P.x != -1) {
@@ -1024,14 +1025,14 @@ int Room::checkLeftSlopes(const LineVertical* line) {
}
// Comprueba las colisiones
bool Room::checkLeftSlopes(SDL_FPoint* p) {
auto Room::checkLeftSlopes(SDL_FPoint* p) -> bool {
return std::ranges::any_of(left_slopes_, [&](const auto& slope) {
return checkCollision(*p, slope);
});
}
// Comprueba las colisiones
int Room::checkRightSlopes(const LineVertical* line) {
auto Room::checkRightSlopes(const LineVertical* line) -> int {
for (const auto& slope : right_slopes_) {
const auto P = checkCollision(slope, *line);
if (P.x != -1) {
@@ -1043,7 +1044,7 @@ int Room::checkRightSlopes(const LineVertical* line) {
}
// Comprueba las colisiones
bool Room::checkRightSlopes(SDL_FPoint* p) {
auto Room::checkRightSlopes(SDL_FPoint* p) -> bool {
return std::ranges::any_of(right_slopes_, [&](const auto& slope) {
return checkCollision(*p, slope);
});

60
source/game/gameplay/room.hpp
View File

@@ -55,19 +55,19 @@ struct RoomData {
};
// Carga las variables desde un fichero de mapa
RoomData loadRoomFile(const std::string& file_path, bool verbose = false);
auto loadRoomFile(const std::string& file_path, bool verbose = false) -> RoomData;
// Carga las variables y texturas desde un fichero de mapa de tiles
std::vector<int> loadRoomTileFile(const std::string& file_path, bool verbose = false);
auto loadRoomTileFile(const std::string& file_path, bool verbose = false) -> std::vector<int>;
// Asigna variables a una estructura RoomData
bool setRoom(RoomData* room, const std::string& key, const std::string& value);
auto setRoom(RoomData* room, const std::string& key, const std::string& value) -> bool;
// Asigna variables a una estructura EnemyData
bool setEnemy(EnemyData* enemy, const std::string& key, const std::string& value);
auto setEnemy(EnemyData* enemy, const std::string& key, const std::string& value) -> bool;
// Asigna variables a una estructura ItemData
bool setItem(ItemData* item, const std::string& key, const std::string& value);
auto setItem(ItemData* item, const std::string& key, const std::string& value) -> bool;
class Room {
private:
@@ -116,13 +116,13 @@ class Room {
void fillMapTexture();
// Helper para recopilar tiles inferiores
std::vector<int> collectBottomTiles();
auto collectBottomTiles() -> std::vector<int>;
// Helper para recopilar tiles superiores
std::vector<int> collectTopTiles();
auto collectTopTiles() -> std::vector<int>;
// Helper para recopilar tiles animados (para superficies automaticas)
std::vector<int> collectAnimatedTiles();
auto collectAnimatedTiles() -> std::vector<int>;
// Helper para construir lineas horizontales a partir de tiles consecutivos
static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface);
@@ -158,7 +158,7 @@ class Room {
void renderAnimatedTiles();
// Devuelve el tipo de tile que hay en ese indice
TileType getTile(int index);
auto getTile(int index) -> TileType;
// Abre la jail para poder entrar
void openTheJail();
@@ -174,13 +174,13 @@ class Room {
~Room() = default;
// Devuelve el nombre de la habitación
const std::string& getName() const { return name_; }
[[nodiscard]] auto getName() const -> const std::string& { return name_; }
// Devuelve el color de la habitación
Uint8 getBGColor() const { return stringToColor(bg_color_); }
[[nodiscard]] auto getBGColor() const -> Uint8 { return stringToColor(bg_color_); }
// Devuelve el color del borde
Uint8 getBorderColor() const { return stringToColor(border_color_); }
[[nodiscard]] auto getBorderColor() const -> Uint8 { return stringToColor(border_color_); }
// Dibuja el mapa en pantalla
void renderMap();
@@ -195,59 +195,59 @@ class Room {
void update();
// Devuelve la cadena del fichero de la habitación contigua segun el borde
std::string getRoom(RoomBorder border);
auto getRoom(RoomBorder border) -> std::string;
// Devuelve el tipo de tile que hay en ese pixel
TileType getTile(SDL_FPoint point);
auto getTile(SDL_FPoint point) -> TileType;
// Indica si hay colision con un enemigo a partir de un rectangulo
bool enemyCollision(SDL_FRect& rect);
auto enemyCollision(SDL_FRect& rect) -> bool;
// Indica si hay colision con un objeto a partir de un rectangulo
bool itemCollision(SDL_FRect& rect);
auto itemCollision(SDL_FRect& rect) -> bool;
// Obten el tamaño del tile
static int getTileSize() { return TILE_SIZE; }
static auto getTileSize() -> int { return TILE_SIZE; }
// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
static int getSlopeHeight(SDL_FPoint p, TileType slope);
static auto getSlopeHeight(SDL_FPoint p, TileType slope) -> int;
// Comprueba las colisiones
int checkRightSurfaces(SDL_FRect* rect);
auto checkRightSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
int checkLeftSurfaces(SDL_FRect* rect);
auto checkLeftSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
int checkTopSurfaces(SDL_FRect* rect);
auto checkTopSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
int checkBottomSurfaces(SDL_FRect* rect);
auto checkBottomSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
int checkAutoSurfaces(SDL_FRect* rect);
auto checkAutoSurfaces(SDL_FRect* rect) -> int;
// Comprueba las colisiones
bool checkTopSurfaces(SDL_FPoint* p);
auto checkTopSurfaces(SDL_FPoint* p) -> bool;
// Comprueba las colisiones
bool checkAutoSurfaces(SDL_FPoint* p);
auto checkAutoSurfaces(SDL_FPoint* p) -> bool;
// Comprueba las colisiones
int checkLeftSlopes(const LineVertical* line);
auto checkLeftSlopes(const LineVertical* line) -> int;
// Comprueba las colisiones
bool checkLeftSlopes(SDL_FPoint* p);
auto checkLeftSlopes(SDL_FPoint* p) -> bool;
// Comprueba las colisiones
int checkRightSlopes(const LineVertical* line);
auto checkRightSlopes(const LineVertical* line) -> int;
// Comprueba las colisiones
bool checkRightSlopes(SDL_FPoint* p);
auto checkRightSlopes(SDL_FPoint* p) -> bool;
// Pone el mapa en modo pausa
void setPaused(bool value) { is_paused_ = value; };
// Obten la direccion de las superficies automaticas
int getAutoSurfaceDirection() const { return conveyor_belt_direction_; }
[[nodiscard]] auto getAutoSurfaceDirection() const -> int { return conveyor_belt_direction_; }
};

4
source/game/gameplay/room_tracker.cpp
View File

@@ -3,12 +3,12 @@
#include <algorithm> // Para std::ranges::any_of
// Comprueba si la habitación ya ha sido visitada
bool RoomTracker::hasBeenVisited(const std::string& name) {
auto RoomTracker::hasBeenVisited(const std::string& name) -> bool {
return std::ranges::any_of(list_, [&name](const auto& l) { return l == name; });
}
// Añade la habitación a la lista
bool RoomTracker::addRoom(const std::string& name) {
auto RoomTracker::addRoom(const std::string& name) -> bool {
// Comprueba si la habitación ya ha sido visitada
if (!hasBeenVisited(name)) {
// En caso contrario añádela a la lista

4
source/game/gameplay/room_tracker.hpp
View File

@@ -9,7 +9,7 @@ class RoomTracker {
std::vector<std::string> list_; // Lista con las habitaciones visitadas
// Comprueba si la habitación ya ha sido visitada
bool hasBeenVisited(const std::string& name);
auto hasBeenVisited(const std::string& name) -> bool;
public:
// Constructor
@@ -19,5 +19,5 @@ class RoomTracker {
~RoomTracker() = default;
// Añade la habitación a la lista
bool addRoom(const std::string& name);
auto addRoom(const std::string& name) -> bool;
};

10
source/game/gameplay/scoreboard.cpp
View File

@@ -2,6 +2,8 @@
#include <SDL3/SDL.h>
#include <utility>
#include "core/rendering/screen.hpp" // Para Screen
#include "core/rendering/surface.hpp" // Para Surface
#include "core/rendering/surface_animated_sprite.hpp" // Para SAnimatedSprite
@@ -14,7 +16,7 @@
// Constructor
Scoreboard::Scoreboard(std::shared_ptr<ScoreboardData> data)
: item_surface_(Resource::get()->getSurface("items.gif")),
data_(data) {
data_(std::move(std::move(data))) {
const float SURFACE_WIDTH = Options::game.width;
constexpr float SURFACE_HEIGHT = 6.0F * BLOCK;
@@ -25,7 +27,7 @@ Scoreboard::Scoreboard(std::shared_ptr<ScoreboardData> data)
player_sprite_->setCurrentAnimation("walk_menu");
surface_ = std::make_shared<Surface>(SURFACE_WIDTH, SURFACE_HEIGHT);
surface_dest_ = {0, Options::game.height - SURFACE_HEIGHT, SURFACE_WIDTH, SURFACE_HEIGHT};
surface_dest_ = {.x = 0, .y = Options::game.height - SURFACE_HEIGHT, .w = SURFACE_WIDTH, .h = SURFACE_HEIGHT};
// Inicializa las variables
counter_ = 0;
@@ -65,7 +67,7 @@ void Scoreboard::update() {
}
// Obtiene el tiempo transcurrido de partida
Scoreboard::ClockData Scoreboard::getTime() {
auto Scoreboard::getTime() -> Scoreboard::ClockData {
const Uint32 TIME_ELAPSED = SDL_GetTicks() - data_->ini_clock - paused_time_elapsed_;
ClockData time;
@@ -109,7 +111,7 @@ void Scoreboard::updateItemsColor() {
}
// Devuelve la cantidad de minutos de juego transcurridos
int Scoreboard::getMinutes() {
auto Scoreboard::getMinutes() -> int {
return getTime().minutes;
}

9
source/game/gameplay/scoreboard.hpp
View File

@@ -4,6 +4,7 @@
#include <memory> // Para shared_ptr
#include <string> // Para string, basic_string
#include <utility>
#include <vector> // Para vector
class SurfaceAnimatedSprite; // lines 10-10
class Surface; // lines 11-11
@@ -54,11 +55,11 @@ class Scoreboard {
separator(":") {}
// Constructor parametrizado
ClockData(int h, int m, int s, const std::string& sep)
ClockData(int h, int m, int s, std::string sep)
: hours(h),
minutes(m),
seconds(s),
separator(sep) {}
separator(std::move(sep)) {}
};
// Objetos y punteros
@@ -79,7 +80,7 @@ class Scoreboard {
SDL_FRect surface_dest_; // Rectangulo donde dibujar la surface del marcador
// Obtiene el tiempo transcurrido de partida
ClockData getTime();
auto getTime() -> ClockData;
// Actualiza el color de la cantidad de items recogidos
void updateItemsColor();
@@ -104,5 +105,5 @@ class Scoreboard {
void setPaused(bool value);
// Devuelve la cantidad de minutos de juego transcurridos
int getMinutes();
auto getMinutes() -> int;
};

15
source/game/gameplay/stats.cpp
View File

@@ -2,13 +2,14 @@
#include <fstream> // Para basic_ostream, basic_ifstream, basic_istream
#include <sstream> // Para basic_stringstream
#include <utility>
#include "game/options.hpp" // Para Options, OptionsStats, options
// Constructor
Stats::Stats(const std::string& file, const std::string& buffer)
: buffer_path_(buffer),
file_path_(file) {}
Stats::Stats(std::string file, std::string buffer)
: buffer_path_(std::move(buffer)),
file_path_(std::move(file)) {}
// Destructor
Stats::~Stats() {
@@ -75,7 +76,7 @@ void Stats::addVisit(const std::string& name) {
}
// Busca una entrada en la lista por nombre
int Stats::findByName(const std::string& name, const std::vector<StatsData>& list) {
auto Stats::findByName(const std::string& name, const std::vector<StatsData>& list) -> int {
int i = 0;
for (const auto& l : list) {
@@ -89,7 +90,7 @@ int Stats::findByName(const std::string& name, const std::vector<StatsData>& lis
}
// Carga las estadisticas desde un fichero
bool Stats::loadFromFile(const std::string& file_path, std::vector<StatsData>& list) {
auto Stats::loadFromFile(const std::string& file_path, std::vector<StatsData>& list) -> bool {
list.clear();
// Indicador de éxito en la carga
@@ -144,9 +145,9 @@ void Stats::saveToFile(const std::string& file_path, const std::vector<StatsData
std::ofstream file(file_path);
// Escribe en el fichero
file << "# ROOM NAME;VISITS;DEATHS" << std::endl;
file << "# ROOM NAME;VISITS;DEATHS" << '\n';
for (const auto& item : list) {
file << item.name << ";" << item.visited << ";" << item.died << std::endl;
file << item.name << ";" << item.visited << ";" << item.died << '\n';
}
// Cierra el fichero

10
source/game/gameplay/stats.hpp
View File

@@ -24,10 +24,10 @@ class Stats {
std::string file_path_; // Fichero con las estadísticas completas
// Busca una entrada en la lista por nombre
static int findByName(const std::string& name, const std::vector<StatsData>& list);
static auto findByName(const std::string& name, const std::vector<StatsData>& list) -> int;
// Carga las estadisticas desde un fichero
static bool loadFromFile(const std::string& file_path, std::vector<StatsData>& list);
static auto loadFromFile(const std::string& file_path, std::vector<StatsData>& list) -> bool;
// Guarda las estadisticas en un fichero
static void saveToFile(const std::string& file_path, const std::vector<StatsData>& list);
@@ -39,9 +39,9 @@ class Stats {
void updateListFromBuffer();
public:
// Constructor
Stats(const std::string& file, const std::string& buffer);
// Constructostd::string nst stdstd::string nst std::string& buffer);
Stats(std::string file, std::string buffer);
// Destructor
~Stats();