Animation System

{
  "format_version": 1,
  "model": "monmod:block/ma_lootbox",
  "animations": {
    "open": {
      "duration": 15,
      "endBehavior": "freeze",
      "tracks": {
        "lid": {
          "rotation": [
            { "tick": 0,  "value": [0, 0, 0],    "easing": "linear" },
            { "tick": 15, "value": [-110, 0, 0],  "easing": "ease_out_back" }
          ]
        },
        "lock": {
          "translation": [
            { "tick": 0,  "value": [0, 0, 0],  "easing": "linear" },
            { "tick": 8,  "value": [0, -3, 0],  "easing": "ease_out" }
          ],
          "visible": [
            { "tick": 8, "value": false }
          ]
        }
      },
      "events": [
        { "tick": 0,  "type": "sound", "value": "minecraft:block.chest.open", "volume": 1.0, "pitch": 1.2 },
        { "tick": 15, "type": "callback", "value": "open_complete" }
      ]
    }
  }
}

src/main/resources/assets/monmod/
  models/block/ma_lootbox.json              ← Modele Blockbench (export)
  animations/block/ma_lootbox.erianim.json  ← Fichier d'animation
  textures/blocks/ma_lootbox/               ← Textures PNG du modele
    base.png
    lid.png
    lock.png
  blockstates/ma_lootbox.json               ← Blockstate (genere auto)

import fr.eri.eriapi.anim.AnimatedBlockTileEntity;
import fr.eri.eriapi.anim.EriAnimBlock;
import net.minecraft.block.material.Material;

public class MonBlocks {

    public static void init() {
        EriAnimBlock.create("monmod", "ma_lootbox")
            .material(Material.IRON)
            .hardness(5.0f)
            .resistance(10.0f)
            .model("monmod:block/ma_lootbox")
            .animation("monmod:block/ma_lootbox")
            .renderDistance(64)
            .onRightClick(ctx -> {
                // Recuperer le TileEntity du block
                AnimatedBlockTileEntity te = (AnimatedBlockTileEntity)
                    ctx.world.getTileEntity(ctx.pos);
                if (te != null) {
                    te.playAnimation("open");
                }
            })
            .register();
    }
}

EriAnimBlock.create("monmod", "machine_raffinage")
    .material(Material.IRON)
    .hardness(5.0f)
    .resistance(10.0f)
    .harvestTool("pickaxe", 2)
    .soundType(SoundType.METAL)
    .lightLevel(0.5f)
    .model("monmod:block/machine_raffinage")
    // Anims Java declarees directement sur le builder (v1.6.5)
    .javaAnimation("idle", new IdleAnim())
    .javaAnimation("work", new WorkAnim())
    .defaultAnimation("idle")              // auto-play au spawn
    .renderDistance(48)
    .onRightClick(ctx -> {
        AnimatedBlockTileEntity te = (AnimatedBlockTileEntity)
            ctx.world.getTileEntity(ctx.pos);
        if (te != null) te.playAnimation("work");
    })
    .onBreak(ctx -> {
        // Lacher des items quand le block est casse
        dropItems(ctx.world, ctx.pos);
    })
    .register();

import fr.eri.eriapi.anim.*;
import fr.eri.eriapi.gui.anim.Easing;

public class WalkAnim extends EriAnimJava {

    @Override
    public void defineKeyframes(AnimContext ctx) {
        // Equivalent au JSON .erianim, mais en code
        ctx.at(0)
            .group("leg_left").rotateTo(-30, 0, 0).easing(Easing.EASE_IN_OUT)
            .group("leg_right").rotateTo(30, 0, 0).easing(Easing.EASE_IN_OUT);
        ctx.at(15)
            .group("leg_left").rotateTo(30, 0, 0)
            .group("leg_right").rotateTo(-30, 0, 0);
        ctx.at(30)
            .group("leg_left").rotateTo(-30, 0, 0)
            .group("leg_right").rotateTo(30, 0, 0);
    }

    @Override
    public void compute(AnimContext ctx, AnimationPose pose) {
        // Procedural: bobbing de la tete sur sin(t)
        float t = ctx.animTick + ctx.partial;
        pose.group("head").addRotateY((float) Math.sin(t * 0.2f) * 5f);
    }

