fix: handle everything regarding minos in i8, since that is way easier

Totto16 · Totto16 · commit cc15613426d6 · 2024-11-06T00:51:53.000+01:00
diff --git a/src/game/graphic_helpers.cpp b/src/game/graphic_helpers.cpp
@@ -35,7 +35,7 @@ void helper::graphics::render_mino(
         const double original_scale,
         const Mino::ScreenCordsFunction& to_screen_coords,
         const shapes::UPoint& tile_size,
-        const grid::GridUPoint& offset
+        const grid::GridPoint& offset
 ) {
     const auto alpha = get_transparency_value(transparency);
     const auto alpha_factor = static_cast<double>(alpha) / 255.0;
diff --git a/src/game/graphic_helpers.hpp b/src/game/graphic_helpers.hpp
@@ -28,7 +28,7 @@ namespace helper::graphics {
             double original_scale,
             const Mino::ScreenCordsFunction& to_screen_coords,
             const shapes::UPoint& tile_size,
-            const grid::GridUPoint& offset = grid::GridUPoint::zero()
+            const grid::GridPoint& offset = grid::GridPoint::zero()
     );
 
 
diff --git a/src/game/grid.cpp b/src/game/grid.cpp
@@ -31,7 +31,7 @@ Grid::Grid(const ui::Layout& layout, bool is_top_level)
     return static_cast<double>(m_tile_size) / static_cast<double>(grid::original_tile_size);
 }
 
-[[nodiscard]] shapes::UPoint Grid::to_screen_coords(grid::GridUPoint grid_coords) const {
+[[nodiscard]] shapes::UPoint Grid::to_screen_coords(grid::GridPoint grid_coords) const {
     return m_fill_rect.top_left + (grid_coords.cast<u32>() * m_tile_size);
 }
 
@@ -51,7 +51,7 @@ void Grid::draw_preview_background(const ServiceProvider& service_provider) cons
             service_provider,
             GridRect{
                     grid::preview_background_position,
-                    grid::preview_background_position + grid::preview_extends - grid::GridUPoint{ 1, 1 },
+                    grid::preview_background_position + grid::preview_extends - grid::GridPoint{ 1, 1 },
     }
     );
 }
@@ -61,7 +61,7 @@ void Grid::draw_hold_background(const ServiceProvider& service_provider) const {
             service_provider,
             GridRect{
                     grid::hold_background_position,
-                    grid::hold_background_position + grid::hold_background_extends - grid::GridUPoint{ 1, 1 },
+                    grid::hold_background_position + grid::hold_background_extends - grid::GridPoint{ 1, 1 },
     }
     );
 }
@@ -71,7 +71,7 @@ void Grid::draw_playing_field_background(const ServiceProvider& service_provider
             service_provider,
             GridRect{
                     grid::grid_position,
-                    grid::grid_position + shapes::UPoint{ grid::width_in_tiles - 1, grid::height_in_tiles - 1 },
+                    grid::grid_position + shapes::IPoint{ grid::width_in_tiles - 1, grid::height_in_tiles - 1 },
     }
     );
 }
