class Game(object): CARDS_PER_PLAYER = 2 def __init__(self, player_count): self._initialize_players(player_count) self.deck = Deck() self.community = Community() def _initialize_players(self, player_count): self.players = [] for i in range(0, int(player_count)): self.players.append(Player()) def deal_to_players(self): for i in range(0, Game.CARDS_PER_PLAYER): for player in self.players: player.hand.add_card(self.deck.draw()) def deal_to_flop(self): for i in range(0, Community.CARDS_PER_FLOP): self.community.flop.add_card(self.deck.draw()) def deal_to_turn(self): card = self.deck.draw() self.community.turn.suite = card.suite self.community.turn.number = card.number def deal_to_river(self): card = self.deck.draw() self.community.river.suite = card.suite self.community.river.number = card.number
class Game: def __init__(self, numDecks): self.players = [] self.players.append( Dealer('Crack Ass Dealer') ) self.deck = Deck(numDecks) def addPlayer(self,player): self.players.append(player) def showAllHands(self): for player in self.players: player.showHand() print '\n' def clearTable(self): for player in self.players: player.hand.clearHand() def checkCardsRemaining(self): if len(self.deck.cards) <= 2 * len(self.players): self.deck.newDeck() print "Replacing deck with new deck\n" def checkHit(self, player): if player.hand.value < 9: self.deck.dealCard()
def __init__(self, player_count: int = 3): self.players = self.create_players(player_count) self.player_order = [player.name for player in self.players] self.deck = Deck() self.set_rank() self.draw_cards() self.start_card = Card("Hearts", 3)
def test_deck_deal(self): d = Deck() c = d.deal() self.assertFalse(d.contains(c)) d2 = Deck() self.assertTrue(d2.contains(c))
def test_joker_deck(self): d = Deck(jokers=4) cards = [d.deal() for r in range(20)] card_count = defaultdict(int) for c in cards: card_count[c.suit] += 1 self.assertEqual(len(d.cards), 36) print(card_count) print(unicode(d)) self.assertEqual(card_count['Wild'], 2)
def test_joker_deck(self): d = Deck(jokers=4) cards = [ d.deal() for r in range(20) ] card_count = defaultdict(int) for c in cards: card_count[c.suit] += 1 self.assertEqual(len(d.cards), 36) print(card_count) print(unicode(d)) self.assertEqual(card_count['Wild'], 2)
def main(): """Entry point for the application""" print('Hello world') game_deck = Deck() human_player = Hand() computer_player = Hand() game_deck.shuffle() game_over = False human_player.cards = game_deck.deal_hand() computer_player.cards = game_deck.deal_hand() while not game_over: print(f'Computer has: {computer_player}') # delete me later players_turn = True while players_turn: player_card_selection = input( f'Please choose a card from your hand you have the following: {human_player}' ) while not human_player.check_if_in_hand( player_card_selection.upper()): print(f'{player_card_selection} not in hand.') player_card_selection = input( f'Please choose a card from your hand you have the following: {human_player}' ) print(f'Computer has: {computer_player}') # delete me later if computer_player.check_if_in_hand(player_card_selection.upper()): print(f'Computer has those cards!') human_player.cards = computer_player.draw_card( player_card_selection, human_player.cards) human_player.book_check(player_card_selection) else: print('Go fish!') drawn_card = game_deck.draw_card() human_player.cards.append(drawn_card) human_player.book_check(drawn_card) players_turn = False while not players_turn: computer_card_selection = random.choice(computer_player.cards) if human_player.check_if_in_hand(computer_card_selection): print( f'Computer guessed {computer_card_selection} and got it right!' ) computer_player.cards = human_player.draw_card( computer_card_selection, computer_player.cards) computer_player.book_check(computer_card_selection) else: drawn_card = game_deck.draw_card() computer_player.cards.append(drawn_card) computer_player.book_check(drawn_card) print( f'Computer guessed {computer_card_selection} and got it wrong!\n It is now your turn!' ) players_turn = True print(human_player) print(computer_player)
class Dealer: def __init__(self): self.table = Table(2) self.deck = Deck() def seat_player(self, player): self.table.seat_player(player) def go(self): print("Game is starting") self._deal() def deal(self): self.deck.reset() seats = self.table.seats for seat in seats: if not seat.is_free: seat.player.clear_hand() hand = [] for i in range(5): seat.player.give_card(self.deck.draw_card()) def _printGameState(self): self.table.print_state() def process_actions(self): for seat in self.table.seats: if not seat.is_free: seat.player.print_state() action = seat.player.collect_action() seat.player.take_cards(action) for i in range(len(action)): seat.player.give_card(self.deck.draw_card()) seat.player.print_state() def declare_winner(self): hands = [] for seat in self.table.seats: if not seat.is_free: hands.append(HandResult(seat.player.hand, seat.player)) round_result = RoundResult(hands) winning_hands = round_result.find_winning_hands() for seat in self.table.seats: if not seat.is_free: seat.player.tell_result(round_result) print("Round Winner(s)!: ") for winning_hand in winning_hands: print(winning_hand.player.name + " " + str(winning_hand.hand_type))
def __init__(self, event_dispatcher): self.event_dispatcher = event_dispatcher self.connections = [] self.deck = Deck('classes/decks/starterdeck.json') self.deck.cards[0].scale(0.8) self.deck.cards[0].position(300, 420) self.deck.cards[1].scale(0.8) self.deck.cards[1].position(1000, 420) self.cards = Group(self.deck.cards)
def test_shuffle(self): d = Deck() cards = [d.deal() for r in range(20)] print(unicode(d)) self.assertEqual(len(d.cards), 32) card_count = defaultdict(int) for c in cards: card_count[c.suit] += 1 print(card_count) self.assertGreater(card_count['Spades'], 4) self.assertGreater(card_count['Hearts'], 3) self.assertGreater(card_count['Clubs'], 7) self.assertGreater(card_count['Diamonds'], 2)
def test_shuffle(self): d = Deck() cards = [ d.deal() for r in range(20) ] print(unicode(d)) self.assertEqual(len(d.cards), 32) card_count = defaultdict(int) for c in cards: card_count[c.suit] += 1 print(card_count) self.assertGreater(card_count['Spades'], 4) self.assertGreater(card_count['Hearts'], 3) self.assertGreater(card_count['Clubs'], 7) self.assertGreater(card_count['Diamonds'], 2)
class DeckManager: def __init__(self): self.unused = Deck((Card(n, s) for n, s in itertools.product( constants.STANDARD_CARDS, constants.STANDARD_SUITS))) self.discard, self.active = Deck(), Deck() self.Reset() # moves cards between decks def _move(self, source, dest, card): source.Draw(card) dest.Append(card) def _combine(self, dest, *sources): for source in sources: while not source.Empty(): dest.Append(source.Draw()) # move a card from unused to active def Draw(self): card = self.unused.Draw() self.active.Append(card) return card # move cards from unused or active to the Discard pile. def Discard(self, *cards): for card in cards: if not self.active.Contains(card) and not self.unused.Contains( card): raise Exception('Card not in play or unused') if self.active.Contains(card): self._move(self.active, self.discard, card) else: self._move(self.unused, self.discard, card) def Reset(self): self._combine(self.unused, self.discard, self.active) assert self.unused.Size() == 52 self.unused.Shuffle()
def test_deck_contains_ace_of_hearts(self): d = Deck() c = Card('Hearts', 'Ace') self.assertTrue(d.contains(c))
def test_init(self): d = Deck(jokers=False) self.assertEqual(len(d.cards), 52) self.assertFalse(d.contains(Card('Wild', 'Joker')))
def test_init_jokers(self): d = Deck(jokers=2) self.assertEqual(len(d.cards), 54) self.assertTrue(d.contains(Card('Wild', 'Joker')))
class Game: def __init__(self, player_count: int = 3): self.players = self.create_players(player_count) self.player_order = [player.name for player in self.players] self.deck = Deck() self.set_rank() self.draw_cards() self.start_card = Card("Hearts", 3) @staticmethod def create_players(player_count: int) -> List[Player]: """Create a list of players according to count return: list of Players """ player_list = [] for n in range(player_count): player_list.append(Player(f"Player{n}")) return player_list def draw_cards(self): # keep drawing if there are cards while self.deck.cards: for player in self.players: # stop if no cards to draw if not self.deck.cards: break player.draw(self.deck) def set_rank(self): """Set up the ranking for this game and change ranking of the cards.""" name_to_rank = { "Two": 1, "Ace": 2, "King": 3, "Queen": 4, "Jack": 5, "Ten": 6, "Nine": 7, "Eight": 8, "Seven": 9, "Six": 10, "Five": 11, "Four": 12, "Three": 13 } self.deck.set_rank(name_to_rank) def determine_first(self) -> str: """Determine who goes first. Need to draw cards first""" for player in self.players: if self.start_card in player.hand: print(f"{player.name} goes first.") return player.name return "Nobody" def play(self): # sort hand according to the game ranking [player.sort_hand() for player in self.players] # show player hands # [player.show_hand() for player in self.players] # determine who start and change player order starting_player = self.determine_first() starter_index = self.player_order.index(starting_player) self.player_order = self.players[ starter_index:] + self.players[:starter_index] # print(self.player_order) # go through each turns previous_hands = [] player_card_count = len(self.player_order[0].hand) while player_card_count > 0: for current_player in self.player_order: previous_hand = current_player.play_hand(previous_hands) player_card_count = len(current_player.hand) # print(f"current player hand len {player_card_count}") previous_hands.append(previous_hand) # print(f"{current_player.name}: {current_player.hand}") # need to exit for loop when last card from any player is played. # TODO: might be a better algorithm with the whle loop? if player_card_count == 0: current_player.win_total = +1 break win_total = [{ player.name: player.win_total } for player in self.player_order] print(f"win total {win_total}")
def __init__(self, player_count): self._initialize_players(player_count) self.deck = Deck() self.community = Community()
from __future__ import print_function, unicode_literals import random from cards.card import Card from cards.deck import Deck random.seed(5) def get_cards(deck, number): return [deck.deal() for i in range(number)] if __name__ == '__main__': d = Deck(jokers=2) print(unicode(d)) #Shuffle the deck again d.shuffle() print("\nPost shuffling again:") print(unicode(d)) #Get a hand of cards from the deck print('\nDealt Hand:') hand = get_cards(d, 5) for c in hand: print(unicode(c)) #Make sure one of the cards dealt is no longer in the deck check_card = hand[1]
def test_init(): deck = Deck()
def stacked_deck(): deck = Deck() for rank in ranks.get_royals(): card = playing_cards.StandardPlayingCard(rank, 'spade') deck.insert_to_top(card) return deck
def test_init(self): deck = Deck([1, 2, 3, 4], ['a', 'b', 'c']) self.assertEqual(12, len(deck._deck))
def __init__(self): self.unused = Deck((Card(n, s) for n, s in itertools.product( constants.STANDARD_CARDS, constants.STANDARD_SUITS))) self.discard, self.active = Deck(), Deck() self.Reset()
def __init__(self, numDecks): self.players = [] self.players.append( Dealer('Crack Ass Dealer') ) self.deck = Deck(numDecks)
def test_deck(self): deck = Deck() self.assertEqual(deck.cards_left(), 52)
def test_deck_unicode(self): d = Deck() s = unicode(d) print(s) self.assertEqual(type(s), unicode)
def __init__(self): self.table = Table(2) self.deck = Deck()
def empty_deck(): return Deck()
#!/usr/bin/python2.7 from __future__ import print_function, unicode_literals import random from cards.card import Card from cards.deck import Deck random.seed(5) def get_cards(deck, number): return [ deck.deal() for i in range(number) ] if __name__ == '__main__': d = Deck(jokers=2) print(unicode(d)) #Shuffle the deck again d.shuffle() print("\nPost shuffling again:") print(unicode(d)) #Get a hand of cards from the deck print('\nDealt Hand:') hand = get_cards(d, 5) for c in hand: print(unicode(c)) #Make sure one of the cards dealt is no longer in the deck check_card = hand[1] print('\n{} in deck? {}'.format(unicode(check_card),\
def test_deck_creation(self): deck = Deck() for i in range(52): deck.draw_card() with self.assertRaises(OutOfCardsError) as context: deck.draw_card()