Mapa piràmide 4×5 amb muros i passadissos de 16 px + motor de colisions AABB amb snap al passadís (v0.12.0)

source/game/entities/player.cpp

@@ -3,9 +3,12 @@
 #include <SDL3/SDL.h>
 
 #include <algorithm>
+#include <cmath>
+#include <cstdint>
 
+#include "core/rendering/screen.hpp"
 #include "core/resources/resource_cache.hpp"
-#include "utils/defines.hpp"
+#include "game/map/map.hpp"
 
 namespace {
 
@@ -13,6 +16,10 @@ namespace {
     // es pot convertir en un membre modificable.
     constexpr float SPEED_PX_PER_S = 60.0F;
 
+    // Color de debug per a la caixa de col·lisió (ARGB opac). S'elimina
+    // quan el joc estiga afinat.
+    constexpr std::uint32_t DEBUG_COLLISION_ARGB = 0xFF00FFFFU;
+
 }  // namespace
 
 Player::Player(float x, float y, const Controls& controls)
@@ -46,14 +53,106 @@ void Player::update(float delta_time) {
     const bool MOVING = vx != 0.0F || vy != 0.0F;
     setCurrentAnimation(MOVING ? "walk" : "stand");
 
-    AnimatedSprite::update(delta_time);
+    // Snap al passadís: si només hi ha moviment horitzontal (o vertical) i
+    // la caixa està prou prop d'una lane perpendicular (≤ mitja caixa), la
+    // Y (o X) es corregeix gradualment per enfilar el passadís. Amb
+    // moviment diagonal no es fa snap — l'usuari pilota manualment.
+    const bool ONLY_H = (vx != 0.0F) && (vy == 0.0F);
+    const bool ONLY_V = (vy != 0.0F) && (vx == 0.0F);
+    if (ONLY_H) {
+        snapToHorizontalLane(delta_time);
+    } else if (ONLY_V) {
+        snapToVerticalLane(delta_time);
+    }
 
-    // Límits de pantalla amb perspectiva falsa: el cap (12px superiors) pot
-    // quedar fora per dalt; els peus (12×12 inferiors) sempre dins del canvas.
-    constexpr auto MIN_X = 0.0F;
-    constexpr auto MAX_X = static_cast<float>(GameCanvas::WIDTH - SPRITE_WIDTH);
-    constexpr auto MIN_Y = -static_cast<float>(SPRITE_HEIGHT - COLLISION_HEIGHT);
-    constexpr auto MAX_Y = static_cast<float>(GameCanvas::HEIGHT - SPRITE_HEIGHT);
+    // Guardem la posició prèvia i deixem que AnimatedSprite::update aplique
+    // la velocitat com sempre; així no dupliquem la integració temporal ni
+    // l'animació. Després, axis-separated collision: revertim i re-apliquem
+    // cada eix comprovant el mapa de colisions, de manera que el jugador
+    // llisca contra els sarcòfags en compte de quedar-se bloquejat en sec.
+    const float OLD_X = getPosX();
+    const float OLD_Y = getPosY();
+    AnimatedSprite::update(delta_time);
+    const float NEW_X = getPosX();
+    const float NEW_Y = getPosY();
+    setPos(OLD_X, OLD_Y);
+
+    setPosX(NEW_X);
+    if (Map::collides(baseBox())) { setPosX(OLD_X); }
+    setPosY(NEW_Y);
+    if (Map::collides(baseBox())) { setPosY(OLD_Y); }
+
+    // Límits de la zona jugable: la caixa de col·lisió no pot eixir del
+    // playfield (muros). El cap del sprite sí pot sobresortir per damunt.
+    constexpr auto MIN_X = static_cast<float>(Map::PLAYFIELD_X - COLLISION_X_OFFSET);
+    constexpr auto MAX_X = static_cast<float>(
+        Map::PLAYFIELD_X + Map::PLAYFIELD_W - COLLISION_X_OFFSET - COLLISION_SIZE);
+    constexpr auto MIN_Y = static_cast<float>(Map::PLAYFIELD_Y - COLLISION_Y_OFFSET);
+    constexpr auto MAX_Y = static_cast<float>(
+        Map::PLAYFIELD_Y + Map::PLAYFIELD_H - COLLISION_Y_OFFSET - COLLISION_SIZE);
     setPosX(std::clamp(getPosX(), MIN_X, MAX_X));
     setPosY(std::clamp(getPosY(), MIN_Y, MAX_Y));
 }
+
+void Player::render() {
+    // Debug: pinta la caixa de col·lisió (16×16) per sota del sprite perquè
+    // es vegen els límits del mapa de colisions alineats amb els passadissos.
+    Screen::get().fillRect(
+        static_cast<int>(getPosX()) + COLLISION_X_OFFSET,
+        static_cast<int>(getPosY()) + COLLISION_Y_OFFSET,
+        COLLISION_SIZE,
+        COLLISION_SIZE,
+        DEBUG_COLLISION_ARGB);
+    AnimatedSprite::render();
+}
+
+auto Player::baseBox() const -> SDL_FRect {
+    return {
+        .x = getPosX() + static_cast<float>(COLLISION_X_OFFSET),
+        .y = getPosY() + static_cast<float>(COLLISION_Y_OFFSET),
+        .w = static_cast<float>(COLLISION_SIZE),
+        .h = static_cast<float>(COLLISION_SIZE),
+    };
+}
+
+void Player::snapToHorizontalLane(float delta_time) {
+    // Lanes en posY: base + i·PITCH_Y per a i ∈ [0, GRID_ROWS]. Correspon a
+    // la caixa de col·lisió ocupant exactament un passadís horitzontal.
+    constexpr auto BASE = static_cast<float>(Map::PLAYFIELD_Y - COLLISION_Y_OFFSET);
+    constexpr auto PITCH = static_cast<float>(Map::PITCH_Y);
+    constexpr auto THRESHOLD = static_cast<float>(COLLISION_SIZE) / 2.0F;
+
+    const auto IDX = std::clamp(
+        static_cast<int>(std::round((getPosY() - BASE) / PITCH)),
+        0,
+        Map::GRID_ROWS);
+    const float LANE = BASE + (static_cast<float>(IDX) * PITCH);
+    const float DY = LANE - getPosY();
+
+    if (std::abs(DY) > 0.0F && std::abs(DY) <= THRESHOLD) {
+        const float STEP = std::min(std::abs(DY), SPEED_PX_PER_S * delta_time);
+        const float SAVED = getPosY();
+        setPosY(getPosY() + std::copysign(STEP, DY));
+        if (Map::collides(baseBox())) { setPosY(SAVED); }
+    }
+}
+
+void Player::snapToVerticalLane(float delta_time) {
+    constexpr auto BASE = static_cast<float>(Map::PLAYFIELD_X - COLLISION_X_OFFSET);
+    constexpr auto PITCH = static_cast<float>(Map::PITCH_X);
+    constexpr auto THRESHOLD = static_cast<float>(COLLISION_SIZE) / 2.0F;
+
+    const auto IDX = std::clamp(
+        static_cast<int>(std::round((getPosX() - BASE) / PITCH)),
+        0,
+        Map::GRID_COLS);
+    const float LANE = BASE + (static_cast<float>(IDX) * PITCH);
+    const float DX = LANE - getPosX();
+
+    if (std::abs(DX) > 0.0F && std::abs(DX) <= THRESHOLD) {
+        const float STEP = std::min(std::abs(DX), SPEED_PX_PER_S * delta_time);
+        const float SAVED = getPosX();
+        setPosX(getPosX() + std::copysign(STEP, DX));
+        if (Map::collides(baseBox())) { setPosX(SAVED); }
+    }
+}

source/game/entities/player.hpp

@@ -16,18 +16,47 @@ class Player : public AnimatedSprite {
         SDL_Scancode right;
     };
 
-    // Sprite 12×24 amb perspectiva falsa: la base real del jugador són els
-    // 12×12 inferiors. Per això el bounding horitzontal és l'amplada completa,
-    // però verticalment permetem que el cap (12px superiors) isca fora de la
-    // pantalla — s'hi fa clipping natural al render.
+    // Sprite 12×24 amb perspectiva falsa: visualment, els 12 píxels
+    // superiors són el cap i els 12 inferiors la base.
     static constexpr int SPRITE_WIDTH = 12;
     static constexpr int SPRITE_HEIGHT = 24;
-    static constexpr int COLLISION_HEIGHT = 12;
+
+    // Caixa de col·lisió: quadrat 16×16 concèntric amb els 12×12 inferiors
+    // del sprite (la base "antiga"). Encaixa just als passadissos de 16 px
+    // → el jugador va ajustat pels corredors. L'ampliació és simètrica:
+    // 2 px per cada costat i 2 px per dalt i per baix. Mapa de colisions i
+    // de dibuix són independents: el sprite pot sobresortir (el cap) sense
+    // afectar les col·lisions.
+    static constexpr int LEGACY_BASE_SIZE = 12;
+    static constexpr int COLLISION_SIZE = 16;
+    static constexpr int COLLISION_PADDING = (COLLISION_SIZE - LEGACY_BASE_SIZE) / 2;
+    static constexpr int COLLISION_X_OFFSET = -COLLISION_PADDING;
+    static constexpr int COLLISION_Y_OFFSET =
+        (SPRITE_HEIGHT - LEGACY_BASE_SIZE) - COLLISION_PADDING;
 
     Player(float x, float y, const Controls& controls);
 
     void update(float delta_time) override;
+    void render() override;
+
+    // Y de la base del jugador (cara inferior de la caixa de colisió). Usada
+    // per al Z-order contra els sarcs: peus per sobre d'un sarc → darrere;
+    // per sota → davant.
+    [[nodiscard]] auto getFeetY() const -> float {
+        return getPosY() + static_cast<float>(COLLISION_Y_OFFSET + COLLISION_SIZE);
+    }
 
    private:
+    // Rectangle de col·lisió del jugador (16×16), usat pel mapa de colisions
+    // i com a referència per al Z-order.
+    [[nodiscard]] auto baseBox() const -> SDL_FRect;
+
+    // Snap cap al passadís perpendicular a la direcció premuda. Si la caixa
+    // de col·lisió està a ≤ COLLISION_SIZE/2 d'una lane, s'hi aproxima
+    // gradualment (a velocitat de moviment). Això permet canviar de direcció
+    // sense haver d'alinear-se píxel-perfect en l'encreuament.
+    void snapToHorizontalLane(float delta_time);
+    void snapToVerticalLane(float delta_time);
+
     Controls controls_;
 };

