trianglengin 2.0.1__cp310-cp310-macosx_11_0_arm64.whl

trianglengin/cpp/game_state.cpp

@@ -0,0 +1,327 @@
+// File: src/trianglengin/cpp/game_state.cpp
+#include "game_state.h"
+#include "grid_logic.h"
+#include "shape_logic.h"
+#include <stdexcept>
+#include <numeric>
+#include <iostream>
+#include <algorithm> // For std::min
+
+namespace trianglengin::cpp
+{
+
+  GameStateCpp::GameStateCpp(const EnvConfigCpp &config, unsigned int initial_seed)
+      : config_(config),
+        grid_data_(config_),
+        shapes_(config_.num_shape_slots),
+        score_(0.0),
+        current_step_(0),
+        game_over_(false),
+        rng_(initial_seed)
+  {
+    reset();
+  }
+
+  void GameStateCpp::reset()
+  {
+    grid_data_.reset();
+    std::fill(shapes_.begin(), shapes_.end(), std::nullopt);
+    score_ = 0.0;
+    current_step_ = 0;
+    game_over_ = false;
+    game_over_reason_ = std::nullopt;
+    valid_actions_cache_ = std::nullopt;
+    shape_logic::refill_shape_slots(*this, rng_);
+    check_initial_state_game_over();
+  }
+
+  void GameStateCpp::check_initial_state_game_over()
+  {
+    get_valid_actions(true);
+    if (!game_over_ && valid_actions_cache_ && valid_actions_cache_->empty())
+    {
+      force_game_over("No valid actions available at start.");
+    }
+  }
+
+  std::tuple<double, bool> GameStateCpp::step(Action action)
+  {
+    if (game_over_)
+    {
+      return {0.0, true};
+    }
+
+    const auto &valid_actions = get_valid_actions();
+    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
+    }
+
+    int shape_idx, r, c;
+    try
+    {
+      std::tie(shape_idx, r, c) = decode_action(action);
+    }
+    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
+      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
+      return {config_.penalty_game_over, true};
+    }
+
+    const ShapeCpp &shape_to_place = shapes_[shape_idx].value();
+
+    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
+      return {config_.penalty_game_over, true};
+    }
+
+    // --- Placement ---
+    std::set<Coord> newly_occupied_coords;
+    int placed_count = 0;
+    auto &occupied_grid = grid_data_.get_occupied_grid_mut();
+    auto &color_grid = grid_data_.get_color_id_grid_mut();
+    for (const auto &tri_data : shape_to_place.triangles)
+    {
+      int dr, dc;
+      bool is_up_ignored;
+      std::tie(dr, dc, is_up_ignored) = tri_data;
+      int target_r = r + dr;
+      int target_c = c + dc;
+      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
+        return {config_.penalty_game_over, true};
+      }
+      occupied_grid[target_r][target_c] = true;
+      color_grid[target_r][target_c] = static_cast<int8_t>(shape_to_place.color_id);
+      newly_occupied_coords.insert({target_r, target_c});
+      placed_count++;
+    }
+    shapes_[shape_idx] = std::nullopt;
+
+    // --- Line Clearing ---
+    int lines_cleared_count;
+    std::set<Coord> cleared_coords;
+    LineFsSet cleared_lines_fs;
+    std::tie(lines_cleared_count, cleared_coords, cleared_lines_fs) =
+        grid_logic::check_and_clear_lines(grid_data_, newly_occupied_coords);
+    int cleared_count = static_cast<int>(cleared_coords.size());
+
+    // --- Refill ---
+    bool all_slots_empty = true;
+    for (const auto &shape_opt : shapes_)
+    {
+      if (shape_opt.has_value())
+      {
+        all_slots_empty = false;
+        break;
+      }
+    }
+    if (all_slots_empty)
+    {
+      shape_logic::refill_shape_slots(*this, rng_);
+    }
+
+    // --- 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
+
+    // --- Calculate Reward & Update Score ---
+    double reward = 0.0;
+    reward += static_cast<double>(placed_count) * config_.reward_per_placed_triangle;
+    reward += static_cast<double>(cleared_count) * config_.reward_per_cleared_triangle;
+
+    if (game_over_)
+    {
+      reward += config_.penalty_game_over;
+    }
+    else
+    {
+      reward += config_.reward_per_step_alive;
+    }
+    score_ += reward; // Update score based on calculated reward
+
+    return {reward, game_over_};
+  }
+
+  bool GameStateCpp::is_over() const
+  {
+    if (game_over_)
+      return true;
+    if (valid_actions_cache_.has_value())
+      return valid_actions_cache_->empty();
+    calculate_valid_actions_internal();
+    return valid_actions_cache_->empty();
+  }
+
+  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>();
+    }
+  }
+
+  double GameStateCpp::get_score() const
+  {
+    return score_;
+  }
+
+  const std::set<Action> &GameStateCpp::get_valid_actions(bool force_recalculate)
+  {
+    if (game_over_)
+    {
+      if (!valid_actions_cache_.has_value() || !valid_actions_cache_->empty())
+      {
+        valid_actions_cache_ = std::set<Action>();
+      }
+      return *valid_actions_cache_;
+    }
+    if (!force_recalculate && valid_actions_cache_.has_value())
+    {
+      return *valid_actions_cache_;
+    }
+    calculate_valid_actions_internal();
+    // Check if game should end *after* calculating actions
+    if (!game_over_ && valid_actions_cache_->empty())
+    {
+      force_game_over("No valid actions available.");
+    }
+    return *valid_actions_cache_;
+  }
+
+  void GameStateCpp::invalidate_action_cache()
+  {
+    valid_actions_cache_ = std::nullopt;
+  }
+
+  void GameStateCpp::calculate_valid_actions_internal() const
+  {
+    if (game_over_)
+    {
+      valid_actions_cache_ = std::set<Action>();
+      return;
+    }
+    std::set<Action> valid_actions;
+    for (int shape_idx = 0; shape_idx < static_cast<int>(shapes_.size()); ++shape_idx)
+    {
+      if (!shapes_[shape_idx].has_value())
+        continue;
+      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)
+        {
+          if (grid_logic::can_place(grid_data_, shape, r, c))
+          {
+            valid_actions.insert(encode_action(shape_idx, r, c));
+          }
+        }
+      }
+    }
+    valid_actions_cache_ = std::move(valid_actions);
+  }
+
+  int GameStateCpp::get_current_step() const { return current_step_; }
+  std::optional<std::string> GameStateCpp::get_game_over_reason() const { return game_over_reason_; }
+
+  GameStateCpp GameStateCpp::copy() const
+  {
+    GameStateCpp newState = *this;
+    if (this->valid_actions_cache_.has_value())
+    {
+      newState.valid_actions_cache_ = this->valid_actions_cache_;
+    }
+    else
+    {
+      newState.valid_actions_cache_ = std::nullopt;
+    }
+    return newState;
+  }
+
+  void GameStateCpp::debug_toggle_cell(int r, int c)
+  {
+    if (grid_data_.is_valid(r, c) && !grid_data_.is_death(r, c))
+    {
+      auto &occupied_grid = grid_data_.get_occupied_grid_mut();
+      auto &color_grid = grid_data_.get_color_id_grid_mut();
+      bool was_occupied = occupied_grid[r][c];
+      occupied_grid[r][c] = !was_occupied;
+      color_grid[r][c] = was_occupied ? NO_COLOR_ID : DEBUG_COLOR_ID;
+      if (!was_occupied)
+      {
+        grid_logic::check_and_clear_lines(grid_data_, {{r, c}});
+      }
+      invalidate_action_cache();
+    }
+  }
+
+  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();
+  }
+
+  Action GameStateCpp::encode_action(int shape_idx, int r, int c) const
+  {
+    int grid_size = config_.rows * config_.cols;
+    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.");
+    }
+    return shape_idx * grid_size + r * config_.cols + c;
+  }
+
+  std::tuple<int, int, int> GameStateCpp::decode_action(Action action) const
+  {
+    int action_dim = config_.num_shape_slots * config_.rows * config_.cols;
+    if (action < 0 || action >= action_dim)
+    {
+      throw std::out_of_range("Action index out of range: " + std::to_string(action));
+    }
+    int grid_size = config_.rows * config_.cols;
+    int shape_idx = action / grid_size;
+    int remainder = action % grid_size;
+    int r = remainder / config_.cols;
+    int c = remainder % config_.cols;
+    return {shape_idx, r, c};
+  }
+
+} // namespace trianglengin::cpp

