Scripting Lua : Boss et Entités

Cette page couvre tout ce qui concerne les wrappers de boss et d'entités dans les pouvoirs Lua EliteMobs : context.boss, context.player, context.players, context.entities, et les tables wrapper d'entité qu'ils retournent. Si vous êtes nouveau aux pouvoirs Lua, commencez d'abord par Démarrage.

Wrappers d'entité

Lorsque vous accédez aux entités via l'API Lua -- que ce soit depuis context.boss, context.player, des résultats de requête comme context.players:nearby_players(), ou des champs d'événement -- vous recevez toujours des tables wrapper. Ce ne sont pas des objets Bukkit bruts. Chaque wrapper fournit un ensemble de champs (valeurs de snapshot capturées au moment de la création) et de méthodes (appels en direct qui atteignent le serveur).

Cette page décrit les wrappers natifs des pouvoirs de boss EliteMobs. Les helpers partagés de MagmaCore, comme context.world:get_entity(uuid), peuvent renvoyer un autre wrapper dont les champs sont lus en direct et les signatures diffèrent. Consultez la référence de l'API partagée pour ceux-ci. Les méthodes natives acceptent les deux-points ou le point sans argument self explicite. Affecter un champ ne modifie que la table Lua ; utilisez une méthode pour modifier l'entité.

Deux règles à retenir :

Les champs comme health, current_location, et maximum_health sont des snapshots. Ils reflètent l'état au moment où le wrapper a été créé et ne se mettent pas à jour automatiquement.
Les méthodes comme get_location(), get_health(), et is_alive() effectuent une vérification en direct à chaque appel.

Champs d'entité communs

Chaque wrapper d'entité vivante inclut ces champs.

Champ	Type	Notes
`entity.name`	string	Nom d'affichage
`entity.uuid`	string	UUID sous forme de texte
`entity.entity_type`	string	Nom Bukkit EntityType (ex. `"ZOMBIE"`, `"PLAYER"`)
`entity.is_player`	boolean	`true` pour les joueurs
`entity.is_elite`	boolean	`true` si EliteMobs le suit en tant qu'élite
`entity.is_mount`	boolean	`true` si ce wrapper représente une monture de boss
`entity.is_monster`	boolean	`true` pour les entités de type monstre
`entity.health`	number	Santé actuelle (snapshot)
`entity.maximum_health`	number	Santé max (snapshot)
`entity.current_location`	location table	Position au moment où le wrapper a été créé
`entity.is_valid`	boolean	Validité Bukkit lors de la création du wrapper (instantané)

is_valid est un champ sur les entités vivantes, pas une méthode

Sur les wrappers d'entité vivante (y compris context.player et context.boss), is_valid est un simple booléen capturé au moment de la construction du wrapper. Appeler entity:is_valid() déclenche attempt to call a boolean value et désactive le pouvoir.

Lisez l'instantané avec entity.is_valid (point).
Pour une vérification en direct, appelez plutôt entity:is_alive() — elle réinterroge le serveur à chaque fois.

is_valid() est une véritable méthode sur les wrappers de référence d'entité non vivante plus légers, renvoyés par summon_projectile, spawn_falling_block_at_location et consorts. Ce sont les wrappers que vous êtes le plus susceptible de conserver d'un tick à l'autre, et c'est là que la vérification en direct compte.

Pour lire des données spécifiques aux élites comme le niveau du boss, utilisez les champs et méthodes de context.boss décrits dans la section context.boss ci-dessous. Pour faire disparaître un élite depuis un script, appelez la méthode entity:remove_elite().

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.log:info("Boss level: " .. context.boss.level)
  end
}

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local target = context.players:current_target()
    if target ~= nil then
      context.log:info("Target: " .. target.name .. " HP: " .. target.health)
    end
  end
}

Méthodes d'entité communes

Les méthodes suivantes effectuent des appels en direct au serveur. Le déplacement, la santé, l'équipement et les effets appartiennent aux wrappers d'entités vivantes. Le chat, les barres d'action, les titres, les barres de boss et les commandes nécessitent un wrapper de joueur. context.boss:send_message(...) est une méthode de boss distincte qui diffuse aux joueurs proches. Sauf retour documenté, les méthodes de modification renvoient nil, sans indicateur de réussite.

Les changements d'IA, de conscience, d'invulnérabilité et d'échelle appartiennent au pouvoir qui les a effectués. Chacun enregistre la valeur qu'il a remplacée : une durée positive restaure cette valeur après le nombre de ticks indiqué, et la fermeture du script restaure tout changement encore actif. Lorsque plusieurs pouvoirs modifient la même propriété, la fin d'un changement restaure le changement restant le plus récent, ou la valeur d'origine s'il n'en reste aucun. Si un autre plugin ou une commande modifie la propriété entre-temps, sa valeur est conservée. Mettre le script en pause n'annule pas ces changements. Les durées des tags, les poussées différées et les barres de boss des joueurs utilisent des tâches indépendantes de l'horloge de jeu, qui continuent après la fermeture du script. Les autres changements des entités ne sont pas annulés.

`entity:is_alive()`

Renvoie true si l'entité est toujours valide et n'est pas morte.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if context.player:is_alive() then
      context.player:send_message("&aYou're still standing!")
    end
  end
}

`entity:get_location()`

Renvoie l'emplacement actuel en direct sous forme de location table.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    local loc = context.player:get_location()
    context.world:play_sound_at_location(loc, "entity.experience_orb.pickup")
  end
}

`entity:get_eye_location()`

Renvoie l'emplacement au niveau des yeux sous forme de location table.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    local eye = context.player:get_eye_location()
    context.world:spawn_particle_at_location(eye, "FLAME")
  end
}

`entity:get_health()` / `entity:get_maximum_health()`

Renvoie la santé actuelle ou maximale en direct.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    local pct = context.player:get_health() / context.player:get_maximum_health()
    if pct < 0.25 then
      context.player:send_message("&cYou're running low!")
    end
  end
}

`entity:get_velocity()`

Renvoie la vélocité actuelle de l'entité sous forme de vector table.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    local vel = context.player:get_velocity()
    context.log:info("Player speed Y: " .. vel.y)
  end
}

`entity:send_message(text)`

Envoie un message de chat à un joueur. Prend en charge le formatage de couleur d'EliteMobs.

Paramètre	Type	Notes
`text`	string	Message avec codes de couleur

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    context.player:send_message("&6[Boss] &fPrepare yourself!")
  end
}

`entity:show_action_bar(message)`

Envoie un message dans la barre d'action d'un joueur via la source Lua d'EliteMobs. Cette source participe au compositeur de barres d'action sans réserver l'affichage au script.

Paramètre	Type	Notes
`message`	string	Texte de la barre d'action avec codes de couleur

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    context.player:show_action_bar("&c&lDANGER ZONE")
  end
}

`entity:show_title(title[, subtitle][, fadeIn][, stay][, fadeOut])`

Envoie un titre et un sous-titre optionnel à un joueur avec les couleurs EliteMobs. Les durées sont des nombres entiers de ticks.

Paramètre	Type	Défaut	Notes
`title`	string		Texte du titre
`subtitle`	string	`""`	Texte du sous-titre
`fadeIn`	number	`10`	Ticks d'apparition
`stay`	number	`40`	Ticks de maintien
`fadeOut`	number	`10`	Ticks de disparition

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local nearby = context.players:nearby_players(20)
    for _, p in ipairs(nearby) do
      p:show_title("&4PHASE 2", "&7The boss is enraged!", 10, 40, 10)
    end
  end
}

`entity:show_boss_bar(title[, color][, style][, duration])`

Crée une nouvelle barre de boss pour un joueur via le gestionnaire d'ordre des barres. Les noms de couleur et de style ignorent la casse ; les valeurs inconnues utilisent WHITE et SOLID. Une durée positive programme une suppression indépendante. Une durée non positive n'ajoute aucun minuteur, et cette méthode ne renvoie ni référence ni clé permettant une suppression ultérieure. Utilisez une durée positive. Cette signature diffère de l'API partagée de MagmaCore, qui identifie les barres par des clés.

Paramètre	Type	Défaut	Notes
`title`	string		Texte du titre de la barre
`color`	string	`"WHITE"`	Valeur BarColor
`style`	string	`"SOLID"`	Valeur BarStyle
`duration`	number	`40`	Durée en ticks

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local nearby = context.players:nearby_players(20)
    for _, p in ipairs(nearby) do
      p:show_boss_bar("&cIncoming Attack!", "RED", "SOLID", 100)
    end
  end
}

`entity:teleport_to_location(location)`

Demande une téléportation Bukkit et renvoie nil, sans indiquer sa réussite. La conversion native accepte x, y, z, yaw/pitch optionnels, le nom d'un world chargé ou une table current_location imbriquée. Les coordonnées absentes valent 0 ; sans monde explicite, elle utilise celui du boss qui lance le pouvoir, pas nécessairement celui de la cible. Un monde explicitement inconnu fait échouer la conversion. nil ou une valeur autre qu'une table utilise la position du boss. Aucune vérification de destination sûre ou de protection de région n'est ajoutée.

Paramètre	Type	Notes
`location`	location table	Destination

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("teleport_pull", 200) then return end
    context.player:teleport_to_location(context.boss:get_location())
    context.player:send_message("&cThe boss pulls you in!")
  end
}

