Scripting Lua : monde et environnement

Cette page présente les extensions de boss EliteMobs de context.world, ainsi que context.vectors, context.settings et context.event. Elles permettent de créer des entités, produire des effets, consulter des blocs et modifier le monde. Pour commencer, consultez les premiers pas.

Contexte de boss EliteMobs

Les pouvoirs de boss réutilisent le bac à sable Lua de MagmaCore. Leur context.world part de la table partagée : get_block_at(...), set_block_at(...) et spawn_particle(...) restent disponibles. Cette page décrit les ajouts et redéfinitions propres aux boss. Pour l'API générique, consultez le moteur de scripts Lua de MagmaCore.

Lorsqu'un même nom existe dans les deux tables, la version EliteMobs prévaut. Les méthodes ci-dessous conservent ses règles : contournement des annulations d'apparition de foudre, spécifications de particules enrichies et suivi des blocs temporaires. Les autres méthodes partagées restent disponibles, notamment get_entity(uuid), block_is_passable(x, y, z), location_is_protected(location), spawn_dust(...) et raycast(...). Consultez leurs arguments et règles pour les chunks déchargés dans la référence de l'API partagée ; ces garanties ne s'appliquent pas automatiquement aux redéfinitions EliteMobs.

Les fonctions de butin de FreeMinecraftModels ne sont pas disponibles ici

FreeMinecraftModels ajoute drop_elitemobs_procedural_loot, drop_elitemobs_random_loot, drop_elitemobs_custom_loot et start_elitemobs_transport au context.world de ses propres scripts de props uniquement. Chaque plugin embarque sa propre copie de la bibliothèque de scripting partagée : ces fonctions n'apparaissent donc ni dans les pouvoirs de boss EliteMobs ni dans les scripts de PNJ, même lorsque FreeMinecraftModels est installé. Les pouvoirs de boss utilisent plutôt generate_player_loot et drop_bonus_coins.

`context.world`

La table de monde permet de créer des entités, produire des effets et modifier le monde. Ses méthodes acceptent les deux-points (world:method()) ou le point sans argument self explicite.

Les redéfinitions de boss ci-dessous convertissent une table contenant x, y, z, éventuellement yaw/pitch, et un nom de monde chargé dans world. Les coordonnées absentes valent 0 ; omettre le monde utilise celui du boss, mais un nom explicite inconnu fait échouer la conversion. Une table imbriquée current_location est aussi acceptée. Une position nil ou non tabulaire utilise celle du boss. Les méthodes partagées conservent leur propre contrat de position et le monde capturé à la création de la table.

Fermer l'instance Lua n'annule pas automatiquement les modifications du monde et ne supprime pas les entités créées. Les moniteurs du script s'arrêtent, mais les temporisateurs indépendants de suppression, la régénération d'explosions, la foudre renforcée et les projectiles d'or ont leurs propres durées de vie. Les redéfinitions de blocs et d'apparition n'appliquent automatiquement ni location_is_protected ni les contrôles partagés de chunks chargés ; vérifiez les contraintes nécessaires avant de modifier le monde.

`world:spawn_particle_at_location(location, particleSpec)`

Crée des particules à une position. Le deuxième argument accepte un nom ou une table de spécification. Un troisième entier facultatif fournit la quantité en l'absence de amount ; il vaut 1 par défaut. Les noms sont convertis en majuscules avant recherche. Un nom invalide ou des données non prises en charge produisent un avertissement et aucune particule.

Paramètre	Type	Remarques
`location`	table location	Où faire apparaître les particules
`particleSpec`	chaîne ou table	Nom de particule ou table de spécification de particule (voir ci-dessous)

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Simple particle by name
    context.world:spawn_particle_at_location(context.boss:get_location(), "FLAME")

    -- Full particle spec table with red dust
    context.world:spawn_particle_at_location(context.boss:get_location(), {
      particle = "DUST",
      amount = 10,
      x = 0.5,
      y = 0.5,
      z = 0.5,
      speed = 0.02,
      red = 255,
      green = 0,
      blue = 0,
    })
  end
}

Format de la table de spécification de particule

Clé	Type	Défaut	Remarques
`particle`	chaîne	obligatoire	Nom de particule
`amount`	int	1	Nombre de particules
`x`, `y`, `z`	nombre	0	Dispersion/décalage sur chaque axe
`speed`	nombre	0	Vitesse des particules
`red`, `green`, `blue`	int	255	Couleur RVB pour `DUST` et `DUST_COLOR_TRANSITION`
`toRed`, `toGreen`, `toBlue`	int	255	Couleur cible de transition pour `DUST_COLOR_TRANSITION`

astuce

Pour DUST_COLOR_TRANSITION, to_red, to_green, to_blue sont également acceptés ; les clés camelCase ont priorité. Les deux types de poussière ont une taille fixe de 1, avec des composantes RVB dans 0..255. Les autres particules ne reçoivent aucune donnée supplémentaire : celles qui en exigent ne sont donc pas toutes prises en charge.

attention

Contrairement aux configurations YAML d'EliteScript, les noms de particules Lua ne prennent pas en charge les conversions d'anciens noms de particules. Vous devez utiliser les noms actuels de l'API Spigot (par ex. FIREWORK et non FIREWORKS_SPARK, SMOKE et non SMOKE_NORMAL, DUST et non REDSTONE). Consultez la liste des particules valides pour la liste complète des noms actuels et de leurs équivalents historiques.

`world:play_sound_at_location(location, sound, volume, pitch)`

Joue un son à un emplacement.

Paramètre	Type	Défaut	Remarques
`location`	table location		Où jouer le son
`sound`	chaîne		Clé de son Minecraft (par ex. `"entity.blaze.shoot"`) ou nom d'énumération Spigot `Sound`. Les clés de resource pack fonctionnent aussi.
`volume`	nombre	`1.0`	Volume
`pitch`	nombre	`1.0`	Hauteur du son

Exemple

return {
  api_version = 1,
  on_spawn = function(context)
    context.world:play_sound_at_location(
      context.boss:get_location(),
      "entity.wither.spawn",
      1.0,
      0.5
    )
  end
}

`world:strike_lightning_at_location(location)`

Fait tomber une vraie foudre infligeant des dégâts et active le contournement EliteMobs des annulations d'apparition de foudre. Ce n'est pas la fonction partagée purement visuelle ; cela ne garantit pas non plus que toutes les règles de dégâts ou de protection des autres plugins soient ignorées.