    @Override public float duration() { return 30f; }
    @Override public EndBehavior endBehavior() { return EndBehavior.LOOP; }
}

// Dans le constructeur du TileEntity (ou un init partage server+client)
public MyTileEntity() {
    addJavaAnimation("walk", new WalkAnim());
    addJavaAnimation("idle", new IdleAnim());
}

// Lecture (cote serveur, comme .erianim)
te.playAnimation("walk");
te.pauseAnimation();
te.resumeAnimation();
te.resetAnimationInstant();

ctx.at(0)
    .group("arm_left").rotateTo(0, 0, 0)
    .group("arm_right").rotateTo(0, 0, 0)
    .group("body").translateTo(0, 0, 0).easing(Easing.EASE_OUT)
.at(20)
    .group("arm_left").rotateTo(0, 45, 0)
    .group("arm_right").rotateTo(0, -45, 0).scaleTo(1.1f, 1.1f, 1.1f)
    .group("body").translateY(0.2f);

@Override
public void compute(AnimContext ctx, AnimationPose pose) {
    float t = ctx.animTick + ctx.partial;

    // Tete: balance a gauche/droite
    pose.group("head")
        .addRotateY((float) Math.sin(t * 0.15f) * 8f)
        .addRotateZ((float) Math.cos(t * 0.10f) * 3f);

    // Body: petite respiration verticale
    pose.group("body").addTranslateY((float) Math.sin(t * 0.05f) * 0.05f);

    // Reaction a l'etat de l'entite (si target est une entite)
    if (ctx.asEntity() != null) {
        float yaw = ctx.asEntity().rotationYaw;
        pose.group("head").addRotateY(yaw * 0.1f);
    }
}

// Lancer l'overlay
te.playOverlay("flash", new FlashOverlayAnim());

// Stopper
te.stopOverlay();

// Verifier
boolean active = te.hasOverlay();
String name = te.getOverlayAnimName();

import fr.eri.eriapi.anim.AnimatedBlockTileEntity;
import fr.eri.eriapi.anim.AnimationEvent;

public class TileLootbox extends AnimatedBlockTileEntity {

    private boolean isOpen = false;

    // Constructeur sans argument OBLIGATOIRE
    public TileLootbox() {
        super("monmod:block/lootbox", "monmod:block/lootbox");
        //     ^--- modelId              ^--- animFileId
    }

    @Override
    protected void onAnimationCallback(String callbackName) {
        if ("open_complete".equals(callbackName)) {
            isOpen = true;
            // Donner les recompenses au joueur, etc.
        }
    }

    @Override
    protected void onAnimationComplete(String animName) {
        if ("close".equals(animName)) {
            isOpen = false;
        }
    }

    @Override
    protected void onAnimationEvent(AnimationEvent event) {
        if (event.getType() == AnimationEvent.EventType.PARTICLE) {
            // Spawn des particules custom
            spawnParticles(event.getCount(), event.getSpread());
        }
    }

    public boolean isOpen() { return isOpen; }
}

EriAnimBlock.create("monmod", "lootbox")
    .material(Material.WOOD)
    .hardness(3.0f)
    .model("monmod:block/lootbox")
    .animation("monmod:block/lootbox")
    .tileEntity(TileLootbox.class)  // ← Notre TE custom
    .onRightClick(ctx -> {
        TileLootbox te = (TileLootbox) ctx.world.getTileEntity(ctx.pos);
        if (te != null && !te.isOpen()) {
            te.playAnimation("open");
        }
    })
    .register();

// Approche .erianim — necessite un fichier assets/monmod/animations/ma_machine.erianim.json
EriAnimBlock.create("monmod", "ma_machine")
    .material(Material.IRON)
    .hardness(5.0f)
    .model("monmod:block/ma_machine")
    .animation("monmod:animations/ma_machine")  // ← fichier .erianim
    .defaultAnimation("idle")
    .onRightClick(ctx -> {
        AnimatedBlockTileEntity te = (AnimatedBlockTileEntity)
            ctx.world.getTileEntity(ctx.pos);
        if (te != null) te.playAnimation("work");
    })
    .register();

