Scripting Lua : monde et environnement

Cette page couvre toutes les méthodes disponibles sur context.world, context.vectors, context.settings et context.event. Elles permettent à vos pouvoirs Lua d'interagir avec le monde Minecraft -- faire apparaître des entités, jouer des effets, interroger des blocs, et plus encore. Si vous débutez avec les pouvoirs Lua, commencez d'abord par Getting Started.

EliteMobs boss context

Les pouvoirs de boss d'EliteMobs réutilisent le bac à sable Lua de MagmaCore. Le context.world des boss part de la table world partagée de MagmaCore, si bien que les fonctions utilitaires génériques de coordonnées telles que get_block_at(...), set_block_at(...) et spawn_particle(...) restent disponibles. Cette page se concentre sur les ajouts et les redéfinitions de context.world, context.vectors, context.settings et context.event propres aux boss d'EliteMobs. Pour l'API world générique, consultez MagmaCore Lua Scripting Engine.

`context.world`

La table world fournit des méthodes pour faire apparaître des entités, jouer des effets, modifier des blocs et changer l'état du monde. Toutes les méthodes s'appellent avec la syntaxe à deux-points (world:method()).

`world:spawn_particle_at_location(location, particleSpec)`

Fait apparaître des particules à un emplacement. Le second argument peut être une simple chaîne de nom de particule ou une table de spécification de particule complète pour un contrôle avancé.

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, vous pouvez aussi utiliser des clés en snake_case : to_red, to_green, to_blue.

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 la foudre à un emplacement (visuel et infligeant des dégâts).

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)`

Fait apparaître une entité Minecraft vanilla.

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`	Suppression automatique après ce nombre de ticks (0 = jamais)
`on_land`	fonction	`nil`	Rappel lorsque l'entité atterrit au sol
`max_ticks`	int	`6000`	Nombre maximal de ticks de surveillance avant de forcer le rappel `on_land`

Renvoie une table d'encapsulation d'entité.

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_falling_block_at_location(location, material, options)`

Fait apparaître une entité de bloc tombant.

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 table de référence d'entité.

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 custom boss

Clé	Type	Défaut	Remarques
`level`	int	niveau du boss	Remplace le niveau du boss apparu
`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)`

Une méthode d'apparition de boss plus simple. Fait apparaître un custom boss à un emplacement avec un niveau facultatif.

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, level, velocity)`

Fait apparaître un renfort suivi par le système de renforts d'EliteMobs.

Paramètre	Type	Défaut	Remarques
`filename`	chaîne		Nom du fichier de configuration du boss
`location`	table location		Où le faire apparaître
`level`	int	`0`	Niveau du renfort. `0` laisse l'assistant d'invocation appliquer son comportement de niveau par défaut.
`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)`

Fait apparaître une entité feu d'artifice avec un contrôle complet sur les effets.

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	`nil`	Tableau de noms de couleurs ou de tables `{red, green, blue}`
`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 table de référence d'entité. Vous pouvez appeler :detonate() dessus pour forcer une détonation immédiate.

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" },
        },
      },
    })

    -- Detonate immediately for a visual burst
    context.scheduler:run_after(1, function()
      fw:detonate()
    end)
  end
}

`world:spawn_splash_potion_at_location(location, spec)`

Fait apparaître une entité de potion jetable lancée.

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`	Indique s'il faut écraser les effets existants du même type

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)`

Place un bloc temporaire qui revient automatiquement à son état d'origine après une certaine durée.

Paramètre	Type	Défaut	Remarques
`location`	table location		Où le placer
`material`	chaîne		Nom de matériau
`duration`	int	`0`	Ticks avant que le bloc ne revienne à son état d'origine (0 = permanent)
`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)`

Définit un bloc de façon permanente. Utilisez place_temporary_block_at_location si vous voulez qu'il revienne à son état d'origine.

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 de matériau du bloc situé à un emplacement, sous forme de chaîne.

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 non vide le plus haut à la position X/Z donnée.

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 bloc situé à un emplacement, sous forme de nombre.

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 true si le bloc situé à cet emplacement est traversable (les entités peuvent le traverser).

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 situé à cet emplacement n'est pas solide ET que le bloc situé en dessous est solide (autrement dit, l'emplacement « repose sur le sol »).

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)`