Paramètre	Type	Remarques
`location`	table location	Où frapper

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("lightning", 100) then return end
    context.world:strike_lightning_at_location(context.player:get_location())
    context.player:send_message("&eA bolt of lightning strikes you!")
  end
}

`world:spawn_entity_at_location(entityType, location, options)`

Crée directement une entité vanilla dans le monde indiqué. Un nom inconnu renvoie nil ; un type reconnu mais impossible à créer peut encore provoquer une erreur. Aucun tireur n'est automatiquement attribué aux projectiles, et l'entité n'est pas enregistrée comme renfort élite.

Paramètre	Type	Remarques
`entityType`	chaîne	Nom de type d'entité (par ex. `"FIREBALL"`, `"ARROW"`)
`location`	table location	Où la faire apparaître
`options`	table (facultatif)	Options d'apparition (voir ci-dessous)

Options d'apparition d'entité

Clé	Type	Défaut	Remarques
`velocity`	table vector	`nil`	Vélocité initiale `{x, y, z}`
`effect`	chaîne	`nil`	EntityEffect à jouer à l'apparition
`duration`	int	`0`	Une valeur positive programme la suppression après ces ticks ; sinon aucun temporisateur n'est ajouté
`on_land`	fonction	`nil`	`function(land_location, entity_ref)` au sol, à l'invalidation ou après `max_ticks` ; ni événement d'impact ni preuve d'atterrissage
`max_ticks`	int	`6000`	Nombre maximal de ticks de surveillance avant de forcer le rappel `on_land`
`persistent`	booléen	valeur par défaut de Minecraft	`false` garde l'entité hors de la sauvegarde du chunk : un arrêt du serveur ou un déchargement de chunk en plein effet ne peut donc pas la laisser dans le monde

Renvoie une table d'entité. Les entités non vivantes (FIREBALL, ARROW, TNT, ...) utilisent une référence non vivante, où is_valid() est une méthode. Les entités vivantes (ZOMBIE, GIANT, ...) utilisent une table d'entité vivante, où is_valid est un champ booléen ; appeler entity:is_valid() provoque attempt to call a boolean value.

Le moniteur vérifie l'entité chaque tick tant que le script est actif et s'arrête avec ses tâches. Le temporisateur positif de duration est indépendant et peut supprimer l'entité après la fermeture du script. Les noms effect inconnus sont ignorés.

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_spawn", 100) then return end
    -- Spawn a fireball aimed at the player
    local boss_loc = context.boss:get_location()
    local dir = context.vectors.get_vector_between_locations(boss_loc, context.player:get_location())
    dir = context.vectors.normalize_vector(dir)

    context.world:spawn_entity_at_location("FIREBALL", boss_loc, {
      velocity = { x = dir.x * 2, y = dir.y * 2, z = dir.z * 2 },
      duration = 100,
    })
  end
}

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Spawn a primed TNT with a landing callback
    context.world:spawn_entity_at_location("TNT", context.boss:get_location(), {
      velocity = { x = 0, y = 1.5, z = 0 },
      on_land = function(land_location, entity_ref)
        context.world:spawn_particle_at_location(land_location, {
          particle = "EXPLOSION_EMITTER",
          amount = 1,
        })
      end,
    })
  end
}

`world:spawn_display_at_location(location, options)`

Fait apparaître un item display ou un block display : un visuel flottant sans hitbox, sans gravité et sans IA. Utilisez-le pour des pierres en orbite, des accessoires lancés et d'autres effets qui n'ont besoin que d'être vus, plutôt que de styliser un porte-armure. L'affichage est centré sur location et orienté selon son yaw.

Option	Type	Défaut	Remarques
`item`	chaîne		Matériau affiché comme objet. Un objet de bloc tel que `"AMETHYST_BLOCK"` s'affiche comme un bloc centré
`block`	chaîne		Bloc affiché comme block display, sous forme de matériau ou de données de bloc telles que `"lantern[hanging=true]"`
`scale`	nombre ou table vector	`1`	Un nombre met tous les axes à l'échelle ; `{x, y, z}` règle chaque axe. À `1`, un bloc mesure un bloc de large
`duration`	int	`0`	Une valeur positive supprime l'affichage après ce nombre de ticks
`teleport_duration`	int	`0`	Nombre de ticks que le client met à glisser vers chaque nouvel emplacement, de `0` à `59`. Utilisez `1` si vous téléportez l'affichage à chaque tick
`billboard`	chaîne	`FIXED`	`FIXED`, `VERTICAL`, `HORIZONTAL` ou `CENTER`
`glowing`	booléen	`false`	Halo lumineux de contour
`brightness`	int	lumière du monde	De `0` à `15`, remplace la lumière à l'emplacement de l'affichage
`bedrock_fallback`	booléen	`true`	Voir ci-dessous

Indiquez exactement un seul des deux champs item ou block. Un item ou block absent ou inconnu, les deux à la fois, ou un scale qui n'est pas positif renvoie nil et consigne un avertissement qui nomme le pouvoir. Une valeur billboard inconnue conserve FIXED.

Les affichages ne sont jamais sauvegardés avec le chunk. Ils sont supprimés lorsque duration expire, lorsque vous appelez remove() ou lorsque le pouvoir s'arrête, selon ce qui survient en premier.

Les clients Bedrock ne peuvent pas afficher les entités display. Les joueurs Bedrock présents dans le monde au moment où l'affichage apparaît voient à la place un porte-armure invisible qui porte le même objet, ou l'objet du bloc pour un block display, et l'affichage leur est masqué. Le porte-armure suit l'affichage et est supprimé avec lui. Les joueurs Bedrock qui entrent dans le monde plus tard n'obtiennent aucun porte-armure, et un bloc sans forme d'objet, comme fire, n'en obtient aucun non plus. Désactivez ce comportement avec bedrock_fallback = false pour les effets que les joueurs Bedrock n'ont pas besoin de voir.

Le wrapper renvoyé possède uuid et entity_type, ainsi que ces méthodes :

Méthode	Remarques
`is_valid()`, `is_alive()`	Indique si l'affichage existe toujours
`get_location()`	Emplacement actuel
`teleport_to_location(location)`	Déplace l'affichage, et son porte-armure Bedrock
`remove()`	Supprime l'affichage et son porte-armure Bedrock
`set_scale(scale)`	Mêmes valeurs que l'option `scale`
`set_item(material)`	Item displays uniquement ; renvoie `false` sinon
`set_block(block)`	Block displays uniquement ; renvoie `false` sinon
`set_glowing(enabled)`	Halo lumineux de contour
`set_brightness(level)`	De `0` à `15`, ou `nil` pour utiliser de nouveau la lumière du monde
`set_teleport_duration(ticks)`	Identique à l'option `teleport_duration`

