Aller au contenu

McLincoln2

Membre
 Afficher le profil  Afficher son activité

  • Compteur de contenus

    90

  • Inscription

  • Dernière visite

  • Jours gagnés

    8

 Type de contenu 

Messages posté(e)s par McLincoln2

    Algorithme (chunks around %location%)

    dans Fragments codes

    Posté(e)

    Cet algorithme va permettre de récupérer les chunks autour d'un joueur ou d'une position.

     

    all (chunk|land)s in [a ]rectangle of %number% by %number% around (%player%|%location%)

     

    Pour mieux comprendre, on a ceci:

    [ATTACH=full]7943[/ATTACH]

     

    Dans notre expression ci-dessus nos valeurs sont bien stockées.

    Exemple d'utilisation de l'expression:

    loop all lands in a rectangle of arg 1 by arg 2 around player:
loop all lands in a rectangle of arg 1 by arg 2 around location of player:

     

     

    Pour changer de chunk on ajoute 16 à la coordonnée X ou Z du joueur visé.

    Dans cet algorithme on va se placer dans un coin puis remonter jusqu'en haut.

    get plural expression all (chunk|land)s in [a ]rectangle of %number% by %number% around (%player%|%location%):
   set {_x} to (rounded down x-coordinate of expression 3)+0.5-16*(expression 1)
   set {_z} to (rounded down z-coordinate of expression 3)+0.5-16*(expression 2)
   loop (1+2*(expression 1)) times:
       set {_z2} to {_z}
       loop (1+2*(expression 2)) times:
           set {_chunk} to chunk at block at location ({_x}, 1, {_z2}) in world world of expression-3
           add {_chunk} to {_chunks::*}
           add 16 to {_z2}
       add 16 to {_x}
   return {_chunks::*}

     

    Résultat:

    command /chunks [<number=1>] [<number=1>]:
   trigger:
       loop all lands in a rectangle of arg 1 by arg 2 around player:
           if "%loop-value%" is "%chunk at player%":
               broadcast "§a%loop-value%"
           else:
               broadcast "%loop-value%"

    Lors de l'exécution de la commande
    /chunks 1 1
    on a:

    1520973768-capture.png

     

     

    Le chunk lors de l'action est bien trouvé et on aura toujours autant de chunk avant et après (ici = 4)

    • J'aime 1

    Demande de balancetop hardcore

    dans Inactifs

    Posté(e)

    Bonjour, je poste la solution ici:

     

    Premièrement vous allez avoir besoin de skript-mirror

    Merci à @AlexLew pour son tutoriel.

     

    Ce script contient de nouvelles expressions.

    1. loop all registered uuid
    2. loop all registered players
    3. player with registered uuid %string%

    Ces expressions vont chercher des informations dans un fichier stockant "UUID et PSEUDO" de tous les joueurs se connectant sur votre serveur dans le but de pouvoir chercher les joueurs s'étant déjà connecté mais ne l'étant pas.

     

    Vous pouvez configurer la taille de la première page, des pages suivantes et du "mini" classement affiché sur les pages autre que la première.

    options:
   firstpagesize: 10
   sizepage: 7
   topsize: 4

     

    Ce script s'applique dans le cas ou votre variable est enregistrée sur l'uuid comme '{navaria_money.%player's uuid%}'.

    Pour appliquer le script à votre variable il faut dans le cas ci-dessus faire ceci

    options:
   variable: navaria_money.

    En mettant tout ce qui précède %player's uuid%.

     

    Voilà le code.[spoiler=Plutôt court]

    options:
   firstpagesize: 10
   sizepage: 7
   topsize: 4
   variable: navaria_money.
# Permet d'avoir les UUID de tous les joueurs

get plural expression all [registered] uuid:
   set {_uuid::*} to configuration section "registered" get of "Server/registered.yml"
   return {_uuid::*}

# Permet d'avoir les PSEUDOS de tous les joueurs

get plural expression all (offline players|registered players):
   loop all registered uuid:
       set {_p} to single value "registered.%loop-value%" get of "Server/registered.yml"
       add {_p} to {_players::*}
   return {_players::*}

# Permet de retrouver un joueur avec son UUID

get expression player with [registered] uuid %string%:
   set {_p} to single value "registered.%expression-1%" get of "Server/registered.yml"
   return "%{_p}%"

