Beispiel #1
0
 def __init__(self):
     self.desks = []
     self.bank_cards = []
     self.player_cards = []
     self.game_state = 2
     self.deck = Deck()
     self.deck.shuffle()
Beispiel #2
0
    def __init__(self, pygame_clock, game_controller):
        self.dt = 0
        self.pygame_clock, self.game_controller = pygame_clock, game_controller
        self.deck = Deck()
        self.load_image_assets()
        self.board = Board(pygame_clock, self.deck)
        self.back_image = self.deck.cards_list[-1].current_image.copy()
        self.deck_x, self.deck_y = (SCREENWIDTH // 2), (SCREENHEIGHT // 2) - (self.back_image.get_rect().size[1] // 2)

        # mouse + position
        self.click = False
        self.mx, self.my = 0, 0

        self.were_init_cards_dealt = False

        self.animating_init_deck = True
        self.animating_init_deal = False

        self.show_card_size = False

        self.animate_deck_count = 1 # used in self.animate_init_deck
        self.animate_init_deal_count = 0 # used in deal_cards_init_animation

        self.players = []
        self.player_count = 0
        self.attacker = None

        self.add_player(Player("Alex", True, 0))
        self.add_player(simpleBot("NPC837", 1))
        self.add_player(simpleBot("NPC619", 2))
class PasyansGameState(CardGameState):
    """Represents the history of a Pasyans game, allowing turns to be reversed or a game to be resumed."""

    ranks = [
        Rank.SIX, Rank.SEVEN, Rank.EIGHT, Rank.NINE, Rank.TEN, Rank.JACK,
        Rank.QUEEN, Rank.KING, Rank.ACE
    ]
    command_aliases = {
        'move': ['move', 'mv'],
        'exit': ['exit', 'end', 'quit'],
        'win': ['win']
    }
    cell_names = ['1', '2', '3', '4', '5', '6', '7', '8', '9', 'F', 'f']

    def __init__(self, debug_mode=False):
        super().__init__(self.ranks, debug_mode)
        self.deck.shuffle()
        self.cells = [[self.deck.draw() for i in range(4)] for j in range(9)]
        self.free_cell = None

    def reset_game(self):
        self.deck = Deck(self.ranks)
        self.deck.shuffle()
        self.cells = [[self.deck.draw() for i in range(4)] for j in range(9)]
        self.free_cell = None

        self.turn_history = []
        self.is_won = False
Beispiel #4
0
class DeckTest(unittest.TestCase):

    def setUp(self):
        self.deck = Deck()

    def test_get_suit(self):
        self.assertEqual(self.deck.get_suit(0), 'Spades')
        self.assertEqual(self.deck.get_suit(13), 'Hearts')
        self.assertEqual(self.deck.get_suit(26), 'Diamonds')
        self.assertEqual(self.deck.get_suit(39), 'Clubs')

    def test_get_rank(self):
        self.assertEqual(self.deck.get_rank(0), 1)
        self.assertEqual(self.deck.get_rank(13), 1)
        self.assertEqual(self.deck.get_rank(26), 1)
        self.assertEqual(self.deck.get_rank(39), 1)

    def test_get_card(self):
        i = 0
        cardnumber = self.deck[i]
        card = (
            self.deck.get_rank(cardnumber),
            self.deck.get_suit(cardnumber)
        )
        self.assertEqual(self.deck.get_card(i), card)

    def test_teek(self):
        self.assertEqual(self.deck.peek(0), self.deck[0])

    def test_shuffle(self):
        shuffled_deck = Deck()
        shuffled_deck.shuffle()
        self.assertNotEqual(self.deck, shuffled_deck)
Beispiel #5
0
def main():
    print(
        "Hi! Welcome to the Blackjack table. Let's see if you can beat the dealer"
    )
    money = ask_how_much_money(
        "How much money do you want to start with? You must enter a positve integer \n"
    )
    round = 1
    deck = Deck()
    while (money > 0):
        print("Round " + str(round))
        print("Currently you have " + str(money) + " money")
        if new_round():
            bet = ask_how_much_money("How much money do you want to bet? \n",
                                     money)
            if len(deck.cards) < MIN_NUMBER_CARDS_IN_DECK:
                # reshuffle the cards, and start off with a full deck if have less than 10 cards
                deck = Deck()
            playerHand, dealerHand, deck = play_round(deck)
            if playerHand.cur_value == GOAL_CONSTANT or dealerHand.cur_value > GOAL_CONSTANT:
                money += bet
            elif playerHand.cur_value > GOAL_CONSTANT:
                money -= bet
            elif playerHand.cur_value > dealerHand.cur_value:
                win_statement("You", playerHand.cur_value)
                money += bet
            else:
                lose_statement("You", playerHand.cur_value)
                money -= bet
            round += 1
        else:
            print("You have left the game with " + str(money) + " money")
            return
    print("You have run out of money")
    return
Beispiel #6
0
    def __init__(self):
        """
        Constructor, do the setup here.

        After setup with Solitaire.columns = 7, Solitaire.cards_in_column = 5
        You should have:
        self.tableau -> 7 columns of cards with 5 cards in each column
        self.stock -> 16 cards
        self.waste -> 1 card
        """
        self.deck = Deck()
        self.tableau = []
        self.waste = []
        self.stock = []
        self.deck.shuffle_deck()

        for col in range(Solitaire.columns):
            column = []
            # Deal cards to each column in range of given nr.
            for cards in range(Solitaire.cards_in_column):
                column.append(self.deck.deal_card())
            self.tableau.append(column)
        self.waste.append(self.deck.deal_card())

        while not self.deck.is_empty():
            self.stock.append(self.deck.deal_card())
Beispiel #7
0
    def start_game(self):

        print_info("Game started!")

        # Initialize Deck
        deck = Deck()
        deck.shuffle()
        # print_deck(deck)

        # Initialize all players
        print_info("Dealing {} cards each to {} players".format(
            self.numOfCardsPerPlayer, self.numOfPlayers))

        # Initialize player 0 - fork subprocess
        user_id = 0
        playerProcess = Thread(target=self.player_process,
                               args=(user_id, deck))

        self.threads.append(playerProcess)

        # Initialize CPU's - fork subprocesses for CPU's
        for cpu_id in range(1, self.numOfPlayers):

            # CPU Processes
            cpuProcess = Thread(target=self.cpu_process, args=(cpu_id, deck))

            self.threads.append(cpuProcess)

        for thread in self.threads:
            thread.start()

        self.turns[0].put(1)
    def __init__(self):
        """Creates the cards and sets up the images and labels for two cards
to be displayed, the state label, and two command buttons. """
        EasyFrame.__init__(self, title="Card Game")
        self.setSize(220,200)

        #create cards/deck
        self.card1=Deck()
        self.card="b"
        
      
        

        #labels
        self.cardLabel1= self.addLabel("",row=0, column=0, sticky= "NSEW",columnspan=2)
        
        self.stateLabel = self.addLabel(self.card, row = 1, column = 0,
                                        sticky = "NSEW",
                                        columnspan = 2)
        
        self.addButton(row = 2, column = 0,
                       text = "Draw",
                       command = self.nextDraw)
        
        self.addButton(row = 2, column = 1,
                       text = "New game",
                       command = self.newGame)
        
        self.refreshImages()
class TestDeck(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test52(self):
        self.assertEqual(len(self.deck), 52)

    def test_no_dupes(self):
        seen = set()
        for card in self.deck:
            self.assertNotIn(card, seen)
            seen.add(card)

    def test_repr_string(self):
        self.assertIsInstance(repr(self.deck), str)

    def test_shuffle(self):
        deck2 = Deck()
        random.shuffle(deck2)
        self.assertNotEqual(self.deck.cards, deck2.cards)

    def test_deal_5(self):
        hand = self.deck.deal(5)
        self.assertEqual(len(hand), 5)

    def test_draw(self):
        hand = self.deck.deal(5)
        self.deck.draw(hand)
        self.assertEqual(len(hand), 6)
Beispiel #10
0
 def defends(self, attack_cards, trump_suit):
     print("Here're your cards: ")
     self.deck.show()
     print("Comp attacks you with these cards: ")
     for i in range(len(attack_cards)):
         print(VALUES_DICT[attack_cards.get_card_by_index(i).value],
               attack_cards.get_card_by_index(i).suit)
     defend_cards = Deck()
     cards_indices = list(
         map(
             int,
             input(
                 "What cards do you put for attack? Write their indices (if you can't beat a card, type '-1'):  "
             ).split()))
     for card_index in cards_indices:
         for attack_card in attack_cards:
             if card_index == -1:
                 self.deck.add_cards(attack_cards)
                 return "You couldn't defend and picked up cards"
             defend_card = self.deck.get_card_by_index(card_index)
             if is_beatable(defend_card, attack_card, trump_suit) == False:
                 return "Wrong action"
             defend_cards.add_card(defend_card)
     print("You're throwing these cards: ")
     defend_cards.show()
     updated_deck = Deck()
     for j in range(len(self.deck)):
         if j in cards_indices:
             continue
         updated_deck.add_card(self.deck[j])
     self.deck = updated_deck
     print("Here're your cards now: ")
     self.deck.show()
     return "Defended succesfully"
Beispiel #11
0
 def __init__(self, player_list):
     self.player_list = player_list
     self.deck = Deck()
     self.deck.construct_new_deck()
     # Move dealer to end
     player_list.append(player_list.pop(0))
     self.game_end = False
Beispiel #12
0
    def __init__(self):
        """
        Constructor, do the setup here.

        After setup with Solitaire.columns = 7, Solitaire.cards_in_column = 5
        You should have:
        self.tableau -> 7 columns of cards with 5 cards in each column
        self.stock -> 16 cards
        self.waste -> 1 card
        """
        self.deck = Deck()  # -> Deck instance
        self.tableau = [
        ]  # -> list of (columns[lists] (where each list -> cards_in_column * Card instances))
        self.waste = []  # -> list of Card instances
        self.stock = []  # -> list of Card instances
        self.deck.shuffle_deck()  # ->  shuffle_deck() from package cards
        for column in range(self.columns):
            column = []
            for card in range(self.cards_in_column):
                column.append(
                    self.deck.deal_card())  # -> deal_card() from package cards
            self.tableau.append(column)
        self.waste.append(self.deck.deal_card())
        for card in range(len(self.deck.cards)):
            self.stock.append(self.deck.deal_card())
Beispiel #13
0
    def testAddCard(self):
        d = Deck()
        card = d.pop_card()
        self.assertEqual(51, len(d.cards))

        d.add_card(card)
        self.assertEqual(52, len(d.cards))
Beispiel #14
0
    def testPopCard(self):
        d = Deck()
        card = d.pop_card()

        self.assertEqual(12, card.rank)
        self.assertEqual(3, card.suit)
        self.assertEqual(51, len(d.cards))
Beispiel #15
0
def simulateAGame():
  P1Hand = Deck()
  P2Hand = Deck()
  community = buildCommunityDeck()
  for i in range(0,8):
    P1Hand.insertCard(community['mainDeck'].cards.pop())
    P2Hand.insertCard(community['mainDeck'].cards.pop())
#  print "player 2 cards"
#  P2Hand.revealSorted()
  print "Remaining:"
 # mainDeck.revealAll()
  b = Card(Color.RED.value,10)
  computer = ai.DumbAI()
  computer2=ai.AlwaysDraw()
  while True:
    if len(P2Hand)<8:
      raise Exception("P2 doesn't have 8 cards")
    if len(P1Hand)<8:
      raise Exception("P1 doesn't have 8 cards")
    print "Cards remaining: {}".format(len(community['mainDeck']))
    print "Player 1 cards"
    P1Hand.revealSorted()
    printGameBoard(community)
#    getMove("P1",P1Hand,community)
    computer.computerMakeMove("P1",P1Hand,community)
    if gameOver(community['mainDeck']):
      break
    print "Cards remaining: {}".format(len(community['mainDeck']))
   # P2Hand.revealSorted()
    printGameBoard(community)
   # getMove("P2",P2Hand,community)
    computer2.computerMakeMove("P2",P2Hand,community)
    if gameOver(community['mainDeck']):
      break
  return printGameSummary(community)
Beispiel #16
0
    def __init__(self):
        self._deck = Deck()
        self._deck.shuffle()

        #Pass the player and the dealer two cards each
        self._player = Player([self._deck.deal(), self._deck.deal()])
        self._dealer = Dealer([self._deck.deal(), self._deck.deal()])
Beispiel #17
0
class Cribbage:
    HUMAN = "human"
    COMPUTER = "computer"

    def __init__(self):
        self.deck = None
        self.starter = None
        self.board = None
        self.players = {Cribbage.HUMAN: HumanPlayer(),
                        Cribbage.COMPUTER: ComputerPlayer()}
        self.crib = []
        self.game_state = GAME_STATE_DONE

    def play(self):
        self.deck = Deck()
        self.board = {Cribbage.HUMAN: 0,
                      Cribbage.COMPUTER: 0}
        self.players[Cribbage.COMPUTER].deal([self.deck.draw() for c in range(6)], False)
        self.players[Cribbage.HUMAN].deal([self.deck.draw() for c in range(6)], False)

    def get_computer_cards(self):
        return self.players[Cribbage.COMPUTER].get_cards()

    def get_human_cards(self):
        return self.players[Cribbage.HUMAN].get_cards()

    def update(self):
        pass
Beispiel #18
0
 def generatePokerHands(self):
     """Generates every possible poker hand
     
     Returns
     -------
     num: integer
         Number of hand instances
     """
     deck_1 = Deck().cards
     for card_1 in deck_1:
         deck_2 = list(deck_1)
         deck_2.pop(deck_1.index(card_1))
         filename = 'poker_hand_%s_%s.data' % (card_1.suit, card_1.rank)
         file = open(filename, 'a+')
         for card_2 in deck_2:
             deck_3 = list(deck_2)
             deck_3.pop(deck_2.index(card_2))
             for card_3 in deck_3:
                 deck_4 = list(deck_3)
                 deck_4.pop(deck_3.index(card_3))
                 for card_4 in deck_4:
                     deck_5 = list(deck_4)
                     deck_5.pop(deck_4.index(card_4))
                     for card_5 in deck_5:
                         hand = self.createDataRow(
                             [card_1, card_2, card_3, card_4, card_5])
                         hand = str(hand).strip('[]')
                         file.write(hand + "\n")
                     deck_5.append(card_4)
                 deck_4.append(card_3)
             deck_3.append(card_2)
         deck_2.append(card_1)
         file.close()
Beispiel #19
0
def test_shuffle():
    deck = Deck()
    deck.shuffle()
    card1 = deck.draw_card()
    card2 = deck.draw_card()
    assert card1.rank != "King" and card1.suit != "Spades" and card2.rank != "King" and card2.suit != "Hearts"
    
Beispiel #20
0
    def __init__(self, server, channel):
        self.status = "Waiting for players to join"

        # Keep track of the current channel/server
        self.channel = channel
        self.server = server

        #flag to keep track of whether or not game is running
        self.running = True

        #list of active players in a game
        self.players = []

        #dummy with a small deck for testing.
        #replace with actual card loading from DB later
        self.deck = Deck()

        # Who is the current czar in self.players?
        # Starting at -1 so the first iteration has the czar be the first person to join
        self.current_czar = -1

        # What is the current black card?
        self.current_card = None

        # Cards submitted
        self.submissions = {}
Beispiel #21
0
 def test_deck_length1(self):
     x = Deck()
     card = Card("a", "b")
     x[:] = [card]
     actual = x.draw()
     self.assertEqual(actual, card)
     self.assertListEqual(x, [])
Beispiel #22
0
 def test_2elements(self):
     card1 = Card("a", "b")
     card2 = Card("c", "d")
     x = Deck([card1, card2])
     x.shuffle()
     # NOTE: don't check order because it has a 50% chance of not changing
     self.assertSetEqual(set(x), set([card1, card2]))
Beispiel #23
0
 def newDeck(self):
     """Create a new craps game and updates the view."""
     self.deck = Deck()
     self.deck.shuffle()
     self.stateLabel["text"] = ""
     card = ""
     self.refreshImages(card)
Beispiel #24
0
def deck_card_count_test():
    '''Testing create deck function, that it creates a 52 card deck'''
    d = Deck()
    if d.card_count() == 52:
        return True
    else:
        return False
Beispiel #25
0
    def __init__(self, mode=None, print_games=True):

        self.deck = Deck()
        self.mode = mode

        self.dealer_hand = []
        self.player_hand = []

        # deal out initial cards
        dealer_card = self.deck.draw()
        dealer_card.facing = "down"

        self.dealer_hand.append(dealer_card)
        self.player_hand.append(self.deck.draw())
        self.dealer_hand.append(self.deck.draw())
        self.player_hand.append(self.deck.draw())

        if print_games:
            logging.basicConfig(stream=sys.stdout,
                                level=logging.DEBUG,
                                format="%(message)s")
        else:
            logging.basicConfig(level=logging.CRITICAL)

        logging.info("--------- A GAME OF BLACKJACK ---------")
        logging.info(self)

        if self.mode == "stdin":
            while True:
                command = raw_input(
                    "What would you like to do? [s]tay, [h]it...")
                self.dealer_command(command)
Beispiel #26
0
def war(num_players = 4):
	deck = Deck().shuffle()
	decks = deck.split(num_players)
	human = Player(deck = decks[0])
	cpus = [Player(deck = decks[i+1]) for i in range(num_players-1)]
	# play game here, player.deck.cards.pop(0) removes and returns first card in player's deck
	return
Beispiel #27
0
 def test_3elements(self):
     card1 = Card("a", "b")
     card2 = Card("c", "d")
     card3 = Card("e", "f")
     x = Deck([card1, card2, card3])
     x.shuffle_riffle()
     self.assertSetEqual(set(x), set([card1, card2, card3]))
Beispiel #28
0
class DeckTest(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()

    def test_get_suit(self):
        self.assertEqual(self.deck.get_suit(0), 'Spades')
        self.assertEqual(self.deck.get_suit(13), 'Hearts')
        self.assertEqual(self.deck.get_suit(26), 'Diamonds')
        self.assertEqual(self.deck.get_suit(39), 'Clubs')

    def test_get_rank(self):
        self.assertEqual(self.deck.get_rank(0), 1)
        self.assertEqual(self.deck.get_rank(13), 1)
        self.assertEqual(self.deck.get_rank(26), 1)
        self.assertEqual(self.deck.get_rank(39), 1)

    def test_get_card(self):
        i = 0
        cardnumber = self.deck[i]
        card = (self.deck.get_rank(cardnumber), self.deck.get_suit(cardnumber))
        self.assertEqual(self.deck.get_card(i), card)

    def test_teek(self):
        self.assertEqual(self.deck.peek(0), self.deck[0])

    def test_shuffle(self):
        shuffled_deck = Deck()
        shuffled_deck.shuffle()
        self.assertNotEqual(self.deck, shuffled_deck)
Beispiel #29
0
 def test_full(self):
     x = Deck()
     x.reset()
     before = list(x)
     x.shuffle()
     after = list(x)
     self.assertTrue(before != after)
     self.assertSetEqual(set(x), set(before))
Beispiel #30
0
def test1():
    card1 = Card("spades", 10)
    card2 = Card("diamonds", 11)
    deck1 = Deck()
    deck1.add_card(card1)
    deck1.add_card(card2)
    for card in deck1:
        card.show_card()
Beispiel #31
0
def deck_deal_cards_test():
    d = Deck()
    h = Hand()
    d.deal_cards(h, 10)
    if d.card_count() == 42 and h.card_count() == 10:
        return True
    else:
        return False
    def reset_game(self):
        self.deck = Deck(self.ranks)
        self.deck.shuffle()
        self.cells = [[self.deck.draw() for i in range(4)] for j in range(9)]
        self.free_cell = None

        self.turn_history = []
        self.is_won = False
Beispiel #33
0
def hand_card_count_test():
    d = Deck()
    h = Hand()
    d.deal_cards(h, 8)
    if h.card_count() == 8:
        return True
    else:
        return False
Beispiel #34
0
 def test_deck_full(self):
     x = Deck()
     x.reset()
     expected_state_after = x[:-1]
     expected_card = x[-1]
     actual_card = x.draw()
     self.assertEqual(actual_card, expected_card)
     self.assertListEqual(x, expected_state_after)
Beispiel #35
0
 def test_deck_length2(self):
     x = Deck()
     card1 = Card("a", "b")
     card2 = Card("c", "d")
     x[:] = [card1, card2]
     actual = x.draw()
     self.assertEqual(actual, card2)
     self.assertListEqual(x, [card1])
Beispiel #36
0
    def test_num_cards(self):
        """ Test number of cards in deck is correct """
        d1, d13 = Deck(), Deck()
        d1.reload()
        d13.reload(13)
        d1_len, d13_len = len(d1.cards), len(d13.cards)

        self.assertEqual(d1_len, 52)
        self.assertEqual(d13_len, 676)
Beispiel #37
0
 def __init__(self, interface):
     # interface is an object for user interaction
     # Initializes the instance variables
     self.money = 100  # user starts with $100
     self.deck = Deck()  # start with a shuffled deck
     self.deck.shuffle()
     self.player = None  # player hand (initially None)
     self.dealer = None  # Dealer hand (initially None
     self.interface = interface  # for user interaction
Beispiel #38
0
 def __init__(self):
     """Sets up the two players, the war pile, the deck, and the
     game state."""
     self._player1 = Player()
     self._player2 = Player()
     self._warPile = []
     self._gameState = ""
     self._deck = Deck()
     self._deck.shuffle()
 def reset(self, deck=None):
     self.clear()
     self._moveLog = []
     if deck == None:
         self._deck = Deck()
         self._deck.shuffle()
     else:
         self._deck = deck
     self.deal()
     self.getPotentialMoves()
Beispiel #40
0
  def __init__(self, numberOfPlayers):
    # initialize local variables
    deck = Deck(WITHOUT_JOKERS)
    deck.shuffleDeck()

    # initialize class variables
    self.deck = deck
    self.numberOfPlayers = numberOfPlayers
    self.dealer = deck.getCards() # dealer gets all cards
    self.players = []
    for i in range(0, numberOfPlayers):
      self.players.append([]) # players get no cards
Beispiel #41
0
 def __init__(self):
     self.grid = []
     deck = Deck()
     deck.shuffle()
     n = 0
     for i in range(1,5):
         self.grid.append([])
         for j in range(1, 14):
             card = deck.cards[n]
             if card.rank[0] == "A":
                 card = None
             self.grid[i-1].append(card)
             n += 1
Beispiel #42
0
class CardDemo(Frame):

    def __init__(self):
        """Sets up the window and widgets."""
        Frame.__init__(self)
        self.master.title("Card Demo")
        self.grid()
        self._deck = Deck()
        self._backImage = PhotoImage(file = Card.BACK_NAME)
        self._cardImage = None
        self._imageLabel = Label(self, image = self._backImage)
        self._imageLabel.grid(row = 0, column = 0, rowspan = 3)
        self._textLabel = Label(self, text = "")
        self._textLabel.grid(row = 3, column = 0)

        self._dealButton = Button(self,
                                  text = "Deal",
                                  command = self._deal)
        self._dealButton.grid(row = 0, column = 1)
        self._shuffleButton = Button(self,
                                     text = "Shuffle",
                                     command = self._shuffle)
        self._shuffleButton.grid(row = 1, column = 1)
        self._newButton = Button(self,
                                 text = "New Deck",
                                 command = self._new)
        self._newButton.grid(row = 2, column = 1)

    def _deal(self):
        """If the deck is not empty, deals and displays the
        next card.  Otherwise, returns the program to its
        initial state."""
        card = self._deck.deal()
        if card != None:
            self._cardImage = PhotoImage(file = card.fileName)
            self._imageLabel["image"] = self._cardImage
            self._textLabel["text"] = str(card)
        else:
            self._new()
            
    def _shuffle(self):
        self._deck.shuffle()
        
    def _new(self):
        """Returns the program to its initial state."""
        self._deck = Deck()
        self._cardImage = None
        self._imageLabel["image"] = self._backImage
        self._textLabel["text"] = ""
Beispiel #43
0
	def pop_card(self):
		#All cards are used create an new deck of cards
		if self.deck.cards_left() == 0:
			self.deck = Deck(self.number_of_decks)
			self.deck.shuffle()

		return self.deck.pop_card()
Beispiel #44
0
    def __init__(self):
        """Sets up the window and widgets."""
        Frame.__init__(self)
        self.master.title("Card Demo")
        self.grid()
        self._deck = Deck()
        self._backImage = PhotoImage(file = Card.BACK_NAME)
        self._cardImage = None
        self._imageLabel = Label(self, image = self._backImage)
        self._imageLabel.grid(row = 0, column = 0, rowspan = 3)
        self._textLabel = Label(self, text = "")
        self._textLabel.grid(row = 3, column = 0)

        self._dealButton = Button(self,
                                  text = "Deal",
                                  command = self._deal)
        self._dealButton.grid(row = 0, column = 1)
        self._shuffleButton = Button(self,
                                     text = "Shuffle",
                                     command = self._shuffle)
        self._shuffleButton.grid(row = 1, column = 1)
        self._newButton = Button(self,
                                 text = "New Deck",
                                 command = self._new)
        self._newButton.grid(row = 2, column = 1)
Beispiel #45
0
	def __init__(self, name, sb=1, bb=2, ante=0, max_players=6, players=None, 
											min_buyin=None, max_buyin=None):
		self.id = name
		self.name = name

		self.sb = sb
		self.bb = bb
		self.ante = ante

		self.min_buyin = min_buyin or 50*bb
		self.max_buyin = max_buyin or 200*bb

		self.players = [None] * max_players
		if players:
			for i, p in enumerate(players):
				self.players[i] = p

		# http://www.learn-texas-holdem.com/questions/blind-rules-when-players-bust-out.htm
		self.owes_bb = set()
		self.owes_sb = set()

		# individual hand state
		self.deck = Deck()
		self.game_state = {
			"sb_idx": None,
			"bb_idx": None,
			"board": []
		}

		self.games = [HandHistory()]
Beispiel #46
0
 def __init__(self, dealer, tricks=None, hands=None, round_state=None,
              called_trump=None, trump=None, turn=None, maybe_trump=None,
              going_alone=None):
     deck = Deck()
     self.tricks = tricks or []
     self.hands = hands or [Hand(deck.deal(5)) for x in range(4)]
     # Other valid states: "bid2", "play", "end"
     self.round_state = round_state or "bid"
     self.called_trump = called_trump or None  # Nobody has called trump yet
     self.trump = trump or None                # Initially, there is no trump
     self.dealer = dealer                      # Player num
     self.turn = turn or (dealer + 1) % 4      # Who starts?
     # The card that might be trump
     self.maybe_trump = maybe_trump or deck.deal(1)[0]
     # Is the player who called trump going alone?
     self.going_alone = going_alone or False
Beispiel #47
0
 def __init__(self):
     self.desks = []
     self.bank_cards = []
     self.player_cards = []
     self.game_state = 2
     self.deck = Deck()
     self.deck.shuffle()
Beispiel #48
0
    def __init__(self, server, channel):
        self.status = "Waiting for players to join"

        # Keep track of the current channel/server
        self.channel = channel
        self.server = server

        #flag to keep track of whether or not game is running
        self.running = True

        #list of active players in a game
        self.players = []

        #dummy with a small deck for testing.
        #replace with actual card loading from DB later
        self.deck = Deck()

        # Who is the current czar in self.players?
        # Starting at -1 so the first iteration has the czar be the first person to join
        self.current_czar = -1

        # What is the current black card?
        self.current_card = None

        # Cards submitted
        self.submissions = {}
Beispiel #49
0
	def new_hand(self):
		self.log("===Starting hand {}===".format(len(self.games)))
		self.games.append(HandHistory())
		self.game_state['board'] = []
		self.deck = Deck()
		self.new_street()
		for player in self.get_active_players():
			player.new_hand()
Beispiel #50
0
    def __init__(self, players=None):
        self.game_over = False
        cards = Deck()
        divided_cards = cards.split_equally(4)
        if players is None:
            players = [DumbAI(hand=Hand(cards_list=hand), name='Player %s' % index) for index, hand in enumerate(divided_cards)]
        if all(player.hand is None for player in players):
            for idx, player in enumerate(players):
                player.hand = divided_cards[idx]

        self.players = players
        for player in self.players:
            player.create_players([p.name for p in self.players])

        print(*['%s - %s' % (player.name, player.hand) for player in self.players], sep='\n')

        self.present_trick = Trick(len(self.get_player_still_game()))
Beispiel #51
0
	def __init__(self):
		self.deckStyle = 'French'
		self.deck = Deck(self.deckStyle)
		self.playerLimit = [3,4,5,6,7]
		self.handLimit = [11,13,15,17,19,21,23]
		super(Rules, self).__init__()
		self.handCounter = 0
		self.hands = [Hand(n, self.handLimit) for n in range(self.handLimit)]
Beispiel #52
0
 def test_noargs(self):
     # if no args are given then the deck should be initialized to 52 cards
     x = Deck()
     self.assertEqual(len(x), 52)
     expected_elements = list(Deck.iter_cards())
     self.assertListEqual(x, expected_elements)
     rlock_type = type(threading.RLock())
     self.assertIs(type(x.lock), rlock_type)
Beispiel #53
0
	def __init__(self,h,n=5,b=1):
		self.Stat = Stats()
		self.number_of_decks = n
		self.house = h
		self.players = []
		self.deck = Deck(self.number_of_decks)
		self.minimum_bet = b
		self.deck.shuffle()
Beispiel #54
0
    def test_full(self):
        x = Deck()
        split_1 = 20
        split_2 = 30
        chunk1 = x[:split_1]
        chunk2 = x[split_1:split_2]
        chunk3 = x[split_2:]
        before = set(x)
        x.shuffle_3waycut(split_index_1=split_1, split_index_2=split_2)
        after = set(x)
        self.assertSetEqual(before, after)

        # make sure that each chunk is preserved in the deck
        chunks = [chunk1, chunk2, chunk3]
        for chunk in chunks:
            index = x.index(chunk[0])
            sublist = x[index:index+len(chunk)]
            self.assertListEqual(sublist, chunk)
Beispiel #55
0
	def __init__(self):
		super(Rules, self).__init__()
		self.deckStyle = 'French'
		self.deck = Deck(self.deckStyle)
		print self.deck
		self.playerLimit = [4]
		self.gameLimit = 0
		self.roundLimit = 0
		self.handLimit = 0
Beispiel #56
0
    def cah_madlib(self, server, event, bot):
        '''Entertaining function for dev, delete later.'''
        d = Deck()
        b = d.draw("black")
        madlib = b.body
        blanks = b.num_answers
        if blanks == 0:
            madlib += ' ' + d.draw("white").body.rstrip('.')
        elif madlib.count('_') == 0:
            madlib += ' ' + ', '.join([d.draw("white").body.rstrip('.') for x in range(blanks)])
        else:
            replacements = []
            madlib = madlib.replace("%","%%").replace("_", "%s")
            for i in range(blanks):
                replacements.append("\x02\x1F%s\x0F" % d.draw("white").body.rstrip('.'))
            madlib = madlib % tuple(replacements)

        server.privmsg(event.target, madlib)
Beispiel #57
0
    def __init__(self):
        # Create the deck
        self.deck = Deck(6)

        # Create the player
        self.player = Player(self.deck)

        # Create the dealer
        self.dealer = Dealer(self.deck, [self.player])
Beispiel #58
0
class DeckGUI(EasyFrame):

   def __init__(self):
      EasyFrame.__init__(self, title = "Testing a Deck Display")
      self.setSize(350, 200)
      self.deck = Deck()
      self.card = self.deck.deal()
      self.image = PhotoImage(file = self.card.fileName)
      self.cardImageLabel = self.addLabel("", row = 0, column = 0)
      self.cardImageLabel["image"] = self.image
      self.cardNameLabel = self.addLabel(row = 1, column = 0,
                                         text = self.card)
      self.button = self.addButton(row = 0, column = 1,
                                   text = "Next Card",
                                   command = self.nextCard)
      self.button = self.addButton(row = 1, column = 1,
                                   text = "Shuffle",
                                   command = self.shuffleDeck)
      self.button = self.addButton(row = 2, column = 1,
                                   text = "New Deck",
                                   command = self.newDeck)

   def nextCard(self):
      """Deals a card from the deck and displays it,
      or displays the back side if empty."""
      if len(self.deck) == 0:
         self.image = PhotoImage(file = Card.BACK_NAME)
         self.cardNameLabel["text"] = 'Empty'     
      else:   
         self.card = self.deck.deal()
         self.image = PhotoImage(file = self.card.fileName)
         self.cardNameLabel["text"] = self.card
      self.cardImageLabel["image"] = self.image

   def shuffleDeck(self):
     """Shuffles the existing deck of cards."""
     self.deck.shuffle()

   def newDeck(self):
      """Creates a new Deck object, assigns it to the window's deck, and
      updates the card images appropriately."""
      self.deck = Deck()
Beispiel #59
0
class Rules(Game):
	"""Rules for the game of 500"""
	def __init__(self):
		super(Rules, self).__init__()
		self.deckStyle = 'French'
		self.deck = Deck(self.deckStyle)
		print self.deck
		self.playerLimit = [4]
		self.gameLimit = 0
		self.roundLimit = 0
		self.handLimit = 0

	def deck(self):
		for cards in [(0,2),(1,2),(2,2),(3,2),(0,3),(1,3),(2,3),(3,3),(0,4),(1,4)]:
			card = Card(self.deckStyle, cards[0], cards[1])
			self.deck.remove(card)

	def dealing(self, players):
		for player in range(self.playerLimit):
			return player
Beispiel #60
0
    def setup(self, decks, games):

        ## Call shuffle
        deck = Deck().deck 

        for game in range(0, games):    

            # deal
            player_cards = []
            dealer_cards = []

            for card in range(0,2):
                player_cards.append(deck.pop())
                dealer_cards.append(deck.pop())

            # call player logic
            player_score = self.player_logic(player_cards, deck, dealer_cards[0])
            dealer_score = self.dealer_logic(dealer_cards, deck)

            for card in player_cards:
                print card

            for card in dealer_cards:
                print card

            print "Player score {0}".format(player_score)
            print "Dealer score {0}".format(dealer_score)

            if  player_score > 21:
                print "Dealer Wins :("
            else:                
                if  dealer_score > 21:
                    print "PLAYER WINS!! :D"
                else:
                    if player_score > dealer_score:
                        print "PLAYER WINS!! :D"
                    else:
                        print "Dealer Wins :("
            
            if game % 5 == 0:
                print "reshuffle!"