ryg/royal-mifia
ryg/royal-mifia
1
Fork 0
mirror of https://github.com/RYGhub/royal-mifia.git synced 2024-11-25 07:04:18 +00:00
Code Activity

Convertito l'argomento bot in un parametro della classe Game

Browse source
This commit is contained in:
Steffo 2017-07-19 01:28:49 +02:00
parent 86e0512b7b
commit f01edb5085
13 changed files with 185 additions and 203 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

248
main.py
View file

@ -11,6 +11,7 @@ import filemanager
import random import random
import strings as s import strings as s
import logging import logging
from typing import List, Union, Dict
from roles.roles import * from roles.roles import *
logging.basicConfig(level=logging.WARNING, logging.basicConfig(level=logging.WARNING,
@ -43,31 +44,32 @@ class Player:
def __str__(self) -> str: def __str__(self) -> str:
return "@{}".format(self.tusername) return "@{}".format(self.tusername)
def message(self, bot: Bot, text: str): def message(self, text: str):
"""Manda un messaggio privato al giocatore.""" """Manda un messaggio privato al giocatore."""
if not self.dummy: if not self.dummy:
bot.sendMessage(self.tid, text, parse_mode=ParseMode.MARKDOWN) self.game.bot.sendMessage(self.tid, text, parse_mode=ParseMode.MARKDOWN)
def kill(self, bot: Bot): def kill(self):
"""Uccidi il giocatore.""" """Uccidi il giocatore."""
self.role.ondeath(bot) self.role.ondeath()
self.alive = False self.alive = False
class Game: class Game:
"""Classe di una partita, contenente parametri riguardanti stato della partita """Classe di una partita, contenente parametri riguardanti stato della partita
e informazioni sul gruppo di Telegram.""" e informazioni sul gruppo di Telegram."""
def __init__(self, groupid: int): def __init__(self, bot: Bot, groupid: int):
self.groupid = groupid # ID del gruppo in cui si sta svolgendo una partita self.groupid = groupid # type: int
self.admin = None # ID telegram dell'utente che ha creato la partita con /newgame self.bot = bot # type: Bot
self.players = list() # Lista dei giocatori in partita self.admin = None # type: Player
self.tokill = list() # Giocatori che verranno uccisi all'endday self.players = list() # type: List['Player']
self.phase = 'Join' # Fase di gioco: 'Join', 'Preset', 'Config', 'Voting' self.tokill = list() # type: List['Player']
self.day = 0 # Numero del giorno. 0 se la partita deve ancora iniziare self.phase = 'Join' # type: str
self.day = 0 # type: int
self.configstep = 0 # Passo attuale di configurazione self.configstep = 0 # type: int
self.roleconfig = dict() # Dizionario con le quantità di ruoli da aggiungere self.roleconfig = dict() # type: Dict[int]
self.votingmifia = False # Seguire le regole originali della mifia che vota? self.votingmifia = False # type: bool
# Liste di ruoli in gioco, per velocizzare gli endday # Liste di ruoli in gioco, per velocizzare gli endday
self.playersinrole = dict() self.playersinrole = dict()
@ -97,29 +99,29 @@ class Game:
.format(name=self.name, groupid=self.groupid, nplayers=len(self.players), phase=self.phase) .format(name=self.name, groupid=self.groupid, nplayers=len(self.players), phase=self.phase)
return r return r
def message(self, bot: Bot, text: str): def message(self, text: str):
"""Manda un messaggio nel gruppo.""" """Manda un messaggio nel gruppo."""
bot.sendMessage(self.groupid, text, parse_mode=ParseMode.MARKDOWN) self.bot.sendMessage(self.groupid, text, parse_mode=ParseMode.MARKDOWN)
def adminmessage(self, bot: Bot, text: str): def adminmessage(self, text: str):
"""Manda un messaggio privato al creatore della partita.""" """Manda un messaggio privato al creatore della partita."""
self.admin.message(bot, text) self.admin.message(text)
def mifiamessage(self, bot: Bot, text: str): def mifiamessage(self, text: str):
"""Manda un messaggio privato a tutti i Mifiosi nella partita.""" """Manda un messaggio privato a tutti i Mifiosi nella partita."""
# Trova tutti i mifiosi nell'elenco dei giocatori # Trova tutti i mifiosi nell'elenco dei giocatori
for player in self.players: for player in self.players:
if isinstance(player.role, Mifioso) or isinstance(player.role, Corrotto): if isinstance(player.role, Mifioso) or isinstance(player.role, Corrotto):
player.message(bot, text) player.message(text)
def findplayerbyid(self, tid: int): def findplayerbyid(self, tid: int) -> Union['Player', None]:
"""Trova il giocatore con un certo id.""" """Trova il giocatore con un certo id."""
for player in self.players: for player in self.players:
if player.tid == tid: if player.tid == tid:
return player return player
return None return None
def findplayerbyusername(self, tusername: str): def findplayerbyusername(self, tusername: str) -> Union['Player', None]:
"""Trova il giocatore con un certo username.""" """Trova il giocatore con un certo username."""
for player in self.players: for player in self.players:
if player.tusername.lower() == tusername.strip("@").lower(): if player.tusername.lower() == tusername.strip("@").lower():
@ -136,8 +138,8 @@ class Game:
# except Unauthorized: # except Unauthorized:
# print("Bot is not administrator in group {}".format(self.groupid)) # print("Bot is not administrator in group {}".format(self.groupid))
def assignroles(self, bot: Bot): def assignroles(self):
"""Assegna i ruoli specificati ib playersinrole a tutti i giocatori.""" """Assegna i ruoli specificati in playersinrole a tutti i giocatori."""
random.seed() random.seed()
playersleft = self.players.copy() playersleft = self.players.copy()
# Assegna i ruoli secondo i numeri all'interno di playersinrole # Assegna i ruoli secondo i numeri all'interno di playersinrole
@ -151,16 +153,16 @@ class Game:
player.role = Royal(self) player.role = Royal(self)
# Manda i ruoli assegnati a tutti # Manda i ruoli assegnati a tutti
for player in self.players: for player in self.players:
player.message(bot, s.role_assigned.format(icon=player.role.icon, name=player.role.name)) player.message(s.role_assigned.format(icon=player.role.icon, name=player.role.name))
if player.role.powerdesc is not None: if player.role.powerdesc is not None:
player.message(bot, player.role.powerdesc.format(gamename=self.name)) player.message(player.role.powerdesc.format(gamename=self.name))
# Manda ai mifiosi l'elenco dei loro compagni di squadra # Manda ai mifiosi l'elenco dei loro compagni di squadra
text = s.mifia_team_intro text = s.mifia_team_intro
for player in self.playersinrole['Mifioso']: for player in self.playersinrole['Mifioso']:
text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername) text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername)
for player in self.playersinrole['Corrotto']: for player in self.playersinrole['Corrotto']:
text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername) text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername)
self.mifiamessage(bot, text) self.mifiamessage(text)
def updatevotes(self): def updatevotes(self):
"""Aggiorna il conteggio dei voti di tutti i giocatori.""" """Aggiorna il conteggio dei voti di tutti i giocatori."""
@ -179,8 +181,8 @@ class Game:
if player.role.target is not None: if player.role.target is not None:
player.role.target.mifiavotes += 1 player.role.target.mifiavotes += 1
def mostvotedplayer(self) -> list: def mostvotedplayers(self) -> List[Player]:
"""Trova il giocatore più votato.""" """Trova i giocatori più votati."""
mostvoted = list() mostvoted = list()
currenttop = 0 currenttop = 0
self.updatevotes() self.updatevotes()
@ -196,8 +198,8 @@ class Game:
else: else:
return list() return list()
def mostvotedmifia(self) -> list: def mostvotedmifia(self) -> List[Player]:
"""Trova il giocatore più votato dalla mifia.""" """Trova i giocatori più votati dalla mifia."""
mostvoted = list() mostvoted = list()
currenttop = 0 currenttop = 0
self.updatemifiavotes() self.updatemifiavotes()
@ -213,25 +215,23 @@ class Game:
else: else:
return list() return list()
def endday(self, bot: Bot): def endday(self):
"""Finisci la giornata, uccidi il più votato del giorno ed esegui gli endday di tutti i giocatori.""" """Finisci la giornata, uccidi il più votato del giorno ed esegui gli endday di tutti i giocatori."""
# SALVA LA PARTITA, così se crasha si riprende da qui # SALVA LA PARTITA, così se crasha si riprende da qui
self.save(bot) self.save()
# Conta i voti ed elimina il più votato. # Conta i voti ed elimina il più votato.
topvotes = self.mostvotedplayer() topvotes = self.mostvotedplayers()
if len(topvotes) > 0: if len(topvotes) > 0:
# In caso di pareggio, elimina un giocatore casuale. # In caso di pareggio, elimina un giocatore casuale.
random.seed() random.seed()
random.shuffle(topvotes) random.shuffle(topvotes)
lynched = topvotes.pop() lynched = topvotes.pop()
if lynched.alive: if lynched.alive:
self.message(bot, s.player_lynched.format(name=lynched.tusername, self.message(s.player_lynched.format(name=lynched.tusername, icon=lynched.role.icon, role=lynched.role.name))
icon=lynched.role.icon,
role=lynched.role.name))
self.lastlynch = lynched self.lastlynch = lynched
lynched.kill(bot, self) lynched.kill()
elif self.day > 1: elif self.day > 1:
self.message(bot, s.no_players_lynched) self.message(s.no_players_lynched)
# Fai gli endday in un certo ordine. # Fai gli endday in un certo ordine.
# Si potrebbe fare più velocemente, credo. # Si potrebbe fare più velocemente, credo.
# Ma non sto ho voglia di ottimizzare ora. # Ma non sto ho voglia di ottimizzare ora.
@ -246,30 +246,26 @@ class Game:
killed = killlist.pop() killed = killlist.pop()
if killed.alive: if killed.alive:
if killed.protectedby is None: if killed.protectedby is None:
killed.kill(bot, self) killed.kill()
self.message(bot, s.mifia_target_killed.format(target=killed.tusername, self.message(s.mifia_target_killed.format(target=killed.tusername, icon=killed.role.icon, role=killed.role.name))
icon=killed.role.icon,
role=killed.role.name))
else: else:
self.message(bot, s.mifia_target_protected.format(target=killed.tusername, self.message(s.mifia_target_protected.format(target=killed.tusername, icon=killed.protectedby.role.icon, protectedby=killed.protectedby.tusername))
icon=killed.protectedby.role.icon,
protectedby=killed.protectedby.tusername))
# Attiva gli \ # Attiva gli \
for currentrole in rolepriority: for currentrole in rolepriority:
for player in self.playersinrole[currentrole.__name__]: for player in self.playersinrole[currentrole.__name__]:
if player.alive: if player.alive:
player.role.onendday(bot) player.role.onendday()
# Cancella tutti i voti # Cancella tutti i voti
for player in self.players: for player in self.players:
player.votingfor = None player.votingfor = None
# Incrementa il giorno # Incrementa il giorno
self.day += 1 self.day += 1
# Notifica dell'inizi # Notifica dell'inizi
self.message(bot, s.new_day.format(day=self.day)) self.message(s.new_day.format(day=self.day))
# Controlla se qualcuno ha vinto # Controlla se qualcuno ha vinto
self.victoryconditions(bot) self.victoryconditions()
def startpreset(self, bot: Bot): def startpreset(self):
"""Inizio della fase di preset""" """Inizio della fase di preset"""
self.phase = 'Preset' self.phase = 'Preset'
# Aggiorna il nome del gruppo # Aggiorna il nome del gruppo
@ -285,9 +281,9 @@ class Game:
] ]
]) ])
# Manda la tastiera # Manda la tastiera
bot.sendMessage(self.groupid, s.preset_choose, parse_mode=ParseMode.MARKDOWN, reply_markup=kbmarkup) self.bot.sendMessage(self.groupid, s.preset_choose, parse_mode=ParseMode.MARKDOWN, reply_markup=kbmarkup)
def loadpreset(self, bot: Bot, preset: str): def loadpreset(self, preset: str):
"""Fine della fase di preset: carica il preset selezionato o passa a config""" """Fine della fase di preset: carica il preset selezionato o passa a config"""
if preset == "simple": if preset == "simple":
# Preset semplice (solo Royal, Mifiosi e Investigatori) # Preset semplice (solo Royal, Mifiosi e Investigatori)
@ -305,10 +301,10 @@ class Game:
"Servitore": 0 "Servitore": 0
} }
self.votingmifia = True self.votingmifia = True
self.message(bot, s.preset_simple_selected.format(mifioso=self.roleconfig["Mifioso"], self.message(s.preset_simple_selected.format(mifioso=self.roleconfig["Mifioso"],
investigatore=self.roleconfig["Investigatore"], investigatore=self.roleconfig["Investigatore"],
royal=len(self.players) - self.roleconfig["Mifioso"] - self.roleconfig["Investigatore"])) royal=len(self.players) - self.roleconfig["Mifioso"] - self.roleconfig["Investigatore"]))
self.endconfig(bot) self.endconfig()
elif preset == "classic": elif preset == "classic":
# Preset classico (solo Royal, Mifiosi, Investigatori, Angeli e Terroristi) # Preset classico (solo Royal, Mifiosi, Investigatori, Angeli e Terroristi)
self.roleconfig = { self.roleconfig = {
@ -325,8 +321,8 @@ class Game:
"Servitore": 0 "Servitore": 0
} }
self.votingmifia = True self.votingmifia = True
self.message(bot, s.preset_classic_selected.format(mifioso=self.roleconfig["Mifioso"], investigatore=self.roleconfig["Investigatore"], angelo=self.roleconfig["Angelo"], royal=len(self.players) - self.roleconfig["Mifioso"] - self.roleconfig["Investigatore"] - self.roleconfig["Angelo"], royalmenouno=len(self.players) - self.roleconfig["Mifioso"] - self.roleconfig["Investigatore"] - self.roleconfig["Angelo"] - 1)) self.message(s.preset_classic_selected.format(mifioso=self.roleconfig["Mifioso"], investigatore=self.roleconfig["Investigatore"], angelo=self.roleconfig["Angelo"], royal=len(self.players) - self.roleconfig["Mifioso"] - self.roleconfig["Investigatore"] - self.roleconfig["Angelo"], royalmenouno=len(self.players) - self.roleconfig["Mifioso"] - self.roleconfig["Investigatore"] - self.roleconfig["Angelo"] - 1))
self.endconfig(bot) self.endconfig()
elif preset == "oneofall": elif preset == "oneofall":
self.roleconfig = { self.roleconfig = {
"Mifioso": 1, "Mifioso": 1,
@ -352,11 +348,11 @@ class Game:
self.roleconfig[availableroles.pop().__name__] += 1 self.roleconfig[availableroles.pop().__name__] += 1
unassignedplayers -= 1 unassignedplayers -= 1
self.votingmifia = False self.votingmifia = False
self.message(bot, s.preset_oneofall_selected) self.message(s.preset_oneofall_selected)
self.endconfig(bot) self.endconfig()
def endconfig(self, bot: Bot): def endconfig(self):
"""Fine della fase di config, inizio assegnazione ruoli""" """Fine della fase di config, inizio assegnazione ruoli"""
# Controlla che ci siano abbastanza giocatori per avviare la partita # Controlla che ci siano abbastanza giocatori per avviare la partita
requiredplayers = 0 requiredplayers = 0
@ -364,7 +360,7 @@ class Game:
requiredplayers += self.roleconfig[selectedrole] requiredplayers += self.roleconfig[selectedrole]
# Se non ce ne sono abbastanza, torna alla fase di join # Se non ce ne sono abbastanza, torna alla fase di join
if requiredplayers > len(self.players): if requiredplayers > len(self.players):
self.message(bot, s.error_not_enough_players) self.message(s.error_not_enough_players)
self.phase = "Join" self.phase = "Join"
# self.updategroupname(bot) # self.updategroupname(bot)
else: else:
@ -372,28 +368,28 @@ class Game:
# self.updategroupname(bot) # self.updategroupname(bot)
self.day += 1 self.day += 1
self.players.sort(key=lambda p: p.tusername) self.players.sort(key=lambda p: p.tusername)
self.assignroles(bot) self.assignroles()
self.message(bot, s.roles_assigned_successfully) self.message(s.roles_assigned_successfully)
for player in self.players: for player in self.players:
player.role.onstartgame(bot) player.role.onstartgame()
def revealallroles(self, bot: Bot): def revealallroles(self):
text = s.status_header.format(name=self.name, admin=self.admin.tusername, phase=self.phase) text = s.status_header.format(name=self.name, admin=self.admin.tusername, phase=self.phase)
self.updatevotes() self.updatevotes()
# Aggiungi l'elenco dei giocatori # Aggiungi l'elenco dei giocatori
for player in self.players: for player in self.players:
text += s.status_basic_player.format(icon=player.role.icon, text += s.status_basic_player.format(icon=player.role.icon,
name=player.tusername) name=player.tusername)
self.message(bot, text) self.message(text)
def endgame(self, bot: Bot): def endgame(self):
self.revealallroles(bot) self.revealallroles()
for player in self.players: for player in self.players:
# Togli la referenza circolare # Togli la referenza circolare
player.role.player = None player.role.player = None
inprogress.remove(self) inprogress.remove(self)
def save(self, bot: Bot): def save(self):
# Crea il file. # Crea il file.
try: try:
file = open(str(self.groupid) + ".p", 'x') file = open(str(self.groupid) + ".p", 'x')
@ -417,10 +413,10 @@ class Game:
# Scrivi sul file. # Scrivi sul file.
file = open("{group}-{yy}-{mm}-{dd}-{hh}-{mi}.p".format(group=str(self.groupid), yy=t.year, mm=t.month, dd=t.day, hh=t.hour, mi=t.minute), 'wb') file = open("{group}-{yy}-{mm}-{dd}-{hh}-{mi}.p".format(group=str(self.groupid), yy=t.year, mm=t.month, dd=t.day, hh=t.hour, mi=t.minute), 'wb')
pickle.dump(self, file) pickle.dump(self, file)
self.adminmessage(bot, s.game_saved.format(name=self.name)) self.adminmessage(s.game_saved.format(name=self.name))
file.close() file.close()
def victoryconditions(self, bot: Bot): def victoryconditions(self):
"""Controlla se qualcuno ha completato le condizioni di vittoria.""" """Controlla se qualcuno ha completato le condizioni di vittoria."""
good = 0 good = 0
evil = 0 evil = 0
@ -434,34 +430,34 @@ class Game:
alive += 1 alive += 1
# Distruzione atomica! # Distruzione atomica!
if alive == 0: if alive == 0:
self.message(bot, s.end_game_wiped) self.message(s.end_game_wiped)
for player in self.players: for player in self.players:
player.message(bot, s.end_game_wiped + s.tie) player.message(s.end_game_wiped + s.tie)
self.endgame(bot) self.endgame()
# I mifiosi vincono se sono più dei royal # I mifiosi vincono se sono più dei royal
elif evil >= good: elif evil >= good:
self.message(bot, s.end_mifia_outnumber + s.victory_mifia) self.message(s.end_mifia_outnumber + s.victory_mifia)
for player in self.players: for player in self.players:
if player.role.team == 'Good': if player.role.team == 'Good':
player.message(bot, s.end_mifia_outnumber + s.defeat) player.message(s.end_mifia_outnumber + s.defeat)
elif player.role.team == 'Evil': elif player.role.team == 'Evil':
player.message(bot, s.end_mifia_outnumber + s.victory) player.message(s.end_mifia_outnumber + s.victory)
elif player.role.team == 'Chaos': elif player.role.team == 'Chaos':
player.message(bot, s.end_game_chaos + s.victory) player.message(s.end_game_chaos + s.victory)
self.endgame(bot) self.endgame()
# Male distrutto # Male distrutto
elif evil == 0: elif evil == 0:
self.message(bot, s.end_mifia_killed + s.victory_royal) self.message(s.end_mifia_killed + s.victory_royal)
for player in self.players: for player in self.players:
if player.role.team == 'Good': if player.role.team == 'Good':
player.message(bot, s.end_mifia_killed + s.victory) player.message(s.end_mifia_killed + s.victory)
elif player.role.team == 'Evil': elif player.role.team == 'Evil':
player.message(bot, s.end_mifia_killed + s.defeat) player.message(s.end_mifia_killed + s.defeat)
elif player.role.team == 'Chaos': elif player.role.team == 'Chaos':
player.message(bot, s.end_game_chaos + s.victory) player.message(s.end_game_chaos + s.victory)
self.endgame(bot) self.endgame()
def changerole(self, bot: Bot, player: Player, newrole): def changerole(self, player: Player, newrole):
"""Cambia il ruolo di un giocatore, aggiornando tutti i valori""" """Cambia il ruolo di un giocatore, aggiornando tutti i valori"""
# Aggiorna le liste dei ruoli # Aggiorna le liste dei ruoli
if player.role.__class__ != Royal: if player.role.__class__ != Royal:
@ -471,21 +467,21 @@ class Game:
# Cambia il ruolo al giocatore # Cambia il ruolo al giocatore
player.role = newrole(player) player.role = newrole(player)
# Manda i messaggi del nuovo ruolo # Manda i messaggi del nuovo ruolo
player.message(bot, s.role_assigned.format(icon=player.role.icon, name=player.role.name)) player.message(s.role_assigned.format(icon=player.role.icon, name=player.role.name))
if player.role.powerdesc is not None: if player.role.powerdesc is not None:
player.message(bot, player.role.powerdesc.format(gamename=self.name)) player.message(player.role.powerdesc.format(gamename=self.name))
# Manda ai mifiosi l'elenco dei loro compagni di squadra # Manda ai mifiosi l'elenco dei loro compagni di squadra
text = s.mifia_team_intro text = s.mifia_team_intro
for player in self.playersinrole['Mifioso']: for player in self.playersinrole['Mifioso']:
text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername) text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername)
for player in self.playersinrole['Corrotto']: for player in self.playersinrole['Corrotto']:
text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername) text += s.mifia_team_player.format(icon=player.role.icon, name=player.tusername)
self.mifiamessage(bot, text) self.mifiamessage(text)
def joinplayer(self, bot: Bot, player: Player, silent=False): def joinplayer(self, player: Player, silent=False):
self.players.append(player) self.players.append(player)
if not silent: if not silent:
self.message(bot, s.player_joined.format(name=player.tusername, players=len(self.players))) self.message(s.player_joined.format(name=player.tusername, players=len(self.players)))
# Se è il primo giocatore ad unirsi, diventa admin # Se è il primo giocatore ad unirsi, diventa admin
if len(self.players) == 1: if len(self.players) == 1:
self.admin = player self.admin = player
@ -532,9 +528,9 @@ def newgame(bot: Bot, update):
if game is not None: if game is not None:
bot.sendMessage(update.message.chat.id, s.error_game_in_progress, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_game_in_progress, parse_mode=ParseMode.MARKDOWN)
return return
game = Game(update.message.chat.id) game = Game(bot, update.message.chat.id)
inprogress.append(game) inprogress.append(game)
game.message(bot, s.new_game.format(name=game.name)) game.message(s.new_game.format(name=game.name))
join(bot, update) join(bot, update)
@ -547,28 +543,28 @@ def join(bot: Bot, update):
return return
# Fase di join finita # Fase di join finita
if game.phase != 'Join': if game.phase != 'Join':
game.message(bot, s.error_join_phase_ended) game.message(s.error_join_phase_ended)
return return
p = game.findplayerbyid(update.message.from_user['id']) p = game.findplayerbyid(update.message.from_user['id'])
# Giocatore già in partita # Giocatore già in partita
if p is not None: if p is not None:
game.message(bot, s.error_player_already_joined) game.message(s.error_player_already_joined)
return return
# Giocatore senza username # Giocatore senza username
if update.message.from_user.username is None: if update.message.from_user.username is None:
game.message(bot, s.error_no_username) game.message(s.error_no_username)
return return
p = Player(game, update.message.from_user.id, update.message.from_user.username) p = Player(game, update.message.from_user.id, update.message.from_user.username)
try: try:
p.message(bot, s.you_joined.format(game=game.name, adminname=game.admin.tusername if game.admin is not None else p.tusername)) p.message(s.you_joined.format(game=game.name, adminname=game.admin.tusername if game.admin is not None else p.tusername))
except Unauthorized: except Unauthorized:
# Bot bloccato dall'utente # Bot bloccato dall'utente
game.message(bot, s.error_chat_unavailable) game.message(s.error_chat_unavailable)
return return
# Aggiungi il giocatore alla partita # Aggiungi il giocatore alla partita
game.joinplayer(bot, p) game.joinplayer(p)
# Salva # Salva
game.save(bot) game.save()
def debugjoin(bot: Bot, update): def debugjoin(bot: Bot, update):
@ -579,13 +575,13 @@ def debugjoin(bot: Bot, update):
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
return return
if game.phase != 'Join': if game.phase != 'Join':
game.message(bot, s.error_join_phase_ended) game.message(s.error_join_phase_ended)
return return
arg = update.message.text.split(" ") arg = update.message.text.split(" ")
for name in range(1, int(arg[1]) + 1): for name in range(1, int(arg[1]) + 1):
p = Player(game, int(name), str(name), True) p = Player(game, int(name), str(name), True)
try: try:
game.joinplayer(bot, p, silent=True) game.joinplayer(p, silent=True)
except RetryAfter: except RetryAfter:
pass pass
@ -610,7 +606,7 @@ def status(bot: Bot, update):
else: else:
text += s.status_basic_player.format(icon="\U0001F610", text += s.status_basic_player.format(icon="\U0001F610",
name=player.tusername) name=player.tusername)
game.message(bot, text) game.message(text)
else: else:
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
@ -620,10 +616,10 @@ def endjoin(bot: Bot, update):
game = findgamebyid(update.message.chat.id) game = findgamebyid(update.message.chat.id)
if game is not None and game.phase == 'Join': if game is not None and game.phase == 'Join':
if update.message.from_user.id == game.admin.tid: if update.message.from_user.id == game.admin.tid:
game.message(bot, s.join_phase_ended) game.message(s.join_phase_ended)
game.startpreset(bot) game.startpreset()
else: else:
game.message(bot, s.error_not_admin) game.message(s.error_not_admin)
else: else:
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
@ -639,7 +635,7 @@ def vote(bot: Bot, update):
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
return return
elif game.day <= 1: elif game.day <= 1:
game.message(bot, s.error_no_votes_on_first_day) game.message(s.error_no_votes_on_first_day)
return return
# Genera la tastiera # Genera la tastiera
table = list() table = list()
@ -657,11 +653,11 @@ def vote(bot: Bot, update):
bot.sendMessage(game.groupid, s.vote_keyboard, parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard) bot.sendMessage(game.groupid, s.vote_keyboard, parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard)
def endday(bot: Bot, update): def endday(_: Bot, update):
"""Termina la giornata attuale.""" """Termina la giornata attuale."""
game = findgamebyid(update.message.chat.id) game = findgamebyid(update.message.chat.id)
if game is not None and game.phase is 'Voting' and update.message.from_user.id == game.admin.tid: if game is not None and game.phase is 'Voting' and update.message.from_user.id == game.admin.tid:
game.endday(bot) game.endday()
def power(bot: Bot, update): def power(bot: Bot, update):
@ -680,11 +676,11 @@ def power(bot: Bot, update):
if player is not None: if player is not None:
if player.alive: if player.alive:
if len(cmd) > 2: if len(cmd) > 2:
player.role.power(bot, cmd[2]) player.role.power(cmd[2])
else: else:
player.message(bot, s.error_missing_parameters) player.message(s.error_missing_parameters)
else: else:
player.message(bot, s.error_dead) player.message(s.error_dead)
else: else:
bot.sendMessage(update.message.chat.id, s.error_not_in_game, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_not_in_game, parse_mode=ParseMode.MARKDOWN)
else: else:
@ -700,10 +696,10 @@ def role(bot: Bot, update):
player = game.findplayerbyid(update.message.from_user.id) player = game.findplayerbyid(update.message.from_user.id)
if player is not None: if player is not None:
if player.alive: if player.alive:
player.message(bot, s.role_assigned.format(icon=player.role.icon, name=player.role.name)) player.message(s.role_assigned.format(icon=player.role.icon, name=player.role.name))
game.message(bot, s.check_private) game.message(s.check_private)
else: else:
game.message(bot, s.error_dead) game.message(s.error_dead)
else: else:
bot.sendMessage(update.message.chat.id, s.error_not_in_game, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_not_in_game, parse_mode=ParseMode.MARKDOWN)
else: else:
@ -718,14 +714,14 @@ def kill(bot: Bot, update):
if update.message.from_user.id == game.admin.tid: if update.message.from_user.id == game.admin.tid:
target = game.findplayerbyusername(update.message.text.split(' ')[1]) target = game.findplayerbyusername(update.message.text.split(' ')[1])
if target is not None: if target is not None:
target.kill(bot, game) target.kill()
game.message(bot, s.admin_killed.format(name=target.tusername, game.message(s.admin_killed.format(name=target.tusername,
icon=target.role.icon, icon=target.role.icon,
role=target.role.name)) role=target.role.name))
else: else:
game.message(bot, s.error_username) game.message(s.error_username)
else: else:
game.message(bot, s.error_not_admin) game.message(s.error_not_admin)
else: else:
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
@ -740,10 +736,10 @@ def delete(bot: Bot, update):
if game is None: if game is None:
game = findgamebyid(int(cmd[1])) game = findgamebyid(int(cmd[1]))
if game is not None: if game is not None:
game.message(bot, s.owner_ended) game.message(s.owner_ended)
game.endgame(bot) game.endgame()
else: else:
game.message(bot, s.error_no_games_found) game.message(s.error_no_games_found)
else: else:
bot.sendMessage(update.message.chat.id, s.error_not_owner, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_not_owner, parse_mode=ParseMode.MARKDOWN)
else: else:
@ -762,7 +758,7 @@ def save(bot: Bot, update):
"""Salva una partita su file.""" """Salva una partita su file."""
game = findgamebyid(update.message.chat.id) game = findgamebyid(update.message.chat.id)
if game is not None: if game is not None:
game.save(bot) game.save()
else: else:
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
@ -772,7 +768,7 @@ def debug(bot: Bot, update):
if __debug__: if __debug__:
game = findgamebyid(update.message.chat.id) game = findgamebyid(update.message.chat.id)
if game is not None: if game is not None:
game.revealallroles(bot) game.revealallroles()
else: else:
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
@ -783,7 +779,7 @@ def debugchangerole(bot: Bot, update):
game = findgamebyid(update.message.chat.id) game = findgamebyid(update.message.chat.id)
if game is not None: if game is not None:
cmd = update.message.text.split(' ', 2) cmd = update.message.text.split(' ', 2)
game.changerole(bot, game.findplayerbyusername(cmd[1]), globals()[cmd[2]]) game.changerole(game.findplayerbyusername(cmd[1]), globals()[cmd[2]])
else: else:
bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN) bot.sendMessage(update.message.chat.id, s.error_no_games_found, parse_mode=ParseMode.MARKDOWN)
@ -804,7 +800,7 @@ def inlinekeyboard(bot: Bot, update):
if update.callback_query.from_user.id != game.admin.tid: if update.callback_query.from_user.id != game.admin.tid:
bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.error_not_admin, show_alert=True) bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.error_not_admin, show_alert=True)
return return
game.loadpreset(bot, update.callback_query.data) game.loadpreset(update.callback_query.data)
bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.preset_selected.format(selected=update.callback_query.data)) bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.preset_selected.format(selected=update.callback_query.data))
elif game.phase is 'Voting': elif game.phase is 'Voting':
# Trova il giocatore # Trova il giocatore
@ -818,13 +814,13 @@ def inlinekeyboard(bot: Bot, update):
if update.callback_query.data == "-": if update.callback_query.data == "-":
# Annulla il voto # Annulla il voto
player.votingfor = None player.votingfor = None
game.message(bot, s.vote_none.format(player=player)) game.message(s.vote_none.format(player=player))
bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.vote_none_fp) bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.vote_none_fp)
else: else:
# Cambia il voto # Cambia il voto
target = game.findplayerbyusername(update.callback_query.data) target = game.findplayerbyusername(update.callback_query.data)
player.votingfor = target player.votingfor = target
game.message(bot, s.vote.format(voting=player.tusername, voted=target.tusername)) game.message(s.vote.format(voting=player.tusername, voted=target.tusername))
bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.vote_fp.format(voted=target.tusername)) bot.answerCallbackQuery(callback_query_id=update.callback_query.id, text=s.vote_fp.format(voted=target.tusername))