join:
   loop all registered uuid:
       if loop-value is uuid of player:
           if single value "registered.%uuid of player%" get of "Server/registered.yml" is "%player%":
               stop
   set "registered.%uuid of player%" to "%player%" in yaml file "Server/registered.yml"

command /balancetop [<integer = 1>]:
   aliases: /baltop
   trigger:
       loop all registered uuid:
           set {_copy::%loop-value%} to "%{{@variable}%loop-value%}%"
       # Stockage des données (montant, uuid) ensuite pour récupérer le joueur 'player with registered uuid loop-value' et non loop-index
       # Tri des données par ordre croissant

       while size of {_copy::*} is not 0:  
           loop {_copy::*}:
               if {_maxv} is not set:
                   set {_maxv} to loop-value parsed as number
                   set {_maxi} to loop-index
               else if loop-value parsed as number is bigger or equal to {_maxv}:
                   set {_maxv} to loop-value parsed as number
                   set {_maxi} to loop-index
           add {_maxv} to {_value::*}
           add {_maxi} to {_index::*}
           do [clear {_copy::%{_maxi}%}]->[clear {_maxv}]->[clear {_maxi}]
       # Condition pour savoir si le rangement a bugué
       if size of {_value::*} is equal to (size of {_value::*} + size of {_index::*}) / 2:
           if argument is 1:
               set {_min} to 1
               set {_max} to {@firstpagesize}
           else:
               set {_min} to 1 + {@firstpagesize} + {@sizepage}*arg - 2*{@sizepage}
               set {_max} to 1 + {@firstpagesize} + {@sizepage}*arg - {@sizepage}
           loop all numbers between {_min} and {_max}:
               if {_ok} is not set:
                   if "%{_value::%loop-number%}%" is not "<none>":
                       set {_ok} to true
                       send "§f§m-----------------§f Page %arg% §f§m-----------------" to sender
                       send "## %loop-number% %player with registered uuid {_index::%loop-number%}% - %{_value::%loop-number%}%$" to sender
                   else:
                       send "§cLa page demandée n'a pas pu être affichée." to sender
                       stop
               else if {_ok} is true:
                   if "%{_value::%loop-number%}%" is not "<none>":
                       send "## %loop-number% %player with registered uuid {_index::%loop-number%}% - %{_value::%loop-number%}%$" to sender
           if argument is not 1:
               send "" to sender
               loop all numbers between 1 and {@topsize}:
                   send "## %loop-number% %player with registered uuid {_index::%loop-number%}% - %{_value::%loop-number%}%$" to sender
           execute console command "/tellraw %sender% {text:""Clique ici pour afficher la page suivante"",clickEvent:{action:run_command,value:""/baltop %arg + 1%""},hoverEvent:{action:show_text,value:""Clic""}}"
       else:
           send "§cLa page demandée n'a pas pu être affichée." to sender

     

     

     

    Cas d'utilisation:

    16 joueurs enregistrés

    1520679188-capture.png

    1520679219-capture2.png

     

    Bonne utilisation. (pti like)

    • J'aime 2

    Créer des pages avec un GUI [Facilement]

    dans Tutoriels

    Posté(e)

    Je vais passer par une fonction mais il est possible de faire la même chose avec une commande

    function Page(page: number,joueur: player)

     

    Valeurs des options:

    {_page} : la page que l'on souhaite affichée
{_joueur} : le joueur à qui on affiche la page

     

    Je note Y la hauteur que l'on dispose et X la quantité à afficher.

    X : number
Y : number

     

     

    Dans notre fonction Page il faut logiquement saisir une page existante.

    Je note nP, le nombre de page existante.

    nP = rounded up (X / (Y * 9))

     

    On aura une valeur de {_page} variant de 1 à nP, première condition de notre code trouvée

    function Page(page: number,joueur: player):
 if check [{_page} is bigger than 0]->[{_page} is smaller or equal to rounded up (X / (Y * 9))]:

     

    Admettons nos éléments X sont stockés dans une liste.

     

    Il faut donc afficher seulement les bons éléments et ne pas dépasser dans notre inventaire.

    Pour cela on doit définir un intervalle avec comme bornes les limites à dépasser et à ne pas dépasser:

    set {_index} to 0
