WIP working on go board optimization?

src/games/go/board.rs

@@ -210,7 +210,13 @@ impl GoBoard {
     }
 }
 
-fn is_available_move_sim(rules: &Rules, history: &IntSet<Zobrist>, kind: PlacementKind, next_zobrist: Zobrist) -> bool {
+fn is_available_move_sim(
+    rules: &Rules,
+    history: &IntSet<Zobrist>,
+    kind: PlacementKind,
+    has_had_same_color: bool,
+    next_zobrist: Zobrist,
+) -> bool {
     // check placement kind
     match kind {
         PlacementKind::Normal => {}
@@ -223,9 +229,11 @@ fn is_available_move_sim(rules: &Rules, history: &IntSet<Zobrist>, kind: Placeme
         }
     }
 
+    let could_repeat = has_had_same_color || kind == PlacementKind::SuicideMulti;
+
     // check history
     //   scan in reverse to hopefully find quicker matches
-    if !rules.allow_repeating_tiles() && history.contains(&next_zobrist) {
+    if could_repeat && !rules.allow_repeating_tiles() && history.contains(&next_zobrist) {
         return false;
     }
 
@@ -250,7 +258,18 @@ impl Board for GoBoard {
                 } else {
                     let tile = tile.to_flat(self.size());
                     match self.chains.simulate_place_stone_minimal(tile, self.next_player) {
-                        Ok(sim) => is_available_move_sim(&self.rules, &self.history, sim.kind, sim.next_zobrist),
+                        Ok(sim) => {
+                            // TODO move earlier for perf
+                            let could_be_super_ko = self.chains.has_had_stone_at(tile, self.next_player);
+
+                            is_available_move_sim(
+                                &self.rules,
+                                &self.history,
+                                sim.kind,
+                                could_be_super_ko,
+                                sim.next_zobrist,
+                            )
+                        }
                         Err(TileOccupied) => false,
                     }
                 }
@@ -288,8 +307,9 @@ impl Board for GoBoard {
                     let tile = tile.to_flat(self.size());
                     let rules = &self.rules;
                     let history = &self.history;
+                    let has_had_same_color = self.chains.has_had_stone_at(tile, curr) | true;
                     let place_result = self.chains.place_stone_if(tile, curr, |sim| {
-                        is_available_move_sim(rules, history, sim.kind, sim.next_zobrist)
+                        is_available_move_sim(rules, history, sim.kind, has_had_same_color, sim.next_zobrist)
                     });
                     match place_result {
                         Ok((_, true)) => {}

src/games/go/chains.rs

@@ -44,6 +44,9 @@ pub struct Chains {
 pub struct TileContent {
     pub group_id: OptionU16,
     pub link: LinkNode,
+    /// Whether a tile of the given color has ever been present at the current position.
+    /// Bitset with indices corresponding to [Player::index].
+    pub has_had_stone: u8,
 }
 
 // TODO compact? we can at least force player into one of the other fields
@@ -125,6 +128,7 @@ impl Chains {
             .map(|i| TileContent {
                 group_id: OptionU16::None,
                 link: LinkNode::full(area, i),
+                has_had_stone: 0,
             })
             .collect_vec();
 
@@ -180,6 +184,10 @@ impl Chains {
         self.group_at(tile).map(|group| group.color)
     }
 
+    pub fn has_had_stone_at(&self, tile: FlatTile, color: Player) -> bool {
+        (self.content_at(tile).has_had_stone & (1 << color.index())) != 0
+    }
+
     pub fn zobrist(&self) -> Zobrist {
         self.zobrist
     }
@@ -568,7 +576,9 @@ impl Chains {
                     };
 
                     // set tile itself
-                    self.tiles[tile_index as usize].group_id = OptionU16::Some(group_id);
+                    let content = &mut self.tiles[tile_index as usize];
+                    content.group_id = OptionU16::Some(group_id);
+                    content.has_had_stone |= 1 << color.index();
 
                     // decrement adjacent liberties
                     change_liberty_edges_at(
@@ -651,7 +661,9 @@ impl Chains {
 
         // mark tiles as part of new group
         new_group_stones.for_each_mut(&mut self.tiles, |tiles, tile_index| {
-            tiles[tile_index as usize].group_id = OptionU16::Some(new_group_id);
+            let content = &mut tiles[tile_index as usize];
+            content.group_id = OptionU16::Some(new_group_id);
+            content.has_had_stone |= 1 << color.index();
         });
 
         new_group_id
@@ -748,6 +760,7 @@ impl Chains {
                 TileContent {
                     group_id: old_content.group_id,
                     link: old_content.link.map_index(map_tile_index),
+                    has_had_stone: old_content.has_had_stone,
                 }
             })
             .collect_vec();
@@ -809,6 +822,16 @@ impl Chains {
                 // group must be alive
                 assert!(!group.is_dead());
 
+                // has_had_stone must at least cover the current stones
+                assert_ne!(
+                    content.has_had_stone & (1 << group.color.index()),
+                    0,
+                    "Tile {:?} has history {:0b} but group {:?}",
+                    tile,
+                    content.has_had_stone,
+                    group
+                );
+
                 // track info
                 let group_zobrist = group_info.entry(id).or_insert((Zobrist::default(), HashSet::default()));
                 group_zobrist.0 ^= Zobrist::for_color_tile(group.color, tile);

tests/board/go_chains.rs

@@ -160,6 +160,14 @@ fn capture_corner() {
     println!("{}", chains);
     assert_eq!(chains.to_fen(), "...../...../...../w..../b....");
 
+    let tile_dead = Tile::new(0, 0).to_flat(chains.size());
+    let tile_final = Tile::new(1, 0).to_flat(chains.size());
+
+    assert!(chains.has_had_stone_at(tile_dead, Player::A));
+    assert!(!chains.has_had_stone_at(tile_dead, Player::B));
+    assert!(!chains.has_had_stone_at(tile_final, Player::A));
+    assert!(!chains.has_had_stone_at(tile_final, Player::B));
+
     let sim = chains
         .place_stone(Tile::new(1, 0).to_flat(chains.size()), Player::B)
         .unwrap();
@@ -175,6 +183,11 @@ fn capture_corner() {
     expected.assert_eq(chains.group_at(Tile::new(1, 0).to_flat(chains.size())));
     expected.assert_eq(chains.group_at(Tile::new(0, 1).to_flat(chains.size())));
 
+    assert!(chains.has_had_stone_at(tile_dead, Player::A));
+    assert!(!chains.has_had_stone_at(tile_dead, Player::B));
+    assert!(!chains.has_had_stone_at(tile_final, Player::A));
+    assert!(chains.has_had_stone_at(tile_final, Player::B));
+
     chains_test_main(&chains);
 }