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

title, type, weight

title	type	weight
Priorités d'Événements	docs	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

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

// 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

@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

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

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

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

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

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 :

// 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());
    }
});