10
roles/Angelo.py
View file

@ -19,11 +19,11 @@ class Angelo(Role):
else: else:
return "<Role: Angelo, protecting {target}>".format(target=self.protecting.tusername) return "<Role: Angelo, protecting {target}>".format(target=self.protecting.tusername)
def power(self, bot, arg): def power(self, arg):
# Imposta qualcuno come protetto # Imposta qualcuno come protetto
selected = self.player.game.findplayerbyusername(arg) selected = self.player.game.findplayerbyusername(arg)
if selected is None: if selected is None:
self.player.message(bot, s.error_username) self.player.message(s.error_username)
return return
# Controlla che l'angelo stia provando a proteggere sè stesso # Controlla che l'angelo stia provando a proteggere sè stesso
@ -34,11 +34,11 @@ class Angelo(Role):
# Aggiungi la protezione al nuovo giocatore selezionato # Aggiungi la protezione al nuovo giocatore selezionato
selected.protectedby = self.player selected.protectedby = self.player
self.protecting = selected self.protecting = selected
self.player.message(bot, s.angel_target_selected.format(target=self.protecting.tusername)) self.player.message(s.angel_target_selected.format(target=self.protecting.tusername))
else: else:
self.player.message(bot, s.error_angel_no_selfprotect) self.player.message(s.error_angel_no_selfprotect)
def onendday(self, bot): def onendday(self):
# Resetta la protezione # Resetta la protezione
if self.protecting is not None: if self.protecting is not None:
self.protecting.protectedby = None self.protecting.protectedby = None