EriAnimBlock.create("monmod", "ma_machine")
    .material(Material.IRON)
    .hardness(5.0f)
    .model("monmod:block/ma_machine")
    // Anims Java directement sur le builder — pas besoin de TE custom
    .javaAnimation("idle", new IdleAnim())
    .javaAnimation("work", new WorkAnim())
    .defaultAnimation("idle")             // auto-play au spawn
    .onRightClick(ctx -> {
        AnimatedBlockTileEntity te = (AnimatedBlockTileEntity)
            ctx.world.getTileEntity(ctx.pos);
        if (te != null) te.playAnimation("work");
    })
    .register();

// Mix : animations .erianim + animations Java sur le meme bloc
EriAnimBlock.create("monmod", "ma_machine")
    .model("monmod:block/ma_machine")
    .animation("monmod:animations/ma_machine")  // animations .erianim
    .javaAnimation("glow", new GlowPulseAnim()) // animation Java en plus
    .register();

public class TileMachine extends AnimatedBlockTileEntity {

    public TileMachine() {
        super("monmod:block/machine", "monmod:block/machine");
    }

    @Override
    protected void onAnimationCallback(String callbackName) {
        switch (callbackName) {
            case "produce_item":
                // L'animation a atteint le point ou l'item est cree
                produceOutput();
                break;
            case "consume_fuel":
                // L'animation a atteint le point ou le carburant est consomme
                consumeFuel();
                break;
        }
    }

    @Override
    protected void onAnimationComplete(String animName) {
        if ("process".equals(animName)) {
            // L'animation de traitement est terminee
            // Relancer si il y a encore du carburant
            if (hasFuel()) {
                playAnimation("process");
            }
        }
    }

    @Override
    protected void onAnimationEvent(AnimationEvent event) {
        if (event.getType() == AnimationEvent.EventType.PARTICLE) {
            // Spawn des particules de fumee cote serveur
            // Les particules seront visibles par tous les joueurs a proximite
            if (world instanceof WorldServer) {
                ((WorldServer) world).spawnParticle(
                    EnumParticleTypes.SMOKE_NORMAL,
                    pos.getX() + 0.5, pos.getY() + 1.0, pos.getZ() + 0.5,
                    event.getCount(), event.getSpread(), 0.1, event.getSpread(),
                    0.01);
            }
        }
    }
}

// EriAnimBlock avec callback onRightClick
EriAnimBlock.create("monmod", "lootbox")
    .animation("monmod:block/lootbox")
    .onRightClick(ctx -> {
        AnimatedBlockTileEntity te = (AnimatedBlockTileEntity)
            ctx.world.getTileEntity(ctx.pos);
        if (te != null && !te.isAnimating()) {
            te.playAnimation("open");  // Declenche l'animation "open"
        }
    })
    .register();

// Sous-classe AnimatedBlockTileEntity avec ITickable
public class TileMachine extends AnimatedBlockTileEntity {

    private boolean running = false;

    @Override
    public void update() {
        super.update();
        if (!world.isRemote && running && !isAnimating()) {
            // Relance l'animation en boucle
            playAnimation("spin");
        }
    }

    public void setRunning(boolean running) {
        this.running = running;
        if (!running) resetAnimation();
    }
}

// Via EriEvents - bloquer l'animation quand une explosion explose a cote
EriEvents.on(ExplosionEvent.Detonate.class)
    .handle(e -> {
        BlockPos center = e.getExplosion().getPosition().toBlockPos();
        // Chercher notre block dans un rayon de 5 blocs
        for (BlockPos pos : BlockPos.getAllInBoxMutable(
                center.add(-5,-5,-5), center.add(5,5,5))) {
            TileEntity te = e.world.getTileEntity(pos);
            if (te instanceof AnimatedBlockTileEntity) {
                ((AnimatedBlockTileEntity) te).playAnimation("shake");
            }
        }
    });

