fmt

rbtying · Jan 15, 2025 · c5f4fe4 · c5f4fe4
1 parent 770e672
commit c5f4fe4
Show file tree

Hide file tree

Showing 5 changed files with 42 additions and 36 deletions.
diff --git a/core/src/game_state/mod.rs b/core/src/game_state/mod.rs
@@ -193,18 +193,20 @@ impl Deref for GameState {
 #[cfg(test)]
 mod tests {
     use crate::settings::{
-        AdvancementPolicy, FriendSelection, FriendSelectionPolicy, GameMode, GameModeSettings,
-        KittyTheftPolicy, BackToTwoSetting,
+        AdvancementPolicy, BackToTwoSetting, FriendSelection, FriendSelectionPolicy, GameMode,
+        GameModeSettings, KittyTheftPolicy,
     };
 
     use shengji_mechanics::player::Player;
-    use shengji_mechanics::types::{cards, Card, Number, PlayerID, Rank, FULL_DECK, Trump, Suit};
+    use shengji_mechanics::types::{cards, Card, Number, PlayerID, Rank, Suit, Trump, FULL_DECK};
 
     use crate::game_state::{initialize_phase::InitializePhase, play_phase::PlayPhase};
     use crate::message::MessageVariant;
 
-    use shengji_mechanics::trick::{PlayCards, TractorRequirements, ThrowEvaluationPolicy, Trick, TrickDrawPolicy};
     use shengji_mechanics::hands::Hands;
+    use shengji_mechanics::trick::{
+        PlayCards, ThrowEvaluationPolicy, TractorRequirements, Trick, TrickDrawPolicy,
+    };
 
     const R2: Rank = Rank::Number(Number::Two);
     const R3: Rank = Rank::Number(Number::Three);
@@ -667,7 +669,7 @@ mod tests {
         trick.play_cards(pc!(P3, &mut hands, &[S_2])).unwrap();
         trick.play_cards(pc!(P4, &mut hands, &[S_3])).unwrap();
 
-        // Neither side levels up, but the non-landlord team wins the final trick with 
+        // Neither side levels up, but the non-landlord team wins the final trick with
         // a single jack
         let _ = PlayPhase::compute_player_level_deltas(
             players.iter_mut(),
@@ -703,7 +705,7 @@ mod tests {
         trick.play_cards(pc!(P3, &mut hands, &[S_2])).unwrap();
         trick.play_cards(pc!(P4, &mut hands, &[S_3])).unwrap();
 
-        // The landlord team defends, but the non-landlord team wins the final trick with 
+        // The landlord team defends, but the non-landlord team wins the final trick with
         // a single jack
         let _ = PlayPhase::compute_player_level_deltas(
             players.iter_mut(),
@@ -743,7 +745,7 @@ mod tests {
         trick.play_cards(pc!(P3, &mut hands, &[S_2])).unwrap();
         trick.play_cards(pc!(P4, &mut hands, &[S_3])).unwrap();
 
-        // The non-landlord team advances and they win the final trick with 
+        // The non-landlord team advances and they win the final trick with
         // a single jack
         let _ = PlayPhase::compute_player_level_deltas(
             players.iter_mut(),

diff --git a/core/src/game_state/play_phase.rs b/core/src/game_state/play_phase.rs
@@ -8,13 +8,15 @@ use shengji_mechanics::deck::Deck;
 use shengji_mechanics::hands::Hands;
 use shengji_mechanics::player::Player;
 use shengji_mechanics::scoring::{compute_level_deltas, next_threshold_reachable, GameScoreResult};
-use shengji_mechanics::trick::{PlayCards, PlayCardsMessage, Trick, TrickEnded, TrickUnit, PlayedCards};
+use shengji_mechanics::trick::{
+    PlayCards, PlayCardsMessage, PlayedCards, Trick, TrickEnded, TrickUnit,
+};
 use shengji_mechanics::types::{Card, PlayerID, Rank, Trump};
 
 use crate::message::MessageVariant;
 use crate::settings::{
-    AdvancementPolicy, GameMode, KittyPenalty, MultipleJoinPolicy, PlayTakebackPolicy,
-    PropagatedState, ThrowPenalty, BackToTwoSetting,
+    AdvancementPolicy, BackToTwoSetting, GameMode, KittyPenalty, MultipleJoinPolicy,
+    PlayTakebackPolicy, PropagatedState, ThrowPenalty,
 };
 
 use crate::game_state::initialize_phase::InitializePhase;
@@ -365,7 +367,8 @@ impl PlayPhase {
     ) -> Vec<MessageVariant> {
         let mut msgs = vec![];
 
-        let should_go_back_to_two = Self::check_jacks_last_trick(last_trick, jack_variation, landlords_team, landlord.1);
+        let should_go_back_to_two =
+            Self::check_jacks_last_trick(last_trick, jack_variation, landlords_team, landlord.1);
 
         let result = players
             .map(|player| {
@@ -454,31 +457,31 @@ impl PlayPhase {
     }
 
     pub fn check_jacks_last_trick(
-        last_trick: Option<Trick>, 
-        jack_variation: BackToTwoSetting, 
+        last_trick: Option<Trick>,
+        jack_variation: BackToTwoSetting,
         landlords_team: &[PlayerID],
-        landlord_rank: Rank) -> bool {
+        landlord_rank: Rank,
+    ) -> bool {
         if !jack_variation.is_applicable(landlord_rank) {
-            return false
+            return false;
         }
 
         let last_trick = last_trick.unwrap();
         let TrickEnded {
-            winner: winner_pid,
-            ..
+            winner: winner_pid, ..
         } = last_trick.complete().unwrap();
 
         // In any jack variation, the rule can only applies if the non-landord team wins the
         // last trick
         if landlords_team.contains(&winner_pid) {
-            return false
+            return false;
         }
 
         let lt_played_cards = last_trick.played_cards();
-        let PlayedCards {
-            cards,
-            ..
-        } = lt_played_cards.iter().find(|pc| pc.id == winner_pid).unwrap();
+        let PlayedCards { cards, .. } = lt_played_cards
+            .iter()
+            .find(|pc| pc.id == winner_pid)
+            .unwrap();
 
         // In the jack variation, the last trick must be won with a single (trump) jack
         jack_variation.compute(cards)

diff --git a/core/src/interactive.rs b/core/src/interactive.rs
@@ -16,10 +16,10 @@ use shengji_mechanics::types::{Card, PlayerID, Rank};
 use crate::game_state::{initialize_phase::InitializePhase, GameState};
 use crate::message::MessageVariant;
 use crate::settings::{
-    AdvancementPolicy, FirstLandlordSelectionPolicy, FriendSelection, FriendSelectionPolicy,
-    GameModeSettings, GameShadowingPolicy, GameStartPolicy, GameVisibility, KittyBidPolicy,
-    KittyPenalty, KittyTheftPolicy, MultipleJoinPolicy, PlayTakebackPolicy, PropagatedState,
-    ThrowPenalty, BackToTwoSetting,
+    AdvancementPolicy, BackToTwoSetting, FirstLandlordSelectionPolicy, FriendSelection,
+    FriendSelectionPolicy, GameModeSettings, GameShadowingPolicy, GameStartPolicy, GameVisibility,
+    KittyBidPolicy, KittyPenalty, KittyTheftPolicy, MultipleJoinPolicy, PlayTakebackPolicy,
+    PropagatedState, ThrowPenalty,
 };
 pub struct InteractiveGame {
     state: GameState,
@@ -220,10 +220,7 @@ impl InteractiveGame {
                 info!(logger, "Setting hide throw halting player"; "hide_throw_halting_player" => hide_throw_halting_player);
                 state.set_hide_throw_halting_player(hide_throw_halting_player)?
             }
-            (
-                Action::SetJackVariation(jack_variation),
-                GameState::Initialize(ref mut state),
-            ) => {
+            (Action::SetJackVariation(jack_variation), GameState::Initialize(ref mut state)) => {
                 info!(logger, "Setting jack variation"; "jack_variation" => jack_variation);
                 state.set_jack_variation(jack_variation)?
             }

diff --git a/core/src/message.rs b/core/src/message.rs
@@ -14,9 +14,9 @@ use shengji_mechanics::types::{Card, PlayerID, Rank};
 
 use crate::game_state::play_phase::PlayerGameFinishedResult;
 use crate::settings::{
-    AdvancementPolicy, FirstLandlordSelectionPolicy, FriendSelectionPolicy, GameModeSettings,
-    GameShadowingPolicy, GameStartPolicy, GameVisibility, KittyBidPolicy, KittyPenalty,
-    KittyTheftPolicy, MultipleJoinPolicy, PlayTakebackPolicy, ThrowPenalty, BackToTwoSetting,
+    AdvancementPolicy, BackToTwoSetting, FirstLandlordSelectionPolicy, FriendSelectionPolicy,
+    GameModeSettings, GameShadowingPolicy, GameStartPolicy, GameVisibility, KittyBidPolicy,
+    KittyPenalty, KittyTheftPolicy, MultipleJoinPolicy, PlayTakebackPolicy, ThrowPenalty,
 };
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type")]

diff --git a/core/src/settings.rs b/core/src/settings.rs
@@ -227,13 +227,15 @@ impl BackToTwoSetting {
         match self {
             BackToTwoSetting::Disabled => false,
             BackToTwoSetting::SingleJack => landlord_rank == Rank::Number(Number::Jack),
-        } 
+        }
     }
 
     pub fn compute(&self, cards: &[Card]) -> bool {
         match self {
             BackToTwoSetting::Disabled => false,
-            BackToTwoSetting::SingleJack => cards.len() == 1 && cards[0].number() == Some(Number::Jack),
+            BackToTwoSetting::SingleJack => {
+                cards.len() == 1 && cards[0].number() == Some(Number::Jack)
+            }
         }
     }
 }
@@ -831,7 +833,9 @@ impl PropagatedState {
         jack_variation: BackToTwoSetting,
     ) -> Result<Vec<MessageVariant>, Error> {
         self.jack_variation = jack_variation;
-        Ok(vec![MessageVariant::JackVariation { variation: jack_variation }])
+        Ok(vec![MessageVariant::JackVariation {
+            variation: jack_variation,
+        }])
     }
 
     pub fn make_observer(&mut self, player_id: PlayerID) -> Result<Vec<MessageVariant>, Error> {