finish fixing merge

Author: gmweinberg

open_spiel/games/gomoku/gomoku.cc

@@ -174,42 +174,44 @@ void GomokuState::DoApplyAction(Action move) {
   CheckWinFromLastMove(move);
 }
 
-void GomokuState::CheckWinFromLastMove(Action last_move) {
+absl::optional<std::vector<Grid<Stone>::Coord>>
+GomokuState::FindWinLineFromLastMove(Action last_move) const {
+  using Coord = Grid<Stone>::Coord;
 
-  const Grid<Stone>::Coord start =
-      board_.Unflatten(last_move);
+  const Coord start = board_.Unflatten(last_move);
   const Stone stone = board_.At(start);
-	const auto* gomoku = static_cast<const GomokuGame*>(game_.get());
 
   SPIEL_CHECK_NE(stone, Stone::kEmpty);
 
   for (const auto& dir : board_.Directions()) {
     if (!board_.IsCanonical(dir)) continue;
 
-    int count = 1;  // include the starting stone
+    std::vector<Coord> line;
+    line.push_back(start);
 
-    // forward direction
+    // forward
     {
       Coord c = start;
       while (static_cast<int>(line.size()) < connect_ &&
              board_.Step(c, dir) &&
              board_.At(c) == stone) {
-        ++count;
+        line.push_back(c);
       }
     }
 
-    // backward direction
+    // backward
     {
-      auto neg_dir = dir;
+      Coord neg_dir = dir;
       for (int& v : neg_dir) v = -v;
 
       Coord c = start;
       while (static_cast<int>(line.size()) < connect_ &&
              board_.Step(c, neg_dir) &&
              board_.At(c) == stone) {
-        ++count;
+        line.insert(line.begin(), c);
       }
     }
+
     if (static_cast<int>(line.size()) >= connect_) {
       line.resize(connect_);  // arbitrary truncation is fine
       return line;
@@ -372,6 +374,57 @@ int GomokuGame::NumDistinctActions() const {
   return total_size_;
 }
 
+uint64_t GomokuState::ComputeZobrist(
+  const Grid<Stone>& grid) const {
+    const auto* gomoku = static_cast<const GomokuGame*>(game_.get());
+    uint64_t h = 0;
+    for (int i = 0; i < grid.NumCells(); ++i) {
+      Stone s = grid.AtIndex(i);
+      if (s != Stone::kEmpty) {
+         h ^= gomoku->ZobristTable()[i][StoneToInt(s)];
+      }
+    }
+    if (current_player_ == 1) {
+      h ^= gomoku->PlayerToMoveHash();
+    }
+    return h;
+}
+
+uint64_t GomokuState::SymmetricHash() const {
+  uint64_t best = ComputeZobrist(board_);
+
+  // --- Basic rotations ---
+  for (auto [i, j] : board_.GenRotations()) {
+    Grid<Stone> rotated = board_;
+    for (int r = 0; r < 3; ++r) {  // 90, 180, 270
+      rotated = rotated.ApplyRotation(i, j);
+      best = std::min(best, ComputeZobrist(rotated));
+    }
+  }
+
+  // --- Reflections ---
+  if (symmetry_policy_.allow_reflections) {
+    for (int axis = 0; axis < dims_; ++axis) {
+      Grid<Stone> refl = board_.ApplyReflection(axis);
+      best = std::min(best, ComputeZobrist(refl));
+
+      // --- Reflection + rotations ---
+      if (symmetry_policy_.allow_reflection_rotations) {
+        for (auto [i, j] : board_.GenRotations()) {
+          Grid<Stone> rotated = refl;
+          for (int r = 0; r < 3; ++r) {
+            rotated = rotated.ApplyRotation(i, j);
+            best = std::min(best, ComputeZobrist(rotated));
+          }
+        }
+      }
+    }
+  }
+
+  return best;
+}
+
+
 GomokuState::GomokuState(std::shared_ptr<const Game> game,
                          const std::string& state_str)
     : State(game),
@@ -434,5 +487,7 @@ GomokuState::GomokuState(std::shared_ptr<const Game> game,
   zobrist_hash_ = ComputeZobrist(board_);
 }
 
+
+
 }  // namespace gomoku
 }  // namespace open_spiel

open_spiel/games/gomoku/gomoku.h

@@ -49,8 +49,6 @@ inline constexpr int kNumPlayers = 2;
 inline constexpr int kBlackPlayer = 0;
 inline constexpr int kWhitePlayer = 1;
 
-
-//
 enum class Stone {
   kEmpty,
   kBlack,

open_spiel/games/gomoku/gomoku_grid.h

@@ -34,10 +34,8 @@ class Grid {
         wrap_(wrap),
         strides_(dims),
         data_(ComputeTotalSize(size, dims)) {
-    if (size_ == 0 || dims_ == 0) {
-      throw std::invalid_argument("Grid size and dims must be >= 1");
-    }
-
+    SPIEL_CHECK_GE(size, 1);
+    SPIEL_CHECK_GE(dims, 1);
     // stride[d] = size^(dims - d - 1)
     strides_[dims_ - 1] = 1;
     for (std::size_t i = dims_ - 1; i > 0; --i) {

open_spiel/games/gomoku/gomoku_test.cc

@@ -70,7 +70,7 @@ void TestObservationTensor() {
   // Make two moves: Black 0, White 1
   state->ApplyAction(0);
   // white on move
-	state->ObservationTensor(/*player=*/0, absl::MakeSpan(obs));
+  state->ObservationTensor(/*player=*/0, absl::MakeSpan(obs));
   SPIEL_CHECK_EQ(obs[2 * num_cells], 0.0f);
   state->ApplyAction(1);
 

open_spiel/python/pybind11/games_gomoku.cc

@@ -27,6 +27,7 @@ namespace py = ::pybind11;
 using open_spiel::Game;
 using open_spiel::Action;
 using open_spiel::State;
+using open_spiel::gomoku::SymmetryPolicy;
 using open_spiel::gomoku::GomokuGame;
 using open_spiel::gomoku::GomokuState;
 
@@ -55,10 +56,14 @@ void open_spiel::init_pyspiel_games_gomoku(::pybind11::module &m) {
        [](const std::string& data) {
          return std::dynamic_pointer_cast<GomokuGame>(
            std::const_pointer_cast<Game>(LoadGame(data)));
-       }));;
+       }));
 
   py::classh<GomokuState, State>(m, "GomokuState")
     .def("hash_value", &GomokuState::HashValue)
+    .def("symmetric_hash", &GomokuState::SymmetricHash)
+		.def("winning_line", &GomokuState::WinningLine,
+       py::return_value_policy::reference_internal)
+
 		.def(py::pickle(
        [](const GomokuState& state) {
        return SerializeGameAndState(*state.GetGame(), state);
@@ -67,5 +72,18 @@ void open_spiel::init_pyspiel_games_gomoku(::pybind11::module &m) {
       auto game_and_state = DeserializeGameAndState(data);
       return dynamic_cast<GomokuState*>(
           game_and_state.second.release());
-      }));
+      }))
+	  .def("set_symmetry_policy",
+         &GomokuState::SetSymmetryPolicy)
+    .def("get_symmetry_policy",
+         &GomokuState::GetSymmetryPolicy,
+         py::return_value_policy::reference_internal);
+
+  py::class_<SymmetryPolicy>(m, "SymmetryPolicy")
+    .def(py::init<>())
+    .def_readwrite("allow_reflections",
+                   &SymmetryPolicy::allow_reflections)
+    .def_readwrite("allow_reflection_rotations",
+                   &SymmetryPolicy::allow_reflection_rotations);
+
 }

