def test_init_invalid(self): with self.assertRaises(ValueError): deck.Card(-1) with self.assertRaises(ValueError): deck.Card(52) with self.assertRaises(ValueError): deck.Card(1000)
def test_sorting_deck_low_cards(unshuffled_deck): low_cards = [ deck.Card("2", suit) for suit in "clubs diamonds hearts spades".split() ] + [deck.Card("3", "clubs")] sorted_deck = sorted(unshuffled_deck, key=deck.spades_high) for expected_card, actual_card in zip(low_cards, sorted_deck): assert expected_card == actual_card
def test_get_winner_dealer(self): test_dealer = dealer.Dealer() test_player = player.Player() test_dealer.hand = [deck.Card(5, 0)] test_player.hand = [deck.Card(4, 0)] test_game = game.Game() winner, score = test_game.get_winner(test_dealer, test_player) self.assertEqual(winner, test_dealer)
def test_sorting_deck_high_cards(unshuffled_deck): high_cards = [deck.Card("K", "spades")] + [ deck.Card("A", suit) for suit in "clubs diamonds hearts spades".split() ] sorted_deck = sorted(unshuffled_deck, key=deck.spades_high) for expected_card, actual_card in zip(high_cards, sorted_deck[-len(high_cards):]): assert expected_card == actual_card
def test_order(self): order = list(range(52)) order.remove(50) order.insert(0, 50) d = deck.Deck(order=order) self.assertEqual(deck.Card(50), d.our_deck[0]) self.assertEqual(deck.Card(0), d.our_deck[1]) self.assertEqual(deck.Card(49), d.our_deck[50]) self.assertEqual(deck.Card(51), d.our_deck[51])
def test_get_winner_dealer_bust(self): test_dealer = dealer.Dealer() test_player = player.Player() test_player.hand = [deck.Card(8, 0)] test_dealer.hand = [ deck.Card(10, 0), deck.Card(10, 0), deck.Card(10, 0) ] test_game = game.Game() winner, score = test_game.get_winner(test_dealer, test_player) self.assertEqual(score, -1)
def silent_request(self): requestable_cards = self.brain.get_requestable_cards() if requestable_cards == []: #will ask for own or random card with 1/3 vs 2/3 chance #only asking own cards is really bad for performance. x = random.randrange(3) if x > 0: return self.random_request() else: return self.owned_request() #list here the cards of requestable cards that player is actually allowed to ask may_request = [] for kinds in self.brain.get_owned_kinds(): #counter to keep track if location of all four cards is known count = 0 for i in range(4): card = deck.Card(kinds, i) #if card is owned by themselves increase count if card in self.cards: count += 1 #if card location is known increase count if self.brain.check_if_in_list(card): count += 1 #when the count is 4, all locations are known #Here we add the cards we do not own and can request to the may request list if count == 4: for i in range(4): card = deck.Card(kinds, i) if self.brain.check_if_in_list(card): may_request.append( self.brain.return_card_in_list(card)) #If may request is empty, ask for owned or random card if may_request == []: x = random.randrange(3) if x > 0: return self.random_request() else: return self.owned_request() #request all cards in the may request list. This works the same as the greedy request code for opponent in self.opponents: if opponent.id == may_request[0][1]: r = opponent.draw(may_request[0][0]) assert (r) self.cards.append(r) self.announcer.card_taken(r, opponent.id, self.id) return True return False
def moneyGains(self, players, scores, turnHistory) -> list: if self.gameType.is100 or self.gameType.is7: raise Exception("Announced 100 or announced 7 not supported yet") leaderWonGame = False leaderWon7 = False coopWon7 = False leader7killed = False coop7killed = False leaderScore = 0 coopScore = 0 leaderGain = 0 coopGain = 0 for player, score, idx in zip(players, scores, range(len(players))): if player.role == ROLE_LEADER: leaderScore += score leaderIdx = idx else: coopScore += score if leaderScore == coopScore: raise Exception("Leader and opposition scores cannot be equal.") if leaderScore > coopScore: leaderWonGame = True lastTurnCards, startIdx, takingIdx = turnHistory[-1] try: trump7Idx = lastTurnCards.index( deck.Card(self.gameType.trump, deck.RANK_7)) if trump7Idx == takingIdx: if takingIdx == leaderIdx: leaderWon7 = True else: coopWon7 = True else: if trump7Idx == leaderIdx: leader7killed = True else: coop7killed = True except ValueError: pass if leaderWonGame: gameGain = 2 * (2 * BASE_GAME_COST + self.above100Gain(leaderScore)) leaderGain += gameGain coopGain -= gameGain else: gameGain = 2 * (2 * BASE_GAME_COST + self.above100Gain(coopScore)) coopGain += gameGain leaderGain -= gameGain if leaderWon7 or coop7killed: silent7Gain = 2 * BASE_7_COST leaderGain += silent7Gain coopGain -= silent7Gain elif coopWon7 or leader7killed: silent7Gain = 2 * BASE_7_COST leaderGain -= silent7Gain coopGain += silent7Gain gains = [coopGain / 2] * len(players) gains[leaderIdx] = leaderGain if self.gameType.trump == deck.SUIT_HEARTS: gains = [2 * g for g in gains] return gains
def test_can_use_reversed_on_deck(unshuffled_deck): expected_cards = [ deck.Card(suit="hearts", rank=rank) for rank in list("akqjt9".upper()) ] for expected_card, actual_card in zip(expected_cards, reversed(unshuffled_deck)): assert expected_card == actual_card
def remove_kind(self, kind, id): self.removed_kinds.append(kind) if id == self.id: for value in range(4): self.cards.remove(deck.Card(kind, value)) for known_player in self.known_players: known_player.remove_kind(kind)
def testCardInit(self): self.card = deck.Card('heart', 'A', 1, self) self.assertEqual(self.card.suit, 'heart') self.assertEqual(self.card.rank, 'A') self.assertEqual(self.card.value, 1) self.assertFalse(self.card.dealt) self.assertFalse(self.card.discarded)
def removeKinds(self, kinds): for kind in kinds: self.score += 1 for val in range(4): card = deck.Card(kind, val) self.cards.remove(card) self.announcer.announce_remove_kind(kind, self.id)
def test_str(self): self.assertEqual("2c", str(deck.Card(0))) self.assertEqual("2d", str(deck.Card(13))) self.assertEqual("Th", str(deck.Card(34))) self.assertEqual("Jh", str(deck.Card(35))) self.assertEqual("Qh", str(deck.Card(36))) self.assertEqual("Kh", str(deck.Card(37))) self.assertEqual("As", str(deck.Card(51)))
def test_hand(): """ Verify the player gets the cards we expect on unshuffled deck """ player1 = player.Player(1) deck1 = deck.Deck() testHand = [deck.Card(deck.Suits.CLUBS, 14), deck.Card(deck.Suits.CLUBS, 13), deck.Card(deck.Suits.CLUBS, 12)] match = True for _ in range(0, 3): player1.draw(deck1) cards = player1.getHand() for count in range(0, 3): match = match and (cards[count].getSuit() == testHand[count].getSuit()) match = match and (cards[count].getValue() == testHand[count].getValue()) assert match
def perform_inference(self): #We only check for cards the player may actually ask about for kinds in self.brain.get_owned_kinds(): #We create a list of all cards of a certain kind kindSet = [deck.Card(kinds, value) for value in range(4)] #we remove the cards the player already owns for card in kindSet: if card in self.cards: kindSet.remove(card) #Here we check for all the cards currently in the list, whether we already know the location #and otherwise we'll check if we can determine the owner for card in kindSet: total_sum = 0 #check if we already know the location. for player in self.opponents: total_sum += self.brain.certain_cards(player.id, card) #create a list of possible owners possible_card_owners = [] #If we don't know the location yet if total_sum is 0: #go through all players for player in self.opponents: #when the card is not in the player's list of certain_not_cards if self.brain.certain_not_cards(player.id, card) is 0: #calculate the number of unknown cards, thus cards the player has but we don't know what card it is unknown_cards = self.brain.known_cards_number[ player. id] - self.brain.get_number_of_requestable_cards( player.id) #If the number of unknown cards is larger than 0 it is possible they own this card and are appended in the list if unknown_cards > 0: possible_card_owners.append(player.id) #If there is now only one possible player left who can have the card, then that player indeed has that card if len(possible_card_owners) is 1: self.brain.add_card_to_knowledge( possible_card_owners[0], card) kindSet.remove(card) self.perform_inference() return True
def test_sort(): cards = [] cards.append(deck.Card(deck.Suits.SPADES, 2)) cards.append(deck.Card(deck.Suits.DIAMONDS, 5)) cards.append(deck.Card(deck.Suits.SPADES, 13)) cards.append(deck.Card(deck.Suits.HEARTS, 3)) cards.append(deck.Card(deck.Suits.CLUBS, 14)) testCards = [] testCards.append(deck.Card(deck.Suits.SPADES, 2)) testCards.append(deck.Card(deck.Suits.SPADES, 13)) testCards.append(deck.Card(deck.Suits.DIAMONDS, 5)) testCards.append(deck.Card(deck.Suits.HEARTS, 3)) testCards.append(deck.Card(deck.Suits.CLUBS, 14)) newCards = game.sort(cards) match = True for c in range(0, 5): match = match and (newCards[c].getSuit() == testCards[c].getSuit()) match = match and (newCards[c].getValue() == testCards[c].getValue()) assert match
def random_request(self): requestable_kinds = self.brain.get_owned_kinds() if requestable_kinds == []: return False kind = random.choice(requestable_kinds) hcard = deck.Card(kind, random.randrange(4)) opponent = self.opponents[random.randrange(len(self.opponents))] r = opponent.draw(hcard) if not r: self.announcer.failed_request(hcard, opponent.id, self.id) return False else: self.cards.append(r) self.announcer.card_taken(r, opponent.id, self.id) return True
def move_c2c(self, moves): max_card = deck.Card(suit=-1, rank=-1) # filler card max_src = -1 for src in moves: # ignore hand or foundation moves if src == -1 or src == -2: continue # move the largest card first curr = s.get_first_visible_card(self.game.columns[src])[0] if curr > max_card: max_card = curr max_src = src # move the largest card to the longest pile dst = self.get_longest_visible_column(moves[max_src]) ret = self.game.column_to_column(max_src, dst) self.visible_cards_count[dst] = count_visible(self.game.columns[dst]) return ret
def test_get_hand_score_over(self): hand = [deck.Card(5, 0), deck.Card(13, 0), deck.Card(9, 1)] score = game.Game.get_hand_score(hand) self.assertEqual(score, 24)
def checkSingleKind(self, kind): for val in range(4): card = deck.Card(kind, val) if card not in self.cards: return return kind
def test_get_hand_score_with_ace_high(self): hand = [deck.Card(5, 0), deck.Card(13, 0), deck.Card(1, 0)] score = game.Game.get_hand_score(hand) self.assertEqual(score, 16)
def remove_kind(self, kind): kindSet = [deck.Card(kind, value) for value in range(4)] for card in self.certainCards: if card in kindSet: self.certainCards.remove(card) self.number_of_cards -= 1
import deck import gameEvaluator import headsUpGame import player # test royal flush player = player.Player() player.setBothCards(deck.Card('A', 'H'), deck.Card('Q', 'H')) table = [deck.Card('J','H'),deck.Card('10','H'),deck.Card('K','H'),deck.Card('7','C'),deck.Card('2','S')] evalu = gameEvaluator.Evaluator(table, player) evalu.sortCards() evalu.checkRoyalFlush() #test straigh flush player.setBothCards(deck.Card('3', 'D'), deck.Card('6', 'D')) table = [deck.Card('4', 'D'), deck.Card('5', 'D'), deck.Card('7', 'D'), deck.Card('7', 'C'), deck.Card('2', 'S')] evalu = gameEvaluator.Evaluator(table, player) evalu.checkStraightFlush()
def test_deck_order(unshuffled_deck): expected_cards = [ deck.Card(suit="spades", rank=str(rank)) for rank in range(2, 5) ] assert unshuffled_deck[0:3] == expected_cards
handScore = score1 + score2 + score3 + score4 + score5 print("Player has score {}".format(handScore)) print("Analytical score:") print("Score1 " + str(score1)) print("Score2 " + str(score2)) print("Score3 " + str(score3)) print("Score4 " + str(score4)) print("Score5 " + str(score5)) print() return handScore assert evaluateHand([ deck.Card(settings.SUIT.Spades, "8"), deck.Card(settings.SUIT.Hearts, "7"), deck.Card(settings.SUIT.Diamonds, "Q"), deck.Card(settings.SUIT.Hearts, "2"), deck.Card(settings.SUIT.Spades, "Q") ]) == 231 assert evaluateHand([ deck.Card(settings.SUIT.Spades, "10"), deck.Card(settings.SUIT.Clubs, "J"), deck.Card(settings.SUIT.Hearts, "A"), deck.Card(settings.SUIT.Clubs, "8"), deck.Card(settings.SUIT.Hearts, "2") ]) == 86 assert evaluateHand([
def setUp(self): self.card_deck = deck.Deck() self.first_card = deck.Card(1, "clubs")
def test_deck_card_not_in_deck(unshuffled_deck): card = deck.Card(suit="spades", rank="beasts") assert card not in unshuffled_deck
def test_deck_check_for_in_operator(unshuffled_deck): card = deck.Card(suit="spades", rank="8") assert card in unshuffled_deck
def setUp(self): self.king_hearts = deck.Card(13, "hearts") self.four_diamonds = deck.Card(4, "diamonds") self.ace_spades = deck.Card(1, "spades")
def add_exhaustion(self): # print('Exhaustion', self.name) self.recycle_deck.cards.append(deck.Card(2))