Overlay HUD

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

public class HealthOverlay extends EriOverlay {

    public HealthOverlay() {
        // unique id, width and height in design pixels
        super("health_hud", 200, 60);

        setAnchor(Anchor.BOTTOM_LEFT);   // bottom-left corner
        setOffset(10, -10);              // offset from the anchor
    }

    @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)
        );
    }
}

// Registration (once, in ClientProxy.init() for example):
OverlayManager.getInstance().register(new HealthOverlay());

import fr.eri.eriapi.overlay.OverlayManager;

OverlayManager om = OverlayManager.getInstance();

// Register overlays (once, during init)
om.register(new HealthOverlay());
om.register(new ManaOverlay());
om.register(new FactionHudOverlay());

// Visibility control by ID
om.show("health_hud");
om.hide("health_hud");
om.toggle("health_hud");

// Global control
om.hideAll();
om.showAll();

// Retrieve an overlay to modify it
EriOverlay overlay = om.get("health_hud");
if (overlay != null) {
    overlay.rebuild(); // Force a rebuild
}

// Unregister an overlay
om.unregister("health_hud");

// Overlay in bottom-right with 15px margin
new MonOverlay()
    .setAnchor(Anchor.BOTTOM_RIGHT)
    .setOffset(-15, -15);  // negative = toward top/left

// Overlay centered at top with 20px margin from edge
new BossBarOverlay()
    .setAnchor(Anchor.TOP_CENTER)
    .setOffset(0, 20);     // positive = toward bottom

// Display the overlay on top of the entire HUD (default behavior)
overlay.setLayer(OverlayLayer.POST_ALL);

// Display just after the hotbar
overlay.setLayer(OverlayLayer.POST_HOTBAR);

// Ambient background beneath the entire 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); // above the vanilla health bar
    }

    @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);

        // Breathing animation — scope "overlay" so it is not stopped
        // when the player opens/closes a 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);
    }

    // Public method to update the mana value
    public void setMana(float ratio) {
        if (manaBar != null) {
            manaBar.progress(ratio);
        }
    }
}

// ❌ Will be stopped when the player closes a GUI
label.breathe(40); // internal helper, no scope

// ✅ Continues even when a GUI is opened then closed
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); // just above the health bar
        hideInGui(true);    // hide when GUI is open
        hideOnF1(true);     // hide when F1 is pressed
    }

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

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

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

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

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

    /** Called from your mana system to update the bar. */
    public void setMana(int current, int max) {
        if (manaBar != null) {
            manaBar.progress((float) current / max);
        }
    }
}

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

// From anywhere in your mod (client side):
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() {
        // Gradient background
        getRoot().add(new GradientRectangle()
            .originalPos(0, 0).originalSize(220, 70)
            .vertical(0x80150A2A, 0x801A0B35)
            .cornerRadius(8));

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

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

        // Faction name
        factionNameLabel = new Label(28, 8, 180, 18, "No faction")
            .color(0xFFE0E0E0)
            .scale(1.0f)
            .shadow(true);

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

        // Members online
        membersLabel = new Label(8, 48, 204, 14, "Members online: 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("Rank: " + rank);
        if (membersLabel != null) membersLabel.text("Members online: " + 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); // beneath the vanilla HUD
        hideInGui(false); // stays visible even in menus
        hideOnF1(true);
    }

    @Override
    protected void buildOverlay() {
        // Star field background
        getRoot().add(new Starfield()
            .originalPos(0, 0).originalSize(1920, 300)
            .starCount(60)
            .starColor(0xFFF0F2FF)
            .shootingStarChance(0.002f));

        // Aurora on top
        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("Displays the player's health points.");
        setDefaultPosition(0.01f, 0.9f);  // bottom-left (x and y as screen fraction)
        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;

// In 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("Visible sections")
        .toggle("show_fps", "FPS", true)
        .toggle("show_coords", "Coordinates", true)
        .separator("Appearance")
        .colorPicker("text_color", "Text color", 0xFFCCCCCC)
        .slider("bg_opacity", "Background opacity", 0f, 1f, 0.67f)
        .toggle("compact", "Compact mode", 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();  // The layout changes completely in compact mode
    }
}

// Reading a value in onFrame() or onTick():
boolean showFps = getSetting("show_fps", true);
float opacity  = getSetting("bg_opacity", 0.67f);

// Open the editor from code (e.g. from a keybinding or a command)
OverlayModManager.getInstance().openEditor();

private long timer = 0L;
private static final long INTERVAL = 500_000_000L; // 500ms in nanoseconds

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

    // Light update every frame (smooth)
    fpsLabel.text("FPS: " + Minecraft.getDebugFPS());

    // Heavy update only every 500ms
    if (timer >= INTERVAL) {
        timer = 0L;
        biomeLabel.text("Biome: " + getBiomeName()); // world access, more costly
    }
}

