trianglengin 2.0.4__pp310-pypy310_pp73-win_amd64.whl → 2.0.6__pp310-pypy310_pp73-win_amd64.whl

trianglengin/cpp/game_state.cpp

@@ -12,7 +12,7 @@ namespace trianglengin::cpp
 
   GameStateCpp::GameStateCpp(const EnvConfigCpp &config, unsigned int initial_seed)
       : config_(config),
-        grid_data_(config_),
+        grid_data_(config_), // Initialize GridData with config
         shapes_(config_.num_shape_slots),
         score_(0.0),
         current_step_(0),
@@ -22,6 +22,39 @@ namespace trianglengin::cpp
     reset();
   }
 
+  // --- Explicit Copy Constructor ---
+  GameStateCpp::GameStateCpp(const GameStateCpp &other)
+      : config_(other.config_),                           // Copy config
+        grid_data_(other.grid_data_),                     // Use GridData's copy constructor
+        shapes_(other.shapes_),                           // Copy vector of optional shapes
+        score_(other.score_),                             // Copy score
+        current_step_(other.current_step_),               // Copy step
+        game_over_(other.game_over_),                     // Copy game over flag
+        game_over_reason_(other.game_over_reason_),       // Copy reason
+        valid_actions_cache_(other.valid_actions_cache_), // Copy the optional cache
+        rng_(other.rng_)                                  // Copy the RNG state
+  {
+    // No additional logic needed if members handle their own copying well
+  }
+
+  // --- Explicit Copy Assignment Operator ---
+  GameStateCpp &GameStateCpp::operator=(const GameStateCpp &other)
+  {
+    if (this != &other)
+    {
+      config_ = other.config_;
+      grid_data_ = other.grid_data_; // Use GridData's copy assignment
+      shapes_ = other.shapes_;
+      score_ = other.score_;
+      current_step_ = other.current_step_;
+      game_over_ = other.game_over_;
+      game_over_reason_ = other.game_over_reason_;
+      valid_actions_cache_ = other.valid_actions_cache_; // Copy the optional cache
+      rng_ = other.rng_;                                 // Copy the RNG state
+    }
+    return *this;
+  }
+
   void GameStateCpp::reset()
   {
     grid_data_.reset();
@@ -37,12 +70,9 @@ namespace trianglengin::cpp
 
   void GameStateCpp::check_initial_state_game_over()
   {
-    get_valid_actions(true); // This calls calculate_valid_actions_internal
-    if (!game_over_ && valid_actions_cache_ && valid_actions_cache_->empty())
-    {
-      force_game_over("No valid actions available at start.");
-      // REMOVED C++ Log: std::cerr << "[GameStateCpp::check_initial_state_game_over] Forced game over: No valid actions at start." << std::endl;
-    }
+    // Force calculation which updates the cache and potentially the game_over flag
+    get_valid_actions(true);
+    // No need to check cache emptiness here, get_valid_actions handles setting the flag
   }
 
   std::tuple<double, bool> GameStateCpp::step(Action action)
@@ -52,14 +82,16 @@ namespace trianglengin::cpp
       return {0.0, true};
     }
 
-    const auto &valid_actions = get_valid_actions();
+    // Ensure cache is populated before checking the action
+    const auto &valid_actions = get_valid_actions(); // This populates cache if needed
+
+    // Check against the (now guaranteed) populated cache
     if (valid_actions.find(action) == valid_actions.end())
     {
       // Invalid action detected
       force_game_over("Invalid action provided: " + std::to_string(action));
-      // Apply penalty to score *before* returning
-      score_ += config_.penalty_game_over;
-      return {config_.penalty_game_over, true}; // Return penalty and done=true
+      score_ += config_.penalty_game_over; // Apply penalty
+      return {config_.penalty_game_over, true};
     }
 
     int shape_idx, r, c;
