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)
