Macros for Dummies - A MapTool Macro-Tutorial (german)

[Thargun]

7.8 - Auf beliebige Tokens zugreifen

Ein Makro bezieht Tokendaten, wie z. B. Properties, immer vom Current Token, in unserem Fall also der verkörperte Token. Was ist aber wenn du Daten von einem anderen Token benötigst, oder die Daten eines anderen Token ändern möchtest? Das ist zum Glück auch kein Problem, und es gibt gleich mehrere Wege zum Ziel.

Erstelle gleich mal einen neuen Token auf der Spieloberfläche und ändere seinen Namen in "Token-Test". Ändere jetzt noch den Wert der Properties Staerke, Geschick und Klugheit dieses Tokens auf jeweils 15. Falls du gerade einen Token verkörpert hast, löse die Verkörperung für die folgenden Beispiele auf (Mausklick auf das kleine "x" beim Tokenbild im Chatbereich).


Token-ID oder Tokenname als Funktionsparameter

Viele Funktionen erlauben als Parameter eine Token-ID oder den Namen eines Tokens. Dadurch greift die Funktion direkt auf diesen Token zu und ignoriert den Current Token. Als Beispiel versuchen wir den Wert der Property "Klugheit" des neuen Tokens herauszufinden. Dafür nutzen wir die bereits bekannte Funktion getProperty().

Mit Hilfe des Tokennamen ist das recht einfach:

Code: Select all

[r: getProperty("Klugheit", "Token-Test")]

Du könntest den Namen natürlich vorher auch in einer Variable speichern:

Code: Select all

[h: ziel.Token = "Token-Test"]
[r: getProperty("Klugheit", ziel.Token)]

Wenn du statt des Namens die ID benutzen möchtest musst du diese vorher natürlich herausfinden. Dafür kannst du wieder die Funktion getSelected() verwenden. In diesem Fall muss vor dem Ausführen des Makros natürlich der Token mit der Maus angewählt werden.

Code: Select all

[h: ziel.Token = getSelected()]
[r: getProperty("Klugheit", ziel.Token)]

Hinweis: Wenn du dir in der MapTool-Wiki einige Funktionen anschaust wirst du besonders bei den Token-Funktionen viele finden, bei denen du eine Token-ID angeben kannst. Es steht zwar nicht dabei, aber in den meisten Fällen kannst du statt der ID auch einen Tokennamen angeben. Oft sinnvoller ist die Angabe der ID, da diese einmalig ist. Tokennamen dagegen können doppelt vorkommen, auch wenn sie es eigentlich nicht sollten.


Die Funktion "switchToken()"

Die Funktion switchToken(), bei der du auch wieder Token-ID oder Tokenname als Parameter angeben kannst, ist etwas Besonderes. Wenn du diese Funktion in einem Makro anwendest, bezieht sich alles was nach dieser Funktion in dem Makro geschieht, auf das als Parameter angegebene Token. Ein Beispiel:

Code: Select all

[h: ziel.Token = getSelected()]
[h: switchToken(ziel.Token)]
Die Staerke des aktuell ausgewaehlten Tokens ist [r: Staerke], das Geschick [r: Geschick], und die Klugheit [r: Klugheit].

Nochmal: Wenn du z. B. in den ersten zehn Zeilen eines Makros verschiedene Token-Properties abfragst oder änderst, bezieht sich das Makro auf den Current Token. In Zeile 11 nutzt du dann die Funktion switchToken(), und in Zeile 12 bis 20 greifst du wieder auf verschiedene Token-Properties zu. Alles nach Zeile 11 bezieht sich dann aber auf den Token, den du bei switchToken() in Zeile 11 als Parameter angegeben hast.


TOKEN Roll Option

Mit der TOKEN Roll Option änderst du für einen Makro-Befehl, z. B. für eine Funktion oder das Ändern einer Property, den Token auf das sich dieser Befehl bezieht. Als Parameter kannst du erneut eine Token-ID, einen Tokennamen, und sogar den GM-Namen eines Tokens angeben. Da es sich um eine Roll Option handelt musst du bei zusätzlicher Verwendung anderer Roll Options, z. B. hide oder result, diese mit einem Komma (,) voneinander trennen. Ein Beispiel:

Code: Select all

[h,token("Token-Test"): Geschick = 16]
[r,token("Token-Test"): getProperty("Geschick")]

Es gibt noch eine weitere Variante dieser Roll Option, bei der du das Token gleich für beliebig viele Makro-Befehle ändern kannst. Dafür verwendest du zusätzlich die CODE Roll Option. Schaue dir das Format dafür an:

Code: Select all

[token(zieltoken), code:
  {
    [Befehl 1]
    [Befehl 2]
  }
]

Dir fällt bestimmt die Syntax, also die Anordnung bzw. Reihenfolge der Klammern und Befehle auf. Diese muss unbedingt eingehalten werden: Zuerst werden alle Roll Options notiert, hier also token und code, wobei die Roll Options wie immer durch ein Komma getrennt werden. Dann folgt ein Doppelpunkt (:) um das Ende der Roll Options anzuzeigen. Anschließend werden beliebig viele Befehle innerhalb geschweifter Klammern notiert, wobei die einzelnen Befehle nochmals in eckigen Klammern notiert werden. Mit einem richtigen Beispiel ist es leichter zu durchschauen:

Code: Select all

[token("Token-Test"), code:
  {
    [h: Staerke = 18]
    [h: Geschick = 18]
    [h: setProperty("Klugheit", 18)]
    [r: "Die Staerke von Token-Test ist "+Staerke+", das Geschick "+getProperty("Geschick")+", und die Klugheit "+Klugheit]
  }
]

Übrigens: Wenn du in der ersten Zeile die TOKEN Roll Option z. B. mit hide kombinierst gilt das auch für alle Befehle innerhalb der geschweiften Klammern {}, so dass du bei diesen Befehlen auf hide verzichten kannst. Wenn du dann allerdings bei einem dieser Befehle die Roll Option result benutzt hat das auch keine Wirkung mehr.

[Thargun]

7.9 - Properties per Funktion erstellen