@@ -69,27 +101,25 @@ namespace trianglengin::cpp
     }
     catch (const std::out_of_range &e)
     {
-      // Error during decoding (should be caught by valid_actions check, but defensive)
       force_game_over("Failed to decode action: " + std::to_string(action));
-      score_ += config_.penalty_game_over; // Apply penalty
+      score_ += config_.penalty_game_over;
       return {config_.penalty_game_over, true};
     }
 
     if (shape_idx < 0 || shape_idx >= static_cast<int>(shapes_.size()) || !shapes_[shape_idx].has_value())
     {
-      // Action references invalid slot (should be caught by valid_actions check)
       force_game_over("Action references invalid/empty shape slot: " + std::to_string(shape_idx));
-      score_ += config_.penalty_game_over; // Apply penalty
+      score_ += config_.penalty_game_over;
       return {config_.penalty_game_over, true};
     }
 
     const ShapeCpp &shape_to_place = shapes_[shape_idx].value();
 
+    // Re-check placement just before modification (defensive)
     if (!grid_logic::can_place(grid_data_, shape_to_place, r, c))
     {
-      // Should not happen if valid_actions is correct
       force_game_over("Placement check failed for valid action (logic error?). Action: " + std::to_string(action));
-      score_ += config_.penalty_game_over; // Apply penalty
+      score_ += config_.penalty_game_over;
       return {config_.penalty_game_over, true};
     }
 
@@ -105,10 +135,11 @@ namespace trianglengin::cpp
       std::tie(dr, dc, is_up_ignored) = tri_data;
       int target_r = r + dr;
       int target_c = c + dc;
+      // Bounds check should be implicitly handled by can_place, but double-check
       if (!grid_data_.is_valid(target_r, target_c) || grid_data_.is_death(target_r, target_c))
       {
         force_game_over("Attempted placement out of bounds/death zone during execution. Action: " + std::to_string(action));
-        score_ += config_.penalty_game_over; // Apply penalty
+        score_ += config_.penalty_game_over;
         return {config_.penalty_game_over, true};
       }
       occupied_grid[target_r][target_c] = true;
@@ -116,7 +147,7 @@ namespace trianglengin::cpp
       newly_occupied_coords.insert({target_r, target_c});
       placed_count++;
     }
-    shapes_[shape_idx] = std::nullopt;
+    shapes_[shape_idx] = std::nullopt; // Clear the used shape slot
 
     // --- Line Clearing ---
     int lines_cleared_count;
@@ -143,9 +174,8 @@ namespace trianglengin::cpp
 
     // --- Update State & Check Game Over ---
     current_step_++;
-    valid_actions_cache_ = std::nullopt;
-    get_valid_actions(true); // Force recalculation and update game_over_ if needed
-    // game_over_ flag is now definitive
+    invalidate_action_cache(); // Invalidate cache AFTER state changes
+    get_valid_actions(true);   // Force recalculation AND update game_over_ flag if needed
 
     // --- Calculate Reward & Update Score ---
     double reward = 0.0;
@@ -154,7 +184,8 @@ namespace trianglengin::cpp
 
     if (game_over_)
     {
-      reward += config_.penalty_game_over;
+      // Penalty was applied earlier if game over was due to invalid action this step.
+      // If game over is due to lack of actions *after* this step, no penalty applies here.
     }
     else
     {
@@ -162,34 +193,24 @@ namespace trianglengin::cpp
     }
     score_ += reward; // Update score based on calculated reward
 
-    return {reward, game_over_};
+    return {reward, game_over_}; // Return the potentially updated game_over_ flag
   }
 
