notnull/banned
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Convert the transition_night_end event

Browse Source
This commit is contained in:
Vgr E. Barry 2017-08-30 10:16:02 -04:00
parent 2f0d4f8b1c
commit 0f1d513daa
18 changed files with 187 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/roles/angel.py
View File

@ -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()
for bg in var.ROLES["bodyguard"]:
ps = get_players()
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):
pm(cli, bg, messages["bodyguard_notify"].format(warning))
else:
pm(cli, bg, messages["bodyguard_simple"]) # !simple
pm(cli, bg, "Players: " + ", ".join(pl))
to_send = "bodyguard_notify"
if bg.prefers_simple():
to_send = "bodyguard_simple"
bg.send(messages[to_send].format(warning), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
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:
pl.remove(LASTGUARDED[gangel])
if gangel.nick in LASTGUARDED:
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):
pm(cli, gangel, messages["guardian_notify"].format(warning, gself))
else:
pm(cli, gangel, messages["guardian_simple"]) # !simple
pm(cli, gangel, "Players: " + ", ".join(pl))
to_send = "guardian_notify"
if gangel.prefers_simple():
to_send = "guardian_simple"
gangel.send(messages[to_send].format(warning, gself), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
@event_listener("assassinate")
def on_assassinate(evt, cli, var, nick, target, prot):

16
src/roles/blessed.py
View File

@ -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"]:
if blessed in var.PLAYERS and not is_user_simple(blessed):
pm(cli, blessed, messages["blessed_notify"])
else:
pm(cli, blessed, messages["blessed_simple"])
for blessed in var.ROLES["blessed villager"]: # FIXME
user = users._get(blessed) # FIXME
to_send = "blessed_notify"
if user.prefers_simple():
to_send = "blessed_simple"
user.send(messages[to_send])
@event_listener("desperation_totem")
def on_desperation(evt, cli, var, votee, target, prot):

16
src/roles/detective.py
View File

@ -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):
ps = list_players()
for dttv in var.ROLES["detective"]:
def on_transition_night_end(evt, var):
ps = get_players()
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):
pm(cli, dttv, messages["detective_notify"].format(warning))
else:
pm(cli, dttv, messages["detective_simple"]) # !simple
pm(cli, dttv, "Players: " + ", ".join(pl))
to_send = "detective_notify"
if dttv.prefers_simple():
to_send = "detective_simple"
dttv.send(messages[to_send].format(warning), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
@event_listener("transition_night_begin")
def on_transition_night_begin(evt, cli, var):

18
src/roles/dullahan.py
View File

@ -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):
for dullahan in var.ROLES["dullahan"]:
duser = users._get(dullahan) # FIXME
targets = list(TARGETS[duser])
def on_transition_night_end(evt, var):
for dullahan in get_players(("dullahan",)):
targets = list(TARGETS[dullahan])
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():
duser.send(messages["dullahan_simple"])
else:
duser.send(messages["dullahan_notify"])
to_send = "dullahan_notify"
if dullahan.prefers_simple():
to_send = "dullahan_simple"
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):

15
src/roles/harlot.py
View File

@ -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):
for harlot in var.ROLES["harlot"]:
pl = list_players()
def on_transition_night_end(evt, var):
for harlot in get_players(("harlot",)):
pl = get_players()
random.shuffle(pl)
pl.remove(harlot)
if harlot in var.PLAYERS and not is_user_simple(harlot):
pm(cli, harlot, messages["harlot_info"])
else:
pm(cli, harlot, messages["harlot_simple"])
pm(cli, harlot, "Players: " + ", ".join(pl))
to_send = "harlot_info"
if harlot.prefers_simple():
to_send = "harlot_simple"
harlot.send(messages[to_send], "Players: " + ", ".join(p.nick for p in pl), sep="\n")
@event_listener("begin_day")
def on_begin_day(evt, var):

13
src/roles/hunter.py
View File

@ -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"]:
user = users._get(hunter) # FIXME
if user in HUNTERS:
for hunter in get_players(("hunter",)):
if hunter 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):

15
src/roles/madscientist.py
View File

@ -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):
for ms in var.ROLES["mad scientist"]:
def on_transition_night_end(evt, var):
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):
pm(cli, ms, messages["mad_scientist_notify"].format(target1, target2))
else:
pm(cli, ms, messages["mad_scientist_simple"].format(target1, target2))
to_send = "mad_scientist_notify"
if ms.prefers_simple():
to_send = "mad_scientist_simple"
ms.send(messages[to_send].format(target1, target2))
@event_listener("myrole")
def on_myrole(evt, cli, var, nick):

17
src/roles/mystic.py
View File

@ -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 ""))
for mystic in var.ROLES["mystic"]:
if mystic in var.PLAYERS and not is_user_simple(mystic):
pm(cli, mystic, messages["mystic_notify"])
else:
pm(cli, mystic, messages["mystic_simple"])
wolf.send(messages["wolf_mystic_info"].format("are" if numvills != 1 else "is", numvills, "s" if numvills != 1 else ""))
for mystic in get_players(("mystic",)):
to_send = "mystic_notify"
if mystic.prefers_simple():
to_send = "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):

20
src/roles/seer.py
View File

@ -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):
for seer in list_players(("seer", "oracle", "augur")):
pl = list_players()
def on_transition_night_end(evt, var):
for seer in get_players(("seer", "oracle", "augur")):
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):
pm(cli, seer, messages["seer_role_info"].format(a, role, what))
else:
pm(cli, seer, messages["seer_simple"].format(a, role)) # !simple
pm(cli, seer, "Players: " + ", ".join(pl))
to_send = "seer_role_info"
if seer.prefers_simple():
to_send = "seer_simple"
seer.send(messages[to_send].format(a, role, what), "Players: " + ", ".join(p.nick for p in pl), sep="\n")
@event_listener("begin_day")
def on_begin_day(evt, var):

