Change a bunch of things because we felt like it

* Convert the del_player event
* HAAAAAAAAAAAAAAANDS
* <insert snarky commit message here>

src/gamemodes.py

@@ -9,6 +9,7 @@ import botconfig
 import src.settings as var
 from src.utilities import *
 from src.messages import messages
+from src.functions import get_players, get_all_players
 from src.decorators import handle_error
 from src import events, channels, users
 
@@ -1135,25 +1136,25 @@ class SleepyMode(GameMode):
             var.DYING.add(self.having_nightmare)
             pm(cli, self.having_nightmare, messages["sleepy_nightmare_death"])
 
-    def happy_fun_times(self, evt, cli, var, nick, mainrole, allroles, death_triggers):
+    def happy_fun_times(self, evt, var, user, mainrole, allroles, death_triggers):
         if death_triggers:
             if mainrole == "priest":
                 pl = evt.data["pl"]
                 turn_chance = 3/4
-                seers = [p for p in var.ROLES["seer"] if p in pl and random.random() < turn_chance]
+                seers = [p for p in get_all_players(("seer",)) if p.nick in pl and random.random() < turn_chance]
-                harlots = [p for p in var.ROLES["harlot"] if p in pl and random.random() < turn_chance]
+                harlots = [p for p in get_all_players(("harlot",)) if p.nick in pl and random.random() < turn_chance]
-                cultists = [p for p in var.ROLES["cultist"] if p in pl and random.random() < turn_chance]
+                cultists = [p for p in get_all_players(("cultist",)) if p.nick in pl and random.random() < turn_chance]
-                cli.msg(botconfig.CHANNEL, messages["sleepy_priest_death"])
+                channels.Main.send(messages["sleepy_priest_death"])
                 for seer in seers:
-                    change_role(users._get(seer), "seer", "doomsayer") # FIXME
+                    change_role(seer, "seer", "doomsayer")
-                    pm(cli, seer, messages["sleepy_doomsayer_turn"])
+                    seer.send(messages["sleepy_doomsayer_turn"])
-                    relay_wolfchat_command(cli, seer, messages["sleepy_doomsayer_wolfchat"].format(seer), var.WOLF_ROLES, is_wolf_command=True, is_kill_command=True)
+                    relay_wolfchat_command(seer.client, seer.nick, messages["sleepy_doomsayer_wolfchat"].format(seer), var.WOLF_ROLES, is_wolf_command=True, is_kill_command=True)
                 for harlot in harlots:
-                    change_role(users._get(harlot), "harlot", "succubus") # FIXME
+                    change_role(harlot, "harlot", "succubus")
-                    pm(cli, harlot, messages["sleepy_succubus_turn"])
+                    harlot.send(messages["sleepy_succubus_turn"])
                 for cultist in cultists:
-                    change_role(users._get(cultist), "cultist", "demoniac") # FIXME
+                    change_role(cultist, "cultist", "demoniac")
-                    pm(cli, cultist, messages["sleepy_demoniac_turn"])
+                    cultist.send(messages["sleepy_demoniac_turn"])
                 # NOTE: chk_win is called by del_player, don't need to call it here even though this has a chance of ending game
 
 @game_mode("maelstrom", minp = 8, maxp = 24, likelihood = 0)
@@ -1189,15 +1190,15 @@ class MaelstromMode(GameMode):
         events.remove_listener("del_player", self.on_del_player)
         events.remove_listener("join", self.on_join)
 
-    def on_del_player(self, evt, cli, var, nick, mainrole, allroles, death_triggers):
+    def on_del_player(self, evt, var, user, mainrole, allroles, death_triggers):
-        if is_fake_nick(nick):
+        if user.is_fake:
             return
 
         if not var.DISABLE_ACCOUNTS:
-            self.DEAD_ACCOUNTS.add(irc_lower(var.USERS[nick]["account"]))
+            self.DEAD_ACCOUNTS.add(user.lower().account)
 
         if not var.ACCOUNTS_ONLY:
-            self.DEAD_HOSTS.add(var.USERS[nick]["host"].lower())
+            self.DEAD_HOSTS.add(user.lower().host)
 
     def on_join(self, evt, var, wrapper, message, forced=False):
         if var.PHASE != "day" or (wrapper.public and wrapper.target is not channels.Main):

src/roles/angel.py