Abgesehen von dem Weg über die Kampagneneigenschaften gibt es noch eine Möglichkeit Token-Properties zu erstellen. Dafür benutzt du die Funktion setProperty(), mit der du auch den Wert bestehender Properties ändern kannst. Als Parameter müssen der Name der neuen Property und deren Wert angegeben werden. Das Format lautet:

Code: Select all

setProperty(property, value)

Hier ein Beispiel:

Code: Select all

[h: setProperty("NeueProperty", 22)]

Wenn du eine Property auf diese Weise erstellst gibt es ein paar Dinge die du beachten musst:

• Die Property wird nur für den Current Token erstellt, in unserem Fall also der verkörperte Token. Andere Tokens besitzen diese Property dann nicht.
• Die Property taucht nicht in der Properties-Liste des Tokens auf. Sie ist also quasi unsichtbar.
• Um auf die Property zuzugreifen und deren Wert zu erhalten musst du immer die Funktion getProperty() benutzen.
• Um auf die Property zuzugreifen und deren Wert zu ändern musst du immer die Funktion setProperty() benutzen.

[Thargun]

7.10 - Token Typen

Gehe mal wieder in die Kampagneneigenschaften und dort zum Tab "Token Properties". Auf der linken Seite fällt dir nun sicherlich die Spalte Token Type auf. Hier wählst du normalerweise "Basic" an wenn du die Standard-Properties ändern möchtest.

"Basic" ist also ein Token Type, das ist eine Sammlung an Standard-Properties die du für Tokens nutzen kannst. Du kannst noch weitere Token Types erstellen. Klicke unter der Spalte auf den Button "New", gebe dann rechts oben beim Eingabefeld "Name" (über dem Eingabefeld für die Properties) die Bezeichnung "Enemy" ein (ohne Anführungszeichen), und klicke dann unten auf den Button "Update".

Klicke auf den Token Type "Enemy", so dass es blau hinterlegt ist. Gebe jetzt rechts im Eingabefeld wieder unsere bekannten Properties ein, aber mit anderen Standardwerten:

Code: Select all

Staerke:16
Geschick:14
Klugheit:9
Angriff:15
Verteidigung:13
HP:40
Ruestung:3

Klicke dann wieder auf den Button "Update" und abschließend unten auf "OK".

Jetzt ziehe einen neuen Token auf die Spieloberfläche, mache einen Doppelklick darauf und wechsele zum Tab "Config". Dort kannst du auf der linken Seite im Dropdown-Menü "Properties" nun wählen welchen Token Type, also welche Standard-Properties, du für diesen Token nutzen willst. Wähle "Enemy" und klicke unten auf den Button "OK". Nun mache erneut einen Doppelklick auf den Token und schaue dir die Properties an. Du siehst, dass für diesen Token nun die Properties und Werte des Token Type "Enemy" genutzt werden.

Verschiedene Token Types können sehr nützlich sein. So kannst du z. B. Gegnern, also NPC-Tokens, schnell andere Werte für die Properties zuweisen. Oder du könntest auch einen neuen Token Type für Tiere erstellen, die dann vielleicht ganz andere Properties haben.

Tokens, die du neu auf die Spieloberfläche ziehst, nutzen immer den Token Type "Basic". Möchtest du einen anderen Token Type verwenden musst du das immer manuell im Token umstellen. Um einen Token Type wieder zu löschen wähle ihn in den Kampagneneigenschaften auf der linken Seite aus, lösche dann seine Bezeichnung auf der rechten Seite im Feld "Name", und klicke anschließend auf "Update" und schließlich auf "OK".

[Thargun]

7.11 - Properties in Library Tokens

Erinnerst du dich noch an die Library Tokens aus Kapitel "3.1 - Wo werden Makros gespeichert"? Erstelle jetzt solch ein Library Token mit dem Namen Lib:makros, und beachte dabei auch die Regeln aus dem genannten Kapitel.

Wie normale Tokens besitzen auch Library Tokens Properties. Da Library Tokens ohnehin dafür gedacht sind Makros zu speichern, bieten sie sich perfekt dazu an in ihren Properties auch Optionen zu speichern, auf die deine Makros zugreifen können.

Wofür das gut sein soll? Stelle dir z. B. ein Rollenspiel-Regelwerk vor das für Angriffswürfe optional einen Bonus vorsieht. Manche Spielgruppen möchten vielleicht mit dieser optionalen Regel und dem Bonus spielen, manche vielleicht aber auch nicht. Jetzt könntest du in einem Library Token dafür eine Property erstellen. Der Wert "1" würde dann bedeuten, dass die Regel für den Bonus benutzt wird, und der Wert "0" würde bedeuten, dass die Regel nicht benutzt wird. In einem Angriffsmakro könntest du dann den Wert der Property abfragen, und je nachdem welcher Wert zurückgegeben wird den Bonus beim Angriff miteinberechnen oder eben nicht. Außerdem kannst du ein weiteres Makro schreiben mit dem du den Wert der Property ändern, und somit die Option bzw. den Angriffsbonus ein- oder ausschalten kannst.

Bestimmt fallen dir mit der Zeit noch weitere Anwendungsmöglichkeiten ein. Natürlich ist es dann aber wenig sinnvoll die Standard-Properties von normalen Charaktertokens zu benutzen. Erstelle also einen neuen Token Type mit dem Namen "Optionen" und trage folgende Standard-Properties (ohne Standardwerte) ein:

Code: Select all

BonusAngriff
BonusVerteidigung

Stelle dann noch den Library-Token auf den neuen Token Type um und ändere direkt im Token die Property "BonusAngriff" auf "1" und die Property "BonusVerteidigung" auf "0".

So, kommen wir nun aber zum eigentlichen Thema des Kapitels. Properties in einem Library Token abzurufen, oder zu ändern, funktioniert ähnlich wie bei normalen Tokens. Du musst dafür allerdings zwei spezielle Funktionen benutzen.

Zum Abrufen der Property benutzt du getLibProperty(). Als Parameter werden dabei der Name der Property angegeben, und der Name des Library Tokens. Schließlich kann es ja auch mehrere Library Tokens geben, und die Funktion muss ja wissen, welches es benutzen soll. So etwas wie ein Current Token gibt es bei Library Tokens also nicht. Das Beispiel:

Code: Select all

[r: getLibProperty("BonusAngriff", "Lib:makros")]

