RGSS Tutorial: Grundlagen mit Menüscript

[FlipelyFlip]

Heyho,

ich möchte euch nun ein kleines Script Tutorial anhand eines Menüs vorstellen. Hier setzte ich keine Grundkenntnise vorraus. Wenn ihr Fragen dazu habt, könnt ihr hier im Thread diese stellen oder falls ich mal in der chatbox bin auch dort.

Vorwort

Dieses Tutorial beschäftigt sich mit dem Grundgerüsts eines Menüs, dem Aufbau und den verschiedenen Windows die in das Menü einfließen. Es wird keinerlei weiterführung in diesem Tutorial geben. Damit meine ich, raus aus dem Menü in das Inventar usw.
Ich würde mich gern darüber freuen wenn ihr mir Kommentare hinterlassen würdet, wie gut es euch gefallen hat und ob ihr was daraus lernen könnt oder ob es zu unverständlich geschrieben worden ist. Wenn ihr mir eure Veränderungen zeigen möchtet, könnt ihr dies ebenfalls in diesem Thread zeigen oder per PN. Im Chat stehe ich nur für Fragen und Bugs zur verfügung (mags nich so gern dort pics anklicken zu müssen^^")

So genug vom Vorwort^^"

Aufbau

1) Einleitung
1.1) Klassen & Methoden
1.2) Vererbung
1.3) If-Abfragen
1.4) Wiederholung

2) Das Window
2.1) Erstellen eines Windows und seine Funktionen
2.2) Window_Base
2.2.1) Das Gold Window
2.2.2) Das Spielzeitwindow (Extra)
2.2.3) Window_Selectable
2.2.3.1) Das Statusmenü Window
2.2.3.2) Das Command Window
2.3) Wiederholung

3) Das Menü
3.1) Grundgerüst
3.1.1) Einbinden von verschiedenen Windows
3.1.2) Updates & Disposes: wofür sie gut sind
3.1.3) Anzeigen der Command Punkte
3.1.4) Sonstige Standardmenü-Scriptteile
3.2) Wiederholung

1) Einleitung

Diese Einleitung in die Welt von RGSS wird kurz gehalten, da die meisten Grundbegriffe zu RGSS sowieso im Internet rumkursieren und es auch genügend Tutorials gibt in dennen das abgehandelt wird. Ich möchte euch hier zwar nur einen kleinen Teil von RGSS näher bringen, jedoch ist dieser Teil schon für Anfänger im RGSS Bereich ein sehr großer Batzen Arbeit.
Was ich euch in dieser Einleitung erklären will/werde werdet ihr später im Tutorial nochmals finden, also wird die beschreibung sowieso kurz gehalten (=

Was ich vorweg Anmerken möchte ist folgendes: wenn ihr irgendwo in diesem Tutorial ein # Zeichen seht, dann bedeutet das, dass es für den Maker als Kommentar markiert wird (farblich wird es in ein grün eingefärbt). alles was hinter dem # Zeichen in einer Zeile steht wird als Kommentar gewertet und im Prozess nicht ausgeführt. So werden einige Beschreibungen hinzugefügt in die codetags (=

1.1) Klassen & Methoden

Was sind Klassen und was sind Methoden? Man hört oft von beidem, aber meist hat man keine wirkliche Ahnung davon. Viele Anfänger denken meistens sogar das Klassen und Methoden das selbe sind. Leider ist es aber nicht das selbe.

Wie sieht eine Klasse aus?

Code: [Auswählen]

class (Klassenname)Dies wäre eine Klasse. Man erkennt sie wirklich blöd gesagt an folgenem:

Code: [Auswählen]

class
Da das "class" alleine aber nicht wirklich was bringt, benötigt man auch noch einen Namen der definiert was die Klasse zu tun hat. Viele Klassen erhalten dadurch zum eigentlichen Namen noch einen Präfix, damit der Maker weiß was für eine Art von Klasse dies nun ist.
Der maker unterscheidet zwischen 5 Arten von Klassen.

Code: [Auswählen]

class Scene_(Klassenname)
endDie Wohl bekannteste Klassenart unter uns Makerern ist wohl die Scene. Diese gibt dem Maker an, das es Aufgerufen werden muss durch den Befehl

Code: [Auswählen]

$scene = Scene_(Klassenname).new

Code: [Auswählen]

class Window_(Klassenname)
endDieses wird auch noch oft gesehen, da viele Scripts auch noch eigene Windowsettings mit sich bringen. Ein Window unterscheidet sich zum Scene in dem Sinne, dass es nur durch Aufrufen einer Scene erscheinen kann und auch in der Scene ein update benötigt. Aufgerufen wird es durch folgenden Befehl:

Code: [Auswählen]

@(klassenname)_window = Window_(Klassenname).new(x,y)

Code: [Auswählen]

class Game_(Klassenname)
endDiese Klasse wird relativ selten geschrieben und auch nur dann wenn es nötig ist. Diese Klasse greift direkt ohne Aufruf in die verschiedensten Bereiche über. Man kann schon sagen, es bringt das Spiel erst richtig zum laufen. Man kann es nicht aufrufen, da es schon so oder so aktiv ist, aber man kann mit einigen Teilen arbeiten. Die bekanntesten sind folgende zwei befehle:

Code: [Auswählen]

$game_switches[ID] = true:false
$game_variables[ID] += 1

Code: [Auswählen]

class Spriteset_(Klassenname)
end
# bzw.
Sprite_(Klassenname)
endDiese Klasse aktiviert sich genau so wie die Game-Klasse automatisch bei Spielbeginn und ist für alle Grafikanzeigen zuständig. Es wird noch seltener wie die Game-Klassen bearbeitet und noch seltener wird eine neue Spriteset-Klasse bzw. Sprite-Klasse erstellt.

Code: [Auswählen]

class (Klassenname)Dies sind Klassen die keinen Präfix haben und auch eigentlich nie verwendet werden. Es gibt nur ein mir bekanntes Script (ich kenn schon so ziemlich jedes Script was es gibt) verwendet. Es ist das Pokemon Starterkit. Man kann nicht viel über diese Klasse sagen, da ich selbst nicht weiß wie sie genau funktioniert^^" Ich wollte sie dennoch erwähnen, damit man sieht wieviele verschiedene Klassenarten es gibt (=