Définit l'heure du monde. Vous pouvez facultativement passer un emplacement pour préciser quel monde est concerné.

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)`

Définit la météo dans le monde du boss.

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)`

Crée un effet visuel de fausse explosion à l'aide du système de régénération d'explosions d'EliteMobs (les blocs se cassent puis se régénèrent).

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 une commande console en tant que serveur.

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)`

Exécute la tâche visuelle de foudre renforcée (utilisée par les pouvoirs de l'Ender Dragon). Cela produit un éclair plus spectaculaire assorti d'effets supplémentaires.

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)`

Fait apparaître un faux projectile de pépite d'or utilisé par le système de bullet hell.

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 dotée des méthodes : get_location(), set_gravity(bool), remove(), 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)

    context.world:spawn_fake_gold_nugget_at_location(
      context.boss:get_location(),
      { x = dir.x, y = dir.y, z = dir.z }
    )
  end
}

`world:run_fake_gold_nugget_damage(projectiles)`

Traite les dégâts d'une table de faux projectiles de pépite d'or contre les entités proches.

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)
    -- Spawn some projectiles and store them
    context.state.active_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 }
      )
      table.insert(context.state.active_projectiles, nugget)
    end

    -- Process damage each tick for 3 seconds
    local task_id
    task_id = context.scheduler:run_every(1, function(tick_context)
      tick_context.world:run_fake_gold_nugget_damage(tick_context.state.active_projectiles)
    end)
    context.scheduler:run_after(60, function(later_context)
      later_context.scheduler:cancel_task(task_id)
    end)
  end
}

`world:generate_player_loot(times)`

Génère du butin pour les joueurs ayant blessé le boss.

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)`

Fait tomber des pièces bonus pour tous les joueurs ayant contribué à blesser le boss.

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`

Fonctions utilitaires de calcul vectoriel. Elles s'appellent comme des fonctions ordinaires (syntaxe à point), et non comme des méthodes.

Méthode	Renvoie	Remarques
`vectors.get_vector_between_locations(loc1, loc2[, options])`	table vector	Direction de `loc1` vers `loc2`
`vectors.normalize_vector(vec)`	table vector	Renvoie un vecteur de longueur unitaire
`vectors.rotate_vector(vec, pitch, yaw)`	table vector	Fait pivoter un vecteur de tant de degrés en pitch et en yaw

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

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, 360, 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 aux valeurs de configuration liées aux pouvoirs.

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 pour le hook en cours. Les champs disponibles dépendent du hook qui a déclenché l'appel.

Champ ou méthode	Disponibilité	Remarques
`event.damage_amount`	Hooks de dégâts	Le montant de dégâts actuel (instantané au moment de l'appel)
`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	Encapsulation de référence d'entité pour l'agresseur
`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`	`on_death`, événements de zone	L'encapsulation d'entité concernée

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().
À l'intérieur des rappels planifiés, context.event vaut nil. Utilisez les hooks d'événement pour modifier les événements.

Étapes suivantes

Getting Started | NPC Scripts | Hooks & Lifecycle | Boss & Entities | Zones & Targeting | Examples | Enums | Troubleshooting
API Reference | Scripting Engine

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_falling_block_at_location(location, material, options)​

Options de bloc tombant​

world:spawn_custom_boss_at_location(filename, location, options)​

Options d'apparition de custom boss​

world:spawn_boss_at_location(filename, location, level)​

world:spawn_reinforcement_at_location(filename, location, level, 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_falling_block_at_location(location, material, options)`

Options de bloc tombant

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

Options d'apparition de custom boss

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

`world:spawn_reinforcement_at_location(filename, location, level, 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