`entity:set_velocity_vector(vector)`

Définit immédiatement la vélocité de l'entité.

Paramètre	Type	Notes
`vector`	vector table	`{ x, y, z }` ou `{ x = 0, y = 1, z = 0 }`

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("launch", 100) then return end
    context.player:set_velocity_vector({ x = 0, y = 1.5, z = 0 })
    context.player:send_message("&cYou are launched into the air!")
  end
}

`entity:apply_push_vector(vector[, additive][, delay])`

Applique une vélocité capturée après un délai de 1 tick par défaut. Le minuteur indépendant vérifie que l'entité est encore valide. Avec additive = true, il ajoute le vecteur à la vélocité au moment de l'exécution ; sinon, il la remplace. Mettre en pause ou fermer le script n'annule pas la poussée.

Paramètre	Type	Défaut	Notes
`vector`	vector table		Direction et puissance
`additive`	boolean	`false`	Ajoute à la vélocité existante au lieu de la remplacer
`delay`	number	`1`	Délai en ticks avant application

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("push_up", 100) then return end
    context.player:apply_push_vector({ x = 0, y = 2.0, z = 0 })
    context.player:send_message("&cUpward blast!")
  end
}

`entity:face_direction_or_location(directionOrLocation)`

Oriente l'entité en la téléportant à sa position actuelle avec une nouvelle rotation. Une table contenant une chaîne world ou une table current_location imbriquée est une destination, qui doit être dans le monde de l'entité. Une table contenant seulement x/y/z est un vecteur de direction. Une direction nulle ne change rien.

Paramètre	Type	Notes
`directionOrLocation`	vector ou location table	Cible vers laquelle se tourner

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    context.player:face_direction_or_location(context.boss:get_location())
    context.player:send_message("&cThe boss forces you to look at it!")
  end
}

`entity:set_fire_ticks(ticks)`

Définit les ticks de feu Bukkit. La politique d'effets d'instance revérifie la cible à chaque appel. Les joueurs doivent être connectés, vivants et dans le monde source ; dans une instance, ils doivent appartenir à la partie active et à sa liste de participants. Les autres cibles vivantes doivent être valides. Cela ne garantit pas que le feu inflige des dégâts.

Paramètre	Type	Notes
`ticks`	number	Durée du feu en ticks (20 ticks = 1 seconde)

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("ignite", 100) then return end
    context.player:set_fire_ticks(60)
    context.player:send_message("&cYou catch fire!")
  end
}

`entity:add_visual_freeze_ticks([ticks])`

Ajoute des ticks à la valeur réelle de gel de Bukkit, sous la même politique d'effets d'instance que set_fire_ticks. Malgré son nom, ce n'est pas un simple affichage par paquets et cela n'arrête pas directement l'IA ou le déplacement. Le comportement normal de gel de Minecraft peut s'appliquer.

Paramètre	Type	Défaut	Notes
`ticks`	number	`1`	Quantité de ticks de gel

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("freeze", 200) then return end
    context.player:add_visual_freeze_ticks(100)
    context.player:send_message("&bYou feel a chilling frost!")
  end
}

`entity:apply_potion_effect(effect, duration[, amplifier])`

Applique un effet de potion Bukkit après la même vérification d'instance que set_fire_ticks. Les noms ignorent la casse ; les noms inconnus produisent un avertissement sans appliquer d'effet. Les règles de remplacement de Bukkit s'appliquent, sans remplacement forcé de tous les effets existants.

Paramètre	Type	Défaut	Notes
`effect`	string		Nom PotionEffectType
`duration`	number		Durée en ticks
`amplifier`	number	`0`	Niveau de l'effet (0 = niveau I)

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("slow", 200) then return end
    context.player:apply_potion_effect("SLOWNESS", 60, 1)
    context.player:send_message("&7You feel sluggish...")
  end
}

attention

remove_potion_effect(effect) n'est pas disponible sur les wrappers natifs des pouvoirs de boss EliteMobs. Il existe sur les wrappers partagés de MagmaCore. Choisissez une durée adaptée lors de l'application des effets ; appliquer un effet de durée nulle ne retire pas fiablement un effet existant.

`entity:deal_damage(amount)` / `entity:deal_custom_damage(amount)` / `entity:deal_damage_from_boss(amount)`

Soumet des dégâts à Bukkit. Les trois méthodes renvoient nil ; le montant demandé ne prouve pas la santé perdue. Les règles de combat et les listeners ultérieurs peuvent modifier ou annuler le coup.

Méthode	Notes
`deal_damage(amount)`	Appelle les dégâts Bukkit sans attaquant explicite
`deal_custom_damage(amount)`	Utilise `BossCustomAttackDamage` avec le boss lanceur ; refuse les coups sur soi, les cibles invulnérables ou mortes et les joueurs hors Survival/Adventure, soumet un coup personnalisé, puis efface le délai de dégâts natif
`deal_damage_from_boss(amount)`	Appelle les dégâts Bukkit avec le boss lanceur comme attaquant ; le traitement normal de combat EliteMobs peut s'appliquer

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local nearby = context.players:nearby_players(10)
    for _, p in ipairs(nearby) do
      p:deal_custom_damage(10)
      p:send_message("&cThe boss unleashes a shockwave!")
    end
  end
}

`entity:restore_health(amount)`

Pour les élites suivis, appelle le soin EliteMobs et déclenche l'événement annulable EliteMobHealEvent. Les autres entités vivantes sont soignées directement jusqu'à la valeur de base de leur attribut de santé maximale, qui peut différer du maximum effectif renvoyé par get_maximum_health(). Fournissez une quantité non négative ; ce helper n'est pas une API de dégâts qui borne automatiquement les entrées.

Paramètre	Type	Notes
`amount`	number	Quantité à soigner

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    -- Heal the player slightly when they hit the boss
    context.player:restore_health(5)
    context.player:send_message("&aYou drain life from the boss!")
  end
}

`entity:set_invulnerable(enabled[, duration])`

Définit l'invulnérabilité de l'entité et enregistre la valeur remplacée. Une durée positive restaure cette valeur après le nombre de ticks indiqué ; sinon, le changement dure jusqu'à l'arrêt de ce pouvoir, qui le restaure également. Un nouvel appel depuis le même pouvoir remplace le changement précédent de ce pouvoir.

Paramètre	Type	Défaut	Notes
`enabled`	boolean		`true` pour activer l'invulnérabilité
`duration`	number	`0`	Restaure la valeur remplacée après ce nombre de ticks ; `0` conserve le changement jusqu'à l'arrêt du pouvoir

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("shield", 200) then return end
    context.player:set_invulnerable(true, 40)
    context.player:send_message("&6A brief shield protects you!")
  end
}

`entity:set_ai_enabled(enabled[, duration])`

Définit l'IA de l'entité et enregistre la valeur remplacée. Une durée positive restaure cette valeur après le nombre de ticks indiqué ; sinon, le changement dure jusqu'à l'arrêt de ce pouvoir, qui le restaure également. Appeler set_ai_enabled(true) alors que ce pouvoir détient un changement d'IA met fin à ce changement et restaure la valeur remplacée au lieu d'en appliquer un nouveau.

Paramètre	Type	Défaut	Notes
`enabled`	boolean		`true` pour activer l'IA
`duration`	number	`0`	Restaure la valeur remplacée après ce nombre de ticks ; `0` conserve le changement jusqu'à l'arrêt du pouvoir

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Disable boss AI for 3 seconds at combat start
    context.boss:set_ai_enabled(false, 60)
    context.boss:send_message("&7The boss is stunned!")
  end
}

`entity:add_tag(tag[, duration])` / `entity:remove_tag(tag)` / `entity:has_tag(tag)`

Gère les tags EliteMobs sensibles à la casse sur les élites suivis et les joueurs dont les données d'inventaire EliteMobs sont chargées. Les mobs ordinaires non suivis ne les stockent pas. Ce ne sont pas des tags de scoreboard Bukkit. Une durée positive programme une suppression indépendante ; ajouter à nouveau le même tag n'annule pas son ancien minuteur.

Méthode	Paramètre	Notes
`add_tag(tag[, duration])`	string, number optionnel	Ajoute le tag, le retire éventuellement automatiquement après des ticks
`remove_tag(tag)`	string	Retire le tag
`has_tag(tag)`	string	Renvoie `true` si le tag est présent

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.player:has_tag("marked") then
      context.player:add_tag("marked", 200)
      context.player:send_message("&cYou have been marked!")
    end
  end
}

`entity:run_command(command)`

Exécute immédiatement une commande en tant que joueur, avec ses permissions. Utilisez le texte sans / initial. Cette méthode réservée aux joueurs renvoie nil, n'indique pas la réussite et ne remplace pas les placeholders.

Paramètre	Type	Notes
`command`	string	Texte de la commande sans `/` au début

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("curse_cmd", 200) then return end
    context.player:run_command("say I have been cursed!")
  end
}

`entity:set_scale(scale[, duration])`

Définit la valeur de base de l'attribut d'échelle s'il est disponible et enregistre la valeur remplacée. Une durée positive restaure cette valeur après le nombre de ticks indiqué ; sinon, le changement dure jusqu'à l'arrêt de ce pouvoir, qui le restaure également. Les modificateurs d'attribut peuvent changer la taille effective.

