---
title: Événements Entité
type: docs
weight: 2
---

Événements déclenchés par les actions et changements d'état des entités dans le monde du jeu.

{{< callout type="warning" >}}
**Note :** Le système d'événements d'entité de Hytale est minimal comparé à d'autres APIs de jeu. La plupart de la logique liée aux entités est gérée via l'ECS (Entity Component System) plutôt que par des événements traditionnels. Pour les interactions de blocs, drops d'items et craft, voir [Événements Bloc](../block-events).
{{< /callout >}}

## Événements du Cycle de Vie

### EntityRemoveEvent

Déclenché quand une entité est supprimée du monde.

**Package :** `com.hypixel.hytale.server.core.event.events.entity`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| entity | `Entity` | L'entité supprimée |
{{< /tab >}}
{{< tab >}}
- `getEntity()` - Retourne l'objet Entity supprimé
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(EntityRemoveEvent.class, event -> {
    Entity entity = event.getEntity();

    // Nettoyer les données personnalisées associées à cette entité
    if (trackedEntities.contains(entity.getUuid())) {
        trackedEntities.remove(entity.getUuid());
        getLogger().at(Level.INFO).log("Entité suivie supprimée : " + entity.getType().getId());
    }
});
```
{{< /tab >}}
{{< /tabs >}}

---

## Événements d'Entités Vivantes

### LivingEntityInventoryChangeEvent

Déclenché quand l'inventaire d'une entité vivante change.

**Package :** `com.hypixel.hytale.server.core.event.events.entity`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| entity | `LivingEntity` | L'entité dont l'inventaire a changé |
| itemContainer | `ItemContainer` | Le conteneur d'items modifié |
| transaction | `Transaction` | La transaction effectuée |
{{< /tab >}}
{{< tab >}}
- `getEntity()` - Retourne le LivingEntity
- `getItemContainer()` - Retourne l'ItemContainer modifié
- `getTransaction()` - Retourne les détails de la Transaction
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(LivingEntityInventoryChangeEvent.class, event -> {
    LivingEntity entity = event.getEntity();
    ItemContainer container = event.getItemContainer();
    Transaction transaction = event.getTransaction();

    // Logger les changements d'inventaire pour debug
    getLogger().at(Level.INFO).log("Inventaire changé pour : " + entity.getType().getId());
    getLogger().at(Level.INFO).log("Conteneur : " + container);
    getLogger().at(Level.INFO).log("Transaction : " + transaction);
});
```
{{< /tab >}}
{{< /tabs >}}

---

### LivingEntityUseBlockEvent

{{< badge "Déprécié" >}}

Déclenché quand une entité vivante utilise un bloc. Cet événement est déprécié et marqué pour suppression.

**Package :** `com.hypixel.hytale.server.core.event.events.entity`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| ref | `Ref<EntityStore>` | Référence au store d'entité |
| blockType | `String` | Le type de bloc utilisé |
{{< /tab >}}
{{< tab >}}
- `getRef()` - Retourne la référence du store d'entité
- `getBlockType()` - Retourne la chaîne du type de bloc
{{< /tab >}}
{{< tab >}}
```java
// Note : Cet événement est déprécié. Utilisez UseBlockEvent à la place.
getEventRegistry().register(LivingEntityUseBlockEvent.class, event -> {
    String blockType = event.getBlockType();
    Ref<EntityStore> ref = event.getRef();

    getLogger().at(Level.INFO).log("Entité a utilisé le bloc : " + blockType);
});
```
{{< /tab >}}
{{< /tabs >}}

{{< callout type="warning" >}}
**Déprécié :** Cet événement est marqué pour suppression. Utilisez `UseBlockEvent.Pre` et `UseBlockEvent.Post` du système d'événements ECS à la place. Voir [Événements Bloc](../block-events#useblockevent) pour l'alternative moderne.
{{< /callout >}}

---

## Travailler avec les Entités

### Entity Component System (ECS)

Hytale utilise une architecture Entity Component System. Au lieu d'événements d'entité traditionnels, la plupart du comportement des entités est géré via des composants et le système d'événements ECS.

Pour les opérations liées aux entités, considérez utiliser :

- **Événements ECS** pour les interactions de blocs, gestion d'items et changements de mode de jeu
- **Composants d'Entité** pour l'état et le comportement des entités
- **EntityStore** pour la persistance des données d'entité

### Exemple : Suivi d'Entités

```java
public class EntityTrackerPlugin extends JavaPlugin {

    private final Set<UUID> trackedEntities = new HashSet<>();

    @Override
    public void start() {
        // Suivre la suppression d'entités
        getEventRegistry().register(EntityRemoveEvent.class, event -> {
            Entity entity = event.getEntity();

            if (trackedEntities.remove(entity.getUuid())) {
                getLogger().at(Level.INFO).log("Entité suivie supprimée : " + entity.getUuid());
                onEntityRemoved(entity);
            }
        });

        // Suivre les changements d'inventaire
        getEventRegistry().register(LivingEntityInventoryChangeEvent.class, event -> {
            LivingEntity entity = event.getEntity();

            if (trackedEntities.contains(entity.getUuid())) {
                onInventoryChanged(entity, event.getTransaction());
            }
        });
    }

    public void trackEntity(Entity entity) {
        trackedEntities.add(entity.getUuid());
        getLogger().at(Level.INFO).log("Suivi de l'entité : " + entity.getUuid());
    }

    private void onEntityRemoved(Entity entity) {
        // Logique de nettoyage personnalisée
    }

    private void onInventoryChanged(LivingEntity entity, Transaction transaction) {
        // Réagir aux changements d'inventaire
    }
}
```

## Bonnes Pratiques

{{< callout type="info" >}}
**Directives pour les Événements d'Entité :**
- Les événements d'entité dans Hytale sont minimaux - préférez les patterns ECS pour les comportements complexes
- Utilisez `EntityRemoveEvent` pour le nettoyage quand les entités sont supprimées
- `LivingEntityUseBlockEvent` est déprécié - migrez vers `UseBlockEvent`
- Pour les événements d'entité spécifiques aux joueurs, voir [Événements Joueur](../player-events)
- Pour les interactions de blocs et d'items, voir [Événements Bloc](../block-events)
{{< /callout >}}

{{< callout type="tip" >}}
**Note de Migration :** Si vous venez du développement Minecraft/Bukkit, notez que Hytale n'a pas de `EntityDamageEvent`, `EntityDeathEvent`, ou `EntitySpawnEvent` traditionnels. Le cycle de vie des entités et le combat sont gérés différemment via l'architecture ECS.
{{< /callout >}}
