def _set_lovers(target1, target2):
if target1 in LOVERS:
LOVERS[target1].add(target2)
else:
LOVERS[target1] = UserSet({target2})
if target2 in LOVERS:
LOVERS[target2].add(target1)
else:
LOVERS[target2] = UserSet({target1})
target1.send(messages["matchmaker_target_notify"].format(target2))
target2.send(messages["matchmaker_target_notify"].format(target1))
def add_force_vote(var, votee: users.User,
targets: Iterable[users.User]) -> None:
"""Force votee to vote for the specified targets."""
if votee not in get_players():
return
_add_count(var, votee, 1)
FORCED_TARGETS.setdefault(votee, UserSet()).update(targets)
def setup_variables(rolename):
SEEN = UserSet()
@event_listener("del_player")
def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
SEEN.discard(user)
@event_listener("night_acted")
def on_acted(evt, var, user, actor):
if user in SEEN:
evt.data["acted"] = True
@event_listener("get_special")
def on_get_special(evt, var):
evt.data["villagers"].update(get_players((rolename, )))
@event_listener("exchange_roles")
def on_exchange(evt, var, actor, target, actor_role, target_role):
if actor_role == rolename and target_role != rolename:
SEEN.discard(actor)
elif target_role == rolename and actor_role != rolename:
SEEN.discard(target)
@event_listener("chk_nightdone")
def on_chk_nightdone(evt, var):
evt.data["actedcount"] += len(SEEN)
evt.data["nightroles"].extend(get_all_players((rolename, )))
@event_listener("transition_night_end", priority=2)
def on_transition_night_end(evt, var):
for seer in get_all_players((rolename, )):
pl = get_players()
random.shuffle(pl)
pl.remove(seer) # remove self from list
a = "a"
if rolename.startswith(("a", "e", "i", "o", "u")):
a = "an"
what = messages[rolename + "_ability"]
to_send = "seer_role_info"
if seer.prefers_simple():
to_send = "seer_simple"
seer.send(messages[to_send].format(a, rolename, what),
messages["players_list"].format(", ".join(p.nick
for p in pl)),
sep="\n")
@event_listener("begin_day")
def on_begin_day(evt, var):
SEEN.clear()
@event_listener("reset")
def on_reset(evt, var):
SEEN.clear()
return SEEN
def _set_lovers(target1, target2):
if target1 in LOVERS:
LOVERS[target1].add(target2)
else:
LOVERS[target1] = UserSet({target2})
if target2 in LOVERS:
LOVERS[target2].add(target1)
else:
LOVERS[target2] = UserSet({target1})
t1_msg = "matchmaker_target_notify"
if target1.prefers_simple():
t1_msg += "_simple"
t2_msg = "matchmaker_target_notify"
if target2.prefers_simple():
t2_msg += "_simple"
target1.send(messages[t1_msg].format(target2))
target2.send(messages[t2_msg].format(target1))
def on_role_assignment(evt, var, gamemode, pl):
# assign random targets to dullahan to kill
if var.ROLES["dullahan"]:
max_targets = math.ceil(8.1 * math.log(len(pl), 10) - 5)
for dull in var.ROLES["dullahan"]:
TARGETS[dull] = UserSet()
dull_targets = Event("dullahan_targets", {"targets": TARGETS}) # support sleepy
dull_targets.dispatch(var, var.ROLES["dullahan"], max_targets)
for dull, ts in TARGETS.items():
ps = pl[:]
ps.remove(dull)
while len(ts) < max_targets:
target = random.choice(ps)
ps.remove(target)
ts.add(target)
def on_new_role(evt, var, player, old_role):
if player in TARGETS and old_role == "dullahan" and evt.data["role"] != "dullahan":
del KILLS[:player:]
del TARGETS[player]
if player not in TARGETS and evt.data["role"] == "dullahan":
ps = get_players()
max_targets = math.ceil(8.1 * math.log(len(ps), 10) - 5)
TARGETS[player] = UserSet()
dull_targets = Event("dullahan_targets", {"targets": TARGETS[player]}) # support sleepy
dull_targets.dispatch(var, player, max_targets)
ps.remove(player)
while len(TARGETS[player]) < max_targets:
target = random.choice(ps)
ps.remove(target)
TARGETS[player].add(target)
def setup_variables(rolename):
SEEN = UserSet()
@event_listener("del_player", listener_id="<{}>.on_del_player".format(rolename))
def on_del_player(evt, var, player, all_roles, death_triggers):
SEEN.discard(player)
@event_listener("new_role", listener_id="<{}>.on_new_role".format(rolename))
def on_new_role(evt, var, user, old_role):
if old_role == rolename and evt.data["role"] != rolename:
SEEN.discard(user)
@event_listener("chk_nightdone", listener_id="<{}>.on_chk_nightdone".format(rolename))
def on_chk_nightdone(evt, var):
evt.data["actedcount"] += len(SEEN)
evt.data["nightroles"].extend(get_all_players((rolename,)))
@event_listener("transition_night_end", priority=2, listener_id="<{}>.on_transition_night_end".format(rolename))
def on_transition_night_end(evt, var):
for seer in get_all_players((rolename,)):
pl = get_players()
random.shuffle(pl)
pl.remove(seer) # remove self from list
a = "a"
if rolename.startswith(("a", "e", "i", "o", "u")):
a = "an"
what = messages[rolename + "_ability"]
to_send = "seer_role_info"
if seer.prefers_simple():
to_send = "seer_simple"
seer.send(messages[to_send].format(a, rolename, what), messages["players_list"].format(", ".join(p.nick for p in pl)), sep="\n")
@event_listener("begin_day", listener_id="<{}>.on_begin_day".format(rolename))
def on_begin_day(evt, var):
SEEN.clear()
@event_listener("reset", listener_id="<{}>.on_reset".format(rolename))
def on_reset(evt, var):
SEEN.clear()
return SEEN
def setup_variables(rolename):
SEEN = UserSet()
@event_listener("del_player", listener_id="<{}>.on_del_player".format(rolename))
def on_del_player(evt, var, player, all_roles, death_triggers):
SEEN.discard(player)
@event_listener("new_role", listener_id="<{}>.on_new_role".format(rolename))
def on_new_role(evt, var, user, old_role):
if old_role == rolename and evt.data["role"] != rolename:
SEEN.discard(user)
@event_listener("chk_nightdone", listener_id="<{}>.on_chk_nightdone".format(rolename))
def on_chk_nightdone(evt, var):
evt.data["acted"].extend(SEEN)
evt.data["nightroles"].extend(get_all_players((rolename,)))
@event_listener("transition_night_end", priority=2, listener_id="<{}>.on_transition_night_end".format(rolename))
def on_transition_night_end(evt, var):
for seer in get_all_players((rolename,)):
pl = get_players()
random.shuffle(pl)
pl.remove(seer) # remove self from list
seer.send(messages["seer_info_general"].format(rolename), messages[rolename + "_info"])
seer.send(messages["players_list"].format(pl))
@event_listener("begin_day", listener_id="<{}>.on_begin_day".format(rolename))
def on_begin_day(evt, var):
SEEN.clear()
@event_listener("reset", listener_id="<{}>.on_reset".format(rolename))
def on_reset(evt, var):
SEEN.clear()
return SEEN
import re
import random
from collections import defaultdict
from src.utilities import *
from src import users, channels, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_target, get_main_role
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.events import Event
KILLS = UserDict() # type: Dict[users.User, users.User]
HUNTERS = UserSet()
PASSED = UserSet()
@command("kill",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("hunter", ))
def hunter_kill(var, wrapper, message):
"""Kill someone once per game."""
if wrapper.source in HUNTERS and wrapper.source not in KILLS:
wrapper.pm(messages["hunter_already_killed"])
return
target = get_target(var,
wrapper,
import random
from src.utilities import *
from src import users, channels, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_all_roles, get_target, get_main_role, change_role
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange, add_lycanthropy, add_lycanthropy_scope
from src.cats import Wolf, All
from src.roles.helper.wolves import is_known_wolf_ally, send_wolfchat_message, register_wolf
register_wolf("alpha wolf")
ENABLED = False
ALPHAS = UserSet() # type: UserSet[users.User]
BITTEN = UserDict() # type: UserDict[users.User, users.User]
@command("bite", chan=False, pm=True, playing=True, silenced=True, phases=("night",), roles=("alpha wolf",))
def observe(var, wrapper, message):
"""Turn a player into a wolf!"""
if not ENABLED:
wrapper.pm(messages["alpha_no_bite"])
return
if wrapper.source in ALPHAS:
wrapper.pm(messages["alpha_already_bit"])
return
target = get_target(var, wrapper, re.split(" +", message)[0])
if not target:
return
if is_known_wolf_ally(var, wrapper.source, target):
import re
import random
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.events import Event
PRAYED = UserSet() # type: Set[users.User]
@command("pray",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("prophet", ))
def pray(var, wrapper, message):
"""Receive divine visions of who has a role."""
if wrapper.source in PRAYED:
wrapper.pm(messages["already_prayed"])
return
what = re.split(" +", message)[0]
import re
import random
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import users, channels, debuglog, errlog, plog
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
REVEALED_MAYORS = UserSet()
@event_listener("chk_decision_lynch", priority=3)
def on_chk_decision_lynch(evt, var, voters):
votee = evt.data["votee"]
if votee in var.ROLES["mayor"] and votee not in REVEALED_MAYORS:
channels.Main.send(messages["mayor_reveal"].format(votee))
REVEALED_MAYORS.add(votee)
evt.data["votee"] = None
evt.prevent_default = True
evt.stop_processing = True
@event_listener("reset")
def on_reset(evt, var):
REVEALED_MAYORS.clear()
from src.decorators import event_listener
from src.containers import UserSet
from src.functions import get_players
from src.events import Event
__all__ = ["add_disease", "remove_disease", "wolves_diseased"]
DISEASED = UserSet() # type: Set[users.User]
DISEASED_WOLVES = False
def add_disease(var, target):
"""Effect the target with disease. Fire the add_disease event."""
if target in DISEASED or target not in get_players():
return
if Event("add_disease", {}).dispatch(var, target):
DISEASED.add(target)
def remove_disease(var, target):
"""Remove the disease effect from the player."""
DISEASED.discard(target)
def wolves_diseased(var):
"""Return whether or not wolves are currently diseased."""
return DISEASED_WOLVES
@event_listener("transition_day_resolve_end")
def on_transition_day_resolve(evt, var, victims):
global DISEASED_WOLVES
for victim in evt.data["dead"]:
if "@wolves" in evt.data["killers"][victim] and victim in DISEASED: # Silly wolves, eating a sick person... tsk tsk
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
from src.events import Event
from src.cats import Wolf, Wolfchat
VISITED = UserDict() # type: UserDict[users.User, users.User]
PASSED = UserSet()
FORCE_PASSED = UserSet()
@command("visit",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("harlot", ))
def hvisit(var, wrapper, message):
"""Visit a player. You will die if you visit a wolf or a target of the wolves."""
if VISITED.get(wrapper.source):
wrapper.pm(messages["harlot_already_visited"].format(
VISITED[wrapper.source]))
def charm(var, wrapper, message):
"""Charm a player or two, slowly leading to your win!"""
pieces = re.split(" +", message)
target1 = pieces[0]
if len(pieces) > 1:
if len(pieces) > 2 and pieces[1].lower() == "and":
target2 = pieces[2]
else:
target2 = pieces[1]
else:
target2 = None
target1 = get_target(var, wrapper, target1)
if not target1:
return
if target2 is not None:
target2 = get_target(var, wrapper, target2)
if not target2:
return
orig1 = target1
orig2 = target2
target1 = try_misdirection(var, wrapper.source, target1)
if target2 is not None:
target2 = try_misdirection(var, wrapper.source, target2)
if try_exchange(var, wrapper.source, target1) or try_exchange(
var, wrapper.source, target2):
return
# Do these checks based on original targets, so piper doesn't know to change due to misdirection/luck totem
if orig1 is orig2:
wrapper.send(messages["must_charm_multiple"])
return
if orig1 in CHARMED and orig2 in CHARMED:
wrapper.send(messages["targets_already_charmed"].format(orig1, orig2))
return
elif orig1 in CHARMED:
wrapper.send(messages["target_already_charmed"].format(orig1))
return
elif orig2 in CHARMED:
wrapper.send(messages["target_already_charmed"].format(orig2))
return
if wrapper.source in TOBECHARMED:
TOBECHARMED[wrapper.source].clear()
else:
TOBECHARMED[wrapper.source] = UserSet()
TOBECHARMED[wrapper.source].update({target1, target2} - {None})
PASSED.discard(wrapper.source)
if orig2:
debuglog("{0} (piper) CHARM {1} ({2}) && {3} ({4})".format(
wrapper.source, target1, get_main_role(target1), target2,
get_main_role(target2)))
wrapper.send(messages["charm_multiple_success"].format(orig1, orig2))
else:
debuglog("{0} (piper) CHARM {1} ({2})".format(wrapper.source, target1,
get_main_role(target1)))
wrapper.send(messages["charm_success"].format(orig1))
from datetime import datetime, timedelta
import random
import copy
import math
import re
from src.containers import UserDict, UserList, UserSet
from src.decorators import command, event_listener
from src.functions import get_players, get_target, get_reveal_role
from src.messages import messages
from src.status import try_absent, get_absent, get_forced_votes, get_forced_abstains, get_vote_weight, try_lynch_immunity, add_dying, kill_players
from src.events import Event
from src import channels
VOTES = UserDict() # type: UserDict[users.User, UserList[users.User]]
ABSTAINS = UserSet() # type: UserList[users.User]
ABSTAINED = False
LAST_VOTES = None
LYNCHED = 0 # type: int
@command("lynch", playing=True, pm=True, phases=("day", ))
def lynch(var, wrapper, message):
"""Use this to vote for a candidate to be lynched."""
if not message:
show_votes.func(var, wrapper, message)
return
if wrapper.private:
return
msg = re.split(" +", message)[0].strip()
import random
import itertools
import math
from collections import defaultdict, deque
import botconfig
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.events import Event
TARGETED = UserDict() # type: Dict[users.User, users.User]
PREV_ACTED = UserSet()
@command("target", chan=False, pm=True, playing=True, silenced=True, phases=("night",), roles=("assassin",))
def target(var, wrapper, message):
"""Pick a player as your target, killing them if you die."""
if wrapper.source in PREV_ACTED:
wrapper.send(messages["assassin_already_targeted"])
return
target = get_target(var, wrapper, re.split(" +", message)[0])
if not target:
return
evt = Event("targeted_command", {"target": target, "misdirection": True, "exchange": True})
if not evt.dispatch(var, wrapper.source, target):
return
import re
import random
from src import users, channels, status, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
from src.cats import All
from src.roles.helper.wolves import is_known_wolf_ally, register_wolf, send_wolfchat_message
register_wolf("doomsayer")
SEEN = UserSet()
LASTSEEN = UserDict() # type: UserDict[users.User, users.User]
KILLS = UserDict()
SICK = UserDict()
LYCANS = UserDict()
_mappings = ("death", KILLS), ("lycan", LYCANS), ("sick", SICK)
@command("see",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("doomsayer", ))
from src.containers import UserSet
from src.decorators import event_listener
from src.functions import get_main_role, change_role, get_players
from src.messages import messages
from src.events import Event
__all__ = ["add_exchange", "try_exchange"]
EXCHANGE = UserSet() # type: Set[users.User]
def add_exchange(var, user):
if user not in get_players():
return
EXCHANGE.add(user)
def try_exchange(var, actor, target):
"""Check if an exchange is happening. Return True if the exchange occurs."""
if actor is target or target not in EXCHANGE:
return False
EXCHANGE.remove(target)
role = get_main_role(actor)
target_role = get_main_role(target)
actor_role = change_role(var,
actor,
role,
target_role,
# 4. Implement the "transition_day_begin" and "transition_night_end" events to give #
# out totems if the shaman didn't act, and send night messages, respectively. #
# Implementation of the "get_role_metadata" event with the "role_categories" #
# kind is also necessary for the bot to know that the role exists at all. You #
# may look at existing shamans for reference. If your shaman isn't a wolf role, #
# the "lycanthropy_role" kind should also be implemented as follows: #
# evt.data[role] = {"role": "wolf shaman", "prefix": "shaman"} #
# You will also need to implement your own "give" command; see existing #
# shamans for reference, or ask for help in our development channel. #
# #
# It is generally unneeded to modify this file to add new totems or shaman roles #
#####################################################################################
DEATH = UserDict() # type: Dict[users.User, List[users.User]]
PROTECTION = UserList() # type: List[users.User]
REVEALING = UserSet() # type: Set[users.User]
NARCOLEPSY = UserSet() # type: Set[users.User]
SILENCE = UserSet() # type: Set[users.User]
DESPERATION = UserSet() # type: Set[users.User]
IMPATIENCE = UserList() # type: List[users.User]
PACIFISM = UserList() # type: List[users.User]
INFLUENCE = UserSet() # type: Set[users.User]
EXCHANGE = UserSet() # type: Set[users.User]
LYCANTHROPY = UserSet() # type: Set[users.User]
LUCK = UserSet() # type: Set[users.User]
PESTILENCE = UserSet() # type: Set[users.User]
RETRIBUTION = UserSet() # type: Set[users.User]
MISDIRECTION = UserSet() # type: Set[users.User]
DECEIT = UserSet() # type: Set[users.User]
# holding vars that don't persist long enough to need special attention in
import re
import random
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.events import Event
MATCHMAKERS = UserSet() # type: Set[users.User]
LOVERS = UserDict() # type: Dict[users.User, Set[users.User]]
def _set_lovers(target1, target2):
if target1 in LOVERS:
LOVERS[target1].add(target2)
else:
LOVERS[target1] = UserSet({target2})
if target2 in LOVERS:
LOVERS[target2].add(target1)
else:
LOVERS[target2] = UserSet({target1})
t1_msg = "matchmaker_target_notify"
if target1.prefers_simple():
import re
import random
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
JESTERS = UserSet() # type: UserSet[users.User]
@event_listener("lynch")
def on_lynch(evt, var, votee, voters):
if votee in get_all_players(("jester",)):
JESTERS.add(votee)
@event_listener("player_win")
def on_player_win(evt, var, player, main_role, all_roles, winner, team_win, survived):
if player in JESTERS:
evt.data["individual_win"] = True
@event_listener("transition_night_end")
def on_transition_night_end(evt, var):
for jester in get_all_players(("jester",)):
jester.send(messages["jester_notify"])
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.events import Event
from src.roles.helper.wolves import get_wolfchat_roles, is_known_wolf_ally, send_wolfchat_message
CURSED = UserDict() # type: UserDict[users.User, users.User]
PASSED = UserSet() # type: UserSet[users.Set]
@command("curse",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("warlock", ))
def curse(var, wrapper, message):
target = get_target(var, wrapper, re.split(" +", message)[0])
if not target:
return
if target in get_all_players(("cursed villager", )):
import random
import itertools
import math
from collections import defaultdict
import botconfig
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
from src.cats import Wolf
RECEIVED_INFO = UserSet()
def wolf_list(var):
wolves = [wolf.nick for wolf in get_all_players(Wolf)]
random.shuffle(wolves)
return messages["wolves_list"].format(", ".join(wolves))
@event_listener("transition_night_end", priority=2)
def on_transition_night_end(evt, var):
for minion in get_all_players(("minion", )):
if minion in RECEIVED_INFO and not var.ALWAYS_PM_ROLE:
continue
minion.send(messages["minion_notify"])
minion.send(wolf_list(var))
import re
import random
import itertools
import math
from collections import defaultdict
import botconfig
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.events import Event
ENTRANCED = UserSet() # type: Set[users.User]
VISITED = UserDict() # type: Dict[users.User, users.User]
PASSED = UserSet() # type: Set[users.User]
ALL_SUCC_IDLE = True
@command("visit", chan=False, pm=True, playing=True, silenced=True, phases=("night",), roles=("succubus",))
def hvisit(var, wrapper, message):
"""Entrance a player, converting them to your team."""
if VISITED.get(wrapper.source):
wrapper.send(messages["succubus_already_visited"].format(VISITED[wrapper.source]))
return
target = get_target(var, wrapper, re.split(" +", message)[0], not_self_message="succubus_not_self")
if not target:
return
import random
import itertools
import math
from collections import defaultdict
import botconfig
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.events import Event
VISITED = UserDict() # type: Dict[users.User, users.User]
PASSED = UserSet() # type: Set[users.User]
@command("visit",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("harlot", ))
def hvisit(var, wrapper, message):
"""Visit a player. You will die if you visit a wolf or a target of the wolves."""
if VISITED.get(wrapper.source):
wrapper.pm(messages["harlot_already_visited"].format(
VISITED[wrapper.source]))
import math
from collections import defaultdict
import src.settings as var
from src.utilities import *
from src import users, channels, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_target, get_main_role
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange, add_protection, add_dying
from src.cats import Wolf
GUARDED = UserDict() # type: UserDict[users.User, users.User]
LASTGUARDED = UserDict() # type: UserDict[users.User, users.User]
PASSED = UserSet()
@command("guard",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("guardian angel", ))
def guard(var, wrapper, message):
"""Guard a player, preventing them from being killed that night."""
if wrapper.source in GUARDED:
wrapper.pm(messages["already_protecting"])
return
import re
import random
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
from src.events import Event
ENTRANCED = UserSet()
VISITED = UserDict() # type: UserDict[users.User, users.User]
PASSED = UserSet()
FORCE_PASSED = UserSet()
ALL_SUCC_IDLE = True
@command("visit",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("succubus", ))
def hvisit(var, wrapper, message):
"""Entrance a player, converting them to your team."""
import random
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
from src.events import Event
from src.cats import Neutral, Wolfteam
INVESTIGATED = UserSet()
@command("id",
"investigate",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("day", ),
roles=("investigator", ))
def investigate(var, wrapper, message):
"""Investigate two players to determine their relationship to each other."""
if wrapper.source in INVESTIGATED:
wrapper.pm(messages["already_investigated"])
return
import random
import itertools
import math
from collections import defaultdict
import botconfig
from src.utilities import *
from src import channels, users, debuglog, errlog, plog
from src.functions import get_players, get_all_players, get_main_role, get_reveal_role, get_target
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import try_misdirection, try_exchange
from src.cats import Wolf
RECEIVED_INFO = UserSet()
KNOWS_MINIONS = UserSet()
def wolf_list(var):
wolves = [wolf.nick for wolf in get_all_players(Wolf)]
random.shuffle(wolves)
return messages["wolves_list"].format(", ".join(wolves))
@event_listener("transition_night_end", priority=2)
def on_transition_night_end2(evt, var):
for minion in get_all_players(("minion",)):
if minion in RECEIVED_INFO and not var.ALWAYS_PM_ROLE:
continue
minion.send(messages["minion_notify"])
minion.send(wolf_list(var))
RECEIVED_INFO.add(minion)