Movement.h

Go to the documentation of this file.

#ifndef BOMBERMAN_SIM_MOVEMENT_H
#define BOMBERMAN_SIM_MOVEMENT_H
 
#include "Const.h"
#include "Sim/SimConfig.h"
 
namespace bomberman::sim
{
    constexpr int32_t kPlayerSpeedQ = static_cast<int32_t>(kPlayerSpeedTilesPerSecond * 256.0 / kTickRate + 0.5);
 
    constexpr int32_t kHitboxHalfQ = static_cast<int32_t>(kPlayerHitboxScale * 256.0f / 2.0f);
 
    struct TilePos
    {
        int32_t xQ = 0;
        int32_t yQ = 0;
    };
 
    using TileMap = Tile[tileArrayHeight][tileArrayWidth];
 
    [[nodiscard]]
    inline bool isWalkable(const TileMap& map, int col, int row)
    {
        // Out-of-bounds check.
        if (col < 0 || row < 0 ||
            col >= static_cast<int>(tileArrayWidth) ||
            row >= static_cast<int>(tileArrayHeight))
        {
            return false;
        }
 
        const Tile t = map[row][col];
        return t != Tile::Stone && t != Tile::Brick;
    }
 
    [[nodiscard]]
    inline bool overlapsWall(const TileMap& map, int32_t xQ, int32_t yQ)
    {
        // Convert the hitbox corners from tile-Q8 center coordinates to tile indices.
        const int left   = (xQ - kHitboxHalfQ) / 256;
        const int right  = (xQ + kHitboxHalfQ - 1) / 256; // -1 so touching edge is not solid
        const int top    = (yQ - kHitboxHalfQ) / 256;
        const int bottom = (yQ + kHitboxHalfQ - 1) / 256;
 
        return !isWalkable(map, left,  top)    ||
               !isWalkable(map, right, top)    ||
               !isWalkable(map, left,  bottom) ||
               !isWalkable(map, right, bottom);
    }
 
    [[nodiscard]]
    inline TilePos stepMovement(TilePos pos, int8_t moveX, int8_t moveY, int32_t speedQ = kPlayerSpeedQ)
    {
        pos.xQ += moveX * speedQ;
        pos.yQ += moveY * speedQ;
        return pos;
    }
 
    [[nodiscard]]
    inline TilePos stepMovementWithCollision(TilePos pos,
                                             int8_t moveX,
                                             int8_t moveY,
                                             const TileMap& map,
                                             int32_t speedQ = kPlayerSpeedQ)
    {
        // Try X axis.
        if (moveX != 0)
        {
            const int32_t newXQ = pos.xQ + moveX * speedQ;
            if (!overlapsWall(map, newXQ, pos.yQ))
                pos.xQ = newXQ;
        }
 
        // Try Y axis.
        if (moveY != 0)
        {
            const int32_t newYQ = pos.yQ + moveY * speedQ;
            if (!overlapsWall(map, pos.xQ, newYQ))
                pos.yQ = newYQ;
        }
 
        return pos;
    }
 
    [[nodiscard]]
    inline int tileQToScreen(int32_t tileQ, int fieldPx, int scaledTile, int cameraPx)
    {
        return fieldPx + (tileQ * scaledTile / 256) - cameraPx;
    }
 
    [[nodiscard]]
    inline int tileQToScreenTopLeft(int32_t tileQ, int fieldPx, int scaledTile, int cameraPx)
    {
        return fieldPx + ((tileQ - 128) * scaledTile / 256) - cameraPx;
    }
 
} // namespace bomberman::sim
 
#endif // BOMBERMAN_SIM_MOVEMENT_H