Mapa piràmide 4×5 amb muros i passadissos de 16 px + motor de colisions AABB amb snap al passadís (v0.12.0)
This commit is contained in:
JailDesigner committed
1 parent
297dc85e47
commit
c921833537
7 files changed
+360
-18
No files matched your search
@@ -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); }
|
||||
}
|
||||
}
|
||||
@@ -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_;
|
||||
};
|
||||
Reference in new issue
Block a user