Hinweis: Die Funktion getLibProperty() gibt keine Standardwerte von Properties zurück, daher solltest du bei Properties, die für ein Library Token bestimmt sind, auch keine Standardwerte eintragen. Wenn solche Properties trotzdem einen Anfangswert haben sollen, trage diese direkt im Library Token ein.

Zum Ändern einer Property in einem Library Token wird die Funktion setLibProperty() genutzt. Hier gibt es dann noch einen zusätzlichen Parameter, nämlich den neuen Wert für die Property. Im folgenden Beispiel ist der neue Wert "1":

Code: Select all

[h: setLibProperty("BonusVerteidigung", 1, "Lib:makros")]
[r: getLibProperty("BonusVerteidigung", "Lib:makros")]

[Thargun]

7.12 - Mögliche Werte für Properties

Datentypen

Bisher hast du Properties immer nur Zahlen als Wert zugewiesen, aber das ist genauso gut mit jedem anderen Datentyp möglich. Gehe in die Kampagneneigenschaften und erstelle die neue Property "TestProp", und zwar ohne einen Standardwert. Dann verkörpere einen Token.

Da du Properties wie Variablen behandeln kannst, kannst du auch die üblichen Wege nutzen um einer Property einen Wert eines beliebigen Datentyps zuzuweisen. Hier drei Beispiele für Strings, String Listen und String Property Listen:

Code: Select all

[h: TestProp = "Das ist ein String"]
[r: TestProp]

Code: Select all

[h: stringList = "Item 1, Item 2, Item 3"]
[h: TestProp = stringList]
[r: TestProp]

Code: Select all

[h: TestProp = "Waffe1Name=Schwert; Waffe1Typ=Klingenwaffe"]
[r: TestProp]

Und natürlich kannst du alle typischen Funktionen für die Datentypen auch mit Properties nutzen, und damit dann z. B. Einträge in String Listen oder String Property Listen hinzufügen, ändern oder löschen.

Du kannst bei Erstellen neuer Properties in den Kampagneneigenschaften ebenfalls Strings, String Listen oder String Property Listen als Standardwert festlegen. Lasse dann einfach die Anführungszeichen weg. Ein Beispiel mit einer String Property Liste:

Code: Select all

TestProp:Waffe1Name=Schwert; Waffe1Typ=Klingenwaffe

Selbstverständlich kannst du Properties dieser Datentypen auch direkt manuell in einem Token eintragen. In diesem Fall lässt du dann ebenfalls einfach die Anführungszeichen weg.


Kalkulationen

Wenn du Properties in den Kampagneneigenschaften einen Standardwert zuweist, oder das manuell im Token machst, kannst du sogar Kalkulationen und Funktionen als Wert angeben. Bei Rechnungen ist auch die Nutzung anderer Properties möglich. Jedes Mal wenn du die Property abrufst wird dann die Rechnung bzw. Funktion ausgeführt und das Ergebnis zurückgeliefert. Dafür muss der Wert allerdings in geschweiften Klammern angegeben werden.

Erstelle in den Kampagneneigenschaften drei neue Properties mit Standardwerten:

Code: Select all

TestProp2:{Klugheit+5}
TestProp3:{Staerke+Geschick}
TestProp4:{round(5.45)}

Lasse dir die Properties jetzt nacheinander im Chat ausgeben. Du wirst immer das Ergebnis der Kalkulation sehen. Anschließend ändere mal den Wert für Klugheit in deinem Token, und lasse dir TestProp2 erneut im Chat ausgeben. Selbstverständlich hat sich jetzt auch hier das Ergebnis geändert.

Solche Kalkulationen als Werte für Properties zu verwenden kann in vielen Situationen natürlich recht verführerisch sein. Aber sei vorichtig damit und überlege dir den Einsatz gut! Am flexibelsten bist du immer noch wenn du jegliche Kalkulationen direkt in den Makros ausführst, und nicht in Properties.

[Thargun]

7.13 - Token-Funktionen

In der MapTool-Wiki findest du eine Liste aller Token-Funktionen, mit deren Hilfe du Tokendaten, also z. B. Properties, abrufen oder ändern kannst. Tokens sind ein wesentlicher Bestandteil von MapTool, daher wirst du wahrscheinlich oft mit diesen Funktionen arbeiten. Schaue dir doch schon mal ein paar dieser Funktionen an und probiere das eine oder andere aus.

[Thargun]

8 - Codeverzweigungen

8.1 - IF als Funktion: Wenn...dann...sonst...

Nicht nur im Leben, auch in Makros können sich Dinge in verschiedene Richtungen entwickeln. Im Leben kannst du auf eine Situation reagieren. Wenn ein Makro aber erst mal läuft hast du keinen Einfluss mehr darauf. Aus diesem Grund musst du dich schon vorher auf alle Möglichkeiten vorbereiten.

Z. B. bei einem Angriffswurf. Der kann gelingen oder daneben gehen. Damit du auf beide Ergebnisse vorbereitet bist, kannst du die IF-Funktion benutzen. Diese Funktion beinhaltet eine Bedingung bei der zwei Werte miteinander verglichen werden. Und je nachdem ob die Bedingung zutrifft oder nicht geschieht etwas anderes.

In deinen Token-Properties hast du für Angriff "14" eingetragen. Sagen wir der Angriffswurf mit einem 20-seitigen Würfel muss kleiner oder gleich deines Angriffwerts sein, damit der Angriff gelingt. Dann könnte das so aussehen:

Code: Select all

[r: if(1d20 <= Angriff, "Erfolgreicher Angriff!", "Misserfolg!")]

Achte auf die Syntax: Der erste Parameter der IF-Funktion beinhaltet die Bedingung, also den Vergleich von zwei Werten. Der zweite Parameter enthält den String der zurückgeliefert wird, wenn die Bedingung zutrifft. Der dritte Parameter enthält den String der zurückgeliefert wird, wenn die Bedingung nicht zutrifft. In diesem Fall also:

Wenn das Ergebnis von 1d20 kleiner oder gleich 14 ist, dann wird "Erfolgreicher Angriff!" zurückgeliefert, sonst wird "Misserfolg!" zurückgeliefert.

