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