Paramètre	Type	Défaut	Notes
`scale`	number		Multiplicateur d'échelle
`duration`	number	`0`	Restaure l'échelle remplacée après ce nombre de ticks ; `0` conserve le changement jusqu'à l'arrêt du pouvoir

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Boss grows to double size for 5 seconds
    context.boss:set_scale(2.0, 100)
    context.boss:send_message("&4The boss grows in size!")
  end
}

`entity:set_gravity(enabled)`

Active ou désactive la gravité. Elle n'est pas restaurée automatiquement à la fermeture du script. Un callback différé appartenant au script peut ne jamais s'exécuter après sa fermeture ; ne le considérez pas comme une restauration garantie pour les entités survivantes.

Paramètre	Type	Notes
`enabled`	boolean	`true` pour une gravité normale

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("levitate", 200) then return end
    -- Change the boss's gravity; the callback runs only while this script stays active.
    context.boss:set_gravity(false)
    context.scheduler:run_after(60, function(tick_context)
      if tick_context.boss.exists then
        tick_context.boss:set_gravity(true)
      end
    end)
  end
}

`entity:play_sound_at_entity(sound[, volume][, pitch])`

Joue un son à l'emplacement de l'entité.

Paramètre	Type	Défaut	Notes
`sound`	string		Clé de son Minecraft (par exemple, `"entity.ender_dragon.growl"`) ou un nom d'enum Spigot `Sound`. Les clés de resource pack fonctionnent également.
`volume`	number	`1.0`	Volume
`pitch`	number	`1.0`	Hauteur

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    context.player:play_sound_at_entity("entity.ender_dragon.growl", 1.0, 0.5)
  end
}

`entity:play_sound_at_self(sound[, volume][, pitch])`

Alias de play_sound_at_entity. Joue un son à l'emplacement de l'entité.

`entity:spawn_particle_at_self(particleOrSpec[, count])`

Fait apparaître des particules à l'emplacement actuel de l'entité. Utilise la même spécification de particules que le helper natif du monde. Le champ amount d'une table remplace le count de secours ; les noms sont convertis en majuscules et les particules nécessitant des données non prises en charge produisent un avertissement sans apparaître.

Paramètre	Type	Défaut	Notes
`particleOrSpec`	string ou table		Nom de particule ou table de spécification
`count`	number	`1`	Nombre de particules

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    context.player:spawn_particle_at_self("HEART", 5)
  end
}

`entity:spawn_particles_at_location(location, particle[, count])`

Fait apparaître des particules à un emplacement spécifique.

Paramètre	Type	Défaut	Notes
`location`	location table		Emplacement cible
`particle`	string		Nom du type de particule
`count`	number	`1`	Nombre de particules

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    local loc = context.player:get_location()
    context.player:spawn_particles_at_location(loc, "FLAME", 10)
  end
}

`entity:play_model_animation(name)`

Demande une animation uniquement si EliteMobs suit l'entité comme un boss personnalisé avec modèle personnalisé. Renvoie nil, sans attendre la fin ni indiquer si le nom d'animation existe. Une entité générique équipée d'un modèle ne suffit pas pour ce helper natif.

Paramètre	Type	Notes
`name`	string	Nom de l'animation

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.boss:play_model_animation("attack_swing")
  end
}

Méthodes de véhicule et de passager

Les wrappers d'entités vivantes exposent aussi les helpers de véhicule et de passager Bukkit. Les arguments wrappers sont résolus par UUID Bukkit ; une simple chaîne UUID n'est pas acceptée. Monter refuse les entités absentes, identiques ou invalides, contourne temporairement la protection EliteMobs contre les abus de monture et renvoie l'acceptation de Bukkit. Ces méthodes n'enregistrent pas de trajet de transport et ne prévoient pas de nettoyage à la fermeture du script.

Méthode	Renvoie	Notes
`entity:is_inside_vehicle()`	boolean	Vrai si l'entité monte une autre entité.
`entity:has_vehicle()`	boolean	Vrai si l'entité a actuellement un véhicule.
`entity:get_vehicle()`	wrapper d'entité ou nil	Renvoie le wrapper du véhicule actuel.
`entity:set_vehicle(vehicle)`	boolean	Fait monter cette entité sur `vehicle`.
`entity:leave_vehicle()`	boolean	Fait quitter à cette entité son véhicule actuel.
`entity:has_passengers()`	boolean	Vrai si cette entité a des passagers.
`entity:get_passenger_count()`	number	Nombre de passagers.
`entity:get_passengers()`	table	Tableau de wrappers de passagers.
`entity:add_passenger(passenger)`	boolean	Ajoute un passager à cette entité.
`entity:remove_passenger(passenger)`	boolean	Retire un passager de cette entité.
`entity:eject_passengers()`	boolean	Éjecte tous les passagers.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if context.player:has_vehicle() then
      context.player:leave_vehicle()
    end
  end
}

`entity:push_relative_to(source[, strength][, xOffset][, yOffset][, zOffset])`

Remplace immédiatement la vélocité par le déplacement normalisé de la source vers l'entité, multiplié par strength, puis ajoute les décalages selon les axes du monde. Les positions confondues reçoivent tout de même les décalages. Un wrapper fournit son current_location sauvegardé, pas sa position actuelle ; passez source:get_location() au besoin. Ce helper ne compare pas les mondes ; utilisez uniquement des positions du même monde.

Paramètre	Type	Défaut	Notes
`source`	location ou wrapper		Origine de la poussée
`strength`	number	`1.0`	Multiplicateur de puissance de poussée
`xOffset`	number	`0`	Décalage X supplémentaire
`yOffset`	number	`0`	Décalage Y supplémentaire
`zOffset`	number	`0`	Décalage Z supplémentaire

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("knockback", 60) then return end
    context.player:push_relative_to(context.boss:get_location(), 2.0, 0, 0.5, 0)
    context.player:send_message("&cThe boss knocks you back!")
  end
}

`entity:set_custom_name(name)` / `entity:reset_custom_name()`

Définit le nom personnalisé Bukkit avec formatage des couleurs. La réinitialisation utilise le nom configuré de l'élite suivi ; pour une entité non suivie, elle utilise son getName() actuel et ne restaure donc pas un ancien nom sauvegardé. Cela ne modifie ni le nom de compte d'un joueur ni le champ instantané du wrapper.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("mark", 200) then return end
    context.boss:set_custom_name("&c&lEnraged Boss")
    context.boss:send_message("&cThe boss is enraged!")
    -- Reset after 5 seconds
    context.scheduler:run_after(100, function(tick_context)
      if tick_context.boss:is_alive() then
        tick_context.boss:reset_custom_name()
      end
    end)
  end
}

`entity:place_temporary_block(material[, duration][, requireAir])`

Place un bloc temporaire à l'emplacement actuel de l'entité et renvoie nil, même si requireAir empêche la pose. Avec une durée positive, les données sauvegardées du bloc, mais pas le contenu des conteneurs, sont restaurées à la fin du minuteur, au déchargement du chunk ou du monde, ou à l'arrêt du plugin, mais uniquement si l'emplacement contient toujours le bloc temporaire. Poser de nouveau sur le même bloc temporaire relance son minuteur. Les blocs dotés d'une entité de bloc, comme les coffres, et les blocs détenus par un autre propriétaire de blocs temporaires sont ignorés. Casser le bloc ne lâche rien. Une durée non positive place le bloc de façon permanente, sans suivi. Utilisez un matériau de bloc et vérifiez vous-même les protections.

Paramètre	Type	Défaut	Notes
`material`	string		Nom du matériau du bloc
`duration`	number	`0`	Ticks positifs avant restauration ; les valeurs non positives placent le bloc de façon permanente
`requireAir`	boolean	`false`	Ne place que si le bloc est actuellement de l'air

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("ice_trap", 200) then return end
    context.player:place_temporary_block("ICE", 60, true)
    context.player:send_message("&bIce forms at your feet!")
  end
}

`entity:get_height()`

Renvoie la hauteur de l'entité en blocs.

`entity:is_on_ground()`

Renvoie le flag actuel isOnGround() de Bukkit. Ne lance pas de nouvelle requête de blocs ou d'espace libre au-dessus.

`entity.is_valid`

Sur un wrapper d'entité vivante, ce champ booléen enregistre la validité Bukkit lors de sa création. Lisez-le avec un point (entity.is_valid) ; l'appeler comme une méthode provoque une erreur.

Comme il s'agit d'un instantané, il se périme : ce n'est donc pas un substitut à une vérification en direct. Utilisez entity:is_alive() lorsque vous avez besoin de l'état actuel, et is_valid() (la méthode) sur les wrappers de référence d'entité non vivante que vous avez conservés d'un tick à l'autre.

`entity:is_frozen()`

Renvoie true si l'entité (lorsqu'elle est suivie comme un boss personnalisé) a le flag « gelé » défini.

`entity:set_awareness_enabled(aware[, duration])`

Définit la conscience du mob et enregistre la valeur remplacée. N'affecte que les entités de type mob. Une durée positive restaure cette valeur après le nombre de ticks indiqué ; sinon, le changement dure jusqu'à l'arrêt de ce pouvoir, qui le restaure également. L'appeler avec true alors que ce pouvoir détient un changement de conscience met fin à ce changement au lieu d'en appliquer un nouveau.