+  // --- Simplified is_over ---
   bool GameStateCpp::is_over() const
   {
-    if (game_over_)
-      return true;
-    // If cache exists, use it. Otherwise, calculate.
-    if (valid_actions_cache_.has_value())
-      return valid_actions_cache_->empty();
-    // Need to remove const to calculate and potentially set game_over_
-    const_cast<GameStateCpp *>(this)->calculate_valid_actions_internal();
-    // Check game_over_ again as calculate might have set it
-    if (game_over_)
-      return true;
-    // Now the cache should exist
-    return valid_actions_cache_->empty();
+    // The game_over_ flag is the single source of truth.
+    // It's updated by step() [via get_valid_actions()] and reset().
+    return game_over_;
   }
 
   void GameStateCpp::force_game_over(const std::string &reason)
   {
-    // This function only sets the flags and reason.
-    // Score update should happen in the context where the game over is triggered (e.g., step).
     if (!game_over_)
     {
       game_over_ = true;
       game_over_reason_ = reason;
-      valid_actions_cache_ = std::set<Action>();
+      valid_actions_cache_ = std::set<Action>(); // Clear valid actions on game over
     }
   }
 
@@ -200,25 +221,34 @@ namespace trianglengin::cpp
 
   const std::set<Action> &GameStateCpp::get_valid_actions(bool force_recalculate)
   {
+    // If game is over, always return the cached empty set
     if (game_over_)
     {
+      // Ensure cache is empty if game_over is true
       if (!valid_actions_cache_.has_value() || !valid_actions_cache_->empty())
       {
         valid_actions_cache_ = std::set<Action>();
       }
       return *valid_actions_cache_;
     }
+
+    // If not forcing and cache exists, return it
     if (!force_recalculate && valid_actions_cache_.has_value())
     {
       return *valid_actions_cache_;
     }
+
+    // Otherwise, calculate (which updates the mutable cache)
     calculate_valid_actions_internal();
-    // Check if game should end *after* calculating actions
+
+    // Check if the calculation resulted in no valid actions, triggering game over
     if (!game_over_ && valid_actions_cache_->empty())
     {
+      // Set the game over flag HERE, as this is the definitive check after calculation
       force_game_over("No valid actions available.");
-      // REMOVED C++ Log: std::cerr << "[GameStateCpp::get_valid_actions] Forced game over: No valid actions found after calculation." << std::endl;
     }
+
+    // Return the calculated (and potentially now empty) cache
     return *valid_actions_cache_;
   }
 
@@ -227,19 +257,12 @@ namespace trianglengin::cpp
     valid_actions_cache_ = std::nullopt;
   }
 
-  // Make this non-const so it can modify the cache
-  void GameStateCpp::calculate_valid_actions_internal() const // Keep const for now, use mutable cache
+  // calculate_valid_actions_internal remains const, modifies mutable cache
+  void GameStateCpp::calculate_valid_actions_internal() const
   {
-    if (game_over_)
-    {
-      valid_actions_cache_ = std::set<Action>();
-      // REMOVED C++ Log: std::cerr << "[GameStateCpp::calculate_valid_actions_internal] Game already over. Returning empty set." << std::endl;
-      return;
-    }
+    // This function should NOT set game_over_ directly.
+    // It just calculates the set. The caller (get_valid_actions) checks if empty.
     std::set<Action> valid_actions;
-    int can_place_true_count = 0; // Counter for debugging
-    int attempts_count = 0;       // Counter for total placement checks
-
     for (int shape_idx = 0; shape_idx < static_cast<int>(shapes_.size()); ++shape_idx)
     {
       if (!shapes_[shape_idx].has_value())
@@ -247,46 +270,26 @@ namespace trianglengin::cpp
       const ShapeCpp &shape = shapes_[shape_idx].value();
       for (int r = 0; r < config_.rows; ++r)
       {
-        const auto &[start_c, end_c] = config_.playable_range_per_row[r];
-        for (int c = start_c; c < end_c; ++c)
+        // Optimization: Check only within playable range? No, C++ can_place handles death zones.
+        for (int c = 0; c < config_.cols; ++c)
         {
-          attempts_count++;                                                       // Increment attempt counter
-          bool can_place_result = grid_logic::can_place(grid_data_, shape, r, c); // Store result
-          if (can_place_result)
+          if (grid_logic::can_place(grid_data_, shape, r, c))
           {
             valid_actions.insert(encode_action(shape_idx, r, c));
-            can_place_true_count++; // Increment counter
           }
         }
       }
     }
-    // REMOVED C++ Log:
-    // std::cerr << "[GameStateCpp::calculate_valid_actions_internal] Step: " << current_step_
-    //           << ", Attempts: " << attempts_count
-    //           << ", CanPlaceTrue: " << can_place_true_count
-    //           << ", ValidActionsFound: " << valid_actions.size()
-    //           << std::endl;
-
-    // Use mutable cache
-    valid_actions_cache_ = std::move(valid_actions);
+    valid_actions_cache_ = std::move(valid_actions); // Update the mutable cache
   }
 
   int GameStateCpp::get_current_step() const { return current_step_; }
   std::optional<std::string> GameStateCpp::get_game_over_reason() const { return game_over_reason_; }
 
