Lua-Scripting: Welt & Umgebung

Diese Seite behandelt sämtliche Methoden, die auf context.world, context.vectors, context.settings und context.event verfügbar sind. Damit können deine Lua-Kräfte mit der Minecraft-Welt interagieren -- Entitäten spawnen, Effekte abspielen, Blöcke abfragen und mehr. Wenn du neu bei Lua-Kräften bist, beginne zuerst mit Erste Schritte.

EliteMobs-Bosskontext

EliteMobs-Bosskräfte verwenden die Lua-Sandbox von MagmaCore wieder. Das context.world eines Bosses geht von der gemeinsamen MagmaCore-Welttabelle aus, sodass allgemeine Koordinaten-Helfer wie get_block_at(...), set_block_at(...) und spawn_particle(...) weiterhin verfügbar sind. Diese Seite konzentriert sich auf die bossspezifischen Ergänzungen und Überschreibungen von EliteMobs für context.world, context.vectors, context.settings und context.event. Die allgemeine Welt-API findest du unter MagmaCore Lua Scripting Engine.

Bei gleichen Methodennamen gilt die EliteMobs-Version. Die unten beschriebenen Methoden behalten deren Verhalten: Umgehung von Blitz-Spawn-Abbrüchen, erweiterte Partikeldaten und Verwaltung temporärer Blöcke. Andere gemeinsame Methoden bleiben verfügbar, darunter get_entity(uuid), block_is_passable(x, y, z), location_is_protected(location), spawn_dust(...) und raycast(...). Argumente und Verhalten bei ungeladenen Chunks stehen in der gemeinsamen API-Referenz; diese Garantien gelten nicht automatisch für EliteMobs-Überschreibungen.

Beutehelfer von FreeMinecraftModels sind hier nicht verfügbar

FreeMinecraftModels fügt drop_elitemobs_procedural_loot, drop_elitemobs_random_loot, drop_elitemobs_custom_loot und start_elitemobs_transport nur in seinen eigenen Prop-Skripten zu context.world hinzu. Jedes Plugin bringt eine eigene Kopie der gemeinsamen Scripting-Bibliothek mit, daher erscheinen diese Helfer nicht in EliteMobs-Bosskräften oder NPC-Skripten, auch wenn FreeMinecraftModels installiert ist. Bosskräfte verwenden stattdessen generate_player_loot und drop_bonus_coins.

`context.world`

Die Welttabelle stellt Methoden für Entitäten, Effekte, Blöcke und den Weltzustand bereit. Sie akzeptieren Doppelpunkt-Syntax (world:method()) oder Punktsyntax ohne explizites self-Argument.

Die Boss-Überschreibungen unten konvertieren Positionstabellen mit x, y, z, optional yaw/pitch und einem geladenen Weltnamen in world. Fehlende Koordinaten werden 0; ohne Weltangabe gilt die aktuelle Bosswelt, ein explizit unbekannter Weltname verhindert jedoch die Konvertierung. Eine verschachtelte Tabelle current_location wird ebenfalls akzeptiert. nil oder eine Position ohne Tabellenform verwendet die Bossposition. Gemeinsame Methoden behalten ihren eigenen Positionsvertrag und die bei Tabellenerstellung gespeicherte Welt.

Beim Schließen der Lua-Instanz werden Weltänderungen und gespawnte Entitäten nicht automatisch zurückgesetzt. Skripteigene Überwachungen stoppen; unabhängige Entfernungstimer, Explosionsregeneration, verstärkte Blitze und Goldprojektile haben eigene Laufzeiten. Block- und Spawn-Überschreibungen wenden weder location_is_protected noch die gemeinsamen Prüfungen auf geladene Chunks automatisch an. Prüfe die nötigen Bedingungen vor Weltänderungen.

`world:spawn_particle_at_location(location, particleSpec)`

Erzeugt Partikel an einer Position. Das zweite Argument akzeptiert einen Namen oder eine Spezifikationstabelle. Ein optionales drittes Ganzzahlargument liefert die Anzahl, wenn amount fehlt; Standard ist 1. Namen werden vor der Suche großgeschrieben. Ungültige Namen oder nicht unterstützte Partikeldaten erzeugen eine Warnung und keine Partikel.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Wo die Partikel erzeugt werden
`particleSpec`	Zeichenkette oder Tabelle	Partikelname oder eine Partikel-Spezifikationstabelle (siehe unten)

Beispiel

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 der Partikel-Spezifikationstabelle

Schlüssel	Typ	Standard	Hinweise
`particle`	Zeichenkette	erforderlich	Partikelname
`amount`	int	1	Anzahl der Partikel
`x`, `y`, `z`	Zahl	0	Streuung/Versatz je Achse
`speed`	Zahl	0	Partikelgeschwindigkeit
`red`, `green`, `blue`	int	255	RGB-Farbe für `DUST` und `DUST_COLOR_TRANSITION`
`toRed`, `toGreen`, `toBlue`	int	255	Zielfarbe des Übergangs für `DUST_COLOR_TRANSITION`

Tipp

