Fenster, Auswahlmöglichkeiten und Zahleneingaben aus einem PlugIn aufrufen und auswerten

Die Abkürzungen für die Argumente hier bedeuten: sr = Startpixel von rechts, so = Startpixel von oben, fb = Fensterbreite, fh = Fensterhöhe

Ansonsten muss hierzu nichts erklärt werden.

Wenn man diese Funktion aufruft, gibt man ihr mindestens den Parameter text mit. Die Parameter sr, so, fb und fh (Bedeutung siehe Window_Custom-Spoiler) sind optional.

Die Ifs sind dazu da, um Standardwerte zu bekommen, damit eben nicht immer jeder Parameter durchgegeben werden muss. Wie ihr die Standardwerte festlegt ist natürlich euch überlassen. In meinem Beispiel würde ein Standardfenster oben links angezeigt werden, bis zum rechten Bildschirmrand breit sein und eine Zeile hoch sein.

Für die Zeilenhöhe gilt: Für die erste Zeile muss der Wert 72 verwendet werden, für jede weitere Zeile müssen 36 dazu gerechnet werden.

Weiter unten baue ich ein Beispiel-PlugIn auf, in dem es verschiedene Beispiele zu dieser Funktion gibt.

Die beiden Funktionen habe ich aus dem rpg_objects.js-PlugIn kopiert und nur um den nötigen Parameter erweitert. Damit aber die ursprüngliche Funktion nicht überschrieben wird habe ich den beiden Funktionen neue Namen gegeben.

Zum Game_Interpreter.prototype.auswahl:

Mit dieser Funktion lassen wir das Auswahlfenster anzeigen. Wenn wir diese Funktion im Beispiel später aufrufen, übergeben wir ihr einen Parameter, damit die Funktion ordentlich ausgeführt werden kann. Dieser Parameter (hier einfach auswahlEingabe genannt) muss ein Array sein mit folgendem Format:

1. Array mit den Auswahlmöglichkeiten (maximal sechs Stück)

2. Abbruchtyp als Integer, bestimmt was passiert wenn man die Auswahl mit ESC z.B. verlässt (-2 = extra Zweig, -1 = kein Abbruchtyp, 0-5 = Entspricht der Position im Auswahlarray)

3. Standardtyp als Integer, bestimmt welche Auswahl anfangs markiert ist (-1 = kein Standard, 0-5 = Entspricht der Position im Auswahlarray)

4. Positionstyp als Integer, bestimmt die Position des Auswahlfensters (2 = rechts, 1 = Mitte, 0 = links)

5. Hintergrundtyp als Integer, bestimmt die Transparenz des Auswahlfensters (0 = normal, 1 = gedimmt, 2 = kein Hintergrund)

Man könnte dieser Funktion auch noch Standardwerte zuweisen, wie wir es oben bei der Funktion fensteranzeigen gemacht haben. Der Code dafür könnte so aussehen:

Zum Game_Interpreter.prototype.zahleneingabe:

Mit dieser Funktion lässt sich eine Zahl in eine Variable speichern. Den jeweiligen Wert legt der Nutzer fest. Wenn wir diese Funktion im Beispiel später aufrufen, übergeben wir ihr einen Parameter, damit die Funktion ordentlich ausgeführt werden kann. Dieser Parameter (hier einfach zeingabe genannt) muss ein Array sein mit folgendem Format:

1. ID der Spielvariable in die der Wert gespeichert werden soll

2. Anzahl der Ziffern die die Zahl haben darf.

Wir definieren am Anfang einige Variablen mit deren Hilfe später die verschiedenen Abzweigungen erstellt werden und noch einige Variablen die für die Anzeige der verschiedenen Fenster genutzt werden.

Wir setzen also über die Funktion zurücksetzen() alle benötigten Booleans auf false und eine Spielvariable auf 0. Wenn wir diese Funktion aufrufen, möchten wir wieder am Anfang des PlugIns sein. Die Spielvariable wird nur auf 0 gesetzt, da es meiner Meinung nach besser aussieht wenn der Zähler bei der Zahleneingabe auf 0 steht, selbst wenn wir öfter Zahlen eingeben. Nötig ist das aber nicht unbedingt.

Die Funktion ende() führt einmal die Funktion zurücksetzen() aus, damit wieder ein einheitlicher Ausgangspunkt geschaffen wird, und beendet unseren Intervall. Weiter unten zeige ich euch wie wir den Intervall starten. Davor möchte ich aber die Grundauswahl und die ganzen Abzweigungen durchsprechen. Wir gehen also erstmal davon aus, dass sich unsere Testfunktion ununterbrochen wiederholt.

Zuerst prüfen wir, ob schon eine Eingabe erwartet wird. Beim ersten Durchlauf wird das nicht so sein, da wir oben die entsprechende Variable auf false gesetzt haben. Also springen wir gleich ins else.