Paramètre	Type	Défaut	Notes
`aware`	boolean		`true` pour activer la conscience
`duration`	number	`0`	Restaure la valeur remplacée après ce nombre de ticks ; `0` conserve le changement jusqu'à l'arrêt du pouvoir

`entity:is_healing()` / `entity:set_healing(enabled)`

Lit ou définit le flag de soin de l'élite suivi. Cela ne restaure pas de santé et ne démarre pas de minuteur de soin. set_healing(true) marque l'élite comme en soin s'il ne l'est pas déjà ; set_healing(false) n'efface que le soin défini par ce pouvoir. À l'arrêt du pouvoir, celui-ci efface tout flag de soin qu'il détient encore. Une entité non suivie renvoie false à la lecture et reste inchangée à l'écriture.

`entity:overlaps_box_at_location(center[, halfX][, halfY][, halfZ])`

Renvoie true si la boîte englobante chevauche la boîte numérique alignée sur les axes. Ne compare pas les mondes ; fournissez un centre dans le monde de l'entité. Un centre impossible à résoudre renvoie false.

Paramètre	Type	Défaut	Notes
`center`	location table		Centre de la boîte de test
`halfX`	number	`0.5`	Demi-largeur sur l'axe X
`halfY`	number	identique à halfX	Demi-hauteur sur l'axe Y
`halfZ`	number	identique à halfX	Demi-largeur sur l'axe Z

`entity:remove_elite()`

Retire l'entité élite du suivi d'EliteMobs. Si l'entité est un élite, cela la fait disparaître correctement via EliteMobs.

`entity:remove()`

Supprime une entité vivante ordinaire qu'un script a fait apparaître, comme un porte-armure. Renvoie true si elle a été supprimée. Les joueurs et les élites sont refusés et renvoient false ; faites disparaître les élites avec remove_elite().

`entity:set_invisible(enabled)` et `entity:set_silent(enabled)`

set_invisible masque le corps de l'entité ; les objets portés et tenus restent visibles. set_silent coupe les sons propres à l'entité.

`entity:set_marker(enabled)`

Porte-armures uniquement. Ces quatre méthodes existent sur les wrappers de porte-armure et sont absentes de toute autre entité.

Méthode	Effet
`set_marker(enabled)`	Un porte-armure marqueur n'a pas de hitbox et ne peut être ni frappé ni heurté
`set_small(enabled)`	Porte-armure de moitié moins grand
`set_base_plate(enabled)`	Affiche ou masque la plaque de base en pierre
`set_arms(enabled)`	Affiche ou masque les bras

Pour un objet ou un bloc flottant purement visuel, préférez world:spawn_display_at_location, qui n'a besoin d'aucune de ces méthodes.

`entity:set_custom_name_visible(visible)`

Définit si le nom personnalisé de l'entité est toujours visible ou seulement lorsqu'on le regarde.

Paramètre	Type	Notes
`visible`	boolean	`true` pour toujours visible

`entity:set_equipment(slot, material[, options])`

Remplace l'emplacement choisi par un nouvel objet du matériau indiqué. Les noms d'emplacement, de matériau et d'enchantement ignorent la casse. Les emplacements ou matériaux inconnus ne changent rien ; les enchantements inconnus sont ignorés et les autres utilisent des niveaux sans les restrictions normales. Ce helper ne charge pas de fichier d'objet personnalisé et ne conserve pas les métadonnées de l'ancien objet. Il renvoie nil.

Paramètre	Type	Défaut	Notes
`slot`	string		Emplacement d'équipement : `"HEAD"`, `"CHEST"`, `"LEGS"`, `"FEET"`, `"HAND"`, `"OFF_HAND"`
`material`	string		Nom du matériau (ex. `"DIAMOND_SWORD"`, `"IRON_HELMET"`)
`options`	table	`{}`	Paramètres optionnels (voir ci-dessous)

Table d'options :

Clé	Type	Défaut	Notes
`enchantments`	tableau de tables	`nil`	Chaque entrée : `{ type = "SHARPNESS", level = 2 }`
`unbreakable`	boolean	`false`	Indique si l'item est incassable

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Give the boss a glowing diamond sword
    context.boss:set_equipment("HAND", "DIAMOND_SWORD", {
      unbreakable = true,
      enchantments = {
        { type = "SHARPNESS", level = 5 }
      }
    })
  end
}

`entity:damage_equipment(slot, amount)`

Endommage l'objet dans HAND, OFF_HAND, HEAD, CHEST, LEGS ou FEET et renvoie les dégâts de durabilité réellement appliqués. Demandez entre 1 et 64 points par appel. Les objets absents, non endommageables ou incassables renvoient 0.

Pour les joueurs, déclenche PlayerItemDamageEvent et respecte son annulation ou le montant modifié. Un listener peut dépasser la limite initiale de 64 points ; le résultat reste borné par la durabilité restante. Un objet atteignant son maximum de dégâts est retiré de l'emplacement, avec toute sa pile, et déclenche PlayerItemBreakEvent. Les métadonnées de dégâts maximaux personnalisés sont respectées. Cette méthode ne calcule pas elle-même les réductions d'Unbreaking. Un emplacement invalide ou une demande hors de 1..64 provoque une erreur d'argument Lua.

`entity:is_ai_enabled()`

Renvoie true si l'IA de l'entité est activée. Pour les élites suivis, lit l'état logique d'IA d'EliteMobs, y compris la gestion du comportement natif, au lieu de dépendre uniquement du flag Bukkit sous-jacent.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.boss:is_ai_enabled() then
      context.log:info("Boss AI is active")
    else
      context.log:info("Boss AI is disabled (stunned?)")
    end
  end
}

Wrappers de référence d'entité non vivante

Lorsqu'une entité apparue n'est pas une LivingEntity -- par exemple un bloc qui tombe, un projectile ou une boule de feu -- vous recevez un wrapper de référence plus léger. Ils sont renvoyés par des méthodes comme context.world:spawn_falling_block_at_location() ou context.boss:summon_projectile().

Champs instantanés : name, uuid, entity_type, is_player (toujours false), is_elite (toujours false), is_mount (normalement false ; boss:get_mount() le définit à true), current_location.

Méthodes :

Méthode	Notes
`is_valid()`	Vérification de validité en direct. Contrairement aux wrappers d'entité vivante, c'est bien une méthode ici
`get_location()`	Emplacement actuel en direct
`get_velocity()`	Vecteur de vélocité actuel
`is_on_ground()`	Indique si l'entité est au sol
`teleport_to_location(location)`	Téléporte l'entité
`set_velocity_vector(vector)`	Définit la vélocité
`set_direction_vector(vector)`	Définit la direction (Fireball uniquement)
`set_yield(value)`	Définit la puissance d'explosion (Fireball uniquement)
`set_gravity(enabled)`	Active ou désactive la gravité
`detonate()`	Demande la détonation des feux d'artifice ; sans effet sur les autres types
`remove()`	Retire l'entité du monde
`unregister([reason])`	Exécute le retrait du tracker EliteMobs pour les entités suivies reconnues ; une entité non suivie reste inchangée

Ces wrappers fournissent aussi toutes les méthodes de véhicule et de passager, notamment is_inside_vehicle(), get_vehicle(), set_vehicle(v), add_passenger(p) et eject_passengers(). Elles permettent à un boss de monter une entité non vivante.

unregister accepte un nom de motif de retrait sans tenir compte de la casse et utilise OTHER par défaut ; ce n'est pas une requête booléenne de réussite. Les méthodes conservent la référence à l'entité sous-jacente ; vérifiez is_valid() avant d'utiliser une référence sauvegardée. Un retrait différé planifié par l'instance Lua est annulé si celle-ci ferme. Utilisez une durée native adaptée ou le suivi par le propriétaire lorsque le nettoyage doit survivre au script.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("fireball", 100) then return end
    local fb = context.boss:summon_projectile("FIREBALL",
      context.boss:get_eye_location(),
      context.player:get_location(),
      1.5
    )
    if fb == nil then return end
    -- fb is a non-living reference wrapper; remove it after 5 seconds if still alive
    context.scheduler:run_after(100, function()
      if fb:is_valid() then
        fb:remove()
      end
    end)
  end
}

`context.player`

Disponible lorsque la cible directe ou l'acteur de l'événement est un joueur, notamment dans on_boss_damaged_by_player et on_player_damaged_by_boss. Les wrappers de joueur incluent les méthodes communes des entités vivantes, mais celles nécessitant un élite suivi ou un boss personnalisé ne font rien pour un joueur ordinaire. Les méthodes supplémentaires ci-dessous sont réservées aux joueurs.

attention

context.player vaut nil dans les hooks qui n'ont pas de joueur associé, tels que on_spawn, les callbacks planifiés et les hooks de minuteur. Vérifiez toujours qu'il n'est pas nil avant utilisation.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    context.player:send_message("&cHello!")
  end
}

Champs réservés aux joueurs

Champ	Type	Notes
`game_mode`	string	Instantané du mode de jeu en majuscules (ex. `"SURVIVAL"`)

Méthodes réservées aux joueurs

Méthode	Notes
`send_message(message)`	Message de chat avec formatage de couleur d'EliteMobs
`show_action_bar(message)`	Texte de la barre d'action
`show_title(title[, subtitle][, fadeIn][, stay][, fadeOut])`	Superposition d'écran de titre
`show_boss_bar(title[, color][, style][, duration])`	Barre de boss temporaire
`run_command(command)`	Exécute une commande en tant que joueur (sans `/` au début)