Für DUST_COLOR_TRANSITION sind auch to_red, to_green, to_blue möglich; camelCase-Werte haben Vorrang. Beide Staubtypen verwenden die feste Größe 1; RGB-Komponenten müssen in 0..255 liegen. Andere Partikel erhalten keine zusätzlichen Nutzdaten, weshalb nicht alle datenabhängigen Partikel unterstützt werden.

Warnung

Anders als bei EliteScript-YAML-Konfigurationen unterstützen Lua-Partikelnamen keine Umwandlung alter Partikelnamen. Du musst die aktuellen Namen der Spigot-API verwenden (z. B. FIREWORK statt FIREWORKS_SPARK, SMOKE statt SMOKE_NORMAL, DUST statt REDSTONE). Die vollständige Liste der aktuellen Namen und ihrer alten Entsprechungen findest du in der Liste gültiger Partikel.

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

Spielt einen Klang an einer Position ab.

Parameter	Typ	Standard	Hinweise
`location`	Location-Tabelle		Wo der Klang abgespielt wird
`sound`	Zeichenkette		Minecraft-Klangschlüssel (z. B. `"entity.blaze.shoot"`) oder ein Spigot-`Sound`-Enum-Name. Ressourcenpaket-Schlüssel funktionieren ebenfalls.
`volume`	Zahl	`1.0`	Lautstärke
`pitch`	Zahl	`1.0`	Tonhöhe

Beispiel

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

Erzeugt einen echten Blitz mit Schaden und aktiviert die EliteMobs-Umgehung von Blitz-Spawn-Abbrüchen. Dies ist nicht der rein visuelle gemeinsame Blitzhelfer. Die Umgehung garantiert nicht, dass sämtliche Schadens- oder Schutzregeln anderer Plugins ignoriert werden.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Wo der Blitz einschlägt

Beispiel

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

Spawnt eine Vanilla-Entität direkt in der angegebenen Welt. Unbekannte Namen geben nil zurück; ein bekannter, aber nicht spawnbarer Typ kann trotzdem einen Fehler auslösen. Der Helfer setzt keinen Projektilschützen automatisch und registriert keine Elite-Verstärkung.

Parameter	Typ	Hinweise
`entityType`	Zeichenkette	Entitätstyp-Name (z. B. `"FIREBALL"`, `"ARROW"`)
`location`	Location-Tabelle	Wo gespawnt wird
`options`	Tabelle (optional)	Spawn-Optionen (siehe unten)

Spawn-Optionen für Entitäten

Schlüssel	Typ	Standard	Hinweise
`velocity`	Vektortabelle	`nil`	Anfangsgeschwindigkeit `{x, y, z}`
`effect`	Zeichenkette	`nil`	EntityEffect, der beim Spawnen abgespielt wird
`duration`	int	`0`	Positive Werte planen die Entfernung nach diesen Ticks; nicht positive Werte fügen keinen Timer hinzu
`on_land`	Funktion	`nil`	`function(land_location, entity_ref)` bei Bodenkontakt, Ungültigkeit oder nach `max_ticks`; kein Projektiltreffer und kein Beweis einer Landung
`max_ticks`	int	`6000`	Maximale Anzahl an Ticks zur Überwachung, bevor der `on_land`-Rückruf erzwungen wird
`persistent`	boolean	Minecrafts Standard	`false` schließt die Entität vom Speichern des Chunks aus, sodass ein Herunterfahren oder Entladen des Chunks mitten im Effekt sie nicht in der Welt zurücklassen kann

Gibt eine Entitäts-Wrappertabelle zurück. Nicht-lebende Entitäten (FIREBALL, ARROW, TNT, ...) kommen als Referenz-Wrapper für nicht-lebende Entitäten zurück, bei denen is_valid() eine Methode ist. Lebende Entitätstypen (ZOMBIE, GIANT, ...) kommen stattdessen als vollwertiger Wrapper für lebende Entitäten zurück, bei dem is_valid ein boolesches Feld ist -- ein Aufruf von entity:is_valid() auf einem solchen Wrapper löst attempt to call a boolean value aus.

Die Überwachung prüft jeden Tick, solange das Skript aktiv ist, und stoppt mit seinen Aufgaben. Der positive duration-Timer läuft unabhängig und kann die Entität auch nach dem Schließen des Skripts entfernen. Unbekannte effect-Namen werden ignoriert.

Beispiel

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
}

Beispiel

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

Spawnt ein Item- oder Block-Display: ein schwebendes visuelles Element ohne Hitbox, Schwerkraft oder KI. Verwende es für kreisende Steine, geworfene Requisiten und andere Effekte, die nur gesehen werden müssen, statt einen Rüstungsständer zu stylen. Das Display wird auf location zentriert und nach dem Yaw dieser Position ausgerichtet.

