Move rules were incorrectly/incompletely implemented

1 files changed, 117 insertions, 48 deletions

diff --git a/src/game.rs b/src/game.rs
index 1d61732..2922121 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -228,7 +228,7 @@ impl GameState {
         player: Player,
         pos: &Position,
         stone: Stone,
-    ) -> Result<GameState, String> {
+    ) -> Result<(Vec<Position>, GameState), String> {
         if let Err(e) = self.is_legal_place(player, pos, stone) {
             return Err(e);
         }
@@ -256,7 +256,7 @@ impl GameState {
                 }
             }
         }
-        Ok(copy)
+        Ok((vec![pos.clone()], copy))
     }
 
     fn is_legal_move(
@@ -268,37 +268,70 @@ impl GameState {
     ) -> Result<(), String> {
         if self.within_bounds(pos) {
             /* Rules for moving a stack:
-            0. There are stones
-            1. Top stone belongs to player
-            2. Zero or One stones dropped on starting square
-            3. Total number of stones moved does not exceed the carry capacity
-            4. Direction does not contain a capstone
-            5. Wall may only appear on last spot if it's capstone alone that covers
-            6. All stones are used up before then end of the board is met
+            - There are stones
+            - Drops have been specified
+            - Must actually move at least one stone
+            - Top stone belongs to player
+            - Zero or more dropped on starting square
+            - One or more on each subsequent square
+            - Total number of stones moved does not exceed the carry capacity
+            - Moved the entire stack (up to the carry capacity)
+            - Direction does not contain a capstone
+            - Wall may only appear on last spot if it's capstone alone that covers
+            - All stones are used up before then end of the board is met
              */
             if let Some(stack) = &self.board.get(self.pos_to_idx(pos)) {
-                if stack.len() == 0 {
+                let stack_len = stack.len();
+                let drops_len = drops.len();
+
+                if stack_len == 0 {
                     return Err(format!("{} has no stones to move.", pos));
-                } else if drops.len() == 0 {
+                };
+
+                if drops_len == 0 {
                     return Err(String::from(
                         "A drop sequence for must be specified for a move.",
                     ));
-                } else if stack[0].player != player {
-                    return Err(format!(
-                        "{} may not move the stack at {} as it belongs to {}.",
-                        player, pos, stack[0].player
+                };
+
+                if drops_len == 1 && drops[0] == 1 {
+                    return Err(String::from(
+                        "A valid move must change the position of at least a single stone.",
                     ));
-                } else if drops[0] > 1 {
+                }
+
+                if stack[stack_len - 1].player != player {
                     return Err(format!(
-                        "A move may only drop 0 or 1 stones at it's origin square."
+                        "{} may not move the stack at {} as it belongs to {}.",
+                        player,
+                        pos,
+                        stack[stack_len - 1].player
                     ));
-                // Do the sum in u32 just in case ?
-                } else if drops.iter().map(|&d| d as u32).sum::<u32>() > self.size as u32 {
+                };
+
+                for i in 0..drops_len {
+                    if i > 0 && drops[i] == 0 {
+                        return Err(String::from(
+                            "A move may not drop 0 stones past the first square.",
+                        ));
+                    }
+                }
+
+                let num_dropped = drops.iter().map(|&d| d as usize).sum::<usize>();
+                let carry_capacity = self.size as usize;
+                if num_dropped > carry_capacity {
                     return Err(format!(
-                        "A move may not exceed the carry limit of {} stones.",
+                        "A move may not exceed the carry capacity of {} stones.",
                         self.size
                     ));
                 }
+
+                if num_dropped != std::cmp::max(carry_capacity, stack_len) {
+                    return Err(String::from(
+                        "A move must effect the whole stack, up to the carry limit.",
+                    ));
+                }
+
                 let mut steps: usize = drops.len() - 1;
                 let cap: bool = stack[0].stone == Stone::Capstone;
                 let mut pos_new = Position { x: pos.x, y: pos.y };
@@ -309,8 +342,8 @@ impl GameState {
                         match direction {
                             Direction::Up => pos_new.y + 1 >= self.size,
                             Direction::Down => pos_new.y == 0,
-                            Direction::Left => pos_new.x + 1 >= self.size,
-                            Direction::Right => pos_new.x == 0,
+                            Direction::Left => pos_new.x == 0,
+                            Direction::Right => pos_new.x + 1 >= self.size,
                         }
                     } {
                         return Err(String::from("A move may not extend past the board."));
@@ -318,8 +351,8 @@ impl GameState {
                         match direction {
                             Direction::Up => pos_new.y += 1,
                             Direction::Down => pos_new.y -= 1,
-                            Direction::Left => pos_new.x += 1,
-                            Direction::Right => pos_new.x -= 1,
+                            Direction::Left => pos_new.x -= 1,
+                            Direction::Right => pos_new.x += 1,
                         }
                         if let Some(stack) = &self.board.get(self.pos_to_idx(&pos_new)) {
                             if stack.len() > 0 {
@@ -365,30 +398,53 @@ impl GameState {
         pos: &Position,
         direction: Direction,
         drops: &Vec<u8>,
-    ) -> Result<GameState, String> {
+    ) -> Result<(Vec<Position>, GameState), String> {
         if let Err(e) = self.is_legal_move(player, pos, direction, drops) {
             return Err(e);
         }
 
         let mut copy = self.copy();
-        let mut pos_new = Position { x: pos.x, y: pos.y };
+        let mut pos_vec: Vec<Position> = vec![pos.clone()];
+
+        let idx = copy.pos_to_idx(&pos);
         let stack: &Stack = &self.board[self.pos_to_idx(pos)];
 
-        let mut k = 0;
-        for &d in drops {
-            let idx = copy.pos_to_idx(&pos_new);
-            for i in 0..d {
-                copy.board[idx].push(stack[(k + i) as usize]);
+        copy.board[idx].clear();
+
+        let num_drops = drops.len();
+        let mut offset = 0;
+        for drop_idx in 0..num_drops {
+            let pos = pos_vec[pos_vec.len() - 1];
+            let idx = copy.pos_to_idx(&pos);
+            let num = drops[drop_idx];
+
+            for i in 0..num {
+                copy.board[idx].push(stack[(offset + i) as usize]);
+            }
+            offset += num;
+
+            if drop_idx + 1 < num_drops {
+                pos_vec.push(match direction {
+                    Direction::Up => Position {
+                        x: pos.x,
+                        y: pos.y + 1,
+                    },
+                    Direction::Down => Position {
+                        x: pos.x,
+                        y: pos.y - 1,
+                    },
+                    Direction::Left => Position {
+                        x: pos.x - 1,
+                        y: pos.y,
+                    },
+                    Direction::Right => Position {
+                        x: pos.x + 1,
+                        y: pos.y,
+                    },
+                });
             }
-            k += d;
-            match direction {
-                Direction::Up => pos_new.y += 1,
-                Direction::Down => pos_new.y -= 1,
-                Direction::Left => pos_new.x -= 1,
-                Direction::Right => pos_new.x += 1,
-            };
         }
-        Ok(copy)
+        Ok((pos_vec, copy))
     }
 }
 
@@ -449,6 +505,14 @@ impl Game {
         self.current_player
     }
 
+    pub fn query_stone_owner(&self) -> Player {
+        match self.turn_order {
+            TurnOrder::BlackPlacesWhite => Player::White,
+            TurnOrder::WhitePlacesBlack => Player::Black,
+            TurnOrder::Normal => self.current_player,
+        }
+    }
+
     // pub fn query_action(&self, turn: u16) -> Option<&Action> {
     //     self.actions.get(turn as usize)
     // }
@@ -459,15 +523,15 @@ impl Game {
 
     pub fn query_action_lines(&self) -> String {
         let mut result = String::new();
-        let mut newline = false;
+        let mut newline = true;
         result += "0. ";
         for i in 0..self.actions.len() {
-            if newline {
+            if i > 1 && newline {
                 // TODO: Is placing the opponent's first stone the zeroeth action?
                 result += &format!("{}. ", i);
             }
             result += &format!("{} ", self.actions[i]);
-            if !newline {
+            if i > 0 && !newline {
                 result.push('\n');
             }
             newline = !newline;
@@ -475,7 +539,7 @@ impl Game {
         result
     }
 
-    pub fn perform_action(&mut self, act: Action) -> Result<(), String> {
+    pub fn perform_action(&mut self, act: Action) -> Result<Vec<Position>, String> {
         let maybe_state = self.states.last();
         if maybe_state.is_none() {
             return Err(String::from("Internal error: cannot find last game state"));
@@ -528,19 +592,24 @@ impl Game {
 
         match new_state_either {
             Err(e) => return Err(e),
-            Ok(new_state) => {
+            Ok((pos_vec, new_state)) => {
                 self.states.push(new_state);
                 self.actions.push(act);
-                self.current_player = match self.current_player {
-                    Player::Black => Player::White,
-                    Player::White => Player::Black,
+                self.current_player = match self.turn_order {
+                    TurnOrder::BlackPlacesWhite => Player::White,
+                    TurnOrder::WhitePlacesBlack => Player::White,
+                    TurnOrder::Normal => match self.current_player {
+                        Player::Black => Player::White,
+                        Player::White => Player::Black,
+                    },
                 };
+
                 self.turn_order = match self.turn_order {
                     TurnOrder::BlackPlacesWhite => TurnOrder::WhitePlacesBlack,
                     TurnOrder::WhitePlacesBlack => TurnOrder::Normal,
                     TurnOrder::Normal => TurnOrder::Normal,
                 };
-                return Ok(());
+                return Ok(pos_vec);
             }
         }
     }