fix: Update hare movement logic to handle negative distances and card usage

Author: maxblan

logic.py

@@ -1,8 +1,10 @@
 # not all imports are currently used, but they might be in the future and it shows all available functionalities
-import logging
+import math
 import random
-from typing import List
+import time
+from typing import Optional, Tuple
 from socha import (
+    Field,
     GameState,
     Move
 )
@@ -16,9 +18,7 @@ class Logic(IClientHandler):
     # this method is called every time the server is requesting a new move
     # this method should always be implemented otherwise the client will be disqualified
     def calculate_move(self) -> Move:
-        moves: List[Move] = self.game_state.possible_moves()
-        move: Move = random.choice(moves)
-        return move
+        return random.choice(self.game_state.possible_moves())
 
     # this method is called every time the server has sent a new game state update
     # this method should be implemented to keep the game state up to date

src/plugin/action/advance.rs

@@ -28,7 +28,7 @@ impl Advance {
     pub fn perform(&self, state: &mut GameState) -> Result<(), PyErr> {
         let mut player = state.clone_current_player();
 
-        player.advance_by(state, self.distance)?;
+        player.advance_by(state, self.distance as isize, self.cards.clone())?;
 
         let current_field = state.board.get_field(player.position).unwrap();
         if self.cards.is_empty() {
@@ -66,7 +66,15 @@ impl Advance {
                     }
 
                     last_card = Some(card);
-                    card.perform(state)?;
+                    let mut remaining_cards = self.cards.clone();
+
+                    if let Some(position) = player.cards.iter().position(|c| c == card) {
+                        remaining_cards.remove(position);
+                    } else {
+                        return Err(CannotPlayCardError::new_err("Card not owned"));
+                    }
+
+                    card.perform(state, remaining_cards)?;
                 }
                 _ => {}
             }

src/plugin/action/card.rs

@@ -7,6 +7,7 @@ use crate::plugin::{
     field::Field,
     game_state::GameState,
     hare::Hare,
+    rules_engine::RulesEngine,
 };
 
 use super::Action;
@@ -29,11 +30,36 @@ impl Card {
         }
     }
 