Option	Typ	Standard	Hinweise
`item`	Zeichenkette		Als Item angezeigtes Material. Ein Block-Item wie `"AMETHYST_BLOCK"` wird als zentrierter Block angezeigt
`block`	Zeichenkette		Als Block-Display angezeigter Block, als Material oder Blockdaten wie `"lantern[hanging=true]"`
`scale`	Zahl oder Vektortabelle	`1`	Eine Zahl skaliert jede Achse; `{x, y, z}` skaliert jede einzeln. Bei `1` ist ein Block einen Block breit
`duration`	int	`0`	Positive Werte entfernen das Display nach so vielen Ticks
`teleport_duration`	int	`0`	Ticks, die der Client braucht, um zu jedem neuen Ort zu gleiten, `0` bis `59`. Verwende `1`, wenn du das Display jeden Tick teleportierst
`billboard`	Zeichenkette	`FIXED`	`FIXED`, `VERTICAL`, `HORIZONTAL` oder `CENTER`
`glowing`	boolean	`false`	Leuchtende Umrandung
`brightness`	int	Weltlicht	`0` bis `15`, überschreibt das Licht am Display
`bedrock_fallback`	boolean	`true`	Siehe unten

Gib genau eines von item oder block an. Ein fehlendes oder unbekanntes item oder block, beide zugleich oder eine nicht positive scale geben nil zurück und protokollieren eine Warnung, die die Power nennt. Ein unbekannter billboard-Wert behält FIXED.

Displays werden nie mit dem Chunk gespeichert. Sie werden entfernt, wenn duration abläuft, wenn du remove() aufrufst oder wenn die Power herunterfährt, je nachdem, was zuerst eintritt.

Bedrock-Clients können Display-Entitäten nicht darstellen. Bedrock-Spieler, die sich beim Spawnen des Displays in der Welt befinden, sehen stattdessen einen unsichtbaren Rüstungsständer, der dasselbe Item trägt (bei einem Block-Display das Item des Blocks), und das Display wird vor ihnen verborgen. Der Ständer folgt dem Display und wird mit ihm entfernt. Bedrock-Spieler, die die Welt später betreten, erhalten keinen Ständer, und ein Block ohne Item-Form, etwa fire, erhält gar keinen Ständer. Schalte das mit bedrock_fallback = false ab, wenn Bedrock-Spieler den Effekt nicht sehen müssen.

Der zurückgegebene Wrapper hat uuid und entity_type sowie diese Methoden:

Methode	Hinweise
`is_valid()`, `is_alive()`	Ob das Display noch existiert
`get_location()`	Aktueller Ort
`teleport_to_location(location)`	Bewegt das Display und seinen Bedrock-Ständer
`remove()`	Entfernt das Display und seinen Bedrock-Ständer
`set_scale(scale)`	Dieselben Werte wie die Option `scale`
`set_item(material)`	Nur Item-Displays; gibt sonst `false` zurück
`set_block(block)`	Nur Block-Displays; gibt sonst `false` zurück
`set_glowing(enabled)`	Leuchtende Umrandung
`set_brightness(level)`	`0` bis `15`, oder `nil`, um wieder das Licht der Welt zu verwenden
`set_teleport_duration(ticks)`	Dasselbe wie die Option `teleport_duration`

Beispiel

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

Spawnt einen fallenden Block aus einem Blockmaterial. Mit on_land fängt EliteMobs dessen Blockänderungsereignis ab, verhindert die Platzierung und ruft einmal function(land_location, entity_ref) auf. Ohne Rückruf kann die normale Platzierung erfolgen. Es gibt hier keine Optionen duration/max_ticks und keinen Rückruf bei Ungültigkeit oder Zeitüberschreitung.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Wo gespawnt wird
`material`	Zeichenkette	Materialname (z. B. `"STONE"`, `"MAGMA_BLOCK"`)
`options`	Tabelle (optional)	Spawn-Optionen (siehe unten)

Optionen für fallende Blöcke

Schlüssel	Typ	Standard	Hinweise
`velocity`	Vektortabelle	`nil`	Anfangsgeschwindigkeit `{x, y, z}`
`drop_item`	boolean	`false`	Ob der Block als Gegenstand fällt
`hurt_entities`	boolean	`false`	Ob der Block Entitäten schadet, auf denen er landet
`on_land`	Funktion	`nil`	Rückruf `function(land_location, entity_ref)`, wenn der Block landet

Gibt eine Referenz für eine nicht lebende Entität zurück, oder nil, wenn Position oder Material nicht aufgelöst werden können. Ein bekanntes Material, das kein Block ist, kann beim Erstellen der Blockdaten fehlschlagen.

Beispiel

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

Spawnt einen benutzerdefinierten EliteMobs-Boss aus einer Konfigurationsdatei.

Parameter	Typ	Hinweise
`filename`	Zeichenkette	Dateiname der Boss-Konfiguration (z. B. `"my_boss.yml"`)
`location`	Location-Tabelle	Wo gespawnt wird
`options`	Tabelle (optional)	Spawn-Optionen (siehe unten)

Spawn-Optionen für benutzerdefinierte Bosse

