GUI Manager - Syst3ms/TuSKe GitHub Wiki

GUI Manager

À propos:

Le GUI Manager est une API simple qui permet de facilement créer des guis avec la meilleure performance possible. Il y a **deux types** disponibles: **gui simple** et **gui avancé**. Si vous êtes un débutant ou que vous voulez simplement un **gui simple**, choisissez la première option. Sinon, vous pouvez essayer le **gui avancé**.

<details><summary>GUI simple - Les fonctionnalités les plus basiques, mais assez pour créer vos propres guis facilement</summary> <br>

**Syntaxe**:

<details><summary>Ouvrir l’inventaire</summary> <p>

#Effet
open {virtual %inventory type% inventory [with size %integer%] [(named|with (name|title)) %string%]} to %players%

#Seulement l'expression entre accolades, qui retourne un inventaire vide, est de TuSKe
#Le reste est juste l'effet de Skript vanilla

</p></details> <details><summary>Créer un GUI</summary> <p>

#Effets
(format|create|make) [a] gui slot %integers% of %players% with %item stack% [to [do] nothing]

(format|create|make) [a] gui slot %integers% of %players% with %item stack% to close [(using|with) %click action% [(button|click|action)]]

(format|create|make) [a] gui slot %integers% of %players% with %item stack% to [close then] (run|exe[cute]) %sender% command %string% [with permission %string%] [(using|with) %click action% [(button|click|action)]] [(using|with) cursor [item] %item stack%]

(format|create|make) [a] gui slot %integers% of %players% with %item stack% to [close then] (run|exe[cute]) function %function% [(using|with) %click action% [(button|click|action)]] [(using|with) cursor [item] %item stack%]

#Déprécié : explication ci-dessous
(format|create|make) [a] gui slot %integers% of %players% with %item stack% to (run|exe[cute]) [gui [click]] event

#Nouveauté de la 1.7.5 (voir ci-dessous)
(format|create|make) [a] gui slot %numbers% of %players% with %itemstack% to (run|exe[cute]) [(using|with) %click action% [(button|click|action)]]
<p></details> <details><summary>Enlever un GUI</summary> <p> 
#Effets
(unformat|remove) [the] gui slot %integers% of %players%

(unformat|remove) [all] [the] gui slots of %players%
<p></details> <details><summary>Conditions</summary> <p> 
%player% has [a] gui
%player% does(n't| not) have [a] gui

slot %number% of %player% is [a] gui
slot %number% of %player% is(n't| not) [a] gui
<p></details> <br>

**Ce que les effets font**:

Il y a 4 types d’actions : `do nothing` (alias `unstealable` de SkQuery), `run command`, `run function` and `run code`.

Les 3 premiers types ont une option pour fermer le GUI lors d’un clic ; pour faire ça, incluez simplement `to close`. Il est également possible de n’exécuter l’action que si l’on clique d’une certaine façon ; pour faire ça, incluez juste `using %clicktype%`. Types de clic possibles: <details><summary>Types de clic</summary> <p>

left [mouse button]
right [mouse button]
(shift left|left mouse button with shift)
(shift right|right mouse button with shift)
double click [using mouse]
middle [mouse button]
number key
drop [key]
(control drop|drop key with control)
</p></details> <br>

`run command` et `run function` ont une possibilité de ne s’exécuter que si le joueur clique avec un certain item dans sont curseur. Pour ça, incluez `(using|with) cursor [item] %itemstack%`.

`Run command` vous permet d’exécuter une commande quand on cliquee ; on peut choisir entre `console` et `player` pour le `sender` (celui qui exécute la commande). On peut également ajouter `with permission %string%` (qui n’a d’effet que quand le `sender` est `player`), ce qui fera exécuter la commande par le joueur avec une certaine permission, qui disparaîtra immédiatement après l’exécution de la commande. **NOTE** : Utiliser une permission est plus sûr que le `as op` pouvant avoir été utilisé avec skQuery. **Astuce** : Pour répliquer l’effet de ce dernier, utilisez `with permission “*”`, `*` étant la permission d’avoir toutes les permissions

`Run function` permet d’exécuter une fonction quand on clique. Le format est exactement le même que celui pour appeler une fonction dans Skript : `<nom de la fonction>(<paramètres s’il y en a>)`.

Le `run code` est beaucoup plus simple :il exécute le code à l’intérieur d’un effet `format gui slot`, ce qui supprime le besoin de créer un fonction ou une commande. Pour cette raison, l’utilisation de `to run gui click event` est découragée. Vous pouvez utiliser les event-values de l’event `on inventory click` provenant de n’importe quel addon ou utiliser les expressions intégrées à TuSKe pour ça (voir `Expressions de GUI` dans `GUI avancé`). Elles requièrent la version `1.7.5` ou plus.

<details><summary>Exemple</summary> <br>

open virtual chest to player
format gui slot 0 of player with stone to run:
    send "Ce message sera envoyé quand le joueur clique"
format gui slot 1 of player with arrow to close with middle click:
    send "Ce message sera envoyé après avoir été fermé si le joueur clique avec sa molette"
format gui slot 2 of player with diamond to run using left click:
    if gui-cursor-item is a stone: # si le curseur est de la stone
        set gui-clicked-item to gui-cursor-item # l'item cliqué devient l'item du curseur
        set gui-cursor-item to air # et ce dernier est supprimé
</details> <br>

**Structure basique**:

Pour créer un gui, vous devez suivre deux étapes simples:

Utiliser n’importe quel effet pour ouvrir un inventaire

Utiliser n’importe quel effet parmi ceux ci-dessus pour formatter un gui

Voici un exemple type de code <br>

**Exemples**:

<details><summary>Test de tous les effets</summary> <p>

command /gui:
    trigger:
        if sender is console:
            broadcast "Exécuté par la console!"
            stop
        if player has permission "*":
            send "Le joueur a exécuté cette commande avec la permission ""*"""
            wait a tick
            if player doesn't have permission "*":
                send "Le joueur n'a plus la permission."
            else:
                send "Le joueur a toujours la permission, c'est sans doute un OP"
        else:
            send "Le joueur a exécuté la commande sans permission"
                        
command /guiExample:
    trigger:
        open virtual chest inventory to player
        format gui slot 0 of player with stone named "Ne fera rien"
        format gui slot 1 of player with stone named "Ne fera que se fermer" to close
        format gui slot 2 of player with stone named "Se fermera que si on clique avec une touche de nombre" to close using number key
        format gui slot 3 of player with stone named "Cela va exécuter une commande par le joueur, mais il n'aura peut-être pas la permission" to run player command "/gui"
        format gui slot 4 of player with stone named "Cela va exécuter une commande avec la permission ""*"" par le joueur" to run player command "/gui" with permission "*"
        format gui slot 5 of player with stone named "Cela va exécuter la commande par la console" to run console command "/gui"
        format gui slot 6 of player with stone named "Va exécuter la fonction faireQuelqueChose()" to run function faireQuelqueChose()
        format gui slot 7 of player with stone named "Va fermer le gui et exécuter faireQuelqueChose()" to close then run function faireQuelqueChose()
        format gui slot 8 of player with stone named "Va exécuter faireQuelqueChose() si on clique avec une pierre" to run function faireQuelqueChose() with cursor stone
        format gui slot 9 of player with stone named "Va exécuter l'event de GUI" to run gui event # Déprécié
        format gui slot 10 of player with stone named "Va exécuter la code ci-dessous":
            send "Salut." to player
            give a stone to player
            heal player
        
function faireQuelqueChose(i: int = 0): #TuSKe pourra exécuter la fonction même si elle a été chargée après
    broadcast "Et ça l'a fait"
                
on gui click: # Déprécié
    send "Exécuté via un event séparé"
</p></details> <details><summary>Exemple d’actions multiples</summary> <p>

L’exemple ci-dessous montre comment exécuter différentes actions dépendamment du type de clic

function changerNom(p: Player, clicktype: String):
    set {_number} to name of slot 4 of {_p}'s current inventory parsed as number #Requiert SkQuery ou les versions de Bensku
    if {_clicktype} is "gauche":
        remove 1 from {_number}
    else if {_clicktype} is "shift gauche":
        remove 100 from {_number}
    else if {_clicktype} is "droit":
        add 1 to {_number}
    else if {_clicktype} is "shift droit":
        add 100 to {_number}
    set name of slot 4 of {_p}'s current inventory to "%{_number}%"

command /multiactionExample:
    trigger:
        open virtual dispenser inventory named "Multi-action example" to player
        set {_item} to diamond named "1"
        set line 1 of lore of {_item} to "&7Clic gauche : enlève 1"
        set line 2 of lore of {_item} to "&7Shift clic gauche: enlève 100"
        set line 3 of lore of {_item} to "&7Clic droit : ajoute 1"
        set line 4 of lore of {_item} to "&7Shift clic droit : ajoute 100"
        format gui slot 4 of player with {_item} to run function changerNom(player, "gauche") with "left" click
        format gui slot 4 of player with {_item} to run function changerNom(player, "shift gauche") with "shift left" click
        format gui slot 4 of player with {_item} to run function changerNom(player, "droit") with "right" click
        format gui slot 4 of player with {_item} to run function changerNom(player, "shift droit") with "shift right" click
<p></details> <details><summary>GUI à plusieurs pages</summary> <p> 
function ouvrirMenu(p: Player, type: String):
    if {_type} is "page 1":
        open virtual chest inventory with size 1 named "Page 1" to {_p}
        make a gui slot 0 of {_p} with stone named "Aller à la page 2" to run function ouvrirMenu({_p}, "page 2")
    else if {_type} is "page 2":
        open virtual chest inventory with size 1 named "Page 2" to {_p}
        make a gui slot 0 of {_p} with stone named "Aller à la page 3" to run function ouvrirMenu({_p}, "page 3")
   #Et pareil jusqu'à la dernière page
    else if {_type} is "page 3":
        open virtual chest inventory with size 1 named "Page 3" to {_p}
        make a gui slot 0 of {_p} with stone named "Revenir à la page 1" to run function ouvrirMenu({_p}, "page 1")
</p></details> <br>

**Things you should know**:

  • Si vous voulez changer un item après qu’il ai déjà été formatté, pas besoin de le re-formatter, utilisez juste n’importe quel effet pour changer un item dans un inventaire. Par exemple, `set slot 0 of player’s current inventory to {_nouvelItem}`.
  • Si vous formattez un slot avec de l’air, un slot vide et verouillé sera créé. Le joueur ne peut pas non plus y placer un item
  • Vous pouvez formatter le même slot avec le même item mais une différente action ; une commande avec un clic droit et une fonction avec un clic gauche, par exemple.
  • Dans l’event `on gui click`, vous devrez utiliser la condition `the name of event-inventory is the gui name that you want`, car plusieurs scripts peuvent utiliser à la fois.
  • utiliser `uncancel event` dans l’event `on gui click` permettra au joueur d’enlever l’item et de verrouiller le slot après pour la raison ci-dessus. Si vous ne voulez pas que le slot soit verrouillé, utilisez `unformat gui slot event-number of player`
  • À partir de la version 1.7.2 de TuSKe, les fonctions utilisées dans `to run function` n’ont pas nécessairement à être déclarées au dessus.
  • À partir de la version 1.7.5 de TuSKe, vous pouvez exécuter du code directement sous l’effet. Voir exemples ci-dessus

</details> <br> <details><summary>GUI avancé - Plus de ressources, qui permettent de faire des guis plus rapidement et proprement</summary> <br>

Syntaxes:

Se familiariser avec les syntaxes

<details><summary>Créer/éditer un GUI</summary> <p>

#Expression pour créer un inventaire
#Elles font toutes la même chose, il y en a plusieurs pour mettre à disposition tous les usages possible de la syntaxe
virtual %inventorytype% [inventory] [with size %-number%] [(named|with (name|title)) %-string%]
virtual %inventorytype% [inventory] [with %-number% row[s]] [(named|with (name|title)) %-string%]
virtual %inventorytype% [inventory] [(named|with (name|title)) %-string%] with size %-number%
virtual %inventorytype% [inventory] [(named|with (name|title)) %-string%] with %-number% row[s]

#Effets
create [a] [new] gui [[with id] %-string%] with %inventory% [and shape %-strings%]
(change|edit) %guiinventory%

</p></details>

<details><summary>Formatter un GUI</summary> <p>

(make|format) next gui [slot] (with|to) %itemstack%
(make|format) gui [slot] %strings/numbers% (with|to) %itemstack%

</p></details> <details><summary>Fermer un GUI</summary> <p>

#C'est un effet qui va exécuter du code quand le gui est fermé
run (when|while) clos(e|ing) [gui]

</p></details>

<details><summary>Changer les propriétés du GUI</summary> <p>

#Change les propriétés d'un gui, comme le nom et la taille de l'inventaire ou l'arrangement des items
change gui inventory to name %string% and size %number%
change gui shape [of (items|actions)] to %strings%
change gui properties of inventory to name %string% [with %-number% row[s]] and shape [of (items|actions)] to %strings%

</p></details>

<details><summary>GUI Expressions</summary> <p>

#Expressions générales
last[ly] [created] gui #Retourne le gui le plus récemment créé. Est dépendant de l'event, comme une variable locale
gui [with id] %string% #Retourne un gui à partir d'un identifiant

#GUI expressions (voir plus loin)
# Retourne le numéro du slot cliqué
gui-slot 

# Retourne le slot cliqué "cru"
# Un nombre de 0 à la taille de l'inventaire du haut veut dire un slot de l'inventaire du haut
# Un nombre supérieur ou égal à la taille de l'inventaire du haut + 1 veut dire un sloot de l'inventaire du joueur.
# Pas encore utilisé, simplement une option qui pourra devenir utile dans le futur
gui-raw-slot 

# Le numéro correspondant si le type de clic est "number key"
gui-hotbar-slot

# L'inventaire impliqué dans l'action
gui-inventory

# L'action d'inventaire (valeurs listées ci-dessous)
gui-inventory-action

# Le type de clic
gui-click-(type|action)

# L'item dans le curseur et l'item cliqué. Ces deux expressions sont modifiables (add/remove/set/clear/delete)
gui-cursor
gui-[(clicked|current)-]item

# Le type de slot (pas de grande utilité)
gui-slot-type

# Le joueur qui a cliqué
gui-player

# La liste de tous les joueurs pour qui le gui actuel est ouvert
gui-players

# Le nom de l'inventaire (pareil que "name of event-inventory")
gui-inventory-name

# L'identifiant texte du slot, voir ci-dessous
gui-slot-id

# L'objet du gui lui-même, permettant de le modifier
gui

</p></details>

<details><summary>Types</summary> <p>

gui inventory: Représente un inventaire de gui, ce type est seulement utilisé quand on édite un gui déjà créé

click (type|action): Représente un type de clic dans un event de `on inventory click`. À partir de la 1.7.4-beta/1.7.5, il utilise les valeurs de Bensku pour compatibilité.
Valeurs: left [mouse button], (shift left|left mouse button with shift), right [mouse button], (shift right|right mouse button with shift), middle [mouse button], number key, double click [using mouse], drop [key], (control drop|drop key with control)

inventory action: Représente une action d'inventaire (=/= type de clic). À partir de la 1.7.4-beta/1.7.5, il utilise les valeurs de Bensku pour compatibilité.
Valeurs: nothing, pickup all, pickup some, pickup half, pickup one [item], place all, place some, place one, swap with cursor, drop all [from] cursor, drop one [from] cursor, drop all [from] slot, drop one [from] slot, (move to other inventory|instant move), hotbar move and read, (hotbar swap|swap with hotbar), clone stack, collect to cursor, unknown

slot type: Représent le type d'un slot dans un event de `on inventory click`
Valeurs: armor, container, crafting, fuel, outside, quickbar, result
Si vous utilisez les versions de Bensku, référez vous aux valeurs de [click action](http://bensku.github.io/Skript/classes.html#clickaction) et [inventory action](http://bensku.github.io/Skript/classes.html#inventoryaction) dans sa documentation. TuSKe n’utilise les mêmes valeurs que si vous utilisez une version ancienne. </p></details>

Comment créer un gui

D’abord, ce système de guis utilise un nouveau format pour en créer un : au lieu d’ouvrir l’inventaire puis de formatter les slots, on crée un gui puis on l’ouvre au joueur. Il faut d’abord la base pour le créer: 

create [a] [new] gui ) [[with id] %-string%] with %inventory% [and shape %-strings%]
create a gui with virtual chest with 6 rows named "&4Select the server"
Maintenant, quelque chose de nouveau : des effets dans des effets. NDLR : Ceci étant une traduction, vous entendrez l’avis de Tuke-Nuke. Personellement, je pense que c’est des éléments à part, comme Tlatoani (développeur de MundoSK) En utilisant ce concept, vous devez y utiliser l’effet `Make GUI` à l’intérieur. Exemple : 
create a gui with virtual chest with 6 rows named "&4Select the server":
    #Syntaxes:
    # (make|format) next gui [slot] (with|to) %itemstack%
    # (make|format) gui [slot] %strings/numbers% (with|to) %itemstack%
    make next gui with diamond sword named "&4PvP server" # It will format the next free slot that is not formatted yet.
    make next gui with grass named "&aSkyBlock"
Pour le moment, c’est juste un item verrouillé (comme le `to do nothing` de la v1). Au lieu d’utiliser des commandes ou des fonctions, vous pouvez maintenant utiliser du code Skript directment (des effets dans des effets dans des effets ? Effet-ception !). NDLR : Idem, c’est toujours l’avis de Tuke-Nuke Pour faire ça, mettez simplement la code **à l’intérieur** de l’effet, comme si c’était une boucle ou une condition : 
create a gui with virtual chest with 6 rows named "&4Select the server":
    make next gui with diamond sword named "&4PvP server":
        send "You will be teleported to the Pvp server"
        execute player command "/server pvp"
    make next gui with grass named "&aSkyBlock":
        send "You will be teleported to the Skyblock server"
        execute player command "/server skyblock"
Maintenant, vous n’avez qu’à ouvrir le gui déjà créé au joueur en utilisant l’expression `last[ly] [created] gui` + l’effet `open inventory` to player: 
open last gui to player
Et voilà, le gui le plus basique se résume à ça. Voici ce à quoi votre code devrait ressembler : 
command /servers:
    trigger:
        create a gui with virtual chest with 6 rows named "&4Choix de serveur":
            make next gui with diamond sword named "&4Serveur PvP":
                send "Vous allez être tp au serveur PvP"
                execute player command "/server pvp" # exemple
            make next gui with grass named "&aSkyBlock":
                send "Vous allez être tp au serveur SkyBlock"
                execute player command "/server skyblock" #exemple
        open last gui to player

Il y a aussi un effet pour exécuter du code quand le gui est fermé 

create new gui with virtual chest named "Sac à dos":
    run when close the gui: # Ce code va être exécuté AVANT d'enlever les items
        set {Variable::%gui-player%::*} to all items of gui-inventory

Les event-values de `on inventory click`

Maintenant, vous pouvez utiliser les **event-values** de l’event `on inventory click` même hors de l’event, au cas où vous avez un addon qui a ces event-values. 

create a gui with virtual chest with 6 rows named "&4Choix de serveur":
    make next gui with diamond sword named "&4Serveur PvP":
        send "%clicked item%" #Umbaska
Mais pour ne pas vous en rendre dépendant, TuSKe apporte ses propres expressions (voir `GUI Expressions` ci-dessus). Exemple : 
create a gui with virtual chest with 6 rows:
    make next gui with glass:
        if gui-click-action is left mouse buttom or right mouse buttom:
            set gui-clicked-item to gui-cursor-item
            set gui-cursor-item to air
            # Seuls ces deux expressions peuvent être changées

GUIs globaux

Maintenant vous pouvez créer des guis globaux grâce à un identifiant texte 

on skript load:
    create a gui with virtual chest with 6 rows named "&4Choix de serveur":
        make next gui with diamond sword named "&4Serveur PvP":
            send "Vous allez être tp au serveur PvP"
            execute player command "/server pvp" # exemple
        make next gui with grass named "&aSkyBlock":
            send "Vous allez être tp au serveur SkyBlock"
            execute player command "/server skyblock" #exemple

command /servers:
    trigger:
        open gui "HUB" to player
**NOTE**: **Tous les guis (globaux ou locaux) partagent le même inventaire**. Cela veut dire que si vous changez un item pour un joueur, alors il changera pour tous les joueurs.

Le meilleur usage pour les guis globaux sont des guis “statiques” (un sélecteur de serveur ou un gui pour montrer les stats d’une faction, par exemple), où les valeurs ne dépendent pas du joueur. Vous pouvez aussi créer des guis globaux par joueur pour ne pas avoir à les recréer à chaque fois, mais **n’oubliez pas de supprimer un gui quand il n’est plus utilisé (quand un joueur dee déconnecte par exemple)**: 

on quit:
    delete gui "PlayerStats.%player%"
    # Va supprimer le gui et le fermer s'il est ouvert pour un joueur

Editer un GUI

Si vous voulez éditer un gui, en reformattant un slot ou changer les propriétés du gui (plus d’infos dessous), vous pouvez juste utiliser l’effet `edit` au lieu de `create`. 

command /edit:
    trigger:
        edit gui "HUB":
            # L'item va automatiquement se changer si le GUI est ouvert pour un joueur
            make gui 0 with diamond sword named "Le serveur PvP est en maintenance."

GUIs avec forme

Pour rendre vos guis simples et modulable, vous pouvez utiliser des formes. Ces formes utilisent le même concept que **les formes des recettes de craft** : un caractère représente un slot d’un inventaire. Avec ça, il devient plus simple de faire des **guis dynamiques personnalisés**. 

#syntax: create [a] [new] gui [[with id] %string%] with %inventory% [and shape %strings%]
add "xxxxxxxxx" to {_forme::*}
add "x--------x" to {_forme::*}
add "xxxxxxxxx" to {_forme::*}
create a gui with virtual chest and shape {_forme::*}
Imaginez que les textes ci-dessus représentent un inventaire. Chaque slot qui est représenté par le même caractère sera le même, donc quand ils seront formattés et que le joueur clique, alors ils auront le même item et la même action. 
add "xxxxxxxxx" to {_forme::*}
add "x--------x" to {_forme::*}
add "xxxxxxxxx" to {_forme::*}
create a gui with virtual chest and shape {_forme::*}:
    make gui slot "x" with iron ingot
    make gui slot "-" with diamond
Regardez les exemples dessous pour en voir l’utilité.

Changer les propriétés d’un GUI

Ces effets vous aideront à changer l’inventaire du GUI proprement. Vous devez les utiliser dans `(edit|change) %gui inventory%` (Il n’est pas nécessaire de changer lors de la création). NDLR : la phrase entre parenthèses est possiblement incorrecte, la phrase originale en anglais n’ayant pas trop de sens 

#Syntaxes:
change gui inventory to name %string% and size %number%
change gui shape [of (items|actions)] to %strings%
change gui properties of inventory to name %string% [with %-number% row[s]] and shape [of (items|actions)] to %strings%
La **première* permet simplement de changer le nom et la taille si c’est un coffre d’un gui. Pas grand chose d’autre à dire. La **deuxième** est plus complexe : elle permet de changer l’arrangement des items, leur action, ou les deux. Prenons ce gui pour exemple: 
create new gui with id "Exemple" with virtual hopper and shape "ABCDE": # vous pouvez créer la forme en une ligne
    loop 9 times:
        make next gui with a random item of all items
open last gui to player
**/!\ ATTENTION /!\** : cette forme n’est pas la même que celle dont nous avons parlé au dessus.

En utilisant `change gui shape of items <…>`, vous devez utiliser une forme où on bouge un slot X vers un autre slot Y. En utilisant la forme `EABCD`, notez que `E` a été déplacé vers le premier slot et que les autres ont été décalés vers la droite. Donc : 

edit last gui:
    loop 10 times:
        wait 1 second
        change gui shape of items to "EABCD"
va décaler tous les items vers le slot de `droite`.

En utilisant `change gui shape of actions <…>`, on va uniquement changer les actions des items, donc :

  • si on a un gui avec deux slots et la forme `AB` et qu’on change la forme des actions à `BA`, l’action exécutée dans le slot 0 précédemment sera exécutée dans le slot 1 maintenant.

En utilisant `change gui shape to <…>` on va changer les items et les actions à la fois.

C’est comme utiliser les deux syntaxes précédentes à la fois.

Choses à savoir:

On ne peut pas utiliser des event-values dans le code à exécuter en cas de click

  • Pour éviter ça, utilisez une variable temporaire 
    command /example <text>:
    trigger:
        set {_arg} to arg # peut être une event-value 
        create new gui with virtual chest:
            make gui slot 0 with diamond:
                send "%{_arg}%"
  • Les variables à l’intérieur du code de click se comporteront comme des “variables de slot”. Cela veut dire qu’elle garderont la même valeur à chaque fois que le joueur clique : 
    create gui with virtual chest:
    make gui slot 0 with diamond:
        add 1 to {_count}
        send "%{_count}%"
        # Va augmenter à chaque fois qu'on clique
  • Ces variables ne sont pas partagées entre slots, excepté si on utilise les gui “formés” (avec une forme) “`vbs command /example2: trigger: set {_var} to 1 create new gui with virtual chest: loop integers from 0 to 35: make gui slot loop-integer with diamond: add 1 to {_var} send “%{_var}%”

“`

Examples de code :

<details><summary>À faire</summary> <br> Si vous avez des exemples, n’hésitez pas à me les proposer sur Discord et peut-être que je les posterais ici ! </details> </details> <br>

Mon identifiant discord est Syst3ms#9959 et je suis présent sur les serveurs de skUnity et de Skript-MC, pour ne nommer qu’eux

Add a custom footer
⚠️ **GitHub.com Fallback** ⚠️