391 lines
12 KiB
Python
391 lines
12 KiB
Python
import sys
|
|
import random
|
|
import datetime
|
|
import time
|
|
import threading
|
|
|
|
import discord
|
|
import sqlite3
|
|
|
|
import interface
|
|
|
|
secrets_file = open(sys.argv[1], mode="rt")
|
|
secrets = secrets_file.read()
|
|
secrets_file.close()
|
|
|
|
token = secrets
|
|
|
|
intents = discord.Intents.default()
|
|
intents.message_content = True
|
|
intents.members = True
|
|
intents.moderation = True
|
|
|
|
client = discord.Client(intents=intents, activity=discord.Game(name='En train de niquer des mères'))
|
|
|
|
interface.client = client
|
|
|
|
import forgejo
|
|
|
|
database = sqlite3.connect(sys.argv[2])
|
|
cursor = database.cursor()
|
|
|
|
#try:
|
|
# cursor.execute("CREATE TABLE casino (id INT PRIMARY KEY, cash INT)")
|
|
# database.commit()
|
|
#except:
|
|
# print("La table existe déja")
|
|
|
|
guilds = []
|
|
|
|
globals()["gmembers"] = {}
|
|
|
|
async def roll(message):
|
|
spec = message.content.split(" ")[1].split("d")
|
|
roll = ""
|
|
print(spec)
|
|
if len(spec) > 1:
|
|
d = int(spec[1])
|
|
for i in range(int(spec[0])):
|
|
roll += str(random.randint(1,d)) + " "
|
|
else:
|
|
roll += str(random.randint(1,int(spec[0])))
|
|
await message.channel.send(roll)
|
|
|
|
async def pinguncon(message):
|
|
#fcalva's server
|
|
if message.guild.id == 750665878072328242:
|
|
await message.channel.send("<@499533339468759052>")
|
|
elif message.guild.id in [1008485562304450610, 1157767629738618941]:
|
|
await message.channel.send("<@755081785393676328>")
|
|
elif message.guild.id == 1294017120631525416:
|
|
await message.channel.send("<@504751919760408617>")
|
|
else:
|
|
await message.channel.send("Pas dispo ici")
|
|
|
|
async def pingjuif(message):
|
|
if message.guild.id in [1008485562304450610, 1157767629738618941]:
|
|
await message.channel.send("<@459021187083927553>")
|
|
else:
|
|
message.channel.send("Pas dispo ici")
|
|
|
|
async def pingrand(message):
|
|
choice = random.choice(globals()["gmembers"][str(message.guild.id)])
|
|
await message.channel.send("<@"+str(choice.id)+">")
|
|
|
|
async def reload(message):
|
|
cursor.execute(f"CREATE TABLE IF NOT EXISTS roulette (gid INT PRIMARY KEY, shots INT)")
|
|
gid = int(message.guild.id)
|
|
ret = cursor.execute(f"SELECT shots FROM roulette WHERE gid = {gid}").fetchone()
|
|
shots = random.randint(0,5)
|
|
if ret == None:
|
|
cursor.execute(f"INSERT INTO roulette (gid,shots) VALUES ({gid},{shots})")
|
|
else:
|
|
cursor.execute(f"UPDATE roulette SET shots = {shots} WHERE gid = {gid}")
|
|
database.commit()
|
|
await message.channel.send("Revolver rechargé")
|
|
|
|
|
|
async def roulette(message):
|
|
cursor.execute(f"CREATE TABLE IF NOT EXISTS roulette (gid INT PRIMARY KEY, shots INT)")
|
|
database.commit()
|
|
gid = int(message.guild.id)
|
|
ret = cursor.execute(f"SELECT shots FROM roulette WHERE gid = {gid}").fetchone()
|
|
if ret == None:
|
|
shots = random.randint(0,5)
|
|
cursor.execute(f"INSERT INTO roulette (gid,shots) VALUES ({gid},{shots})")
|
|
database.commit()
|
|
else:
|
|
shots = ret[0]
|
|
print("Shots : ", shots)
|
|
if shots <= 0:
|
|
tdelt = datetime.timedelta(minutes=5)
|
|
uid = message.author.id
|
|
try:
|
|
await message.author.timeout(tdelt, reason="Vous avez perdu à la roulette...")
|
|
await message.channel.send(f"<@{uid}> s'est tiré une balle, et est dans un coma pendant 5 minutes")
|
|
except Exception as err:
|
|
await message.channel.send("Une erreur s'est produite : `" + str(err) + "`")
|
|
nshots = random.randint(0,5)
|
|
cursor.execute(f"UPDATE roulette SET shots = {nshots} WHERE gid = {gid}")
|
|
database.commit()
|
|
else:
|
|
shots -= 1
|
|
cursor.execute(f"UPDATE roulette SET shots = {shots} WHERE gid = {gid}")
|
|
database.commit()
|
|
await message.channel.send("Clic... il n'y avait pas de cartouche dans la chambre...")
|
|
|
|
async def casino_init(message):
|
|
usrid = int(message.author.id)
|
|
gid = int(message.guild.id)
|
|
try:
|
|
cursor.execute(f"CREATE TABLE IF NOT EXISTS tab_{gid} (id INT PRIMARY KEY, cash INT, lst_coll INT)")
|
|
cursor.execute(f"INSERT INTO tab_{gid} (id, cash, lst_coll) VALUES ({usrid}, 0, 0)")
|
|
database.commit()
|
|
await message.channel.send(f"Casino initialisé pour <@{usrid}>")
|
|
except:
|
|
await message.channel.send(f"Échec ! Réessayez plus tard")
|
|
|
|
init_global_str = "Essayer d'initialiser le casino du serveur avec ?init"
|
|
init_perso_str = "Essayez d'initialiser votre portemonnaie avec ?init"
|
|
|
|
async def balance(message):
|
|
usrid = int(message.author.id)
|
|
gid = int(message.guild.id)
|
|
try:
|
|
cash = cursor.execute(f"SELECT cash FROM tab_{gid} WHERE id={usrid}").fetchone()
|
|
except:
|
|
await message.channel.send(init_global_str)
|
|
if cash != None:
|
|
await message.channel.send(f"Vous avez {cash[0]}$")
|
|
else:
|
|
await message.channel.send(init_perso_str)
|
|
|
|
async def collect(message):
|
|
collect_gain = 50
|
|
cooldown = 10*60
|
|
curr_time = int(time.time())
|
|
usrid = int(message.author.id)
|
|
gid = int(message.guild.id)
|
|
lst_coll = 0
|
|
try:
|
|
lst_coll = cursor.execute(f"SELECT lst_coll FROM tab_{gid} WHERE id={usrid}").fetchone()[0]
|
|
except:
|
|
await message.channel.send(init_perso_str)
|
|
return
|
|
if lst_coll >= curr_time - cooldown:
|
|
rtime = (-curr_time + cooldown + lst_coll)//60
|
|
await message.channel.send(f"Vous pourrez toucher votre RSA dans {rtime} minutes")
|
|
return
|
|
cash = None
|
|
cash = cursor.execute(f"SELECT cash FROM tab_{gid} WHERE id={usrid}").fetchone()
|
|
if cash != None:
|
|
cash = cash[0]
|
|
cash += collect_gain
|
|
cursor.execute(f"UPDATE tab_{gid} SET lst_coll = {curr_time} WHERE id={usrid}")
|
|
cursor.execute(f"UPDATE tab_{gid} SET cash = {cash} WHERE id={usrid}")
|
|
database.commit()
|
|
nc = cooldown//60
|
|
await message.channel.send(f"Vous avez recu {collect_gain}$ en RSA. Vous avez désormais {cash}$\n"\
|
|
f"Revenez dans {nc} minutes pour votre prochain chèque")
|
|
else:
|
|
await message.channel.send(init_perso_str)
|
|
|
|
async def slot(message):
|
|
amnt = message.content.split(' ')[1]
|
|
try:
|
|
amnt = int(amnt)
|
|
except:
|
|
await message.channel.send("Quantité invalide")
|
|
return
|
|
gid = int(message.guild.id)
|
|
uid = int(message.author.id)
|
|
ret = cursor.execute(f"SELECT cash FROM tab_{gid} WHERE id={uid}").fetchone()
|
|
if ret == None:
|
|
await message.channel.send(init_perso_str)
|
|
return
|
|
cash = ret[0]
|
|
if amnt > cash:
|
|
await message.channel.send("Vous n'avez pas assez d'argent")
|
|
return
|
|
roll = random.random()
|
|
gain = 0
|
|
if roll < 1/6:
|
|
await message.channel.send(f"<@{uid}> a perdu toute sa mise")
|
|
if roll >= 1/6 and roll < 3/6:
|
|
gain = int(round(amnt*0.5*random.random()))
|
|
await message.channel.send(f"<@{uid}> n'a remporté que {gain}$")
|
|
if roll >= 3/6 and roll < 5/6:
|
|
gain = int(round(amnt*1.25*random.random()))
|
|
await message.channel.send(f"<@{uid}> a réussi à remporter {gain}$")
|
|
if roll >= 5/6 and roll < 19/20:
|
|
gain = int(round(amnt*0.5 + amnt*1.2*random.random()))
|
|
await message.channel.send(f"<@{uid}> a extrait {gain}$ des griffes de la machine")
|
|
if roll >= 19/20:
|
|
gain = int(round(amnt*4 + amnt*17*random.random()))
|
|
await message.channel.send(f"## <@{uid}> JACKPOT ! Vous avez gagné {gain}$ !")
|
|
cash -= amnt-gain
|
|
cursor.execute(f"UPDATE tab_{gid} SET cash = {cash} WHERE id={uid}")
|
|
database.commit()
|
|
|
|
async def leaderboard(message):
|
|
uid = int(message.author.id)
|
|
gid = int(message.guild.id)
|
|
lb = None
|
|
result = cursor.execute(f"SELECT * FROM tab_{gid} ORDER BY cash DESC").fetchall()
|
|
msgstr = "## ===== Leaderboard =====\n"
|
|
i = 0
|
|
rlen = len(result)
|
|
while i < 10 and i < rlen:
|
|
uid = result[i][0]
|
|
ucash = result[i][1]
|
|
msgstr += " "+str(i+1)+f". <@{uid}> - {ucash}$\n"
|
|
i += 1
|
|
await message.channel.send(msgstr, allowed_mentions=discord.AllowedMentions().none())
|
|
|
|
async def transfer(message):
|
|
split = message.content.split(" ")
|
|
gid = int(message.guild.id)
|
|
result = None
|
|
tid = 0
|
|
uid = int(message.author.id)
|
|
utili = cursor.execute(f"SELECT * FROM tab_{gid} WHERE id={uid}").fetchone()
|
|
if utili == None:
|
|
await message.channel.send(init_perso_str)
|
|
return
|
|
try:
|
|
tid = int(split[1].strip("<@").rstrip(">"))
|
|
except:
|
|
await message.channel.send("Destinataire invalide")
|
|
return
|
|
target = cursor.execute(f"SELECT * FROM tab_{gid} WHERE id={tid}").fetchone()
|
|
if target == None:
|
|
await message.channel.send("Destinataire non initialisé")
|
|
return
|
|
amnt = 0
|
|
try:
|
|
amnt = int(split[2])
|
|
except:
|
|
await message.channel.send("Quantité non valide")
|
|
return
|
|
taxamnt = int(round(amnt*0.05))
|
|
if amnt + taxamnt > utili[1]:
|
|
await message.channel.send("Vous n'avez pas assez d'argent")
|
|
return
|
|
ncashu = utili[1] - amnt - taxamnt
|
|
ncasht = target[1] + amnt
|
|
cursor.execute(f"UPDATE tab_{gid} SET cash={ncashu} WHERE id={uid}")
|
|
cursor.execute(f"UPDATE tab_{gid} SET cash={ncasht} WHERE id={tid}")
|
|
database.commit()
|
|
await message.channel.send(f"Transfert effectué. Une taxe de 5% ({taxamnt}) a été prélevée.")
|
|
|
|
async def ecoaide(message):
|
|
await message.channel.send("Eco+, un bot Eco plus pour faire des conneries\n"\
|
|
"?pinguncon : Ping le con local\n"\
|
|
"?pingunjuif : Ping le juif local\n"\
|
|
"?pingrand : Ping un membre aléatoire du serveur\n"\
|
|
"?roulette : Jouez à la roulette russe\n"\
|
|
"?reload : Réinitialisez la roulette russe\n")
|
|
|
|
async def ecohelp(message):
|
|
await message.channel.send("Eco+ help page \n"\
|
|
"?pinguncon : Ping the local dumbass\n"\
|
|
"?pingrand : Ping a random user\n"\
|
|
"?roulette : Take one shot on six to get timed out")
|
|
|
|
async def hello(message):
|
|
await message.channel.send('henlo')
|
|
|
|
commentaires_zizi = [
|
|
#0
|
|
["Vous avez essayé de mesurer à la base ?","Dur d'avoir des chromosomes XX. Retourne à la cuisine"],\
|
|
#1
|
|
["J'ai pitié.", "Échec critique !"],\
|
|
#2
|
|
["Tu peux toujours te dire que la taille ne compte pas"],\
|
|
#3
|
|
["Dire que c'était ma taille à trois ans..."],\
|
|
#4
|
|
["Retourne dans ton 4x4 micropénis"],\
|
|
#5
|
|
["En impérial, ça aurait été la moyenne"],\
|
|
#6
|
|
["T'es pas la bite la plus dure du gloryhole"],\
|
|
#7
|
|
[""],\
|
|
#8
|
|
[""],\
|
|
#9
|
|
[""],\
|
|
#10
|
|
[""],\
|
|
#11
|
|
[""],\
|
|
#12
|
|
[""],\
|
|
#13
|
|
["La moyenne, pour de vrai"],\
|
|
#14
|
|
[""],\
|
|
#15
|
|
[""],\
|
|
#16
|
|
["La verité est dure à avaler"],\
|
|
#17
|
|
["C'est roc, c'est un pic, c'est un cap. Que dis-je ? C'est une péninsule"],\
|
|
#18
|
|
["Si le goût se rapporte à la taille, vous êtes le phoenix des hôtes du gang bang"],\
|
|
#19
|
|
["Bien membré !"],\
|
|
#20
|
|
["Je veux la même !", "Coup critique !"],\
|
|
#21
|
|
["Profite de tes chromosomes YY :moai:", "La taille moyenne en Uganda"]
|
|
]
|
|
|
|
async def zizi(message):
|
|
id = message.author.id
|
|
size = random.randint(0,10) + random.randint(0,11)
|
|
comment = random.choice(commentaires_zizi[size])
|
|
await message.channel.send(f"<@{id}>, votre chibre fait **{size} cm**. {comment}")
|
|
|
|
@client.event
|
|
async def on_ready():
|
|
print(f'We have logged in as {client.user}')
|
|
async for guild in client.fetch_guilds(limit=150):
|
|
print(str(guild.id)+":")
|
|
guilds.append(guild)
|
|
sid = str(guild.id)
|
|
globals()["gmembers"] |= {sid:[]}
|
|
async for member in guild.fetch_members(limit=150):
|
|
globals()["gmembers"][sid].append(member)
|
|
print(" "+str(member))
|
|
|
|
cmd_dict = {\
|
|
"?hello":hello,\
|
|
"?pinguncon":pinguncon,\
|
|
"?pingrand":pingrand,\
|
|
"?pingunjuif":pingjuif,\
|
|
"?zizi":zizi,\
|
|
"?roulette":roulette,\
|
|
"?help":ecohelp,\
|
|
"?aide":ecoaide,\
|
|
"?init":casino_init,\
|
|
"?cash":balance,\
|
|
"?collect":collect,\
|
|
"?lb":leaderboard,\
|
|
"?reload":reload,\
|
|
"?slot":slot,\
|
|
"?roll":roll,\
|
|
"?transfer":transfer,\
|
|
}
|
|
|
|
@client.event
|
|
async def on_message(message):
|
|
if message.author == client.user:
|
|
return
|
|
|
|
content = message.content.split(" ")[0]
|
|
|
|
if not content:
|
|
return
|
|
if content[0] != "?":
|
|
return
|
|
if not content in cmd_dict:
|
|
await message.channel.send("Commande non reconnue !")
|
|
return
|
|
|
|
try:
|
|
await cmd_dict[content](message)
|
|
except Exception as err:
|
|
print(err)
|
|
await message.channel.send("Une erreur s'est produite : `" + str(err) + "`")
|
|
|
|
def do_forgejo_thread():
|
|
forgejo.app.run(port=5000)
|
|
|
|
forgejo_thread = threading.Thread()
|
|
forgejo_thread.run = do_forgejo_thread
|
|
|
|
print("227")
|
|
forgejo_thread.start()
|
|
client.run(token)
|