Classement

Mais mdr tu t'arrete jamais toi x) Tient c'est cadeau (besoin de l'addon morkazsk "%items within caught entity%"

Bonjour très bien je vais réexpliquer étape par étape: on clique droit avec un bâton; des falling block de glace tombe au endroit montrer plus haut; au moment ou les block touchent le sol je veux qu'ils se suppriment ; Voila j’espère que c'est plus clair merci de votre aide !

Salut ! Vous avez besoin d'un système de tri ? Vous êtes au bon endroit ? ! Le petit algorithme suivant (moins de 15 lignes) va vous permettre de trier une liste contenant des nombres, dans un ordre croissant ou décroissant. Ce système de tri prend aussi en charge les égalités, les nombres à virgules ainsi que les nombres négatifs. Pratique non ? De plus, vous n'avez pas besoin d'autres plugins (juste Skript est nécessaire) ! function sorting(1: numbers) :: numbers: loop {_1::*}: set {_1} to 1 loop {_2::*}: loop-value-1 >= loop-value-2 # Pour trier la liste dans un ordre décroissant, mettez "<=" au lieu de ">=". add 1 to {_1} set {_2} to {_1} + 1 set {_3::*} to {_2::*} loop (size of {_2::*} - {_1} + 1) times: set {_3} to {_2} - 1 set {_2::%{_2}%} to {_3::%{_3}%} add 1 to {_2} set {_2::%{_1}%} to loop-value return {_2::*} Pour utiliser la fonction, c'est très simple. Imaginons une liste {_numbers::*} contenant des nombres : command /test: trigger: set {_numbers::*} to 8, 4, 12, -6, 2, 1.5, 19, 726, 0.28, -65, 3, 13, 19, 72, 21, 15 and 6 send "Départ :" loop {_numbers::*}: send "%loop-value%" set {_numbers::*} to sorting({_numbers::*}) send "Arrivée :" loop {_numbers::*}: send "%loop-value%" Cette commande va trier la liste ci-dessus dans un ordre croissant. Pour trier la liste dans un ordre décroissant, référez-vous à la ligne 5 de la fonction. Merci d'avoir lu ? !

Bonjour, aujourd'hui je vous partage ma dernière création en Skript : un algorithme Soundex Merci de laisser le commentaire avec mon nom avant la fonction si vous l'utiliser dans votre code. Vous pouvez aussi me citer sur le post si vous êtes quelqu'un de gentil Il est très important d'avoir SkUtilities et skQuery pour que la fonction marche ! Qu'est ce que l'algorithme Soundex ? L'algorithme Soundex est un algorithme phonétique d'indexation de noms par prononciations (merci Wikipedia). En gros, il va transformer les mots en chiffres selon certains critères, et permettra ainsi de reconnaitre deux mots proches, deux mots qui ont une correspondance entre eux malgré des différences dans l'écriture. Il est utilisé par beaucoup de sites, du moins est repris par beaucoup de sites (moteurs de recherches, etc.). Je prefère vous le partager plutôt que le voir copier coller depuis mes futurs skripts qui l'utiliseront. L'algorithme L'algorithme Soundex est plutôt simple à comprendre. Je vais le décrire grossièrement, si vous voulez le voir en détail, rendez-vous ici. (le wikipedia anglais indique les exceptions et les règles, alors que la page française non) On retire les espaces, les voyelles (dont celles anglaises), et les lettres doublées puis on met le mot en majuscule On garde la première lettre On attribue un numéro à chaque lettre que l'on a encore sauf la première On garde seulement 3 chiffres, ou bien on ajoute des 0 pour avoir 3 chiffres On met la première lettre suivi des trois chiffres, voilà. Prenons par exemple le mot "Comment" COMMENT CMMNT CMNT M = 5, N = 5, T = 3 C553 La personne écrit mal le mot, et écrit "Cament" CAMENT CMNT M = 5, N = 5, T = 3 C553 Même code, donc mot proche Exceptions Il y a néanmoins quelques exceptions. L'algorithme les respecte parfaitement ! Si 3 chiffres sont les même de suite dans le code final, on en garde qu'un seul. C'est à dire que si 3 lettres avec le même chiffre se suivent, on en garde qu'une. Par exemple, "Jackson" ne donne pas pas "A222" mais "A250" Si deux lettres avec le même chiffre sont séparés d'un H ou d'un W, il n'y a qu'un chiffre et pas deux. Par exemple, "Ashcraft" n'est pas "A226" mais "A261" Le code, la fonction, l'algorithme donc pour l'utiliser, il suffit de faire soundex("text") et cela retournera un code. Par exemple "set {var} to soundex("salut")" Le code expliqué Utilisation théorique Vous allez sûrement vous dire "ok mais je fais quoi de cette fonction". Exemple théorique Il suffit de comparer ce que retourne la fonction pour un terme, et pour l'autre. On peut comparer 'soundex("salut")' et 'soundex("solut")', on aura le même code. Exemple command /money <text>:[/size][/size] [size=5][size=4] trigger: if arg 1 is not "remove": if soundex("remove") is soundex(arg 1): send "The command is /money remove and not /remove %arg 1% :)" Corrige la commande /money remove Il y a des tonnes de choses à faire avec cela ! Des corrections, des anti-spam développés, pleins de trucs ! A vous de voir maintenant... Si vous avez besoin d'aide n'hésitez pas à me demander, et n'hésitez pas non plus à lâcher un petit j'aime et un commentaire si vous aimez l'algorithme. Polymeth.

Salut, voici Soundex mis aux dernières version de skript et skquery, et y'a plus besoin de skutilities. Je l'ai pas du tout optimisé, mais si qqn est chaud, foncez ? function Soundex(a: text) :: text: set {_text} to capitalized {_a} set {_first} to first character of {_text} replace all "a", "e", "i", "o", "u", "y" and " " with "" in {_text} set {_1} to first character of {_text} set {_2} to first character of {_a} if {_1} is not {_2}: set {_text} to concatenate {_first} and {_text} set {_text::*} to {_text} split at "" loop {_text::*}: set {_v} to (loop-index parsed as number + 1) if loop-index is "1": remove loop-value from {_text::*} else: if loop-value is "%{_text::%{_v}%}%": remove loop-value from {_text::*} else: if loop-value is "B" or "F" or "P" or "V": add "1" to {_s::*} else if loop-value is "C" or "G" or "J" or "K" or "Q" or "S" or "X" or "Z": add "2" to {_s::*} else if loop-value is "D" or "T": add "3" to {_s::*} else if loop-value is "L": add "4" to {_s::*} else if loop-value is "M" or "N": add "5" to {_s::*} else if loop-value is "R": add "6" to {_s::*} else if loop-value is "H" or "W": add "*" to {_s::*} loop {_s::*}: set {_v} to (loop-index parsed as number + 1) set {_v2} to (loop-index parsed as number + 2) if {_s::*} is "*": return "%{_first}%000" else if loop-value is "%{_s::%{_v}%}%" and "%{_s::%{_v2}%}%": remove {_s::%{_v}%} from {_s::*} remove {_s::%{_v2}%} from {_s::*} else if loop-value is "%{_s::%{_v2}%}%": if "%{_s::%{_v}%}%" is "*": remove {_s::%{_v2}%} from {_s::*} else if loop-value is "*": remove loop-value from {_s::*} else: add 1 to {_t} set {_final} to concatenate {_final} and loop-value if size of {_s::*} is 1: return "%{_first}%%{_final}%00" if size of {_s::*} is 2: if {_t} is 2: return "%{_first}%%{_final}%0" else: if {_t} is 3: return "%{_first}%%{_final}%"

Voici un algorithme pour créer une sphère dans minecraft: Premièrement, voici une sphère: [ATTACH=full]8086[/ATTACH] Rien de plus classique, mais une forme complexe n'est-ce pas ? Après quelques recherches, il est facilement possible de récupérer un algorithme qui permet de créer des disques ou des cercles: Algorithmes de Bresenham et Andres. Dans mes algorithmes qui sont des fonctions je vais simplement récupérer les locations dans une liste: Pour les intéressés, j'ai refait Bresenham et Andres sous forme de fonction return. [spoiler=Bresenham, Andres][spoiler=Cercle Bresenham] function bresenham(radius:number,location:location,world:world) :: locations: set {_x} to 0 set {_z} to {_radius} set {_m} to 5-4*{_radius} while {_x} <= {_z}: add location {_x}+x-location of {_location}, y-location of {_location}-1, {_z}+z-location of {_location} of {_world} to {_locations::*} add location {_z}+x-location of {_location}, y-location of {_location}-1, {_x}+z-location of {_location} of {_world} to {_locations::*} add location -1*{_x}+x-location of {_location}, y-location of {_location}-1, {_z}+z-location of {_location} of {_world} to {_locations::*} add location -1*{_z}+x-location of {_location}, y-location of {_location}-1, {_x}+z-location of {_location} of {_world} to {_locations::*} add location {_x}+x-location of {_location}, y-location of {_location}-1, -1*{_z}+z-location of {_location} of {_world} to {_locations::*} add location {_z}+x-location of {_location}, y-location of {_location}-1, -1*{_x}+z-location of {_location} of {_world} to {_locations::*} add location -1*{_x}+x-location of {_location}, y-location of {_location}-1, -1*{_z}+z-location of {_location} of {_world} to {_locations::*} add location -1*{_z}+x-location of {_location}, y-location of {_location}-1, -1*{_x}+z-location of {_location} of {_world} to {_locations::*} if {_m} > 0: remove 1 from {_z} set {_m} to {_m}-8*{_z} add 1 to {_x} set {_m} to {_m}+8*{_x}+4 return {_locations::*} [spoiler= Cercle Andres] function andres(radius:number,location:location,world:world) :: locations: set {_x} to 0 set {_z} to {_radius} set {_d} to {_radius}-1 while {_z} >= {_x}: add location x-location of {_location}+{_x}, y-location of {_location}-1, z-location of {_location}+{_z} of {_world} to {_locations::*} add location x-location of {_location}+{_z}, y-location of {_location}-1, z-location of {_location}+{_x} of {_world} to {_locations::*} add location x-location of {_location}-{_x}, y-location of {_location}-1, z-location of {_location}+{_z} of {_world} to {_locations::*} add location x-location of {_location}-{_z}, y-location of {_location}-1, z-location of {_location}+{_x} of {_world} to {_locations::*} add location x-location of {_location}+{_x}, y-location of {_location}-1, z-location of {_location}-{_z} of {_world} to {_locations::*} add location x-location of {_location}+{_z}, y-location of {_location}-1, z-location of {_location}-{_x} of {_world} to {_locations::*} add location x-location of {_location}-{_x}, y-location of {_location}-1, z-location of {_location}-{_z} of {_world} to {_locations::*} add location x-location of {_location}-{_z}, y-location of {_location}-1, z-location of {_location}-{_x} of {_world} to {_locations::*} if {_d} >= 2*{_x}: set {_d} to {_d}-2*{_x}-1 add 1 to {_x} else if {_d} < 2*({_radius}-{_z}): set {_d} to {_d}+2*{_z}-1 remove 1 from {_z} else: set {_d} to {_d}+2*({_z}-{_x}-1) remove 1 from {_z} add 1 to {_x} return {_locations::*} [spoiler=Disque Andres] function disk(radius:number,location:location,world:world) :: locations: set {_x} to x-location of {_location}+{_radius} set {_y} to rounded down z-location of {_location}+{_radius} set {_d} to {_radius}-1 set {_a} to {_radius}-1 set {_b} to 0 while {_a} >= {_b}: loop all integers between {_y}-{_a} and {_y}+{_a}: add location {_x}+{_b}-{_radius}, y-location of {_location}-1, loop-integer+0.5-{_radius} of {_world} to {_locations::*} loop all integers between {_y}-{_b} and {_y}+{_b}: add location {_x}+{_a}-{_radius}, y-location of {_location}-1, loop-integer+0.5-{_radius} of {_world} to {_locations::*} loop all integers between {_y}-{_a} and {_y}+{_a}: add location -1*{_radius}+{_x}-{_b}, y-location of {_location}-1, loop-integer+0.5-{_radius} of {_world} to {_locations::*} loop all integers between {_y}-{_b} and {_y}+{_b}: add location -1*{_radius}+{_x}-{_a}, y-location of {_location}-1, loop-integer+0.5-{_radius} of {_world} to {_locations::*} if {_d} >= 2*{_b}: set {_d} to {_d}-2*{_b}-1 add 1 to {_b} else if {_d} < 2*({_radius}-{_a}): set {_d} to {_d}+2*{_a}-1 remove 1 from {_a} else: set {_d} to {_d}+2*({_a}-{_b}-1) remove 1 from {_a} add 1 to {_b} return {_locations::*} Passons à notre sphère: Première chose à "savoir", une sphère de rayon r, est contenu dans un cube de côté 2r. Le centre O, est aussi le centre de notre cube. En géométrie cartésienne, une sphère de centre (x0,y0,z0) et de rayon r est l'ensemble des points (x,y,z) tel que: L'algorithme: r = rayon x0 = position x du centre y0 = position y du centre z0 = position z du centre on se place dans deux coins opposés du cuboid de côté 2r de centre (x0,y0,z0) créer une liste de position contenant les blocs de notre cuboid saisir cette liste: x = position x du bloc y = position y du bloc z = position z du bloc si la difference entre (x-x0)²+(y-y0)²+(z-z0)² et r² < r: ajouter les positions de ce bloc à notre liste finale renvoyer la liste finale En skript: Plusieurs étapes nécessaires: Récupérer un cuboid en format texte Récupérer les locations d'un cuboid [spoiler=Cuboid sous format texte] function bigger(numbers:numbers) :: number: loop {_numbers::*}: if {_max} is not set: set {_max} to loop-value else if loop-value is bigger or equal to {_max}: set {_max} to loop-value return {_max} function smaller(numbers:numbers) :: number: loop {_numbers::*}: if {_min} is not set: set {_min} to loop-value else if loop-value is smaller or equal to {_min}: set {_min} to loop-value return {_min} function cuboid(corner:location,corner2:location,world:world) :: text: set {_x::*} to rounded down x-location of {_corner} and rounded down x-location of {_corner2} set {_y::*} to rounded down y-location of {_corner} and rounded down y-location of {_corner2} set {_z::*} to rounded down z-location of {_corner} and rounded down z-location of {_corner2} add bigger({_x::*}) to {_c::*} add bigger({_y::*}) to {_c::*} add bigger({_z::*}) to {_c::*} add smaller({_x::*}) to {_c::*} add smaller({_y::*}) to {_c::*} add smaller({_z::*}) to {_c::*} return "%{_c::1}%,%{_c::4}%,%{_c::2}%,%{_c::5}%,%{_c::3}%,%{_c::6}%,%{_world}%" [spoiler=Locations du cuboid] function cuboids(cuboid:text) :: locations: loop {_cuboid} split by ",": if loop-value parsed as number is set: add loop-value parsed as number to {_c::*} else: set {_world} to loop-value parsed as world loop all numbers between {_c::2} and {_c::1}: loop all numbers between {_c::4} and {_c::3}: loop all numbers between {_c::6} and {_c::5}: add location loop-number-1, loop-number-2, loop-number-3 of {_world} to {_locations::*} return {_locations::*} [spoiler=Fonction finale] function sphere(radius:number,center:location,world:world) :: locations: set {_corner} to location x-location of {_center}+{_radius}, y-location of {_center}+{_radius}, z-location of {_center}+{_radius} of {_world} set {_corner2} to location x-location of {_center}-{_radius}, y-location of {_center}-{_radius}, z-location of {_center}-{_radius} of {_world} set {_x0} to x-location of {_center} set {_y0} to y-location of {_center} set {_z0} to z-location of {_center} loop cuboids(cuboid({_corner},{_corner2},{_world})): set {_x} to x-location of loop-value+0.5 set {_y} to y-location of loop-value+0.5 set {_z} to z-location of loop-value+0.5 if difference between ({_x}-{_x0})^2+({_y}-{_y0})^2+({_z}-{_z0})^2 and {_radius}^2 is smaller than {_radius}: add loop-value to {_locations::*} return {_locations::*} Bonne utilisation.

Il existe déjà un système de Top/Flop ici : https://skript-mc.fr/forum/threads/créer-un-top-flop-de-joueurs-tri-croissant-décroissant.3944/ Mais je vous en propose un autre qui n'a rien à voir et qui est très performant : Ne nécessite pas d'addon possibilité de choisir par exemple "de la place 5 à la place 10" (ex: /top Kill 5 10) Ordre croissant et décroissant (ex: /top Kill 10 5) inverser l'ordre de lecture : la place 1 à la plus haute valeur/ la plus basse valeur (ex: /top Kill 1 10 /top Kill 1 10 f) /top Kill 10 1 est donc l'équivalent de /top Kill 1 10 f command /top <text> [<integer=1>] [<integer=5>] [<text>]: usage: /top <statistique> [debut] [fin] [inverser] trigger: set {_now} to now #---------------------------------------------------------------# # CODE A MODIFIER # # OBJECTIF : RECUPERER LA LISTE DES JOUEURS ET LEUR STATISTIQUE # #---------------------------------------------------------------# set {_players::*} to yml list "list.allplayers" from file "plugins/PlayerStats/SERVEUR.yml" loop {_players::*}: "%loop-value%" is not "SERVEUR" set {_value} to yml value "%arg-1%" from file "plugins/PlayerStats/%loop-value%.yml" parsed as number #----------------------------# # DEBUT DU CODE UTILE # # NE MODIFIER QUE LES TEXTES # #----------------------------# # les 2 lignes en dessous sont 2 sécurités à activer en cas de doute du fonctionnement du code au dessus # set {_value} to {_value} parsed as number # {_value} +1 > {_value} set {_value} to ({_value}*100000 + (random integer between 1 and 99)) set {_list::%{_value}%} to loop-value delete {_value} if arg-4 is not set: send "<gold>Top <white>%arg-1% <gold>a partir de la place <white>%arg-2% <gold>a la place <white>%arg-3%" to player else: send "<gold>Top <white>%arg-1% <gold>a partir de la place <white>%arg-2% <gold>a la place <white>%arg-3% <gray>(Inversé)" to player set {_a} to 1 loop {_list::*}: set {_result::%{_a}%::%loop-index%} to loop-value add 1 to {_a} set {_num} to arg-2 loop (1+ difference between arg-2 and arg-3) times: if arg-4 is not set: set {_i} to ({_a} + {_num}*-1) else: set {_i} to {_num} loop {_result::%{_i}%::*}: send " <gold>%{_num}%- <light green>%loop-value-2% : <white>%(( (loop-index parsed as number) /100000))%" to player remove 1 from {_num} if arg-3 > arg-2: add 2 to {_num} send "Temps de calcul : %difference between {_now} and now%" to player Il n'y a que le début du code à changer, par exemple avec quelque chose comme: #---------------------------------------------------------------# # CODE A MODIFIER # # OBJECTIF : RECUPERER LA LISTE DES JOUEURS ET LEUR STATISTIQUE # #---------------------------------------------------------------# set {_players::*} to all players loop {_players::*}: set {_value} to {%loop-player%.%arg-1%} parsed as number #----------------------------# # DEBUT DU CODE UTILE # # NE MODIFIER QUE LES TEXTES # #----------------------------# En faite tout ce qu'il faut faire c'est définir les variables {_players::*} et {_value} ! Le reste du code va se charger de traiter ces variables * # les 2 lignes en dessous sont 2 sécurités à activer en cas de doute du fonctionnement du code au dessus # set {_value} to {_value} parsed as number # {_value} +1 > {_value} **N’hésitez pas à supprimer le "set {_now} to now" et la dernière ligne de code qui ne sert qu'à montrer la rapidité du code.

Bonjour ! Le titre résume très bien l'affaire, je ne sais pas si c'est très utile, mais sait-on jamais, peut-être dans un skript complexe... ? Tout est expliqué dans le code, le voici en spoiler avec un exemple pour ceux ayant la flemme de télécharger ^^: EDIT : voici quelques exemples de forme que l'équation peut prendre : 2x + 1 = 5 -5x +6 = -2 -x -4 = 2 x + 1 = 0 Vous envoyez ceci en paramètre de la fonction en faisant : set {variableTexte} to solv("2x+1=5") Et le tour est joué, la {variableTexte} contient la valeur de x selon cette fonction. Par défaut de la forme "x = ...", modifiable dans les options. Il n'y a besoin que de SkQuery, pour le fait que ce soit une fonction. Vous pouvez l'adapter comme vous voulez :) Voilà voilà :D Blueblasterz

Bonjour bonsoir, je décide aujourd'hui de partager un petit bout de code qui est la fonction factorielle. Je vous invite à mener 2/3 recherches pour comprendre cela. Je ne sais pas trop à quoi ça peut servir en Skript, mais bon on ne sait jamais :P function ffactorial(n: number) :: number: if {_n} is less than or equal to 0: return 1 else: return {_n} * ffactorial({_n} - 1) Voilà, c'est juste comme ça mais bon, Polymeth.