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))