source/game/map/map.cpp

@@ -0,0 +1,79 @@
+#include "game/map/map.hpp"
+
+#include "core/rendering/screen.hpp"
+#include "core/resources/resource_cache.hpp"
+#include "utils/defines.hpp"
+
+namespace {
+
+    // AABB amb inequitat estricta: dos rects que es toquen exactament (la
+    // cantonada o una vora al píxel) NO es consideren intersecció. SDL3
+    // SDL_HasRectIntersectionFloat tracta el toc com a intersecció, cosa
+    // que bloqueja el moviment als encreuaments del nostre laberint.
+    auto overlapStrict(const SDL_FRect& a, const SDL_FRect& b) -> bool {
+        return (a.x + a.w) > b.x && (b.x + b.w) > a.x && (a.y + a.h) > b.y && (b.y + b.h) > a.y;
+    }
+
+}  // namespace
+
+Map::Map() = default;
+
+auto Map::getSarcRowBottomY(int row) -> int {
+    return ORIGIN_Y + (row * PITCH_Y) + SARC_H;
+}
+
+auto Map::getSarcRect(int col, int row) -> SDL_FRect {
+    return {
+        .x = static_cast<float>(ORIGIN_X + (col * PITCH_X)),
+        .y = static_cast<float>(ORIGIN_Y + (row * PITCH_Y)),
+        .w = static_cast<float>(SARC_W),
+        .h = static_cast<float>(SARC_H),
+    };
+}
+
+void Map::renderBackground() {
+    auto& screen = Screen::get();
+    const auto& palette = Resource::Cache::get().getPalette("ui");
+
+    // Comencem pintant el sòl a tota la pantalla; després tapem marcador i
+    // murs. Els rectangles dels murs s'encavalquen a les cantonades: no
+    // importa perquè són del mateix color.
+    screen.fillRect(0, 0, GameCanvas::WIDTH, GameCanvas::HEIGHT, palette[FLOOR]);
+
+    // Marcador (dalt).
+    screen.fillRect(0, 0, GameCanvas::WIDTH, HUD_H, palette[HUD_BG]);
+
+    // Mur posterior: banda horitzontal sota el marcador.
+    screen.fillRect(0, HUD_H, GameCanvas::WIDTH, BACK_WALL_H, palette[WALL]);
+
+    // Murs laterals (des del marcador fins al final).
+    screen.fillRect(0, HUD_H, SIDE_WALL_W, GameCanvas::HEIGHT - HUD_H, palette[WALL]);
+    screen.fillRect(GameCanvas::WIDTH - SIDE_WALL_W, HUD_H, SIDE_WALL_W, GameCanvas::HEIGHT - HUD_H, palette[WALL]);
+
+    // Mur frontal: de la vora inferior del passadís de baix fins al final del
+    // canvas. Assumeix els 40 px extra de 320×240 i fa de primer pla.
+    const int FRONT_WALL_Y = ORIGIN_Y + BOARD_H + OUTER_CORRIDOR;
+    screen.fillRect(0, FRONT_WALL_Y, GameCanvas::WIDTH, GameCanvas::HEIGHT - FRONT_WALL_Y, palette[WALL]);
+}
+
+void Map::renderSarcsRow(int row) {
+    auto& screen = Screen::get();
+    const auto& palette = Resource::Cache::get().getPalette("ui");
+    const int Y = ORIGIN_Y + (row * PITCH_Y);
+    for (int col = 0; col < GRID_COLS; ++col) {
+        const int X = ORIGIN_X + (col * PITCH_X);
+        screen.fillRect(X, Y, SARC_W, SARC_H, palette[SARC]);
+    }
+}
+
+auto Map::collides(const SDL_FRect& base_box) -> bool {
+    // Recorregut trivial dels 20 sarcòfags. Amb una graella tan petita no
+    // val la pena indexar per col/row prèviament; si algun dia creix, es pot
+    // calcular el rang de columnes/files candidates a partir de base_box.
+    for (int row = 0; row < GRID_ROWS; ++row) {
+        for (int col = 0; col < GRID_COLS; ++col) {
+            if (overlapStrict(base_box, getSarcRect(col, row))) { return true; }
+        }
+    }
+    return false;
+}

