from src.functions import get_all_roles
from src.decorators import event_listener
from src.roles.helper.wolves import register_wolf
register_wolf("werekitten")
@event_listener("gun_shoot")
def on_gun_shoot(evt, var, user, target, role):
if "werekitten" in get_all_roles(target):
evt.data["hit"] = False
evt.data["kill"] = False
@event_listener("get_role_metadata")
def on_get_role_metadata(evt, var, kind):
if kind == "role_categories":
evt.data["werekitten"] = {
"Wolf", "Wolfchat", "Wolfteam", "Innocent", "Killer", "Nocturnal",
"Village Objective", "Wolf Objective"
}
import re
import random
import itertools
import math
from collections import defaultdict
from src.utilities import *
from src import users, channels, status, debuglog, errlog, plog
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.functions import get_players, get_all_players
from src.messages import messages
from src.status import try_misdirection, try_exchange
from src.cats import Wolf
from src.roles.helper.wolves import register_wolf
register_wolf("fallen angel")
@event_listener("try_protection")
def on_try_protection(evt, var, target, attacker, attacker_role, reason):
if attacker_role == "wolf" and get_all_players(("fallen angel",)):
status.remove_all_protections(var, target, attacker=None, attacker_role="fallen angel", reason="fallen_angel")
evt.prevent_default = True
@event_listener("get_role_metadata")
def on_get_role_metadata(evt, var, kind):
if kind == "role_categories":
evt.data["fallen angel"] = {"Wolf", "Wolfchat", "Wolfteam", "Killer", "Nocturnal"}
import re
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
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, add_silent
from src.roles.helper.wolves import is_known_wolf_ally, send_wolfchat_message, register_wolf
register_wolf("hag")
HEXED = UserDict() # type: UserDict[users.User, users.User]
LASTHEXED = UserDict() # type: UserDict[users.User, users.User]
@command("hex",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("hag", ))
def hex_cmd(var, wrapper, message):
"""Hex someone, preventing them from acting the next day and night."""
if wrapper.source in HEXED:
import re
import random
import itertools
import math
from collections import defaultdict
from src import debuglog, errlog, plog, users, channels
from src.decorators import command, event_listener
from src.containers import UserList, UserSet, UserDict, DefaultUserDict
from src.messages import messages
from src.status import in_misdirection_scope
from src.events import Event
from src.roles.helper.wolves import register_wolf, get_wolfchat_roles
from src.cats import All, Wolf
register_wolf("traitor")
@event_listener("get_reveal_role")
def on_get_reveal_role(evt, var, user):
# in team reveal, show traitor as wolfteam, otherwise team stats won't sync with how
# they're revealed upon death. Team stats should show traitor as wolfteam or else
# the stats are wrong in that they'll report one less wolf than actually exists,
# which can confuse a lot of people
if evt.data["role"] == "traitor" and var.HIDDEN_TRAITOR and var.ROLE_REVEAL != "team":
evt.data["role"] = var.HIDDEN_ROLE
@event_listener("get_final_role")
def on_get_final_role(evt, var, user, role):
# if a traitor turns we want to show them as traitor in the end game readout
# instead of "wolf (was traitor)"
if role == "traitor" and evt.data["role"] == "wolf":
from src import debuglog, errlog, plog, users, channels
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.dispatcher import MessageDispatcher
from src.messages import messages
from src.events import Event
from src.status import try_misdirection, try_exchange, is_silent
from src.roles.helper.shamans import get_totem_target, give_totem, setup_variables, totem_message
from src.roles.helper.wolves import register_wolf, send_wolfchat_message
TOTEMS, LASTGIVEN, SHAMANS, RETARGET = setup_variables("wolf shaman",
knows_totem=True)
register_wolf("wolf shaman")
@command("totem",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("wolf shaman", ))
def wolf_shaman_totem(var, wrapper, message):
"""Give a totem to a player."""
totem_types = list(TOTEMS[wrapper.source].keys())
totem, target = get_totem_target(var, wrapper, message, LASTGIVEN,
totem_types)
import re
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
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 Nocturnal
from src.roles.helper.wolves import is_known_wolf_ally, send_wolfchat_message, register_wolf
register_wolf("werecrow")
OBSERVED = UserDict() # type: UserDict[users.User, users.User]
@command("observe",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("werecrow", ))
def observe(var, wrapper, message):
"""Observe a player to see whether they are able to act at night."""
if wrapper.source in OBSERVED:
wrapper.pm(messages["werecrow_already_observing"].format(
OBSERVED[wrapper.source]))
return
import math
from src.events import Event, find_listener
from src.functions import get_players, get_all_players
from src.decorators import event_listener
from src.messages import messages
from src.roles.helper.gunners import setup_variables
from src.roles.helper.wolves import register_wolf, is_known_wolf_ally
register_wolf("wolf gunner")
GUNNERS = setup_variables("wolf gunner")
# unregister the gunner night message and send the number of bullets a different way
find_listener("transition_night_end",
"gunners.<wolf gunner>.on_transition_night_end").remove(
"transition_night_end")
# wolf gunners don't shoot other wolves at night nor get their gun stolen
find_listener("transition_day_resolve_end",
"gunners.<wolf gunner>.on_transition_day_resolve_end").remove(
"transition_day_resolve_end")
@event_listener("transition_night_end")
def on_transition_night_end(evt, var):
gunners = get_all_players(("wolf gunner", ))
for gunner in gunners:
if GUNNERS[gunner] or var.ALWAYS_PM_ROLE:
gunner.send(messages["gunner_bullets"].format(GUNNERS[gunner]))
@event_listener("gun_shoot")
from src.decorators import event_listener
from src.roles.helper.wolves import register_wolf
register_wolf("cult leader")
@event_listener("get_role_metadata")
def on_get_role_metadata(evt, var, kind):
if kind == "role_categories":
evt.data["cult leader"] = {"Wolfchat", "Wolfteam"}
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", ))
import re
import random
from src.utilities import *
from src import users, channels, debuglog, errlog, plog
from src.functions import get_players, get_all_players
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.roles.helper.mystics import register_mystic
from src.roles.helper.wolves import register_wolf
register_mystic("wolf mystic", send_role=False, types=("Safe", "Win Stealer"))
register_wolf("wolf mystic")
@event_listener("get_role_metadata")
def on_get_role_metadata(evt, var, kind):
if kind == "role_categories":
evt.data["wolf mystic"] = {
"Wolf", "Wolfchat", "Wolfteam", "Killer", "Nocturnal", "Intuitive"
}
from src.decorators import event_listener
from src.roles.helper.wolves import register_wolf
register_wolf("wolf")
@event_listener("get_role_metadata")
def on_get_role_metadata(evt, var, kind):
if kind == "role_categories":
evt.data["wolf"] = {
"Wolf", "Wolfchat", "Wolfteam", "Killer", "Nocturnal"
}
import re
import random
from collections import defaultdict
from src.utilities import *
from src.functions import get_players
from src import debuglog, errlog, plog, users, channels
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, Killer
from src.roles.helper.wolves import wolf_can_kill, register_wolf
register_wolf("wolf cub")
ANGRY_WOLVES = False
@event_listener("wolf_numkills")
def on_wolf_numkills(evt, var):
if ANGRY_WOLVES:
evt.data["numkills"] = max(evt.data["numkills"], 2)
@event_listener("del_player")
def on_del_player(evt, var, player, all_roles, death_triggers):
if death_triggers and "wolf cub" in all_roles:
global ANGRY_WOLVES
ANGRY_WOLVES = True
@event_listener("new_role")
def on_new_role(evt, var, player, old_role):
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.roles.helper.wolves import get_wolfchat_roles, is_known_wolf_ally, send_wolfchat_message, get_wolflist, register_wolf
register_wolf("warlock")
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",)):
wrapper.pm(messages["target_already_cursed"].format(target))
return
# There may actually be valid strategy in cursing other wolfteam members,
from src import channels
from src.messages import messages
from src.decorators import event_listener
from src.containers import UserSet
from src.functions import get_all_players, get_all_roles
from src.status import add_lynch_immunity
from src.roles.helper.wolves import register_wolf
ACTIVATED = UserSet()
register_wolf("tough wolf")
@event_listener("reset")
def on_reset(evt, var):
ACTIVATED.clear()
@event_listener("transition_day_begin")
def on_transition_day_begin(evt, var):
for player in get_all_players(("tough wolf", )):
if player not in ACTIVATED:
add_lynch_immunity(var, player, "tough_wolf")
@event_listener("lynch_immunity")
def on_lynch_immunity(evt, var, player, reason):
if reason == "tough_wolf":
channels.Main.send(messages["tough_wolf_reveal"].format(player))
evt.data["immune"] = True
ACTIVATED.add(player)
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.cats import Spy
from src.roles.helper.wolves import is_known_wolf_ally, send_wolfchat_message, register_wolf
register_wolf("sorcerer")
OBSERVED = UserSet() # type: UserSet[users.User]
@command("observe",
chan=False,
pm=True,
playing=True,
silenced=True,
phases=("night", ),
roles=("sorcerer", ))
def observe(var, wrapper, message):
"""Observe a player to obtain various information."""
target = get_target(var,
wrapper,
