async def show(self, ctx: commands.Context):
await ctx.message.delete()
guild_settings = self.welcome_message_repo.find(ctx.guild)
em = discord.Embed(title="Current welcome message settings",
color=discord.Color.blue())
em.add_field(name="Welcome message",
value=str(guild_settings.welcome_message),
inline=False)
em.add_field(
name="Welcome channel",
value=str(
discord.utils.get(
ctx.guild.channels,
id=int(guild_settings.welcome_message_channel_id)).name)
if guild_settings.welcome_message_channel_id else "None",
inline=False)
em.add_field(name="Welcome messages status",
value="Enabled"
if guild_settings.welcome_message_enable else "Disabled",
inline=False)
add_author_footer(em, ctx.author)
await ctx.channel.send(embed=em,
delete_after=Config.base_long_success_duration)
async def flip_func(ctx: commands.Context):
embed = discord.Embed(title="Coin flip",
description=random.choice(["True", "False"]),
color=discord.Color.gold())
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed,
delete_after=Config.base_long_success_duration)
async def start_work(self, ctx: commands.Context, hours: int = 1):
await general_util.delete_message(self.bot, ctx)
if not self.player_repo.is_idle(ctx.author.id):
return await ctx.send(embed=general_util.generate_error_message(
Strings.rpg_cant_perfor_action_no_idle),
delete_after=Config.base_error_duration)
if hours < 0 or hours > 12:
return await ctx.send(embed=general_util.generate_error_message(
Strings.rpg_work_invalid_work_time),
delete_after=Config.base_error_duration)
end_date = datetime.now(tz=timezone.utc) + timedelta(hours=hours)
action = self.player_repo.create_action(ctx.author, ActionsEnum.WORK,
end_date)
reward_string = rpg_util.get_expected_rewards_string(action.rewards)
embed = discord.Embed(title="Work started",
description=reward_string,
color=discord.Color.blue())
embed.add_field(name="Duration", value=f"{hours}h")
embed.add_field(name="End time (UTC)",
value=end_date.strftime("%d.%b.%Y %H:%M"))
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed,
delete_after=Config.base_long_success_duration)
async def items_list(self, ctx: commands.Context, item_id:Optional[int]=None):
await general_util.delete_message(self.bot, ctx)
if item_id is None:
items = self.item_repo.get_all_items()
items_embeds = []
for item in items:
embed = rpg_util.generate_item_embed(item)
general_util.add_author_footer(embed, ctx.author)
items_embeds.append(embed)
if items_embeds:
p_session = PaginatorSession(self.bot, ctx, pages=items_embeds)
await p_session.run()
else:
await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_list_no_items), delete_after=Config.base_error_duration)
else:
item = self.item_repo.get_item_by_id(item_id)
if item is None:
return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_item_not_found", id=item_id)), delete_after=Config.base_error_duration)
embed = rpg_util.generate_item_embed(item)
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def action_rewards_list(self, ctx: commands.Context, action_id: Optional[int] = None):
await general_util.delete_message(self.bot, ctx)
if action_id is not None:
if action_id not in ActionsEnum.val_list():
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_list_actions_rewards_invalid_action_id), delete_after=Config.base_error_duration)
action_rewards = self.rewards_repo.get_action_rewards(action_id)
number_of_rewards = len(action_rewards)
number_of_pages = math.ceil(number_of_rewards / 20)
batches = [action_rewards[i * 20: i * 20 + 20] for i in range(number_of_pages)]
pages = []
for batch in batches:
embed = discord.Embed(title="Action rewards list", color=discord.Color.dark_blue())
general_util.add_author_footer(embed, ctx.author)
for reward in batch:
if reward.reward is not None:
embed.add_field(name=f"ID: {reward.reward.id} - {ActionsEnum.get_name(reward.action_id)}", value=rpg_util.reward_to_string(reward.reward))
pages.append(embed)
if pages:
p_session = PaginatorSession(self.bot, ctx, pages=pages)
await p_session.run()
else:
await ctx.send(embed=general_util.generate_error_message(Strings.rpg_list_actions_rewards_no_rewards), delete_after=Config.base_error_duration)
async def role_giver_list(self, ctx: commands.Context):
await general_util.delete_message(self.bot, ctx)
role_givers = self.role_giver_repo.get_guild_role_givers(ctx.guild.id)
if not role_givers:
embed = discord.Embed(title="Title giver list",
description="*No title givers*",
color=discord.Color.orange())
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed,
delete_after=Config.base_long_success_duration)
else:
pages = []
guild: discord.Guild = ctx.guild
for role_giver in role_givers:
embed = discord.Embed(title=role_giver.title,
description=role_giver.description,
color=discord.Color.blurple())
general_util.add_author_footer(embed, ctx.author)
channel: Union[discord.Guild, None] = guild.get_channel(
int(role_giver.channel_ID)
) if role_giver.channel_ID is not None else None
embed.add_field(name="Channel",
value=channel.name
if channel is not None else "*No channel*")
embed.add_field(name="Enabled",
value="Yes" if role_giver.enabled else "No")
roles = None
role_ids = role_giver.role_IDs.split(";") if (
role_giver.role_IDs is not None
and role_giver.role_IDs != "") else None
if role_ids:
roles = [
guild.get_role(int(role_id)) for role_id in role_ids
]
roles = [role.name for role in roles if role is not None]
roles = (
"\n".join(roles)) if roles is not None else "*No roles*"
roles_splits = general_util.split_to_parts(roles, 1000)
if len(roles_splits) == 1:
embed.add_field(name="Roles", value=roles_splits[0])
else:
for idx, role_split in enumerate(roles_splits):
embed.add_field(name=f"Roles {idx + 1}",
value=role_split)
embed.add_field(name="ID", value=str(role_giver.id))
pages.append(embed)
p_session = PaginatorSession(self.bot,
ctx,
Config.base_long_success_duration,
pages=pages)
await p_session.run()
async def _bot(self, ctx):
em = discord.Embed(color=discord.Color.green(), title='Bot Info')
em.description = 'Universal bot made by MatesXs using Pycord.py'
em.add_field(name="Servers", value=str(len(self.bot.guilds)))
em.add_field(name='Total Users', value=str(len(self.bot.users)))
em.add_field(
name='Channels',
value=f"{sum(1 for g in self.bot.guilds for _ in g.channels)}")
em.add_field(name="Library",
value=f"[disnake](https://github.com/DisnakeDev/disnake)")
em.add_field(name="Bot Latency",
value=f"{round(self.bot.latency * 1000)} ms")
em.add_field(name="Uptime",
value=humanize.naturaldelta(datetime.datetime.utcnow() -
self.start_date))
if Config.enable_invite_link:
em.add_field(
name="Invite",
value=
f"[Click Here](https://discordapp.com/oauth2/authorize?client_id={self.bot.user.id}&scope=bot%20applications.commands&permissions=8)"
)
else:
em.add_field(name="Invite", value=f"WIP")
general_util.add_author_footer(em, ctx.message.author)
await general_util.delete_message(self.bot, ctx)
await ctx.channel.send(embed=em,
delete_after=Config.base_long_success_duration)
async def get_action(self, ctx: commands.Context):
await general_util.delete_message(self.bot, ctx)
action = self.player_repo.get_action(ctx.author.id)
embed = discord.Embed(title="Current action",
color=discord.Color.blue())
if action is None:
embed.description = "*No action*"
else:
if action.rewards:
rewards_str = rpg_util.get_expected_rewards_string(
action.rewards)
if rewards_str != "":
embed.description = rewards_str
embed.add_field(name="Action type",
value=ActionsEnum.get_name(action.action_id))
embed.add_field(name="Remaining time",
value=humanize.naturaldelta(
action.end_date.replace(tzinfo=timezone.utc) -
datetime.now(tz=timezone.utc)))
embed.add_field(name="End time (UTC)",
value=action.end_date.strftime("%d.%b.%Y %H:%M"))
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed,
delete_after=Config.base_long_success_duration)
async def get_player(self,
ctx: commands.Context,
*,
player: Optional[Union[discord.Member, discord.User,
int]] = None):
await general_util.delete_message(self.bot, ctx)
if player is None:
player = ctx.author
elif isinstance(player, int):
player = await general_util.get_user(self.bot, player)
if player is None:
return ctx.send(embed=general_util.generate_error_message(
Strings.rpg_player_get_player_doesnt_exist),
delete_after=Config.base_error_duration)
db_player = self.player_repo.get_player(player)
embed = discord.Embed(title=f"{player.display_name} profile",
color=discord.Color.blue())
embed.set_thumbnail(
url=player.display_avatar.url if player.
display_avatar is not None else player.default_avatar.url)
embed.add_field(name="Level", value=str(db_player.level))
embed.add_field(name="XP", value=str(db_player.xp))
embed.add_field(
name="XP to level",
value=str(
rpg_util.get_next_level_xp_requirement(db_player.level) -
db_player.xp))
embed.add_field(name="Coins", value=str(db_player.money))
embed.add_field(name="Energy", value=str(db_player.energy))
embed.add_field(
name="Inventory",
value=
f"{self.player_repo.get_current_size_of_inventory(player.id)}/{rpg_util.get_inventory_size(db_player.level)}"
)
embed.add_field(name="Action",
value=ActionsEnum.get_name(db_player.action.action_id)
if db_player.action is not None else "None")
if db_player.action is not None:
embed.add_field(
name="Remaining time",
value=humanize.naturaldelta(
db_player.action.end_date.replace(tzinfo=timezone.utc) -
datetime.now(tz=timezone.utc)))
embed.add_field(
name="Return time (UTC)",
value=db_player.action.end_date.strftime("%d.%b.%Y %H:%M"))
if db_player.action.rewards:
rewards_str = rpg_util.get_expected_rewards_string(
db_player.action.rewards, length_limit=1000, header=False)
if rewards_str != "":
embed.add_field(name="Action reward", value=rewards_str)
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed,
delete_after=Config.base_long_success_duration)
async def reposter_show(self, ctx: commands.Context):
await general_util.delete_message(self.bot, ctx)
settings = self.repost_settings_repo.get_repost_settings(ctx.guild.id)
if settings is None:
embed = discord.Embed(title="Content reposter", description="*There is no content reposter*", color=discord.Color.orange())
general_util.add_author_footer(embed, ctx.author)
return await ctx.send(embed=embed, delete_after=Config.base_error_duration)
embed = discord.Embed(title="Content reposter", description="**Enabled**" if settings.enabled else "**Disabled**", color=discord.Color.dark_blue())
general_util.add_author_footer(embed, ctx.author)
repost_channel = await general_util.get_text_channel(ctx.guild, int(settings.repost_channel_id))
repost_channel_name = repost_channel.name if repost_channel is not None else "*Invalid*"
embed.add_field(name="Repost channel", value=repost_channel_name)
mode = "Whitelist" if not settings.blacklist_mode else "Blacklist"
embed.add_field(name="Mode", value=mode)
channels_title = "Blacklisted channels" if settings.blacklist_mode else "Whitelisted channels"
if settings.mode_channel_ids is not None and settings.mode_channel_ids != "":
channels_ids_string = settings.mode_channel_ids if settings.mode_channel_ids is not None else ""
channel_ids = [int(chan_id) for chan_id in channels_ids_string.split(";") if chan_id != ""]
channels_future = [general_util.get_text_channel(ctx.guild, chan_id) for chan_id in channel_ids]
channels_result = await asyncio.gather(*channels_future)
channels_result = [chan for chan in channels_result if chan is not None]
channel_names = [chan.name for chan in channels_result]
channel_names_print_string, _ = general_util.add_string_until_length(channel_names, 1000, "\n")
test_database_ids = [str(chan.id) for chan in channels_result]
test_database_string = ";".join(test_database_ids)
if test_database_ids != settings.mode_channel_ids:
# Modify database
settings.mode_channel_ids = test_database_string
self.repost_settings_repo.update()
embed.add_field(name=channels_title, value=channel_names_print_string)
else:
embed.add_field(name=channels_title, value="*No channels set*")
if not settings.any_emoji:
emoji_ids = settings.emoji_ids.split(";") if settings.emoji_ids is not None else []
emojis = []
for emoji_id in emoji_ids:
tmp_emoji = general_util.get_emoji_from_id(emoji_id, ctx.guild, self.bot)
if tmp_emoji is not None:
emojis.append(tmp_emoji)
else:
emojis.append(emoji_id)
emojis = [str(emoji) for emoji in emojis if emoji is not None]
emojis_string, _ = general_util.add_string_until_length(emojis, 1000, "\n")
if emojis_string == "":
emojis_string = "*No emojis*"
embed.add_field(name="Emojis", value=emojis_string)
else:
embed.add_field(name="Emojis", value="Any")
embed.add_field(name="Emojis threshold", value=str(settings.emoji_threshold))
await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def role_giver_enable(self, ctx: commands.Context,
role_giver_id: int):
await general_util.delete_message(self.bot, ctx)
role_giver = self.role_giver_repo.get_role_giver_by_id(role_giver_id)
if role_giver is None:
return await ctx.send(embed=general_util.generate_error_message(
Strings.role_giver_doesnt_exist),
delete_after=Config.base_error_duration)
if role_giver.guild_ID != str(ctx.guild.id):
return await ctx.send(embed=general_util.generate_error_message(
Strings.role_giver_doesnt_belong_to_this_guild),
delete_after=Config.base_error_duration)
if role_giver.enabled:
return await ctx.send(embed=general_util.generate_error_message(
Strings.role_giver_enable_already_enabled),
delete_after=Config.base_error_duration)
if role_giver.role_IDs is None or role_giver.role_IDs == "":
return await ctx.send(embed=general_util.generate_error_message(
Strings.role_giver_enable_no_roles),
delete_after=Config.base_error_duration)
if role_giver.channel_ID is None:
return await ctx.send(embed=general_util.generate_error_message(
Strings.role_giver_enable_no_channel),
delete_after=Config.base_error_duration)
channel = await general_util.get_text_channel(
ctx.guild, int(role_giver.channel_ID))
if channel is None:
return await ctx.send(embed=general_util.generate_error_message(
Strings.role_giver_enable_no_channel),
delete_after=Config.base_error_duration)
embed, number_of_roles = await generate_role_giver(
role_giver, ctx.guild)
if number_of_roles == 0:
return await ctx.send(embed=general_util.generate_error_message(
Strings.role_giver_enable_no_roles),
delete_after=Config.base_error_duration)
general_util.add_author_footer(embed, ctx.author)
instance_message = await ctx.send(embed=embed)
for i in range(number_of_roles):
await instance_message.add_reaction(reactions[i])
role_giver.instance_message_ID = str(instance_message.id)
role_giver.enabled = True
self.role_giver_repo.update()
await ctx.send(embed=general_util.generate_success_message(
Strings.populate_string("role_giver_enable_success",
id=role_giver.id)),
delete_after=Config.base_success_duration)
async def handle_reaction_add(self, ctx: ReactionContext):
if self.bot.user.id in (ctx.member.id, ctx.message.author.id):
return
if not isinstance(ctx.emoji, str):
return
if ctx.emoji not in self.flag_to_code.keys():
return
if ctx.guild.id in self.guilds_usage.keys() and self.guilds_usage[
ctx.guild.id] >= Config.translate_usage_limit_per_10_mins:
return await ctx.channel.send(
embed=general_util.generate_error_message(
Strings.populate_string(
"translate_on_cooldown",
limit=Config.translate_usage_limit_per_10_mins)),
delete_after=Config.base_error_duration)
if self.translator.get_usage().any_limit_exceeded:
return await ctx.channel.send(
embed=general_util.generate_error_message(
Strings.translate_api_limit_exceeded),
delete_after=Config.base_error_duration)
trg_lan = self.flag_to_code[ctx.emoji]
if trg_lan.upper() not in self.supp_list:
return await ctx.channel.send(
embed=general_util.generate_error_message(
Strings.translate_unsupported_language),
delete_after=Config.base_error_duration)
if ctx.message.content is not None and ctx.message.content != "":
if len(ctx.message.content) > 1000:
return await ctx.channel.send(
embed=general_util.generate_error_message(
Strings.populate_string(
"translate_message_too_large",
message_url=ctx.message.jump_url)),
delete_after=Config.base_error_duration)
if ctx.guild.id in self.guilds_usage.keys():
self.guilds_usage[ctx.guild.id] += 1
else:
self.guilds_usage[ctx.guild.id] = 1
result = str(
self.translator.translate_text(ctx.message.content,
target_lang=trg_lan.upper()))
translate_result = discord.Embed(
color=discord.Color.dark_blue(),
description=str(result) +
f"\n\n[Original]({ctx.message.jump_url})",
title=f"Translation to {trg_lan.upper()}")
general_util.add_author_footer(translate_result, ctx.member)
await ctx.channel.send(embed=translate_result)
async def show_effect_enum(self, ctx: commands.Context):
await general_util.delete_message(self.bot, ctx)
effects = []
for effect in EffectEnum:
effects.append(f"{effect.value}: {effect.name}")
description, _ = general_util.add_string_until_length(effects, 4000, "\n")
embed = discord.Embed(title="Available effects", description=description, color=discord.Color.dark_blue())
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def languages(self, ctx: commands.Context):
await ctx.message.delete()
response = discord.Embed(title="Translation supported languages",
color=discord.Color.dark_blue())
general_util.add_author_footer(response, ctx.author)
for lang in self.translator.get_target_languages():
response.add_field(name=f"{lang.name}", value=f"{lang.code}")
await ctx.send(embed=response,
delete_after=Config.base_long_success_duration)
async def ping(self, ctx: commands.Context):
await general_util.delete_message(self.bot, ctx)
em = discord.Embed(color=discord.Color.green(), title="Pong!")
general_util.add_author_footer(em, ctx.message.author)
start_time = time.time()
message: discord.Message = await ctx.channel.send(embed=em)
end_time = time.time()
em.description = em.description = f'Bot: {round(self.bot.latency * 1000)} ms\nAPI: {round((end_time - start_time) * 1000)}ms'
await message.edit(embed=em, delete_after=Config.base_success_duration)
async def invite(self, ctx):
emb = discord.Embed(title='Invite Link',
colour=discord.Color.dark_blue())
invite_link = f"https://discordapp.com/oauth2/authorize?client_id={self.bot.user.id}&scope=bot%20applications.commands&permissions=8"
logger.info(invite_link)
if Config.enable_invite_link:
emb.description = f'[Click Here]({invite_link})'
else:
emb.description = "WIP"
general_util.add_author_footer(emb, ctx.message.author)
await ctx.send(embed=emb)
def generate_help_for_cog(
cog: Base_Cog,
ctx: commands.Context) -> Union[None, List[discord.Embed]]:
if cog.hidden and ctx.author.id not in Config.developer_ids: return None
coms = [
com for com in cog.walk_commands()
if isinstance(com, commands.Command) and not com.hidden
and command_check(com, ctx)
]
number_of_coms = len(coms)
if number_of_coms == 0: return None
pages = []
if number_of_coms > Config.help_number_per_page:
number_of_batches = math.ceil(number_of_coms /
Config.help_number_per_page)
batches = [
coms[i *
Config.help_number_per_page:i * Config.help_number_per_page +
Config.help_number_per_page] for i in range(number_of_batches)
]
for idx, batch in enumerate(batches):
emb = discord.Embed(
title=
f'{str(cog.qualified_name).replace("_", " ")} {idx + 1} Help',
colour=discord.Color.green())
general_util.add_author_footer(emb, ctx.author)
for com in batch:
add_command_help(emb, com)
if len(emb) > 6000:
logger.warning(f"Help for {cog.qualified_name} is too long")
else:
pages.append(emb)
else:
emb = discord.Embed(title=f'{str(cog.qualified_name)} Help',
colour=discord.Color.green())
general_util.add_author_footer(emb, ctx.author)
for com in coms:
add_command_help(emb, com)
if len(emb) > 6000:
logger.warning(f"Help for {cog.qualified_name} is too long")
else:
pages.append(emb)
return pages
async def create_item(self, ctx: commands.Context, name:str, level_req:int, rarity:int, *, additional_info:Optional[str]=None):
await general_util.delete_message(self.bot, ctx)
name = name.replace("_", " ")
if level_req < 0:
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_invalid_level_req), delete_after=Config.base_error_duration)
if rarity not in RarityEnum.val_list():
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_invalid_rarity), delete_after=Config.base_error_duration)
description = None
icon_path = None
item_slot = None
sell_value = None
if additional_info is not None:
additional_info_parts = additional_info.split(";")
for add_inf_part in additional_info_parts:
info_pair = add_inf_part.split(":")
key = info_pair[0]
val = info_pair[1]
if key == "description":
description = val
elif key == "icon_path":
icon_path = val
elif key == "slot":
if not val.isnumeric():
return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_items_create_key_not_numeric", key=key)), delete_after=Config.base_error_duration)
val = int(val)
if val not in ItemSlotEnum.val_list():
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_invalid_slot), delete_after=Config.base_error_duration)
item_slot = val
elif key == "sell_value":
if not val.isnumeric():
return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_items_create_key_not_numeric", key=key)), delete_after=Config.base_error_duration)
val = int(val)
if val < 0:
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_sell_value_negative), delete_after=Config.base_error_duration)
sell_value = val
item = self.item_repo.create_item(name, level_req, rarity, description=description, icon_path=icon_path, item_slot=item_slot, sell_value=sell_value)
embed = rpg_util.generate_item_embed(item)
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def actions_list(self, ctx: commands.Context):
await general_util.delete_message(self.bot, ctx)
action_index_list = ActionsEnum.val_list()
actions_parts = []
for action_val in action_index_list:
actions_parts.append(f"**{action_val}**: {ActionsEnum.get_name(action_val)}")
actions_string, _ = general_util.add_string_until_length(actions_parts, 4000, "\n")
embed = discord.Embed(title="List of actions", color=discord.Color.dark_blue(), description=actions_string)
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def add_action_reward(self, ctx: commands.Context, action_id: Union[int, str], probability: float, *, content_string: str):
await general_util.delete_message(self.bot, ctx)
if isinstance(action_id, str):
if action_id.isnumeric():
action_id = int(action_id)
else:
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_action_id_invalid), delete_after=Config.base_error_duration)
if action_id not in ActionsEnum.val_list():
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_action_id_invalid), delete_after=Config.base_error_duration)
action = ActionsEnum(action_id)
if probability > 100 or probability < 0:
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_invalid_probability), delete_after=Config.base_error_duration)
item_id = None
xp = None
money = None
contents = content_string.split(";")
for content in contents:
parts = content.split(":")
if len(parts) != 2: return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_invalid_content_string_format), delete_after=Config.base_error_duration)
key = parts[0].lower()
value = parts[1]
if not value.isnumeric(): return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key)))
value = int(value)
if key == "item":
item = self.item_repo.get_item_by_id(value)
if item is None: return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key)))
item_id = item.id
elif key == "xp":
if value < 0: return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key)))
xp = value
elif key == "money":
if value < 0: return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key)))
money = value
else:
return
reward = self.rewards_repo.create_action_reward(action_id, probability, item=item_id, xp=xp, money=money)
embed = discord.Embed(title=f"Action reward added for {action.name}", color=discord.Color.green(), description=rpg_util.reward_to_string(reward.reward))
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
def __generate_pool(self):
embed = discord.Embed(title=self.title, color=discord.Color.gold())
general_util.add_author_footer(embed, self.ctx.author)
embed.add_field(name="Pool duration", value=f"{self.timeout}min")
embed.add_field(name="Minimum votes", value=str(self.minimum_votes))
description = (self.description +
"\n\n") if self.description != "" else ""
for question, reaction in zip(self.choices, reactions):
description += f"{reaction}: {question}\n"
assert len(description) < 4095, "Too large description"
embed.description = description
return embed
async def create_effect(self, ctx: commands.Context, item_id:int, effect_id:int, ammount:int):
await general_util.delete_message(self.bot, ctx)
if not self.item_repo.item_exist(item_id):
return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_item_not_found", id=item_id)), delete_after=Config.base_error_duration)
if effect_id not in EffectEnum.val_list():
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_effect_create_invalid_effect_id), delete_after=Config.base_error_duration)
effect = self.item_repo.create_effect(item_id, effect_id, ammount)
embed = rpg_util.generate_effect_embed(effect)
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def clear_actions(self, ctx: commands.Context):
await general_util.delete_message(self.bot, ctx)
if self.player_repo.is_idle(ctx.author.id):
return await ctx.send(embed=general_util.generate_error_message(
Strings.rpg_return_already_idle),
delete_after=Config.base_error_duration)
self.player_repo.delete_action(ctx.author.id)
embed = discord.Embed(
title=f"{ctx.author.display_name} returned back",
description="*Returned home from journey without reward*",
color=discord.Color.blue())
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed,
delete_after=Config.base_long_success_duration)
async def process_reminder_creation(self, ctx: commands.Context,
author: Union[discord.User,
discord.Member, None],
date: str, time: str, message: str):
date_splits = date.split(".")
time_splits = time.split(":")
date_obj = parse_date_splits(date_splits, time_splits)
if date_obj is None:
return await ctx.send(embed=general_util.generate_error_message(
Strings.reminder_invalid_time_or_date_format),
delete_after=Config.base_error_duration)
if (datetime.utcnow() + timedelta(minutes=1)) > date_obj:
return await ctx.send(embed=general_util.generate_error_message(
Strings.reminder_date_in_past),
delete_after=Config.base_error_duration)
message = general_util.split_to_parts(message, 3000)[0]
embed = discord.Embed(title="Creating reminder",
color=discord.Color.orange())
general_util.add_author_footer(embed, ctx.author)
resp_msg = await ctx.send(embed=embed)
reminder = self.reminder_repo.create_reminder(resp_msg.id,
ctx.channel.id, author,
date_obj, message)
if reminder is None:
return await resp_msg.edit(
embed=general_util.generate_error_message(
"Failed to create new reminder"),
delete_after=Config.base_error_duration)
embed = generate_reminder_embed(
reminder, "⏰ Reminder created ⏰",
"\n\nReact with 🙋 to subscribe for this reminder"
if ctx.guild is not None else None)
general_util.add_author_footer(embed, ctx.author)
await resp_msg.edit(embed=embed)
if ctx.guild is not None:
await resp_msg.add_reaction("🙋")
self.reminder_force_update = True
async def list_effects(self, ctx: commands.Context, item_id:Optional[int]=None):
await general_util.delete_message(self.bot, ctx)
effects = self.item_repo.get_all_effects(item_id)
if not effects:
return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_effect_no_effects), delete_after=Config.base_error_duration)
pages = [general_util.add_author_footer(rpg_util.generate_effect_embed(effect), ctx.author) for effect in effects]
p_session = PaginatorSession(self.bot, ctx, pages=pages)
await p_session.run()
async def weather_slash(
self,
inter: discord.CommandInteraction,
where: str = commands.Param(description="Place where show weather"),
when: str = commands.Param(
autocomplete=when_autocomplete,
default="UTC Now",
description="UTC Time offset of weather prediction")):
when = when.lower()
if when == "utc now":
time = timestamps.now()
elif when == "utc tomorrow":
time = timestamps.tomorrow()
else:
if when.isnumeric():
when = int(when)
else:
if when[-1] != "h":
return await inter.send(
embed=general_util.generate_error_message(
Strings.weather_slash_invalid_when_format),
delete_after=Config.base_error_duration)
when = int(when[:-1])
time = timestamps.now() + timestamps.timedelta(hours=when)
try:
weather = self.get_time_specific_weather(where, time)
except commands.CommandOnCooldown:
return await inter.send(embed=general_util.generate_error_message(
Strings.weather_api_reached_minute_limit),
delete_after=Config.base_error_duration)
if weather is None:
return await inter.send(embed=general_util.generate_error_message(
Strings.populate_string("weather_failed_to_get_weather",
place=where)),
delete_after=Config.base_error_duration)
embed = generate_weather_embed(weather, where)
general_util.add_author_footer(embed, inter.author)
await inter.send(embed=embed)
async def weather_now(self, ctx: commands.Context, *, place: str):
await general_util.delete_message(self.bot, ctx)
try:
weather = self.get_time_specific_weather(place, timestamps.now())
except commands.CommandOnCooldown:
return await ctx.send(embed=general_util.generate_error_message(
Strings.weather_api_reached_minute_limit),
delete_after=Config.base_error_duration)
if weather is None:
return await ctx.send(embed=general_util.generate_error_message(
Strings.populate_string("weather_failed_to_get_weather",
place=place)),
delete_after=Config.base_error_duration)
embed = generate_weather_embed(weather, place)
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed)
async def _send_result(ctx: commands.Context, result: dict, src: str):
if "message" in result:
# There is error in code execution
return await ctx.send(embed=general_util.generate_error_message(
result["message"]),
delete_after=Config.base_error_duration)
output = result["output"]
output = general_util.split_to_parts(output, 1000)
desc = ("**Output shortened**\n"
if len(output) > 1 else "") + f"*{src}*"
embed = discord.Embed(title=f"Ran your {result['language']} code",
color=discord.Color.green(),
description=desc)
embed.add_field(name="Output", value=output[-1])
general_util.add_author_footer(embed, ctx.author)
await ctx.send(embed=embed)
async def translate(self, ctx: commands.Context, target_language: str, *,
text: str):
if len(text) > 1000:
return await ctx.send(embed=general_util.generate_error_message(
Strings.populate_string("translate_message_too_large",
message_url=ctx.message.jump_url)),
delete_after=Config.base_error_duration)
if ctx.guild.id in self.guilds_usage.keys() and self.guilds_usage[
ctx.guild.id] >= Config.translate_usage_limit_per_10_mins:
return await ctx.send(embed=general_util.generate_error_message(
Strings.populate_string(
"translate_on_cooldown",
limit=Config.translate_usage_limit_per_10_mins)),
delete_after=Config.base_error_duration)
if target_language.upper() not in self.supp_list:
return await ctx.send(embed=general_util.generate_error_message(
Strings.translate_unsupported_language),
delete_after=Config.base_error_duration)
if self.translator.get_usage().any_limit_exceeded:
return await ctx.send(embed=general_util.generate_error_message(
Strings.translate_api_limit_exceeded),
delete_after=Config.base_error_duration)
if ctx.guild.id in self.guilds_usage.keys():
self.guilds_usage[ctx.guild.id] += 1
else:
self.guilds_usage[ctx.guild.id] = 1
result = str(
self.translator.translate_text(
text, target_lang=target_language.upper()))
translate_result = discord.Embed(
color=discord.Color.dark_blue(),
description=str(result) +
f"\n\n[Original]({ctx.message.jump_url})",
title=f"Translation to {target_language.upper()}")
general_util.add_author_footer(translate_result, ctx.author)
await ctx.send(embed=translate_result)
async def get_inventory(self, ctx: commands.Context, simple: bool = False):
await general_util.delete_message(self.bot, ctx)
inventory = self.player_repo.get_inventory(ctx.author.id)
if not inventory:
embed = discord.Embed(title=f"{ctx.author.display_name} Inventory",
description="*Your inventory is empty*",
color=discord.Color.blue())
return await ctx.send(
embed=embed, delete_after=Config.base_long_success_duration)
if simple:
parts = []
for inventory_slot in inventory:
parts.append(
rpg_util.generate_simple_item_text(inventory_slot.item))
pages = []
while parts:
final_string, parts = general_util.add_string_until_length(
parts, 4000, "\n")
page = discord.Embed(
title=f"{ctx.author.display_name} Inventory",
description=final_string,
color=discord.Color.blue())
general_util.add_author_footer(page, ctx.author)
pages.append(page)
else:
pages = []
for inventory_slot in inventory:
embed = rpg_util.generate_item_embed(inventory_slot.item)
embed.title = f"{ctx.author.display_name} Inventory\n{inventory_slot.item.name}"
general_util.add_author_footer(embed, ctx.author)
pages.append(embed)
p_session = PaginatorSession(self.bot,
ctx,
timeout=Config.base_long_success_duration,
pages=pages)
await p_session.run()
