Vecteurs relatifs Elite Script

À quoi servent-ils ?

Les vecteurs relatifs sont définis par rapport à une position précise mais dynamique.

Par exemple, pour attirer un joueur vers un boss en mouvement, calculez un vecteur de la position du joueur vers celle du boss. Un vecteur fixe ne peut pas suivre leurs positions changeantes.

Les vecteurs relatifs permettent de viser avec des projectiles, de lancer des blocs en chute et d'orienter des entités. Comme décalages relatifs, ils peuvent placer un renfort au-delà d'un joueur ou prolonger un rayon au-delà de sa cible.

Contexte d'utilisation

Dans les actions, les vecteurs relatifs utilisent la clé YAML RelativeVector:. Les actions concernées sont :

SUMMON_ENTITY : définit la vélocité, donc la direction et la vitesse, de l'entité créée.
SUMMON_REINFORCEMENT : définit la vélocité du renfort créé.
SPAWN_PARTICLE : fournit le vecteur de mouvement dans chaque entrée de particles: ; le champ au niveau de l'action n'est pas utilisé pour cela.
PUSH : définit la vélocité de poussée.
SPAWN_FALLING_BLOCK : définit la vélocité du bloc en chute.
SET_FACING : définit l'orientation d'une entité.

Les autres actions lisent un bloc RelativeVector: valide, mais ne l'utilisent pas. Ces clés sont insensibles à la casse : les entrées de particules acceptent donc RelativeVector: et relativeVector:. Les valeurs de type de cible conservent les majuscules documentées.

Pour les actions de vélocité, RelativeVector a priorité sur vValue ; les deux ne sont pas additionnés. PUSH calcule un seul vecteur pour toutes les entités sélectionnées et l'applique un tick plus tard. SET_FACING calcule également une seule direction pour toutes les entités sélectionnées.

Pour modifier les positions des cibles, placez relativeOffset: dans un bloc de cible tel que Target, FinalTarget, Target2 ou FinalTarget2. Un relativeOffset: au niveau de l'action produit Failed to read key relativeOffset .... Il ne prend effet que si l'action n'a aucun bloc Target, car la cible SELF par défaut lit alors les clés de cible directement dans l'action. Voir la section sur les décalages relatifs ci-dessous.

Comment fonctionnent les vecteurs ?

Vous pouvez représenter un vecteur comme une flèche reliant deux points.

Sa longueur est importante : pour une flèche lancée, elle représente la vitesse ; pour un décalage de position, elle représente la distance. Des points plus éloignés donnent un vecteur plus long.

Si seule la direction vous intéresse, normalisez le vecteur : sa direction est conservée et sa longueur devient 1.0. Un multiplicateur permet ensuite d'ajuster le déplacement ou la vélocité souhaitée.

Propriétés

Valeur	Détails	Obligatoire ?	Valeur par défaut
`SourceTarget`	Cible au point de départ du vecteur	✅	`none`
`DestinationTarget`	Cible au point d'arrivée du vecteur	✅	`none`
`normalize`	Normalise ou non le vecteur	❌	`false`
`multiplier`	Multiplie la longueur. Accepte une plage avec `~`, par exemple `1.0~2.5`.	❌	`1.0`
`offset`	Ajoute un décalage fixe. Accepte des plages avec `~`, par exemple `0~5,0~2,0~10`.	❌	`0,0,0`

Valeurs aléatoires

multiplier et offset acceptent des plages avec le tilde (~) :

multiplier : utilisez min~max, par exemple 1.0~2.5. Cet exemple tire une valeur de 1.0 à 2.5, sans inclure 2.5.
offset : utilisez x1~x2,y1~y2,z1~z2, par exemple 0~5,0~2,0~10. Chaque composante X, Y et Z est tirée indépendamment.

Les valeurs sont tirées à chaque calcul du vecteur. Les composantes aléatoires du décalage suivent la même règle : de min jusqu'à max, ce dernier exclu.

Exemple