40
src/roles/shaman.py
View File

@ -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()
shamans = list_players(var.TOTEM_ORDER)
ps = get_players()
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:
pl.remove(LASTGIVEN[shaman])
role = get_role(shaman) # FIXME: don't use get_role here once split into one file per role
if shaman.nick in LASTGIVEN:
user = users._get(LASTGIVEN[shaman.nick]) # FIXME
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)
else:
if role not in var.WOLFCHAT_ROLES:
pm(cli, shaman, messages["shaman_simple"].format(role))
if role != "crazed shaman":
pm(cli, shaman, messages["totem_simple"].format(TOTEMS[shaman]))
shaman.send(tmsg)
if role not in var.WOLFCHAT_ROLES:
pm(cli, shaman, "Players: " + ", ".join(pl))
shaman.send("Players: " + ", ".join(p.nick for p in pl))
@event_listener("begin_day")
def on_begin_day(evt, var):

22
src/roles/succubus.py
View File

@ -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):
for succubus in var.ROLES["succubus"]:
pl = list_players()
def on_transition_night_end(evt, var):
succubi = get_players(("succubus",))
for succubus in succubi:
pl = get_players()
random.shuffle(pl)
pl.remove(succubus)
if succubus in var.PLAYERS and not is_user_simple(succubus):
pm(cli, succubus, messages["succubus_notify"])
else:
pm(cli, succubus, messages["succubus_simple"])
pm(cli, succubus, "Players: " + ", ".join(("{0} ({1})".format(x, get_role(x)) if x in var.ROLES["succubus"] else x for x in pl)))
to_send = "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:
succ.append(p.nick)
succubus.send(messages[to_send], "Players: " + ", ".join(succ), sep="\n")
@event_listener("begin_day")
def on_begin_day(evt, var):

18
src/roles/vengefulghost.py
View File

@ -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()
wolves = list_players(var.WOLFTEAM_ROLES)
ps = get_players()
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():
v_ghost.send(messages["vengeful_ghost_notify"].format(who))
else:
v_ghost.send(messages["vengeful_ghost_simple"])
v_ghost.send(who.capitalize() + ": " + ", ".join(pl))
debuglog("GHOST: {0} (target: {1}) - players: {2}".format(v_ghost.nick, who, ", ".join(pl)))
to_send = "vengeful_ghost_notify"
if v_ghost.prefers_simple():
to_send = "vengeful_ghost_simple"
v_ghost.send(messages[to_send].format(who), who.capitalize() + ": " + ", ".join(pl), sep="\n")
debuglog("GHOST: {0} (target: {1}) - players: {2}".format(v_ghost, who, ", ".join(p.nick for p in pl)))
@event_listener("myrole")
def on_myrole(evt, cli, var, nick):

15
src/roles/vigilante.py
View File

@ -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):
ps = list_players()
for vigilante in var.ROLES["vigilante"]:
def on_transition_night_end(evt, var):
ps = get_players()
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):
pm(cli, vigilante, messages["vigilante_notify"])
else:
pm(cli, vigilante, messages["vigilante_simple"])
pm(cli, vigilante, "Players: " + ", ".join(pl))
to_send = "vigilante_notify"
if vigilante.prefers_simple():
to_send = "vigilante_simple"
vigilante.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):

31
src/roles/villager.py
View File

@ -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)
for villager in villagers:
if villager in var.PLAYERS and not is_user_simple(villager):
pm(cli, villager, messages["villager_notify"])
else:
pm(cli, villager, messages["villager_simple"])
villagers = get_players(villroles)
if villagers:
for villager in villagers:
to_send = "villager_notify"
if villager.prefers_simple():
to_send = "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)
for cultist in cultists:
if cultist in var.PLAYERS and not is_user_simple(cultist):
pm(cli, cultist, messages["cultist_notify"])
else:
pm(cli, cultist, messages["cultist_simple"])
cultists = get_players(cultroles)
if cultists:
for cultist in cultists:
to_send = "cultist_notify"
if cultist.prefers_simple():
to_send = "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

13
src/roles/wildchild.py
View File

@ -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):
for child in var.ROLES["wild child"]:
if child in var.PLAYERS and not is_user_simple(child):
pm(cli, child, messages["child_notify"])
else:
pm(cli, child, messages["child_simple"])
def on_transition_night_end(evt, var):
for child in get_players(("wild child",)):
to_send = "child_notify"
if child.prefers_simple():
to_send = "child_simple"
child.send(messages[to_send])
@event_listener("revealroles_role")
def on_revealroles_role(evt, var, wrapper, nick, role):

55
src/roles/wolf.py
View File

@ -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.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)
wolfroles = get_all_roles(wolf)
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):
ps = list_players()
wolves = list_players(var.WOLFCHAT_ROLES)
def on_transition_night_end(evt, var):
ps = get_players()
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)
role = get_role(wolf)
normal_notify = not wolf.prefers_simple()
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):
prole = get_role(player)
for player in pl:
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):
if player in var.ROLES["cursed villager"]:
pl[i] = player + " (cursed)"
for player in pl:
if player.nick in var.ROLES["cursed villager"]: # FIXME: Once var.ROLES holds User instances
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:
pm(cli, wolf, messages["wolf_bite"])
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
wolf.send(messages["wolf_bite"])
@event_listener("succubus_visit")
def on_succubus_visit(evt, cli, var, nick, victim):

8
src/roles/wolfcub.py
View File

@ -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):

2
src/wolfgame.py
View File

@ -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"])