trianglengin/cpp/game_state.h

@@ -0,0 +1,73 @@
+// File: src/trianglengin/cpp/game_state.h
+#ifndef TRIANGLENGIN_CPP_GAME_STATE_H
+#define TRIANGLENGIN_CPP_GAME_STATE_H
+
+#pragma once
+
+#include <vector>
+#include <set>
+#include <optional>
+#include <random>
+#include <memory>
+#include <string> // Include string for optional<string>
+#include <tuple>  // Include tuple for std::tuple
+
+#include "config.h"
+#include "structs.h"
+#include "grid_data.h"
+// Remove direct includes causing cycles if possible, use forward declarations
+// #include "grid_logic.h" // Included by game_state.cpp
+// #include "shape_logic.h" // Included by game_state.cpp
+
+namespace trianglengin::cpp
+{
+
+  class GameStateCpp
+  {
+  public:
+    explicit GameStateCpp(const EnvConfigCpp &config, unsigned int initial_seed);
+
+    void reset();
+    std::tuple<double, bool> step(Action action);
+    bool is_over() const;
+    double get_score() const;
+    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;
+    void debug_toggle_cell(int r, int c);
+    void invalidate_action_cache(); // Moved to public
+    // Debug method to force shapes into slots
+    void debug_set_shapes(const std::vector<std::optional<ShapeCpp>> &new_shapes);
+
+    // Accessors needed by logic functions or bindings
+    const GridData &get_grid_data() const { return grid_data_; }
+    GridData &get_grid_data_mut() { return grid_data_; }
+    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_; }
+
+  private:
+    EnvConfigCpp config_;
+    GridData grid_data_;
+    std::vector<std::optional<ShapeCpp>> shapes_;
+    double score_;
+    int current_step_;
+    bool game_over_;
+    std::optional<std::string> game_over_reason_;
+    mutable std::optional<std::set<Action>> valid_actions_cache_; // Mutable for const getter
+    std::mt19937 rng_;
+
+    void check_initial_state_game_over();
+    void force_game_over(const std::string &reason);
+    // void invalidate_action_cache(); // Moved from private
+    void calculate_valid_actions_internal() const; // Made const
+
+    // Action encoding/decoding (can be private if only used internally)
+    Action encode_action(int shape_idx, int r, int c) const;
+    std::tuple<int, int, int> decode_action(Action action) const;
+  };
+
+} // namespace trianglengin::cpp
+
+#endif // TRIANGLENGIN_CPP_GAME_STATE_H