Exemple

return {
  api_version = 1,
  on_player_damaged_by_boss = function(context)
    if context.player == nil then return end
    local hp_pct = context.player:get_health() / context.player:get_maximum_health()
    if hp_pct < 0.3 then
      context.player:show_title("&4LOW HEALTH", "&7Find cover!", 5, 30, 10)
      context.player:show_boss_bar("&cBoss Enrage Incoming", "RED", "SEGMENTED_6", 80)
    end
  end
}

`context.boss`

Le wrapper du boss pour l'élite mob propriétaire de ce pouvoir Lua. Toujours disponible dans chaque hook.

astuce

Tant qu'une entité vivante sous-jacente existe, le wrapper du boss hérite des méthodes communes des entités vivantes, dont push_relative_to, apply_push_vector, set_gravity, set_scale, set_invulnerable, spawn_particle_at_self et overlaps_box_at_location. Il n'hérite pas de l'interface ni des commandes réservées aux joueurs. Les méthodes ci-dessous sont propres au boss ou passent par la couche EliteEntity. Si l'entité sous-jacente manque, la table existe toujours, mais l'ensemble des méthodes héritées n'est pas garanti.

Champs du boss

Champ	Type	Notes
`boss.name`	string	Nom d'affichage
`boss.uuid`	string	UUID de l'élite boss
`boss.entity_type`	string	Nom Bukkit EntityType
`boss.is_monster`	boolean	`true` si l'entité sous-jacente est un Monster
`boss.level`	number	Niveau de l'élite
`boss.health`	number	Santé actuelle (snapshot)
`boss.maximum_health`	number	Santé max (snapshot)
`boss.damager_count`	number	Nombre d'attaquants (snapshot)
`boss.is_in_combat`	boolean	Instantané de l'état de combat
`boss.exists`	boolean	Indique si l'élite existait à la construction de cette table
`boss.current_location`	location table	Position à la création du wrapper (snapshot)

Exemple

return {
  api_version = 1,
  on_spawn = function(context)
    context.log:info(context.boss.name .. " level " .. context.boss.level)
  end
}

Méthodes du boss

Méthodes de déplacement de patrouille

Les boss avec une patrouille configurée exposent patrol_pause(), patrol_resume(), walk_to(x, y, z), hold(x, y, z) et teleport(x, y, z). Les coordonnées sont des décalages depuis le point d'apparition et chaque méthode indique si la demande a été acceptée. walk_to reprend l'itinéraire à l'arrivée ; hold attend patrol_resume() ; les longs trajets utilisent le solveur automatique.

`boss:is_alive()`

Renvoie true si l'entité boss est valide, n'est pas morte et que l'élite existe encore. Utilisez ceci au lieu du champ exists pour les vérifications en direct.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if not context.boss:is_alive() then return end
    context.boss:send_message("&cI still live!")
  end
}

`boss:get_location()`

Renvoie l'emplacement actuel en direct du boss sous forme de location table.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local loc = context.boss:get_location()
    context.world:spawn_particle_at_location(loc, "FLAME")
  end
}

`boss:get_eye_location()`

Renvoie l'emplacement au niveau des yeux du boss.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local eye = context.boss:get_eye_location()
    context.world:spawn_particle_at_location(eye, "SMOKE")
  end
}

`boss:set_ai_enabled(enabled[, duration])`

Définit l'IA du boss avec les mêmes règles de changement détenu que entity:set_ai_enabled : une durée positive restaure la valeur remplacée, et la fermeture du pouvoir restaure tout changement encore actif.

Paramètre	Type	Défaut	Notes
`enabled`	boolean		`true` pour activer l'IA
`duration`	number	`0`	Restaure la valeur remplacée après ce nombre de ticks ; `0` conserve le changement jusqu'à l'arrêt du pouvoir

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if not context.cooldowns:check_local("stun", 200) then return end
    context.boss:set_ai_enabled(false, 60)
    context.boss:send_message("&7The boss is stunned for 3 seconds!")
  end
}

`boss:teleport_to_location(location)`

Demande une téléportation Bukkit avec les règles de conversion native décrites plus haut. Renvoie nil, sans indicateur de réussite. Ne déplace pas le point d'apparition configuré et ne définit pas de destination de patrouille.

Paramètre	Type	Notes
`location`	location table	Destination

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if not context.cooldowns:check_local("retreat", 300) then return end
    local spawn = context.entities:get_boss_spawn_location()
    context.boss:teleport_to_location(spawn)
    context.boss:send_message("&7The boss retreats to its lair!")
  end
}

`boss:set_velocity_vector(vector)`

Définit immédiatement la vélocité du boss.

Paramètre	Type	Notes
`vector`	vector table	`{ x, y, z }` ou `{ x = 0, y = 1, z = 0 }`

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Boss leaps into the air at combat start
    context.boss:set_velocity_vector({ x = 0, y = 2.0, z = 0 })
    context.boss:send_message("&cThe boss leaps!")
  end
}

`boss:restore_health(amount)`

Appelle le soin EliteMobs, qui déclenche l'événement annulable EliteMobHealEvent et borne la santé au minimum entre le maximum EliteMobs et la valeur de base de l'attribut de santé maximale Bukkit. Renvoie nil ; une annulation peut empêcher le soin.

Paramètre	Type	Notes
`amount`	number	Quantité à soigner

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if not context.cooldowns:check_local("heal", 200) then return end
    context.boss:restore_health(20)
    context.boss:send_message("&aThe boss regenerates!")
    context.boss:spawn_particle_at_self("HEART")
  end
}

`boss:play_sound_at_self(sound[, volume][, pitch])`

Joue un son à l'emplacement du boss.

Paramètre	Type	Défaut	Notes
`sound`	string		Clé de son Minecraft (par exemple, `"entity.wither.spawn"`) ou un nom d'enum Spigot `Sound`. Les clés de resource pack fonctionnent également.
`volume`	number	`1.0`	Volume
`pitch`	number	`1.0`	Hauteur

Exemple

return {
  api_version = 1,
  on_spawn = function(context)
    context.boss:play_sound_at_self("entity.wither.spawn", 1.0, 0.8)
  end
}

`boss:spawn_particle_at_self(particleOrSpec[, count])`

Fait apparaître des particules à l'emplacement du boss.

Paramètre	Type	Défaut	Notes
`particleOrSpec`	string ou table		Nom de particule ou table de spécification
`count`	number	`1`	Nombre de particules

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.boss:spawn_particle_at_self("SMOKE", 20)
    context.boss:send_message("&8Smoke billows from the boss!")
  end
}

`boss:play_model_animation(name)`

Joue une animation de modèle personnalisé sur le boss si elle est disponible.

Paramètre	Type	Notes
`name`	string	Nom de l'animation

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.boss:play_model_animation("slam")
  end
}

`boss:has_mount()` / `boss:get_mount()`

Vérifie ou renvoie l'entité que ce boss monte actuellement. boss:get_mount() renvoie nil si le boss n'a pas de monture. Lorsqu'une monture est renvoyée, son wrapper a is_mount = true.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local mount = context.boss:get_mount()
    if mount ~= nil then
      context.log:info("Boss is mounted on " .. mount.entity_type)
    end
  end
}

`boss:set_mount(entity)` / `boss:clear_mount()` / `boss:dismount()`

Monte ou démonte le boss. boss:set_mount(entity) fait monter le boss sur le wrapper d'entité fourni et renvoie true si Bukkit a accepté le changement de passager. boss:clear_mount() et boss:dismount() font tous deux quitter au boss son véhicule actuel.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if not context.cooldowns:check_local("mount_check", 100) then return end
    if context.boss:has_mount() then
      context.boss:dismount()
    end
  end
}

`boss:face_direction_or_location(vectorOrLocation)`

Fait en sorte que le boss se tourne vers une direction ou un emplacement.

Paramètre	Type	Notes
`vectorOrLocation`	vector ou location table	Direction vers laquelle se tourner

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    context.boss:face_direction_or_location(context.player:get_location())
  end
}

`boss:navigate_to_location(location[, speed][, forceTeleport][, timeout])`

Utilise la recherche de chemin pour faire marcher le boss vers un emplacement. Fonctionne uniquement avec les boss personnalisés.

Paramètre	Type	Défaut	Notes
`location`	location table		Destination
`speed`	number	`1.0`	Multiplicateur de vitesse de déplacement
`forceTeleport`	boolean	`false`	Téléporte le boss à destination si `timeout` expire avant son arrivée
`timeout`	number	`0`	Délai d'abandon en ticks. `0` utilise la valeur par défaut de `100` ticks (5 secondes)

La navigation s'arrête aussi lorsque le boss se trouve à moins d'un bloc de la destination, cesse d'exister ou quitte le monde de destination. Une nouvelle navigation annule celle qui était déjà active pour ce boss. Elle utilise une tâche Bukkit indépendante ; mettre en pause ou fermer Lua ne l'annule pas. La méthode renvoie nil, sans résultat d'arrivée, et capture la destination lors de l'appel.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("charge", 200) then return end
    context.boss:navigate_to_location(context.player:get_location(), 1.5)
    context.boss:send_message("&cThe boss charges at you!")
  end
}