@@ -80,15 +80,14 @@ def on_rename(evt, cli, var, prefix, nick):
         PASSED.add(nick)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
-    if var.PHASE == "night" and nick in GUARDED:
+    if var.PHASE == "night" and user.nick in GUARDED:
-        pm(cli, GUARDED[nick], messages["protector_disappeared"])
+        pm(user.client, GUARDED[user.nick], messages["protector_disappeared"])
     for dictvar in (GUARDED, LASTGUARDED):
         for k,v in list(dictvar.items()):
-            if nick in (k, v):
+            if user.nick in (k, v):
                 del dictvar[k]
-    if nick in PASSED:
+    PASSED.discard(user.nick)
-        PASSED.discard(nick)
 
 @event_listener("night_acted")
 def on_acted(evt, var, nick, sender):

src/roles/detective.py

@@ -62,12 +62,12 @@ def on_rename(evt, cli, var, prefix, nick):
         INVESTIGATED.add(nick)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
-    INVESTIGATED.discard(nick)
+    INVESTIGATED.discard(user.nick)
 
 @event_listener("get_special")
 def on_get_special(evt, var):
-    evt.data["special"].update(get_all_players(("detective",)))
+    evt.data["special"].update(get_players(("detective",)))
 
 @event_listener("exchange_roles")
 def on_exchange(evt, cli, var, actor, nick, actor_role, nick_role):

src/roles/doomsayer.py

@@ -87,11 +87,11 @@ def on_exchange(evt, cli, var, actor, nick, actor_role, nick_role):
             mapping.pop(nick, None)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
-    SEEN.discard(nick)
+    SEEN.discard(user.nick)
     for name, dictvar in _mappings:
         for k, v in list(dictvar.items()):
-            if nick == k or nick == v:
+            if user.nick in (k, v):
                 del dictvar[k]
 
 @event_listener("doctor_immunize")
@@ -104,7 +104,7 @@ def on_doctor_immunize(evt, cli, var, doctor, target):
 
 @event_listener("get_special")
 def on_get_special(evt, var):
-    evt.data["special"].update(get_all_players(("doomsayer",)))
+    evt.data["special"].update(get_players(("doomsayer",)))
 
 @event_listener("chk_nightdone")
 def on_chk_nightdone(evt, cli, var):

src/roles/dullahan.py

@@ -59,16 +59,16 @@ def on_player_win(evt, var, user, role, winner, survived):
         evt.data["iwon"] = True
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     for h, v in list(KILLS.items()):
-        if v.nick == nick:
+        if v is user:
             h.send(messages["hunter_discard"])
             del KILLS[h]
-        elif h.nick == nick:
+        elif h is user:
             del KILLS[h]
     if death_triggers and "dullahan" in allroles:
         pl = evt.data["pl"]
-        targets = TARGETS[users._get(nick)].intersection(users._get(x) for x in pl) # FIXME
+        targets = TARGETS[user].intersection(users._get(x) for x in pl) # FIXME
         if targets:
             target = random.choice(list(targets))
             prots = deque(var.ACTIVE_PROTECTIONS[target.nick])
@@ -79,7 +79,7 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
                     refresh_pl=evt.params.refresh_pl,
                     message_prefix="dullahan_die_",
                     source="dullahan",
-                    killer=nick,
+                    killer=user.nick,
                     killer_mainrole=mainrole,
                     killer_allroles=allroles,
                     prots=prots)
@@ -87,7 +87,7 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
                 # an event can read the current active protection and cancel or redirect the assassination
                 # if it cancels, it is responsible for removing the protection from var.ACTIVE_PROTECTIONS
                 # so that it cannot be used again (if the protection is meant to be usable once-only)
-                if not aevt.dispatch(cli, var, nick, target.nick, prots[0]):
+                if not aevt.dispatch(user.client, var, user.nick, target.nick, prots[0]):
                     evt.data["pl"] = aevt.data["pl"]
                     if target is not aevt.data["target"]:
                         target = aevt.data["target"]
@@ -101,11 +101,11 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
             if var.ROLE_REVEAL in ("on", "team"):
                 role = get_reveal_role(target)
                 an = "n" if role.startswith(("a", "e", "i", "o", "u")) else ""
-                cli.msg(botconfig.CHANNEL, messages["dullahan_die_success"].format(nick, target, an, role))
+                channels.Main.send(messages["dullahan_die_success"].format(user, target, an, role))
             else:
-                cli.msg(botconfig.CHANNEL, messages["dullahan_die_success_noreveal"].format(nick, target))
+                channels.Main.send(messages["dullahan_die_success_noreveal"].format(user, target))
-            debuglog("{0} (dullahan) DULLAHAN ASSASSINATE: {1} ({2})".format(nick, target, get_role(target)))
+            debuglog("{0} (dullahan) DULLAHAN ASSASSINATE: {1} ({2})".format(user, target, get_role(target)))
-            evt.params.del_player(cli, target, True, end_game=False, killer_role="dullahan", deadlist=evt.params.deadlist, original=evt.params.original, ismain=False)
+            evt.params.del_player(user.client, target, True, end_game=False, killer_role="dullahan", deadlist=evt.params.deadlist, original=evt.params.original, ismain=False)
             evt.data["pl"] = evt.params.refresh_pl(pl)
 
 @event_listener("night_acted")
@@ -131,7 +131,7 @@ def on_swap(evt, var, old_user, user):
 
 @event_listener("get_special")
 def on_get_special(evt, var):
-    evt.data["special"].update(get_all_players(("dullahan",)))
+    evt.data["special"].update(get_players(("dullahan",)))
 
 @event_listener("transition_day", priority=2)
 def on_transition_day(evt, cli, var):

src/roles/harlot.py

@@ -138,14 +138,13 @@ def on_begin_day(evt, var):
 
 @event_listener("get_special")
 def on_get_special(evt, var):
-    evt.data["special"].update(get_all_players(("harlot",)))
+    evt.data["special"].update(get_players(("harlot",)))
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     if "harlot" not in allroles:
         return
-    if nick in VISITED:
+    VISITED.pop(user.nick, None)
-        del VISITED[nick]
 
 @event_listener("rename_player")
 def on_rename(evt, cli, var, prefix, nick):

src/roles/hunter.py

@@ -70,8 +70,7 @@ def hunter_pass(var, wrapper, message):
     chk_nightdone(wrapper.client)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
-    user = users._get(nick) # FIXME
     HUNTERS.discard(user)
     PASSED.discard(user)
     KILLS.pop(user, None)
@@ -102,7 +101,7 @@ def on_acted(evt, var, nick, sender):
 
 @event_listener("get_special")
 def on_get_special(evt, var):
-    evt.data["special"].update(get_all_players(("hunter",)))
+    evt.data["special"].update(get_players(("hunter",)))
 
 @event_listener("transition_day", priority=2)
 def on_transition_day(evt, cli, var):

src/roles/madscientist.py

@@ -48,12 +48,12 @@ def _get_targets(var, pl, nick):
 
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     if not death_triggers or "mad scientist" not in allroles:
         return
 
     pl = evt.data["pl"]
-    target1, target2 = _get_targets(var, pl, nick)
+    target1, target2 = _get_targets(var, pl, user.nick)
 
     # apply protections (if applicable)
     prots1 = deque(var.ACTIVE_PROTECTIONS[target1.nick])
@@ -68,13 +68,13 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
         refresh_pl=evt.params.refresh_pl,
         message_prefix="mad_scientist_fail_",
         source="mad scientist",
-        killer=nick,
+        killer=user.nick,
         killer_mainrole=mainrole,
         killer_allroles=allroles,
         prots=prots1)
     while len(prots1) > 0:
         # events may be able to cancel this kill
-        if not aevt.dispatch(cli, var, nick, target1.nick, prots1[0]):
+        if not aevt.dispatch(user.client, var, user.nick, target1.nick, prots1[0]):
             pl = aevt.data["pl"]
             if target1 is not aevt.data["target"]:
                 target1 = aevt.data["target"]
@@ -87,7 +87,7 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
     aevt.params.prots = prots2
     while len(prots2) > 0:
         # events may be able to cancel this kill
-        if not aevt.dispatch(cli, var, nick, target2.nick, prots2[0]):
+        if not aevt.dispatch(user.client, var, user.nick, target2.nick, prots2[0]):
             pl = aevt.data["pl"]
             if target2 is not aevt.data["target"]:
                 target2 = aevt.data["target"]
@@ -107,46 +107,46 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
                 an1 = "n" if r1.startswith(("a", "e", "i", "o", "u")) else ""
                 r2 = get_reveal_role(target2.nick)
                 an2 = "n" if r2.startswith(("a", "e", "i", "o", "u")) else ""