// Dans un EriCommand
EriCommand.create("machine")
    .sub("start")
        .arg(PosArg.of("pos"))
        .execute(ctx -> {
            BlockPos pos = ctx.getPos("pos");
            TileEntity te = ctx.getSender().world.getTileEntity(pos);
            if (te instanceof AnimatedBlockTileEntity) {
                ((AnimatedBlockTileEntity) te).playAnimation("run");
                ctx.reply("Animation demarree.");
            }
        })
    .register();

// Dans ta classe entite Java (extends EntityLiving implements IAnimatedEntity)
public class EntityMonstre extends EntityLiving implements IAnimatedEntity {

    @Override
    public void onUpdate() {
        super.onUpdate();
        if (!world.isRemote) {
            // Lancer idle si aucune animation n'est en cours
            if (dataManager.get(ANIM_NAME).isEmpty()) {
                playAnimation("idle");
            }
        }
    }
}

// Dans ta classe entite Java (extends EntityLiving implements IAnimatedEntity)
public class EntityMonstre extends EntityLiving implements IAnimatedEntity {

    @Override
    public void onUpdate() {
        super.onUpdate();
        if (!world.isRemote) {
            double speed = Math.sqrt(motionX * motionX + motionZ * motionZ);
            String current = dataManager.get(ANIM_NAME);
            if (speed > 0.01 && !"walk".equals(current)) {
                playAnimation("walk");       // Commence a marcher
            } else if (speed <= 0.01 && "walk".equals(current)) {
                playAnimation("idle");       // Revient en idle
            }
        }
    }
}

// Dans ta classe entite Java (extends EntityMob implements IAnimatedEntity)
public class EntityMonstre extends EntityMob implements IAnimatedEntity {

    @Override
    public boolean attackEntityAsMob(Entity target) {
        boolean result = super.attackEntityAsMob(target);
        if (result && !world.isRemote) {
            playAnimation("attack");         // Lance l'animation d'attaque
        }
        return result;
    }
}

// Declarer l'item avec modele anime
EriItem.create("monmod", "epee")
    .animatedModel("monmod:item/epee")
    .onRightClick(ctx -> {
        if (ctx.world.isRemote) {
            AnimatedItemController.play("monmod:item/epee", "use");
        }
    })
    .register();

// Depuis n'importe ou cote client
AnimatedItemController.play("monmod:item/epee", "monmod:item/epee_anims", "idle"); // animFileId explicite
AnimatedItemController.play("monmod:item/epee", "swing");  // animFileId = modelId
AnimatedItemController.stop("monmod:item/epee");
boolean playing = AnimatedItemController.isPlaying("monmod:item/epee");

{
  "format_version": 1,
  "model": "monmod:block/ma_machine",
  "animations": {
    "idle_breathe": { ... },
    "open": { ... },
    "close": { ... },
    "process": { ... }
  }
}

{
  "duration": 40,
  "endBehavior": "freeze",
  "rollbackDuration": 10,
  "blendIn": 5,
  "blendOut": 0,
  "loopCount": 3,
  "loopPause": 20,
  "tracks": { ... },
  "events": [ ... ]
}

{
  "formatVersion": 1,
  "modelId": "mymod:block/turret",
  "animations": {
    "idle": {
      "duration": 40,
      "endBehavior": "loop",
      "tracks": {
        "base": {
          "rotation": [
            { "tick": 0,  "value": [0, 0, 0] },
            { "tick": 40, "value": [0, 360, 0] }
          ]
        }
      },
      "elementTracks": {
        "body:2": {
          "translation": [
            { "tick": 0,  "value": [0, 0, 0] },
            { "tick": 20, "value": [0, 2, 0] },
            { "tick": 40, "value": [0, 0, 0] }
          ]
        }
      }
    }
  }
}

// Tester la presence de pistes d'element avant d'iterer
if (animDef.hasElementTracks()) {
    for (Map.Entry<String, GroupTrack> entry : animDef.getElementTracks().entrySet()) {
        // entry.getKey() = "body:2"
        // entry.getValue() = GroupTrack
    }
}

// Acces direct via groupe + index
GroupTrack t = animDef.getElementTrack("body", 2);

// Cle canonique (utilitaire statique)
String key = AnimationDef.elementTrackKey("body", 2); // -> "body:2"