`boss:add_tag(tag[, duration])` / `boss:remove_tag(tag)` / `boss:has_tag(tag)`

Gère les tags du boss.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    local pct = context.boss:get_health() / context.boss:get_maximum_health()
    if pct < 0.5 and not context.boss:has_tag("phase2") then
      context.boss:add_tag("phase2")
      context.boss:send_message("&4Entering Phase 2!")
    end
  end
}

`boss:send_message(message[, range])`

Envoie un message de chat formaté à tous les joueurs dans le rayon sphérique 3D du boss, dans son monde. Ne filtre ni le mode de jeu, ni la ligne de vue, ni la participation au combat ou à une instance.

Paramètre	Type	Défaut	Notes
`message`	string		Texte du message avec codes de couleur
`range`	number	`20`	Rayon en blocs

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.boss:send_message("&4You dare challenge me?!")
  end
}

`boss:summon_projectile(entityType, origin, destination[, speed][, options])`

Crée une entité et renvoie son wrapper natif, ou nil si une position ne peut pas être résolue ou si le type est inconnu. Un type reconnu mais impossible à faire apparaître peut encore échouer. Les projectiles Bukkit normaux partent du boss sauf avec spawn_at_origin = true ; l'origine fournie détermine toujours la direction vers la destination. Gardez les deux positions dans le même monde, car le helper ne le vérifie pas. Les autres types apparaissent à l'origine fournie et utilisent le wrapper vivant ou non vivant adapté.

Paramètre	Type	Défaut	Notes
`entityType`	string		Type d'entité (ex. `"FIREBALL"`, `"ARROW"`)
`origin`	location table		Position de lancement
`destination`	location table		Position cible
`speed`	number	`1.0`	Vitesse du projectile
`options`	table	`{}`	Voir les options ci-dessous

Table d'options :

Clé	Type	Notes
`duration`	number	Une valeur positive programme un retrait indépendant après ce nombre de ticks ; une valeur non positive n'ajoute aucun minuteur
`max_ticks`	number	Limite du suivi d'atterrissage ; `6000` par défaut
`custom_damage`	number	Métadonnées de dégâts personnalisés pour le combat du projectile, sans garantie de santé perdue
`detonation_power`	string	Nom de fichier de pouvoir utilisé comme métadonnée de projectile explosif, pas une puissance numérique d'explosion
`yield`	number	Puissance d'explosion (Fireball)
`persistent`	boolean	Définit la persistance Bukkit si fourni ; ne remplace pas la durée, les collisions ou le retrait par le propriétaire
`effect`	string	Nom EntityEffect à jouer à l'apparition
`incendiary`	boolean	Indique si l'explosion est incendiaire
`gravity`	boolean	Indique si le projectile a de la gravité
`glowing`	boolean	Effet brillant
`invulnerable`	boolean	Indique si le projectile est invulnérable
`track`	boolean	`true` par défaut : enregistre le projectile dans EliteMobs, sans guidage vers une cible.
`spawn_at_origin`	boolean	`false` par défaut : les projectiles normaux partent du boss. Utilisez `true` pour les créer à l'origine fournie.
`direction_only`	boolean	Pour les boules de feu créées à une origine explicite, définit la direction sans affectation supplémentaire de vélocité
`on_land`	function	Callback `(landing_location, spawned_entity)` au sol, à l'invalidation ou au dépassement de `max_ticks` ; ne correspond pas exclusivement à un impact

direction_only concerne les boules de feu créées explicitement à l'origine fournie ; il omet l'affectation supplémentaire de vélocité après la direction. La destination détermine toujours cette direction. Le boss devient le tireur des projectiles Bukkit. Avec track = true, le projectile est enregistré dans EliteMobs et lié au cycle de vie des renforts du boss. Ce suivi ne concerne pas les types autres que les projectiles. track = false désactive ce nettoyage par le propriétaire ; prévoyez un autre retrait.

Le suivi on_land appartient à l'instance Lua et s'arrête à sa fermeture. Il appelle une fois (landing_location, spawned_entity) au sol, à l'invalidation ou au dépassement de son compteur, sans retirer lui-même l'entité. Le minuteur de duration positive est indépendant et survit à la fermeture du script. Le callback ne prouve donc pas que le projectile a touché quelque chose.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if not context.cooldowns:check_local("fireball", 100) then return end
    context.boss:summon_projectile(
      "FIREBALL",
      context.boss:get_eye_location(),
      context.player:get_location(),
      1.5,
      {
        custom_damage = 10,
        on_land = function(loc, entity)
          context.world:spawn_particle_at_location(loc, "EXPLOSION")
        end
      }
    )
  end
}

`boss:summon_reinforcement(filename[, zoneOrLocation][, duration])`

Invoque silencieusement un renfort depuis un fichier de boss personnalisé, enregistre l'invocateur et hérite du combat normalisé lorsque le boss invocateur l'utilise. La configuration du renfort et ses règles de niveau dynamique déterminent son niveau. Une zone choisit une position échantillonnée aléatoire, ou son centre s'il n'y en a aucune ; un résultat non résolu utilise la position du boss. Renvoie son wrapper d'entité vivante, ou nil si aucun renfort vivant n'a été produit.

Paramètre	Type	Notes
`filename`	string	Nom de fichier de config du boss
`zoneOrLocation`	location table ou zone	Emplacement d'apparition ou définition de zone optionnel. Par défaut, l'emplacement du boss.
`duration`	number	Délai positif optionnel avant fuite, en ticks. Vaut `0` par défaut, sans minuteur ajouté par ce helper ; ce n'est pas un remplacement du niveau.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.boss:summon_reinforcement("my_minion.yml", context.boss:get_location(), 0)
    context.boss:send_message("&cMinions, come to my aid!")
  end
}

`boss:despawn()`

Retire le boss via EliteMobs avec le motif OTHER. boss:remove() est un alias utilisant le même cycle de retrait. Ce n'est ni un coup ni une demande normale de récompenses de mort.

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    local pct = context.boss:get_health() / context.boss:get_maximum_health()
    if pct < 0.1 then
      context.boss:send_message("&7The boss vanishes into thin air!")
      context.boss:despawn()
    end
  end
}

`boss:get_nearby_players(range)`

Renvoie les wrappers des joueurs dans le rayon sphérique 3D du boss, dans son monde. Ne filtre ni le mode de jeu, ni la ligne de vue, ni la participation à une instance, et ne trie pas par distance.

Paramètre	Type	Notes
`range`	number	Rayon en blocs

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local players = context.boss:get_nearby_players(30)
    for _, p in ipairs(players) do
      p:show_action_bar("&cThe boss sees you!")
    end
  end
}

`boss:get_damager_count()`

Renvoie la taille actuelle du registre des attaquants du boss. Contrairement au champ damager_count, c'est une lecture en direct ; ce n'est pas le nombre de participants proches ou actuellement connectés.

`boss:get_nearby_elites(radius)`

Renvoie au plus 32 élites vivants suivis dans le monde du boss, en excluant le boss lui-même. Le rayon doit être fini, supérieur à 0 et ne pas dépasser 64 blocs. Les résultats sont des wrappers d'entités vivantes triés par distance, puis par UUID d'élite en cas d'égalité. Cette requête ne détermine pas à elle seule si un effet est autorisé à viser chaque résultat.

`boss:get_target_player()`

Renvoie la cible actuelle du mob boss sous forme de wrapper de joueur, ou nil si la cible n'est pas un joueur ou n'est pas définie.

Méthodes de zone et de particules

Ces méthodes combinent les zones avec des effets de particules. Elles nécessitent une zone table en entrée.

`boss:get_nearby_players_in_zone(zone)`

Renvoie les wrappers des joueurs dont l'entité correspond à la forme de zone native dans le monde du boss. Ne filtre ni le mode de jeu ni la participation à une instance. C'est une nouvelle requête, pas une surveillance persistante.

Paramètre	Type	Notes
`zone`	zone table	Une définition de forme de zone

`boss:spawn_particles_in_zone(zone, particle[, amount][, x][, y][, z][, speed][, coverage])`

Remplit l'intérieur d'une zone de particules. Les arguments sont positionnels ; cette méthode n'accepte pas de table de spécification.

Paramètre	Type	Défaut	Notes
`zone`	zone table		Forme native avec `kind` ; voir Zones et ciblage
`particle`	string		Nom du type de particule
`amount`	number	`1`	Particules par emplacement échantillonné
`x`, `y`, `z`	number	`0`	Dispersion, ou direction lorsque `amount` vaut `0`
`speed`	number	`0`	Vitesse des particules
`coverage`	number	`1.0`	Probabilité indépendante d'échantillonnage par position, bornée à `0.01`–`1.0` ; un ensemble non vide fournit au moins une position

`boss:spawn_particles_in_zone_border(zone, particle[, amount][, x][, y][, z][, speed][, coverage])`

Identique à la méthode précédente, mais échantillonne la bordure de la zone au lieu de son intérieur.

`boss:get_particles_from_self_toward_zone(zone, particle[, speed])`

Renvoie un tableau de spécifications de particules placées aux positions échantillonnées de la zone et orientées à l'opposé du boss. Ne crée pas de particules sur le boss et n'anime pas leur trajet depuis celui-ci. Transmettez le résultat à boss:spawn_particles_with_vector(...).