Exemple

-- Three amethyst stones circle the target for three seconds.
return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil or not context.cooldowns:check_local("orbit", 200) then return end
    local target = context.player
    local stones = {}
    for i = 1, 3 do
      stones[i] = context.world:spawn_display_at_location(target:get_location(), {
        item = "AMETHYST_BLOCK", scale = 0.3, duration = 60, teleport_duration = 1
      })
    end
    local elapsed = 0
    local task
    task = context.scheduler:run_every(1, function(context)
      elapsed = elapsed + 1
      if elapsed >= 60 then
        context.scheduler:cancel_task(task)
        return
      end
      local center = target:get_location()
      for i = 1, 3 do
        local angle = elapsed * 0.2 + i * (2 * math.pi / 3)
        if stones[i] ~= nil and stones[i]:is_valid() then
          stones[i]:teleport_to_location(em.create_location(
            center.x + math.cos(angle) * 1.5, center.y + 1.2, center.z + math.sin(angle) * 1.5, center.world, 0, 0))
        end
      end
    end)
  end
}

`world:spawn_falling_block_at_location(location, material, options)`

Crée un bloc tombant à partir d'un matériau de bloc. Avec on_land, EliteMobs intercepte son changement de bloc, annule la pose et appelle une fois function(land_location, entity_ref). Sans rappel, la pose normale reste possible. Il n'existe ici ni option duration/max_ticks, ni rappel d'invalidation ou d'expiration.

Paramètre	Type	Remarques
`location`	table location	Où la faire apparaître
`material`	chaîne	Nom de matériau (par ex. `"STONE"`, `"MAGMA_BLOCK"`)
`options`	table (facultatif)	Options d'apparition (voir ci-dessous)

Options de bloc tombant

Clé	Type	Défaut	Remarques
`velocity`	table vector	`nil`	Vélocité initiale `{x, y, z}`
`drop_item`	booléen	`false`	Indique si le bloc tombe sous forme d'objet
`hurt_entities`	booléen	`false`	Indique si le bloc blesse les entités sur lesquelles il atterrit
`on_land`	fonction	`nil`	Rappel `function(land_location, entity_ref)` lorsque le bloc atterrit

Renvoie une référence d'entité non vivante, ou nil si la position ou le matériau ne sont pas résolus. Un matériau reconnu qui n'est pas un bloc peut échouer lors de la création des données de bloc.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Rain magma blocks from above
    local loc = context.boss:get_location()
    for i = 1, 5 do
      local offset_loc = {
        x = loc.x + math.random(-3, 3),
        y = loc.y + 10,
        z = loc.z + math.random(-3, 3),
        world = loc.world
      }
      context.world:spawn_falling_block_at_location(offset_loc, "MAGMA_BLOCK", {
        velocity = { x = 0, y = -0.5, z = 0 },
        hurt_entities = true,
        on_land = function(land_location, entity_ref)
          context.world:spawn_particle_at_location(land_location, { particle = "LAVA", amount = 8 })
        end,
      })
    end
  end
}

`world:spawn_custom_boss_at_location(filename, location, options)`

Fait apparaître un custom boss EliteMobs à partir d'un fichier de configuration.

Paramètre	Type	Remarques
`filename`	chaîne	Nom du fichier de configuration du boss (par ex. `"my_boss.yml"`)
`location`	table location	Où le faire apparaître
`options`	table (facultatif)	Options d'apparition (voir ci-dessous)

Options d'apparition de boss personnalisé

Clé	Type	Défaut	Remarques
`level`	int	niveau configuré du boss créé	Remplace son niveau. Sinon, sa propre configuration et ses règles de niveau dynamique s'appliquent ; il n'hérite pas du niveau du boss créateur.
`silent`	booléen	`false`	Supprime les messages d'apparition
`velocity`	table vector	`nil`	Vélocité initiale
`add_as_reinforcement`	booléen	`false`	Enregistre l'entité comme renfort du boss actuel

Renvoie une table d'encapsulation d'entité, ou nil si le boss n'a pas pu être créé.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local minion = context.world:spawn_custom_boss_at_location(
      "skeleton_minion.yml",
      context.boss:get_location(),
      { level = 10, add_as_reinforcement = true }
    )
    if minion ~= nil then
      context.boss:send_message("&cMinions, arise!")
    end
  end
}

`world:spawn_boss_at_location(filename, location, level)`

Méthode simplifiée : la position et le niveau omis utilisent ceux du boss créateur. Le résultat n'est pas enregistré comme renfort. Omettez le troisième argument pour utiliser son défaut ; un nil explicite à cette position n'est pas accepté.

Paramètre	Type	Défaut	Remarques
`filename`	chaîne		Nom du fichier de configuration du boss
`location`	table location	emplacement du boss	Où le faire apparaître (facultatif, correspond par défaut à l'emplacement du boss)
`level`	int	niveau du boss	Remplace le niveau d'apparition (facultatif)

Renvoie une table d'encapsulation d'entité, ou nil.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.world:spawn_boss_at_location("zombie_guard.yml", context.boss:get_location(), 5)
    context.boss:send_message("&cGuards, defend me!")
  end
}

`world:spawn_reinforcement_at_location(filename, location, duration, velocity)`

Crée silencieusement un renfort, enregistre son invocateur et hérite du combat normalisé si le boss personnalisé invocateur l'utilise. Sa propre configuration et ses règles de niveau dynamique déterminent son niveau ; duration règle le délai de fuite, pas le niveau.

Paramètre	Type	Défaut	Remarques
`filename`	chaîne		Nom du fichier de configuration du boss
`location`	table location		Où le faire apparaître
`duration`	int	`0`	Délai de fuite en ticks ; `0` n'ajoute aucun temporisateur. Cet argument ne remplace pas le niveau.
`velocity`	table vector	`nil`	Vélocité initiale (facultatif)

Renvoie une table d'encapsulation d'entité, ou nil.

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.world:spawn_reinforcement_at_location(
      "necro_skeleton.yml",
      context.boss:get_location(),
      0,
      { x = 0, y = 0.5, z = 0 }
    )
    context.boss:send_message("&5Rise, my servant!")
  end
}

`world:spawn_fireworks_at_location(location, spec)`

Crée un vrai feu d'artifice sans suppression automatique de ses dégâts. Fournissez au moins une couleur valide par effet ; construire un effet sans couleur peut échouer.