AnimationPose pose = controller.getCurrentPose(partialTicks);

// Pose du groupe
AnimationPose.GroupPose bodyPose = pose.getGroup("body");

// Pose de l'element (null si aucune piste n'existe pour cet element)
AnimationPose.GroupPose elemPose = pose.getElement("body", 2);
if (elemPose != null) {
    if (!elemPose.visible) return; // element cache
    float rotY = elemPose.rotation[1];
    // ...
}

"events": [
  {
    "tick": 0,
    "type": "sound",
    "value": "minecraft:block.anvil.use",
    "volume": 0.8,
    "pitch": 1.5
  },
  {
    "tick": 10,
    "type": "particle",
    "value": "smoke",
    "count": 5,
    "spread": 0.3
  },
  {
    "tick": 20,
    "type": "callback",
    "value": "halfway_done"
  },
  {
    "tick": 5,
    "type": "hide_group",
    "value": "lock"
  },
  {
    "tick": 30,
    "type": "show_group",
    "value": "reward"
  },
  {
    "tick": 40,
    "type": "cut"
  }
]

AnimatedBlockTileEntity te = (AnimatedBlockTileEntity) world.getTileEntity(pos);

// Utiliser le EndBehavior par defaut du fichier .erianim.json
te.playAnimation("process");

// Forcer un EndBehavior different
te.playAnimation("process", EndBehavior.LOOP);
te.playAnimation("open", EndBehavior.WAIT_SERVER);
te.playAnimation("flash", EndBehavior.ROLLBACK_INSTANT);

// Passer null = utiliser le defaut du fichier
te.playAnimation("idle", null);

AnimatedBlockTileEntity te = (AnimatedBlockTileEntity) world.getTileEntity(pos);

// Verifier si une animation est en cours
if (te.isAnimating()) {
    // PLAYING ou ROLLING_BACK
}

// Verifier un etat precis
if (te.getAnimState() == AnimState.WAITING_SERVER) {
    // L'animation est terminee, le serveur doit agir
    te.resetAnimation();
}

// Verifier la progression
float progress = te.getAnimationProgress(); // 0.0 a 1.0
if (progress > 0.5f) {
    // L'animation a depasse la moitie
}

EriItem.create("monmod", "epee_fancy")
    .maxStackSize(1)
    .rarity(EnumRarity.EPIC)
    .animatedModel("monmod:item/epee_fancy")  // Modele Blockbench 3D
    .register();

// 1. Definir l'entite via EriEntity builder (dans preInit)
EriEntity.create("monmod", "monstre")
    .model("monmod:entity/monstre")
    .texture("body", "monmod:textures/entity/monstre/body")
    .animation("idle", "monmod:entity/monstre_idle")
    .animation("walk", "monmod:entity/monstre_walk")
    .hitbox(0.8f, 1.8f)
    .seat(0.0f, 24.0f, 0.0f)
    .register();

// 2. Classe d'entite — gestion de l'etat d'animation via DataParameters
public class EntityMonstre extends EntityLiving implements IAnimatedEntity {

    // DataParameters pour sync serveur -> client
    private static final DataParameter<String> ANIM_NAME =
        EntityDataManager.createKey(EntityMonstre.class, DataSerializers.STRING);
    private static final DataParameter<Integer> ANIM_TICK =
        EntityDataManager.createKey(EntityMonstre.class, DataSerializers.VARINT);

    private final AnimationController controller = new AnimationController();

    public EntityMonstre(World world) {
        super(world);
        setSize(0.8f, 1.8f);
    }

    @Override
    protected void entityInit() {
        super.entityInit();
        dataManager.register(ANIM_NAME, "");
        dataManager.register(ANIM_TICK, 0);
    }

    // Appeler cote serveur pour lancer une animation
    public void playAnimation(String name) {
        dataManager.set(ANIM_NAME, name);
        dataManager.set(ANIM_TICK, 0);
    }

    public void stopAnimation() {
        dataManager.set(ANIM_NAME, "");
    }

