From 9c1ec01ce0fca0c1878282cc1636ba3da72cc9a8 Mon Sep 17 00:00:00 2001 From: Jan Mrna Date: Thu, 30 Oct 2025 15:10:00 +0100 Subject: [PATCH] Re-formatted files --- cpp/src/camera.cpp | 34 ++--- cpp/src/camera.hpp | 21 ++- cpp/src/entities.cpp | 23 ++-- cpp/src/entities.hpp | 12 +- cpp/src/gameloop.cpp | 34 ++--- cpp/src/gameloop.hpp | 16 +-- cpp/src/log.hpp | 6 +- cpp/src/map.cpp | 67 +++++----- cpp/src/map.hpp | 13 +- cpp/src/math.hpp | 221 ++++++++++++++------------------ cpp/src/pathfinder/base.cpp | 9 +- cpp/src/pathfinder/base.hpp | 26 ++-- cpp/src/pathfinder/bfs.cpp | 87 ++++++------- cpp/src/pathfinder/bfs.hpp | 10 +- cpp/src/pathfinder/dijkstra.cpp | 64 +++++---- cpp/src/pathfinder/dijkstra.hpp | 8 +- cpp/src/pathfinder/gbfs.cpp | 58 ++++----- cpp/src/pathfinder/gbfs.hpp | 10 +- cpp/src/pathfinder/utils.cpp | 30 ++--- cpp/src/pathfinder/utils.hpp | 18 +-- cpp/src/pathfindingdemo.cpp | 185 +++++++++++--------------- cpp/src/pathfindingdemo.hpp | 19 +-- cpp/src/tile.cpp | 10 +- cpp/src/tile.hpp | 2 +- cpp/src/user_input.cpp | 135 ++++++++----------- cpp/src/user_input.hpp | 12 +- cpp/src/window.cpp | 18 +-- cpp/src/window.hpp | 11 +- 28 files changed, 523 insertions(+), 636 deletions(-) diff --git a/cpp/src/camera.cpp b/cpp/src/camera.cpp index 8e04ae7..c09d8cc 100644 --- a/cpp/src/camera.cpp +++ b/cpp/src/camera.cpp @@ -1,45 +1,35 @@ #include "camera.hpp" -#include "math.hpp" #include "log.hpp" +#include "math.hpp" // for now only pass-through placeholder functions, -// since we draw the whole map +// since we draw the whole map +void Camera::Pan(const WorldPos &delta) { m_Pan += (delta / m_Zoom); } -void Camera::Pan(const WorldPos& delta) -{ - m_Pan += (delta / m_Zoom); -} - -void Camera::Zoom(float delta) -{ +void Camera::Zoom(float delta) { constexpr float ZOOM_SCALE = 0.1f; m_Zoom += delta * ZOOM_SCALE; LOG_DEBUG("Zoom: ", m_Zoom); } -WindowPos Camera::WorldToWindow(WorldPos world) const -{ - const auto& v = world + m_Pan; +WindowPos Camera::WorldToWindow(WorldPos world) const { + const auto &v = world + m_Pan; return WindowPos{v[0], v[1]} * m_Zoom; } -WorldPos Camera::WindowToWorld(WindowPos window) const -{ +WorldPos Camera::WindowToWorld(WindowPos window) const { window /= m_Zoom; return WorldPos{window[0], window[1]} - m_Pan; } - -WindowSize Camera::WorldToWindowSize(WorldSize world) const -{ - const auto& v = world; +WindowSize Camera::WorldToWindowSize(WorldSize world) const { + const auto &v = world; // no zoom yet, just pass-through return WindowSize{v[0], v[1]} * m_Zoom; } -WorldSize Camera::WindowToWorldSize(WindowSize window) const -{ - window /= m_Zoom; - return WorldSize{window[0], window[1]}; +WorldSize Camera::WindowToWorldSize(WindowSize window) const { + window /= m_Zoom; + return WorldSize{window[0], window[1]}; } diff --git a/cpp/src/camera.hpp b/cpp/src/camera.hpp index b321baa..37b2527 100644 --- a/cpp/src/camera.hpp +++ b/cpp/src/camera.hpp @@ -2,28 +2,27 @@ #include "math.hpp" -class Camera -{ +class Camera { public: - void Pan(const WorldPos& delta); + void Pan(const WorldPos &delta); void Zoom(float delta); WorldPos GetPan() const { return m_Pan; } float GetZoom() const { return m_Zoom; } - WindowPos WorldToWindow(WorldPos) const; - WorldPos WindowToWorld(WindowPos) const; - WindowSize WorldToWindowSize(WorldSize) const; - WorldSize WindowToWorldSize(WindowSize) const; - + WindowPos WorldToWindow(WorldPos) const; + WorldPos WindowToWorld(WindowPos) const; + WindowSize WorldToWindowSize(WorldSize) const; + WorldSize WindowToWorldSize(WindowSize) const; + template - requires std::floating_point + requires std::floating_point T WindowToWorldSize(T window_size) const { return window_size / static_cast(m_Zoom); } - + template - requires std::floating_point + requires std::floating_point T WorldToWindowSize(T world_size) const { return world_size * static_cast(m_Zoom); } diff --git a/cpp/src/entities.cpp b/cpp/src/entities.cpp index 453b003..cd919f5 100644 --- a/cpp/src/entities.cpp +++ b/cpp/src/entities.cpp @@ -30,7 +30,8 @@ void Entity::ZeroActualVelocityInDirection(WorldPos direction) { // q1 * e1 + q2 * e2 = v, from this follows: auto &v = GetActualVelocity(); - float q2 = (v.y() * e1.x() - v.x() * e1.y()) / (e2.y() * e1.x() - e2.x() * e1.y()); + float q2 = + (v.y() * e1.x() - v.x() * e1.y()) / (e2.y() * e1.x() - e2.x() * e1.y()); float q1 = (v.x() - q2 * e2.x()) / e1.x(); // We then zero-out the q1, but only if it's positive - meaning @@ -46,9 +47,8 @@ void Entity::Update(float time_delta) { m_Position += m_ActualVelocity * time_delta; } -std::optional Entity::GetMoveTarget() -{ - auto& path = GetPath(); +std::optional Entity::GetMoveTarget() { + auto &path = GetPath(); if (path.empty()) { return {}; } @@ -61,27 +61,24 @@ std::optional Entity::GetMoveTarget() return next_pos; } // target reached, pop it - //m_MoveQueue.pop(); + // m_MoveQueue.pop(); path.erase(path.begin()); // return nothing - if there's next point in the queue, // we'll get it in the next iteration return {}; } -bool Entity::CollidesWith(const Entity& other) const -{ - const auto& A = *this; - const auto& B = other; +bool Entity::CollidesWith(const Entity &other) const { + const auto &A = *this; + const auto &B = other; auto position_A = A.GetPosition(); auto position_B = B.GetPosition(); auto distance_sq = position_A.DistanceSquared(position_B); auto collision_distance_sq = - A.GetCollisionRadiusSquared() + - B.GetCollisionRadiusSquared() + + A.GetCollisionRadiusSquared() + B.GetCollisionRadiusSquared() + 2 * A.GetCollisionRadius() * B.GetCollisionRadius(); - if (distance_sq < collision_distance_sq) - { + if (distance_sq < collision_distance_sq) { return true; } return false; diff --git a/cpp/src/entities.hpp b/cpp/src/entities.hpp index 6ad8521..41cc754 100644 --- a/cpp/src/entities.hpp +++ b/cpp/src/entities.hpp @@ -4,13 +4,13 @@ #include #include #include -#include #include +#include #include "log.hpp" #include "math.hpp" -#include "sprite.hpp" #include "pathfinder/base.hpp" +#include "sprite.hpp" class Entity { public: @@ -58,12 +58,12 @@ public: void ZeroActualVelocityInDirection(WorldPos direction); - const pathfinder::Path& GetPath() const { return m_Path; } - pathfinder::Path& GetPath() { return m_Path; } - void SetPath(pathfinder::Path& path) { m_Path = path; } + const pathfinder::Path &GetPath() const { return m_Path; } + pathfinder::Path &GetPath() { return m_Path; } + void SetPath(pathfinder::Path &path) { m_Path = path; } std::optional GetMoveTarget(); - bool CollidesWith(const Entity& other) const; + bool CollidesWith(const Entity &other) const; bool IsCollisionBoxVisible() const { return m_CollisionBoxVisible; } diff --git a/cpp/src/gameloop.cpp b/cpp/src/gameloop.cpp index 7944493..8d7b9b0 100644 --- a/cpp/src/gameloop.cpp +++ b/cpp/src/gameloop.cpp @@ -21,18 +21,17 @@ void GameLoop::Draw() { TilePos{static_cast(row), static_cast(col)})); const auto &size = camera.WorldToWindowSize(map.GetTileSize()); // LOG_DEBUG("Drawing rect (", row, ", ", col, ")"); - m_Window->DrawFilledRect(position, size, tiles[row][col]->R, tiles[row][col]->G, - tiles[row][col]->B, tiles[row][col]->A); + m_Window->DrawFilledRect(position, size, tiles[row][col]->R, + tiles[row][col]->G, tiles[row][col]->B, + tiles[row][col]->A); } } // draw the path, if it exists - for (const auto& entity : m_Game->GetEntities()) - { + for (const auto &entity : m_Game->GetEntities()) { WorldPos start_pos = entity->GetPosition(); - for (const auto &next_pos : entity->GetPath()) - { + for (const auto &next_pos : entity->GetPath()) { const auto &camera = m_Game->GetCamera(); m_Window->DrawLine(camera.WorldToWindow(start_pos), camera.WorldToWindow(next_pos)); @@ -44,29 +43,24 @@ void GameLoop::Draw() { for (auto &entity : m_Game->GetEntities()) { const auto &camera = m_Game->GetCamera(); auto entity_pos = camera.WorldToWindow(entity->GetPosition()); - m_Window->DrawSprite(entity_pos, - entity->GetSprite(), - camera.GetZoom()); - if (entity->IsCollisionBoxVisible()) - { - float collision_radius = camera.WorldToWindowSize(entity->GetCollisionRadius()); + m_Window->DrawSprite(entity_pos, entity->GetSprite(), camera.GetZoom()); + if (entity->IsCollisionBoxVisible()) { + float collision_radius = + camera.WorldToWindowSize(entity->GetCollisionRadius()); m_Window->DrawCircle(entity_pos, collision_radius, 255, 0, 0); } - if (entity->IsSelected()) - { - float collision_radius = camera.WorldToWindowSize(entity->GetCollisionRadius()); + if (entity->IsSelected()) { + float collision_radius = + camera.WorldToWindowSize(entity->GetCollisionRadius()); m_Window->DrawCircle(entity_pos, collision_radius, 0, 255, 0); } } // draw the selection box, if present - if (m_Game->IsSelectionBoxActive()) - { - const auto& [corner_pos, size] = m_Game->GetSelectionBoxPosSize(); + if (m_Game->IsSelectionBoxActive()) { + const auto &[corner_pos, size] = m_Game->GetSelectionBoxPosSize(); m_Window->DrawRect(corner_pos, size, 200, 20, 20); } - - } // TODO rethink coupling and dependencies in the game loop class diff --git a/cpp/src/gameloop.hpp b/cpp/src/gameloop.hpp index 1e381ae..daca1ff 100644 --- a/cpp/src/gameloop.hpp +++ b/cpp/src/gameloop.hpp @@ -3,24 +3,22 @@ #include #include "pathfindingdemo.hpp" -#include "window.hpp" #include "user_input.hpp" +#include "window.hpp" class GameLoop { public: GameLoop() = default; ~GameLoop() = default; - GameLoop(const GameLoop&) = delete; - GameLoop(GameLoop&&) = delete; - GameLoop& operator=(const GameLoop&) = delete; - GameLoop& operator=(GameLoop&&) = delete; - + GameLoop(const GameLoop &) = delete; + GameLoop(GameLoop &&) = delete; + GameLoop &operator=(const GameLoop &) = delete; + GameLoop &operator=(GameLoop &&) = delete; + void Run(); - void SetGame(std::unique_ptr x) { - m_Game = std::move(x); - } + void SetGame(std::unique_ptr x) { m_Game = std::move(x); } void SetWindow(std::unique_ptr x) { m_Window = std::move(x); } void SetUserInput(std::unique_ptr x) { m_UserInput = std::move(x); diff --git a/cpp/src/log.hpp b/cpp/src/log.hpp index 2f1cb6d..d81323f 100644 --- a/cpp/src/log.hpp +++ b/cpp/src/log.hpp @@ -3,11 +3,11 @@ #include #if defined(__GNUC__) || defined(__clang__) -# define PRETTY_FUNC __PRETTY_FUNCTION__ +#define PRETTY_FUNC __PRETTY_FUNCTION__ #elif defined(_MSC_VER) -# define PRETTY_FUNC __FUNCTION__ +#define PRETTY_FUNC __FUNCTION__ #else -# define PRETTY_FUNC __func__ +#define PRETTY_FUNC __func__ #endif #define LOG_CRITICAL(...) Log::critical(PRETTY_FUNC, ": ", __VA_ARGS__) diff --git a/cpp/src/map.cpp b/cpp/src/map.cpp index 902880f..5f378cf 100644 --- a/cpp/src/map.cpp +++ b/cpp/src/map.cpp @@ -11,21 +11,22 @@ Map::Map(int rows, int cols) : m_Cols(cols), m_Rows(rows) { for (size_t row = 0; row < m_Rows; row++) { m_Tiles.push_back(std::vector{}); for (size_t col = 0; col < m_Cols; col++) { - m_Tiles[row].push_back(&tile_types.at(TileType::GRASS)); + m_Tiles[row].push_back(&tile_types.at(TileType::GRASS)); } } } WorldPos Map::TileToWorld(TilePos p) const { - return WorldPos{(p.x() + 0.5f) * TILE_SIZE, (p.y() + 0.5f) * TILE_SIZE}; + return WorldPos{(p.x() + 0.5f) * TILE_SIZE, (p.y() + 0.5f) * TILE_SIZE}; } WorldPos Map::TileEdgeToWorld(TilePos p) const { - return WorldPos{p.x() * TILE_SIZE, p.y() * TILE_SIZE}; + return WorldPos{p.x() * TILE_SIZE, p.y() * TILE_SIZE}; } TilePos Map::WorldToTile(WorldPos p) const { - return TilePos{static_cast(p.x() / TILE_SIZE), static_cast(p.y() / TILE_SIZE)}; + return TilePos{static_cast(p.x() / TILE_SIZE), + static_cast(p.y() / TILE_SIZE)}; } WorldSize Map::GetTileSize() const { return WorldSize{TILE_SIZE, TILE_SIZE}; } @@ -51,40 +52,38 @@ bool Map::IsTilePosValid(TilePos p) const { return row < m_Tiles.size() && col < m_Tiles[0].size(); } - -std::vector Map::GetNeighbors(TilePos center) const -{ +std::vector Map::GetNeighbors(TilePos center) const { std::vector neighbours; neighbours.reserve(4); std::array candidates = { - center + TilePos{ 1, 0}, - center + TilePos{-1, 0}, - center + TilePos{ 0, 1}, - center + TilePos{ 0, -1}, + center + TilePos{1, 0}, + center + TilePos{-1, 0}, + center + TilePos{0, 1}, + center + TilePos{0, -1}, }; - for (const auto& c : candidates) { + for (const auto &c : candidates) { if (IsTilePosValid(c)) - neighbours.push_back(c); + neighbours.push_back(c); } return neighbours; } - -void Map::PaintCircle(TilePos center, unsigned radius, TileType tile_type) -{ +void Map::PaintCircle(TilePos center, unsigned radius, TileType tile_type) { // get rectangle that wraps the circle - TilePos corner1 = TilePos{center.x() - static_cast(radius), center.y() - static_cast(radius)}; - TilePos corner2 = TilePos{center.x() + static_cast(radius), center.y() + static_cast(radius)}; + TilePos corner1 = TilePos{center.x() - static_cast(radius), + center.y() - static_cast(radius)}; + TilePos corner2 = TilePos{center.x() + static_cast(radius), + center.y() + static_cast(radius)}; // iterate through all valid points, setting the type - const unsigned radius_squared = radius * radius; + const unsigned radius_squared = radius * radius; for (int x = corner1.x(); x < corner2.x(); x++) { for (int y = corner1.y(); y < corner2.y(); y++) { - TilePos current_tile = {x, y}; - unsigned distance_squared = static_cast(center.DistanceTo(current_tile) * center.DistanceTo(current_tile)); - if (IsTilePosValid(current_tile) && distance_squared < radius_squared) - { + TilePos current_tile = {x, y}; + unsigned distance_squared = static_cast( + center.DistanceTo(current_tile) * center.DistanceTo(current_tile)); + if (IsTilePosValid(current_tile) && distance_squared < radius_squared) { // y is row, x is col m_Tiles[y][x] = &tile_types.at(tile_type); } @@ -92,10 +91,12 @@ void Map::PaintCircle(TilePos center, unsigned radius, TileType tile_type) } } -void Map::PaintLine(TilePos start_tile, TilePos stop_tile, double width, TileType tile_type) -{ - const vec start{static_cast(start_tile.x()), static_cast(start_tile.y())}; - const vec stop{static_cast(stop_tile.x()), static_cast(stop_tile.y())}; +void Map::PaintLine(TilePos start_tile, TilePos stop_tile, double width, + TileType tile_type) { + const vec start{static_cast(start_tile.x()), + static_cast(start_tile.y())}; + const vec stop{static_cast(stop_tile.x()), + static_cast(stop_tile.y())}; const double line_length = start.DistanceTo(stop); const vec step = (stop - start) / line_length; const vec ortho = step.GetOrthogonal(); @@ -104,7 +105,8 @@ void Map::PaintLine(TilePos start_tile, TilePos stop_tile, double width, TileTyp for (double t = 0; t < line_length; t += 1.0) { for (double ortho_t = 0; ortho_t < width; ortho_t += 0.1) { auto tile_pos = start + step * t + ortho * ortho_t; - TilePos tile_pos_int{static_cast(tile_pos.x()), static_cast(tile_pos.y())}; + TilePos tile_pos_int{static_cast(tile_pos.x()), + static_cast(tile_pos.y())}; if (IsTilePosValid(tile_pos_int)) { size_t row = static_cast(tile_pos.x()); size_t col = static_cast(tile_pos.y()); @@ -114,15 +116,14 @@ void Map::PaintLine(TilePos start_tile, TilePos stop_tile, double width, TileTyp } } - -void Map::PaintRectangle(TilePos first_corner, TilePos second_corner, TileType tile_type) -{ +void Map::PaintRectangle(TilePos first_corner, TilePos second_corner, + TileType tile_type) { std::initializer_list xvals = {first_corner.x(), second_corner.x()}; std::initializer_list yvals = {first_corner.y(), second_corner.y()}; for (int x = std::min(xvals); x < std::max(xvals); x++) { for (int y = std::min(yvals); y < std::max(yvals); y++) { - TilePos tile_pos{x,y}; - LOG_DEBUG("tile_pos = ", tile_pos); + TilePos tile_pos{x, y}; + LOG_DEBUG("tile_pos = ", tile_pos); if (IsTilePosValid(tile_pos)) { size_t row = static_cast(tile_pos.x()); size_t col = static_cast(tile_pos.y()); diff --git a/cpp/src/map.hpp b/cpp/src/map.hpp index 6b400f6..9b40dcb 100644 --- a/cpp/src/map.hpp +++ b/cpp/src/map.hpp @@ -14,10 +14,10 @@ public: Map(int rows, int cols); Map() : Map(0, 0) {} - Map(const Map&) = delete; - Map(Map&&) = delete; - Map& operator=(const Map&) = delete; - Map& operator=(Map&&) = delete; + Map(const Map &) = delete; + Map(Map &&) = delete; + Map &operator=(const Map &) = delete; + Map &operator=(Map &&) = delete; const TileGrid &GetMapTiles() const { return m_Tiles; } @@ -25,7 +25,7 @@ public: WorldPos TileToWorld(TilePos p) const; WorldPos TileEdgeToWorld(TilePos p) const; TilePos WorldToTile(WorldPos p) const; - + WorldSize GetTileSize() const; const Tile *GetTileAt(TilePos p) const; const Tile *GetTileAt(WorldPos p) const; @@ -35,7 +35,8 @@ public: // methods for drawing on the map void PaintCircle(TilePos center, unsigned radius, TileType tile_type); void PaintLine(TilePos start, TilePos stop, double width, TileType tile_type); - void PaintRectangle(TilePos first_corner, TilePos second_corner, TileType tile_type); + void PaintRectangle(TilePos first_corner, TilePos second_corner, + TileType tile_type); std::vector GetNeighbors(TilePos center) const; float GetCost(TilePos pos) const { return GetTileAt(pos)->cost; } diff --git a/cpp/src/math.hpp b/cpp/src/math.hpp index fea1c92..d496a5d 100644 --- a/cpp/src/math.hpp +++ b/cpp/src/math.hpp @@ -4,12 +4,12 @@ #include #include #include +#include #include #include #include #include #include -#include #ifdef _WIN32 #include @@ -39,8 +39,7 @@ struct Any {}; template class vec { // Friend declaration for move constructor from different tag types - template - friend class vec; + template friend class vec; public: vec() : m_Array{} {} @@ -51,8 +50,8 @@ public: vec(std::array array) : m_Array{array} {} - template - vec(vec&& other) : m_Array{std::move(other.m_Array)} {} + template + vec(vec &&other) : m_Array{std::move(other.m_Array)} {} // // Access to elements & data @@ -77,20 +76,20 @@ public: return os; } - std::array& Data() { return m_Array; } + std::array &Data() { return m_Array; } // // binary operators // friend bool operator==(const vec &a, const vec &b) - requires (std::is_integral_v) + requires(std::is_integral_v) { return std::ranges::equal(a.m_Array, b.m_Array); } friend bool operator==(const vec &a, const vec &b) - requires (std::is_floating_point_v) + requires(std::is_floating_point_v) { for (const auto &[u, v] : std::views::zip(a.m_Array, b.m_Array)) { if (!equalEpsilon(u, v)) { @@ -109,8 +108,7 @@ public: return c; } - friend vec operator+(const vec& a, T b) - { + friend vec operator+(const vec &a, T b) { vec c; std::ranges::transform(a.m_Array, std::views::repeat(b), c.m_Array.begin(), std::plus{}); @@ -124,8 +122,7 @@ public: return c; } - friend vec operator-(const vec& a, T b) - { + friend vec operator-(const vec &a, T b) { vec c; std::ranges::transform(a.m_Array, std::views::repeat(b), c.m_Array.begin(), std::minus{}); @@ -148,10 +145,10 @@ public: return c; } - friend vec operator/(const vec &a, const vec& b) { + friend vec operator/(const vec &a, const vec &b) { vec c; - std::ranges::transform(a.m_Array, b.m_Array, - c.m_Array.begin(), std::divides{}); + std::ranges::transform(a.m_Array, b.m_Array, c.m_Array.begin(), + std::divides{}); return c; } @@ -173,12 +170,12 @@ public: return a; } - vec& operator/=(float scalar) - { - vec& a = *this; + vec &operator/=(float scalar) { + vec &a = *this; auto b = std::views::repeat(scalar); std::ranges::transform(a.m_Array, b, a.m_Array.begin(), std::divides{}); - // TODO check all of this, could be done better with views instead of ranges? + // TODO check all of this, could be done better with views instead of + // ranges? return a; } @@ -203,7 +200,6 @@ public: return (a - b).LengthSquared(); } - // // In-place vector operations // @@ -237,16 +233,14 @@ public: return tmp; } - static T DotProduct(const vec& a, const vec& b) - { - return std::inner_product( - a.m_Array.begin(), a.m_Array.end(), b.m_Array.begin(), - T{}, std::plus{}, std::multiplies{}); + static T DotProduct(const vec &a, const vec &b) { + return std::inner_product(a.m_Array.begin(), a.m_Array.end(), + b.m_Array.begin(), T{}, std::plus{}, + std::multiplies{}); } - T DotProduct(const vec& b) const - { - const auto& a = *this; + T DotProduct(const vec &b) const { + const auto &a = *this; return DotProduct(a, b); } @@ -290,28 +284,24 @@ public: return m_Array[2]; } - template - vec ChangeTag() const & - { - return vec(m_Array); + template vec ChangeTag() const & { + return vec(m_Array); } - template - vec ChangeTag() && - { - return vec(std::move(*this)); + template vec ChangeTag() && { + return vec(std::move(*this)); } // Structured binding support for N == 2 - template - const T& get() const + template + const T &get() const requires(N == 2 && I < 2) { return m_Array[I]; } - template - T& get() + template + T &get() requires(N == 2 && I < 2) { return m_Array[I]; @@ -372,114 +362,101 @@ struct TilePosHash { // // Collumn major square matrix -template -class Matrix { +template class Matrix { -using vec_type = vec; + using vec_type = vec; public: - Matrix() = default; + Matrix() = default; - // Initialization using flat array of N*N elements - template - requires (M == N*N && std::same_as) - Matrix(std::array array) : m_Array{} - { - std::size_t idx = 0; - for (auto col : array | std::views::chunk(N)) - { - std::ranges::copy(col, m_Array[idx++].Data().begin()); - } + // Initialization using flat array of N*N elements + template + requires(M == N * N && std::same_as) + Matrix(std::array array) : m_Array{} { + std::size_t idx = 0; + for (auto col : array | std::views::chunk(N)) { + std::ranges::copy(col, m_Array[idx++].Data().begin()); } + } - const vec_type& operator[](size_t index) const { return m_Array[index]; } - vec_type& operator[](size_t index) { return m_Array[index]; } + const vec_type &operator[](size_t index) const { return m_Array[index]; } + vec_type &operator[](size_t index) { return m_Array[index]; } - friend std::ostream &operator<<(std::ostream &os, const Matrix &obj) - { - os << "( "; - for (const auto &element : obj.m_Array) { - os << element << " "; - } - os << ")"; - return os; + friend std::ostream &operator<<(std::ostream &os, const Matrix &obj) { + os << "( "; + for (const auto &element : obj.m_Array) { + os << element << " "; } + os << ")"; + return os; + } + friend Matrix operator+(const Matrix &A, const Matrix &B) { + Matrix C; + std::ranges::transform(A.m_Array, B.m_Array, C.m_Array.begin(), + std::plus{}); + return C; + } - friend Matrix operator+(const Matrix& A, const Matrix& B) - { - Matrix C; - std::ranges::transform(A.m_Array, B.m_Array, C.m_Array.begin(), std::plus{}); - return C; + friend Matrix operator-(const Matrix &A, const Matrix &B) { + Matrix C; + std::ranges::transform(A.m_Array, B.m_Array, C.m_Array.begin(), + std::minus{}); + return C; + } + + friend Matrix operator*(const Matrix &A, const Matrix &B) { + Matrix C; + + for (size_t i = 0; i < N; i++) { + for (size_t j = 0; j < N; j++) { + T sum = 0; + for (size_t k = 0; k < N; ++k) + sum += A[i][k] * B[k][j]; + C[i][j] = sum; + } } + return C; + } - friend Matrix operator-(const Matrix& A, const Matrix& B) - { - Matrix C; - std::ranges::transform(A.m_Array, B.m_Array, C.m_Array.begin(), std::minus{}); - return C; + friend vec_type operator*(const Matrix &A, const vec_type &b) { + // we assume that b is row vector + vec_type c; + for (size_t i = 0; i < N; i++) { + c[i] = b.DotProduct(A[i]); } + return c; + } - friend Matrix operator*(const Matrix& A, const Matrix& B) - { - Matrix C; - - for (size_t i = 0; i < N; i++) - { - for (size_t j = 0; j < N; j++) - { - T sum = 0; - for (size_t k = 0; k < N; ++k) sum += A[i][k] * B[k][j]; - C[i][j] = sum; - } - } - return C; + static constexpr Matrix Eye() { + Matrix E; + for (size_t i = 0; i < N; i++) { + E[i][i] = T{1}; } - - friend vec_type operator*(const Matrix& A, const vec_type& b) - { - // we assume that b is row vector - vec_type c; - for (size_t i = 0; i < N; i++) - { - c[i] = b.DotProduct(A[i]); - } - return c; - } - - static constexpr Matrix Eye() - { - Matrix E; - for (size_t i = 0; i < N; i++) - { - E[i][i] = T{1}; - } - return E; - } - + return E; + } private: - std::array m_Array; + std::array m_Array; }; // Structured binding support for vec namespace std { - template - struct tuple_size> : integral_constant {}; +template +struct tuple_size> : integral_constant {}; - template - struct tuple_element> { - using type = T; - }; -} +template +struct tuple_element> { + using type = T; +}; +} // namespace std // ADL-based get for structured bindings -template -const T& get(const vec& v) { +template +const T &get(const vec &v) { return v.template get(); } -template -T& get(vec& v) { +template T &get(vec &v) { return v.template get(); } diff --git a/cpp/src/pathfinder/base.cpp b/cpp/src/pathfinder/base.cpp index cccaf5b..9df1300 100644 --- a/cpp/src/pathfinder/base.cpp +++ b/cpp/src/pathfinder/base.cpp @@ -1,5 +1,5 @@ -#include #include +#include #include #include "pathfinder/base.hpp" @@ -9,14 +9,15 @@ namespace pathfinder { -PathFinderBase::PathFinderBase(const Map* map) : m_Map(map) {} +PathFinderBase::PathFinderBase(const Map *map) : m_Map(map) {} // LinearPathFinder also lives here, since it is too small to get it's // own implementation file -Path LinearPathFinder::CalculatePath(WorldPos, WorldPos end) // first argument (start pos) not used +Path LinearPathFinder::CalculatePath( + WorldPos, WorldPos end) // first argument (start pos) not used { auto path = Path{end}; return path; } -} // pathfinder namespace +} // namespace pathfinder diff --git a/cpp/src/pathfinder/base.hpp b/cpp/src/pathfinder/base.hpp index 97ce18f..c9cb09c 100644 --- a/cpp/src/pathfinder/base.hpp +++ b/cpp/src/pathfinder/base.hpp @@ -1,11 +1,11 @@ #pragma once -#include #include #include +#include -#include "math.hpp" #include "map.hpp" +#include "math.hpp" namespace pathfinder { @@ -21,32 +21,30 @@ enum class PathFinderType { class PathFinderBase { public: - PathFinderBase(const Map* m); + PathFinderBase(const Map *m); ~PathFinderBase() = default; - PathFinderBase(const PathFinderBase&) = delete; - PathFinderBase(PathFinderBase&&) = delete; - PathFinderBase& operator=(const PathFinderBase&) = delete; - PathFinderBase& operator=(PathFinderBase&&) = delete; + PathFinderBase(const PathFinderBase &) = delete; + PathFinderBase(PathFinderBase &&) = delete; + PathFinderBase &operator=(const PathFinderBase &) = delete; + PathFinderBase &operator=(PathFinderBase &&) = delete; - virtual const std::string_view& GetName() const = 0; + virtual const std::string_view &GetName() const = 0; virtual Path CalculatePath(WorldPos start, WorldPos end) = 0; protected: - const Map* m_Map; + const Map *m_Map; }; - class LinearPathFinder : public PathFinderBase { public: - LinearPathFinder(const Map* m): PathFinderBase(m) {} + LinearPathFinder(const Map *m) : PathFinderBase(m) {} Path CalculatePath(WorldPos start, WorldPos end) override; - const std::string_view& GetName() const override { return m_Name; } + const std::string_view &GetName() const override { return m_Name; } private: const std::string_view m_Name = "Linear Path"; }; -} // pathfinder namespace - +} // namespace pathfinder diff --git a/cpp/src/pathfinder/bfs.cpp b/cpp/src/pathfinder/bfs.cpp index 747f410..8807021 100644 --- a/cpp/src/pathfinder/bfs.cpp +++ b/cpp/src/pathfinder/bfs.cpp @@ -7,60 +7,61 @@ #include "math.hpp" namespace pathfinder { - + Path BFS::CalculatePath(WorldPos start_world, WorldPos end_world) { - if (m_Map == nullptr) return {}; + if (m_Map == nullptr) + return {}; - const TilePos start = m_Map->WorldToTile(start_world); - const TilePos end = m_Map->WorldToTile(end_world); + const TilePos start = m_Map->WorldToTile(start_world); + const TilePos end = m_Map->WorldToTile(end_world); - if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end)) - return {}; - if (start == end) { - return {}; - } - // clear previous run - m_CameFrom.clear(); - m_Distance.clear(); + if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end)) + return {}; + if (start == end) { + return {}; + } + // clear previous run + m_CameFrom.clear(); + m_Distance.clear(); - std::queue frontier; - frontier.push(start); - m_CameFrom[start] = start; - m_Distance[start] = 0.0f; + std::queue frontier; + frontier.push(start); + m_CameFrom[start] = start; + m_Distance[start] = 0.0f; - // ---------------- build flow-field ---------------- - bool early_exit = false; - while (!frontier.empty() && !early_exit) { - TilePos current = frontier.front(); - frontier.pop(); + // ---------------- build flow-field ---------------- + bool early_exit = false; + while (!frontier.empty() && !early_exit) { + TilePos current = frontier.front(); + frontier.pop(); - for (TilePos next : m_Map->GetNeighbors(current)) { - if (m_CameFrom.find(next) == m_CameFrom.end()) { // not visited - frontier.push(next); - m_Distance[next] = m_Distance[current] + 1.0f; - m_CameFrom[next] = current; + for (TilePos next : m_Map->GetNeighbors(current)) { + if (m_CameFrom.find(next) == m_CameFrom.end()) { // not visited + frontier.push(next); + m_Distance[next] = m_Distance[current] + 1.0f; + m_CameFrom[next] = current; - if (next == end) { // early exit - early_exit = true; - break; - } - } + if (next == end) { // early exit + early_exit = true; + break; } + } } + } - // --------------- reconstruct path ----------------- - if (m_CameFrom.find(end) == m_CameFrom.end()) - return {}; // end not reached + // --------------- reconstruct path ----------------- + if (m_CameFrom.find(end) == m_CameFrom.end()) + return {}; // end not reached - Path path; - TilePos cur = end; + Path path; + TilePos cur = end; + path.push_back(m_Map->TileToWorld(cur)); + while (cur != start) { + cur = m_CameFrom[cur]; path.push_back(m_Map->TileToWorld(cur)); - while (cur != start) { - cur = m_CameFrom[cur]; - path.push_back(m_Map->TileToWorld(cur)); - } - std::reverse(path.begin(), path.end()); - return path; + } + std::reverse(path.begin(), path.end()); + return path; } -} // pathfinder namespace +} // namespace pathfinder diff --git a/cpp/src/pathfinder/bfs.hpp b/cpp/src/pathfinder/bfs.hpp index f42124c..2d19b02 100644 --- a/cpp/src/pathfinder/bfs.hpp +++ b/cpp/src/pathfinder/bfs.hpp @@ -8,13 +8,13 @@ #include "math.hpp" namespace pathfinder { - -class BFS: public PathFinderBase { + +class BFS : public PathFinderBase { public: - BFS(const Map* m): PathFinderBase(m) {} + BFS(const Map *m) : PathFinderBase(m) {} Path CalculatePath(WorldPos start, WorldPos end) override; - const std::string_view& GetName() const override { return m_Name; } + const std::string_view &GetName() const override { return m_Name; } private: const std::string_view m_Name = "Breadth First Search"; @@ -22,4 +22,4 @@ private: std::unordered_map m_CameFrom; }; -} +} // namespace pathfinder diff --git a/cpp/src/pathfinder/dijkstra.cpp b/cpp/src/pathfinder/dijkstra.cpp index 4c7048f..4d13497 100644 --- a/cpp/src/pathfinder/dijkstra.cpp +++ b/cpp/src/pathfinder/dijkstra.cpp @@ -3,71 +3,69 @@ #include "dijkstra.hpp" #include "base.hpp" -#include "utils.hpp" -#include "math.hpp" #include "map.hpp" +#include "math.hpp" +#include "utils.hpp" namespace pathfinder { -Path Dijkstra::CalculatePath(WorldPos start_world, WorldPos end_world) -{ +Path Dijkstra::CalculatePath(WorldPos start_world, WorldPos end_world) { using QueueEntry = utils::QueueEntry; - if (!m_Map) return {}; + if (!m_Map) + return {}; const TilePos start = m_Map->WorldToTile(start_world); - const TilePos end = m_Map->WorldToTile(end_world); + const TilePos end = m_Map->WorldToTile(end_world); if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end)) - return {}; - if (start == end) return {}; + return {}; + if (start == end) + return {}; // clear previous run m_CameFrom.clear(); m_Cost.clear(); - std::priority_queue, std::greater<>> frontier; + std::priority_queue, std::greater<>> + frontier; frontier.push({0.0f, start}); - m_CameFrom[start] = start; // sentinel - m_Cost[start] = 0.0f; + m_CameFrom[start] = start; // sentinel + m_Cost[start] = 0.0f; - while (!frontier.empty()) - { - const QueueEntry current = frontier.top(); - frontier.pop(); + while (!frontier.empty()) { + const QueueEntry current = frontier.top(); + frontier.pop(); - if (current.tile == end) // early exit - break; + if (current.tile == end) // early exit + break; - for (TilePos next : m_Map->GetNeighbors(current.tile)) - { - // cost of moving to neighbour (uniform 1.0 matches original BFS) - const float newCost = m_Cost[current.tile] + m_Map->GetCost(next); + for (TilePos next : m_Map->GetNeighbors(current.tile)) { + // cost of moving to neighbour (uniform 1.0 matches original BFS) + const float newCost = m_Cost[current.tile] + m_Map->GetCost(next); - if (!m_Cost.count(next) || newCost < m_Cost[next]) - { - m_Cost[next] = newCost; - m_CameFrom[next] = current.tile; - frontier.push({newCost, next}); - } + if (!m_Cost.count(next) || newCost < m_Cost[next]) { + m_Cost[next] = newCost; + m_CameFrom[next] = current.tile; + frontier.push({newCost, next}); } + } } // reconstruct path if (!m_CameFrom.count(end)) - return {}; // goal never reached + return {}; // goal never reached Path path; TilePos cur = end; path.push_back(m_Map->TileToWorld(cur)); - while (cur != start) - { - cur = m_CameFrom[cur]; - path.push_back(m_Map->TileToWorld(cur)); + while (cur != start) { + cur = m_CameFrom[cur]; + path.push_back(m_Map->TileToWorld(cur)); } std::reverse(path.begin(), path.end()); return path; } -} // pathfinder namespace +} // namespace pathfinder diff --git a/cpp/src/pathfinder/dijkstra.hpp b/cpp/src/pathfinder/dijkstra.hpp index 4d867c8..beeae81 100644 --- a/cpp/src/pathfinder/dijkstra.hpp +++ b/cpp/src/pathfinder/dijkstra.hpp @@ -10,12 +10,12 @@ namespace pathfinder { -class Dijkstra: public PathFinderBase { +class Dijkstra : public PathFinderBase { public: - Dijkstra(const Map* m): PathFinderBase(m) {} + Dijkstra(const Map *m) : PathFinderBase(m) {} Path CalculatePath(WorldPos start, WorldPos end) override; - const std::string_view& GetName() const override { return m_Name; } + const std::string_view &GetName() const override { return m_Name; } private: const std::string_view m_Name = "Dijkstra's Algorithm"; @@ -23,4 +23,4 @@ private: std::unordered_map m_CameFrom; }; -} // pathfinder namespace +} // namespace pathfinder diff --git a/cpp/src/pathfinder/gbfs.cpp b/cpp/src/pathfinder/gbfs.cpp index 02684ca..12e09c1 100644 --- a/cpp/src/pathfinder/gbfs.cpp +++ b/cpp/src/pathfinder/gbfs.cpp @@ -3,69 +3,67 @@ #include "gbfs.hpp" #include "base.hpp" -#include "math.hpp" #include "map.hpp" +#include "math.hpp" #include "pathfinder/utils.hpp" namespace pathfinder { -float GBFS::Heuristic(const TilePos& a, const TilePos& b) -{ - return static_cast(std::abs(a.x() - b.x()) + std::abs(a.y() - b.y())); +float GBFS::Heuristic(const TilePos &a, const TilePos &b) { + return static_cast(std::abs(a.x() - b.x()) + std::abs(a.y() - b.y())); } -Path GBFS::CalculatePath(WorldPos start_world, WorldPos end_world) -{ +Path GBFS::CalculatePath(WorldPos start_world, WorldPos end_world) { using QueueEntry = pathfinder::utils::QueueEntry; - if (!m_Map) return {}; + if (!m_Map) + return {}; const TilePos start = m_Map->WorldToTile(start_world); - const TilePos end = m_Map->WorldToTile(end_world); + const TilePos end = m_Map->WorldToTile(end_world); if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end)) - return {}; - if (start == end) return {}; + return {}; + if (start == end) + return {}; m_CameFrom.clear(); - std::priority_queue, std::greater<>> frontier; + std::priority_queue, std::greater<>> + frontier; frontier.push({Heuristic(start, end), start}); - m_CameFrom[start] = start; // sentinel + m_CameFrom[start] = start; // sentinel - while (!frontier.empty()) - { - const QueueEntry current = frontier.top(); - frontier.pop(); + while (!frontier.empty()) { + const QueueEntry current = frontier.top(); + frontier.pop(); - if (current.tile == end) // early exit - break; + if (current.tile == end) // early exit + break; - for (TilePos next : m_Map->GetNeighbors(current.tile)) + for (TilePos next : m_Map->GetNeighbors(current.tile)) { + if (!m_CameFrom.count(next)) // not visited { - if (!m_CameFrom.count(next)) // not visited - { - m_CameFrom[next] = current.tile; - frontier.push({Heuristic(end, next), next}); - } + m_CameFrom[next] = current.tile; + frontier.push({Heuristic(end, next), next}); } + } } // reconstruct path if (!m_CameFrom.count(end)) - return {}; // goal never reached + return {}; // goal never reached Path path; TilePos cur = end; path.push_back(m_Map->TileToWorld(cur)); - while (cur != start) - { - cur = m_CameFrom[cur]; - path.push_back(m_Map->TileToWorld(cur)); + while (cur != start) { + cur = m_CameFrom[cur]; + path.push_back(m_Map->TileToWorld(cur)); } std::reverse(path.begin(), path.end()); return path; } -} // pathfinder namespace +} // namespace pathfinder diff --git a/cpp/src/pathfinder/gbfs.hpp b/cpp/src/pathfinder/gbfs.hpp index dc50585..29a7266 100644 --- a/cpp/src/pathfinder/gbfs.hpp +++ b/cpp/src/pathfinder/gbfs.hpp @@ -10,17 +10,17 @@ namespace pathfinder { -class GBFS: public PathFinderBase { +class GBFS : public PathFinderBase { public: - GBFS(const Map* m): PathFinderBase(m) {} + GBFS(const Map *m) : PathFinderBase(m) {} Path CalculatePath(WorldPos start, WorldPos end) override; - const std::string_view& GetName() const override { return m_Name; } + const std::string_view &GetName() const override { return m_Name; } private: - static float Heuristic(const TilePos& a, const TilePos& b); + static float Heuristic(const TilePos &a, const TilePos &b); const std::string_view m_Name = "Greedy Best First Search"; std::unordered_map m_CameFrom; }; -} // pathfinder namespace +} // namespace pathfinder diff --git a/cpp/src/pathfinder/utils.cpp b/cpp/src/pathfinder/utils.cpp index e2bc5a4..f4a0717 100644 --- a/cpp/src/pathfinder/utils.cpp +++ b/cpp/src/pathfinder/utils.cpp @@ -3,9 +3,9 @@ #include "utils.hpp" #include "base.hpp" +#include "log.hpp" #include "map.hpp" #include "math.hpp" -#include "log.hpp" #include "pathfinder/bfs.hpp" #include "pathfinder/dijkstra.hpp" #include "pathfinder/gbfs.hpp" @@ -13,23 +13,23 @@ namespace pathfinder { namespace utils { -std::unique_ptr create(PathFinderType type, const Map* map) { +std::unique_ptr create(PathFinderType type, const Map *map) { using namespace pathfinder; switch (type) { - case PathFinderType::LINEAR: - return std::move(std::make_unique(map)); - case PathFinderType::BFS: - return std::move(std::make_unique(map)); - case PathFinderType::DIJKSTRA: - return std::move(std::make_unique(map)); - case PathFinderType::GBFS: - return std::move(std::make_unique(map)); - case PathFinderType::COUNT: - LOG_WARNING("Incorrect pathfinder type"); - return nullptr; + case PathFinderType::LINEAR: + return std::move(std::make_unique(map)); + case PathFinderType::BFS: + return std::move(std::make_unique(map)); + case PathFinderType::DIJKSTRA: + return std::move(std::make_unique(map)); + case PathFinderType::GBFS: + return std::move(std::make_unique(map)); + case PathFinderType::COUNT: + LOG_WARNING("Incorrect pathfinder type"); + return nullptr; }; return nullptr; } -} // utils namespace -} // pathfinding namespace +} // namespace utils +} // namespace pathfinder diff --git a/cpp/src/pathfinder/utils.hpp b/cpp/src/pathfinder/utils.hpp index c40e4fb..cdf7821 100644 --- a/cpp/src/pathfinder/utils.hpp +++ b/cpp/src/pathfinder/utils.hpp @@ -10,16 +10,16 @@ namespace pathfinder { namespace utils { -struct QueueEntry -{ - float cost; - TilePos tile; +struct QueueEntry { + float cost; + TilePos tile; - // min-heap -> smallest cost on top - bool operator>(const QueueEntry& o) const noexcept { return cost > o.cost; } + // min-heap -> smallest cost on top + bool operator>(const QueueEntry &o) const noexcept { return cost > o.cost; } }; -std::unique_ptr create(pathfinder::PathFinderType type, const Map* map); +std::unique_ptr +create(pathfinder::PathFinderType type, const Map *map); -} // utils namespace -} // pathfinding namespace +} // namespace utils +} // namespace pathfinder diff --git a/cpp/src/pathfindingdemo.cpp b/cpp/src/pathfindingdemo.cpp index 7d8cd50..6e06b70 100644 --- a/cpp/src/pathfindingdemo.cpp +++ b/cpp/src/pathfindingdemo.cpp @@ -8,17 +8,16 @@ #include "entities.hpp" #include "log.hpp" #include "map.hpp" -#include "user_input.hpp" #include "pathfinder/base.hpp" #include "pathfinder/utils.hpp" #include "tile.hpp" +#include "user_input.hpp" -PathFindingDemo::PathFindingDemo(int width, int height) : - m_Map(width, height) -{ +PathFindingDemo::PathFindingDemo(int width, int height) : m_Map(width, height) { LOG_DEBUG("."); // set default pathfinder method - m_PathFinder = pathfinder::utils::create(pathfinder::PathFinderType::DIJKSTRA, (const Map*)&m_Map); + m_PathFinder = pathfinder::utils::create(pathfinder::PathFinderType::DIJKSTRA, + (const Map *)&m_Map); } PathFindingDemo::~PathFindingDemo() { LOG_DEBUG("."); } @@ -33,29 +32,29 @@ void PathFindingDemo::CreateMap() { m_Map.PaintCircle(TilePos{50, 50}, 10, TileType::WATER); m_Map.PaintCircle(TilePos{75, 100}, 50, TileType::WATER); // river - m_Map.PaintLine(TilePos{0,0}, TilePos{100,100}, 3.0, TileType::WATER); + m_Map.PaintLine(TilePos{0, 0}, TilePos{100, 100}, 3.0, TileType::WATER); // road - m_Map.PaintLine(TilePos{17,6}, TilePos{100,6}, 5.0, TileType::ROAD); - m_Map.PaintLine(TilePos{10,17}, TilePos{10,100}, 5.0, TileType::ROAD); - m_Map.PaintLine(TilePos{20,10}, TilePos{10,20}, 5.0, TileType::ROAD); + m_Map.PaintLine(TilePos{17, 6}, TilePos{100, 6}, 5.0, TileType::ROAD); + m_Map.PaintLine(TilePos{10, 17}, TilePos{10, 100}, 5.0, TileType::ROAD); + m_Map.PaintLine(TilePos{20, 10}, TilePos{10, 20}, 5.0, TileType::ROAD); // bridges - m_Map.PaintLine(TilePos{50,75}, TilePos{70,75}, 5.0, TileType::WOOD); - m_Map.PaintLine(TilePos{95,26}, TilePos{95,60}, 5.0, TileType::WOOD); + m_Map.PaintLine(TilePos{50, 75}, TilePos{70, 75}, 5.0, TileType::WOOD); + m_Map.PaintLine(TilePos{95, 26}, TilePos{95, 60}, 5.0, TileType::WOOD); // island - m_Map.PaintRectangle(TilePos{70, 60}, TilePos{100,100}, TileType::GRASS); + m_Map.PaintRectangle(TilePos{70, 60}, TilePos{100, 100}, TileType::GRASS); // walls - m_Map.PaintLine(TilePos{71,60}, TilePos{90,60}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{77,67}, TilePos{100,67}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{71,60}, TilePos{71,75}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{72,73}, TilePos{95,73}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{95,73}, TilePos{95,90}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{71,81}, TilePos{71,100}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{72,81}, TilePos{90,81}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{89,87}, TilePos{89,100}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{84,81}, TilePos{84,96}, 1.0, TileType::WALL); - m_Map.PaintLine(TilePos{78,87}, TilePos{78,100}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{71, 60}, TilePos{90, 60}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{77, 67}, TilePos{100, 67}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{71, 60}, TilePos{71, 75}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{72, 73}, TilePos{95, 73}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{95, 73}, TilePos{95, 90}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{71, 81}, TilePos{71, 100}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{72, 81}, TilePos{90, 81}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{89, 87}, TilePos{89, 100}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{84, 81}, TilePos{84, 96}, 1.0, TileType::WALL); + m_Map.PaintLine(TilePos{78, 87}, TilePos{78, 100}, 1.0, TileType::WALL); - // add some controllable entities + // add some controllable entities m_Entities.clear(); auto player = std::make_shared(); player->SetPosition(m_Map.TileToWorld(TilePos{25, 20})); @@ -65,19 +64,16 @@ void PathFindingDemo::CreateMap() { player2->SetPosition(m_Map.TileToWorld(TilePos{50, 20})); AddEntity(player2); - for (int i = 0; i < 1; i++) - { - for (int j = 0; j < 10; j++) - { + for (int i = 0; i < 1; i++) { + for (int j = 0; j < 10; j++) { auto p = std::make_shared(); - p->SetPosition(m_Map.TileToWorld(TilePos{10+5*i, 40+5*j})); + p->SetPosition(m_Map.TileToWorld(TilePos{10 + 5 * i, 40 + 5 * j})); AddEntity(p); } } // select everything - TODO this is just temporary for testing - for (const auto& entity : m_Entities) - { + for (const auto &entity : m_Entities) { m_SelectedEntities.push_back(entity); } } @@ -86,23 +82,17 @@ WorldPos PathFindingDemo::GetRandomPosition() const { return WorldPos{0.0f, 0.0f}; // totally random! } - - -const std::vector& PathFindingDemo::GetEntityCollisions() -{ +const std::vector &PathFindingDemo::GetEntityCollisions() { static std::vector m_Collisions; m_Collisions.clear(); - for (const auto &entity_A : m_Entities) - { - for (const auto &entity_B : m_Entities) - { + for (const auto &entity_A : m_Entities) { + for (const auto &entity_B : m_Entities) { if (entity_A == entity_B) continue; if (!entity_A->IsCollidable() || !entity_B->IsCollidable()) continue; - if (entity_A->CollidesWith(*entity_B)) - { + if (entity_A->CollidesWith(*entity_B)) { // handle collision logic m_Collisions.emplace_back(Collision(entity_A, entity_B)); } @@ -111,37 +101,33 @@ const std::vector& PathFindingDemo::GetEntityCollisions() return m_Collisions; } - // Update entity positions, handle collisions void PathFindingDemo::UpdateWorld() { - + float time_delta = 1.0f; - - for (auto& entity : m_Entities) - { + + for (auto &entity : m_Entities) { // calculate the velocity auto current_pos = entity->GetPosition(); double tile_velocity_coeff = m_Map.GetTileVelocityCoeff(current_pos); auto next_pos = entity->GetMoveTarget(); WorldPos velocity = WorldPos{}; - if (next_pos) - { + if (next_pos) { velocity = next_pos.value() - current_pos; velocity.Normalize(); - //LOG_DEBUG("I want to move to: ", next_pos.value(), - // ", velocity: ", velocity); + // LOG_DEBUG("I want to move to: ", next_pos.value(), + // ", velocity: ", velocity); } entity->SetActualVelocity(velocity * tile_velocity_coeff); - - for (const auto& collision : GetEntityCollisions()) - { - // TODO this loop is quite "hot", is it good idea to use weak_ptr and promote it? + + for (const auto &collision : GetEntityCollisions()) { + // TODO this loop is quite "hot", is it good idea to use weak_ptr and + // promote it? auto weak_A = std::get<0>(collision); auto weak_B = std::get<1>(collision); auto A = weak_A.lock(); auto B = weak_B.lock(); - if (A == nullptr || B == nullptr) - { + if (A == nullptr || B == nullptr) { continue; } if (!A->IsMovable()) @@ -152,65 +138,50 @@ void PathFindingDemo::UpdateWorld() { A->ZeroActualVelocityInDirection(AB); // handle logic // TODO - } - + } + // update the position entity->Update(time_delta); } } -void PathFindingDemo::HandleActions(const std::vector &actions) -{ - for (const auto &action : actions) - { - if (action.type == UserAction::Type::EXIT) - { +void PathFindingDemo::HandleActions(const std::vector &actions) { + for (const auto &action : actions) { + if (action.type == UserAction::Type::EXIT) { LOG_INFO("Exit requested"); m_ExitRequested = true; - } - else if (action.type == UserAction::Type::SET_MOVE_TARGET) - { + } else if (action.type == UserAction::Type::SET_MOVE_TARGET) { WorldPos target_pos = m_Camera.WindowToWorld(action.Argument.position); - for (auto& selected_entity : m_SelectedEntities) - { + for (auto &selected_entity : m_SelectedEntities) { LOG_INFO("Calculating path to target: ", target_pos); - if (auto sp = selected_entity.lock()) - { - auto path = m_PathFinder->CalculatePath(sp->GetPosition(), target_pos); + if (auto sp = selected_entity.lock()) { + auto path = + m_PathFinder->CalculatePath(sp->GetPosition(), target_pos); sp->SetPath(path); LOG_INFO("Done, path node count: ", path.size()); } else { - LOG_INFO("Cannot calculate path for destroyed entity (weak_ptr.lock() failed)"); + LOG_INFO("Cannot calculate path for destroyed entity " + "(weak_ptr.lock() failed)"); } } - } - else if (action.type == UserAction::Type::SELECT_PATHFINDER) - { + } else if (action.type == UserAction::Type::SELECT_PATHFINDER) { using namespace pathfinder; PathFinderType type = static_cast(action.Argument.number); - m_PathFinder = pathfinder::utils::create(type, (const Map*)&m_Map); + m_PathFinder = pathfinder::utils::create(type, (const Map *)&m_Map); LOG_INFO("Switched to path finding method: ", m_PathFinder->GetName()); - } - else if (action.type == UserAction::Type::CAMERA_PAN) - { - const auto& window_pan = action.Argument.position; + } else if (action.type == UserAction::Type::CAMERA_PAN) { + const auto &window_pan = action.Argument.position; WorldPos world_pan{window_pan.x(), window_pan.y()}; m_Camera.Pan(world_pan); LOG_INFO("Camera pan delta: ", world_pan); - } - else if (action.type == UserAction::Type::CAMERA_ZOOM) - { + } else if (action.type == UserAction::Type::CAMERA_ZOOM) { m_Camera.Zoom(action.Argument.float_number); LOG_INFO("Camera zoom: ", action.Argument.float_number); - } - else if (action.type == UserAction::Type::SELECTION_START) - { + } else if (action.type == UserAction::Type::SELECTION_START) { m_SelectionBox.active = true; m_SelectionBox.start = action.Argument.position; m_SelectionBox.end = action.Argument.position; - } - else if (action.type == UserAction::Type::SELECTION_END) - { + } else if (action.type == UserAction::Type::SELECTION_END) { m_SelectionBox.end = action.Argument.position; m_SelectionBox.active = false; auto diff = m_SelectionBox.end - m_SelectionBox.start; @@ -219,9 +190,7 @@ void PathFindingDemo::HandleActions(const std::vector &actions) WorldPos start = m_Camera.WindowToWorld(m_SelectionBox.start); WorldPos end = m_Camera.WindowToWorld(m_SelectionBox.end); SelectEntitiesInRectangle(start, end); - } - else if (action.type == UserAction::Type::SELECTION_CHANGE) - { + } else if (action.type == UserAction::Type::SELECTION_CHANGE) { m_SelectionBox.end = action.Argument.position; auto diff = m_SelectionBox.end - m_SelectionBox.start; m_SelectionBox.size = diff.ChangeTag(); @@ -229,30 +198,25 @@ void PathFindingDemo::HandleActions(const std::vector &actions) }; } -void PathFindingDemo::DeselectEntities() -{ - std::for_each(m_SelectedEntities.begin(), m_SelectedEntities.end(), [](auto& x) - { - if (auto entity = x.lock()) - entity->Deselect(); - } - ); +void PathFindingDemo::DeselectEntities() { + std::for_each(m_SelectedEntities.begin(), m_SelectedEntities.end(), + [](auto &x) { + if (auto entity = x.lock()) + entity->Deselect(); + }); m_SelectedEntities.clear(); } -void PathFindingDemo::SelectEntitiesInRectangle(WorldPos A, WorldPos B) -{ +void PathFindingDemo::SelectEntitiesInRectangle(WorldPos A, WorldPos B) { DeselectEntities(); // TODO use colliders for this auto [x_min, x_max] = std::minmax(A.x(), B.x()); auto [y_min, y_max] = std::minmax(A.y(), B.y()); - for (const auto& entity : m_Entities) - { - const auto& pos = entity->GetPosition(); + for (const auto &entity : m_Entities) { + const auto &pos = entity->GetPosition(); bool x_in_range = x_min < pos.x() && pos.x() < x_max; bool y_in_range = y_min < pos.y() && pos.y() < y_max; - if (x_in_range && y_in_range) - { + if (x_in_range && y_in_range) { m_SelectedEntities.push_back(std::weak_ptr(entity)); entity->Select(); } @@ -260,12 +224,9 @@ void PathFindingDemo::SelectEntitiesInRectangle(WorldPos A, WorldPos B) LOG_INFO("Selected ", m_SelectedEntities.size(), " entities"); } -std::pair PathFindingDemo::GetSelectionBoxPosSize() -{ - const auto& pos = m_SelectionBox.start; +std::pair PathFindingDemo::GetSelectionBoxPosSize() { + const auto &pos = m_SelectionBox.start; WindowPos size_pos = m_SelectionBox.end - m_SelectionBox.start; WindowSize size = size_pos.ChangeTag(); return std::pair(pos, size); - } - diff --git a/cpp/src/pathfindingdemo.hpp b/cpp/src/pathfindingdemo.hpp index 2f3eb4c..9a96020 100644 --- a/cpp/src/pathfindingdemo.hpp +++ b/cpp/src/pathfindingdemo.hpp @@ -5,17 +5,16 @@ #include #include +#include "camera.hpp" #include "entities.hpp" #include "log.hpp" #include "map.hpp" -#include "user_input.hpp" #include "pathfinder/base.hpp" -#include "camera.hpp" +#include "user_input.hpp" using Collision = std::pair, std::weak_ptr>; -struct SelectionBox -{ +struct SelectionBox { WindowPos start, end; WindowSize size; bool active; @@ -31,9 +30,9 @@ public: PathFindingDemo &operator=(const PathFindingDemo &) = delete; PathFindingDemo &operator=(PathFindingDemo &&) = delete; - std::vector>& GetEntities() { return m_Entities; } - const Map& GetMap() const { return m_Map; } - const Camera& GetCamera() const { return m_Camera; } + std::vector> &GetEntities() { return m_Entities; } + const Map &GetMap() const { return m_Map; } + const Camera &GetCamera() const { return m_Camera; } bool IsExitRequested() const { return m_ExitRequested; } void AddEntity(std::shared_ptr e); @@ -46,10 +45,12 @@ public: void DeselectEntities(); bool IsSelectionBoxActive() const { return m_SelectionBox.active; } std::pair GetSelectionBoxPosSize(); - std::vector> GetSelectedEntities() { return m_SelectedEntities; } + std::vector> GetSelectedEntities() { + return m_SelectedEntities; + } private: - const std::vector& GetEntityCollisions(); + const std::vector &GetEntityCollisions(); bool m_ExitRequested = false; Map m_Map; diff --git a/cpp/src/tile.cpp b/cpp/src/tile.cpp index e8d5aa0..836c0fc 100644 --- a/cpp/src/tile.cpp +++ b/cpp/src/tile.cpp @@ -6,9 +6,9 @@ // we could use array here, but this is more explicit, // and we don't access tile_types that often, so it should be ok const std::unordered_map tile_types = { - { TileType::GRASS, Tile{1.0, 0, 200, 0, 255}}, - { TileType::WOOD, Tile{1.0, 132, 68, 0, 255}}, - { TileType::ROAD, Tile{0.5, 20, 20, 20, 255}}, - { TileType::WATER, Tile{10.0, 0, 50, 200, 255}}, - { TileType::WALL, Tile{1000.0, 144, 33, 0, 255}}, + {TileType::GRASS, Tile{1.0, 0, 200, 0, 255}}, + {TileType::WOOD, Tile{1.0, 132, 68, 0, 255}}, + {TileType::ROAD, Tile{0.5, 20, 20, 20, 255}}, + {TileType::WATER, Tile{10.0, 0, 50, 200, 255}}, + {TileType::WALL, Tile{1000.0, 144, 33, 0, 255}}, }; diff --git a/cpp/src/tile.hpp b/cpp/src/tile.hpp index c80f931..be97665 100644 --- a/cpp/src/tile.hpp +++ b/cpp/src/tile.hpp @@ -1,9 +1,9 @@ #pragma once +#include #include #include #include -#include #include struct Tile { diff --git a/cpp/src/user_input.cpp b/cpp/src/user_input.cpp index ae9895f..a46139b 100644 --- a/cpp/src/user_input.cpp +++ b/cpp/src/user_input.cpp @@ -2,8 +2,8 @@ #include #include #include -#include #include +#include #include "user_input.hpp" @@ -20,130 +20,103 @@ UserInput::~UserInput() { LOG_DEBUG("."); }; std::expected UserInput::Init() { return {}; } -void UserInput::GetActions_mouse(const SDL_Event& event) -{ +void UserInput::GetActions_mouse(const SDL_Event &event) { static bool mouse_pan = false; SDL_MouseButtonEvent mouse_event = event.button; MouseButton button = static_cast(mouse_event.button); - if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) - { - if (button == MouseButton::LEFT) - { + if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) { + if (button == MouseButton::LEFT) { LOG_DEBUG("Selection start at ", mouse_event.x, ", ", mouse_event.y); m_SelectionActive = true; m_Actions.emplace_back(UserAction::Type::SELECTION_START, WindowPos{mouse_event.x, mouse_event.y}); - } - else if (button == MouseButton::RIGHT) - { + } else if (button == MouseButton::RIGHT) { LOG_DEBUG("Set move target to: ", mouse_event.x, ", ", mouse_event.y); m_Actions.emplace_back(UserAction::Type::SET_MOVE_TARGET, WindowPos{mouse_event.x, mouse_event.y}); - } - else if (button == MouseButton::MIDDLE) - { + } else if (button == MouseButton::MIDDLE) { mouse_pan = true; } - } - else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP) - { - if (button == MouseButton::LEFT) - { + } else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP) { + if (button == MouseButton::LEFT) { LOG_DEBUG("Selection end at ", mouse_event.x, ", ", mouse_event.y); m_SelectionActive = false; m_Actions.emplace_back(UserAction::Type::SELECTION_END, WindowPos{mouse_event.x, mouse_event.y}); } - if (button == MouseButton::MIDDLE) - { + if (button == MouseButton::MIDDLE) { mouse_pan = false; } - } - else if (event.type == SDL_EVENT_MOUSE_MOTION) - { + } else if (event.type == SDL_EVENT_MOUSE_MOTION) { SDL_MouseMotionEvent motion_event = event.motion; - if (mouse_pan) - { + if (mouse_pan) { m_Actions.emplace_back(UserAction::Type::CAMERA_PAN, - WindowPos{motion_event.xrel, motion_event.yrel}); + WindowPos{motion_event.xrel, motion_event.yrel}); } - if (m_SelectionActive) - { + if (m_SelectionActive) { m_Actions.emplace_back(UserAction::Type::SELECTION_CHANGE, WindowPos{mouse_event.x, mouse_event.y}); } - } - else if(event.type == SDL_EVENT_MOUSE_WHEEL) - { + } else if (event.type == SDL_EVENT_MOUSE_WHEEL) { SDL_MouseWheelEvent mouse_wheel = event.wheel; m_Actions.emplace_back(UserAction::Type::CAMERA_ZOOM, mouse_wheel.y); } } -void UserInput::GetActions_keyboard(const SDL_Event& event) -{ - bool key_down = event.type == SDL_EVENT_KEY_DOWN ? true : false; - SDL_KeyboardEvent kbd_event = event.key; - if (kbd_event.repeat) { - // SDL repeats KEY_DOWN if key is held down, we ignore that - return; - } - LOG_DEBUG("Key '", static_cast(kbd_event.key), - key_down ? "' down" : "' up"); +void UserInput::GetActions_keyboard(const SDL_Event &event) { + bool key_down = event.type == SDL_EVENT_KEY_DOWN ? true : false; + SDL_KeyboardEvent kbd_event = event.key; + if (kbd_event.repeat) { + // SDL repeats KEY_DOWN if key is held down, we ignore that + return; + } + LOG_DEBUG("Key '", static_cast(kbd_event.key), + key_down ? "' down" : "' up"); - switch (kbd_event.key) { - case 'q': - m_Actions.emplace_back(UserAction::Type::EXIT); - return; - case '1': - case '2': - case '3': - case '4': - if (key_down) { - int selection = kbd_event.key - '0'; - m_Actions.emplace_back(UserAction::Type::SELECT_PATHFINDER, selection); - LOG_INFO("Pathfinder selected: ", selection); - } - break; - default: - LOG_INFO("Key '", static_cast(kbd_event.key), "' not mapped"); - break; - } + switch (kbd_event.key) { + case 'q': + m_Actions.emplace_back(UserAction::Type::EXIT); + return; + case '1': + case '2': + case '3': + case '4': + if (key_down) { + int selection = kbd_event.key - '0'; + m_Actions.emplace_back(UserAction::Type::SELECT_PATHFINDER, selection); + LOG_INFO("Pathfinder selected: ", selection); + } + break; + default: + LOG_INFO("Key '", static_cast(kbd_event.key), "' not mapped"); + break; + } } -const std::vector& UserInput::GetActions() { +const std::vector &UserInput::GetActions() { static std::unordered_set mouse_events = { - SDL_EVENT_MOUSE_MOTION, - SDL_EVENT_MOUSE_BUTTON_DOWN, - SDL_EVENT_MOUSE_BUTTON_UP, - SDL_EVENT_MOUSE_WHEEL, - SDL_EVENT_MOUSE_ADDED, - SDL_EVENT_MOUSE_REMOVED, + SDL_EVENT_MOUSE_MOTION, SDL_EVENT_MOUSE_BUTTON_DOWN, + SDL_EVENT_MOUSE_BUTTON_UP, SDL_EVENT_MOUSE_WHEEL, + SDL_EVENT_MOUSE_ADDED, SDL_EVENT_MOUSE_REMOVED, }; - + static std::unordered_set keyboard_events = { - SDL_EVENT_KEY_DOWN, - SDL_EVENT_KEY_UP, + SDL_EVENT_KEY_DOWN, + SDL_EVENT_KEY_UP, }; - + SDL_Event event; m_Actions.clear(); - while (SDL_PollEvent(&event)) - { - if (keyboard_events.contains(event.type)) - { + while (SDL_PollEvent(&event)) { + if (keyboard_events.contains(event.type)) { GetActions_keyboard(event); - } - else if (mouse_events.contains(event.type)) - { - GetActions_mouse(event); - } - else - { + } else if (mouse_events.contains(event.type)) { + GetActions_mouse(event); + } else { // TODO uncomment, for now too much noise // LOG_WARNING("Action not processed"); } diff --git a/cpp/src/user_input.hpp b/cpp/src/user_input.hpp index dee9231..630d470 100644 --- a/cpp/src/user_input.hpp +++ b/cpp/src/user_input.hpp @@ -7,14 +7,12 @@ #include "log.hpp" #include "math.hpp" -// Seems like SDL doesn't have named constants for mouse button +// Seems like SDL doesn't have named constants for mouse button enum class MouseButton { LEFT = 1, MIDDLE, RIGHT }; class UserAction { public: - - enum class Type - { + enum class Type { NONE, EXIT, SET_MOVE_TARGET, @@ -44,7 +42,7 @@ public: } Argument; // TODO use std::variant - //std::variant Argument; + // std::variant Argument; }; class UserInput { @@ -65,6 +63,6 @@ private: std::vector m_Actions; bool m_SelectionActive = false; - void GetActions_keyboard(const SDL_Event&); - void GetActions_mouse(const SDL_Event&); + void GetActions_keyboard(const SDL_Event &); + void GetActions_mouse(const SDL_Event &); }; diff --git a/cpp/src/window.cpp b/cpp/src/window.cpp index f92bfcc..49ad415 100644 --- a/cpp/src/window.cpp +++ b/cpp/src/window.cpp @@ -79,19 +79,20 @@ Window::~Window() { void Window::DrawSprite(const WindowPos &position, Sprite &s, float scale) { WorldSize size = s.GetSize() * scale; WorldPos img_center = s.GetCenter() * scale; - SDL_FRect rect = {position.x() - img_center.x(), position.y() - img_center.y(), - size.x(), size.y()}; + SDL_FRect rect = {position.x() - img_center.x(), + position.y() - img_center.y(), size.x(), size.y()}; SDL_RenderTexture(m_Renderer.get(), s.GetTexture(), nullptr, &rect); } -void Window::DrawFilledRect(const WindowPos &position, const WindowSize size, uint8_t R, - uint8_t G, uint8_t B, uint8_t A) { +void Window::DrawFilledRect(const WindowPos &position, const WindowSize size, + uint8_t R, uint8_t G, uint8_t B, uint8_t A) { SDL_FRect rect = {position.x(), position.y(), size.x(), size.y()}; SDL_SetRenderDrawColor(m_Renderer.get(), R, G, B, A); SDL_RenderFillRect(m_Renderer.get(), &rect); } -void Window::DrawRect(const WindowPos &position, const WindowSize size, uint8_t R, uint8_t G, uint8_t B) { +void Window::DrawRect(const WindowPos &position, const WindowSize size, + uint8_t R, uint8_t G, uint8_t B) { SDL_FRect rect = {position.x(), position.y(), size.x(), size.y()}; SDL_SetRenderDrawColor(m_Renderer.get(), R, G, B, 255); SDL_RenderRect(m_Renderer.get(), &rect); @@ -105,7 +106,8 @@ void Window::ClearWindow() { void Window::Flush() { SDL_RenderPresent(m_Renderer.get()); } // TODO use some struct for color -void Window::DrawCircle(const WindowPos &position, float radius, uint8_t R, uint8_t G, uint8_t B) { +void Window::DrawCircle(const WindowPos &position, float radius, uint8_t R, + uint8_t G, uint8_t B) { int cx = static_cast(position.x()); int cy = static_cast(position.y()); SDL_SetRenderDrawColor(m_Renderer.get(), R, G, B, 255); @@ -117,9 +119,7 @@ void Window::DrawCircle(const WindowPos &position, float radius, uint8_t R, uint } } -void Window::DrawLine(const WindowPos &A, const WindowPos &B) -{ +void Window::DrawLine(const WindowPos &A, const WindowPos &B) { SDL_SetRenderDrawColor(m_Renderer.get(), 255, 0, 0, 255); SDL_RenderLine(m_Renderer.get(), A.x(), A.y(), B.x(), B.y()); } - diff --git a/cpp/src/window.hpp b/cpp/src/window.hpp index 0729bd4..dec8d15 100644 --- a/cpp/src/window.hpp +++ b/cpp/src/window.hpp @@ -23,12 +23,14 @@ public: std::expected Init(); void DrawSprite(const WindowPos &position, Sprite &s, float scale = 1.0f); - void DrawFilledRect(const WindowPos &position, const WindowSize size, uint8_t R, - uint8_t G, uint8_t B, uint8_t A); - void DrawRect(const WindowPos &position, const WindowSize size, uint8_t R, uint8_t G, uint8_t B); + void DrawFilledRect(const WindowPos &position, const WindowSize size, + uint8_t R, uint8_t G, uint8_t B, uint8_t A); + void DrawRect(const WindowPos &position, const WindowSize size, uint8_t R, + uint8_t G, uint8_t B); void ClearWindow(); void Flush(); - void DrawCircle(const WindowPos &position, float radius, uint8_t R, uint8_t G, uint8_t B); + void DrawCircle(const WindowPos &position, float radius, uint8_t R, uint8_t G, + uint8_t B); void DrawLine(const WindowPos &A, const WindowPos &B); private: @@ -37,5 +39,4 @@ private: std::shared_ptr m_Renderer = nullptr; SDL_Window *m_Window; SDL_GLContext m_Context; - };