source/game/map/map.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+// Mapa d'una piràmide: sala rectangular amb marcador superior, muros pels
+// quatre costats i graella 4×4 de sarcòfags envoltada per un passadís a cada
+// cantó. Mesures portades de l'AEE original (mapa.cpp: sarcòfag 50×20, pitch
+// 65×35, passadís 15 px) i adaptades a 320×240 repartint els 40 px extra
+// sobretot al mur frontal, que fa de primer pla per a la falsa perspectiva.
+//
+// Z-order: el render es divideix en fons (marcador + muros + sòl) i files
+// de sarcòfags. El caller (GameScene) alternarà jugadors ordenats per la Y
+// dels peus amb cada fila per a aconseguir la perspectiva falsa (el sarcòfag
+// tapa el cos del jugador si aquest està "darrere"; el cap del jugador tapa
+// el sarcòfag de la fila superior si està "davant").
+class Map {
+   public:
+    // Graella portada tal qual de l'AEE (4×4 sarcòfags, pitch 65×35).
+    static constexpr int GRID_COLS = 4;
+    static constexpr int GRID_ROWS = 5;
+    static constexpr int SARC_W = 50;
+    static constexpr int SARC_H = 16;
+    static constexpr int PITCH_X = 66;
+    static constexpr int PITCH_Y = 32;
+
+    // El pas entre sarcòfags (15×15) és exactament el que ha de cabre el
+    // jugador; el reutilitzem també com a passadís exterior (perímetre).
+    static constexpr int CORRIDOR_W = PITCH_X - SARC_W;
+    static constexpr int CORRIDOR_H = PITCH_Y - SARC_H;
+    static constexpr int OUTER_CORRIDOR = CORRIDOR_W;
+
+    // Dimensions del tauler complet (des del primer sarcòfag fins al cantó
+    // inferior dret de l'últim). Derivades: no cal tocar-les a mà.
+    static constexpr int BOARD_W = ((GRID_COLS - 1) * PITCH_X) + SARC_W;
+    static constexpr int BOARD_H = ((GRID_ROWS - 1) * PITCH_Y) + SARC_H;
+
+    // Cromat de la sala: marcador, mur posterior (dalt), murs laterals i mur
+    // frontal (baix). El frontal és més gros per absorbir els 40 px extra del
+    // pas de 320×200 → 320×240 i reforçar la falsa perspectiva.
+    static constexpr int HUD_H = 24;
+    static constexpr int BACK_WALL_H = 24;
+    static constexpr int SIDE_WALL_W = 20;
+
+    // Origen del tauler dins del canvas (cantó superior-esquerra del primer
+    // sarcòfag). Derivat: mur + passadís en cada eix.
+    static constexpr int ORIGIN_X = SIDE_WALL_W + OUTER_CORRIDOR;
+    static constexpr int ORIGIN_Y = HUD_H + BACK_WALL_H + OUTER_CORRIDOR;
+
+    // Límits de la zona jugable (on el jugador pot moure's lliurement, sense
+    // comptar encara les colisions contra sarcòfags). Serviran per al pas
+    // següent de colisions.
+    static constexpr int PLAYFIELD_X = SIDE_WALL_W;
+    static constexpr int PLAYFIELD_Y = HUD_H + BACK_WALL_H;
+    static constexpr int PLAYFIELD_W = BOARD_W + (2 * OUTER_CORRIDOR);
+    static constexpr int PLAYFIELD_H = BOARD_H + (2 * OUTER_CORRIDOR);
+
+    // Índexs a la paleta UI (data/palettes/sega-cube.pal). Centralitzats ací
+    // per a poder ajustar l'estètica sense buscar magic numbers pel codi.
+    static constexpr Uint8 HUD_BG = 0;
+    static constexpr Uint8 WALL = 80;
+    static constexpr Uint8 FLOOR = 40;
+    static constexpr Uint8 SARC = 160;
+
+    Map();
+
+    // Fons estàtic: marcador, muros (back/side/front) i sòl interior. No
+    // pinta cap sarcòfag; això queda per a renderSarcsRow() perquè el caller
+    // puga interleaveing amb els jugadors.
+    static void renderBackground();
+
+    // Pinta la fila `row` de sarcòfags (4 rectangles a pitch 65). El caller
+    // decideix quan cridar-la respecte als jugadors segons la seua Y.
+    static void renderSarcsRow(int row);
+
+    // Y de la cara inferior dels sarcòfags de la fila `row` (la "baseline"
+    // per a ordenar en Z): un jugador amb els peus per sobre d'aquest valor
+    // queda darrere; per sota, queda davant.
+    [[nodiscard]] static auto getSarcRowBottomY(int row) -> int;
+
+    // Rectangle ocupat pel sarcòfag a la posició (col, row) de la graella.
+    [[nodiscard]] static auto getSarcRect(int col, int row) -> SDL_FRect;
+
+    // Mapa de colisions (separat del mapa de dibuix): retorna true si el
+    // rectangle `base_box` (la base del jugador, per exemple) s'encavalca
+    // amb cap sarcòfag. Així Player mai camine sobre un sarcòfag,
+    // independentment de com els pinte renderSarcsRow.
+    [[nodiscard]] static auto collides(const SDL_FRect& base_box) -> bool;
+};

