async def king(self, ctx: Context, player1: Member, player2: Member,
player3: Member, *players: Member):
players = list(players)
players.extend((player1, player2, player3))
tasks = list()
king = None
i = 0
count_description = literals('king')['count'] % (len(players) - 1)
footer = literals('king')['footer']
while len(players):
player1 = players.pop(randrange(0, len(players)))
if i == 0:
king = player1
else:
embed = ChainedEmbed(title=literals('king')['number'] % i,
description=count_description)
embed.set_footer(text=footer)
tasks.append(player1.send(embed=embed))
i = i + 1
embed = ChainedEmbed(title=literals('king')['king'] %
king.display_name,
description=count_description)
embed.set_image(url=king.avatar_url)
embed.set_footer(text=footer)
tasks.append(
ctx.send(' '.join(
[member.mention for member in ctx.message.mentions]),
embed=embed))
tasks.append(ctx.message.delete())
await asyncio.wait(tasks)
async def delete(self, ctx: Context, count: int):
count = min(max(1, count), 100)
messages = await ctx.channel.purge(limit=count, bulk=True)
try:
await ctx.channel.delete_messages(messages)
except NotFound:
if count != 1:
await ctx.channel.send(literals('delete')['failed'])
except (ClientException, Forbidden, HTTPException) as e:
await ctx.channel.send(literals('delete')['failed'])
raise e
await ctx.channel.send(literals('delete')['done'] % count,
delete_after=10)
async def reload_cogs(self, ctx: Context):
message = await ctx.send(literals('reload_cogs')['start'])
try:
done = self.client.reload_all_extensions()
except Exception as e:
await message.edit(content=(literals('reload_cogs')['failed'] +
'```\n' + str(e) + '```'))
Log.error(e)
else:
if done:
await message.edit(content=literals('reload_cogs')['done'])
else:
await message.edit(content=(literals('reload_cogs')['failed']))
async def send_command_help(self, ctx: Context, command: Command):
literal = literals('send_command_help')
command_name = command.qualified_name
default_signature = get_command_default_signature(command)
footer = get_command_signature(command)
description = ''
if command.help is not None:
description = command.help + '\n'
elif command.brief is not None:
description = command.brief + '\n'
description += f'`{default_signature}`'
embeds = ChainedEmbed(title=get_constant('default_prefix') + command_name, description=description)
embeds.set_thumbnail(url=self.client.user.avatar_url)
if not command.enabled:
embeds.add_field(name=literal['disabled_name'], value=literal['disabled_value'])
if isinstance(command, CustomGroup):
embeds.add_field(name=literal['subcommand'],
value=f'\n{brief_group(command)}\n')
for check in command.checks:
data = get_check(check.name)
if data is None:
continue
embeds.add_field(name=f'{data["emoji"]} {data["name"]}', value=data["description"])
if command.cog is not None:
category = command.cog.qualified_name
if isinstance(command.cog, CustomCog):
category = command.cog.emoji + ' ' + category
footer += ' · ' + category
embeds.set_footer(text=footer)
for embed in embeds.to_list():
await ctx.send(embed=embed)
async def deck_leave(self, ctx: Context, *, deck: DeckConverter = None):
literal = literals('deck_leave')
if deck is None:
if (deck := self.deck_handler.get_deck_by_channel(
ctx.channel)) is None:
await ctx.send(literal['failed'])
return
async def get_guild_profile_embed(guild: Guild, brief: bool = True):
literal = literals('get_guild_profile_embed')
online_members = (await guild.widget()).members
description = literal['description'] % (guild.region, guild.member_count)
if guild.premium_tier:
description += '\n' + literal['tier'] % guild.premium_tier
if online_members:
description += '\n' + (literal['online'] % len(online_members))
guild_embed = ChainedEmbed(title=guild.name, description=description)
guild_embed.set_author(name=literal['author'] % guild.owner.name,
icon_url=guild.owner.avatar_url)
guild_embed.set_thumbnail(url=guild.icon_url)
if not brief:
if guild.premium_subscription_count:
guild_embed.add_field(
name=literal['boost'] % guild.premium_subscription_count,
value='\n'.join(
str(subscriber)
for subscriber in guild.premium_subscribers))
guild_embed.set_footer(text=f'{to_kst(guild.created_at)} · {guild.id}')
guild_embed.set_image(url=guild.banner_url)
if guild.channels:
value = literal['category'] % len(guild.categories)
value += '\n' + literal['text_channel'] % len(guild.text_channels)
value += '\n' + literal['voice_channel'] % len(
guild.voice_channels)
guild_embed.add_field(name=literal['channel'] %
len(guild.channels),
value=value)
return guild_embed
async def yacht_help(self, ctx: Context):
literal = literals('yacht_help')
help_embed: ChainedEmbed = ChainedEmbed(
title=literal['title'], description=literal['description'])
for field in literal['fields']:
help_embed.add_field(name=field['name'], value=field['value'])
await ctx.send(embed=help_embed)
def get_application_state_emoji(application: list):
literal = literals('get_state_emoji')
if application[APPLICATION_STATE] == APPLICATION_RECEIVED:
return literal['received']
elif application[APPLICATION_STATE] == APPLICATION_APPROVED:
return literal['approved']
return literal['not_handled']
def get_chip_str(chip: int):
literal = literals('get_chip_str')
if chip > 5:
return literal['emoji'] + '**× ' + str(chip) + '**'
if chip > 0:
return literal['emoji'] * chip
return '-'
async def start(self):
literal = literals('IndianPoker.start')
await self.ctx.send(literal['start'])
winner = None
while winner is None:
winner = await self.start_round()
await self.ctx.send(literal['winner'] % winner.user.mention)
async def predicate(ctx: Context) -> bool:
deck_handler = DeckHandler(ctx.bot)
if not deck_handler.ready:
message = await ctx.send(
literals('wait_until_deck_handler_ready.predicate')['start'])
await deck_handler.wait_until_ready()
await message.delete()
return True
async def deck_refresh(self, ctx: Context):
literal = literals('deck_refresh')
message = await ctx.send(literal['start'])
if not self.deck_handler.ready:
await self.deck_handler.wait_until_ready()
else:
await self.deck_handler.fetch_decks()
await message.edit(content=literal['done'])
async def edit_deck_topic(self, ctx: Context, deck: Deck, new_topic: str):
literal = literals('edit_deck_topic')
old_topic = wrap_codeblock(deck.topic, markdown='')[0]
deck.topic = new_topic
deck_embed = await self.get_deck_embed(deck)
deck_embed.clear_fields()
deck_embed.add_field(name=literal['before'], value=old_topic)
await self.save_deck(ctx, deck, deck_embed)
async def start(self):
literal = literals('Yacht.start')
await self.player.send(literal['start'])
for _ in range(len(self.scores)):
self.round += 1
await self.start_round()
await self.player.send(literal["done"] %
(self.player.mention, self.get_total_score()))
async def change_deck_id(self, ctx: Context, deck: Deck, new_id: str):
literal = literals('change_deck_id')
old_id = '`' + deck.id + '`'
deck.id = new_id
deck_embed = await self.get_deck_embed(deck)
deck_embed.clear_fields()
deck_embed.add_field(name=literal['before'], value=old_id)
await self.save_deck(ctx, deck, deck_embed)
async def game_close(self, ctx: Context):
literal = literals('game_close')
game = Game.get_game(ctx.author)
if game is None or not game.stop():
await ctx.send(literal['not_found'])
else:
await ctx.send(
literal['done'] %
' '.join([player.mention for player in game.players]))
async def deck_start(self, ctx: Context, *, description: str):
literal = literals('deck_start')
partner_role: Role = discord.utils.get(
await self.deck_handler.guild.fetch_roles(),
id=get_constant('partner_role'))
partner_channel = await self.client.fetch_channel(
get_constant('partner_channel'))
if not isinstance(author := ctx.author, Member):
author = await self.deck_handler.guild.fetch_member(ctx.author.id)
async def regulation_all(self, ctx: Context):
literal = literals('regulation_all')
message = await ctx.send(literal['start'])
paragraphs = wrap_codeblock(doc_read(
get_constant('regulation')['doc_id']),
split_paragraph=True)
await message.edit(content=literal['done'])
for p in paragraphs:
await ctx.author.send(p)
def get_dice_embed(self, rerolled: int = 3) -> ChainedEmbed:
literal = literals('get_dice_embed')
sorted_dice = sorted(self.dice.items(), key=lambda item: item[1])
description = ' '.join([d[0] for d in sorted_dice]) + '\n' + ' '.join(
[DICE_DIE[d[1] - 1] for d in sorted_dice])
dice_embed: ChainedEmbed = ChainedEmbed(
title=literal['title'] %
(self.round, literal['rerolled'][rerolled]),
description=description)
return dice_embed
async def deck_quick_accept(self,
ctx: Context,
deck: DeckConverter = None):
literal = literals('deck_quick_accept')
if deck is None:
if (deck := self.deck_handler.get_deck_by_channel(
ctx.channel)) is None:
await ctx.send(literal['failed'])
ctx.command.reset_cooldown(ctx)
return
async def deck_end(self, ctx: Context, *, deck: DeckConverter = None):
literal = literals('deck_end')
partner_role: Role = discord.utils.get(
await self.deck_handler.guild.fetch_roles(),
id=get_constant('partner_role'))
partner_channel = await self.client.fetch_channel(
get_constant('partner_channel'))
if deck is None:
deck = await DeckConverter().convert(ctx, str(ctx.channel.id))
if not isinstance(author := ctx.author, Member):
author = await self.deck_handler.guild.fetch_member(ctx.author.id)
async def deck_list(self, ctx: Context):
literal = literals('deck_list')
list_embeds = ChainedEmbed(
title=literal['title'],
description='\n'.join([
deck.get_brief()
for deck in sorted(self.deck_handler.decks.values(),
key=lambda item: item.id)
]))
list_embeds.set_thumbnail(url=self.client.user.avatar_url)
for embed in list_embeds.to_list():
await ctx.send(embed=embed)
async def save_deck(self,
ctx: Context,
deck: Deck,
deck_embed: ChainedEmbed = None,
save: Coroutine = None):
literal = literals('save_deck')
if deck_embed is None:
deck_embed = await self.get_deck_embed(deck)
if save is None:
save = self.deck_handler.update_deck(deck)
message = await ctx.send(literal['start'], embed=deck_embed)
await save
await message.edit(content=literal['done'] % deck.name)
async def distance(self, ctx: Context):
literal = literals('distance')
nick = ctx.author.nick
if nick is None:
nick = ctx.author.name
if ' ' in nick:
nick = nick.replace(' ', '')
distance_regex = '\\u2003+'
if found := findall(distance_regex, nick):
level = len(min(found, key=len)) + 1
print(nick)
nick = sub(distance_regex, ' ' * level, nick)
print(nick)
async def deck_id(self, ctx: Context, new_id: str = ''):
if not new_id:
await self.deck_info(ctx)
ctx.command.reset_cooldown(ctx)
return
deck = await DeckConverter().convert(ctx, str(ctx.channel.id))
check_deck_manager(deck, ctx.author)
literal = literals('deck_id')
if (deck_with_same_id :=
self.deck_handler.get_deck_by_id(new_id)) is not None:
await ctx.send(literal['already'] % deck_with_same_id.name)
ctx.command.reset_cooldown(ctx)
return
async def channel_delete(self,
ctx: Context,
*,
channel: Union[TextChannel, VoiceChannel] = None):
literal = literals('channel_delete')
if channel is None:
channel = ctx.channel
deck: Deck = await DeckConverter().convert(ctx, str(channel.id))
if channel == deck.default_channel:
await ctx.send(literal['failed'])
raise BadArgument('default channel of deck is not removable')
check_deck_manager(deck, ctx.author)
await ctx.send(literal['done'] % channel.name)
await self.deck_handler.remove_channel(channel, deck)
async def search(self, ctx: Context, keyword: str, *keywords: str):
literal = literals('search')
keywords = list(keywords)
keywords.append(keyword)
description = literal['found']
embeds = ChainedEmbed(title=literal['title'], description=description)
embeds.set_thumbnail(url=self.client.user.avatar_url)
found = 0
for command in self.client.commands:
found += check_correlation(command, keywords, embeds)
embeds.description = description % (found, ', '.join(keywords)) if found \
else literal['not_found'] % ', '.join(keywords)
for embed in embeds.to_list():
await ctx.send(embed=embed)
def brief_cog(cog: Cog):
brief = literals('cog_brief')['no_description']
if cog.description is not None:
brief = cog.description
elif cog.get_commands():
brief = ''
if not cog.get_commands():
return brief
commands = ''
for command in cog.get_commands():
commands += brief_command(command) + '\n'
if commands:
brief += '\n' + commands
return brief
async def get_deck_embed(self,
deck: Deck,
brief: bool = True) -> ChainedEmbed:
literal = literals('get_deck_embed')
deck_embed = ChainedEmbed(title=literal['title'] % deck.name,
description=deck.topic)
deck_role = discord.utils.get(await
self.deck_handler.guild.fetch_roles(),
name=deck.name)
deck_members = list()
async for member in self.deck_handler.guild.fetch_members():
if deck_role in member.roles:
deck_members.append(str(member))
deck_embed.set_thumbnail(url=deck.manager.avatar_url)
deck_embed.add_field(name=literal['manager'], value=str(deck.manager))
if deck.public:
deck_embed.add_field(name=literal['public_name'],
value=literal['public_value'])
if deck.nsfw:
deck_embed.add_field(name=literal['nsfw_name'],
value=literal['nsfw_value'])
if deck.auto:
deck_embed.add_field(name=literal['auto_name'],
value=literal['auto_value'])
if deck.lock:
deck_embed.add_field(name=literal['lock_name'],
value=literal['lock_value'])
if deck.pending:
deck_embed.add_field(name=literal['pending'] % len(deck.pending),
value=' '.join(
[str(member) for member in deck.pending]))
if not brief:
if deck_members:
deck_embed.add_field(name=literal['members'] %
len(deck_members),
value='\n'.join(deck_members),
inline=True)
channels = list()
for channel in deck.category_channel.channels:
channels.append(
(literal['voice'] if isinstance(channel, VoiceChannel
) else '') +
(channel.name if channel != deck.default_channel else
f'**__{channel.name}__**'))
deck_embed.add_field(name=literal['channels'] %
len(deck.category_channel.channels),
value='\n'.join(channels),
inline=True)
deck_embed.set_footer(text=literal['id'] % deck.id)
return deck_embed
async def deck_name(self, ctx: Context, *, new_name: str = ''):
if not new_name:
await self.deck_info(ctx)
ctx.command.reset_cooldown(ctx)
return
deck = await DeckConverter().convert(ctx, str(ctx.channel.id))
check_deck_manager(deck, ctx.author)
check_length(new_name, Deck.NAME_MAX_LENGTH)
literal = literals('deck_name')
if (deck_with_same_name :=
self.deck_handler.get_deck_by_name(new_name)) is not None:
await ctx.send(literal['already'] % deck_with_same_name.name)
ctx.command.reset_cooldown(ctx)
return
