Init

content/world/interactions/selectors.fr.md

@@ -0,0 +1,270 @@
+---
+title: Sélecteurs
+type: docs
+weight: 2
+---
+
+Les sélecteurs déterminent quelles entités ou blocs sont ciblés par une interaction.
+
+**Package:** `com.hypixel.hytale.server.core.modules.interaction.interaction.config.selector`
+
+## Types de Sélecteurs
+
+### RaycastSelector
+
+Lance un rayon depuis la vue du joueur pour trouver des cibles :
+
+```yaml
+Selector:
+  Type: Raycast
+  Range: 5.0
+  BlockCollision: true
+  EntityCollision: true
+```
+
+Propriétés :
+- `Range` - Distance maximale
+- `BlockCollision` - S'arrêter aux blocs
+- `EntityCollision` - Détecter les entités
+
+### AOECircleSelector
+
+Sélectionne toutes les cibles dans une zone circulaire :
+
+```yaml
+Selector:
+  Type: AOECircle
+  Radius: 3.0
+  Height: 2.0
+```
+
+Propriétés :
+- `Radius` - Rayon du cercle
+- `Height` - Étendue verticale
+
+### AOECylinderSelector
+
+Sélectionne les cibles dans une zone cylindrique :
+
+```yaml
+Selector:
+  Type: AOECylinder
+  Radius: 4.0
+  Height: 3.0
+  HeightOffset: 0.0
+```
+
+### StabSelector
+
+Attaque vers l'avant à courte portée :
+
+```yaml
+Selector:
+  Type: Stab
+  Range: 2.0
+  Width: 1.5
+```
+
+### HorizontalSelector
+
+Attaque en balayage horizontal :
+
+```yaml
+Selector:
+  Type: Horizontal
+  Range: 3.0
+  Angle: 90.0
+```
+
+## Interface Selector
+
+L'interface `Selector` fournit des méthodes pour le ciblage :
+
+```java
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.function.consumer.TriIntConsumer;
+import com.hypixel.hytale.math.vector.Vector4d;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import java.util.function.BiConsumer;
+import java.util.function.Predicate;
+
+public interface Selector {
+    // Sélectionner les entités cibles - le consumer reçoit la ref ET la position de frappe
+    void selectTargetEntities(
+        CommandBuffer<EntityStore> buffer,
+        Ref<EntityStore> attacker,
+        BiConsumer<Ref<EntityStore>, Vector4d> consumer,
+        Predicate<Ref<EntityStore>> filter
+    );
+
+    // Sélectionner les blocs cibles
+    void selectTargetBlocks(
+        CommandBuffer<EntityStore> buffer,
+        Ref<EntityStore> attacker,
+        TriIntConsumer consumer
+    );
+
+    // Mettre à jour l'état du sélecteur à chaque tick
+    void tick(
+        CommandBuffer<EntityStore> buffer,
+        Ref<EntityStore> entity,
+        float startTime,
+        float currentTime
+    );
+}
+```
+
+{{< callout type="info" >}}
+**Note :** La méthode d'instance `selectTargetEntities()` fournit la position de frappe via `Vector4d`, tandis que la méthode statique `selectNearbyEntities()` fournit uniquement les références d'entités.
+{{< /callout >}}
+
+## Filtres d'Entités
+
+Filtrer quelles entités peuvent être sélectionnées :
+
+### VulnerableMatcher
+
+Sélectionner uniquement les entités pouvant subir des dégâts :
+
+```yaml
+Matcher:
+  Type: Vulnerable
+```
+
+### PlayerMatcher
+
+Sélectionner uniquement les joueurs :
+
+```yaml
+Matcher:
+  Type: Player
+```
+
+## Utilitaires de Sélection Statique
+
+L'interface `Selector` fournit des méthodes statiques pour les opérations courantes :
+
+### Sélectionner les Blocs Proches
+
+```java
+Selector.selectNearbyBlocks(
+    commandBuffer,
+    attackerRef,
+    range,
+    (x, y, z) -> {
+        // Traiter chaque position de bloc
+    }
+);
+
+// Ou depuis une position
+Selector.selectNearbyBlocks(
+    position,
+    range,
+    (x, y, z) -> {
+        // Traiter chaque position de bloc
+    }
+);
+```
+
+### Sélectionner les Entités Proches
+
+```java
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+Selector.selectNearbyEntities(
+    commandBuffer,
+    attackerRef,
+    range,
+    (Consumer<Ref<EntityStore>>) entityRef -> {
+        // Traiter chaque entité
+    },
+    (Predicate<Ref<EntityStore>>) entityRef -> {
+        // Prédicat de filtre - retourner true pour inclure
+        return true;
+    }
+);
+
+// Ou depuis une position avec ComponentAccessor
+Selector.selectNearbyEntities(
+    componentAccessor,
+    position,
+    range,
+    entityRef -> {
+        // Traiter chaque entité
+    },
+    entityRef -> true  // Filtre ou null
+);
+```
+
+{{< callout type="info" >}}
+**Note :** Le consumer reçoit uniquement `Ref<EntityStore>`. Pour les positions de frappe d'entité (comme `Vector4d`), utilisez plutôt `selectTargetEntities()` d'une instance de Selector.
+{{< /callout >}}
+
+## Exemples Pratiques
+
+### Tranchant d'Épée
+
+```yaml
+SwordSlash:
+  Type: DamageCalculator
+  Selector:
+    Type: Horizontal
+    Range: 2.5
+    Angle: 120.0
+  Matcher:
+    Type: Vulnerable
+  Damage:
+    Base: 10.0
+    Type: Physical
+```
+
+### Aura de Soin
+
+```yaml
+HealingAura:
+  Type: ChangeStatInteraction
+  Selector:
+    Type: AOECircle
+    Radius: 5.0
+    Height: 3.0
+  Matcher:
+    Type: Player
+  Stat: Health
+  Amount: 5.0
+```
+
+### Minage
+
+```yaml
+Mining:
+  Type: BreakBlock
+  Selector:
+    Type: Raycast
+    Range: 4.0
+    BlockCollision: true
+    EntityCollision: false
+```
+
+## Bonnes Pratiques
+
+{{< callout type="info" >}}
+**Directives des Sélecteurs :**
+- Utilisez une portée appropriée pour le type d'interaction
+- Appliquez des filtres pour éviter les cibles non voulues
+- Considérez les performances avec les grands sélecteurs AOE
+- Utilisez le raycast pour les attaques de précision
+- Vérifiez toujours `entity.isValid()` avant d'accéder aux composants d'entité
+{{< /callout >}}
+
+{{< callout type="warning" >}}
+**Validité des Entités :** Avant d'interagir avec une entité, vérifiez qu'elle est toujours valide pour éviter les exceptions de pointeur null :
+```java
+if (entityRef.isValid()) {
+    // Accès sécurisé aux composants de l'entité
+    // ... effectuer les opérations
+}
+```
+Le serveur valide les références d'entité en interne, mais le code personnalisé doit toujours vérifier la validité avec `Ref.isValid()`.
+{{< /callout >}}