Paramètre	Type	Remarques
`location`	table location	Où le faire apparaître
`spec`	table	Spécification du feu d'artifice (voir ci-dessous)

Table de spécification de feu d'artifice

Clé	Type	Défaut	Remarques
`power`	int	`1`	Puissance de vol (hauteur)
`velocity`	table vector	`nil`	Vélocité initiale
`shot_at_angle`	booléen	`true`	Indique si le feu d'artifice est tiré en biais (utilisé lorsque velocity est défini)
`effects`	table de tables	`nil`	Tableau de spécifications d'effets de feu d'artifice. S'il est omis, la spécification de premier niveau est traitée comme un effet unique.

Spécification d'effet de feu d'artifice

Clé	Type	Défaut	Remarques
`type`	chaîne	`"BALL_LARGE"`	`"BALL"`, `"BALL_LARGE"`, `"STAR"`, `"BURST"`, `"CREEPER"`
`flicker`	booléen	`true`	Effet de scintillement
`trail`	booléen	`true`	Effet de traînée
`colors`	table	obligatoire par effet	Tableau non vide de noms de couleurs ou de tables `{red = 255, green = 0, blue = 0}`
`fade_colors`	table	`nil`	Tableau de noms de couleurs de fondu ou de tables `{red, green, blue}`

Noms de couleurs : "WHITE", "SILVER", "GRAY", "BLACK", "RED", "MAROON", "YELLOW", "OLIVE", "LIME", "GREEN", "AQUA", "TEAL", "BLUE", "NAVY", "FUCHSIA", "PURPLE", "ORANGE"

Renvoie une référence d'entité non vivante, ou nil si la position n'est pas résolue. :detonate() demande la détonation. Les noms de types et de couleurs ignorent la casse ; un type inconnu utilise BALL_LARGE, une couleur inconnue utilise le blanc. Les composantes RVB doivent être dans 0..255.

Exemple

return {
  api_version = 1,
  on_spawn = function(context)
    local fw = context.world:spawn_fireworks_at_location(context.boss:get_location(), {
      power = 0,
      effects = {
        {
          type = "STAR",
          flicker = true,
          trail = true,
          colors = { "RED", "ORANGE", { red = 255, green = 200, blue = 0 } },
          fade_colors = { "YELLOW" },
        },
      },
    })

    if fw == nil then return end
    -- Detonate on the next tick for a visual burst
    context.scheduler:run_after(1, function()
      fw:detonate()
    end)
  end
}

`world:spawn_splash_potion_at_location(location, spec)`

Crée une vraie potion jetable. Les effets Bukkit inconnus sont signalés puis ignorés. Cette fonction n'attribue pas de tireur et n'applique pas le filtre d'effets d'instance des méthodes directes de potion du boss ; les règles normales des potions jetables s'appliquent.

Paramètre	Type	Remarques
`location`	table location	Où la faire apparaître
`spec`	table	Spécification de la potion (voir ci-dessous)

Table de spécification de potion jetable

Clé	Type	Remarques
`velocity`	table vector	Vélocité initiale de la potion lancée
`effects`	table de tables	Tableau de spécifications d'effets de potion

Spécification d'effet de potion

Clé	Type	Défaut	Remarques
`type`	chaîne	obligatoire	Nom de type d'effet de potion (par ex. `"SLOWNESS"`, `"POISON"`)
`duration`	int	`0`	Durée en ticks
`amplifier`	int	`0`	Amplificateur de l'effet (0 = niveau I)
`overwrite`	booléen	`true`	Remplace un effet précédent du même type dans les métadonnées de cette potion ; ne régit pas les effets déjà présents sur un joueur

Renvoie une table de référence d'entité, ou nil.

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("potion_throw", 200) then return end

    local dir = context.vectors.get_vector_between_locations(
      context.boss:get_location(),
      context.player:get_location()
    )
    dir = context.vectors.normalize_vector(dir)

    context.world:spawn_splash_potion_at_location(context.boss:get_location(), {
      velocity = { x = dir.x * 1.5, y = 0.5, z = dir.z * 1.5 },
      effects = {
        { type = "SLOWNESS", duration = 100, amplifier = 1 },
        { type = "WEAKNESS", duration = 60, amplifier = 0 },
      },
    })
  end
}

`world:place_temporary_block_at_location(location, material, duration, requireAir)`

Pose un bloc suivi dont les données précédentes sont restaurées après une durée positive. Les contenus de conteneurs ne sont pas sauvegardés. Le bloc d'origine revient à la fin du temporisateur, au déchargement du chunk ou du monde, ou à l'arrêt du plugin, mais uniquement si l'emplacement contient toujours le bloc temporaire : une modification ultérieure n'est donc pas écrasée. Poser de nouveau sur un bloc qui contient encore un bloc temporaire relance son temporisateur et conserve l'original sauvegardé en premier. Les blocs dotés d'une entité de bloc, comme les coffres et les pancartes, les chunks déchargés et les blocs détenus par un autre propriétaire de blocs temporaires sont ignorés. Casser un bloc suivi ne lâche rien et met fin au suivi sans restauration. Utilisez un matériau de bloc. Cette redéfinition renvoie nil, même si requireAir ou un cas ignoré empêche la pose ; elle ne confirme pas la réussite et ne vérifie pas automatiquement les protections régionales.

Paramètre	Type	Défaut	Remarques
`location`	table location		Où le placer
`material`	chaîne		Nom de matériau
`duration`	int	`0`	Ticks avant restauration ; zéro ou une valeur négative place le bloc de façon permanente, sans suivi
`requireAir`	booléen	`false`	Si `true`, ne place le bloc que si l'emplacement est actuellement de l'air

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Create a temporary ice floor under the boss
    local loc = context.boss:get_location()
    for dx = -2, 2 do
      for dz = -2, 2 do
        context.world:place_temporary_block_at_location(
          { x = loc.x + dx, y = loc.y - 1, z = loc.z + dz, world = loc.world },
          "PACKED_ICE",
          100,
          false
        )
      end
    end
  end
}

`world:set_block_at_location(location, material, requireAir)`

Pose un bloc de façon permanente via le gestionnaire de blocs temporaires, sans temporisateur de restauration ni suivi : la modification subsiste après l'arrêt du plugin. Si l'emplacement contient actuellement un bloc temporaire minuté, ce bloc cesse d'être suivi et n'est pas restauré. Les blocs détenus par un autre propriétaire de blocs temporaires restent inchangés. Utilisez une durée positive avec place_temporary_block_at_location pour restaurer l'original après un délai.