Schlüssel	Typ	Standard	Hinweise
`level`	int	konfiguriertes Level des gespawnten Bosses	Überschreibt dessen Level. Ohne Angabe gelten seine eigene Konfiguration und dynamischen Levelregeln; das Level des aufrufenden Bosses wird nicht geerbt.
`silent`	boolean	`false`	Unterdrückt Spawn-Nachrichten
`velocity`	Vektortabelle	`nil`	Anfangsgeschwindigkeit
`add_as_reinforcement`	boolean	`false`	Als Verstärkung des aktuellen Bosses registrieren

Gibt eine Entitäts-Wrappertabelle zurück oder nil, falls der Boss nicht erstellt werden konnte.

Beispiel

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

Einfachere Spawn-Methode: Fehlende Position und fehlendes Level verwenden die Werte des aufrufenden Bosses. Das Ergebnis wird nicht als Verstärkung registriert. Lasse das dritte Argument für den Standard weg; explizites nil wird dort nicht akzeptiert.

Parameter	Typ	Standard	Hinweise
`filename`	Zeichenkette		Dateiname der Boss-Konfiguration
`location`	Location-Tabelle	Bossposition	Wo gespawnt wird (optional, standardmäßig die Bossposition)
`level`	int	Bosslevel	Überschreibt das Spawn-Level (optional)

Gibt eine Entitäts-Wrappertabelle zurück oder nil.

Beispiel

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

Spawnt lautlos über das Verstärkungssystem, speichert den Beschwörer und übernimmt normalisierten Kampf, wenn der benutzerdefinierte Beschwörerboss ihn nutzt. Das Level folgt der eigenen Konfiguration und den dynamischen Levelregeln der Verstärkung; duration ist ein Fluchttimer, keine Levelangabe.

Parameter	Typ	Standard	Hinweise
`filename`	Zeichenkette		Dateiname der Boss-Konfiguration
`location`	Location-Tabelle		Wo gespawnt wird
`duration`	int	`0`	Fluchttimer in Ticks; `0` fügt keinen Timer hinzu. Überschreibt nicht das Level.
`velocity`	Vektortabelle	`nil`	Anfangsgeschwindigkeit (optional)

Gibt eine Entitäts-Wrappertabelle zurück oder nil.

Beispiel

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

Spawnt ein echtes Feuerwerk ohne automatische Schadensunterdrückung. Jeder Effekt benötigt mindestens eine gültige Farbe; ein Effekt ohne Farben kann beim Erstellen fehlschlagen.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Wo gespawnt wird
`spec`	Tabelle	Feuerwerks-Spezifikation (siehe unten)

Feuerwerks-Spezifikationstabelle

Schlüssel	Typ	Standard	Hinweise
`power`	int	`1`	Flugkraft (Höhe)
`velocity`	Vektortabelle	`nil`	Anfangsgeschwindigkeit
`shot_at_angle`	boolean	`true`	Ob das Feuerwerk in einem Winkel abgeschossen wird (wird verwendet, wenn `velocity` gesetzt ist)
`effects`	Tabelle aus Tabellen	`nil`	Array von Feuerwerkseffekt-Spezifikationen. Wird sie weggelassen, gilt die oberste Spezifikation als einzelner Effekt.

Spezifikation eines Feuerwerkseffekts

Schlüssel	Typ	Standard	Hinweise
`type`	Zeichenkette	`"BALL_LARGE"`	`"BALL"`, `"BALL_LARGE"`, `"STAR"`, `"BURST"`, `"CREEPER"`
`flicker`	boolean	`true`	Funkeleffekt
`trail`	boolean	`true`	Schweifeffekt
`colors`	Tabelle	pro Effekt erforderlich	Nicht leeres Array aus Farbnamen oder Tabellen wie `{red = 255, green = 0, blue = 0}`
`fade_colors`	Tabelle	`nil`	Array von Verblassfarben-Namen oder `{red, green, blue}`-Tabellen

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

Gibt eine Referenz für eine nicht lebende Entität zurück, oder nil bei nicht auflösbarer Position. :detonate() fordert die Detonation an. Typen und Farbnamen ignorieren Groß-/Kleinschreibung; unbekannte Typen verwenden BALL_LARGE, unbekannte Farben Weiß. RGB-Komponenten müssen in 0..255 liegen.

Beispiel

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

Spawnt einen echten Wurftrank. Unbekannte Bukkit-Effektnamen erzeugen eine Warnung und werden übersprungen. Der Helfer setzt keinen Schützen und verwendet nicht den Instanzfilter der direkten Boss-Trankmethoden; es gelten die normalen Wurftrankregeln.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Wo gespawnt wird
`spec`	Tabelle	Trank-Spezifikation (siehe unten)

Spezifikationstabelle für Wurftränke

Schlüssel	Typ	Hinweise
`velocity`	Vektortabelle	Anfangsgeschwindigkeit des geworfenen Tranks
`effects`	Tabelle aus Tabellen	Array von Trankeffekt-Spezifikationen

Spezifikation eines Trankeffekts

Schlüssel	Typ	Standard	Hinweise
`type`	Zeichenkette	erforderlich	Name des Trankeffekttyps (z. B. `"SLOWNESS"`, `"POISON"`)
`duration`	int	`0`	Dauer in Ticks
`amplifier`	int	`0`	Effektverstärker (0 = Stufe I)
`overwrite`	boolean	`true`	Ersetzt einen früheren Effekt desselben Typs in den Metadaten dieses Tranks; keine Regel für bereits auf Spielern aktive Effekte

