def card_game(self, card_match):
"""Card Game"""
self.render_background()
deck = Deck()
deck.shuffle()
if not card_match.card_players:
self.render_text("There are no Card Players... Restart the game",
(620, 300))
else:
while card_match.deck.has_cards():
for p in card_match.card_players:
width_c = 500
if card_match.playing(p):
self.render_background()
self.show_player_scores(card_match.card_players)
self.render_image(self.player_pic, (450, 350))
self.render_text(p.first_name, (450, 320))
pos = 1
for card in p.stats.cards:
self.render_image(self.card_images[str(card)],
(width_c + 70 * pos, 350))
pos += 1
pygame.display.flip()
time.sleep(0.1)
else:
return
def check_snap(desk_pile: Deck, players: List[Player]):
"""After every turn check if two last cards have the same value.
If True, then every Player says 'SNAP' with his own latency is seconds.
Round winner is the player with minimum latency, he takes all cards from the desk to his pile.
Args:
desk_pile (Deck): deck of cards that are currently at the table
players (List[Player]): list of participating players
"""
# if desk is empty, wait for new turns
if desk_pile.size < 2:
pass
else:
# compare two last card from the desk pile
if list(desk_pile)[0] == list(desk_pile)[1]:
latencies = []
# every player is saying 'SNAP', save their latencies in seconds
for player in players:
latencies.append(player.say_snap())
# determine round winner with minimal latency
min_latency = latencies.index(min(latencies))
round_winner: Player = list(players)[min_latency]
print(
f"{round_winner.name} won with {round(min(latencies), 2)} seconds latency "
f"and grabbed {desk_pile.size} cards")
# round winner takes all cards from the desk pile to his own pile
desk_pile.fetch_all(round_winner.pile)
class CardMatch:
def __init__(self, card_players):
self.card_players = card_players
self.deck = Deck()
self.deck.shuffle()
for pl in card_players:
pl.stats.card_games += 1
def get_winner(self):
rank_players = sorted(self.card_players,
key=lambda x: x.stats.aces,
reverse=True)
if len(rank_players) > 1:
if rank_players[0].stats.aces == rank_players[1].stats.aces:
return None
return rank_players[0] if rank_players else None
def playing(self, player: CardPlayer):
if self.deck.has_cards():
card_picked = self.deck.take_card()
player.stats.cards.append(card_picked)
if card_picked.rank == Ranks.ACE:
player.stats.aces += 1
return True
else:
return False
def game(players: List[Player]):
"""Start the game with determined players.
Steps:
1. As long as the players have cards, each player takes turns placing the card on the table.
2. After that, the snap is checked.
3. When there are no cards left in our hands, find the winner of the game
with the maximum number of cards in his pile.
"""
desk_pile = Deck()
turn_number = 0
while players[0].has_cards:
turn_number += 1
print(f"Turn {turn_number}")
for player in players:
played_card = player.turn()
desk_pile.add_card(played_card)
check_snap(desk_pile, players)
sleep(DEFAULT_TURN_TIME_SECONDS)
pile_sizes = [(player, player.pile_size) for player in players]
# sort from maximum player pile size to minimum, first player in the list wins the round
pile_sizes.sort(key=lambda x: x[1], reverse=True)
game_winner: Player = pile_sizes[0][0]
# print game results
print("############################")
print(f"Player {game_winner.name} WON!")
print("############################")
print(f"Game results:\n" +
"\n".join(f"{player.name}: {player.pile_size} cards"
for player in list(players)))
def __init__(self):
self.__hands = [[], []]
self.__account = 100
self.__bet = self.__account + 1
self.__playerValue = 0
self.__dealerValue = 0
self.__deck = Deck()
def test_deck_shuffle(self):
deck = Deck()
random.seed(2020)
before = deck.cards.copy()
deck.shuffle()
after = deck.cards.copy()
self.assertCountEqual(before, after)
self.assertNotEqual(before, after)
def test_fcn_generate_numeric_cards_generates_9_cards(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=False)
testDeck.__generate_numeric_cards__()
self.assertEqual(len(testDeck.__deck__), 9)
def test_get_hidden_card_returns_copy_of_a_card_from_deck(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=True)
cardFromDeck = testDeck.get_hidden_card()
self.assertNotIn(cardFromDeck, testDeck.__deck__)
def test_get_card_returns_a_card(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=True)
cardFromDeck = testDeck.get_hidden_card()
self.assertIsInstance(cardFromDeck, Card)
def test_get_hidden_card_returns_a_hidden_card(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=True)
cardFromDeck = testDeck.get_hidden_card()
self.assertTrue(cardFromDeck.__is_hidden__)
def setUp(self):
self.deck = Deck()
self.test_cards = [
Card('London', 'Blue'),
Card('Washington', 'Yellow'),
Card('Bejing', 'Red'),
Card('Moscow', 'Black'),
Card('New York', 'Yellow'),
]
self.deck.cards = self.test_cards.copy()
def test_card_faces_of_face_cards_are_all_str(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=False)
testDeck.__generate_face_cards__()
faceIsStr = True
for card in testDeck.__deck__:
if not isinstance(card.__face__, str):
faceIsStr = False
self.assertTrue(faceIsStr)
def prepare_game(decks_count: int, auto_mode: bool, player_one_name: str,
players_count: int) -> List[Player]:
"""
Initialize cards, decks, players for game
Args:
decks_count (int): amount of decks for the game
auto_mode (bool): indicates if player one is bot or human
player_one_name (str): name of player one. another names choose randomly
players_count (int): amount of players for the game
Returns:
List[Player]: list of initialized players with cards
"""
# define list of random names for bot-players
random_names = RANDOM_NAMES
shuffle(random_names)
if player_one_name:
names = [player_one_name] + random_names[:players_count - 1]
else:
names = random_names[:players_count]
# generate cards and split all cards to the even chunks
all_cards = generate_deck(decks_count)
chunked_deck = chunk_deck(all_cards, len(all_cards) // players_count)
# initialize players
players: List[Player] = []
for player, hand in zip(names, chunked_deck):
players.append(Player(name=player, hand=Deck(hand)))
# set auto_mode flag to the main player, because it's enabled by default
players[0].auto_mode = auto_mode
return players
def test_deck_add_another_deck(deck, cards):
"""Test extracting all cards of one deck to another specified deck"""
second_deck = Deck(
(Card(value="ACE", suit="DIAMONDS"), Card(value="ACE", suit="SPADES")))
expected = list(deck) + list(second_deck)
deck.fetch_all(second_deck)
assert second_deck.size == 7
assert not sum([not card in expected for card in second_deck])
def test_face_cards_are_correct(self):
from src.deck import Deck
testDeck = Deck()
faceCards = ['A', 'J', 'Q', 'K']
self.assertListEqual(testDeck.__faceCards__, faceCards)
def deal_new_hand(self) -> None:
deck: Deck = Deck()
player_cards: List[List] = [[], [], [], []]
for i, card in enumerate(deck.get_cards()):
player_cards[i % 4].append(card)
players: List[Player] = self.get_players()
players[0].set_cards(player_cards[0])
players[1].set_cards(player_cards[1])
players[2].set_cards(player_cards[2])
players[3].set_cards(player_cards[3])
def test_player_has_no_cards():
"""Check that is player has no cards, property returns False"""
Daenerys = Player(
name="Queen Daenerys Stormborn of the House Targaryen, the First of Her Name, "
"Queen of the Andals, the Rhoynar and the First Men, "
"Lady of the Seven Kingdoms and Protector of the Realm, "
"Lady of Dragonstone, Queen of Meereen, "
"Khaleesi of the Great Grass Sea, the Unburnt, Breaker of Chains and Mother of Dragons",
hand=Deck([]),
)
assert not Daenerys.has_cards
class Game():
def __init__(self):
self.players = []
self.deck = Deck()
def create_players(self, name, seed=100):
self.players.append(Player(name, seed))
def shuffle_deck(self):
self.deck.shuffle()
def deal(self):
for i in range(2):
for player in self.players:
player.receive_card(self.deck.pop())
def get_chip_count(self):
for player in self.players:
print(player.get_name(), player.get_wallet())
class Shoe:
def __init__(self, no_decks):
self.shoe = Deck(no_decks)
self._cards = queue.Queue(maxsize=52 * no_decks)
self.shuffle()
self._add_cards(self.shoe.deck)
def shuffle(self):
self.shoe.shuffle()
def get_queue_size(self):
return self._cards.qsize()
def get_card(self):
card = self._cards.get()
return card
def _add_cards(self, cards):
for card in cards:
self._cards.put(card)
def test_ace_value_is_11(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=True)
valueOfAce = 0
for card in testDeck.__deck__:
if card.__is_ace__:
valueOfAce = card.__value__
self.assertEqual(valueOfAce, 11)
def test_ace_generated(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=True)
aceInDeck = False
for card in testDeck.__deck__:
if card.__is_ace__:
aceInDeck = True
self.assertTrue(aceInDeck)
def test_only_one_ace_card_is_generated(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=True)
numberOfAcesInDeck = 0
for card in testDeck.__deck__:
if card.__is_ace__:
numberOfAcesInDeck = numberOfAcesInDeck + 1
self.assertEqual(numberOfAcesInDeck, 1)
def test_deck_size(self):
deck = Deck()
self.assertEqual(len(deck.cards), 52)
self.assertTrue(deck.has_cards())
for i in range(52):
deck.take_card()
self.assertFalse(deck.has_cards())
class TestDeck(unittest.TestCase):
def setUp(self):
print("running setup")
self.deck = Deck()
def test_deck_length(self):
self.assertEqual(len(self.deck.deck), 52)
def test_suit_length(self):
result = 0
for card in self.deck.deck:
if card.suit == "Hearts":
result += 1
self.assertEqual(result, 13)
def test_shuffle(self):
not_expected = self.deck.deck
print("NOT EXPECTED")
print(not_expected)
self.deck.shuffle()
print("AFTER SHUFFLE")
print(self.deck.deck)
self.assertEqual(len(self.deck.deck), 52)
self.assertNotEqual(not_expected, self.deck.deck)
def test_deck_only_contains_cards_type(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck()
# testDeck.__deck__.append(2319)
isCardType = True
for card in testDeck.__deck__:
if not isinstance(card, Card):
isCardType = False
break
self.assertTrue(isCardType)
def test_fcn_face_cards_are_of_value_10(self):
from src.deck import Deck
from src.deck import Card
testDeck = Deck(generate=False)
faceCardValueIs10 = True
for card in testDeck.__deck__:
# Skip the Ace
if not card.__is_ace__:
if not (card.__value__ == 10):
faceCardValueIs10 = False
break
self.assertTrue(faceCardValueIs10)
def __init__(self, resources_path):
pygame.init()
pygame.font.init()
pygame.display.set_caption(
"Welcome to John's Card Dice Game, developed by Panagiotis Vafiadis"
)
self.mode = WindowGameMode.STARTUP_SCREEN
self.resources_path = resources_path
self.FONT_SIZE = 15
self.DICE_ROLLS = 10
self.BLACK = (0, 0, 0)
self.GREEN = (40, 120, 80)
self.RED = (130, 10, 0)
self.LGREEN = (130, 200, 150)
self.screen = pygame.display.set_mode((1200, 600))
self.my_font = pygame.font.SysFont('Times New Roman', self.FONT_SIZE,
True)
self.bg_surf = self.load_image('table.jpg', (900, 600))
self.bg_logo = self.load_image('ihu.png', (380, 240))
self.joker = self.load_image('joker.jpg', (95, 80))
self.player_pic = self.load_image('player.png', (80, 80))
self.clock = pygame.time.Clock()
self.dice_imag = self.load_dice_images()
self.card_images = self.load_card(Deck())
def test_game_deck_shuffled(game):
game.start_game()
assert game.deck != Deck().cards
def empty_deck():
deck = Deck()
return deck
def second_deck():
deck = Deck()
deck.build()
return deck
