def make_guess(self, game, drawn_tile, is_optional=False, view=None):
if view:
view.canvas.draw_game(game, drawn_tile=drawn_tile)
# Choose a player
prompt = "\nOf which player you want to guess a tile?" + (
"\nType -1 to not guess" if is_optional else "")
player_name = int(
self.save_prompt(
prompt,
list({str(p.name)
for p in game.players} - {str(self.name)}) + ['-1'],
view.master))
if is_optional and player_name == -1:
return None, None, None
chosen_player = [p for p in game.players if p.name == player_name][0]
# Choose a tile idx
prompt = "\nWhat is the idx of the tile? (Starting at 1)"
tile_idx = int(
self.save_prompt(
prompt,
[str(idx + 1)
for idx in range(len(chosen_player.tiles))], view.master)) - 1
# Choose the tile
prompt = "\nWhat tile do you think the player has. (Enter as b1 or w2)"
guess = Tile.from_string(
self.save_prompt(
prompt,
[str(t) for t in Tile.complete_set(game.max_tile_number)],
view.master))
return chosen_player, tile_idx, guess
def __init__(self,
amount_of_players=3,
amount_of_starting_tiles=4,
max_tile_number=7,
player_classes=SimpleRandomPlayer,
add_human_player=False):
if not isinstance(player_classes, list):
player_classes = [player_classes] * amount_of_players
self.max_tile_number = max_tile_number
self.unplayed_tiles = Tile.complete_set(max_number=max_tile_number)
# random.seed(9)
random.shuffle(self.unplayed_tiles)
self.players = []
for name, player_class in zip(list(range(amount_of_players)),
player_classes):
p = player_class(self.unplayed_tiles[:amount_of_starting_tiles],
name)
self.unplayed_tiles = self.unplayed_tiles[
amount_of_starting_tiles:]
self.players.append(p)
if add_human_player:
self.players.append(
HumanControlledPlayer(
self.unplayed_tiles[:amount_of_starting_tiles],
len(self.players)))
self.unplayed_tiles = self.unplayed_tiles[
amount_of_starting_tiles:]
self.current_player_idx = 0
def make_guess(self, game, drawn_tile, is_optional=False, view=None):
if is_optional:
return None, None, None
possible_tiles = list(
set(Tile.complete_set(max_number=game.max_tile_number)) -
self.all_known_tiles(game) - {drawn_tile})
# Try to get the player with the most invisible tiles
chosen_player = sorted(
[p for p in game.players if p.name != self.name],
key=lambda p: len([t for t in p.tiles if not t.visible]),
reverse=True)[0]
# Either choose high or low tile according to invisible tiles of the chosen player
half_tiles_idx = len(chosen_player.tiles) // 2
if len([t for t in chosen_player.tiles[:half_tiles_idx] if not t.visible]) > \
len([t for t in chosen_player.tiles[half_tiles_idx:] if not t.visible]):
# Choose a low possible tile
tile_idx, chosen_tile = sorted(
list(enumerate(chosen_player.tiles)),
key=lambda p: (p[1].visible, p[0]))[0]
guess = exponential_random_choice(
sorted([
t for t in possible_tiles if t.color == chosen_tile.color
]))
else:
# Choose a high possible tile
tile_idx, chosen_tile = sorted(
list(enumerate(chosen_player.tiles)),
key=lambda p: (p[1].visible, -p[0]))[0]
guess = exponential_random_choice(
sorted([
t for t in possible_tiles if t.color == chosen_tile.color
],
reverse=True))
return chosen_player, tile_idx, guess
def unknown_tiles(self):
return list(
set(Tile.complete_set(self.max_tile_number)) -
set(self.known_tiles))