source/game/scenes/game_scene.cpp

@@ -2,12 +2,18 @@
 
 #include <SDL3/SDL.h>
 
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <vector>
+
 #include "core/input/global_inputs.hpp"
 #include "core/rendering/notifier.hpp"
 #include "core/rendering/render_info.hpp"
 #include "core/rendering/screen.hpp"
 #include "core/resources/resource_cache.hpp"
 #include "game/entities/player.hpp"
+#include "game/map/map.hpp"
 #include "game/ui/ui_palette.hpp"
 #include "utils/defaults.hpp"
 #include "utils/defines.hpp"
@@ -25,9 +31,16 @@ GameScene::GameScene() {
         .left = Defaults::KeysGame::LEFT,
         .right = Defaults::KeysGame::RIGHT,
     };
-    const float X = static_cast<float>(GameCanvas::CENTER_X) - (static_cast<float>(Player::SPRITE_WIDTH) / 2.0F);
-    const float Y = static_cast<float>(GameCanvas::CENTER_Y) - (static_cast<float>(Player::SPRITE_HEIGHT) / 2.0F);
-    players_.emplace_back(std::make_unique<Player>(X, Y, CONTROLS_P1));
+    // Spawn centrat al passadís exterior superior: la caixa de col·lisió
+    // queda dins del passadís vertical del mig (entre columnes 1 i 2) i
+    // centrada en Y al passadís exterior superior. Així no naix dins de
+    // cap sarcòfag.
+    constexpr auto CORRIDOR_CENTER_X = static_cast<float>(GameCanvas::CENTER_X);
+    constexpr auto CORRIDOR_CENTER_Y =
+        static_cast<float>(Map::PLAYFIELD_Y) + (static_cast<float>(Map::OUTER_CORRIDOR) / 2.0F);
+    constexpr auto SPAWN_X = CORRIDOR_CENTER_X - (static_cast<float>(Player::SPRITE_WIDTH) / 2.0F);
+    constexpr auto SPAWN_Y = CORRIDOR_CENTER_Y - static_cast<float>(Player::COLLISION_Y_OFFSET) - (static_cast<float>(Player::COLLISION_SIZE) / 2.0F);
+    players_.emplace_back(std::make_unique<Player>(SPAWN_X, SPAWN_Y, CONTROLS_P1));
 }
 
 GameScene::~GameScene() = default;