Bevor ich nun zu den Methoden komme, möchte ich bei den Klassen noch etwas anmerken. (Klassenname) steht stellvertretend für jeden Klassennamen den man sich Ausdenken will, solange keine Sonderzeichen vorkommen. Am einfachsten ist es, wenn man Klassen nur mit Buchstaben benennt und die Namen auch kurz hält. Das ganze dient der Übersicht.
Das end am Schluss ist ebenfalls sehr wichtig, damit der Maker weiß wo das Ende ist. Würde man in einem Script einmal ein End vergessen, würde der Maker einen Fehler in der letzten Zeile ausspucken. Wenn dies geschieht hat man entweder ein paar End zu viel oder ein paar zu wenig (=

Nun bei den Methoden angelangt, gibt es kaum mehr was zu sagen. Die Methoden sind schnell abgehandelt, da diese nicht wirklich eine Richtline haben. Methoden können alles enthalten.
So sieht eine Methode aus:

Code: [Auswählen]

def (Methodenname)
endMethoden werden innerhalb eines Scriptes in dem sie definiert wurden mit ihrem normalen Methodennamen aufgerufen ansonsten sieht dies wie folgt aus:

Code: [Auswählen]

$scene_(klassenname).(methoenname)Würde man bei einer Methode das End an ihrem Ende vergessen, würde es wieder einen Fehler in der letzten Zeile des Scriptes auswerfen und man müsste sich auf die Endsuche machen.

Was es noch wissenswertes über die Methode gibt:
Eine Methode kann nie ohne einer Klasse stehen. Das Heißt:
Würde man eine Methode einfach so hinschreiben, dann würde es dir einen Error auswerfen. Jetzt fragt man sich bestimmt, wie man das schreiben muss, wenn ich sage dass es nicht ohne eine Klasse stehen kann. Das schreibt man dann so an:

Code: [Auswählen]

class Scene_(Klassenname) # Kann auch eine andere Klassenart sein
  def (Methodenname)
  end
end
Bevor ich nun die Methoden abschließe möchte ich noch anmerken, dass Methodennamen klein geschrieben werden. Sie können ebenfalls wie die Klassen keine sonderzeichen enthalten, sind aber auch von Zahlen im Namen nicht abgeneigt. eine Ausnahme unter den Sonderzeichen ist das "_" um einen Methodennamen besser zu definieren.

Soviel dann mal zu den Klassen & Methoden.

1.2) Vererbung

Vererbung ist ein ganz kleines und schnell abgehandeltes Thema. Bei der Vererbung werden von Eigenschaften von einer Klasse in einer anderen Klasse übernommen. In RGSS2 sieht man dies nun häufiger, bzw. nahezu bei jeder "Scene" und bei jedem "Window".
Eine Vererbung sieht in RGSS so aus:

Code: [Auswählen]

class Scene_(KlassennameA) < Scene_(KlassennameB)
endDurch diese Vererbung erhält KLassennameA auch Eigenschaften von KlassennameB.

Soviel zur Vererbung. Da gibt es eigentlich nichts mehr wirklich zu sagen^^"

1.3) Variablen & If-Abfragen

Variablen sind Buchstaben wie zB. x in der Mathematik. Einer Variable kann ein bestimmter Wert zugewiesen werden. Mehr gibt es auch nicht wirklich über die Variablen zu verlieren, da sie so eigentlich am einfachsten erklärt wurden^^"

If-Abfragen sind wie Conditional Branches, nur eben auf RGSS Basis. Mit If-Abfragen kann man so ziemlich alles Abfragen. Ob 1 größer als 2 ist usw. If-Abfragen können aber nur 2 verschiedene Werte wiedergeben. Diese werte sind True und False. If-Abfragen können unterschiedlich aussehen, aber ich behandle hier nur ein paar kleine Grundformen.

Code: [Auswählen]

a = 1 # die Variable a hat jetzt den Wert 1
b = 2 # die Variable b hat jetzt den Wert 2
if a <= b # Hier wird überprüft ob a größer oder gleichgroß wie b ist. trifft dies zu, wird der Befehl unterhalb genutzt. Trifft dies nicht zu, wird das else aktiv.
  p("Ja") # p bedeutet print, man kann auch print hinschreiben. () sind nicht pflicht, dienen aber der übersicht
else # else ist das Ansonsten in einer Conditional Branche
p("Nein")
end # auch If-Abfragen brauchen ein end. Hier wird für den Maker klar gemacht, dass die abfrage zu ende ist.

if a > b # überprüfung ob a größer als b ist, trift dies zu, dann true, sonst elsif
  p("A ist größer")
elsif a == b # überprüft ob a Gleichgroß b ist, aber nur wenn erste Abfrage falsch ist. Es braucht bei so einer überprüfung auch 2 = da nur ein = eine zuweisung wäre und somit immer true ergeben würde.
  p("A ist gleichgroß wie B")
else
  p("B ist größer")
end

if $game_switches(1) == true # überprüft ob der Switch mit der ID 1 auf on gestellt ist
  p("Ja")
else
  p("Nein")
end

if $game_variables[1] >= 2 # überprüft ob Variable 1 größer oder gleichgroß wie 2 ist. wenn ja, dann ist die abfrage true sonst false
  $game_switches[1] = true # wenn abfrage true ergibt, dann wird switch 1 aktiviert
else
  $game_switches[1] = false # wenn abfrage false ergibt, wird switch 1 deaktiviert
end

Das sind jetzt schon mal die meistverwendeten Abfragen mit den Ifs. Es gibt noch einige mehr, die aber nicht von bedeutung sind in diesem Tutorial (=

1.4) Wiederholung

Was haben wir also nun in diesem Kapitel gelernt?
Nun wir haben jetzt gelernt, dass es 5 verschiedene Arten von Klassen gibt. 1 Davon wird eigentlich nie verwendet, 2 werden so gut wie nie gescriptet und die restlichen 2 sind die meistverwendeten und das Herzstück ein jedes selbst gemachten Scripts.
Wir haben auch gelernt, dass Methoden viele verschiedene Namen haben können, aber auch viele verschiedene und nützliche Funktionen erfüllen können.
Auch gelernt haben wir, dass wenn wir eine Klasse vererben, dass die Klasse die erbt, die Eigenschaften der Vererberklasse übernimmt.
Bei den If-Abfragen haben wir die unterschiedlichen Arten gelernt und wie diese Funktionieren.

Da kommt doch schon recht viel zusammen wenn wir uns das so recht ansehen (=

2) Das Window

Das Window ist wohl neben der Map, das was uns wohl am häufigsten Begegnet. Wir machen das Menü auf, was sehen wir da? OMG! Ein Window! Wir gehen in einen Menüpunkt, was taucht auf? EIN WINDOW!! Wir gehen Game Over (wenn kein anderes Script eingefügt ist, dass das Game Over ändert), was sehen wir da? OMG! Nein keine Angst, dann taucht da kein Window auf q: Das könnte man aber alles durch diese kleinen nützlichen Helferlein von Windows mit einbringen.
Doch wie das ganze Funktioniert, werden wir nun in den nächsten paar Kapiteln lernen (=

2.2) Windwo_Base

Dieses Script macht nicht wirklich Sinn genauestens zu Analysieren, da es nur Grundfunktionen enthält, die für ein Window nötig sind. Es enthält informationen wie zB. das das Window mit dem Windowskin erstellt wird, oder das im Kampfsystem verschiedene Statusveränderungen mit verschiedenen Farben dargestellt werden, wie welche Actorgrafik angezeigt werden soll, wie welche Monstergrafik usw.