trianglengin/cpp/grid_data.cpp

@@ -0,0 +1,239 @@
+// File: src/trianglengin/cpp/grid_data.cpp
+#include "grid_data.h"
+#include <stdexcept>
+#include <set>
+#include <algorithm>
+#include <iostream>
+
+namespace trianglengin::cpp
+{
+
+  // Constructor: Initialize config_ by copying the passed config
+  GridData::GridData(const EnvConfigCpp &config)
+      : config_(config), // Copy config here
+        rows_(config_.rows),
+        cols_(config_.cols)
+  {
+    if (rows_ <= 0 || cols_ <= 0)
+    {
+      throw std::invalid_argument("Grid dimensions must be positive.");
+    }
+    occupied_grid_.assign(rows_, std::vector<bool>(cols_, false));
+    color_id_grid_.assign(rows_, std::vector<int8_t>(cols_, NO_COLOR_ID));
+    death_grid_.assign(rows_, std::vector<bool>(cols_, true));
+
+    if (config_.playable_range_per_row.size() != static_cast<size_t>(rows_))
+    {
+      throw std::invalid_argument("Playable range size mismatch with rows.");
+    }
+    for (int r = 0; r < rows_; ++r)
+    {
+      const auto &[start_col, end_col] = config_.playable_range_per_row[r];
+      if (start_col < 0 || end_col > cols_ || start_col > end_col) // Allow start == end
+      {
+        throw std::invalid_argument("Invalid playable range for row " + std::to_string(r));
+      }
+      if (start_col < end_col)
+      {
+        for (int c = start_col; c < end_col; ++c)
+        {
+          death_grid_[r][c] = false;
+        }
+      }
+    }
+    precompute_lines();
+  }
+
+  // Copy constructor: Copy the config_ member
+  GridData::GridData(const GridData &other)
+      : config_(other.config_), // Copy config value
+        rows_(other.rows_),
+        cols_(other.cols_),
+        occupied_grid_(other.occupied_grid_),
+        color_id_grid_(other.color_id_grid_),
+        death_grid_(other.death_grid_),
+        lines_(other.lines_),
+        coord_to_lines_map_(other.coord_to_lines_map_)
+  {
+  }
+
+  // Copy assignment operator: Copy the config_ member
+  GridData &GridData::operator=(const GridData &other)
+  {
+    if (this != &other)
+    {
+      config_ = other.config_; // Copy config value
+      rows_ = other.rows_;
+      cols_ = other.cols_;
+      occupied_grid_ = other.occupied_grid_;
+      color_id_grid_ = other.color_id_grid_;
+      death_grid_ = other.death_grid_;
+      lines_ = other.lines_;
+      coord_to_lines_map_ = other.coord_to_lines_map_;
+    }
+    return *this;
+  }
+
+  void GridData::reset()
+  {
+    for (int r = 0; r < rows_; ++r)
+    {
+      std::fill(occupied_grid_[r].begin(), occupied_grid_[r].end(), false);
+      std::fill(color_id_grid_[r].begin(), color_id_grid_[r].end(), NO_COLOR_ID);
+    }
+  }
+
+  bool GridData::is_valid(int r, int c) const
+  {
+    return r >= 0 && r < rows_ && c >= 0 && c < cols_;
+  }
+
+  bool GridData::is_death(int r, int c) const
+  {
+    if (!is_valid(r, c))
+    {
+      throw std::out_of_range("Coordinates (" + std::to_string(r) + "," + std::to_string(c) + ") out of bounds.");
+    }
+    return death_grid_[r][c];
+  }
+
+  bool GridData::is_occupied(int r, int c) const
+  {
+    if (!is_valid(r, c))
+    {
+      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];
+  }
+
+  std::optional<int> GridData::get_color_id(int r, int c) const
+  {
+    if (!is_valid(r, c) || death_grid_[r][c] || !occupied_grid_[r][c])
+    {
+      return std::nullopt;
+    }
+    return color_id_grid_[r][c];
+  }
+
+  bool GridData::is_up(int r, int c) const
+  {
+    return (r + c) % 2 != 0;
+  }
+
+  bool GridData::is_live(int r, int c) const
+  {
+    return is_valid(r, c) && !death_grid_[r][c];
+  }
+
+  std::optional<Coord> GridData::get_neighbor(int r, int c, const std::string &direction, bool backward) const
+  {
+    bool up = is_up(r, c);
+    int nr = -1, nc = -1;
+
+    if (direction == "h")
+    {
+      int dc = backward ? -1 : 1;
+      nr = r;
+      nc = c + dc;
+    }
+    else if (direction == "d1")
+    { // TL-BR
+      if (backward)
+      {
+        nr = up ? r : r - 1;
+        nc = up ? c - 1 : c;
+      }
+      else
+      {
+        nr = up ? r + 1 : r;
+        nc = up ? c : c + 1;
+      }
+    }
+    else if (direction == "d2")
+    { // BL-TR
+      if (backward)
+      {
+        nr = up ? r + 1 : r;
+        nc = up ? c : c - 1;
+      }
+      else
+      {
+        nr = up ? r : r - 1;
+        nc = up ? c + 1 : c;
+      }
+    }
+    else
+    {
+      throw std::invalid_argument("Unknown direction: " + direction);
+    }
+
+    if (!is_valid(nr, nc))
+      return std::nullopt;
+    return Coord{nr, nc};
+  }
+
+  void GridData::precompute_lines()
+  {
+    lines_.clear();
+    coord_to_lines_map_.clear();
+    std::set<Line> maximal_lines_set;
+    std::set<std::tuple<Coord, std::string>> processed_starts;
+    const std::vector<std::string> directions = {"h", "d1", "d2"};
+
+    for (int r_init = 0; r_init < rows_; ++r_init)
+    {
+      for (int c_init = 0; c_init < cols_; ++c_init)
+      {
+        if (!is_live(r_init, c_init))
+          continue;
+        Coord start_coord = {r_init, c_init};
+        for (const auto &direction : directions)
+        {
+          Coord line_start_coord = start_coord;
+          while (true)
+          {
+            auto prev_coord_opt = get_neighbor(std::get<0>(line_start_coord), std::get<1>(line_start_coord), direction, true);
+            if (prev_coord_opt && is_live(std::get<0>(*prev_coord_opt), std::get<1>(*prev_coord_opt)))
+            {
+              line_start_coord = *prev_coord_opt;
+            }
+            else
+              break;
+          }
+          if (processed_starts.count({line_start_coord, direction}))
+            continue;
+          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)))
+          {
+            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)
+          {
+            maximal_lines_set.insert(current_line);
+            processed_starts.insert({line_start_coord, direction});
+          }
+        }
+      }
+    }
+
+    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 (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(); });
+
+    for (const auto &line_vec : lines_)
+    {
+      LineFs line_fs(line_vec.begin(), line_vec.end());
+      for (const auto &coord : line_vec)
+      {
+        coord_to_lines_map_[coord].insert(line_fs);
+      }
+    }
+  }
+
+} // namespace trianglengin::cpp