    @Override
    public void onUpdate() {
        super.onUpdate();
        if (!world.isRemote) {
            String name = dataManager.get(ANIM_NAME);
            if (!name.isEmpty()) {
                dataManager.set(ANIM_TICK, dataManager.get(ANIM_TICK) + 1);
            }
        }
    }

    // --- IAnimatedEntity ---

    @Override
    public AnimationPose getCurrentPose(float partialTicks) {
        String animName = dataManager.get(ANIM_NAME);
        if (animName.isEmpty()) return null;

        // Charger le fichier d'animation depuis le cache
        AnimationFile animFile = EriAnimCache.get("monmod:entity/monstre_" + animName);
        if (animFile == null) return null;

        AnimationDef animDef = animFile.getAnimations().values().iterator().next();
        if (animDef == null) return null;

        float tickFloat = dataManager.get(ANIM_TICK) + partialTicks;
        return controller.computePose(
            animDef,
            AnimState.PLAYING,
            tickFloat,
            animDef.getDuration(),
            10,    // rollbackDuration (non utilise ici)
            null,  // blendPose
            1.0f   // blendProgress
        );
    }

    @Override
    public AnimState getAnimState() {
        return dataManager.get(ANIM_NAME).isEmpty() ? AnimState.IDLE : AnimState.PLAYING;
    }
}

// 3. Enregistrer le renderer (ClientProxy.preInit)
RenderingRegistry.registerEntityRenderingHandler(
    EntityMonstre.class,
    AnimatedEntityRenderer.factory("monmod:entity/monstre")
);

// 4. Enregistrer dans Forge (RegistryEvent.Register<EntityEntry>)
for (EntityDefinition def : ContentRegistry.getEntityDefs()) {
    // Enregistrer EntityEntry avec EntityRegistry.registerModEntity(...)
    // Associer AnimatedEntityRenderer via RenderingRegistry (client only)
}

// Approche .erianim — necessite des fichiers .erianim.json dans assets/
EriEntity.create("monmod", "monstre")
    .model("monmod:entity/monstre")
    .texture("body", "monmod:textures/entity/monstre")
    .hitbox(0.8f, 1.8f)
    .animation("idle", "monmod:entity/monstre_idle")   // ← fichier .erianim
    .animation("walk", "monmod:entity/monstre_walk")   // ← fichier .erianim
    .register();

// Anims Java declarees directement sur le builder (depuis v1.6.5)
EriEntity.create("monmod", "monstre")
    .model("monmod:entity/monstre")
    .texture("body", "monmod:textures/entity/monstre")
    .hitbox(0.8f, 1.8f)
    .javaAnimation("idle", new IdleAnim())
    .javaAnimation("walk", new WalkAnim())
    .register();

// Mix : .erianim pour les anims longues/complexes + Java pour les effets proceduraux
EriEntity.create("monmod", "monstre")
    .model("monmod:entity/monstre")
    .animation("walk", "monmod:entity/monstre_walk")   // .erianim
    .javaAnimation("headBob", new HeadBobAnim())       // Java
    .register();

import fr.eri.eriapi.anim.AnimationController;
import fr.eri.eriapi.anim.AnimationPose;
import fr.eri.eriapi.anim.AnimState;
import fr.eri.eriapi.anim.EndBehavior;
import fr.eri.eriapi.anim.EriAnimJava;
import fr.eri.eriapi.anim.IAnimatedEntity;
import fr.eri.eriapi.content.ContentRegistry;
import fr.eri.eriapi.content.EntityDefinition;

public class EntityMonstre extends EntityLiving implements IAnimatedEntity {

    private final AnimationController controller = new AnimationController();
    private EriAnimJava currentAnim;
    private float animTick = 0;

    public EntityMonstre(World world) {
        super(world);
        setSize(0.8f, 1.8f);
        // Anims recuperees depuis l'EntityDefinition cree par EriEntity
        EntityDefinition def = ContentRegistry.getEntityDef("monmod", "monstre");
        this.currentAnim = def != null ? def.getJavaAnimation("idle") : null;
    }

    @Override
    public void onUpdate() {
        super.onUpdate();
        if (currentAnim != null) {
            animTick += 1.0f;
            float dur = currentAnim.duration();
            if (currentAnim.endBehavior() == EndBehavior.LOOP && animTick >= dur) {
                animTick -= dur;   // boucle
            }
        }
    }

