kifu/kifu-core/Cargo.lock

@@ -26,15 +26,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
-[[package]]
-name = "grid"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0634107a3a005070dd73e27e74ecb691a94e9e5ba7829f434db7fbf73a6b5c47"
-dependencies = [
- "no-std-compat",
-]
-
 [[package]]
 name = "hermit-abi"
 version = "0.2.6"
@@ -48,7 +39,6 @@ dependencies = [
 name = "kifu-core"
 version = "0.1.0"
 dependencies = [
- "grid",
  "tokio",
 ]
 
@@ -95,12 +85,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "no-std-compat"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b93853da6d84c2e3c7d730d6473e8817692dd89be387eb01b94d7f108ecb5b8c"
-
 [[package]]
 name = "num_cpus"
 version = "1.15.0"

kifu/kifu-core/Cargo.toml

@@ -7,4 +7,3 @@ edition = "2021"
 
 [dependencies]
 tokio = { version = "1.26", features = [ "full" ] }
-grid    = { version = "0.9" }

kifu/kifu-core/src/api.rs

@@ -10,8 +10,8 @@ pub enum Request {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct PlayStoneRequest {
-    pub column: usize,
+    pub column: u8,
-    pub row: usize,
+    pub row: u8,
 }
 
 #[derive(Clone, Debug)]

kifu/kifu-core/src/board.rs

@@ -1,611 +0,0 @@
-use crate::{Color, Size};
-use grid::Grid;
-use std::collections::HashSet;
-
-#[derive(Clone, Debug)]
-pub enum Error {
-    InvalidPosition,
-}
-
-#[derive(Clone, Debug)]
-pub struct Board {
-    pub size: Size,
-    pub grid: Grid<Option<Color>>,
-    pub groups: Vec<Group>,
-}
-
-impl std::fmt::Display for Board {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        print!("   ");
-        // for c in 'A'..'U' {
-        for c in 0..19 {
-            print!("{:2}", c);
-        }
-        println!("");
-
-        for row in 0..self.size.height {
-            print!(" {:2}", row);
-            for column in 0..self.size.width {
-                match self.stone(&Coordinate { column, row }) {
-                    None => write!(f, " .")?,
-                    Some(Color::Black) => write!(f, " X")?,
-                    Some(Color::White) => write!(f, " O")?,
-                }
-            }
-            writeln!(f, "")?;
-        }
-        Ok(())
-    }
-}
-
-impl Board {
-    pub fn new() -> Self {
-        Self {
-            size: Size {
-                width: 19,
-                height: 19,
-            },
-            grid: Grid::new(19, 19),
-            groups: Vec::new(),
-        }
-    }
-
-    pub fn from_coordinates(coordinates: impl Iterator<Item = (Coordinate, Color)>) -> Self {
-        let mut s = Self::new();
-        for (coordinate, color) in coordinates {
-            s.place_stone(coordinate, color);
-        }
-        s
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Hash, Eq)]
-pub struct Coordinate {
-    pub column: usize,
-    pub row: usize,
-}
-
-impl Board {
-    pub fn place_stone(&mut self, coordinate: Coordinate, color: Color) -> Result<(), Error> {
-        if let Some(_) = self.stone(&coordinate) {
-            return Err(Error::InvalidPosition);
-        }
-
-        let mut friendly_group = self
-            .adjacencies(&coordinate)
-            .into_iter()
-            .filter(|c| self.stone(c) == Some(color))
-            .filter_map(|c| self.group(&c).map(|g| g.coordinates.clone()))
-            .fold(HashSet::new(), |acc, set| {
-                acc.union(&set).cloned().collect()
-            });
-
-        friendly_group.insert(coordinate.clone());
-
-        self.groups
-            .retain(|g| g.coordinates.is_disjoint(&friendly_group));
-        let friendly_group = Group {
-            color,
-            coordinates: friendly_group,
-        };
-        self.groups.push(friendly_group.clone());
-
-        match self.grid.get_mut(coordinate.row, coordinate.column) {
-            None => return Err(Error::InvalidPosition),
-            Some(space) => *space = Some(color),
-        }
-
-        let adjacent_groups = self.adjacent_groups(&friendly_group);
-        for group in adjacent_groups {
-            if self.liberties(&group) == 0 {
-                self.remove_group(&group);
-            }
-        }
-
-        Ok(())
-    }
-
-    pub fn stone(&self, coordinate: &Coordinate) -> Option<Color> {
-        match self.grid.get(coordinate.row, coordinate.column) {
-            None => None,
-            Some(val) => *val,
-        }
-    }
-
-    pub fn group(&self, coordinate: &Coordinate) -> Option<&Group> {
-        self.groups
-            .iter()
-            .find(|g| g.coordinates.contains(coordinate))
-    }
-
-    pub fn remove_group(&mut self, group: &Group) {
-        self.groups.retain(|g| g != group);
-        for coord in group.coordinates.iter() {
-            match self.grid.get_mut(coord.row, coord.column) {
-                None => (),
-                Some(v) => *v = None,
-            }
-        }
-    }
-
-    pub fn adjacent_groups(&self, group: &Group) -> Vec<Group> {
-        let adjacent_spaces = self.group_halo(group).into_iter();
-        println!("adjacent spaces: {:?}", adjacent_spaces);
-        let mut grps: Vec<Group> = Vec::new();
-
-        adjacent_spaces.for_each(|coord| match self.group(&coord) {
-            None => return,
-            Some(adj) => {
-                println!("group found: {:?}", adj.color);
-                if group.color == adj.color {
-                    return;
-                }
-                if grps.iter().any(|g| g.coordinates.contains(&coord)) {
-                    return;
-                }
-                grps.push(adj.clone());
-            }
-        });
-
-        grps
-    }
-
-    pub fn group_halo(&self, group: &Group) -> HashSet<Coordinate> {
-        group
-            .coordinates
-            .iter()
-            .map(|c| self.adjacencies(c))
-            .flatten()
-            .collect::<HashSet<Coordinate>>()
-    }
-
-    pub fn liberties(&self, group: &Group) -> usize {
-        self.group_halo(group)
-            .into_iter()
-            .filter(|c| self.stone(&c) == None)
-            .count()
-
-        // let adjacencies: HashSet<Coordinate> = self.adjacencies(group.coordinates.iter()).collect();
-        /*
-        println!("adjacencies: {:?}", adjacencies);
-        let opposing_spaces = adjacencies
-            .iter()
-            .filter(|coord| match self.grid.get(coord.row, coord.column) {
-                None => true,
-                Some(&None) => false,
-                Some(&Some(c)) => c != group.color,
-            })
-            .cloned()
-            .collect::<HashSet<Coordinate>>();
-        println!("opposition: {:?}", opposing_spaces);
-
-        adjacencies.len() - opposing_spaces.len()
-        */
-
-        /*
-        group
-            .adjacencies(self.size.width as u8 - 1, self.size.height as u8 - 1)
-            .into_iter()
-            .filter(|coordinate| self.stone(*coordinate).is_none())
-            .collect::<Vec<Coordinate>>()
-            .len()
-            */
-    }
-
-    pub fn adjacencies(&self, coordinate: &Coordinate) -> Vec<Coordinate> {
-        let mut v = Vec::new();
-        if coordinate.column > 0 {
-            v.push(Coordinate {
-                column: coordinate.column - 1,
-                row: coordinate.row,
-            });
-        }
-        if coordinate.row > 0 {
-            v.push(Coordinate {
-                column: coordinate.column,
-                row: coordinate.row - 1,
-            });
-        }
-        v.push(Coordinate {
-            column: coordinate.column + 1,
-            row: coordinate.row,
-        });
-        v.push(Coordinate {
-            column: coordinate.column,
-            row: coordinate.row + 1,
-        });
-        v.into_iter().filter(|c| self.within_board(c)).collect()
-    }
-
-    /*
-    pub fn adjacencies<'a>(
-        &'a self,
-        coordinates: impl Iterator<Item = &'a Coordinate> + 'a,
-    ) -> impl Iterator<Item = Coordinate> + 'a {
-        coordinates
-            .map(|coordinate| {
-                let mut v = Vec::new();
-                if coordinate.column > 0 {
-                    v.push(Coordinate {
-                        column: coordinate.column - 1,
-                        row: coordinate.row,
-                    });
-                }
-                if coordinate.row > 0 {
-                    v.push(Coordinate {
-                        column: coordinate.column,
-                        row: coordinate.row - 1,
-                    });
-                }
-                v.push(Coordinate {
-                    column: coordinate.column + 1,
-                    row: coordinate.row,
-                });
-                v.push(Coordinate {
-                    column: coordinate.column,
-                    row: coordinate.row + 1,
-                });
-                v
-            })
-            .flatten()
-            .filter(|coordinate| self.within_board(coordinate))
-    }
-    */
-
-    pub fn within_board(&self, coordinate: &Coordinate) -> bool {
-        coordinate.column < self.size.width && coordinate.row < self.size.height
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct Group {
-    color: Color,
-    coordinates: HashSet<Coordinate>,
-}
-
-/*
-impl Group {
-    pub fn adjacencies(&self, max_column: usize, max_row: usize) -> HashSet<Coordinate> {
-        self.coordinates
-            .iter()
-            .map(|stone| stone.adjacencies(max_column, max_row))
-            .flatten()
-            .collect()
-    }
-}
-*/
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    /* Two players (Black and White) take turns and Black plays first
-     * Stones are placed on the line intersections and not moved.
-     * A stone with no liberties is removed from the board.
-     * A group of stones of the same color share liberties.
-     * A stone at the edge of the board has only three liberties.
-     * A stone at the corner of the board has only two liberties.
-     * A stone may not be placed in a suicidal position.
-     * A stone placed in a suicidal position is legal if it captures other stones first.
-     */
-
-    fn with_example_board(test: impl FnOnce(Board)) {
-        let board = Board::from_coordinates(
-            vec![
-                (Coordinate { column: 3, row: 3 }, Color::White),
-                (Coordinate { column: 3, row: 4 }, Color::White),
-                /* */
-                (Coordinate { column: 8, row: 3 }, Color::Black),
-                (Coordinate { column: 9, row: 3 }, Color::Black),
-                (Coordinate { column: 9, row: 4 }, Color::Black),
-                /* */
-                (Coordinate { column: 15, row: 3 }, Color::White),
-                (Coordinate { column: 15, row: 4 }, Color::White),
-                (Coordinate { column: 15, row: 5 }, Color::White),
-                (Coordinate { column: 14, row: 4 }, Color::White),
-                /* */
-                (Coordinate { column: 3, row: 8 }, Color::White),
-                (Coordinate { column: 3, row: 9 }, Color::White),
-                (Coordinate { column: 4, row: 9 }, Color::White),
-                (Coordinate { column: 3, row: 10 }, Color::Black),
-                /* */
-                (Coordinate { column: 0, row: 0 }, Color::White),
-                (Coordinate { column: 1, row: 0 }, Color::White),
-                (Coordinate { column: 0, row: 1 }, Color::White),
-                /* */
-                (Coordinate { column: 9, row: 9 }, Color::White),
-                (Coordinate { column: 8, row: 9 }, Color::Black),
-                (Coordinate { column: 9, row: 8 }, Color::Black),
-                (Coordinate { column: 9, row: 10 }, Color::Black),
-                /* */
-                (Coordinate { column: 0, row: 17 }, Color::White),
-                (Coordinate { column: 1, row: 18 }, Color::White),
-                (Coordinate { column: 0, row: 18 }, Color::White),
-                (Coordinate { column: 0, row: 16 }, Color::Black),
-                (Coordinate { column: 1, row: 17 }, Color::Black),
-                /* */
-                (Coordinate { column: 4, row: 17 }, Color::Black),
-                (Coordinate { column: 5, row: 17 }, Color::Black),
-                (Coordinate { column: 6, row: 17 }, Color::Black),
-                (Coordinate { column: 4, row: 18 }, Color::Black),
-                (Coordinate { column: 6, row: 18 }, Color::Black),
-                (Coordinate { column: 3, row: 17 }, Color::White),
-                (Coordinate { column: 3, row: 18 }, Color::White),
-                (Coordinate { column: 4, row: 16 }, Color::White),
-                (Coordinate { column: 5, row: 16 }, Color::White),
-                (Coordinate { column: 6, row: 16 }, Color::White),
-                (Coordinate { column: 7, row: 17 }, Color::White),
-                (Coordinate { column: 7, row: 18 }, Color::White),
-            ]
-            .into_iter(),
-        );
-        test(board);
-    }
-
-    #[test]
-    fn it_gets_adjacencies_for_coordinate() {
-        let board = Board::new();
-        for column in 0..19 {
-            for row in 0..19 {
-                for coordinate in board.adjacencies(&Coordinate { column, row }) {
-                    assert!(
-                        board.within_board(&coordinate),
-                        "{} {}: {:?}",
-                        column,
-                        row,
-                        coordinate
-                    );
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn it_counts_individual_liberties() {
-        let board = Board::from_coordinates(
-            vec![
-                (Coordinate { column: 3, row: 3 }, Color::White),
-                (Coordinate { column: 0, row: 3 }, Color::White),
-                (Coordinate { column: 0, row: 0 }, Color::White),
-                (Coordinate { column: 18, row: 9 }, Color::Black),
-                (
-                    Coordinate {
-                        column: 18,
-                        row: 18,
-                    },
-                    Color::Black,
-                ),
-            ]
-            .into_iter(),
-        );
-        assert!(board.group(&Coordinate { column: 18, row: 3 }).is_none());
-        assert_eq!(
-            board
-                .group(&Coordinate { column: 3, row: 3 })
-                .map(|g| board.liberties(&g)),
-            Some(4)
-        );
-        assert_eq!(
-            board
-                .group(&Coordinate { column: 0, row: 3 })
-                .map(|g| board.liberties(&g)),
-            Some(3)
-        );
-        assert_eq!(
-            board
-                .group(&Coordinate { column: 0, row: 0 })
-                .map(|g| board.liberties(&g)),
-            Some(2)
-        );
-        assert_eq!(
-            board
-                .group(&Coordinate { column: 18, row: 9 })
-                .map(|g| board.liberties(&g)),
-            Some(3)
-        );
-        assert_eq!(
-            board
-                .group(&Coordinate {
-                    column: 18,
-                    row: 18
-                })
-                .map(|g| board.liberties(&g)),
-            Some(2)
-        );
-    }
-
-    #[test]
-    fn stones_share_liberties() {
-        with_example_board(|board: Board| {
-            let test_cases = vec![
-                (
-                    board.clone(),
-                    Coordinate { column: 0, row: 0 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![
-                            Coordinate { column: 0, row: 0 },
-                            Coordinate { column: 1, row: 0 },
-                            Coordinate { column: 0, row: 1 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(3),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 1, row: 0 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![
-                            Coordinate { column: 0, row: 0 },
-                            Coordinate { column: 1, row: 0 },
-                            Coordinate { column: 0, row: 1 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(3),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 9, row: 9 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![Coordinate { column: 9, row: 9 }].into_iter().collect(),
-                    }),
-                    Some(1),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 3, row: 4 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![
-                            Coordinate { column: 3, row: 3 },
-                            Coordinate { column: 3, row: 4 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(6),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 9, row: 3 },
-                    Some(Group {
-                        color: Color::Black,
-                        coordinates: vec![
-                            Coordinate { column: 8, row: 3 },
-                            Coordinate { column: 9, row: 3 },
-                            Coordinate { column: 9, row: 4 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(7),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 15, row: 4 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![
-                            Coordinate { column: 15, row: 3 },
-                            Coordinate { column: 15, row: 4 },
-                            Coordinate { column: 15, row: 5 },
-                            Coordinate { column: 14, row: 4 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(8),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 3, row: 9 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![
-                            Coordinate { column: 3, row: 8 },
-                            Coordinate { column: 3, row: 9 },
-                            Coordinate { column: 4, row: 9 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(6),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 0, row: 18 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![
-                            Coordinate { column: 0, row: 17 },
-                            Coordinate { column: 0, row: 18 },
-                            Coordinate { column: 1, row: 18 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(1),
-                ),
-                (
-                    board.clone(),
-                    Coordinate { column: 0, row: 17 },
-                    Some(Group {
-                        color: Color::White,
-                        coordinates: vec![
-                            Coordinate { column: 0, row: 17 },
-                            Coordinate { column: 0, row: 18 },
-                            Coordinate { column: 1, row: 18 },
-                        ]
-                        .into_iter()
-                        .collect(),
-                    }),
-                    Some(1),
-                ),
-            ];
-
-            println!("{}", board);
-            for (board, coordinate, group, liberties) in test_cases {
-                assert_eq!(board.group(&coordinate), group.as_ref());
-                assert_eq!(
-                    board.group(&coordinate).map(|g| board.liberties(&g)),
-                    liberties,
-                    "{:?}",
-                    coordinate
-                );
-            }
-        });
-    }
-
-    #[test]
-    fn it_finds_adjacent_groups() {
-        with_example_board(|mut board| {
-            println!("{}", board);
-            let group = board
-                .group(&Coordinate { column: 0, row: 0 })
-                .cloned()
-                .unwrap();
-            assert_eq!(board.adjacent_groups(&group), Vec::new());
-
-            let group = board
-                .group(&Coordinate { column: 3, row: 10 })
-                .cloned()
-                .unwrap();
-            assert_eq!(board.adjacent_groups(&group).len(), 1);
-        });
-    }
-
-    #[test]
-    fn surrounding_a_group_removes_it() {
-        with_example_board(|mut board| {
-            board.place_stone(Coordinate { column: 10, row: 9 }, Color::Black);
-            assert!(board.stone(&Coordinate { column: 9, row: 9 }).is_none());
-
-            board.place_stone(Coordinate { column: 2, row: 18 }, Color::Black);
-            assert!(board.stone(&Coordinate { column: 0, row: 18 }).is_none());
-            assert!(board.stone(&Coordinate { column: 1, row: 18 }).is_none());
-            assert!(board.stone(&Coordinate { column: 0, row: 17 }).is_none());
-            assert!(board.group(&Coordinate { column: 0, row: 18 }).is_none());
-
-            board.place_stone(Coordinate { column: 5, row: 18 }, Color::White);
-            assert!(board.stone(&Coordinate { column: 4, row: 17 }).is_none());
-            assert!(board.stone(&Coordinate { column: 5, row: 17 }).is_none());
-            assert!(board.stone(&Coordinate { column: 6, row: 17 }).is_none());
-            assert!(board.stone(&Coordinate { column: 4, row: 18 }).is_none());
-            assert!(board.stone(&Coordinate { column: 6, row: 18 }).is_none());
-        });
-    }
-
-    fn suicide_is_forbidden() {
-        assert!(false);
-    }
-
-    fn captures_preceed_self_capture() {
-        assert!(false);
-    }
-}

kifu/kifu-core/src/lib.rs

@@ -4,6 +4,3 @@ pub use api::{CoreApp, Request, Response};
 mod types;
 pub use types::{Color, Size};
 pub mod ui;
-
-mod board;
-pub use board::*;

kifu/kifu-core/src/types.rs

@@ -1,8 +1,5 @@
-use crate::{
+use crate::api::PlayStoneRequest;
-    api::PlayStoneRequest,
+use std::{collections::HashSet, time::Duration};
-    board::{Board, Coordinate},
-};
-use std::time::Duration;
 
 #[derive(Clone, Copy, Debug, PartialEq, Hash, Eq)]
 pub enum Color {
@@ -10,10 +7,10 @@ pub enum Color {
     White,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug)]
 pub struct Size {
-    pub width: usize,
+    pub width: u8,
-    pub height: usize,
+    pub height: u8,
 }
 
 impl Default for Size {
@@ -117,3 +114,377 @@ impl GameState {
         }
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Hash, Eq)]
+pub struct Coordinate {
+    pub column: u8,
+    pub row: u8,
+}
+
+impl Coordinate {
+    fn adjacencies(&self, max_column: u8, max_row: u8) -> impl Iterator<Item = Coordinate> {
+        vec![
+            if self.column > 0 {
+                Some(Coordinate {
+                    column: self.column - 1,
+                    row: self.row,
+                })
+            } else {
+                None
+            },
+            if self.row > 0 {
+                Some(Coordinate {
+                    column: self.column,
+                    row: self.row - 1,
+                })
+            } else {
+                None
+            },
+            if self.column < max_column {
+                Some(Coordinate {
+                    column: self.column + 1,
+                    row: self.row,
+                })
+            } else {
+                None
+            },
+            if self.row < max_row {
+                Some(Coordinate {
+                    column: self.column,
+                    row: self.row + 1,
+                })
+            } else {
+                None
+            },
+        ]
+        .into_iter()
+        .filter_map(|v| v)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Board {
+    pub size: Size,
+    pub spaces: Vec<Option<Color>>,
+}
+
+impl std::fmt::Display for Board {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        print!("   ");
+        for c in 'A'..'U' {
+            if c == 'I' {
+                continue;
+            }
+            print!(" {}", c);
+        }
+        println!("");
+
+        for row in 0..self.size.height {
+            print!(" {:2}", row);
+            for column in 0..self.size.width {
+                match self.stone(Coordinate { column, row }) {
+                    None => write!(f, " .")?,
+                    Some(Color::Black) => write!(f, " X")?,
+                    Some(Color::White) => write!(f, " O")?,
+                }
+            }
+            writeln!(f, "")?;
+        }
+        Ok(())
+    }
+}
+
+impl Board {
+    fn new() -> Self {
+        let mut spaces = Vec::new();
+        for _ in 0..19 * 19 {
+            spaces.push(None);
+        }
+        Self {
+            size: Size {
+                width: 19,
+                height: 19,
+            },
+            spaces,
+        }
+    }
+
+    fn from_coordinates(coordinates: impl Iterator<Item = (Coordinate, Color)>) -> Self {
+        let mut s = Self::new();
+        for (coordinate, color) in coordinates {
+            s.place_stone(coordinate, color);
+        }
+        s
+    }
+
+    pub fn place_stone(&mut self, coordinate: Coordinate, stone: Color) {
+        let addr = self.addr(coordinate.column, coordinate.row);
+        self.spaces[addr] = Some(stone);
+    }
+
+    pub fn stone(&self, coordinate: Coordinate) -> Option<Color> {
+        let addr = self.addr(coordinate.column, coordinate.row);
+        self.spaces[addr]
+    }
+
+    pub fn group(&self, coordinate: Coordinate) -> Option<Group> {
+        let mut visited: HashSet<Coordinate> = HashSet::new();
+
+        if let Some(color) = self.stone(coordinate) {
+            let mut fringes = coordinate
+                .adjacencies(self.size.width as u8 - 1, self.size.height as u8 - 1)
+                .collect::<Vec<Coordinate>>();
+            visited.insert(coordinate);
+
+            while let Some(coordinate) = fringes.pop() {
+                if self.stone(coordinate) == Some(color) {
+                    if !visited.contains(&coordinate) {
+                        fringes.append(
+                            &mut coordinate
+                                .adjacencies(self.size.width as u8 - 1, self.size.height as u8 - 1)
+                                .collect::<Vec<Coordinate>>(),
+                        );
+                        visited.insert(coordinate);
+                    }
+                }
+            }
+
+            Some(Group {
+                color,
+                coordinates: visited,
+            })
+        } else {
+            None
+        }
+    }
+
+    pub fn liberties(&self, group: &Group) -> usize {
+        group
+            .adjacencies(self.size.width as u8 - 1, self.size.height as u8 - 1)
+            .into_iter()
+            .filter(|coordinate| self.stone(*coordinate).is_none())
+            .collect::<Vec<Coordinate>>()
+            .len()
+    }
+
+    fn addr(&self, column: u8, row: u8) -> usize {
+        ((row as usize) * (self.size.width as usize) + (column as usize)) as usize
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Group {
+    color: Color,
+    coordinates: HashSet<Coordinate>,
+}
+
+impl Group {
+    fn adjacencies(&self, max_column: u8, max_row: u8) -> HashSet<Coordinate> {
+        self.coordinates
+            .iter()
+            .map(|stone| stone.adjacencies(max_column, max_row))
+            .flatten()
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    /* Two players (Black and White) take turns and Black plays first
+     * Stones are placed on the line intersections and not moved.
+     * A stone with no liberties is removed from the board.
+     * A group of stones of the same color share liberties.
+     * A stone at the edge of the board has only three liberties.
+     * A stone at the corner of the board has only two liberties.
+     * A stone may not be placed in a suicidal position.
+     * A stone placed in a suicidal position is legal if it captures other stones first.
+     */
+
+    #[test]
+    fn it_counts_individual_liberties() {
+        let board = Board::from_coordinates(
+            vec![
+                (Coordinate { column: 3, row: 3 }, Color::White),
+                (Coordinate { column: 0, row: 3 }, Color::White),
+                (Coordinate { column: 0, row: 0 }, Color::White),
+                (Coordinate { column: 18, row: 9 }, Color::Black),
+                (
+                    Coordinate {
+                        column: 18,
+                        row: 18,
+                    },
+                    Color::Black,
+                ),
+            ]
+            .into_iter(),
+        );
+        assert!(board.group(Coordinate { column: 18, row: 3 }).is_none());
+        assert_eq!(
+            board
+                .group(Coordinate { column: 3, row: 3 })
+                .map(|g| board.liberties(&g)),
+            Some(4)
+        );
+        assert_eq!(
+            board
+                .group(Coordinate { column: 0, row: 3 })
+                .map(|g| board.liberties(&g)),
+            Some(3)
+        );
+        assert_eq!(
+            board
+                .group(Coordinate { column: 0, row: 0 })
+                .map(|g| board.liberties(&g)),
+            Some(2)
+        );
+        assert_eq!(
+            board
+                .group(Coordinate { column: 18, row: 9 })
+                .map(|g| board.liberties(&g)),
+            Some(3)
+        );
+        assert_eq!(
+            board
+                .group(Coordinate {
+                    column: 18,
+                    row: 18
+                })
+                .map(|g| board.liberties(&g)),
+            Some(2)
+        );
+    }
+
+    #[test]
+    fn stones_share_liberties() {
+        let board = Board::from_coordinates(
+            vec![
+                (Coordinate { column: 3, row: 3 }, Color::White),
+                (Coordinate { column: 3, row: 4 }, Color::White),
+                (Coordinate { column: 8, row: 3 }, Color::Black),
+                (Coordinate { column: 9, row: 3 }, Color::Black),
+                (Coordinate { column: 9, row: 4 }, Color::Black),
+                (Coordinate { column: 15, row: 3 }, Color::White),
+                (Coordinate { column: 15, row: 4 }, Color::White),
+                (Coordinate { column: 15, row: 5 }, Color::White),
+                (Coordinate { column: 14, row: 4 }, Color::White),
+                (Coordinate { column: 3, row: 8 }, Color::White),
+                (Coordinate { column: 3, row: 9 }, Color::White),
+                (Coordinate { column: 4, row: 9 }, Color::White),
+                (Coordinate { column: 3, row: 10 }, Color::Black),
+            ]
+            .into_iter(),
+        );
+        println!("{}", board);
+        assert!(false);
+        let test_cases = vec![
+            (
+                board.clone(),
+                Coordinate { column: 3, row: 4 },
+                Some(Group {
+                    color: Color::White,
+                    coordinates: vec![
+                        Coordinate { column: 3, row: 3 },
+                        Coordinate { column: 3, row: 4 },
+                    ]
+                    .into_iter()
+                    .collect(),
+                }),
+                Some(6),
+            ),
+            (
+                board.clone(),
+                Coordinate { column: 9, row: 3 },
+                Some(Group {
+                    color: Color::Black,
+                    coordinates: vec![
+                        Coordinate { column: 8, row: 3 },
+                        Coordinate { column: 9, row: 3 },
+                        Coordinate { column: 9, row: 4 },
+                    ]
+                    .into_iter()
+                    .collect(),
+                }),
+                Some(7),
+            ),
+            (
+                board.clone(),
+                Coordinate { column: 15, row: 4 },
+                Some(Group {
+                    color: Color::White,
+                    coordinates: vec![
+                        Coordinate { column: 15, row: 3 },
+                        Coordinate { column: 15, row: 4 },
+                        Coordinate { column: 15, row: 5 },
+                        Coordinate { column: 14, row: 4 },
+                    ]
+                    .into_iter()
+                    .collect(),
+                }),
+                Some(8),
+            ),
+            (
+                board.clone(),
+                Coordinate { column: 3, row: 9 },
+                Some(Group {
+                    color: Color::White,
+                    coordinates: vec![
+                        Coordinate { column: 3, row: 8 },
+                        Coordinate { column: 3, row: 9 },
+                        Coordinate { column: 4, row: 9 },
+                    ]
+                    .into_iter()
+                    .collect(),
+                }),
+                Some(6),
+            ),
+        ];
+
+        for (board, coordinate, group, liberties) in test_cases {
+            assert_eq!(board.group(coordinate), group);
+            assert_eq!(
+                board.group(coordinate).map(|g| board.liberties(&g)),
+                liberties
+            );
+        }
+    }
+
+    #[test]
+    fn opposing_stones_reduce_liberties() {
+        let test_cases = vec![(
+            Board::from_coordinates(
+                vec![
+                    (Coordinate { column: 3, row: 3 }, Color::White),
+                    (Coordinate { column: 3, row: 4 }, Color::Black),
+                ]
+                .into_iter(),
+            ),
+            Coordinate { column: 3, row: 4 },
+            Some(6),
+        )];
+        println!("{}", test_cases[0].0);
+        for (board, coordinate, liberties) in test_cases {
+            assert_eq!(
+                board.group(coordinate).map(|g| board.liberties(&g)),
+                liberties
+            );
+        }
+    }
+
+    fn surrounding_a_stone_removes_it() {
+        assert!(false);
+    }
+
+    fn sorrounding_a_group_removes_it() {
+        assert!(false);
+    }
+
+    fn suicide_is_forbidden() {
+        assert!(false);
+    }
+
+    fn captures_preceed_self_capture() {
+        assert!(false);
+    }
+}

kifu/kifu-core/src/ui/playing_field.rs

@@ -1,7 +1,5 @@
-use crate::{
+use crate::types::Color;
-    types::{Color, GameState},
+use crate::{types::GameState, ui::types};
-    ui::types,
-};
 
 #[derive(Clone, Debug)]
 pub struct PlayingFieldView {

kifu/kifu-core/src/ui/types.rs

@@ -1,7 +1,7 @@
 use crate::types::{Color, Size};
 use crate::{
     api::{PlayStoneRequest, Request},
-    Board, Coordinate,
+    types::{Board, Coordinate},
 };
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -73,10 +73,10 @@ impl From<&Board> for BoardElement {
         let spaces: Vec<IntersectionElement> = (0..board.size.height)
             .map(|row| {
                 (0..board.size.width)
-                    .map(|column| match board.stone(&Coordinate { column, row }) {
+                    .map(|column| match board.stone(Coordinate { column, row }) {
                         Some(color) => IntersectionElement::Filled(StoneElement {
                             jitter: Jitter { x: 0, y: 0 },
-                            liberties: Some(0),
+                            liberties: None,
                             color,
                         }),
                         None => IntersectionElement::Empty(Request::PlayStoneRequest(

kifu/kifu-gtk/Cargo.lock

@@ -488,15 +488,6 @@ dependencies = [
  "system-deps",
 ]
 
-[[package]]
-name = "grid"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0634107a3a005070dd73e27e74ecb691a94e9e5ba7829f434db7fbf73a6b5c47"
-dependencies = [
- "no-std-compat",
-]
-
 [[package]]
 name = "gsk4"
 version = "0.6.3"
@@ -666,7 +657,6 @@ dependencies = [
 name = "kifu-core"
 version = "0.1.0"
 dependencies = [
- "grid",
  "tokio",
 ]
 
@@ -761,12 +751,6 @@ dependencies = [
  "getrandom",
 ]
 
-[[package]]
-name = "no-std-compat"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b93853da6d84c2e3c7d730d6473e8817692dd89be387eb01b94d7f108ecb5b8c"
-
 [[package]]
 name = "num-integer"
 version = "0.1.45"