fix: fix mess with i8 and u8 grid coordinates

Totto16 · Totto16 · commit 05d4b3a3a95f · 2024-11-06T00:51:48.000+01:00
the minos and the grids coordinates are unsigned, but single tetrions can have a negative position
diff --git a/settings.json b/settings.json
@@ -76,7 +76,7 @@
 			}
 		]
 	},
-	"volume": 0.0,
+	"volume": 0.2,
 	"discord": false,
 	"api_url": "https://oopetris.totto.lt/api/"
 }
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 Mino::GridPoint& offset
+        const grid::GridUPoint& 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 Mino::GridPoint& offset = Mino::GridPoint::zero()
+            const grid::GridUPoint& offset = grid::GridUPoint::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(GridPoint grid_coords) const {
+[[nodiscard]] shapes::UPoint Grid::to_screen_coords(grid::GridUPoint 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 - GridPoint{ 1, 1 },
+                    grid::preview_background_position + grid::preview_extends - grid::GridUPoint{ 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 - GridPoint{ 1, 1 },
+                    grid::hold_background_position + grid::hold_background_extends - grid::GridUPoint{ 1, 1 },
     }
     );
 }
@@ -80,7 +80,7 @@ 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 + (GridPoint(grid_rect.width(), grid_rect.height()).cast<u32>() * m_tile_size);
+    const auto bottom_right = top_left + (grid::GridUPoint(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);
 
diff --git a/src/game/grid.hpp b/src/game/grid.hpp
@@ -11,15 +11,13 @@
 
 struct Grid final : public ui::Widget {
 public:
-    using GridType = grid::GridType;
-    using GridPoint = grid::GridPoint;
-    using GridRect = shapes::AbstractRect<GridType>;
-
     static constexpr Color background_color{ 12, 12, 12 };
     static constexpr Color border_color{ 42, 42, 42 };
     static constexpr Color grid_color{ 31, 31, 31 };
 
 private:
+    using GridRect = shapes::AbstractRect<grid::GridUType>;
+
     shapes::URect m_fill_rect;
     u32 m_tile_size;
 
@@ -30,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(GridPoint grid_coords) const;
+    OOPETRIS_GRAPHICS_EXPORTED [[nodiscard]] shapes::UPoint to_screen_coords(grid::GridUPoint 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 GridPoint spawn_position{ 3, 0 };
+    constexpr grid::GridUPoint spawn_position{ 3, 0 };
     m_active_tetromino = Tetromino{ spawn_position, type };
     refresh_previews();
     if (not is_active_tetromino_position_valid()) {
@@ -146,7 +146,7 @@ void SimulatedTetrion::spawn_next_tetromino(
             all_valid = true;
             for (auto& mino : current_pieces) {
                 if (mino.position().y != 0) {
-                    mino.position() = mino.position() - GridPoint{ 0, 1 };
+                    mino.position() = mino.position() - grid::GridUPoint{ 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 -= GridPoint{ 0, move_up };
+                position -= grid::GridUPoint{ 0, move_up };
                 m_mino_stack.set(position, mino.type());
             }
         }
@@ -292,7 +292,7 @@ void SimulatedTetrion::clear_fully_occupied_lines() {
         for (u8 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(GridPoint{ column, row })) {
+                if (m_mino_stack.is_empty(grid::GridUPoint{ column, row })) {
                     fully_occupied = false;
                     break;
                 }
@@ -355,16 +355,16 @@ bool SimulatedTetrion::is_active_tetromino_position_valid() const {
     return is_tetromino_position_valid(m_active_tetromino.value());
 }
 
-bool SimulatedTetrion::is_valid_mino_position(GridPoint position) const {
+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::mino_can_move_down(GridPoint position) const {
+bool SimulatedTetrion::mino_can_move_down(grid::GridUPoint position) const {
     if (position.y == (grid::height_in_tiles - 1)) {
         return false;
     }
 
-    return is_valid_mino_position(position + GridPoint{ 0, 1 });
+    return is_valid_mino_position(position + grid::GridUPoint{ 0, 1 });
 }
 
 
diff --git a/src/game/simulated_tetrion.hpp b/src/game/simulated_tetrion.hpp
@@ -32,7 +32,6 @@ struct SimulatedTetrion {
 private:
     using WallKickPoint = shapes::AbstractPoint<i8>;
     using WallKickTable = std::array<std::array<WallKickPoint, 5>, 8>;
-    using GridPoint = Mino::GridPoint;
 
     static constexpr SimulationStep lock_delay = 30;
     static constexpr int num_lock_delays = 30;
@@ -151,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(GridPoint position) const;
-    [[nodiscard]] bool is_valid_mino_position(GridPoint position) const;
+    [[nodiscard]] bool mino_can_move_down(grid::GridUPoint position) const;
+    [[nodiscard]] bool is_valid_mino_position(grid::GridUPoint 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 GridPoint& point) {
+    const ScreenCordsFunction to_screen_coords = [grid](const grid::GridUPoint& point) {
         return grid->to_screen_coords(point);
     };
     const shapes::UPoint& tile_size = grid->tile_size();
diff --git a/src/game/tetrion.hpp b/src/game/tetrion.hpp
@@ -21,11 +21,9 @@ namespace recorder {
 struct Tetrion final : public ui::Widget, SimulatedTetrion {
 private:
     using ScreenCordsFunction = Mino::ScreenCordsFunction;
-    using GridPoint = Mino::GridPoint;
 
     ui::TileLayout m_main_layout;
 
-
 public:
     OOPETRIS_GRAPHICS_EXPORTED Tetrion(
             u8 tetrion_index,
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 GridPoint& offset
+        const grid::GridUPoint& offset
 ) const {
     for (const auto& mino : m_minos) {
         helper::graphics::render_mino(
@@ -49,7 +49,7 @@ void Tetromino::move_right() {
 
 void Tetromino::move(const shapes::AbstractPoint<i8> offset) {
     // this looks weird but silently asserts, that the final point is not negative
-    m_position = (m_position.cast<i8>() + offset).cast<u8>();
+    m_position = m_position.cast<i8>() + offset;
     refresh_minos();
 }
 
@@ -67,11 +67,11 @@ Tetromino::Pattern Tetromino::get_pattern(helper::TetrominoType type, Rotation r
 }
 
 
-std::array<Mino, 4> Tetromino::create_minos(GridPoint position, Rotation rotation, helper::TetrominoType type) {
+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), 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 },
+        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 },
     };
 }
diff --git a/src/game/tetromino.hpp b/src/game/tetromino.hpp
@@ -11,23 +11,27 @@
 
 struct Tetromino final {
 private:
-    using GridPoint = Mino::GridPoint;
     using ScreenCordsFunction = Mino::ScreenCordsFunction;
 
-    GridPoint m_position;
+    grid::GridPoint m_position;
     Rotation m_rotation{ Rotation::North };
     helper::TetrominoType m_type;
     std::array<Mino, 4> m_minos;
 
 public:
-    using TetrominoPoint = shapes::AbstractPoint<u8>;
+    using TetrominoPoint = shapes::AbstractPoint<i8>;
     using Pattern = std::array<TetrominoPoint, 4>;
 
-    OOPETRIS_GRAPHICS_EXPORTED Tetromino(GridPoint position, helper::TetrominoType type)
+    OOPETRIS_GRAPHICS_EXPORTED Tetromino(grid::GridPoint position, helper::TetrominoType type)
         : m_position{ position },
           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;
 
@@ -37,7 +41,7 @@ struct Tetromino final {
             double original_scale,
             const ScreenCordsFunction& to_screen_coords,
             const shapes::UPoint& tile_size,
-            const GridPoint& offset = GridPoint::zero()
+            const grid::GridUPoint& offset = grid::GridUPoint::zero()
     ) const;
 
     OOPETRIS_GRAPHICS_EXPORTED void rotate_right();
@@ -56,7 +60,7 @@ struct Tetromino final {
 
     static Pattern get_pattern(helper::TetrominoType type, Rotation rotation);
 
-    static std::array<Mino, 4> create_minos(GridPoint position, Rotation rotation, helper::TetrominoType type);
+    static std::array<Mino, 4> create_minos(grid::GridPoint position, Rotation rotation, helper::TetrominoType type);
 
     using TetrominoPatterns = std::array<Pattern, 4>; // one pattern per rotation
 
diff --git a/src/libs/core/game/grid_properties.hpp b/src/libs/core/game/grid_properties.hpp
@@ -6,22 +6,25 @@
 
 namespace grid {
 
-    using GridType = u8;
+    using GridType = i8;
     using GridPoint = shapes::AbstractPoint<GridType>;
 
-    constexpr GridType original_tile_size = 26;
+    using GridUType = u8;
+    using GridUPoint = shapes::AbstractPoint<GridUType>;
 
-    constexpr GridType width_in_tiles = 10;
-    constexpr GridType height_in_tiles = 20;
+    constexpr GridUType original_tile_size = 26;
 
-    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;
+    constexpr GridUType width_in_tiles = 10;
+    constexpr GridUType 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;
 
 
 } // 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 Mino::GridPoint& Mino::position() const {
+[[nodiscard]] const grid::GridUPoint& Mino::position() const {
     return m_position;
 }
 
-[[nodiscard]] Mino::GridPoint& Mino::position() {
+[[nodiscard]] grid::GridUPoint& Mino::position() {
     return m_position;
 }
 
diff --git a/src/libs/core/game/mino.hpp b/src/libs/core/game/mino.hpp
@@ -9,23 +9,22 @@
 #include <functional>
 struct Mino final {
 public:
-    using GridPoint = grid::GridPoint;
-    using ScreenCordsFunction = std::function<shapes::UPoint(const GridPoint&)>;
+    using ScreenCordsFunction = std::function<shapes::UPoint(const grid::GridUPoint&)>;
 
 private:
-    GridPoint m_position;
+    grid::GridUPoint m_position;
     helper::TetrominoType m_type;
 
 public:
-    OOPETRIS_CORE_EXPORTED explicit constexpr Mino(GridPoint position, helper::TetrominoType type)
+    OOPETRIS_CORE_EXPORTED explicit constexpr Mino(grid::GridUPoint position, helper::TetrominoType type)
         : m_position{ position },
           m_type{ type } { }
 
     OOPETRIS_CORE_EXPORTED [[nodiscard]] helper::TetrominoType type() const;
 
-    OOPETRIS_CORE_EXPORTED [[nodiscard]] const GridPoint& position() const;
+    OOPETRIS_CORE_EXPORTED [[nodiscard]] const grid::GridUPoint& position() const;
 
-    OOPETRIS_CORE_EXPORTED [[nodiscard]] GridPoint& position();
+    OOPETRIS_CORE_EXPORTED [[nodiscard]] grid::GridUPoint& 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(GridPoint coordinates) const {
+[[nodiscard]] bool MinoStack::is_empty(grid::GridUPoint coordinates) const {
     return not std::ranges::any_of(m_minos, [&coordinates](const Mino& mino) {
         return mino.position() == coordinates;
     });
 }
 
-void MinoStack::set(GridPoint coordinates, helper::TetrominoType type) {
+void MinoStack::set(grid::GridUPoint coordinates, helper::TetrominoType type) {
     const Mino to_insert = Mino{ coordinates, type };
     for (Mino& current : m_minos) {
         if (current.position() == coordinates) {
diff --git a/src/libs/core/game/mino_stack.hpp b/src/libs/core/game/mino_stack.hpp
@@ -8,17 +8,16 @@
 
 struct MinoStack final {
 private:
-    using GridPoint = Mino::GridPoint;
     using ScreenCordsFunction = Mino::ScreenCordsFunction;
 
     std::vector<Mino> m_minos;
 
 public:
     OOPETRIS_CORE_EXPORTED void clear_row_and_let_sink(u8 row);
 
-    OOPETRIS_CORE_EXPORTED [[nodiscard]] bool is_empty(GridPoint coordinates) const;
+    OOPETRIS_CORE_EXPORTED [[nodiscard]] bool is_empty(grid::GridUPoint coordinates) const;
 
-    OOPETRIS_CORE_EXPORTED void set(GridPoint coordinates, helper::TetrominoType type);
+    OOPETRIS_CORE_EXPORTED void set(grid::GridUPoint 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(shapes::AbstractPoint<u8>(x_coord.value(), y_coord.value()), maybe_type.value());
+        mino_stack.set(grid::GridUPoint(x_coord.value(), y_coord.value()), maybe_type.value());
     }
 
 
diff --git a/src/libs/recordings/utility/tetrion_snapshot.hpp b/src/libs/recordings/utility/tetrion_snapshot.hpp
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
`@@ -76,7 +76,7 @@`
`76`	`76`	`}`
`77`	`77`	`]`
`78`	`78`	`},`
`79`		`- "volume": 0.0,`
	`79`	`+ "volume": 0.2,`
`80`	`80`	`"discord": false,`
`81`	`81`	`"api_url": "https://oopetris.totto.lt/api/"`
`82`	`82`	`}`
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(GridPoint grid_coords) const {`
	`34`	`+[[nodiscard]] shapes::UPoint Grid::to_screen_coords(grid::GridUPoint 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 - GridPoint{ 1, 1 },`
	`54`	`+ grid::preview_background_position + grid::preview_extends - grid::GridUPoint{ 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 - GridPoint{ 1, 1 },`
	`64`	`+ grid::hold_background_position + grid::hold_background_extends - grid::GridUPoint{ 1, 1 },`
`65`	`65`	`}`
`66`	`66`	`);`
`67`	`67`	`}`
`@@ -80,7 +80,7 @@ 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 + (GridPoint(grid_rect.width(), grid_rect.height()).cast<u32>() * m_tile_size);`
	`83`	`+ const auto bottom_right = top_left + (grid::GridUPoint(grid_rect.width(), grid_rect.height()).cast<u32>() * m_tile_size);`
`84`	`84`
`85`	`85`	`service_provider.renderer().draw_rect_filled(shapes::URect{ top_left, bottom_right }, background_color);`
`86`	`86`