async def set(self, ctx, pref: str, value: str):
"""!settings set [pref] [value]
Admin powers required"""
language = prefs.getPref(ctx.message.server, "language")
if pref in commons.defaultSettings.keys():
try:
if pref == "ducks_per_day":
maxCJ = int(125 + (ctx.message.server.member_count / (5 + (ctx.message.server.member_count / 300))))
if int(value) > maxCJ:
if ctx.message.author.id in commons.owners:
await comm.message_user(ctx.message, _("Bypassing the max_ducks_per_day check as you are the bot owner. It would have been `{max}`.", language).format(**{
"max": maxCJ
}))
else:
value = maxCJ
except (TypeError, ValueError):
await comm.message_user(ctx.message, _(":x: Incorrect value.", language))
return
if prefs.setPref(ctx.message.server, pref=pref, value=value):
if pref == "ducks_per_day":
await ducks.planifie(ctx.message.channel)
await comm.message_user(ctx.message, _(":ok: The setting {pref} has been set to `{value}` on this server.", language).format(**{
"value": prefs.getPref(ctx.message.server, pref),
"pref" : pref
}))
else:
await comm.message_user(ctx.message, _(":x: Incorrect value.", language))
else:
await comm.message_user(ctx.message, _(":x: Invalid preference, maybe a typo? Check the list with `!settings list`", language))
def addToStat(channel, player, stat, value, announce=True):
cond = stat == "exp" and prefs.getPref(channel.server,
"announce_level_up") and announce
if cond:
ancien_niveau = getPlayerLevel(channel, player)
setStat(channel, player, stat, int(getStat(channel, player, stat)) + value)
if cond:
language = prefs.getPref(channel.server, "language")
embed = discord.Embed(
description=_("Level of {player} on #{channel}", language).format(
**{
"player": player.name,
"channel": channel.name
}))
level = getPlayerLevel(channel, player)
if ancien_niveau["niveau"] > level["niveau"]:
embed.title = _("You leveled down!", language)
embed.colour = discord.Colour.red()
elif ancien_niveau["niveau"] < level["niveau"]:
embed.title = _("You leveled up!", language)
embed.colour = discord.Colour.green()
else:
return
embed.set_thumbnail(url=player.avatar_url if player.
avatar_url else commons.bot.user.avatar_url)
embed.url = 'https://api-d.com/'
embed.add_field(name=_("Current level", language),
value=str(level["niveau"]) + " (" +
_(level["nom"], language) + ")")
embed.add_field(name=_("Previous level", language),
value=str(ancien_niveau["niveau"]) + " (" +
_(ancien_niveau["nom"], language) + ")")
embed.add_field(name=_("Shots accuracy", language),
value=str(level["precision"]))
embed.add_field(name=_("Weapon fiability", language),
value=str(level["fiabilitee"]))
embed.add_field(name=_("Exp points", language),
value=str(getStat(channel, player, "exp")))
embed.set_footer(
text='DuckHunt V2',
icon_url='http://api-d.com/snaps/2016-11-19_10-38-54-q1smxz4xyq.jpg'
)
try:
commons.bot.loop.create_task(
commons.bot.send_message(channel, embed=embed))
except:
commons.logger.exception("error sending embed, with embed " +
str(embed.to_dict()))
commons.bot.loop.create_task(
commons.bot.send_message(
channel,
_(
":warning: There was an error while sending the embed, please check if the bot has the `embed_links` permission and try again!",
language)))
async def listm(self, ctx):
"""!settings modified"""
language = prefs.getPref(ctx.message.server, "language")
defaultSettings = commons.defaultSettings
x = PrettyTable()
x._set_field_names([
_("Parameter", language),
_("Value", language),
_("Default value", language)
])
for param in defaultSettings.keys():
if prefs.getPref(ctx.message.server,
param) != defaultSettings[param]["value"]:
x.add_row([
param,
prefs.getPref(ctx.message.server, param),
defaultSettings[param]["value"]
])
await comm.message_user(
ctx.message,
_("List of modified parameters : \n```{table}```",
language).format(
**{"table": x.get_string(sortby=_("Parameter", language))}))
async def view(self, ctx, pref: str):
"""!settings view [pref]"""
language = prefs.getPref(ctx.message.server, "language")
if pref in commons.defaultSettings.keys():
await comm.message_user(ctx.message, _("The {pref} setting's value is set to `{value}` on this server.", language).format(**{
"value": prefs.getPref(ctx.message.server, pref),
"pref" : pref
}))
else:
await comm.message_user(ctx.message, _(":x: Invalid preference, maybe a typo? Check the list with `!settings list`.", language))
async def planifie(channel_obj: discord.Channel = None):
now = int(time.time())
thisDay = now - (now % 86400)
seconds_left = 86400 - (now - thisDay)
multiplicator = round(seconds_left / 86400, 5)
if not channel_obj:
logger.debug("Replanning")
commons.bread = defaultdict(int)
planification_ = {}
if multiplicator == 0:
multiplicator = 1
servers = prefs.JSONloadFromDisk("channels.json")
for server_ in list(servers.keys()):
server = bot.get_server(str(server_))
if not server:
logger.debug("Non-existant server: " + str(server_))
servers.pop(server_)
scores.delServerPlayers(sid=server_)
elif not "channels" in servers[server.id]:
await comm.logwithinfos(server.default_channel, log_str="Server not configured: " + server.id)
try:
await bot.send_message(server, "The bot is not configured properly, please check the config or contact Eyesofcreeper#4758 | https://discord.gg/2BksEkV")
await comm.logwithinfos(server.default_channel, log_str="Unconfigured message sent...")
except:
await comm.logwithinfos(server.default_channel, log_str="Error sending the unconfigured message to the default channel on the server.")
else:
for channel_ in servers[server.id]["channels"]:
channel = server.get_channel(str(channel_))
if channel:
permissions = channel.permissions_for(server.me)
if permissions.read_messages and permissions.send_messages:
# logger.debug("Adding channel: {id} ({ducks_per_day} c/j)".format(**{
# "id" : channel.id,
# "ducks_per_day": prefs.getPref(server, "ducks_per_day")
# }))
planification_[channel] = round(prefs.getPref(server, "ducks_per_day") * multiplicator)
else:
await comm.logwithinfos(channel, log_str="Error adding channel to planification: no read/write permissions!")
else:
pass
commons.ducks_planned = planification_ # {"channel":[time objects]}
prefs.JSONsaveToDisk(servers, "channels.json")
else:
commons.bread[channel_obj] = 0
permissions = channel_obj.permissions_for(channel_obj.server.me)
if permissions.read_messages and permissions.send_messages:
pass
else:
await comm.logwithinfos(channel_obj, log_str="Error adding channel to planification: no read/write permissions!")
commons.ducks_planned[channel_obj] = round(prefs.getPref(channel_obj.server, "ducks_per_day") * multiplicator)
async def reset(self, ctx, pref: str):
"""!settings reset [pref]
Admin powers required"""
language = prefs.getPref(ctx.message.server, "language")
if pref in commons.defaultSettings.keys():
prefs.setPref(ctx.message.server, pref)
await comm.message_user(ctx.message, _(":ok: The setting {pref} has been reset to its defalut value: `{value}`.", language).format(**{
"value": prefs.getPref(ctx.message.server, pref),
"pref" : pref
}))
else:
await comm.message_user(ctx.message, _(":x: Invalid preference, maybe a typo? Check the list with `!settings list`", language))
async def reload(self, ctx):
await self.giveBackIfNeeded(ctx.message)
message = ctx.message
language = prefs.getPref(message.server, "language")
if scores.getStat(message.channel, message.author, "confisque", default=False):
await comm.message_user(message, _("Your weapon is confiscated.", language))
return
if scores.getStat(message.channel, message.author, "enrayee", default=False):
await comm.message_user(message, _("You unjammed your weapon.", language))
scores.setStat(message.channel, message.author, "enrayee", False)
# TODO : simplifier
if scores.getStat(message.channel, message.author, "balles", default=scores.getPlayerLevel(message.channel, message.author)["balles"]) > 0:
return
if scores.getStat(message.channel, message.author, "balles", default=scores.getPlayerLevel(message.channel, message.author)["balles"]) <= 0:
if scores.getStat(message.channel, message.author, "chargeurs", default=scores.getPlayerLevel(message.channel, message.author)["chargeurs"]) > 0:
scores.setStat(message.channel, message.author, "balles", scores.getPlayerLevel(message.channel, message.author)["balles"])
scores.addToStat(message.channel, message.author, "chargeurs", -1)
scores.addToStat(message.channel, message.author, "reloads", 1)
greet = _("You reloaded your weapon.", language)
else:
greet = _("You don't have any ammo left!", language)
scores.addToStat(message.channel, message.author, "reloads_without_chargers", 1)
else:
greet = _("You don't need to reload your weapon.", language)
scores.addToStat(message.channel, message.author, "unneeded_reloads", 1)
await comm.message_user(message, _("{greet} | Ammo in weapon: {balles_actuelles}/{balles_max} | Chargers left: {chargeurs_actuels}/{chargeurs_max}", language).format(**{
"greet" : greet,
"balles_actuelles" : scores.getStat(message.channel, message.author, "balles", default=scores.getPlayerLevel(message.channel, message.author)["balles"]),
"balles_max" : scores.getPlayerLevel(message.channel, message.author)["balles"],
"chargeurs_actuels": scores.getStat(message.channel, message.author, "chargeurs", default=scores.getPlayerLevel(message.channel, message.author)["chargeurs"]),
"chargeurs_max" : scores.getPlayerLevel(message.channel, message.author)["chargeurs"]
}))
async def game_unban(self, ctx, member: discord.Member):
"""Unban someone from the bot on the current channel
!game_unban [member]"""
language = prefs.getPref(ctx.message.server, "language")
scores.setStat(ctx.message.channel, member, "banned", False)
await comm.message_user(ctx.message, _(":ok: Done, user unbanned. :eyes:", language))
def getChannelId(channel):
server = channel.server
def getit():
sql.execute(
"SELECT id FROM channels WHERE server = %(server)s AND channel = %(channel)s",
{
'server':
int(server.id),
'channel': (0 if prefs.getPref(server, "global_scores") else
int(channel.id))
})
getit()
result = sql.fetchone()
if result:
return result['id']
else:
sql.execute(
"INSERT INTO channels (server, channel) VALUES (%(server)s, %(channel)s)",
{
'server':
int(server.id),
'channel': (0 if prefs.getPref(server, "global_scores") else
int(channel.id))
})
getit()
return sql.fetchone()['id']
async def add_channel(self, ctx):
"""Add the current channel to the server
!add_channel
"""
language = prefs.getPref(ctx.message.server, "language")
servers = prefs.JSONloadFromDisk("channels.json")
if not "channels" in servers[ctx.message.server.id]:
servers[ctx.message.server.id]["channels"] = []
if not ctx.message.channel.id in servers[
ctx.message.server.id]["channels"]:
await comm.logwithinfos_ctx(
ctx, "Adding channel {name} | {id} to channels.json...".format(
**{
"id": ctx.message.channel.id,
"name": ctx.message.channel.name
}))
servers[ctx.message.server.id]["channels"] += [
ctx.message.channel.id
]
prefs.JSONsaveToDisk(servers, "channels.json")
await ducks.planifie(ctx.message.channel)
await comm.message_user(ctx.message,
_(":robot: Channel added!", language))
else:
await comm.logwithinfos_ctx(ctx, "Channel exists")
await comm.message_user(
ctx.message,
_(":x: This channel already exists in the game.", language))
async def del_admin(self, ctx, target: discord.Member):
"""!del_admin [target]
Remove an admin from the server
"""
language = prefs.getPref(ctx.message.server, "language")
servers = prefs.JSONloadFromDisk("channels.json")
if target.id in servers[ctx.message.server.id]["admins"]:
servers[ctx.message.server.id]["admins"].remove(target.id)
await comm.logwithinfos_ctx(ctx, "Deleting admin {admin_name} | {admin_id} from configuration file for server {server_name} | {server_id}.".format(**{
"admin_name" : target.name,
"admin_id" : target.id,
"server_name": ctx.message.server.name,
"server_id" : ctx.message.server.id
}))
await comm.message_user(ctx.message, _(":robot: OK, {name} is not an admin anymore!", language).format(**{
"name": target.name
}))
prefs.JSONsaveToDisk(servers, "channels.json")
else:
await comm.message_user(ctx.message, _(":robot: {name} is not an admin!", language).format(**{
"name": target.name
}))
async def permissions(self, ctx):
"""Check permissions given to the bot. You'll need admin powers
!permissions"""
permissionsToHave = [
"change_nicknames", "connect", "create_instant_invite",
"embed_links", "manage_messages", "mention_everyone",
"read_messages", "send_messages", "send_tts_messages"
]
permissions_str = ""
for permission, value in ctx.message.server.me.permissions_in(
ctx.message.channel):
if value:
emo = ":white_check_mark:"
else:
emo = ":negative_squared_cross_mark:"
if (value and permission in permissionsToHave) or (
not value and not permission in permissionsToHave):
pass
else:
emo += ":warning:"
permissions_str += "\n{value}\t{name}".format(
**{
"value": emo,
"name": str(permission)
})
await comm.message_user(
ctx.message,
_("Permissions: {permissions}",
prefs.getPref(
ctx.message.server,
"language")).format(**{"permissions": permissions_str}))
async def claimserver(self, ctx):
"""Sets yourself as an admin if there are no admin configured, IE: when you just added the bot to a server
!claimserver"""
language = prefs.getPref(ctx.message.server, "language")
servers = prefs.JSONloadFromDisk("channels.json")
if not ctx.message.server.id in servers:
servers[ctx.message.server.id] = {}
if not "admins" in servers[ctx.message.server.id] or not servers[
ctx.message.server.id]["admins"]:
servers[ctx.message.server.id]["admins"] = [ctx.message.author.id]
await comm.logwithinfos_ctx(
ctx,
"Adding admin {admin_name} | {admin_id} to configuration file for server {server_name} | {server_id}."
.format(
**{
"admin_name": ctx.message.author.name,
"admin_id": ctx.message.author.id,
"server_name": ctx.message.server.name,
"server_id": ctx.message.server.id
}))
await comm.message_user(
ctx.message,
_(":robot: OK, you've been set as an admin!", language))
else:
await comm.logwithinfos_ctx(ctx, "An admin already exist")
await comm.message_user(
ctx.message,
_(
":x: This server has already been claimed! Try !add_admin instead.",
language))
prefs.JSONsaveToDisk(servers, "channels.json")
async def dbtable(self, ctx):
if not prefs.getPref(ctx.message.server, "global_scores"):
await comm.message_user(
ctx.message,
str(ctx.message.server.id) + "-" + str(ctx.message.channel.id))
else:
await comm.message_user(ctx.message, str(ctx.message.server.id))
async def spawn_duck(duck):
servers = prefs.JSONloadFromDisk("channels.json", default="{}")
try:
if servers[duck["channel"].server.id]["detecteur"].get(duck["channel"].id, False):
for playerid in servers[duck["channel"].server.id]["detecteur"][duck["channel"].id]:
player = discord.utils.get(duck["channel"].server.members, id=playerid)
try:
await bot.send_message(player, _("There is a duck on #{channel}", prefs.getPref(duck["channel"].server, "language")).format(**{
"channel": duck["channel"].name
}))
await comm.logwithinfos(duck["channel"], player, "Sending a duck notification")
except:
await comm.logwithinfos(duck["channel"], player, "Error sending the duck notification")
pass
servers[duck["channel"].server.id]["detecteur"].pop(duck["channel"].id)
prefs.JSONsaveToDisk(servers, "channels.json")
except KeyError:
pass
chance = random.randint(0, 100)
if chance <= prefs.getPref(duck["channel"].server, "super_ducks_chance"):
minl = prefs.getPref(duck["channel"].server, "super_ducks_minlife")
maxl = prefs.getPref(duck["channel"].server, "super_ducks_maxlife")
if minl != maxl:
if maxl < minl:
maxl, minl = minl, maxl
await comm.logwithinfos(duck["channel"], None, "Minl and maxl swapped")
life = random.randint(minl, maxl)
else:
life = minl
duck["isSC"] = True
duck["SCvie"] = life
duck["level"] = life
else:
duck["isSC"] = False
duck["level"] = 1
duck["SCvie"] = 1
await comm.logwithinfos(duck["channel"], None, "New duck: " + str(duck))
duck["time"] = time.time()
if prefs.getPref(duck["channel"].server, "emoji_ducks"):
corps = prefs.getPref(duck["channel"].server, "emoji_used") + " < "
else:
corps = random.choice(commons.canards_trace) + " " + random.choice(commons.canards_portrait) + " "
if prefs.getPref(duck["channel"].server, "randomize_ducks"):
canard_str = corps + _(random.choice(commons.canards_cri), language=prefs.getPref(duck["channel"].server, "language"))
else:
canard_str = corps + "QUAACK"
try:
await bot.send_message(duck["channel"], canard_str, tts=prefs.getPref(duck["channel"].server, "tts_ducks"))
except:
pass
commons.n_ducks_spawned += 1
commons.ducks_spawned.append(duck)
async def deleteeverysinglescoreandstatonthischannel(self, ctx):
"""Delete scores and stats of players on this channel. You'll need admin powers
!deleteeverysinglescoreandstatonthischannel"""
scores.delChannelPlayers(ctx.message.channel)
await comm.message_user(
ctx.message,
_(":ok: Scores / stats of the channel were successfully deleted.",
prefs.getPref(ctx.message.server, "language")))
async def list(self, ctx):
"""!settings list"""
language = prefs.getPref(ctx.message.server, "language")
await comm.message_user(
ctx.message,
_(
"The list of preferences is available on our new website: https://api-d.com/bot-settings.html",
language))
async def duckplanning(self, ctx):
"""!duckplanning
DEPRECATED! Get the number of ducks left to spawn on the channel
"""
await comm.message_user(
ctx.message,
_("There are {ducks} ducks left to spawn today!",
prefs.getPref(ctx.message.server, "language")).format(
ducks=commons.ducks_planned[ctx.message.channel]))
async def del_channel(self, ctx):
"""!del_channel
Remove the current channel from the server
"""
await ducks.del_channel(ctx.message.channel)
await comm.message_user(
ctx.message,
_(":ok: Channel deleted.",
prefs.getPref(ctx.message.server, "language")))
async def settings(self, ctx):
language = prefs.getPref(ctx.message.server, "language")
if not ctx.invoked_subcommand:
await comm.message_user(
ctx.message,
_(
":x: Incorrect syntax. Use the command this way: `!settings [view/set/reset/list/modified] [setting if applicable]`",
language))
def getit():
sql.execute(
"SELECT id FROM channels WHERE server = %(server)s AND channel = %(channel)s",
{
'server':
int(server.id),
'channel': (0 if prefs.getPref(server, "global_scores") else
int(channel.id))
})
async def sendBangMessage(self, message: discord.Message, string: str):
lag = prefs.getPref(message.server, "bang_lag")
if lag > 0:
tmp = await self.bot.send_message(message.channel, str(message.author.mention) + " > BANG")
await asyncio.sleep(lag)
await self.bot.edit_message(tmp, str(message.author.mention) + " > " + string)
else:
await comm.message_user(message, string)
def check(ctx, warn):
owner = is_owner_check(ctx.message)
if not owner and warn:
commons.bot.loop.create_task(
comm.message_user(
ctx.message,
_(
":x: You can't use this command, you're not the bot owner!",
prefs.getPref(ctx.message.server, "language"))))
return owner
def check(ctx, warn):
admin = is_owner_check(ctx.message) or is_admin_check(ctx.message)
if not admin and warn:
commons.bot.loop.create_task(
comm.message_user(
ctx.message,
_(
":x: You can't use this command, you're not an admin on this server!",
prefs.getPref(ctx.message.server, "language"))))
return admin
def check(ctx, exp, warn):
exp_ = have_exp_check(ctx.message, exp)
if not exp_ and warn:
commons.bot.loop.create_task(
comm.message_user(
ctx.message,
_(
":x: You can't use this command, you need at least {exp} exp points!",
prefs.getPref(ctx.message.server,
"language")).format(**{"exp": exp})))
return exp_
async def guild(ctx: HTTPRequestContext, server_id: str):
await commons.bot.wait_until_ready()
server = commons.bot.get_server(server_id)
if server:
player_count = 0
channels = []
global_scores = prefs.getPref(server, "global_scores")
stats = defaultdict(int)
if not global_scores:
for channel in server.channels:
activated = checks.is_activated_check(channel)
if activated and channel.type == ChannelType.text:
table = scores.getChannelPlayers(channel,
columns=['shoots_fired'])
for member in table:
if checks.is_player_check(member):
channels.append({
"id": channel.id,
"name": channel.name
})
break
channels.sort(key=lambda x: x['name'])
resp = {
"server": {
"name": server.name,
"channels": channels
},
"global_scores": global_scores
}
else:
data = await list_members(server_id, server_id)
if data:
resp = {
"server": {
"id": data['server'].id,
"name": data['server'].name
},
"players": data['players'],
"global_scores": global_scores
}
else:
return await prepare_resp(None, 404) # Error
return await prepare_resp(resp)
else:
return await prepare_resp(None, 404) # Guild not found
async def time(self, ctx):
time_data = int(time.time()) % 86400
hour = str(int(time_data / 60 / 60)).rjust(2, "0")
minutes = str(int(time_data / 60 % 60)).rjust(2, "0")
seconds = str(int(time_data % 60)).rjust(2, "0")
await comm.message_user(
ctx.message,
_("It's {hour}:{minutes}:{seconds}.",
getPref(ctx.message.server, "language")).format(hour=hour,
minutes=minutes,
seconds=seconds))
async def allCanardsGo():
for canard in commons.ducks_spawned:
try:
await bot.send_message(
canard["channel"],
_(random.choice(commons.canards_bye),
language=getPref(canard["channel"].server, "language")))
await logwithinfos(canard["channel"], None,
"Force-leaving of duck " + str(canard))
except:
await logwithinfos(canard["channel"], None,
"Force-leaving of duck FAILED " + str(canard))
logger.exception("Here is why : ")
async def give_exp(self, ctx, target: discord.Member, exp: int):
"""Give exp to a player.
Require admin powers
!give_exp [target] [exp]"""
try:
scores.addToStat(ctx.message.channel, target, "exp", exp)
except OverflowError:
await comm.message_user(
ctx.message,
_(
"Congratulations, you sent / gave more experience than the maximum number I'm able to store.",
prefs.getPref(ctx.message.server, "language")))
return
await comm.logwithinfos_ctx(
ctx, "[giveexp] Giving " + str(exp) + " exp points to " +
target.mention)
await comm.message_user(
ctx.message,
_(":ok:, they now have {newexp} exp points!",
prefs.getPref(ctx.message.server, "language")).format(**{
"newexp":
scores.getStat(ctx.message.channel, target, "exp")
}))
async def purge_messages_criteria(self, ctx, *, remove: str):
language = prefs.getPref(ctx.message.server, "language")
import datetime
weeks = datetime.datetime.now() - datetime.timedelta(days=13)
if ctx.message.channel.permissions_for(ctx.message.server.me).manage_messages:
def check(m):
return remove in m.content and not m.timestamp < weeks
deleted = await ctx.bot.purge_from(ctx.message.channel, limit=100, check=check)
await comm.message_user(ctx.message, _("{deleted} message(s) deleted", language).format(**{
"deleted": len(deleted)
}))
else:
await comm.message_user(ctx.message, _("No messages deleted: permission denied.", language))