Paramètre	Type	Défaut	Remarques
`location`	table location		Où le placer
`material`	chaîne		Nom de matériau
`requireAir`	booléen	`false`	Si `true`, ne place le bloc que si l'emplacement est actuellement de l'air

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Place fire at the boss's location
    context.world:set_block_at_location(context.boss:get_location(), "FIRE", true)
  end
}

`world:get_block_type_at_location(location)`

Renvoie le nom du matériau en majuscules, ou nil si la position n'est pas résolue. Contrairement à la requête partagée par coordonnées, cette redéfinition accède directement au bloc sans vérifier que son chunk est chargé.

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local block_type = context.world:get_block_type_at_location(context.boss:get_location())
    if block_type == "WATER" then
      context.boss:send_message("&bThe boss is empowered by water!")
      context.boss:apply_potion_effect("SPEED", 200, 1)
    end
  end
}

`world:get_highest_block_y_at_location(location)`

Renvoie la coordonnée Y du bloc le plus haut selon Bukkit à la position X/Z, ou nil si la position n'est pas résolue. Ne vérifie ni que le chunk est déjà chargé ni que la destination convient à une téléportation sûre.

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger (X et Z sont utilisés)

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("skyport", 200) then return end
    local loc = context.player:get_location()
    local ground_y = context.world:get_highest_block_y_at_location(loc)
    -- Teleport the player to the surface
    context.player:teleport_to_location({
      x = loc.x, y = ground_y + 1, z = loc.z, world = loc.world
    })
    context.player:send_message("&eYou are teleported to the surface!")
  end
}

`world:get_blast_resistance_at_location(location)`

Renvoie la résistance aux explosions du matériau, ou 0 si la position n'est pas résolue.

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local resistance = context.world:get_blast_resistance_at_location(context.boss:get_location())
    context.log:info("Blast resistance at boss: " .. resistance)
  end
}

`world:is_air_at_location(location)`

Renvoie true si le bloc situé à cet emplacement est de l'air.

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local loc = context.boss:get_location()
    local above = { x = loc.x, y = loc.y + 2, z = loc.z, world = loc.world }
    if context.world:is_air_at_location(above) then
      -- There is space above the boss, launch upward
      context.boss:set_velocity_vector({ x = 0, y = 1.5, z = 0 })
    end
  end
}

`world:is_passable_at_location(location)`

Renvoie le résultat Bukkit de Block.isPassable(), ou false si la position n'est pas résolue. Cette requête porte sur un seul bloc ; elle ne vérifie pas si une entité entière peut y tenir ou y naviguer.

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    if context.world:is_passable_at_location(context.boss:get_location()) then
      context.log:info("Boss is in a passable block")
    end
  end
}

`world:is_passthrough_at_location(location)`

Renvoie true si le bloc situé à cet emplacement n'est pas solide (semblable à traversable, mais basé sur la vérification de solidité).

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local loc = context.boss:get_location()
    local above = { x = loc.x, y = loc.y + 1, z = loc.z, world = loc.world }
    if context.world:is_passthrough_at_location(above) then
      context.log:info("Boss can move upward")
    end
  end
}

`world:is_on_floor_at_location(location)`

Renvoie true si le bloc à la position n'est pas solide et celui une unité Y plus bas est solide. Ne vérifie ni le contact au sol d'une entité, ni sa boîte de collision, ni l'espace au-dessus de sa tête.

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    if context.world:is_on_floor_at_location(context.boss:get_location()) then
      context.boss:send_message("&aThe boss slams the ground!")
      context.world:spawn_particle_at_location(context.boss:get_location(), {
        particle = "CLOUD",
        amount = 30,
      })
    end
  end
}

`world:is_standing_on_material(location, material)`

Renvoie true si le bloc situé directement sous l'emplacement correspond au matériau donné.

Paramètre	Type	Remarques
`location`	table location	Emplacement à interroger
`material`	chaîne	Nom de matériau à vérifier

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    if context.world:is_standing_on_material(context.player:get_location(), "SOUL_SAND") then
      context.player:send_message("&8The soul sand saps your strength!")
      context.player:apply_potion_effect("SLOWNESS", 60, 2)
    end
  end
}

`world:set_world_time(time)` / `world:set_world_time(location, time)`

Change l'heure du monde entier. Une position facultative sélectionne le monde. L'heure précédente n'est pas restaurée à la fermeture du script.

Paramètre	Type	Remarques
`location`	table location (facultatif)	Quel monde affecter. Correspond par défaut au monde du boss.
`time`	int	Heure du monde en ticks (0 = aube, 6000 = midi, 13000 = nuit, 18000 = minuit)

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Set to midnight when combat starts
    context.world:set_world_time(18000)
    context.boss:send_message("&8Darkness falls...")
  end
}

`world:set_world_weather(weather, duration)` / `world:set_world_weather(location, weather, duration)`

Change la météo dans le monde du boss ou de la position facultative. Les noms ignorent la casse ; les inconnus produisent seulement un avertissement. RAIN/CLEAR règlent la durée météo, tandis que THUNDER règle la durée du tonnerre. Le monde entier est affecté et son état précédent n'est pas restauré à la fermeture du script.

Paramètre	Type	Défaut	Remarques
`location`	table location (facultatif)	monde du boss	Quel monde affecter
`weather`	chaîne		`"CLEAR"`, `"RAIN"` (ou `"PRECIPITATION"`), `"THUNDER"`
`duration`	int	`6000`	Durée de la météo en ticks

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Start a thunderstorm for 200 ticks
    context.world:set_world_weather("THUNDER", 200)
    context.boss:send_message("&eA storm gathers!")
  end
}

`world:generate_fake_explosion(blockLocations, sourceLocation)`

Supprime de vrais blocs et crée des débris de blocs tombants via la régénération d'explosions EliteMobs. Les débris peuvent infliger des dégâts : ce n'est pas un simple effet de particules inoffensif. doExplosionRegen doit être activé ; le drapeau WorldGuard de régénération est vérifié lorsqu'une position source est fournie. L'air, le feu, les liquides et les blocs temporaires suivis sont ignorés ; des blocs voisins dépendants peuvent être inclus. La restauration commence après 1200 ticks, à raison d'un bloc enregistré par tick. Gardez toutes les positions dans le monde du boss. Renvoie nil ; fermer le script n'annule pas l'opération.