eliteScript:
  ShootChicken:
    Events:
    - EliteMobDamagedByPlayerEvent
    Actions:
    - action: SUMMON_ENTITY
      sValue: CHICKEN
      Target:
        targetType: SELF
      RelativeVector:
        SourceTarget:
          targetType: SELF
        DestinationTarget:
          targetType: DIRECT_TARGET
        normalize: true
        multiplier: 2.0

Lance un poulet depuis le boss vers le joueur qui l'attaque.

eliteScript:
  ShootArrow:
    Events:
    - EliteMobDamagedByPlayerEvent
    Actions:
    - action: SUMMON_ENTITY
      sValue: ARROW
      Target:
        targetType: SELF
      RelativeVector:
        SourceTarget:
          targetType: SELF
        DestinationTarget:
          targetType: DIRECT_TARGET
        normalize: true
        multiplier: 2.0

Lance une flèche vers le joueur attaquant. Pour les entités projectiles lorsque le boss est vivant, SUMMON_ENTITY utilise le lanceur de projectiles du boss : le projectile part donc du boss même si le Target de l'action indique une autre position.

eliteScript:
  SpawnReinforcement:
    Events:
    - EliteMobDamagedByPlayerEvent
    Actions:
    - action: SUMMON_ENTITY
      sValue: ZOMBIE
      Target:
        targetType: DIRECT_TARGET
        relativeOffset:
          SourceTarget:
            targetType: SELF
          DestinationTarget:
            targetType: DIRECT_TARGET
          normalize: true
          multiplier: 2.0

Crée un zombie vanilla deux blocs au-delà du joueur, suivant la ligne du boss au joueur. Malgré le nom du script, ce n'est pas un renfort EliteMobs. relativeOffset se place dans Target : il modifie la position d'apparition, pas la vélocité. La direction utilise la ligne tridimensionnelle complète, pas l'orientation du joueur. Ce décalage ne recherche ni sol ni collision.

eliteScript:
  Example:
    Events:
    - EliteMobDamagedByPlayerEvent
    Zone:
      Shape: SPHERE
      target:
        targetType: SELF_SPAWN
        offset: 0,0,0
        track: false
      filter: PLAYER
      radius: 6
    Actions:
    - action: SPAWN_PARTICLE
      repeatEvery: 38
      times: 5
      Target:
        targetType: ZONE_FULL
        track: false
        coverage: 0.9
      particles:
      - particle: FLAME
        RelativeVector:
          SourceTarget:
            targetType: ACTION_TARGET
            track: true
          DestinationTarget:
            targetType: SELF_SPAWN
            offset: 0,-0.5,0
        speed: 0.05

Crée des salves répétées de flammes se déplaçant vers l'intérieur d'une sphère autour du point d'apparition. La zone elle-même ne rétrécit pas.

Fonctionnement :

La zone fournit des points géométriques dans une sphère de six blocs. filter: PLAYER affecte la sélection d'entités, pas les positions des particules utilisées ici.
coverage: 0.9 donne à chaque point généré environ 90 % de chances d'être sélectionné. Le track: false de l'action conserve cette sélection pour les répétitions de cette exécution.
Le vecteur de chaque particule va de son point d'apparition (ACTION_TARGET) à un demi-bloc sous le point d'apparition du boss (SELF_SPAWN avec offset: 0,-0.5,0).
Le vecteur est calculé à la création de chaque particule. ACTION_TARGET utilise directement la position fournie par l'action ; son paramètre track imbriqué ne dirige pas les particules déjà en vol.
Un vecteur relatif de particule remplace x, y, z et force amount à zéro pour une émission directionnelle. speed est toujours transmis à Bukkit et le type de particule détermine le mouvement résultant.
L'action s'exécute cinq fois, à 38 ticks d'intervalle, sauf annulation du travail planifié. Chaque coup admissible démarre une autre exécution, car cet exemple n'a pas de temps de recharge.

Ordre des opérations

Les propriétés s'appliquent dans cet ordre :

Calcul du vecteur -> normalize -> multiplier -> offset

Notes techniques

Normalisation : Pour un vecteur non nul, elle conserve la direction et fixe la longueur à 1.0 avant le multiplicateur et le décalage.