2.2.1) Das Gold Window

Code: [Auswählen]

#==============================================================================
# ** Window_Gold
#------------------------------------------------------------------------------
#  This window displays the amount of gold.
#==============================================================================

class Window_Gold < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 160, WLH + 32)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_currency_value($game_party.gold, 4, 0, 120)
  end
end

Wow unser Gold_Window. So guckt der Code dazu also aus... Atemberaubend oder? Ach, du verstehst da null und gar nix? naja ich erklärs dir mal so:

Code: [Auswählen]

class Window_Gold < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 160, WLH + 32)
    refresh
  endWie wir hier sehen, erbt das Window_Gold informationen aus dem Window_Base. Wenn wir jetzt im Window_Base nachsehen würden, welche Informationen das wären, würden wir sie schnell finden, doch das gucken wir nachher mal nach (=
Jetzt wird erstmal erklärt was passiert.

Wie wir hier sehen wird bei der ersten Methode eine Klammer mit 2 variablen angegeben. Also heißt diese Methode nun:

Code: [Auswählen]

def initialize(x, y)
doch was bedeutet dies nun? Ganz einfach. Wenn wir dieses Window aufrufen wollen, müssen wir beim aufrufen einen Wert der x und einen Wert der y Variable zuweisen. diese werden dann in der zweiten Zeile der Methode genauer definiert, was diese Werte dann bedeuten werden. Die zweite Zeile ist folgende:

Code: [Auswählen]

super(x, y, 160, WLH + 32)
Hier sehen wir gleich ein paar seltsame Begriffe drinnen. Wir erkennen auch unsere Freunde das x und auch das y wieder. Nun wenn wir genau aufgepasst haben, mussten wir doch beim Aufrufen des Windows dem x und dem y einen Wert zuweisen, diese werden hier also als Koordinaten benötigt, um einen fixen standpunkt zu erhalten. 160 bestimmt wie lang das Window werden soll und WLH + 32 bedeutet nichts weiter als: Window Line High. Dieses WLH wurde in Window Base als 24 definiert. Ja wer jetzt aufgepasst hat, wird merken, das WLH ebenso wie x und y eine variable ist! Aber was bedeutet das + 32 bei dem WLH? Ganz einfach. Die + 32 ändern das Window um 32 Pixel nach unten. So das die Schrift schön mittig ist. Je mehr in die Box rein soll, desto mehr muss man zur WLH dazu addieren.

Die dritte Zeile dieser Methode ist nun ein refresh. Jetzt könnte man sagen, dass refresh ist auch eine Variable, jedoch wenn man sich das Script weiter anguckt, findet man raus, das das refresh jedoch eine Methode ist.

Nach dem refresh kommt noch ein end, was uns nun anzeigt, dass die Methode initialize(x, y) fertig ist.

Code: [Auswählen]

 def refresh
    self.contents.clear
    draw_currency_value($game_party.gold, 4, 0, 120)
  end
end

Was finden wir nun hier drinnen alles? Oh stimmt, eine Methode, ein self.contents.clear, ein draw_currency_value($game_party.gold, 4,0, 120) und 2 end.

beginnen wir bei der Methode am anfang in der ersten Zeile.

An dieses refresh erinnern wir uns doch von vorher, also ist das refresh dort oben wirklich eine Methode wie ich es euch von anfang an gesagt habe. Jetzt kann man doch beruhigt weiter in die zweite Zeile gehen (=

Code: [Auswählen]

self.contents.cleardieser code besagt nur, dass der inhalt in diesem window gelöscht werden soll. Wieso? Damit es zu keinen Anzeigefehlern kommt, falls es sich vermehrt. Es ist der selbe Wunderheiler wie wenn man in Eventcodes einmal ein Wait einbaut. Dadurch können seltsame und schwere Bugs vermindert werden.

Code: [Auswählen]

draw_currency_value($game_party.gold, 4, 0, 120)Was erfahren wir eigentlich aus diesem schnippsel? eigentlich nichts so wie es aussieht, jedoch müssen wir da etwas genauer nachforschen. Wenn wir uns das genau ansehen, besteht der schnippsel aus einer Methode mit Variablen. Jedoch ist im Window_Gold keine weitere Methode mehr vermerkt. Woher kommt die wohl?
Wir haben ja alle am anfang des Window_Gold Tutorials aufgepasst und sind darauf gekommen, dass sie ja aus der Window_Base erbt! Daher gucken wir mal in der Window_Base nach einer draw_currency_value() nach. Siehe da!? Ganz unten finden wir sogar folgenden Schnippsel:

Code: [Auswählen]

 def draw_currency_value(value, x, y, width)
    cx = contents.text_size(Vocab::gold).width
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, width-cx-2, WLH, value, 2)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, width, WLH, Vocab::gold, 2)
  end