Paramètre	Type	Remarques
`blockLocations`	table de tables location	Tableau des emplacements de blocs à « faire exploser »
`sourceLocation`	table location (facultatif)	Source de l'explosion pour les calculs directionnels

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    local loc = context.boss:get_location()
    local blocks = {}
    for dx = -1, 1 do
      for dz = -1, 1 do
        table.insert(blocks, { x = loc.x + dx, y = loc.y, z = loc.z + dz, world = loc.world })
      end
    end
    context.world:generate_fake_explosion(blocks, loc)
  end
}

`world:run_console_command(command)`

Exécute immédiatement une commande console en tant que serveur et renvoie nil, sans exposer sa réussite. Aucun marqueur de joueur ou de boss n'est remplacé automatiquement.

Les commandes vanilla signalent leur résultat et, avec la valeur par défaut broadcast-console-to-ops=true, le serveur affiche chaque résultat à tous les opérateurs en ligne. Les commandes exécutées souvent, comme data merge entity, kill ou damage, inondent leur chat. Utilisez plutôt les méthodes natives : spawn_display_at_location pour les visuels, les méthodes de porte-armure pour les porte-armures, entity:remove() pour supprimer ce qu'un script a fait apparaître, et entity:deal_custom_damage(amount) pour des dégâts exacts infligés par le boss.

Paramètre	Type	Remarques
`command`	chaîne	La commande à exécuter (sans le `/` initial)

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.world:run_console_command("say The boss has entered phase 2!")
  end
}

`world:run_empowered_lightning_task_at_location(location)`

Démarre une tâche Bukkit indépendante à la position capturée. Elle émet SOUL_FIRE_FLAME pendant 60 itérations, puis produit une vraie foudre avec contournement des annulations d'apparition et une boule de feu descendante de puissance explosive 5, marquée ender_dragon_empowered_lightning.yml. C'est une attaque infligeant des dégâts. Fermer ou suspendre Lua ne l'annule pas ; elle ne consulte pas non plus le réglage des effets d'avertissement.

Paramètre	Type	Remarques
`location`	table location	Où frapper

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    context.world:run_empowered_lightning_task_at_location(context.boss:get_location())
    context.boss:send_message("&eFeel the power of the storm!")
  end
}

`world:spawn_fake_gold_nugget_at_location(location, velocity, hasGravity)`

Crée une pépite d'or visuelle par paquets pour les joueurs proches ; joueurs et entonnoirs ne peuvent pas la ramasser. La création seule ne la déplace pas et n'inflige aucun dégât. Transmettez-la une fois à run_fake_gold_nugget_damage dans un groupe, ou supprimez-la explicitement.

Paramètre	Type	Défaut	Remarques
`location`	table location		Emplacement d'apparition
`velocity`	table vector		Vélocité initiale
`hasGravity`	booléen	`false`	Indique si le projectile est soumis à la gravité

Renvoie une table de faux projectile, ou nil si la position ou le vecteur ne sont pas résolus, avec get_location(), set_gravity(bool), remove() et is_removed().

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("nugget", 60) then return end

    local dir = context.vectors.get_vector_between_locations(
      context.boss:get_location(),
      context.player:get_location()
    )
    dir = context.vectors.normalize_vector(dir)

    local nugget = context.world:spawn_fake_gold_nugget_at_location(
      context.boss:get_location(),
      { x = dir.x, y = dir.y, z = dir.z }
    )
    if nugget ~= nil then
      context.world:run_fake_gold_nugget_damage({ nugget })
    end
  end
}

`world:run_fake_gold_nugget_damage(projectiles)`

Démarre une tâche Bukkit indépendante qui déplace et vérifie le groupe à chaque tick. Appelez-la une seule fois par groupe : chaque appel crée une tâche supplémentaire. Elle cherche les entités vivantes dans une boîte de demi-taille 0.5 à la nouvelle position, ignore le boss d'origine et les joueurs bloquant, puis soumet des dégâts personnalisés de 1 via la politique de dégâts du boss. Une collision peut supprimer le projectile même si les dégâts sont refusés. Le contact au sol et la limite de 100 ticks le suppriment aussi. La détection échantillonne des positions, sans rayon parcourant tout le trajet ; fermer ou suspendre Lua n'annule pas la tâche.

Paramètre	Type	Remarques
`projectiles`	table	Tableau de tables de faux projectiles issues de `spawn_fake_gold_nugget_at_location`

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    -- Keep this batch separate from later combat entries.
    local projectiles = {}
    local loc = context.boss:get_location()
    for i = 1, 5 do
      local angle = (i / 5) * math.pi * 2
      local nugget = context.world:spawn_fake_gold_nugget_at_location(
        loc,
        { x = math.cos(angle) * 0.5, y = 0.3, z = math.sin(angle) * 0.5 }
      )
      if nugget ~= nil then table.insert(projectiles, nugget) end
    end

    -- Start the batch once; the helper runs its own per-tick task.
    context.world:run_fake_gold_nugget_damage(projectiles)
    -- Remove any surviving projectiles after 3 seconds.
    context.scheduler:run_after(60, function()
      for _, projectile in ipairs(projectiles) do
        projectile:remove()
      end
    end)
  end
}

`world:generate_player_loot(times)`

Exécute le générateur normal de butin times fois ; une valeur non positive ne fait rien. Requiert eliteLoot, aucune protection anti-abus déclenchée, les données du joueur chargées et au moins 10% de la santé maximale en dégâts enregistrés. Les joueurs bloqués pour les récompenses de l'instance sont ignorés. Chaque passage peut fournir des pièces et, si le butin aléatoire est activé, du butin aléatoire/spécial et des parchemins selon les réglages et règles de groupe. Il ne rejoue pas toutes les récompenses personnalisées définies et ne garantit pas un objet par tirage. Des appels répétés ajoutent des tentatives ; aucune limite d'un appel par boss n'est imposée.

Paramètre	Type	Défaut	Remarques
`times`	int	`1`	Nombre de tirages de butin

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("bonus_loot") then
      context.boss:add_tag("bonus_loot")
      context.world:generate_player_loot(2)
      context.boss:send_message("&6Bonus loot drops!")
    end
  end
}

`world:drop_bonus_coins(multiplier)`

Distribue des pièces bonus aux joueurs dont les dégâts enregistrés dépassent 10% de la santé maximale du boss. Ignore les PNJ et les joueurs sans données EliteMobs chargées. Le montant utilise le niveau de récompense ajusté du joueur multiplié par multiplier.