// Legacy method — fractions (0.0 to 1.0)
// Still valid, converted internally: x * 1920, y * 1080
setDefaultPosition(0.01f, 0.9f);   // ≈ (19, 972) in design pixels

// New method — direct design pixels (recommended)
// More precise and consistent with the rest of the EriAPI system
setDefaultPositionDesign(20f, 960f);  // exactly 20px from the left, 960px from the top

// Mana bar at the bottom left
public class ManaBarMod extends OverlayMod {
    public ManaBarMod() {
        super("mana_bar", "Mana", 240, 20);
        setDefaultPositionDesign(20f, 1010f); // 20px from the left, 1010px from the top
    }
}

// Stamina bar just below, 6 design pixels apart
public class StaminaMod extends OverlayMod {
    public StaminaMod() {
        super("stamina_bar", "Stamina", 240, 20);
        // 1010 (mana) + 20 (mana height) + 6 (gap) = 1036
        setDefaultPositionDesign(20f, 1036f);
    }
}
// The 6 design-pixel gap is identical at every resolution.

.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 updated every frame
    private Label fpsLabel;
    private Label coordsLabel;
    private Label chunkLabel;
    private Label biomeLabel;
    private Label directionLabel;
    private Label lightLabel;
    private Label memoryLabel;

    // Background
    private Rectangle background;

    // nanotime timer for heavy updates (500ms)
    private long heavyUpdateTimer = 0L;
    private static final long HEAVY_UPDATE_INTERVAL = 500_000_000L;

    // Cache for heavy values
    private String cachedBiome   = "";
    private String cachedLight   = "";
    private String cachedMemory  = "";

    public DebugOverlayMod() {
        super("erinium_debug", "Debug Info", 380, 160);
        setCategory("Information");
        setDescription("Displays FPS, coordinates, biome, direction and memory.");
        setDefaultPosition(0.005f, 0.005f); // top-left corner
        setMinScale(0.5f);
        setMaxScale(2.0f);
    }

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

        // Semi-transparent background with rounded corners
        background = new Rectangle();
        background.originalPos(0, 0).originalSize(w, 160);
        background.fillColor(0xAA1A1A2E).cornerRadius(6);
        getRoot().add(background);

        // Creating labels on each row (20px spacing)
        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("Visible sections")
            .toggle("show_fps",       "FPS",          true)
            .toggle("show_coords",    "Coordinates",  true)
            .toggle("show_chunk",     "Chunk",        true)
            .toggle("show_biome",     "Biome",        true)
            .toggle("show_direction", "Direction",    true)
            .toggle("show_light",     "Light",        true)
            .toggle("show_memory",    "Memory",       true)
            .separator("Appearance")
            .colorPicker("text_color", "Text color",          0xFFCCCCCC)
            .slider("bg_opacity",      "Background opacity",  0f, 1f, 0.67f)
            .toggle("compact",         "Compact mode",        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(); // Layout changes (hidden rows in compact mode)
        }
    }

    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 — every frame, with adaptive color
        if (fpsLabel != null && getSetting("show_fps", true)) {
            int fps = Minecraft.getDebugFPS();
            fpsLabel.text("FPS: " + fps);
            fpsLabel.color(fps >= 60 ? 0xFF55FF55 : fps >= 30 ? 0xFFFFFF55 : 0xFFFF5555);
        }

        // Coordinates — every frame for maximum smoothness
        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 — every 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 — every frame (interpolated rotation)
        if (directionLabel != null && getSetting("show_direction", true)) {
            float yaw = MathHelper.wrapDegrees(player.rotationYaw);
            directionLabel.text("Direction: " + getCardinalDirection(yaw)
                + " (" + String.format("%.0f", yaw) + ")");
        }

        // Heavy data — every 500ms via nanotime timer
        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) + "%)";
            }
        }

        // Apply cached values for heavy data
        if (biomeLabel   != null) biomeLabel.text("Biome: " + cachedBiome);
        if (lightLabel   != null) lightLabel.text("Light " + cachedLight);
        if (memoryLabel  != null) memoryLabel.text("Mem: " + cachedMemory);

        // Visibility per 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() {
        // All update logic is in onFrame() for smoothness.
        // onTick() is not used here but could serve for network calls.
    }

    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";
    }
}