Refactor with a Position2d struct

board-shared/src/board.rs

@@ -1,3 +1,4 @@
+use crate::position::Position2d;
 use crate::tile::Tile;
 
 pub const BOARD_SIZE: usize = 25;
@@ -16,38 +17,38 @@ impl Board {
         self.tiles[y * BOARD_SIZE + x] = Some(tile);
     }
 
-    pub fn difference(&self, other: &Board) -> Vec<(usize, usize)> {
+    pub fn difference(&self, other: &Board) -> Vec<Position2d> {
         let mut diff = Vec::new();
         for x in 0..BOARD_SIZE {
             for y in 0..BOARD_SIZE {
                 if self.get(x, y) != other.get(x, y) {
-                    diff.push((x, y));
+                    diff.push(Position2d::new(x, y));
                 }
             }
         }
         diff
     }
 
-    pub fn is_contiguous(positions: &[(usize, usize)]) -> Option<bool> {
+    pub fn is_contiguous(positions: &[Position2d]) -> Option<bool> {
         let mut it = positions.iter();
         let first = *it.next()?;
         let mut second = *it.next()?;
-        if first.0 == second.0 {
+        if first.x == second.x {
             // Vertical
-            for &(x, y) in it {
-                if x != first.0 || y != second.1 + 1 {
+            for &pos in it {
+                if pos.x != first.x || pos.y != second.y + 1 {
                     return Some(false);
                 }
-                second = (x, y);
+                second = pos;
             }
             Some(true)
-        } else if first.1 == second.1 {
+        } else if first.y == second.y {
             // Horizontal
-            for &(x, y) in it {
-                if y != first.1 || x != second.0 + 1 {
+            for &pos in it {
+                if pos.y != first.y || pos.y != second.y + 1 {
                     return Some(false);
                 }
-                second = (x, y);
+                second = pos;
             }
             Some(true)
         } else {
@@ -68,18 +69,27 @@ impl Default for Board {
 mod tests {
     use super::*;
 
+    fn positions(input: &[(usize, usize)]) -> Vec<Position2d> {
+        input
+            .iter()
+            .map(|(x, y)| Position2d::new(*x, *y))
+            .collect::<Vec<_>>()
+    }
+
     #[test]
     fn test_is_contiguous() {
         assert_eq!(Board::is_contiguous(&[]), None);
-        assert_eq!(Board::is_contiguous(&[(0, 0)]), None);
-        assert_eq!(Board::is_contiguous(&[(0, 0), (0, 1), (0, 2)]), Some(true));
+        assert_eq!(Board::is_contiguous(&positions(&[(0, 0)])), None);
         assert_eq!(
-            Board::is_contiguous(&[(1, 0), (2, 0), (3, 0), (4, 0)]),
+            Board::is_contiguous(&positions(&[(0, 0), (0, 1), (0, 2)])),
             Some(true)
         );
-        assert_eq!(Board::is_contiguous(&[(0, 0), (0, 1), (1, 3)]), Some(false));
         assert_eq!(
-            Board::is_contiguous(&[(0, 0), (0, 1), (0, 2), (1, 2)]),
+            Board::is_contiguous(&positions(&[(0, 0), (0, 1), (1, 3)])),
+            Some(false)
+        );
+        assert_eq!(
+            Board::is_contiguous(&positions(&[(0, 0), (0, 1), (0, 2), (1, 2)])),
             Some(false)
         );
     }