Paramètre	Type	Défaut	Remarques
`multiplier`	nombre	`2.0`	Multiplicateur du montant de pièces

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.25 and not context.boss:has_tag("bonus_coins") then
      context.boss:add_tag("bonus_coins")
      context.world:drop_bonus_coins(3.0)
      context.boss:send_message("&6Gold spills everywhere!")
    end
  end
}

`context.vectors`

Les fonctions vectorielles acceptent le point ou les deux-points. Les entrées acceptent x, y, z, les indices numériques 1..3 ou une table imbriquée direction. Les composantes absentes valent 0. Les résultats sont de nouvelles tables ; les entrées ne sont pas modifiées.

Méthode	Renvoie	Remarques
`vectors.get_vector_between_locations(loc1, loc2[, options])`	table vector	Déplacement `loc2 - loc1`, non normalisé par défaut
`vectors.normalize_vector(vec)`	table vector	Vecteur unitaire pour une entrée non nulle ; zéro reste zéro
`vectors.rotate_vector(vec, pitch, yaw)`	table vector	Rotation autour de X du monde, puis de Y, en degrés

Toutes les tables vector possèdent les champs x, y, z.

`vectors.get_vector_between_locations(loc1, loc2, options)`

Paramètre	Type	Remarques
`loc1`	table location	Point de départ
`loc2`	table location	Point d'arrivée
`options`	table (facultatif)	Options de post-traitement (voir ci-dessous)

Options de vecteur

Clé	Type	Défaut	Remarques
`normalize`	booléen	`false`	Normalise le vecteur résultant
`multiplier`	nombre	`1.0`	Met le vecteur à l'échelle
`offset`	table vector	`nil`	Ajoute un vecteur de décalage

Ordre d'application : normaliser le déplacement non nul, multiplier, puis ajouter le décalage dans les axes du monde. Les positions non résolues ou de mondes différents renvoient zéro avant toute option. Des positions valides identiques peuvent encore recevoir un décalage.

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("dash", 100) then return end
    -- Compute a normalized direction from boss to player, scaled to speed 2
    local dir = context.vectors.get_vector_between_locations(
      context.boss:get_location(),
      context.player:get_location(),
      { normalize = true, multiplier = 2.0 }
    )
    -- Launch the boss toward the player
    context.boss:set_velocity_vector(dir)
  end
}

`vectors.normalize_vector(vec)`

Paramètre	Type	Remarques
`vec`	table vector	Vecteur d'entrée

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.player == nil then return end
    local raw = context.vectors.get_vector_between_locations(
      context.boss:get_location(),
      context.player:get_location()
    )
    local unit = context.vectors.normalize_vector(raw)
    context.log:info("Direction: " .. unit.x .. ", " .. unit.y .. ", " .. unit.z)
  end
}

`vectors.rotate_vector(vec, pitch, yaw)`

Paramètre	Type	Remarques
`vec`	table vector	Vecteur d'entrée
`pitch`	nombre	Rotation autour de l'axe X en degrés
`yaw`	nombre	Rotation autour de l'axe Y en degrés

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("spread_shot", 100) then return end
    local forward = context.vectors.normalize_vector(
      context.vectors.get_vector_between_locations(
        context.boss:get_location(),
        context.player:get_location()
      )
    )
    -- Fire three fireballs in a spread pattern
    for _, yaw_offset in ipairs({ -30, 0, 30 }) do
      local dir = context.vectors.rotate_vector(forward, 0, yaw_offset)
      context.boss:summon_projectile(
        "FIREBALL",
        context.boss:get_eye_location(),
        {
          x = context.boss:get_location().x + dir.x * 10,
          y = context.boss:get_location().y + dir.y * 10,
          z = context.boss:get_location().z + dir.z * 10,
          world = context.boss:get_location().world
        },
        1.0
      )
    end
  end
}

astuce

Vous pouvez construire un éventail de directions en faisant pivoter un vecteur de base dans une boucle :

local base = context.vectors.normalize_vector(
  context.vectors.get_vector_between_locations(boss_loc, target_loc)
)
for angle = 0, 330, 30 do
  local dir = context.vectors.rotate_vector(base, 0, angle)
  -- Use dir for spawning projectiles in a ring
end

`context.settings`

Accès en lecture seule à la configuration des pouvoirs. La fonction lit le réglage actuel à chaque appel ; elle ne supprime pas automatiquement les particules ou autres effets. Le script doit utiliser ce résultat pour décider d'afficher un avertissement.

Méthode	Renvoie	Remarques
`settings:warning_visual_effects_enabled()`	booléen	Indique si les effets visuels d'avertissement sont activés dans les réglages de combat des mobs

Exemple

return {
  api_version = 1,
  on_enter_combat = function(context)
    if context.settings:warning_visual_effects_enabled() then
      context.world:spawn_particle_at_location(context.boss:get_location(), {
        particle = "DUST",
        amount = 20,
        red = 255, green = 0, blue = 0,
      })
    end
  end
}

`context.event`

Données d'événement du hook courant. Les champs dépendent de l'événement sous-jacent ; vérifiez les champs facultatifs. Les modificateurs numériques de dégâts exigent le point (event.set_damage_amount(value)) ; transfer_damage accepte point et deux-points. Cette table de boss n'expose pas les membres partagés cancel, uncancel ou is_cancelled.

Champ ou méthode	Disponibilité	Remarques
`event.damage_amount`	Hooks de dégâts	Instantané des dégâts lors de la première résolution de la table différée de l'événement
`event.get_damage_amount()`	Hooks de dégâts	Lit le montant actuel après les modifications
`event.damage_cause`	Hooks de dégâts	Nom d'énumération Bukkit `DamageCause` (par ex. `"ENTITY_ATTACK"`)
`event.cancel_event()`	Événements annulables	Annule l'événement
`event.set_damage_amount(value)`	Hooks basés sur `EliteDamageEvent`	Définit directement les dégâts
`event.multiply_damage_amount(multiplier)`	Hooks basés sur `EliteDamageEvent`	Multiplie les dégâts actuels
`event.damager`	Événements de dégâts comportant une entité agresseur	Agresseur Bukkit brut : le projectile lui-même pour un impact, pas son tireur
`event.projectile`	Événements de dégâts où l'agresseur est un projectile	Encapsulation de référence d'entité de projectile
`event.spawn_reason`	`on_spawn`	Nom d'énumération de la raison d'apparition
`event.entity`	Dégâts joueur vers boss, `on_death`, événements de zone	Boss blessé, entité morte ou traversant la zone ; pour les dégâts d'un renfort, c'est le renfort
`event.is_damage_transfer`	Dégâts joueur vers boss, y compris le relais des renforts	Indique si le coup provient d'un transfert
`event:transfer_damage(target, amount)`	Dégâts joueur vers boss, y compris le relais des renforts	Soumet un coup distinct à un autre élite admissible ; voir le contrat de transfert des dégâts