open_spiel/python/tests/games_gomoku_test.py

@@ -54,14 +54,11 @@ def test_gomoku_game_funs(self):
     self.assertEqual(coord, move, f"Coord {coord} move {move}")
 
   def test_gomoku_hash(self):
-    game = pyspiel.load_game("gomoku")
+    game = pyspiel.load_game("gomoku(size=3,connect=3)")
     state = game.new_initial_state()
     hash0 = state.hash_value()
     self.assertEqual(hash0, 0, f"Initial board hash {hash0}")
     state.apply_action(1)
-<<<<<<< HEAD
-    print("hash", state.hash_value())
-=======
     hash1 = state.hash_value()
     sym1 = state.symmetric_hash()
     # States related by symmetry shoud have different hashes
@@ -78,15 +75,15 @@ def test_gomoku_hash(self):
     state = game.new_initial_state()
     policy = state.get_symmetry_policy()
     print("policy", policy)
-    self.assertEqual(policy.allow_reflections, False, f"Wrong symmetry ploicy")
+    self.assertEqual(policy.allow_reflections, False, f"Wrong symmetry policy")
     # verify policy is correct here
     state.apply_action(0)
     state.apply_action(1)
     sym11 = state.symmetric_hash()
     # set symmetry policy here
     policy.allow_reflections = True
     policy = state.get_symmetry_policy()
-    self.assertEqual(policy.allow_reflections, True, f"Wrong symmetry ploicy")
+    self.assertEqual(policy.allow_reflections, True, f"Wrong symmetry policy")
     sym12 = state.symmetric_hash()
 
     state = game.new_initial_state()
@@ -102,7 +99,6 @@ def test_gomoku_hash(self):
     self.assertNotEqual(sym11, sym21, f"Hash1 {sym11} Hash2 {sym21}")
     self.assertEqual(sym12, sym22, f"Hash1 {sym12} Hash2 {sym22}")
 
->>>>>>> 09f40196 (Cleaned up lint, added tests)
 
   def test_gommoku_game_sim(self):
       game = pyspiel.load_game("gomoku")
@@ -115,8 +111,6 @@ def test_gommoku_game_sim(self):
           state.apply_action(action)
           mc += 1
 
-<<<<<<< HEAD
-=======
   def test_winning_line(self):
       game = pyspiel.load_game("gomoku(size=3,connect=3)")
       state = game.new_initial_state()
@@ -167,6 +161,5 @@ def test_consistent_hash(self):
       hash2 = state.hash_value()
       self.assertEqual(hash1, hash2, f"Hash1 {hash1} Hash2 {hash2}")
 
->>>>>>> 09f40196 (Cleaned up lint, added tests)
 if __name__ == "__main__":
   absltest.main()