示例#1
0
def main():
    cardset = build_default_cardset()
    deck = card.Deck(cardset)

    user_cards = deck.draw(5)
    user_hand = Hand(user_cards)

    bot_cards = deck.draw(5)
    bot_hand = Hand(bot_cards)

    def colorize_card(card):
        s = str(card)
        if card.suit in [Suit.JOKER]:
            s = Color.blue(s)
        elif card.suit in [Suit.HEART, Suit.DIAMOND]:
            s = Color.red(s)
        return s

    def format_colored_hand(cards, hand, prefix):
        return prefix + " " + ", ".join(map(colorize_card, cards)) + \
               " ({})".format(hand)

    print(format_colored_hand(user_cards, user_hand, "Your hand:"))
    print(format_colored_hand(bot_cards, bot_hand, "Dealer hand:"))

    if user_hand == bot_hand:
        print("Draw")
    elif user_hand > bot_hand:
        print("You win!")
    else:
        print("You lose")
示例#2
0
    def gamePlay(self):
        self.deck = card.Deck()
        self.deck.shuffle()
        self.hands = self.deck.distribute(self.no_of_players, self.no_of_cards)
        for hand in self.hands:
            hand.checkForJokers()

        self.name = input('Enter your name ? ')
        self.hands[0].playerName = self.name
        while True:
            player = self.hands[self.turn]

            if self.turn != 0:
                # For Computer Player
                player.draw_card()

                if player.check_for_win():
                    self.gameOver(player)
                    break

                player.choose_and_drop_card()
                self.displayInfo()
            else:
                # For Human Player

                print(self.name)
                print('Your cards:')
                self.displayHand(player)

                print('On Floor:')
                floorCard = self.deck.get_top_card_on_floor()
                print(decorate(floorCard))

                print('Joker:', colored(card.rankName[self.deck.joker], 'red'))

                print(message1)
                inp = input('>>> ')
                if inp == '1':
                    player.pick_from_floor()
                else:
                    player.draw_from_deck()

                if player.check_for_win():
                    self.gameOver(player)
                    break

                self.displayHand(player)

                print(message2)

                index = self.getIndex()
                player.drop(player.cards[index - 1])

            self.nextTurn()
示例#3
0
 def __init__(self, player_name='Player'):
     self.values = dict({str(i): i
                         for i in range(2, 11)},
                        Ace=1,
                        Jack=10,
                        Queen=10,
                        King=10)
     self.deck = card.Deck()
     self.dealer = card.player('Dealer')
     self.player = card.player(player_name)
     self.player_wall = 28
     self.dealer_wall = 28
     self.table_string = '\n|{:>49}|'
示例#4
0
def main():

    myDeck = card.Deck()
    myDeck.shuffle()

    playerNo = int(input('Enter no of player? '))
    hands = myDeck.distribute(playerNo, 3)

    for hand in hands:
        print(colored(f'\n{hand.playerName}', 'cyan'))
        line = decorate(hand.getCardList())
        print(f'{line} \n')

    winner = findWinner(hands)

    showWinner(winner)
示例#5
0
    def __init__(self, size):
        self.deck = card.Deck()
        self.deck.create(size)
        self.deck.shuffle()
        self.deck.blackjack()

        self.playerDeck = []
        self.playerDeckBust = False
        self.playerSplitBust = False
        self.playerSplit = []
        self.playerSplitBool = False
        self.playerDouble = False
        self.playerSplitDouble = False
        self.dealerDeck = []

        self.playerTotal = 0
        self.playerSplitTotal = 0
        self.dealerTotal = 0
示例#6
0
def Monte_Carlo(bot, table):
    """
    A implimentation of the Monte Carlo algorithm, this algorithm works by taking
    a sample size of the different possibilities of what the remaining cards on the
    table will be and what cards the player has in their hand. It takes 10,000
    different samples and calculates if it will win in each scenario and returns
    how many times it won out of 10,000

    Inputs:
    bot - an object of the bot class, essentially our bot we will be playing against
    table - an object of the Table class

    Output: How many times the bot won in 10,000 scenarios

    Runtime: O(p*xlog(x) + plog(p)) where x=n+m where n is the the number of cards that the player
    has and m is the number of cards on the table and p is the number of players
    """
    count = 0
    for i in range(MONTE_CARLO_ITERATIONS):  #O(10,000)=O(1)
        my_deck = cardsets.Deck()
        my_deck.remove_card(bot.get_cards()[0])  #O(n)
        my_deck.remove_card(bot.get_cards()[1])  #O(n)

        for card in table.get_cards():
            my_deck.remove_card(card)

        listed_deck = my_deck.get_cards()
        x = sample(listed_deck, 7 - len(table.get_cards()))
        person = cardsets.Player(0, x[0:2])
        players = [person, bot]
        new_table = cardsets.Table(table.get_cards() + x[2:])

        if type(winner(
                new_table, players,
                printing=False)) is cardsets.Bot:  #O(p*xlog(x) + plog(p))
            count += 1

    return count
