Init

content/getting-started/plugin-lifecycle.fr.md

@@ -0,0 +1,186 @@
+---
+title: Cycle de Vie du Plugin
+type: docs
+weight: 4
+---
+
+Comprendre le cycle de vie du plugin est essentiel pour initialiser et nettoyer correctement les ressources de votre plugin.
+
+## États du Cycle de Vie
+
+Un plugin passe par plusieurs états durant sa vie :
+
+```
+NONE → SETUP → START → ENABLED → SHUTDOWN → DISABLED
+```
+
+| État | Description |
+|------|-------------|
+| `NONE` | État initial avant toute initialisation |
+| `SETUP` | Le plugin est en phase de configuration |
+| `START` | Le plugin démarre |
+| `ENABLED` | Le plugin est pleinement opérationnel |
+| `SHUTDOWN` | Le plugin s'arrête |
+| `DISABLED` | Le plugin a été désactivé |
+
+## Méthodes du Cycle de Vie
+
+### Constructeur
+
+Le constructeur est appelé lorsque le plugin est instancié. Utilisez ceci pour :
+
+- Enregistrer les fichiers de configuration avec `withConfig()` (recommandé)
+- Stocker la référence init si nécessaire
+
+```java
+import com.hypixel.hytale.server.core.util.Config;
+
+private Config<MyConfig> config;
+
+public MyPlugin(JavaPluginInit init) {
+    super(init);
+    // Enregistrer la config dans le constructeur - chargée de façon asynchrone pendant preLoad()
+    config = withConfig(MyConfig.CODEC);
+}
+```
+
+{{< callout type="info" >}}
+Enregistrer les configs dans le constructeur garantit qu'elles sont chargées de façon asynchrone pendant `preLoad()`, avant que `setup()` ne soit appelé. C'est l'approche recommandée.
+{{< /callout >}}
+
+### setup()
+
+Appelé pendant la phase initiale de configuration, après le chargement des configs. Utilisez ceci pour :
+
+- Préparer les ressources qui ne dépendent pas d'autres plugins
+- Logique d'initialisation précoce
+- Accéder aux valeurs de configuration chargées
+
+```java
+import java.util.logging.Level;
+
+@Override
+public void setup() {
+    // La config est déjà chargée et disponible
+    getLogger().at(Level.INFO).log("Configuration terminée !");
+}
+```
+
+{{< callout type="info" >}}
+Pour créer des classes de configuration avec `CODEC`, voir la [documentation des Codecs]({{< ref "core-concepts/codecs#buildercodec" >}}).
+{{< /callout >}}
+
+{{< callout type="warning" >}}
+N'enregistrez pas de commandes ou d'événements dans `setup()`. D'autres plugins peuvent ne pas être encore chargés.
+{{< /callout >}}
+
+### start()
+
+Appelé après que tous les plugins aient terminé leur configuration. Utilisez ceci pour :
+
+- Enregistrer les commandes
+- Enregistrer les écouteurs d'événements
+- Enregistrer les entités
+- Interagir avec d'autres plugins
+
+```java
+import com.hypixel.hytale.server.core.event.events.player.PlayerConnectEvent;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import java.util.logging.Level;
+
+@Override
+public void start() {
+    // Enregistrer les commandes
+    getCommandRegistry().registerCommand(new MyCommand());
+
+    // Enregistrer les événements
+    getEventRegistry().register(PlayerConnectEvent.class, this::onPlayerConnect);
+
+    getLogger().at(Level.INFO).log("Plugin démarré !");
+}
+
+private void onPlayerConnect(PlayerConnectEvent event) {
+    // Voir la documentation PlayerRef pour les références thread-safe aux joueurs
+    PlayerRef playerRef = event.getPlayerRef();
+    getLogger().at(Level.INFO).log("Joueur en connexion : " + playerRef.getUsername());
+}
+```
+
+{{< callout type="info" >}}
+Voir la [documentation des Registres]({{< ref "core-concepts/registries" >}}) pour une liste complète des registres disponibles et leur utilisation.
+{{< /callout >}}
+
+### shutdown()
+
+Appelé quand le plugin est désactivé ou le serveur s'arrête. Utilisez ceci pour :
+
+- Sauvegarder les données
+- Nettoyer les ressources
+- Annuler les tâches planifiées
+
+```java
+import java.util.logging.Level;
+
+@Override
+public void shutdown() {
+    // Sauvegarder les données en attente
+    savePlayerData();
+
+    getLogger().at(Level.INFO).log("Arrêt du plugin terminé !");
+}
+```
+
+{{< callout type="info" >}}
+Les registres sont automatiquement nettoyés après `shutdown()`. Vous n'avez pas besoin de désinscrire manuellement les commandes ou événements.
+{{< /callout >}}
+
+## Diagramme du Flux de Vie
+
+{{< steps >}}
+
+### Chargement du Plugin
+Le serveur découvre votre JAR de plugin et lit `manifest.json`
+
+### Appel du Constructeur
+`MyPlugin(JavaPluginInit init)` est instancié
+
+### preLoad()
+Les fichiers de configuration enregistrés avec `withConfig()` sont chargés de façon asynchrone
+
+### setup()
+Votre méthode `setup()` est appelée
+
+### start()
+Votre méthode `start()` est appelée après que tous les plugins soient configurés
+
+### En Cours d'Exécution
+Le plugin est maintenant en état `ENABLED` et pleinement opérationnel
+
+### shutdown()
+Appelé quand le serveur s'arrête ou le plugin est désactivé
+
+### Nettoyage
+Tous les registres sont automatiquement nettoyés
+
+{{< /steps >}}
+
+## Vérifier l'État du Plugin
+
+Vous pouvez vérifier si votre plugin est activé :
+
+```java
+if (isEnabled()) {
+    // Le plugin fonctionne
+}
+
+if (isDisabled()) {
+    // Le plugin ne fonctionne pas
+}
+
+// Obtenir l'état actuel
+PluginState state = getState();
+```
+
+## Étapes Suivantes
+
+Apprenez à [Compiler et Exécuter](../building-and-running) votre plugin.