Gibt eine Entitätsreferenz-Tabelle zurück oder nil.

Beispiel

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

Platziert einen verwalteten Block und stellt nach positiver Dauer die vorherigen Blockdaten wieder her. Containerinhalte werden nicht gespeichert. Der ursprüngliche Block kehrt zurück, wenn der Timer endet, wenn der Chunk oder die Welt entladen wird oder wenn das Plugin stoppt, aber nur, solange an der Stelle noch der temporäre Block steht; eine spätere Bearbeitung wird daher nicht überschrieben. Eine erneute Platzierung auf einem Block, der noch einen temporären Block enthält, startet dessen Timer neu und behält das zuerst gespeicherte Original. Blöcke mit Blockentitäten wie Truhen und Schilder, ungeladene Chunks und Blöcke, die ein anderer Besitzer temporärer Blöcke hält, werden übersprungen. Das Abbauen eines verwalteten Blocks lässt nichts fallen und beendet die Verwaltung ohne Wiederherstellung. Verwende ein Blockmaterial. Diese Boss-Methode gibt immer nil zurück, auch wenn requireAir oder ein Überspringen die Platzierung verhindert; sie bestätigt keinen Erfolg und prüft nicht automatisch Gebietsschutz.

Parameter	Typ	Standard	Hinweise
`location`	Location-Tabelle		Wo platziert wird
`material`	Zeichenkette		Materialname
`duration`	int	`0`	Ticks bis zur Wiederherstellung; null oder negative Werte platzieren den Block dauerhaft und ohne Verwaltung
`requireAir`	boolean	`false`	Bei `true` wird nur platziert, wenn der Block derzeit Luft ist

Beispiel

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

Setzt einen Block dauerhaft über die Verwaltung temporärer Blöcke, ohne Wiederherstellungstimer und ohne Verwaltung, sodass die Änderung nach dem Plugin-Stopp bestehen bleibt. Enthält der Block derzeit einen zeitgesteuerten temporären Block, wird dieser nicht mehr verwaltet und nicht wiederhergestellt. Blöcke, die ein anderer Besitzer temporärer Blöcke hält, bleiben unverändert. Verwende place_temporary_block_at_location mit positiver Dauer für eine zeitgesteuerte Wiederherstellung.

Parameter	Typ	Standard	Hinweise
`location`	Location-Tabelle		Wo platziert wird
`material`	Zeichenkette		Materialname
`requireAir`	boolean	`false`	Bei `true` wird nur platziert, wenn der Block derzeit Luft ist

Beispiel

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

Gibt den Materialnamen in Großbuchstaben zurück, oder nil bei nicht auflösbarer Position. Anders als die gemeinsame Koordinatenabfrage greift diese Überschreibung direkt auf den Block zu, ohne auf geladene Chunks zu prüfen.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position

Beispiel

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

Gibt Bukkits höchste Block-Y-Koordinate an X/Z zurück, oder nil bei nicht auflösbarer Position. Prüft weder, ob der Chunk bereits geladen ist, noch ob eine Teleportation zum Ziel sicher ist.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position (X und Z werden verwendet)

Beispiel

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

Gibt den Explosionswiderstand des Materials zurück, oder 0 bei nicht auflösbarer Position.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position

Beispiel

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

Gibt true zurück, wenn der Block an der Position Luft ist.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position

Beispiel

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

Gibt Bukkits Block.isPassable() zurück, oder false bei nicht auflösbarer Position. Dies prüft nur einen Block, nicht ob eine ganze Entität hineinpasst oder dort navigieren kann.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position

Beispiel

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

Gibt true zurück, wenn der Block an der Position nicht fest ist (ähnlich wie passierbar, aber basierend auf der Festkörper-Prüfung).

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position

Beispiel

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

Gibt true zurück, wenn der Block an der Position nicht fest und der Block eine Y-Einheit darunter fest ist. Prüft weder tatsächlichen Bodenkontakt einer Entität noch deren Kollisionsbox oder Kopffreiheit.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position

Beispiel

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

Gibt true zurück, wenn der Block direkt unterhalb der Position dem angegebenen Material entspricht.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Abzufragende Position
`material`	Zeichenkette	Zu prüfender Materialname

Beispiel

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

Ändert die Zeit der gesamten Welt. Eine optionale Position wählt die Welt aus. Beim Schließen des Skripts wird die vorherige Zeit nicht wiederhergestellt.

Parameter	Typ	Hinweise
`location`	Location-Tabelle (optional)	Welche Welt betroffen ist. Standardmäßig die Bosswelt.
`time`	int	Weltzeit in Ticks (0 = Morgengrauen, 6000 = Mittag, 13000 = Nacht, 18000 = Mitternacht)

Beispiel

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