+    fn move_to_field(
+        &self,
+        player: &mut Hare,
+        state: &mut GameState,
+        target_position: usize,
+        cards: Vec<Card>,
+    ) -> Result<(), PyErr> {
+        println!("target_position: {}", target_position);
+        println!("player.position: {}", player.position);
+        let distance = target_position as isize - player.position as isize;
+        RulesEngine::can_advance_to(
+            &state.board,
+            distance,
+            player,
+            &state.clone_other_player(),
+            cards,
+        )?;
+
+        player.position = (player.position as isize + distance) as usize;
+
+        state.update_player(player.clone());
+        Ok(())
+    }
+
     fn play(
         &self,
         state: &mut GameState,
         current: &mut Hare,
         other: &mut Hare,
+        remaining_cards: Vec<Card>,
     ) -> Result<(), PyErr> {
         match self {
             Card::FallBack => {
@@ -42,15 +68,21 @@ impl Card {
                         "You can only play this card if you are ahead of the other player",
                     ));
                 }
-                current.move_to_field(state, other.position - 1)?;
+                self.move_to_field(
+                    current,
+                    state,
+                    other.position.saturating_sub(1),
+                    remaining_cards,
+                )?;
             }
             Card::HurryAhead => {
                 if current.position > other.position {
                     return Err(CannotPlayCardError::new_err(
                         "You can only play this card if you are behind the other player",
                     ));
                 }
-                current.move_to_field(state, other.position + 1)?;
+                self.move_to_field(current, state, other.position + 1, remaining_cards)?;
+                // saturating add is here unnecessary because the board is finite and never larger than usize::MAX
             }
             Card::EatSalad => current.eat_salad(state)?,
             Card::SwapCarrots => {
@@ -90,7 +122,7 @@ impl Card {
         Ok(())
     }
 
-    pub fn perform(&self, state: &mut GameState) -> Result<(), PyErr> {
+    pub fn perform(&self, state: &mut GameState, remaining_cards: Vec<Card>) -> Result<(), PyErr> {
         let mut current = state.clone_current_player();
         let mut other = state.clone_other_player();
 
@@ -109,9 +141,9 @@ impl Card {
             .cards
             .iter()
             .position(|card| card == self)
-            .ok_or_else(|| CardNotOwnedError::new_err(""))?;
+            .ok_or_else(|| CardNotOwnedError::new_err("Card not owned"))?;
 
-        self.play(state, &mut current, &mut other)?;
+        self.play(state, &mut current, &mut other, remaining_cards)?;
 
         current.cards.remove(index);
 

src/plugin/hare.rs

@@ -81,23 +81,33 @@ impl Hare {
         self.carrots <= 10 && self.salads == 0
     }
 
-    pub fn advance_by(&mut self, state: &mut GameState, distance: usize) -> Result<(), PyErr> {
-        let new_position = self.position + distance;
+    pub fn advance_by(
+        &mut self,
+        state: &mut GameState,
+        distance: isize,
+        cards: Vec<Card>,
+    ) -> Result<(), PyErr> {
+        let needed_carrots = RulesEngine::calculates_carrots(distance.unsigned_abs());
+
+        if self.carrots - needed_carrots < 0 {
+            return Err(MissingCarrotsError::new_err("Not enough carrots"));
+        }
 
         RulesEngine::can_advance_to(
             &state.board,
-            new_position,
+            distance,
             self,
             &state.clone_other_player(),
+            cards,
         )?;
 
-        let needed_carrots = RulesEngine::calculates_carrots(distance);
+        let new_position = (self.position as isize + distance) as usize;
 
         self.carrots -= needed_carrots;
         self.position = new_position;
 
         state.update_player(self.clone());
-        
+
         Ok(())
     }
 
@@ -128,23 +138,6 @@ impl Hare {
         Ok(())
     }
 
-    pub fn move_to_field(
-        &mut self,
-        state: &mut GameState,
-        new_position: usize,
-    ) -> Result<(), PyErr> {
-        RulesEngine::can_advance_to(
-            &state.board,
-            new_position,
-            self,
-            &state.clone_other_player(),
-        )?;
-        self.position = new_position;
-
-        state.update_player(self.clone());
-        Ok(())
-    }
-
     pub fn get_fall_back(&self, state: &GameState) -> Option<usize> {
         match state
             .board

src/plugin/rules_engine.rs

@@ -6,7 +6,7 @@ use crate::plugin::errors::{
 };
 
 use super::{
-    action::{eat_salad::EatSalad, Action},
+    action::{card::Card, eat_salad::EatSalad, Action},
     board::Board,
     errors::{CannotEnterFieldError, NoSaladError},
     field::Field,
@@ -95,26 +95,23 @@ impl RulesEngine {
     #[staticmethod]
     pub fn can_advance_to(
         board: &Board,
-        distance: usize,
+        distance: isize,
         player: &Hare,
         other_player: &Hare,
+        cards: Vec<Card>,
     ) -> Result<(), PyErr> {
         if distance == 0 {
             return Err(CannotEnterFieldError::new_err(
                 "Advance distance cannot be 0",
             ));
         }
 
-        let new_position = player.position + distance;
+        let new_position = (player.position as isize + distance) as usize;
 
         if new_position == 0 {
             return Err(CannotEnterFieldError::new_err("Cannot jump to position 0"));
         }
 
-        if player.carrots - Self::calculates_carrots(distance) < 0 {
-            return Err(MissingCarrotsError::new_err("Not enough carrots"));
-        }
-
         Self::has_to_eat_salad(board, player)?;
 
         let field = board
@@ -131,7 +128,7 @@ impl RulesEngine {
             )),
             Field::Salad if player.salads > 0 => Ok(()),
             Field::Salad => Err(FieldOccupiedError::new_err("Field is occupied by opponent")),
-            Field::Hare if !player.cards.is_empty() => Ok(()),
+            Field::Hare if !cards.is_empty() => Ok(()),
             Field::Hare => Err(CardNotOwnedError::new_err("No card to play")),
             Field::Market if player.carrots >= 10 => Ok(()),
             Field::Market => Err(MissingCarrotsError::new_err("Not enough carrots")),

src/plugin/test/card_test.rs

@@ -43,7 +43,9 @@ mod tests {
     fn test_fallback_card() {
         let mut state = create_test_game_state();
         let fallback_card = Card::FallBack;
-        assert!(fallback_card.perform(&mut state).is_ok());
+        assert!(fallback_card
+            .perform(&mut state, vec![Card::EatSalad, Card::SwapCarrots])
+            .is_ok());
         let current_player = state.clone_current_player();
         assert_eq!(current_player.position, 2);
     }
@@ -52,8 +54,8 @@ mod tests {
     fn test_hurryahead_card() {
         let mut state = create_test_game_state();
         state.turn = 1;
-        let hurry_ahead_card = Card::HurryAhead;
-        assert!(hurry_ahead_card.perform(&mut state).is_ok());
+        let hurry_ahead_card: Card = Card::HurryAhead;
+        assert!(hurry_ahead_card.perform(&mut state, vec![]).is_ok());
         let current_player = state.clone_current_player();
         assert_eq!(current_player.position, 7);
     }
@@ -62,7 +64,9 @@ mod tests {
     fn test_eatsalad_card() {
         let mut state = create_test_game_state();
         let eat_salad_card = Card::EatSalad;
-        assert!(eat_salad_card.perform(&mut state).is_ok());
+        assert!(eat_salad_card
+            .perform(&mut state, vec![Card::FallBack, Card::SwapCarrots])
+            .is_ok());
         let current_player = state.clone_current_player();
         assert_eq!(current_player.salads, 2);
     }
@@ -71,7 +75,9 @@ mod tests {
     fn test_swapcarrots_card() {
         let mut state = create_test_game_state();
         let swap_carrots_card = Card::SwapCarrots;
-        assert!(swap_carrots_card.perform(&mut state).is_ok());
+        assert!(swap_carrots_card
+            .perform(&mut state, vec![Card::FallBack, Card::EatSalad])
+            .is_ok());
         let current_player = state.clone_current_player();
         let other_player = state.clone_other_player();
         assert_eq!(current_player.carrots, 60);
@@ -83,7 +89,7 @@ mod tests {
         let mut state = create_test_game_state();
         state.turn = 1;
         let card_not_owned = Card::FallBack;
-        let result = card_not_owned.perform(&mut state);
+        let result = card_not_owned.perform(&mut state, vec![Card::HurryAhead]);
         assert!(result.is_err());
     }
 
@@ -94,7 +100,7 @@ mod tests {
         let mut current_player = state.clone_current_player();
         current_player.position = 1;
         state.update_player(current_player);
-        let result = card.perform(&mut state);
+        let result = card.perform(&mut state, vec![Card::EatSalad, Card::SwapCarrots]);
         assert!(result.is_err());
     }
 
@@ -103,7 +109,7 @@ mod tests {
         let mut state = create_test_game_state();
         let invalid_card = Card::FallBack;
         state.board.track.clear();
-        let result = invalid_card.perform(&mut state);
+        let result = invalid_card.perform(&mut state, vec![Card::EatSalad, Card::SwapCarrots]);
         assert!(result.is_err());
     }
 }

src/plugin/test/rules_test.rs

@@ -77,14 +77,14 @@ mod tests {
         let mut player_one = create_player(TeamEnum::One, 0);
         let player_two = create_player(TeamEnum::Two, 2);
 
-        assert!(RulesEngine::can_advance_to(&board, 3, &player_one, &player_two).is_ok());
+        assert!(RulesEngine::can_advance_to(&board, 3, &player_one, &player_two, vec![Card::FallBack]).is_ok());
 
-        assert!(RulesEngine::can_advance_to(&board, 2, &player_one, &player_two).is_err());
+        assert!(RulesEngine::can_advance_to(&board, 2, &player_one, &player_two, vec![]).is_err());
 
         player_one.carrots = 1;
-        assert!(RulesEngine::can_advance_to(&board, 5, &player_one, &player_two).is_err());
+        assert!(RulesEngine::can_advance_to(&board, 5, &player_one, &player_two, vec![]).is_err());
 
         player_one.cards = vec![];
-        assert!(RulesEngine::can_advance_to(&board, 6, &player_one, &player_two).is_err());
+        assert!(RulesEngine::can_advance_to(&board, 6, &player_one, &player_two, vec![]).is_err());
     }
 }