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

linter

Browse Source
This commit is contained in:
Sergio
2025-10-27 18:56:24 +01:00
parent 3179a08dac
commit 5f47c88770
8 changed files with 121 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/core/input/input.cpp
View File

@@ -28,7 +28,7 @@ auto Input::get() -> Input* {
// Constructor
Input::Input(const std::string& game_controller_db_path)
: game_controller_db_path_(std::move(game_controller_db_path)) {
: game_controller_db_path_(game_controller_db_path) {
// Busca si hay mandos conectados
discoverGameControllers();

30
source/core/rendering/screen.cpp
View File

@@ -1,9 +1,9 @@
#include "core/rendering/screen.hpp"
#include <SDL3/SDL.h>
#include <ctype.h> // Para toupper
#include <algorithm> // Para max, min, transform
#include <cctype> // Para toupper
#include <fstream> // Para basic_ostream, operator<<, endl, basic_...
#include <iostream> // Para cerr
#include <iterator> // Para istreambuf_iterator, operator==
@@ -15,7 +15,7 @@
#include "core/rendering/text.hpp" // Para Text
#include "core/resources/asset.hpp" // Para Asset, AssetType
#include "core/resources/resource.hpp" // Para Resource
#include "game/options.hpp" // Para Options, options, OptionsVideo, Border
#include "game/options.hpp" // Para Options, options, OptionsVideo, Border
#include "game/ui/notifier.hpp" // Para Notifier
// [SINGLETON]
@@ -32,7 +32,7 @@ void Screen::destroy() {
}
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
Screen* Screen::get() {
auto Screen::get() -> Screen* {
return Screen::screen;
}
@@ -43,7 +43,7 @@ Screen::Screen()
initSDLVideo();
// Ajusta los tamaños
game_surface_dstrect_ = {Options::video.border.width, Options::video.border.height, Options::game.width, Options::game.height};
game_surface_dstrect_ = {.x = Options::video.border.width, .y = Options::video.border.height, .w = Options::game.width, .h = Options::game.height};
// adjustWindowSize();
current_palette_ = findPalette(Options::video.palette);
@@ -55,7 +55,7 @@ Screen::Screen()
if (game_texture_ == nullptr) {
// Registrar el error si está habilitado
if (Options::console) {
std::cerr << "Error: game_texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
std::cerr << "Error: game_texture_ could not be created!\nSDL Error: " << SDL_GetError() << '\n';
}
}
SDL_SetTextureScaleMode(game_texture_, SDL_SCALEMODE_NEAREST);
@@ -65,7 +65,7 @@ Screen::Screen()
if (border_texture_ == nullptr) {
// Registrar el error si está habilitado
if (Options::console) {
std::cerr << "Error: border_texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
std::cerr << "Error: border_texture_ could not be created!\nSDL Error: " << SDL_GetError() << '\n';
}
}
SDL_SetTextureScaleMode(border_texture_, SDL_SCALEMODE_NEAREST);
@@ -142,7 +142,7 @@ void Screen::toggleVideoMode() {
}
// Reduce el tamaño de la ventana
bool Screen::decWindowZoom() {
auto Screen::decWindowZoom() -> bool {
if (static_cast<int>(Options::video.fullscreen) == 0) {
const int PREVIOUS_ZOOM = Options::window.zoom;
--Options::window.zoom;
@@ -158,7 +158,7 @@ bool Screen::decWindowZoom() {
}
// Aumenta el tamaño de la ventana
bool Screen::incWindowZoom() {
auto Screen::incWindowZoom() -> bool {
if (static_cast<int>(Options::video.fullscreen) == 0) {
const int PREVIOUS_ZOOM = Options::window.zoom;
++Options::window.zoom;
@@ -235,7 +235,7 @@ void Screen::adjustRenderLogicalSize() {
}
// Establece el renderizador para las surfaces
void Screen::setRendererSurface(std::shared_ptr<Surface> surface) {
void Screen::setRendererSurface(const std::shared_ptr<Surface> &surface) {
(surface) ? renderer_surface_ = std::make_shared<std::shared_ptr<Surface>>(surface) : renderer_surface_ = std::make_shared<std::shared_ptr<Surface>>(game_surface_);
}
@@ -274,7 +274,7 @@ void Screen::setPalete() {
}
// Convertir a mayúsculas
std::transform(Options::video.palette.begin(), Options::video.palette.end(), Options::video.palette.begin(), ::toupper);
std::ranges::transform(Options::video.palette, Options::video.palette.begin(), ::toupper);
}
// Extrae los nombres de las paletas
@@ -316,7 +316,7 @@ void Screen::renderOverlays() {
}
// Localiza la paleta dentro del vector de paletas
size_t Screen::findPalette(const std::string& name) {
auto Screen::findPalette(const std::string& name) -> size_t {
std::string upper_name = toUpper(name + ".pal");
for (size_t i = 0; i < palettes_.size(); ++i) {
@@ -373,11 +373,11 @@ void Screen::toggleIntegerScale() {
}
// Getters
SDL_Renderer* Screen::getRenderer() { return renderer_; }
std::shared_ptr<Surface> Screen::getRendererSurface() { return (*renderer_surface_); }
std::shared_ptr<Surface> Screen::getBorderSurface() { return border_surface_; }
auto Screen::getRenderer() -> SDL_Renderer* { return renderer_; }
auto Screen::getRendererSurface() -> std::shared_ptr<Surface> { return (*renderer_surface_); }
auto Screen::getBorderSurface() -> std::shared_ptr<Surface> { return border_surface_; }
std::vector<uint8_t> loadData(const std::string& filepath) {
auto loadData(const std::string& filepath) -> std::vector<uint8_t> {
// Fallback a filesystem
std::ifstream file(filepath, std::ios::binary | std::ios::ate);
if (!file) {

4
source/core/rendering/screen.hpp
View File

@@ -39,7 +39,7 @@ class Screen {
// Constructor para inicializar la estructura.
FPS()
{}
= default;
// Incrementador que se llama en cada frame.
void increment() {
@@ -192,7 +192,7 @@ class Screen {
void hide();
// Establece el renderizador para las surfaces
void setRendererSurface(std::shared_ptr<Surface> surface = nullptr);
void setRendererSurface(const std::shared_ptr<Surface> &surface = nullptr);
// Cambia la paleta
void nextPalette();

2
source/core/rendering/surface_animated_sprite.hpp
View File

@@ -21,7 +21,7 @@ struct AnimationData {
AnimationData()
{}
= default;
};
using Animations = std::vector<std::string>;

111
source/core/resources/resource.cpp
View File

@@ -1,18 +1,19 @@
#include "core/resources/resource.hpp"
#include <SDL3/SDL.h>
#include <stdlib.h> // Para exit, size_t
#include <algorithm> // Para find_if
#include <cstdlib> // Para exit, size_t
#include <iostream> // Para basic_ostream, operator<<, endl, cout
#include <stdexcept> // Para runtime_error
#include <utility>
#include "core/rendering/screen.hpp" // Para Screen
#include "core/rendering/text.hpp" // Para Text, loadTextFile
#include "core/resources/asset.hpp" // Para AssetType, Asset
#include "external/jail_audio.h" // Para JA_DeleteMusic, JA_DeleteSound, JA_Loa...
#include "game/options.hpp" // Para Options, OptionsGame, options
#include "game/gameplay/room.hpp" // Para RoomData, loadRoomFile, loadRoomTileFile
#include "game/options.hpp" // Para Options, OptionsGame, options
#include "utils/utils.hpp" // Para getFileName, printWithDots, PaletteColor
struct JA_Music_t; // lines 17-17
struct JA_Sound_t; // lines 18-18
@@ -27,7 +28,7 @@ void Resource::init() { Resource::resource = new Resource(); }
void Resource::destroy() { delete Resource::resource; }
// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
Resource* Resource::get() { return Resource::resource; }
auto Resource::get() -> Resource* { return Resource::resource; }
// Constructor
Resource::Resource() { load(); }
@@ -47,7 +48,7 @@ void Resource::clear() {
void Resource::load() {
calculateTotal();
Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK));
std::cout << "** LOADING RESOURCES" << std::endl;
std::cout << "** LOADING RESOURCES" << '\n';
loadSounds();
loadMusics();
loadSurfaces();
@@ -57,7 +58,7 @@ void Resource::load() {
loadTileMaps();
loadRooms();
createText();
std::cout << "\n** RESOURCES LOADED" << std::endl;
std::cout << "\n** RESOURCES LOADED" << '\n';
}
// Recarga todos los recursos
@@ -67,127 +68,127 @@ void Resource::reload() {
}
// Obtiene el sonido a partir de un nombre
JA_Sound_t* Resource::getSound(const std::string& name) {
auto it = std::find_if(sounds_.begin(), sounds_.end(), [&name](const auto& s) { return s.name == name; });
auto Resource::getSound(const std::string& name) -> JA_Sound_t* {
auto it = std::ranges::find_if(sounds_, [&name](const auto& s) { return s.name == name; });
if (it != sounds_.end()) {
return it->sound;
}
std::cerr << "Error: Sonido no encontrado " << name << std::endl;
std::cerr << "Error: Sonido no encontrado " << name << '\n';
throw std::runtime_error("Sonido no encontrado: " + name);
}
// Obtiene la música a partir de un nombre
JA_Music_t* Resource::getMusic(const std::string& name) {
auto it = std::find_if(musics_.begin(), musics_.end(), [&name](const auto& m) { return m.name == name; });
auto Resource::getMusic(const std::string& name) -> JA_Music_t* {
auto it = std::ranges::find_if(musics_, [&name](const auto& m) { return m.name == name; });
if (it != musics_.end()) {
return it->music;
}
std::cerr << "Error: Música no encontrada " << name << std::endl;
std::cerr << "Error: Música no encontrada " << name << '\n';
throw std::runtime_error("Música no encontrada: " + name);
}
// Obtiene la surface a partir de un nombre
std::shared_ptr<Surface> Resource::getSurface(const std::string& name) {
auto it = std::find_if(surfaces_.begin(), surfaces_.end(), [&name](const auto& t) { return t.name == name; });
auto Resource::getSurface(const std::string& name) -> std::shared_ptr<Surface> {
auto it = std::ranges::find_if(surfaces_, [&name](const auto& t) { return t.name == name; });
if (it != surfaces_.end()) {
return it->surface;
}
std::cerr << "Error: Imagen no encontrada " << name << std::endl;
std::cerr << "Error: Imagen no encontrada " << name << '\n';
throw std::runtime_error("Imagen no encontrada: " + name);
}
// Obtiene la paleta a partir de un nombre
Palette Resource::getPalette(const std::string& name) {
auto it = std::find_if(palettes_.begin(), palettes_.end(), [&name](const auto& t) { return t.name == name; });
auto Resource::getPalette(const std::string& name) -> Palette {
auto it = std::ranges::find_if(palettes_, [&name](const auto& t) { return t.name == name; });
if (it != palettes_.end()) {
return it->palette;
}
std::cerr << "Error: Paleta no encontrada " << name << std::endl;
std::cerr << "Error: Paleta no encontrada " << name << '\n';
throw std::runtime_error("Paleta no encontrada: " + name);
}
// Obtiene el fichero de texto a partir de un nombre
std::shared_ptr<TextFile> Resource::getTextFile(const std::string& name) {
auto it = std::find_if(text_files_.begin(), text_files_.end(), [&name](const auto& t) { return t.name == name; });
auto Resource::getTextFile(const std::string& name) -> std::shared_ptr<TextFile> {
auto it = std::ranges::find_if(text_files_, [&name](const auto& t) { return t.name == name; });
if (it != text_files_.end()) {
return it->text_file;
}
std::cerr << "Error: TextFile no encontrado " << name << std::endl;
std::cerr << "Error: TextFile no encontrado " << name << '\n';
throw std::runtime_error("TextFile no encontrado: " + name);
}
// Obtiene el objeto de texto a partir de un nombre
std::shared_ptr<Text> Resource::getText(const std::string& name) {
auto it = std::find_if(texts_.begin(), texts_.end(), [&name](const auto& t) { return t.name == name; });
auto Resource::getText(const std::string& name) -> std::shared_ptr<Text> {
auto it = std::ranges::find_if(texts_, [&name](const auto& t) { return t.name == name; });
if (it != texts_.end()) {
return it->text;
}
std::cerr << "Error: Text no encontrado " << name << std::endl;
std::cerr << "Error: Text no encontrado " << name << '\n';
throw std::runtime_error("Texto no encontrado: " + name);
}
// Obtiene la animación a partir de un nombre
Animations& Resource::getAnimations(const std::string& name) {
auto it = std::find_if(animations_.begin(), animations_.end(), [&name](const auto& a) { return a.name == name; });
auto Resource::getAnimations(const std::string& name) -> Animations& {
auto it = std::ranges::find_if(animations_, [&name](const auto& a) { return a.name == name; });
if (it != animations_.end()) {
return it->animation;
}
std::cerr << "Error: Animación no encontrada " << name << std::endl;
std::cerr << "Error: Animación no encontrada " << name << '\n';
throw std::runtime_error("Animación no encontrada: " + name);
}
// Obtiene el mapa de tiles a partir de un nombre
std::vector<int>& Resource::getTileMap(const std::string& name) {
auto it = std::find_if(tile_maps_.begin(), tile_maps_.end(), [&name](const auto& t) { return t.name == name; });
auto Resource::getTileMap(const std::string& name) -> std::vector<int>& {
auto it = std::ranges::find_if(tile_maps_, [&name](const auto& t) { return t.name == name; });
if (it != tile_maps_.end()) {
return it->tile_map;
}
std::cerr << "Error: Mapa de tiles no encontrado " << name << std::endl;
std::cerr << "Error: Mapa de tiles no encontrado " << name << '\n';
throw std::runtime_error("Mapa de tiles no encontrado: " + name);
}
// Obtiene la habitación a partir de un nombre
std::shared_ptr<RoomData> Resource::getRoom(const std::string& name) {
auto it = std::find_if(rooms_.begin(), rooms_.end(), [&name](const auto& r) { return r.name == name; });
auto Resource::getRoom(const std::string& name) -> std::shared_ptr<RoomData> {
auto it = std::ranges::find_if(rooms_, [&name](const auto& r) { return r.name == name; });
if (it != rooms_.end()) {
return it->room;
}
std::cerr << "Error: Habitación no encontrada " << name << std::endl;
std::cerr << "Error: Habitación no encontrada " << name << '\n';
throw std::runtime_error("Habitación no encontrada: " + name);
}
// Obtiene todas las habitaciones
std::vector<ResourceRoom>& Resource::getRooms() {
auto Resource::getRooms() -> std::vector<ResourceRoom>& {
return rooms_;
}
// Carga los sonidos
void Resource::loadSounds() {
std::cout << "\n>> SOUND FILES" << std::endl;
std::cout << "\n>> SOUND FILES" << '\n';
auto list = Asset::get()->getListByType(AssetType::SOUND);
sounds_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
sounds_.emplace_back(ResourceSound(name, JA_LoadSound(l.c_str())));
sounds_.emplace_back(name, JA_LoadSound(l.c_str()));
printWithDots("Sound : ", name, "[ LOADED ]");
updateLoadingProgress();
}
@@ -195,13 +196,13 @@ void Resource::loadSounds() {
// Carga las musicas
void Resource::loadMusics() {
std::cout << "\n>> MUSIC FILES" << std::endl;
std::cout << "\n>> MUSIC FILES" << '\n';
auto list = Asset::get()->getListByType(AssetType::MUSIC);
musics_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
musics_.emplace_back(ResourceMusic(name, JA_LoadMusic(l.c_str())));
musics_.emplace_back(name, JA_LoadMusic(l.c_str()));
printWithDots("Music : ", name, "[ LOADED ]");
updateLoadingProgress(1);
}
@@ -209,13 +210,13 @@ void Resource::loadMusics() {
// Carga las texturas
void Resource::loadSurfaces() {
std::cout << "\n>> SURFACES" << std::endl;
std::cout << "\n>> SURFACES" << '\n';
auto list = Asset::get()->getListByType(AssetType::BITMAP);
surfaces_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
surfaces_.emplace_back(ResourceSurface(name, std::make_shared<Surface>(l)));
surfaces_.emplace_back(name, std::make_shared<Surface>(l));
surfaces_.back().surface->setTransparentColor(0);
updateLoadingProgress();
}
@@ -232,52 +233,52 @@ void Resource::loadSurfaces() {
// Carga las paletas
void Resource::loadPalettes() {
std::cout << "\n>> PALETTES" << std::endl;
std::cout << "\n>> PALETTES" << '\n';
auto list = Asset::get()->getListByType(AssetType::PALETTE);
palettes_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
palettes_.emplace_back(ResourcePalette(name, readPalFile(l)));
palettes_.emplace_back(name, readPalFile(l));
updateLoadingProgress();
}
}
// Carga los ficheros de texto
void Resource::loadTextFiles() {
std::cout << "\n>> TEXT FILES" << std::endl;
std::cout << "\n>> TEXT FILES" << '\n';
auto list = Asset::get()->getListByType(AssetType::FONT);
text_files_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
text_files_.emplace_back(ResourceTextFile(name, loadTextFile(l)));
text_files_.emplace_back(name, loadTextFile(l));
updateLoadingProgress();
}
}
// Carga las animaciones
void Resource::loadAnimations() {
std::cout << "\n>> ANIMATIONS" << std::endl;
std::cout << "\n>> ANIMATIONS" << '\n';
auto list = Asset::get()->getListByType(AssetType::ANIMATION);
animations_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
animations_.emplace_back(ResourceAnimation(name, loadAnimationsFromFile(l)));
animations_.emplace_back(name, loadAnimationsFromFile(l));
updateLoadingProgress();
}
}
// Carga los mapas de tiles
void Resource::loadTileMaps() {
std::cout << "\n>> TILE MAPS" << std::endl;
std::cout << "\n>> TILE MAPS" << '\n';
auto list = Asset::get()->getListByType(AssetType::TILEMAP);
tile_maps_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
tile_maps_.emplace_back(ResourceTileMap(name, loadRoomTileFile(l)));
tile_maps_.emplace_back(name, loadRoomTileFile(l));
printWithDots("TileMap : ", name, "[ LOADED ]");
updateLoadingProgress();
}
@@ -285,13 +286,13 @@ void Resource::loadTileMaps() {
// Carga las habitaciones
void Resource::loadRooms() {
std::cout << "\n>> ROOMS" << std::endl;
std::cout << "\n>> ROOMS" << '\n';
auto list = Asset::get()->getListByType(AssetType::ROOM);
rooms_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
rooms_.emplace_back(ResourceRoom(name, std::make_shared<RoomData>(loadRoomFile(l))));
rooms_.emplace_back(name, std::make_shared<RoomData>(loadRoomFile(l)));
printWithDots("Room : ", name, "[ LOADED ]");
updateLoadingProgress();
}
@@ -304,13 +305,13 @@ void Resource::createText() {
std::string text_file; // Nombre del archivo de texto
// Constructor para facilitar la creación de objetos ResourceInfo
ResourceInfo(const std::string& k, const std::string& t_file, const std::string& txt_file)
: key(k),
texture_file(t_file),
text_file(txt_file) {}
ResourceInfo(std::string k, std::string t_file, std::string txt_file)
: key(std::move(k)),
texture_file(std::move(t_file)),
text_file(std::move(txt_file)) {}
};
std::cout << "\n>> CREATING TEXT_OBJECTS" << std::endl;
std::cout << "\n>> CREATING TEXT_OBJECTS" << '\n';
std::vector<ResourceInfo> resources = {
{"debug", "debug.gif", "debug.txt"},
@@ -320,7 +321,7 @@ void Resource::createText() {
{"8bithud", "8bithud.gif", "8bithud.txt"}};
for (const auto& resource : resources) {
texts_.emplace_back(ResourceText(resource.key, std::make_shared<Text>(getSurface(resource.texture_file), getTextFile(resource.text_file))));
texts_.emplace_back(resource.key, std::make_shared<Text>(getSurface(resource.texture_file), getTextFile(resource.text_file)));
printWithDots("Text : ", resource.key, "[ DONE ]");
}
}

71
source/core/resources/resource.hpp
View File

@@ -2,6 +2,7 @@
#include <memory> // Para shared_ptr
#include <string> // Para string
#include <utility>
#include <vector> // Para vector
#include "core/rendering/surface.hpp" // Para Surface
@@ -17,8 +18,8 @@ struct ResourceSound {
JA_Sound_t* sound; // Objeto con el sonido
// Constructor
ResourceSound(const std::string& name, JA_Sound_t* sound)
: name(name),
ResourceSound(std::string name, JA_Sound_t* sound)
: name(std::move(name)),
sound(sound) {}
};
@@ -28,8 +29,8 @@ struct ResourceMusic {
JA_Music_t* music; // Objeto con la música
// Constructor
ResourceMusic(const std::string& name, JA_Music_t* music)
: name(name),
ResourceMusic(std::string name, JA_Music_t* music)
: name(std::move(name)),
music(music) {}
};
@@ -39,9 +40,9 @@ struct ResourceSurface {
std::shared_ptr<Surface> surface; // Objeto con la surface
// Constructor
ResourceSurface(const std::string& name, std::shared_ptr<Surface> surface)
: name(name),
surface(surface) {}
ResourceSurface(std::string name, std::shared_ptr<Surface> surface)
: name(std::move(name)),
surface(std::move(std::move(surface))) {}
};
// Estructura para almacenar objetos Palette y su nombre
@@ -50,8 +51,8 @@ struct ResourcePalette {
Palette palette; // Paleta
// Constructor
ResourcePalette(const std::string& name, Palette palette)
: name(name),
ResourcePalette(std::string name, Palette palette)
: name(std::move(name)),
palette(palette) {}
};
@@ -61,9 +62,9 @@ struct ResourceTextFile {
std::shared_ptr<TextFile> text_file; // Objeto con los descriptores de la fuente de texto
// Constructor
ResourceTextFile(const std::string& name, std::shared_ptr<TextFile> text_file)
: name(name),
text_file(text_file) {}
ResourceTextFile(std::string name, std::shared_ptr<TextFile> text_file)
: name(std::move(name)),
text_file(std::move(std::move(text_file))) {}
};
// Estructura para almacenar objetos Text y su nombre
@@ -72,9 +73,9 @@ struct ResourceText {
std::shared_ptr<Text> text; // Objeto
// Constructor
ResourceText(const std::string& name, std::shared_ptr<Text> text)
: name(name),
text(text) {}
ResourceText(std::string name, std::shared_ptr<Text> text)
: name(std::move(name)),
text(std::move(std::move(text))) {}
};
// Estructura para almacenar ficheros animaciones y su nombre
@@ -83,9 +84,9 @@ struct ResourceAnimation {
Animations animation; // Objeto con las animaciones
// Constructor
ResourceAnimation(const std::string& name, const Animations& animation)
: name(name),
animation(animation) {}
ResourceAnimation(std::string name, Animations animation)
: name(std::move(name)),
animation(std::move(animation)) {}
};
// Estructura para almacenar ficheros con el mapa de tiles de una habitación y su nombre
@@ -94,8 +95,8 @@ struct ResourceTileMap {
std::vector<int> tile_map; // Vector con los indices del mapa de tiles
// Constructor
ResourceTileMap(const std::string& name, const std::vector<int>& tile_map)
: name(name),
ResourceTileMap(std::string name, const std::vector<int>& tile_map)
: name(std::move(name)),
tile_map(tile_map) {}
};
@@ -105,9 +106,9 @@ struct ResourceRoom {
std::shared_ptr<RoomData> room; // Habitación
// Constructor
ResourceRoom(const std::string& name, std::shared_ptr<RoomData> room)
: name(name),
room(room) {}
ResourceRoom(std::string name, std::shared_ptr<RoomData> room)
: name(std::move(name)),
room(std::move(std::move(room))) {}
};
// Estructura para llevar la cuenta de los recursos cargados
@@ -131,7 +132,7 @@ struct ResourceCount {
}
// Obtiene el porcentaje de recursos cargados
float getPercentage() const {
[[nodiscard]] auto getPercentage() const -> float {
return static_cast<float>(loaded) / static_cast<float>(total);
}
};
@@ -220,37 +221,37 @@ class Resource {
static void destroy();
// [SINGLETON] Con este método obtenemos el objeto resource y podemos trabajar con él
static Resource* get();
static auto get() -> Resource*;
// Obtiene el sonido a partir de un nombre
JA_Sound_t* getSound(const std::string& name);
auto getSound(const std::string& name) -> JA_Sound_t*;
// Obtiene la música a partir de un nombre
JA_Music_t* getMusic(const std::string& name);
auto getMusic(const std::string& name) -> JA_Music_t*;
// Obtiene la surface a partir de un nombre
std::shared_ptr<Surface> getSurface(const std::string& name);
auto getSurface(const std::string& name) -> std::shared_ptr<Surface>;
// Obtiene la paleta a partir de un nombre
Palette getPalette(const std::string& name);
auto getPalette(const std::string& name) -> Palette;
// Obtiene el fichero de texto a partir de un nombre
std::shared_ptr<TextFile> getTextFile(const std::string& name);
auto getTextFile(const std::string& name) -> std::shared_ptr<TextFile>;
// Obtiene el objeto de texto a partir de un nombre
std::shared_ptr<Text> getText(const std::string& name);
auto getText(const std::string& name) -> std::shared_ptr<Text>;
// Obtiene la animación a partir de un nombre
Animations& getAnimations(const std::string& name);
auto getAnimations(const std::string& name) -> Animations&;
// Obtiene el mapa de tiles a partir de un nombre
std::vector<int>& getTileMap(const std::string& name);
auto getTileMap(const std::string& name) -> std::vector<int>&;
// Obtiene la habitación a partir de un nombre
std::shared_ptr<RoomData> getRoom(const std::string& name);
auto getRoom(const std::string& name) -> std::shared_ptr<RoomData>;
// Obtiene todas las habitaciones
std::vector<ResourceRoom>& getRooms();
auto getRooms() -> std::vector<ResourceRoom>&;
// Recarga todos los recursos
void reload();

2
source/core/system/debug.cpp
View File

@@ -21,7 +21,7 @@ void Debug::destroy() {
}
// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
Debug* Debug::get() {
auto Debug::get() -> Debug* {
return Debug::debug;
}