# à chaque nouvelle boucle on ajoute 1
loop {notreliste::*}:
 # code non dévoilé
 add 1 to {_index}

     

    On aura donc comme borne

    [{_page} * (Y * 9) - Y * 9 ; {_page} * Y * 9[

     

    Exemple avec une hauteur de 4 et une page de 3:

    [3 * (5 * 9) - 5 * 9 ; 3 * 5 * 9[
[90 ; 135[

5 * 9 = 45
135 - 90 = 45

     

    Ajout des conditions dans notre fonction:

    function Page(page: number,joueur: player):
 if check [{_page} is bigger than 0]->[{_page} is smaller or equal to rounded up (X / (Y * 9))]:
   set {_index} to 0
   loop {notreliste::*}:
     if {_index} >= {_page} * (Y * 9) - Y * 9:
       if {_index} < {_page} * Y * 9:
         # create a gui slot {_index} - (Y * 9)*({_page} - 1} of {_joueur} ...
     add 1 to {_index}

     

     

     

    Bonus: Faire des items pour changer les pages:

     

    Condition pour savoir si la page {_page} n'est pas la dernière pas:

    if rounded up (size of {notreliste::*} / (Y * 9 - 9)) is bigger than {_page}:

    Condition pour savoir si la page {_page} est la dernière:

    if rounded up (size of {notreliste::*} / (Y * 9 - 9)) is equal to {_page}:

    Condition pour savoir si il y a plus d'une page disponible:

    if rounded up (size of {notreliste::*} / (Y * 9 - 9)) is bigger than 1:

     

     

    On intègre cela dans notre code et c'est terminé, vous pouvez bien sûr ajouter des conditions si vous le souhaitez, ceci est juste le minimum pour avoir un système de page fonctionnel:

    Code entier:[spoiler=Ouvrir]

    function Page(page: number,joueur: player):
 if check [{_page} is bigger than 0]->[{_page} is smaller or equal to rounded up (X / (Y * 9))]:
   set {_index} to 0
   loop {notreliste::*}:
     if {_index} >= {_page} * (Y * 9) - Y * 9:
       if {_index} < {_page} * Y * 9:
         # create a gui slot {_index} - (Y * 9)*({_page} - 1} of {_joueur} ...
     add 1 to {_index}
   if rounded up (size of {notreliste::*} / (Y * 9 - 9)) is bigger than {_page}:
     set {_next} to {_page} + 1
     # create a gui slot <slot> of {_joueur} with <item> to run function Page({_next}, sender)
   else if rounded up (size of {notreliste::*} / (Y * 9 - 9)) is equal to {_page}:
     if rounded up (size of {notreliste::*} / (Y * 9 - 9)) is not 1:
       # create a gui slot <slot> of {_joueur} with <item> to run function Page(1, sender)

     

     

     

    Code pour tester:

    function Page(page: number,joueur: player):
 if check [{_page} > 0]->[{_page} is smaller or equal to rounded up (size of {var::*} / (5 * 9))]:
   if inventory name of current inventory of {_joueur} is not "§cPage %{_page}%/%rounded up (size of {var::*} / (5 * 9))%":
     open virtual chest inventory with size 6 named "§cPage %{_page}%/%rounded up (size of {var::*} / (5 * 9))%" to {_joueur}
   wait 3 ticks
   set {_index} to 0
   loop {var::*}:
     if {_index} >= {_page} * (5 * 9) - 5 * 9:
       if {_index} < {_page} * 5 * 9:
         create a gui slot {_index} - (5 * 9) * ({_page} - 1) of {_joueur} with "%loop-value%" parsed as number of stone to do Nothing
     add 1 to {_index}
   if rounded up (size of {var::*} / (5 * 9 - 9)) is bigger than {_page}:
     set {_next} to {_page} + 1
     create a gui slot 45 of {_joueur} with paper to run function Page({_next}, {_joueur})
   else if rounded up (size of {var::*} / (5 * 9 - 9)) is not 1:
     create a gui slot 45 of {_joueur} with paper to run function Page(1, {_joueur})
command /var:
 trigger:
   loop a random integer between 123 and 321 times:
     add a random integer between 0 and 9 to {var::*}
command /menu:
 trigger:
   Page(1, sender)
command /clearvar:
 trigger:
   size of {var::*} is not 0
   clear {var::*}

    • J'aime 3

    Balancetop avec une economy.

    dans Résolus

    Posté(e)

    J'ai fais cela toute à l'heure ca peut t'intéresser, surement:[spoiler=Code]

    options:
   cmd_money: /money

   start: 30

   page_size: 8
first join:
   if {money::%uuid of player%} is not set:
       execute console command "{@cmd_money} create %player%"
   else:
       if "%{money::%uuid of player%}%" is not "%player%":
           set {money::%uuid of player%} to "%player%"
           send "§bTransfert de votre ancien compte bancaire." to player
join:
   if {money::%uuid of player%} is not set:
       execute console command "{@cmd_money} create %player%"
   else:
       if "%{money::%uuid of player%}%" is not "%player%":
           set {money::%uuid of player%} to "%player%"
           send "§bTransfert de votre ancien compte bancaire." to player
command {@cmd_money} [<text>] [<text>] [<text>]:
   trigger:
       if argument 1 is "help" or "h" or "?":
           if argument 2 parsed as number is set:
               add "§b{@cmd_money} h,help,?§3 [page=1]§f affiche l'aide" to {_commands::*}
               add "§b{@cmd_money} create§3 <uuid>§f créer un compte." to {_commands::*}
               add "§b{@cmd_money} del,delete§3 <uuid>§f supprimer un compte." to {_commands::*}
               add "§b{@cmd_money} give/take/set§3 <uuid> <amount>§f faire varier le montant d'un compte." to {_commands::*}
               add "§b{@cmd_money}§3 <uuid=you>§f voir l'argent d'un joueur." to {_commands::*}
               add "§b{@cmd_money} top§3 [page=1]§f voir le classement." to {_commands::*}
               if argument 2 parsed as number is bigger than 0:
                   if argument 2 parsed as number is smaller or equal to rounded up (size of {_commands::*} / {@page_size}):
                       send "§8§m-------------------------%nl%§8Page %argument 2 parsed as number%/%rounded up (size of {_commands::*} / {@page_size})%" to sender
                       loop {_commands::*}:
                           send "%loop-value%" to sender
                       send "§8§m-------------------------" to sender
                   else:
                       send "§cErreur: La page demandée n'a pas pu être affichée." to sender
               else:
                   send "§cErreur: La page demandée n'a pas pu être affichée." to sender
           else:
               execute sender command "{@cmd_money} ? 1"
       else if argument 1 is "create":
           if argument 2 parsed as player is set:
               execute sender command "{@cmd_money} create %uuid of argument 2 parsed as player%"
           else if argument 2 is set:
               loop all players:
                   if "%uuid of loop-player%" is "%argument 2%":
                       set {_found} to "%loop-player%"
                       exit loop
               if {_found} is set:
                   if {money::%argument 2%} is not set:
                       set {money::%argument 2%} to "%{_found}%"
                       if {money::%argument 2%::value} is not set:
                           set {money::%argument 2%::value} to {@start}
                       send "§bCréation du compte:§3 %{_found}% --> {@start}$%nl%§bChemin d'accès:§f %argument 2%" to sender and "%{_found}%" parsed as player
                   else:
                       send "§cErreur: Ce compte bancaire existe déjà." to sender
               else:
                   send "§cErreur: Aucun joueur connecté n'est associé à cet UUID." to sender
           else:
               send "§cErreur: {@cmd_money} h,help,? [page=1] pour afficher l'aide." to sender
       else if argument 1 is "del" or "delete":
           if argument 2 is set:
               if "%argument 2%" parsed as offline player is online:
                   if {money::%uuid of argument 2 parsed as offline player%} is set:
                       clear {money::%uuid of argument 2 parsed as offline player%::value}
                       clear {money::%uuid of argument 2 parsed as offline player%}
                       send "§bSuppression du compte bancaire§3 %argument 2%§b effecutée.%nl%§bAncien chemin:§f %uuid of argument 2 parsed as offline player%" to sender and argument 2 parsed as offline player
                   else:
                       send "§cErreur: Ce compte bancaire n'existe pas." to sender
               else:
                   loop {money::*}:
                       if "%loop-value%" is "%argument 2 parsed as offline player%":
                           set {_found} to "%loop-index%"
                           exit loop
                   if {_found} is set:
                       clear {money::%uuid of argument 2 parsed as offline player%::value}
                       clear {money::%uuid of argument 2 parsed as offline player%}
                       send "§bSuppression du compte bancaire§3 %argument 2%§b effecutée.%nl%§bAncien chemin:§f %uuid of argument 2 parsed as offline player%" to sender
                   else:
                       send "§cErreur: Ce compte bancaire n'existe pas." to sender
           else:
               send "§cErreur: {@cmd_money} h,help,? [page=1] pour afficher l'aide." to sender
       else if argument 1 is "take" or "give" or "set":
           if argument 2 is set:
               if argument 3 parsed as number is set:
                   loop {money::*}:
                       if "%loop-value%" is "%argument 2 parsed as offline player%":
                           set {_found} to "%loop-index%"
                           exit loop
                   if {_found} is set:
                       if argument 1 is "take":
                           if {money::%uuid of argument 2 parsed as offline player%::value} is bigger or equal to argument 3 parsed as number:
                               set {_money} to argument 3 parsed as number * -1
                       else if argument 1 is "give":
                           set {_money} to argument 3 parsed as number
                       if argument 1 is "take" or "give":
                           if "%sender%" is not "%argument 2%":
                               send "§bNouveau montant du joueur§3 %argument 2%§b:§3 %{money::%uuid of argument 2 parsed as offline player%::value} + {_money}%$%nl%§f%{_money}%$" to sender and argument 2 parsed as player
                           else:
                               send "§bNouveau montant du joueur§3 %argument 2%§b:§3 %{money::%uuid of argument 2 parsed as offline player%::value} + {_money}%$%nl%§f%{_money}%$" to sender
                           set {money::%uuid of argument 2 parsed as offline player%::value} to {money::%uuid of argument 2 parsed as offline player%::value} + {_money}
                       else if argument 3 parsed as number is bigger or equal to 0:
                           if "%sender%" is not "%argument 2%":
                               send "§bNouveau montant du joueur§3 %argument 2%§b:§3 %argument 3 parsed as number%$" to sender and argument 2 parsed as player
                           else:
                               send "§bNouveau montant du joueur§3 %argument 2%§b:§3 %argument 3 parsed as number%$" to sender
                           set {money::%uuid of argument 2 parsed as offline player%::value} to argument 3 parsed as number
                       else:
                           send "§cErreur: Un compte bancaire ne peut être négatif." to sender
                   else:
                       send "§cErreur: Ce compte bancaire n'existe pas." to sender
               else:
                   send "§cErreur: {@cmd_money} h,help,? [page=1] pour afficher l'aide." to sender
           else:
               send "§cErreur: {@cmd_money} h,help,? [page=1] pour afficher l'aide." to sender
       else if argument 1 is "top":
           if argument 2 parsed as number is set:
               if argument 2 parsed as number is bigger than 0:
                   if argument 2 parsed as number is smaller or equal to rounded up (size of {money::*} / {@page_size}):
                       loop {money::*}:
                           set {_liste::%loop-value%} to {money::%loop-index%::value}
                       while size of {_liste::*} is not 0:
                           loop {_liste::*}:
                               if {_max} is not set:
                                   set {_max} to loop-value
                                   set {_index} to loop-index
                               else if loop-value is bigger or equal to {_max}:
                                   set {_max} to loop-value
                                   set {_index} to loop-index
                           clear {_liste::%{_index}%}
                           add {_max} to {_value::*}
                           add {_index} to {_account::*}
                           do [clear {_max}]->[clear {_index}]
                       set {_index} to 0
                       send "§8§m-------------------------%nl%§8Page %argument 2 parsed as number%/%rounded up (size of {money::*} / {@page_size})%" to sender
                       loop size of {money::*} times:
                           if {_index} >= argument 2 parsed as number * {@page_size} - {@page_size}:
                               if {_index} < argument 2 parsed as number * {@page_size}:
                                   set {_checked} to {_index} + 1
                                   send "§b##%{_checked}% - %{_account::%{_checked}%}%:§f %{_value::%{_checked}%}%$" to sender
                               else:   
                                   exit loop
                           add 1 to {_index}
                       send "§8§m-------------------------" to sender
                   else:
                       send "§cErreur: La page demandée n'a pas pu être affichée." to sender
               else:
                   send "§cErreur: La page demandée n'a pas pu être affichée." to sender
           else:
               execute sender command "{@cmd_money} %argument 1% 1"
       else if argument 1 is not set:
           execute sender command "{@cmd_money} %player%"
       else:
           loop {money::*}:
               if "%{money::%uuid of argument 1 parsed as offline player%}%" is "%argument 1%":
                   set {_found} to loop-index
                   exit loop
           if {_found} is set:
               send "§bArgent de§3 %argument 1%§b:§f %{money::%uuid of argument 1 parsed as offline player%::value}%$" to sender
           else:
               send "§cErreur: Ce compte bancaire n'existe pas." to sender

     

     

    Code testé et fonctionnel, bonne journée.

    • J'aime 1

    On rightclick on " objet moddé ":

    dans Résolus

    Posté(e)

    Fais des tests par exemple:

    rightclick:
 broadcast "%targeted block%"

    Par exemple après tu compares le format texte avec un autre:

    rightclick:
 "%targeted block%" is "tonbloc":
   # suite du code

    Malheureusement si "%targeted block%" c'est "<none>", essaie avec ces positions, toujours des solutions.

    Skript : Perte de stuff ou pas sur un joueur

    dans Inactifs

    Posté(e) 

    death:
 Victim has permission "save.stuff"
   Loop all numbers between 0 and 35:
     If slot loop-number of victim is not "air":
       set {deathslot.%victim%::%loop-number%} to slot loop-number of victim
     If "%victim's helmet%" is not "air" or "<none>":
       Set {deathslot.%victim%::helmet} to victim's helmet
     # pareil pour chestplate, leggings et boots
   Clear dropped items
Respawn:
 Size of {deathslot.%player%::*} is not 0:
   Loop {deathslot.%victim%::*}:
     If "%loop-index parsed as number%" is not "<none>":
       Set slot loop-index parsed as number of playrr to "%loop-value%" parsed as item
     Else:
       If "%loop-index%" is "helmet":
         Set player's helmet to "%loop-value%" parsed as item
     # pareil pour chestplate, leggings et boots
   Clear {deathslot.%victim%::*}

    Tournois Sumo

    dans Inactifs

    Posté(e) 

    options:
   ypos: 10
join:
   set slot 5 of player to book named "§6Tournament Create" with lore "§7Right-Click"
click with book:
   if name of tool is "§6Tournament Create":
       cancel event
       if {creator} is not set:
           lore of tool is "§7Right-Click"
           player has permission "tournament.create"
           set {_s} to 60
           set {creator} to "%sender%"
           while {_s} is not 0:
               if {_f} is set:
                   delete {_f}
               else if {_s} is 60 or 30 or 10 or 5:
                   loop all players:
                       send "§6Tournament (§eSumo§6) will start in few seconds, minimum %{_s}% seconds.%nl%§b/tournament join§e to join tournament" to loop-player
               if size of {tournament::*} is bigger or equal to 3:
                   remove 1 from {_s}
               else:
                   set {_s} to 60
                   set {_f} to true
               wait a second
           loop {tournament::*}:
               set {_copy::%loop-index%} to "%loop-value%"
               teleport loop-index parsed as player to {spectatingroom}
           set {start} to true
           while size of {tournament::*} is bigger than 1:
               loop {tournament::*}:
                   set {_copy::%loop-index%} to "%loop-value%"
               set {_player1} to a random element of {_copy::*}
               set {_player1} parsed as player's display name to "§a%{_player1}%"
               delete {_copy::%{_player1}%}
               set {_player2} to a random element of {_copy::*}
               set {_player2} parsed as player's display name to "§c%{_player2}%"
               set {_copy::%{_player1}%} to "%{_player1}%"
               loop all players:
                   if {tournament::%loop-player%} is set:
                       if "%loop-player%" is not "%{_player1}%":
                           if "%loop-player%" is not "%{_player2}%":
                               send "§6Picked players:§e %{_player1}%§6,§e %{_player2}%" to loop-player
                           else:
                               send loop-player title "§cPicked !"
                               clear loop-player's inventory
                               teleport loop-player to {tournamentpostion.2}
                       else:
                           send loop-player title "§cPicked !"
                           clear loop-player's inventory
                           teleport loop-player to {tournamentpostion.1}
               set {_statut} to true
               while {_statut} is set:
                   if "%{_player1}%" parsed as offline player is online:
                       if "%{_player2}%" parsed as offline player is online:
                           if y-coordinate of "%{_player1}%" parsed as player is bigger than {@ypos}:
                               if y-coordinate of "%{_player2}%" parsed as player is bigger than {@ypos}:
                                   add 1 to {_time}
                                   wait 1 second
                               else:
                                   delete {_statut}
                                   delete {_copy::%{_player2}%}
                                   set {_m} to "§bElimined player(s):§c %{_player2}%"
                           else:
                               delete {_statut}
                               delete {_copy::%{_player1}%}
                               set {_m} to "§bElimined player(s):§c %{_player1}%"
                       else:
                           delete {_statut}
                           delete {_copy::%{_player2}%}
                           set {_m} to "§bElimined player(s):§c %{_player2}%"
                   else:
                       delete {_statut}
                       delete {_copy::%{_player1}%}
                       set {_m} to "§bEliminated player(s):§c %{_player1}%"
               if "%{_player1}%" parsed as offline player is offline:
                   delete {_copy::%{_player1}%}
               if "%{_player2}%" parsed as offline player is offline:
                   delete {_copy::%{_player2}%}
               loop {tournament::*}:
                   if {_copy::%loop-index%} is not set:
                       clear {tournament::%loop-index%}
                       teleport loop-index parsed as player to {spawn}
               loop all players:
                   if {tournament::%loop-player%} is set:
                       send "%{_m}%" to loop-player
               delete {_m}
               delete {_player1}
               delete {_player2}
           delete {creator}
           delete {start}
           if size of {tournament::*} is not 0:
               loop {tournament::*}:
                   set {_winner} to "%{tournament::%loop-index%}%"
           else:
               stop
           loop all players:
               send "§6Tournament is now ended, winner is §a%{_winner}%" to loop-player
           clear {tournament::*}
       else:
           send "§6Tournament will start, sorry." to sender
   else if name of tool is "§6Tournament info":
       cancel event
       lore of tool is "§7Right-Click"
       loop {tournament::*}:
           if {_t} is not set:
               set {_t} to "§6Player(s) [§e%size of {tournament::*}%/12§6]:§e %{tournament::%loop-index%}%"
           else:
               set {_t} to "%{_t}%§6,§e %{tournament::%loop-index%}%"
       send "§6Tournament's creator:§e %{creator}%%nl%%{_t}%" to sender
quit:
   {tournament::%player%} is set:
       clear {tournament::%player%}
click with redstone torch:
   name of tool is "§cLeave tournament":
       cancel event
       if {tournament::%player%} is set:
           clear player's inventory
           wait 3 ticks
           # remet ton inventaire ici 'set slot <slot> of player to <item> named "<text>" with lore "<text>"
           clear {tournament::%player%}
           teleport player to {spawn}
command /queue <text>:
   permission: tournament.create
   trigger:
       if arg is "setspawn":
           send "§6Tournament Sumo's waiting room is now set where you are." to sender
           set {waitingroom} to position of sender
       else:
           send "§cCorrect usage: /queue setspawn" to sender
command /waitfight <text>:
   permission: tournament.create
   trigger:
       if arg is "setspawn":
           send "§6Tournament Sumo's spectating room is now set where you are." to sender
           set {spectatingroom} to position of sender
       else:
           send "§cCorrect usage: /waitfight setspawn" to sender
command /tournament <text> [<number>]:
   trigger:
       arg 2 is not set:
           arg 1 is "join":
               {start} is not set
               {creator} is set
               {tournament::%sender%} is not set:
                   size of {tournament::*} is smaller than 12
                   set {tournament::%sender%} to "%sender%"
                   loop all players:
                       {tournament::%loop-player%} is set
                       send "§3%sender%§b joins tournament§3 (%size of {tournament::*}%/12)" to loop-player
                   clear sender's inventory
                   wait 3 ticks
                   set slot 4 of sender to book named "§6Tournament info" with lore "§7Right-Click"
                   set slot 8 of sender to redstone torch named "§cLeave tournament"
                   teleport player to {waitingroom}
       arg 1 is "setspawn":
           player has permission "tournament.create":
               arg 2 is 1 or 2:
                   set {tournamentpostion.%arg 2%} to position of sender
                   send "§6Tournament Sumo's position number %arg 2% is now set where you are." to sender
               else:
                   send "§cCorrect usage: /tournament setspawn 1/2"

    Il se peut que j'ai terminé, si tu veux préciser certaines choses viens sur ce teamspeak:

    ts.hadside.fr

     

    Un double while c'est pas tous les jours, si ?

    • J'aime 2
×
×
  • Créer...

Information importante

Nous avons placé des cookies sur votre appareil pour aider à améliorer ce site. Vous pouvez choisir d’ajuster vos paramètres de cookie, sinon nous supposerons que vous êtes d’accord pour continuer.