Multiplicateurs négatifs : Un multiplicateur négatif inverse la direction. Par exemple, -1.0 pointe dans le sens opposé.

Coordonnées du décalage : Le décalage utilise les axes du monde, pas ceux de la direction du vecteur. Il est ajouté après les autres calculs.

Validation du monde : Les cibles source et destination doivent être dans le même monde. Sinon, un vecteur nul (0, 0, 0) est renvoyé, ce qui peut faire échouer une action ou produire un résultat inattendu.

Cibles absentes : Une collection résolue vide pour la source ou la destination renvoie un vecteur nul avant l'application du multiplicateur et du décalage. Cela inclut une extrémité DIRECT_TARGET lorsque l'événement n'a pas de cible directe. Un bloc SourceTarget ou DestinationTarget absent provoque toujours une erreur.

Si les positions valides de source et de destination coïncident, le vecteur a une longueur nulle. normalize: true le laisse à zéro : seul l'offset propre au vecteur relatif subsiste. Lorsqu'une cible produit plusieurs positions, le vecteur utilise la première, sans garantie qu'elle soit la plus proche. Utilisez une cible unique telle que DIRECT_TARGET pour obtenir une direction sans ambiguïté.

ACTION_TARGET : Utilise une position fournie par l'action et contourne les paramètres imbriqués offset, relativeOffset et track. Pour les particules, c'est leur point d'apparition ; pour les entités et blocs en chute, la position demandée ; pour la vélocité des renforts, la position du renfort créé. Pour PUSH et SET_FACING, c'est la position du boss, pas celle de chaque entité sélectionnée. Dans le relativeOffset d'une cible, c'est la position en cours de décalage, après l'offset simple de cette cible.

Vélocité et position : Dans une action comme SUMMON_ENTITY, RelativeVector définit la vélocité de l'entité. Dans une cible, relativeOffset définit un décalage de position. Le calcul sous-jacent est identique, mais son usage dépend du contexte.

Appliquez relativeOffset à une cible telle que SELF, SELF_SPAWN, DIRECT_TARGET, LOCATION ou LOCATIONS, y compris pour l'origine ou l'extrémité d'une zone. Sur ZONE_FULL / ZONE_BORDER, il décale chaque emplacement échantillonné de la zone. Il n'a aucun effet sur LANDING_LOCATION ni INHERIT_SCRIPT_TARGET. Voir les règles des décalages de cible.

Décalage relatif Elite Script

À quoi servent-ils ?

Les décalages relatifs fonctionnent comme les vecteurs relatifs, mais permettent d'ajuster dynamiquement les positions des cibles ou des effets selon le contexte.

Comment fonctionnent les décalages relatifs ?

Ils sont additifs : leur résultat est ajouté à la valeur de base, par exemple une position ou un vecteur.

Prenons une zone en rayon :

Target 1 est SELF, le boss.
Target 2 est DIRECT_TARGET, le joueur fourni par l'événement.

Supposons que le joueur se trouve à huit blocs, dans le même monde, sans autre décalage. Définissez SELF comme SourceTarget du décalage relatif et DIRECT_TARGET comme DestinationTarget, puis placez ce relativeOffset dans Target2. Ces exemples décrivent la distance jusqu'à l'extrémité ; les points dessinés dépendent aussi des paramètres du rayon.

Appliquons le décalage relatif :

Cas 1 : `normalize = false`, `multiplier = 1`

La distance d'origine est 8.
Le décalage vaut 8 × 1 = 8.
La longueur finale vaut 8 + 8 = 16.

Le rayon traverse le joueur et continue sur huit blocs supplémentaires.

Cas 2 : `normalize = false`, `multiplier = 2`

Le décalage vaut 8 × 2 = 16.
La longueur finale vaut 8 + 16 = 24.

Cas 3 : `normalize = true`, `multiplier = 1`

La distance est normalisée à 1.
Le décalage vaut 1 × 1 = 1.
La longueur finale vaut 8 + 1 = 9.