+  // Python-facing copy method uses the C++ copy constructor
   GameStateCpp GameStateCpp::copy() const
   {
-    GameStateCpp newState = *this;
-    // Copy the cache state explicitly
-    if (this->valid_actions_cache_.has_value())
-    {
-      newState.valid_actions_cache_ = this->valid_actions_cache_;
-    }
-    else
-    {
-      newState.valid_actions_cache_ = std::nullopt;
-    }
-    return newState;
+    return GameStateCpp(*this);
   }
 
   void GameStateCpp::debug_toggle_cell(int r, int c)
@@ -304,33 +307,36 @@ namespace trianglengin::cpp
         grid_logic::check_and_clear_lines(grid_data_, {{r, c}});
       }
       invalidate_action_cache(); // Always invalidate after manual change
+      // Force recalculation of valid actions and game over state after toggle
+      get_valid_actions(true);
     }
   }
 
   void GameStateCpp::debug_set_shapes(const std::vector<std::optional<ShapeCpp>> &new_shapes)
   {
-    // Overwrite the current shapes with the provided ones.
-    // Ensure the size matches the number of slots.
     size_t num_to_copy = std::min(new_shapes.size(), shapes_.size());
     for (size_t i = 0; i < num_to_copy; ++i)
     {
       shapes_[i] = new_shapes[i];
     }
-    // Fill remaining slots with nullopt if new_shapes is shorter
     for (size_t i = num_to_copy; i < shapes_.size(); ++i)
     {
       shapes_[i] = std::nullopt;
     }
-    // Invalidate cache as valid actions will change
     invalidate_action_cache();
+    // Force recalculation of valid actions and game over state after setting shapes
+    get_valid_actions(true);
   }
 
   Action GameStateCpp::encode_action(int shape_idx, int r, int c) const
   {
     int grid_size = config_.rows * config_.cols;
+    // Basic bounds check (more robust check in can_place)
     if (shape_idx < 0 || shape_idx >= config_.num_shape_slots || r < 0 || r >= config_.rows || c < 0 || c >= config_.cols)
     {
-      throw std::out_of_range("encode_action arguments out of range.");
+      // This case should ideally not be reached if called after can_place
+      // Return an invalid action index or throw? Let's throw for internal logic errors.
+      throw std::out_of_range("encode_action arguments out of range during valid action calculation.");
     }
     return shape_idx * grid_size + r * config_.cols + c;
   }

trianglengin/cpp/game_state.h

@@ -27,6 +27,13 @@ namespace trianglengin::cpp
   public:
     explicit GameStateCpp(const EnvConfigCpp &config, unsigned int initial_seed);
 
+    // --- Rule of 5 ---
+    ~GameStateCpp() = default;                                        // Default destructor
+    GameStateCpp(const GameStateCpp &other);                          // Copy constructor
+    GameStateCpp &operator=(const GameStateCpp &other);               // Copy assignment operator
+    GameStateCpp(GameStateCpp &&other) noexcept = default;            // Default move constructor
+    GameStateCpp &operator=(GameStateCpp &&other) noexcept = default; // Default move assignment operator
+
     void reset();
     std::tuple<double, bool> step(Action action);
     bool is_over() const;