Für die beiden zu vergleichenden Werte, sowie für die beiden möglichen Rückgabewerte, kannst du wie immer Variablen, Properties, Funktionen, Zahlen oder Strings einsetzen. Dieses Prinzip solltest du mittlerweile verinnerlicht haben, deswegen werde ich es zukünftig nicht mehr erwähnen. Und ja, auch Strings kannst du miteinander vergleichen. Im Beispiel oben würde das allerdings nicht funktionieren, denn ein String kann nicht kleiner sein als ein anderer (es geht dabei also nicht um die Zeichenanzahl).

Die IF-Funktion als Codeverzweigung ist eigentlich nur in recht kleinen Makros nützlich. Es gibt aber noch zwei mächtigere Varianten, die du schon bald kennenlernen wirst.

[Thargun]

8.2 - Operatoren


Vergleichende Operatoren

Wie der Name bereits verrät kannst du mit vergleichenden Operatoren zwei Werte auf verschiedene Art und Weise miteinander vergleichen. Im letzten Kapitel hast du schon so einen Operator benutzt, nämlich <= (kleiner oder gleich). Selbstverständlich gibt es noch ein paar mehr, die ich dir an einigen einfachen Beispielen erläutern möchte. Probiere sie alle aus, und verändere auch mal die Werte der Bedingungen damit du einen anderen Rückgabewert erhältst.

== (ist gleich zu)
Prüft ob der Wert auf der linken Seite der Bedingung dem Wert auf der rechten Seite gleicht. Achte darauf, dass es sich hier um zwei aufeinanderfolgende Gleichheitszeichen handelt. Einzelne Gleichheitszeichen werden immer nur beim Definieren von Variablen oder Properties benutzt.

Code: Select all

[r: if(10 == 10, "Die Werte sind gleich", "Die Werte unterscheiden sich")]

!= (ist nicht gleich zu)
Prüft ob sich der Wert auf der linken Seite der Bedingung vom Wert auf der rechten Seite unterscheidet.

Code: Select all

[r: if(24 != 18, "Die Werte sind unterschiedlich", "Die Werte sind gleich")]

< (ist kleiner als)
Prüft ob der Wert auf der linken Seite der Bedingung kleiner ist als der Wert auf der rechten Seite.

Code: Select all

[r: if(12 < 15, "Der Wert ist kleiner", "Der Wert ist nicht kleiner")]

<= (ist kleiner als oder gleich zu)
Prüft ob der Wert auf der linken Seite der Bedingung kleiner ist als der Wert auf der rechten Seite, oder ob er gleich dazu ist.

Code: Select all

[r: if(15 <= 15, "Der Wert ist kleiner oder gleich", "Der Wert ist groesser")]

> (ist größer als)
Prüft ob der Wert auf der linken Seite der Bedingung größer ist als der Wert auf der rechten Seite.

Code: Select all

[r: if(39 > 28, "Der Wert ist groesser", "Der Wert ist nicht groesser")]

>= (ist größer als oder gleich zu)
Prüft ob der Wert auf der linken Seite der Bedingung größer ist als der Wert auf der rechten Seite, oder ob er gleich dazu ist.

Code: Select all

[r: if(9 >= 7, "Der Wert ist groesser oder gleich", "Der Wert ist kleiner")]

Strings vergleichen

Wenn du Strings miteinander vergleichen möchtest sind nur die Operatoren == und != möglich. Zwei Beispiele dazu:

Code: Select all

[r: if("Test" == "Test", "Die Werte sind gleich", "Die Werte unterscheiden sich")]

Code: Select all

[r: if("Test" != "Ein anderer Test", "Die Werte sind unterschiedlich", "Die Werte sind gleich")]

Logische Operatoren

Mit logischen Operatoren kannst du zwei oder mehr Bedingungen kombinieren und somit beliebig viele Bedingungen auf einmal überprüfen. Dadurch kannst du z. B. feststellen ob eine Zahl, z. B. das Ergebnis eines Würfelwurfs, größer als 5 ist, gleichzeitig aber auch kleiner als 15. Es gibt zwei logische Operatoren, schauen wir sie uns wieder mit Beispielen an.

&& (und)
Bedingungen die du mit diesem Operator kombinierst gelten quasi als eine große Bedingung. Nur wenn alle einzelnen, bzw. kombinierten Bedingungen zutreffen, gilt diese große Bedingung ebenfalls als zutreffend.

Code: Select all

[h: wuerfel = 1d20]
[r: if(wuerfel > 5 && wuerfel < 15, "Das Ergebnis ist groesser als 5 und kleiner als 15", "Das Ergebnis ist kleiner als 6 oder groesser als 14")]

|| (oder)
Mit diesem Operator kombinierte Bedingungen gelten ebenfalls als eine große Bedingung. Hier langt es aber schon wenn eine einzige der einzelnen, bzw. kombinierten Bedingungen zutrifft, damit auch die große Bedingung als zutreffend gilt.

Code: Select all

[h: wuerfel = 1d20]
[r: if(wuerfel < 5 || wuerfel > 15, "Das Ergebnis ist kleiner als 5 oder groesser als 15", "Das Ergebnis liegt zwischen 4 und 16")]

[Thargun]

8.3 - IF als Roll Option

Statt der IF-Funktion kann auch die IF-Roll Option genutzt werden. Dabei gibt es zwei wesentliche Unterschiede. Der eine ist die Syntax:

Code: Select all

[if(Bedingung): Befehl wenn die Bedingung zutrifft; Befehl wenn die Bedingung nicht zutrifft]

Zuerst wird die IF-Roll Option inklusive Bedingung (in runden Klammern) notiert, dann kommt ein Doppelpunkt (:) um das Ende der Roll Options anzuzeigen. Jetzt folgt der Befehl falls die Bedingung zutrifft, und anschließend, durch ein Semikolon (;) getrennt, der Befehl falls die Bedingung nicht zutrifft. Denke daran: Bei Kombination mit anderen Roll Options, z. B. result oder hide, müssen diese mit einem Komma getrennt werden (auch das solltest du jetzt verinnerlicht haben und wird zukünftig nicht mehr erwähnt).

Der zweite Unterschied ist, dass es sich bei den Befehlen nicht um einfache Rückgabewerte handelt, sondern immer um eine Wertezuweisung einer Variable oder Property (was bei der normalen IF-Funktion gar nicht möglich ist). Das schauen wir uns am besten anhand eines Beispiels an. Erneut ein Angriffswurf:

Code: Select all

[h,if(1d20 <= Angriff): ausgabe = "gelungen"; ausgabe = "misslungen"]
Der Angriff ist [r: ausgabe].

Kombination mit der CODE-Roll Option

Die IF-Roll Option lässt sich auch mit der CODE-Roll Option kombinieren. Dadurch können, ob die Bedingung nun zutrifft oder nicht, gleich mehrere Befehle ausgeführt werden. Die Syntax:

Code: Select all

[if(Bedingung), code:
  {
    [Befehl 1]
    [Befehl 2]
    [Befehl 3]
  };
  {
    [Befehl 1]
    [Befehl 2]
    [Befehl 3]
  }
]

Zuerst werden alle Roll Options notiert, hier also if (inklusive Bedingung in runden Klammern) und code. Dann wieder ein Doppelpunkt (:) um das Ende der Roll Options anzuzeigen. Nun folgen in geschweiften Klammern alle Befehle die ausgeführt werden sollen falls die Bedingung zutrifft, wobei die einzelnen Befehle nochmals in eckigen Klammern eingeschlossen werden. Anschließend wird ein Semikolon (;) als Abtrennung notiert. Schließlich folgen, erneut in geschweiften Klammern, alle Befehle die ausgeführt werden sollen wenn die Bedingung nicht zutrifft.

Als Beispiel wieder ein Angriffswurf, bei dessen Gelingen auch gleich der Schaden ausgewürfelt werden soll:

Code: Select all

[h,if(1d20 <= Angriff), code:
  {
    [ausgabe = "gelungen"]
    [schaden = 1d6+2]
  };
  {
    [ausgabe = "misslungen"]
    [schaden = 0]
  }
]
Der Angriff ist [r: ausgabe]. Verursachter Schaden: [r: schaden]

Beachte die zusätzliche Angabe der Roll Option hide in der ersten Zeile. Diese Angabe wirkt sich auf alle Befehle innerhalb der gesamten IF-Anweisung aus, so dass keiner dieser Befehle in der Chatbox angezeigt wird.

[Thargun]

8.4 - SWITCH: Die Qual der Wahl

Bei der IF-Anweisung gibt es immer zwei Möglichkeiten, entweder trifft die Bedingung zu oder eben nicht. Wenn nun aber mehrere Möglichkeiten bestehen, und bei jeder etwas anderes geschehen soll, eignet sich SWITCH sehr gut dafür. Bei der SWITCH-Anweisung wird immer eine Variable (oder auch eine Property) überprüft. Je nachdem was die Variable dann enthält geschieht etwas anderes. SWITCH ist eine Roll Option, denke also an die entsprechenden Regeln.

Das Format von SWITCH:

Code: Select all

[switch(variable):
  case Möglichkeit1: Befehl;
  case Möglichkeit2: Befehl;
  case Möglichkeit3: Befehl;
  default: Standard-Befehl
]

In der ersten Zeile wird die SWITCH-Roll Option notiert und die zu überprüfende Variable angegeben. In Zeile zwei bis vier werden dann die möglichen Inhalte der Variable angegeben. Dabei folgt immer ein Doppelpunkt und ein Makro-Befehl, der ausgeführt wird falls der mögliche Inhalt tatsächlich mit dem Inhalt der Variable übereinstimmt. Die einzelnen Zeilen werden dabei mit einem Semikolon (;) getrennt. In Zeile fünf wird dann noch ein Standard-Befehl angegeben, der immer dann ausgeführt wird wenn keiner der möglichen Inhalte mit dem Inhalt der Variable übereinstimmt. Bei dieser letzten Zeile darf dann kein Semikolon mehr notiert werden.

Was passiert hier also im Klartext?

1. Der Parser schaut sich den Inhalt der Variable an.
2. Der Parser überprüft Zeile für Zeile ob eine der Möglichkeiten mit dem Inhalt der Variable übereinstimmen.
3. Falls eine Übereinstimmung gefunden wird, wird der dazugehörige Befehl ausgeführt.
4. Falls keine Übereinstimmung gefunden wird, wird der Standard-Befehl ausgeführt.

Beachte: Sobald eine Übereinstimmung gefunden wurde, werden alle nachfolgenden Möglichkeiten ignoriert und nicht mehr überprüft. Die SWITCH-Anweisung endet dann also nach dem Ausführen des entsprechenden Befehls.

Kommen wir zum Beispiel. Stelle dir vor dein Charakter wird von etwas getroffen und erhält Schaden. Je nachdem wie viel Schaden der Charakter erhält soll ein bestimmter Text ausgegeben werden:

Code: Select all

[h: schaden = 1d8]
[h,switch(schaden):
  case 1: treffer.text = "Nur ein Kratzer.";
  case 2: treffer.text = "Ein bisschen Blut.";
  case 3: treffer.text = "Eine schmerzhafte Verletzung.";
  case 4: treffer.text = "Eine ernsthafte Wunde.";
  case 5: treffer.text = "Das Blut spritzt in alle Richtungen!";
  default: treffer.text = "Ein sehr schwerer Treffer, du wirst ohnmaechtig!"
]
Du erhaeltst [r: schaden] Schadenspunkte: [r: treffer.text]

Erhält der Charakter also 1-5 Schadenspunkte wird der entsprechende Text ausgegeben. Erhält der Charakter aber mehr als 5 Schadenspunkte wird der Text im Standard-Befehl ausgegeben.


Kombination mit der CODE-Roll Option

SWITCH kann ebenfalls wieder mit CODE kombiniert werden um gleich mehrere Befehle auszuführen. Das Format:

Code: Select all

[switch(variable), code:
  case Möglichkeit1:
    {
      [Befehl 1]
      [Befehl 2]
    };
  case Möglichkeit2:
    {
      [Befehl 1]
      [Befehl 2]
    };
  default:
    {
      [Befehl 1]
      [Befehl 2]
    }
]

Auch hier werden zuerst die Roll Options notiert und anschließend, erneut durch ein Semikolon (;) getrennt, die verschiedenen Möglichkeiten. Dabei werden die auszuführenden Befehle zu jeder Möglichkeit nochmals in geschweiften Klammern notiert.

