Documentation/content/advanced/effects/dynamic-lights.fr.md

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