async def start_game(self):
self.cards = self.assign_roles()
#checking if deck has any players that need to wake
no_wake = [
self.role_switch[c].post is self.role_switch[c].__base__.post
for c in self.cards
]
if all(no_wake):
self.no_wakers = True
deck_msg = ["{}".format(self.role_switch[d].__name__) \
for d in sorted(self.deck)]
deck_msg = ("Deck includes the following cards " +
"and will be called in the following order:\n\n" +
"\n".join(deck_msg))
self.phase.append('start')
for k in self.players:
bot.send_text_message(self.players[k]['id'], "Game has started!")
role = self.players[k]['role'] = self.cards.pop()
self.players[k] = self.role_switch[role](self, k, self.players[k])
bot.send_text_message(self.players[k].id, deck_msg)
#checking for doppelganger in the deck
if 0 in self.deck:
for v in self.players.values():
v.pre_game()
await asyncio.sleep(self.pre_game_time)
if not self.no_wakers:
asyncio.ensure_future(self.min_call_wake(self.pre_game_time))
for v in self.players.values():
v()
def resolve(self):
for card_no in self.seen:
center = self.player.game_state.cards[card_no - 1]
role_name = self.player.role_dict[center]
bot.send_image_url(self.player.id, urls.role[role_name])
msg = ("Card {num} is the {card}.".format(num=card_no,
card=role_name))
bot.send_text_message(self.player.id, msg)
def enter_room(self, room):
if len(room) == 5 and room.islower():
if self.open_games.get(room):
self.open_games[room].add_player(self.caller_id)
return "Success"
bot.send_text_message(self.caller_id, "Not a valid room. Try again:")
self.first_message()
return "Success"
def pre_game(self):
self.pre_game_bool = True
msg = ("Look at another player’s card. You are now that role." +
"(You have {} seconds to complete the action or one will be " +
"chosen for you.)").format(self.game_state.pre_game_time)
bot.send_text_message(self.id, msg)
carousel = player_carousel(self, 'doppel')
bot.send_generic_message(self.id, carousel)
def resolve(self):
if self.chosen_player:
self.game_state.swap_player_cards(self.player_no,
self.chosen_player.player_no)
role_name = self.role_dict[self.card]
bot.send_image_url(self.id, urls.role[role_name])
msg = ("You are now the {} and {} will have your card.".format(
role_name, self.chosen_player.first_name))
bot.send_text_message(self.id, msg)
def resolve(self):
if self.spy:
card = self.game_state.players[self.spy].card
role_name = self.role_dict[card]
bot.send_image_url(self.id, urls.role[role_name])
msg = "{} is a {}".format(self.spied_name, role_name)
bot.send_text_message(self.id, msg)
else:
self.peeker.resolve()
def __call__(self):
msg = "Exchange your card with a card from the center"
bot.send_text_message(self.id, msg)
payload = player_payload(self, 'drunk')
element = pick_center_card(payload,
title="Pick",
subtitle="Exchange your card with a" +
" card from the center")
bot.send_generic_message(self.id, element)
def post(self, pl_dict):
if not self.card_no:
self.card_no = card_parse(pl_dict)
msg = ("You have picked Card {num}".format(num=self.card_no))
bot.send_text_message(self.id, msg)
else:
bot.send_text_message(self.id, "You cannot view more cards.")
self.wait()
self.action_complete = True
def create_game(self, message):
max_players = int(message.get('text'))
room = ''.join(random.choices(string.ascii_lowercase, k=5))
pass_msg = "Passcode: {}".format(room)
pass_prompt = (
"Give passcode to {:d} other players".format(max_players - 1))
bot.send_text_message(self.caller_id, pass_msg)
bot.send_text_message(self.caller_id, pass_prompt)
self.open_games[room] = GameState(room, self.caller_id, max_players)
def deck_entry(self):
card_lmt = {i: FULL_DECK.count(i) for i in range(max(FULL_DECK) + 1)}
msg_list = ["{k} : {v} ({l})".format(k=k, v=v.__name__, l=card_lmt[k])\
for k, v in self.role_switch.items()]
msg = "\n".join(msg_list)
bot.send_text_message(self.admin, msg)
msg2 = ("Enter card numbers seperated by spaces " +
"(must be 3 more than the number of players, " +
"limit of players per role are listed in parentheses.")
bot.send_text_message(self.admin, msg2)
def post(self, pl_dict):
if pl_dict.get('action') == 'doppel':
if not self.chosen_player:
self.chosen_player = self.game_state.players[int(pl_dict[0])]
self.copy_role()
else:
msg = ("You have already copied a role.")
bot.send_text_message(self.id, msg)
else:
self.copy.post(pl_dict)
def join_response(self, message):
if 'text' in message:
room = message['text']
else:
bot.send_text_message(self.caller_id,
"Not a valid passcode. Try again: ")
self.first_message()
return "Success"
result = self.enter_room(room)
return result
def default_postback(self, postback):
room, pl_dict = payload_format(postback)
if self.open_games.get(room):
result = self.open_games[room].post_process(
self.caller_id, pl_dict)
if result == "Needs Text":
return dict(fun=self.open_games[room].text_process,
recipient_id=self.caller_id)
else:
bot.send_text_message(self.caller_id, "Game no longer exists")
def end_night(self):
self.phase.append('day')
#gives the player number in role order to be resolved
roles = [(p_no, v.role) for p_no, v in self.players.items()]
player_order = [x[0] for x in sorted(roles, key=lambda y: y[1])]
for player_no in player_order:
player = self.players[player_no]
player.resolve()
bot.send_text_message(player.id, "Day phase has started!")
player.vote()
def reveal_player(player, role_name):
names = player.game_state.get_players(player.reveal)
try:
names.remove(player.first_name)
except ValueError:
pass
for n in names:
msg = "{name} is a {role}".format(name=n, role=role_name)
bot.send_text_message(player.id, msg)
return names
def copy(self):
if not self._copy:
player_no_list = list(range(0, self.game_state.max_players))
player_no_list.remove(self.player_no)
player_no = random.choice(player_no_list)
self.chosen_player = self.game_state.players[player_no]
msg = "You have ran out of time. {} was picked for you."
msg = msg.format(self.chosen_player.first_name)
bot.send_text_message(self.id, msg)
self.copy_role()
return self._copy
def add_player(self, recipient_id):
player_no = len(self.players)
if self.phase[-1] == 'setup':
player_info = bot.get_user_info(
recipient_id, fields=['first_name', 'profile_pic'])
self.players[len(self.players)] = player_info
if self.admin != recipient_id:
bot.send_text_message(self.players[player_no].get('id'),
"Successfuly joined room")
else:
bot.send_text_message(recipient_id, "Game room is full")
def vote_process(self, pl_dict):
player_no = pl_dict.get('player_no')
chosen_player = int(pl_dict[0])
if player_no not in [x['voter'] for x in self.votes]:
self.votes.append({'voter': player_no, 'chosen': chosen_player})
bot.send_text_message(self.players[player_no].id,
"Votes are being counted.")
else:
bot.send_text_message(self.players[player_no].id,
"You have already voted.")
if len(self.votes) == self.max_players:
self.kill_players()
def _spy(self, pl_dict):
if not self.spy:
#0 is the key for other player_no
self.spy = int(pl_dict[0])
self.spied_name = self.game_state.players[self.spy].first_name
bot.send_text_message(
self.id, "You have chosen {}'s card".format(self.spied_name))
self.action_complete = True
else:
bot.send_text_message(self.id,
"You have already chosen a player's card")
self.wait()
def _choose(self, pl_dict):
if not self.choice:
self.choice = pl_dict.get('title')
if self.choice == "Player's Card":
bot.send_text_message(self.id, "Look at another player's card")
carousel = player_carousel(self, 'spy')
bot.send_generic_message(self.id, carousel)
else:
self.peeker.max_peeks = 2
self.peeker()
else:
bot.send_text_message(self.id, "You have already chosen an action")
def post(self, pl_dict):
picked_cards = len(self.chosen_players)
if picked_cards < 2 and not self.action_complete:
#If 0 exists in pl_dict, it implies that the player did not chose
#to do nothing.
if 0 in pl_dict:
player_no = int(pl_dict[0])
if player_no not in self.chosen_players:
self.chosen_players.append(player_no)
name = self.game_state.players[player_no].first_name
if picked_cards < 1:
msg = ("You have picked {}'s card. ".format(name) +
"Pick a second card to switch.")
bot.send_text_message(self.id, msg)
carousel = player_carousel(self, 'switch')
bot.send_generic_message(self.id, carousel)
else:
msg = ("You have picked {}'s card. ".format(name) +
"The cards you have chosen will be switched.")
bot.send_text_message(self.id, msg)
self.wait()
self.action_complete = True
else:
msg = "You have decided to not cause trouble."
bot.send_text_message(self.id, msg)
self.wait()
self.action_complete = True
else:
msg = "You have already completed your action."
bot.send_text_message(self.id, msg)
self.wait()
def kill_players(self):
votes = [x['chosen'] for x in self.votes]
#counts all the votes and organizes them by player
votes_by_player = ([(i, votes.count(i))
for i in range(self.max_players)])
highest = max([c for i, c in votes_by_player])
if highest > 1:
#kills all the players with the highest votes if it is more than 1
killed_players = [i for i, c in votes_by_player if c == highest]
else:
killed_players = []
msg = ("The village did not kill anyone!")
for v in self.players.values():
bot.send_text_message(v.id, msg)
for k in killed_players:
p_dead = self.players[k]
p_dead.kill()
dead_role_name = p_dead.role_dict[p_dead.card]
msg = ("The village has killed {p}! He was a {r}.".format(
p=p_dead.first_name, r=dead_role_name))
for v in self.players.values():
bot.send_image_url(v.id, p_dead.profile_pic)
bot.send_text_message(v.id, msg)
# checking if a hunter is in the deck to not end the game
if 10 not in [v.card for v in self.players.values()]:
self.end_game()
else:
for v in self.players.values():
bot.send_text_message(
v.id, "Wait for hunter to kill another player")
def deck_response(self, message):
deck = make_deck(message.get('text'))
if deck != "Invalid":
full_deck = FULL_DECK.copy()
#check if deck is a subset of full deck
for c in deck:
try:
full_deck.remove(c)
except ValueError:
bot.send_text_message(
self.admin,
"Not all numbers are " + "in the deck. Try again:")
self.deck_prompt()
return "Success"
if self.max_players == len(deck) - 3:
self.deck = deck
return "Success"
else:
bot.send_text_message(
self.admin,
"There needs to be 3 more card than players. Try again:")
else:
bot.send_text_message(self.admin, "Invalid numbers. Try again:")
self.deck_prompt()
return "Success"
def post(self, pl_dict):
if not self.action_complete:
#If pl_dict.get(0) exists, it implies that the player did not chose
#to do nothing.
if 0 in pl_dict:
self.chosen_player = self.game_state.players[int(pl_dict[0])]
msg = ("You will switch cards with {}".format(
self.chosen_player.first_name))
bot.send_text_message(self.id, msg)
else:
msg = "You have decided to do nothing."
bot.send_text_message(self.id, msg)
self.wait()
self.action_complete = True
else:
msg = "You have already completed your action."
bot.send_text_message(self.id, msg)
self.wait()
def post(self, pl_dict):
card_no = card_parse(pl_dict)
if len(self.seen) < self.max_peeks or card_no in self.seen:
msg = ("You have picked Card {num}".format(num=card_no))
bot.send_text_message(self.player.id, msg)
self.seen.add(card_no)
new_tot = len(self.seen)
if new_tot != self.max_peeks:
remaining = self.max_peeks - new_tot
msg = ("Pick {:d} more card(s) to look at.".format(remaining))
bot.send_text_message(self.player.id, msg)
self.request()
else:
return "Wait"
else:
bot.send_text_message(self.player.id,
"You cannot view more cards.")
return "Wait"
def resolve(self):
if len(self.chosen_players) == 2:
self.game_state.swap_player_cards(*self.chosen_players)
msg = "The cards you have chosen have been switched!"
bot.send_text_message(self.id, msg)
def __call__(self):
msg = ("You may exchange cards between two other players. " +
"Pick the first card or choose to do nothing")
bot.send_text_message(self.id, msg)
carousel = player_carousel(self, 'switch', do_nothing=True)
bot.send_generic_message(self.id, carousel)
def resolve(self):
role_name = self.role_dict[self.card]
bot.send_image_url(self.id, urls.role[role_name])
msg = "Your card is now the {}".format(role_name)
bot.send_text_message(self.id, msg)
def resolve(self):
self.game_state.swap_with_center(self.card_no, self.player_no)
msg = ("Your card is now Card {} ".format(self.card_no) +
"and your previous card is in the center.")
bot.send_text_message(self.id, msg)
def kill(self):
self.dead = True
bot.send_text_message(self.id, "Kill another player!")
carousel = player_carousel(self, 'kill')
bot.send_generic_message(self.id, carousel)
