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

refactor: JD8_* a namespace Jd8::

Browse Source
This commit is contained in:
Sergio Valor
2026-05-16 14:24:22 +02:00
parent 1ce0d9c56c
commit f37308a5f0
41 changed files with 394 additions and 396 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/game/scenes/banner_scene.cpp
+5 -5
View File
@@ -15,10 +15,10 @@ namespace scenes {
gfx_ = SurfaceHandle("gfx/ffase.gif");
JD8_ClearScreen(0);
Jd8::clearScreen(0);
// Títols superior i inferior del banner (compartits per tots els nivells)
JD8_Blit(81, 24, gfx_, 81, 155, 168, 21);
JD8_Blit(39, 150, gfx_, 39, 175, 248, 20);
Jd8::blit(81, 24, gfx_, 81, 155, 168, 21);
Jd8::blit(39, 150, gfx_, 39, 175, 248, 20);
// Número de piràmide: les 4 variants del vell `doBanner` es reduïxen
// a coordenades (sx,sy) calculades a partir de l'índex 0..3.
@@ -26,11 +26,11 @@ namespace scenes {
if (idx >= 0 && idx <= 3) {
const int sx = (idx % 2) * 160;
const int sy = (idx / 2) * 75;
JD8_Blit(82, 60, gfx_, sx, sy, 160, 75);
Jd8::blit(82, 60, gfx_, sx, sy, 160, 75);
}
// PaletteFade copia internament amb memcpy; alliberem la paleta temporal.
JD8_Palette pal = JD8_LoadPalette("gfx/ffase.gif");
Jd8::Palette pal = Jd8::loadPalette("gfx/ffase.gif");
fade_.startFadeTo(pal);
delete[] pal;
source/game/scenes/boot_loader_scene.cpp
+8 -8
View File
@@ -24,8 +24,8 @@ namespace scenes {
// Inicialitza la paleta mínima per a la barra. La resta de
// colors queden a negre — després cada escena del joc carregarà
// la seua pròpia paleta.
JD8_SetPaletteColor(BG_COLOR, 0, 0, 0);
JD8_SetPaletteColor(BAR_COLOR, 63, 63, 63);
Jd8::setPaletteColor(BG_COLOR, 0, 0, 0);
Jd8::setPaletteColor(BAR_COLOR, 63, 63, 63);
}
void BootLoaderScene::tick(int /*delta_ms*/) {
@@ -36,7 +36,7 @@ namespace scenes {
}
void BootLoaderScene::render() {
JD8_ClearScreen(BG_COLOR);
Jd8::clearScreen(BG_COLOR);
if (!Options::game.show_preload) {
return;
@@ -46,14 +46,14 @@ namespace scenes {
const int filled = static_cast<int>(static_cast<float>(BAR_W) * pct);
// Vora de la barra (línia 1 píxel a dalt i a baix).
JD8_FillRect(BAR_X - 1, BAR_Y - 1, BAR_W + 2, 1, BAR_COLOR);
JD8_FillRect(BAR_X - 1, BAR_Y + BAR_H, BAR_W + 2, 1, BAR_COLOR);
JD8_FillRect(BAR_X - 1, BAR_Y, 1, BAR_H, BAR_COLOR);
JD8_FillRect(BAR_X + BAR_W, BAR_Y, 1, BAR_H, BAR_COLOR);
Jd8::fillRect(BAR_X - 1, BAR_Y - 1, BAR_W + 2, 1, BAR_COLOR);
Jd8::fillRect(BAR_X - 1, BAR_Y + BAR_H, BAR_W + 2, 1, BAR_COLOR);
Jd8::fillRect(BAR_X - 1, BAR_Y, 1, BAR_H, BAR_COLOR);
Jd8::fillRect(BAR_X + BAR_W, BAR_Y, 1, BAR_H, BAR_COLOR);
// Ompliment proporcional al progrés.
if (filled > 0) {
JD8_FillRect(BAR_X, BAR_Y, filled, BAR_H, BAR_COLOR);
Jd8::fillRect(BAR_X, BAR_Y, filled, BAR_H, BAR_COLOR);
}
}
source/game/scenes/credits_scene.cpp
+15 -15
View File
@@ -52,8 +52,8 @@ namespace scenes {
vaddr2_ = SurfaceHandle("gfx/final.gif");
vaddr3_ = SurfaceHandle("gfx/finals.gif");
JD8_Palette pal = JD8_LoadPalette("gfx/final.gif");
JD8_SetScreenPalette(pal);
Jd8::Palette pal = Jd8::loadPalette("gfx/final.gif");
Jd8::setScreenPalette(pal);
// `pal` passa a ser propietat de main_palette — no l'alliberem.
phase_ = Phase::Rolling;
@@ -62,40 +62,40 @@ namespace scenes {
}
void CreditsScene::render() {
JD8_ClearScreen(BG_INDEX);
Jd8::clearScreen(BG_INDEX);
// Columna 1: scroll vertical del bloc (0,0,80,200) pujant des de
// y=200 fins que el contador supera 2750.
if (contador_ < 2750) {
JD8_BlitCKCut(115, 200 - (contador_ / 6), vaddr2_, 0, 0, 80, 200, 0);
Jd8::blitCKCut(115, 200 - (contador_ / 6), vaddr2_, 0, 0, 80, 200, 0);
}
// Columna 2: scroll vertical del bloc (85,0,120,140), arrenca
// a contador 1200 i s'atura (fix en y=20) a partir de 2250.
if ((contador_ > 1200) && (contador_ < 2280)) {
JD8_BlitCKCut(100, 200 - ((contador_ - 1200) / 6), vaddr2_, 85, 0, 120, 140, 0);
Jd8::blitCKCut(100, 200 - ((contador_ - 1200) / 6), vaddr2_, 85, 0, 120, 140, 0);
} else if (contador_ >= 2250) {
JD8_BlitCK(100, 20, vaddr2_, 85, 0, 120, 140, 0);
Jd8::blitCK(100, 20, vaddr2_, 85, 0, 120, 140, 0);
}
// Fons: 4 capes parallax + cotxe només si l'usuari ha aconseguit
// tots els diamants (final "bo"). Altrament fons estàtic.
if (info::ctx.diamants == 16) {
JD8_BlitCKScroll(50, vaddr3_, ((contador_ >> 3) % 320) + 1, 0, 50, 255);
JD8_BlitCKScroll(50, vaddr3_, ((contador_ >> 2) % 320) + 1, 50, 50, 255);
JD8_BlitCKScroll(50, vaddr3_, ((contador_ >> 1) % 320) + 1, 100, 50, 255);
JD8_BlitCKScroll(50, vaddr3_, (contador_ % 320) + 1, 150, 50, 255);
Jd8::blitCKScroll(50, vaddr3_, ((contador_ >> 3) % 320) + 1, 0, 50, 255);
Jd8::blitCKScroll(50, vaddr3_, ((contador_ >> 2) % 320) + 1, 50, 50, 255);
Jd8::blitCKScroll(50, vaddr3_, ((contador_ >> 1) % 320) + 1, 100, 50, 255);
Jd8::blitCKScroll(50, vaddr3_, (contador_ % 320) + 1, 150, 50, 255);
const CocheFrame& cf = COCHE_FRAMES[coche_.frame()];
JD8_BlitCK(100, 50, vaddr2_, cf.x, cf.y, 106, 48, 255);
Jd8::blitCK(100, 50, vaddr2_, cf.x, cf.y, 106, 48, 255);
} else {
JD8_BlitCK(0, 50, vaddr3_, 0, 0, 320, 50, 255);
JD8_BlitCK(0, 50, vaddr3_, 0, 50, 320, 50, 255);
Jd8::blitCK(0, 50, vaddr3_, 0, 0, 320, 50, 255);
Jd8::blitCK(0, 50, vaddr3_, 0, 50, 320, 50, 255);
}
// Barres de marc que cobreixen els extrems del scroll vertical.
JD8_FillSquare(0, 50, BG_INDEX);
JD8_FillSquare(100, 10, BG_INDEX);
Jd8::fillSquare(0, 50, BG_INDEX);
Jd8::fillSquare(100, 10, BG_INDEX);
}
void CreditsScene::writeTrickIni() {
source/game/scenes/intro_new_logo_scene.cpp
+14 -14
View File
@@ -41,7 +41,7 @@ namespace scenes {
IntroNewLogoScene::IntroNewLogoScene() = default;
// No alliberem `pal_`: JD8_SetScreenPalette n'ha pres ownership i el
// No alliberem `pal_`: Jd8::setScreenPalette n'ha pres ownership i el
// proper SetScreenPalette / FadeToPal el lliurarà. Alliberar-lo ací
// provocaria double free.
IntroNewLogoScene::~IntroNewLogoScene() = default;
@@ -50,15 +50,15 @@ namespace scenes {
playMusic("music/menu.ogg");
gfx_ = SurfaceHandle("gfx/logo_new.gif");
pal_ = JD8_LoadPalette("gfx/logo_new.gif");
JD8_SetScreenPalette(pal_);
pal_ = Jd8::loadPalette("gfx/logo_new.gif");
Jd8::setScreenPalette(pal_);
// Surface auxiliar omplida amb el color del cursor — permet pintar
// el "subratllat" amb un blit normal.
cursor_surf_.adopt(JD8_NewSurface());
cursor_surf_.adopt(Jd8::newSurface());
std::memset(cursor_surf_.get(), CURSOR_COLOR, 64000);
JD8_ClearScreen(0);
Jd8::clearScreen(0);
phase_ = Phase::Initial;
phase_acc_ms_ = 0;
@@ -70,30 +70,30 @@ namespace scenes {
void IntroNewLogoScene::render() {
switch (phase_) {
case Phase::Initial:
JD8_ClearScreen(0);
Jd8::clearScreen(0);
break;
case Phase::Revealing: {
JD8_ClearScreen(0);
JD8_Blit(LOGO_DST_X, LOGO_DST_Y, gfx_, LOGO_SRC_X, LOGO_SRC_Y, LETTER_WIDTHS[reveal_letter_], LOGO_HEIGHT);
Jd8::clearScreen(0);
Jd8::blit(LOGO_DST_X, LOGO_DST_Y, gfx_, LOGO_SRC_X, LOGO_SRC_Y, LETTER_WIDTHS[reveal_letter_], LOGO_HEIGHT);
if (reveal_cursor_visible_) {
JD8_Blit(CURSOR_X[reveal_letter_], CURSOR_Y, cursor_surf_, 0, 0, CURSOR_W, CURSOR_H);
Jd8::blit(CURSOR_X[reveal_letter_], CURSOR_Y, cursor_surf_, 0, 0, CURSOR_W, CURSOR_H);
}
break;
}
case Phase::FullLogoFlash:
JD8_ClearScreen(0);
JD8_Blit(LOGO_DST_X, LOGO_DST_Y, gfx_, LOGO_SRC_X, LOGO_SRC_Y, LETTER_WIDTHS[8], LOGO_HEIGHT);
JD8_Blit(CURSOR_X[8], CURSOR_Y, cursor_surf_, 0, 0, CURSOR_W, CURSOR_H);
Jd8::clearScreen(0);
Jd8::blit(LOGO_DST_X, LOGO_DST_Y, gfx_, LOGO_SRC_X, LOGO_SRC_Y, LETTER_WIDTHS[8], LOGO_HEIGHT);
Jd8::blit(CURSOR_X[8], CURSOR_Y, cursor_surf_, 0, 0, CURSOR_W, CURSOR_H);
break;
case Phase::PaletteCycle:
case Phase::FinalWait:
// Logo complet sense cursor — els pixels del cursor
// ciclarien de color durant el cicle de paleta.
JD8_ClearScreen(0);
JD8_Blit(LOGO_DST_X, LOGO_DST_Y, gfx_, LOGO_SRC_X, LOGO_SRC_Y, LETTER_WIDTHS[8], LOGO_HEIGHT);
Jd8::clearScreen(0);
Jd8::blit(LOGO_DST_X, LOGO_DST_Y, gfx_, LOGO_SRC_X, LOGO_SRC_Y, LETTER_WIDTHS[8], LOGO_HEIGHT);
break;
case Phase::Sprites:
source/game/scenes/intro_new_logo_scene.hpp
+1 -1
View File
@@ -55,7 +55,7 @@ namespace scenes {
SurfaceHandle gfx_;
SurfaceHandle cursor_surf_;
JD8_Palette pal_{nullptr}; // propietat transferida a main_palette via SetScreenPalette
Jd8::Palette pal_{nullptr}; // propietat transferida a main_palette via SetScreenPalette
std::unique_ptr<IntroSpritesScene> sprites_scene_;
Phase phase_{Phase::Initial};
source/game/scenes/intro_scene.cpp
+10 -10
View File
@@ -50,7 +50,7 @@ namespace {
// IntroScene només s'activa quan use_new_logo == false, així que la
// branca use_new_logo d'aquell helper aquí no es necessita.
void drawWordmark(const Uint8* gfx) {
JD8_Blit(43, 78, gfx, 43, 155, 231, 45);
Jd8::blit(43, 78, gfx, 43, 155, 231, 45);
}
} // namespace
@@ -59,7 +59,7 @@ namespace scenes {
IntroScene::IntroScene() = default;
// No alliberem `pal_`: JD8_SetScreenPalette n'ha pres ownership i el
// No alliberem `pal_`: Jd8::setScreenPalette n'ha pres ownership i el
// proper SetScreenPalette / FadeToPal la lliurarà. Alliberar-la ací
// provocaria double free.
IntroScene::~IntroScene() = default;
@@ -68,10 +68,10 @@ namespace scenes {
playMusic("music/menu.ogg");
gfx_ = SurfaceHandle("gfx/logo.gif");
pal_ = JD8_LoadPalette("gfx/logo.gif");
JD8_SetScreenPalette(pal_);
pal_ = Jd8::loadPalette("gfx/logo.gif");
Jd8::setScreenPalette(pal_);
JD8_ClearScreen(0);
Jd8::clearScreen(0);
phase_ = Phase::InitialWait;
phase_acc_ms_ = 0;
@@ -82,21 +82,21 @@ namespace scenes {
void IntroScene::render() {
switch (phase_) {
case Phase::InitialWait:
JD8_ClearScreen(0);
Jd8::clearScreen(0);
break;
case Phase::Reveal: {
const RevealStep& s = REVEAL_STEPS[reveal_index_];
if (s.clear) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
}
if (s.wordmark) {
drawWordmark(gfx_);
} else if (s.body_w > 0) {
JD8_Blit(43, 78, gfx_, 43, 155, s.body_w, 45);
Jd8::blit(43, 78, gfx_, 43, 155, s.body_w, 45);
}
if (s.plane_x >= 0) {
JD8_Blit(s.plane_x, 78, gfx_, 274, 155, 27, 45);
Jd8::blit(s.plane_x, 78, gfx_, 274, 155, 27, 45);
}
break;
}
@@ -106,7 +106,7 @@ namespace scenes {
// Wordmark complet fix mentre cicla la paleta — l'últim
// pas del revelat (PAS 15) deixa la pantalla en aquest mateix
// estat, i el vell doIntro no redibuixava durant el cicle.
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx_);
break;
source/game/scenes/intro_scene.hpp
+1 -1
View File
@@ -54,7 +54,7 @@ namespace scenes {
void advancePaletteCycle();
SurfaceHandle gfx_;
JD8_Palette pal_{nullptr}; // propietat transferida a main_palette via SetScreenPalette
Jd8::Palette pal_{nullptr}; // propietat transferida a main_palette via SetScreenPalette
std::unique_ptr<IntroSpritesScene> sprites_scene_;
Phase phase_{Phase::InitialWait};
source/game/scenes/intro_sprites_scene.cpp
+70 -70
View File
@@ -55,9 +55,9 @@ namespace {
void drawWordmark(const Uint8* gfx) {
if (Options::game.use_new_logo) {
// Centrat: (320 − 188) / 2 = 66 (IntroNewLogoScene usa la mateixa x).
JD8_Blit(66, 78, gfx, 60, 158, 188, 28);
Jd8::blit(66, 78, gfx, 60, 158, 188, 28);
} else {
JD8_Blit(43, 78, gfx, 43, 155, 231, 45);
Jd8::blit(43, 78, gfx, 43, 155, 231, 45);
}
}
@@ -79,70 +79,70 @@ namespace {
// =========================================================================
void v0_walk_right(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(i, 150, gfx, fr1[(i / 5) % 13], 0, 15, 15, 0);
Jd8::blitCK(i, 150, gfx, fr1[(i / 5) % 13], 0, 15, 15, 0);
}
void v0_pull_map_right(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 150, gfx, fr3[std::min(i / 5, 10)], 30, 15, 15, 0);
Jd8::blitCK(200, 150, gfx, fr3[std::min(i / 5, 10)], 30, 15, 15, 0);
}
void v0_walk_left_to_80(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(i, 150, gfx, fr2[(i / 5) % 13], 15, 15, 15, 0);
Jd8::blitCK(i, 150, gfx, fr2[(i / 5) % 13], 15, 15, 15, 0);
}
void v0_pull_map_left(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(80, 150, gfx, fr4[std::min(i / 5, 10)], 45, 15, 15, 0);
Jd8::blitCK(80, 150, gfx, fr4[std::min(i / 5, 10)], 45, 15, 15, 0);
}
void v0_momia_left(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(i, 150, gfx, fr6[(i / 5) % 8], 60, 15, 15, 0);
JD8_BlitCK(80, 150, gfx, fr4[10], 45, 15, 15, 0);
Jd8::blitCK(i, 150, gfx, fr6[(i / 5) % 8], 60, 15, 15, 0);
Jd8::blitCK(80, 150, gfx, fr4[10], 45, 15, 15, 0);
}
void v0_turn(const Uint8* gfx, int /*i*/) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(80, 150, gfx, fr1[1], 0, 15, 15, 0);
JD8_BlitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
JD8_BlitCK(80, 133, gfx, 0, INTERROGANT, 15, 15, 0);
Jd8::blitCK(80, 150, gfx, fr1[1], 0, 15, 15, 0);
Jd8::blitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
Jd8::blitCK(80, 133, gfx, 0, INTERROGANT, 15, 15, 0);
}
void v0_jump1(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(80, 150 - ((i % 50) / 5), gfx, fr5[std::min(i / 5, 19)], 45, 15, 15, 0);
JD8_BlitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
Jd8::blitCK(80, 150 - ((i % 50) / 5), gfx, fr5[std::min(i / 5, 19)], 45, 15, 15, 0);
Jd8::blitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
}
void v0_jump2(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(80, 140 + ((i % 50) / 5), gfx, fr5[std::min(i / 5, 19)], 45, 15, 15, 0);
JD8_BlitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
Jd8::blitCK(80, 140 + ((i % 50) / 5), gfx, fr5[std::min(i / 5, 19)], 45, 15, 15, 0);
Jd8::blitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
}
void v0_walk_final(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(i, 150, gfx, fr2[(i / 5) % 13], 15, 15, 15, 0);
JD8_BlitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
Jd8::blitCK(i, 150, gfx, fr2[(i / 5) % 13], 15, 15, 15, 0);
Jd8::blitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
}
void v0_final(const Uint8* gfx, int /*i*/) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
JD8_BlitCK(95, 133, gfx, 0, INTERROGANT, 15, 15, 0);
Jd8::blitCK(95, 150, gfx, fr6[4], 60, 15, 15, 0);
Jd8::blitCK(95, 133, gfx, 0, INTERROGANT, 15, 15, 0);
}
constexpr SpritePhase variant_0[] = {
@@ -164,63 +164,63 @@ namespace {
// =========================================================================
void v1_walk_right(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
JD8_BlitCK(i, 150, gfx, fr1[(i / 5) % 13], 0, 15, 15, 255);
Jd8::blitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
Jd8::blitCK(i, 150, gfx, fr1[(i / 5) % 13], 0, 15, 15, 255);
}
void v1_pull_map(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
JD8_BlitCK(200, 150, gfx, fr3[std::min(i / 5, 10)], 30, 15, 15, 255);
Jd8::blitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
Jd8::blitCK(200, 150, gfx, fr3[std::min(i / 5, 10)], 30, 15, 15, 255);
}
void v1_interrogant(const Uint8* gfx, int /*i*/) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
JD8_BlitCK(200, 134, gfx, 0, INTERROGANT, 15, 15, 255);
JD8_BlitCK(200, 150, gfx, fr3[10], 30, 15, 15, 255);
Jd8::blitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
Jd8::blitCK(200, 134, gfx, 0, INTERROGANT, 15, 15, 255);
Jd8::blitCK(200, 150, gfx, fr3[10], 30, 15, 15, 255);
}
void v1_drop_map(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
Jd8::blitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
const int idx = std::min(i / 5, 28);
// fr7 té 29 frames dividits en dos grups: paper (idx 0..13, src_y=75)
// i sombra (idx 14..28, src_y=105). El vell feia una branca al bucle.
if (idx <= 13) {
JD8_BlitCK(200, 150, gfx, fr7[idx], 75, 15, 15, 255);
Jd8::blitCK(200, 150, gfx, fr7[idx], 75, 15, 15, 255);
} else {
JD8_BlitCK(200, 150, gfx, fr7[idx], 105, 15, 15, 255);
Jd8::blitCK(200, 150, gfx, fr7[idx], 105, 15, 15, 255);
}
}
void v1_stone_fall(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
JD8_BlitCK(200, 150, gfx, fr7[28], 105, 15, 15, 255);
JD8_BlitCK(200, i * 2, gfx, fr8[0], 75, 15, 15, 255);
Jd8::blitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
Jd8::blitCK(200, 150, gfx, fr7[28], 105, 15, 15, 255);
Jd8::blitCK(200, i * 2, gfx, fr8[0], 75, 15, 15, 255);
}
void v1_stone_break(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
JD8_BlitCK(200, 150, gfx, fr8[i / 10], 75, 15, 15, 255);
Jd8::blitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
Jd8::blitCK(200, 150, gfx, fr8[i / 10], 75, 15, 15, 255);
}
void v1_final(const Uint8* gfx, int /*i*/) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
JD8_BlitCK(200, 150, gfx, fr8[1], 75, 15, 15, 255);
JD8_BlitCK(185, 150, gfx, fr8[2], 75, 15, 15, 255);
JD8_BlitCK(215, 150, gfx, fr8[3], 75, 15, 15, 255);
Jd8::blitCK(200, 155, gfx, 0, CREU, 15, 15, 255);
Jd8::blitCK(200, 150, gfx, fr8[1], 75, 15, 15, 255);
Jd8::blitCK(185, 150, gfx, fr8[2], 75, 15, 15, 255);
Jd8::blitCK(215, 150, gfx, fr8[3], 75, 15, 15, 255);
}
constexpr SpritePhase variant_1[] = {
@@ -238,33 +238,33 @@ namespace {
// =========================================================================
void v2_approach(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(i, 150, gfx, fr1[(i / 5) % 13], 0, 15, 15, 255);
JD8_BlitCK(304 - i, 150, gfx, fr6[(i / 10) % 8], 60, 15, 15, 255);
Jd8::blitCK(i, 150, gfx, fr1[(i / 5) % 13], 0, 15, 15, 255);
Jd8::blitCK(304 - i, 150, gfx, fr6[(i / 10) % 8], 60, 15, 15, 255);
}
void v2_still(const Uint8* gfx, int /*i*/) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(145, 150, gfx, fr1[1], 0, 15, 15, 255);
JD8_BlitCK(160, 150, gfx, fr6[1], 60, 15, 15, 255);
Jd8::blitCK(145, 150, gfx, fr1[1], 0, 15, 15, 255);
Jd8::blitCK(160, 150, gfx, fr6[1], 60, 15, 15, 255);
}
void v2_horn(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(125, 150, gfx, fr11[(i / 10) % 2], 90, 15, 15, 255);
JD8_BlitCK(145, 150, gfx, fr1[1], 0, 15, 15, 255);
JD8_BlitCK(160, 150, gfx, fr6[1], 60, 15, 15, 255);
Jd8::blitCK(125, 150, gfx, fr11[(i / 10) % 2], 90, 15, 15, 255);
Jd8::blitCK(145, 150, gfx, fr1[1], 0, 15, 15, 255);
Jd8::blitCK(160, 150, gfx, fr6[1], 60, 15, 15, 255);
}
void v2_ball(const Uint8* gfx, int i) {
JD8_ClearScreen(0);
Jd8::clearScreen(0);
drawWordmark(gfx);
JD8_BlitCK(145, 150, gfx, fr9[(i / 10) % 16], 120, 15, 15, 255);
JD8_BlitCK(160, 150, gfx, fr10[(i / 10) % 16], 135, 15, 15, 255);
JD8_BlitCK(125, 150, gfx, fr11[((i / 5) % 4) + 2], 90, 15, 15, 255);
Jd8::blitCK(145, 150, gfx, fr9[(i / 10) % 16], 120, 15, 15, 255);
Jd8::blitCK(160, 150, gfx, fr10[(i / 10) % 16], 135, 15, 15, 255);
Jd8::blitCK(125, 150, gfx, fr11[((i / 5) % 4) + 2], 90, 15, 15, 255);
}
constexpr SpritePhase variant_2[] = {
@@ -330,7 +330,7 @@ namespace scenes {
done_ = false;
// Renderitzem ja el primer frame (step 0 de la primera fase) perquè
// el JD8_Flip del mini-loop del fiber el pinte al primer cicle.
// el Jd8::flip del mini-loop del fiber el pinte al primer cicle.
const SpritePhase* phases = variant_table(variant_);
phases[0].render(gfx_.get(), phase_current_i(phases[0], 0));
}
source/game/scenes/menu_scene.cpp
+16 -16
View File
@@ -14,12 +14,12 @@ namespace scenes {
// Pintat inicial (congelat durant el fade-in de paleta). El loop
// d'animació repintarà tot des de zero en el primer tick de Showing.
JD8_Blit(fondo_);
JD8_BlitCK(100, 25, gfx_, 0, 74, 124, 68, 255); // logo
JD8_BlitCK(130, 100, gfx_, 0, 0, 80, 74, 255); // camell (frame 0)
JD8_BlitCK(0, 150, gfx_, 0, 150, 320, 50, 255); // base "jdes"
Jd8::blit(fondo_);
Jd8::blitCK(100, 25, gfx_, 0, 74, 124, 68, 255); // logo
Jd8::blitCK(130, 100, gfx_, 0, 0, 80, 74, 255); // camell (frame 0)
Jd8::blitCK(0, 150, gfx_, 0, 150, 320, 50, 255); // base "jdes"
JD8_Palette pal = JD8_LoadPalette("gfx/menu2.gif");
Jd8::Palette pal = Jd8::loadPalette("gfx/menu2.gif");
fade_.startFadeTo(pal);
delete[] pal;
@@ -28,32 +28,32 @@ namespace scenes {
void MenuScene::render() {
// Cel estàtic (els primers 100 pixels verticals)
JD8_Blit(0, 0, fondo_, 0, 0, 320, 100);
Jd8::blit(0, 0, fondo_, 0, 0, 320, 100);
// Fondo mòvil (horitzó) amb wrap a 320
JD8_BlitCK(horitzo_, 100, fondo_, 0, 100, 320 - horitzo_, 100, 255);
JD8_BlitCK(0, 100, fondo_, 320 - horitzo_, 100, horitzo_, 100, 255);
Jd8::blitCK(horitzo_, 100, fondo_, 0, 100, 320 - horitzo_, 100, 255);
Jd8::blitCK(0, 100, fondo_, 320 - horitzo_, 100, horitzo_, 100, 255);
// Logo i camell animat
JD8_BlitCK(100, 25, gfx_, 0, 74, 124, 68, 255);
JD8_BlitCK(130, 100, gfx_, camello_.frame() * 80, 0, 80, 74, 255);
Jd8::blitCK(100, 25, gfx_, 0, 74, 124, 68, 255);
Jd8::blitCK(130, 100, gfx_, camello_.frame() * 80, 0, 80, 74, 255);
// Palmeres mòvils amb wrap a 320
JD8_BlitCK(palmeres_, 150, gfx_, 0, 150, 320 - palmeres_, 50, 255);
JD8_BlitCK(0, 150, gfx_, 320 - palmeres_, 150, palmeres_, 50, 255);
Jd8::blitCK(palmeres_, 150, gfx_, 0, 150, 320 - palmeres_, 50, 255);
Jd8::blitCK(0, 150, gfx_, 320 - palmeres_, 150, palmeres_, 50, 255);
// "jdes" estàtic (davant dels scrollers) i versió a la cantonada
JD8_BlitCK(87, 167, gfx_, 127, 124, 150, 24, 255);
JD8_BlitCK(303, 193, gfx_, 305, 143, 15, 5, 255);
Jd8::blitCK(87, 167, gfx_, 127, 124, 150, 24, 255);
Jd8::blitCK(303, 193, gfx_, 305, 143, 15, 5, 255);
// "Polsa tecla" parpallejant. Al vell `contador % 100 > 30` amb
// updateTicks=20 ms, el cicle són 2000 ms amb un llindar de 600 ms:
// amagat els primers 600 ms, visible els següents 1400 ms.
const bool blink_on = (blink_ms_ % 2000) > 600;
if (blink_on) {
JD8_BlitCK(98, 130, gfx_, 161, 92, 127, 9, 255);
Jd8::blitCK(98, 130, gfx_, 161, 92, 127, 9, 255);
if (info::ctx.nou_personatge) {
JD8_BlitCK(68, 141, gfx_, 128, 105, 189, 9, 255);
Jd8::blitCK(68, 141, gfx_, 128, 105, 189, 9, 255);
}
}
}
source/game/scenes/mort_scene.cpp
+3 -3
View File
@@ -15,12 +15,12 @@ namespace scenes {
info::ctx.vida = 5;
gfx_ = SurfaceHandle("gfx/gameover.gif");
JD8_ClearScreen(0);
JD8_Blit(gfx_);
Jd8::clearScreen(0);
Jd8::blit(gfx_);
// PaletteFade en fa una còpia interna via memcpy, així que alliberem
// la paleta temporal immediatament.
JD8_Palette pal = JD8_LoadPalette("gfx/gameover.gif");
Jd8::Palette pal = Jd8::loadPalette("gfx/gameover.gif");
fade_.startFadeTo(pal);
delete[] pal;
source/game/scenes/palette_fade.cpp
+3 -3
View File
@@ -3,12 +3,12 @@
namespace scenes {
void PaletteFade::startFadeOut() {
JD8_FadeStartOut();
Jd8::fadeStartOut();
active_ = true;
}
void PaletteFade::startFadeTo(const Color* target) {
JD8_FadeStartToPal(target);
Jd8::fadeStartToPal(target);
active_ = true;
}
@@ -22,7 +22,7 @@ namespace scenes {
// de 500ms exactes independent del framerate") podem convertir la
// màquina d'estats de jdraw8 a time-based ací sense tocar cap altre
// call site.
if (JD8_FadeTickStep()) {
if (Jd8::fadeTickStep()) {
active_ = false;
}
}
source/game/scenes/palette_fade.hpp
+1 -1
View File
@@ -5,7 +5,7 @@
namespace scenes {
// Embolcall fi damunt de la màquina d'estats de fade de jdraw8
// (`JD8_FadeStart*` / `JD8_FadeTickStep`). Exposa una API time-based
// (`JD8_FadeStart*` / `Jd8::fadeTickStep`). Exposa una API time-based
// però internament avança un pas del fade per cada crida a `tick()`.
// La raó de tindre-ho com a classe a banda: que una escena no puga
// cridar accidentalment a `JD8_FadeOut`/`JD8_FadeToPal` (els shims
source/game/scenes/scene.hpp
+1 -1
View File
@@ -6,7 +6,7 @@
// cert, i llavors consulta `nextState()` per decidir la següent.
//
// Contracte:
// - `tick(delta_ms)` no pot bloquejar ni cridar JD8_Flip — el caller
// - `tick(delta_ms)` no pot bloquejar ni cridar Jd8::flip — el caller
// s'encarrega de fer el flip després del tick.
// - `done()` es consulta just després de cada tick.
// - Els assets són propietat de l'escena (normalment via SurfaceHandle)
source/game/scenes/secreta_scene.cpp
+14 -14
View File
@@ -50,7 +50,7 @@ namespace scenes {
fade_.startFadeOut();
gfx_ = SurfaceHandle("gfx/tomba1.gif");
pal_aux_ = JD8_LoadPalette("gfx/tomba1.gif");
pal_aux_ = Jd8::loadPalette("gfx/tomba1.gif");
pal_active_ = new Color[256];
std::memcpy(pal_active_, pal_aux_, 768);
@@ -59,20 +59,20 @@ namespace scenes {
}
void SecretaScene::swapToTomba2() {
JD8_ClearScreen(255);
Jd8::clearScreen(255);
gfx_.reset("gfx/tomba2.gif");
delete[] pal_aux_;
pal_aux_ = JD8_LoadPalette("gfx/tomba2.gif");
pal_aux_ = Jd8::loadPalette("gfx/tomba2.gif");
// pal_active_ continua sent el mateix buffer: només actualitzem
// el seu contingut. main_palette ja apunta ací.
std::memcpy(pal_active_, pal_aux_, 768);
}
void SecretaScene::beginRedPulseSetup() {
JD8_ClearScreen(0);
JD8_SetPaletteColor(254, 12, 11, 11);
JD8_SetPaletteColor(253, 12, 11, 11);
Jd8::clearScreen(0);
Jd8::setPaletteColor(254, 12, 11, 11);
Jd8::setPaletteColor(253, 12, 11, 11);
}
void SecretaScene::beginFinalFade() {
@@ -98,8 +98,8 @@ namespace scenes {
// SetScreenPalette allibera la vella i adopta pal_active_
// — des d'ara main_palette == pal_active_, així que les
// futures escriptures a pal_active_ afecten la pantalla.
JD8_SetScreenPalette(pal_active_);
JD8_ClearScreen(255);
Jd8::setScreenPalette(pal_active_);
Jd8::clearScreen(255);
phase_ = Phase::Tomba1ScrollIn;
phase_acc_ms_ = 0;
}
@@ -110,8 +110,8 @@ namespace scenes {
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);
JD8_BlitCK(70, 60, gfx_, 178, contador >> 1, 142, 70, 255);
Jd8::blit(70, 60, gfx_, 0, contador, 178, 70);
Jd8::blitCK(70, 60, gfx_, 178, contador >> 1, 142, 70, 255);
if (phase_acc_ms_ >= TOMBA1_SCROLL_MS) {
phase_ = Phase::Tomba1Hold;
phase_acc_ms_ = 0;
@@ -131,7 +131,7 @@ namespace scenes {
case Phase::Tomba2ScrollIn: {
phase_acc_ms_ += delta_ms;
const int contador = std::min(94, (phase_acc_ms_ / TICK_MS) + 1);
JD8_Blit(55, 53, gfx_, 0, 158 - contador, 211, contador);
Jd8::blit(55, 53, gfx_, 0, 158 - contador, 211, contador);
if (phase_acc_ms_ >= TOMBA2_SCROLL_MS) {
phase_ = Phase::Tomba2Hold;
phase_acc_ms_ = 0;
@@ -153,7 +153,7 @@ namespace scenes {
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);
Jd8::blit(80, 68, gfx_, 160 - (contador * 2), 0, contador * 2, 64);
if (phase_acc_ms_ >= TOMBA2_REVEAL_MS) {
phase_ = Phase::Tomba2RevealHold;
phase_acc_ms_ = 0;
@@ -174,8 +174,8 @@ namespace scenes {
const int contador = std::min(51, phase_acc_ms_ / TICK_MS);
// Anima el canal R dels índexs 254 i 253 (aquest a la meitat
// de brillantor). Va de (12,11,11) fins a (63,11,11) / (31,11,11).
JD8_SetPaletteColor(254, contador + 12, 11, 11);
JD8_SetPaletteColor(253, (contador + 12) >> 1, 11, 11);
Jd8::setPaletteColor(254, contador + 12, 11, 11);
Jd8::setPaletteColor(253, (contador + 12) >> 1, 11, 11);
if (phase_acc_ms_ >= RED_PULSE_MS) {
phase_ = Phase::RedPulseHold;
phase_acc_ms_ = 0;
source/game/scenes/secreta_scene.hpp
+2 -2
View File
@@ -56,8 +56,8 @@ namespace scenes {
void beginFinalFade();
SurfaceHandle gfx_;
JD8_Palette pal_aux_{nullptr};
JD8_Palette pal_active_{nullptr}; // propietat transferida a main_palette
Jd8::Palette pal_aux_{nullptr};
Jd8::Palette pal_active_{nullptr}; // propietat transferida a main_palette
PaletteFade fade_;
Phase phase_{Phase::InitialFadeOut};
source/game/scenes/slides_scene.cpp
+5 -5
View File
@@ -48,7 +48,7 @@ namespace scenes {
}
gfx_ = SurfaceHandle(arxiu);
pal_aux_ = JD8_LoadPalette(arxiu);
pal_aux_ = Jd8::loadPalette(arxiu);
// Còpia editable de la paleta. `pal_active_` comparteix memòria amb
// main_palette després del SetScreenPalette — modificar-la modifica
@@ -56,9 +56,9 @@ namespace scenes {
// restaurar després de cada fade-out intermedi.
pal_active_ = new Color[256];
std::memcpy(pal_active_, pal_aux_, 768);
JD8_SetScreenPalette(pal_active_);
Jd8::setScreenPalette(pal_active_);
JD8_ClearScreen(BG_COLOR_INDEX);
Jd8::clearScreen(BG_COLOR_INDEX);
phase_ = Phase::Slide1Enter;
phase_acc_ms_ = 0;
@@ -83,7 +83,7 @@ namespace scenes {
}
if (w > 0) {
JD8_Blit(dst_x, SLIDE_Y, gfx_, src_x, src_y, w, SLIDE_H);
Jd8::blit(dst_x, SLIDE_Y, gfx_, src_x, src_y, w, SLIDE_H);
}
}
@@ -169,7 +169,7 @@ namespace scenes {
fade_.tick(delta_ms);
if (fade_.done()) {
restorePalette();
JD8_ClearScreen(BG_COLOR_INDEX);
Jd8::clearScreen(BG_COLOR_INDEX);
if (phase_ == Phase::FadeOut1) {
phase_ = Phase::Slide2Enter;
} else {
source/game/scenes/slides_scene.hpp
+2 -2
View File
@@ -67,8 +67,8 @@ namespace scenes {
void beginFinalFade();
SurfaceHandle gfx_;
JD8_Palette pal_aux_{nullptr}; // còpia "neta" que preservem
JD8_Palette pal_active_{nullptr}; // propietat transferida a main_palette
Jd8::Palette pal_aux_{nullptr}; // còpia "neta" que preservem
Jd8::Palette pal_active_{nullptr}; // propietat transferida a main_palette
PaletteFade fade_;
Phase phase_{Phase::Slide1Enter};
source/game/scenes/surface_handle.cpp
+9 -9
View File
@@ -3,11 +3,11 @@
namespace scenes {
SurfaceHandle::SurfaceHandle(const char* file)
: surface_(JD8_LoadSurface(file)) {}
: surface_(Jd8::loadSurface(file)) {}
SurfaceHandle::~SurfaceHandle() {
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
Jd8::freeSurface(surface_);
}
}
@@ -19,7 +19,7 @@ namespace scenes {
auto SurfaceHandle::operator=(SurfaceHandle&& other) noexcept -> SurfaceHandle& {
if (this != &other) {
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
Jd8::freeSurface(surface_);
}
surface_ = other.surface_;
other.surface_ = nullptr;
@@ -29,20 +29,20 @@ namespace scenes {
void SurfaceHandle::reset(const char* file) {
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
Jd8::freeSurface(surface_);
}
surface_ = (file != nullptr) ? JD8_LoadSurface(file) : nullptr;
surface_ = (file != nullptr) ? Jd8::loadSurface(file) : nullptr;
}
void SurfaceHandle::adopt(JD8_Surface raw) {
void SurfaceHandle::adopt(Jd8::Surface raw) {
if (surface_ != nullptr) {
JD8_FreeSurface(surface_);
Jd8::freeSurface(surface_);
}
surface_ = raw;
}
auto SurfaceHandle::release() -> JD8_Surface {
JD8_Surface r = surface_;
auto SurfaceHandle::release() -> Jd8::Surface {
Jd8::Surface r = surface_;
surface_ = nullptr;
return r;
}
source/game/scenes/surface_handle.hpp
+12 -12
View File
@@ -4,10 +4,10 @@
namespace scenes {
// Wrapper RAII damunt de `JD8_Surface`. Allibera automàticament amb
// `JD8_FreeSurface` al destructor. Move-only per evitar dobles alliberaments.
// Converteix implícitament a `JD8_Surface` per a poder passar-lo
// directament a `JD8_Blit*` sense haver de cridar `.get()`.
// Wrapper RAII damunt de `Jd8::Surface`. Allibera automàticament amb
// `Jd8::freeSurface` al destructor. Move-only per evitar dobles alliberaments.
// Converteix implícitament a `Jd8::Surface` per a poder passar-lo
// directament a `Jd8::blit*` sense haver de cridar `.get()`.
class SurfaceHandle {
public:
SurfaceHandle() = default;
@@ -25,25 +25,25 @@ namespace scenes {
// (p.ex. doSecreta que passa de tomba1 a tomba2).
void reset(const char* file);
// Adopta una surface ja creada (p.ex. amb JD8_NewSurface). Pren ownership
// Adopta una surface ja creada (p.ex. amb Jd8::newSurface). Pren ownership
// — la surface adoptada s'allibera al destructor o al següent reset/adopt.
void adopt(JD8_Surface raw);
void adopt(Jd8::Surface raw);
// Allibera ownership sense destruir la surface. Retorna el pointer cru;
// el caller passa a ser responsable d'alliberar-lo (o de passar-lo a un
// 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]] auto release() -> JD8_Surface;
[[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_; }
[[nodiscard]] auto get() const -> JD8_Surface { return 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_; }
[[nodiscard]] auto get() const -> Jd8::Surface { return surface_; }
[[nodiscard]] auto valid() const -> bool { return surface_ != nullptr; }
private:
JD8_Surface surface_{nullptr};
Jd8::Surface surface_{nullptr};
};
} // namespace scenes
source/game/scenes/timeline.hpp
+1 -1
View File
@@ -9,7 +9,7 @@ namespace scenes {
// ms i un callback. Exemple d'ús:
//
// timeline_
// .once([this] { JD8_ClearScreen(0); fade_.startFadeTo(pal); })
// .once([this] { Jd8::clearScreen(0); fade_.startFadeTo(pal); })
// .step(5000) // espera pura
// .step(1000, [this](float p) { /*...*/ }) // animat amb progress
// .once([this] { Ja::fadeOutMusic(250); });