@@ -34,7 +41,7 @@ namespace trianglengin::cpp
     const std::set<Action> &get_valid_actions(bool force_recalculate = false);
     int get_current_step() const;
     std::optional<std::string> get_game_over_reason() const;
-    GameStateCpp copy() const;
+    GameStateCpp copy() const; // Keep Python-facing copy method
     void debug_toggle_cell(int r, int c);
     void invalidate_action_cache(); // Moved to public
     // Debug method to force shapes into slots
@@ -46,6 +53,8 @@ namespace trianglengin::cpp
     const std::vector<std::optional<ShapeCpp>> &get_shapes() const { return shapes_; }
     std::vector<std::optional<ShapeCpp>> &get_shapes_mut() { return shapes_; }
     const EnvConfigCpp &get_config() const { return config_; }
+    // Expose RNG state for copying if needed (or handle seeding in copy)
+    std::mt19937 get_rng_state() const { return rng_; }
 
   private:
     EnvConfigCpp config_;

trianglengin/cpp/grid_data.cpp

@@ -44,7 +44,7 @@ namespace trianglengin::cpp
     precompute_lines();
   }
 
-  // Copy constructor: Copy the config_ member
+  // Copy constructor: Explicitly copy all members
   GridData::GridData(const GridData &other)
       : config_(other.config_), // Copy config value
         rows_(other.rows_),
@@ -55,9 +55,11 @@ namespace trianglengin::cpp
         lines_(other.lines_),
         coord_to_lines_map_(other.coord_to_lines_map_)
   {
+    // All members are copyable, default member-wise copy is sufficient here,
+    // but being explicit ensures correctness if members change later.
   }
 
-  // Copy assignment operator: Copy the config_ member
+  // Copy assignment operator: Explicitly copy all members
   GridData &GridData::operator=(const GridData &other)
   {
     if (this != &other)
@@ -103,7 +105,8 @@ namespace trianglengin::cpp
     {
       throw std::out_of_range("Coordinates (" + std::to_string(r) + "," + std::to_string(c) + ") out of bounds.");
     }
-    return !death_grid_[r][c] && occupied_grid_[r][c];
+    // An occupied cell cannot be a death cell by game logic after placement/clearing
+    return occupied_grid_[r][c];
   }
 
   std::optional<int> GridData::get_color_id(int r, int c) const
@@ -190,6 +193,7 @@ namespace trianglengin::cpp
         for (const auto &direction : directions)
         {
           Coord line_start_coord = start_coord;
+          // Find the true start of the line segment in this direction
           while (true)
           {
             auto prev_coord_opt = get_neighbor(std::get<0>(line_start_coord), std::get<1>(line_start_coord), direction, true);
@@ -200,8 +204,11 @@ namespace trianglengin::cpp
             else
               break;
           }
+          // Check if we already processed this line starting from this coordinate and direction
           if (processed_starts.count({line_start_coord, direction}))
             continue;
+
+          // Trace the line forward from the true start
           Line current_line;
           std::optional<Coord> trace_coord_opt = line_start_coord;
           while (trace_coord_opt && is_live(std::get<0>(*trace_coord_opt), std::get<1>(*trace_coord_opt)))
@@ -209,7 +216,9 @@ namespace trianglengin::cpp
             current_line.push_back(*trace_coord_opt);
             trace_coord_opt = get_neighbor(std::get<0>(*trace_coord_opt), std::get<1>(*trace_coord_opt), direction, false);
           }
-          if (current_line.size() >= 2)
+
+          // Store the line if it's long enough and mark it as processed
+          if (current_line.size() >= 2) // Only store lines of length 2 or more
           {
             maximal_lines_set.insert(current_line);
             processed_starts.insert({line_start_coord, direction});
@@ -218,16 +227,20 @@ namespace trianglengin::cpp
       }
     }
 
