def wrapper(room_id, *args, **kwargs):
actual_found = PlayingRole.exists(room_id)
if not should_be_found and actual_found:
return [GameState(Status.ONGOING_GAME_FOUND)]
elif should_be_found and not actual_found:
return [GameState(Status.ONGOING_GAME_NOT_FOUND)]
return func(room_id, *args, **kwargs)
def evaluate_game(room_id):
n_alive_civilians = Player.num_alive_players(room_id,
role=Role.CIVILIAN.name)
if n_alive_civilians == 1:
summary = generate_summary(room_id)
clear_game(room_id)
return [
GameState(Status.NON_CIVILIAN_WIN, room_id=room_id),
GameState(Status.SUMMARY, data=summary),
]
n_alive_players = Player.num_alive_players(room_id)
if n_alive_civilians == n_alive_players:
summary = generate_summary(room_id)
clear_game(room_id)
return [
GameState(Status.CIVILIAN_WIN, room_id=room_id),
GameState(Status.SUMMARY, data=summary),
]
alive_player_ids = Player.alive_player_ids(room_id)
playing_order = decide_playing_order(alive_player_ids)
return [GameState(Status.PLAYING_ORDER, playing_order, room_id=room_id)]
def complete_poll(room_id):
tally, total_votes = count_vote(room_id)
data = {"tally": tally}
if total_votes == 0:
terminate_poll(room_id)
return [GameState(Status.NO_VOTES_SUBMITTED, data)]
alive_player_ids = Player.alive_player_ids(room_id)
data["players"] = alive_player_ids
if total_votes < len(alive_player_ids) // 2 + 1:
terminate_poll(room_id)
return [GameState(Status.NOT_ENOUGH_VOTES, data)]
max_votes = max(tally.values())
voted_players = [
voted_player
for voted_player, votes in tally.items()
if votes == max_votes
]
if len(voted_players) > 1:
terminate_poll(room_id)
return [GameState(Status.MULTIPLE_PLAYERS_VOTED, data)]
data["player"] = voted_players[0]
terminate_poll(room_id)
return [GameState(Status.POLL_DECIDED, data)]
def decide_vote_states(room_id):
tally, total_votes = count_vote(room_id)
num_alive_players = Player.num_alive_players(room_id)
poll = Poll.get(room_id)
data = {"msg_id": poll.msg_id, "tally": tally}
if total_votes == num_alive_players:
return [GameState(Status.TOTAL_VOTES_REACHED, data)]
return [GameState(Status.VOTE_SUCCESS, data)]
def wrapper(room_id, user_id, *args, **kwargs):
player = Player.get(user_id)
data = {"player": user_id}
if player is None or player.room_id != room_id:
return [GameState(Status.PLAYER_NOT_FOUND, data)]
if not player.alive:
return [GameState(Status.PLAYER_ALREADY_KILLED, data)]
return func(room_id, user_id, *args, **kwargs)
def wrapper(room_id, *args, **kwargs):
poll = Poll.get(room_id)
actual_found = poll is not None
if not should_be_found and actual_found:
return [GameState(Status.ONGOING_POLL_FOUND)]
elif should_be_found and not actual_found:
return [GameState(Status.ONGOING_POLL_NOT_FOUND)]
return func(room_id, *args, **kwargs)
def guess_word(user_id, word):
player = Player.get(user_id)
if player is None or not player.guessing:
return [GameState(Status.NOT_IN_GUESSING_TURN)]
civilian_word = PlayingRole.get_word(player.room_id, Role.CIVILIAN).word
word = re.sub("[^a-z0-9]", "", word.lower())
civilian_word = re.sub("[^a-z0-9]", "", civilian_word.lower())
if Levenshtein.distance(word, civilian_word) <= 1:
clear_game(player.room_id)
return [GameState(Status.MR_WHITE_WIN, room_id=player.room_id)]
Player.update(user_id, guessing=False)
return evaluate_game(player.room_id)
def eliminate_player(room_id, user_id):
kill_player(user_id)
killed_player = Player.get(user_id)
data = {"player": killed_player.user_id, "role": killed_player.role}
game_states = []
if killed_player.role == Role.CIVILIAN.name:
game_states.append(GameState(Status.CIVILIAN_ELIMINATED, data))
game_states += evaluate_game(room_id)
elif killed_player.role == Role.UNDERCOVER.name:
game_states.append(GameState(Status.UNDERCOVER_ELIMINATED, data))
game_states += evaluate_game(room_id)
elif killed_player.role == Role.MR_WHITE.name:
game_states.append(GameState(Status.MR_WHITE_ELIMINATED, data))
game_states.append(GameState(Status.ASK_GUESSED_WORD))
return game_states
def wrapper(room_id, user_ids, *args, **kwargs):
if len(user_ids) not in ROLE_PROPORTIONS:
data = {
"min_player": min(ROLE_PROPORTIONS),
"max_player": max(ROLE_PROPORTIONS),
}
return [GameState(Status.INVALID_PLAYER_NUMBER, data)]
return func(room_id, user_ids, *args, **kwargs)
def start_game(room_id, user_ids):
role_proportion = ROLE_PROPORTIONS[len(user_ids)]
num_civilians, num_undercovers, num_mr_whites = role_proportion
civilian_word, undercover_word = get_secret_word()
mr_white_exists = num_mr_whites > 0
store_playing_roles(
room_id, civilian_word, undercover_word, mr_white_exists
)
user_words, mr_whites = assign_role(
room_id, user_ids, civilian_word, undercover_word, role_proportion
)
played_word_state = GameState(Status.PLAYED_WORD, user_words)
playing_order = decide_playing_order(user_ids, mr_whites)
playing_order_state = GameState(Status.PLAYING_ORDER, playing_order)
return [played_word_state, playing_order_state]
def check_voter_valid(room_id, voter_id): # room_id used inside decorator
vote = Vote.get(voter_id)
if vote is not None:
data = {"player": voter_id}
return [GameState(Status.VOTE_EXISTS, data)]
def start_poll(room_id, user_id, msg_id): # user_id used inside decorator
alive_player_ids = Player.alive_player_ids(room_id)
new_poll = Poll(room_id, msg_id)
Poll.add(new_poll)
data = {"players": alive_player_ids}
return [GameState(Status.POLL_STARTED, data)]
def wrapper(room_id, user_ids, *args, **kwargs):
playing_users = Player.filter_exists(user_ids)
if len(playing_users) > 0:
data = {"playing_users": playing_users}
return [GameState(Status.PLAYING_USER_FOUND, data)]
return func(room_id, user_ids, *args, **kwargs)