Paramètre	Type	Défaut	Notes
`zone`	zone table		Zone cible
`particle`	string		Nom du type de particule
`speed`	number	`0.1`	Vitesse de déplacement inscrite dans chaque spécification

Chaque entrée a la forme { location = ..., particle = ..., amount = 0, x/y/z = <unit direction>, speed = ... }. Chaque position a 20 % de chances d'être sélectionnée, avec au moins une sélection dans un ensemble non vide ; les positions confondues avec celle du boss sont ensuite ignorées. Le comportement directionnel réel dépend du type de particule.

`boss:get_particles_toward_self(zone, particle, speed)`

Même comportement avec une direction inversée ; chaque particule pointe depuis sa position dans la zone vers le boss. Renvoie également le tableau sans faire apparaître les particules.

Paramètre	Type	Notes
`zone`	zone table	Zone source
`particle`	string	Nom du type de particule
`speed`	number	Fournissez une vitesse explicite, par exemple `0.1` ; sinon la méthode lit le nom de particule comme un nombre et échoue.

`boss:spawn_particles_with_vector(particles)`

Fait apparaître un tableau de particules directionnelles, chacune avec sa propre position et son propre vecteur de vélocité.

Paramètre	Type	Notes
`particles`	tableau de tables	Chaque entrée définit une particule avec une position et une direction

Méthodes de l'Ender Dragon

Ces méthodes ne s'appliquent que lorsque l'entité boss est un Ender Dragon.

`boss:get_ender_dragon_phase()`

Renvoie le nom de la EnderDragon.Phase actuelle sous forme de chaîne, ou nil si le boss n'est pas un Ender Dragon.

`boss:set_ender_dragon_phase(phase)`

Définit la phase de l'Ender Dragon.

Paramètre	Type	Notes
`phase`	string	Nom `EnderDragon.Phase` (ex. `"CIRCLING"`, `"CHARGE_PLAYER"`)

Méthodes de support de pouvoirs spéciaux

Ces méthodes prennent en charge les mécaniques de pouvoir intégrées d'EliteMobs depuis les scripts Lua.

`boss:start_tracking_fireball_system(speed?)`

Démarre un contrôleur pour ce pouvoir sur un boss de type monstre. À sa première exécution, au tick suivant, puis toutes les 8 secondes, il lance des boules de feu guidées vers les joueurs Survival et Adventure situés à moins de 20 blocs sur chaque axe, tant que le monstre a une cible. Une exécution sans cible arrête le contrôleur, y compris la première ; un nouvel appel peut le redémarrer. Les appels répétés pendant son activité ne remplacent pas la vitesse. Le contrôleur appartient au script du pouvoir : mettre le script en pause le met en pause, et fermer le script l'arrête. Lorsque l'appel démarre un contrôleur, la vitesse doit être finie et positive, sinon l'appel lève une erreur.

Les boules sont incendiaires avec une puissance d'explosion de 3. La tâche de suivi de chaque boule est indépendante du script. Elle s'arrête après environ 3 minutes ou un contexte invalide, sans supprimer elle-même la boule. Un coup non annulé sur une boule suivie alterne sa poursuite entre le joueur et le lanceur.

Paramètre	Type	Défaut	Notes
`speed`	number	`0.5`	Vitesse des boules de feu ; doit être finie et positive

`boss:handle_spirit_walk_damage(cause)`

Transmet une cause de dégâts au helper Spirit Walk. Le feu, les ticks de feu, le poison, wither, les épines et les attaques de balayage n'avancent pas son compteur. La noyade et la suffocation déclenchent immédiatement une fuite ; les autres causes acceptées la déclenchent tous les neuf coups. Le helper cherche une destination valide proche et anime le déplacement avec une invulnérabilité temporaire. Il n'annule pas l'événement de dégâts fourni et ne garantit pas une position derrière l'attaquant.

Paramètre	Type	Notes
`cause`	string	Nom Bukkit `DamageCause` (ex. `"ENTITY_ATTACK"`, `"PROJECTILE"`)

`boss:shield_wall_is_active()`

Renvoie le flag d'activité du contrôleur de bouclier. Cela ne garantit pas qu'une direction donnée conserve une réserve positive.

`boss:initialize_shield_wall(openingDirection?)`

Initialise les réserves directionnelles et les effets visuels sauf si un mur est déjà actif. Chaque direction protégée commence avec une santé égale au niveau du boss. L'argument choisit l'ouverture non protégée, pas un nombre de charges. La méthode Lua renvoie nil et n'installe pas de gestionnaire d'événement de dégâts.

Paramètre	Type	Défaut	Notes
`openingDirection`	number	`1`	`1` = nord, `2` = est, `3` = sud, `4` = ouest ; les autres entiers protègent les quatre côtés

`boss:shield_wall_absorb_damage(player, damage)`

Vérifie la position de l'attaquant par rapport au boss et soustrait les dégâts de la réserve de cette direction. Renvoie true si la réserve était positive avant soustraction, même si le coup dépasse le montant restant. Renvoie false si le joueur ou l'état manque, si le monde diffère ou si la direction est ouverte ou épuisée. N'annule pas l'événement de dégâts. Si le retour vaut true, votre hook doit appeler context.event.cancel_event() pour bloquer le coup. Fournissez des dégâts non négatifs.

Paramètre	Type	Notes
`player`	wrapper de joueur	Le joueur attaquant
`damage`	number	Quantité de dégâts à absorber

`boss:deactivate_shield_wall()`

Arrête la tâche visuelle indépendante du mur et retire son état ainsi que ses porte-armures. Fermer l'instance Lua n'appelle pas cette méthode ; désactivez explicitement le mur à la fin de la mécanique.

`boss:start_zombie_necronomicon(target, chant)`

Démarre le contrôleur Necronomicon avec une cible vivante et un chant défilant. Le second argument est du texte affiché, pas un fichier de boss. Il invoque les fichiers fixes necronomicon_zombie.yml avec 80 % de probabilité et necronomicon_skeleton.yml avec 20 %, au niveau du lanceur, un toutes les 60 ticks. Une nouvelle activation nécessite au plus neuf renforts suivis et aucun contrôleur actif. Le contrôleur en cours remplit le groupe jusqu'à onze, active l'IA lorsqu'il est plein et reprend l'invocation quand ce nombre baisse.

L'invocation désactive l'IA du boss et change son nom affiché ; les avertissements visuels respectent le réglage des effets d'avertissement. La cible doit rester valide, dans le même monde et à moins de 30 blocs. Un contexte invalide ou le retrait du propriétaire arrête les contrôleurs, restaure la présentation et supprime leurs renforts. Ce sont des tâches Bukkit indépendantes ; fermer Lua seul ne les arrête pas. La méthode renvoie nil.

Paramètre	Type	Notes
`target`	wrapper d'entité	Entité cible pour le nécronomicon
`chant`	string	Texte défilant ; un texte vide utilise le nom du boss et un texte court est complété

`context.players`

Helpers de requête de joueur centrés sur le boss. Utilisez-les pour trouver des joueurs sans avoir besoin d'un joueur spécifique issu de l'événement.

Ces requêtes ne filtrent ni le mode de jeu, ni la ligne de vue, ni l'état vivant, ni la participation au combat ou à une instance, et ne trient pas par distance. current_target() privilégie l'acteur de l'événement, contrairement à la priorité de la cible directe de context.player. Un contexte planifié neuf n'a pas d'acteur d'événement et utilise donc la cible actuelle du mob.

Méthode	Renvoie	Notes
`players:current_target()`	wrapper de joueur ou `nil`	Le joueur de l'événement ou la cible du mob boss s'il s'agit d'un joueur
`players:nearby_players(radius)`	tableau de wrappers de joueur	Tous les joueurs dans le rayon du boss
`players:all_players_in_world()`	tableau de wrappers de joueur	Tous les joueurs dans le monde du boss

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local nearby = context.players:nearby_players(20)
    for _, player in ipairs(nearby) do
      player:send_message("&cThe boss is enraged!")
      player:apply_potion_effect("GLOWING", 60, 0)
    end
  end
}

Exemple

return {
  api_version = 1,
  on_spawn = function(context)
    -- Warn everyone in the world
    local everyone = context.players:all_players_in_world()
    for _, p in ipairs(everyone) do
      p:show_title("&4WARNING", "&7A world boss has spawned!", 10, 60, 20)
    end
  end
}

`context.entities`

Helpers généraux de requête d'entité centrés sur le boss.

Méthode	Renvoie	Notes
`entities:get_nearby_entities(radius[, filter])`	tableau de wrappers d'entité	Entités à proximité autour du boss
`entities:get_entities_in_box(center, halfX, halfY, halfZ[, filter])`	tableau de wrappers d'entité	Entités vivantes dont les pieds sont dans les limites inclusives de la boîte, dans le monde du centre ; ce n'est pas un test de chevauchement des boîtes englobantes
`entities:get_all_entities([filter])`	tableau de wrappers d'entité	Toutes les entités correspondantes dans le monde du boss
`entities:get_direct_target_entity()`	wrapper d'entité ou `nil`	Cible directe pour l'événement actuel
`entities:get_boss_spawn_location()`	location table	L'emplacement d'apparition d'origine du boss

Filtres valides : living (par défaut), player / players, elite / elites, mob / mobs, all / entities

