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

tidy-fix automàtic (sense naming)

Browse Source
This commit is contained in:
JailDesigner committed 2026-05-14 18:28:23 +02:00
1 parent 358e91ea30
commit b7a551c158
81 files changed
+1549 -831
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

source/game/scenes/banner_scene.cpp
+6 -2
View File
@@ -42,7 +42,9 @@ namespace scenes {
switch (phase_) {
case Phase::FadingIn:
fade_.tick(delta_ms);
if (fade_.done()) phase_ = Phase::Showing;
if (fade_.done()) {
phase_ = Phase::Showing;
}
break;
case Phase::Showing:
@@ -60,7 +62,9 @@ namespace scenes {
case Phase::FadingOut:
fade_.tick(delta_ms);
if (fade_.done()) phase_ = Phase::Done;
if (fade_.done()) {
phase_ = Phase::Done;
}
break;
case Phase::Done:
source/game/scenes/banner_scene.hpp
+2 -2
View File
@@ -22,8 +22,8 @@ namespace scenes {
public:
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
int nextState() const override { return 0; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
[[nodiscard]] auto nextState() const -> int override { return 0; }
private:
enum class Phase { FadingIn,
source/game/scenes/boot_loader_scene.cpp
+4 -2
View File
@@ -35,10 +35,12 @@ namespace scenes {
render();
}
void BootLoaderScene::render() const {
void BootLoaderScene::render() {
JD8_ClearScreen(BG_COLOR);
if (!Options::game.show_preload) return;
if (!Options::game.show_preload) {
return;
}
const float pct = Resource::Cache::get()->getProgress();
const int filled = static_cast<int>(static_cast<float>(BAR_W) * pct);
source/game/scenes/boot_loader_scene.hpp
+2 -2
View File
@@ -15,10 +15,10 @@ namespace scenes {
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return done_; }
[[nodiscard]] auto done() const -> bool override { return done_; }
private:
void render() const;
static void render();
bool done_{false};
};
source/game/scenes/credits_scene.cpp
+9 -9
View File
@@ -18,14 +18,14 @@ namespace {
};
constexpr CocheFrame COCHE_FRAMES[8] = {
{214, 152},
{214, 104},
{214, 56},
{214, 104},
{214, 152},
{214, 8},
{108, 152},
{214, 8},
{.x = 214, .y = 152},
{.x = 214, .y = 104},
{.x = 214, .y = 56},
{.x = 214, .y = 104},
{.x = 214, .y = 152},
{.x = 214, .y = 8},
{.x = 108, .y = 152},
{.x = 214, .y = 8},
};
constexpr int CONTADOR_MAX = 3100; // ~62 s de crèdits a 20 ms/tick
@@ -101,7 +101,7 @@ namespace scenes {
void CreditsScene::writeTrickIni() {
FILE* ini = std::fopen("trick.ini", "wb");
if (ini) {
if (ini != nullptr) {
std::fwrite("1", 1, 1, ini);
std::fclose(ini);
}
source/game/scenes/credits_scene.hpp
+2 -2
View File
@@ -28,7 +28,7 @@ namespace scenes {
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
private:
enum class Phase { Rolling,
@@ -36,7 +36,7 @@ namespace scenes {
Done };
void render();
void writeTrickIni();
static void writeTrickIni();
SurfaceHandle vaddr2_; // gfx/final.gif (sprites i coches)
SurfaceHandle vaddr3_; // gfx/finals.gif (fons / parallax)
source/game/scenes/frame_animator.cpp
+3 -1
View File
@@ -10,7 +10,9 @@ namespace scenes {
loop_(loop) {}
void FrameAnimator::tick(int delta_ms) {
if (finished_) return;
if (finished_) {
return;
}
elapsed_ms_ += delta_ms;
while (elapsed_ms_ >= frame_ms_) {
elapsed_ms_ -= frame_ms_;
source/game/scenes/frame_animator.hpp
+3 -3
View File
@@ -15,9 +15,9 @@ namespace scenes {
void tick(int delta_ms);
int frame() const { return current_frame_; }
bool done() const { return !loop_ && finished_; }
int numFrames() const { return num_frames_; }
[[nodiscard]] auto frame() const -> int { return current_frame_; }
[[nodiscard]] auto done() const -> bool { return !loop_ && finished_; }
[[nodiscard]] auto numFrames() const -> int { return num_frames_; }
void reset();
void setFrameMs(int frame_ms) { frame_ms_ = frame_ms; }
source/game/scenes/intro_new_logo_scene.cpp
+21 -7
View File
@@ -108,14 +108,28 @@ namespace scenes {
// els índexs 16..31 (grup del verd brillant del logo).
for (int i = 16; i < 32; i++) {
if (i == 17) {
if (pal_[i].r < 255) pal_[i].r++;
if (pal_[i].g < 255) pal_[i].g++;
if (pal_[i].b < 255) pal_[i].b++;
if (pal_[i].r < 255) {
pal_[i].r++;
}
if (pal_[i].g < 255) {
pal_[i].g++;
}
if (pal_[i].b < 255) {
pal_[i].b++;
}
}
if (pal_[i].b < pal_[i].g) {
pal_[i].b++;
}
if (pal_[i].b > pal_[i].g) {
pal_[i].b--;
}
if (pal_[i].r < pal_[i].g) {
pal_[i].r++;
}
if (pal_[i].r > pal_[i].g) {
pal_[i].r--;
}
if (pal_[i].b < pal_[i].g) pal_[i].b++;
if (pal_[i].b > pal_[i].g) pal_[i].b--;
if (pal_[i].r < pal_[i].g) pal_[i].r++;
if (pal_[i].r > pal_[i].g) pal_[i].r--;
}
}
source/game/scenes/intro_new_logo_scene.hpp
+1 -1
View File
@@ -36,7 +36,7 @@ namespace scenes {
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
private:
enum class Phase {
source/game/scenes/intro_scene.cpp
+39 -23
View File
@@ -27,21 +27,21 @@ namespace {
};
constexpr RevealStep REVEAL_STEPS[] = {
{100, 27, 68, false, false}, // J
{100, 53, 96, false, false}, // JA
{100, 66, 109, false, false}, // JAI
{200, 92, 136, false, false}, // JAIL
{200, 92, -1, true, false}, // JAIL (clear, sense avió — parpelleig)
{100, 118, 160, false, false}, // JAILG
{100, 145, 188, false, false}, // JAILGA
{100, 178, 221, false, false}, // JAILGAM
{100, 205, 248, false, false}, // JAILGAME
{200, 0, 274, false, true}, // JAILGAMES (wordmark complet) + avió
{200, 0, -1, true, true}, // JAILGAMES (clear, sense avió)
{200, 0, 274, false, true}, // JAILGAMES + avió (sense clear)
{200, 0, -1, true, true}, // JAILGAMES (clear, sense avió)
{200, 0, 274, false, true}, // JAILGAMES + avió (sense clear)
{200, 0, -1, true, true}, // JAILGAMES (clear, sense avió)
{.duration_ms = 100, .body_w = 27, .plane_x = 68, .clear = false, .wordmark = false}, // J
{.duration_ms = 100, .body_w = 53, .plane_x = 96, .clear = false, .wordmark = false}, // JA
{.duration_ms = 100, .body_w = 66, .plane_x = 109, .clear = false, .wordmark = false}, // JAI
{.duration_ms = 200, .body_w = 92, .plane_x = 136, .clear = false, .wordmark = false}, // JAIL
{.duration_ms = 200, .body_w = 92, .plane_x = -1, .clear = true, .wordmark = false}, // JAIL (clear, sense avió — parpelleig)
{.duration_ms = 100, .body_w = 118, .plane_x = 160, .clear = false, .wordmark = false}, // JAILG
{.duration_ms = 100, .body_w = 145, .plane_x = 188, .clear = false, .wordmark = false}, // JAILGA
{.duration_ms = 100, .body_w = 178, .plane_x = 221, .clear = false, .wordmark = false}, // JAILGAM
{.duration_ms = 100, .body_w = 205, .plane_x = 248, .clear = false, .wordmark = false}, // JAILGAME
{.duration_ms = 200, .body_w = 0, .plane_x = 274, .clear = false, .wordmark = true}, // JAILGAMES (wordmark complet) + avió
{.duration_ms = 200, .body_w = 0, .plane_x = -1, .clear = true, .wordmark = true}, // JAILGAMES (clear, sense avió)
{.duration_ms = 200, .body_w = 0, .plane_x = 274, .clear = false, .wordmark = true}, // JAILGAMES + avió (sense clear)
{.duration_ms = 200, .body_w = 0, .plane_x = -1, .clear = true, .wordmark = true}, // JAILGAMES (clear, sense avió)
{.duration_ms = 200, .body_w = 0, .plane_x = 274, .clear = false, .wordmark = true}, // JAILGAMES + avió (sense clear)
{.duration_ms = 200, .body_w = 0, .plane_x = -1, .clear = true, .wordmark = true}, // JAILGAMES (clear, sense avió)
};
constexpr int REVEAL_COUNT = sizeof(REVEAL_STEPS) / sizeof(REVEAL_STEPS[0]);
@@ -88,7 +88,9 @@ namespace scenes {
case Phase::Reveal: {
const RevealStep& s = REVEAL_STEPS[reveal_index_];
if (s.clear) JD8_ClearScreen(0);
if (s.clear) {
JD8_ClearScreen(0);
}
if (s.wordmark) {
drawWordmark(gfx_);
} else if (s.body_w > 0) {
@@ -121,14 +123,28 @@ namespace scenes {
// els altres convergeixen cap al mateix gris mitjà.
for (int i = 16; i < 32; i++) {
if (i == 17) {
if (pal_[i].r < 255) pal_[i].r++;
if (pal_[i].g < 255) pal_[i].g++;
if (pal_[i].b < 255) pal_[i].b++;
if (pal_[i].r < 255) {
pal_[i].r++;
}
if (pal_[i].g < 255) {
pal_[i].g++;
}
if (pal_[i].b < 255) {
pal_[i].b++;
}
}
if (pal_[i].b < pal_[i].g) {
pal_[i].b++;
}
if (pal_[i].b > pal_[i].g) {
pal_[i].b--;
}
if (pal_[i].r < pal_[i].g) {
pal_[i].r++;
}
if (pal_[i].r > pal_[i].g) {
pal_[i].r--;
}
if (pal_[i].b < pal_[i].g) pal_[i].b++;
if (pal_[i].b > pal_[i].g) pal_[i].b--;
if (pal_[i].r < pal_[i].g) pal_[i].r++;
if (pal_[i].r > pal_[i].g) pal_[i].r--;
}
}
source/game/scenes/intro_scene.hpp
+1 -1
View File
@@ -37,7 +37,7 @@ namespace scenes {
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
private:
enum class Phase {
source/game/scenes/intro_sprites_scene.cpp
+29 -27
View File
@@ -146,17 +146,17 @@ namespace {
}
constexpr SpritePhase variant_0[] = {
{0, 200, v0_walk_right, true},
{0, 200, v0_pull_map_right, true},
{200, 0, v0_pull_map_right, true}, // guarda el mapa (reprodueix inversament)
{200, 80, v0_walk_left_to_80, true},
{0, 200, v0_pull_map_left, true},
{300, 95, v0_momia_left, true},
{0, 50, v0_turn, true},
{0, 49, v0_jump1, true},
{50, 99, v0_jump2, true},
{80, 0, v0_walk_final, true},
{0, 150, v0_final, true},
{.start_i = 0, .end_i = 200, .render = v0_walk_right, .skippable = true},
{.start_i = 0, .end_i = 200, .render = v0_pull_map_right, .skippable = true},
{.start_i = 200, .end_i = 0, .render = v0_pull_map_right, .skippable = true}, // guarda el mapa (reprodueix inversament)
{.start_i = 200, .end_i = 80, .render = v0_walk_left_to_80, .skippable = true},
{.start_i = 0, .end_i = 200, .render = v0_pull_map_left, .skippable = true},
{.start_i = 300, .end_i = 95, .render = v0_momia_left, .skippable = true},
{.start_i = 0, .end_i = 50, .render = v0_turn, .skippable = true},
{.start_i = 0, .end_i = 49, .render = v0_jump1, .skippable = true},
{.start_i = 50, .end_i = 99, .render = v0_jump2, .skippable = true},
{.start_i = 80, .end_i = 0, .render = v0_walk_final, .skippable = true},
{.start_i = 0, .end_i = 150, .render = v0_final, .skippable = true},
};
// =========================================================================
@@ -224,13 +224,13 @@ namespace {
}
constexpr SpritePhase variant_1[] = {
{0, 200, v1_walk_right, true},
{0, 300, v1_pull_map, true},
{0, 100, v1_interrogant, true},
{0, 200, v1_drop_map, true},
{0, 75, v1_stone_fall, true},
{0, 19, v1_stone_break, true},
{0, 200, v1_final, true},
{.start_i = 0, .end_i = 200, .render = v1_walk_right, .skippable = true},
{.start_i = 0, .end_i = 300, .render = v1_pull_map, .skippable = true},
{.start_i = 0, .end_i = 100, .render = v1_interrogant, .skippable = true},
{.start_i = 0, .end_i = 200, .render = v1_drop_map, .skippable = true},
{.start_i = 0, .end_i = 75, .render = v1_stone_fall, .skippable = true},
{.start_i = 0, .end_i = 19, .render = v1_stone_break, .skippable = true},
{.start_i = 0, .end_i = 200, .render = v1_final, .skippable = true},
};
// =========================================================================
@@ -268,17 +268,17 @@ namespace {
}
constexpr SpritePhase variant_2[] = {
{0, 145, v2_approach, true},
{0, 100, v2_still, true},
{0, 50, v2_horn, true},
{0, 800, v2_ball, true},
{.start_i = 0, .end_i = 145, .render = v2_approach, .skippable = true},
{.start_i = 0, .end_i = 100, .render = v2_still, .skippable = true},
{.start_i = 0, .end_i = 50, .render = v2_horn, .skippable = true},
{.start_i = 0, .end_i = 800, .render = v2_ball, .skippable = true},
};
// =========================================================================
// Dispatch per variant
// =========================================================================
const SpritePhase* variant_table(int variant) {
auto variant_table(int variant) -> const SpritePhase* {
switch (variant) {
case 0:
return variant_0;
@@ -290,7 +290,7 @@ namespace {
return variant_0;
}
int variant_length(int variant) {
auto variant_length(int variant) -> int {
switch (variant) {
case 0:
return sizeof(variant_0) / sizeof(variant_0[0]);
@@ -302,11 +302,11 @@ namespace {
return 0;
}
int phase_step_count(const SpritePhase& p) {
auto phase_step_count(const SpritePhase& p) -> int {
return std::abs(p.end_i - p.start_i) + 1;
}
int phase_current_i(const SpritePhase& p, int step) {
auto phase_current_i(const SpritePhase& p, int step) -> int {
return p.end_i >= p.start_i ? p.start_i + step : p.start_i - step;
}
@@ -334,7 +334,9 @@ namespace scenes {
}
void IntroSpritesScene::tick(int delta_ms) {
if (done_) return;
if (done_) {
return;
}
const SpritePhase* phases = variant_table(variant_);
const int num_phases = variant_length(variant_);
source/game/scenes/intro_sprites_scene.hpp
+1 -1
View File
@@ -28,7 +28,7 @@ namespace scenes {
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return done_; }
[[nodiscard]] auto done() const -> bool override { return done_; }
private:
SurfaceHandle gfx_;
source/game/scenes/menu_scene.cpp
+15 -5
View File
@@ -62,7 +62,9 @@ namespace scenes {
switch (phase_) {
case Phase::FadingIn:
fade_.tick(delta_ms);
if (fade_.done()) phase_ = Phase::Showing;
if (fade_.done()) {
phase_ = Phase::Showing;
}
break;
case Phase::Showing: {
@@ -70,20 +72,26 @@ namespace scenes {
palmeres_acc_ms_ += delta_ms;
while (palmeres_acc_ms_ >= 80) {
palmeres_acc_ms_ -= 80;
if (--palmeres_ < 0) palmeres_ = 319;
if (--palmeres_ < 0) {
palmeres_ = 319;
}
}
// Horitzó: 1 pixel cada 320 ms (= cada 16 ticks × 20 ms)
horitzo_acc_ms_ += delta_ms;
while (horitzo_acc_ms_ >= 320) {
horitzo_acc_ms_ -= 320;
if (--horitzo_ < 0) horitzo_ = 319;
if (--horitzo_ < 0) {
horitzo_ = 319;
}
}
camello_.tick(delta_ms);
blink_ms_ += delta_ms;
if (blink_ms_ >= 2000) blink_ms_ %= 2000;
if (blink_ms_ >= 2000) {
blink_ms_ %= 2000;
}
render();
@@ -102,7 +110,9 @@ namespace scenes {
case Phase::FadingOut:
fade_.tick(delta_ms);
if (fade_.done()) phase_ = Phase::Done;
if (fade_.done()) {
phase_ = Phase::Done;
}
break;
case Phase::Done:
source/game/scenes/menu_scene.hpp
+1 -1
View File
@@ -26,7 +26,7 @@ namespace scenes {
public:
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
private:
enum class Phase { FadingIn,
source/game/scenes/mort_scene.cpp
+6 -2
View File
@@ -32,7 +32,9 @@ namespace scenes {
switch (phase_) {
case Phase::FadingIn:
fade_.tick(delta_ms);
if (fade_.done()) phase_ = Phase::Showing;
if (fade_.done()) {
phase_ = Phase::Showing;
}
break;
case Phase::Showing:
@@ -53,7 +55,9 @@ namespace scenes {
case Phase::FadingOut:
fade_.tick(delta_ms);
if (fade_.done()) phase_ = Phase::Done;
if (fade_.done()) {
phase_ = Phase::Done;
}
break;
case Phase::Done:
source/game/scenes/mort_scene.hpp
+1 -1
View File
@@ -18,7 +18,7 @@ namespace scenes {
public:
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
private:
enum class Phase { FadingIn,
source/game/scenes/palette_fade.cpp
+3 -1
View File
@@ -13,7 +13,9 @@ namespace scenes {
}
void PaletteFade::tick(int /*delta_ms*/) {
if (!active_) return;
if (!active_) {
return;
}
// El fade té 32 passos interns. Amb un tick per frame (~16ms)
// dura ~512ms — el mateix temps que la versió bloquejant original.
// Si en el futur volem fer-lo genuinament time-based (p.ex. "fade
source/game/scenes/palette_fade.hpp
+2 -2
View File
@@ -20,8 +20,8 @@ namespace scenes {
void tick(int delta_ms);
bool active() const { return active_; }
bool done() const { return !active_; }
[[nodiscard]] auto active() const -> bool { return active_; }
[[nodiscard]] auto done() const -> bool { return !active_; }
private:
bool active_{false};
source/game/scenes/scene.hpp
+2 -2
View File
@@ -24,14 +24,14 @@ namespace scenes {
virtual void tick(int delta_ms) = 0;
virtual bool done() const = 0;
[[nodiscard]] virtual auto done() const -> bool = 0;
// Valor retornat al caller quan l'escena acaba — equivalent al int
// que retornaven les velles funcions `Go()` de ModuleSequence:
// 1 = continuar amb la següent escena segons info::ctx
// 0 = entrar al gameplay (ModuleGame)
// -1 = eixir del joc
virtual int nextState() const { return 1; }
[[nodiscard]] virtual auto nextState() const -> int { return 1; }
};
} // namespace scenes
source/game/scenes/scene_registry.cpp
+5 -3
View File
@@ -2,7 +2,7 @@
namespace scenes {
SceneRegistry& SceneRegistry::instance() {
auto SceneRegistry::instance() -> SceneRegistry& {
static SceneRegistry inst;
return inst;
}
@@ -11,9 +11,11 @@ namespace scenes {
factories_[state_key] = std::move(factory);
}
std::unique_ptr<Scene> SceneRegistry::tryCreate(int state_key) const {
auto SceneRegistry::tryCreate(int state_key) const -> std::unique_ptr<Scene> {
const auto it = factories_.find(state_key);
if (it == factories_.end()) return nullptr;
if (it == factories_.end()) {
return nullptr;
}
return it->second();
}
source/game/scenes/scene_registry.hpp
+2 -2
View File
@@ -21,13 +21,13 @@ namespace scenes {
public:
using Factory = std::function<std::unique_ptr<Scene>()>;
static SceneRegistry& instance();
static auto instance() -> SceneRegistry&;
void registerScene(int state_key, Factory factory);
// Retorna `nullptr` si no hi ha cap escena registrada per a aquest
// state. El caller hauria de caure al path legacy en aquest cas.
std::unique_ptr<Scene> tryCreate(int state_key) const;
auto tryCreate(int state_key) const -> std::unique_ptr<Scene>;
private:
SceneRegistry() = default;
source/game/scenes/scene_utils.cpp
+4 -2
View File
@@ -7,7 +7,7 @@
namespace scenes {
namespace {
std::string basename(const char* path) {
auto basename(const char* path) -> std::string {
std::string s = path;
auto pos = s.find_last_of("/\\");
return pos == std::string::npos ? s : s.substr(pos + 1);
@@ -15,7 +15,9 @@ namespace scenes {
} // namespace
void playMusic(const char* filename, int loop) {
if (!filename) return;
if (filename == nullptr) {
return;
}
Audio::get()->playMusic(basename(filename), loop);
}
source/game/scenes/secreta_scene.cpp
+3 -3
View File
@@ -107,7 +107,7 @@ namespace scenes {
case Phase::Tomba1ScrollIn: {
phase_acc_ms_ += delta_ms;
const int contador = std::min(128, phase_acc_ms_ / TICK_MS + 1);
const int contador = std::min(128, (phase_acc_ms_ / TICK_MS) + 1);
// Dos blits solapats: el primer avança a velocitat completa,
// el segon (contingut de la dreta del src) a meitat (contador>>1).
JD8_Blit(70, 60, gfx_, 0, contador, 178, 70);
@@ -130,7 +130,7 @@ namespace scenes {
case Phase::Tomba2ScrollIn: {
phase_acc_ms_ += delta_ms;
const int contador = std::min(94, phase_acc_ms_ / TICK_MS + 1);
const int contador = std::min(94, (phase_acc_ms_ / TICK_MS) + 1);
JD8_Blit(55, 53, gfx_, 0, 158 - contador, 211, contador);
if (phase_acc_ms_ >= TOMBA2_SCROLL_MS) {
phase_ = Phase::Tomba2Hold;
@@ -150,7 +150,7 @@ namespace scenes {
case Phase::Tomba2Reveal: {
phase_acc_ms_ += delta_ms;
const int contador = std::min(80, phase_acc_ms_ / TICK_MS + 1);
const int contador = std::min(80, (phase_acc_ms_ / TICK_MS) + 1);
// Revelat horitzontal simètric: l'amplada creix 2px per tick
// i el src_x es desplaça a l'esquerra el mateix.
JD8_Blit(80, 68, gfx_, 160 - (contador * 2), 0, contador * 2, 64);
source/game/scenes/secreta_scene.hpp
+3 -3
View File
@@ -31,8 +31,8 @@ namespace scenes {
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
int nextState() const override { return 0; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
[[nodiscard]] auto nextState() const -> int override { return 0; }
private:
enum class Phase {
@@ -50,7 +50,7 @@ namespace scenes {
};
void swapToTomba2();
void beginRedPulseSetup();
static void beginRedPulseSetup();
void beginFinalFade();
SurfaceHandle gfx_;
source/game/scenes/slides_scene.cpp
+14 -9
View File
@@ -105,7 +105,9 @@ namespace scenes {
// el final natural crida JA_FadeOutMusic (beginFinalFade() distingeix).
if (!skip_triggered_ && JI_AnyKey()) {
skip_triggered_ = true;
if (num_piramide_at_start_ != 7) Audio::get()->fadeOutMusic(250);
if (num_piramide_at_start_ != 7) {
Audio::get()->fadeOutMusic(250);
}
fade_.startFadeOut();
phase_ = Phase::FadeFinal;
}
@@ -118,7 +120,7 @@ namespace scenes {
const int slide_idx = (phase_ == Phase::Slide1Enter ? 0
: phase_ == Phase::Slide2Enter ? 1
: 2);
const float t = std::min(1.0f, static_cast<float>(phase_acc_ms_) / static_cast<float>(SCROLL_MS));
const float t = std::min(1.0F, static_cast<float>(phase_acc_ms_) / static_cast<float>(SCROLL_MS));
const float eased = Easing::outCubic(t);
const int pos_x = Easing::lerpInt(SLIDE_START_X[slide_idx], 0, eased);
drawSlide(slide_idx, pos_x);
@@ -126,12 +128,13 @@ namespace scenes {
if (phase_acc_ms_ >= SCROLL_MS) {
// Garanteix posició final exacta (pos_x=0).
drawSlide(slide_idx, 0);
if (phase_ == Phase::Slide1Enter)
if (phase_ == Phase::Slide1Enter) {
phase_ = Phase::Slide1Hold;
else if (phase_ == Phase::Slide2Enter)
} else if (phase_ == Phase::Slide2Enter) {
phase_ = Phase::Slide2Hold;
else
} else {
phase_ = Phase::Slide3Hold;
}
phase_acc_ms_ = 0;
}
break;
@@ -142,10 +145,11 @@ namespace scenes {
phase_acc_ms_ += delta_ms;
if (phase_acc_ms_ >= HOLD_MS) {
fade_.startFadeOut();
if (phase_ == Phase::Slide1Hold)
if (phase_ == Phase::Slide1Hold) {
phase_ = Phase::FadeOut1;
else
} else {
phase_ = Phase::FadeOut2;
}
phase_acc_ms_ = 0;
}
break;
@@ -163,10 +167,11 @@ namespace scenes {
if (fade_.done()) {
restorePalette();
JD8_ClearScreen(BG_COLOR_INDEX);
if (phase_ == Phase::FadeOut1)
if (phase_ == Phase::FadeOut1) {
phase_ = Phase::Slide2Enter;
else
} else {
phase_ = Phase::Slide3Enter;
}
phase_acc_ms_ = 0;
}
break;
source/game/scenes/slides_scene.hpp
+2 -2
View File
@@ -40,8 +40,8 @@ namespace scenes {
void onEnter() override;
void tick(int delta_ms) override;
bool done() const override { return phase_ == Phase::Done; }
int nextState() const override { return next_state_; }
[[nodiscard]] auto done() const -> bool override { return phase_ == Phase::Done; }
[[nodiscard]] auto nextState() const -> int override { return next_state_; }
private:
enum class Phase {
source/game/scenes/sprite_mover.cpp
+5 -3
View File
@@ -11,7 +11,7 @@ namespace scenes {
y1_ = y1;
duration_ms_ = std::max(0, duration_ms);
elapsed_ms_ = 0;
ease_ = ease ? ease : Easing::linear;
ease_ = (ease != nullptr) ? ease : Easing::linear;
cur_x_ = x0;
cur_y_ = y0;
}
@@ -38,8 +38,10 @@ namespace scenes {
cur_y_ = Easing::lerpInt(y0_, y1_, eased);
}
float SpriteMover::progress() const {
if (duration_ms_ <= 0) return 1.0f;
auto SpriteMover::progress() const -> float {
if (duration_ms_ <= 0) {
return 1.0F;
}
return static_cast<float>(elapsed_ms_) / static_cast<float>(duration_ms_);
}
source/game/scenes/sprite_mover.hpp
+4 -4
View File
@@ -22,10 +22,10 @@ namespace scenes {
void tick(int delta_ms);
int x() const { return cur_x_; }
int y() const { return cur_y_; }
bool done() const { return elapsed_ms_ >= duration_ms_; }
float progress() const; // 0..1 sense easing aplicat
[[nodiscard]] auto x() const -> int { return cur_x_; }
[[nodiscard]] auto y() const -> int { return cur_y_; }
[[nodiscard]] auto done() const -> bool { return elapsed_ms_ >= duration_ms_; }
[[nodiscard]] auto progress() const -> float; // 0..1 sense easing aplicat
private:
int x0_{0}, y0_{0}, x1_{0}, y1_{0};
source/game/scenes/surface_handle.cpp
+15 -7
View File
@@ -6,7 +6,9 @@ namespace scenes {
: surface_(JD8_LoadSurface(file)) {}
SurfaceHandle::~SurfaceHandle() {
if (surface_) JD8_FreeSurface(surface_);
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
}
}
SurfaceHandle::SurfaceHandle(SurfaceHandle&& other) noexcept
@@ -14,9 +16,11 @@ namespace scenes {
other.surface_ = nullptr;
}
SurfaceHandle& SurfaceHandle::operator=(SurfaceHandle&& other) noexcept {
auto SurfaceHandle::operator=(SurfaceHandle&& other) noexcept -> SurfaceHandle& {
if (this != &other) {
if (surface_) JD8_FreeSurface(surface_);
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
}
surface_ = other.surface_;
other.surface_ = nullptr;
}
@@ -24,16 +28,20 @@ namespace scenes {
}
void SurfaceHandle::reset(const char* file) {
if (surface_) JD8_FreeSurface(surface_);
surface_ = file ? JD8_LoadSurface(file) : nullptr;
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
}
surface_ = (file != nullptr) ? JD8_LoadSurface(file) : nullptr;
}
void SurfaceHandle::adopt(JD8_Surface raw) {
if (surface_) JD8_FreeSurface(surface_);
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
}
surface_ = raw;
}
JD8_Surface SurfaceHandle::release() {
auto SurfaceHandle::release() -> JD8_Surface {
JD8_Surface r = surface_;
surface_ = nullptr;
return r;
source/game/scenes/surface_handle.hpp
+5 -5
View File
@@ -15,10 +15,10 @@ namespace scenes {
~SurfaceHandle();
SurfaceHandle(const SurfaceHandle&) = delete;
SurfaceHandle& operator=(const SurfaceHandle&) = delete;
auto operator=(const SurfaceHandle&) -> SurfaceHandle& = delete;
SurfaceHandle(SurfaceHandle&& other) noexcept;
SurfaceHandle& operator=(SurfaceHandle&& other) noexcept;
auto operator=(SurfaceHandle&& other) noexcept -> SurfaceHandle&;
// Allibera la surface actual (si n'hi ha) i carrega una nova.
// Usat per escenes que recarreguen assets a mitja cinemàtica
@@ -34,13 +34,13 @@ namespace scenes {
// altre propietari). Usat quan una escena delega a codi legacy que
// també allibera la mateixa surface — cal "soltar" el ownership per
// evitar double free.
[[nodiscard]] JD8_Surface release();
[[nodiscard]] auto release() -> JD8_Surface;
// Conversió implícita per al confort d'ús: JD8_Blit(handle)
// en lloc de JD8_Blit(handle.get()).
operator JD8_Surface() const { return surface_; }
JD8_Surface get() const { return surface_; }
bool valid() const { return surface_ != nullptr; }
[[nodiscard]] auto get() const -> JD8_Surface { return surface_; }
[[nodiscard]] auto valid() const -> bool { return surface_ != nullptr; }
private:
JD8_Surface surface_{nullptr};
source/game/scenes/timeline.cpp
+28 -12
View File
@@ -4,7 +4,7 @@
namespace scenes {
Timeline& Timeline::step(int duration_ms, StepFn fn) {
auto Timeline::step(int duration_ms, StepFn fn) -> Timeline& {
Step s;
s.duration_ms = duration_ms;
s.continuous = std::move(fn);
@@ -12,7 +12,7 @@ namespace scenes {
return *this;
}
Timeline& Timeline::once(OnceFn fn) {
auto Timeline::once(OnceFn fn) -> Timeline& {
Step s;
s.duration_ms = 0;
s.oneshot = std::move(fn);
@@ -25,7 +25,9 @@ namespace scenes {
auto& s = steps_[current_];
if (!s.entered) {
s.entered = true;
if (s.oneshot) s.oneshot();
if (s.oneshot) {
s.oneshot();
}
}
++current_;
elapsed_in_step_ = 0;
@@ -33,21 +35,29 @@ namespace scenes {
}
void Timeline::tick(int delta_ms) {
if (skipped_) return;
if (skipped_) {
return;
}
flushOneShots();
if (current_ >= steps_.size()) return;
if (current_ >= steps_.size()) {
return;
}
auto& s = steps_[current_];
if (!s.entered) {
s.entered = true;
// Primer tick dins del pas: cridem amb progress=0 si hi ha callback.
if (s.continuous) s.continuous(0.0f);
if (s.continuous) {
s.continuous(0.0F);
}
}
elapsed_in_step_ += delta_ms;
if (elapsed_in_step_ >= s.duration_ms) {
// Tancament del pas: una crida final amb progress=1.
if (s.continuous) s.continuous(1.0f);
if (s.continuous) {
s.continuous(1.0F);
}
++current_;
elapsed_in_step_ = 0;
// Pot ser que el següent pas siga una cadena de one-shots.
@@ -65,20 +75,26 @@ namespace scenes {
}
void Timeline::reset() {
for (auto& s : steps_) s.entered = false;
for (auto& s : steps_) {
s.entered = false;
}
current_ = 0;
elapsed_in_step_ = 0;
skipped_ = false;
}
bool Timeline::done() const {
auto Timeline::done() const -> bool {
return skipped_ || current_ >= steps_.size();
}
float Timeline::currentProgress() const {
if (current_ >= steps_.size()) return 1.0f;
auto Timeline::currentProgress() const -> float {
if (current_ >= steps_.size()) {
return 1.0F;
}
const auto& s = steps_[current_];
if (s.duration_ms <= 0) return 0.0f;
if (s.duration_ms <= 0) {
return 0.0F;
}
return static_cast<float>(elapsed_in_step_) / static_cast<float>(s.duration_ms);
}
source/game/scenes/timeline.hpp
+5 -5
View File
@@ -25,16 +25,16 @@ namespace scenes {
using StepFn = std::function<void(float progress_0_1)>;
using OnceFn = std::function<void()>;
Timeline& step(int duration_ms, StepFn fn = nullptr);
Timeline& once(OnceFn fn);
auto step(int duration_ms, StepFn fn = nullptr) -> Timeline&;
auto once(OnceFn fn) -> Timeline&;
void tick(int delta_ms);
void skip();
void reset();
bool done() const;
int currentStepIndex() const { return static_cast<int>(current_); }
float currentProgress() const;
[[nodiscard]] auto done() const -> bool;
[[nodiscard]] auto currentStepIndex() const -> int { return static_cast<int>(current_); }
[[nodiscard]] auto currentProgress() const -> float;
private:
struct Step {