Die Variable anweisungFenster ruft die Funktion fensteranzeigen auf und speichert sie in sich. Das ist wichtig, damit wir das Fenster später wieder schließen können. Dieses Fenster sagt einfach nur "Triff eine Auswahl:". Wie ihr seht wurde nur der Parameter text übergeben, da er der erste Parameter ist den die Funktion erwartet, also greifen unsere Standardwerte für die restlichen Parameter. Dementsprechend wird das Fenster oben links angezeigt, ist bis zum rechten Rand breit und eine Zeile hoch.

Wir rufen mit unserem Interpreter (myInterpreter) die Methode auswahl auf, die wir vorhin erstellt haben, und übergeben ihr ein Array. Dieses Array besteht aus einem Array das die Auswahlmöglichkeiten beinhaltet und vier Integern. Diese bedeuten in diesem Fall, dass es einen extra Zweig für den Abbruch geben soll (-2), dass die Standardauswahl die erste Auswahl sein soll (0, da man die Stellen von Arrays bei 0 anfängt zu zählen), dass das Auswahlfenster links erscheinen soll (0) und dass der Hintergrund normal sein soll (0).

Im Anschluss setzen wir die Variable erwarteEingabe auf true, da wir jetzt ja eine Eingabe vom Spieler erwarten.

Ok, das ist jetzt natürlich sehr viel. Fangen wir am Besten oben an:

Das erste If fragt eine Funktion des RMMV ab. Diese Funktion liefert true zurück, falls gerade ein Fenster im Spiel offen ist, also ein Nachrichtenfenster, eine Auswahl, eine Zahleneingabe usw... Unser Anweisungsfenster ist dieser Funktion egal, das von uns erstellte Auswahlfenster aber nicht. Das ! vor der Funktion bedeutet, dass wir eben nicht true bei der Funktion haben wollen, also dass diese Funktion uns false geben soll. Sobald die Funktion false zurückgibt geht es in unserer Funktion weiter. Das ist essenziell, da das PlugIn sonst einfach weiter machen würde ohne dass wir auf die Eingaben reagieren können.

Der Ausdruck anweisungsFenster.close() schließt das Anweisungsfenster. Hätten wir das Fenster nur mit der Funktion geöffnet und nicht in diese Variable gespeichert, könnten wir das Fenster nicht mehr schließen. Daher sollen alle Fenster, die ihr mit der Funktion fensteranzeigen öffnet, in eine Variable gespeichert werden. Sicherheitshalber sollte für jedes neue Fenster eine neue Variable angelegt werden.

Das If und das else if überspringen wir hier. Darauf wird später noch eingegangen.

Im Else steht der Code drinnen um die erste Auswahl auszuwerten. Dazu nutzen wir switch case. Es wird die Variable myInterpreter._branch[myInterpreter._indent] abgefragt. Unser myInterpreter hat ja alle Variablen die der Game_Interpreter ihm mitgibt. Dementsprechend auch _branch und _indent. Die Variable myInterpreter._branch[myInterpreter._indent] wurde nach der getroffenen Auswahl des Spielers verändert. Entweder nimmt sie einen Wert zwischen 0 und 5 an, was der getroffenen Auswahl entsprechen würde, oder den Wert -2, was den Abbruchzweig darstellt. Unsere Auswahl hatte ja nur drei Möglichkeiten und den Abbruchzweig, dementsprechend brauchen wir auch nur vier cases.

Wenn der Spieler also auf Zahleneingabe geklickt hat wird unser case 0 : ausgeführt. Darin rufen wir die Funktion zahleneingabe von unserem myInterpreter auf und setzen den Boolean eingabeZahl auf true. Der Zahleneingabe werden zwei Parameter mitgegeben. Der erste ist die Spielvariable in die der Wert gespeichert werden soll und der zweite ist die Anzahl der Ziffern die der Wert haben darf.

Bei case 1 : , also wenn der Spieler auf Eine weitere Auswahl klickt, erstellen wir ein neues Fenster welches wir einfach zweitesFenster nennen und schreiben dort die Informationen für unseren Spieler rein. In dem Beispiel habe ich einen Text gewählt der drei Zeilen lang ist. Demnach müssen wir hier auch weitere Parameter mitgeben. Nun reicht es aber leider nicht wenn wir als ersten Parameter den Text und als zweiten die Fensterhöhe mitgeben. Denn die Funktion fensteranzeigen hat als zweiten Parameter den Startpixel von rechts. Also müssten wir nun eigentlich alle Parameter mitgeben. Wir können aber die Parameter 2 bis 4 als undefined mitgeben. Dadurch werden wieder die Standardwerte für diese Parameter genommen. Den letzten Parameter setzen wird dann auf 72+2*36. 72 wegen der ersten Zeile und die 2*36 wegen den beiden weiteren Zeilen. Damit spart man sich einfach die eigene Rechenarbeit. Wir könnten dort genau so gut 144 reinschreiben. Wir müssen in den Text aber noch die Zeilenumbrüche einfügen, da die nicht automatisch erkannt werden. Demnach muss für jeden Zeilenumbruch an der jeweiligen Stelle im String \n eingetragen werden.

