def point(self):
s = _('word_point')+'\n'
s += '{}: {}\\{} \n{}: {}\\{}'.format(
_('team', team = self.team_red.name), self.grid_table.get_red_point(), self.grid_table.number_red,
_('team', team=self.team_blue.name), self.grid_table.get_blue_point(), self.grid_table.number_blue
)
return s
def join(self, member):
if self.status != Status.JOINABLE:
raise NotAllowedCommand(_('error_joinable'))
if self.get_team_member(member) is None:
self.auto_join(member)
else:
raise NotAllowedCommand(_('error_already_joined', team=self.get_team_member(member).name))
def show(self, member, word):
if self.status == Status.PLAY:
if member.id in self.current_turn.members.keys():
found, color = self.grid_table.show(word)
if not found:
raise NotAllowedCommand(_('error_word_not_found', word=word))
elif color == ColorGame.ASSASSIN:
self.status = Status.STOPPED
self.winner = self.next_turn
return ActionResult.FINISH
elif self.verify_victory_condition() is None:
if color != self.current_turn.color:
self.current_turn, self.next_turn = self.next_turn, self.current_turn
return ActionResult.NOT_GUESS
else:
return ActionResult.GUESS
else:
self.winner = self.verify_victory_condition()
self.status = Status.STOPPED
return ActionResult.FINISH
else:
raise NotAllowedCommand(_('error_team_not_allowed', team=self.current_turn.name))
else:
raise NotAllowedCommand(_('error_not_started'))
def leave(self, member):
if self.status != Status.JOINABLE:
raise NotAllowedCommand(_('error_joinable'))
team = self.get_team_member(member)
if team is not None:
team.leave(member)
else:
raise NotAllowedCommand(_('error_not_join'))
def pass_turn(self, member):
if self.status == Status.PLAY:
if member.id in self.current_turn.members.keys():
self.current_turn, self.next_turn = self.next_turn, self.current_turn
else:
raise NotAllowedCommand(_('error_team_not_allowed', team=self.current_turn.name))
else:
raise NotAllowedCommand(_('error_not_started'))
def print_members(self):
s = _('team', team=self.name) + '\n'
if self.master is not None:
s += self.master.name + ' ({})\n'.format(_('master'))
for m in self.members.keys():
if self.master is None or m != self.master.id:
s += self.members[m].name + ' ({})\n'.format(_('spy'))
return s + '\n'
async def addtag(self, ctx, tag, lang, *, member: discord.Member = None):
if not isinstance(ctx.message.channel, discord.DMChannel):
await ctx.send(_('error_addtag_private'))
else:
try:
member = member or ctx.author
self.db.add_tag(tag, lang)
await ctx.send(_('tag_added', tag=tag))
except NotAllowedCommand as err:
await ctx.send(err.message)
def play(self, tag):
if self.status != Status.JOINABLE:
raise NotAllowedCommand(_('error_joinable'))
elif not self.has_masters():
raise NotAllowedCommand(_('error_need_two_master'))
else:
self.status = Status.PLAY
self.grid_table = WordTable()
self.grid_table.generate_words(tag)
self.current_turn = self.team_red
self.next_turn = self.team_blue
def change_team(self, member):
if self.status != Status.JOINABLE:
raise NotAllowedCommand(_('error_joinable'))
if member.id in self.team_red.members.keys():
self.team_red.leave(member)
self.team_blue.join(member)
elif member.id in self.team_blue.members.keys():
self.team_blue.leave(member)
self.team_red.join(member)
else:
raise NotAllowedCommand(_('error_not_join'))
def join_team_as_master(self, member):
if self.team_red.master is not None and self.team_blue.master is not None:
raise NotAllowedCommand(_('error_master_already_set'))
if self.team_red.master is None and member.id not in self.team_blue.members.keys():
self.team_red.set_master(member)
return self.team_red.name
elif self.team_blue.master is None and member.id not in self.team_red.members.keys():
self.team_blue.set_master(member)
return self.team_blue.name
else:
raise NotAllowedCommand(_('error_master_other_team'))
async def stopword(self, ctx, *, member: discord.Member = None):
if not isinstance(ctx.message.channel, discord.DMChannel):
await ctx.send(_('error_stopword_private'))
else:
try:
member = member or ctx.author
self.user_tag.pop(member.id, None)
await ctx.send(_('stop_word'))
except NotAllowedCommand as err:
await ctx.send(err.message)
async def listtags(self, ctx, *, member: discord.Member = None):
try:
member = member or ctx.author
tags = self.db.get_tags()
if len(tags) == 0:
s = _('tags_empty')
else:
s = _('tags_available') + '\n'
for (tag, lang) in tags:
s += '{} ({})\n'.format(tag, lang)
await ctx.send(s)
except NotAllowedCommand as err:
await ctx.send(err.message)
async def addword(self, ctx, tag, *, member: discord.Member = None):
if not isinstance(ctx.message.channel, discord.DMChannel):
await ctx.send(_('error_addword_private'))
else:
try:
member = member or ctx.author
if self.db.get_tag_id(tag) is not None:
self.user_tag[member.id] = tag
await ctx.send(_('tag_adding', tag=tag))
else:
raise NotAllowedCommand(_('error_tag_not_exists', tag=tag))
except NotAllowedCommand as err:
await ctx.send(err.message)
async def show(self, ctx, word, *, member: discord.Member = None):
"""Set the user as captain of a team"""
try:
member = member or ctx.author
res = self.show_word(ctx.message.author.guild, ctx.message.channel, member, word)
if res == ActionResult.FINISH:
name = self.game_helper.matches[(ctx.message.author.guild.id, ctx.message.channel.id)].winner.name
await ctx.send(_('end_game', team=name))
elif res == ActionResult.GUESS:
await ctx.send(_('word_guessed', word=word))
else:
await ctx.send(_('word_not_guessed', word=word))
await self.send_images(ctx)
except NotAllowedCommand as err:
await ctx.send(err.message)
def start(self):
if self.status == Status.JOINABLE:
raise NotAllowedCommand(_('error_started'))
else:
self.status = Status.JOINABLE
self.team_red = Team(ColorGame.RED, 'Red')
self.team_blue = Team(ColorGame.BLUE, 'Blue')
async def send_images(self, ctx):
words = self.game_helper.matches[(
ctx.message.author.guild.id,
ctx.message.channel.id)].grid_table.words
next_team = self.game_helper.matches[(
ctx.message.author.guild.id,
ctx.message.channel.id)].current_turn.name
spies_image = [discord.File(ImageGenerator().generate(words, False))]
await ctx.send(
_('turn', team=next_team) + '\n' +
self.game_helper.matches[(ctx.message.author.guild.id,
ctx.message.channel.id)].point(),
files=spies_image)
master_red = self.game_helper.matches[(
ctx.message.author.guild.id,
ctx.message.channel.id)].team_red.master
master_blue = self.game_helper.matches[(
ctx.message.author.guild.id,
ctx.message.channel.id)].team_blue.master
if master_red is not None:
masters_image = [
discord.File(ImageGenerator().generate(words, True))
]
await master_red.send(files=masters_image)
if master_blue is not None:
masters_image = [
discord.File(ImageGenerator().generate(words, True))
]
await master_blue.send(files=masters_image)
async def master(self, ctx, *, member: discord.Member = None):
"""Set the user as captain of a team"""
try:
member = member or ctx.author
self.join_as_master(ctx.message.author.guild, ctx.message.channel, member)
await ctx.send(_('join_game_as_master', user=member.name))
await ctx.send(self.game_helper.matches[(ctx.message.author.guild.id, ctx.message.channel.id)].print_members())
except NotAllowedCommand as err:
await ctx.send(err.message)
async def stop(self, ctx, *, member: discord.Member = None):
""" Stop the game
"""
print(ctx.message)
try:
self.game_helper.stop(ctx.message.guild.id, ctx.message.channel.id)
member = member or ctx.author
await ctx.send(_('stop_game', user=member.name))
except NotAllowedCommand as err:
await ctx.send(err.message)
async def start(self, ctx, *, member: discord.Member = None):
""" start a game in which player can join with join command.
"""
print(ctx.message)
try:
self.game_helper.start(ctx.message.author.guild, ctx.message.channel)
member = member or ctx.author
await ctx.send(_('start_game', user=member.name))
except NotAllowedCommand as err:
await ctx.send(err.message)
async def play(self, ctx, tag, *, member: discord.Member = None):
""" The game start and is not joinable anymore
"""
print(ctx.message)
try:
self.game_helper.play(ctx.message.guild.id, ctx.message.channel.id, tag)
member = member or ctx.author
await ctx.send(_('play_game', user=member.name, tag=tag))
await self.send_images(ctx)
except NotAllowedCommand as err:
await ctx.send(err.message)
async def leave(self, ctx, *, member: discord.Member = None):
"""leave the game. Allowed only if the game is JOINABLE
"""
print(ctx.message)
try:
self.game_helper.leave(ctx.message.guild.id, ctx.message.channel.id, ctx.author)
member = member or ctx.author
await ctx.send(_('leave_game', user=member.name))
await ctx.send(self.game_helper.matches[(ctx.message.author.guild.id, ctx.message.channel.id)].print_members())
except NotAllowedCommand as err:
await ctx.send(err.message)
async def word_listener(self, ctx, *, member: discord.Member = None):
if ctx.author == self.bot.user:
return
member = member or ctx.author
if isinstance(ctx.channel,
discord.DMChannel) and member.id in self.user_tag.keys(
) and ctx.content[0] != '!':
words = ctx.content.split('\n')
#for each word in words, upperize the first letter
words = [(lambda x: x[0].upper() + x[1:])(w) for w in words]
self.db.add_words(words, self.user_tag[member.id])
await ctx.send(_('words_added'))
async def _pass(self, ctx, *, member: discord.Member = None):
try:
member = member or ctx.author
self.pass_turn(ctx.message.author.guild, ctx.message.channel,
member)
next_team = self.game_helper.matches[(
ctx.message.author.guild.id,
ctx.message.channel.id)].current_turn.name
await ctx.send(
_('turn', team=next_team) + '\n' +
self.game_helper.matches[(ctx.message.author.guild.id,
ctx.message.channel.id)].point())
except NotAllowedCommand as err:
await ctx.send(err.message)
def join_as_master(self, member):
"""Joins the member to one team if available
Args:
member: A member instance
Returns:
A string with the name of the team
Raises:
NotAllowedCommand: An error occured when there are not spaces to be master available
"""
if self.status != Status.JOINABLE:
raise NotAllowedCommand(_('error_joinable'))
else:
return self.join_team_as_master(member)
def play(self, guild_id, channel_id, tag):
if (guild_id, channel_id) in self.matches.keys():
self.matches[(guild_id, channel_id)].play(tag)
else:
raise NotAllowedCommand(_('error_not_started'))
def pass_turn(self, guild, channel, member):
if (guild.id, channel.id) in self.game_helper.matches.keys():
return self.game_helper.matches[(guild.id,
channel.id)].pass_turn(member)
else:
raise NotAllowedCommand(_('error_not_started'))
def show_word(self, guild, channel, member, word):
if (guild.id, channel.id) in self.game_helper.matches.keys():
return self.game_helper.matches[(guild.id,
channel.id)].show(member, word)
else:
raise NotAllowedCommand(_('error_not_started'))
def stop(self):
if self.status == Status.NOT_STARTED or self.status == Status.STOPPED:
raise NotAllowedCommand(_('error_not_started'))
else:
self.status = Status.STOPPED
def print_members(self):
s = _('members') + ':\n'
s += self.team_red.print_members()
s += self.team_blue.print_members()
return s
def stop(self, guild_id, channel_id):
if (guild_id, channel_id) in self.matches.keys():
self.matches[(guild_id, channel_id)].stop()
else:
raise NotAllowedCommand(_('error_not_started'))
