150 lines
5 KiB
Python
150 lines
5 KiB
Python
import random
|
|
|
|
NB_PLAYERS = 2
|
|
NB_TRIES = 10000
|
|
VERBOSE = True
|
|
|
|
class Game():
|
|
|
|
cards: dict
|
|
status: str
|
|
winner: int
|
|
nb_players: int
|
|
verbose: bool
|
|
MAX_HANDS = 10000
|
|
|
|
|
|
def shuffle_deal(nb_players):
|
|
elements = [i for i in range(1, 7) for _ in range(6)]
|
|
|
|
if len(elements) % nb_players!= 0:
|
|
raise ValueError("List cannot be divided into {} equal parts".format(nb_players))
|
|
|
|
random.shuffle(elements)
|
|
sublist_size = len(elements) // nb_players
|
|
return {i:elements[i:i + sublist_size] for i in range(0, nb_players)}
|
|
|
|
|
|
def __init__(self, nb_players, init_state=False, verbose=True):
|
|
self.status = 'playing'
|
|
self.nb_players = nb_players
|
|
self.verbose = verbose
|
|
if init_state:
|
|
self.cards = init_state
|
|
else:
|
|
self.cards = Game.shuffle_deal(nb_players)
|
|
self.winner = None
|
|
|
|
|
|
def __str__(self):
|
|
s = f'{self.nb_players} players in game - {self.status}\n'
|
|
for k,v in self.cards.items():
|
|
s += f'Player {k} cards: {v}\n'
|
|
return s
|
|
|
|
|
|
def keys_of_max_values(hand):
|
|
max_indexes = []
|
|
if hand.values():
|
|
max_value = max(hand.values())
|
|
max_indexes = [k for k, v in hand.items() if v == max_value]
|
|
return max_indexes
|
|
|
|
|
|
def get_round_remaining_players(self):
|
|
return [k for k,v in self.cards.items() if v]
|
|
|
|
|
|
def play_hand(self):
|
|
# at the beginning of the hand we assume all players should have at least 1 card in their stack
|
|
rrp = self.get_round_remaining_players()
|
|
test_cards = {k: self.cards[k][0] for k in rrp}
|
|
trick_cards = [self.cards[k].pop(0) for k in rrp]
|
|
|
|
hand_remaining_players = Game.keys_of_max_values(test_cards)
|
|
|
|
# case when at least 2 cards of the hand have the same value
|
|
while len(hand_remaining_players) > 1:
|
|
|
|
# test that there's enough cards in decks before doing this
|
|
for k in hand_remaining_players:
|
|
if self.cards[k]:
|
|
trick_cards.append(self.cards[k].pop(0))
|
|
|
|
# test that there's enough cards in decks
|
|
test_cards = {}
|
|
for k in hand_remaining_players:
|
|
if self.cards[k]:
|
|
test_cards[k] = self.cards[k].pop(0)
|
|
|
|
trick_cards.extend(list(test_cards.values()))
|
|
hand_remaining_players = Game.keys_of_max_values(test_cards)
|
|
|
|
rrp = self.get_round_remaining_players()
|
|
if len(rrp) == 0 and len(test_cards) == 0:
|
|
self.status = 'finished'
|
|
self.winner = -1
|
|
if self.verbose:
|
|
print(f'==== Game ended in a draw ====')
|
|
elif len(rrp) == 0 and len(test_cards) > 0:
|
|
self.status = 'finished'
|
|
self.winner = hand_remaining_players[0]
|
|
elif len(rrp) == 1 and rrp == hand_remaining_players:
|
|
self.status = 'finished'
|
|
self.winner = rrp[0]
|
|
else:
|
|
hand_winner = hand_remaining_players[0]
|
|
if self.verbose:
|
|
print(f'Player {hand_winner} won the hand!')
|
|
# distribute the cards to the winning player
|
|
self.cards[hand_winner].extend(trick_cards)
|
|
|
|
|
|
def play_round(self):
|
|
if self.verbose:
|
|
print('--- Starting game ---')
|
|
i = 1
|
|
while self.status == 'playing' and i <= Game.MAX_HANDS:
|
|
if self.verbose:
|
|
print(f'--- Playing hand {i} ---')
|
|
print(str(self))
|
|
self.play_hand()
|
|
if self.status == 'finished':
|
|
if self.verbose:
|
|
print(f'==== Game finished after {i} hands - Player {self.winner} won the game =====')
|
|
return i
|
|
elif i == Game.MAX_HANDS:
|
|
if self.verbose:
|
|
print(f'Forced game to finish - infinite loop')
|
|
return 0
|
|
else:
|
|
i += 1
|
|
|
|
|
|
# Run a simulation on many games
|
|
def simulate(n_games):
|
|
nb_hands_to_finish_game = []
|
|
for _ in range(n_games):
|
|
g = Game(NB_PLAYERS,verbose=False)
|
|
nb_hands = g.play_round()
|
|
nb_hands_to_finish_game.append(nb_hands)
|
|
del g
|
|
return nb_hands_to_finish_game
|
|
|
|
|
|
r = simulate(NB_TRIES)
|
|
print(f"Number of games that didn't finish {len([e for e in r if e == 0])}")
|
|
print(f"Average number of hands to finish a game {sum(r)/len([e for e in r if e != 0])}")
|
|
print(f"Min-Max number of hands to finish a game {min([e for e in r if e != 0])} - {max(r)}")
|
|
|
|
# init_s = {0: [5, 3, 5, 1, 1, 2, 4, 1, 4, 6, 2, 6, 3, 6, 4, 2, 5, 3],
|
|
# 1: [3, 5, 1, 1, 2, 4, 1, 4, 6, 2, 6, 3, 6, 4, 2, 5, 3, 5]}
|
|
|
|
# init_s = {0: [6, 1, 6, 5, 3, 3, 2],
|
|
# 1: [1, 2, 5, 3, 3, 3, 3, 2, 3, 3, 2, 6, 2, 3, 1, 3, 6, 3, 6, 1, 1, 6, 3],
|
|
# 2: [6, 1, 6, 1, 3],
|
|
# 3: [1]}
|
|
|
|
# g = Game(4, init_s)
|
|
# nb_hands = g.play_round()
|
|
# print(nb_hands)
|