Im Beispiel, dieses Mal mit Strings statt Zahlen, wirst du einem Charakter passend zu seiner Charakterklasse eine Rüstung zuweisen. Nicht aufgeführte Charakterklassen erhalten keine Rüstung. Wir kombinieren das mit einer Usereingabe, legen also keinen Wert für die zu überprüfende Variable fest, damit du die verschiedenen Möglichkeiten selbst ausprobieren kannst.

Code: Select all

[h,switch(charakter.klasse), code:
  case "Ritter":
    {
      [ruestung.titel = "Plattenruestung"]
      [ruestung.wert = 3]
    };
  case "Krieger":
    {
      [ruestung.titel = "Kettenruestung"]
      [ruestung.wert = 2]
    };
  case "Barbar":
    {
      [ruestung.titel = "Lederruestung"]
      [ruestung.wert = 1]
    };
  default:
    {
      [ruestung.titel = "Keine"]
      [ruestung.wert = 0]
    }
]
Erhaltene Ruestung: [r: ruestung.titel] ([r: ruestung.wert] Ruestungspunkte)

[Thargun]

8.5 - CODE-Blöcke ohne Befehle

Wenn du die CODE-Roll Option benutzt werden die geschweiften Klammern mit den Befehlen immer als "Codeblock" bezeichnet. Bei einer IF-Anweisung gibt es also zwei Codeblöcke:

Code: Select all

[if(Bedingung), code:
  {
    Codeblock 1
  };
  {
    Codeblock 2
  }
]

Nun könnte es ja sein, dass nur Makro-Befehle ausgeführt werden sollen wenn die Bedingung zutrifft, aber nichts geschehen soll wenn die Bedingung nicht zutrifft (oder umgekehrt). Auch das ist kein Problem:

Code: Select all

[if(Bedingung), code:
  {
    [Befehl 1]
    [Befehl 2]
  };{}
]

Der entsprechende Codeblock wird dann einfach ohne Inhalt notiert (also nur die geschweiften Klammern). Er darf aber nicht weggelassen werden! Das funktioniert bei der SWITCH-Anweisung genauso, auch dort kannst du Codeblöcke ohne Inhalt notieren.

[Thargun]

8.6 - Verschachtelte Codeverzweigungen

Wenn du IF oder SWITCH mit der CODE-Roll Option kombinierst kannst du diese auch beliebig ineinander verschachteln. Das schauen wir uns am besten anhand eines Beispiels an.

Wieder geht es um einen Angriffswurf bei dessen Erfolg auch gleich der Schaden ausgewürfelt wird. Doch wenn der Angriffswurf besonders gut gelingt, also eine "1" gewürfelt wird, soll der Schaden verdoppelt werden:

Code: Select all

[h: angriffswurf = 1d20]
[h,if(angriffswurf <= Angriff), code:
  {
    [if(angriffswurf == 1), code:
      {
        [angriff.text = "sehr gut gelungen"]
        [schaden = 1d6 * 2]
      };
      {
        [angriff.text = "gelungen"]
        [schaden = 1d6]
      }
    ]
  };
  {
    [angriff.text = "misslungen"]
    [schaden = 0]
  }
]
Der Angriff ist [r: angriff.text] und du verursachst [r: schaden] Schadenspunkte.

Zuerst wird der eigentliche Angriffswurf in einer Variable gespeichert. Dann wird eine IF-Anweisung ausgeführt die prüft ob der Angriff gelungen ist. Ist er gelungen, wird eine weitere IF-Anweisung ausgeführt die prüft ob der Angriffswurf sehr gut gelungen ist, also ob eine "1" gewürfelt wurde. Je nachdem ob das zutrifft oder nicht wird der Schaden verdoppelt oder nur einfach ausgewürfelt, und ein entsprechender Text für die Ausgabe in der Chatbox in einer Variable gespeichert.


Was lässt sich verschachteln?

Bei dieser Art von Verschachtelungen muss es sich nicht unbedingt um IF-Anweisungen wie im obigen Beispiel handeln. Tatsächlich lässt sich alles beliebig ineinander verschachteln was die CODE-Roll Option benutzt, egal ob IF, SWITCH, TOKEN oder diverse Schleifenanweisungen die ebenfalls die CODE-Roll Option benutzen, und die du später noch kennenlernen wirst.


Das Limit von Verschachtelungen

MapTool besitzt ein Limit bei Verschachtelungen der CODE-Roll Option, es dürfen maximal zwei Ebenen verschachtelt werden. Im ersten Codeblock des obigen Beispiels ist das bereits der Fall: In der inneren IF-Anweisung kannst du zwar beliebig viele Makro-Befehle notieren, darfst aber nicht nochmal die CODE-Roll Option nutzen. Allerdings könntest du im zweiten Codeblock der äußeren IF-Anweisung noch einmal die CODE-Roll Option nutzen, denn dort gibt es ja noch keine Verschachtelung.

Um ehrlich zu sein geht es bei dem Limit aber gar nicht um die CODE-Roll Option selbst, damit hat es sich einfach nur gut erklären lassen. Tatsächlich betrifft das Limit die geschweiften Klammern die dort benutzt werden. Es darf also nicht mehr als zwei Ebenen geschweifter Klammern geben. Das ist wichtig zu wissen wenn du z. B. später mit Fenstern arbeitest, deren Inhalt ebenfalls in geschweiften Klammern notiert wird.

Wenn du das Limit nicht einhältst wirst du Probleme mit deinen Makros bekommen, das kann sogar zu Abstürzen von MapTool führen. Und solltest du irgendwo lesen, dass man das Limit doch umgehen kann: Ja, das stimmt. Allerdings sind dazu schmutzige Tricks nötig die "dreckigen" Code erzeugen und offiziell nicht von MapTool unterstützt werden. Das kann dann auch schnell zur Inkompatibilität mit anderen MapTool-Versionen führen. Also: Halte dich an das Limit!

[Thargun]

9 - Usereingaben mit input()

9.1 - Grundlagen

Für die Usereingabe eine nicht definierte Variable zu verwenden, wie wir das bisher gemacht haben, ist weder elegant noch praktisch. Mit der Funktion input() lässt sich da schon einiges mehr anstellen.