13
roles/Corrotto.py
View file

@ -16,24 +16,21 @@ class Corrotto(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Corrotto, {uses} uses left>".format(uses=self.poweruses) return "<Role: Corrotto, {uses} uses left>".format(uses=self.poweruses)
def power(self, bot, arg): def power(self, arg):
# Indaga sul vero ruolo di una persona, se sono ancora disponibili usi del potere. # Indaga sul vero ruolo di una persona, se sono ancora disponibili usi del potere.
if self.poweruses <= 0: if self.poweruses <= 0:
# Non hai abbastanza cariche! # Non hai abbastanza cariche!
self.player.message(bot, s.error_no_uses) self.player.message(s.error_no_uses)
return return
target = self.player.game.findplayerbyusername(arg) target = self.player.game.findplayerbyusername(arg)
if target is None: if target is None:
# Username non valido # Username non valido
self.player.message(bot, s.error_username) self.player.message(s.error_username)
return return
# Utilizza il potere su quella persona # Utilizza il potere su quella persona
self.poweruses -= 1 self.poweruses -= 1
self.player.message(bot, s.detective_discovery.format(target=target.tusername, self.player.message(s.detective_discovery.format(target=target.tusername, icon=target.role.icon, role=target.role.name, left=self.poweruses))
icon=target.role.icon,
role=target.role.name,
left=self.poweruses))
def onendday(self, bot): def onendday(self):
# Ripristina il potere # Ripristina il potere
self.poweruses = self.refillpoweruses self.poweruses = self.refillpoweruses

12
roles/Derek.py
View file

@ -17,17 +17,17 @@ class Derek(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Derek>" return "<Role: Derek>"
def power(self, bot, arg): def power(self, arg):
# Attiva / disattiva la morte alla fine del round # Attiva / disattiva la morte alla fine del round
self.deathwish = not self.deathwish self.deathwish = not self.deathwish
if self.deathwish: if self.deathwish:
self.player.message(bot, s.derek_deathwish_unset) self.player.message(s.derek_deathwish_unset)
else: else:
self.player.message(bot, s.derek_deathwish_set) self.player.message(s.derek_deathwish_set)
def onendday(self, bot): def onendday(self):
if self.deathwish: if self.deathwish:
self.player.game.message(bot, s.derek_deathwish_successful.format(name=self.player.tusername)) self.player.game.message(s.derek_deathwish_successful.format(name=self.player.tusername))
self.player.kill(bot, self.player.game) self.player.kill(self.player.game)
self.chaos = True self.chaos = True

12
roles/Disastro.py
View file

@ -16,7 +16,7 @@ class Disastro(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Investigatore, {uses} uses left>".format(uses=self.poweruses) return "<Role: Investigatore, {uses} uses left>".format(uses=self.poweruses)
def power(self, bot, arg): def power(self, arg):
# Indaga sul vero ruolo di una persona, se sono ancora disponibili usi del potere. # Indaga sul vero ruolo di una persona, se sono ancora disponibili usi del potere.
if self.poweruses > 0: if self.poweruses > 0:
target = self.player.game.findplayerbyusername(arg) target = self.player.game.findplayerbyusername(arg)
@ -26,19 +26,19 @@ class Disastro(Role):
while isinstance(target.role, randomrole): while isinstance(target.role, randomrole):
# TODO: se ci fossero solo disastri in una partita cosa succederebbe? # TODO: se ci fossero solo disastri in una partita cosa succederebbe?
randomrole = self.player.game.getrandomrole() randomrole = self.player.game.getrandomrole()
self.player.message(bot, s.detective_discovery.format(target=target.tusername, self.player.message(s.detective_discovery.format(target=target.tusername,
icon=randomrole.icon, icon=randomrole.icon,
role=randomrole.name, role=randomrole.name,
left=self.poweruses)) left=self.poweruses))
else: else:
self.player.message(bot, s.error_username) self.player.message(s.error_username)
else: else:
self.player.message(bot, s.error_no_uses) self.player.message(s.error_no_uses)
def onendday(self, bot): def onendday(self):
# Ripristina il potere # Ripristina il potere
self.poweruses = self.refillpoweruses self.poweruses = self.refillpoweruses
def ondeath(self, bot): def ondeath(self):
self.icon = s.disaster_icon self.icon = s.disaster_icon
self.name = s.disaster_name self.name = s.disaster_name

13
roles/Investigatore.py
View file

@ -16,24 +16,21 @@ class Investigatore(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Investigatore, {uses} uses left>".format(uses=self.poweruses) return "<Role: Investigatore, {uses} uses left>".format(uses=self.poweruses)
def power(self, bot, arg): def power(self, arg):
# Indaga sul vero ruolo di una persona, se sono ancora disponibili usi del potere. # Indaga sul vero ruolo di una persona, se sono ancora disponibili usi del potere.
if self.poweruses <= 0: if self.poweruses <= 0:
# Non hai abbastanza cariche! # Non hai abbastanza cariche!
self.player.message(bot, s.error_no_uses) self.player.message(s.error_no_uses)
return return
target = self.player.game.findplayerbyusername(arg) target = self.player.game.findplayerbyusername(arg)
if target is None: if target is None:
# Username non valido # Username non valido
self.player.message(bot, s.error_username) self.player.message(s.error_username)
return return
# Utilizza il potere su quella persona # Utilizza il potere su quella persona
self.poweruses -= 1 self.poweruses -= 1
self.player.message(bot, s.detective_discovery.format(target=target.tusername, self.player.message(s.detective_discovery.format(target=target.tusername, icon=target.role.icon, role=target.role.name, left=self.poweruses))
icon=target.role.icon,
role=target.role.name,
left=self.poweruses))
def onendday(self, bot): def onendday(self):
# Ripristina il potere # Ripristina il potere
self.poweruses = self.refillpoweruses self.poweruses = self.refillpoweruses

6
roles/Mamma.py
View file

@ -12,11 +12,9 @@ class Mamma(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Mamma>" return "<Role: Mamma>"
def onstartgame(self, bot): def onstartgame(self):
# Scegli un bersaglio casuale che non sia il giocatore stesso # Scegli un bersaglio casuale che non sia il giocatore stesso
possibletargets = self.player.game.players.copy() possibletargets = self.player.game.players.copy()
possibletargets.remove(self.player) possibletargets.remove(self.player)
target = random.sample(possibletargets, 1)[0] target = random.sample(possibletargets, 1)[0]
self.player.message(bot, s.mom_discovery.format(target=target.tusername, self.player.message(s.mom_discovery.format(target=target.tusername, icon=target.role.icon, role=target.role.name))
icon=target.role.icon,
role=target.role.name))

18
roles/Mifioso.py
View file

@ -18,17 +18,17 @@ class Mifioso(Role):
else: else:
return "<Role: Mifioso, targeting {target}>".format(target=self.target.tusername) return "<Role: Mifioso, targeting {target}>".format(target=self.target.tusername)
def power(self, bot, arg): def power(self, arg):
# Imposta una persona come bersaglio da uccidere. # Imposta una persona come bersaglio da uccidere.
selected = self.player.game.findplayerbyusername(arg) selected = self.player.game.findplayerbyusername(arg)
if selected is None: if selected is None:
self.player.message(bot, s.error_username) self.player.message(s.error_username)
return return
self.target = selected self.target = selected
self.player.message(bot, s.mifia_target_selected.format(target=self.target.tusername)) self.player.message(s.mifia_target_selected.format(target=self.target.tusername))
def onendday(self, bot): def onendday(self):
if self.player.game.votingmifia: if self.player.game.votingmifia:
# Se la partita è in modalità votingmifia l'uccisione della mifia viene gestita dalla classe Game # Se la partita è in modalità votingmifia l'uccisione della mifia viene gestita dalla classe Game
self.target = None self.target = None
@ -37,13 +37,9 @@ class Mifioso(Role):
if self.target is not None: if self.target is not None:
if self.target.protectedby is None: if self.target.protectedby is None:
# Uccisione riuscita # Uccisione riuscita
self.target.kill(bot, self) self.target.kill(self)
self.player.game.message(bot, s.mifia_target_killed.format(target=self.target.tusername, self.player.game.message(s.mifia_target_killed.format(target=self.target.tusername, icon=self.target.role.icon, role=self.target.role.name))
icon=self.target.role.icon,
role=self.target.role.name))
else: else:
# Bersaglio protetto da un angelo # Bersaglio protetto da un angelo
self.player.game.message(bot, s.mifia_target_protected.format(target=self.target.tusername, self.player.game.message(s.mifia_target_protected.format(target=self.target.tusername, icon=self.target.protectedby.role.icon, protectedby=self.target.protectedby.tusername))
icon=self.target.protectedby.role.icon,
protectedby=self.target.protectedby.tusername))
self.target = None self.target = None

8
roles/Role.py
View file

@ -15,18 +15,18 @@ class Role:
def __str__(self) -> str: def __str__(self) -> str:
return "{} {}".format(self.icon, self.name) return "{} {}".format(self.icon, self.name)
def power(self, bot, arg): def power(self, arg):
"""Il potere del ruolo. Si attiva quando il bot riceve un /power in chat privata.""" """Il potere del ruolo. Si attiva quando il bot riceve un /power in chat privata."""
pass pass
def onendday(self, bot): def onendday(self):
"""Metodo chiamato alla fine di ogni giorno.""" """Metodo chiamato alla fine di ogni giorno."""
pass pass
def ondeath(self, bot): def ondeath(self):
"""Metodo chiamato alla morte del giocatore.""" """Metodo chiamato alla morte del giocatore."""
pass pass
def onstartgame(self, bot): def onstartgame(self):
"""Metodo chiamato all'inizio della partita.""" """Metodo chiamato all'inizio della partita."""
pass pass

6
roles/Servitore.py
View file

@ -13,10 +13,10 @@ class Servitore(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Servitore del Caos>" return "<Role: Servitore del Caos>"
def onendday(self, bot): def onendday(self):
for chaoslord in self.player.game.playersinrole["SignoreDelCaos"]: for chaoslord in self.player.game.playersinrole["SignoreDelCaos"]:
if chaoslord.alive: if chaoslord.alive:
break break
else: else:
self.player.game.changerole(bot, self.player, SignoreDelCaos) self.player.game.changerole(self.player, SignoreDelCaos)
self.player.game.message(bot, s.chaos_servant_inherited) self.player.game.message(s.chaos_servant_inherited)

14
roles/SignoreDelCaos.py
View file

@ -16,20 +16,20 @@ class SignoreDelCaos(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Signore del Caos>" return "<Role: Signore del Caos>"
def power(self, bot, arg): def power(self, arg):
selected = self.player.game.findplayerbyusername(arg) selected = self.player.game.findplayerbyusername(arg)
if selected is not None and selected is not self.player and selected.alive: if selected is not None and selected is not self.player and selected.alive:
self.target = selected self.target = selected
self.player.message(bot, s.chaos_lord_target_selected.format(target=self.target.tusername)) self.player.message(s.chaos_lord_target_selected.format(target=self.target.tusername))
else: else:
self.player.message(bot, s.error_no_username) self.player.message(s.error_no_username)
def onendday(self, bot): def onendday(self):
if self.target is not None: if self.target is not None:
if self.target.alive and self.player.alive: if self.target.alive and self.player.alive:
if not isinstance(self.target.role, SignoreDelCaos): if not isinstance(self.target.role, SignoreDelCaos):
randomrole = self.player.game.getrandomrole() randomrole = self.player.game.getrandomrole()
self.player.game.changerole(bot, self.target, randomrole) self.player.game.changerole(self.target, randomrole)
self.player.game.message(bot, s.chaos_lord_randomized) self.player.game.message(s.chaos_lord_randomized)
else: else:
self.player.game.message(bot, s.chaos_lord_failed) self.player.game.message(s.chaos_lord_failed)

18
roles/Stagista.py
View file

@ -18,21 +18,21 @@ class Stagista(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Stagista>" return "<Role: Stagista>"
def power(self, bot, arg): def power(self, arg):
target = self.player.game.findplayerbyusername(arg) target = self.player.game.findplayerbyusername(arg)
if target is not None and target is not self.player and target.alive: if target is not None and target is not self.player and target.alive:
self.master = target self.master = target
self.player.message(bot, s.intern_started_internship.format(master=self.master.tusername)) self.player.message(s.intern_started_internship.format(master=self.master.tusername))
else: else:
self.player.message(bot, s.error_no_username) self.player.message(s.error_no_username)
def onendday(self, bot): def onendday(self):
if self.master is not None: if self.master is not None:
if isinstance(self.master.role, Derek) and self.master.role.chaos: if isinstance(self.master.role, Derek) and self.master.role.chaos:
self.player.game.message(bot, s.intern_chaos_summoned) self.player.game.message(s.intern_chaos_summoned)
self.master.alive = True self.master.alive = True
self.player.game.changerole(bot, self.master, SignoreDelCaos) self.player.game.changerole(self.master, SignoreDelCaos)
self.player.game.changerole(bot, self.player, Servitore) self.player.game.changerole(self.player, Servitore)
else: else:
self.player.game.message(bot, s.intern_changed_role.format(icon=self.master.role.__class__.icon, role=self.master.role.__class__.name)) self.player.game.message(s.intern_changed_role.format(icon=self.master.role.__class__.icon, role=self.master.role.__class__.name))
self.player.game.changerole(bot, self.player, self.master.role.__class__) self.player.game.changerole(self.player, self.master.role.__class__)

10
roles/Terrorista.py
View file

@ -12,14 +12,12 @@ class Terrorista(Role):
def __repr__(self) -> str: def __repr__(self) -> str:
return "<Role: Terrorista>" return "<Role: Terrorista>"
def ondeath(self, bot): def ondeath(self):
# Se è stato ucciso da una votazione, attiva il suo potere # Se è stato ucciso da una votazione, attiva il suo potere
if self.player == self.player.game.lastlynch: if self.player == self.player.game.lastlynch:
self.player.game.message(bot, s.terrorist_kaboom) self.player.game.message(s.terrorist_kaboom)
for selectedplayer in self.player.game.players: for selectedplayer in self.player.game.players:
# Elimina ogni giocatore che sta votando per sè stesso # Elimina ogni giocatore che sta votando per sè stesso
if selectedplayer.votingfor == self.player: if selectedplayer.votingfor == self.player:
self.player.game.message(bot, s.terrorist_target_killed.format(target=selectedplayer.tusername, self.player.game.message(s.terrorist_target_killed.format(target=selectedplayer.tusername, icon=selectedplayer.role.icon, role=selectedplayer.role.name))
icon=selectedplayer.role.icon, selectedplayer.kill(self.player.game)
role=selectedplayer.role.name))
selectedplayer.kill(bot, self.player.game)