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)
def test_deck_deal(self):
d = Deck()
c = d.deal()
self.assertFalse(d.contains(c))
d2 = Deck()
self.assertTrue(d2.contains(c))
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_deck_contains_ace_of_hearts(self):
d = Deck()
c = Card('Hearts', 'Ace')
self.assertTrue(d.contains(c))
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 test_init(self):
d = Deck(jokers=False)
self.assertEqual(len(d.cards), 52)
self.assertFalse(d.contains(Card('Wild', 'Joker')))
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()
def test_init_jokers(self):
d = Deck(jokers=2)
self.assertEqual(len(d.cards), 54)
self.assertTrue(d.contains(Card('Wild', 'Joker')))
