159 lines
8.0 KiB
Python
159 lines
8.0 KiB
Python
#dummy module
|
|
import asyncio
|
|
import fractale.source.main
|
|
import random
|
|
import discord
|
|
import os
|
|
from PIL import Image
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
class MainClass():
|
|
def __init__(self, client, modules, owners, prefix):
|
|
self.client = client
|
|
self.modules = modules
|
|
self.owners = owners
|
|
self.prefix = prefix
|
|
self.events=['on_message'] #events list
|
|
self.command="%sfractale"%self.prefix #command prefix (can be empty to catch every single messages)
|
|
|
|
self.name="Fractale"
|
|
self.description="Module de génération de fractales"
|
|
self.interactive=True
|
|
self.color=0x78ffc3
|
|
self.fractals={
|
|
"von_koch_curve_flake":{"Type":"Figures", "Max":((5000,5000), 5000, 10), "Min":((0,0),0,1), "Default":"(2500 2500) 2000 5 #ffffff 1", "Indication":"(départ) (arrivée) longueur iterations color bg stroke", "ParseData":"pfixi"},
|
|
"von_koch_curve":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1), "Default":"(0 2500) (5000 2500) 5 #ffffff 1", "Indication":"(départ) (arrivée) iterations color bg stroke", "ParseData":"ppixi"},
|
|
"blanc_manger":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1), "Default":"(1000 1000) (4000 4000) 7 #ffffff 1", "Indication":"(départ) (arrivée) iterations color bg stroke", "ParseData":"ppixi"},
|
|
"dragon":{"Type":"Lsystem", "Max":((5000,5000), 2500,19), "Min":((0,0),1,1), "Default":"(2500 2500)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
|
|
"sierpinski_triangle":{"Type":"Lsystem", "Max":((5000,5000),2500,11), "Min":((0,0),0,1), "Default":"(0 0)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
|
|
"fractal_plant":{"Type":"Lsystem", "Max":((5000,5000),2500,8), "Min":((0,0),0,1), "Default":"(0 2500)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
|
|
"koch_curve_right_angle":{"Type":"Lsystem", "Max":((5000,5000),2500,9), "Min":((0,0),0,1), "Default":"(0 5000)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
|
|
"fractal_binary_tree":{"Type":"Lsystem", "Max":((5000,5000),2500,15), "Min":((0,0),0,1), "Default":"(0 0)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"}
|
|
}
|
|
self.help="""\
|
|
</prefix>fractale info <fractale>
|
|
=> Affiche les informations relatives à la fractale spécifiée. (paramètres attendus, paramètres par défaut, type des arguments)
|
|
|
|
</prefix>fractale <fractale> <arguments>
|
|
=> Génère une image fractale à partir des arguments fournis. Pour mettre la valeur par défaut pour un des arguments, le remplacer par le caractère *
|
|
|
|
</prefix>fractale <fractale>
|
|
=> Génère une image fractale avec les paramètres par défaut.
|
|
|
|
-> Valeurs possible pour <fractale>
|
|
```..: Toutes les fractales:
|
|
%s```"""%'\n'.join(['......: %s'%t for t in self.fractals.keys()])
|
|
|
|
async def on_message(self, message):
|
|
args=message.content.split(" ")
|
|
if len(args)==1:
|
|
await self.modules['help'][1].send_help(message.channel, self)
|
|
elif len(args)==2:
|
|
pass
|
|
elif len(args)==3:
|
|
if args[1]=="" and args[2] in self.fractals.keys():
|
|
description="""\
|
|
La fractale {nom} attend les arguments suivant :
|
|
`{arguments}`
|
|
avec le type suivant:
|
|
`{type}`
|
|
|
|
Attention, les coordonnées des points doivent être entre parentheses et son considérés comme un unique argument.
|
|
|
|
Les arguments valent par défaut :
|
|
`{defaut}`""".format(nom=args[2])
|
|
await message.channel.send(embed=discord.Embed(title="[%s] - Infos : *%s*"%(self.name,args[2]), description=""))
|
|
else:
|
|
await self.modules['help'][1].send_help(message.channel, self)
|
|
#parsed_data=self.parse(message.content[len("%sfractale "%self.prefix):])))
|
|
async def send_fractal(self, message, command):
|
|
return #TODO Coder la fonction
|
|
def parse(self, inp):
|
|
retDic={"Success":False, "Message":"", "Result":()}
|
|
#Parsing the fractal name and storing the corresponding dic into a variable
|
|
try:
|
|
fractal=self.fractals[inp.split(' ')[0]]
|
|
except KeyError:
|
|
retDic.update({"Success":False, "Message":"La fractale %s n'existe pas."%inp.split(' ')[0]})
|
|
return(retDic)
|
|
arg=' '.join(inp.split(' ')[1:]) #Stuff after the fractal name
|
|
#checking for incoherent parentheses usage
|
|
parentheses_count=0
|
|
for i,char in enumerate(arg):
|
|
if char=='(':
|
|
parentheses_count+=1
|
|
elif char==')':
|
|
parentheses_count-=1
|
|
if not(-1<parentheses_count<2):
|
|
retDic.update({"Success":False, "Message":"Usage invalide de parentheses au charactère numéro %s (à partir d'après le nom de la fractale)."%i})
|
|
return(retDic)
|
|
|
|
#Here, we have a coherent parentheses usage
|
|
if ',' in arg:
|
|
retDic.update({"Success":False, "Message":"Les virgules n'ont pas leur place dans les paramètres de génération. Il ne doit y avoir que des espaces uniques."})
|
|
return(retDic)
|
|
|
|
#parsing the fractal
|
|
args=arg.replace(')','').replace('(','').split(' ')
|
|
parsed_args=[]
|
|
i=0
|
|
for parse in fractal['ParseData'] :
|
|
if parse=='p':
|
|
if args[i]!='*':
|
|
try:
|
|
int(args[i])
|
|
int(args[i+1])
|
|
except:
|
|
retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (nombre entiers attendus pour les coordonnées d'un point)"})
|
|
return(retDic)
|
|
parsed_args.append((int(args[i]),int(args[i+1])))
|
|
i+=2
|
|
else:
|
|
parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
|
|
i+=1
|
|
|
|
elif parse=='f':
|
|
if args[i]!='*':
|
|
try:
|
|
float(args[i])
|
|
except:
|
|
retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Nombre à virgule flottante attendu (mettre un point pour la virgule))"})
|
|
return(retDic)
|
|
parsed_args.append(float(args[i]))
|
|
i+=1
|
|
else:
|
|
parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
|
|
i+=1
|
|
|
|
elif parse=='i':
|
|
if args[i]!='*':
|
|
try:
|
|
int(args[i])
|
|
except:
|
|
print(args[i])
|
|
print(i)
|
|
retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Nombre entier attendu)"})
|
|
return(retDic)
|
|
parsed_args.append(int(args[i]))
|
|
i+=1
|
|
else:
|
|
parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
|
|
i+=1
|
|
|
|
elif parse=='x':
|
|
if args[i]!='*':
|
|
try:
|
|
if '#' in args[i]:
|
|
int(args[i].replace('#','0x'),16)
|
|
else:
|
|
raise
|
|
except:
|
|
retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Valeur hexadécimale attendue)"})
|
|
return(retDic)
|
|
parsed_args.append(int(args[i].replace('#','0x'),16))
|
|
i+=1
|
|
else:
|
|
parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
|
|
i+=1
|
|
retDic.update({"Success":True, "Result":parsed_args})
|
|
return(retDic)
|