Étends cette classe pour créer un menu. Implémente initGui() pour ajouter tes composants.

• EriGuiScreen(int designWidth, int designHeight)

  Constructeur — passe la taille de ton espace de design (ex: 1920, 1080). Le framework gère le scaling automatiquement.
  Constructeur
• void initGui()

  Appelée une fois à l'ouverture du menu. C'est ici que tu crées tes composants avec addComponent(). Toujours appeler super.initGui() en premier !
  À override
• void addComponent(Component c)

  Ajoute un composant à la GUI. Il sera rendu et recevra les événements automatiquement.
  Méthode
• void close()

  Ferme le menu (comme si le joueur appuyait sur Échap).
  Méthode
• void onClose()

  Appelée quand le menu se ferme. Tu peux overrider cette méthode pour faire quelque chose à la fermeture.
  Optionnel

Toutes les propriétés communes à chaque composant. Ces méthodes sont disponibles sur tous les composants.

• visible(boolean visible)

  Afficher ou cacher le composant. Quand il est caché, il ne reçoit plus les clics non plus.
  Fluent
• enabled(boolean enabled)

  Activer ou désactiver le composant. Un bouton désactivé est grisé et ne répond plus aux clics.
  Fluent
• tooltip(String text)

  Texte affiché au survol de la souris (infobulle).
  Fluent
• zIndex(int z)

  Ordre d'affichage. Les composants avec un zIndex plus grand s'affichent par-dessus les autres.
  Fluent

Texture de fond (tous composants)

Tous les composants héritent de ces méthodes de texture. Quand une image de fond est définie, elle remplace le rendu couleur. Si aucune image n'est définie, le comportement classique (couleur) s'applique.

• backgroundImage(ResourceLocation image)

  Image de fond du composant. Remplace la couleur de fond si définie. Fonctionne sur Button, TextField, Panel, ScrollList, ScrollPanel, ContainerComponent, ProgressBar, etc.
  Fluent
• scaleMode(ScaleMode mode)

  Mode de redimensionnement de la texture : STRETCH, FIT, FILL, TILE, NINE_SLICE.
  Fluent
• imageTint(int argb)

  Teinte ARGB appliquée sur la texture. 0xFFFFFFFF = pas de teinte (défaut).
  Fluent
• nineSliceBorder(int pixels)

  Taille de la bordure pour le mode NINE_SLICE (en pixels texture). Les coins sont préservés, les bords étirés.
  Fluent
• imageUV(int u, int v, int uW, int vH, int texW, int texH)

  Sous-région d'une spritesheet. Permet d'utiliser une seule image contenant plusieurs textures.
  Fluent

ResourceLocation panelTex = new ResourceLocation("monmod", "textures/gui/panel.png");

// Fonctionne sur ScrollPanel, ScrollList, ContainerComponent, Panel...
ScrollPanel panel = new ScrollPanel()
    .originalPos(100, 50)
    .originalSize(300, 200)
    .backgroundColor(Colors.PANEL_BG);  // fallback si texture absente
panel.backgroundImage(panelTex);
panel.scaleMode(ScaleMode.NINE_SLICE);
panel.nineSliceBorder(8);

// Fonctionne aussi sur TextField, Button, etc.
TextField tf = new TextField()
    .originalPos(100, 260)
    .originalSize(200, 20)
    .placeholder("Input texture...");
tf.backgroundImage(new ResourceLocation("monmod", "textures/gui/input.png"));
tf.scaleMode(ScaleMode.NINE_SLICE);
tf.nineSliceBorder(4);

Exemple basique

// new Button(x, y, largeur, hauteur)
Button monBouton = new Button(760, 500, 400, 50)
    .text("Cliquer ici !")           // Le texte affiché sur le bouton
    .colorScheme(Button.Style.CYAN)  // Couleur du bouton
    .onClick(() -> {
        // Ce code s'exécute quand on clique
        System.out.println("Cliqué !");
    });

addComponent(monBouton);

Les 7 styles disponibles

Le style définit la couleur du bouton. Tu le passes à colorScheme().

Toutes les options

• text(String texte)

  Définit le texte affiché sur le bouton.
  Fluent
• colorScheme(Button.Style style)

  Définit le style de couleur du bouton (voir tableau ci-dessus).
  Fluent
• outlined(boolean outlined)

  Si true, le bouton est transparent avec seulement une bordure colorée (style "ghost").
  Fluent
• cornerRadius(int radius)

  Arrondit les coins du bouton. 0 = carré, 4 = légèrement arrondi, 25 = très arrondi (pill).
  Fluent
• onClick(Runnable action)

  Définit ce qui se passe quand on clique. Le code dans () -> { ... } s'exécute au clic.
  Événement
• enabled(boolean actif)

  Active ou désactive le bouton. Un bouton désactivé est grisé et ne clique plus.
  Fluent
• visible(boolean visible)

  Affiche ou cache le bouton.
  Fluent
• textScale(float scale)

  Taille du texte du bouton. 1.0 = normal, 0.8 = plus petit, 1.2 = plus grand.
  Fluent

Exemple avancé

// Un bouton "outlined" (contour seulement) rouge pour une action dangereuse
Button boutonSupprimer = new Button(760, 600, 400, 50)
    .text("Supprimer mon personnage")
    .colorScheme(Button.Style.RED)    // Rouge = danger
    .outlined(true)                   // Contour seulement (plus discret)
    .cornerRadius(4)                  // Légèrement arrondi
    .enabled(false)                   // Désactivé au départ
    .onClick(() -> {
        // Code exécuté au clic
        supprimerPersonnage();
    });

// Plus tard, pour activer le bouton :
boutonSupprimer.enabled(true);

// Plusieurs boutons en ligne avec des styles différents
Button boutonValider = new Button(760, 700, 185, 45)
    .text("Valider")
    .colorScheme(Button.Style.GREEN)
    .cornerRadius(8)
    .onClick(() -> valider());

Button boutonAnnuler = new Button(975, 700, 185, 45)
    .text("Annuler")
    .colorScheme(Button.Style.GRAY)
    .outlined(true)
    .cornerRadius(8)
    .onClick(() -> this.close());

addComponent(boutonValider);
addComponent(boutonAnnuler);

Support Textures (états)

Le Button supporte des textures différentes pour chaque état visuel. Le backgroundImage hérité de Component sert de texture par défaut (état normal). hoverImage et pressedImage permettent de changer l'apparence au survol et au clic.

• hoverImage(ResourceLocation image)

  Texture affichée quand la souris survole le bouton. Si non définie, utilise backgroundImage.
  Fluent
• pressedImage(ResourceLocation image)

  Texture affichée quand le bouton est cliqué/pressé. Si non définie, utilise hoverImage ou backgroundImage.
  Fluent

ResourceLocation btnNormal  = new ResourceLocation("monmod", "textures/gui/btn.png");
ResourceLocation btnHover   = new ResourceLocation("monmod", "textures/gui/btn_hover.png");
ResourceLocation btnPressed = new ResourceLocation("monmod", "textures/gui/btn_pressed.png");

Button btn = new Button("Acheter")
    .originalPos(100, 200)
    .originalSize(200, 40)
    .hoverImage(btnHover)
    .pressedImage(btnPressed)
    .textColor(Colors.WHITE);
btn.backgroundImage(btnNormal);
btn.scaleMode(ScaleMode.NINE_SLICE);
btn.nineSliceBorder(6);

import net.minecraft.util.ResourceLocation;

// Un ResourceLocation pointe vers une image dans tes assets
// Le fichier doit être dans : src/main/resources/assets/tonmodid/textures/gui/monbouton.png
ResourceLocation maTexture = new ResourceLocation("tonmodid", "textures/gui/monbouton.png");

TexturedButton boutonTexture = new TexturedButton(760, 500, 64, 64)
    .texture(maTexture)              // L'image à afficher
    .hoverTint(0x4400DDFF)           // Teinte bleutée au survol (ARGB, AA=alpha)
    .pressedTint(0x88AA44FF)         // Teinte violette quand on appuie
    .label("Jouer", Colors.WHITE)    // Texte optionnel affiché sur le bouton
    .onClick(() -> ouvrirMenu());

addComponent(boutonTexture);

• texture(ResourceLocation rl)

  L'image PNG à utiliser pour le bouton.
  Fluent
• hoverTint(int argbColor)

  Teinte de couleur appliquée quand la souris survole le bouton. Format ARGB : 0xAARRGGBB. Utilise un alpha faible (ex: 0x44) pour un effet subtil.
  Fluent
• pressedTint(int argbColor)

  Teinte appliquée quand on appuie sur le bouton (mouse down).
  Fluent
• label(String text, int color)

  Texte optionnel affiché par-dessus la texture. Pratique pour les boutons avec icône + libellé.
  Fluent
• onClick(Runnable action)

  Code exécuté au clic.
  Événement

// new Label(x, y, largeur, hauteur)
Label monTexte = new Label(760, 100, 400, 30)
    .text("Bienvenue dans mon mod !")  // Le texte à afficher
    .color(Colors.WHITE)               // Couleur du texte
    .align(Label.Align.CENTER)         // Centrer dans la zone
    .scale(1.5f);                      // Taille (1.0 = normal)

addComponent(monTexte);

• text(String texte)

  Le texte à afficher. Tu peux le changer après coup avec la même méthode.
  Fluent
• color(int argbColor)

  Couleur du texte au format ARGB. Utilise les constantes de la classe Colors (ex: Colors.WHITE, Colors.CYAN).
  Fluent
• align(Label.Align align)

  Alignement du texte dans la zone. Label.Align.LEFT (gauche, défaut), CENTER (centré), RIGHT (droite).
  Fluent
• scale(float scale)

  Taille du texte. 1.0 = taille normale, 0.8 = plus petit, 2.0 = double taille. Utile pour les titres.
  Fluent
• shadow(boolean shadow)

  Ajoute une ombre portée sous le texte pour le rendre plus lisible sur fond clair.
  Fluent
• clip(boolean clip)

  Si le texte est trop long pour la zone, il est coupé avec "..." à la fin. Utile pour les noms de joueurs longs.
  Fluent
• scaleToFit(boolean enabled)

  Si true, au lieu de tronquer le texte avec "...", reduit automatiquement l'echelle du texte pour qu'il rentre exactement dans la largeur du composant. Mutuellement exclusif avec wrapped() au rendu — si les deux sont actifs, wrapped prend la priorite.
  Fluent
• wrapped(boolean enabled)

  Si true, le texte passe a la ligne suivante aux limites de mots au lieu d'etre tronque. Si le contenu depasse la hauteur du composant, le scroll vertical a la souris est active (clippe par scissor). Mutuellement exclusif avec scaleToFit() — wrapped a la priorite si les deux sont actifs.
  Fluent

Exemple avancé

// Titre principal centré, grand et blanc
Label titre = new Label(0, 60, 1920, 50)
    .text("Tableau de Bord")
    .color(Colors.WHITE)
    .align(Label.Align.CENTER)
    .scale(2.0f)
    .shadow(true);         // Ombre pour le rendre plus visible

// Sous-titre en couleur, centré
Label sousTitre = new Label(0, 120, 1920, 30)
    .text("Statistiques du joueur")
    .color(0xFF00DDFF)     // Cyan en ARGB
    .align(Label.Align.CENTER)
    .scale(1.2f);

// Texte long avec clip (tronqué si trop long)
Label nomLong = new Label(100, 200, 200, 20)
    .text("NomDeJoueurTrèsTrèsTrèsLong")
    .color(Colors.GRAY)
    .clip(true);           // Devient "NomDeJoueurTrès..." si trop long

// Texte long qui s'adapte automatiquement (scaleToFit)
Label nomAdapte = new Label(100, 240, 200, 20)
    .text("NomDeJoueurTrèsTrèsTrèsLong")
    .color(Colors.GRAY)
    .scaleToFit(true);     // Réduit la taille pour rentrer dans 200px

// Description multi-ligne avec retour à la ligne (wrapped)
Label description = new Label(100, 280, 400, 100)
    .text("Ceci est une longue description qui va automatiquement passer à la ligne quand elle dépasse la largeur du composant. Si le texte dépasse la hauteur, le joueur peut scroller avec la molette.")
    .color(Colors.LIGHT_GRAY)
    .wrapped(true);        // Retour à la ligne automatique

addComponent(titre);
addComponent(sousTitre);
addComponent(nomLong);
addComponent(nomAdapte);
addComponent(description);

// Mettre à jour le texte dynamiquement (en dehors de initGui)
titre.text("Nouveau titre !");

import fr.eri.eriapi.gui.components.Rectangle;

// Un panneau sombre avec bordure cyan et coins arrondis
Rectangle panneau = new Rectangle(100, 100, 600, 400)
    .fillColor(0xCC0D0D1A)   // Fond bleu très sombre, 80% opaque
    .borderColor(0xFF00DDFF) // Bordure cyan opaque
    .borderThickness(2)      // Épaisseur de la bordure en pixels
    .cornerRadius(12);       // Coins arrondis

addComponent(panneau);

// Un simple séparateur horizontal
Rectangle separateur = new Rectangle(100, 260, 600, 2)
    .fillColor(0xFF252540);  // Gris foncé

addComponent(separateur);

• fillColor(int argbColor)

  Couleur de remplissage du rectangle. Utilise 0x00000000 pour transparent (pas de fond).
  Fluent
• borderColor(int argbColor)

  Couleur de la bordure. Si tu ne l'appelles pas, pas de bordure.
  Fluent
• borderThickness(int pixels)

  Épaisseur de la bordure en pixels. Par défaut : 1.
  Fluent
• cornerRadius(int radius)

  Arrondit les coins. 0 = carré, 4-8 = légèrement arrondi, 16+ = très arrondi.
  Fluent

import fr.eri.eriapi.gui.components.Circle;

// Un cercle plein cyan, 80x80 pixels, positionné à (200, 200)
// Pour un cercle, largeur et hauteur doivent être égaux
Circle cercle = new Circle(200, 200, 80, 80)
    .fillColor(0xFF00DDFF)    // Rempli en cyan
    .borderColor(0xFFFFFFFF)  // Bordure blanche
    .borderThickness(3);      // Bordure de 3px

addComponent(cercle);

// Un cercle sans remplissage (juste la bordure)
Circle anneau = new Circle(350, 200, 60, 60)
    .fillColor(0x00000000)    // Transparent (pas de fond)
    .borderColor(0xFFAA44FF)  // Bordure violette
    .borderThickness(4);

• fillColor(int argbColor)

  Couleur de remplissage du cercle.
  Fluent
• borderColor(int argbColor)

  Couleur de la bordure du cercle.
  Fluent
• borderThickness(int pixels)

  Épaisseur de la bordure en pixels.
  Fluent

import fr.eri.eriapi.gui.components.Triangle;

// Flèche vers le haut (comme un "^")
Triangle flecheHaut = new Triangle(200, 200, 30, 20)
    .direction(Triangle.Direction.UP)
    .fillColor(0xFF00DDFF);   // Cyan

// Flèche vers le bas (comme un "v")
Triangle flecheBas = new Triangle(200, 240, 30, 20)
    .direction(Triangle.Direction.DOWN)
    .fillColor(0xFF00DDFF);

// Flèche vers la gauche
Triangle flecheGauche = new Triangle(160, 215, 20, 30)
    .direction(Triangle.Direction.LEFT)
    .fillColor(0xFFAA44FF);   // Violet

// Flèche vers la droite
Triangle flecheDroite = new Triangle(250, 215, 20, 30)
    .direction(Triangle.Direction.RIGHT)
    .fillColor(0xFFAA44FF);

addComponent(flecheHaut);
addComponent(flecheBas);
addComponent(flecheGauche);
addComponent(flecheDroite);

• direction(Triangle.Direction dir)

  Direction de la pointe. Valeurs : UP, DOWN, LEFT, RIGHT.
  Fluent
• fillColor(int argbColor)

  Couleur de remplissage du triangle.
  Fluent

import fr.eri.eriapi.gui.components.TextField;

// new TextField(x, y, largeur, hauteur)
TextField champNom = new TextField(760, 400, 400, 40)
    .placeholder("Entre ton pseudo...")  // Texte affiché quand vide
    .maxLength(20)                        // Maximum 20 caractères
    .onTextChanged(text -> {
        // Appelé à chaque fois que le texte change (chaque touche)
        System.out.println("Texte actuel : " + text);
    });

addComponent(champNom);

// Récupérer le texte entré par le joueur (dans onClick d'un bouton par exemple) :
Button boutonValider = new Button(760, 460, 400, 45)
    .text("Valider")
    .colorScheme(Button.Style.GREEN)
    .onClick(() -> {
        String texteEntré = champNom.getText();  // Récupère le texte
        System.out.println("Le joueur a entré : " + texteEntré);
    });

addComponent(boutonValider);

• placeholder(String texte)

  Texte grisé affiché quand le champ est vide. Disparaît quand le joueur commence à taper.
  Fluent
• maxLength(int max)

  Nombre maximum de caractères que le joueur peut taper.
  Fluent
• onTextChanged(Consumer<String> callback)

  Code exécuté à chaque modification du texte. Reçoit le nouveau texte en paramètre.
  Événement
• getText()

  Retourne le texte actuellement dans le champ.
  Getter
• setText(String texte)

  Remplace le contenu du champ par ce texte (utile pour pré-remplir).
  Fluent
• focus(boolean focus)

  Donner ou retirer le focus au champ. Quand un champ a le focus, le clavier tape dedans.
  Fluent

import fr.eri.eriapi.gui.components.NumericField;

// Champ pour saisir un niveau entre 1 et 100 (entiers uniquement)
NumericField champNiveau = new NumericField(760, 400, 300, 40)
    .placeholder("Niveau (1-100)")
    .min(1)           // Valeur minimum autorisée
    .max(100)         // Valeur maximum autorisée
    .decimal(false)   // false = entiers seulement, true = autorise les décimales
    .negative(false)  // false = nombres positifs seulement
    .onTextChanged(text -> System.out.println("Valeur : " + text));

addComponent(champNiveau);

// Récupérer la valeur saisie
Button bouton = new Button(760, 460, 300, 45)
    .text("Appliquer")
    .colorScheme(Button.Style.CYAN)
    .onClick(() -> {
        double valeur = champNiveau.getValue();  // Récupère la valeur numérique
        int niveau = (int) valeur;
        System.out.println("Niveau sélectionné : " + niveau);
    });

// Champ pour un prix avec décimales (ex: 9.99)
NumericField champPrix = new NumericField(760, 520, 300, 40)
    .placeholder("Prix (ex: 9.99)")
    .min(0.01)
    .max(9999.99)
    .decimal(true);   // Autorise les nombres décimaux (9.99, 14.50, etc.)

• min(double valeurMin)

  Valeur minimale autorisée. Le champ refuse les valeurs inférieures.
  Fluent
• max(double valeurMax)

  Valeur maximale autorisée.
  Fluent
• decimal(boolean autorisé)

  Si true, le joueur peut entrer des nombres décimaux (avec une virgule ou un point).
  Fluent
• negative(boolean autorisé)

  Si true, le joueur peut entrer des nombres négatifs.
  Fluent
• getValue()

  Retourne la valeur numérique saisie sous forme de double. Retourne 0.0 si le champ est vide.
  Getter

import fr.eri.eriapi.gui.components.PasswordField;

// Un champ mot de passe avec points comme masque
PasswordField champMdp = new PasswordField(760, 450, 400, 40)
    .placeholder("Mot de passe")
    .maxLength(32)         // Maximum 32 caractères
    .bulletChar('*');      // Caractère utilisé comme masque (* par défaut, aussi: •, ●)

addComponent(champMdp);

// Bouton pour révéler/masquer le mot de passe (comme l'icône oeil)
Button boutonReveal = new Button(1175, 450, 45, 40)
    .text("voir")
    .colorScheme(Button.Style.GRAY)
    .outlined(true)
    .onClick(() -> {
        // toggleReveal() bascule entre masqué et visible
        champMdp.toggleReveal();
    });

addComponent(boutonReveal);

// Récupérer le vrai mot de passe (pas les étoiles)
Button boutonConnexion = new Button(760, 510, 400, 45)
    .text("Se connecter")
    .colorScheme(Button.Style.CYAN)
    .onClick(() -> {
        String vraiMotDePasse = champMdp.getText();
        // Utilise vraiMotDePasse pour l'authentification
    });

addComponent(boutonConnexion);

• bulletChar(char caractère)

  Le caractère utilisé pour masquer les lettres. Par défaut : *. Tu peux utiliser '•' ou '●' pour un rendu plus moderne.
  Fluent
• toggleReveal()

  Bascule entre "mot de passe visible" et "mot de passe masqué". Appelle deux fois pour revenir à l'état initial.
  Méthode
• getText()

  Retourne le vrai texte entré par le joueur (pas les étoiles).
  Getter

import fr.eri.eriapi.gui.components.GridLayout;

// Une grille de 3 colonnes dans un espace de 600x400
GridLayout grille = new GridLayout(160, 100, 600, 400)
    .columns(3)          // 3 colonnes
    .spacing(10)         // 10px entre chaque cellule (horizontal ET vertical)
    .padding(16);        // 16px de marge intérieure tout autour

// Ajouter des boutons — ils se placent automatiquement dans la grille
// Bouton 1 : colonne 1, ligne 1
grille.add(new Button(0, 0, 180, 50)
    .text("Option 1").colorScheme(Button.Style.CYAN));

// Bouton 2 : colonne 2, ligne 1
grille.add(new Button(0, 0, 180, 50)
    .text("Option 2").colorScheme(Button.Style.PURPLE));

// Bouton 3 : colonne 3, ligne 1
grille.add(new Button(0, 0, 180, 50)
    .text("Option 3").colorScheme(Button.Style.GREEN));

// Bouton 4 : colonne 1, ligne 2 (passe automatiquement à la ligne suivante)
grille.add(new Button(0, 0, 180, 50)
    .text("Option 4").colorScheme(Button.Style.ORANGE));

// Le x,y dans new Button(0, 0, ...) n'est pas important :
// la grille calcule les positions automatiquement !

addComponent(grille);

• columns(int nbColonnes)

  Nombre de colonnes dans la grille. Les composants passent automatiquement à la ligne suivante quand la colonne est pleine.
  Fluent
• rows(int nbLignes)

  Optionnel : limite le nombre de lignes (les composants supplémentaires ne sont pas affichés).
  Fluent
• spacing(int pixels)

  Espace en pixels entre chaque cellule de la grille (horizontal et vertical).
  Fluent
• padding(int pixels)

  Marge intérieure entre le bord de la grille et les composants.
  Fluent
• add(Component composant)

  Ajoute un composant à la grille. Il sera automatiquement positionné dans la prochaine cellule disponible.
  Méthode

import fr.eri.eriapi.gui.components.ScrollList;
import fr.eri.eriapi.gui.components.ListItem;

// Une liste scrollable verticale
ScrollList maListe = new ScrollList(100, 100, 400, 500)
    .itemHeight(40)           // Hauteur de chaque élément en pixels
    .scrollbarVisible(true)   // Afficher la barre de scroll
    .searchEnabled(true);     // Activer une barre de recherche en haut

// Ajouter des éléments (voir la classe ListItem plus bas)
maListe.addItem(new MonItem("joueur1", "Joueur Un", 1500));
maListe.addItem(new MonItem("joueur2", "Joueur Deux", 1200));
maListe.addItem(new MonItem("joueur3", "Joueur Trois", 980));
// ... tu peux en ajouter autant que tu veux, la liste scrolle automatiquement

// Vider la liste et la remplir à nouveau (pour mise à jour)
maListe.clearItems();
// Puis addItem() de nouveau...

addComponent(maListe);

• itemHeight(int pixels)

  Hauteur de chaque ligne de la liste en pixels.
  Fluent
• scrollbarVisible(boolean visible)

  Afficher ou cacher la barre de défilement verticale.
  Fluent
• searchEnabled(boolean actif)

  Affiche un champ de recherche en haut de la liste. Le filtrage des éléments est automatique.
  Fluent
• addItem(ListItem item)

  Ajoute un élément à la liste. Les éléments sont affichés dans l'ordre d'ajout.
  Méthode
• clearItems()

  Supprime tous les éléments de la liste. Utile pour rafraîchir le contenu.
  Méthode

Support texture

Le fond de la liste utilise le backgroundImage hérité de Component. Les items et la poignée de la scrollbar peuvent recevoir leurs propres textures.

• itemBackgroundImage(ResourceLocation texture)

  Texture de fond de chaque item (état normal). Remplace itemBackgroundColor quand définie.
  Fluent
• itemHoverImage(ResourceLocation texture)

  Texture de fond au survol. Si non définie, utilise itemBackgroundImage.
  Fluent
• itemSelectedImage(ResourceLocation texture)

  Texture de fond de l'item sélectionné. Si non définie, utilise itemBackgroundImage.
  Fluent
• itemImageScaleMode(ScaleMode mode)

  Mode d'étirement de la texture des items.
  Fluent
• itemImageTint(int argb)

  Teinte ARGB sur la texture des items.
  Fluent
• itemSliceBorder(int pixels)

  Bordure 9-slice pour la texture des items (si itemImageScaleMode est NINE_SLICE).
  Fluent
• thumbImage(ResourceLocation texture)

  Texture de la poignée de la barre de défilement.
  Fluent
• thumbScaleMode(ScaleMode mode)

  Mode d'étirement de la texture de la poignée.
  Fluent
• thumbImageTint(int argb)

  Teinte ARGB sur la texture de la poignée.
  Fluent

import fr.eri.eriapi.gui.components.ListItem;
import fr.eri.eriapi.gui.util.Colors;
import fr.eri.eriapi.gui.util.RenderUtil;

// Créer une classe pour les joueurs dans un classement
// Elle étend ListItem — c'est obligatoire
public class ItemJoueur extends ListItem {

    // Les données de cet élément
    private String nomJoueur;
    private int score;
    private int rang;

    // Constructeur : initialise les données
    // "id" est un identifiant unique pour cet élément (pour la recherche)
    // "displayName" est le texte utilisé pour la recherche
    public ItemJoueur(String id, String nomJoueur, int score, int rang) {
        super(id, nomJoueur);  // id + nom affiché (utilisé pour filtrer)
        this.nomJoueur = nomJoueur;
        this.score = score;
        this.rang = rang;
    }

    // render() est appelée pour dessiner cet élément dans la liste
    // x, y = position du coin supérieur gauche de l'élément
    // width, height = taille disponible
    // mouseX, mouseY = position de la souris (pour les effets hover)
    @Override
    public void render(int x, int y, int width, int height, int mouseX, int mouseY) {
        // Fond légèrement coloré au survol
        boolean hover = mouseX >= x && mouseX <= x + width
                     && mouseY >= y && mouseY <= y + height;
        if (hover) {
            RenderUtil.drawRect(x, y, width, height, 0x1500DDFF);
        }

        // Numéro de rang à gauche
        RenderUtil.drawText("#" + rang, x + 10, y + 12, Colors.CYAN, true);

        // Nom du joueur
        RenderUtil.drawText(nomJoueur, x + 50, y + 12, Colors.WHITE, false);

        // Score à droite
        String scoreStr = score + " pts";
        RenderUtil.drawText(scoreStr, x + width - 80, y + 12, Colors.YELLOW, false);
    }

    // getSearchText() retourne le texte utilisé pour la recherche
    // Ici : on recherche par nom de joueur
    @Override
    public String getSearchText() {
        return nomJoueur;
    }
}

// Utilisation dans initGui() :
// ScrollList classement = new ScrollList(100, 100, 500, 400).itemHeight(40);
// classement.addItem(new ItemJoueur("uuid1", "Notch", 5000, 1));
// classement.addItem(new ItemJoueur("uuid2", "Dinnerbone", 4200, 2));
// addComponent(classement);

• void render(int x, int y, int width, int height, int mouseX, int mouseY)

  À overrider — dessine cet élément. Utilise RenderUtil pour dessiner du texte, des rectangles, etc.
  À implémenter
• String getSearchText()

  À overrider — retourne le texte utilisé pour la recherche. Généralement le nom ou l'identifiant de l'élément.
  À implémenter
• String getId()

  Retourne l'identifiant unique passé au constructeur.
  Getter

import fr.eri.eriapi.gui.components.ListItem;
import fr.eri.eriapi.gui.components.ListRenderContext;

public class RecipeItem extends ListItem {
    private final ItemStack icon;
    private final String name, cost, status;

    public RecipeItem(String id, ItemStack icon, String name, String cost, String status) {
        super(id, name);
        this.icon = icon; this.name = name; this.cost = cost; this.status = status;
    }

    @Override
    public void render(int x, int y, int width, int height, int mouseX, int mouseY, float pt) {
        ListRenderContext ctx = ListRenderContext.of(x, y, width, height, mouseX, mouseY);
        int gap = ctx.gap();

        // Icone a gauche, taille auto-proportionnelle
        int iconSize = ctx.drawItem(icon, gap * 2, 0);
        int textX = gap * 2 + iconSize + gap;

        // Statut a droite
        int statusW = ctx.textWidth(status);
        int statusOffsetX = width - gap * 2 - statusW;
        int textMaxW = statusOffsetX - textX - gap;

        // Texte avec offset PROPORTIONNEL a la hauteur (drawTextProp)
        ctx.drawTextProp(name,   textX,         -150, textMaxW,         0xFFFFFFFF);
        ctx.drawTextProp(cost,   textX,         +150, textMaxW,         0xFF4ADE80);
        ctx.drawTextProp(status, statusOffsetX, -150, statusW + gap,    0xFFBB55FF);
    }

    @Override public String getSearchText() { return name; }
}

Champs publics

• final int x, y, width, height

  Position et dimensions de la ligne en pixels ecran.
  Champ
• final int mouseX, mouseY

  Position de la souris en pixels ecran.
  Champ

Construction

• static ListRenderContext of(int x, int y, int width, int height, int mouseX, int mouseY)

  Cree un contexte a partir des parametres de ListItem.render().
  Statique

Tailles proportionnelles

• int propW(int permil)

  Retourne une largeur proportionnelle a la largeur de la ligne (permil = millieme : 1000 = pleine largeur). Minimum 1 pixel.
  Methode
• int propH(int permil)

  Retourne une hauteur proportionnelle a la hauteur de la ligne. Minimum 1 pixel.
  Methode
• int gap()

  Espacement standard proportionnel a la largeur de la ligne (minimum 2 pixels).
  Methode

Positionnement

• int midY()

  Y central de la ligne (y + height / 2).
  Methode
• int centerY(int elementHeight)

  Y pour centrer verticalement un element de la hauteur donnee.
  Methode
• int rightX(int offset)

  X depuis le bord droit, decale de offset pixels ecran (x + width - offset).
  Methode
• boolean isHover(int rx, int ry, int rw, int rh)

  Verifie si la souris est dans le rectangle donne (pixels ecran).
  Methode

Dessin

• int drawItem(ItemStack stack, int offsetX, int offsetY)

  Dessine une icone d'item Minecraft. Taille proportionnelle a la hauteur de la ligne (height - 6 px). Si offsetY = 0, l'icone est centree verticalement. Retourne la taille de l'icone en pixels ecran.
  Methode
• void drawText(String text, int offsetX, int offsetY, int maxWidth, int color)

  Dessine du texte design-scaled. offsetY est en pixels ecran bruts depuis le centre vertical de la ligne. Si maxWidth > 0, le texte est tronque pour rentrer.
  Methode
• void drawTextProp(String text, int offsetX, int offsetYPermil, int maxWidth, int color) v1.6.1

  Variante de drawText ou l'offset vertical est en permil de la hauteur de la ligne (1/1000). Indispensable pour des layouts qui restent corrects a toutes les tailles de fenetre. Exemple : offsetYPermil = -150 place le texte a 15% au-dessus du centre, +150 a 15% en dessous.
  Methode
• void drawRect(int rx, int ry, int rw, int rh, int color)

  Dessine un rectangle plein (badges, boutons internes a la ligne).
  Methode
• void drawCenteredText(String text, int rx, int ry, int rw, int rh, int color)

  Dessine du texte centre dans un rectangle.
  Methode

Mesure

• int textWidth(String text)

  Largeur du texte en pixels ecran (design-scaled).
  Methode
• int textHeight()

  Hauteur d'une ligne de texte en pixels ecran (design-scaled).
  Methode

import fr.eri.eriapi.gui.components.ScrollPanel;

// Un panneau de 600x400 pixels avec contenu interne de 600x1200 (plus grand = scrollable)
ScrollPanel panneau = new ScrollPanel(160, 100, 600, 400)
    .contentHeight(1200)   // Hauteur totale du contenu (plus grande que le panneau = scroll)
    .scrollbarVisible(true);

// Ajouter des composants DANS le panneau
// Leurs coordonnées sont relatives au panneau (0,0 = coin supérieur gauche du panneau)
panneau.add(new Label(20, 20, 560, 30)
    .text("Section 1 : Paramètres généraux")
    .color(Colors.CYAN).scale(1.3f));

panneau.add(new TextField(20, 70, 560, 40)
    .placeholder("Nom du serveur"));

panneau.add(new Label(20, 140, 560, 30)
    .text("Section 2 : Options avancées")
    .color(Colors.CYAN).scale(1.3f));

// Encore plus de composants... le panneau scroll automatiquement

addComponent(panneau);

• contentHeight(int pixels)

  Hauteur totale du contenu interne. Si plus grande que la hauteur du panneau, une barre de scroll apparaît.
  Fluent
• contentWidth(int pixels)

  Largeur totale du contenu interne (pour le scroll horizontal).
  Fluent
• scrollbarVisible(boolean visible)

  Afficher ou cacher la barre de défilement.
  Fluent
• add(Component composant)

  Ajoute un composant dans le panneau. Les coordonnées sont relatives au panneau.
  Méthode

Support texture

Le fond du panneau utilise le backgroundImage hérité de Component. La poignée de la scrollbar peut recevoir sa propre texture.

• thumbImage(ResourceLocation texture)

  Texture de la poignée de la barre de défilement du panneau.
  Fluent
• thumbScaleMode(ScaleMode mode)

  Mode d'étirement de la texture de la poignée.
  Fluent
• thumbImageTint(int argb)

  Teinte ARGB sur la texture de la poignée.
  Fluent

Classe de données légère. Tu ne l'instancies généralement pas directement — c'est TabView.addTab() qui la crée pour toi en coulisses.

• Tab(String title, ContainerComponent content)

  Crée un onglet avec un titre et un composant conteneur comme contenu.
  Constructeur
• isActive()

  Retourne true si cet onglet est actuellement sélectionné.
  Getter

Sous-classe de ContainerComponent pensée pour servir de contenu à un onglet. Tu y ajoutes tes composants avec .add() — leurs coordonnées sont relatives au TabView.

• add(Component composant)

  Ajoute un composant dans ce panneau. Retourne this pour le chaînage.
  Fluent

import fr.eri.eriapi.gui.components.TabView;
import fr.eri.eriapi.gui.components.Panel;
import fr.eri.eriapi.gui.components.Label;
import fr.eri.eriapi.gui.components.ProgressBar;

// Crée le contenu de chaque onglet dans un Panel séparé
Panel inventaire = new Panel()
    .add(new Label("Mes items").originalPos(110, 90).originalSize(200, 14));

Panel stats = new Panel()
    .add(new ProgressBar().originalPos(110, 90).originalSize(200, 14).progress(0.7f));

// Assemble le TabView
TabView tabs = new TabView()
    .originalPos(100, 50)
    .originalSize(300, 200)
    .addTab("Inventaire", inventaire)
    .addTab("Stats", stats)
    .selected(0)                                          // Ouvre l'onglet 0 au démarrage
    .onTabChange(index -> System.out.println("Tab " + index));

addComponent(tabs);

• addTab(String title, ContainerComponent content)

  Ajoute un onglet avec son titre affiché dans le header et son contenu à afficher quand l'onglet est actif.
  Fluent
• selected(int index)

  Sélectionne l'onglet à l'index donné (commence à 0). Utilisé pour définir l'onglet ouvert au démarrage.
  Fluent
• selectByTitle(String title)

  Sélectionne l'onglet dont le titre correspond exactement à la chaîne passée. Pratique pour naviguer sans connaître l'index.
  Fluent
• onTabChange(Consumer<Integer> callback)

  Définit un callback déclenché à chaque fois que l'utilisateur change d'onglet. Reçoit l'index du nouvel onglet actif.
  Fluent
• getSelectedIndex()

  Retourne l'index de l'onglet actuellement actif.
  Getter
• getSelectedTitle()

  Retourne le titre de l'onglet actuellement actif.
  Getter
• tabHeight(int h)

  Hauteur en pixels des headers d'onglets (la barre du haut). Par défaut : 20px.
  Fluent
• tabBgColor(int couleur)

  Couleur de fond des headers inactifs au format 0xAARRGGBB.
  Fluent
• activeTabBgColor(int couleur)

  Couleur de fond du header de l'onglet actif.
  Fluent
• tabTextColor(int couleur)

  Couleur du texte dans les headers inactifs.
  Fluent
• activeTabTextColor(int couleur)

  Couleur du texte dans le header de l'onglet actif.
  Fluent
• highlightColor(int couleur)

  Couleur de la barre d'accentuation tracée sous le header actif pour indiquer visuellement la sélection.
  Fluent
• contentBgColor(int couleur)

  Couleur de fond de la zone de contenu (sous les headers).
  Fluent
• contentBorderColor(int couleur)

  Couleur de la bordure autour de la zone de contenu.
  Fluent

Support texture

Les onglets inactifs, l'onglet actif et la zone de contenu peuvent chacun afficher une texture, indépendamment des couleurs de fond.

• tabImage(ResourceLocation texture)

  Texture des headers d'onglets inactifs.
  Fluent
• activeTabImage(ResourceLocation texture)

  Texture du header de l'onglet actuellement actif.
  Fluent
• contentImage(ResourceLocation texture)

  Texture de la zone de contenu (la zone en dessous des headers).
  Fluent
• tabImageScaleMode(ScaleMode mode)

  Mode d'étirement pour les textures d'onglets (actif et inactif).
  Fluent
• contentImageScaleMode(ScaleMode mode)

  Mode d'étirement pour la texture de contenu.
  Fluent
• tabImageTint(int argb)

  Teinte ARGB sur les textures d'onglets.
  Fluent
• contentImageTint(int argb)

  Teinte ARGB sur la texture de contenu.
  Fluent
• contentSliceBorder(int pixels)

  Taille des coins pour le mode NINE_SLICE sur la texture de contenu.
  Fluent

import fr.eri.eriapi.gui.components.ProgressBar;

// Une barre de vie : de 0.0 (vide) à 1.0 (plein)
ProgressBar barreVie = new ProgressBar(100, 100, 400, 20)
    .progress(0.75f)          // 75% rempli
    .fillColor(0xFF00C864)    // Vert = vie
    .backgroundColor(0xFF252540)  // Fond gris foncé
    .cornerRadius(10)         // Coins arrondis (aspect pill)
    .animated(true)           // Transition fluide quand la valeur change
    .showPercentage(true);    // Afficher "75%" au-dessus de la barre

addComponent(barreVie);

// Mettre à jour la progression plus tard (par exemple dans drawScreen ou un callback) :
barreVie.progress(0.5f);  // Passer à 50%

// Une barre d'expérience bleue sans pourcentage
ProgressBar barreXP = new ProgressBar(100, 140, 400, 12)
    .progress(0.3f)
    .fillColor(0xFF00DDFF)
    .cornerRadius(6)
    .animated(true);

• progress(float valeur)

  Valeur entre 0.0 (vide) et 1.0 (plein). 0.5 = 50%, 0.75 = 75%, etc. Tu peux appeler cette méthode à tout moment pour mettre à jour la barre.
  Fluent
• fillColor(int argbColor)

  Couleur de la partie remplie de la barre.
  Fluent
• backgroundColor(int argbColor)

  Couleur du fond (partie vide) de la barre.
  Fluent
• cornerRadius(int radius)

  Arrondit les coins de la barre. Un grand radius par rapport à la hauteur donne un aspect "pill".
  Fluent
• animated(boolean animé)

  Si true, la barre se déplace de façon fluide quand la valeur change (interpolation).
  Fluent
• showPercentage(boolean afficher)

  Affiche le pourcentage en texte au-dessus de la barre (ex: "75%").
  Fluent
• getProgress()

  Retourne la valeur actuelle (entre 0.0 et 1.0).
  Getter

Support texture

En plus des couleurs plates, tu peux habiller la barre avec des textures. La texture de remplissage (fillImage) est clippée par scissor pour suivre exactement la progression. Le backgroundImage hérité de Component s'applique au fond de la barre.

ProgressBar bar = new ProgressBar()
    .originalPos(100, 50)
    .originalSize(200, 16)
    .progress(0.7f)
    .fillImage(new ResourceLocation("monmod", "textures/gui/fill.png"))
    .fillScaleMode(ScaleMode.NINE_SLICE)
    .fillSliceBorder(4);

// Image de fond (hérité de Component)
bar.backgroundImage(new ResourceLocation("monmod", "textures/gui/bar_bg.png"));

• fillImage(ResourceLocation texture)

  Texture de la partie remplie. Clippée via scissor pour correspondre au niveau de progression.
  Fluent
• fillScaleMode(ScaleMode mode)

  Mode d'étirement de la texture de remplissage : STRETCH, NINE_SLICE, TILE ou FIT.
  Fluent
• fillImageTint(int argb)

  Teinte ARGB appliquée par-dessus la texture de remplissage. Par défaut 0xFFFFFFFF (aucune teinte).
  Fluent
• fillSliceBorder(int pixels)

  Taille des coins en pixels pour le mode NINE_SLICE.
  Fluent

import fr.eri.eriapi.gui.components.Slider;

// Un slider de volume : de 0 à 100, par pas de 1
Slider sliderVolume = new Slider(100, 200, 400, 20)
    .range(0, 100)             // Valeur minimum et maximum
    .value(75)                 // Valeur initiale (75 = 75%)
    .step(1)                   // Granularité des pas (1 = entiers, 0.5 = demi-valeurs)
    .showValue(true)           // Afficher la valeur actuelle à côté du slider
    .onValueChange(val -> {
        // Appelé chaque fois que le joueur déplace le slider
        int volume = (int) val;
        System.out.println("Volume : " + volume + "%");
    });

addComponent(sliderVolume);

// Un slider de 0.0 à 1.0 pour la transparence (avec décimales)
Slider sliderAlpha = new Slider(100, 250, 400, 20)
    .range(0.0, 1.0)
    .value(0.8)
    .step(0.05)               // Par pas de 0.05
    .showValue(true)
    .onValueChange(val -> setAlpha((float) val));

// Lire la valeur actuelle depuis un bouton :
Button btnApply = new Button(100, 290, 200, 40)
    .text("Appliquer")
    .colorScheme(Button.Style.CYAN)
    .onClick(() -> {
        double val = sliderVolume.getValue();
        appliquerVolume((int) val);
    });

• range(double min, double max)

  Définit la plage de valeurs. range(0, 100) pour 0 à 100, range(0.0, 1.0) pour 0 à 1.
  Fluent
• value(double valeur)

  Valeur initiale du slider. Doit être dans la plage définie par range().
  Fluent
• step(double pas)

  Granularité du slider. 1 = entiers, 0.5 = demi-valeurs, 0.1 = dixièmes.
  Fluent
• showValue(boolean afficher)

  Affiche la valeur actuelle à côté du curseur.
  Fluent
• onValueChange(Consumer<Double> callback)

  Code exécuté chaque fois que la valeur change. Reçoit la nouvelle valeur en paramètre.
  Événement
• getValue()

  Retourne la valeur actuelle du slider.
  Getter

Support texture

La piste et le curseur (thumb) peuvent chacun recevoir une texture indépendante.

• trackImage(ResourceLocation texture)

  Texture de la piste (le rail sur lequel glisse le curseur).
  Fluent
• trackScaleMode(ScaleMode mode)

  Mode d'étirement de la texture de piste.
  Fluent
• trackImageTint(int argb)

  Teinte ARGB sur la texture de piste.
  Fluent
• trackSliceBorder(int pixels)

  Taille des coins pour le mode NINE_SLICE sur la piste.
  Fluent
• thumbImage(ResourceLocation texture)

  Texture du curseur (la poignée que le joueur déplace).
  Fluent
• thumbScaleMode(ScaleMode mode)

  Mode d'étirement de la texture du curseur.
  Fluent
• thumbImageTint(int argb)

  Teinte ARGB sur la texture du curseur.
  Fluent

import fr.eri.eriapi.gui.components.Checkbox;

// Une case à cocher pour les notifications
Checkbox caseNotifs = new Checkbox(100, 200, 200, 24)
    .label("Activer les notifications")  // Texte à côté de la case
    .checked(true)                        // Cochée par défaut
    .onToggle(checked -> {
        // Appelé quand l'état change
        // "checked" est true si cochée, false si décochée
        if (checked) {
            System.out.println("Notifications activées");
        } else {
            System.out.println("Notifications désactivées");
        }
    });

addComponent(caseNotifs);

// Une case décochée par défaut
Checkbox caseSon = new Checkbox(100, 240, 180, 24)
    .label("Activer le son")
    .checked(false)
    .onToggle(checked -> setSound(checked));

addComponent(caseSon);

// Lire l'état depuis un bouton :
Button btnSauvegarder = new Button(100, 300, 200, 45)
    .text("Sauvegarder")
    .colorScheme(Button.Style.GREEN)
    .onClick(() -> {
        boolean notifsActives = caseNotifs.isChecked();
        boolean sonActif = caseSon.isChecked();
        sauvegarderPreferences(notifsActives, sonActif);
    });

• label(String texte)

  Texte affiché à côté de la case. Cliquer sur le texte coche/décoche aussi.
  Fluent
• checked(boolean cochée)

  État initial de la case. true = cochée, false = décochée.
  Fluent
• onToggle(Consumer<Boolean> callback)

  Code exécuté quand l'état change. Reçoit true si cochée, false si décochée.
  Événement
• isChecked()

  Retourne true si la case est cochée, false sinon.
  Getter

Support texture

La case et la coche peuvent chacune avoir une texture distincte. checkImage utilise ScaleMode.FIT par défaut pour conserver les proportions de l'icône.

• boxImage(ResourceLocation texture)

  Texture du carré de la case à cocher (arrière-plan de la case).
  Fluent
• checkImage(ResourceLocation texture)

  Texture de la coche affichée quand la case est cochée. Mode par défaut : ScaleMode.FIT.
  Fluent
• boxScaleMode(ScaleMode mode)

  Mode d'étirement de la texture de la case.
  Fluent
• boxImageTint(int argb)

  Teinte ARGB appliquée sur la texture de la case.
  Fluent

import fr.eri.eriapi.gui.components.RadioButton;

// Un RadioButton individuel
RadioButton option = new RadioButton(100, 200, 150, 24)
    .label("Option A")      // Texte à côté du bouton radio
    .selected(true)         // Sélectionné par défaut
    .onSelect(() -> {
        // Appelé quand ce bouton est sélectionné
        System.out.println("Option A sélectionnée");
    });

addComponent(option);

• label(String texte)

  Texte affiché à côté du bouton radio.
  Fluent
• selected(boolean sélectionné)

  Sélectionné par défaut. Dans un groupe, un seul devrait être true.
  Fluent
• onSelect(Runnable callback)

  Code exécuté quand ce RadioButton est sélectionné.
  Événement
• isSelected()

  Retourne true si ce RadioButton est actuellement sélectionné.
  Getter

import fr.eri.eriapi.gui.components.RadioGroup;
import fr.eri.eriapi.gui.components.RadioButton;

// Créer les 3 boutons radio pour la difficulté
RadioButton rbFacile = new RadioButton(100, 200, 160, 28)
    .label("Facile").selected(true);   // Sélectionné par défaut

RadioButton rbNormal = new RadioButton(100, 236, 160, 28)
    .label("Normal");

RadioButton rbDifficile = new RadioButton(100, 272, 160, 28)
    .label("Difficile");

// Créer le groupe et y ajouter les boutons
// Le groupe gère automatiquement la logique "un seul sélectionné"
RadioGroup groupeDifficulte = new RadioGroup()
    .add("facile",    rbFacile)     // "facile" = identifiant unique de cette option
    .add("normal",    rbNormal)
    .add("difficile", rbDifficile)
    .select("facile")               // Sélectionner "facile" par défaut
    .onSelect(id -> {
        // Appelé quand une option est sélectionnée
        // "id" contient l'identifiant choisi ("facile", "normal" ou "difficile")
        System.out.println("Difficulté choisie : " + id);
    });

// Ajouter les RadioButtons (pas le groupe) à la GUI
addComponent(rbFacile);
addComponent(rbNormal);
addComponent(rbDifficile);

// Récupérer la sélection actuelle depuis un bouton :
Button btnValider = new Button(100, 320, 200, 45)
    .text("Commencer")
    .colorScheme(Button.Style.GREEN)
    .onClick(() -> {
        String difficulte = groupeDifficulte.getSelected();  // "facile", "normal" ou "difficile"
        lancerPartie(difficulte);
    });

• add(String id, RadioButton bouton)

  Ajoute un RadioButton au groupe avec un identifiant unique. L'identifiant est retourné par getSelected().
  Fluent
• select(String id)

  Sélectionne programmatiquement un bouton par son identifiant. Les autres sont désélectionnés.
  Fluent
• onSelect(Consumer<String> callback)

  Code exécuté quand la sélection change. Reçoit l'identifiant du bouton nouvellement sélectionné.
  Événement
• getSelected()

  Retourne l'identifiant du bouton actuellement sélectionné.
  Getter

Classe de base pour tous les graphiques. Elle définit les options visuelles communes : titre, labels des axes, grille, couleurs de fond et de bordure. Ces méthodes sont disponibles sur tous les types de graphiques.

• title(String titre)

  Affiche un titre centré en haut du graphique.
  Fluent
• xLabel(String label)

  Texte affiché sous l'axe horizontal (axe X). Par exemple : "Temps (s)".
  Fluent
• yLabel(String label)

  Texte affiché à gauche de l'axe vertical (axe Y). Par exemple : "Score".
  Fluent
• chartPadding(int padding)

  Espace intérieur (en pixels design) entre le bord du composant et la zone de dessin du graphique. Défaut : 25.
  Fluent
• titleHeight(int hauteur)

  Hauteur réservée pour le titre en haut du graphique. Défaut : 12 px design.
  Fluent
• gridLines(int nombre)

  Nombre de lignes de grille horizontales tracées dans la zone de dessin. Défaut : 5.
  Fluent
• showGrid(boolean afficher)

  Active ou désactive l'affichage de la grille de fond. Par défaut activée.
  Fluent
• backgroundColor(int couleur)

  Couleur de fond de la zone de graphique au format 0xAARRGGBB. Défaut : 0xFF1A1A2A (bleu très sombre).
  Fluent
• gridColor(int couleur)

  Couleur des lignes de la grille. Défaut : 0xFF303045.
  Fluent
• axisColor(int couleur)

  Couleur des axes X et Y. Défaut : 0xFF505070.
  Fluent
• textColor(int couleur)

  Couleur du texte (titre, labels, valeurs). Défaut : blanc.
  Fluent
• borderColor(int couleur)

  Couleur de la bordure autour du graphique. Défaut : 0xFF404060.
  Fluent

Un graphique en courbes. Tu peux afficher plusieurs séries de données (datasets) en même temps, chacune avec sa propre couleur et son propre nom dans la légende. Idéal pour suivre l'évolution d'une valeur dans le temps (score, vie, distance...).

Chaque point de données est un objet LineChart.DataPoint qui contient une valeur X et une valeur Y. Tu regroupes tes points dans une List et tu passes cette liste à addDataset().

import fr.eri.eriapi.gui.components.charts.LineChart;
import java.util.Arrays;

// Crée les points pour la série "Vie"
List<LineChart.DataPoint> pointsVie = Arrays.asList(
    new LineChart.DataPoint(0, 100),
    new LineChart.DataPoint(1,  85),
    new LineChart.DataPoint(2,  60),
    new LineChart.DataPoint(3,  90),
    new LineChart.DataPoint(4,  75)
);

// Crée les points pour la série "Mana"
List<LineChart.DataPoint> pointsMana = Arrays.asList(
    new LineChart.DataPoint(0,  50),
    new LineChart.DataPoint(1,  30),
    new LineChart.DataPoint(2,  80),
    new LineChart.DataPoint(3,  65),
    new LineChart.DataPoint(4,  90)
);

LineChart graphique = new LineChart()
    .originalPos(50, 50)
    .originalSize(300, 180)
    .title("Statistiques du joueur")
    .xLabel("Temps (min)")
    .yLabel("Points")
    .addDataset("Vie",  pointsVie)
    .addDataset("Mana", pointsMana)
    .datasetColor("Vie",  0xFF00C864)   // Vert pour la vie
    .datasetColor("Mana", 0xFF00AAFF)   // Bleu pour le mana
    .showLegend(true)
    .showDots(true)
    .showGrid(true);

addComponent(graphique);

• addDataset(String nom, List<DataPoint> points)

  Ajoute une série de données au graphique. Chaque série a un nom unique qui sert aussi de label dans la légende.
  Fluent
• datasetColor(String nom, int couleur)

  Définit la couleur de la courbe et des points d'une série. La couleur est au format 0xAARRGGBB.
  Fluent
• removeDataset(String nom)

  Supprime la série dont le nom correspond. Utile pour mettre à jour le graphique dynamiquement.
  Fluent
• clearDatasets()

  Supprime toutes les séries d'un coup. Pratique pour recharger le graphique avec de nouvelles données.
  Fluent
• showLegend(boolean afficher)

  Affiche ou masque la légende listant les noms et couleurs de chaque série.
  Fluent
• showDots(boolean afficher)

  Affiche ou masque les points (ronds) à chaque coordonnée de donnée sur la courbe.
  Fluent
• lineWidth(int epaisseur)

  Épaisseur en pixels de chaque courbe tracée.
  Fluent
• yLabelDecimals(int decimales)

  Nombre de décimales affichées sur les labels de l'axe Y (et dans le tooltip de survol des points). Valeur par défaut : 1. Mettre 0 pour forcer un affichage entier.
  Fluent

Un graphique en barres verticales. Chaque barre a un label (affiché sous la barre) et une valeur (affichée au-dessus). Tu peux choisir une couleur par barre individuelle ou définir une couleur globale. La détection de survol (hover) est incluse automatiquement.

import fr.eri.eriapi.gui.components.charts.BarChart;

BarChart barres = new BarChart()
    .originalPos(50, 50)
    .originalSize(300, 180)
    .title("Kills par joueur")
    .yLabel("Kills")
    .addBar("Alice", 42, 0xFF00C864)    // Barre verte
    .addBar("Bob",   18, 0xFF00AAFF)    // Barre bleue
    .addBar("Carol", 35, 0xFFFF8800)    // Barre orange
    .addBar("Dave",   7, 0xFFFF4444)    // Barre rouge
    .showValues(true)                    // Affiche les valeurs au-dessus des barres
    .showLabels(true)                    // Affiche les noms sous les barres
    .barSpacing(4)                       // Espace entre les barres
    .hoverBarColor(0xFFFFDD00);          // Couleur au survol (jaune)

addComponent(barres);

• addBar(String label, float valeur)

  Ajoute une barre avec son label et sa valeur. Utilise la couleur globale définie par barColor().
  Fluent
• addBar(String label, float valeur, int couleur)

  Ajoute une barre avec sa propre couleur individuelle (remplace la couleur globale pour cette barre uniquement).
  Fluent
• updateBar(String label, float nouvelleValeur)

  Met à jour la valeur d'une barre existante (identifiée par son label). Pratique pour des données qui changent en temps réel.
  Fluent
• clearBars()

  Supprime toutes les barres. Utile pour recharger complètement le graphique.
  Fluent
• barColor(int couleur)

  Couleur globale appliquée à toutes les barres qui n'ont pas de couleur individuelle.
  Fluent
• hoverBarColor(int couleur)

  Couleur affichée quand la souris survole une barre.
  Fluent
• barSpacing(int espace)

  Espace en pixels design entre chaque barre.
  Fluent
• showValues(boolean afficher)

  Affiche ou masque la valeur numérique au-dessus de chaque barre.
  Fluent
• showLabels(boolean afficher)

  Affiche ou masque le label textuel sous chaque barre.
  Fluent
• valueFormat(String format)

  Format d'affichage des valeurs. Par exemple "%.0f pts" affichera "42 pts". Utilise la syntaxe Java String.format().
  Fluent

Un graphique en camembert (aussi appelé "pie chart" ou "diagramme circulaire"). Chaque tranche représente une catégorie. Tu peux afficher les pourcentages directement sur les tranches et une légende à côté. Le nombre de segments utilisés pour dessiner chaque tranche est configurable pour ajuster la fluidité du rendu.

import fr.eri.eriapi.gui.components.charts.PieChart;

PieChart camembert = new PieChart()
    .originalPos(50, 50)
    .originalSize(200, 200)
    .title("Répartition des dégâts")
    .addSlice("Épée",  55, 0xFFFF4444)   // Rouge
    .addSlice("Arc",   25, 0xFF00AAFF)   // Bleu
    .addSlice("Magie", 15, 0xFFCC44FF)   // Violet
    .addSlice("Chute",  5, 0xFFFFAA00)   // Orange
    .showPercentage(true)   // Affiche "55%" sur la tranche épée
    .showLegend(true)       // Affiche la légende à côté
    .segments(64);          // 64 segments pour un rendu lisse

addComponent(camembert);

• addSlice(String label, float valeur, int couleur)

  Ajoute une tranche avec son label, sa valeur (proportion relative) et sa couleur. Les valeurs n'ont pas besoin de faire 100 — le graphique les normalise automatiquement.
  Fluent
• addSlice(String label, float valeur)

  Ajoute une tranche sans couleur personnalisée — le graphique lui attribue automatiquement une couleur depuis sa palette interne.
  Fluent
• clearSlices()

  Supprime toutes les tranches. Utile pour recharger le graphique avec de nouvelles données.
  Fluent
• showLegend(boolean afficher)

  Affiche ou masque la légende listant les labels et couleurs de chaque tranche.
  Fluent
• showPercentage(boolean afficher)

  Affiche ou masque le pourcentage calculé automatiquement sur chaque tranche du camembert.
  Fluent
• segments(int nombre)

  Nombre de segments OpenGL utilisés pour dessiner chaque tranche. Plus le nombre est élevé, plus le contour est lisse. Valeur recommandée : 32 à 64.
  Fluent

import fr.eri.eriapi.gui.components.ColorWheel;

// Roue chromatique centrée sur (50, 50), rayon de 50 px design
ColorWheel wheel = new ColorWheel()
    .originalPos(50, 50)
    .originalSize(100, 100)
    .defaultColor(0xFFFF0000)           // Couleur de départ : rouge
    .onColorChange(color -> {
        // Appelé à chaque déplacement du curseur
        System.out.println("Couleur choisie : #" + Integer.toHexString(color));
    });

addComponent(wheel);

// Lire la couleur courante depuis un bouton :
Button btnAppliquer = new Button(50, 170, 100, 30)
    .text("Appliquer")
    .colorScheme(Button.Style.CYAN)
    .onClick(() -> {
        int couleur = wheel.getSelectedColor();   // Entier ARGB
        float teinte = wheel.getHue();            // 0.0 – 1.0
        float saturation = wheel.getSaturation(); // 0.0 – 1.0
        float luminosite = wheel.getBrightness(); // 0.0 – 1.0
        appliquerCouleur(couleur);
    });

• defaultColor(int argb)

  Définit la couleur sélectionnée au démarrage. La roue se positionne automatiquement sur cette teinte et saturation.
  Fluent
• radius(int rayonDesign)

  Rayon de la roue en pixels design. La taille réelle s'adapte automatiquement à la résolution.
  Fluent
• brightness(float valeur)

  Luminosité initiale de la roue, entre 0.0 (noir) et 1.0 (couleur pure). Modifiable ensuite par un BrightnessSlider.
  Fluent
• onColorChange(Consumer<Integer> callback)

  Code exécuté chaque fois que la couleur change (drag de souris). Reçoit la couleur ARGB en paramètre.
  Événement
• getSelectedColor()

  Retourne la couleur actuellement sélectionnée sous forme d'entier ARGB (0xAARRGGBB).
  Getter
• getHue()

  Retourne la teinte (hue) sélectionnée, valeur entre 0.0 et 1.0 (0 = rouge, 0.33 = vert, 0.66 = bleu).
  Getter
• getSaturation()

  Retourne la saturation sélectionnée, valeur entre 0.0 (gris) et 1.0 (couleur pure).
  Getter
• getBrightness()

  Retourne la luminosité actuelle, valeur entre 0.0 (noir) et 1.0 (pleine luminosité).
  Getter

import fr.eri.eriapi.gui.components.ColorWheel;
import fr.eri.eriapi.gui.components.BrightnessSlider;

// 1. Créer la roue chromatique
ColorWheel wheel = new ColorWheel()
    .originalPos(50, 50)
    .originalSize(100, 100)
    .defaultColor(0xFF00AAFF);

// 2. Lier le slider à la roue — le dégradé se met à jour automatiquement
BrightnessSlider slider = new BrightnessSlider(wheel)
    .originalPos(50, 160)
    .originalSize(100, 14);

addComponent(wheel);
addComponent(slider);

• BrightnessSlider(ColorWheel roue)

  Constructeur principal. Lie immédiatement le slider à la ColorWheel donnée. Le dégradé et la valeur de luminosité sont synchronisés automatiquement.
  Constructeur

import fr.eri.eriapi.gui.components.ColorPicker;

// Sélecteur de couleur tout-en-un
ColorPicker picker = new ColorPicker()
    .originalPos(50, 50)
    .originalSize(120, 170)
    .defaultColor(0xFF00AAFF)       // Couleur initiale : bleu ciel
    .backgroundColor(0xFF2A2A2A)   // Fond du panneau
    .onChange(color -> {
        // Appelé à chaque changement de couleur (roue, slider OU champ hex)
        System.out.println("Nouvelle couleur : #" + Integer.toHexString(color));
        appliquerCouleur(color);
    });

addComponent(picker);

// Lire la couleur à tout moment :
Button btnValider = new Button(50, 240, 120, 32)
    .text("Valider")
    .colorScheme(Button.Style.GREEN)
    .onClick(() -> {
        int couleurChoisie = picker.getColor(); // Entier ARGB
        sauvegarderCouleur(couleurChoisie);
    });

• defaultColor(int argb)

  Couleur affichée à l'ouverture du composant. Initialise la roue, le slider et le champ hex de façon cohérente.
  Fluent
• backgroundColor(int argb)

  Couleur de fond du panneau du ColorPicker.
  Fluent
• onChange(Consumer<Integer> callback)

  Code exécuté chaque fois que la couleur change, quelle que soit la source (roue, slider ou saisie hex). Reçoit la couleur ARGB.
  Événement
• getColor()

  Retourne la couleur actuellement sélectionnée sous forme d'entier ARGB (0xAARRGGBB).
  Getter

import fr.eri.eriapi.gui.components.MenuItem;

// Item standard : texte + action
MenuItem itemCopier   = new MenuItem("Copier",     () -> copier());
MenuItem itemColler   = new MenuItem("Coller",     () -> coller());
MenuItem itemRenommer = new MenuItem("Renommer",   () -> renommer());

// Séparateur visuel (ligne horizontale de séparation)
MenuItem separateur = MenuItem.separator();

// Item désactivé (grisé, ne peut pas être cliqué)
MenuItem itemSupprimer = new MenuItem("Supprimer", () -> supprimer())
    .enabled(false);

// Ces items seront ensuite ajoutés à un ContextMenu (voir ci-dessous)

• MenuItem(String texte, Runnable action)

  Constructeur principal. Crée un item avec un libellé et une action exécutée au clic.
  Constructeur
• MenuItem.separator()

  Méthode de fabrique. Crée un séparateur visuel (ligne horizontale) sans texte ni action. Utilisé pour regrouper les items par catégorie.
  Statique
• enabled(boolean actif)

  Active ou désactive l'item. Un item désactivé (false) s'affiche en grisé et n'exécute pas son action au clic.
  Fluent

import fr.eri.eriapi.gui.components.ContextMenu;
import fr.eri.eriapi.gui.components.MenuItem;

// Construire le menu avec la fluent API
ContextMenu menu = new ContextMenu()
    .add("Copier",    () -> copier())
    .add("Coller",    () -> coller())
    .add("Renommer",  () -> renommer())
    .addSeparator()
    .add("Supprimer", () -> supprimer());

addComponent(menu);

// Ouvrir le menu à la position de la souris (ex : clic droit sur un item)
Button btnClic = new Button(100, 100, 150, 36)
    .text("Clic droit simulé")
    .onClick(() -> menu.open(mouseX, mouseY));  // Ouvre à la position du curseur

import fr.eri.eriapi.gui.components.ContextMenu;
import fr.eri.eriapi.gui.components.MenuItem;
import fr.eri.eriapi.gui.util.Colors;

// Créer des items avec MenuItem pour plus de contrôle
MenuItem itemCopier    = new MenuItem("Copier",     () -> copier());
MenuItem itemRenommer  = new MenuItem("Renommer",   () -> renommer());
MenuItem itemSupprimer = new MenuItem("Supprimer",  () -> supprimer()).enabled(false);

// Menu avec couleurs personnalisées
ContextMenu menu = new ContextMenu()
    .addItem(itemCopier)
    .addItem(itemRenommer)
    .addSeparator()
    .addItem(itemSupprimer)
    .minWidth(160)                         // Largeur minimale du panneau
    .backgroundColor(0xFF1E1E2E)           // Fond sombre
    .hoverColor(0xFF2A2A3E)                // Couleur de survol
    .textColor(Colors.WHITE)               // Couleur du texte
    .separatorColor(0xFF3A3A4E);           // Couleur de la ligne séparateur

addComponent(menu);

// Vider et reconstruire les items dynamiquement
menu.clear();
menu.add("Option A", () -> choixA());
menu.add("Option B", () -> choixB());

• add(String texte, Runnable action)

  Ajoute un item cliquable avec son libellé et son action. Méthode la plus rapide pour remplir un menu.
  Fluent
• addItem(MenuItem item)

  Ajoute un MenuItem pré-construit (utile pour les items désactivés ou partagés entre plusieurs menus).
  Fluent
• addSeparator()

  Insère un séparateur visuel (ligne horizontale) à la position courante dans la liste des items.
  Fluent
• minWidth(int largeurDesign)

  Largeur minimale du panneau du menu en pixels design. Le menu s'élargit automatiquement si un item est plus long.
  Fluent
• backgroundColor(int argb)

  Couleur de fond du panneau du menu contextuel.
  Fluent
• hoverColor(int argb)

  Couleur de fond d'un item au survol de la souris.
  Fluent
• textColor(int argb)

  Couleur du texte des items actifs.
  Fluent
• separatorColor(int argb)

  Couleur de la ligne de séparation entre les groupes d'items.
  Fluent
• clear()

  Supprime tous les items du menu. Permet de reconstruire dynamiquement le contenu selon le contexte.
  Fluent
• open(int x, int y)

  Affiche le menu à la position indiquée (coordonnées écran). Si le menu dépasse les bords de l'écran, sa position est corrigée automatiquement.
  Action
• close()

  Ferme et masque le menu. Appelé automatiquement quand le joueur clique en dehors du menu ou sélectionne un item.
  Action

Support texture

Le panneau du menu contextuel peut afficher une texture de fond. Par défaut, le mode NINE_SLICE avec un border de 4 px est utilisé pour s'adapter à toutes les tailles.

• menuImage(ResourceLocation texture)

  Texture de fond du panneau du menu contextuel.
  Fluent
• menuImageScaleMode(ScaleMode mode)

  Mode d'étirement de la texture (par défaut NINE_SLICE).
  Fluent
• menuImageTint(int argb)

  Teinte ARGB sur la texture du panneau.
  Fluent
• menuSliceBorder(int pixels)

  Taille des coins pour le mode NINE_SLICE (par défaut 4).
  Fluent

import fr.eri.eriapi.gui.components.GradientRectangle;

// Degrade vertical (haut -> bas) violet -> bleu
new GradientRectangle()
    .originalPos(100, 100).originalSize(400, 200)
    .vertical(0xFF6B2FA0, 0xFF00E5FF)
    .cornerRadius(12);

// Degrade horizontal (gauche -> droite) cyan -> transparent
new GradientRectangle()
    .originalPos(0, 0).originalSize(1920, 4)
    .horizontal(0xFF00E5FF, 0x0000E5FF); // fondu vers transparent

// Degrade vertical avec alpha (fond semi-transparent)
new GradientRectangle()
    .originalPos(660, 340).originalSize(600, 400)
    .vertical(0xCC1A1A2E, 0xCC2A1A3E)
    .cornerRadius(16);

• vertical(int topColor, int bottomColor)

  Definit un degrade de haut en bas. Les deux couleurs sont en format ARGB (0xAARRGGBB).
  Fluent
• horizontal(int leftColor, int rightColor)

  Definit un degrade de gauche a droite.
  Fluent
• cornerRadius(int radius)

  Arrondit les coins en pixels de design. Le degrade est correctement applique aux coins arrondis.
  Fluent

import fr.eri.eriapi.gui.components.Aurora;

// Aurora en fond de GUI (pleine largeur, haut de l'ecran)
Aurora aurora = new Aurora()
    .originalPos(0, 0)
    .originalSize(1920, 500)
    .addBand(0x406B2FA0, 0.3f, 1.2f, 80, 50)   // violet, 1 vague, amplitude 1.2, hauteur 80px, yOffset 50
    .addBand(0x3000E5FF, 0.5f, 0.8f, 60, 120)  // cyan, 1.5 vagues, amplitude 0.8
    .addBand(0x20FF6B6B, 0.7f, 0.6f, 50, 200)  // rose subtil
    .speed(0.02f)    // vitesse des vagues (defaut: 0.015)
    .segments(80);   // lisse (defaut: 64)

root.add(aurora);

• addBand(int color, float frequency, float amplitude, int height, int yOffset)

  Ajoute une bande d'aurore. color : couleur ARGB (le bas sera transparent). frequency : nombre de cycles sinusoidaux sur la largeur (ex : 0.5 = une demi-vague, 1.0 = une vague complete). amplitude : hauteur de l'ondulation en design pixels. height : epaisseur du degrade de la bande en design pixels. yOffset : position Y de la bande relative au composant. Max 10 bandes.
  Fluent
• speed(float speed)

  Vitesse de deplacement des vagues. Defaut : 0.015f. Plus grand = plus rapide.
  Fluent
• segments(int segments)

  Nombre de segments par bande pour la fluidite. Defaut : 64. Minimum : 16.
  Fluent

import fr.eri.eriapi.gui.components.Starfield;

new Starfield()
    .originalPos(0, 0)
    .originalSize(1920, 1080)
    .starCount(80)                  // nombre d'etoiles statiques
    .starColor(0xFFF0F2FF)          // couleur (blanc legerement bleu)
    .shootingStarChance(0.003f);    // probabilite d'etoile filante par frame
                                    // 0 = jamais, 0.01 = tres frequent

• starCount(int count)

  Nombre d'etoiles statiques a generer. Defaut : 50.
  Fluent
• starColor(int argb)

  Couleur des etoiles. Defaut : 0xFFF0F2FF (blanc casse).
  Fluent
• shootingStarChance(float chance)

  Probabilite par frame qu'une etoile filante apparaisse. Defaut : 0.002f. 0 = jamais. Max 3 simultanees.
  Fluent

import fr.eri.eriapi.gui.components.ParticleSystem;

// Particules qui montent doucement (fumee legere)
new ParticleSystem()
    .originalPos(0, 600).originalSize(1920, 480)
    .maxParticles(40)
    .spawnRate(0.6f)           // ~0.6 particule par frame (36/s a 60fps)
    .particleLife(3000, 6000)  // duree de vie : 3 a 6 secondes
    .particleSize(30, 100)     // grossit de 30 a 100 design px au cours de sa vie
    .particleColor(0x206B2FA0) // violet tres transparent (blending additif)
    .drift(0, -0.008f)         // monte lentement
    .spread(0.012f)            // dispersion aleatoire legere
    .fadeIn(0.15f)             // fondu entrant sur 15% de la vie
    .fadeOut(0.35f);           // fondu sortant sur 35% de la vie

// Particules sur les bords uniquement
new ParticleSystem()
    .originalPos(0, 0).originalSize(1920, 1080)
    .maxParticles(20)
    .spawnOnEdges(true)        // spawn sur les bords de la zone
    .drift(0.005f, 0.002f)
    .particleColor(0x3000E5FF);

• maxParticles(int max)

  Nombre maximum de particules simultanees (cap a 200). Defaut : 30.
  Fluent
• spawnRate(float rate)

  Particules emises par frame. 0.5 = 1 particule toutes les 2 frames. Defaut : 0.5f.
  Fluent
• particleLife(int minMs, int maxMs)

  Duree de vie min/max des particules en millisecondes. Defaut : 3000, 6000.
  Fluent
• particleSize(int startPx, int endPx)

  Taille de la particule en design pixels (debut de vie, fin de vie). La particule grossit progressivement. Defaut : 40, 120.
  Fluent
• particleColor(int argb)

  Couleur ARGB des particules. L'alpha de la couleur est multiplie par les facteurs de fade. Defaut : 0x20FFFFFF.
  Fluent
• drift(float dx, float dy)

  Derive constante en px/ms. dy negatif = monte. Defaut : 0, -0.008f.
  Fluent
• spread(float s)

  Vitesse aleatoire ajoutee a la derive (dispersion). Plus grand = plus chaotique. Defaut : 0.015f.
  Fluent
• fadeIn(float ratio) / fadeOut(float ratio)

  Fraction de la vie utilisee pour le fondu d'apparition / disparition (0-1). Defaut : 0.15f, 0.3f.
  Fluent
• spawnOnEdges(boolean edges)

  Si true, les particules naissent sur les bords de la zone plutot qu'a l'interieur.
  Fluent

import fr.eri.eriapi.gui.components.SmokeFog;

// Brouillard violet subtil en fond de GUI
new SmokeFog()
    .originalPos(0, 0).originalSize(1920, 1080)
    .color(0x6B2FA0)       // couleur RGB (sans alpha — l'alpha est gere par intensity)
    .intensity(0.08f)      // alpha max (0-1). 0.05-0.15 = tres subtil, 0.3+ = visible
    .scale(0.006f)         // echelle du bruit. Petit = grands motifs
    .speed(0.0003f)        // vitesse d'evolution du bruit
    .wind(0.0001f, -0.00005f) // derive legere
    .octaves(3)            // detail fractal (2-6). Plus = plus de detail mais plus couteux
    .persistence(0.5f)     // persistence FBM (0-1). 0.5 = standard
    .cellSize(12);         // taille de chaque cellule en px ecran. Plus petit = plus lisse

• color(int rgb)

  Couleur RGB du brouillard sans alpha (ex : 0x6B2FA0). L'alpha est controle par intensity().
  Fluent
• intensity(float i)

  Alpha maximum du brouillard (0-1). 0.05-0.12 = tres subtil, 0.2-0.35 = bien visible. Defaut : 0.10f.
  Fluent
• scale(float s)

  Echelle spatiale du bruit. Plus petit = motifs plus grands et organiques. Defaut : 0.007f.
  Fluent
• speed(float s)

  Vitesse d'evolution temporelle du bruit (animation). Defaut : 0.0003f.
  Fluent
• wind(float wx, float wy)

  Derive constante du brouillard (px/ms). Cree un effet de vent. Defaut : 0.0001f, -0.00008f.
  Fluent
• octaves(int o)

  Octaves FBM — nombre de couches de bruit superposees (1-6). Plus = plus de detail mais plus couteux. Defaut : 3.
  Fluent
• persistence(float p)

  Persistence FBM (0-1). Controle l'influence des octaves hautes. Defaut : 0.5f.
  Fluent
• cellSize(int s)

  Taille de chaque cellule de la grille en pixels ecran. Plus petit = rendu plus lisse mais plus couteux. Minimum : 4. Defaut : 10.
  Fluent

import fr.eri.eriapi.gui.components.PageView;
import fr.eri.eriapi.gui.core.ContainerComponent;

// Creer le PageView
PageView pageView = new PageView()
    .originalPos(300, 100)
    .originalSize(800, 600)
    .transitionDuration(10)         // transition en 10 ticks (0.5s)
    .transitionEasing(Easing.EASE_OUT_CUBIC)
    .slideDistance(40);             // le contenu glisse de 40 design px

// Creer les pages (des ContainerComponent)
ContainerComponent page1 = new ContainerComponent()
    .originalPos(0, 0).originalSize(800, 600);
page1.add(new Label(20, 20, 760, 30, "Page 1 — Profil"));

ContainerComponent page2 = new ContainerComponent()
    .originalPos(0, 0).originalSize(800, 600);
page2.add(new Label(20, 20, 760, 30, "Page 2 — Stats"));

// Definir la page initiale (sans animation)
pageView.setContent(page1);

// Naviguer vers une autre page (avec transition)
new Button("Stats").onClick(() -> pageView.switchTo(page2));

root.add(pageView);

• transitionDuration(int ticks)

  Duree de la transition en ticks. Defaut : 10 (0.5 seconde).
  Fluent
• transitionEasing(Easing easing)

  Easing de la transition. Defaut : EASE_OUT_CUBIC.
  Fluent
• slideDistance(int designPx)

  Distance de glissement en design pixels. Plus petit = plus subtil. Defaut : 50.
  Fluent
• void setContent(ContainerComponent content)

  Definit le contenu initial sans animation. A appeler lors du premier affichage.
  Methode
• void switchTo(ContainerComponent newContent)

  Change de page avec animation slide + fade. Si une transition est deja en cours, elle est terminee immediatement avant de lancer la nouvelle.
  Methode
• boolean isTransitioning()

  Retourne true si une transition est en cours.
  Getter
• ContainerComponent getCurrentContent()

  Retourne le contenu actuellement affiche (null si aucun).
  Getter

• T tooltip(String text)

  Définit le texte du tooltip. Supporte les retours à la ligne avec \n en Java et \\n littéral depuis les fichiers .lang (les deux sont normalisés automatiquement au rendu). Passer null pour désactiver le tooltip.
  Fluent
• T tooltipDelay(int ticks)

  Délai avant l'affichage du tooltip en ticks (20 ticks = 1 seconde). Valeur par défaut : 15 ticks (0.75 s).
  Fluent
• String getTooltip()

  Retourne le texte du tooltip actuellement configuré, ou null si aucun.
  Getter

Une notification est composée d'un type, d'un message et d'une durée. Elle est créée via NotificationManager et non instanciée directement.

Types disponibles

• static void success(String message)

  Affiche une notification de type SUCCESS (verte) avec la durée par défaut (60 ticks).
  Statique
• static void error(String message)

  Affiche une notification de type ERROR (rouge) avec la durée par défaut.
  Statique
• static void info(String message)

  Affiche une notification de type INFO (bleue) avec la durée par défaut.
  Statique
• static void warning(String message)

  Affiche une notification de type WARNING (orange) avec la durée par défaut.
  Statique
• static void notify(Notification.Type type, String message, int durationTicks)

  Affiche une notification avec un type et une durée personnalisés.
  Statique
• void tick()

  Décrémente les timers et retire les notifications expirées. Appelé automatiquement par EriGuiScreen à chaque tick.
  Interne
• void render(int screenWidth, int screenHeight)

  Rend toutes les notifications actives. Appelé automatiquement par EriGuiScreen à chaque frame.
  Interne
• void clearAll()

  Supprime immédiatement toutes les notifications en cours (sans animation de sortie).
  Méthode
• int activeCount()

  Retourne le nombre de notifications actuellement affichées (entre 0 et 5).
  Getter

Palette de couleurs

Méthodes utilitaires

• int Colors.withAlpha(int color, int alpha)

  Retourne la même couleur mais avec un alpha différent. Alpha : 0 (transparent) à 255 (opaque). Ex: Colors.withAlpha(Colors.CYAN, 128) = cyan semi-transparent.
  Statique
• int Colors.fromHex(String hex)

  Crée une couleur depuis une chaîne hexadécimale. Ex: Colors.fromHex("#00DDFF") ou Colors.fromHex("FF00DDFF").
  Statique
• int Colors.lerp(int colorA, int colorB, float t)

  Mélange deux couleurs. t=0.0 = colorA, t=1.0 = colorB, t=0.5 = moitié-moitié. Utile pour les animations.
  Statique
• int Colors.of(int r, int g, int b)

  Crée une couleur depuis les composantes rouge, vert, bleu (0-255 chacune). Alpha = 255 (opaque).
  Statique
• int Colors.of(int r, int g, int b, int a)

  Crée une couleur depuis les composantes rouge, vert, bleu et alpha (0-255 chacune).
  Statique

import fr.eri.eriapi.gui.util.Colors;

// Utiliser une constante directement
label.color(Colors.WHITE);
label.color(Colors.CYAN);

// Couleur semi-transparente (alpha 128 = 50% opacité)
rectangle.fillColor(Colors.withAlpha(Colors.BLACK, 128));

// Couleur depuis hex (utile si tu copie depuis Photoshop/Figma)
int maColor = Colors.fromHex("#FF6600");    // Orange vif
int maColor2 = Colors.fromHex("80FF6600"); // Orange vif 50% transparent

// Couleur depuis RGB (rouge, vert, bleu)
int rouge = Colors.of(255, 0, 0);          // Rouge pur
int bleuPale = Colors.of(100, 160, 240);   // Bleu pâle

// Mélange de deux couleurs (animation de fadeout par exemple)
float t = 0.5f;   // 50% entre les deux
int fondu = Colors.lerp(Colors.WHITE, Colors.TRANSPARENT, t);
// Résultat : blanc à 50% de transparence

• static void drawRect(int x, int y, int w, int h, int color)

  Dessine un rectangle plein. Coordonnées en pixels écran.
  Statique
• static void drawRoundedRect(int x, int y, int w, int h, int radius, int color)

  Dessine un rectangle avec coins arrondis.
  Statique
• static void drawBorder(int x, int y, int w, int h, int thickness, int color)

  Dessine uniquement la bordure d'un rectangle (pas le remplissage).
  Statique
• static void drawCircle(int cx, int cy, int radius, int color)

  Dessine un cercle plein. cx, cy = centre du cercle.
  Statique
• static void drawGradient(int x, int y, int w, int h, int colorTop, int colorBottom)

  Dessine un rectangle avec un dégradé vertical de colorTop (haut) à colorBottom (bas).
  Statique
• static void drawText(String text, int x, int y, int color, boolean shadow)

  Dessine du texte à la position donnée. shadow=true ajoute une ombre portée.
  Statique
• static void drawCenteredText(String text, int centerX, int y, int color, boolean shadow)

  Dessine du texte centré horizontalement autour de centerX.
  Statique
• static void enableScissor(int x, int y, int w, int h)

  Active le "scissor" (découpe) : tout ce qui est dessiné en dehors de cette zone est invisible. Parfait pour les zones scrollables.
  Statique
• static void disableScissor()

  Désactive le scissor — obligatoire après enableScissor() pour ne pas affecter le reste du rendu.
  Statique

Exemple : dessin personnalisé dans un ListItem

import fr.eri.eriapi.gui.util.RenderUtil;
import fr.eri.eriapi.gui.util.Colors;

@Override
public void render(int x, int y, int width, int height, int mouseX, int mouseY) {

    // Fond de l'élément (légèrement plus clair au survol)
    boolean hover = mouseX >= x && mouseX < x + width
                 && mouseY >= y && mouseY < y + height;
    RenderUtil.drawRect(x, y, width, height,
        hover ? 0x1500DDFF : 0x08FFFFFF);

    // Barre de couleur à gauche (style indicateur)
    RenderUtil.drawRect(x, y, 4, height, Colors.CYAN);

    // Avatar circulaire (cercle de couleur représentant le joueur)
    int avatarX = x + 16 + (height / 2);  // Centre X de l'avatar
    int avatarY = y + (height / 2);        // Centre Y de l'avatar
    RenderUtil.drawCircle(avatarX, avatarY, height / 2 - 4, 0xFF4060FF);

    // Initiale du nom sur l'avatar
    String initiale = nomJoueur.substring(0, 1).toUpperCase();
    RenderUtil.drawCenteredText(initiale, avatarX, avatarY - 5, Colors.WHITE, true);

    // Nom du joueur
    RenderUtil.drawText(nomJoueur, x + height + 12, y + 8, Colors.WHITE, false);

    // Score à droite
    RenderUtil.drawText(score + " pts", x + width - 70, y + 8, Colors.CYAN, false);

    // Dégradé discret en bas de l'élément (séparateur)
    RenderUtil.drawGradient(x, y + height - 1, width, 1,
        Colors.withAlpha(Colors.WHITE, 20),
        Colors.withAlpha(Colors.WHITE, 0));
}

Sons pré-faits

Configuration globale

• static void setMuted(boolean muted)

  Active ou désactive tous les sons UI globalement. Quand true, aucun son ne sera joué par aucun composant.
  Statique
• static void toggleMute()

  Bascule l'état mute/unmute. Équivalent à setMuted(!isMuted()).
  Statique
• static void setVolume(float volume)

  Règle le volume global des sons UI. Valeur entre 0.0 (silencieux) et 1.0 (volume maximum). La valeur est appliquée à tous les sons joués par le SoundManager.
  Statique
• static void play(SoundEvent event, float volume, float pitch)

  Joue un son vanilla personnalisé avec le volume et le pitch spécifiés. Respecte le mute global et le volume global.
  Statique

Exemple d'utilisation

import fr.eri.eriapi.gui.util.SoundManager;
import net.minecraft.init.SoundEvents;

// --- Configuration globale ---
SoundManager.setMuted(true);      // Désactiver tous les sons UI
SoundManager.setMuted(false);     // Les réactiver
SoundManager.setVolume(0.5f);     // Volume global à 50%
SoundManager.toggleMute();        // Basculer mute/unmute

// --- Son vanilla personnalisé ---
SoundManager.play(SoundEvents.ENTITY_EXPERIENCE_ORB_PICKUP, 0.6f, 1.2f);

// --- Désactiver le son sur un composant spécifique ---
new Button("Silencieux", 100, 50, 120, 30)
    .sound(false)                 // Ce bouton ne jouera aucun son
    .onClick(() -> doSomething());

Exemple

import fr.eri.eriapi.gui.components.Dropdown;

// new Dropdown(x, y, width, height)
Dropdown dd = new Dropdown(660, 400, 300, 40)
    .placeholder("Choisir un rang...")
    .searchable(true)
    .maxVisibleItems(8)
    .onChange(val -> applyRank(val));

dd.addOption("Membre",  "member");
dd.addOption("Officier", "officer");
dd.addOption("Chef",    "leader");

root.add(dd);

• addOption(String label, String value)

  Ajoute une entree dans la liste deroulante. label est le texte affiche, value est la valeur retournee par getSelected().
  Methode
• setSelected(String value)

  Selectionne programmatiquement une entree par sa valeur. Si la valeur n'existe pas, l'etat retombe sur le placeholder.
  Fluent
• String getSelected()

  Retourne la valeur actuellement selectionnee, ou null si rien n'est selectionne.
  Getter
• onChange(Consumer<String> callback)

  Appele chaque fois que la selection change. Recoit la nouvelle valeur selectionnee.
  Evenement
• placeholder(String text)

  Texte affiche quand aucune valeur n'est selectionnee (ex : "Choisir..."). Grise et en italique.
  Fluent
• maxVisibleItems(int n)

  Nombre maximum d'entrees visibles avant que la liste devienne scrollable. Defaut : 6.
  Fluent
• searchable(boolean enabled)

  Active un champ de recherche en haut de la liste deroulante. Le texte tape filtre les entrees en temps reel.
  Fluent

Rendu differe (deferred rendering)

• static void Dropdown.renderDeferredDropdown()

  Dessine la liste deroulante ouverte. Appele automatiquement par EriGuiScreen.drawScreen() apres le rendu du root. A appeler manuellement uniquement si vous surchargez drawScreen() sans super.
  Static
• static boolean Dropdown.handleDeferredClick(int mouseX, int mouseY, int mouseButton)

  Gere le clic sur la liste deroulante ouverte. Appele automatiquement par EriGuiScreen.mouseClicked() avant le clic du root. Retourne true si le clic a ete consomme. A appeler manuellement uniquement si vous surchargez mouseClicked() sans super.
  Static
• static void Dropdown.resetState()

  Reinitialise l'etat interne du Dropdown (ferme la liste). Appele automatiquement par EriGuiScreen.onGuiClosed(). A appeler manuellement si vous gerez la fermeture du GUI vous-meme.
  Static

Exemple

import fr.eri.eriapi.gui.components.ToggleSwitch;

// new ToggleSwitch(x, y, width, height)
ToggleSwitch toggle = new ToggleSwitch(860, 500, 60, 30)
    .label("Afficher HUD Mana")
    .setState(true)
    .activeColor(0xFF00E5FF)
    .onToggle(on -> manaBarMod.setEnabled(on));

root.add(toggle);

// Lire l'etat depuis un autre composant :
boolean actif = toggle.getState();

• setState(boolean state)

  Definit l'etat initial ou programmatique du switch. true = active (pastille a droite), false = inactif.
  Fluent
• boolean getState()

  Retourne l'etat actuel du switch.
  Getter
• onToggle(Consumer<Boolean> callback)

  Appele chaque fois que l'utilisateur bascule le switch. Recoit le nouvel etat (true = active).
  Evenement
• label(String text)

  Texte affiche a droite du switch. Cliquer sur le label bascule egalement le switch.
  Fluent
• activeColor(int argb)

  Couleur de fond de la piste quand le switch est actif. Defaut : cyan (0xFF00E5FF).
  Fluent
• inactiveColor(int argb)

  Couleur de fond de la piste quand le switch est inactif. Defaut : gris sombre.
  Fluent

Methodes statiques

• static void Modal.confirm(String title, String msg, Runnable onConfirm, Runnable onCancel)

  Affiche un dialog de confirmation avec deux boutons : "Confirmer" (vert) et "Annuler" (gris). Appelle onConfirm ou onCancel selon le choix.
  Statique
• static void Modal.alert(String title, String msg, Runnable onClose)

  Affiche un dialog d'alerte avec un seul bouton "OK". Appelle onClose a la fermeture (bouton ou Echap).
  Statique
• static ContainerComponent Modal.custom(String title, int width, int height)

  Cree un modal vide et retourne son ContainerComponent interne. Tu peux y ajouter n'importe quel composant pour personnaliser entierement le contenu.
  Statique

Exemple

import fr.eri.eriapi.gui.components.Modal;

// Dialog de confirmation — action irreversible
Modal.confirm(
    "Dissoudre la faction ?",
    "Cette action est irreversible. Tous les membres seront exclus.",
    () -> factionManager.dissolve(player),   // Confirmer
    () -> {}                                 // Annuler (ne rien faire)
);

// Dialog d'alerte simple
Modal.alert(
    "Permission refusee",
    "Vous n'avez pas les droits pour effectuer cette action.",
    () -> {}
);

// Modal personnalise avec des composants libres
ContainerComponent content = Modal.custom("Parametres avances", 600, 400);
content.add(new Label(20, 20, 560, 30, "Choisissez une option :"));
content.add(new Dropdown(20, 60, 560, 40)
    .addOption("Option A", "a")
    .addOption("Option B", "b"));

Exemple

import fr.eri.eriapi.gui.components.PlayerHead;
import com.mojang.authlib.GameProfile;

// A partir d'un GameProfile (joueur connecte)
PlayerHead head = new PlayerHead(860, 300, 80, player.getGameProfile())
    .setRotation(-20f, 15f)  // yaw, pitch
    .showHat(true);

root.add(head);

// A partir d'un UUID (joueur hors-ligne / stocke)
UUID uuid = UUID.fromString("069a79f4-44e9-4726-a5be-fca90e38aaf5"); // Notch
PlayerHead headByUuid = new PlayerHead(960, 300, 80, uuid)
    .showHat(false);

• PlayerHead(int x, int y, int size, GameProfile profile)

  Cree un rendu de tete a partir d'un GameProfile. Le skin est charge automatiquement.
  Constructeur
• PlayerHead(int x, int y, int size, UUID uuid)

  Cree un rendu de tete a partir d'un UUID. Le skin est recupere de facon asynchrone.
  Constructeur
• setProfile(GameProfile profile)

  Change le profil rendu (utile pour les listes dynamiques).
  Fluent
• setRotation(float yaw, float pitch)

  Oriente la tete en degres. Yaw = rotation gauche/droite, pitch = haut/bas. Ex : (-20f, 15f) pour un angle tres-quart de face.
  Fluent
• showHat(boolean enabled)

  Affiche ou cache la seconde couche du skin (chapeau, accessoires). Defaut : true.
  Fluent

Exemple

import fr.eri.eriapi.gui.components.ItemStackRenderer;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;

// new ItemStackRenderer(x, y, size, stack)
ItemStackRenderer renderer = new ItemStackRenderer(
        900, 400, 32, new ItemStack(Items.DIAMOND_SWORD))
    .showTooltip(true)    // Affiche le tooltip vanilla au survol
    .showCount(false)     // Cache le numero de stack
    .scale(1.5f);         // Agrandit l'icone de 50%

root.add(renderer);

// Changer l'item dynamiquement (ex : inventaire)
renderer.setStack(player.getHeldItemMainhand());

• setStack(ItemStack stack)

  Remplace l'ItemStack rendu. Peut etre appele a chaque tick pour un rendu dynamique.
  Fluent
• showTooltip(boolean enabled)

  Affiche le tooltip vanilla (nom, lore, enchantements) quand la souris survole le composant. Defaut : true.
  Fluent
• showCount(boolean enabled)

  Affiche le texte du nombre d'items en superposition (coin bas-droit). Defaut : true. Independant de showDurability() — vous pouvez cacher le compteur tout en gardant la barre de durabilite.
  Fluent
• showDurability(boolean enabled)

  Affiche la barre de durabilite sous l'icone (pour les items avec durabilite). Defaut : true. Independant de showCount() — par exemple, showCount(false).showDurability(true) affiche la barre de durabilite sans le texte du compteur.
  Fluent
• scale(float factor)

  Facteur de mise a l'echelle de l'icone. 1.0f = taille normale (16x16), 2.0f = double. Defaut : 1.0f.
  Fluent

Exemple — inventaire client simple

import fr.eri.eriapi.gui.components.ItemSlot;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;

// Slot vide interactif
ItemSlot slot = new ItemSlot()
    .originalPos(100, 100)
    .originalSize(48, 48)
    .onSlotChanged((s, stack) -> System.out.println("Contenu : " + stack.getDisplayName()));

// Slot pre-rempli avec un diamant
ItemSlot slotDia = new ItemSlot(new ItemStack(Items.DIAMOND, 32))
    .originalPos(160, 100)
    .originalSize(48, 48)
    .slotId("chest:0")                               // identifiant logique pour le serveur
    .onSlotChanged((s, stack) -> saveToServer(stack))
    .onShiftClick((s, stack) -> transferToPlayer(stack));

root.add(slot, slotDia);

Exemple — mode server-only (inventaire serveur)

// Tous les slots ciblent le serveur — aucune manipulation locale
for (int i = 0; i < 27; i++) {
    final int idx = i;
    ItemSlot slot = new ItemSlot()
        .originalPos(80 + (i % 9) * 54, 200 + (i / 9) * 54)
        .originalSize(48, 48)
        .serverOnly(true)            // mode server-authoritative
        .slotId("chest:" + idx)      // identifiant envoye au serveur dans le drag callback
        .onAnyClick((s, button) -> {
            // Appele pour chaque clic simple. button : 0=gauche, 1=droit, 2=shift+gauche
            sendClickPacket(idx, button, ItemSlot.getCursorStack());
        })
        .onDoubleClick((s, type) -> {
            // type 0 = double-clic collecte, type 3 = shift+double-clic
            sendDoubleClickPacket(idx, type);
        });
    root.add(slot);
}

// Enregistrer le callback de drag (un seul, global)
ItemSlot.setServerDragCallback((button, targetSlotIds) -> {
    sendDragPacket(button, targetSlotIds);
});

Exemple — mode takeOnly (vitrine)

// Le joueur peut prendre l'item mais pas en deposer d'autre
ItemSlot vitrine = new ItemSlot(new ItemStack(Items.DIAMOND_SWORD))
    .originalPos(200, 300)
    .originalSize(48, 48)
    .takeOnly(true)
    .onSlotChanged((s, taken) -> giveTo(player, taken));

Comportement des clics (mode normal)

Flux server-only — une seule action par clic physique

En mode serverOnly, aucune action n'est fired a mouseDown. Toute la logique est decidee a mouseUp (via onDragEnd()) : si des slots de drag ont ete accumules, c'est un drag — sinon c'est un clic simple. Un seul callback est toujours declenche, jamais deux.

• ItemSlot()

  Cree un slot vide.
  Constructeur
• ItemSlot(ItemStack stack)

  Cree un slot pre-rempli avec l'ItemStack fourni.
  Constructeur
• stack(ItemStack s)

  Definit ou remplace l'ItemStack du slot. Passe null pour vider le slot.
  Fluent
• interactive(boolean b)

  Active ou desactive les interactions. Un slot non-interactif est rendu mais ne repond pas aux clics. Defaut : true.
  Fluent
• takeOnly(boolean b)

  Mode prise directe — un clic prend l'item sans passer par le curseur. Le joueur ne peut pas deposer d'item dans ce slot.
  Fluent
• serverOnly(boolean b)

  Mode server-authoritative — aucune manipulation locale. Les clics et drags sont deleguees aux callbacks, le serveur repond avec le nouvel etat. Active automatiquement interactive(true).
  Fluent
• slotId(String id)

  Identifiant logique du slot (ex. : "chest:5", "player:12"). Utilise par le drag server-only pour identifier les slots dans le packet envoye au serveur.
  Fluent
• filter(Predicate<ItemStack> f)

  Filtre les items acceptes. Retourner false bloque le depot de l'item dans ce slot.
  Fluent
• bgColor(int color)

  Couleur de fond du slot au repos (ARGB). Defaut : 0x20FFFFFF.
  Fluent
• hoverColor(int color)

  Couleur de fond au survol de la souris (ARGB). Defaut : 0x40FFFFFF.
  Fluent
• slotBorderColor(int color)

  Couleur de la bordure du slot (ARGB). Mettre 0 pour supprimer la bordure. Defaut : 0x15FFFFFF.
  Fluent
• cornerRadius(int r)

  Rayon des coins arrondis en pixels de design. Defaut : 4.
  Fluent
• onSlotChanged(SlotAction action)

  Callback appele quand le contenu du slot change. Recoit le slot et la nouvelle ItemStack (vide si slot vide). Signature : (ItemSlot slot, ItemStack stack) -> void.
  Fluent
• onShiftClick(SlotAction action)

  Callback appele sur Shift+clic gauche. Recoit le slot et son ItemStack actuel. Utilise pour implementer le transfer en masse (ex. : coffre → inventaire joueur).
  Fluent
• onRightClick(SlotAction action)

  Callback appele sur clic droit quand le curseur est vide (ramassage de la moitie).
  Fluent
• onAnyClick(ClickAction action)

  Callback generique appele sur n'importe quel clic simple en mode serverOnly. Signature : (ItemSlot slot, int button) -> void. button vaut 0 (gauche), 1 (droit) ou 2 (shift+gauche).
  Fluent
• onDoubleClick(DoubleClickAction action)

  Callback appele sur double-clic gauche en mode serverOnly. Signature : (ItemSlot slot, int type) -> void. type vaut 0 (collecte) ou 3 (Shift+double-clic transfer).
  Fluent

Methodes statiques

• ItemSlot.getCursorStack()

  Retourne l'ItemStack actuellement tenu par le curseur (partage entre tous les slots du GUI).
  Statique
• ItemSlot.setCursorStack(ItemStack s)

  Force le contenu du curseur (utile pour appliquer la reponse serveur).
  Statique
• ItemSlot.clearCursor()

  Vide le curseur et reinitialise toute l'etat de drag. Appele automatiquement par EriGuiScreen.onGuiClosed().
  Statique
• ItemSlot.renderCursorItem(int mouseX, int mouseY)

  Rend l'item tenu par le curseur a la position de la souris. Appele automatiquement par EriGuiScreen.drawScreen() apres tous les composants.
  Statique
• ItemSlot.setServerDragCallback(ServerDragCallback cb)

  Enregistre le callback de drag global pour le mode server-only. Signature : (int button, List<String> targetSlotIds) -> void. Un seul callback suffit pour tout le GUI.
  Statique
• ItemSlot.onDragEnd()

  Finalise le drag en cours et fire les callbacks appropries. Appele automatiquement par EriGuiScreen.mouseReleased(). Ne jamais appeler manuellement.
  Statique

Exemple

import fr.eri.eriapi.gui.components.TexturedRect;
import net.minecraft.util.ResourceLocation;

// Icone 64x64 en couleur
TexturedRect icon = new TexturedRect(
        new ResourceLocation("eriniumfaction", "textures/gui/faction_icon.png"))
    .originalPos(40, 40)
    .originalSize(64, 64)
    .tint(0xFFFFFFFF);          // blanc = pas de teinte

root.add(icon);

// Icone desaturee (niveaux de gris) pour un element inactif
TexturedRect iconGray = new TexturedRect(
        new ResourceLocation("eriniumfaction", "textures/gui/faction_icon.png"))
    .originalPos(120, 40)
    .originalSize(64, 64)
    .grayscale(true);

root.add(iconGray);

// Teinte coloree semi-transparente
TexturedRect tinted = new TexturedRect(
        new ResourceLocation("eriniumfaction", "textures/gui/banner.png"))
    .originalPos(0, 0)
    .originalSize(1920, 1080)
    .tint(0x80FF6600)           // orange 50% transparent
    .textureSize(256, 128);     // taille reelle de l'image PNG

root.add(tinted);

// Mettre a jour dynamiquement
icon.setGrayscale(true);
icon.setTint(0x80FFFFFF);

• TexturedRect(ResourceLocation texture)

  Cree un composant qui rend la texture PNG specifiee. La texture doit etre dans le classpath du mod (dossier assets/).
  Constructeur
• texture(ResourceLocation tex)

  Remplace la texture rendue. Peut etre appele dynamiquement pour changer l'image affichee.
  Fluent
• tint(int color)

  Applique une teinte ARGB sur la texture. 0xFFFFFFFF = aucune teinte (defaut). L'alpha de la teinte multiplie l'opacite du composant.
  Fluent
• grayscale(boolean gray)

  Active le rendu en niveaux de gris (applique une couleur neutre (0.35, 0.35, 0.35)). Utile pour des elements desactives ou des icones inactives. Defaut : false.
  Fluent
• textureSize(int w, int h)

  Declare la resolution reelle de l'image PNG (en pixels). Informe le moteur de rendu sur les proportions UV de la texture. Defaut : 64x64.
  Fluent
• setGrayscale(boolean g)

  Equivalent non-fluent de grayscale() — utile pour basculer le mode depuis un callback.
  Setter
• setTint(int c)

  Equivalent non-fluent de tint() — utile pour animer la teinte depuis un onColorUpdate().
  Setter
• getTexture()

  Retourne la ResourceLocation de la texture actuellement affichee.
  Getter

Exemple

import fr.eri.eriapi.gui.components.Divider;

// new Divider(x, y, length)  — horizontal par defaut
root.add(new Divider(60, 200, 500)
    .gradient(0x4400E5FF, 0x00000000)  // Cyan vers transparent
    .thickness(1)
    .margin(20));

// Separateur vertical plein
root.add(new Divider(960, 100, 800)
    .vertical()
    .color(0x33FFFFFF)
    .thickness(2));

• horizontal()

  Mode horizontal (defaut). Le parametre length est la largeur.
  Fluent
• vertical()

  Mode vertical. Le parametre length devient la hauteur.
  Fluent
• color(int argb)

  Couleur unie de la ligne. Remplace tout degrade defini precedemment.
  Fluent
• thickness(int px)

  Epaisseur de la ligne en pixels design. Defaut : 1.
  Fluent
• gradient(int startColor, int endColor)

  Applique un degrade lineaire de startColor a endColor le long de la ligne. Remplace la couleur unie.
  Fluent
• margin(int px)

  Espace vide (transparent) au debut et a la fin de la ligne. Utile pour laisser de l'air par rapport aux bords du panneau.
  Fluent

Exemple

import fr.eri.eriapi.gui.components.Badge;

// new Badge(x, y, text) — taille auto calculee depuis le texte
root.add(new Badge(200, 150, "Combat")
    .color(0x206B2FA0, 0xFF9B4FCF)  // (bgColor, textColor)
    .outlined(true));

// Badge avec icone
root.add(new Badge(300, 150, "Chef")
    .color(0x20FFD700, 0xFFFFD700)
    .icon(new ResourceLocation("eriniumfaction", "textures/gui/icon_crown.png"))
    .cornerRadius(4));

// Badge plein (non outlined)
root.add(new Badge(400, 150, "En ligne")
    .color(0xFF1A6B3C, 0xFF2ECC71)
    .scale(0.75f));

• color(int bgColor, int textColor)

  Couleur de fond et couleur du texte en ARGB. Le fond accepte un alpha faible pour un effet translucide.
  Fluent
• outlined(boolean enabled)

  Mode contour : fond transparent, bordure coloree avec bgColor.
  Fluent
• cornerRadius(int px)

  Rayon des coins en pixels design. Defaut : 999 (pilule parfaite). Mettre 4 pour un look rectangulaire arrondi.
  Fluent
• icon(ResourceLocation texture)

  Icone 16x16 affichee a gauche du texte. La largeur du badge s'ajuste automatiquement.
  Fluent
• scale(float factor)

  Scale du texte du badge. Defaut : 0.8f. Diminuer pour les badges tres compacts.
  Fluent

Exemple

import fr.eri.eriapi.gui.components.Accordion;

// new Accordion(x, y, width)
Accordion acc = new Accordion(660, 300, 600)
    .singleMode(true);  // Une seule section ouverte a la fois

acc.addSection("Informations", section -> {
    section.add(new Label(10, 10, 580, 20,
        "Nom : " + faction.getName()));
    section.add(new Label(10, 35, 580, 20,
        "Membres : " + faction.getMemberCount()));
});

acc.addSection("Statistiques", section -> {
    section.add(new Label(10, 10, 580, 20,
        "Victoires : " + faction.getWins()));
    section.add(new Label(10, 35, 580, 20,
        "Defaites : " + faction.getLosses()));
});

acc.addSection("Membres", section -> {
    for (String member : faction.getMembers()) {
        section.add(new Label(10, 10 + i * 25, 580, 20, member));
    }
});

root.add(acc);

• addSection(String title, Consumer<ContainerComponent> builder)

  Ajoute une section avec l'en-tete title. Le lambda recoit le ContainerComponent de contenu — ajoute tes composants dedans.
  Methode
• expandAll()

  Deplie toutes les sections. Ignore singleMode.
  Methode
• collapseAll()

  Replie toutes les sections.
  Methode
• singleMode(boolean enabled)

  Quand actif, ouvrir une section ferme automatiquement toute autre section ouverte. Defaut : false.
  Fluent

Exemple

import fr.eri.eriapi.gui.components.Carousel;

// new Carousel(x, y, width, height)
Carousel car = new Carousel(200, 300, 1520, 400)
    .setVisibleCount(3)    // 3 cartes visibles simultanement
    .showArrows(true)      // Boutons < et > de navigation
    .showDots(true)        // Points indicateurs en bas
    .autoScroll(100);      // Defilement auto toutes les 100 ticks (5 sec)

// Ajouter des items (n'importe quel Component)
for (FactionCard card : factionCards) {
    ContainerComponent cardComp = new ContainerComponent(0, 0, 480, 380);
    cardComp.add(new Rectangle(0, 0, 480, 380)
        .fillColor(0xCC1A1A2E).cornerRadius(12));
    cardComp.add(new Label(20, 20, 440, 30, card.getName())
        .scale(2.0f).color(0xFFFFFFFF));
    car.addItem(cardComp);
}

root.add(car);

• addItem(Component component)

  Ajoute un element au carousel. Chaque item est un Component quelconque — generalement un ContainerComponent.
  Methode
• setVisibleCount(int n)

  Nombre d'items affiches simultanement. L'espace disponible est divise equitablement. Defaut : 1.
  Fluent
• showArrows(boolean enabled)

  Affiche les boutons fleche gauche/droite sur les cotes du carousel.
  Fluent
• showDots(boolean enabled)

  Affiche des points indicateurs en bas du carousel (un point par item, l'actif est mis en evidence).
  Fluent
• autoScroll(int intervalTicks)

  Active le defilement automatique toutes les intervalTicks ticks. Passer 0 pour desactiver.
  Fluent

Formes disponibles — enum BarShape

Sens de remplissage — enum FillDirection

Exemples

import fr.eri.eriapi.gui.components.ProgressBarEnhanced;
import fr.eri.eriapi.gui.components.ProgressBarEnhanced.BarShape;
import fr.eri.eriapi.gui.components.ProgressBarEnhanced.FillDirection;

// Anneau circulaire pour un cooldown
ProgressBarEnhanced ring = new ProgressBarEnhanced(860, 440, 200, 200)
    .shape(BarShape.CIRCULAR)
    .value(0.72f)
    .barWidth(18)
    .gradientFill(0xFF00E5FF, 0xFF6B2FA0)
    .backgroundColor(0xFF1A1A2E)
    .showPercentage(true)
    .animate(true);

root.add(ring);

// Barre XP segmentee style old-school
ProgressBarEnhanced bar = new ProgressBarEnhanced(100, 50, 400, 20)
    .shape(BarShape.HORIZONTAL)
    .value(0.5f)
    .segments(10)
    .segmentGap(2)
    .fillColor(0xFF00D4FF)
    .cornerRadius(4)
    .animate(true)
    .animationSpeed(10);  // Transition en 10 ticks (0.5 sec)

root.add(bar);

• shape(BarShape shape)

  Definit la forme geometrique de la barre. Voir le tableau BarShape ci-dessus.
  Fluent
• value(float v)

  Valeur de remplissage entre 0.0 (vide) et 1.0 (plein). Si animate est actif, la transition est animee.
  Fluent
• fillColor(int argb)

  Couleur unie du remplissage. Remplace tout degrade defini.
  Fluent
• backgroundColor(int argb)

  Couleur de la zone vide (fond de la barre).
  Fluent
• barWidth(int px)

  Epaisseur de l'anneau ou du contour pour les formes circulaires et polygonales.
  Fluent
• gradientFill(int startColor, int endColor)

  Degrade lineaire du remplissage. Pour CIRCULAR/PIE, le degrade suit l'arc.
  Fluent
• segments(int n)

  Divise la barre en n segments separes. Tres utile pour les barres de vie style jeu de roles.
  Fluent
• segmentGap(int px)

  Espacement en pixels design entre les segments.
  Fluent
• direction(FillDirection dir)

  Sens de remplissage. Voir le tableau FillDirection ci-dessus.
  Fluent
• animate(boolean enabled)

  Active les transitions animees lors des changements de valeur via value().
  Fluent
• animationSpeed(int ticks)

  Duree de la transition en ticks. Defaut : 10 (0.5 sec). Necessite animate(true).
  Fluent
• showPercentage(boolean enabled)

  Affiche le pourcentage ("72%") au centre du composant.
  Fluent
• label(String text)

  Texte centre affiche en superposition. Remplace le pourcentage si showPercentage est aussi actif.
  Fluent
• cornerRadius(int px)

  Rayon des coins pour les formes HORIZONTAL, VERTICAL et SQUARE.
  Fluent