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 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 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))
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 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 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 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 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 broadcast(self, ctx, *, bc: str):
"""!broadcast [message]"""
language = prefs.getPref(ctx.message.server, "language")
await comm.message_user(ctx.message,
_("Starting the broadcast", language))
await comm.logwithinfos_ctx(ctx, "Broadcast started")
for channel in list(commons.ducks_planned.keys()):
try:
await self.bot.send_message(channel, bc)
except:
await comm.logwithinfos_ctx(
ctx, "Error broadcasting to " + str(channel.name))
pass
await comm.logwithinfos_ctx(ctx, "Broadcast ended")
await comm.message_user(ctx.message, _("Broadcast finished", language))
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))
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 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 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 don't have at least {exp} exp points!", prefs.getPref(ctx.message.server, "language")).format(**{
"exp": exp
})))
return exp_
async def purgemessages(self, ctx, number: int = 500):
"""Delete last messages in the channel
!purgemessages <number of messages>"""
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 not_pinned(m):
return not m.pinned and not m.timestamp < weeks
deleted = await self.bot.purge_from(ctx.message.channel, limit=number, check=not_pinned)
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))
async def ping(self, ctx):
language = getPref(ctx.message.server, "language")
current_time = time.time()
# TODO: ensure_soon?
ping_msg = await comm.message_user(
ctx.message,
_("BANG OR BANG, what's the best? :p\nAnyway I'm up and running!",
language))
new_time = time.time(
) # Just f*****g imprécis cela dit, a cause du await...
send_delay = int(round((new_time * 1000) - (current_time * 1000)))
if send_delay > 0: # Si l'OS supporte la précision à la milliseconde
await self.bot.edit_message(
ping_msg,
ping_msg.content + _("\n\n`This message took {ms}ms to send.`",
language).format(ms=send_delay))
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 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 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 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 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, 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
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 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 send_message(self, ctx, server_name: str, channel_name: str, *,
message: str):
language = prefs.getPref(ctx.message.server, "language")
await self.bot.send_message(
discord.utils.find(
lambda m: m.name == channel_name,
discord.utils.find(
lambda m: m.name == server_name or str(m.id) == str(
server_name), self.bot.servers).channels), message)
await comm.message_user(
ctx.message,
_("Message ({message}) sent to {server} #{channel} ",
language).format(message=message,
server=server_name,
channel=channel_name))
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 reliability", 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 add_admin(self, ctx, target: discord.Member):
"""!add_admin [target]
Remove an admin to the server
"""
language = prefs.getPref(ctx.message.server, "language")
servers = prefs.JSONloadFromDisk("channels.json")
servers[ctx.message.server.id]["admins"] += [target.id]
await comm.logwithinfos_ctx(ctx, "Adding admin {admin_name} | {admin_id} to 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} was set as an admin on the server!", language).format(**{
"name": target.name
}))
prefs.JSONsaveToDisk(servers, "channels.json")
async def cleanup_servers(self, ctx):
language = prefs.getPref(ctx.message.server, "language")
await comm.message_user(ctx.message,
_("Serching for servers to leave", language))
to_clean = []
total_members_lost = 0
servers = JSONloadFromDisk("channels.json", default="{}")
for server in list(self.bot.servers):
try:
if len(servers[server.id]["channels"]) == 0:
to_clean.append(server)
total_members_lost += server.member_count
except KeyError: # Pas de channels ou une autre merde dans le genre ?
to_clean.append(server)
total_members_lost += server.member_count
def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
random_str = id_generator()
await comm.message_user(
ctx.message,
_(
"Cleaning {servers} unused servers (accounting for {members} members in total)",
language).format(servers=len(to_clean),
members=total_members_lost))
await comm.message_user(
ctx.message,
_("To confirm, please type {random_str} now.",
language).format(random_str=random_str))
def is_random_str(m):
return m.content == random_str
guess = await self.bot.wait_for_message(timeout=10.0,
author=ctx.message.author,
check=is_random_str)
if guess is None:
await comm.message_user(
ctx.message,
_(":x: Operation canceled, you took too long to answer.",
language).format(random_str=random_str))
else:
failed = 0
for server in to_clean:
try:
await self.bot.send_message(
server,
":warning: I'll now leave the server, as you have not configured me... Join https://discord.gg/2BksEkV the duckhunt server for help about the setup and actions you have to take to bring me back."
)
except:
failed += 1
pass
try:
await self.bot.leave_server(server) # Good Bye :'(
except:
commons.logger.exception("")
await comm.message_user(
ctx.message,
_(":ok: Finished, failed for {failed} servers.",
language).format(failed=failed))
async def bang(self, ctx):
now = time.time()
message = ctx.message
channel = message.channel
author = message.author
language = prefs.getPref(message.server, "language")
await self.giveBackIfNeeded(message)
if scores.getStat(channel, author, "mouille") > int(now): # Water
await comm.message_user(
message,
_(
"Your clothes are wet, you can't go hunting! Wait {temps_restant} minutes.",
language).format(
**{
"temps_restant":
int((scores.getStat(channel, author, "mouille") -
int(time.time())) / 60)
}))
scores.addToStat(channel, author, "shoots_tried_while_wet", 1)
return
if scores.getStat(channel, author, "confisque",
default=False): # No weapon
await comm.message_user(message,
_("You don't have a weapon.", language))
scores.addToStat(channel, author, "shoots_without_weapon", 1)
return
if scores.getStat(channel, author, "enrayee", default=False): # Jammed
await comm.message_user(
message,
_("Your weapon is jammed, it must be reloaded to unjam it.",
language))
scores.addToStat(channel, author, "shoots_with_jammed_weapon", 1)
return
if scores.getStat(channel, author, "sabotee",
default="-") is not "-": # Sabotaged
await comm.message_user(
message,
_(
"Your weapon is sabotaged, thank {assaillant} for this bad joke.",
language).format(
**{
"assaillant":
scores.getStat(
channel, author, "sabotee", default="-")
}))
scores.addToStat(channel, author, "shoots_sabotaged", 1)
scores.setStat(channel, author, "enrayee", True)
scores.setStat(channel, author, "sabotee", "-")
return
if scores.getStat(
channel,
author,
"balles",
default=scores.getPlayerLevel(
channel,
author)["balles"]) <= 0: # No more bullets in charger
await comm.message_user(
message,
_(
"** CHARGER EMPTY ** | Ammunition in the weapon: {balles_actuelles} / {balles_max} | Magazines remaining: {chargeurs_actuels} / {chargeurs_max}",
language).format(
**{
"balles_actuelles":
scores.getStat(channel,
author,
"balles",
default=scores.getPlayerLevel(
channel, author)["balles"]),
"balles_max":
scores.getPlayerLevel(channel, author)["balles"],
"chargeurs_actuels":
scores.getStat(channel,
author,
"chargeurs",
default=scores.getPlayerLevel(
channel, author)["chargeurs"]),
"chargeurs_max":
scores.getPlayerLevel(channel, author)["chargeurs"]
}))
scores.addToStat(channel, author, "shoots_without_bullets", 1)
return
fiabilite = scores.getPlayerLevel(channel, author)["fiabilitee"]
if scores.getStat(channel, author, "sand", default=False):
fiabilite /= 2
scores.setStat(channel, author, "sand", False)
if not random.randint(1, 100) <= fiabilite and not (scores.getStat(
channel, author,
"graisse") > int(now)): # Weapon jammed just now
await comm.message_user(
message,
_("Your weapon just jammed, reload it to unjam it.", language))
scores.addToStat(channel, author, "shoots_jamming_weapon", 1)
scores.setStat(channel, author, "enrayee", True)
return
current_duck = None
if commons.ducks_spawned:
for duck in commons.ducks_spawned:
if duck["channel"] == channel:
current_duck = duck
break
if not current_duck and scores.getStat(
channel, author,
"detecteurInfra") > int(now) and scores.getStat(
channel, author, "detecteur_infra_shots_left"
) > 0: # No ducks but infrared detector
await comm.message_user(
message,
_(
"There isn't any duck in here, but the bullet wasn't fired because the infrared detector you added to your weapon is doing its job!",
language))
scores.addToStat(channel, author, "shoots_infrared_detector", 1)
scores.addToStat(channel, author, "detecteur_infra_shots_left", -1)
return
scores.addToStat(channel, author, "balles", -1)
scores.addToStat(channel, author, "shoots_fired", 1)
if not current_duck: # No duck
await self.sendBangMessage(
message,
_(
"Luckily you missed, but what were you aiming at exactly? There isn't any duck in here... [missed: -1 xp] [wild shot: -1 xp]",
language))
scores.addToStat(channel, author, "exp", -2)
scores.addToStat(channel, author, "shoots_no_duck", 1)
return
if random.randint(1, 100) <= prefs.getPref(
message.server, "duck_frighten_chance") and scores.getStat(
channel, author,
"silencieux") < int(now): # Duck frightened
try:
commons.ducks_spawned.remove(current_duck)
commons.n_ducks_flew += 1
scores.addToStat(channel, author, "exp", -1)
await self.sendBangMessage(
message,
_(
"**FLAPP**\tFrightened by so much noise, the duck fled! CONGRATS! [missed: -1 xp]",
language))
scores.addToStat(channel, author, "shoots_frightened", 1)
except ValueError:
await self.sendBangMessage(
message,
_("**PIEWW**\tYou missed the duck! [missed: -1 xp]",
language))
scores.addToStat(channel, author, "shoots_missed", 1)
return
if scores.getStat(channel, author, "dazzled", True):
accuracy = 200 # 50% moins de chance de toucher
scores.setStat(channel, author, "dazzled", False)
else:
accuracy = 100
precision = scores.getPlayerLevel(channel, author)["precision"]
sight = scores.getStat(channel, author, "sight")
if sight:
precision += (100 - precision) / 3
scores.setStat(channel, author, "sight", sight - 1)
if random.randint(1, accuracy) > precision * prefs.getPref(
message.server, "multiplier_miss_chance"):
if random.randint(1, 100) <= prefs.getPref(
message.server,
"chance_to_kill_on_missed"): # Missed and shot someone
scores.addToStat(channel, author, "exp", -3)
scores.addToStat(channel, author, "shoots_missed", 1)
scores.addToStat(channel, author, "killed_players", 1)
scores.setStat(channel, author, "confisque", True)
memberlist = scores.getChannelPlayers(channel,
columns=['shoots_fired'])
victim = None
while not victim:
victim = random.choice(memberlist)
while not checks.is_player_check(victim):
memberlist.remove(victim)
victim = random.choice(memberlist)
victim = message.server.get_member(str(victim['id_']))
if victim is not author:
await self.sendBangMessage(
message,
_(
"**BANG**\tYou missed the duck... and shot {player}! [missed: -1 xp] [hunting accident: -2 xp] [weapon confiscated]",
language).format(
**{
"player":
victim.mention if prefs.
getPref(message.server, "killed_mentions"
) else victim.name
}))
else:
await self.sendBangMessage(
message,
_(
"**BANG**\tYou missed the duck... and shot yourself! Maybe you should turn your weapon a little before shooting the next time? [missed: -1 xp] [hunting accident: -2 xp] [weapon confiscated]",
language))
scores.addToStat(channel, author, "self_killing_shoots", 1)
if scores.getStat(channel, victim,
"life_insurance") > int(now):
exp = int(
scores.getPlayerLevel(channel, author)["niveau"] / 2)
scores.addToStat(channel, victim, "exp", exp)
await self.bot.send_message(
channel,
str(victim.mention) +
_(" > You won {exp} with your life insurance !",
language).format(**{"exp": exp}))
scores.addToStat(channel, victim, "life_insurence_rewards",
1)
else: # Missed and none was shot
scores.addToStat(channel, author, "exp", -1)
scores.addToStat(channel, author, "shoots_missed", 1)
await self.sendBangMessage(
message,
_("**PIEWW**\tYou missed the duck! [missed: -1 xp]",
language))
return
if scores.getStat(channel, author, "explosive_ammo") > int(now):
current_duck["SCvie"] -= 3
vieenmoins = 3
ono = _("BPAM", language)
elif scores.getStat(channel, author, "ap_ammo") > int(now):
current_duck["SCvie"] -= 2
vieenmoins = 2
ono = _("BAAM", language)
else:
current_duck["SCvie"] -= 1
vieenmoins = 1
ono = random.choice([_("BOUM", language), _("SPROTCH", language)])
if current_duck["SCvie"] <= 0: # Duck killed
try:
commons.ducks_spawned.remove(current_duck)
commons.n_ducks_killed += 1
except ValueError:
await self.sendBangMessage(
message,
_(
"That was close, you almost killed the duck, but the other hunter got it first! [missed: -1 xp]",
language))
scores.addToStat(channel, author, "exp", -1)
scores.addToStat(channel, author, "shoots_missed", 1)
scores.addToStat(channel, author, "shoots_almost_killed", 1)
return
exp = prefs.getPref(message.server, "exp_won_per_duck_killed")
exp += prefs.getPref(
message.server, "super_ducks_exp_multiplier") * (
current_duck["level"] - 1) * prefs.getPref(
message.server, "exp_won_per_duck_killed")
if scores.getStat(channel, author, "trefle") >= time.time():
toadd = scores.getStat(channel, author, "trefle_exp")
exp += toadd
scores.addToStat(channel, author, "exp_won_with_clover", toadd)
exp = int(exp)
scores.addToStat(channel, author, "exp", exp)
scores.addToStat(channel, author, "killed_ducks", 1)
if current_duck["level"] > 1:
scores.addToStat(channel, author, "killed_super_ducks", 1)
await self.sendBangMessage(
message,
_(
":skull_crossbones: **{onomatopoeia}**\tYou killed the duck in {time} seconds, you are now at a grand total of {total} ducks (of which {supercanards} were super-ducks) killed on #{channel}. \_X< *COUAC* [{exp} exp]",
language).format(
**{
"time":
round(now - current_duck["time"], 4),
"total":
scores.getStat(channel, author, "killed_ducks"),
"channel":
channel,
"exp":
exp,
"supercanards":
scores.getStat(channel, author,
"killed_super_ducks"),
"onomatopoeia":
ono
}))
if scores.getStat(channel,
author,
"best_time",
default=prefs.getPref(message.server,
"time_before_ducks_leave")
) > float(now - current_duck["time"]):
scores.setStat(channel, author, "best_time",
round(now - current_duck["time"], 6))
if prefs.getPref(message.server, "users_can_find_objects"):
rand = random.randint(0, 1000)
HOUR = 3600
DAY = 86400
if rand <= 50:
scores.addToStat(channel, author, "trashFound", 1)
await comm.message_user(
message,
_(
"While searching in the bushes around the duck, you found **{inutilite}**.",
language).format(
**{
"inutilite":
_(random.choice(commons.inutilite),
language)
}))
elif rand <= 54:
c = scores.getStat(message.channel, message.author,
"explosive_ammo")
if c > time.time():
scores.setStat(message.channel, message.author,
"explosive_ammo", int(c + DAY))
else:
scores.setStat(message.channel,
message.author, "explosive_ammo",
int(time.time() + DAY))
scores.addToStat(message.channel, message.author,
"found_explosive_ammo", 1)
await comm.message_user(
message,
_(
"While searching in the bushes around the duck, you found **a box of explosive ammo**.",
language))
elif rand <= 60:
c = scores.getStat(message.channel, message.author,
"explosive_ammo")
if c > time.time():
scores.setStat(message.channel, message.author,
"explosive_ammo", int(c + DAY / 4))
else:
scores.setStat(message.channel, message.author,
"explosive_ammo",
int(time.time() + DAY / 4))
scores.addToStat(message.channel, message.author,
"found_almost_empty_explosive_ammo", 1)
await comm.message_user(
message,
_(
"While searching in the bushes around the duck, you found **an almost empty box of explosive ammo**.",
language))
elif rand <= 63:
scores.addToStat(message.channel, message.author,
"found_chargers", 1)
if scores.getStat(message.channel,
message.author,
"chargeurs",
default=scores.getPlayerLevel(
message.channel, message.author)
["chargeurs"]) < scores.getPlayerLevel(
message.channel,
message.author)["chargeurs"]:
scores.addToStat(message.channel, message.author,
"chargeurs", 1)
await comm.message_user(
message,
_(
"While searching in the bushes around the duck, you found **a full charger**.",
language))
else:
scores.addToStat(message.channel, message.author,
"found_chargers_not_taken", 1)
await comm.message_user(
message,
_(
"While searching in the bushes around the duck, you found **a full charger**. You left it there, because your backpack is full.",
language))
elif rand <= 70:
scores.addToStat(message.channel, message.author,
"found_bullets", 1)
if scores.getStat(message.channel,
message.author,
"balles",
default=scores.getPlayerLevel(
message.channel, message.author)
["balles"]) < scores.getPlayerLevel(
message.channel,
message.author)["balles"]:
scores.addToStat(message.channel, message.author,
"balles", 1)
await comm.message_user(
message,
_(
"While searching in the bushes around the duck, you found **a bullet**.",
language))
else: # Shouldn't happen but we never know...
await comm.message_user(
message,
_(
"While searching in the bushes around the duck, you found **a bullet**. You left it there, because you have enough in your charger.",
language))
scores.addToStat(message.channel, message.author,
"found_bullets_not_taken", 1)
else: # Duck harmed
await self.sendBangMessage(
message,
_(
":gun: The duck survived, try again! *SUPER DUCK DETECTED* [life: -{vie}]",
language).format(**{"vie": vieenmoins}))
current_duck["SCvie"] -= vieenmoins
scores.addToStat(channel, author, "shoots_harmed_duck", 1)
async def serverlist(self,
ctx,
passed_prefs: str = "",
maxservs: int = None):
language = prefs.getPref(ctx.message.server, "language")
x = PrettyTable()
args_ = passed_prefs.split(" ")
x._set_field_names([
_("Name", language),
_("Invitation", language),
_("Server ID", language),
_("Number of enabled channels", language),
_("Number of connected users", language),
_("Ducks per day", language),
_("Number of unneeded permissions", language),
_("Number of needed permissions", language)
])
x.reversesort = True
tmp = await self.bot.send_message(
ctx.message.channel,
str(ctx.message.author.mention) + _(" > En cours", language))
servers = JSONloadFromDisk("channels.json", default="{}")
i = 0
lu = 0
slist = sorted(list(self.bot.servers),
key=lambda s: int(s.member_count),
reverse=True)[:maxservs]
total = len(slist)
for server in list(slist):
i += 1
if time.time() - lu >= 1.5 or i == total:
lu = time.time()
try:
await self.bot.edit_message(
tmp,
str(ctx.message.author.mention) +
_(" > Processing servers ({done}/{total})",
language).format(**{
"done": i,
"total": total
}))
except:
pass
invite = None
permissionsToHave = [
"change_nicknames", "connect", "create_instant_invite",
"embed_links", "manage_messages", "mention_everyone",
"read_messages", "send_messages", "send_tts_messages"
]
permEnMoins = 0
permEnPlus = 0
channel = server.default_channel
for permission, value in channel.permissions_for(server.me):
if not value and permission in permissionsToHave:
permEnMoins += 1
elif value and not permission in permissionsToHave:
permEnPlus += 1
if "invitations" in args_:
for channel in server.channels:
permissions = channel.permissions_for(server.me)
if permissions.create_instant_invite:
try:
invite = await self.bot.create_invite(channel,
max_age=120 *
60)
invite = invite.url
except:
invite = ""
else:
invite = ""
try:
channels = str(len(servers[server.id]["channels"]))
except KeyError: # Pas de channels ou une autre merde dans le genre ?
channels = "0"
x.add_row([
server.name, invite,
str(server.id), channels + "/" + str(len(server.channels)),
server.member_count,
prefs.getPref(server, "ducks_per_day"), permEnPlus, permEnMoins
])
await comm.message_user(
ctx.message, "```\n" +
x.get_string(sortby=_("Number of connected users", language)) +
"\n```")
