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

linter

Browse Source
This commit is contained in:
Sergio
2025-10-24 17:50:31 +02:00
parent 3cfb65320c
commit 4679255d60
8 changed files with 68 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/asset_integrated.cpp
View File

@@ -61,7 +61,7 @@ auto AssetIntegrated::loadFile(const std::string& filename) -> std::vector<uint8
return data;
}
auto AssetIntegrated::fileExists(const std::string& filename) const -> bool {
auto AssetIntegrated::fileExists(const std::string& filename) -> bool {
if (shouldUseResourcePack(filename) && resource_pack_enabled) {
auto& loader = ResourceLoader::getInstance();

4
source/asset_integrated.hpp
View File

@@ -13,10 +13,10 @@ class AssetIntegrated : public Asset {
const std::string& resource_pack_path = "resources.pack");
// Carga un archivo usando ResourceLoader como primera opción
auto loadFile(const std::string& filename) -> std::vector<uint8_t>;
static auto loadFile(const std::string& filename) -> std::vector<uint8_t>;
// Verifica si un archivo existe (pack o filesystem)
auto fileExists(const std::string& filename) const -> bool;
static auto fileExists(const std::string& filename) -> bool;
// Obtiene la ruta completa para archivos del sistema/config
static auto getSystemPath(const std::string& filename) -> std::string;

2
source/path_sprite.cpp
View File

@@ -56,7 +56,7 @@ void PathSprite::render() {
}
// Determina el tipo de centrado basado en el tipo de path
auto PathSprite::determineCenteringType(const Path& path, bool centered) const -> PathCentered {
auto PathSprite::determineCenteringType(const Path& path, bool centered) -> PathCentered {
if (!centered) {
return PathCentered::NONE;
}

6
source/path_sprite.hpp
View File

@@ -95,7 +95,7 @@ class PathSprite : public Sprite {
void goToNextPathOrDie(); // Cambia de recorrido o finaliza
// --- Métodos auxiliares para addPath ---
[[nodiscard]] auto determineCenteringType(const Path& path, bool centered) const -> PathCentered; // Determina el tipo de centrado
void centerPathOnX(Path& path, float offset); // Aplica centrado en el eje X
void centerPathOnY(Path& path, float offset); // Aplica centrado en el eje Y
[[nodiscard]] static auto determineCenteringType(const Path& path, bool centered) -> PathCentered; // Determina el tipo de centrado
static void centerPathOnX(Path& path, float offset); // Aplica centrado en el eje X
static void centerPathOnY(Path& path, float offset); // Aplica centrado en el eje Y
};

14
source/rendering/opengl/opengl_shader.cpp
View File

@@ -42,13 +42,13 @@ auto OpenGLShader::initGLExtensions() -> bool {
glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)SDL_GL_GetProcAddress("glVertexAttribPointer");
glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)SDL_GL_GetProcAddress("glEnableVertexAttribArray");
return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv &&
glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
glLinkProgram && glValidateProgram && glGetProgramiv && glGetProgramInfoLog &&
glUseProgram && glDeleteProgram && glGetUniformLocation && glUniform2f &&
glGenVertexArrays && glBindVertexArray && glDeleteVertexArrays &&
glGenBuffers && glBindBuffer && glBufferData && glDeleteBuffers &&
glVertexAttribPointer && glEnableVertexAttribArray;
return (glCreateShader != nullptr) && (glShaderSource != nullptr) && (glCompileShader != nullptr) && (glGetShaderiv != nullptr) &&
(glGetShaderInfoLog != nullptr) && (glDeleteShader != nullptr) && (glAttachShader != nullptr) && (glCreateProgram != nullptr) &&
(glLinkProgram != nullptr) && (glValidateProgram != nullptr) && (glGetProgramiv != nullptr) && (glGetProgramInfoLog != nullptr) &&
(glUseProgram != nullptr) && (glDeleteProgram != nullptr) && (glGetUniformLocation != nullptr) && (glUniform2f != nullptr) &&
(glGenVertexArrays != nullptr) && (glBindVertexArray != nullptr) && (glDeleteVertexArrays != nullptr) &&
(glGenBuffers != nullptr) && (glBindBuffer != nullptr) && (glBufferData != nullptr) && (glDeleteBuffers != nullptr) &&
(glVertexAttribPointer != nullptr) && (glEnableVertexAttribArray != nullptr);
}
#endif

26
source/sections/credits.cpp
View File

@@ -432,7 +432,7 @@ void Credits::updateBlackRects(float delta_time) {
static_cast<float>(param.game.game_area.center_y + 1));
int bottom_steps_by_h = static_cast<int>(bottom_black_rect_.h) - prev_bottom_h;
int bottom_steps_by_y = prev_bottom_y - static_cast<int>(bottom_black_rect_.y);
int bottom_steps = std::max(0, std::max(bottom_steps_by_h, bottom_steps_by_y));
int bottom_steps = std::max({0, bottom_steps_by_h, bottom_steps_by_y});
int steps_done = top_delta + bottom_steps;
if (steps_done > 0) {
@@ -460,20 +460,20 @@ void Credits::updateBlackRects(float delta_time) {
if (!horizontal_done_) {
int prev_left_w = static_cast<int>(left_black_rect_.w);
left_black_rect_.w = std::min(left_black_rect_.w + static_cast<float>(HORIZONTAL_SPEED),
static_cast<float>(param.game.game_area.center_x));
param.game.game_area.center_x);
int left_gain = static_cast<int>(left_black_rect_.w) - prev_left_w;
int prev_right_x = static_cast<int>(right_black_rect_.x);
right_black_rect_.w = right_black_rect_.w + static_cast<float>(HORIZONTAL_SPEED);
right_black_rect_.x = std::max(right_black_rect_.x - static_cast<float>(HORIZONTAL_SPEED),
static_cast<float>(param.game.game_area.center_x));
param.game.game_area.center_x);
int right_move = prev_right_x - static_cast<int>(right_black_rect_.x);
int steps_done = left_gain + right_move;
if (steps_done > 0) {
current_step_ = std::max(0.0f, current_step_ - static_cast<float>(steps_done));
current_step_ = std::max(0.0F, current_step_ - static_cast<float>(steps_done));
float vol_f = initial_volume_ * (current_step_ / static_cast<float>(total_steps_));
int vol_i = static_cast<int>(std::clamp(vol_f, 0.0f, static_cast<float>(initial_volume_)));
int vol_i = static_cast<int>(std::clamp(vol_f, 0.0F, static_cast<float>(initial_volume_)));
Audio::get()->setMusicVolume(vol_i); // usa tu API de audio aquí
}
@@ -495,7 +495,9 @@ void Credits::updateBlackRects(float delta_time) {
// Usar segundos puros en lugar de frames equivalentes
if (counter_pre_fade_ >= PRE_FADE_DELAY_S) {
if (fade_out_) fade_out_->activate();
if (fade_out_) {
fade_out_->activate();
}
} else {
counter_pre_fade_ += delta_time;
}
@@ -680,7 +682,9 @@ void Credits::startCredits() {
int pasos_right = (dx_right + (HORIZONTAL_SPEED - 1)) / HORIZONTAL_SPEED; // ceil
total_steps_ = pasos_top + pasos_bottom + pasos_left + pasos_right;
if (total_steps_ <= 0) total_steps_ = 1;
if (total_steps_ <= 0) {
total_steps_ = 1;
}
current_step_ = static_cast<float>(total_steps_);
@@ -690,7 +694,9 @@ void Credits::startCredits() {
initialized_ = true;
// Asegurar volumen inicial consistente
if (steps_ <= 0) steps_ = 1;
if (steps_ <= 0) {
steps_ = 1;
}
float vol_f = initial_volume_ * (current_step_ / static_cast<float>(total_steps_));
setVolume(static_cast<int>(std::clamp(vol_f, 0.0F, static_cast<float>(initial_volume_))));
}
@@ -711,8 +717,8 @@ void Credits::drawBorderRect() {
SDL_Rect r;
r.x = static_cast<int>(std::floor(border_rect_.x + 0.5F));
r.y = static_cast<int>(std::floor(border_rect_.y + 0.5F));
r.w = static_cast<int>(std::max(0.0f, std::floor(border_rect_.w + 0.5F)));
r.h = static_cast<int>(std::max(0.0f, std::floor(border_rect_.h + 0.5F)));
r.w = static_cast<int>(std::max(0.0F, std::floor(border_rect_.w + 0.5F)));
r.h = static_cast<int>(std::max(0.0F, std::floor(border_rect_.h + 0.5F)));
if (r.w > 0 && r.h > 0) {
SDL_RenderRect(Screen::get()->getRenderer(), &border_rect_);

52
source/sections/game.cpp
View File

@@ -551,19 +551,18 @@ void Game::handleTabeHitEffects() {
// Maneja la colisión entre bala y globos
auto Game::checkBulletBalloonCollision(const std::shared_ptr<Bullet>& bullet) -> bool {
for (auto& balloon : balloon_manager_->getBalloons()) {
return std::ranges::any_of(balloon_manager_->getBalloons(), [this, &bullet](auto& balloon) {
if (!balloon->isEnabled() || balloon->isInvulnerable()) {
continue;
return false;
}
if (!checkCollision(balloon->getCollider(), bullet->getCollider())) {
continue;
return false;
}
processBalloonHit(bullet, balloon);
return true;
}
return false;
});
}
// Procesa el impacto en un globo
@@ -1966,8 +1965,10 @@ void Game::handleGameOverEvents() {
void Game::buildPlayerDrawList(const Players& elements, Players& draw_list) {
draw_list.clear();
draw_list.reserve(elements.size());
for (const auto& e : elements) draw_list.push_back(e); // copia el shared_ptr
std::stable_sort(draw_list.begin(), draw_list.end(), [](const std::shared_ptr<Player>& a, const std::shared_ptr<Player>& b) {
for (const auto& e : elements) {
draw_list.push_back(e); // copia el shared_ptr
}
std::ranges::stable_sort(draw_list, [](const std::shared_ptr<Player>& a, const std::shared_ptr<Player>& b) {
return a->getZOrder() < b->getZOrder();
});
}
@@ -1981,31 +1982,42 @@ void Game::updatePlayerDrawList(const Players& elements, Players& draw_list) {
return;
}
// Dado que apuntan a los mismos elementos, basta ordenar por los z_order actuales.
std::stable_sort(draw_list.begin(), draw_list.end(), [](const std::shared_ptr<Player>& a, const std::shared_ptr<Player>& b) {
std::ranges::stable_sort(draw_list, [](const std::shared_ptr<Player>& a, const std::shared_ptr<Player>& b) {
return a->getZOrder() < b->getZOrder();
});
}
// Dibuja en el orden definido por draw_list
void Game::renderPlayerDrawList(const Players& draw_list) {
for (const auto& e : draw_list) e->render();
for (const auto& e : draw_list) {
e->render();
}
}
// Operaciones sobre z_order que mantienen la invariante y actualizan draw_list.
auto Game::findPlayerIndex(const Players& elems, const std::shared_ptr<Player>& who) -> size_t {
for (size_t i = 0; i < elems.size(); ++i)
if (elems[i] == who) return static_cast<int>(i); // compara shared_ptr directamente
for (size_t i = 0; i < elems.size(); ++i) {
if (elems[i] == who) {
return static_cast<int>(i); // compara shared_ptr directamente
}
}
return -1;
}
void Game::sendPlayerToBack(Players& elements, const std::shared_ptr<Player>& who, Players& draw_list) {
int idx = findPlayerIndex(elements, who);
if (idx < 0) return; // no encontrado
if (idx < 0) {
return; // no encontrado
}
const int OLD_Z = elements[idx]->getZOrder();
if (OLD_Z <= 0) return;
if (OLD_Z <= 0) {
return;
}
for (auto& p : elements) {
int z = p->getZOrder();
if (z < OLD_Z) { p->setZOrder(z + 1); }
if (z < OLD_Z) {
p->setZOrder(z + 1);
}
}
elements[idx]->setZOrder(0);
updatePlayerDrawList(elements, draw_list);
@@ -2013,13 +2025,19 @@ void Game::sendPlayerToBack(Players& elements, const std::shared_ptr<Player>& wh
void Game::bringPlayerToFront(Players& elements, const std::shared_ptr<Player>& who, Players& draw_list) {
int idx = findPlayerIndex(elements, who);
if (idx < 0) return; // no encontrado
if (idx < 0) {
return; // no encontrado
}
const int OLD_Z = elements[idx]->getZOrder();
const int N = static_cast<int>(elements.size());
if (OLD_Z >= N - 1) return;
if (OLD_Z >= N - 1) {
return;
}
for (auto& p : elements) {
int z = p->getZOrder();
if (z > OLD_Z) p->setZOrder(z - 1);
if (z > OLD_Z) {
p->setZOrder(z - 1);
}
}
elements[idx]->setZOrder(N - 1);
updatePlayerDrawList(elements, draw_list);

4
source/sections/game.hpp
View File

@@ -336,9 +336,9 @@ class Game {
void playSound(const std::string& name) const; // Reproduce un efecto de sonido específico
// --- Gestion y dibujado de jugadores en z-order ---
void buildPlayerDrawList(const Players& elements, Players& draw_list); // Construye el draw_list a partir del vector principal
static void buildPlayerDrawList(const Players& elements, Players& draw_list); // Construye el draw_list a partir del vector principal
void updatePlayerDrawList(const Players& elements, Players& draw_list); // Actualiza draw_list tras cambios en los z_order
void renderPlayerDrawList(const Players& draw_list); // Dibuja en el orden definido
static void renderPlayerDrawList(const Players& draw_list); // Dibuja en el orden definido
static auto findPlayerIndex(const Players& elems, const std::shared_ptr<Player>& who) -> size_t;
void sendPlayerToBack(Players& elements, const std::shared_ptr<Player>& who, Players& draw_list); // Envia al jugador al fondo de la pantalla
void bringPlayerToFront(Players& elements, const std::shared_ptr<Player>& who, Players& draw_list); // Envia al jugador al frente de la pantalla