@@ -45,7 +58,40 @@ void GameScene::update(int delta_ms) {
 void GameScene::render() {
     const auto BG_ARGB = Resource::Cache::get().getPalette("ui")[UiColor::CANVAS_BG];
     Screen::get().fillRect(0, 0, GameCanvas::WIDTH, GameCanvas::HEIGHT, BG_ARGB);
-    for (auto& player : players_) { player->render(); }
+
+    // Fons del mapa (marcador, muros, sòl). Els sarcòfags es pinten després
+    // fila a fila entrellaçats amb els jugadors per al Z-order.
+    Map::renderBackground();
+
+    // Ordenem punters a jugadors per Y dels peus (ascendent = més al fons
+    // primer). Usem un vector auxiliar per no tocar l'ordre d'entrada de
+    // players_, que és el d'assignació de controls.
+    std::vector<Player*> sorted;
+    sorted.reserve(players_.size());
+    std::ranges::transform(players_, std::back_inserter(sorted), [](const auto& p) { return p.get(); });
+    std::ranges::sort(sorted, [](const Player* a, const Player* b) {
+        return a->getFeetY() < b->getFeetY();
+    });
+
+    // Interleaving: per cada fila de sarcòfags, primer pintem els jugadors
+    // que hi queden "darrere" (peus per sobre de la cara inferior de la fila)
+    // i després la fila. Un jugador amb els peus davall d'una fila es pinta
+    // sobre d'ella (el seu cap tapa la fila superior si s'hi encavalca).
+    std::size_t p = 0;
+    for (int row = 0; row < Map::GRID_ROWS; ++row) {
+        const auto ROW_BOTTOM = static_cast<float>(Map::getSarcRowBottomY(row));
+        while (p < sorted.size() && sorted[p]->getFeetY() <= ROW_BOTTOM) {
+            sorted[p]->render();
+            ++p;
+        }
+        Map::renderSarcsRow(row);
+    }
+    // Jugadors que queden per davall de l'última fila de sarcòfags.
+    while (p < sorted.size()) {
+        sorted[p]->render();
+        ++p;
+    }
+
     Notifier::get().render();
     RenderInfo::get().render();
     Screen::get().present();

source/utils/defines.hpp

@@ -3,7 +3,7 @@
 namespace Texts {
     constexpr const char* WINDOW_TITLE = "© 2026 Aventures en Egipte — JailDesigner";
     constexpr const char* COPYRIGHT = "© 2026 JailDesigner";
-    constexpr const char* VERSION = "0.11.0";  // Single source of truth — Makefile el grep
+    constexpr const char* VERSION = "0.12.0";  // Single source of truth — Makefile el grep
 }  // namespace Texts
 
 namespace GameCanvas {