示例#7
0
        description='BlackJack Neural Network Tester')
    parser.add_argument('num_runs',
                        type=int,
                        help="number of runs to test the model")
    args = parser.parse_args()

    # run parameters
    num_runs = args.num_runs
    max_steps = 10

    # actions in world: hit, stay; split comes later
    actionCount = 2

    wins = 0
    push = 0
    deck = card.Deck()
    for i in range(num_runs):
        # reset environment
        deck.reset()
        deck.shuffle()

        dealer = []

        # Deal cards to dealer and player
        hand = []
        hand.append(deck.draw())
        dealer.append(deck.draw())
        hand.append(deck.draw())
        dealer.append(deck.draw())

        #print("Starting hand %s %s" %(hand[0],hand[1]))
示例#8
0
 def __init__(self):
     Player.__init__(self, "Dealer")
     self.chips = 10000
     self.deck = card.Deck()
示例#9
0
    def __init__(self):
        # initilize the gui
        gui.Desktop.__init__(self)
        self.connect(gui.QUIT, self.quit, None)

        # crate a container in APP
        self.c = gui.Container(width=800, height=750)

        # create a Deck
        deck = card.Deck()
        # reshuffle 2*3*playerAmount cards
        playerAmount = 4
        playerName_0 = 'Andy'
        playerName_1 = 'July'
        playerName_2 = 'Salary'
        playerName_3 = 'Alan'

        # -----------------------------------------------
        # step1. create a human player
        # -----------------------------------------------
        self.humanPlayer_0 = humanPlayer(playerName_0, self.c)
        self.EsUsed = 0
        self.stacks = stacks = deck.createCardField(playerAmount)

        # -----------------------------------------------
        # create a button to open the drating dialog
        # -----------------------------------------------
        b = gui.Button('Open Drafting Dialog')

        def ddo(self):
            self.humanPlayer_0.DecisionMaking_Drafting(self.stacks)
            # the game manager should monitor the confirm event from drafting dialog

        b.connect(gui.CLICK, ddo, self)

        def ddq(self):
            self.stacks = general.delcard(
                self.stacks, self.humanPlayer_0.getSelectedStackIndex())
            print('draft dialog closed, the latest amount of stacks is ',
                  len(self.stacks))

        self.hp0_ddcb = self.humanPlayer_0.getDraftDialogConfirmButton()
        self.hp0_ddcb.connect(gui.CLICK, ddq, self)
        self.c.add(b, 300, 500)

        # -----------------------------------------------
        # test  the function of open/close playing dialog
        # -----------------------------------------------
        self.openPlayingDialog = True
        buttonOCPD = gui.Button('Open/Close Playing Window')

        def ocpd(self):
            self.openPlayingDialog = not self.openPlayingDialog
            self.humanPlayer_0.showHidePlayDialog(self.openPlayingDialog)

        buttonOCPD.connect(gui.CLICK, ocpd, self)
        self.c.add(buttonOCPD, 50, 500)

        # -----------------------------------------------
        # test to capture the confirmation of playing from human player
        # -----------------------------------------------
        def pdq(self):
            print('get the confirmation from playing dialog')
            print(playerName_0, ' played ',
                  self.humanPlayer_0.getSelectedCard().getName(),
                  ' in this turn!')

        self.hp0_pdcb = self.humanPlayer_0.getPlayDialogConfirmButton()
        self.hp0_pdcb.connect(gui.CLICK, pdq, self)

        # -----------------------------------------------
        # create a button to test emergency stop card function
        # -----------------------------------------------
        bes = gui.Button('Open Emergency Stop Dialog')

        def eso(self):
            self.humanPlayer_0.startEsDialog()

        bes.connect(gui.CLICK, eso, self)
        self.c.add(bes, 500, 500)

        def cesd(self):
            self.EsUsed = self.humanPlayer_0.getEsUsed()

        self.humanPlayer_0.getEsDialogConfirmButton().connect(
            gui.CLICK, cesd, self)

        self.widget = self.c