def select(self, active_cards, game_state):
"""
Choose the character to activate whithin
the given choices.
"""
available_characters = [
character.display() for character in active_cards
]
question = {
"question type": "select character",
"data": available_characters,
"game state": game_state
}
selected_character = ask_question_json(self, question)
if selected_character not in range(len(active_cards)):
warning_message = (
' ! : selected character not in '
'available characters. Choosing random character.')
logger.warning(warning_message)
selected_character = randint(0, len(active_cards) - 1)
perso = active_cards[selected_character]
# log
logger.info(f"question : {question['question type']}")
logger.info(f"answer : {perso}")
del active_cards[selected_character]
return perso
def actions(self):
"""
phase = tour
phase 1 : IFFI
phase 2 : FIIF
first phase : initially num_tour = 1, then 3, 5, etc.
so the first player to play is (1+1)%2=0 (inspector)
second phase : num_tour = 2, 4, 6, 8, etc.
so the first player to play is (2+1)%2=1 (fantom)
"""
first_player_in_phase = (self.num_tour + 1) % 2
if first_player_in_phase == 0:
logger.info(
f"-\nshuffle {len(self.character_cards)} character_cards\n-")
shuffle(self.character_cards)
self.active_cards = self.character_cards[:4]
else:
self.active_cards = self.character_cards[4:]
# the characters should be able to use their power at each new round
for card in self.active_cards:
card.power_activated = False
for i in [
first_player_in_phase, 1 - first_player_in_phase,
1 - first_player_in_phase, first_player_in_phase
]:
self.players[i].play(self)
def init_connexion():
while len(clients) != 2:
link.listen(2)
(clientsocket, addr) = link.accept()
logger.info("Received client !")
clients.append(clientsocket)
clientsocket.settimeout(10)
def tour(self):
# log
logger.info("\n------------------")
logger.info(self)
logger.debug(json.dumps(self.update_game_state(""), indent=4))
# work
self.actions()
self.fantom_scream()
for p in self.characters:
p.power = True
self.num_tour += 1
def play(self, game):
logger.info("--\n" + self.role + " plays\n--")
logger.debug(json.dumps(game.update_game_state(""), indent=4))
charact = self.select(game.active_cards,
game.update_game_state(self.role))
# red character can choose to activate its power
# before OR after moving
if charact.color == "red":
activation_possibilities = ["before", "after"]
question = {
"question type": "red character power activation time",
"data": activation_possibilities,
"game state": game.update_game_state(self.role)
}
power_activation_time = ask_question_json(self, question)
if power_activation_time not in [0, 1]:
power_activation_time = random.choice(activation_possibilities)
else:
power_activation_time = activation_possibilities[
power_activation_time]
# now play red character
if power_activation_time == "before":
moved_characters = self.activate_power(
charact, game, before | both,
game.update_game_state(self.role))
self.move(charact, [charact], game.blocked,
game.update_game_state(self.role))
else:
self.move(charact, [charact], game.blocked,
game.update_game_state(self.role))
self.activate_power(charact, game, after | both,
game.update_game_state(self.role))
# character is not red
else:
moved_characters = self.activate_power(
charact, game, before | both,
game.update_game_state(self.role))
self.move(charact, moved_characters, game.blocked,
game.update_game_state(self.role))
self.activate_power(charact, game, after | both,
game.update_game_state(self.role))
def play(self, game):
logger.info("--\n" + self.role + " plays\n--")
logger.debug(json.dumps(game.update_game_state(""), indent=4))
charact = self.select(game.active_cards,
game.update_game_state(self.role))
# purple and brown power choose to activate or not before moving
moved_character = self.activate_power(
charact, game, before, game.update_game_state(self.role))
self.move(charact, moved_character, game.blocked,
game.update_game_state(self.role), game)
self.activate_power(charact, game, after,
game.update_game_state(self.role))
def fantom_scream(self):
partition: List[Set[Character]] = [{
p
for p in self.characters if p.position == i
} for i in range(10)]
if len(partition[self.fantom.position]) == 1 \
or self.fantom.position == self.shadow:
logger.info("The fantom screams.")
self.position_carlotta += 1
for room, chars in enumerate(partition):
if len(chars) > 1 and room != self.shadow:
for p in chars:
p.suspect = False
else:
logger.info("the fantom does not scream.")
for room, chars in enumerate(partition):
if len(chars) == 1 or room == self.shadow:
for p in chars:
p.suspect = False
self.position_carlotta += len(
[p for p in self.characters if p.suspect])
def play(self, game):
logger.info("--\n" + self.role + " plays\n--")
logger.debug(json.dumps(game.update_game_state(""), indent=4))
charact = self.select(game.active_tiles,
game.update_game_state(self.role))
moved_characters = self.activate_power(charact,
game,
before | two,
game.update_game_state(self.role))
self.move(charact,
moved_characters,
game.blocked,
game.update_game_state(self.role))
self.activate_power(charact,
game,
after | two,
game.update_game_state(self.role))
def move(self, charact, moved_characters, blocked, game_state):
"""
Select a new position for the character.
"""
pass_act = pink_passages if charact.color == 'pink' else passages
if charact.color != 'purple' or charact.power:
disp = {x for x in pass_act[charact.position]
if charact.position not in blocked or x not in blocked}
available_positions = list(disp)
question = {"question type": "select position",
"data": available_positions,
"game state": game_state}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(disp)):
warning_message = (
' ! : selected position not available '
'Choosing random position.'
)
logger.warning(warning_message)
selected_position = disp.pop()
else:
selected_position = available_positions[selected_index]
logger.info(f"question : {question['question type']}")
logger.info("answer : " + str(selected_position))
if len(moved_characters) > 1:
logger.debug("more than one character moves")
for q in moved_characters:
q.position = selected_position
logger.info("new position : " + str(q))
def actions(self):
"""
phase = tour
phase 1 : IFFI
phase 2 : FIIF
first phase : initially num_tour = 1, then 3, 5, etc.
so the first player to play is (1+1)%2=0 (inspector)
second phase : num_tour = 2, 4, 6, 8, etc.
so the first player to play is (2+1)%2=1 (fantom)
"""
first_player_in_phase = (self.num_tour + 1) % 2
if first_player_in_phase == 0:
logger.info(f"-\nshuffle {len(self.tiles)} tiles\n-")
shuffle(self.tiles)
self.active_tiles = self.tiles[:4]
else:
self.active_tiles = self.tiles[4:]
for i in [
first_player_in_phase, 1 - first_player_in_phase,
1 - first_player_in_phase, first_player_in_phase
]:
self.players[i].play(self)
def lancer(self):
"""
Run a game until either the fantom is discovered,
or the singer leaves the opera.
"""
# work
while self.position_carlotta < self.exit and len(
[p for p in self.characters if p.suspect]) > 1:
self.tour()
# game ends
if self.position_carlotta < self.exit:
logger.info("----------\n---- inspector wins : fantom is " +
str(self.fantom))
else:
logger.info("----------\n---- fantom wins")
# log
logger.info(
f"---- final position of Carlotta : {self.position_carlotta}")
logger.info(f"---- exit : {self.exit}")
logger.info(
f"---- final score : {self.exit - self.position_carlotta}\n----------"
)
return self.exit - self.position_carlotta
def __init__(self, players: List[Player]):
# Todo: Should be self.players: Tuple[Player] = (player_1, player_2)
self.players = players
self.position_carlotta = 6 # position on the exit path
# Todo: Should be removed and make the game ends when carlotta reach 0.
self.exit = 22
self.num_tour = 1
# Todo: Should be a Dict[enum, Character]
self.characters = set({Character(color) for color in colors})
# character_cards are used to draw 4 characters at the beginning
# of each round
self.character_cards = list(self.characters)
self.active_cards = list()
self.alibi_cards = self.character_cards.copy()
self.fantom = choice(self.alibi_cards)
# Todo: Should be placed in a logger section of the __init__()
logger.info("the fantom is " + self.fantom.color)
self.alibi_cards.remove(self.fantom)
self.alibi_cards.extend(['fantom'] * 3)
# log
logger.info("\n=======\nnew game\n=======")
# Todo: 1 Should be removed
logger.info(f"shuffle {len(self.character_cards)} character_cards")
# Todo: 2 Should be removed
logger.info(f"shuffle {len(self.alibi_cards)} alibi cards")
# work
# Todo: 1 Should be removed
shuffle(self.character_cards)
# Todo: 2 Should be removed
shuffle(self.alibi_cards)
# Initialise character positions
# Rooms at the center of the game are not available
rooms_number = list(range(10))
start_rooms = rooms_number[:5] + rooms_number[7:]
for character in self.characters:
character.position = choice(start_rooms)
for character in self.characters:
# get position of grey character
if character.color == "grey":
grey_character_position = character.display()["position"]
self.shadow = grey_character_position
if character.color == "blue":
blue_character_position = character.display()["position"]
# initially the blocked passage is
# next to blue character clockwise
if blue_character_position == 0:
self.blocked = (0, 1)
elif blue_character_position == 1:
self.blocked = (1, 2)
elif blue_character_position == 2:
self.blocked = (2, 3)
elif blue_character_position == 3:
self.blocked = (3, 4)
elif blue_character_position == 4:
self.blocked = (4, 5)
elif blue_character_position == 7:
self.blocked = (7, 9)
elif blue_character_position == 9:
self.blocked = (8, 9)
elif blue_character_position == 8:
self.blocked = (4, 8)
else:
print(blue_character_position)
raise ValueError(
"Wrong initial position of blue character")
self.characters_display = [
character.display() for character in self.characters
]
# Todo: should be removed
self.character_cards_display = [
tile.display() for tile in self.character_cards
]
self.active_cards_display = [
tile.display() for tile in self.active_cards
]
self.game_state = {
"position_carlotta": self.position_carlotta,
"exit": self.exit,
"num_tour": self.num_tour,
"shadow": self.shadow,
"blocked": self.blocked,
"characters": self.characters_display,
# Todo: should be removed
"character_cards": self.character_cards_display,
"active character_cards": self.active_cards_display,
}
def activate_power(self, charact, game, activables, game_state):
"""
Use the special power of the character.
"""
# check if the power should be used before of after moving
# this depends on the "activables" variable, which is a set.
if not charact.power_activated and charact.color in activables:
# check if special power is mandatory
if charact.color in mandatory_powers:
power_activation = 1
# special power is not mandatory
else:
question = {
"question type": f"activate {charact.color} power",
"data": [0, 1],
"game state": game_state
}
power_activation = ask_question_json(self, question)
# log
logger.info(f"question : {question['question type']}")
if power_activation == 1:
power_answer = "yes"
else:
power_answer = "no"
logger.info(f"answer : {power_answer}")
# the power will be used
# charact.power represents the fact that
# the power is still available
if power_activation:
logger.info(charact.color + " power activated")
charact.power_activated = True
# red character
if charact.color == "red":
draw = choice(game.alibi_cards)
game.alibi_cards.remove(draw)
logger.info(str(draw) + " was drawn")
if draw == "fantom":
game.position_carlotta += -1 if self.num == 0 else 1
elif self.num == 0:
draw.suspect = False
# black character
if charact.color == "black":
for q in game.characters:
if q.position in self.get_adjacent_positions(
charact, game):
q.position = charact.position
logger.info("new position : " + str(q))
# white character
if charact.color == "white":
for moved_character in game.characters:
if moved_character.position == charact.position and charact != moved_character:
available_positions = self.get_adjacent_positions(
charact, game)
# format the name of the moved character to string
character_to_move = str(moved_character).split(
"-")[0]
question = {
"question type":
"white character power move " +
character_to_move,
"data": available_positions,
"game state": game_state
}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(
len(available_positions)):
warning_message = (
' ! : selected position not available '
'Choosing random position.')
logger.warning(warning_message)
selected_position = choice(available_positions)
else:
selected_position = available_positions[
selected_index]
logger.info(
f"question : {question['question type']}")
logger.info("answer : " + str(selected_position))
moved_character.position = selected_position
logger.info("new position : " +
str(moved_character))
# purple character
if charact.color == "purple":
# logger.debug("Rappel des positions :\n" + str(game))
available_characters = [
q for q in game.characters if q.color != "purple"
]
# the socket can not take an object
available_colors = [q.color for q in available_characters]
question = {
"question type": "purple character power",
"data": available_colors,
"game state": game_state
}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(colors)):
warning_message = (
' ! : selected character not available '
'Choosing random character.')
logger.warning(warning_message)
selected_character = choice(colors)
else:
selected_character = available_characters[
selected_index]
logger.info(f"question : {question['question type']}")
logger.info(f"answer : {selected_character}")
# swap positions
charact.position, selected_character.position = selected_character.position, charact.position
logger.info(f"new position : {charact}")
logger.info(f"new position : {selected_character}")
return selected_character
# brown character
if charact.color == "brown":
# the brown character can take one other character with him
# when moving.
available_characters = [
q for q in game.characters
if charact.position == q.position if q.color != "brown"
]
# the socket can not take an object
available_colors = [q.color for q in available_characters]
if len(available_colors) > 0:
question = {
"question type": "brown character power",
"data": available_colors,
"game state": game_state
}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(colors)):
warning_message = (
' ! : selected character not available '
'Choosing random character.')
logger.warning(warning_message)
selected_character = choice(colors)
else:
selected_character = available_characters[
selected_index]
logger.info(f"question : {question['question type']}")
logger.info(f"answer : {selected_character}")
return selected_character
else:
return None
# grey character
if charact.color == "grey":
available_rooms = [
room for room in range(10) if room is not game.shadow
]
question = {
"question type": "grey character power",
"data": available_rooms,
"game state": game_state
}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(available_rooms)):
warning_message = (' ! : selected room not available '
'Choosing random room.')
logger.warning(warning_message)
selected_index = randint(0, len(available_rooms) - 1)
selected_room = available_rooms[selected_index]
else:
selected_room = available_rooms[selected_index]
game.shadow = selected_room
logger.info(f"question : {question['question type']}")
logger.info("answer : " + str(game.shadow))
# blue character
if charact.color == "blue":
# choose room
available_rooms = [room for room in range(10)]
question = {
"question type": "blue character power room",
"data": available_rooms,
"game state": game_state
}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(available_rooms)):
warning_message = (' ! : selected room not available '
'Choosing random room.')
logger.warning(warning_message)
selected_index = randint(0, len(available_rooms) - 1)
selected_room = available_rooms[selected_index]
else:
selected_room = available_rooms[selected_index]
# choose exit
passages_work = passages[selected_room].copy()
available_exits = list(passages_work)
question = {
"question type": "blue character power exit",
"data": available_exits,
"game state": game_state
}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(available_exits)):
warning_message = (' ! : selected exit not available '
'Choosing random exit.')
logger.warning(warning_message)
__import__('ipdb').set_trace()
selected_exit = choice(passages_work)
else:
selected_exit = available_exits[selected_index]
logger.info(f"question : {question['question type']}")
logger.info("answer : " +
str({selected_room, selected_exit}))
game.blocked = tuple((selected_room, selected_exit))
else:
# if the power was not used
return None
def activate_power(self, charact, game, activables, game_state):
"""
Use the special power of the character.
"""
# check if the power should be used before of after moving
# this depends on the "activables" variable, which is a set.
if charact.power and charact.color in activables:
character_color = charact.display()["color"]
question = {"question type": f"activate {character_color} power",
"data": [0, 1],
"game state": game_state}
power_activation = ask_question_json(self, question)
# log
logger.info(f"question : {question['question type']}")
if power_activation == 1:
power_answer = "yes"
else:
power_answer = "no"
logger.info("answer : " + power_answer)
# work
if power_activation:
logger.info(charact.color + " power activated")
charact.power = False
# red character
if charact.color == "red":
# Todo: 2.Origin Should be replaced by
# draw = random.choice(game.cards)
# game.cards.remove(draw)
draw = game.cards[0]
logger.info(str(draw) + " was drawn")
if draw == "fantom":
game.position_carlotta += -1 if self.num == 0 else 1
elif self.num == 0:
draw.suspect = False
# Todo: 2 Should be removed
del game.cards[0]
# black character
if charact.color == "black":
for q in game.characters:
if q.position in {x for x in passages[charact.position] if
x not in game.blocked or q.position not in game.blocked}:
q.position = charact.position
logger.info("new position : " + str(q))
# white character
if charact.color == "white":
for moved_character in game.characters:
if moved_character.position == charact.position and charact != moved_character:
disp = {
x for x in passages[charact.position]
if x not in game.blocked or moved_character.position not in game.blocked}
# edit
available_positions = list(disp)
# format the name of the moved character to string
character_to_move = str(
moved_character).split("-")[0]
question = {"question type": "white character power move " + character_to_move,
"data": available_positions,
"game state": game_state}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(disp)):
warning_message = (
' ! : selected position not available '
'Choosing random position.'
)
logger.warning(warning_message)
selected_position = disp.pop()
else:
selected_position = available_positions[selected_index]
logger.info(
f"question : {question['question type']}")
logger.info("answer : " +
str(selected_position))
moved_character.position = selected_position
logger.info("new position : " + str(moved_character))
# purple character
if charact.color == "purple":
# logger.debug("Rappel des positions :\n" + str(game))
available_characters = list(colors)
available_characters.remove("purple")
question = {"question type": "purple character power",
"data": available_characters,
"game state": game_state}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(colors)):
warning_message = (
' ! : selected character not available '
'Choosing random character.'
)
logger.warning(warning_message)
selected_character = colors.pop()
else:
selected_character = available_characters[selected_index]
logger.info(f"question : {question['question type']}")
logger.info("answer : " + selected_character)
# y a pas plus simple ?
selected_crctr = [x for x in game.characters if x.color
== selected_character][0]
charact.position, selected_crctr.position = selected_crctr.position, charact.position
logger.info("new position : " + str(charact))
logger.info("new position : " + str(selected_crctr))
# brown character
if charact.color == "brown":
# the brown character can take other characters with him
# when moving.
return [q for q in game.characters if charact.position == q.position]
# grey character
if charact.color == "grey":
available_rooms = [room for room in range(10)]
question = {"question type": "grey character power",
"data": available_rooms,
"game state": game_state}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(available_rooms)):
warning_message = (
' ! : selected room not available '
'Choosing random room.'
)
logger.warning(warning_message)
selected_index = random.randint(
0, len(available_rooms) - 1)
selected_room = available_rooms[selected_index]
else:
selected_room = available_rooms[selected_index]
game.shadow = selected_room
logger.info(f"question : {question['question type']}")
logger.info("answer : " + str(game.shadow))
# blue character
if charact.color == "blue":
# choose room
available_rooms = [room for room in range(10)]
question = {"question type": "blue character power room",
"data": available_rooms,
"game state": game_state}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(available_rooms)):
warning_message = (
' ! : selected room not available '
'Choosing random room.'
)
logger.warning(warning_message)
selected_index = random.randint(
0, len(available_rooms) - 1)
selected_room = available_rooms[selected_index]
else:
selected_room = available_rooms[selected_index]
# choose exit
passages_work = passages[selected_room].copy()
available_exits = list(passages_work)
question = {"question type": "blue character power exit",
"data": available_exits,
"game state": game_state}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(available_exits)):
warning_message = (
' ! : selected exit not available '
'Choosing random exit.'
)
logger.warning(warning_message)
selected_exit = passages_work.pop()
else:
selected_exit = available_exits[selected_index]
logger.info(f"question : {question['question type']}")
logger.info("answer : " +
str({selected_room, selected_exit}))
game.blocked = {selected_room, selected_exit}
game.blocked_list = list(game.blocked)
return [charact]
def move(self, charact, moved_character, blocked, game_state, game):
"""
Select a new position for the character.
"""
# get the number of characters in the same room
characters_in_room = [
q for q in game.characters if q.position == charact.position
]
number_of_characters_in_room = len(characters_in_room)
# get the available rooms from a given position
available_rooms = list()
available_rooms.append(self.get_adjacent_positions(charact, game))
for step in range(1, number_of_characters_in_room):
# build rooms that are a distance equal to step+1
next_rooms = list()
for room in available_rooms[step - 1]:
next_rooms += self.get_adjacent_positions_from_position(
room, charact, game)
available_rooms.append(next_rooms)
# flatten the obtained list
temp = list()
for sublist in available_rooms:
for room in sublist:
temp.append(room)
# filter the list in order to keep an unique occurrence of each room
temp = set(temp)
available_positions = list(temp)
# ensure the character changes room
if charact.position in available_positions:
available_positions.remove(charact.position)
# if the character is purple and the power has
# already been used, we pass since it was already moved
# (the positions were swapped)
if charact.color == "purple" and charact.power_activated:
pass
else:
question = {
"question type": "select position",
"data": available_positions,
"game state": game_state
}
selected_index = ask_question_json(self, question)
# test
if selected_index not in range(len(available_positions)):
warning_message = (' ! : selected position not available '
'Choosing random position.')
logger.warning(warning_message)
selected_position = choice(available_positions)
else:
selected_position = available_positions[selected_index]
logger.info(f"question : {question['question type']}")
logger.info(f"answer : {selected_position}")
logger.info(f"new position : {selected_position}")
# it the character is brown and the power has been activated
# we move several characters with him
if charact.color == "brown" and charact.power_activated:
charact.position = selected_position
if moved_character:
moved_character.position = selected_position
else:
charact.position = selected_position
def __init__(self, players: List[Player]):
# Todo: Should be self.players: Tuple[Player] = (player_1, player_2)
self.players = players
self.position_carlotta = 4 # position on the exit path
# Todo: Should be removed and make the game ends when carlotta reach 0.
self.exit = 22
self.num_tour = 1
# Todo: Lock should always block the hallway between the room
# occupied by the blue character pawn Madame Giry and the adjacent
# room clockwise.
x: int = randrange(10)
self.blocked = tuple((x, passages[x].copy().pop()))
# Todo: Should be a Dict[enum, Character]
self.characters = set({Character(color) for color in colors})
# character_cards are used to draw 4 characters at the beginning
# of each round
self.character_cards = list(self.characters)
self.active_cards = list()
self.alibi_cards = self.character_cards.copy()
self.fantom = choice(self.alibi_cards)
# Todo: Should be placed in a logger section of the __init__()
logger.info("the fantom is " + self.fantom.color)
self.alibi_cards.remove(self.fantom)
self.alibi_cards.extend(['fantom'] * 3)
# log
logger.info("\n=======\nnew game\n=======")
# Todo: 1 Should be removed
logger.info(f"shuffle {len(self.character_cards)} character_cards")
# Todo: 2 Should be removed
logger.info(f"shuffle {len(self.alibi_cards)} alibi cards")
# work
# Todo: 1 Should be removed
shuffle(self.character_cards)
# Todo: 2 Should be removed
shuffle(self.alibi_cards)
# Todo:
# rooms_number = list(range(10))
# start_rooms = rooms_number[:5] + rooms_number[7:]
# for c in self.characters:
# c.position = random.choice(start_rooms)
# start_rooms.remove(c.position)
for i, p in enumerate(self.character_cards):
p.position = i
for character in self.characters:
# get position of grey character
if character.color == "grey":
grey_character_position = character.display()["position"]
self.shadow = grey_character_position
self.characters_display = [
character.display() for character in self.characters
]
# Todo: should be removed
self.character_cards_display = [
tile.display() for tile in self.character_cards
]
self.active_cards_display = [
tile.display() for tile in self.active_cards
]
self.game_state = {
"position_carlotta": self.position_carlotta,
"exit": self.exit,
"num_tour": self.num_tour,
"shadow": self.shadow,
"blocked": self.blocked,
"characters": self.characters_display,
# Todo: should be removed
"character_cards": self.character_cards_display,
"active character_cards": self.active_cards_display,
}
def init_connexion():
while len(clients) != 2:
link.listen(2)
(clientsocket, addr) = link.accept()
logger.info("Received client !")
clients.append(clientsocket)
clientsocket.settimeout(10)
if __name__ == '__main__':
players = [Player(0), Player(1)]
scores = []
logger.info("no client yet")
init_connexion()
logger.info("received all clients")
# profiling
pr = cProfile.Profile()
pr.enable()
game = Game(players)
game.lancer()
link.close()
# profiling
pr.disable()
# stats_file = open("{}.txt".format(os.path.basename(__file__)), 'w')
def __init__(self, players: List[Player]):
# Todo: Should be self.players: Tuple[Player] = (player_1, player_2)
self.players = players
self.position_carlotta = 4 # position on the exit path
# Todo: Should be removed and make the game ends when carlotta reach 0.
self.exit = 22
self.num_tour = 1
# Todo: Shadow should always be placed on Joseph Buquet at the
# beginning of a game.
self.shadow = randrange(10)
# Todo: Lock should always block the hallway between the room
# occupied by the blue character pawn Madame Giry and the adjacent
# room clockwise.
x: int = randrange(10)
# Todo: Should be a Tuple[int]
self.blocked = {x, passages[x].copy().pop()}
# Todo: Unused variable, should be removed
self.blocked_list = list(self.blocked)
# Todo: Should be a Dict[enum, Character]
self.characters = set({Character(color) for color in colors})
# tiles are used to draw 4 characters at the beginning
# of each round
# tile means 'tuile'
# Todo: 1 Should be rename character_cards
self.tiles = list(self.characters)
# Todo: Should be rename active_cards
self.active_tiles = list()
# Todo: Should be rename alibi_cards, declared as a List[Character]
# and instanciated with self.tiles.copy()
self.cards = self.tiles[:]
# Todo: 2 Should use random.choice() and simplified as
# self.fantom = random.choice(self.cards)
self.fantom = self.cards[randrange(8)]
# Todo: Should be placed in a logger section of the __init__()
logger.info("the fantom is " + self.fantom.color)
self.cards.remove(self.fantom)
# Todo: Should be replaced by self.cards.extend(['fantom'] * 3)
self.cards += ["fantom"] * 3
# log
logger.info("\n=======\nnew game\n=======")
# Todo: 1 Should be removed
logger.info(f"shuffle {len(self.tiles)} tiles")
# Todo: 2 Should be removed
logger.info(f"shuffle {len(self.cards)} cards")
# work
# Todo: 1 Should be removed
shuffle(self.tiles)
# Todo: 2 Should be removed
shuffle(self.cards)
# Todo:
# rooms_number = list(range(10))
# start_rooms = rooms_number[:5] + rooms_number[7:]
# for c in self.characters:
# c.position = random.choice(start_rooms)
# start_rooms.remove(c.position)
for i, p in enumerate(self.tiles):
p.position = i
self.characters_display = [
character.display() for character in self.characters
]
# Todo: should be removed
self.tiles_display = [tile.display() for tile in self.tiles]
self.active_tiles_display = [
tile.display() for tile in self.active_tiles
]
self.game_state = {
"position_carlotta": self.position_carlotta,
"exit": self.exit,
"num_tour": self.num_tour,
"shadow": self.shadow,
"blocked": self.blocked_list,
"characters": self.characters_display,
# Todo: should be removed
"tiles": self.tiles_display,
"active tiles": self.active_tiles_display,
}