Zuerst eine ganz einfache Variante, bei der du als Parameter die Variablen angibst in denen die Usereingaben gespeichert werden sollen. Die Namen der zu erstellenden Variablen müssen dabei in doppelte Anführungszeichen gesetzt, und durch Kommata voneinander getrennt werden:

Code: Select all

[h: input("zahl1", "zahl2", "zahl3")]

Beim Ausführen dieses Makros wird ein Eingabefenster mit drei Textfeldern angezeigt, in die der User entweder Text oder Zahlen eingeben kann. Diese Eingaben werden dann in den zugehörigen Variablen gespeichert werden.



Diese Methode ist allerdings immer noch nicht sehr schön, denn dem User werden als Bezeichnung der Textfelder wieder nur die Variablennamen angezeigt. Wir arbeiten trotzdem noch etwas damit weiter.

Wenn du in einem Makro input() benutzt wird an entsprechender Stelle das Eingabefenster angezeigt. Dann wird das Makro allerdings erst mal angehalten, damit der User in Ruhe seine Eingaben machen kann. Erst wenn der User im Eingabefenster auf die Schaltfläche "OK" klickt läuft das Makro weiter. Im folgenden Beispiel wird also das Eingabefenster aufgerufen, und erst wenn du auf "OK" klickst die eingegebenen Zahlen zusammengerechnet und das Ergebnis der Addition in der Chatbox ausgegeben:

Code: Select all

[h: input("zahl1", "zahl2", "zahl3")]
[h: ergebnis = zahl1+zahl2+zahl3]
[r: ergebnis]

Was aber passiert wenn der User auf "Abbrechen" klickt? In diesem Fall sollte das Makro eigentlich abgebrochen werden. Wird es aber nicht, und das führt dann zu Fehlern oder ungewollten Konsequenzen. Probiere es ruhig mal mit dem letzten Beispiel aus. Damit das Makro abgebrochen wird müssen wir also ein bisschen nachhelfen.

Auch die Funktion input() liefert einen Rückgabewert. Klickt der User im Eingabefenster auf "OK", ist der Rückgabewert "1". Klickt er dagegen auf "Abbrechen", ist der Rückgabewert "0". Damit du den Rückgabewert aber nutzen kannst, musst du diesen erst mal in einer Variable speichern:

Code: Select all

[h: status = input("zahl1", "zahl2", "zahl3")]

Jetzt benötigst du noch eine weitere Funktion: abort(). Als Parameter wird eine beliebige Zahl akzeptiert. Ist diese Zahl eine "0", wird das Makro an dieser Stelle abgebrochen und nicht weiter ausgeführt. Außerdem werden jegliche Ausgaben in der Chatbox unterdrückt. Handelt es sich bei dem Parameter aber um eine andere Zahl als "0", passiert einfach nichts und das Makro läuft normal weiter. Merkst du schon worauf ich hinaus will?

Wir notieren die Funktion abort() einfach direkt unter dem Code für das input()-Fenster, und geben als Parameter die Variable an in der der Rückgabewert von input() gespeichert ist:

Code: Select all

[h: status = input("zahl1", "zahl2", "zahl3")]
[h: abort(status)]
[h: ergebnis = zahl1+zahl2+zahl3]
[r: ergebnis]

Klickt der User im Eingabefenster also auf "OK", ist der Rückgabewert von input(), der ja auch als Parameter für abort() benutzt wird, eine "1". Das Makro läuft dann also normal weiter. Klickt der User dagegen auf "Abbrechen", ist der Rückgabewert von input() eine "0", und das Makro wird an dieser Stelle abgebrochen.

[Thargun]

9.2 - Sub-Parameter

Statt nur die eigentlichen Variablen als Parameter bei input() anzugeben, kannst du zu jeder Variable noch so genannte Sub-Parameter angeben. Dadurch kannst du die Eingabefelder besser gestalten und zusätzliche Optionen zu jedem Feld angeben. Das Format der eigentlichen Parameter ist dann wie folgt:

Code: Select all

"VariableName|Wert|Titel|InputTyp|Optionen"

Schauen wir uns das genauer an:

VariableName
Der Name der Variable für das Eingabefeld, in der die Usereingabe dann auch gespeichert wird.

Wert
Der Anfangswert, der beim Aufrufen des Eingabefensters im Eingabefeld angezeigt wird.

Titel
Der Titel des Eingabefelds, der vor dem eigentlichen Feld angezeigt wird.

InputTyp
Der Typ des Eingabefelds, z. B. "TEXT" oder "LIST".

Optionen
Je nach Typ des Eingabefelds können noch zusätzliche Optionen angegeben, und das Eingabefeld dadurch auf verschiedene Art und Weise beeinflusst werden. Optionen werden nach dem Format "Option=Optionswert" notiert, wobei mehrere Optionen durch einfache Leerzeichen voneinander getrennt werden.

Im folgenden Beispiel erstellen wir zwei einfache Textfelder, der InputTyp ist also TEXT. Zusätzliche Optionen geben wir dabei nicht an:

Code: Select all

[h: status = input(
  "spieler.name|Bitte Name eingeben|Dein Name|TEXT",
  "spieler.alter|Bitte Alter eingeben|Dein Alter|TEXT"
)]
[h: abort(status)]
Dein Name ist [r: spieler.name] und du bist [r: spieler.alter] Jahre alt.

[Thargun]

9.3 - Input Typen

Hier zeige ich dir die verschiedenen Input Typen und was sie bewirken. Wenn du keine Optionen bei einem Eingabefeld notierst wird immer deren Standardwert genutzt. In einem Eingabefenster kannst du natürlich auch mehrere Eingabefelder mit verschiedenen Input Typen erstellen.


TEXT

Erstellt ein Textfeld, das auch für die Eingabe von Zahlen geeignet ist. Die Eingabe wird in der zugeordneten Variable gespeichert. Wenn kein Anfangswert festgelegt wurde beträgt dieser "0".

Mögliche Optionen:

WIDTH=xxx
Legt die Breite für das Textfeld fest. Der Standardwert ist "WIDTH=16".

SPAN=TRUE
Erlaubt dem Textfeld die Ausdehnung in die gesamte Breite des Eingabefensters. Der Titel des Textfelds wird dabei versteckt und nur als Tooltip des Textfelds angezeigt. Der Standardwert ist "SPAN=FALSE".