+    // Convert set to vector and sort for deterministic order
     lines_ = std::vector<Line>(maximal_lines_set.begin(), maximal_lines_set.end());
     std::sort(lines_.begin(), lines_.end(), [](const Line &a, const Line &b)
               {
-            if (a.empty() || b.empty()) return b.empty();
+            if (a.empty() || b.empty()) return b.empty(); // Handle empty lines if they somehow occur
+            // Sort primarily by starting row, then starting column, then size
             if (std::get<0>(a[0]) != std::get<0>(b[0])) return std::get<0>(a[0]) < std::get<0>(b[0]);
             if (std::get<1>(a[0]) != std::get<1>(b[0])) return std::get<1>(a[0]) < std::get<1>(b[0]);
             return a.size() < b.size(); });
 
+    // Build the coordinate-to-lines map
     for (const auto &line_vec : lines_)
     {
+      // Use a set of Coords (LineFs) as the value in the map for efficient lookup
       LineFs line_fs(line_vec.begin(), line_vec.end());
       for (const auto &coord : line_vec)
       {

trianglengin/cpp/grid_data.h

@@ -48,10 +48,9 @@ namespace trianglengin::cpp
     int rows() const { return rows_; }
     int cols() const { return cols_; }
 
-    // Copy constructor
-    GridData(const GridData &other);
-    // Copy assignment operator
-    GridData &operator=(const GridData &other);
+    // --- Explicit Copy Control ---
+    GridData(const GridData &other);            // Copy constructor
+    GridData &operator=(const GridData &other); // Copy assignment operator
 
     // Default move constructor/assignment should work now
     GridData(GridData &&other) noexcept = default;
@@ -75,4 +74,4 @@ namespace trianglengin::cpp
 
 } // namespace trianglengin::cpp
 
-#endif // TRIANGLENGIN_CPP_GRID_DATA_H
+#endif // TRIANGLENGIN_CPP_GRID_DATA_H

trianglengin/cpp/structs.h

@@ -8,7 +8,9 @@
 #include <tuple>
 #include <string>
 #include <cstdint>
-#include <utility> // For std::move
+#include <utility>  // For std::move
+#include <optional> // For optional members
+#include <set>      // For previous valid actions
 
 namespace trianglengin::cpp
 {
@@ -35,6 +37,33 @@ namespace trianglengin::cpp
       return triangles == other.triangles && color == other.color && color_id == other.color_id;
     }
   };
+
+  // --- NEW: Structure to hold undo information ---
+  struct StepUndoInfo
+  {
+    // Cells changed by placement or clearing
+    // Stores (row, col, previous_occupied_state, previous_color_id)
+    std::vector<std::tuple<int, int, bool, int8_t>> changed_cells;
+
+    // Info about the shape that was consumed by the step
+    int consumed_shape_slot = -1;
+    std::optional<ShapeCpp> consumed_shape = std::nullopt;
+
+    // Previous game state variables
+    double previous_score = 0.0;
+    int previous_step = 0;
+    bool previous_game_over = false;
+    std::optional<std::string> previous_game_over_reason = std::nullopt;
+
+    // Cache invalidation marker (or potentially the previous cache itself)
+    // Storing the previous cache might be large, maybe just invalidate?
+    // Let's start by just marking that the cache *was* valid before the step.
+    bool was_action_cache_valid = false;
+    // OPTIONAL (more complex): Store the actual previous cache
+    // std::optional<std::set<Action>> previous_valid_actions_cache = std::nullopt;
+  };
+  // --- END NEW ---
+
 } // namespace trianglengin::cpp
 
 #endif // TRIANGLENGIN_CPP_STRUCTS_H

