fix: incorrect logic implementation with advances with cards

Author: maxblan

src/plugin/action/advance.rs

@@ -1,10 +1,6 @@
 use pyo3::{pyclass, pymethods, PyErr};
 
-use crate::plugin::{
-    errors::{CannotPlayCardError, MustBuyOneCardError, MustPlayCardError},
-    field::Field,
-    game_state::GameState,
-};
+use crate::plugin::{errors::HUIError, field::Field, game_state::GameState};
 
 use super::card::Card;
 
@@ -28,15 +24,13 @@ impl Advance {
     pub fn perform(&self, state: &mut GameState) -> Result<(), PyErr> {
         let mut player = state.clone_current_player();
 
-        player.advance_by(state, self.distance as isize, self.cards.clone())?;
+        player.advance_by(state, self.distance, self.cards.clone())?;
 
         let current_field = state.board.get_field(player.position).unwrap();
         if self.cards.is_empty() {
             match current_field {
                 Field::Market | Field::Hare => {
-                    return Err(MustPlayCardError::new_err(
-                        "Cannot enter field without any cards",
-                    ));
+                    return Err(HUIError::new_err("Cannot enter field without any cards"));
                 }
                 _ => {
                     state.update_player(player);
@@ -51,7 +45,7 @@ impl Advance {
         for card in &self.cards {
             match current_field {
                 Field::Market if card_bought => {
-                    return Err(MustBuyOneCardError::new_err("Only one card allowed to buy"));
+                    return Err(HUIError::new_err("Only one card allowed to buy"));
                 }
                 Field::Market => {
                     player.consume_carrots(state, 10)?;
@@ -61,22 +55,22 @@ impl Advance {
                 Field::Hare => {
                     if let Some(last) = last_card {
                         if !last.moves() {
-                            return Err(CannotPlayCardError::new_err("Card cannot be played"));
+                            return Err(HUIError::new_err("Card cannot be played"));
                         }
                     }
 
                     last_card = Some(card);
                     let mut remaining_cards = self.cards.clone();
 
-                    if let Some(position) = player.cards.iter().position(|c| c == card) {
+                    if let Some(position) = remaining_cards.iter().position(|c| c == card) {
                         remaining_cards.remove(position);
                     } else {
-                        return Err(CannotPlayCardError::new_err("Card not owned"));
+                        return Err(HUIError::new_err("Card not in list of cards"))?;
                     }
 
                     card.perform(state, remaining_cards)?;
                 }
-                _ => {}
+                _ => Err(HUIError::new_err("Card cannot be played on this field"))?,
             }
         }
 

src/plugin/action/card.rs

@@ -3,11 +3,7 @@ use std::mem::swap;
 use pyo3::*;
 
 use crate::plugin::{
-    errors::{CannotEnterFieldError, CannotPlayCardError, CardNotOwnedError},
-    field::Field,
-    game_state::GameState,
-    hare::Hare,
-    rules_engine::RulesEngine,
+    errors::HUIError, field::Field, game_state::GameState, hare::Hare, rules_engine::RulesEngine,
 };
 
 use super::Action;
@@ -37,10 +33,8 @@ impl Card {
         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(
+        RulesEngine::can_move_to(
             &state.board,
             distance,
             player,
@@ -64,7 +58,7 @@ impl Card {
         match self {
             Card::FallBack => {
                 if current.position < other.position {
-                    return Err(CannotPlayCardError::new_err(
+                    return Err(HUIError::new_err(
                         "You can only play this card if you are ahead of the other player",
                     ));
                 }
@@ -77,7 +71,7 @@ impl Card {
             }
             Card::HurryAhead => {
                 if current.position > other.position {
-                    return Err(CannotPlayCardError::new_err(
+                    return Err(HUIError::new_err(
                         "You can only play this card if you are behind the other player",
                     ));
                 }
@@ -90,14 +84,14 @@ impl Card {
                     .board
                     .get_previous_field(Field::Salad, state.board.track.len() - 1)
                     .ok_or_else(|| {
-                        CannotPlayCardError::new_err(
-                            "Unable to find the last lettuce field position",
-                        )
+                        HUIError::new_err("Unable to find the last lettuce field position")
                     })?;
 
-                if current.position < last_lettuce_position {
-                    return Err(CannotPlayCardError::new_err(
-                    "You can only play this card if you are standing in front of the last lettuce field",
+                if current.position > last_lettuce_position
+                    || other.position > last_lettuce_position
+                {
+                    return Err(HUIError::new_err(
+                    "You can only play this card if both players haven't passed the last lettuce field",
                 ));
                 }
 
@@ -108,9 +102,9 @@ impl Card {
                         (&current_last_move.action, &other_last_move.action)
                     {
                         if current_advance.cards.contains(&Card::SwapCarrots)
-                            && other_advance.cards.contains(&Card::SwapCarrots)
+                            || other_advance.cards.contains(&Card::SwapCarrots)
                         {
-                            return Err(CannotPlayCardError::new_err(
+                            return Err(HUIError::new_err(
                                 "You can only play this card if the last similar swap card was not used in one of the last two turns",
                             ));
                         }
@@ -129,10 +123,10 @@ impl Card {
         let field = state
             .board
             .get_field(current.position)
-            .ok_or_else(|| CannotEnterFieldError::new_err("Field not found"))?;
+            .ok_or_else(|| HUIError::new_err("Field not found"))?;
 
         if field != Field::Hare {
-            return Err(CannotPlayCardError::new_err(
+            return Err(HUIError::new_err(
                 "You can only play cards on the hare field",
             ));
         }
@@ -141,7 +135,7 @@ impl Card {
             .cards
             .iter()
             .position(|card| card == self)
-            .ok_or_else(|| CardNotOwnedError::new_err("Card not owned"))?;
+            .ok_or_else(|| HUIError::new_err("Card not owned"))?;
 
         self.play(state, &mut current, &mut other, remaining_cards)?;
 

src/plugin/board.rs

@@ -30,18 +30,16 @@ impl Board {
 
     /// Finds the previous occurrence of the specified field before the given index.
     pub fn get_previous_field(&self, field: Field, index: usize) -> Option<usize> {
-        if index == 0 {
-            None
-        } else {
-            (0..index)
-                .rev()
-                .find(|&i| self.track.get(i) == Some(&field))
-        }
+        self.track.iter().take(index).rposition(|&f| f == field)
     }
 
     /// Finds the next occurrence of the specified field after the given index.
     pub fn get_next_field(&self, field: Field, index: usize) -> Option<usize> {
-        (index + 1..self.track.len()).find(|&i| self.track.get(i) == Some(&field))
+        self.track
+            .iter()
+            .skip(index + 1)
+            .position(|&f| f == field)
+            .map(|i| i + index + 1)
     }
 
     pub fn __repr__(&self) -> String {

src/plugin/errors.rs

@@ -1,20 +1,3 @@
-use pyo3::{ exceptions::PyException, * };
+use pyo3::{exceptions::PyException, *};
 
-create_exception!(_socha, GoalConditionsError, PyException);
-create_exception!(_socha, NoSaladError, PyException);
-create_exception!(_socha, MissingCarrotsError, PyException);
-create_exception!(_socha, MustEatSaladError, PyException);
-create_exception!(_socha, CannotEnterFieldError, PyException);
-create_exception!(_socha, FieldOccupiedError, PyException);
-create_exception!(_socha, FieldNonexistentError, PyException);
-create_exception!(_socha, HedgehogOnlyBackwardsError, PyException);
-create_exception!(_socha, CannotMoveForwardError, PyException);
-create_exception!(_socha, CannotFallBackError, PyException);
-create_exception!(_socha, CannotEatSaladError, PyException);
-create_exception!(_socha, CannotExchangeCarrotsError, PyException);
-create_exception!(_socha, MustBuyOneCardError, PyException);
-create_exception!(_socha, MustPlayCardError, PyException);
-create_exception!(_socha, CardNotOwnedError, PyException);
-create_exception!(_socha, CannotPlayCardError, PyException);
-create_exception!(_socha, CannotPlayFallBackError, PyException);
-create_exception!(_socha, CannotPlayHurryAheadError, PyException);
+create_exception!(_socha, HUIError, PyException);

src/plugin/hare.rs

@@ -3,13 +3,8 @@ use std::fmt;
 use pyo3::*;
 
 use super::{
-    action::card::Card,
-    constants::PluginConstants,
-    errors::{CannotEnterFieldError, MissingCarrotsError},
-    field::Field,
-    game_state::GameState,
-    r#move::Move,
-    rules_engine::RulesEngine,
+    action::card::Card, constants::PluginConstants, errors::HUIError, field::Field,
+    game_state::GameState, r#move::Move, rules_engine::RulesEngine,
 };
 
 #[pyclass]
@@ -84,24 +79,24 @@ impl Hare {
     pub fn advance_by(
         &mut self,
         state: &mut GameState,
-        distance: isize,
+        distance: usize,
         cards: Vec<Card>,
     ) -> Result<(), PyErr> {
-        let needed_carrots = RulesEngine::calculates_carrots(distance.unsigned_abs());
+        let needed_carrots = RulesEngine::calculates_carrots(distance);
 
         if self.carrots - needed_carrots < 0 {
-            return Err(MissingCarrotsError::new_err("Not enough carrots"));
+            return Err(HUIError::new_err("Not enough carrots"));
         }
 
-        RulesEngine::can_advance_to(
+        RulesEngine::can_move_to(
             &state.board,
-            distance,
+            distance as isize,
             self,
             &state.clone_other_player(),
             cards,
         )?;
 
-        let new_position = (self.position as isize + distance) as usize;
+        let new_position = self.position + distance;
 
         self.carrots -= needed_carrots;
         self.position = new_position;
@@ -126,7 +121,7 @@ impl Hare {
             state.update_player(self.clone());
             Ok(())
         } else {
-            Err(MissingCarrotsError::new_err("Not enough carrots"))
+            Err(HUIError::new_err("Not enough carrots"))
         }
     }
 
@@ -160,7 +155,7 @@ impl Hare {
                 state.update_player(self.clone());
                 Ok(())
             }
-            None => Err(CannotEnterFieldError::new_err("Field not found")),
+            None => Err(HUIError::new_err("Field not found")),
         }
     }