Ändert das Wetter in der Bosswelt oder der Welt der optionalen Position. Namen ignorieren Groß-/Kleinschreibung; unbekannte Namen erzeugen nur eine Warnung. RAIN/CLEAR setzen den Wettertimer, THUNDER dagegen den Donnertimer. Die ganze Welt ist betroffen; beim Schließen des Skripts wird ihr vorheriger Zustand nicht wiederhergestellt.

Parameter	Typ	Standard	Hinweise
`location`	Location-Tabelle (optional)	Bosswelt	Welche Welt betroffen ist
`weather`	Zeichenkette		`"CLEAR"`, `"RAIN"` (oder `"PRECIPITATION"`), `"THUNDER"`
`duration`	int	`6000`	Wetterdauer in Ticks

Beispiel

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

Entfernt echte Blöcke und erzeugt fallende Trümmer über die EliteMobs-Explosionsregeneration. Die Trümmer können Entitäten verletzen; dies ist kein harmloser Partikeleffekt. doExplosionRegen muss aktiv sein; die WorldGuard-Regenerationsflag wird bei angegebener Quellposition geprüft. Luft, Feuer, Flüssigkeiten und verwaltete temporäre Blöcke werden ausgelassen; abhängige Nachbarblöcke können hinzukommen. Die Wiederherstellung beginnt nach 1200 Ticks und verarbeitet einen gespeicherten Block pro Tick. Halte alle Positionen in der Bosswelt. Die Methode gibt nil zurück; das Schließen des Skripts macht die Änderung nicht rückgängig.

Parameter	Typ	Hinweise
`blockLocations`	Tabelle aus Location-Tabellen	Array von Blockpositionen, die "explodieren" sollen
`sourceLocation`	Location-Tabelle (optional)	Explosionsquelle für Richtungsberechnungen

Beispiel

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

Führt sofort einen Konsolenbefehl als Server aus und gibt nil zurück, ohne dessen Erfolg zu melden. Spieler- oder Bossplatzhalter werden nicht automatisch ersetzt.

Vanilla-Befehle melden ihr Ergebnis, und mit dem Standardwert broadcast-console-to-ops=true zeigt der Server jedes Ergebnis allen Online-Operatoren an. Häufig ausgeführte Befehle wie data merge entity, kill oder damage überfluten deren Chat. Verwende stattdessen die nativen Methoden: spawn_display_at_location für visuelle Effekte, die Rüstungsständer-Methoden für Ständer, entity:remove(), um zu entfernen, was ein Skript gespawnt hat, und entity:deal_custom_damage(amount) für exakten Schaden des Bosses.

Parameter	Typ	Hinweise
`command`	Zeichenkette	Der auszuführende Befehl (ohne führenden `/`)

Beispiel

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

Startet eine unabhängige Bukkit-Aufgabe an der gespeicherten Position. Nach 60 Durchläufen mit SOUL_FIRE_FLAME folgen ein echter Blitz mit Spawn-Umgehung und ein abwärts gerichteter Feuerball mit Explosionsstärke 5, markiert als ender_dragon_empowered_lightning.yml. Dies ist ein schadensverursachender Angriff. Schließen oder Pausieren des Lua-Skripts beendet die Aufgabe nicht; die Warneffekt-Einstellung wird ebenfalls nicht abgefragt.

Parameter	Typ	Hinweise
`location`	Location-Tabelle	Wo der Blitz einschlägt

Beispiel

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

Erzeugt per Netzwerkpaketen einen sichtbaren Goldklumpen für nahe Spieler; Spieler und Trichter können ihn nicht aufnehmen. Das Erstellen allein bewegt ihn nicht und verursacht keinen Schaden. Übergib ihn einmal als Teil einer Gruppe an run_fake_gold_nugget_damage oder entferne ihn explizit.

Parameter	Typ	Standard	Hinweise
`location`	Location-Tabelle		Spawn-Position
`velocity`	Vektortabelle		Anfangsgeschwindigkeit
`hasGravity`	boolean	`false`	Ob das Projektil der Schwerkraft unterliegt

Gibt eine Schein-Projektiltabelle zurück, oder nil bei nicht auflösbarer Position bzw. Vektor, mit get_location(), set_gravity(bool), remove() und is_removed().

Beispiel

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

Startet eine unabhängige Bukkit-Aufgabe, die die Gruppe jeden Tick bewegt und prüft. Rufe sie einmal pro Gruppe auf: Jeder Aufruf startet eine weitere Aufgabe. An der neuen Position werden lebende Entitäten in einer Box mit Halbausdehnung 0.5 geprüft; der Ursprungsboss und blockende Spieler werden übersprungen. Benutzerdefinierter Schaden 1 wird über die Boss-Schadensregeln eingereicht. Eine Kollision kann das Projektil auch bei abgelehntem Schaden entfernen. Bodenkontakt oder 100 Ticks Laufzeit entfernen es ebenfalls. Die Prüfung erfolgt an einzelnen Positionen, nicht als Strahl über die gesamte Bewegung; Schließen oder Pausieren von Lua beendet die Aufgabe nicht.

Parameter	Typ	Hinweise
`projectiles`	Tabelle	Array von Schein-Projektiltabellen aus `spawn_fake_gold_nugget_at_location`

