def prob_two_pairs(N=100000): M = 0 # no. of successes for exp in xrange(N): deck = Deck() hand = deck.hand(n=5) M += (same_rank(hand, 2) == 2) return float(M) / N
def prob_fourofakind(N=100000): M = 0 # no. of successes for exp in xrange(N): deck = Deck() hand = deck.hand(n=5) M += (same_rank(hand, 4) == 1) return float(M) / N
def __init__(self, *args, **kwargs): platform = pyglet.window.get_platform() display = platform.get_default_display() screen = display.get_default_screen() template = pyglet.gl.Config(double_buffer=True) config = screen.get_best_config(template) context = config.create_context(None) window.Window.__init__(self, resizable=True, width=WINWIDTH, height=WINHEIGHT, caption="REZD:" + str(VERSION), context=context) self.baseDeck = Deck() # used to lookup cards basically a reference instead of using a database. Basically don't remove / add cards self.baseDeck.populate('assets/cardlist.xml') self.newdeck = Deck() self.selectedCard = None self.runnerbaselist = [] self.corpbaselist = [] for card in self.baseDeck.deck: if card.playertype == "Runner": self.runnerbaselist.append(card.name) else: self.corpbaselist.append(card.name) self.runnerbaselist.sort() self.corpbaselist.sort() # kytten stuff self.theme = kytten.Theme(os.path.join(os.getcwd(), 'theme'), override={ "gui_color": [64, 128, 255, 255], "font_size": 14 }) self.theme2 = kytten.Theme(self.theme, override={ "gui_color": [61, 111, 255, 255], "font_size": 12 })
def battle(): print('\n#<====== Playing a Game of War ======>#\n') ## Creating p1Score, p2Score, ties variables. p1Score = 0 p2Score = 0 ties = 0 ## Creating two hands to hold cards (that are dealt for each player) h1 = [] h2 = [] ## Creating a new deck for the cards d = Deck() ## Shuffling the new deck d.shuffle() ## Using a loop to deal cards to the two players. for i in range(len(d.cards)): if i % 2 == 0: h1.append(d.deal()) elif i % 2 == 1: h2.append(d.deal()) i += 1 ## printing each player's hands print('\n#<====== Player 1\'s Hand: ======>#\n') for card in h1: print(card) print('\n#<====== Player 2\'s Hand: ======>#\n') for card in h2: print(card) print('\n#<====== Now its time for WAR!!! ======>#\n')
def playGame(self): while self.newGame != False: self.newGame = False print("Welcome to Bender's Totally Legit and Not Rigged at All Blackjack Table.") print("You're not a cop, are you? You have to tell me if you're a cop...") self.getPlayers() print("Welcome",self.player.name) self.player.startingCash() print(self.player.name, "has $",self.player.cash,"available") deck = Deck() dealer = Dealer() while self.replayGame != False: if len(deck.currentDeck) <= 10: house = deck.newDeck() round = Round(self) results = Results(self) score = Scoreboard(self) wager = score.placeBet(self.player.cash) if self.newGame == True: break round.startingHands(self.player, dealer, deck, house) round.takeAction(self.player, dealer, deck, house) if self.player.score <= 21 and self.player.score > 0: round.checkDealerHand(self.player, dealer, deck, house) results.determineWinner(self.player, dealer) self.player.cash = score.updateCash(self.player.cash, wager) print(self.player.name, "has $", self.player.cash, "available") replay = KeepPlaying() replay.replayGame(self.player, dealer) self.replayGame = replay.playAgain if self.newGame == False: print("I don't need you. I'll build my own casino. With Blackjack... and hookers... Awww, forget it.") elif self.newGame == True: print("Oops, you're broke! ¯\_(ツ)_/¯") print("Come back when you have some money to lose. (\/)(;,,;)(\/)")
def test(): """ Simple test program for card dragging. """ from Deck import Deck pygame.init() screen = pygame.display.set_mode((640, 480)) deck = Deck() handler = CardDraggingEventHandler(deck) while True: pygame.time.wait(30) for event in pygame.event.get(): if event.type == pygame.QUIT: return elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: sys.exit() else: handler.handle_card_dragging(event) screen.fill((0x00, 0xb0, 0x00)) deck.draw(screen) pygame.display.flip()
class DeckTest(unittest.TestCase): def setUp(self): self.deck = Deck() def test_createDeck(self): self.assertEqual(52, self.deck.getNumOfCards()) def test_shuffle(self): testDeck = self.deck.getAllCards() compareDeck = [] for card in testDeck: compareDeck.append(card) numOfSameCards = 0 for x in range(0, 52): if compareDeck[x] == testDeck[x]: numOfSameCards += 1 self.assertEqual(52, numOfSameCards) self.deck.shuffle() numOfSameCards = 0 for x in range(0, 52): if compareDeck[x] == testDeck[x]: numOfSameCards += 1 self.assertNotEqual(52, numOfSameCards) def test_getNextCard(self): newDeck = Deck() for x in range(0, 52): newDeck.getNextCard() with self.assertRaises((NameError)): newDeck.getNextCard()
def prob_same_suit(N=100000): M = 0 # no. of successes for exp in xrange(N): deck = Deck() hand = deck.hand(n=5) for suit in same_suit(hand): M += (same_suit(hand)[suit] in [4, 5]) return float(M) / N
def playBJ(self): deck = Deck(self.game_deck_num) deck.shuffleDeck() in_hand = True #print deck.printDeck(self.game_deck_num * 52) player_card1 = deck.dealCard(in_hand) dealer_card1 = deck.dealCard(in_hand) player_card2 = deck.dealCard(in_hand) dealer_card2 = deck.dealCard(in_hand)
def updateRatingsAI(self, table, setFound, the_time): '''AI was faster, so all sets involved are actually harder than we thought, ie increase their rating Please call whenever an AI finds a set ''' allSets = Deck.allSets(table) for the_set in allSets: try: self.ratingList[Deck.idOfSet(the_set)] += 50 except: self.ratingList[Deck.idOfSet(the_set)] = 1550 self.dumpData()
def __initializeDeck(self): # Initialize discard columns self.__discardPiles = [ Deck(), Deck(), Deck(), Deck() ] deck = Deck() deck.buildFullDeck() deck.shuffle() self.__deck = deck
def __init__(self, numPlayers=1, numAI = 3): """ basic set up for a game where: numPlayers = the total number of human players numAI = the number of the total players that are AI """ self.totPlayers = numPlayers + numAI #checking that there are atleast 2 players if (self.totPlayers) < 2: raise Exception('need atleast 2 players to play the game') self.deck = Deck() self.numPlayers = numPlayers self.numAI = numAI self.winners = [] #setting up the players self.players = [] [self.players.append(Player(len(self.players), game=self, AI = len(self.players) >= numPlayers)) for i in range(numPlayers + numAI)] for i in range(len(self.players)): self.players[i].setPrev(self.players[i-1]) self.players[i].setNext(self.players[(i + 1) % len(self.players)])
def __init__(self, num_players=1, num_decks=6): self.num_decks = num_decks self.dealer = Dealer() self.bot = Bot('Bot') self.players = [] self.busted = [] self.stand = [] self.move = 0 self.dealer_done = False self.bot_moves = [] for i in xrange(0,num_players): self.players.append(Player('Player'+str(i+1))) self.players.append(self.bot) self.deck = Deck(num_decks) self.bot_deck = self.deck.deck * 1 for player in self.players: player.make_bet() if player.name == 'Bot': player.add(self.bot_deck.pop()) player.add(self.bot_deck.pop()) self.bot_deck.pop() self.bot_deck.pop() else: player.add(self.deck.draw()) player.add(self.deck.draw()) self.dealer.add(self.deck.draw()) self.dealer.add(self.deck.draw()) self.rules = RulesEngine(self.dealer, self.players)
def __init__(self): self.moves = ["hit","stand","double","split"] self.deck = Deck() self.player = Player() self.player_hand = [] self.player_hand.append(Hand()) self.dealer_hand = Hand()
def __init__(self, table, message_handler=None): """players should be array of players to be seated. deal must be the player who is the current dealer. If None, the lowest seated player will be the dealer. message handler must be a MessageHandler instance or None.""" self.table = table self.message_handler = message_handler # # Private state not available to players # self._deck = Deck() self._deck.shuffle() active_players = self.table.get_active_players() # Create main pot to start with self.pot = Pot(contending_players = active_players) # Create initial hands for player in active_players: player.new_hand() # Record of betting rounds self.betting_rounds = []
def initialize_hand(self): self.move_button() self.pots = [Pot(self.players.keys())] self.rake = [0] self.action = self.button_seat self.deck = Deck() self.deck.shuffle() for position, player in self.players.iteritems(): player.discard_hole_cards() self.board = []
def start(self): self.currentPlayer = 0 self.deck = Deck() self.deck.shuffle() # Deal Cards i = 0 for card in self.deck.getNCards(11 * 4): self.players[i].hand.append(card); i = (i + 1)%4
def setUpHint(self): ''' unschedule any current hint and loads up the next one if appropriate''' # Need to remove any previous call or else it might be activated too # quickly Clock.unschedule(self.displayHint) Clock.unschedule(self.displayHintSecond) # After some time in seconds show a hint if self.hintActivated and self.active: self.hint = Deck.hint(self.cards) Clock.schedule_once(self.displayHint, self.displayHintTimer)
def __init__(self, players): self.players_byorder = players # Join order mapped to players self.players_bynick = {} # Current nick mapped to players for order, player in players.iteritems(): self.players_bynick[player.nick] = player self.answers = Deck(Config.FILENAME_ANSWERS) self.questions = Deck(Config.FILENAME_QUESTIONS) self.winner = None self.ids = [] for order, player in self.players_byorder.iteritems(): for i in range(Config.HAND_SIZE): player.addCard(self.answers.take()) # Deal initial hand to each player self.ids.append(order) self.idindex = 0 self.setter = self.players_byorder[self.ids[self.idindex]] # Current question-setter self.played = [] # List of tuples, each tuple composed of a card and the player that played it
def __init__(self, game, cd_kick): BaseClass.__init__(self) self.game = game self.deck = Deck() self.current_card = None self.players = [] self.turn = 0 self.played_time = None self.timeout = cd_kick self.turn_direction = 1 self.playing = False
def suggestion(self, table): all_sets = Deck.allSets(table) set_difficulties = [] for the_set in all_sets: set_difficulties.append(self.get_difficulties(the_set)) time, index = self.get_time(set_difficulties) set_cards1, set_cards2, set_cards3 = all_sets[index] return time, (set_cards1, set_cards2, set_cards3)
class Game(object): def __init__(self): self.players = [] for i in range(4): self.players.append(Player()) def start(self): self.currentPlayer = 0 self.deck = Deck() self.deck.shuffle() # Deal Cards i = 0 for card in self.deck.getNCards(11 * 4): self.players[i].hand.append(card); i = (i + 1)%4 def getCurrentPlayersHand(self): return sorted(self.players[self.currentPlayer].hand)
def on_enter(self): ''' Sets the game ''' # You can only enter the game from the intro self.deck = Deck() self.cards = self.deck.drawGuarantee(numberofcards=12) for i in range(len(self.scores_of_players)): self.scores_of_players[i] = 0 self.ai = AI(self.directory) self.aiScore = 0 self.game.active = True self.active = True self.newRound() self.t0 = datetime.datetime.now()
def newRound(self): self.deck = Deck() self.deck.shuffle() self.roundNum += 1 self.trickNum = 0 self.trickWinner = -1 self.heartsBroken = False self.dealer = (self.dealer + 1) % len(self.players) self.dealCards() self.currentTrick = Trick() self.passingCards = [[], [], [], []] for p in self.players: p.discardTricks()
def __init__(self): ''' Creates a new Game. ''' self._playerList = [] self._deck = Deck() self._deck.shuffle() self._discardPile = DiscardPile() self._currentPlayer = 0 self._currentCard = self._deck.drawCard() self._blankCards = { 'blue' : Card('blue', 'blank'), 'yellow' : Card('yellow', 'blank'), 'red' : Card('red', 'blank'), 'green' : Card('green', 'blank')}
class Dealer(object): def __init__(self, deck=None, discard_pile=None, payout_table=None): self.deck = Deck(52) self.discard_pile = DiscardPile() def shuffle_deck(self): temp_deck = Deck(0) for k in range(len(self.deck)): temp_deck.append(self.deck.pop(random.randint(0, len(self.deck)-1))) self.deck = temp_deck def deal_card(self): return self.deck.pop(0) def deal_indexed_card(self, index): return copy.copy(self.deck[index]) # return self.deck.pop(index)) def rate_hand(self): pass def collect_hand(self): pass
def playwar(): deck = Deck() deck.shuffle() n = deck.size() playerHand = Hand() compHand = Hand() deck.moveCards(playerHand, (n//2)) deck.moveCards(compHand, (n//2)) # playerHand.sort() # compHand.sort() print ("Cards in computer hand: ") print(compHand) print("Cards in player hands: ") print(playerHand) nowPlay(playerHand, compHand)
def updateRatingsHuman(self, table, setFound, the_time): '''updates the ratings of all sets involved in this round Please call whenever a human finds a set ''' initialRating = 1500 setFoundKey = Deck.idOfSet(setFound) try: setFoundRating = self.ratingList[setFoundKey] except KeyError: # first time this set shows up setFoundRating = initialRating losingSets = set(Deck.allSets(table)) - set(setFound) for the_set in losingSets: losingSetKey = Deck.idOfSet(the_set) try: losingSetRating = self.ratingList[losingSetKey] except KeyError: # first time this set shows up losingSetRating = initialRating newWinnerRating, newLoserRating = self.newRatings(setFoundRating, losingSetRating) self.ratingList[setFoundKey] = newWinnerRating self.ratingList[losingSetKey] = newLoserRating self.dumpData()
def __init__(self, timeout, gameTime, maxConnections): self.timeout = timeout self.gameTime = gameTime self.maxConnections = maxConnections self.connections = [] self.table = { '1' : None, '2' : None, '3' : None, '4' : None, '5' : None, '6' : None } self.lobby = [] self.deck = Deck() self.gameStarted = False self.dealerHand = [] self.hiddenCard = '' self.failJoin = []
def __init__(self, rounds=1000, *choices): # Variable declarations for counting self.flush = 0 self.fullHouse = 0 self.threeOfAKind = 0 self.fourOfAKind = 0 self.onePair = 0 self.twoPairs = 0 self.rounds = rounds self.choices = choices # Check for empty values if len(self.choices) == 0: sys.exit("Empty poker type not allowed") # Run game 10000 times for i in range(self.rounds): # Instantiate card and decks self.deck = Deck() self.deck.shuffle() # Play 10 rounds for j in range(10): self.poker = PokerHand() # Pick up 5 cards for k in range(5): self.poker.add(self.deck.deal()) # Check if cards are cetain types of pokers if self.poker.isFlush(): self.flush += 1 elif self.poker.hasFullHouse(): self.fullHouse += 1 elif self.poker.hasThreeOfAKind(): self.threeOfAKind += 1 elif self.poker.hasFourOfAKind(): self.fourOfAKind += 1 elif self.poker.hasOnePair(): self.onePair += 1 elif self.poker.hasTwoPairs(): self.twoPairs += 1
def __init__(self): self.deck = Deck()
from Deck import Deck from ExtraDeck import ExtraDeck from YGOPricesAPI import YGOPricesAPI deck = Deck(list()) extra = ExtraDeck(list()) card_list = YGOPricesAPI().get_names()
chips.lose_bet() def dealer_wins(player, dealer, chips): print("You lost!") chips.lose_bet() def push(player, dealer): print("Tied. Push") while True: print("Welcome to my blackjack game!") deck = Deck() deck.shuffle() player_hand = Hand() player_hand.add_card(deck.deal()) player_hand.add_card(deck.deal()) dealer_hand = Hand() dealer_hand.add_card(deck.deal()) dealer_hand.add_card(deck.deal()) player_chips = Chips() take_bet(player_chips) show_some(player_hand, dealer_hand)
from Deck import Deck import copy ourDeck = Deck(None, None) CardsDelt = copy.deepcopy(ourDeck.dealCards(10)) for Card in CardsDelt: print(type(ourDeck))
class Game: def __init__(self): self.deck = Deck() self.turn_count = 0 self.player_count = 1 self.index = 1 self.hands = [] def text_header(self): clear() print("UNO!\n") draw_pile_count = self.deck.get_draw_pile_count() top_card = self.deck.get_top_card() if len(self.hands) == self.player_count + 1: com_hand_count = len(self.hands[0]) print("COM hand: {} cards".format(com_hand_count)) if draw_pile_count >= 0: print("Draw pile: {} cards".format(draw_pile_count)) if top_card: print("Top card: {}".format(top_card)) print("") def start(self): """ Start the game: Display a header Deal cards Run until somebody wins """ self.text_header() self.deal() has_won = False while has_won != True: self.turn_count += 1 has_won = self.turn() if has_won == False: # Nobody won this turn, see what to do next next_player = self.index + 1 if next_player > self.player_count: next_player = 0 # start back at the beginning self.index = next_player player_name = "Player {}".format(self.index) if self.index == 0: player_name = "Computer" print("\n") print("{} won after {} turns!".format(player_name, self.turn_count)) print("GG :-)\n") def deal(self): """ Deal cards to players. """ deck = self.deck # Number of human players # TODO: adapt deal function to handle more players for j in range(0, self.player_count + 1): self.hands.append([]) for i in range(0, 14): if i % 2 == 1: # give human the card self.hands[0].append(deck.draw()) else: # give player the card self.hands[1].append(deck.draw()) deck.discard(deck.draw()) def turn(self): """ Run the current turn. Call a handler function for a human if this is a human turn (index does not equal 0) """ self.text_header() if self.index == 1: return self.human_turn() else: return self.computer_turn() def human_turn(self, message=None): """ Let the human play their turn; ask for instructions. """ self.text_header() my_hand = self.hands[self.index] my_hand_count = len(my_hand) if message: print(message) else: print("It's your turn. You have {} cards.".format(my_hand_count)) self.view_hand(my_hand) action_str = str(input("Type a number to choose a card or action: ")) if action_str == "D": new_card = self.deck.draw() my_hand.append(new_card) self.confirm("drew", my_hand, new_card) return self.human_turn("You drew {} last turn.".format(new_card)) else: action_int = None try: action_int = int(action_str) except ValueError: print("something went wrong") if action_int != None and action_int >= 0 and action_int <= my_hand_count - 1: # Picking a card card = my_hand[action_int] # Try to discard this card attempt = self.deck.discard(card) if attempt == True: # Toss the card out of my hand del my_hand[action_int] if my_hand_count - 1 == 0: # GG return True else: # Not yet GG return self.confirm("played", my_hand, card) else: return self.human_turn( "You can't play this card, try another!") else: return self.human_turn("This isn't a valid action!") def computer_turn(self): """ Let the computer play its turn. """ com_hand = self.hands[self.index] has_won = False has_played_card = False # Try to play available cards for index, card in enumerate(com_hand): attempt = self.deck.discard(card) if attempt == True: # Toss the card out of my hand del com_hand[index] if len(com_hand) == 0: # GG has_won = True has_played_card = True break # the for loop else: # Not yet GG has_played_card = True break # the for loop # If the computer hasn't played a card, # keep drawing until we can play one if has_played_card == False: # Draw more cards until we get a match while has_played_card == False: # Draw and try to discard this card new_card = self.deck.draw() attempt = self.deck.discard(new_card) if attempt == True: has_played_card = True else: com_hand.append(new_card) return self.confirm2("Computer", "drew and played a card") else: self.confirm2("Computer", "played a card") return has_won # --- # def view_hand(self, hand): """View the player's hand.""" print("D: Draw a card") for index, card in enumerate(hand): print("{}: {}".format(index, card)) print("") def confirm(self, word, hand, card): """Confirmation message when the player acts.""" self.text_header() print("You {} {}, and now have {} cards.".format( word, card, len(hand))) next = input("Press any key to continue...") return False def confirm2(self, who, word): """Confirmation message when the computer acts.""" self.text_header() print("{} {}.".format(who, word)) next = input("Press any key to continue...") return False
class Game: filename = "C:/Users/Owner/Documents/GitHub/Western-AI_Poker-Bot/Poker_Data.xlsx" wb = Workbook(write_only=True) ws = wb.create_sheet() def __init__(self, number_of_players): # Game Class variables self.deck = Deck() self.number_of_players = number_of_players self.player = [0] * self.number_of_players self.card = [0] * 5 # Review variable # self.player_card = [0] * self.number_of_players * 2 # Instantly start a new game self.excel_header() self.play() # Simulate x number of poker games def simulate(self, number_of_games): # Simulate poker games for n in range(number_of_games): if n % 10000 == 0: print("Game " + str(n + 1)) self.play() # Evaluate each player's hand for player in self.player: evaluate = EvaluateHand(self, player) hand_assignment = evaluate.count() # Export Data to Excel self.ws.append(self.extract_game_data(hand_assignment, n)) # Save Excel File self.wb.save( r"C:/Users/Owner/Documents/GitHub/Western-AI_Poker-Bot/Poker_Data.xlsx" ) # Play a game of Poker def play(self): self.deck.reset() # Draw Player Cards for p in range(self.number_of_players): self.player[p] = Player(self.deck, p) # Draw Game Cards for x in range(5): # Store cards in array self.card[x] = self.deck.draw() def extract_game_data(self, hand_assignment, n): p_list = [] b_list = [] for p in range(self.number_of_players): for card in self.player[p].get_hand(): p_list.append(card.get_suit()) p_list.append(card.get_value()) for card in self.card: b_list.append(card.get_suit()) b_list.append(card.get_value()) p_list.extend(b_list) p_list.extend([hand_assignment]) return (p_list) def excel_header(self): headers = [ 'Card 1 suit', 'Card 1 value', 'Card 2 suit', 'Card 2 value', 'Card 3 suit', 'Card 3 value', 'Card 4 suit', 'Card 4 value', 'Card 5 suit', 'Card 5 value', 'Card 6 suit', 'Card 6 value', 'Card 7 suit', 'Card 7 value', 'Label' ] self.ws.append(headers) def save_excel_file(self): self.wb.save() # Get Functions def get_players(self): return self.player def get_cards(self): return self.card # Placeholder Code def game_state(self): return self.card, self.card # Set Function def set_number_of_players(self, number_of_players): self.number_of_players = number_of_players def print(self): color_map = {0: "red", 1: "red", 2: "white", 3: "white"} suit_map = {0: "\u2764", 1: "\u2666", 2: "\u2660", 3: "\u2663"} number_map = { 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: '10', 11: 'J', 12: 'Q', 13: 'K', 14: 'A' } for player in self.get_players(): player_cards = player.get_hand() print("Player " + str(player.get_name())) for card in player_cards: string_color = color_map[card.get_suit()] string_card = suit_map[card.get_suit()] + " " + number_map[ card.get_value()] print(colored(string_card, string_color), end=" ") print() print("Game Cards") for card in self.get_cards(): string_color = color_map[card.get_suit()] string_card = suit_map[card.get_suit()] + " " + number_map[ card.get_value()] print(colored(string_card, string_color), end=" ") print() print()
else: print('Please enter a valid move number') def add_2card_hand_to(player): # deal 2 cards to the player player_hand = Hand() for _ in range(2): card = deck.deal_card() player_hand.add_card(card) player.add_hand(player_hand) # welcome print('\nWelcome To Python Blackjack!\n') deck = Deck() deck.shuffle() players = [] # set up players names = get_player_names() for name in names: players.append(Player(name)) for player in players: new_player, player.chips = get_player_bankroll(player.name) if new_player: print( f'Welcome {player.name}! Please accept these 1000 chips to begin.\n' ) else:
""" A game of War with two players and deck of 52 playing cards """ from Deck import Deck from Player import Player ranks = [ 'Ace', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Jack', 'Queen', 'King' ] suits = ['Hearts', 'Spades', 'Clubs', 'Diamonds'] #set up the game #create game deck game_deck = Deck(suits, ranks) game_deck.shuffle_deck() #create players and decks player_one = Player('Player One') player_two = Player('Player Two') while len(game_deck.cards) > 0: if len(game_deck.cards) % 2: player_one.add_to_deck([game_deck.deal_card()]) else: player_two.add_to_deck([game_deck.deal_card()]) #being 'duel' AT_WAR = True GAME_ON = True round_num = 0 while GAME_ON:
def __init__(self): self.Deck = Deck() self.Deck.Shuffle()
def playRound(self, n=13): # Initialize the round self.initializeRound(n) # Get the bets self.bettingRound() self.initialbets = self.bets # Initialize some state-dependent metrics to pass to AI self.card_played_by = {card.__str__(): None for card in Deck().cards} self.suit_trumped_by = {i: set() for i in range(4)} self.bet_deficits = list(self.bets) # Go through the rounds for t in range(0, self.num_rounds): # No lead suit yet Card.lead = -1 self.cards_this_round = {i: None for i in range(4)} # Save the current hands for history self.H_history[t] = deepcopy(self.H) order = range(4) # Permute player order if t > 0: # The previous winner should go first, then continue in order self.play_order[t] = order[self.T[t - 1]:] + order[:self.T[t - 1]] else: # Randomly choose who goes first first_player = rnd.randint(0, 3) self.play_order[ t] = order[first_player:] + order[:first_player] # Loop through players for p in self.play_order[t]: self.printVerbose( str(p + 1) + ': ' + str(self.bets[p]) + ' bet, ' + str(self.tricks[p]) + ' won') if self.player_strategy[p] == 0: # Ask for human input self.h[t][p] = self.humanInput(p) else: # Ask for AI input with strategy in player_strategy[p] self.h[t][p] = self.aiInput(p, t, self.player_strategy[p], self.H[p].validCards()) # Set the lead suit, if it hasn't been yet if Card.lead == -1: Card.lead = self.h[t][p].suit self.leads[t] = Card.lead # Update the state for the playing NN self.update_state(p, t) # Display what was played self.printVerbose(str(p + 1) + ': ' + str(self.h[t][p])) self.printVerbose('') # Update self.cards_this_round[p] = self.h[t][p] #update the card_played_by dict self.card_played_by[str(self.h[t][p])] = p if Card.lead != -1 and Card.lead != Card.trump: if self.h[t][p].suit == Card.trump: self.suit_trumped_by[Card.lead].add(p) # Find the winning player from the cards played this round self.T[t] = self.winner(self.h[t]) self.tricks[self.T[t]] = self.tricks[self.T[t]] + 1 self.printVerbose('Player ' + str(self.T[t] + 1) + ' won the trick.') self.bet_deficits[self.T[t]] -= 1
# GAMEPLAY! if __name__ == "__main__": player_Chips = Chips() print("Welcome to BlackJack!") while (True): print("How many chips would you like to bet? you have now {} ".format( player_Chips.total)) # if y is int , and you have Enough Chips to Play y = Error().Error_bet(player_Chips.total) player = Hand() dealer = Hand() card_in_game = Deck(Card().all_card) # 1 card to dealer random_choice = random.choices( card_in_game.cards) # random ...[('3', 'Hearts')].... card_in_game.Deck_pop(card_in_game.find_idx( random_choice[0])) # pop obj in card_in_game by idx dealer.add_card( random_choice, card_in_game.cart[random_choice[0][0]]) # add card to player # 2 card to dealer random_choice = random.choices( card_in_game.cards) # random ...[('3', 'Hearts')].... card_in_game.Deck_pop(card_in_game.find_idx( random_choice[0])) # pop obj in card_in_game by idx dealer.add_card(
def LetsPlay(): global play_status global player_cards_drawn global dealer_cards_drawn global game_deck flag = True human_player = Player() # clear_output() print("Welcome to BLACK-JACK command line GAME!!") print("Initially YOU are given 5000 Chips in Hand for play") while flag: chips_on_bet = 0 play_status = True game_deck = Deck() player_cards_drawn = [] dealer_cards_drawn = [] game_result = GAME_ON while True: chips_on_bet = input( "Enter Chips you want to bet(in multiples of 500): ") if chips_on_bet.isnumeric() and human_player.placebet( int(chips_on_bet)): chips_on_bet = int(chips_on_bet) break else: print( "Invalid input, please Try Again (Bet can't be greater than Chips in Hand)" ) print("Drawing 2 cards for PLAYER and 1 card for HOUSE....") time.sleep(3) player_cards_drawn.append(game_deck.drawcard()) player_cards_drawn.append(game_deck.drawcard()) dealer_cards_drawn.append(game_deck.drawcard()) print_table(play_status, dealer_cards_drawn, player_cards_drawn, game_deck, chips_on_bet, human_player) player_choice = True count = 1 while player_choice: print("\n1. Hit\n2. Stay\nInput your Choice(input 1 or 2): ") if int(input()) == 1: player_cards_drawn.append(game_deck.drawcard()) game_result = generate_result() if game_result == GAME_ON: # clear_output() print_table(play_status, dealer_cards_drawn, player_cards_drawn, game_deck, chips_on_bet, human_player) count += 1 else: play_status = False break else: player_choice = False if game_result == GAME_ON: print("Now, Drawing cards for HOUSE....") time.sleep(5) for _ in range(1, count + 1): dealer_cards_drawn.append(game_deck.drawcard()) game_result = generate_result() if game_result == GAME_ON: # clear_output() print_table(play_status, dealer_cards_drawn, player_cards_drawn, game_deck, chips_on_bet, human_player) else: break game_result = generate_result() if game_result == PLAYER_WINS or game_result == DEALER_BUSTED: human_player.chips_in_hand += (2 * chips_on_bet) play_status = False if game_result == PUSH: human_player.chips_in_hand += chips_on_bet else: # clear_output() print_table(play_status, dealer_cards_drawn, player_cards_drawn, game_deck, chips_on_bet, human_player) print("Do you wish to play again?(y/n): ") flag = input().lower() == 'y' print("Thank you for playing!")
from PrintHelper import print_table import time from Deck import Deck from Player import Player DEALER_WINS = 1 DEALER_BUSTED = -1 PLAYER_WINS = 2 PLAYER_BUSTED = -2 GAME_ON = 3 PUSH = -3 play_status = True game_deck = Deck() player_cards_drawn = [] dealer_cards_drawn = [] def generate_result(): dealer_result = game_deck.GetSumOfCards(dealer_cards_drawn) player_result = game_deck.GetSumOfCards(player_cards_drawn) if dealer_result <= 21: if dealer_result > player_result and not play_status: return DEALER_WINS elif player_result > 21: return DEALER_WINS else: return DEALER_BUSTED if player_result <= 21: if dealer_result < player_result and not play_status:
def compare_ranks(rank1, rank2): return Deck.rank_index(rank1) > Deck.rank_index(rank2)
class Game(object): def __init__(self): self.colors = ['red', 'green', 'blue', 'yellow', 'white'] self.deck = Deck(self) self.player_names = [] self.get_names() self.players = [Player(name) for name in self.player_names] self.hints = 8 self.max_hints = 8 self.fuses = 3 self.board = Board(self.colors) self.deal_cards() self.turns_left = len(self.players) self.next_players = {} self.current = self.players[0] self.make_next_player_names() self.journal = {} for player in self.player_names: self.journal[player] = [] self.play() # def get_names(self): # while True: # if len(self.player_names) >= 5: # break # value = raw_input("Enter a player's name. If all player names have been entered, type done.\n") # if value == 'exit': # os._exit(1) # elif value == "done": # if len(self.player_names) < 2: # print("There must be at least 2 players.") # continue # break # elif value in self.player_names: # print("Each name must be unique. Try again.") # continue # else: # self.player_names.append(value) def make_next_player_names(self): g = iter(list(range(1, len(self.player_names)))) for player in self.players: try: self.next_players[player.name] = self.players[next(g)] except StopIteration: self.next_players[player.name] = self.players[0] def get_player(self, name): for player in self.players: if player.name == name: return player return None def deal_cards(self): for each in self.players: if len(self.players) <= 3: while len(each.hand) < 5: each.hand.append(self.deck.deal()) else: while len(each.hand) < 4: each.hand.append(self.deck.deal()) def play(self): possible_actions = ['empty', 'discard_card', 'play_card', 'give_hint'] while self.turns_left > 0: self.print_board() if self.deck.len() == 0: self.turns_left -= 1 print( "\n There are no more cards to draw. This is your last turn." ) if self.hints == 0: action = self.get_valid_string( "\nPlayer {0}, choose an action: \n [1] Discard \n [2] Place a card. \n There are no more hints left. \n \n" .format(self.current.name), ['1', '2']) if self.hints > 0: action = self.get_valid_string( "\nPlayer {0}, choose an action: \n [1] Discard \n [2] Place a card \n [3] Give a hint. \n \n" .format(self.current.name), ['1', '2', '3']) getattr(self.current, possible_actions[int(action)])(self) self.journal[self.current.name] = [] self.current = self.next_players[self.current.name] print("Your turn is over.") self.clear_screen() print( "Pass the computer to {0}. Tell me when you're ready.".format( self.current.name)) self.clear_screen() final_score = sum( [card.number for card in self.board.displayed.values()]) # print("Game over. Your final score is {0}.".format(final_score)) # os._exit(1) # # def get_valid_string(self, prompt, valid_answers): # while True: # value = raw_input(prompt) # if value == 'exit': # os._exit(1) # if value not in valid_answers: # self.invalid_answers(value, valid_answers) # continue # else: # break # return value # def invalid_answers(self, value, valid_answers): # os.system('clear') # self.print_board() # print( # "\n{0} is not a valid response. Please try: {1}.\n".format(value, pretty_list_or(map(str, valid_answers)))) def print_board(self): if self.journal[self.current.name]: print("\nSince you last played: ") for line in self.journal[self.current.name]: print(line) print("\n" + self.board.__repr__()) print("Hints available: " + str(self.hints)) print("Fuses left: {0}\n".format(str(self.fuses))) if self.board.no_more: print("There are no more [{0}] cards. \n".format("] [".join( map(Card.__repr__, self.board.no_more)))) self.current.my_cards() other_player = self.next_players[self.current.name] while other_player != self.current: print(other_player.__repr__()) other_player = self.next_players[other_player.name]
from typing import List colors = dict(pink='\033[95m', blue='\033[94m', cyan='\033[96m', green='\033[92m', yelow='\033[93m', red='\033[91m', white='\033[0m', bold='\033[1m', under='\033[4m') match: bool = True order_numbers = 'Q J K A 2 3' order_suits = '♦ ♠♥ ♣' deck: Deck = Deck('Q J K A 2 3'.split(), '♠♣ ♥ ♦'.split()) teams: List[pl.Team] = [] players: List[pl.Player] = [] def set_number_of_players() -> int: while True: try: number: int = int( input(colors['white'] + "Enter the number of players (2, 4 or 6): ")) if number not in [2, 4, 6]: print(colors['red'] + 'invalid number') else: return number except ValueError:
class Game(object): def __init__(self, numPlayers=1, numAI=1): """ basic set up for a game where: numPlayers = the total number of human players numAI = the number of the total players that are AI """ self.totPlayers = numPlayers + numAI # checking that there are atleast 2 players if (self.totPlayers) < 2: raise Exception('need atleast 2 players to play the game') self.deck = Deck() self.numPlayers = numPlayers self.numAI = numAI self.winners = [] self.losers = [] self.tied = [] # For games with lives and discard piles. self.lives = [3 for i in range(self.totPlayers)] self.discardPile = [] self.theOneWhoKnocked = None # setting up the players self.players = [] [self.players.append(Player(len(self.players), game=self, AI=len(self.players) >= numPlayers)) for i in range(numPlayers + numAI)] for player in self.players: self.defineMoves(player) for i in range(len(self.players)): self.players[i].setPrev(self.players[i - 1]) self.players[i].setNext(self.players[(i + 1) % len(self.players)]) def play(self): self.dealHands() self.played = [self.deck.cards.pop()] player = self.players[0] while not self.endCondition(): print("--------------------------------------") print("It is player " + str(player.idNum) + " turn") played = player.play(self.played[-1]) if played: self.played.append(played) player = self.playerPlayed(player, played) if played else self.cantPlay(player) self.winMessage() def refillDeck(self): keep = [self.played.pop()] add = [] toAdd = self.played for it in toAdd: if type(it) is Card: add.append(it) self.deck.refill(add) self.played = keep # print("+++++++++++++++++++++++++++deck refilled from discarded +++++++++++++++") print(self.played) def defineMoves(self, player): if player.AI: player.AIFunction = self.defineAI else: player.humanFunction = self.defineHuman def endCondition(self): raise Exception("implemention must define this") def calculateScore(self, player): raise Exception("implemention must define this") def validPlays(self, player): raise Exception("implemention must define this") def cantPlay(self, player): raise Exception("implemention must define this") def playerPlayed(self, player, played): raise Exception("implemention must define this") def dealHands(self): raise Exception("implemention must define this") def winMessage(self): raise Exception("implementation must define this") def defineAI(self, player, allowed, prevPlay): raise Exception("implementation must define this") def defineHuman(self, player, allowed, prevPlay): raise Exception("implementation must define this") def __str__(self): return str(self.players)
class Game: def __init__(self): self.deck = Deck() self.players = self.playerSetUp() self.cardsPlayed = [] self.dealerChosen = False self.startingPlayerIndex = 0 def deal(self): while self.deck.cards: for player in self.players: player.draw(self.deck) for player in self.players: player.sortHand() def playerSetUp(self): players = [] for i in range(4): if i == 0: name = input("Please enter YOUR name: ") players.append(Player(name)) else: name = input("Please enter a player name: ") players.append(Player(name)) return players def cutForDealer(self): cutCards = [] lowPlayers = [] for i in range(4): d = self.deck.drawCard() cutCards.append(d) print(self.players[i].name + " drew the " + d.name()) lowestCard = Card("Plops", 99) for i in range(4): if cutCards[i].value < lowestCard.value: lowestCard = cutCards[i] lowestCard.show() for i in range(4): if cutCards[i].value <= lowestCard.value: lowPlayers.append(i) print(lowPlayers) if len(lowPlayers) != 1: print("Low players are:") print(lowPlayers) print("Equal lowest cards. Try again!") else: print(self.players[lowPlayers[0]].name + " drew the lowest card so they will pitch.") self.startingPlayerIndex = lowPlayers.copy()[0] self.dealerChosen = True return self.startingPlayerIndex def round(self): self.trick(self.startingPlayerIndex) def trick(self, leadPlayerIndex): trick = [] for i in range(4): if i == 0: leadCard = Card("Plops", 99) else: leadCard = trick[0] currentPlayerIndex = (leadPlayerIndex + i) % 4 if currentPlayerIndex == 0: print("Your legal cards are: ") for c in self.players[0].legalCards(leadCard): c.show() # self.players[0].legalCards(leadCard,self.heartsBroken).show() number = int(input("Input number of card you want: ")) try: card = self.players[0].legalCards(leadCard)[number] except: print("NOT GOOD") else: rand = random.randint( 0, len(self.players[currentPlayerIndex].legalCards( leadCard, self.heartsBroken)) - 1) card = self.players[currentPlayerIndex].legalCards( leadCard)[rand] self.players[currentPlayerIndex].hand.remove(card) trick.append(card) self.cardsPlayed.append(card) # print(self.players[currentPlayerIndex].name + " played the " + str(card.value) + " of " + card.suit) print(self.players[currentPlayerIndex].name + " played the " + card.name()) winningValue = 0 for c in trick: if c.suit == leadCard.suit and c.value > winningValue: winningCard = c winningValue = c.value winner = self.players[(self.startingPlayerIndex + trick.index(winningCard)) % 4] print(winner.name + " won the trick.") for c in trick: if c.suit == "Hearts": winner.points += 1 if c.equals(Card("Spades", 12)): winner.points += 13 self.startingPlayerIndex = self.players.index(winner) def run(self): if self.deck.cards == []: self.deck = Deck() self.deck.shuffle() while self.dealerChosen == False: self.startingPlayerIndex = self.cutForDealer() self.deck = Deck() self.deck.shuffle() self.deal() print("Your starting hand is: ") self.players[0].showHand() while len(self.cardsPlayed) != 52: self.round() for p in self.players: p.showScore() self.cardsPlayed = []
def __init__(self): self.deck = Deck() self.turn_count = 0 self.player_count = 1 self.index = 1 self.hands = []
def __init__(self): self.deck = Deck() self.players = self.playerSetUp() self.cardsPlayed = [] self.dealerChosen = False self.startingPlayerIndex = 0
class Game: def __init__(self): # self.players_cards = [] # self.dealers_cards = [] self.player = Player() self.dealer = Dealer() self.deck = Deck() self.deck.build_deck() self.deck.shuffle() #This runs the game def game_running(self): in_play = True while in_play: deck = Deck() # If either hand has 0 cards, deal a random card from the card list while len(self.player.hand) < 1 and len(self.player.hand) < 1: player_first_card = deck.deal() self.player.add_card(player_first_card) dealer_first_card = deck.deal() self.dealer.add_card(dealer_first_card) # Show the hand and ask player to hit or stay print(f" Your hand is: {self.player.show_hand()}") # print(f"Dealer's hand is: {self.dealer.display()}") choice = input("Please choose [Hit / Stay] ").lower() while choice not in ["h", "s", "hit", "stay"]: choice = input( "Please enter 'hit' or 'stay' (or H/S) ").lower() # If they hit, add card to their hand and update the score if choice == "hit" or choice == "h": #Deal a card to both player and dealer self.player.add_card(deck.deal()) self.dealer.add_card(deck.deal()) #This checks if dealer or player has blackjack player_blackjack, dealer_blackjack = self.check_blackjack() #If blackjack is True, this ends the game if player_blackjack or dealer_blackjack: return player_blackjack, dealer_blackjack elif choice == "stay" or choice == "s": #If player has higher score, player wins if self.player.get_hand() > self.dealer.get_hand(): print("Your hand was higher, you win!") print("Final Results") print("Dealer's hand:", self.dealer.reveal()) else: #If dealer has higher score, dealer wins, and reveals their cards print("You busted. The dealer wins") print("Final Results") print("Dealer's hand:", self.dealer.reveal()) # Checks if player or dealer has reached 21 or if the player has higher hand def check_blackjack(self): player_blackjack = False dealer_blackjack = False players_hand = self.player.calculate_hand() dealers_hand = self.dealer.calculate_hand() if players_hand == 21 or dealers_hand > 21: player_blackjack = True if dealers_hand == 21 or players_hand > 21: dealer_blackjack = True return player_blackjack, dealer_blackjack # When game is over ask to play # This method returns true or false if the player wants to play again def is_game_over(self, player_has_blackjack, dealer_has_blackjack): game_over = False # If this returns True then the game is over if player_has_blackjack and dealer_has_blackjack: game_over = True print("Draw!") if player_has_blackjack: game_over = True print("dealer busted. you win!") print(self.dealer.reveal()) print(self.player.show_hand()) if dealer_has_blackjack: game_over = True print(self.dealer.reveal()) print(self.player.show_hand()) print("You busted. The dealer wins") if game_over == True: play_again = input("Would you like to play again? Y/N ").lower() if play_again == "n": print("Thanks for playing BlackJack!") return True else: return False
class Game(): """docstring for Game""" def __init__(self): self.deck = Deck() self.deck.shuffle() self.table = Table() for i in range(12): self.table.addCard(self.deck.draw()) self.table.print() def begin(self): while not self.table.existSet(): for i in range(3): self.table.addCard(self.deck.draw()) print("How many players will be playing?") num_players = int(input("Enter a number greater than 0: ")) while num_players < 1: num_players = input("Enter a number greater than 0: ") self.table.print() self.players_score = [] for i in range(0, num_players): self.players_score.append(0) #for test print(self.players_score) def play(self): print("Who finds a set?") print( "Please enter your player number and the cards you pick (separated by space): " ) print( "For example, player1 picks cards 1, 2 ,3 should enter 1 1 2 3 in the command line." ) userInput = input().split() player = int(userInput.pop(0)) userInput = list(map(int, userInput)) userInput.sort() userInput.reverse() print(userInput) card1 = self.table.getCard(int(userInput[0])) card2 = self.table.getCard(int(userInput[1])) card3 = self.table.getCard(int(userInput[2])) while not self.table.isSet(card1, card2, card3): print("Sorry, it is not a set! Try again!") print( "Please enter your player number and the cards you pick (separated by space): " ) print( "For example, player1 picks cards 1, 2 ,3 should enter 1 1 2 3 in the command line." ) userInput = input().split() player = int(userInput.pop(0)) userInput = list(map(int, userInput)) userInput.sort() userInput.reverse() card1 = self.table.getCard(userInput[0]) card2 = self.table.getCard(userInput[1]) card3 = self.table.getCard(userInput[2]) self.players_score[player - 1] += 1 print("Congraduations, Player%i found a set!" % (player)) self.table.removeCard(userInput[0]) self.table.removeCard(userInput[1]) self.table.removeCard(userInput[2]) for i in range(1, 4): self.table.addCard(self.deck.draw()) while not self.table.existSet(): for i in range(1, 4): self.table.addCard(self.deck.draw()) self.table.print() def players_score(self): return self.players_score def finish(self): return self.deck.size() == 0 and not self.table.existSet()
def __init__(self): self.winner = 0 self.draw = False self.has_winner = False self.table: List[List[Card]] = [ [ W_C.copy(), S_10.copy(), S_Q.copy(), S_K.copy(), S_A.copy(), D_2.copy(), D_3.copy(), D_4.copy(), D_5.copy(), W_C.copy() ], [ S_9.copy(), H_10.copy(), H_9.copy(), H_8.copy(), H_7.copy(), H_6.copy(), H_5.copy(), H_4.copy(), H_3.copy(), D_6.copy() ], [ S_8.copy(), H_Q.copy(), D_7.copy(), D_8.copy(), D_9.copy(), D_10.copy(), D_Q.copy(), D_K.copy(), H_2.copy(), D_7.copy() ], [ S_7.copy(), H_K.copy(), D_6.copy(), C_2.copy(), H_A.copy(), H_K.copy(), H_Q.copy(), D_A.copy(), S_2.copy(), D_8.copy() ], [ S_6.copy(), H_A.copy(), D_5.copy(), C_3.copy(), H_4.copy(), H_3.copy(), H_10.copy(), C_A.copy(), S_3.copy(), D_9.copy() ], [ S_5.copy(), C_2.copy(), D_4.copy(), C_4.copy(), H_5.copy(), H_2.copy(), H_9.copy(), C_K.copy(), S_4.copy(), D_10.copy() ], [ S_4.copy(), C_3.copy(), D_3.copy(), C_5.copy(), H_6.copy(), H_7.copy(), H_8.copy(), C_Q.copy(), S_5.copy(), D_Q.copy() ], [ S_3.copy(), C_4.copy(), D_2.copy(), C_6.copy(), C_7.copy(), C_8.copy(), C_9.copy(), C_10.copy(), C_6.copy(), D_K.copy() ], [ S_2.copy(), C_5.copy(), S_A.copy(), S_K.copy(), S_Q.copy(), S_10.copy(), S_9.copy(), S_8.copy(), S_7.copy(), D_A.copy() ], [ W_C.copy(), C_6.copy(), C_7.copy(), C_8.copy(), C_9.copy(), C_10.copy(), C_Q.copy(), C_K.copy(), C_A.copy(), W_C.copy() ], ] self.deck = Deck() self.player1 = Player(self.deck, 1, self) self.player2 = Player(self.deck, 2, self)
def __shuffle(self): #creates new deck self.Deck = Deck() self.Deck.shuffle()
def gen_all_child_states(self, expand_type): if self.node_type == 'random': curr_deck = self.game_state.curr_player().deck other_deck = self.game_state.other_player().deck grouped = Deck.group(other_deck) types = [group[0].get_type() for group in grouped] probs = [len(group) / len(grouped) for group in grouped] probs /= np.sum(probs) new_children = [] for t, p in zip(types, probs): new_state = self.game_state.copy() new_state.turn_stop() new_state.turn_start(t) new_children.append( MTCSPlayer.MTCSNode(new_state, node_type='move', card_type=t, prob=p)) self.add_children(new_children) elif self.node_type == 'move': if expand_type == 'Full': curr_hand = self.game_state.curr_player().hand curr_table = self.game_state.curr_player().on_table spots_on_table = TABLE_SIZE - len(curr_table) legal_play_cards = list_of_possible_card_plays( curr_hand, spots_on_table, self.game_state.curr_player().mana) all_posible_plays = [ a + b for a, b in list( itertools.product(legal_play_cards, [ list(e) for e in self.game_state.possible_plays() ])) ] new_children = [] for nsa in all_posible_plays: try: new_state = self.game_state.copy() for a in nsa: new_state.make_action(*a) new_children.append( MTCSPlayer.MTCSNode(new_state, node_type='random', actions_from_parent=nsa)) except: pass self.add_children(new_children) elif expand_type == 'PlayCardNum' or expand_type == 'PlayCardScr': curr_hand = self.game_state.curr_player().hand curr_table = self.game_state.curr_player().on_table spots_on_table = TABLE_SIZE - len(curr_table) legal_play_cards = list_of_possible_card_plays( curr_hand, spots_on_table, self.game_state.curr_player().mana) k = 2 if len(legal_play_cards) < 5 else 4 scores = [len(e) for e in legal_play_cards] if expand_type == 'PlayCardNum' else \ [calc_att_plus_hp_for_cards(cards) for cards in [[id_from(self.game_state.curr_player().hand, play[1]) for play in plays] for plays in legal_play_cards]] best_inds = np.argpartition(scores, -k)[-k:] all_posible_plays = [ a + b for a, b in list( itertools.product( [legal_play_cards[i] for i in best_inds], [ list(e) for e in self.game_state.possible_plays() ])) ] new_children = [] for nsa in all_posible_plays: try: new_state = self.game_state.copy() for a in nsa: new_state.make_action(*a) new_children.append( MTCSPlayer.MTCSNode(new_state, node_type='random', actions_from_parent=nsa)) except: pass self.add_children(new_children) else: raise Exception('bad expand_type value')
class Dealer(object): def __init__(self): self.Deck = Deck() self.__shuffle() self.cards = [] self.winStatus = True self.bust = False self.matchBet = 0 def makeBet(self, playerBet): self.matchBet += playerBet def getMatchBet(self): return self.matchBet def clearHand(self): self.cards = [] self.bust = False self.matchBet = 0 def __shuffle(self): #creates new deck self.Deck = Deck() self.Deck.shuffle() def deal(self): return self.Deck.topCard() def checkCardsLeftInDeck(self): if len(self.Deck) < 20: self.__shuffle() #skip card[0] to keep it unknown until the end. #also, stop picking up cards when dealer has a total of 17 points def hand(self): print("Dealer has ", end="") for i in range(len(self.cards)): if i > 0: print(", ", end="") if i == (len(self.cards) - 1) and len(self.cards) >= 1: print("and ", end="") self.cards[i].showCard() return self.totalScore() def addCard(self, Card): self.cards.append(Card) def totalScore(self): total = 0 for i in range(len(self.cards)): total += self.cards[i].getPlayableValue( ) # doesn't incorporate Ace yet return total def getCards(self): return self.cards def playerWon(self): self.winStatus = True def hasPlayerWon(self): return self.winStatus def playerBust(self): return self.bust def bustPlay(self): self.bust = True
from Player import Player from Deck import Deck from Dealer import Dealer player = Player([], False, 100, 0, True) dealer = Dealer([], False, False, False, False) gameEnd = False # When the game starts, player turn is automatically set to true. while player.playerTurn: player.gameType(dealer) # Game running while not gameEnd: deck = Deck([]) deck.createDeck() player = Player([], player.isUser, player.balance, 0, True) dealer = Dealer([], dealer.isUser, False, False, False) # Player bets if player.isUser: print(f"Your current balance is: {player.balance}") player.desiredBet() print(f"Bet: {player.bet}") # Player bet is fixed, if dealer gametype is chosen if not player.isUser: player.bet = 20 # Creating the starting hands, and printing to terminal player.hand.append(dealer.dealCards(deck.deck))
def createDeck(self): if self.rigged: self.deck = RiggedDeck(1) else: self.deck = Deck(1)
def make_deck(self, joker): """Initialize the deck with the joker parameter.""" deck = Deck(joker, 100 - Card.width / 2, 75 - Card.height / 2) deck_area = DeckArea(self.scheme[3], self.hands) deck_area.update(deck) return deck, deck_area
def fetchDeck(self, url): html = self.getHTML(url) for a in html.find_all('a'): if a.get('href') and '/deck/download' in a.get('href'): return self.fetchDeckList('https://www.mtggoldfish.com/{0}'.format(a.get('href'))) return Deck(url)