Seul get_nearby_entities respecte all / entities. Il inclut des entités non vivantes telles que les objets au sol et les projectiles, renvoyées comme wrappers de référence plus légers. Les résultats vivants conservent leurs wrappers complets. Ce filtre cherche dans une boîte alignée sur les axes, avec le rayon fourni sur chaque axe ; les filtres vivants utilisent la distance sphérique. Les autres méthodes font retomber all / entities sur living. Le boss est exclu de tous les résultats.

Les filtres ignorent la casse ; les filtres inconnus utilisent aussi living. mob désigne toute entité vivante autre qu'un joueur, pas uniquement les monstres hostiles. Ces requêtes n'ajoutent ni filtre de participants d'instance, ni limite de résultats, ni tri par distance. Les requêtes larges parcourent les entités vivantes chargées du monde ; utilisez un rayon borné et évitez les parcours répétés inutiles. get_direct_target_entity() utilise la cible directe de l'événement et peut être nil ; il ne se rabat pas sur la cible de combat actuelle du mob.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Damage all nearby elites
    local elites = context.entities:get_nearby_entities(10, "elites")
    for _, elite in ipairs(elites) do
      elite:deal_damage(5)
    end
  end
}

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Find players in a box area
    local center = context.boss:get_location()
    local players = context.entities:get_entities_in_box(center, 10, 5, 10, "players")
    for _, p in ipairs(players) do
      p:send_message("&eYou are in the danger zone!")
    end
  end
}

Étapes suivantes

Wrappers d'entité
Champs d'entité communs
Méthodes d'entité communes
Wrappers de référence d'entité non vivante
context.player
- Champs réservés aux joueurs
- Méthodes réservées aux joueurs
context.boss
context.players
context.entities
Étapes suivantes

Wrappers d'entité​

Champs d'entité communs​

Méthodes d'entité communes​

entity:is_alive()​

entity:get_location()​

entity:get_eye_location()​

entity:get_health() / entity:get_maximum_health()​

entity:get_velocity()​

entity:send_message(text)​

entity:show_action_bar(message)​

entity:show_title(title[, subtitle][, fadeIn][, stay][, fadeOut])​

entity:show_boss_bar(title[, color][, style][, duration])​

entity:teleport_to_location(location)​

entity:set_velocity_vector(vector)​

entity:apply_push_vector(vector[, additive][, delay])​

entity:face_direction_or_location(directionOrLocation)​

entity:set_fire_ticks(ticks)​

entity:add_visual_freeze_ticks([ticks])​

entity:apply_potion_effect(effect, duration[, amplifier])​

entity:deal_damage(amount) / entity:deal_custom_damage(amount) / entity:deal_damage_from_boss(amount)​

entity:restore_health(amount)​

entity:set_invulnerable(enabled[, duration])​

entity:set_ai_enabled(enabled[, duration])​

entity:add_tag(tag[, duration]) / entity:remove_tag(tag) / entity:has_tag(tag)​

entity:run_command(command)​

entity:set_scale(scale[, duration])​

entity:set_gravity(enabled)​

entity:play_sound_at_entity(sound[, volume][, pitch])​

entity:play_sound_at_self(sound[, volume][, pitch])​

entity:spawn_particle_at_self(particleOrSpec[, count])​

entity:spawn_particles_at_location(location, particle[, count])​

entity:play_model_animation(name)​

Méthodes de véhicule et de passager​

entity:push_relative_to(source[, strength][, xOffset][, yOffset][, zOffset])​

entity:set_custom_name(name) / entity:reset_custom_name()​

entity:place_temporary_block(material[, duration][, requireAir])​

entity:get_height()​

entity:is_on_ground()​

entity.is_valid​

entity:is_frozen()​

entity:set_awareness_enabled(aware[, duration])​

entity:is_healing() / entity:set_healing(enabled)​

entity:overlaps_box_at_location(center[, halfX][, halfY][, halfZ])​

entity:remove_elite()​

entity:remove()​

entity:set_invisible(enabled) et entity:set_silent(enabled)​

entity:set_marker(enabled)​

entity:set_custom_name_visible(visible)​

entity:set_equipment(slot, material[, options])​

entity:damage_equipment(slot, amount)​

entity:is_ai_enabled()​

Wrappers de référence d'entité non vivante​

context.player​

Champs réservés aux joueurs​

Méthodes réservées aux joueurs​

context.boss​

Champs du boss​

Méthodes du boss​

Méthodes de déplacement de patrouille​

boss:is_alive()​

boss:get_location()​

boss:get_eye_location()​

boss:set_ai_enabled(enabled[, duration])​

boss:teleport_to_location(location)​

boss:set_velocity_vector(vector)​

boss:restore_health(amount)​

boss:play_sound_at_self(sound[, volume][, pitch])​

boss:spawn_particle_at_self(particleOrSpec[, count])​

boss:play_model_animation(name)​

boss:has_mount() / boss:get_mount()​

boss:set_mount(entity) / boss:clear_mount() / boss:dismount()​

boss:face_direction_or_location(vectorOrLocation)​

boss:navigate_to_location(location[, speed][, forceTeleport][, timeout])​

boss:add_tag(tag[, duration]) / boss:remove_tag(tag) / boss:has_tag(tag)​

boss:send_message(message[, range])​

boss:summon_projectile(entityType, origin, destination[, speed][, options])​

boss:summon_reinforcement(filename[, zoneOrLocation][, duration])​

boss:despawn()​

boss:get_nearby_players(range)​

boss:get_damager_count()​

Wrappers d'entité

Champs d'entité communs

Méthodes d'entité communes

`entity:is_alive()`

`entity:get_location()`

`entity:get_eye_location()`

`entity:get_health()` / `entity:get_maximum_health()`

`entity:get_velocity()`

`entity:send_message(text)`

`entity:show_action_bar(message)`

`entity:show_title(title[, subtitle][, fadeIn][, stay][, fadeOut])`

`entity:show_boss_bar(title[, color][, style][, duration])`

`entity:teleport_to_location(location)`

`entity:set_velocity_vector(vector)`

`entity:apply_push_vector(vector[, additive][, delay])`

`entity:face_direction_or_location(directionOrLocation)`

`entity:set_fire_ticks(ticks)`

`entity:add_visual_freeze_ticks([ticks])`

`entity:apply_potion_effect(effect, duration[, amplifier])`

`entity:deal_damage(amount)` / `entity:deal_custom_damage(amount)` / `entity:deal_damage_from_boss(amount)`

`entity:restore_health(amount)`

`entity:set_invulnerable(enabled[, duration])`

`entity:set_ai_enabled(enabled[, duration])`

`entity:add_tag(tag[, duration])` / `entity:remove_tag(tag)` / `entity:has_tag(tag)`

`entity:run_command(command)`

`entity:set_scale(scale[, duration])`

`entity:set_gravity(enabled)`

`entity:play_sound_at_entity(sound[, volume][, pitch])`

`entity:play_sound_at_self(sound[, volume][, pitch])`

`entity:spawn_particle_at_self(particleOrSpec[, count])`

`entity:spawn_particles_at_location(location, particle[, count])`

`entity:play_model_animation(name)`

Méthodes de véhicule et de passager

`entity:push_relative_to(source[, strength][, xOffset][, yOffset][, zOffset])`

`entity:set_custom_name(name)` / `entity:reset_custom_name()`

`entity:place_temporary_block(material[, duration][, requireAir])`

`entity:get_height()`

`entity:is_on_ground()`

`entity.is_valid`

`entity:is_frozen()`

`entity:set_awareness_enabled(aware[, duration])`

`entity:is_healing()` / `entity:set_healing(enabled)`

`entity:overlaps_box_at_location(center[, halfX][, halfY][, halfZ])`

`entity:remove_elite()`

`entity:remove()`

`entity:set_invisible(enabled)` et `entity:set_silent(enabled)`

`entity:set_marker(enabled)`

`entity:set_custom_name_visible(visible)`

`entity:set_equipment(slot, material[, options])`

`entity:damage_equipment(slot, amount)`

`entity:is_ai_enabled()`

Wrappers de référence d'entité non vivante

`context.player`

Champs réservés aux joueurs

Méthodes réservées aux joueurs

`context.boss`

Champs du boss

Méthodes du boss

Méthodes de déplacement de patrouille

`boss:is_alive()`

`boss:get_location()`

`boss:get_eye_location()`

`boss:set_ai_enabled(enabled[, duration])`

`boss:teleport_to_location(location)`

`boss:set_velocity_vector(vector)`

`boss:restore_health(amount)`

`boss:play_sound_at_self(sound[, volume][, pitch])`

`boss:spawn_particle_at_self(particleOrSpec[, count])`

`boss:play_model_animation(name)`

`boss:has_mount()` / `boss:get_mount()`

`boss:set_mount(entity)` / `boss:clear_mount()` / `boss:dismount()`

`boss:face_direction_or_location(vectorOrLocation)`

`boss:navigate_to_location(location[, speed][, forceTeleport][, timeout])`

`boss:add_tag(tag[, duration])` / `boss:remove_tag(tag)` / `boss:has_tag(tag)`

`boss:send_message(message[, range])`

`boss:summon_projectile(entityType, origin, destination[, speed][, options])`

`boss:summon_reinforcement(filename[, zoneOrLocation][, duration])`

`boss:despawn()`

`boss:get_nearby_players(range)`

`boss:get_damager_count()`