Init

2026-01-20 20:33:59 +01:00
commit b16a40e431
583 changed files with 87339 additions and 0 deletions
--- a/content/advanced/effects/dynamic-lights.fr.md
+++ b/content/advanced/effects/dynamic-lights.fr.md
@@ -0,0 +1,268 @@
+---
+title: Lumières Dynamiques
+type: docs
+weight: 2
+---
+
+Les lumières dynamiques ajoutent des effets de lueur aux entités en utilisant le composant `DynamicLight`.
+
+## Structure ColorLight
+
+La classe `ColorLight` définit les propriétés de la lumière :
+
+```java
+import com.hypixel.hytale.protocol.ColorLight;
+
+public class ColorLight {
+    public byte radius;     // 0-255 (rayon/intensité de la lumière)
+    public byte red;        // 0-255 (canal rouge)
+    public byte green;      // 0-255 (canal vert)
+    public byte blue;       // 0-255 (canal bleu)
+
+    public ColorLight(byte radius, byte red, byte green, byte blue) {
+        this.radius = radius;
+        this.red = red;
+        this.green = green;
+        this.blue = blue;
+    }
+}
+```
+
+## Composant DynamicLight
+
+Ajoutez des effets de lueur temporaires aux entités :
+
+```java
+import com.hypixel.hytale.server.core.modules.entity.component.DynamicLight;
+import com.hypixel.hytale.protocol.ColorLight;
+
+// Créer une lumière colorée (rayon, R, V, B)
+ColorLight light = new ColorLight(
+    (byte) 15,      // Rayon (0-255)
+    (byte) 255,     // Rouge (0-255)
+    (byte) 100,     // Vert (0-255)
+    (byte) 50       // Bleu (0-255)
+);
+
+// Ajouter le composant DynamicLight
+DynamicLight dynamicLight = new DynamicLight(light);
+componentAccessor.putComponent(
+    entityRef,
+    DynamicLight.getComponentType(),
+    dynamicLight
+);
+```
+
+## Composant PersistentDynamicLight
+
+Utilisez ce composant quand la lumière doit être sauvegardée avec les données de l'entité :
+
+```java
+import com.hypixel.hytale.server.core.modules.entity.component.PersistentDynamicLight;
+
+// Créer une lumière persistante
+PersistentDynamicLight persistentLight = new PersistentDynamicLight(light);
+componentAccessor.putComponent(
+    entityRef,
+    PersistentDynamicLight.getComponentType(),
+    persistentLight
+);
+```
+
+## Mettre à Jour les Propriétés de Lumière
+
+```java
+// Obtenir le composant de lumière existant
+DynamicLight dynamicLight = store.getComponent(
+    entityRef,
+    DynamicLight.getComponentType()
+);
+
+if (dynamicLight != null) {
+    // Créer de nouvelles propriétés de lumière
+    ColorLight newLight = new ColorLight(
+        (byte) 20,      // Nouveau rayon
+        (byte) 0,       // Pas de rouge
+        (byte) 255,     // Vert maximum
+        (byte) 100      // Un peu de bleu
+    );
+
+    // Mettre à jour et marquer pour sync réseau
+    dynamicLight.setColorLight(newLight);
+    // isNetworkOutdated est défini automatiquement
+}
+```
+
+## Supprimer la Lumière
+
+```java
+// Supprimer le composant pour désactiver la lumière
+componentAccessor.removeComponent(
+    entityRef,
+    DynamicLight.getComponentType()
+);
+```
+
+## Configurations de Lumière Courantes
+
+### Lueur Feu/Chaleur
+
+```java
+ColorLight fireLight = new ColorLight(
+    (byte) 12,
+    (byte) 255,    // Rouge élevé
+    (byte) 150,    // Orange moyen
+    (byte) 50      // Bleu faible
+);
+```
+
+### Lueur Glace/Froid
+
+```java
+ColorLight iceLight = new ColorLight(
+    (byte) 10,
+    (byte) 100,    // Rouge faible
+    (byte) 200,    // Vert moyen
+    (byte) 255     // Bleu élevé
+);
+```
+
+### Lueur Magie/Violet
+
+```java
+ColorLight magicLight = new ColorLight(
+    (byte) 15,
+    (byte) 200,    // Rouge élevé
+    (byte) 50,     // Vert faible
+    (byte) 255     // Bleu élevé
+);
+```
+
+### Lueur Soin/Vert
+
+```java
+ColorLight healLight = new ColorLight(
+    (byte) 10,
+    (byte) 50,     // Rouge faible
+    (byte) 255,    // Vert élevé
+    (byte) 100     // Bleu moyen
+);
+```
+
+## Exemples Pratiques
+
+### Ajouter un Effet de Lueur à un Joueur
+
+```java
+// Ajouter un effet de lueur temporaire à un joueur
+public void addGlowEffect(Player player, ComponentAccessor<EntityStore> componentAccessor,
+                          ScheduledExecutorService scheduler) {
+    World world = player.getWorld();
+
+    // Ajouter une lueur temporaire
+    ColorLight glow = new ColorLight(
+        (byte) 8,
+        (byte) 255,
+        (byte) 215,
+        (byte) 0    // Couleur dorée
+    );
+
+    DynamicLight light = new DynamicLight(glow);
+    Ref<EntityStore> entityRef = player.getReference();
+    componentAccessor.putComponent(
+        entityRef,
+        DynamicLight.getComponentType(),
+        light
+    );
+
+    // Supprimer après 3 secondes avec le scheduling Java standard
+    scheduler.schedule(() -> {
+        world.execute(() -> {
+            if (entityRef.isValid()) {
+                componentAccessor.removeComponent(
+                    entityRef,
+                    DynamicLight.getComponentType()
+                );
+            }
+        });
+    }, 3, TimeUnit.SECONDS);
+}
+```
+
+{{< callout type="warning" >}}
+**Note :** Utilisez `player.getReference()` pour obtenir la référence d'entité, pas `player.getEntityRef()`. Utilisez le `ScheduledExecutorService` Java standard pour les tâches différées.
+{{< /callout >}}
+
+### Effet de Lumière Pulsante
+
+Implémentez les effets pulsants en mettant à jour la lumière dans un gestionnaire de tick :
+
+```java
+// Suivre les entités pulsantes
+private final Map<Ref<EntityStore>, Integer> pulsingEntities = new ConcurrentHashMap<>();
+
+// Appeler cette méthode à chaque tick
+public void onTick(float deltaTime) {
+    for (Map.Entry<Ref<EntityStore>, Integer> entry : pulsingEntities.entrySet()) {
+        Ref<EntityStore> entityRef = entry.getKey();
+        int tick = entry.getValue() + 1;
+        entry.setValue(tick);
+
+        // Calculer l'intensité pulsante
+        double pulse = Math.sin(tick * 0.1) * 0.5 + 0.5;
+        byte radius = (byte) (5 + pulse * 10);
+
+        ColorLight light = new ColorLight(
+            radius,
+            (byte) 255,
+            (byte) (int)(100 + pulse * 100),
+            (byte) 50
+        );
+
+        DynamicLight dynamicLight = store.getComponent(
+            entityRef,
+            DynamicLight.getComponentType()
+        );
+
+        if (dynamicLight != null) {
+            dynamicLight.setColorLight(light);
+        }
+    }
+}
+
+public void startPulsingLight(Ref<EntityStore> entityRef) {
+    pulsingEntities.put(entityRef, 0);
+}
+
+public void stopPulsingLight(Ref<EntityStore> entityRef) {
+    pulsingEntities.remove(entityRef);
+}
+```
+
+## Synchronisation Réseau
+
+{{< callout type="info" >}}
+**Détails de Sync :**
+- Les changements de `DynamicLight` sont automatiquement marqués pour sync lors de l'utilisation de `setColorLight()`
+- Le flag `isNetworkOutdated` déclenche les mises à jour client
+- Utilisez `consumeNetworkOutdated()` avant les opérations de sync manuelles
+{{< /callout >}}
+
+## DynamicLight vs PersistentDynamicLight
+
+| Fonctionnalité | DynamicLight | PersistentDynamicLight |
+|----------------|--------------|------------------------|
+| Sauvegardé sur disque | Non | Oui |
+| Survit au redémarrage | Non | Oui |
+| Cas d'usage | Effets temporaires | Lueurs permanentes |
+| Performance | Plus léger | Légèrement plus lourd |
+
+## Bonnes Pratiques
+
+{{< callout type="warning" >}}
+**Directives pour les Lumières :**
+- Gardez des valeurs de rayon raisonnables (5-20 pour la plupart des effets)
+- N'ajoutez pas de lumières à trop d'entités simultanément
+- Supprimez les lumières temporaires quand plus nécessaires
+- Utilisez `PersistentDynamicLight` seulement quand la persistance est requise
+{{< /callout >}}