Convert the transition_night_end event

src/roles/angel.py

@@ -226,10 +226,10 @@ def on_transition_night_begin(evt, cli, var):
     GUARDED.clear()
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     # the messages for angel and guardian angel are different enough to merit individual loops
-    ps = list_players()
+    ps = get_players()
-    for bg in var.ROLES["bodyguard"]:
+    for bg in get_players(("bodyguard",)):
         pl = ps[:]
         random.shuffle(pl)
         pl.remove(bg)
@@ -238,31 +238,31 @@ def on_transition_night_end(evt, cli, var):
         if chance > 0:
             warning = messages["bodyguard_death_chance"].format(chance)
 
-        if bg in var.PLAYERS and not is_user_simple(bg):
+        to_send = "bodyguard_notify"
-            pm(cli, bg, messages["bodyguard_notify"].format(warning))
+        if bg.prefers_simple():
-        else:
+            to_send = "bodyguard_simple"
-            pm(cli, bg, messages["bodyguard_simple"])  # !simple
+        bg.send(messages[to_send].format(warning), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
-        pm(cli, bg, "Players: " + ", ".join(pl))
 
-    for gangel in var.ROLES["guardian angel"]:
+    for gangel in get_players(("guardian angel",)):
         pl = ps[:]
         random.shuffle(pl)
         gself = messages["guardian_self_notification"]
         if not var.GUARDIAN_ANGEL_CAN_GUARD_SELF:
             pl.remove(gangel)
             gself = ""
-        if LASTGUARDED.get(gangel) in pl:
+        if gangel.nick in LASTGUARDED:
-            pl.remove(LASTGUARDED[gangel])
+            user = users._get(LASTGUARDED[gangel.nick]) # FIXME
+            if user in pl:
+                pl.remove(user)
         chance = math.floor(var.GUARDIAN_ANGEL_DIES_CHANCE * 100)
         warning = ""
         if chance > 0:
             warning = messages["bodyguard_death_chance"].format(chance)
 
-        if gangel in var.PLAYERS and not is_user_simple(gangel):
+        to_send = "guardian_notify"
-            pm(cli, gangel, messages["guardian_notify"].format(warning, gself))
+        if gangel.prefers_simple():
-        else:
+            to_send = "guardian_simple"
-            pm(cli, gangel, messages["guardian_simple"])  # !simple
+        gangel.send(messages[to_send].format(warning, gself), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
-        pm(cli, gangel, "Players: " + ", ".join(pl))
 
 @event_listener("assassinate")
 def on_assassinate(evt, cli, var, nick, target, prot):

src/roles/blessed.py

@@ -7,7 +7,8 @@ from collections import defaultdict
 import botconfig
 import src.settings as var
 from src.utilities import *
-from src import debuglog, errlog, plog
+from src import users, debuglog, errlog, plog
+from src.functions import get_players
 from src.decorators import cmd, event_listener
 from src.messages import messages
 from src.events import Event
@@ -41,13 +42,14 @@ def on_transition_day_resolve(evt, cli, var, victim):
         evt.prevent_default = True
 
 @event_listener("transition_night_end", priority=5)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     if var.FIRST_NIGHT or var.ALWAYS_PM_ROLE:
-        for blessed in var.ROLES["blessed villager"]:
+        for blessed in var.ROLES["blessed villager"]: # FIXME
-            if blessed in var.PLAYERS and not is_user_simple(blessed):
+            user = users._get(blessed) # FIXME
-                pm(cli, blessed, messages["blessed_notify"])
+            to_send = "blessed_notify"
-            else:
+            if user.prefers_simple():
-                pm(cli, blessed, messages["blessed_simple"])
+                to_send = "blessed_simple"
+            user.send(messages[to_send])
 
 @event_listener("desperation_totem")
 def on_desperation(evt, cli, var, votee, target, prot):

src/roles/detective.py

@@ -77,9 +77,9 @@ def on_exchange(evt, cli, var, actor, nick, actor_role, nick_role):
         INVESTIGATED.discard(nick)
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    ps = list_players()
+    ps = get_players()
-    for dttv in var.ROLES["detective"]:
+    for dttv in get_players(("detective",)):
         pl = ps[:]
         random.shuffle(pl)
         pl.remove(dttv)
@@ -87,12 +87,10 @@ def on_transition_night_end(evt, cli, var):
         warning = ""
         if chance > 0:
             warning = messages["detective_chance"].format(chance)
-        if dttv in var.PLAYERS and not is_user_simple(dttv):
+        to_send = "detective_notify"
-            pm(cli, dttv, messages["detective_notify"].format(warning))
+        if dttv.prefers_simple():
-        else:
+            to_send = "detective_simple"
-            pm(cli, dttv, messages["detective_simple"])  # !simple
+        dttv.send(messages[to_send].format(warning), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
-        pm(cli, dttv, "Players: " + ", ".join(pl))
-
 
 @event_listener("transition_night_begin")
 def on_transition_night_begin(evt, cli, var):

src/roles/dullahan.py

@@ -162,23 +162,21 @@ def on_chk_nightdone(evt, cli, var):
             evt.data["nightroles"].append(dullahan)
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    for dullahan in var.ROLES["dullahan"]:
+    for dullahan in get_players(("dullahan",)):
-        duser = users._get(dullahan) # FIXME
+        targets = list(TARGETS[dullahan])
-        targets = list(TARGETS[duser])
         for target in targets[:]:
             if target.nick in var.DEAD:
                 targets.remove(target) # FIXME: Update when var.DEAD holds User instances
         if not targets: # already all dead
-            duser.send("{0} {1}".format(messages["dullahan_simple"], messages["dullahan_targets_dead"]))
+            dullahan.send("{0} {1}".format(messages["dullahan_simple"], messages["dullahan_targets_dead"]))
             continue
         random.shuffle(targets)
-        if duser.prefers_simple():
+        to_send = "dullahan_notify"
-            duser.send(messages["dullahan_simple"])
+        if dullahan.prefers_simple():
-        else:
+            to_send = "dullahan_simple"
-            duser.send(messages["dullahan_notify"])
         t = messages["dullahan_targets"] if var.FIRST_NIGHT else messages["dullahan_remaining_targets"]
-        duser.send(t + ", ".join(t.nick for t in targets))
+        dullahan.send(messages[to_send], t + ", ".join(t.nick for t in targets), sep="\n")
 
 @event_listener("role_assignment")
 def on_role_assignment(evt, cli, var, gamemode, pl, restart):

src/roles/harlot.py

@@ -122,16 +122,15 @@ def on_exchange_roles(evt, cli, var, actor, nick, actor_role, nick_role):
             del VISITED[nick]
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    for harlot in var.ROLES["harlot"]:
+    for harlot in get_players(("harlot",)):
-        pl = list_players()
+        pl = get_players()
         random.shuffle(pl)
         pl.remove(harlot)
-        if harlot in var.PLAYERS and not is_user_simple(harlot):
+        to_send = "harlot_info"
-            pm(cli, harlot, messages["harlot_info"])
+        if harlot.prefers_simple():
-        else:
+            to_send = "harlot_simple"
-            pm(cli, harlot, messages["harlot_simple"])
+        harlot.send(messages[to_send], "Players: " + ", ".join(p.nick for p in pl), sep="\n")
-        pm(cli, harlot, "Players: " + ", ".join(pl))
 
 @event_listener("begin_day")
 def on_begin_day(evt, var):

src/roles/hunter.py

@@ -131,19 +131,18 @@ def on_chk_nightdone(evt, cli, var):
     evt.data["nightroles"].extend([p for p in hunter_users if p not in HUNTERS or p in KILLS])
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     ps = get_players()
-    for hunter in var.ROLES["hunter"]:
+    for hunter in get_players(("hunter",)):
-        user = users._get(hunter) # FIXME
+        if hunter in HUNTERS:
-        if user in HUNTERS:
             continue # already killed
         pl = ps[:]
         random.shuffle(pl)
-        pl.remove(user)
+        pl.remove(hunter)
         to_send = "hunter_notify"
-        if user.prefers_simple():
+        if hunter.prefers_simple():
             to_send = "hunter_simple"
-        user.send(messages[to_send], "Players: " + ", ".join(p.nick for p in pl), sep="\n")
+        hunter.send(messages[to_send], "Players: " + ", ".join(p.nick for p in pl), sep="\n")
 
 @event_listener("succubus_visit")
 def on_succubus_visit(evt, cli, var, nick, victim):

src/roles/madscientist.py

@@ -8,6 +8,7 @@ import botconfig
 import src.settings as var
 from src.utilities import *
 from src import channels, users, debuglog, errlog, plog
+from src.functions import get_players
 from src.decorators import command, event_listener
 from src.messages import messages
 from src.events import Event
@@ -150,15 +151,15 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
     evt.data["pl"] = pl
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    for ms in var.ROLES["mad scientist"]:
+    for ms in get_players(("mad scientist",)):
         pl = list_players()
-        target1, target2 = _get_targets(var, pl, ms)
+        target1, target2 = _get_targets(var, pl, ms.nick) # FIXME: Need to update _get_targets to accept users
 
-        if ms in var.PLAYERS and not is_user_simple(ms):
+        to_send = "mad_scientist_notify"
-            pm(cli, ms, messages["mad_scientist_notify"].format(target1, target2))
+        if ms.prefers_simple():
-        else:
+            to_send = "mad_scientist_simple"
-            pm(cli, ms, messages["mad_scientist_simple"].format(target1, target2))
+        ms.send(messages[to_send].format(target1, target2))
 
 @event_listener("myrole")
 def on_myrole(evt, cli, var, nick):

src/roles/mystic.py

@@ -40,7 +40,7 @@ def on_exchange(evt, cli, var, actor, nick, actor_role, nick_role):
         evt.data["nick_messages"].append(messages["mystic_info"].format("are" if numevil != 1 else "is", numevil, "s" if numevil != 1 else ""))
 
 @event_listener("transition_night_end", priority=2.01)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     # init with all roles that haven't been split yet
     special = set(get_players(("harlot", "priest", "prophet", "matchmaker",
                                "doctor", "hag", "sorcerer", "turncoat", "clone", "piper")))
@@ -51,19 +51,18 @@ def on_transition_night_end(evt, cli, var):
     neutral = set(get_players(var.TRUE_NEUTRAL_ROLES))
     special = evt2.data["special"]
 
-    for wolf in var.ROLES["wolf mystic"]:
+    for wolf in get_players(("wolf mystic",)):
         # if adding this info to !myrole, you will need to save off this count so that they can't get updated info until the next night
         # # of special villagers = # of players - # of villagers - # of wolves - # of neutrals
         numvills = len(special & (pl - wolves - neutral))
-        pm(cli, wolf, messages["wolf_mystic_info"].format("are" if numvills != 1 else "is", numvills, "s" if numvills != 1 else ""))
+        wolf.send(messages["wolf_mystic_info"].format("are" if numvills != 1 else "is", numvills, "s" if numvills != 1 else ""))
-    for mystic in var.ROLES["mystic"]:
+    for mystic in get_players(("mystic",)):
-        if mystic in var.PLAYERS and not is_user_simple(mystic):
+        to_send = "mystic_notify"
-            pm(cli, mystic, messages["mystic_notify"])
+        if mystic.prefers_simple():
-        else:
+            to_send = "mystic_simple"
-            pm(cli, mystic, messages["mystic_simple"])
         # if adding this info to !myrole, you will need to save off this count so that they can't get updated info until the next night
         numevil = len(wolves)
-        pm(cli, mystic, messages["mystic_info"].format("are" if numevil != 1 else "is", numevil, "s" if numevil != 1 else ""))
+        mystic.send(messages[to_send], messages["mystic_info"].format("are" if numevil != 1 else "is", numevil, "s" if numevil != 1 else ""), sep="\n")
 
 @event_listener("get_special")
 def on_get_special(evt, var):

src/roles/seer.py

@@ -5,7 +5,7 @@ import src.settings as var
 from src.utilities import *
 from src import debuglog, errlog, plog
 from src.decorators import cmd, event_listener
-from src.functions import get_players
+from src.functions import get_players, get_main_role
 from src.messages import messages
 from src.events import Event
 
@@ -105,11 +105,11 @@ def on_chk_nightdone(evt, cli, var):
     evt.data["nightroles"].extend(get_roles("seer", "oracle", "augur"))
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    for seer in list_players(("seer", "oracle", "augur")):
+    for seer in get_players(("seer", "oracle", "augur")):
-        pl = list_players()
+        pl = get_players()
         random.shuffle(pl)
-        role = get_role(seer)
+        role = get_main_role(seer)
         pl.remove(seer)  # remove self from list
 
         a = "a"
@@ -125,12 +125,10 @@ def on_transition_night_end(evt, cli, var):
         else:
             what = messages["seer_role_bug"]
 
-        if seer in var.PLAYERS and not is_user_simple(seer):
+        to_send = "seer_role_info"
-            pm(cli, seer, messages["seer_role_info"].format(a, role, what))
+        if seer.prefers_simple():
-        else:
+            to_send = "seer_simple"
-            pm(cli, seer, messages["seer_simple"].format(a, role))  # !simple
+        seer.send(messages[to_send].format(a, role, what), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
-        pm(cli, seer, "Players: " + ", ".join(pl))
-
 
 @event_listener("begin_day")
 def on_begin_day(evt, var):

src/roles/shaman.py

@@ -7,7 +7,7 @@ import botconfig
 import src.settings as var
 from src.utilities import *
 from src import debuglog, errlog, plog, users
-from src.functions import get_players
+from src.functions import get_players, get_main_role
 from src.decorators import cmd, event_listener
 from src.messages import messages
 from src.events import Event
@@ -500,48 +500,50 @@ def on_transition_day_end(evt, cli, var):
     cli.msg(botconfig.CHANNEL, "\n".join(message))
 
 @event_listener("transition_night_end", priority=2.01)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     max_totems = defaultdict(int)
-    ps = list_players()
+    ps = get_players()
-    shamans = list_players(var.TOTEM_ORDER)
+    shamans = list_players(var.TOTEM_ORDER) # FIXME: Need to convert alongside the entire role
     for ix in range(len(var.TOTEM_ORDER)):
         for c in var.TOTEM_CHANCES.values():
             max_totems[var.TOTEM_ORDER[ix]] += c[ix]
     for s in list(LASTGIVEN.keys()):
         if s not in shamans:
             del LASTGIVEN[s]
-    for shaman in list_players(var.TOTEM_ORDER):
+    for shaman in get_players(var.TOTEM_ORDER):
         pl = ps[:]
         random.shuffle(pl)
-        if shaman in LASTGIVEN and LASTGIVEN[shaman] in pl:
+        if shaman.nick in LASTGIVEN:
-            pl.remove(LASTGIVEN[shaman])
+            user = users._get(LASTGIVEN[shaman.nick]) # FIXME
-        role = get_role(shaman) # FIXME: don't use get_role here once split into one file per role
+            if user in pl:
+                pl.remove(user)
+        role = get_main_role(shaman) # FIXME: don't use get_main_role here once split into one file per role
         indx = var.TOTEM_ORDER.index(role)
         target = 0
         rand = random.random() * max_totems[var.TOTEM_ORDER[indx]]
         for t in var.TOTEM_CHANCES.keys():
             target += var.TOTEM_CHANCES[t][indx]
             if rand <= target:
-                TOTEMS[shaman] = t
+                TOTEMS[shaman.nick] = t # FIXME: Fix once shaman is converted
                 break
-        if shaman in var.PLAYERS and not is_user_simple(shaman):
+        if shaman.prefers_simple():
             if role not in var.WOLFCHAT_ROLES:
-                pm(cli, shaman, messages["shaman_notify"].format(role, "random " if shaman in var.ROLES["crazed shaman"] else ""))
+                shaman.send(messages["shaman_simple"].format(role))
             if role != "crazed shaman":
-                totem = TOTEMS[shaman]
+                shaman.send(messages["totem_simple"].format(TOTEMS[shaman.nick])) # FIXME
+        else:
+            if role not in var.WOLFCHAT_ROLES:
+                shaman.send(messages["shaman_notify"].format(role, "random " if shaman.nick in var.ROLES["crazed shaman"] else "")) # FIXME
+            if role != "crazed shaman":
+                totem = TOTEMS[shaman.nick] # FIXME
                 tmsg = messages["shaman_totem"].format(totem)
                 try:
                     tmsg += messages[totem + "_totem"]
                 except KeyError:
                     tmsg += messages["generic_bug_totem"]
-                pm(cli, shaman, tmsg)
+                shaman.send(tmsg)
-        else:
         if role not in var.WOLFCHAT_ROLES:
-                pm(cli, shaman, messages["shaman_simple"].format(role))
+            shaman.send("Players: " + ", ".join(p.nick for p in pl))
-            if role != "crazed shaman":
-                pm(cli, shaman, messages["totem_simple"].format(TOTEMS[shaman]))
-        if role not in var.WOLFCHAT_ROLES:
-            pm(cli, shaman, "Players: " + ", ".join(pl))
 
 @event_listener("begin_day")
 def on_begin_day(evt, var):

src/roles/succubus.py

@@ -267,16 +267,22 @@ def on_targeted_command(evt, cli, var, cmd, actor, orig_target, tags):
         evt.prevent_default = True
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    for succubus in var.ROLES["succubus"]:
+    succubi = get_players(("succubus",))
-        pl = list_players()
+    for succubus in succubi:
+        pl = get_players()
         random.shuffle(pl)
         pl.remove(succubus)
-        if succubus in var.PLAYERS and not is_user_simple(succubus):
+        to_send = "succubus_notify"
-            pm(cli, succubus, messages["succubus_notify"])
+        if succubus.prefers_simple():
+            to_send = "succubus_simple"
+        succ = []
+        for p in pl:
+            if p in succubi:
+                succ.append("{0} (succubus)".format(p))
             else:
-            pm(cli, succubus, messages["succubus_simple"])
+                succ.append(p.nick)
-        pm(cli, succubus, "Players: " + ", ".join(("{0} ({1})".format(x, get_role(x)) if x in var.ROLES["succubus"] else x for x in pl)))
+        succubus.send(messages[to_send], "Players: " + ", ".join(succ), sep="\n")
 
 @event_listener("begin_day")
 def on_begin_day(evt, var):

src/roles/vengefulghost.py

@@ -5,6 +5,7 @@ from collections import defaultdict
 import src.settings as var
 from src.utilities import *
 from src import channels, users, debuglog, errlog, plog
+from src.functions import get_players
 from src.decorators import command, event_listener
 from src.messages import messages
 from src.events import Event
@@ -194,10 +195,10 @@ def on_chk_nightdone(evt, cli, var):
     evt.data["nightroles"].extend([p.nick for p in GHOSTS if GHOSTS[p][0] != "!"])
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     # alive VGs are messaged as part of villager.py, this handles dead ones
-    ps = list_players()
+    ps = get_players()
-    wolves = list_players(var.WOLFTEAM_ROLES)
+    wolves = get_players(var.WOLFTEAM_ROLES)
     for v_ghost, who in GHOSTS.items():
         if who[0] == "!":
             continue
@@ -210,12 +211,11 @@ def on_transition_night_end(evt, cli, var):
 
         random.shuffle(pl)
 
-        if not v_ghost.prefers_simple():
+        to_send = "vengeful_ghost_notify"
-            v_ghost.send(messages["vengeful_ghost_notify"].format(who))
+        if v_ghost.prefers_simple():
-        else:
+            to_send = "vengeful_ghost_simple"
-            v_ghost.send(messages["vengeful_ghost_simple"])
+        v_ghost.send(messages[to_send].format(who), who.capitalize() + ": " + ", ".join(pl), sep="\n")
-        v_ghost.send(who.capitalize() + ": " + ", ".join(pl))
+        debuglog("GHOST: {0} (target: {1}) - players: {2}".format(v_ghost, who, ", ".join(p.nick for p in pl)))
-        debuglog("GHOST: {0} (target: {1}) - players: {2}".format(v_ghost.nick, who, ", ".join(pl)))
 
 @event_listener("myrole")
 def on_myrole(evt, cli, var, nick):

src/roles/vigilante.py

@@ -123,17 +123,16 @@ def on_chk_nightdone(evt, cli, var):
     evt.data["nightroles"].extend(get_roles("vigilante"))
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    ps = list_players()
+    ps = get_players()
-    for vigilante in var.ROLES["vigilante"]:
+    for vigilante in get_players(("vigilante",)):
         pl = ps[:]
         random.shuffle(pl)
         pl.remove(vigilante)
-        if vigilante in var.PLAYERS and not is_user_simple(vigilante):
+        to_send = "vigilante_notify"
-            pm(cli, vigilante, messages["vigilante_notify"])
+        if vigilante.prefers_simple():
-        else:
+            to_send = "vigilante_simple"
-            pm(cli, vigilante, messages["vigilante_simple"])
+        vigilante.send(messages[to_send], "Players: " + ", ".join(p.nick for p in pl), sep="\n")
-        pm(cli, vigilante, "Players: " + ", ".join(pl))
 
 @event_listener("succubus_visit")
 def on_succubus_visit(evt, cli, var, nick, victim):

src/roles/villager.py

@@ -1,6 +1,7 @@
 import src.settings as var
 from src.utilities import *
 from src import debuglog, errlog, plog
+from src.functions import get_players
 from src.decorators import cmd, event_listener
 from src.messages import messages
 from src.events import Event
@@ -8,27 +9,31 @@ from src.events import Event
 # handles villager and cultist
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     if var.FIRST_NIGHT or var.ALWAYS_PM_ROLE:
         villroles = var.HIDDEN_VILLAGERS | {"villager"}
         if var.DEFAULT_ROLE == "villager":
             villroles |= var.HIDDEN_ROLES
-        villagers = list_players(villroles)
+        villagers = get_players(villroles)
+        if villagers:
             for villager in villagers:
-            if villager in var.PLAYERS and not is_user_simple(villager):
+                to_send = "villager_notify"
-                pm(cli, villager, messages["villager_notify"])
+                if villager.prefers_simple():
-            else:
+                    to_send = "villager_simple"
-                pm(cli, villager, messages["villager_simple"])
+                villager.queue_message(messages[to_send])
+            villager.send_messages()
 
         cultroles = {"cultist"}
         if var.DEFAULT_ROLE == "cultist":
             cultroles |= var.HIDDEN_ROLES
-        cultists = list_players(cultroles)
+        cultists = get_players(cultroles)
+        if cultists:
             for cultist in cultists:
-            if cultist in var.PLAYERS and not is_user_simple(cultist):
+                to_send = "cultist_notify"
-                pm(cli, cultist, messages["cultist_notify"])
+                if cultist.prefers_simple():
-            else:
+                    to_send = "cultist_simple"
-                pm(cli, cultist, messages["cultist_simple"])
+                cultist.queue_message(messages[to_send])
+            cultist.send_messages()
 
 # No listeners should register before this one
 # This sets up the initial state, based on village/wolfteam/neutral affiliation

src/roles/wildchild.py

@@ -4,6 +4,7 @@ import re
 import src.settings as var
 from src.utilities import *
 from src import users, debuglog, errlog, plog
+from src.functions import get_players
 from src.decorators import cmd, event_listener
 from src.messages import messages
 from src.events import Event
@@ -137,12 +138,12 @@ def on_transition_day_begin(evt, cli, var):
                     pm(cli, child, messages["wild_child_random_idol"].format(target))
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    for child in var.ROLES["wild child"]:
+    for child in get_players(("wild child",)):
-        if child in var.PLAYERS and not is_user_simple(child):
+        to_send = "child_notify"
-            pm(cli, child, messages["child_notify"])
+        if child.prefers_simple():
-        else:
+            to_send = "child_simple"
-            pm(cli, child, messages["child_simple"])
+        child.send(messages[to_send])
 
 @event_listener("revealroles_role")
 def on_revealroles_role(evt, var, wrapper, nick, role):

src/roles/wolf.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 
 import src.settings as var
 from src.utilities import *
-from src.functions import get_players
+from src.functions import get_players, get_main_role, get_all_roles
 from src import debuglog, errlog, plog, users
 from src.decorators import cmd, event_listener
 from src.messages import messages
@@ -25,9 +25,7 @@ def wolf_can_kill(var, wolf):
     num_kills = nevt.data["numkills"]
     if num_kills == 0:
         return False
-    wolfroles = {get_role(wolf.nick)} # FIXME: pass user to get_role once updated
+    wolfroles = get_all_roles(wolf)
-    wolfroles.update(get_templates(wolf.nick)) # FIXME: pass user to get_templates once updated
-    # (actually should kill get_role/get_templates entirely and make get_mainrole and get_allroles)
     return bool(CAN_KILL & wolfroles)
 
 @cmd("kill", chan=False, pm=True, playing=True, silenced=True, phases=("night",), roles=CAN_KILL)
@@ -314,9 +312,9 @@ def on_chk_nightdone2(evt, cli, var):
             evt.data["actedcount"] -= 1
 
 @event_listener("transition_night_end", priority=2)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
-    ps = list_players()
+    ps = get_players()
-    wolves = list_players(var.WOLFCHAT_ROLES)
+    wolves = get_players(var.WOLFCHAT_ROLES)
     # roles in wolfchat (including those that can only listen in but not speak)
     wcroles = var.WOLFCHAT_ROLES
     # roles allowed to talk in wolfchat
@@ -346,12 +344,12 @@ def on_transition_night_end(evt, cli, var):
             talkroles = var.WOLF_ROLES | {"traitor"}
 
     for wolf in wolves:
-        normal_notify = wolf in var.PLAYERS and not is_user_simple(wolf)
+        normal_notify = not wolf.prefers_simple()
-        role = get_role(wolf)
+        role = get_main_role(wolf)
         wevt = Event("wolflist", {"tags": set()})
         tags = ""
         if role in wcroles:
-            wevt.dispatch(cli, var, wolf, wolf)
+            wevt.dispatch(wolf.client, var, wolf.nick, wolf.nick) # FIXME: Need to update the wolflist event
             tags = " ".join(wevt.data["tags"])
             if tags:
                 tags += " "
@@ -364,14 +362,14 @@ def on_transition_night_end(evt, cli, var):
                     tags2 = " ".join(wevt.data["tags"] - {"cursed"})
                     if tags2:
                         tags2 += " "
-                    pm(cli, wolf, messages[cmsg].format(tags2))
+                    wolf.send(messages[cmsg].format(tags2))
                 except KeyError:
-                    pm(cli, wolf, messages[msg].format(tags))
+                    wolf.send(messages[msg].format(tags))
             else:
-                pm(cli, wolf, messages[msg].format(tags))
+                wolf.send(messages[msg].format(tags))
 
             if len(wolves) > 1 and wccond is not None and role in talkroles:
-                pm(cli, wolf, messages["wolfchat_notify"].format(wccond))
+                wolf.send(messages["wolfchat_notify"].format(wccond))
         else:
             an = ""
             if tags:
@@ -379,35 +377,38 @@ def on_transition_night_end(evt, cli, var):
                     an = "n"
             elif role.startswith(("a", "e", "i", "o", "u")):
                 an = "n"
-            pm(cli, wolf, messages["wolf_simple"].format(an, tags, role))  # !simple
+            wolf.send(messages["wolf_simple"].format(an, tags, role))  # !simple
 
         pl = ps[:]
         random.shuffle(pl)
         pl.remove(wolf)  # remove self from list
+        players = []
         if role in wcroles:
-            for i, player in enumerate(pl):
+            for player in pl:
-                prole = get_role(player)
+                prole = get_main_role(player)
                 wevt.data["tags"] = set()
-                wevt.dispatch(cli, var, player, wolf)
+                wevt.dispatch(wolf.client, var, player.nick, wolf.nick) # FIXME: Need to update the wolflist event
                 tags = " ".join(wevt.data["tags"])
                 if prole in wcroles:
                     if tags:
                         tags += " "
-                    pl[i] = "\u0002{0}\u0002 ({1}{2})".format(player, tags, prole)
+                    players.append("\u0002{0}\u0002 ({1}{2})".format(player, tags, prole))
                 elif tags:
-                    pl[i] = "{0} ({1})".format(player, tags)
+                    players.append("{0} ({1})".format(player, tags))
         elif role == "warlock":
             # warlock specifically only sees cursed if they're not in wolfchat
-            for i, player in enumerate(pl):
+            for player in pl:
-                if player in var.ROLES["cursed villager"]:
+                if player.nick in var.ROLES["cursed villager"]: # FIXME: Once var.ROLES holds User instances
-                    pl[i] = player + " (cursed)"
+                    players.append(player.nick + " (cursed)")
+                else:
+                    players.append(player.nick)
 
-        pm(cli, wolf, "Players: " + ", ".join(pl))
+        wolf.send("Players: " + ", ".join(players))
         if role in CAN_KILL and var.DISEASED_WOLVES:
-            pm(cli, wolf, messages["ill_wolves"])
+            wolf.send(messages["ill_wolves"])
         # TODO: split the following out into their own files (alpha)
-        if var.ALPHA_ENABLED and role == "alpha wolf" and wolf not in var.ALPHA_WOLVES:
+        if var.ALPHA_ENABLED and role == "alpha wolf" and wolf.nick not in var.ALPHA_WOLVES: # FIXME: Fix once var.ALPHA_WOLVES holds User instances
-            pm(cli, wolf, messages["wolf_bite"])
+            wolf.send(messages["wolf_bite"])
 
 @event_listener("succubus_visit")
 def on_succubus_visit(evt, cli, var, nick, victim):

src/roles/wolfcub.py

@@ -45,7 +45,7 @@ def on_exchange(evt, cli, var, actor, nick, actor_role, nick_role):
         evt.data["nick_messages"].append(messages["angry_wolves"])
 
 @event_listener("transition_night_end", priority=3)
-def on_transition_night_end(evt, cli, var):
+def on_transition_night_end(evt, var):
     if not ANGRY_WOLVES:
         return
 
@@ -53,10 +53,10 @@ def on_transition_night_end(evt, cli, var):
     if not wolves or not wolf.wolf_can_kill(var, wolves[0]):
         return
 
-    # TODO: this should probably be a mass privmsg to reduce night lag,
-    # but there isn't a mass_privmsg equivalent with the new user API yet
     for wofl in wolves:
-        wofl.send(messages["angry_wolves"])
+        wofl.queue_message(messages["angry_wolves"])
+
+    wofl.send_messages()
 
 @event_listener("chk_win", priority=1)
 def on_chk_win(evt, cli, var, rolemap, mainroles, lpl, lwolves, lrealwolves):

src/wolfgame.py

@@ -5410,7 +5410,7 @@ def transition_night(cli):
         pm(cli, g, gun_msg)
 
     event_end = Event("transition_night_end", {})
-    event_end.dispatch(cli, var)
+    event_end.dispatch(var)
 
     dmsg = (daydur_msg + messages["night_begin"])