also was gibt es uns nun an? Wir müssen bei der Methode nun sogar 4 variablen beschriften. Einmal die value, was wir mit $game_party.gold gemacht haben, einmal die x-Variable, diese haben wir mit 4 bezeichnet, die y-Variable mit 0 und die width haben wir auf 120 gesetzt. So nun haben wir mal die wünsche der Methode erfüllt, nun gucken wir uns aber auch mal an, was die Methode für uns macht (=

Code: [Auswählen]

cx = contents.text_size(Vocab::gold).widthhier wird in der variable cx die Textweite vom Wort aus dem Vocab Script gespeichert, das für Gold steht. Eigentlich wird das Gold ja in der Datenbank geändert, jedoch aber im Vocabscript nocheinmal weiter verarbeitet (=

Code: [Auswählen]

self.contents.font.color = normal_colorDas bedeutet dass der Text der nach dieser Zeile angezeigt wird, in der Standard-Farbe des Windowskins für Text angezeigt wird. Einfach ausgedrückt. Er wird beim Standardskin einfach Weiß xD

Code: [Auswählen]

self.contents.draw_text(x, y, width-cx-2, WLH, value, 2)Hier wird nun definiert was in der Standardfarbe angezeigt werden soll und an welcher Position. x und y wird wieder aus dem Window_Gold genommen, als in der refresh-Methode definiert wurde, wo der Text angezeigt werden soll.
width-cx-2 ist eine Rechenoperation. Es sieht auf den ersten Blick nicht so aus, aber es ist wirklich eine. Hier wird die Weite des Windows minus der Schriftweite von Gold minus 2 gerechnet. Dadurch kommt man auf die Position wohin der Wert des Goldes hingeschrieben werden soll.
WLH ist unser altbekannter Freund und besagt nur wie groß der Text angezeigt werden soll.
value gibt den Wert an, der von uns vorher definiert wurde zum Anzeigen. Hier in unserem Fall ist es das Gold.
Was das 2 bedeutet bin ich mir selbst nicht im klaren, ich konnte auch nicht in der Hilfe oder in anderen Tutorials was zu diesem Wert finden. Meine Vermutung liegt aber darin, dass es Rechtsbündig heißen soll^^"

Code: [Auswählen]

   self.contents.font.color = system_color
    self.contents.draw_text(x, y, width, WLH, Vocab::gold, 2)
  endIch handle jetzt diese beiden gleich als eins ab, da es wirklich keine längere erklärung mehr benötigt ausser folgendes:
Der Text wird nun in der System Color dargestellt. Diese wird ebenfalls in Window Base definiert und ist dieses helle Blau was wir kennen
hier wird wie euch gleich auffällt nichts von der width abgezogen, da das abgezogene eben dieser Text ist, der erst jetzt hier angezeigt werden soll (=
am schluss noch ein end, damit die Methode geschlossen ist.

Nun aber wieder zurück zu unserem Window_Gold Script. Wie wir hier sehen, kommen nun auch hier 2 end vor und das bedeutet dass einmal die Methode refresh geschlossen wird und dann auch das Window_Gold.
Damit wären wir nun Fertig mit dem Gold Window (=

2.2.2) Das Spielzeit Window (Extra)

Jetzt werdet ihr euch Fragen, warum habe ich das Spielzeitwindow extra mit reingenommen? Aus einem ganz einfachen Grund! Ihr werdet später in den Übungsbeispielen versuchen, aus dem Spielzeit Window ein Location Window zu erstellen. Ich werde euch nötige Codes zur verfügung stellen und diese auch erklären, aber auch möchte ich, dass ihr dann das Spielzeit Window in das Menü einbaut und auch so anpasst, dass es nach etwas schönem aussieht (=

Code: [Auswählen]

#==============================================================================
# ** Window Time
#------------------------------------------------------------------------------
#  Display Game Time
#==============================================================================
class Window_PlayTime < Window_Base
  def initialize(x, y)
    super(x, y, 160, WLH + 40)
    self.contents.font.bold = true
    self.contents.font.size = 16
    self.contents.font.color = normal_color
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @total_sec = Graphics.frame_count / Graphics.frame_rate
    hour = @total_sec / 60 / 60
    min = @total_sec / 60 % 60
    sec = @total_sec % 60
    text = sprintf("%02d:%02d:%02d", hour, min, sec)
    self.contents.draw_text(4, 0, 120, 32, "Spielzeit: " + text, 2)
  end
  def update
    super
    if Graphics.frame_count / Graphics.frame_rate != @total_sec
      refresh
    end
  end
end
Ich werde jetzt nicht mehr wie beim Gold Window auf jeden einzelnen Minibefehl eingehen, der jetzt auftauchen wird, da wir sowieso schon fast alle Windowbefehle durch haben, sondern nur mehr auf die neuen. Ihr dürft euch auch gern zuerst versuchen das Script selbst zu erklären wie es wohl funktionieren könnte (=

Code: [Auswählen]

   self.contents.font.bold = true
    self.contents.font.size = 16Diese beiden Befehle sind recht einfach zu kapieren und benötigen eigentlich keine richtige Erklärung. Man kann es schon leicht erraten. Der Text danach wird fett gedruckt (self.contents.font.bold = true) und wird in Schriftgröße 16 sein (self.contents.font.size = 16).

Code: [Auswählen]

   @total_sec = Graphics.frame_count / Graphics.frame_rate
    hour = @total_sec / 60 / 60
    min = @total_sec / 60 % 60
    sec = @total_sec % 60
    text = sprintf("%02d:%02d:%02d", hour, min, sec)
    self.contents.draw_text(4, 0, 120, 32, "Spielzeit: " + text, 2)Das hier geht schon eher auf die Nieren, vor allem wenn man nicht gut aufpasst =D

Code: [Auswählen]

@total_sec = Graphics.frame_count / Graphics.frame_rateHier wird nun berechnet, wie lang die gesamten Sekunden sind, seit dem das Spiel begonnen wurde (beginn bei Neustart). Um auf eine anzahl von Sekunden zu kommen muss erst einmal die gesamten gezählten Frames durch die framerate dividiert werden. Das @ bei @total_sec wird dazu verwendet, damit der maker nicht meint, das total_sec wäre eine Methode und dann einen Fehler auswirft mit undefined method `total_sec' auswirft.

Code: [Auswählen]

hour = @total_sec / 60 / 60Hier wird nun die variable @total_sec zwei mal durch 60 dividiert. dadurch erhält man die Anzahl der Stunden.

Code: [Auswählen]

min = @total_sec / 60 % 60Hier wird die variable @total_sec durch ebenfalls 2 mal durch 60 dividiert, jedoch wird beim zweiten Mal dividieren, statt des Ergebnisses der Rest angegeben (% entspricht dem Restrechnen der Variablen in der Control Variable)

Code: [Auswählen]

sec = @total_sec % 60Hier wird @total_sec nur mehr einmal durch 60 dividiert und statt dem Ergebnis wird auch hier wieder der Rest verwertet.

Code: [Auswählen]

text = sprintf("%02d:%02d:%02d", hour, min, sec)Hier wird das ganze wieder in eine weitere Variable gespeichert. Damit aber die Werte auch eingetragen werden können wird der text durch sprintf("%02d:%02d:%02d", hour, min, sec) definiert. Dadurch werden die 3 Werte in eine einzige Variabel zusammen getragen und richtig aneinander geordnet. Das heißt: Beträgt unsere Spielzeit 1 Stunde 20 Minuten und 15 Sekunden, wird dies so gespeichert und dann später auch angezeigt: 01:20:15.

Code: [Auswählen]

self.contents.draw_text(4, 0, 120, 32, "Spielzeit: " + text, 2)Hier sehen wir den eigentlich Code, wie wir ihn vorher schon beim Gold gesehen haben, jedoch ist hier die Besonderheit, dass das Wort "Spielzeit: " und die Spielzeit gleichzeitig in einem Befehl angezeigt werden. das geht durch das einfache setzen eines + zwischen den beiden Datensätzen.

Code: [Auswählen]

 def update
    super
    if Graphics.frame_count / Graphics.frame_rate != @total_sec
      refresh
    end
  end
Hier sehen wir die Update Methode in einem Window. Das ist eigentlich recht unüblich, kommt aber denoch hin und wieder vor. Diese wird nur dann aktiv, sobald das Window geupdatet wird durch das update im Menü.

Code: [Auswählen]

if Graphics.frame_count / Graphics.frame_rate != @total_secHier wird überprüft ob die vorherige @total_sec immernoch gleich ist wie vorher. Falls nicht, wird erneut refresht, falls doch, dann passiert nichts. Das != bedeutet für den Maker in der Scriptsprache ungleich.

So das wars dann auch schon vom Playtime Window. Mehr gibts da nicht mehr wirklich zu sagen /=

2.2.3) Das Window_Selectable

Das Window_Selectable sollten wir uns lieber im Maker selbst angucken, da es zu lang ist für dieses Tutorial. Zwar habe ich schon ein paar ganze Scripte hier rein gepostet, aber denoch sollten nicht alle Standardscripte rein

Wie wir erkennen können, erbt das Window_Selectable aus dem Window_Base, was ihm wiederum auch die Eigenschaften von Window_Base erteilt.

Wir werden uns nicht lang im Window_Selectable aufhalten, da es eins der Grundscripts ist, die man eigentlich nie Umschreiben muss.

Das Window_Selectable dient eigentlich all dennen Windows als Erbklasse, die etwas zur Auswahl darlegen wollen.

2.2.3.1) Das Menüstatus Window

Code: [Auswählen]

#==============================================================================
# ** Window_MenuStatus
#------------------------------------------------------------------------------
#  This window displays party member status on the menu screen.
#==============================================================================

class Window_MenuStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 384, 416)
    refresh
    self.active = false
    self.index = -1
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = $game_party.members.size
    for actor in $game_party.members
      draw_actor_face(actor, 2, actor.index * 96 + 2, 92)
      x = 104
      y = actor.index * 96 + WLH / 2
      draw_actor_name(actor, x, y)
      draw_actor_class(actor, x + 120, y)
      draw_actor_level(actor, x, y + WLH * 1)
      draw_actor_state(actor, x, y + WLH * 2)
      draw_actor_hp(actor, x + 120, y + WLH * 1)
      draw_actor_mp(actor, x + 120, y + WLH * 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0               # No cursor
      self.cursor_rect.empty
    elsif @index < @item_max    # Normal
      self.cursor_rect.set(0, @index * 96, contents.width, 96)
    elsif @index >= 100         # Self
      self.cursor_rect.set(0, (@index - 100) * 96, contents.width, 96)
    else                        # All
      self.cursor_rect.set(0, 0, contents.width, @item_max * 96)
    end
  end
end

Die Menüstatusanzeige erbt wohl auch aus dem Window_Selectable, aber wieso? Das ist ganz leicht erklärt. Wer sich an das Menü erinnert, dem fällt schnell auf, dass für Skills, Ausrüstung und Status ein Held ausgewählt werden muss. Also braucht es auch die Eigenschaften vom Window_Selectable. Jetzt werdet ihr vlt Halt schreien, weil das Menüstatus ja viele Statuswerte enthält und diese im Statuswindow auch sind, jedoch wenn wir das Window_Status ansehen, erbt dieses aus Window_Base. Wie kann das also sein? Tjaja, das is eine schöne Frage, jedoch leicht erklärt. Guckt euch doch nochmal das Window_Selectable an und seht nach von wo das Window_Selectable erbt. Richtig! Aus der Window_Base. Sprich: Window_MenuStatus übernimmt nun die Eigenschaften von Window_Base und Window_Selectable, somit dürften keine Probleme mehr auftretten (=

Code: [Auswählen]

   self.active = false
    self.index = -1was machen diese beiden Codes denn?
na es stellt sich selbst auf false, da keine Heldenauswahl getroffen wird zurzeit und den self.index = -1 bedeutet, dass der Coursor auf keinem Helden ruht.

Code: [Auswählen]

   @item_max = $game_party.members.size
    for actor in $game_party.members
      draw_actor_face(actor, 2, actor.index * 96 + 2, 92)
      x = 104
      y = actor.index * 96 + WLH / 2
      draw_actor_name(actor, x, y)
      draw_actor_class(actor, x + 120, y)
      draw_actor_level(actor, x, y + WLH * 1)
      draw_actor_state(actor, x, y + WLH * 2)
      draw_actor_hp(actor, x + 120, y + WLH * 1)
      draw_actor_mp(actor, x + 120, y + WLH * 2)
    end
Hier sehen wir nun einen großen Batzen an codes, jedoch siehts schlimmer aus, als es ist. (=

Code: [Auswählen]

@item_max = $game_party.members.sizeHier wird nun die maximale Anzahl an "Items" definiert. Jedoch dürfen wir hier unter item nicht das Item aus der Datenbank Heiltrank oder so verstehen, sondern Anzahl der Helden für die Auswahl, oder doof gesagt Heldenauswahlitem xD

Code: [Auswählen]

for actor in $game_party.membersHier wird für jeder actor erfasst der in der sich in der Party befindet.

Code: [Auswählen]

draw_actor_face(actor, 2, actor.index * 96 + 2, 92)Hier sehen wir wieder mal eine Methode die nicht in unserem Menüstatuswindow verzeichnit ist, also sehen wir in seiner Erbklasse nach. Da finden wir sie nun leider auch nicht, also müssen wir wohl weiter zurück und zwar in die Window_Base. Da werden wir sie zum Glück finden =D

Code: [Auswählen]

 #--------------------------------------------------------------------------
  # * Draw Face Graphic
  #     face_name  : Face graphic filename
  #     face_index : Face graphic index
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     size       : Display size
  #--------------------------------------------------------------------------
  def draw_face(face_name, face_index, x, y, size = 96)
    bitmap = Cache.face(face_name)
    rect = Rect.new(0, 0, 0, 0)
    rect.x = face_index % 4 * 96 + (96 - size) / 2
    rect.y = face_index / 4 * 96 + (96 - size) / 2
    rect.width = size
    rect.height = size
    self.contents.blt(x, y, bitmap, rect)
    bitmap.dispose
  end
jetzt werden ein paar neue Begriffe erwähnt wie z.B. bitmap oder Cache oder rect, aber das ist halb so wild, da diese begriffe recht schnell erklärt sind.

Bitmap: Bitmap verwendet man nur dann, wenn eine Grafik eingefügt werden soll. Mit Bitmap kann man entweder ganze Grafiken oder auch nur einzelne Pixelpunkte herzaubern.

Cache: Der Speicher des Makers. Eigentlich kann man sagen, das aus dem Cache alle Grafiken geladen werden können, die entweder in einem Script definiert wurden oder in der Database verwendet wurden.

rect: erstellt ein Rechteck, bzw. Bringt die Grafiken in ein Rechteck.

mit diesem Wissen, kann man sich nun eigentlich die restlichen Codes selbst erklären, da ich mich sonst mehrmals wiederholen müsste.

Code: [Auswählen]

draw_actor_class(actor, x + 120, y)Diese Methode finden wir ebenfalls in der Window_Base, jedoch denke ich nicht, dass wir diesmal die Window_Base zum verständnis her ziehen müssen. Wen der Code interessiert, der findet ihn in der Window_Base in der Zeile 253.

Code: [Auswählen]

     draw_actor_level(actor, x, y + WLH * 1)
      draw_actor_state(actor, x, y + WLH * 2)
      draw_actor_hp(actor, x + 120, y + WLH * 1)
      draw_actor_mp(actor, x + 120, y + WLH * 2)diese 4 Codes erklären sich ebenfalls von Selbst, wenn jedoch der Code dahinter interessier, kann wie bei draw_actor_class in der Window_Base nach ihm sehen. (=

Code: [Auswählen]

 def update_cursor
    if @index < 0               # No cursor
      self.cursor_rect.empty
    elsif @index < @item_max    # Normal
      self.cursor_rect.set(0, @index * 96, contents.width, 96)
    elsif @index >= 100         # Self
      self.cursor_rect.set(0, (@index - 100) * 96, contents.width, 96)
    else                        # All
      self.cursor_rect.set(0, 0, contents.width, @item_max * 96)
    end
  endHier sehen wir nun den letzten Teil des MenüStatus Windows. Hier wird nur überprüft mit welchem Cursor die Helden anvisiert werden sollen. Ob normal, ob mit self (wobei ich mich da selbst frage, was das für einen Sinn hat oO) oder ob alle gleichzeitig markiert sein sollen. Um auf diese Methode zurück zu greifen, wird über andere Scenes darauf zurückgegriffen (Scene_Menu und Scene_Item nach auswahl eines Items).

Das war dann auch schon das Ende vom Window Menüstatus.

2.2.3.2) Das Command Window

Wenn wir uns das Command Window angucken, dann fällt uns gleich auf, dass wir hier wieder ein Window haben, dass aus dem Window_Selectable erbt.
Ich werde mich auch mit dem Command Window nicht lange Aufhalten, da man eigentlich schon alle Befehle kennt bis auf folgende paar die ich erläutern werde.

Code: [Auswählen]

   for i in 0...@item_max
      draw_item(i)
    endHier wird für i so lange eingesetzt bis man alle Commands einmal angezeigt bekommen hat. Das "draw_item(i)" steht nur dafür, dass der Command angezeigt wird.

Das wars dann eigentlich auch aus dem Command Window.

2.3) Wiederholung

Was haben wir in diesem Abschnitt den gelernt? Da kommt eigentlich einiges zusammen. Wir haben gelernt, dass ein Window eigentlich eines der wichtigsten Scripts für den Scripter ist und das einige Anzeigesachen ohne dem Window nicht funktionieren würden. Wir haben gelernt, wie man verschiedenste Windows erstellt und welche funktionen sich in den verschiedensten Windows sich verstecken. Auch konnten wir unser Wissen über Vererbungen nun auch live einsetzen. Es wurde uns also bewiesen, dass mit der Vererbung auch Methoden aus anderen Klassen mit einbezogen werden können.

Post zusammen gefügt: [time]Di 27 Jul 2010 00:47:45 GMT-1[/time]

3) Das Menü

Was gibt es dazu eigentlich noch viel zu sagen? Soll man ein Menü verwenden? Wenn ja was für eines? Evented oder gescripted? Kann ichs überhaupt selber machen oder brauch ich wieder ein fremdes Script in dem ich mich nicht wirklich auskenne und zuerst mal alles gründlich durchlesen muss? Gibt es überhaupt so etwas wie ich es will?

Oft grübelt man darüber, nur selten wird dann auch wirklich was in Angriff genommen. Viele suchen sich auf die schnelle ein Script aus dem Netz und passen es nach etwas durchlesen ihren Bedürfnissen an und freuen sich über die Arbeit. Ich war auch mal so, nur seit ich Scripten kann, versuche ich meine Menüs immer selbst zu machen. Anfangs werden sie zwar noch recht grundlegende Änderungen beinhalten, aber man hat etwas, auf das man wirklich Stolz sein kann und sieht es dann auch gleich mit anderen Augen. Doch genug nun dieser vielen Worte und lasst uns direkt in die Materie des Menüscripts eintauchen.

3.1) Das Grundgerüst

Das Grundgerüsts eines Menüs sieht eigentlich kurz in Worte zusammen gefasst so aus:

Command Window -> Menü status
\/
Gold Window

Diese 3 Windows bilden das standard Menü. Wenn wir jetzt logisch überlegen, brauchen wir ein Script, dass uns alle 3 Windows anzeigt und genau das macht was ein Menü machen sollte. Nämlich uns zuerst einen Menüpunkt aussuchen zu lassen und dann eventuell den Helden wählen.

Doch bevor das ganze Geschieht, muss noch ein kurzer Scriptteil erledigt werden. Nun arbeiten wir uns von oben herab durch.

Code: [Auswählen]

class Scene_Menu < Scene_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    create_command_window
    @gold_window = Window_Gold.new(0, 360)
    @status_window = Window_MenuStatus.new(160, 0)
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @command_window.dispose
    @gold_window.dispose
    @status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @command_window.update
    @gold_window.update
    @status_window.update
    if @command_window.active
      update_command_selection
    elsif @status_window.active
      update_actor_selection
    end
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    s1 = Vocab::item
    s2 = Vocab::skill
    s3 = Vocab::equip
    s4 = Vocab::status
    s5 = Vocab::save
    s6 = Vocab::game_end
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
    @command_window.index = @menu_index
    if $game_party.members.size == 0          # If number of party members is 0
      @command_window.draw_item(0, false)     # Disable item
      @command_window.draw_item(1, false)     # Disable skill
      @command_window.draw_item(2, false)     # Disable equipment
      @command_window.draw_item(3, false)     # Disable status
    end
    if $game_system.save_disabled             # If save is forbidden
      @command_window.draw_item(4, false)     # Disable save
    end
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      if $game_party.members.size == 0 and @command_window.index < 4
        Sound.play_buzzer
        return
      elsif $game_system.save_disabled and @command_window.index == 4
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      case @command_window.index
      when 0      # Item
        $scene = Scene_Item.new
      when 1,2,3  # Skill, equipment, status
        start_actor_selection
      when 4      # Save
        $scene = Scene_File.new(true, false, false)
      when 5      # End Game
        $scene = Scene_End.new
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Start Actor Selection
  #--------------------------------------------------------------------------
  def start_actor_selection
    @command_window.active = false
    @status_window.active = true
    if $game_party.last_actor_index < @status_window.item_max
      @status_window.index = $game_party.last_actor_index
    else
      @status_window.index = 0
    end
  end
  #--------------------------------------------------------------------------
  # * End Actor Selection
  #--------------------------------------------------------------------------
  def end_actor_selection
    @command_window.active = true
    @status_window.active = false
    @status_window.index = -1
  end
  #--------------------------------------------------------------------------
  # * Update Actor Selection
  #--------------------------------------------------------------------------
  def update_actor_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_actor_selection
    elsif Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window.index
      Sound.play_decision
      case @command_window.index
      when 1  # skill
        $scene = Scene_Skill.new(@status_window.index)
      when 2  # equipment
        $scene = Scene_Equip.new(@status_window.index)
      when 3  # status
        $scene = Scene_Status.new(@status_window.index)
      end
    end
  end
endWow langer Script, aber fangen wir mal am Anfang an, nach der class Scene_Menu < Scene_Base (oh, da erbt wohl wer aus der Scene_Base)

Code: [Auswählen]

 def initialize(menu_index = 0)
    @menu_index = menu_index
  endhui hui hui, die initialize hat ja schon wieder ne Klammer mit sich mitgebracht, aber das ist jetzt in dem Fall halb so wild, den wenn wir das Menü mit $scene = Scene_Menu.new bzw. mit Esc öffnen, wird der menu_index automatisch auf 0 gesetzt. 0 Entspricht dem ersten Menüpunkt. Will man durch aufrufen per Call Script auf einen anderen Punkt verweisen, so muss man statt "$scene = Scene_Menu.new" "$scene = Scene_Menu.new(ID)" eingeben. ID wird aber mit einer Zahl zwischen 0 und 5 (Standardmenü) ausgetauscht. Aber genug der Nebenstory.
Denoch habe ich mit dieser Erklärung die gesamte initialize erklärt.^^"

3.1.1) Einbinden von verschiedenen Windows

Code: [Auswählen]

 def start
    super # damit ich es unten nicht erwähnen muss, ich hab null plan was das super bedeuten könnte^^"
    create_menu_background
    create_command_window
    @gold_window = Window_Gold.new(0, 360)
    @status_window = Window_MenuStatus.new(160, 0)
  endHier sehen wir bei der def start nun dass mit dem Befehl create_menu_background. Mit diesem Befehl wird nun etwas erstellt, dass sich logischerweise vom Namen ableiten lässt. Richtig! Der Titelsc... quatsch! Der Menühintergrund!!! =D
create_command_window ist ebenfalls wie create_menu_background leicht zu erraten! Er erstellt den was? Richtig! Den Game Ov... NEIN! Den Command Window! Leite doch mal korrekt ab *grml*

Code: [Auswählen]

@gold_window = Window_Gold.new(0, 360)Fällt jemanden was ein? Bei der Einleitung habe ich ja schon mal erzählt wie man ein Window aufruft oder? Hier haben wir nun das gute Stück in einem praktischen Beispiel. Der (Klassenname) ist hier also Gold. das ganze sieht also so in natura aus. Schön schön, doch was haben nun die Zahlen in Klammer zu bedeuten?
Erinnern wir uns zurück an das Gold Window. Dort hatte das initialize eine Klammer mit einem x und einem y. Beides Variablen, die undefiniert blieben. Bis jetzt! Diese Klammer definiert die x und y Variable und erteilt dem Window somit die Position wo es auftauchen soll.

Code: [Auswählen]

@status_window = Window_MenuStatus.new(160, 0)Selbes Spielchen können wir hier auch spielen wie beim Gold Window, wäre aber Sinnlos, findet ihr nicht? ist ja auch egal.

3.1.2) Updates & Dispose:d wofür sie gut sind

Updates und Dispose werden eigentlich dafür verwendet, damit die Windows schön sauber und flüssig bleiben. Damit einfach keine Grafik- und Anzeigefehler entstehen. Zum einen wird durch das Update immer geachtet, dass die aktuellsten Veränderungen angezeigt werden. Dispose wird einerseits zum Windows löschen verwendet, wenn man normal weiter Spielen will und auch damit die Windows im Menü nicht durch die dauernden Updates einfrieren.

Fangen wir mal mit dem an, was im Script zuerst kommt an, das sind die Disposes.

Code: [Auswählen]

 def terminate
    super
    dispose_menu_background
    @command_window.dispose
    @gold_window.dispose
    @status_window.dispose
  endHier lässt sich klar erkennen, dass das Command Window zwar die selbe methode hat, sich aufrufen zu lassen wie der Menühintergrund, aber sich anders entfernen lässt. Ansonsten gibt es hierzu nicht viel zu sagen, ausser dass der dispose wie folgt funktioniert:

Code: [Auswählen]

@(klassenname)_window.dispose
Nun kommen wir mal zu den Updates.

Code: [Auswählen]

 def update
    super
    update_menu_background
    @command_window.update
    @gold_window.update
    @status_window.update
    if @command_window.active
      update_command_selection
    elsif @status_window.active
      update_actor_selection
    end
  endAuch hier zeigt sich uns das command window wieder etwas eigensinnig. Es wird gleich wie die anderen Windows upgedatet und nicht so wie der Hintergrund des Menüs.
Was fällt uns noch auf beim Update? Genau! Wir haben eine If-Abfrage drinnen. Jedoch eine etwas andere als wir am anfang gelernt haben.

Code: [Auswählen]

   if @command_window.active
      update_command_selection
    elsif @status_window.active
      update_actor_selection
    endif @command_window.active überprüft ob das @command_window wirklich aktiv ist. Falls ja, dann wird die command_selection upgedated. Falls nicht, dann wird überprüft ob @status_window aktiv ist. falls ja, dann wird diese geupdated.
Trifft keines von beidem zu, so habt ihr das Menü geschlossen und lauft feucht-fröhlich auf der Map herum oder befindet euch in nem anderen Menü.
Beim Update kann man wie beim dispose folgende regel festlegen:

Code: [Auswählen]

@(klassenname)_window.update

3.1.3) Anzeigen der Command-Punkte

Code: [Auswählen]

 def create_command_window
    s1 = Vocab::item
    s2 = Vocab::skill
    s3 = Vocab::equip
    s4 = Vocab::status
    s5 = Vocab::save
    s6 = Vocab::game_end
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
    @command_window.index = @menu_index
    if $game_party.members.size == 0          # If number of party members is 0
      @command_window.draw_item(0, false)     # Disable item
      @command_window.draw_item(1, false)     # Disable skill
      @command_window.draw_item(2, false)     # Disable equipment
      @command_window.draw_item(3, false)     # Disable status
    end
    if $game_system.save_disabled             # If save is forbidden
      @command_window.draw_item(4, false)     # Disable save
    end
  endHier sehen wir, wie ein Command Window erstellt wird. Ich hab doch vorhin angemerkt, dass das Command Window gleich wie der Menühintergrund erstellt wird. Das hat den Grund, dass das Command Window da als Methode aufgerufen wird, wie wir hier merken werden.

s1 bis s6 sind unsere Menüpunkte wie sie heißen sollen und wie sie angeordnet sind. Will man zB. s1 = Vocab::item statt Item in Inventar ändern, kann man das Vocab::item löschen und ein "Inventar" daraus machen. Ganz wichtig dabei: das s1 = muss denoch vor dem "Inventar" stehen.

Code: [Auswählen]

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
@command_window.index = @menu_indexMit diesem Code werden die gesamten Command Punkte in das Command Window gepackt und erstellt. Beim Befehl @command_window.index = @menu_index handelt es sich darum, dass der menu_index dem command_window index angeglichen wird.

Code: [Auswählen]

   if $game_party.members.size == 0          # If number of party members is 0
      @command_window.draw_item(0, false)     # Disable item
      @command_window.draw_item(1, false)     # Disable skill
      @command_window.draw_item(2, false)     # Disable equipment
      @command_window.draw_item(3, false)     # Disable status
    endHier wird überprüft ob in der Party Member sind. Wenn kein Held in der Gruppe ist, werden die Menüpunkte mit dem Index 0 bis 3 als Nicht Anwählbar angezeigt.

Code: [Auswählen]

   if $game_system.save_disabled             # If save is forbidden
      @command_window.draw_item(4, false)     # Disable save
    endFalls das Speichern nicht möglich ist, dann wird der Speicherpunkt als nicht Anwählbar angezeigt.

3.1.4) Sonstige Standardmenü-Scriptteile

Tjaja nun kommen wir wohl zum letzten Punkt an diesem heutigen Scripttutorials. Den restlichen kleinen Standardmenü-Scriptteilen. Diese Scriptteile habe ich absichtlich noch nicht erwähnt, da sie in keine der vorherigen Kategorien passten.

Code: [Auswählen]

 def update_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      if $game_party.members.size == 0 and @command_window.index < 4
        Sound.play_buzzer
        return
      elsif $game_system.save_disabled and @command_window.index == 4
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      case @command_window.index
      when 0      # Item
        $scene = Scene_Item.new
      when 1,2,3  # Skill, equipment, status
        start_actor_selection
      when 4      # Save
        $scene = Scene_File.new(true, false, false)
      when 5      # End Game
        $scene = Scene_End.new
      end
    end
  endAuf den ersten Blick sieht es nach einem einfachen Update aus, wenn man nach dem Methodennamen gehen würde, jedoch ist dem nicht so. Hier wird nun überprüft ob der B-Knopf bzw. die Esc Taste gedrückt wurde um zurück zur Map zu kommen, oder ob bestätigt wurde, um in einen Menüpunkt zu kommen. Beides unterliegen der If-Abfrage.

Code: [Auswählen]

     if $game_party.members.size == 0 and @command_window.index < 4
        Sound.play_buzzer
        return
      elsif $game_system.save_disabled and @command_window.index == 4
        Sound.play_buzzer
        return
      endHier wird überprüft ob die Anzahl an Helden in der Party gleich 0 ist. Wenn dies zutrifft, werden die ersten 4 Punkte nicht auswählbar sein. dies regelt die zweite abfrage and. durch diesen Aufbau wird eine zweite If abfrage innerhalb des Ifs unnötig. Trifft dies nicht zu, wird eine zweite If-Abfrage in Form von elsif durchgeführt. Ist der Speicherpunkt nicht Anwählbar, aber man wählt ihn trotzdem an, dann wird dies ebenfalls verweigert.

Code: [Auswählen]

     Sound.play_decision # Die SE Decision01 wird abgespielt
      case @command_window.index
      when 0      # Item
        $scene = Scene_Item.new
      when 1,2,3  # Skill, equipment, status
        start_actor_selection
      when 4      # Save
        $scene = Scene_File.new(true, false, false)
      when 5      # End Game
        $scene = Scene_End.new
      endHier wird nun durch die case @command_window.index geregelt, welcher Punkt gerade anvisiert ist und in welche Scene man wechselt. Wie wir hier erkennen können welchseln wir bei den Punkten 1,2 und 3 zu einer weiteren Methode.

Code: [Auswählen]

 def start_actor_selection
    @command_window.active = false
    @status_window.active = true
    if $game_party.last_actor_index < @status_window.item_max
      @status_window.index = $game_party.last_actor_index
    else
      @status_window.index = 0
    end
  endHier wird nun das command_window von aktiv auf passiv gestellt und das status_window von passiv auf aktiv. Wenn der last_actor_index kleiner ist als der vom item_max (Maximalhelden) so wird der Coursor auf den letzten anvisierten Helden gepackt. Ist dies nicht der Fall, wird der oberste Held anvisiert.

Code: [Auswählen]

 def end_actor_selection
    @command_window.active = true
    @status_window.active = false
    @status_window.index = -1
  endHier wird nun wieder die Einstellung so zurückgestellt, dass das Command Window aktiv ist und das Staus Window wieder inaktiv. Ebenso wird beim Statuswindow auch der Cursor entfernt indem er auf die Position -1 gesetzt wird.

Code: [Auswählen]

 def update_actor_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_actor_selection
    elsif Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window.index
      Sound.play_decision
      case @command_window.index
      when 1  # skill
        $scene = Scene_Skill.new(@status_window.index)
      when 2  # equipment
        $scene = Scene_Equip.new(@status_window.index)
      when 3  # status
        $scene = Scene_Status.new(@status_window.index)
      end
    end
  endHier haben wir das selbe Spielchen wie bei der update_command_selection, jedoch werden die möglichen Menüpunkte etwas anders Aufgerufen. Es wird bei @status_window.index der Wert des anvisierten Helden eingesetzt und dieser wird dann auch im Ausgewählten Menübereich Angezeigt.
Würde man B bzw. Esc drücken, würde man in die end_actor_selection Methode kommen.

3.2) Wiederholung

Im letzten Teil des ganzen Tutorials haben wir nun endgültig den Rest über das Menü gelernt. Jetzt wissen wir wie es aufgebaut ist und wie wir kleine Veränderungen daran vornehmen können. Wir wissen welche Methoden verwendet werden und wie diese Aufgebaut sind.

Nachwort

Ich habe recht viel Zeit an diesem Tutorial verbracht. Wenn ihr irgendwelche Fehler in den Erklärungen findet, dann bitte meldet sie mir, da ich selbst nicht perfekt bin. Ich schrieb dieses Tutorial eigentlich auch aus dem Grund, da ich nach dem Motto lebe: "Man kann erst dann etwas, wenn man es anderen erklären kann, dass sie es verstehen." Ich hoffe ich konnte es verständlich genug machen und ich hoffe auch dass es euch hilft, die Welt des RGSS auch etwas klarer zu sehen, als wie nur wirren Buchstabensalat.

lg FlipelyFlip

[Noa3]

geiiiiiiil
ich kans gut gebrauchen vor allem weils endlich mich mal in die regeln einführt wie man nun was beachten muss und was schreibt

[Vesskin]

bin mal grob rüber gegangen, sieht wirklich gut aus, werde es mir heute nachmitag mal Richtig anschauen

[Vizard]

JAA! ein scripting tut
*flippy abknutsch*
super gemacht

[Silvanus]

Sehr praktisch Hab nix zu bemängeln, top^^