---
title: Priorités d'Événements
type: docs
weight: 2
---

Les priorités d'événements contrôlent l'ordre dans lequel les écouteurs sont appelés. C'est important quand plusieurs plugins ou gestionnaires doivent réagir au même événement.

## Valeurs de Priorité

Hytale fournit cinq niveaux de priorité :

| Priorité | Valeur | Description |
|----------|--------|-------------|
| `FIRST` | -21844 | S'exécute en premier, avant tous les autres |
| `EARLY` | -10922 | S'exécute tôt, après FIRST |
| `NORMAL` | 0 | Priorité par défaut |
| `LATE` | 10922 | S'exécute tard, après NORMAL |
| `LAST` | 21844 | S'exécute en dernier, après tous les autres |

{{< callout type="info" >}}
Les valeurs plus basses s'exécutent en premier. Les valeurs sont réparties sur la plage `short` pour permettre des priorités personnalisées entre les niveaux standards.
{{< /callout >}}

## Utiliser EventPriority

### Avec Enum

```java
getEventRegistry().register(
    EventPriority.EARLY,
    PlayerConnectEvent.class,
    event -> {
        // Ceci s'exécute avant les gestionnaires NORMAL
    }
);

getEventRegistry().register(
    EventPriority.LATE,
    PlayerConnectEvent.class,
    event -> {
        // Ceci s'exécute après les gestionnaires NORMAL
    }
);
```

### Avec Valeur Personnalisée

```java
// Utiliser une valeur de priorité personnalisée (entre -32768 et 32767)
short customPriority = -5000;  // Entre EARLY et NORMAL

getEventRegistry().register(
    customPriority,
    PlayerConnectEvent.class,
    event -> {
        // Gestionnaire priorité personnalisée
    }
);
```

## Ordre d'Exécution

Quand un événement est déclenché, les gestionnaires sont appelés dans l'ordre de priorité :

```
FIRST (-21844)
   ↓
EARLY (-10922)
   ↓
NORMAL (0)      ← Par défaut
   ↓
LATE (10922)
   ↓
LAST (21844)
```

### Exemple

```java
@Override
public void start() {
    getEventRegistry().register(EventPriority.LAST, PlayerConnectEvent.class, event -> {
        getLogger().at(Level.INFO).log("3. Gestionnaire LAST");
    });

    getEventRegistry().register(EventPriority.FIRST, PlayerConnectEvent.class, event -> {
        getLogger().at(Level.INFO).log("1. Gestionnaire FIRST");
    });

    getEventRegistry().register(PlayerConnectEvent.class, event -> {
        getLogger().at(Level.INFO).log("2. Gestionnaire NORMAL (défaut)");
    });
}

// Sortie quand un joueur rejoint :
// 1. Gestionnaire FIRST
// 2. Gestionnaire NORMAL (défaut)
// 3. Gestionnaire LAST
```

## Quand Utiliser Chaque Priorité

### FIRST

Utiliser pour :
- Configurer les données de l'événement avant les autres gestionnaires
- Logging/débogage qui doit voir l'événement original
- Validation critique qui doit s'exécuter avant tout le reste

```java
getEventRegistry().register(EventPriority.FIRST, PlayerChatEvent.class, event -> {
    // Logger le message original avant tout filtrage
    logChat(event.getSender(), event.getContent());
});
```

### EARLY

Utiliser pour :
- Modifications que les autres plugins devraient voir
- Vérifications de permissions avant les gestionnaires normaux
- Prétraitement des données

```java
getEventRegistry().register(EventPriority.EARLY, PlayerChatEvent.class, event -> {
    // Filtrer les grossièretés avant que les autres plugins traitent le message
    event.setContent(filterProfanity(event.getContent()));
});
```

### NORMAL

Utiliser pour :
- Gestion standard des événements
- La plupart des fonctionnalités de plugin
- Par défaut quand la priorité n'importe pas

```java
getEventRegistry().register(PlayerChatEvent.class, event -> {
    // Traitement standard du chat
    processMessage(event.getSender(), event.getContent());
});
```

### LATE

Utiliser pour :
- Réactions aux modifications faites par d'autres gestionnaires
- Collecte d'analytics/statistiques
- Effets secondaires

```java
getEventRegistry().register(EventPriority.LATE, PlayerChatEvent.class, event -> {
    // Enregistrer le message final après toutes les modifications
    recordChatHistory(event.getSender(), event.getContent());
});
```

### LAST

Utiliser pour :
- Nettoyage final ou overrides
- Surveillance du statut d'annulation
- Logging de l'état final de l'événement

```java
getEventRegistry().register(EventPriority.LAST, PlayerChatEvent.class, event -> {
    if (event.isCancelled()) {
        getLogger().at(Level.INFO).log("Le chat a été annulé par un autre plugin");
    }
});
```

## Avec les Événements Annulables

La priorité est particulièrement importante avec les événements annulables :

```java
// Le gestionnaire FIRST peut annuler
getEventRegistry().register(EventPriority.FIRST, BreakBlockEvent.class, event -> {
    if (isProtectedArea(event.getTargetBlock())) {
        event.setCancelled(true);
    }
});

// Le gestionnaire NORMAL devrait vérifier l'annulation
getEventRegistry().register(BreakBlockEvent.class, event -> {
    if (!event.isCancelled()) {
        // Traiter la destruction du bloc
        trackBlockBreak(event.getTargetBlock(), event.getBlockType());
    }
});

// Le gestionnaire LAST pour la surveillance
getEventRegistry().register(EventPriority.LAST, BreakBlockEvent.class, event -> {
    if (event.isCancelled()) {
        logProtectedBlockAttempt(event.getTargetBlock());
    }
});
```