Exemple : diviser par deux les dégâts entrants

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.event ~= nil then
      local dmg = context.event.damage_amount
      context.log:info("Boss took " .. dmg .. " damage, halving it")
      context.event.multiply_damage_amount(0.5)
    end
  end
}

Exemple : annuler les dégâts des projectiles

Exemple

return {
  api_version = 1,
  on_boss_damaged_by_player = function(context)
    if context.event ~= nil and context.event.damage_cause == "PROJECTILE" then
      context.event.cancel_event()
      if context.player ~= nil then
        context.player:send_message("&cThe boss deflects your projectile!")
      end
    end
  end
}

Exemple : lire la cause des dégâts

Exemple

return {
  api_version = 1,
  on_player_damaged_by_boss = function(context)
    if context.event ~= nil then
      context.log:info("Damage cause: " .. (context.event.damage_cause or "unknown"))
    end
  end
}

remarque

damage_amount est un instantané. Il ne se met pas à jour automatiquement après un appel à set_damage_amount() ou multiply_damage_amount().
Le nouveau contexte reçu par un rappel planifié a event = nil. Capturer l'ancien contexte ne permet pas de modifier valablement son événement terminé ; modifiez l'événement pendant son hook.
Les modificateurs changent l'événement en attente, pas la santé déjà perdue. D'autres listeners peuvent ensuite modifier ou annuler le coup. Un transfert accepté soumet un coup supplémentaire ; il ne réduit ni n'annule automatiquement l'original.

Étapes suivantes

context.world
context.vectors
context.settings
context.event
Étapes suivantes

context.world​

world:spawn_particle_at_location(location, particleSpec)​

Format de la table de spécification de particule​

world:play_sound_at_location(location, sound, volume, pitch)​

world:strike_lightning_at_location(location)​

world:spawn_entity_at_location(entityType, location, options)​

Options d'apparition d'entité​

world:spawn_display_at_location(location, options)​

world:spawn_falling_block_at_location(location, material, options)​

Options de bloc tombant​

world:spawn_custom_boss_at_location(filename, location, options)​

Options d'apparition de boss personnalisé​

world:spawn_boss_at_location(filename, location, level)​

world:spawn_reinforcement_at_location(filename, location, duration, velocity)​

world:spawn_fireworks_at_location(location, spec)​

Table de spécification de feu d'artifice​

Spécification d'effet de feu d'artifice​

world:spawn_splash_potion_at_location(location, spec)​

Table de spécification de potion jetable​

Spécification d'effet de potion​

world:place_temporary_block_at_location(location, material, duration, requireAir)​

world:set_block_at_location(location, material, requireAir)​

world:get_block_type_at_location(location)​

world:get_highest_block_y_at_location(location)​

world:get_blast_resistance_at_location(location)​

world:is_air_at_location(location)​

world:is_passable_at_location(location)​

world:is_passthrough_at_location(location)​

world:is_on_floor_at_location(location)​

world:is_standing_on_material(location, material)​

world:set_world_time(time) / world:set_world_time(location, time)​

world:set_world_weather(weather, duration) / world:set_world_weather(location, weather, duration)​

world:generate_fake_explosion(blockLocations, sourceLocation)​

world:run_console_command(command)​

world:run_empowered_lightning_task_at_location(location)​

world:spawn_fake_gold_nugget_at_location(location, velocity, hasGravity)​

world:run_fake_gold_nugget_damage(projectiles)​

world:generate_player_loot(times)​

world:drop_bonus_coins(multiplier)​

context.vectors​

vectors.get_vector_between_locations(loc1, loc2, options)​

Options de vecteur​

vectors.normalize_vector(vec)​

vectors.rotate_vector(vec, pitch, yaw)​

context.settings​

context.event​

Exemple : diviser par deux les dégâts entrants​

Exemple : annuler les dégâts des projectiles​

Exemple : lire la cause des dégâts​

Étapes suivantes​

`context.world`

`world:spawn_particle_at_location(location, particleSpec)`

Format de la table de spécification de particule

`world:play_sound_at_location(location, sound, volume, pitch)`

`world:strike_lightning_at_location(location)`

`world:spawn_entity_at_location(entityType, location, options)`

Options d'apparition d'entité

`world:spawn_display_at_location(location, options)`

`world:spawn_falling_block_at_location(location, material, options)`

Options de bloc tombant

`world:spawn_custom_boss_at_location(filename, location, options)`

Options d'apparition de boss personnalisé

`world:spawn_boss_at_location(filename, location, level)`

`world:spawn_reinforcement_at_location(filename, location, duration, velocity)`

`world:spawn_fireworks_at_location(location, spec)`

Table de spécification de feu d'artifice

Spécification d'effet de feu d'artifice

`world:spawn_splash_potion_at_location(location, spec)`

Table de spécification de potion jetable

Spécification d'effet de potion

`world:place_temporary_block_at_location(location, material, duration, requireAir)`

`world:set_block_at_location(location, material, requireAir)`

`world:get_block_type_at_location(location)`

`world:get_highest_block_y_at_location(location)`

`world:get_blast_resistance_at_location(location)`

`world:is_air_at_location(location)`

`world:is_passable_at_location(location)`

`world:is_passthrough_at_location(location)`

`world:is_on_floor_at_location(location)`

`world:is_standing_on_material(location, material)`

`world:set_world_time(time)` / `world:set_world_time(location, time)`

`world:set_world_weather(weather, duration)` / `world:set_world_weather(location, weather, duration)`

`world:generate_fake_explosion(blockLocations, sourceLocation)`

`world:run_console_command(command)`

`world:run_empowered_lightning_task_at_location(location)`

`world:spawn_fake_gold_nugget_at_location(location, velocity, hasGravity)`

`world:run_fake_gold_nugget_damage(projectiles)`

`world:generate_player_loot(times)`

`world:drop_bonus_coins(multiplier)`

`context.vectors`

`vectors.get_vector_between_locations(loc1, loc2, options)`

Options de vecteur

`vectors.normalize_vector(vec)`

`vectors.rotate_vector(vec, pitch, yaw)`

`context.settings`

`context.event`

Exemple : diviser par deux les dégâts entrants

Exemple : annuler les dégâts des projectiles

Exemple : lire la cause des dégâts

Étapes suivantes