def __init__(self, number_of_players): #initialize players self.player = [] for i in range(number_of_players): self.player.append(Splendor_player("Player " + str(i + 1))) print("initialized " + str(number_of_players) + " players") #initialize decks #tier1 deck self.t1deck = deck.Deck() self.t1deck.add_cards_totop(loadcards("asset\\level1.csv")) self.t1inplay = [] #tier2 deck self.t2deck = deck.Deck() self.t2deck.add_cards_totop(loadcards("asset\\level2.csv")) self.t2inplay = [] #tier3 deck self.t3deck = deck.Deck() self.t3deck.add_cards_totop(loadcards("asset\\level3.csv")) self.t3inplay = [] #initialize token pool self.token_pool = Token_pool(7, 7, 7, 7, 7) #initialize nobles self.nobles = [None] * number_of_players for i in range(number_of_players): #randomize nobles pass #current_turn self.current_turn = 0
def shuffle_shoe(self, decks=6): """ Shuffle a new shoe of cards """ del self.shoe self.shoe = deck.Deck(True) for _ in range(1, decks): self.shoe.append(deck.Deck(True)) self.shoe.shuffle_deck()
def test_cut_deck(): d = deck.Deck() c = players.Computer(difficulty='easy') print(f"\n--------- TEST cut_deck() method computer -------------\n") print(f'\n-- before cut --\n') i = 0 for card in d.deck: i += 1 print(f'{i}) {card.name}') c.cut_deck(d) print(f'\n-- after cut --\n') i = 0 for card in d.deck: i += 1 print(f'{i}) {card.name}') d = deck.Deck() username = '******' email = '*****@*****.**' u = users.User(username=username, email=email) h = players.Human(user=u) print(f"\n--------- TEST cut_deck() method human -------------\n") print(f'\n-- before cut --\n') i = 0 for card in d.deck: i += 1 print(f'{i}) {card.name}') h.cut_deck(d) print(f'\n-- after cut --\n') i = 0 for card in d.deck: i += 1 print(f'{i}) {card.name}')
def testScoreTurn(self): p1 = Player("p1") p2 = Player("p2") p3 = Player("p3") p1.hand = deck.Deck([Card(TRUMP_SUIT, deck.RANK_OBER)]) p2.hand = deck.Deck([Card(deck.SUIT_HEARTS, deck.RANK_KING)]) p3.hand = deck.Deck([]) players = (p1, p2, p3) tablesAndResults = (((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(deck.SUIT_HEARTS, deck.RANK_10), Card(deck.SUIT_HEARTS, deck.RANK_8)), ([0, 10, 0], 1)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(deck.SUIT_HEARTS, deck.RANK_10), Card(deck.SUIT_HEARTS, deck.RANK_ACE)), ([0, 0, 20], 2)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(deck.SUIT_HEARTS, deck.RANK_10), Card(deck.SUIT_BELLS, deck.RANK_ACE)), ([0, 20, 0], 1)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(TRUMP_SUIT, deck.RANK_KING), Card(deck.SUIT_HEARTS, deck.RANK_8)), ([0, 0, 0], 1)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(TRUMP_SUIT, deck.RANK_OBER), Card(TRUMP_SUIT, deck.RANK_KING)), ([0, 0, 0], 2)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(deck.SUIT_HEARTS, deck.RANK_10), Card(TRUMP_SUIT, deck.RANK_8)), ([0, 0, 10], 2)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(deck.SUIT_HEARTS, deck.RANK_10), Card(TRUMP_SUIT, deck.RANK_ACE)), ([0, 0, 20], 2)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(TRUMP_SUIT, deck.RANK_10), Card(TRUMP_SUIT, deck.RANK_ACE)), ([0, 0, 20], 2)), ((Card(deck.SUIT_HEARTS, deck.RANK_9), Card(deck.SUIT_HEARTS, deck.RANK_OBER), Card(deck.SUIT_HEARTS, deck.RANK_ACE)), ([0, 20, 10], 2)), ((Card(TRUMP_SUIT, deck.RANK_KING), Card(deck.SUIT_HEARTS, deck.RANK_KING), Card(deck.SUIT_HEARTS, deck.RANK_ACE)), ([50, 0, 0], 0))) for cardsPlayed, scores in tablesAndResults: with self.subTest(cardsPlayed=cardsPlayed): self.assertEqual(scores, self.stdRules.scoreTurn(cardsPlayed, players))
def initTreasure(self): #hardcode ratio create deck of treasure for each city append ot list of treasure t = [] r1 = {0: 1, 1: 5, 2: 3, 4: 2} t.append(dk.Deck(r1, "t1")) r2 = {0: 1, 2: 5, 4: 3, 6: 2} t.append(dk.Deck(r2, "t2")) r3 = {0: 1, 4: 5, 6: 3, 9: 1} t.append(dk.Deck(r3, "t3")) r4 = {0: 1, 6: 5, 9: 3, 12: 1} t.append(dk.Deck(r4, "t4")) r5 = {9: 6, 12: 3} t.append(dk.Deck(r5, "t5")) r6 = {12: 6, 15: 3} t.append(dk.Deck(r6, "t6")) r7 = {15: 6} t.append(dk.Deck(r7, "t7")) r8 = {20: 6} t.append(dk.Deck(r8, "t8")) r9 = {25: 5} t.append(dk.Deck(r9, "t9")) return t
def setUp(self): self.deck1 = deck.Deck() self.deck1.prepare(1) self.deck2 = deck.Deck() self.deck2.prepare(2) self.deck3 = deck.Deck() self.deck3.prepare(3) self.empty_deck = deck.Deck()
def test_deckOrder(): """ Test that all new, unshuffled decks are in same order """ deck1 = deck.Deck() deck2 = deck.Deck() count = random.randint(0, 50) for i in range(count): card1 = deck1.draw() card2 = deck2.draw() assert ((card1.getSuit() == card2.getSuit()) and (card1.getValue() == card2.getValue()))
def main(): deck1 = deck.Deck() deck2 = deck.Deck() deck1.cardList = [20, 3, 5, 4, 4, 3, 1, 0, 0, 0] deck2.cardList = list(deck1.cardList) print deck1 print deck2 playGame(deck1, deck2, 1)
def test_random(): """ Test that a shuffled deck is in different order than new deck """ deck1 = deck.Deck() deck2 = deck.Deck() deck2.shuffle() card1 = deck1.draw() card2 = deck2.draw() assert ((card1.getSuit() != card2.getSuit()) or (card1.getValue() != card2.getValue()))
def generateprefloptables(): twosuitdeck = dk.Deck() for i in range(26): del twosuitdeck.deck[-1] print(twosuitdeck.deck) twosuithands = [] df = [] time = 0.0 twosuithands += itertools.combinations(twosuitdeck.deck, 2) for hand in twosuithands: df2 = [] start = timeit.default_timer() totequity = 0.0 deck1 = dk.Deck() for i in hand: deck1.deck.remove(i) startingHands = [] startingHands += itertools.combinations(deck1.deck, 2) print('# of starting hands: ', len(startingHands)) print("simplified hand: ", tools.simplehand(hand)) for hs in startingHands: if tools.simplehand(hand) not in [i[0] for i in df]: equity = calculate.equity([], [hand, hs])[0][0] totequity = totequity + equity df2.append((tools.simplehand(hs), equity)) if tools.simplehand(hand) not in [i[0] for i in df]: df2 = pd.DataFrame(df2) df2 = df2.groupby(0).mean() df2.to_csv('tables/' + tools.simplehand(hand) + '_equity.csv') totequity = totequity/len(startingHands) stop = timeit.default_timer() time = round(time + stop - start, 2) print('Total elapsed:', time, 'sec.\n') df.append((tools.simplehand(hand), totequity)) print("df", df) else: print("skipped!", tools.simplehand(hand)) df= pd.DataFrame(df) cards = ['A','K','Q','J','T','9','8','7','6','5','4','3','2'] startingHandsTable = pd.DataFrame(np.zeros((13, 13),dtype = int),index = cards,columns = cards) print(df) print(len(df)) df.to_csv('tables/totalequity.csv')
def __init__(self, rank_1_deck=None, rank_2_deck=None, rank_3_deck=None, noble_deck=None, game_bank=None): if rank_1_deck is None: self.rank_1_deck = deck.Deck(None) else: self.rank_1_deck = deck.Deck(rank_1_deck) if rank_2_deck is None: self.rank_2_deck = deck.Deck(None) else: self.rank_2_deck = deck.Deck(rank_2_deck) if rank_3_deck is None: self.rank_3_deck = deck.Deck(None) else: self.rank_3_deck = deck.Deck(rank_3_deck) if noble_deck is None: self.noble_deck = deck.Deck(None) else: self.noble_deck = deck.Deck(noble_deck) if game_bank is None: self.bank = bank.Bank(0, 0, 0, 0, 0) else: self.bank = game_bank self.rank_1_cards_deployed = [] self.rank_2_cards_deployed = [] self.rank_3_cards_deployed = [] self.noble_cards_deployed = []
def __init__(self, p1=None, p2=None): self.p1 = p1 self.p2 = p2 self.deck = deck.Deck() self.state = config.BEGIN self.active_player = self.p1 self.inactive_player = self.p2
def main(): """ draw cards, compare them and determine which player wins by comparing score variables :return: None """ deck1 = deck.Deck() deck1.shuffle() player1_score = 0 player2_score = 0 player1_cards, player2_cards = deal_cards(deck1) for x in range(0, 5): print("Player one has", player1_cards[x]) print("Player two has", player2_cards[x]) if compare_cards(player1_cards[x], player2_cards[x]) == "Player One": player1_score += 1 print("Player One wins this round!") else: player2_score += 1 print("Player Two wins this round!") print(" ") if player1_score > player2_score: print("Player One wins the game!") else: print("Player Two wins the game!")
def dealHand(deck): try: hand = deck.dealHand() except IndexError: deck = d.Deck() hand = deck.dealHand() return hand
def __init__(self): self.dealerHand = [] self.hiddenCard = None self.playerHand = [] self.mainDeck = deck.Deck() self.gameover = False self.finished = False # reveal card
def __init__(self, int_nrOfPlayers): """ Constructor. """ # Set number of players. self.int_nrOfPlayers = int_nrOfPlayers # Create 1 deck. self.gameDeck = deck.Deck() # Shuffle deck. self.gameDeck.shuffle() # Create X number of Hands (one for each player) based on previous input. self.list_playingPlayers = list() for i in range(0, int_nrOfPlayers): # Create player/Hand. self.list_playingPlayers.append( player.Player("Player" + str(i + 1))) # Give each player 2 starting cards. self.list_playingPlayers[i].takeCard(self.gameDeck) self.list_playingPlayers[i].takeCard(self.gameDeck) # List for players that are done playing/have stayed. self.list_stayingPlayers = list() # Create 1 dealer. self.dealer = player.Player("Dealer")
def gameSetUp(self): #set up equipment deck ratio = {"cloud": 20, "lightning": 18, "bird": 16, "pirate": 14} self.deck = dk.Deck(ratio, "deck") self.deck.shuffle() #start boat pos 0 self.setBoatLocation(0) #init players and hands self.player1 = ply.Player(self.deck) self.player2 = ply.Player(self.deck) self.player1.generateHand(self.deck) self.player2.generateHand(self.deck) self.player1.changeBoat(1) self.player2.changeBoat(1) self.player1.setCityLocation(self.boatLocation) self.player2.setCityLocation(self.boatLocation) #init treasure decks self.treasure = self.initTreasure() #init expectedValues self.generateRelativeTreasureValues() #generate dice rolls for round self.generateFutureRolls() #set staring captain (true to indicate first round/start of game) self.setCaptain(True)
def __init__(self): self.myDeck = deck.Deck() #Artificial Neuron AI self.p1 = Player.Player("Player1", 15) self.p2 = Player.Player("Player2", 5) p1Continue = False p2Continue = False
def main(): """ :return: the player's score """ score = 0 get_deck = deck.Deck() get_deck.shuffle_deck() length_deck = get_deck.get_length() while length_deck >= NUM_CARDS_IN_TWO_HANDS: length_deck = get_deck.get_length() - NUM_CARDS_IN_TWO_HANDS my_first_hand = get_a_hand(get_deck) my_second_hand = get_a_hand(get_deck) print('First hand: ', my_first_hand) print('Second hand: ', my_second_hand) result = my_first_hand.compare_to(my_second_hand) user = int( input( 'Type 1 if first hand wins, -1 if second hand wins, 0 if tie game: ' )) if user == result: print('Correct') score += 1 else: print('Wrong') print('Your score is: ', score) return if length_deck < NUM_CARDS_IN_TWO_HANDS: print('Out of cards to play, your score is: ', score) return
def test_empty_init(self): """Test default Deck object creation""" # 1. Create default Deck object mydeck = deck.Deck() # 2. Make sure it has the default values self.assertEqual(mydeck.size, deck.DEFAULT_SIZE) self.assertEqual(len(mydeck.cards), deck.DEFAULT_SIZE) # 3. Check methods self.assertEqual(str(mydeck), '0 1 2 3 4 ... 10002 10003 10004 10005 10006') mydeck.deal_into_new_stack() self.assertEqual(len(mydeck.cards), deck.DEFAULT_SIZE) self.assertEqual(str(mydeck), '10006 10005 10004 10003 10002 ... 4 3 2 1 0') mydeck.cut(3) self.assertEqual(len(mydeck.cards), deck.DEFAULT_SIZE) self.assertEqual(str(mydeck), '10003 10002 10001 10000 9999 ... 1 0 10006 10005 10004') mydeck.cut(-3) self.assertEqual(len(mydeck.cards), deck.DEFAULT_SIZE) self.assertEqual(str(mydeck), '10006 10005 10004 10003 10002 ... 4 3 2 1 0') mydeck.deal_with_increment(3) self.assertEqual(len(mydeck.cards), deck.DEFAULT_SIZE) self.assertEqual(str(mydeck), '10006 6670 3334 10005 6669 ... 6672 3336 0 6671 3335') self.assertEqual(mydeck.position(10006), 0) self.assertEqual(mydeck.position(6670), 1) self.assertEqual(mydeck.position(3334), 2) self.assertEqual(mydeck.position(10005), 3) self.assertEqual(mydeck.position(6669), 4) self.assertEqual(mydeck.position(6672), 10002) self.assertEqual(mydeck.position(3336), 10003) self.assertEqual(mydeck.position(0), 10004) self.assertEqual(mydeck.position(6671), 10005) self.assertEqual(mydeck.position(3335), 10006)
def test_deck_constructor(): print("\n--------- TEST Deck Constructor -------------\n") deck = d.Deck() print(f'---Length of deck is: {len(deck.deck)}\n') for card in deck.deck: print(f'- {card.name}')
def room_rendezvous(self, message_type, room_name_1): client = clt.Client() if (message_type == "host"): self.ip_port_seed = client.init_client( consts.ASK_HOST, room_name=room_name_1, seed=numpy.random.randint(9)) self.myTurn = True self.peer = peer.Peer(server_port=self.ip_port_seed[1], my_port=self.ip_port_seed[1]) self.peer.client_peer.active = True self.peer.server_peer.active = True elif (room_name_1 == ""): self.ip_port_seed = client.init_client(consts.ASK_ANY_OPP, room_name="") self.myTurn = False self.peer = peer.Peer(my_ip=self.ip_port_seed[0], server_port=self.ip_port_seed[1], my_port=self.ip_port_seed[1], listening=False) else: self.ip_port_seed = client.init_client(consts.ASK_ESP_OPP, room_name=room_name_1) self.myTurn = False self.peer = peer.Peer(my_ip=self.ip_port_seed[0], server_port=self.ip_port_seed[1], my_port=self.ip_port_seed[1], listening=False) self.deck = deck.Deck(self.ip_port_seed[2]) self.room_ui.room_window.hide() self.ui.main_window.show() self.ui.set_all_buttons(self.myTurn) self.play_control()
def handpercsq(hand, board, eff=0): startinghands = [] removal = [] d = dk.Deck() startinghands += itertools.combinations(d.deck, 2) for card in board: for h in startinghands: if card in h: removal.append(h) for card in hand: for h in startinghands: if card in h: removal.append(h) startinghands = [hand for hand in startinghands if hand not in removal] startinghands = [str(h[0]) + str(h[1]) for h in startinghands] startinghands = pd.DataFrame(startinghands) startinghands['rank'] = [[h[0:2], h[2:4]] for h in startinghands[0]] if eff == 0: startinghands['rank'] = [ calculate.handpercentile(h, board) for h in startinghands['rank'] ] elif eff == 1: startinghands['rank'] = [ calculate.effectivepercentile(h, board) for h in startinghands['rank'] ] startinghands = startinghands.set_index(0) startinghands = startinghands.sort_values('rank') startinghands = startinghands**2 return startinghands
def test_reset_and_shuffle_cards_restored(self): d = deck.Deck() for _ in xrange(15): d.cards.pop() d.reset_and_shuffle() self.assertEqual(52, len(d.cards))
def on_execute(self): if self.on_init() == False: self._running = False player1 = player.Player(0) player2 = player.Player(1) player3 = player.Player(2) player4 = player.Player(3) self.players = [player1, player2, player3, player4] self.deck = d.Deck(2) #add dealing here for i in range(4): self.players[i].deal_hand(self.deck) # trump_rank = 2 trump_suit = 0 for card in self.deck.cards: card.set_actual_suit(trump_suit, trump_rank) lord = 0 self.on_render() while (self._running): self.play_game(trump_rank, trump_suit, lord) self.on_cleanup()
def draw_from_shuffled_deck(): new_deck = deck.Deck() new_deck.shuffle_deck() new_hand = hand.Hand(new_deck.draw(num_of_cards=5)) #new_hand.show_hand() hand_rank = new_hand.hand_ranking() return hand_rank
def test_deck_deal_one(): print("\n--------- TEST Deck Deal One -------------\n") deck = d.Deck() for i in range(len(deck.deck)): print(f'Card Dealt: {deck.deal_one().name}') #testing exception/error handling deck.deal_one()
def test_drawCard(): d = deck.Deck(cards=[c1, c2]) desired_order = (c1, c2) # Shuffle until `c2` is at the top of the deck while tuple(d.cards) != desired_order: d.shuffle() original_length = len(d.cards) drawn = d.drawCard() # Make sure we actually drew `c2` as expected assert (hash(drawn) == hash(c2)) # Check that we decremented the # of cards by 1 assert (len(d.cards) + 1 == original_length) # `c2` is an equipment card, so it doesn't go back in the deck # Somewhere above we would append `drawn` to a Player's arsenal assert (len(d.discard) == 0) drawn = d.drawCard() # Make sure we actually drew `c1` as expected assert (hash(drawn) == hash(c1)) # `c1` is not an equipment card so it goes back in the deck assert (len(d.discard) == 1) # We lost `c2` to some player, so assert (len(d.discard) + len(d.cards) == original_length - 1)
def plot_shuffle_num(low_deck, high_deck, error_bar=0.005, deck_num=10000): results = [] for i in range(low_deck, high_deck): D = deck.Deck(range(i)) results.append( get_shuffle_num(D, error_bar=error_bar, deck_num=deck_num)) return results
def testDealCards(self): test_player = player.Player("test") test_card = card.Creature("test", "Creature", "B", "B", "", 4, 2) test_deck = deck.Deck("test_deck", [test_card] * 60) test_deck_copy = copy.copy(test_deck) test_player.hand = [] test_player.deck = test_deck_copy game.Game.deal_cards(game.Game, test_player, 7) self.assertTrue(len(test_player.hand) == 7) self.assertFalse(len(test_player.hand) == 6) test_deck_copy = copy.copy(test_deck) test_player.hand = [] test_player.deck = test_deck_copy game.Game.deal_cards(game.Game, test_player, 0) self.assertTrue(len(test_player.hand) == 0) self.assertFalse(len(test_player.hand) == 1) test_deck_copy = copy.copy(test_deck) test_player.hand = [] test_player.deck = test_deck_copy game.Game.deal_cards(game.Game, test_player, 5) self.assertTrue(len(test_player.hand) == 5) self.assertFalse(len(test_player.hand) == 1)