From 0d67c0fa67a552ed8ce52d1ece25d3ef625a625a Mon Sep 17 00:00:00 2001 From: Malfrador Date: Fri, 21 Apr 2023 21:17:40 +0200 Subject: [PATCH] Update docs --- docs/questsxl/actions.md | 222 ++++++++++++++++++++---------------- docs/questsxl/intro.md | 195 ++++++++++++++++++++++++++++++- docs/questsxl/objectives.md | 122 +++++++++++++++++++- 3 files changed, 440 insertions(+), 99 deletions(-) diff --git a/docs/questsxl/actions.md b/docs/questsxl/actions.md index 1710b7b..ec8474b 100644 --- a/docs/questsxl/actions.md +++ b/docs/questsxl/actions.md @@ -9,150 +9,178 @@ Für einige komplexe Actions steht die Kurzschreibweise nicht zur Verfügung. In dieser Dokumentation wird die Kurzschreibweise zu erst genannt und dann die Langschreibweise. ## Animation -Spielt eine Animation ab. - -`animation: ;` +``animation`` -```yaml -key: - type: animation - name: - instanced: -``` +Spielt eine Animation ab. * **name:** Der Name einer vorher erstellten Animation * **instanced:** true/false - Ob die Animation nur für den Spieler (oder seine Gruppe) sichtbar ist (true) oder für alle (false). Default = true. -* **runAfter:** Nachdem die Animation vollständig abgespielt wurde. +* **runAfter:** Actions, nachdem die Animation vollständig abgespielt wurde. ## Command -Führt einen Befehl aus. +``command`` -`command: ;;` +Führt einen Befehl aus. -```yaml -key: - type: command - command: - op: - console: -``` * **command:** Der Befehl. Der Platzhalter `%player%` kann benutzt werden & wird durch den Namen des Spielers ersetzt. * **op:** true/false - Ob der Befehl als OP (mit *-Permissions) ausgeführt wird oder nicht. Sollte vorsichtig genutzt werden. Default = false. * **console:** true/false - Ob der Befehl vom Server ausgeführt werden soll. Default = false. ## Cutscene +``cutscene`` + Spielt eine vorher erstellte Cutscene ab. -`cutscene: ;` -``` -key: - type: cutscene - name: - teleportBack: -``` * **name:** Der Name einer vorher ingame erstellten Cutscene * **instanced:** true/false - Ob der Spieler nach Ende der Cutscene wieder an den Start zurückteleportiert wird (true), oder da bleibt wo die Cutscene endet (false). Default = false. * **runAfter:** Nachdem die Cutscene fertig abgespielt wurde. ## Delay +``delay`` + Führt eine oder mehrere Actions verzögert aus. Keine Kurzschreibweise möglich. -``` -key: - type: delay - delay: - actions: - action1: - action2: -``` + * **delay:** Die Verzögerung, gemessen in Ticks. Eine Sekunde -> 20 Ticks. * **actions:** Eine Aufzählung der Actions, die nach dem Delay ausgeführt werden. Kurz- und Langform sind möglich. * **runAfter:** Nach Ausführung der verzögerten Action. + +## Dialogue +``dialogue`` + +Startet einen Dialog. + +* **id:** Die ID des Dialogs. + ## Give Item +``give_item`` + Vergibt ein oder mehrere Items an den Spieler. -`give_item: ;;` -``` -key: - type: give_item - item: - amount: - chance: -``` * **item:** Das Item. Kann ein Vanilla-Item-Name sein oder ein Custom-Item. * **amount:** Die Menge des Items. Default = 1. * **chance:** Ein Wert von 0 bis 100, der die Chance angibt mit der dieses Item erhalten werden kann. Default = 100. + ## Hide IBC +``hide_ibc`` + +Versteckt eine IBC. + +* **id:** ID der IBC. + ## Message +``message`` + Sendet eine Nachricht an den Spieler. -`message: ` -``` -key: - type: message - message: -``` * **message:** Die Nachricht. ## Mob Follow +:::caution Nicht implementiert +::: +``mob_follow_player`` + Lässt einen Mob/NPC einem Spieler folgen. -`mob_follow_player: ;;;` -``` -key: - type: mob_follow_player - id: - instanced: - distance: - stopOnTeleport: -``` -* **id:** Die ID des Mobs. -* **instanced:** true/false - Ob ein neuer InstancedMob erstellt werden soll, der nur für den Spieler sichtbar ist (true) oder ob der echte Mob, für alle sichtbar, dem Spieler folgen soll (false). Default = true. -* **distance:** Die Entfernung, die der Mob versucht zum Spieler einzuhalten. Werte, die oberhalb der Server-Sichtweite liegen, funktionieren wahrscheinlich nicht. -* **stopOnTeleport:** true/false - Ob der Mob sich mit dem Spieler teleportieren soll (false) oder das Folgen abbricht, sobald der Spieler sich teleportiert (true). Default = true. +## Paste schematic +``paste_schematic`` + +Fügt eine Schematic in der Welt ein. + +* **schematic:** Der Name der Schematic +* **time:** Optional. Zeit in Sekunden, nachdem die Schematic automatisch wieder entfernt wird (//undo) +* **location:** QLocation + ## Permission +``permission`` + Verändert die Permission oder Gruppen eines Spielers. -`permission: ;` -``` -key: - type: permission - permission: - action: -``` * **permission:** Die Permission oder der Gruppen-Name. * **action:** `add`, `remove`, `add_group`, `remove_group` - Was passieren soll. +## Repeat +``repeat`` + +Wiederholt eine oder mehrere Actions. + +* **delay:** Zeit zwischen einzelnen Wiederholungen, in Ticks (20 ticks -> 1 Sekunde) +* **repetitions:** Wie oft die Actions wiederholt werden. +* **actions:** Die Actions. + ## Reset IBC +``reset_ibc`` + +Setzt eine IBC auf den Weltzustand zurück. + +* **id:** Die ID der IBC + +## Run as +``run_as`` + +Führt eine Action für bestimmte Spieler aus. + +* **runMode:** ``event_in_range``, ``event_participants`` oder ``online``. Default: ``online`` +* **runValue:** Nur wenn ``event_participants``: Mindestwert an Eventbeteiligung. + +## Show Beam +:::caution Nicht implementiert in 1.19.3 +::: +``show_beam`` + +Zeigt einen Marker-Lichtstrahl an. + ## Show IBC +``show_ibc`` + +Zeigt eine IBC an. + +* **id:** Die ID der IBC + +## Spawner +``spawner`` + +Triggered einen Spawner manuell. +* **id:** Die ID des Spawners. ## Spawn Mob +``stage`` + Spawnt einen Mob oder NPC. -`spawn_mob: ;;;;;;;` -``` -key: - type: spawn_mob - id: - x: - y: - z: - relative: - instanced: - ignoreConditions: - adjust: -``` * **id:** Die ID des Mobs/NPCs. -* **x/y/z:** Koordinaten -* **relative:** Ob die angegebenen Koordinaten relativ zur aktuellen Position des Spielers sind (true) oder normale Koordinaten (false). Default = false -* **instanced:** Ob es sich um einen InstancedMob handelt, der nur für den Spieler bzw. seine Gruppe sichtbar ist (true) oder einen normalen Mob, der für alle sichtbar ist (false). Default = false. -* **ignoreConditions:** Ob der Mob mögliche Spawn-Bedingungen ignorieren soll. Default = false -* **adjust:** Nur sinnvoll, wenn `relative: true`. Ob versucht werden soll den Mob an einer anderen Stelle zu spawnen, sollte das Spawnen an den angegebenen Koordinaten nicht möglich sein (z.B. weil in einem Block). +* **location:** QLocation + ## Stage change -Ändert die Stage des Spielers. - -`stage: ;` -``` -key: - type: stage - id: - complete: -``` -* **id:** Die ID der neuen Stage. -* **complete:** Ob die aktuelle Stage als abgeschlossen markiert werden soll (true) oder nicht (false). Führt dazu, das eventuelle `onFinish`-Actions ausgeführt werden. Default = false. +``stage`` + +Ändert die Stage des Spielers oder des Events. + +* **quest:** Quest-ID +* **id:** Stage-ID + +## Start Event +``start_event`` + +Startet ein Event. + +* **id:** ID des Events +* **skipConditions:** Ob Conditions für den Event-Start ignoriert werden sollen. + +## Start Quest +``start_quest`` + +Startet eine Quest. + +* **id:** ID der Quest + ## Teleport +``teleport`` + Teleportiert den Spieler. + +* QLocation + ## Title +``title`` + +Sendet einen Titel an den Spieler. + +* **title:** Wie Vanilla-Command +* **subtitle:** Wie Vanilla-Command +* **fadeIn:** Wie Vanilla-Command +* **stay:** Wie Vanilla-Command +* **fadeOut:** Wie Vanilla-Command diff --git a/docs/questsxl/intro.md b/docs/questsxl/intro.md index 27f3224..a3e9156 100644 --- a/docs/questsxl/intro.md +++ b/docs/questsxl/intro.md @@ -37,4 +37,197 @@ Bisher klingt es ja noch alles recht einfach und ein wenig nach dem alten Questp Klingt kompliziert? Keine Sorge. Nehmen wir zum Beispiel wieder unsere Kuhfell-Quest: Wir möchten jetzt den Spieler richtig ärgern, und jedes Mal, wenn er eine der Kühe streichelt, zwei Zombies spawnen. Nichts einfacher als das! Wir fügen einfach dem *Objective* für das Streicheln der Kühe eine *Action* hinzu, die zwei Zombies spawnt. -Dann veröffentlichen wir die Quest, und stellen fest, dass sie suuuuper beliebt bei neuen Spielern ist, diese allerdings aber immer an den Zombies sterben. Ideal wäre es jetzt natürlich, wenn wir keine Zombies spawnen, wenn der Spieler unter Level 5 ist. Dafür gibt es *Conditions*: Wir fügen einfach unserer "Spawne Zombies"-Action eine *Condition* hinzu, die überprüft ob der Spieler schon über Level 5 ist - und wenn nicht, wird die Action nicht ausgeführt und es spawnen keine Zombies - aber die restliche Quest läuft wie gewohnt. \ No newline at end of file +Dann veröffentlichen wir die Quest, und stellen fest, dass sie suuuuper beliebt bei neuen Spielern ist, diese allerdings aber immer an den Zombies sterben. Ideal wäre es jetzt natürlich, wenn wir keine Zombies spawnen, wenn der Spieler unter Level 5 ist. Dafür gibt es *Conditions*: Wir fügen einfach unserer "Spawne Zombies"-Action eine *Condition* hinzu, die überprüft ob der Spieler schon über Level 5 ist - und wenn nicht, wird die Action nicht ausgeführt und es spawnen keine Zombies - aber die restliche Quest läuft wie gewohnt. + +## Single- und Multi-Line-Configs + +Quest-Bausteine lassen sich auf zwei (technisch gesehen drei) Arten definieren. Für eine Actions, Objectives und Conditions ist die Kurzform nicht möglich. Dies ist in der Dokumentation vermerkt. + +Nehmen wir als Beispiel einmal die Command-Action. + +#### Als Sektion: +```yaml +letsRunACommand: + type: command + command: /coolerBefehl %player% + op: true + console: false +``` + +Das ist recht lang. Das muss doch kürzer gehen. + +#### Als kurze Sektion: + +```yaml +command: + command: /coolerBefehl %player% +``` + +Schon besser. Wie man sieht, lässt sich der Typ der Action (``command``) auch als Name des Abschnitts nutzen. Und einige Parameter, wie ``op`` und ``console`` sind optional. +Das geht aber noch kürzer. Es gibt auch eine Schreibweise, mit der sich alles in einer Zeile unterbringen lässt: + +#### In einer Zeile: + +```yaml + command: command=/coolerBefehl %player%;op=true +``` + +:::note Wichtig! +Innerhalb eines Abschnitts müssen die Namen immer einzigartig sein. Sprich +```yaml +abschnitt: + command: command=/coolerBefehl %player%;op=true + command: command=/nochEinCoolerBefehl %player%;op=false +``` +geht aktuell **nicht!** + +In Zukunft wird dies allerdings möglich sein. +::: + +## QLocation + +Häufig ist es notwendig, Locations, also Koordinaten in der Welt, anzugeben. Dabei unterstützt QXL relative Koordinaten sowie Positionen innerhalb von Dungeons. + +Das Format für QLocations ist wie folgt: +```yaml +x=;y=;z=;world= +``` + +bzw. in der langen Version +```yaml +abschnitt: + type: teleport # Beispiel + x: + y: + z: + world: +``` + +Für ``world`` kann der Präfix ``dungeon:`` genutzt werden, um ein Dungeon anzugeben. z.B. ``dungeon:kanalisation`` + +x, y und z-Koordinaten können (wie in Vanilla) mit einem ``~`` angegeben werden, um sie in relative Koordinaten zu verwandeln. + +``world`` ist optional. Wird sie nicht angegeben, wird der Spieler in der aktuellen Welt/dem aktuellen Dungeon teleportiert. + +Beispiel: +* ``teleport: x=0;y=64;1000;world:Erethon`` teleportiert den Spieler zu 0,64,1000 in der Welt "Erethon" +* ``spawn_mob: id=Malf; x=~20; y=~0;z=~0`` spawnt den Mob ``Malf`` 20 Blöcke auf der X-Achse vom Spieler entfernt. + +:::note Dungeons +Den Spieler in ein Dungeon zu teleportieren ist *nicht* möglich. +::: + +## Beispiel-Quest +```yaml +displayName: 'Eine kuhle Quest' +description: 'Eine genauere Beschreibung. Benutze \n für neue Zeilen.' + +# Eine Liste der Conditions (Bedingungen), um eine Quest zu starten. +conditions: + noLevel: + # Die Inverted-Condition ist besonders. Sie ist erfüllt, wenn andere Conditions _nicht_ erfüllt sind + type: INVERTED + conditions: + level: + # Hier: Der Spieler kann diese Quest nur machen, wenn er _nicht_ über Level 10 ist. + type: LEVEL + level: 10 + +# Eine Liste an Actions, die ausgeführt werden, wenn die Quest begonnen wird. +onStart: + group: + # z.B. fügen wir den Spieler zur Gruppe "Templer" hinzu + type: PERMISSION + operation: ADD_GROUP + permission: Templer + +# Eine Liste an Actions, die ausgeführt werden, wenn die Quest beendet wird. +# So lassen sich zum Beispiel Belohnungen vergeben, aber auch z.B. direkt eine andere Quest starten. +onFinish: + items: + type: GIVE_ITEM + item: DIAMOND + teleport: Saragandes;100;20;200 +# Die Stages (Abschnitte) der Quest. +stages: + # Die ID dieser Stage. Hier sind nur Zahlen erlaubt + 0: + # Optional. Diese Nachricht wird angezeigt, wenn der Spieler die Stage beginnt. + startMessage: 'Hello' + # Optional. Diese Nachricht wird angezeigt, wenn der Spieler die Stage erfolgreich abschließt. + completeMessage: 'Du hast die erste Stage geschafft!' + # Eine Liste aller Objectives (Ziele) dieser Stage + objectives: + # Ein beliebiger Name. Wird nicht angezeigt. + TestObjective: + # Der Typ des Objectives. Wird immer benötigt. + type: LOCATION + # Die Anzeige, die der Spieler ingame erhält. + display: 'Gehe zu [100, 10, 40].' + # Verschiedene Einstellungen, abhängig vom Objective. + world: Saragandes + x: 100 + y: 10 + z: 40 + range: 5 + # Optional. Objectives können Actions ausführen, wenn sie abgeschlossen werden. + onComplete: + # Auch die Namen der Actions werden nirgends angezeigt. + teleportThePlayer: + type: TELEPORT + world: Saragandes + x: 100 + y: 10 + z: 70 + # Jede Action kann beliebig viele weitere Actions auführen. Diese können hier gelistet werden. + runAfter: + delay: + type: DELAY + delay: 10 + actions: + msg: + type: MESSAGE + message: 'Geh endlich!' + # Auch Actions können Conditions haben. So fordern wir z.B. den Spieler auf endlich zu gehen, wenn er nach 10s immer noch da steht. + conditions: + stillHere: + type: LOCATION + x: 100 + y: 10 + z: 70 + range: 5 + # runAfter: - Das ganze lässt sich beliebig lange fortsetzen. Irgendwann ist es aber sicher sinnvoller, einfach eine neue Stage zu beginnen. + progress: + # Diese Action verändert die aktuelle Stage eines Spielers. So kann z.B. ein Spieler, der ein bestimmtes Objective abschließt, auf Stage 10 landen + # ein Spieler der ein anderes Objective abschließt, jedoch auf Stage 100. So lassen sich Questverzweigungen erstellen. + # Standardmäßig landet ein Spieler immer in der nächsten Stage, wenn alle Objectives abgeschlossen sind. + type: STAGE + id: 1 + + + 1: + startMessage: 'Zweite Stage' + completeMessage: 'Fertig.' + #onStart: - Eine Liste an Actions, die ausgeführt werden, wenn diese Stage begonnen wird. + #onFinish: - Eine Liste an Actions, die ausgeführt werden, wenn diese Stage abgeschlossen wird. + #conditions: - Eine Liste an Bedingungen für den Beginn dieser Stage. Solange diese nicht erfüllt sind, bleibt der Spieler in der vorherigen Stage "stecken". Sollte niemals für die erste Stage genutzt werden. + objectives: + useItem: + type: USE_ITEM + display: 'Benutze cooles Item, während du den Goldblock ansiehst.' + # Der Name des coolen Items. + item: CoolesCustomItem + # Objectives können auch Conditions haben. + conditions: + lookingAt: + type: LOOKING_AT + block: GOLD_BLOCK + onComplete: + sendMessage: + type: MESSAGE + message: 'Toller Goldblock, nicht wahr?' + # <-- Sonstige Optionen --> + #onFail: - Einige Objectives können auch fehlschlagen - zum Beispiel das EscortNPCObjective, wenn der NPC stirbt. Auch dann lassen sich Actions ausführen. + #optional: true/false - Optionale Objectives müssen nicht erfüllt werden, um die Stage abzuschließen + #persistent: true/false - Objectives, die Persistent sind, können nicht erfüllt werden. Das kann z.B. genutzt werden, um den Spieler immer wieder zu teleportieren, wenn er/sie an eine bestimmte Stelle geht. +``` \ No newline at end of file diff --git a/docs/questsxl/objectives.md b/docs/questsxl/objectives.md index c5365d4..f144b9b 100644 --- a/docs/questsxl/objectives.md +++ b/docs/questsxl/objectives.md @@ -1,4 +1,124 @@ --- title: Objectives sidebar_position: 4 ---- \ No newline at end of file +--- + +## Craft +:::caution Nicht implementiert +ItemsXL ist noch nicht so weit :/ +::: +``craft`` + +Ein Item herstellen. Sowohl Vanilla als auch JobsXL-Crafting. + +* **id:** ID des Items. +* **amount:** Menge + +## Enter Region +``enter_region`` + +Eine Region betreten. + +* **id:** ID der Region. + +## Entity Interact +``entity_interact`` + +Mit einer Entity interagieren (Rechtsklick). + +* **id:** Die Entity. Wenn hier ein Vanilla-Typ angegeben wird, zählt *jede* Vanilla-Entity dieses Typs. Ansonsten versucht QXL, einen Aether-NPC mit dieser ID zu finden. + +## Escort NPC +:::caution Nicht implementiert +::: +``escort_npc`` + +Einen NPC bewachen. + +## Experience +:::caution Nicht implementiert +::: +``experience`` + +## Impossible + +Dieses Objective ist unmöglich und wird niemals erfüllt. Kann für Stages nützlich sein. + +## Instant + +Dieses Objective ist sofort erfüllt. Kann für Stages nützlich sein. + +## Item Pickup +:::caution Nicht implementiert +ItemsXL ist noch nicht so weit :/ +::: +``item_pickup`` + +Ein Item aufsammeln. + +* **id:** ID des Items. +* **amount:** Menge + +## Job Experience +``job_exp`` + +In einem Beruf eine bestimmte Menge Erfahrung erreichen. + +* **amount:** Menge +* **reason:** ``command``, ``crafting``, ``dungeon``, ``item``, ``mob``, ``quest``, ``unknown`` + +## Kill Player +``kill_player`` + +Einen oder mehrere Spieler töten. + +* **amount:** Menge der Spieler. Aktuell zählt der gleiche Spieler mehrmals (TODO). + +## Leave Region +``leave_region`` + +Eine Region verlassen. + +* **id:** Die ID der Region. + +## Location +``location`` + +Eine Position erreichen. + +* **distance:** Maximaldistanz zur Location +* **QLocation** + +## Mob +``mob`` + +Einen Mob töten. Funktioniert aktuell nur für mit Aether gespawnte Mobs. + +* **id:** ID des Mobs. +* **amount:** Menge. + +## Server Command +``server_command`` + +/q command (Identifier) wurde ausgeführt. Nützlich zur Integration mit Commandblocks. + +* **identifier:** Der Identifier. + +## Use Item +:::caution Nicht implementiert +ItemsXL ist noch nicht so weit :/ +::: +``use_item`` + +Ein Item nutzen. + +## Wait +:::note Single-Line-Configs +Das Wait-Objective unterstützt keine Single-Line-Configs. +::: + +Warten. + +* **duration:** Wartezeit +* **range:** Entfernung von der Warte-Location. +* **QLocation**