Init

content/core-concepts/events/event-priorities.fr.md

@@ -0,0 +1,201 @@
+---
+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());
+    }
+});
+```