Beispiel

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

Führt die normale Spielerbeute-Erzeugung times-mal aus; nicht positive Werte tun nichts. Erfordert eliteLoot, keinen ausgelösten Exploitschutz, geladene Spielerdaten und aufgezeichneten Schaden von mindestens 10% der maximalen Gesundheit. Spieler mit Instanz-Belohnungssperre werden übersprungen. Jeder Durchlauf kann Münzen sowie bei aktiver Zufallsbeute zufällige/spezielle Beute und Schriftrollen nach den üblichen Einstellungen und Gruppenregeln ausgeben. Er wiederholt nicht alle definierten benutzerdefinierten Drops und garantiert keinen Gegenstand pro Wurf. Wiederholte Aufrufe erzeugen weitere Belohnungsversuche; es gibt keine Begrenzung auf einmal pro Boss.

Parameter	Typ	Standard	Hinweise
`times`	int	`1`	Anzahl der Beutewürfe

Beispiel

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

Gibt Bonusmünzen für Spieler aus, deren aufgezeichneter Schaden mehr als 10% der maximalen Bossgesundheit beträgt. NPCs und Spieler ohne geladene EliteMobs-Daten werden übersprungen. Der Betrag verwendet das angepasste Belohnungslevel des Spielers mal multiplier.

Parameter	Typ	Standard	Hinweise
`multiplier`	Zahl	`2.0`	Multiplikator für die Münzmenge

Beispiel

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`

Vektorhelfer akzeptieren Punkt- und Doppelpunkt-Syntax. Eingaben verwenden benannte Felder x, y, z, numerische Indizes 1..3 oder eine verschachtelte direction-Tabelle. Fehlende Komponenten werden 0. Ergebnisse sind neue Tabellen; Eingaben bleiben unverändert.

Methode	Gibt zurück	Hinweise
`vectors.get_vector_between_locations(loc1, loc2[, options])`	Vektortabelle	Verschiebung `loc2 - loc1`, standardmäßig nicht normalisiert
`vectors.normalize_vector(vec)`	Vektortabelle	Einheitsvektor bei Eingaben ungleich null; der Nullvektor bleibt null
`vectors.rotate_vector(vec, pitch, yaw)`	Vektortabelle	Dreht erst um die Welt-X-Achse, dann um Y, in Grad

Alle Vektortabellen haben die Felder x, y, z.

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

Parameter	Typ	Hinweise
`loc1`	Location-Tabelle	Startpunkt
`loc2`	Location-Tabelle	Endpunkt
`options`	Tabelle (optional)	Optionen zur Nachbearbeitung (siehe unten)

Vektor-Optionen

Schlüssel	Typ	Standard	Hinweise
`normalize`	boolean	`false`	Normalisiert den resultierenden Vektor
`multiplier`	Zahl	`1.0`	Skaliert den Vektor
`offset`	Vektortabelle	`nil`	Fügt einen Versatzvektor hinzu

Reihenfolge: Verschiebung ungleich null normalisieren, multiplizieren, dann den Versatz entlang der Weltachsen addieren. Nicht auflösbare Positionen oder verschiedene Welten ergeben den Nullvektor, bevor Optionen angewendet werden. Identische gültige Positionen können weiterhin einen Versatz erhalten.

Beispiel

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

Parameter	Typ	Hinweise
`vec`	Vektortabelle	Eingabevektor

Beispiel

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

Parameter	Typ	Hinweise
`vec`	Vektortabelle	Eingabevektor
`pitch`	Zahl	Drehung um die X-Achse in Grad
`yaw`	Zahl	Drehung um die Y-Achse in Grad

Beispiel

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
}

Tipp

Du kannst eine Streuung von Richtungen erzeugen, indem du einen Basisvektor in einer Schleife drehst:

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`

Lesezugriff auf die Konfiguration von Kräften. Der Getter liest bei jedem Aufruf die aktuelle Einstellung; er unterdrückt Partikel oder Effekte nicht automatisch. Das Skript muss anhand des Ergebnisses entscheiden, ob es eine Warnung anzeigt.

Methode	Gibt zurück	Hinweise
`settings:warning_visual_effects_enabled()`	boolean	Ob visuelle Warneffekte in den Mob-Kampfeinstellungen aktiviert sind

