Game incorrectly treats any other tractor of greater or equal length as preventing a tractor-throw about shengji

[rbtying]

Interesting -- it shouldn't matter that Lincoln has 4 cards, in this case. Most likely there is a bug where the three-deck KKQQ vs. AA throw detection isn't working right... will look into it

[rbtying]

    fn test_play_throw_tractor_extra_cards() {
        let mut hands = Hands::new(vec![P1, P2, P3, P4], Number::Four);
        hands.add(P1, vec![S_Q, S_Q, S_K, S_K, S_A]).unwrap();
        hands.add(P2, vec![S_2, S_3, S_3, S_5, S_3]).unwrap();
        hands.add(P3, vec![S_A, S_A, H_3, H_3, H_3]).unwrap();
        hands.add(P4, vec![H_3, H_3, H_3, H_3, H_3]).unwrap();
        let mut trick = Trick::new(TRUMP, vec![P1, P2, P3, P4]);
        trick
            .play_cards(P1, &mut hands, &[S_Q, S_Q, S_K, S_K, S_A])
            .unwrap();
        trick.play_cards(P2, &mut hands, &[S_2, S_3, S_3, S_5, S_3]).unwrap();
        trick.play_cards(P3, &mut hands, &[S_A, S_A, H_3, H_3, H_3]).unwrap();
        trick.play_cards(P4, &mut hands, &[H_3, H_3, H_3, H_3, H_3]).unwrap();
        let TrickEnded {
            winner: winner_id,
            points,
            largest_trick_unit_size,
            failed_throw_size,
            ..
        } = trick.complete().unwrap();
        assert_eq!(largest_trick_unit_size, 5);
        assert_eq!(winner_id, P1);
        assert_eq!(points, vec![]);
        assert_eq!(failed_throw_size, 0);
    }

-edit

Actually, it doesn't look like this repros?

[alex-fung]

Hm...
What would happen if P4 had four spades and a heart?

[alex-fung]

And if P3 had more spades besides the pair aces

[rbtying]

    fn test_play_throw_tractor_extra_cards() {
        use crate::types::cards::*;
        let trump = Trump::Standard {
            number: Number::Four,
            suit: Suit::Hearts,
        };

        let mut hands = Hands::new(vec![P1, P2, P3, P4], Number::Four);
        let p1_hand = vec![S_Q, S_Q, S_K, S_K, S_A];
        let p2_hand = vec![S_2, S_3, S_3, S_5, S_3];
        let p3_hand = vec![S_A, S_A, S_3, S_3, S_3];
        let p4_hand = vec![S_3, S_3, S_3, S_3, S_3];

        hands.add(P1, p1_hand.clone()).unwrap();
        hands.add(P2, p2_hand.clone()).unwrap();
        hands.add(P3, p3_hand.clone()).unwrap();
        hands.add(P4, p4_hand.clone()).unwrap();
        let mut trick = Trick::new(trump, vec![P1, P2, P3, P4]);
        trick
            .play_cards(P1, &mut hands, &p1_hand)
            .unwrap();
        trick.play_cards(P2, &mut hands, &p2_hand).unwrap();
        trick.play_cards(P3, &mut hands, &p3_hand).unwrap();
        trick.play_cards(P4, &mut hands, &p4_hand).unwrap();
        let TrickEnded {
            winner: winner_id,
            points,
            largest_trick_unit_size,
            failed_throw_size,
            ..
        } = trick.complete().unwrap();
        assert_eq!(largest_trick_unit_size, 4);
        assert_eq!(winner_id, P1);
        assert_eq!(points, vec![S_K, S_K, S_5]);
        assert_eq!(failed_throw_size, 0);
    }

this test also passes?

What's weird here is, if p1 was forced to play the tractor (and not the spare A), that would imply that somebody else had a higher tractor... but the only higher available tractor is potentially AAKK in 4 decks, since this isn't the trump suit?

Unfortunately, this kind of thing is hard to fix without being able to reproduce it somehow :(

[rbtying]

OK I figured this out.

diff --git a/core/src/trick.rs b/core/src/trick.rs
index f248e98..bed6c21 100644
--- a/core/src/trick.rs
+++ b/core/src/trick.rs
@@ -381,9 +381,11 @@ impl Trick {
                                     ..
                                 } in find_tractors(self.trump, hands.get(*player)?)
                                 {
-                                    if self.trump.effective_suit(members[0]) == tf.suit
+                                    if self.trump.effective_suit(found_members[0]) == tf.suit
                                         && found_count >= *count
                                         && found_members.len() >= members.len()
+                                        && self.trump.compare(found_members[0], members[0])
+                                            == Ordering::Greater
                                     {
                                         invalid = Some((player, unit.clone()));
                                         break 'search;

The code is incorrectly treating any other tractor as a bigger tractor.

[alex-fung]

Thank you @rbtying!