Danach geben wir wieder eine Auswahl aus. Das machen wir prinzipiell genau so wie wir es bei der ersten Auswahl gemacht haben. Zum Test habe ich aber ein paar Parameter verändert. In diesem Beispiel gibt es keinen Abbruchtyp (-1), die ESC-Taste macht einfach nichts, das Auswahlfenster erscheint rechts (2) und es ist gedimmt (1). Außerdem gibt es nur noch zwei Möglichkeiten, Zahleneingabe oder Ende. Schließlich setzen wir den Boolean weitereAuswahl auf true, damit im nächsten Durchlauf der If-Zweig der weiteren Auswahl genommen wird.

Wenn der Spieler auf Ende klickt, also case 2 : , beenden wir das PlugIn bzw. in diesem Fall nur die Funktion. Dazu rufen wir einfach unsere Ende-Funktion auf. Diese beendet ja den Intervall.

Und wenn der Spieler versucht mit ESC abzubrechen, also case -2 : , werfen wir ihm einen Text aus und führen die Funktion zurücksetzen() aus. Die Parameter vom abbruchFenster sind so gesetzt, dass es unter dem Anweisungsfenster steht, das ja durch den neuen Durchlauf wieder erscheint. Der Parameter so hat den Wert 72, also die Fensterhöhe des Anweisungsfensters.

Wichtig ist in allen Fällen, dass wir die Variable erwarteEingabe nicht wieder auf false setzen, da wir sonst wieder zu unserem ersten Auswahlfenster zurückkommen. Im den Fällen Ende und Abbruch setzen wir die Variable sowieso durch die Funktion zurück.

Diesen Code fügen wir bei dem If-Körper ein. Sobald also eine Zahl eingegeben wurde (wir warten ja darauf, dass $gameMessage.isBusy() eben nicht busy ist) werfen wir ein neues Fenster aus (zahlenFenster) mit einem dreizeiligen Text und der Spielvariable 1, deren Wert wir ja gerade festgelegt haben. Auch dieses Fenster setzen wir unter das Anweisungsfenster, damit es von diesem im nächsten Durchlauf nicht überdeckt wird. Und auch für dieses Fenster brauchen wir Code der es schließt, den wir unter den If-Körper für das Abbruchfenster schreiben. Somit schließt sich auch dieses Fenster nach der nächsten Eingabe.

Schließlich führen wir die Funktion zurücksetzen() aus, damit wir wieder am Anfang sind. Der Spieler kann also wieder munter auswählen.

Kommen wir zum else if (weitereAuswahl):

Wir schließen zuerst das zweite Fenster. Diesen Close müssen wir nicht zu den anderen packen, da das zweite Fenster ja nur erscheint wenn auch die entsprechende Auswahl getätigt wurde und der Spieler nicht abbrechen kann. Somit ist das hier die einzig sinnvolle Stelle das Fenster wieder zu schließen.

Wir nutzen wieder Switch case um an die getätigte Auswahl zu kommen. Dazu hat sich die gleiche Variable wie oben überschrieben. Falls ihr das differenzieren wollt, könnt ihr natürlich einen (oder mehrere) weiteren Interpreter anlegen.

In den case 0 : schreiben wir einfach das rein, was wir bei der letzten Auswahl auch schon reingeschrieben haben. Solche Dopplungen kann man natürlich umgehen, wenn man eine Funktion anlegt, die das gleiche macht, und dort ausführt. Die Variable weitereAuswahl müssen wir nicht auf false setzen, da die Variable eingabeZahl im nächsten Durchlauf vor der weiteren Auswahl abgefragt wird. Solltet ihr das bei eurem PlugIn anders herum machen muss die weitereAuswahl natürlich auf false gesetzt werden, da ihr sonst wieder in diesen Zweig reinrutscht.

Im case 1 : führen wir ebenfalls das gleiche aus, was wir davor ausgeführt haben. Hier habe ich mich sogar an den Tipp mit der Dopplung gehalten

Ihr könnt nun einfach ein Event anlegen und dort über den Scriptbefehl

eingeben. Dadurch wird in die Variable intervallID der Intervall für die Testfunktion gespeichert. Die Testfunktion wird aktuell alle 100 Millisekunden (0,1 Sek) ausgeführt. Und dadurch wird dann auch immer wieder die aktuelle Eingabe abgefragt. Achtet darauf den Befehl nur einmal auszuführen, da sonst für jedes Mal, wenn der Befehl ausgeführt wird, ein neuer Intervall startet und die Variable überschrieben wird. Das ist dann eine klassische Endlosschleife...