-                tmsg = messages["mad_scientist_kill"].format(nick, target1, an1, r1, target2, an2, r2)
+                tmsg = messages["mad_scientist_kill"].format(user, target1, an1, r1, target2, an2, r2)
             else:
-                tmsg = messages["mad_scientist_kill_no_reveal"].format(nick, target1, target2)
+                tmsg = messages["mad_scientist_kill_no_reveal"].format(user, target1, target2)
-            cli.msg(botconfig.CHANNEL, tmsg)
+            channels.Main.send(tmsg)
-            debuglog(nick, "(mad scientist) KILL: {0} ({1}) - {2} ({3})".format(target1, get_role(target1.nick), target2, get_role(target2.nick)))
+            debuglog(user.nick, "(mad scientist) KILL: {0} ({1}) - {2} ({3})".format(target1, get_role(target1.nick), target2, get_role(target2.nick)))
             # here we DO want to tell that the other one is dying already so chained deaths don't mess things up
             deadlist1 = evt.params.deadlist[:]
             deadlist1.append(target2.nick)
             deadlist2 = evt.params.deadlist[:]
             deadlist2.append(target1.nick)
-            evt.params.del_player(cli, target1.nick, True, end_game=False, killer_role="mad scientist", deadlist=deadlist1, original=evt.params.original, ismain=False)
+            evt.params.del_player(user.client, target1.nick, True, end_game=False, killer_role="mad scientist", deadlist=deadlist1, original=evt.params.original, ismain=False)
-            evt.params.del_player(cli, target2.nick, True, end_game=False, killer_role="mad scientist", deadlist=deadlist2, original=evt.params.original, ismain=False)
+            evt.params.del_player(user.client, target2.nick, True, end_game=False, killer_role="mad scientist", deadlist=deadlist2, original=evt.params.original, ismain=False)
             pl = evt.params.refresh_pl(pl)
         else:
             if var.ROLE_REVEAL in ("on", "team"):
                 r1 = get_reveal_role(target1.nick)
                 an1 = "n" if r1.startswith(("a", "e", "i", "o", "u")) else ""
-                tmsg = messages["mad_scientist_kill_single"].format(nick, target1, an1, r1)
+                tmsg = messages["mad_scientist_kill_single"].format(user, target1, an1, r1)
             else:
-                tmsg = messages["mad_scientist_kill_single_no_reveal"].format(nick, target1)
+                tmsg = messages["mad_scientist_kill_single_no_reveal"].format(user, target1)
-            cli.msg(botconfig.CHANNEL, tmsg)
+            channels.Main.send(tmsg)
-            debuglog(nick, "(mad scientist) KILL: {0} ({1})".format(target1, get_role(target1.nick)))
+            debuglog(user.nick, "(mad scientist) KILL: {0} ({1})".format(target1, get_role(target1.nick)))
-            evt.params.del_player(cli, target1.nick, True, end_game=False, killer_role="mad scientist", deadlist=evt.params.deadlist, original=evt.params.original, ismain=False)
+            evt.params.del_player(user.client, target1.nick, True, end_game=False, killer_role="mad scientist", deadlist=evt.params.deadlist, original=evt.params.original, ismain=False)
             pl = evt.params.refresh_pl(pl)
     else:
         if kill2:
             if var.ROLE_REVEAL in ("on", "team"):
                 r2 = get_reveal_role(target2.nick)
                 an2 = "n" if r2.startswith(("a", "e", "i", "o", "u")) else ""
-                tmsg = messages["mad_scientist_kill_single"].format(nick, target2, an2, r2)
+                tmsg = messages["mad_scientist_kill_single"].format(user, target2, an2, r2)
             else:
-                tmsg = messages["mad_scientist_kill_single_no_reveal"].format(nick, target2)
+                tmsg = messages["mad_scientist_kill_single_no_reveal"].format(user, target2)
-            cli.msg(botconfig.CHANNEL, tmsg)
+            channels.Main.send(tmsg)
-            debuglog(nick, "(mad scientist) KILL: {0} ({1})".format(target2, get_role(target2.nick)))
+            debuglog(user.nick, "(mad scientist) KILL: {0} ({1})".format(target2, get_role(target2.nick)))
-            evt.params.del_player(cli, target2.nick, True, end_game=False, killer_role="mad scientist", deadlist=evt.params.deadlist, original=evt.params.original, ismain=False)
+            evt.params.del_player(user.client, target2.nick, True, end_game=False, killer_role="mad scientist", deadlist=evt.params.deadlist, original=evt.params.original, ismain=False)
             pl = evt.params.refresh_pl(pl)
         else:
-            tmsg = messages["mad_scientist_fail"].format(nick)
+            tmsg = messages["mad_scientist_fail"].format(user)
-            cli.msg(botconfig.CHANNEL, tmsg)
+            channels.Main.send(tmsg)
-            debuglog(nick, "(mad scientist) KILL FAIL")
+            debuglog(user.nick, "(mad scientist) KILL FAIL")
 
     evt.data["pl"] = pl
 

src/roles/mystic.py

@@ -67,6 +67,6 @@ def on_transition_night_end(evt, var):
 @event_listener("get_special")
 def on_get_special(evt, var):
     # mystics count as special even though they don't have any commands
-    evt.data["special"].update(get_all_players(("mystic",)))
+    evt.data["special"].update(get_players(("mystic",)))
 
 # vim: set sw=4 expandtab:

src/roles/seer.py

@@ -82,8 +82,8 @@ def on_rename(evt, cli, var, prefix, nick):
         SEEN.add(nick)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
-    SEEN.discard(nick)
+    SEEN.discard(user.nick)
 
 @event_listener("night_acted")
 def on_acted(evt, var, nick, sender):

src/roles/shaman.py

@@ -136,9 +136,9 @@ def on_see(evt, cli, var, nick, victim):
             evt.data["role"] = "wolf"
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     for a,(b,c) in list(SHAMANS.items()):
-        if nick in (a, b, c):
+        if user.nick in (a, b, c):
             del SHAMANS[a]
 
 @event_listener("night_acted")

src/roles/succubus.py

@@ -164,18 +164,18 @@ def on_can_exchange(evt, var, actor, nick):
         evt.stop_processing = True
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     global ALL_SUCC_IDLE
     if "succubus" not in allroles:
         return
-    if nick in VISITED:
+    if user.nick in VISITED:
         # if it's night, also unentrance the person they visited
         if var.PHASE == "night" and var.GAMEPHASE == "night":
-            if VISITED[nick] in ENTRANCED:
+            if VISITED[user.nick] in ENTRANCED:
-                ENTRANCED.discard(visited[nick])
+                ENTRANCED.discard(VISITED[user.nick])
-                ENTRANCED_DYING.discard(visited[nick])
+                ENTRANCED_DYING.discard(VISITED[user.nick])
-                pm(cli, VISITED[nick], messages["entranced_revert_win"])
+                pm(user.client, VISITED[user.nick], messages["entranced_revert_win"])
-        del VISITED[nick]
+        del VISITED[user.nick]
 
     # if all succubi are dead, one of two things happen:
     # 1. if all succubi idled out (every last one of them), un-entrance people
@@ -188,7 +188,7 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
         if ALL_SUCC_IDLE:
             while ENTRANCED:
                 e = ENTRANCED.pop()
-                pm(cli, e, messages["entranced_revert_win"])
+                pm(user.client, e, messages["entranced_revert_win"])
         elif entranced_alive:
             msg = []
             # Run in two loops so we can play the message for everyone dying at once before we actually
@@ -204,18 +204,18 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
                 else:
                     msg.append("\u0002{0}\u0002".format(e))
             if len(msg) == 1:
-                cli.msg(botconfig.CHANNEL, messages["succubus_die_kill"].format(msg[0] + comma))
+                channels.Main.send(messages["succubus_die_kill"].format(msg[0] + comma))
             elif len(msg) == 2:
-                cli.msg(botconfig.CHANNEL, messages["succubus_die_kill"].format(msg[0] + comma + " and " + msg[1] + comma))
+                channels.Main.send(messages["succubus_die_kill"].format(msg[0] + comma + " and " + msg[1] + comma))
             else:
-                cli.msg(botconfig.CHANNEL, messages["succubus_die_kill"].format(", ".join(msg[:-1]) + ", and " + msg[-1] + comma))
+                channels.Main.send(messages["succubus_die_kill"].format(", ".join(msg[:-1]) + ", and " + msg[-1] + comma))
             for e in entranced_alive:
                 # to ensure we do not double-kill someone, notify all child deaths that we'll be
                 # killing off everyone else that is entranced so they don't need to bother
                 dlc = list(evt.params.deadlist)
                 dlc.extend(entranced_alive - {e})
