From c9218335378da59e46095f77e1c8b3605c762bda Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Sun, 19 Apr 2026 18:08:51 +0200 Subject: [PATCH] =?UTF-8?q?Mapa=20pir=C3=A0mide=204=C3=975=20amb=20muros?= =?UTF-8?q?=20i=20passadissos=20de=2016=20px=20+=20motor=20de=20colisions?= =?UTF-8?q?=20AABB=20amb=20snap=20al=20passad=C3=ADs=20(v0.12.0)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CMakeLists.txt | 1 + source/game/entities/player.cpp | 115 +++++++++++++++++++++++++++--- source/game/entities/player.hpp | 39 ++++++++-- source/game/map/map.cpp | 79 ++++++++++++++++++++ source/game/map/map.hpp | 88 +++++++++++++++++++++++ source/game/scenes/game_scene.cpp | 54 ++++++++++++-- source/utils/defines.hpp | 2 +- 7 files changed, 360 insertions(+), 18 deletions(-) create mode 100644 source/game/map/map.cpp create mode 100644 source/game/map/map.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 233fce4..70c30c6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -55,6 +55,7 @@ set(APP_SOURCES source/game/options.cpp source/game/scenes/game_scene.cpp source/game/entities/player.cpp + source/game/map/map.cpp ) find_package(SDL3 REQUIRED CONFIG REQUIRED COMPONENTS SDL3) diff --git a/source/game/entities/player.cpp b/source/game/entities/player.cpp index 942c6b6..bb36694 100644 --- a/source/game/entities/player.cpp +++ b/source/game/entities/player.cpp @@ -3,9 +3,12 @@ #include #include +#include +#include +#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(GameCanvas::WIDTH - SPRITE_WIDTH); - constexpr auto MIN_Y = -static_cast(SPRITE_HEIGHT - COLLISION_HEIGHT); - constexpr auto MAX_Y = static_cast(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(Map::PLAYFIELD_X - COLLISION_X_OFFSET); + constexpr auto MAX_X = static_cast( + Map::PLAYFIELD_X + Map::PLAYFIELD_W - COLLISION_X_OFFSET - COLLISION_SIZE); + constexpr auto MIN_Y = static_cast(Map::PLAYFIELD_Y - COLLISION_Y_OFFSET); + constexpr auto MAX_Y = static_cast( + 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(getPosX()) + COLLISION_X_OFFSET, + static_cast(getPosY()) + COLLISION_Y_OFFSET, + COLLISION_SIZE, + COLLISION_SIZE, + DEBUG_COLLISION_ARGB); + AnimatedSprite::render(); +} + +auto Player::baseBox() const -> SDL_FRect { + return { + .x = getPosX() + static_cast(COLLISION_X_OFFSET), + .y = getPosY() + static_cast(COLLISION_Y_OFFSET), + .w = static_cast(COLLISION_SIZE), + .h = static_cast(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(Map::PLAYFIELD_Y - COLLISION_Y_OFFSET); + constexpr auto PITCH = static_cast(Map::PITCH_Y); + constexpr auto THRESHOLD = static_cast(COLLISION_SIZE) / 2.0F; + + const auto IDX = std::clamp( + static_cast(std::round((getPosY() - BASE) / PITCH)), + 0, + Map::GRID_ROWS); + const float LANE = BASE + (static_cast(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(Map::PLAYFIELD_X - COLLISION_X_OFFSET); + constexpr auto PITCH = static_cast(Map::PITCH_X); + constexpr auto THRESHOLD = static_cast(COLLISION_SIZE) / 2.0F; + + const auto IDX = std::clamp( + static_cast(std::round((getPosX() - BASE) / PITCH)), + 0, + Map::GRID_COLS); + const float LANE = BASE + (static_cast(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); } + } +} diff --git a/source/game/entities/player.hpp b/source/game/entities/player.hpp index 1abd49b..1d9755c 100644 --- a/source/game/entities/player.hpp +++ b/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(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_; }; diff --git a/source/game/map/map.cpp b/source/game/map/map.cpp new file mode 100644 index 0000000..896b114 --- /dev/null +++ b/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(ORIGIN_X + (col * PITCH_X)), + .y = static_cast(ORIGIN_Y + (row * PITCH_Y)), + .w = static_cast(SARC_W), + .h = static_cast(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; +} diff --git a/source/game/map/map.hpp b/source/game/map/map.hpp new file mode 100644 index 0000000..39b9179 --- /dev/null +++ b/source/game/map/map.hpp @@ -0,0 +1,88 @@ +#pragma once + +#include + +// 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; +}; diff --git a/source/game/scenes/game_scene.cpp b/source/game/scenes/game_scene.cpp index c674cc8..8d8f990 100644 --- a/source/game/scenes/game_scene.cpp +++ b/source/game/scenes/game_scene.cpp @@ -2,12 +2,18 @@ #include +#include +#include +#include +#include + #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(GameCanvas::CENTER_X) - (static_cast(Player::SPRITE_WIDTH) / 2.0F); - const float Y = static_cast(GameCanvas::CENTER_Y) - (static_cast(Player::SPRITE_HEIGHT) / 2.0F); - players_.emplace_back(std::make_unique(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(GameCanvas::CENTER_X); + constexpr auto CORRIDOR_CENTER_Y = + static_cast(Map::PLAYFIELD_Y) + (static_cast(Map::OUTER_CORRIDOR) / 2.0F); + constexpr auto SPAWN_X = CORRIDOR_CENTER_X - (static_cast(Player::SPRITE_WIDTH) / 2.0F); + constexpr auto SPAWN_Y = CORRIDOR_CENTER_Y - static_cast(Player::COLLISION_Y_OFFSET) - (static_cast(Player::COLLISION_SIZE) / 2.0F); + players_.emplace_back(std::make_unique(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 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(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(); diff --git a/source/utils/defines.hpp b/source/utils/defines.hpp index 5c7a6f7..c06c8a1 100644 --- a/source/utils/defines.hpp +++ b/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 {