{trianglengin-2.0.4.dist-info → trianglengin-2.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trianglengin
-Version: 2.0.4
+Version: 2.0.6
 Summary: High-performance C++/Python engine for a triangle puzzle game.
 Author-email: "Luis Guilherme P. M." <lgpelin92@gmail.com>
 License-Expression: MIT

{trianglengin-2.0.4.dist-info → trianglengin-2.0.6.dist-info}/RECORD

@@ -1,8 +1,8 @@
 trianglengin/__init__.py,sha256=VBYKMivxX19prPkxmSCSJJrjFXDVWkQJ9b5kQ6RzvkI,954
 trianglengin/game_interface.py,sha256=7zvt61QGmAuagRfNMpRORhX11sy9NqWM9xWstsEawKY,9540
 trianglengin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trianglengin/trianglengin_cpp.pypy310-pp73-win_amd64.pyd,sha256=qgkhweoCmFTVlNa2aibeDOX9VvBM8HU8JOpDKYXdeZw,245248
-trianglengin/Release/trianglengin_cpp.pypy310-pp73-win_amd64.pyd,sha256=qgkhweoCmFTVlNa2aibeDOX9VvBM8HU8JOpDKYXdeZw,245248
+trianglengin/trianglengin_cpp.pypy310-pp73-win_amd64.pyd,sha256=4qhbJfu42HZKB9lwDyu-hZe0xWotvevVrchQnWyCuAU,244224
+trianglengin/Release/trianglengin_cpp.pypy310-pp73-win_amd64.pyd,sha256=4qhbJfu42HZKB9lwDyu-hZe0xWotvevVrchQnWyCuAU,244224
 trianglengin/config/README.md,sha256=zPN8ezwsN5fmH4xCsVSgOZwfyng_TwrCj3MlwEq63Y4,1544
 trianglengin/config/__init__.py,sha256=sdr4D-pSCYmfXY2jOLEjPra2VewDiaWNwx1bWKp0nf8,168
 trianglengin/config/display_config.py,sha256=ivZEGTCuUfmiVU6GJpVpEASFh30AAHSH42PIIi6bPZg,1862
@@ -11,15 +11,15 @@ trianglengin/core/__init__.py,sha256=LWZkoJctRGUhd5DZUJlPCS7usdQLZyKYkoyWUWO3L4o
 trianglengin/cpp/CMakeLists.txt,sha256=vmhTQLRD7LRPbfFlisVVJ9-cCkeM3UMrikIde7TRLWc,1370
 trianglengin/cpp/bindings.cpp,sha256=okdR2NCdxgP_FTgMjwXNbzcaFdERRrvy7m1eB_5FY8g,8899
 trianglengin/cpp/config.h,sha256=rZZ6os70igGgA_fp-81fMv9TQMFJb91m6T-KeTOpKAU,742
-trianglengin/cpp/game_state.cpp,sha256=-aHu2S6zlaXvR8boX8uDxTa9s1ZTwYxrug3NldPB1BM,12442
-trianglengin/cpp/game_state.h,sha256=jR2dmulSr1uE0F0SivyrLf_sSQlgpikeZ44ZX_df-gY,2619
-trianglengin/cpp/grid_data.cpp,sha256=IVhNc9zJFCSNRUJARDo_E3pPBAdh7pNBzF03_rZ1_QA,7142
-trianglengin/cpp/grid_data.h,sha256=IhFXZc4ijLrRqUM1nKZ0gQsg-to1VS66wzao4VnPtp4,2531
+trianglengin/cpp/game_state.cpp,sha256=TTwJm-9BBvof2tntAVdQ5fjMSjqAh2F4wFsMkFlgn48,13068
+trianglengin/cpp/game_state.h,sha256=no5D0SP-vijTuL-sObJ4tx06nW0oaX42mzMZn1matL8,3302
+trianglengin/cpp/grid_data.cpp,sha256=6iucpVisR1dYayKjSPbjCaYEKaqWaNqGVswyLm6f-zM,8024
+trianglengin/cpp/grid_data.h,sha256=HVH5gqXAuHwDJrC2d7uy_maeS2ulckeGy68TkpL9gNg,2568
 trianglengin/cpp/grid_logic.cpp,sha256=O8CfzMw_3r1fU0Iu3KnapPBi5kC7tSs47yWeaVsIxOw,3457
 trianglengin/cpp/grid_logic.h,sha256=kWUheuixufHfywbzxY_ZEjk_3ayOnCTXk41CvAbVdpc,810
 trianglengin/cpp/shape_logic.cpp,sha256=O7OrzngMmU4oLUlHhbbtwzg_he3pfdDK1EA1N8fXF_g,4232
 trianglengin/cpp/shape_logic.h,sha256=GZPK748iKFunOgwus7ZVvUoC_Bu36PxK6JatxoN0hGc,653
-trianglengin/cpp/structs.h,sha256=3Zh8Ug1Tflw2P5yKC3kPasoShvGIKTnNTmwh6mq2pRQ,1032
+trianglengin/cpp/structs.h,sha256=7bcabAxsiWE2lkinYn6rKQaEgzQ69yWHYiBKrTX4Ry0,2223
 trianglengin/ui/README.md,sha256=NB-CFYy4sNmS6ld3YFmIax4p8UQmhnd28eDucaV8TqE,1753
 trianglengin/ui/__init__.py,sha256=ANMOGFAYXw2pbATBwVvSZjfCVQvBN8-RvDg_oWHBXS8,579
 trianglengin/ui/app.py,sha256=XkT5wBJPBMLZIeKDvL57GGQXC9pqdRuT6mrzgy9hIVw,4149
@@ -51,9 +51,9 @@ trianglengin/ui/visualization/drawing/utils.py,sha256=gtGtt8bgaIvctFA5TEmKqmXNov
 trianglengin/utils/__init__.py,sha256=pnFOkerF1TAz9oCzkNYBw6N56uENsyOiMZzA0cQ2SrA,185
 trianglengin/utils/geometry.py,sha256=nrhr5C3MGO-_xXz96w1B0OJNaATLbc_AeZwoB_O6gsI,2128
 trianglengin/utils/types.py,sha256=N_CjVJISvBP5QG1QYvepgORD0oNpMJlJRCJ9IdgjmWc,241
-trianglengin-2.0.4.dist-info/licenses/LICENSE,sha256=DNjSCXzwafRxA5zjyWccoRXZTDMpTNElFpNVKz4NEpY,1098
-trianglengin-2.0.4.dist-info/METADATA,sha256=Mm9gc4krrDA42SvPu0tfWlAMw6OwCwJaM-8bY3rYtIU,12316
-trianglengin-2.0.4.dist-info/WHEEL,sha256=swajkNOprSPE94y57o5LFBDVlRC4NETdBeo0gLNdwn8,108
-trianglengin-2.0.4.dist-info/entry_points.txt,sha256=kQEqO_U-MEpMEC0xwOPSucBzQIq2Ny7XwCtFSruZhvY,57
-trianglengin-2.0.4.dist-info/top_level.txt,sha256=YsSWmp_2zM23wRc5TRERHpVCgQuVYieYHDTpnwVQC7Y,13
-trianglengin-2.0.4.dist-info/RECORD,,
+trianglengin-2.0.6.dist-info/licenses/LICENSE,sha256=DNjSCXzwafRxA5zjyWccoRXZTDMpTNElFpNVKz4NEpY,1098
+trianglengin-2.0.6.dist-info/METADATA,sha256=p_tcQFMpt0tSbMQ5R9lgaGXnfMvnvjMFSdjyJ1G_TNU,12316
+trianglengin-2.0.6.dist-info/WHEEL,sha256=swajkNOprSPE94y57o5LFBDVlRC4NETdBeo0gLNdwn8,108
+trianglengin-2.0.6.dist-info/entry_points.txt,sha256=kQEqO_U-MEpMEC0xwOPSucBzQIq2Ny7XwCtFSruZhvY,57
+trianglengin-2.0.6.dist-info/top_level.txt,sha256=YsSWmp_2zM23wRc5TRERHpVCgQuVYieYHDTpnwVQC7Y,13
+trianglengin-2.0.6.dist-info/RECORD,,