-                debuglog("{0} (succubus) SUCCUBUS DEATH KILL: {1} ({2})".format(nick, e, get_role(e)))
+                debuglog("{0} (succubus) SUCCUBUS DEATH KILL: {1} ({2})".format(user, e, get_role(e)))
-                evt.params.del_player(cli, e, end_game=False, killer_role="succubus",
+                evt.params.del_player(user.client, e, end_game=False, killer_role="succubus",
                     deadlist=dlc, original=evt.params.original, ismain=False)
                 evt.data["pl"] = evt.params.refresh_pl(evt.data["pl"])
         ENTRANCED_DYING.clear()
@@ -299,7 +299,7 @@ def on_transition_day(evt, cli, var):
 
 @event_listener("get_special")
 def on_get_special(evt, var):
-    evt.data["special"].update(get_all_players(("succubus",)))
+    evt.data["special"].update(get_players(("succubus",)))
 
 @event_listener("vg_kill")
 def on_vg_kill(evt, var, ghost, target):

src/roles/vengefulghost.py

@@ -89,22 +89,21 @@ def on_player_win(evt, var, user, role, winner, survived):
             evt.data["iwon"] = False
 
 @event_listener("del_player", priority=6)
-def on_del_player(evt, cli, var, nick, nickrole, nicktpls, death_triggers):
+def on_del_player(evt, var, user, nickrole, nicktpls, death_triggers):
     for h,v in list(KILLS.items()):
-        if v == nick:
+        if v == user.nick:
-            pm(cli, h, messages["hunter_discard"])
+            pm(user.client, h, messages["hunter_discard"])
             del KILLS[h]
     # extending VG to work with new teams can be done by registering a listener
     # at priority < 6, importing src.roles.vengefulghost, and setting
     # GHOSTS[user] to something; if that is done then this logic is not run.
-    user = users._get(nick) # FIXME
     if death_triggers and nickrole == "vengeful ghost" and user not in GHOSTS:
         if evt.params.killer_role in var.WOLFTEAM_ROLES:
             GHOSTS[user] = "wolves"
         else:
             GHOSTS[user] = "villagers"
         user.send(messages["vengeful_turn"].format(GHOSTS[user]))
-        debuglog(nick, "(vengeful ghost) TRIGGER", GHOSTS[user])
+        debuglog(user.nick, "(vengeful ghost) TRIGGER", GHOSTS[user])
 
 @event_listener("rename_player")
 def on_rename(evt, cli, var, prefix, nick):

src/roles/vigilante.py

@@ -62,13 +62,13 @@ def vigilante_pass(cli, nick, chan, rest):
     chk_nightdone(cli)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
-    PASSED.discard(nick)
+    PASSED.discard(user.nick)
-    if nick in KILLS:
+    if user.nick in KILLS:
-        del KILLS[nick]
+        del KILLS[user.nick]
     for h,v in list(KILLS.items()):
-        if v == nick:
+        if v == user.nick:
-            pm(cli, h, messages["hunter_discard"])
+            pm(user.client, h, messages["hunter_discard"])
             del KILLS[h]
 
 @event_listener("rename_player")
@@ -94,7 +94,7 @@ def on_acted(evt, var, nick, sender):
 
 @event_listener("get_special")
 def on_get_special(evt, var):
-    evt.data["special"].update(get_all_players(("vigilante",)))
+    evt.data["special"].update(get_players(("vigilante",)))
 
 @event_listener("transition_day", priority=2)
 def on_transition_day(evt, cli, var):

src/roles/wildchild.py

@@ -4,7 +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, get_all_players
+from src.functions import get_players, get_all_players, get_main_role
 from src.decorators import cmd, event_listener
 from src.messages import messages
 from src.events import Event
@@ -82,19 +82,19 @@ def on_myrole(evt, cli, var, nick):
         evt.data["messages"].append(messages["wild_child_idol"].format(IDOLS[nick]))
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     if var.PHASE not in var.GAME_PHASES:
         return
 
-    for child in var.ROLES["wild child"].copy():
+    for child in get_all_players(("wild child",)):
-        if child not in IDOLS or child in evt.params.deadlist or IDOLS[child] not in evt.params.deadlist:
+        if child.nick not in IDOLS or child.nick in evt.params.deadlist or IDOLS[child.nick] not in evt.params.deadlist:
             continue
 
         # change their main role to wolf, even if wild child was a template
-        pm(cli, child, messages["idol_died"])
+        child.send(messages["idol_died"])
-        WILD_CHILDREN.add(child)
+        WILD_CHILDREN.add(child.nick)
-        change_role(users._get(child), get_role(child), "wolf") # FIXME
+        change_role(child, get_main_role(child), "wolf")
-        var.ROLES["wild child"].discard(child)
+        var.ROLES["wild child"].discard(child.nick)
 
         wcroles = var.WOLFCHAT_ROLES
         if var.RESTRICT_WOLFCHAT & var.RW_REM_NON_WOLVES:
@@ -102,22 +102,26 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
                 wcroles = var.WOLF_ROLES
             else:
                 wcroles = var.WOLF_ROLES | {"traitor"}
-        wolves = list_players(wcroles)
+        wolves = get_players(wcroles)
         wolves.remove(child)
-        mass_privmsg(cli, wolves, messages["wild_child_as_wolf"].format(child))
+        if wolves:
+            for wolf in wolves:
+                wolf.queue_message(messages["wild_child_as_wolf"].format(child))
+            wolf.send_messages()
         if var.PHASE == "day":
             random.shuffle(wolves)
+            new = []
             for i, wolf in enumerate(wolves):
-                wolfroles = get_role(wolf)
+                wolfroles = get_main_role(wolf)
                 cursed = ""
-                if wolf in var.ROLES["cursed villager"]:
+                if wolf in get_all_players(("cursed villager",)):
                     cursed = "cursed "
-                wolves[i] = "\u0002{0}\u0002 ({1}{2})".format(wolf, cursed, wolfroles)
+                new.append("\u0002{0}\u0002 ({1}{2})".format(wolf, cursed, wolfroles))
 
-            if wolves:
+            if new:
-                pm(cli, child, "Wolves: " + ", ".join(wolves))
+                child.send("Wolves: " + ", ".join(new))
             else:
-                pm(cli, child, messages["no_other_wolves"])
+                child.send(messages["no_other_wolves"])
 
 @event_listener("chk_nightdone")
 def on_chk_nightdone(evt, cli, var):

src/roles/wolf.py

@@ -109,7 +109,7 @@ def wolf_retract(cli, nick, chan, rest):
         relay_wolfchat_command(cli, nick, messages["wolfchat_no_bite"].format(nick), ("alpha wolf",), is_wolf_command=True)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     if death_triggers:
         # TODO: split into alpha
         if allroles & var.WOLF_ROLES:
@@ -117,9 +117,9 @@ def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
 
     for a,b in list(KILLS.items()):
         for n in b:
-            if n == nick:
+            if n == user.nick:
-                KILLS[a].remove(nick)
+                KILLS[a].remove(user.nick)
-        if a == nick or len(KILLS[a]) == 0:
+        if a == user.nick or len(KILLS[a]) == 0:
             del KILLS[a]
 
 @event_listener("rename_player")

src/roles/wolfcub.py

@@ -20,7 +20,7 @@ def on_wolf_numkills(evt, var):
         evt.data["numkills"] = max(evt.data["numkills"], 2)
 
 @event_listener("del_player")
-def on_del_player(evt, cli, var, nick, mainrole, allroles, death_triggers):
+def on_del_player(evt, var, user, mainrole, allroles, death_triggers):
     if death_triggers and "wolf cub" in allroles:
         global ANGRY_WOLVES
         ANGRY_WOLVES = True

src/wolfgame.py

@@ -2584,11 +2584,12 @@ def del_player(cli, nick, forced_death=False, devoice=True, end_game=True, death
             pl = refresh_pl(pl)
             # i herd u liek parameters
             evt_death_triggers = death_triggers and var.PHASE in var.GAME_PHASES
+            user = users._get(nick) # FIXME
             event = Event("del_player", {"pl": pl},
                     forced_death=forced_death, end_game=end_game,
                     deadlist=deadlist, original=original, killer_role=killer_role,
                     ismain=ismain, refresh_pl=refresh_pl, del_player=del_player)
-            event.dispatch(cli, var, nick, nickrole, allroles, evt_death_triggers)
+            event.dispatch(var, user, nickrole, allroles, evt_death_triggers)
 
             # update var.ROLE_STATS
             # Event priorities: