Overlay HUD

import fr.eri.eriapi.overlay.*;
import fr.eri.eriapi.gui.components.*;

public class HealthOverlay extends EriOverlay {

    public HealthOverlay() {
        // id unique, largeur et hauteur en design pixels
        super("health_hud", 200, 60);

        setAnchor(Anchor.BOTTOM_LEFT);   // coin inferieur gauche
        setOffset(10, -10);              // decalage depuis l'ancrage
    }

    @Override
    protected void buildOverlay() {
        getRoot().add(
            new Rectangle(0, 0, 200, 60)
                .fillColor(0x80000000)
                .cornerRadius(8),
            new Label(10, 20, 180, 20, "HP : 20")
                .color(0xFFFF5555)
        );
    }
}

// Enregistrement (une fois, dans ClientProxy.init() par exemple) :
OverlayManager.getInstance().register(new HealthOverlay());

import fr.eri.eriapi.overlay.OverlayManager;

OverlayManager om = OverlayManager.getInstance();

// Enregistrer des overlays (une fois, en init)
om.register(new HealthOverlay());
om.register(new ManaOverlay());
om.register(new FactionHudOverlay());

// Controle de la visibilite par ID
om.show("health_hud");
om.hide("health_hud");
om.toggle("health_hud");

// Controle global
om.hideAll();
om.showAll();

// Recuperer un overlay pour le modifier
EriOverlay overlay = om.get("health_hud");
if (overlay != null) {
    overlay.rebuild(); // Forcer une reconstruction
}

// Desenregistrer un overlay
om.unregister("health_hud");

// Overlay en bas a droite avec 15px de marge
new MonOverlay()
    .setAnchor(Anchor.BOTTOM_RIGHT)
    .setOffset(-15, -15);  // negatif = vers le haut/gauche

// Overlay centre en haut avec 20px de marge du bord
new BossBarOverlay()
    .setAnchor(Anchor.TOP_CENTER)
    .setOffset(0, 20);     // positif = vers le bas

// Afficher l'overlay par-dessus tout le HUD (comportement par defaut)
overlay.setLayer(OverlayLayer.POST_ALL);

// Afficher juste apres la hotbar
overlay.setLayer(OverlayLayer.POST_HOTBAR);

// Fond ambiant sous tout le HUD
overlay.setLayer(OverlayLayer.PRE_ALL);

public class ManaOverlay extends EriOverlay {

    private Label manaLabel;
    private ProgressBar manaBar;

    public ManaOverlay() {
        super("mana_hud", 200, 40);
        setAnchor(Anchor.BOTTOM_LEFT);
        setOffset(10, -70); // au-dessus de la barre de vie vanilla
    }

    @Override
    protected void buildOverlay() {
        manaLabel = new Label(10, 5, 100, 15, "Mana")
            .color(0xFF9B59B6);

        manaBar = new ProgressBar(10, 22, 180, 10)
            .progress(1f)
            .fillColor(0xFF6B2FA0)
            .backgroundColor(0x40000000)
            .cornerRadius(5);

        getRoot().add(manaLabel, manaBar);

        // Animation respirante — scope "overlay" pour ne pas etre arretee
        // quand le joueur ouvre/ferme un GUI
        Animation anim = Animation.create(0.6f, 1f, 30)
            .pingPong()
            .scope("overlay")
            .easing(Easing.EASE_IN_OUT)
            .onUpdate(v -> manaLabel.setOpacity(v));
        AnimationManager.getInstance().play(anim);
    }

    // Methode publique pour mettre a jour la valeur de mana
    public void setMana(float ratio) {
        if (manaBar != null) {
            manaBar.progress(ratio);
        }
    }
}

// ❌ Sera arrete quand le joueur ferme un GUI
label.breathe(40); // helper interne, pas de scope

// ✅ Continue meme quand un GUI est ouvert puis ferme
Animation.create(0.4f, 1f, 20)
    .pingPong()
    .scope("overlay")
    .easing(Easing.EASE_IN_OUT)
    .onUpdate(v -> label.setOpacity(v));
AnimationManager.getInstance().play(breatheAnim);

import fr.eri.eriapi.overlay.*;
import fr.eri.eriapi.gui.components.*;

public class ManaOverlay extends EriOverlay {

    private ProgressBar manaBar;
    private Label manaLabel;

    public ManaOverlay() {
        super("mana_overlay", 210, 50);
        setAnchor(Anchor.BOTTOM_LEFT);
        setOffset(10, -80); // juste au-dessus de la barre de vie
        hideInGui(true);    // masquer si GUI ouvert
        hideOnF1(true);     // masquer si F1
    }

    @Override
    protected void buildOverlay() {
        // Fond
        getRoot().add(new Rectangle(0, 0, 210, 50)
            .fillColor(0x90000000)
            .cornerRadius(6));

        // Label "Mana"
        manaLabel = new Label(8, 6, 60, 12, "MANA")
            .color(0xFFBB86FC)
            .scale(0.8f)
            .shadow(true);

        // Barre de mana
        manaBar = new ProgressBar(8, 24, 194, 12)
            .progress(1f)
            .fillColor(0xFF6B2FA0)
            .backgroundColor(0x50000000)
            .cornerRadius(6);

        // Label valeur
        Label valueLabel = new Label(8, 38, 194, 10, "100 / 100")
            .color(0x80FFFFFF)
            .scale(0.75f)
            .align(Label.Align.CENTER);

        getRoot().add(manaLabel, manaBar, valueLabel);
    }

    /** Appele depuis ton systeme de mana pour mettre a jour la barre. */
    public void setMana(int current, int max) {
        if (manaBar != null) {
            manaBar.progress((float) current / max);
        }
    }
}

// Dans ClientProxy.init() :
ManaOverlay manaOverlay = new ManaOverlay();
OverlayManager.getInstance().register(manaOverlay);

// Depuis n'importe ou dans ton mod (cote client) :
ManaOverlay overlay = (ManaOverlay) OverlayManager.getInstance().get("mana_overlay");
if (overlay != null) overlay.setMana(75, 100);

import fr.eri.eriapi.overlay.*;
import fr.eri.eriapi.gui.components.*;

public class FactionHudOverlay extends EriOverlay {

    private Label factionNameLabel;
    private Label rankLabel;
    private Label membersLabel;

    public FactionHudOverlay() {
        super("faction_hud", 220, 70);
        setAnchor(Anchor.BOTTOM_RIGHT);
        setOffset(-10, -10);
    }

    @Override
    protected void buildOverlay() {
        // Fond avec degrade
        getRoot().add(new GradientRectangle()
            .originalPos(0, 0).originalSize(220, 70)
            .vertical(0x80150A2A, 0x801A0B35)
            .cornerRadius(8));

        // Bordure superieure
        getRoot().add(new GradientRectangle()
            .originalPos(0, 0).originalSize(220, 2)
            .horizontal(0x00000000, 0xFF6B2FA0)
            .cornerRadius(0));

        // Icone / prefixe
        getRoot().add(new Label(8, 10, 20, 16, "\u2726")
            .color(0xFFFFD700)
            .scale(1.0f));

        // Nom de la faction
        factionNameLabel = new Label(28, 8, 180, 18, "Aucune faction")
            .color(0xFFE0E0E0)
            .scale(1.0f)
            .shadow(true);

        // Grade
        rankLabel = new Label(8, 30, 204, 14, "Grade : ---")
            .color(0xFF9B8BCC)
            .scale(0.85f);

        // Membres en ligne
        membersLabel = new Label(8, 48, 204, 14, "Membres en ligne : 0")
            .color(0xFF6BCB77)
            .scale(0.85f);

        getRoot().add(factionNameLabel, rankLabel, membersLabel);
    }

    public void update(String faction, String rank, int onlineMembers) {
        if (factionNameLabel != null) factionNameLabel.text(faction);
        if (rankLabel != null) rankLabel.text("Grade : " + rank);
        if (membersLabel != null) membersLabel.text("Membres en ligne : " + onlineMembers);
    }
}

import fr.eri.eriapi.overlay.*;
import fr.eri.eriapi.gui.components.*;
import fr.eri.eriapi.gui.anim.*;

public class AmbientOverlay extends EriOverlay {

    public AmbientOverlay() {
        super("ambient_overlay", 1920, 300);
        setAnchor(Anchor.TOP_LEFT);
        setLayer(OverlayLayer.PRE_ALL); // sous le HUD vanilla
        hideInGui(false); // reste visible meme dans les menus
        hideOnF1(true);
    }

    @Override
    protected void buildOverlay() {
        // Champ d'etoiles en fond
        getRoot().add(new Starfield()
            .originalPos(0, 0).originalSize(1920, 300)
            .starCount(60)
            .starColor(0xFFF0F2FF)
            .shootingStarChance(0.002f));

        // Aurora au-dessus
        getRoot().add(new Aurora()
            .originalPos(0, 0).originalSize(1920, 300)
            .addBand(0x306B2FA0, 0.4f, 1.0f, 100, 80)
            .addBand(0x2000E5FF, 0.6f, 0.7f, 80, 160)
            .speed(0.015f));
    }
}

import fr.eri.eriapi.overlay.OverlayMod;
import fr.eri.eriapi.gui.components.*;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;

public class HealthOverlayMod extends OverlayMod {

    private Label healthLabel;
    private Rectangle background;

    public HealthOverlayMod() {
        super("my_health", "Health Display", 200, 40);
        setCategory("Combat");
        setDescription("Affiche les PV du joueur.");
        setDefaultPosition(0.01f, 0.9f);  // bas-gauche (x et y en fraction de l'ecran)
        setMinScale(0.5f);
        setMaxScale(2.0f);
    }

    @Override
    protected void buildOverlay() {
        background = new Rectangle();
        background.originalPos(0, 0).originalSize(200, 40);
        background.fillColor(0xAA000000).cornerRadius(6);
        getRoot().add(background);

        healthLabel = new Label("HP: 20/20");
        healthLabel.originalPos(8, 8).originalSize(184, 24);
        healthLabel.color(0xFFFF5555).scale(1.2f);
        getRoot().add(healthLabel);
    }

    @Override
    protected void onFrame(float partialTicks, long deltaNanos) {
        EntityPlayer player = Minecraft.getMinecraft().player;
        if (player == null) return;
        int hp = (int) player.getHealth();
        int maxHp = (int) player.getMaxHealth();
        healthLabel.text("HP: " + hp + "/" + maxHp);
    }
}

import fr.eri.eriapi.overlay.OverlayModManager;

// Dans ClientProxy.init() :
OverlayModManager.getInstance().register(new HealthOverlayMod());
OverlayModManager.getInstance().register(new DebugOverlayMod());
OverlayModManager.getInstance().register(new FactionInfoMod());

@Override
protected void buildSettings(ModSettings settings) {
    settings
        .separator("Sections visibles")
        .toggle("show_fps", "FPS", true)
        .toggle("show_coords", "Coordonnees", true)
        .separator("Apparence")
        .colorPicker("text_color", "Couleur du texte", 0xFFCCCCCC)
        .slider("bg_opacity", "Opacite du fond", 0f, 1f, 0.67f)
        .toggle("compact", "Mode compact", false);
}

@Override
protected void onSettingChanged(String key, Object value) {
    if ("text_color".equals(key)) {
        int color = (Integer) value;
        myLabel.color(color);
    } else if ("compact".equals(key)) {
        rebuild();  // Le layout change completement en mode compact
    }
}

// Lire une valeur dans onFrame() ou onTick() :
boolean showFps = getSetting("show_fps", true);
float opacity  = getSetting("bg_opacity", 0.67f);

// Ouvrir l'editeur depuis du code (ex. : depuis un keybinding ou une commande)
OverlayModManager.getInstance().openEditor();

private long timer = 0L;
private static final long INTERVAL = 500_000_000L; // 500ms en nanosecondes

@Override
protected void onFrame(float partialTicks, long deltaNanos) {
    timer += deltaNanos;

    // Mise a jour legere chaque frame (fluide)
    fpsLabel.text("FPS: " + Minecraft.getDebugFPS());

    // Mise a jour lourde toutes les 500ms seulement
    if (timer >= INTERVAL) {
        timer = 0L;
        biomeLabel.text("Biome: " + getBiomeName()); // acces au monde, plus couteux
    }
}

// Methode historique — fractions (0.0 a 1.0)
// Toujours valide, convert en interne : x * 1920, y * 1080
setDefaultPosition(0.01f, 0.9f);   // ≈ (19, 972) en design-pixels

// Nouvelle methode — pixels de design directs (recommandee)
// Plus precis et coherent avec le reste du systeme EriAPI
setDefaultPositionDesign(20f, 960f);  // exactement 20px a gauche, 960px en bas

// Barre de mana en bas a gauche
public class ManaBarMod extends OverlayMod {
    public ManaBarMod() {
        super("mana_bar", "Mana", 240, 20);
        setDefaultPositionDesign(20f, 1010f); // 20px depuis la gauche, 1010px depuis le haut
    }
}

// Barre d'endurance juste en dessous, ecart de 6 design-pixels
public class StaminaMod extends OverlayMod {
    public StaminaMod() {
        super("stamina_bar", "Endurance", 240, 20);
        // 1010 (mana) + 20 (hauteur mana) + 6 (ecart) = 1036
        setDefaultPositionDesign(20f, 1036f);
    }
}
// L'ecart de 6 design-pixels est identique a toutes les resolutions.

.minecraft/config/eriapi/overlay_mods.json

package fr.eriniumgroup.eriniumfaction.overlay;

import fr.eri.eriapi.gui.components.Label;
import fr.eri.eriapi.gui.components.Rectangle;
import fr.eri.eriapi.overlay.OverlayMod;
import fr.eri.eriapi.overlay.settings.ModSettings;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.chunk.Chunk;

public class DebugOverlayMod extends OverlayMod {

    // Labels mis a jour chaque frame
    private Label fpsLabel;
    private Label coordsLabel;
    private Label chunkLabel;
    private Label biomeLabel;
    private Label directionLabel;
    private Label lightLabel;
    private Label memoryLabel;

    // Fond
    private Rectangle background;

    // Timer nanotime pour les mises a jour lourdes (500ms)
    private long heavyUpdateTimer = 0L;
    private static final long HEAVY_UPDATE_INTERVAL = 500_000_000L;

    // Cache pour les valeurs lourdes
    private String cachedBiome   = "";
    private String cachedLight   = "";
    private String cachedMemory  = "";

    public DebugOverlayMod() {
        super("erinium_debug", "Debug Info", 380, 160);
        setCategory("Informations");
        setDescription("Affiche FPS, coordonnees, biome, direction et memoire.");
        setDefaultPosition(0.005f, 0.005f); // coin superieur gauche
        setMinScale(0.5f);
        setMaxScale(2.0f);
    }

    @Override
    protected void buildOverlay() {
        int w = 380;

        // Fond semi-transparent avec coins arrondis
        background = new Rectangle();
        background.originalPos(0, 0).originalSize(w, 160);
        background.fillColor(0xAA1A1A2E).cornerRadius(6);
        getRoot().add(background);

        // Creation des labels sur chaque ligne (espacement de 20px)
        int x = 8, y = 6, lineH = 20;
        fpsLabel       = createLine(x, y, w - 16); y += lineH;
        coordsLabel    = createLine(x, y, w - 16); y += lineH;
        chunkLabel     = createLine(x, y, w - 16); y += lineH;
        biomeLabel     = createLine(x, y, w - 16); y += lineH;
        directionLabel = createLine(x, y, w - 16); y += lineH;
        lightLabel     = createLine(x, y, w - 16); y += lineH;
        memoryLabel    = createLine(x, y, w - 16);

        getRoot().add(fpsLabel, coordsLabel, chunkLabel, biomeLabel,
                      directionLabel, lightLabel, memoryLabel);
    }

    private Label createLine(int x, int y, int w) {
        Label label = new Label("...");
        label.originalPos(x, y).originalSize(w, 18);
        label.color(0xFFCCCCCC).scale(0.9f);
        return label;
    }

    @Override
    protected void buildSettings(ModSettings settings) {
        settings
            .separator("Sections visibles")
            .toggle("show_fps",       "FPS",          true)
            .toggle("show_coords",    "Coordonnees",  true)
            .toggle("show_chunk",     "Chunk",        true)
            .toggle("show_biome",     "Biome",        true)
            .toggle("show_direction", "Direction",    true)
            .toggle("show_light",     "Lumiere",      true)
            .toggle("show_memory",    "Memoire",      true)
            .separator("Apparence")
            .colorPicker("text_color", "Couleur du texte", 0xFFCCCCCC)
            .slider("bg_opacity",      "Opacite du fond",  0f, 1f, 0.67f)
            .toggle("compact",         "Mode compact",     false);
    }

    @Override
    protected void onSettingChanged(String key, Object value) {
        if ("text_color".equals(key)) {
            applyTextColor((Integer) value);
        } else if ("bg_opacity".equals(key)) {
            float opacity = (Float) value;
            int alpha = (int) (opacity * 255);
            background.fillColor((alpha << 24) | 0x1A1A2E);
        } else if ("compact".equals(key) || key.startsWith("show_")) {
            rebuild(); // Le layout change (lignes cachees en mode compact)
        }
    }

    private void applyTextColor(int color) {
        if (fpsLabel       != null) fpsLabel.color(color);
        if (coordsLabel    != null) coordsLabel.color(color);
        if (chunkLabel     != null) chunkLabel.color(color);
        if (biomeLabel     != null) biomeLabel.color(color);
        if (directionLabel != null) directionLabel.color(color);
        if (lightLabel     != null) lightLabel.color(color);
        if (memoryLabel    != null) memoryLabel.color(color);
    }

    @Override
    protected void onFrame(float partialTicks, long deltaNanos) {
        Minecraft mc = Minecraft.getMinecraft();
        EntityPlayer player = mc.player;
        if (player == null || mc.world == null) return;

        heavyUpdateTimer += deltaNanos;

        // FPS — chaque frame, avec couleur adaptative
        if (fpsLabel != null && getSetting("show_fps", true)) {
            int fps = Minecraft.getDebugFPS();
            fpsLabel.text("FPS: " + fps);
            fpsLabel.color(fps >= 60 ? 0xFF55FF55 : fps >= 30 ? 0xFFFFFF55 : 0xFFFF5555);
        }

        // Coordonnees — chaque frame pour une fluidite maximale
        if (coordsLabel != null && getSetting("show_coords", true)) {
            boolean compact = getSetting("compact", false);
            coordsLabel.text(compact
                ? String.format("XYZ: %.0f / %.0f / %.0f", player.posX, player.posY, player.posZ)
                : String.format("X: %.1f  Y: %.1f  Z: %.1f", player.posX, player.posY, player.posZ));
        }

        // Chunk — chaque frame
        if (chunkLabel != null && getSetting("show_chunk", true)) {
            int cx = MathHelper.floor(player.posX) >> 4;
            int cz = MathHelper.floor(player.posZ) >> 4;
            chunkLabel.text("Chunk: " + cx + ", " + cz);
        }

        // Direction — chaque frame (rotation interpolee)
        if (directionLabel != null && getSetting("show_direction", true)) {
            float yaw = MathHelper.wrapDegrees(player.rotationYaw);
            directionLabel.text("Direction: " + getCardinalDirection(yaw)
                + " (" + String.format("%.0f", yaw) + ")");
        }

        // Infos lourdes — toutes les 500ms via timer nanotime
        if (heavyUpdateTimer >= HEAVY_UPDATE_INTERVAL) {
            heavyUpdateTimer = 0L;
            BlockPos pos = player.getPosition();

            if (getSetting("show_biome", true)) {
                cachedBiome = mc.world.getBiome(pos).getBiomeName();
            }
            if (getSetting("show_light", true)) {
                Chunk chunk = mc.world.getChunk(pos);
                cachedLight = "Block: "
                    + chunk.getLightFor(net.minecraft.world.EnumSkyBlock.BLOCK, pos)
                    + "  Sky: "
                    + chunk.getLightFor(net.minecraft.world.EnumSkyBlock.SKY, pos);
            }
            if (getSetting("show_memory", true)) {
                Runtime rt = Runtime.getRuntime();
                long used = (rt.totalMemory() - rt.freeMemory()) / 1048576L;
                long max  = rt.maxMemory() / 1048576L;
                cachedMemory = used + "MB / " + max + "MB (" + (used * 100 / max) + "%)";
            }
        }

        // Appliquer les valeurs cachees des infos lourdes
        if (biomeLabel   != null) biomeLabel.text("Biome: " + cachedBiome);
        if (lightLabel   != null) lightLabel.text("Light " + cachedLight);
        if (memoryLabel  != null) memoryLabel.text("Mem: " + cachedMemory);

        // Visibilite par setting
        if (fpsLabel       != null) fpsLabel.visible(getSetting("show_fps", true));
        if (coordsLabel    != null) coordsLabel.visible(getSetting("show_coords", true));
        if (chunkLabel     != null) chunkLabel.visible(getSetting("show_chunk", true));
        if (biomeLabel     != null) biomeLabel.visible(getSetting("show_biome", true));
        if (directionLabel != null) directionLabel.visible(getSetting("show_direction", true));
        if (lightLabel     != null) lightLabel.visible(getSetting("show_light", true));
        if (memoryLabel    != null) memoryLabel.visible(getSetting("show_memory", true));
    }

    @Override
    protected void onTick() {
        // Toute la logique de mise a jour est dans onFrame() pour la fluidite.
        // onTick() n'est pas utilise ici mais pourrait servir pour des appels reseau.
    }

    private static String getCardinalDirection(float yaw) {
        if (yaw < 0) yaw += 360f;
        if (yaw >= 337.5f || yaw < 22.5f)  return "S";
        if (yaw < 67.5f)                    return "SW";
        if (yaw < 112.5f)                   return "W";
        if (yaw < 157.5f)                   return "NW";
        if (yaw < 202.5f)                   return "N";
        if (yaw < 247.5f)                   return "NE";
        if (yaw < 292.5f)                   return "E";
        return "SE";
    }
}