Cas 4 : `normalize = true`, `multiplier = 2`

Le décalage vaut 1 × 2 = 2.
La longueur finale vaut 8 + 2 = 10.

Résumé

normalize = false utilise la distance réelle entre les cibles.
normalize = true part d'une longueur de 1 pour un vecteur valide non nul.
Le décalage est toujours ajouté à la valeur d'origine.
Un multiplier nul annule le déplacement calculé uniquement s'il est fini. L'offset propre au vecteur relatif reste ajouté ensuite, et l'offset ordinaire de la cible reste distinct. Pour désactiver le décalage relatif, retirez son bloc.

Ce système permet d'allonger ou de raccourcir dynamiquement les distances dans les scripts EliteMobs.

Propriétés

Valeur	Détails	Obligatoire ?	Valeur par défaut
`SourceTarget`	Cible au point de départ du vecteur	✅	`none`
`DestinationTarget`	Cible au point d'arrivée du vecteur	✅	`none`
`normalize`	Normalise ou non le vecteur	❌	`false`
`multiplier`	Multiplie la longueur. Accepte une plage avec `~`, par exemple `1.0~2.5`.	❌	`1.0`
`offset`	Ajoute un vecteur fixe après `normalize` et `multiplier`. Accepte des plages avec `~`, par exemple `0~5,0~2,0~10`.	❌	`0,0,0`

relativeOffset et RelativeVector utilisent exactement le même analyseur et acceptent donc les mêmes cinq clés.

Exemple

eliteScript:
  MakeStaticRay:
    Events:
    - EliteMobDamagedByPlayerEvent
    Zone:
      shape: STATIC_RAY
      Target:
        targetType: SELF
        offset: 0,1,0
      Target2:
        targetType: DIRECT_TARGET
        offset: 0,1,0
        relativeOffset:
          sourceTarget:
            targetType: SELF
          destinationTarget:
            targetType: DIRECT_TARGET
          multiplier: 5
          normalize: true
    Actions:
    - action: SPAWN_PARTICLE
      Target:
        targetType: ZONE_FULL
      particles:
      - particle: ELECTRIC_SPARK
        amount: 1
      repeatEvery: 1
      times: 400

L'extrémité de ce rayon se trouve cinq blocs au-delà du joueur, suivant la ligne du boss au joueur. Les décalages ordinaires relèvent les deux extrémités d'un bloc au-dessus des pieds ; ils ne calculent pas automatiquement le centre des entités. STATIC_RAY désigne la forme, pas un instantané figé des cibles : avec track: true par défaut, cette action recalcule ses cibles à chaque répétition. Définissez Target.track: false dans l'action pour mettre en cache les positions du rayon et obtenir un affichage fixe. L'exemple demande 400 exécutions espacées d'un tick ; chaque coup admissible peut en démarrer une autre série.

Remarque : Les décalages relatifs de cet exemple concernent une zone, mais peuvent également s'appliquer à d'autres cibles.

À quoi servent-ils ?​

Contexte d'utilisation​

Comment fonctionnent les vecteurs ?​

Propriétés​

Valeurs aléatoires​

Ordre des opérations​

Notes techniques​

Décalage relatif Elite Script

À quoi servent-ils ?​

Comment fonctionnent les décalages relatifs ?​

Cas 1 : normalize = false, multiplier = 1​

Cas 2 : normalize = false, multiplier = 2​

Cas 3 : normalize = true, multiplier = 1​

Cas 4 : normalize = true, multiplier = 2​

Résumé​

Propriétés​

À quoi servent-ils ?

Contexte d'utilisation

Comment fonctionnent les vecteurs ?

Propriétés

Valeurs aléatoires

Ordre des opérations

Notes techniques

À quoi servent-ils ?

Comment fonctionnent les décalages relatifs ?

Cas 1 : `normalize = false`, `multiplier = 1`

Cas 2 : `normalize = false`, `multiplier = 2`

Cas 3 : `normalize = true`, `multiplier = 1`

Cas 4 : `normalize = true`, `multiplier = 2`

Résumé

Propriétés