Beispiel:

Code: Select all

[h: status = input(
  "eingabe1|Erstes Eingabefeld|Das erste Eingabefeld|TEXT",
  "eingabe2|Zweites Eingabefeld|Das zweite Eingabefeld|TEXT|WIDTH=30",
  "eingabe3|Drittes Eingabefeld|Das dritte Eingabefeld|TEXT|WIDTH=60 SPAN=TRUE"
)]
[h: abort(status)]
Eingabe 1: [r: eingabe1], Eingabe 2: [r: eingabe2], Eingabe 3: [r: eingabe3]

CHECK

Erstellt eine Checkbox. Der Variable wird der Wert "1" zugewiesen wenn die Checkbox aktiviert wird, und der Wert "0" wenn die Checkbox nicht aktiviert wird.

Mögliche Optionen:

SPAN=TRUE
Erlaubt der Checkbox die Ausdehnung in die gesamte Breite des Eingabefensters. Der Titel der Checkbox wird dabei versteckt und nur als Tooltip der Checkbox angezeigt. Der Standardwert ist "SPAN=FALSE".

Beispiel:

Code: Select all

[h: status = input(
  "checkbox1|0|Die erste Checkbox|CHECK",
  "checkbox2|1|Die zweite Checkbox|CHECK",
  "checkbox3|0|Die dritte Checkbox|CHECK|SPAN=TRUE"
)]
[h: abort(status)]
Checkbox 1 aktiviert: [r: checkbox1], Checkbox 2 aktiviert: [r: checkbox2], Checkbox 3 aktiviert: [r: checkbox3]

LIST

Erstellt eine Drop-Down Liste mit verschiedenen Auswahlmöglichkeiten. Beachte:

• [li]Als Anfangswert wird eine Liste mit mehreren Auswahlmöglichkeiten definiert, wobei die einzelnen Einträge durch ein Komma (,) voneinander getrennt werden.[/li]
  [li]Der Variable wird als Wert der Index des Listeneintrags zugeordnet, wobei der Index bei "0" beginnt. Der erste Eintrag in der Liste hat also den Index "0", der zweite Eintrag den Index "1", der dritte Eintrag den Index "2" usw.[/li]

Mögliche Optionen:

SELECT=x
Bestimmt den Index des Eintrags der bei Aufruf des Eingabefensters in der Liste angezeigt wird. Der Standardwert ist "SELECT=0".

VALUE=STRING
Statt des Index des Eintrags wird der Variable der Inhalt des Eintrags zugeordnet. Der Standardwert ist "VALUE=NUMBER".

SPAN=TRUE
Erlaubt der Liste die Ausdehnung in die gesamte Breite des Eingabefensters. Der Titel der Liste wird dabei versteckt und nur als Tooltip der Liste angezeigt. Der Standardwert ist "SPAN=FALSE".

Beispiel:

Code: Select all

[h: status = input(
  "liste1|Eintrag 1,Eintrag 2,Eintrag 3, Eintrag 4|Die erste Liste|LIST",
  "liste2|Eintrag 1,Eintrag 2,Eintrag 3, Eintrag 4|Die zweite Liste|LIST|SELECT=2",
  "liste3|Eintrag 1,Eintrag 2,Eintrag 3, Eintrag 4|Die dritte Liste|LIST|VALUE=STRING",
  "liste4|Eintrag 1,Eintrag 2,Eintrag 3, Eintrag 4|Die vierte Liste|LIST|SPAN=TRUE"
)]
[h: abort(status)]
Auswahl in Liste 1: [r: liste1] - Auswahl in Liste 2: [r: liste2] - Auswahl in Liste 3: [r: liste3] - Auswahl in Liste 4: [r: liste4]

RADIO

Erstellt eine Gruppe von Radio-Buttons mit verschiedenen Auswahlmöglichkeiten. Beachte:

• Als Anfangswert wird eine Gruppe mit mehreren Auswahlmöglichkeiten definiert, wobei die einzelnen Einträge durch ein Komma (,) voneinander getrennt werden.
• Der Variable wird als Wert der Index des Gruppeneintrags zugeordnet, wobei der Index bei "0" beginnt. Der erste Eintrag in der Gruppe hat also den Index "0", der zweite Eintrag den Index "1", der dritte Eintrag den Index "2" usw.

Mögliche Optionen:

SELECT=x
Bestimmt den Index des Eintrags der bei Aufruf des Eingabefensters in der Gruppe vorausgewählt wird. Der Standardwert ist "SELECT=0".

VALUE=STRING
Statt des Index des Eintrags wird der Variable der Inhalt des Eintrags zugeordnet. Der Standardwert ist "VALUE=NUMBER".

ORIENT=H
Bewirkt, dass die Radio-Buttons in der Gruppe horizontal in einer Linie statt vertikal angezeigt werden. Der Standardwert ist "ORIENT=V".

SPAN=TRUE
Erlaubt der Gruppe die Ausdehnung in die gesamte Breite des Eingabefensters. Der Titel der Gruppe wird dabei als Tooltip der Gruppe angezeigt. Der Standardwert ist "SPAN=FALSE".

Beispiel:

Code: Select all

[h: status = input(
  "gruppe1|Eintrag 1,Eintrag 2,Eintrag 3|Die erste Gruppe|RADIO",
  "gruppe2|Eintrag 1,Eintrag 2,Eintrag 3|Die zweite Gruppe|RADIO|SELECT=2",
  "gruppe3|Eintrag 1,Eintrag 2,Eintrag 3|Die dritte Gruppe|RADIO|VALUE=STRING",
  "gruppe4|Eintrag 1,Eintrag 2,Eintrag 3|Die vierte Gruppe|RADIO|ORIENT=H",
  "gruppe5|Eintrag 1,Eintrag 2,Eintrag 3|Die fuenfte Gruppe|RADIO|SPAN=TRUE"
)]
[h: abort(status)]
Auswahl in Gruppe 1: [r: gruppe1] - Auswahl in Gruppe 2: [r: gruppe2] - Auswahl in Gruppe 3: [r: gruppe3] - Auswahl in Gruppe 4: [r: gruppe4] - Auswahl in Gruppe 5: [r: gruppe5]