    /** Change d'animation par nom (resolution depuis l'EntityDefinition). */
    public void setAnimation(String name) {
        EntityDefinition def = ContentRegistry.getEntityDef("monmod", "monstre");
        EriAnimJava anim = def != null ? def.getJavaAnimation(name) : null;
        if (anim != null) {
            this.currentAnim = anim;
            this.animTick = 0;
        }
    }

    // --- IAnimatedEntity ---

    @Override
    public AnimationPose getCurrentPose(float partialTicks) {
        if (currentAnim == null) return null;
        long worldTick = world != null ? world.getTotalWorldTime() : 0;
        return controller.computeJavaPose(
            currentAnim,             // EriAnimJava courante
            AnimState.PLAYING,
            animTick + partialTicks, // tickFloat interpole
            partialTicks,
            worldTick,
            this,                    // target accessible via ctx.asEntity()
            null,                    // blendPose
            1.0f                     // blendProgress
        );
    }

    @Override
    public AnimState getAnimState() {
        return currentAnim != null ? AnimState.PLAYING : AnimState.IDLE;
    }
}

import fr.eri.eriapi.anim.event.*;
import fr.eri.eriapi.event.EriEvents;

// Empecher certaines animations de se jouer
EriEvents.on(AnimationStartEvent.class, e -> {
    if ("forbidden_anim".equals(e.getAnimName())) {
        e.setCanceled(true); // L'animation ne se jouera pas
    }
});

// Reagir quand une animation se termine
EriEvents.on(AnimationEndEvent.class, e -> {
    if ("charge".equals(e.getAnimName())) {
        // Donner un buff au joueur le plus proche
        giveBuffToNearestPlayer(e.getWorld(), e.getPos());
    }
});

// Arreter une boucle apres une condition
EriEvents.on(AnimationLoopEvent.class, e -> {
    if ("production".equals(e.getAnimName())) {
        TileMachine te = (TileMachine) e.getTileEntity();
        if (!te.hasFuel()) {
            e.setCanceled(true); // Arrete la boucle, freeze le block
        }
    }
});

// Empecher un reset
EriEvents.on(AnimationResetEvent.class, e -> {
    if (isBlockLocked(e.getPos())) {
        e.setCanceled(true); // Le reset ne s'applique pas
    }
});

AnimatedBlockTileEntity te = (AnimatedBlockTileEntity) world.getTileEntity(pos);

// Changer une texture specifique
te.setTexture("screen", "screen_active");

// La texture "screen" du modele sera remplacee par "screen_active"
// Le changement est synchronise automatiquement a tous les clients

// Remettre la texture originale
te.clearTexture("screen");

// Remettre TOUTES les textures originales
te.clearAllTextures();

// Verifier les overrides actuels
Map<String, String> overrides = te.getTextureOverrides();
// overrides = {"screen" -> "screen_active", ...}

public class TileReactor extends AnimatedBlockTileEntity {

    public TileReactor() {
        super("monmod:block/reactor", "monmod:block/reactor");
    }

    @Override
    protected void onAnimationCallback(String callbackName) {
        switch (callbackName) {
            case "activate_core":
                // L'animation atteint le moment ou le coeur doit s'allumer
                setTexture("core", "core_glowing");
                setTexture("panel", "panel_active");
                break;
            case "deactivate_core":
                clearAllTextures();
                break;
        }
    }
}

src/main/resources/assets/monmod/
  models/
    block/
      ma_machine.json                     ← Modele Blockbench (export "Java Block/Item")
  animations/
    block/
      ma_machine.erianim.json             ← Fichier d'animation EriAPI
  textures/
    blocks/
      ma_machine/                         ← Dossier de textures du modele
        base.png                          ← Texture principale
        panel.png                         ← Texture du panneau
        screen_off.png                    ← Ecran eteint
        screen_on.png                     ← Ecran allume (pour texture swap)
  blockstates/
    ma_machine.json                       ← Blockstate (genere automatiquement par EriAnimBlock)