Beispiel

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`

Ereignisdaten des aktuellen Hooks. Verfügbare Felder hängen vom zugrunde liegenden Ereignis ab; prüfe optionale Felder vor der Verwendung. Numerische Schadenssetter erfordern Punktsyntax (event.set_damage_amount(value)); transfer_damage akzeptiert Punkt oder Doppelpunkt. Diese Boss-Ereignistabelle enthält die gemeinsamen Mitglieder cancel, uncancel und is_cancelled nicht.

Feld oder Methode	Verfügbar bei	Hinweise
`event.damage_amount`	Schadens-Hooks	Momentaufnahme bei der ersten Auflösung der verzögert erstellten Ereignistabelle
`event.get_damage_amount()`	Schadens-Hooks	Liest den aktuellen Wert nach Änderungen
`event.damage_cause`	Schadens-Hooks	Name des Bukkit-`DamageCause`-Enums (z. B. `"ENTITY_ATTACK"`)
`event.cancel_event()`	Abbrechbare Ereignisse	Bricht das Ereignis ab
`event.set_damage_amount(value)`	Hooks auf Basis von `EliteDamageEvent`	Setzt den Schaden direkt
`event.multiply_damage_amount(multiplier)`	Hooks auf Basis von `EliteDamageEvent`	Multipliziert den aktuellen Schaden
`event.damager`	Schadensereignisse mit einer schädigenden Entität	Ursprünglicher Bukkit-Verursacher: bei Projektiltreffern das Projektil selbst, nicht sein Schütze
`event.projectile`	Schadensereignisse, bei denen der Verursacher ein Projektil ist	Entitätsreferenz-Wrapper des Projektils
`event.spawn_reason`	`on_spawn`	Name des Spawn-Grund-Enums
`event.entity`	Schaden Spieler zu Boss, `on_death`, Zonenereignisse	Geschädigter Boss, tote oder die Zone überquerende Entität; bei Verstärkungsschaden die Verstärkung
`event.is_damage_transfer`	Schaden Spieler zu Boss, einschließlich Weiterleitung von Verstärkungen	Ob dieser Treffer aus einer Schadensübertragung stammt
`event:transfer_damage(target, amount)`	Schaden Spieler zu Boss, einschließlich Weiterleitung von Verstärkungen	Reicht einen separaten Treffer gegen einen anderen geeigneten Elite ein; siehe Vertrag zur Schadensübertragung

Beispiel: Eingehenden Schaden halbieren

Beispiel

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
}

Beispiel: Schaden von Projektilen abbrechen

Beispiel

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
}

Beispiel: Schadensursache auslesen

Beispiel

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
}

Hinweis

damage_amount ist eine Momentaufnahme. Der Wert wird nach dem Aufruf von set_damage_amount() oder multiply_damage_amount() nicht automatisch aktualisiert.
Der frische Kontext eines geplanten Rückrufs hat event = nil. Das Erfassen des alten Hook-Kontexts macht dessen abgeschlossenes Ereignis nicht nachträglich veränderbar; ändere Ereignisse während ihres Hooks.
Setter ändern das anstehende Ereignis, nicht bereits verlorene Gesundheit. Spätere Listener können den Treffer verändern oder abbrechen. Eine akzeptierte Übertragung reicht einen zusätzlichen Treffer ein; sie reduziert oder beendet den ursprünglichen nicht automatisch.

Nächste Schritte

Erste Schritte | NPC-Skripte | Hooks & Lebenszyklus | Boss & Entitäten | Zonen & Zielauswahl | Beispiele | Enums | Fehlerbehebung
API-Referenz | Scripting Engine

context.world
context.vectors
context.settings
context.event
Nächste Schritte

context.world​

world:spawn_particle_at_location(location, particleSpec)​

Format der Partikel-Spezifikationstabelle​

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

world:strike_lightning_at_location(location)​

world:spawn_entity_at_location(entityType, location, options)​

Spawn-Optionen für Entitäten​

world:spawn_display_at_location(location, options)​

world:spawn_falling_block_at_location(location, material, options)​

Optionen für fallende Blöcke​

world:spawn_custom_boss_at_location(filename, location, options)​

Spawn-Optionen für benutzerdefinierte Bosse​

world:spawn_boss_at_location(filename, location, level)​

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

world:spawn_fireworks_at_location(location, spec)​

Feuerwerks-Spezifikationstabelle​

Spezifikation eines Feuerwerkseffekts​

world:spawn_splash_potion_at_location(location, spec)​

Spezifikationstabelle für Wurftränke​

Spezifikation eines Trankeffekts​

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

Vektor-Optionen​

vectors.normalize_vector(vec)​

vectors.rotate_vector(vec, pitch, yaw)​

context.settings​

context.event​

Beispiel: Eingehenden Schaden halbieren​

Beispiel: Schaden von Projektilen abbrechen​

Beispiel: Schadensursache auslesen​

Nächste Schritte​

`context.world`

`world:spawn_particle_at_location(location, particleSpec)`

Format der Partikel-Spezifikationstabelle

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

`world:strike_lightning_at_location(location)`

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

Spawn-Optionen für Entitäten

`world:spawn_display_at_location(location, options)`

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

Optionen für fallende Blöcke

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

Spawn-Optionen für benutzerdefinierte Bosse

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

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

`world:spawn_fireworks_at_location(location, spec)`

Feuerwerks-Spezifikationstabelle

Spezifikation eines Feuerwerkseffekts

`world:spawn_splash_potion_at_location(location, spec)`

Spezifikationstabelle für Wurftränke

Spezifikation eines Trankeffekts

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

Vektor-Optionen

`vectors.normalize_vector(vec)`

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

`context.settings`

`context.event`

Beispiel: Eingehenden Schaden halbieren

Beispiel: Schaden von Projektilen abbrechen

Beispiel: Schadensursache auslesen

Nächste Schritte