@@ -80,18 +80,19 @@ void Grid::draw_background(const ServiceProvider& service_provider, GridRect gri
     const auto top_left = m_fill_rect.top_left + (grid_rect.top_left.cast<u32>() * m_tile_size);
 
 
-    const auto bottom_right = top_left + (grid::GridUPoint(grid_rect.width(), grid_rect.height()).cast<u32>() * m_tile_size);
+    const auto bottom_right =
+            top_left + (grid::GridPoint(grid_rect.width(), grid_rect.height()).cast<u32>() * m_tile_size);
 
     service_provider.renderer().draw_rect_filled(shapes::URect{ top_left, bottom_right }, background_color);
 
-    for (u32 column = 0; column <= grid_rect.width(); ++column) {
+    for (i32 column = 0; column <= grid_rect.width(); ++column) {
         const auto start = top_left + shapes::UPoint{ column * m_tile_size, 0 };
         const auto end = shapes::UPoint{ start.x, start.y + (grid_rect.height() * m_tile_size) };
         service_provider.renderer().draw_line(start, end, grid_color);
         service_provider.renderer().draw_line(start - shapes::UPoint{ 1, 0 }, end - shapes::UPoint{ 1, 0 }, grid_color);
     }
 
-    for (u32 row = 0; row <= grid_rect.height(); ++row) {
+    for (i32 row = 0; row <= grid_rect.height(); ++row) {
         const auto start = top_left + shapes::UPoint{ 0, row * m_tile_size };
         const auto end = shapes::UPoint{ bottom_right.x, start.y };
         service_provider.renderer().draw_line(start, end, grid_color);
diff --git a/src/game/grid.hpp b/src/game/grid.hpp
@@ -16,7 +16,7 @@ struct Grid final : public ui::Widget {
     static constexpr Color grid_color{ 31, 31, 31 };
 
 private:
-    using GridRect = shapes::AbstractRect<grid::GridUType>;
+    using GridRect = shapes::AbstractRect<grid::GridType>;
 
     shapes::URect m_fill_rect;
     u32 m_tile_size;
@@ -28,7 +28,7 @@ struct Grid final : public ui::Widget {
 
     OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] double scale_to_original() const;
 
-    OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] shapes::UPoint to_screen_coords(grid::GridUPoint grid_coords) const;
+    OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] shapes::UPoint to_screen_coords(grid::GridPoint grid_coords) const;
 
     OOPETRIS_GRAPHICS_EXPORTED void render(const ServiceProvider& service_provider) const override;
 
diff --git a/src/game/simulated_tetrion.cpp b/src/game/simulated_tetrion.cpp
@@ -132,7 +132,7 @@ void SimulatedTetrion::spawn_next_tetromino(
         const helper::TetrominoType type,
         const SimulationStep simulation_step_index
 ) {
-    constexpr grid::GridUPoint spawn_position{ 3, 0 };
+    constexpr grid::GridPoint spawn_position{ 3, 0 };
     m_active_tetromino = Tetromino{ spawn_position, type };
     refresh_previews();
     if (not is_active_tetromino_position_valid()) {
@@ -141,12 +141,12 @@ void SimulatedTetrion::spawn_next_tetromino(
         auto current_pieces = m_active_tetromino.value().minos();
 
         bool all_valid{ false };
-        u8 move_up = 0;
+        i8 move_up = 0;
         while (not all_valid) {
             all_valid = true;
             for (auto& mino : current_pieces) {
                 if (mino.position().y != 0) {
-                    mino.position() = mino.position() - grid::GridUPoint{ 0, 1 };
+                    mino.position() = mino.position() - grid::GridPoint{ 0, 1 };
                     if (not is_valid_mino_position(mino.position())) {
                         all_valid = false;
                     }
@@ -159,7 +159,7 @@ void SimulatedTetrion::spawn_next_tetromino(
         for (const Mino& mino : m_active_tetromino->minos()) {
             auto position = mino.position();
             if (mino.position().y >= move_up && move_up != 0) {
-                position -= grid::GridUPoint{ 0, move_up };
+                position -= grid::GridPoint{ 0, move_up };
                 m_mino_stack.set(position, mino.type());
             }
         }
@@ -289,10 +289,10 @@ void SimulatedTetrion::clear_fully_occupied_lines() {
     const u32 lines_cleared_before = m_lines_cleared;
     do { // NOLINT(cppcoreguidelines-avoid-do-while)
         cleared = false;
-        for (u8 row = 0; row < grid::height_in_tiles; ++row) {
+        for (i8 row = 0; row < grid::height_in_tiles; ++row) {
             bool fully_occupied = true;
-            for (u8 column = 0; column < grid::width_in_tiles; ++column) {
-                if (m_mino_stack.is_empty(grid::GridUPoint{ column, row })) {
+            for (i8 column = 0; column < grid::width_in_tiles; ++column) {
+                if (m_mino_stack.is_empty(grid::GridPoint{ column, row })) {
                     fully_occupied = false;
                     break;
                 }
@@ -355,16 +355,18 @@ bool SimulatedTetrion::is_active_tetromino_position_valid() const {
     return is_tetromino_position_valid(m_active_tetromino.value());
 }
 
-bool SimulatedTetrion::is_valid_mino_position(grid::GridUPoint position) const {
-    return position.x < grid::width_in_tiles and position.y < grid::height_in_tiles and m_mino_stack.is_empty(position);
+bool SimulatedTetrion::is_valid_mino_position(grid::GridPoint position) const {
+
+    return position.x >= 0 and position.x < grid::width_in_tiles and position.y >= 0
+           and position.y < grid::height_in_tiles and m_mino_stack.is_empty(position);
 }
 
-bool SimulatedTetrion::mino_can_move_down(grid::GridUPoint position) const {
+bool SimulatedTetrion::mino_can_move_down(grid::GridPoint position) const {
     if (position.y == (grid::height_in_tiles - 1)) {
         return false;
     }
 
-    return is_valid_mino_position(position + grid::GridUPoint{ 0, 1 });
+    return is_valid_mino_position(position + grid::GridPoint{ 0, 1 });
 }
 
 
@@ -384,7 +386,7 @@ void SimulatedTetrion::refresh_previews() {
     auto bag_index = usize{ 0 };
     for (std::remove_cvref_t<decltype(num_preview_tetrominos)> i = 0; i < num_preview_tetrominos; ++i) {
         m_preview_tetrominos.at(static_cast<usize>(i)) = Tetromino{
-            grid::preview_tetromino_position + shapes::UPoint{ 0, static_cast<u32>(grid::preview_padding * i) },
+            grid::preview_tetromino_position + shapes::IPoint{ 0, grid::preview_padding * i },
             m_sequence_bags.at(bag_index)[sequence_index]
         };
         ++sequence_index;
diff --git a/src/game/simulated_tetrion.hpp b/src/game/simulated_tetrion.hpp
@@ -150,8 +150,8 @@ struct SimulatedTetrion {
     void clear_fully_occupied_lines();
     void lock_active_tetromino(SimulationStep simulation_step_index);
     [[nodiscard]] bool is_active_tetromino_position_valid() const;
-    [[nodiscard]] bool mino_can_move_down(grid::GridUPoint position) const;
-    [[nodiscard]] bool is_valid_mino_position(grid::GridUPoint position) const;
+    [[nodiscard]] bool mino_can_move_down(grid::GridPoint position) const;
+    [[nodiscard]] bool is_valid_mino_position(grid::GridPoint position) const;
 
     void refresh_ghost_tetromino();
     void refresh_previews();
diff --git a/src/game/tetrion.cpp b/src/game/tetrion.cpp
@@ -72,7 +72,7 @@ void Tetrion::render(const ServiceProvider& service_provider) const {
 
     const auto* grid = get_grid();
     const double original_scale = grid->scale_to_original();
-    const ScreenCordsFunction to_screen_coords = [grid](const grid::GridUPoint& point) {
+    const ScreenCordsFunction to_screen_coords = [grid](const grid::GridPoint& point) {
         return grid->to_screen_coords(point);
     };
     const shapes::UPoint& tile_size = grid->tile_size();
diff --git a/src/game/tetromino.cpp b/src/game/tetromino.cpp
@@ -16,7 +16,7 @@ void Tetromino::render(
         const double original_scale,
         const ScreenCordsFunction& to_screen_coords,
         const shapes::UPoint& tile_size,
-        const grid::GridUPoint& offset
+        const grid::GridPoint& offset
 ) const {
     for (const auto& mino : m_minos) {
         helper::graphics::render_mino(
@@ -69,9 +69,9 @@ Tetromino::Pattern Tetromino::get_pattern(helper::TetrominoType type, Rotation r
 
 std::array<Mino, 4> Tetromino::create_minos(grid::GridPoint position, Rotation rotation, helper::TetrominoType type) {
     return std::array<Mino, 4>{
-        Mino{ (position + get_pattern(type, rotation).at(0)).cast<u8>(), type },
-        Mino{ (position + get_pattern(type, rotation).at(1)).cast<u8>(), type },
-        Mino{ (position + get_pattern(type, rotation).at(2)).cast<u8>(), type },
-        Mino{ (position + get_pattern(type, rotation).at(3)).cast<u8>(), type },
+        Mino{ position + get_pattern(type, rotation).at(0), type },
+        Mino{ position + get_pattern(type, rotation).at(1), type },
+        Mino{ position + get_pattern(type, rotation).at(2), type },
+        Mino{ position + get_pattern(type, rotation).at(3), type },
     };
 }
diff --git a/src/game/tetromino.hpp b/src/game/tetromino.hpp
@@ -27,11 +27,6 @@ struct Tetromino final {
           m_type{ type },
           m_minos{ create_minos(position, m_rotation, type) } { }
 
-    OOPETRIS_GRAPHICS_EXPORTED Tetromino(grid::GridUPoint position, helper::TetrominoType type)
-        : m_position{ position.cast<i8>() },
-          m_type{ type },
-          m_minos{ create_minos(m_position, m_rotation, type) } { }
-
     OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] helper::TetrominoType type() const;
     OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] Rotation rotation() const;
 
@@ -41,7 +36,7 @@ struct Tetromino final {
             double original_scale,
             const ScreenCordsFunction& to_screen_coords,
             const shapes::UPoint& tile_size,
-            const grid::GridUPoint& offset = grid::GridUPoint::zero()
+            const grid::GridPoint& offset = grid::GridPoint::zero()
     ) const;
 
     OOPETRIS_GRAPHICS_EXPORTED void rotate_right();
diff --git a/src/libs/core/game/grid_properties.hpp b/src/libs/core/game/grid_properties.hpp
@@ -4,27 +4,26 @@
 
 #include "../helper/point.hpp"
 
+
 namespace grid {
 
     using GridType = i8;
     using GridPoint = shapes::AbstractPoint<GridType>;
 
-    using GridUType = u8;
-    using GridUPoint = shapes::AbstractPoint<GridUType>;
 
-    constexpr GridUType original_tile_size = 26;
+    constexpr GridType original_tile_size = 26;
 
-    constexpr GridUType width_in_tiles = 10;
-    constexpr GridUType height_in_tiles = 20;
+    constexpr GridType width_in_tiles = 10;
+    constexpr GridType height_in_tiles = 20;
 
-    constexpr GridUPoint preview_extends{ 4, (6 * 3) + 1 };
-    constexpr GridUPoint hold_background_position{ 0, 0 };
-    constexpr GridUPoint grid_position = hold_background_position + GridUPoint{ preview_extends.x + 1, 0 };
-    constexpr GridUPoint preview_background_position{ grid_position.x + width_in_tiles + 1, 0 };
-    constexpr GridUPoint preview_tetromino_position = preview_background_position + GridUPoint{ 0, 1 };
-    constexpr GridUPoint hold_tetromino_position = hold_background_position + GridUPoint{ 0, 1 };
-    constexpr GridUPoint hold_background_extends = GridUPoint{ 4, 4 };
-    constexpr GridUType preview_padding = 3;
+    constexpr GridPoint preview_extends{ 4, (6 * 3) + 1 };
+    constexpr GridPoint hold_background_position{ 0, 0 };
+    constexpr GridPoint grid_position = hold_background_position + GridPoint{ preview_extends.x + 1, 0 };
+    constexpr GridPoint preview_background_position{ grid_position.x + width_in_tiles + 1, 0 };
+    constexpr GridPoint preview_tetromino_position = preview_background_position + GridPoint{ 0, 1 };
+    constexpr GridPoint hold_tetromino_position = hold_background_position + GridPoint{ 0, 1 };
+    constexpr GridPoint hold_background_extends = GridPoint{ 4, 4 };
+    constexpr GridType preview_padding = 3;
 
 
 } // namespace grid
diff --git a/src/libs/core/game/mino.cpp b/src/libs/core/game/mino.cpp
@@ -4,11 +4,11 @@
     return m_type;
 }
 
-[[nodiscard]] const grid::GridUPoint& Mino::position() const {
+[[nodiscard]] const grid::GridPoint& Mino::position() const {
     return m_position;
 }
 
-[[nodiscard]] grid::GridUPoint& Mino::position() {
+[[nodiscard]] grid::GridPoint& Mino::position() {
     return m_position;
 }
 
diff --git a/src/libs/core/game/mino.hpp b/src/libs/core/game/mino.hpp
@@ -9,22 +9,22 @@
 #include <functional>
 struct Mino final {
 public:
-    using ScreenCordsFunction = std::function<shapes::UPoint(const grid::GridUPoint&)>;
+    using ScreenCordsFunction = std::function<shapes::UPoint(const grid::GridPoint&)>;
 
 private:
-    grid::GridUPoint m_position;
+    grid::GridPoint m_position;
     helper::TetrominoType m_type;
 
 public:
-    OOPETRIS_CORE_EXPORTED explicit constexpr Mino(grid::GridUPoint position, helper::TetrominoType type)
+    OOPETRIS_CORE_EXPORTED explicit constexpr Mino(grid::GridPoint position, helper::TetrominoType type)
         : m_position{ position },
           m_type{ type } { }
 
     OOPETRIS_CORE_EXPORTED [[nodiscard]] helper::TetrominoType type() const;
 
-    OOPETRIS_CORE_EXPORTED [[nodiscard]] const grid::GridUPoint& position() const;
+    OOPETRIS_CORE_EXPORTED [[nodiscard]] const grid::GridPoint& position() const;
 
-    OOPETRIS_CORE_EXPORTED [[nodiscard]] grid::GridUPoint& position();
+    OOPETRIS_CORE_EXPORTED [[nodiscard]] grid::GridPoint& position();
 
     OOPETRIS_CORE_EXPORTED [[nodiscard]] bool operator==(const Mino& other) const;
 
diff --git a/src/libs/core/game/mino_stack.cpp b/src/libs/core/game/mino_stack.cpp
@@ -16,13 +16,13 @@ void MinoStack::clear_row_and_let_sink(u8 row) {
     }
 }
 
-[[nodiscard]] bool MinoStack::is_empty(grid::GridUPoint coordinates) const {
+[[nodiscard]] bool MinoStack::is_empty(grid::GridPoint coordinates) const {
     return not std::ranges::any_of(m_minos, [&coordinates](const Mino& mino) {
         return mino.position() == coordinates;
     });
 }
 
-void MinoStack::set(grid::GridUPoint coordinates, helper::TetrominoType type) {
+void MinoStack::set(grid::GridPoint coordinates, helper::TetrominoType type) {
     const Mino to_insert = Mino{ coordinates, type };
     for (Mino& current : m_minos) {
         if (current.position() == coordinates) {
@@ -67,10 +67,10 @@ void MinoStack::set(grid::GridUPoint coordinates, helper::TetrominoType type) {
 
 std::ostream& operator<<(std::ostream& ostream, const MinoStack& mino_stack) {
     ostream << "MinoStack(\n";
-    for (u8 y = 0; y < grid::height_in_tiles; ++y) {
-        for (u8 x = 0; x < grid::width_in_tiles; ++x) {
+    for (i8 y = 0; y < grid::height_in_tiles; ++y) {
+        for (i8 x = 0; x < grid::width_in_tiles; ++x) {
             const auto find_iterator = std::ranges::find_if(mino_stack.minos(), [&](const auto& mino) {
-                return mino.position() == shapes::AbstractPoint<u8>{ x, y };
+                return mino.position() == shapes::AbstractPoint<i8>{ x, y };
             });
             const auto found = (find_iterator != mino_stack.minos().cend());
             if (found) {
diff --git a/src/libs/core/game/mino_stack.hpp b/src/libs/core/game/mino_stack.hpp
@@ -15,9 +15,9 @@ struct MinoStack final {
 public:
     OOPETRIS_CORE_EXPORTED void clear_row_and_let_sink(u8 row);
 
-    OOPETRIS_CORE_EXPORTED [[nodiscard]] bool is_empty(grid::GridUPoint coordinates) const;
+    OOPETRIS_CORE_EXPORTED [[nodiscard]] bool is_empty(grid::GridPoint coordinates) const;
 
-    OOPETRIS_CORE_EXPORTED void set(grid::GridUPoint coordinates, helper::TetrominoType type);
+    OOPETRIS_CORE_EXPORTED void set(grid::GridPoint coordinates, helper::TetrominoType type);
 
     OOPETRIS_CORE_EXPORTED [[nodiscard]] u32 num_minos() const;
 
diff --git a/src/libs/recordings/utility/tetrion_snapshot.cpp b/src/libs/recordings/utility/tetrion_snapshot.cpp
@@ -82,7 +82,7 @@ helper::expected<TetrionSnapshot, std::string> TetrionSnapshot::from_istream(std
             };
         }
 
-        mino_stack.set(grid::GridUPoint(x_coord.value(), y_coord.value()), maybe_type.value());
+        mino_stack.set(grid::GridPoint(x_coord.value(), y_coord.value()), maybe_type.value());
     }
 
 
diff --git a/src/scenes/loading_screen/loading_screen.cpp b/src/scenes/loading_screen/loading_screen.cpp
diff --git a/src/scenes/loading_screen/loading_screen.hpp b/src/scenes/loading_screen/loading_screen.hpp
diff --git a/src/scenes/logo/logo.cpp b/src/scenes/logo/logo.cpp

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ Grid::Grid(const ui::Layout& layout, bool is_top_level)`
`31`	`31`	`return static_cast<double>(m_tile_size) / static_cast<double>(grid::original_tile_size);`
`32`	`32`	`}`
`33`	`33`
`34`		`-[[nodiscard]] shapes::UPoint Grid::to_screen_coords(grid::GridUPoint grid_coords) const {`
	`34`	`+[[nodiscard]] shapes::UPoint Grid::to_screen_coords(grid::GridPoint grid_coords) const {`
`35`	`35`	`return m_fill_rect.top_left + (grid_coords.cast<u32>() * m_tile_size);`
`36`	`36`	`}`
`37`	`37`
`@@ -51,7 +51,7 @@ void Grid::draw_preview_background(const ServiceProvider& service_provider) cons`
`51`	`51`	`service_provider,`
`52`	`52`	`GridRect{`
`53`	`53`	`grid::preview_background_position,`
`54`		`- grid::preview_background_position + grid::preview_extends - grid::GridUPoint{ 1, 1 },`
	`54`	`+ grid::preview_background_position + grid::preview_extends - grid::GridPoint{ 1, 1 },`
`55`	`55`	`}`
`56`	`56`	`);`
`57`	`57`	`}`
`@@ -61,7 +61,7 @@ void Grid::draw_hold_background(const ServiceProvider& service_provider) const {`
`61`	`61`	`service_provider,`
`62`	`62`	`GridRect{`
`63`	`63`	`grid::hold_background_position,`
`64`		`- grid::hold_background_position + grid::hold_background_extends - grid::GridUPoint{ 1, 1 },`
	`64`	`+ grid::hold_background_position + grid::hold_background_extends - grid::GridPoint{ 1, 1 },`
`65`	`65`	`}`
`66`	`66`	`);`
`67`	`67`	`}`
`@@ -71,7 +71,7 @@ void Grid::draw_playing_field_background(const ServiceProvider& service_provider`
`71`	`71`	`service_provider,`
`72`	`72`	`GridRect{`
`73`	`73`	`grid::grid_position,`
`74`		`- grid::grid_position + shapes::UPoint{ grid::width_in_tiles - 1, grid::height_in_tiles - 1 },`
	`74`	`+ grid::grid_position + shapes::IPoint{ grid::width_in_tiles - 1, grid::height_in_tiles - 1 },`
`75`	`75`	`}`
`76`	`76`	`);`
`77`	`77`	`}`
`@@ -80,18 +80,19 @@ void Grid::draw_background(const ServiceProvider& service_provider, GridRect gri`
`80`	`80`	`const auto top_left = m_fill_rect.top_left + (grid_rect.top_left.cast<u32>() * m_tile_size);`
`81`	`81`
`82`	`82`
`83`		`- const auto bottom_right = top_left + (grid::GridUPoint(grid_rect.width(), grid_rect.height()).cast<u32>() * m_tile_size);`
	`83`	`+ const auto bottom_right =`
	`84`	`+ top_left + (grid::GridPoint(grid_rect.width(), grid_rect.height()).cast<u32>() * m_tile_size);`
`84`	`85`
`85`	`86`	`service_provider.renderer().draw_rect_filled(shapes::URect{ top_left, bottom_right }, background_color);`
`86`	`87`
`87`		`- for (u32 column = 0; column <= grid_rect.width(); ++column) {`
	`88`	`+ for (i32 column = 0; column <= grid_rect.width(); ++column) {`
`88`	`89`	`const auto start = top_left + shapes::UPoint{ column * m_tile_size, 0 };`
`89`	`90`	`const auto end = shapes::UPoint{ start.x, start.y + (grid_rect.height() * m_tile_size) };`
`90`	`91`	`service_provider.renderer().draw_line(start, end, grid_color);`
`91`	`92`	`service_provider.renderer().draw_line(start - shapes::UPoint{ 1, 0 }, end - shapes::UPoint{ 1, 0 }, grid_color);`
`92`	`93`	`}`
`93`	`94`
`94`		`- for (u32 row = 0; row <= grid_rect.height(); ++row) {`
	`95`	`+ for (i32 row = 0; row <= grid_rect.height(); ++row) {`
`95`	`96`	`const auto start = top_left + shapes::UPoint{ 0, row * m_tile_size };`
`96`	`97`	`const auto end = shapes::UPoint{ bottom_right.x, start.y };`
`97`	`98`	`service_provider.renderer().draw_line(start, end, grid_color);`