fix: hare movement logic and error handling

Author: maxblan

src/plugin/hare.rs

@@ -5,7 +5,7 @@ use pyo3::*;
 use super::{
     action::card::Card,
     constants::PluginConstants,
-    errors::{CannotEnterFieldError, FieldNonexistentError, MissingCarrotsError, NoSaladError},
+    errors::{CannotEnterFieldError, MissingCarrotsError},
     field::Field,
     game_state::GameState,
     r#move::Move,
@@ -82,20 +82,22 @@ impl Hare {
     }
 
     pub fn advance_by(&mut self, state: &mut GameState, distance: usize) -> Result<(), PyErr> {
-        RulesEngine::can_advance_to(&state.board, distance, self, &state.clone_other_player())?;
+        let new_position = self.position + distance;
+        RulesEngine::can_advance_to(
+            &state.board,
+            new_position,
+            self,
+            &state.clone_other_player(),
+        )?;
 
-        let carrots = RulesEngine::calculates_carrots(distance);
+        let needed_carrots = RulesEngine::calculates_carrots(distance);
 
-        if self.carrots - carrots < 0 {
+        if self.carrots - needed_carrots < 0 {
             return Err(MissingCarrotsError::new_err("Not enough carrots"));
         }
 
-        if self.position.checked_sub(distance).is_none() {
-            return Err(FieldNonexistentError::new_err("Cannot go on this field"));
-        }
-
-        self.carrots -= carrots;
-        self.position += distance;
+        self.carrots -= needed_carrots;
+        self.position = new_position;
 
         state.update_player(self.clone());
         Ok(())
@@ -121,9 +123,8 @@ impl Hare {
     }
 
     pub fn eat_salad(&mut self, state: &mut GameState) -> Result<(), PyErr> {
-        if self.salads < 1 {
-            return Err(NoSaladError::new_err("Not enough salads"));
-        }
+        RulesEngine::can_eat_salad(&state.board, self)?;
+
         self.salads -= 1;
         self.carrots += if self.is_ahead(state) { 10 } else { 30 };
 
@@ -162,6 +163,8 @@ impl Hare {
     pub fn fall_back(&mut self, state: &mut GameState) -> Result<(), PyErr> {
         match self.get_fall_back(state) {
             Some(i) => {
+                RulesEngine::has_to_eat_salad(&state.board, self)?;
+                
                 self.carrots += 10 * ((self.position - i) as i32);
                 self.position = i;
 

src/plugin/rules_engine.rs

@@ -6,7 +6,11 @@ use crate::plugin::errors::{
 };
 
 use super::{
-    action::Action, board::Board, errors::CannotEnterFieldError, field::Field, hare::Hare,
+    action::{eat_salad::EatSalad, Action},
+    board::Board,
+    errors::{CannotEnterFieldError, NoSaladError},
+    field::Field,
+    hare::Hare,
     r#move::Move,
 };
 
@@ -17,34 +21,77 @@ pub struct RulesEngine;
 impl RulesEngine {
     #[staticmethod]
     pub fn calculates_carrots(distance: usize) -> i32 {
-        let distancce_i32: i32 = distance.try_into().unwrap();
-        (distancce_i32 * (distancce_i32 + 1)) / 2
+        let distance_i32: i32 = distance.try_into().unwrap();
+        (distance_i32 * (distance_i32 + 1)) / 2
     }
 
     #[staticmethod]
-    pub fn can_exchange_carrots(board: &Board, player: &Hare, count: i32) -> Result<bool, PyErr> {
+    pub fn can_exchange_carrots(board: &Board, player: &Hare, count: i32) -> Result<(), PyErr> {
         match board.get_field(player.position) {
-            Some(f) => {
-                Ok(f == Field::Carrots && (count == 10 || (count == -10 && player.carrots >= 10)))
+            Some(Field::Carrots) => {
+                if count != 10 && count != -10 {
+                    return Err(MissingCarrotsError::new_err(
+                        "You can only exchange 10 carrots",
+                    ));
+                }
+                if count == -10 && player.carrots < 10 {
+                    return Err(MissingCarrotsError::new_err("Not enough carrots"));
+                }
+                Ok(())
             }
+            Some(_) => Err(CannotEnterFieldError::new_err(
+                "Field is not a carrot field",
+            )),
             None => Err(CannotEnterFieldError::new_err("Field not found")),
         }
     }
 
     #[staticmethod]
-    pub fn can_eat_salad(board: &Board, player: &Hare) -> Result<bool, PyErr> {
+    pub fn can_eat_salad(board: &Board, player: &Hare) -> Result<(), PyErr> {
+        if player.salads < 1 {
+            return Err(NoSaladError::new_err("No salad to eat"));
+        }
+
         match board.get_field(player.position) {
-            Some(Field::Salad) => Ok(!matches!(
-                player.last_move,
-                Some(Move {
-                    action: Action::EatSalad(_)
-                })
+            Some(Field::Salad)
+                if !matches!(
+                    player.last_move,
+                    Some(Move {
+                        action: Action::EatSalad(_)
+                    })
+                ) =>
+            {
+                Ok(())
+            }
+            Some(Field::Salad) => Err(CannotEnterFieldError::new_err(
+                "Cannot eat salad twice in a row",
             )),
-            Some(_) => Ok(false),
+            Some(_) => Err(CannotEnterFieldError::new_err("Field is not a salad")),
             None => Err(CannotEnterFieldError::new_err("Field not found")),
         }
     }
 
+    #[staticmethod]
+    pub fn has_to_eat_salad(board: &Board, player: &Hare) -> Result<(), PyErr> {
+        match board.get_field(player.position) {
+            Some(Field::Salad) => {
+                if player.last_move
+                    != Some(Move {
+                        action: Action::EatSalad(EatSalad::new()),
+                    })
+                {
+                    Err(CannotEnterFieldError::new_err(
+                        "Cannot advance without eating salad",
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            Some(_) => Ok(()),
+            None => Ok(()),
+        }
+    }
+
     #[staticmethod]
     pub fn can_advance_to(
         board: &Board,
@@ -56,6 +103,8 @@ impl RulesEngine {
             return Err(CannotEnterFieldError::new_err("Cannot jump to position 0"));
         }
 
+        Self::has_to_eat_salad(board, player)?;
+
         let field = match board.get_field(new_position) {
             Some(f) => f,
             None => {

src/plugin/test/rules_test.rs

@@ -49,21 +49,17 @@ mod tests {
 
         let result = RulesEngine::can_exchange_carrots(&board, &player, 10);
         assert!(result.is_ok());
-        assert!(result.unwrap());
 
         player.carrots = 5;
         let result = RulesEngine::can_exchange_carrots(&board, &player, -10);
-        assert!(result.is_ok());
-        assert!(!result.unwrap());
+        assert!(result.is_err());
 
         player.carrots = 10;
         let result = RulesEngine::can_exchange_carrots(&board, &player, -10);
         assert!(result.is_ok());
-        assert!(result.unwrap());
 
         let result = RulesEngine::can_exchange_carrots(&board, &player, 5);
-        assert!(result.is_ok());
-        assert!(!result.unwrap());
+        assert!(result.is_err());
     }
 
     #[test]
@@ -73,7 +69,6 @@ mod tests {
 
         let result = RulesEngine::can_eat_salad(&board, &player);
         assert!(result.is_ok());
-        assert!(result.unwrap());
     }
 
     #[test]