RGSS/Tutorial/Informationen in Fenstern anzeigen

Informationen in einem Window anzeigen (für fortgeschrittene Anfänger)
Autor	Playm
Thematik	Wo finde ich bestimmte Daten und wie bringe ich sie in ein Window?
Vorraussetzungen	Programme: RPG Maker XP, RPG Maker VX oder VX Ace Fähigkeiten: Die RGSS Standardklassen sollten bekannt, sowie grundlegende Rubykenntnisse vorhanden sein.

Allgemein

In diesem Tutorial wird erklärt, wie in den RPG Makern XP, RPG Maker VX und RPG Maker VX Ace in einem in-game Fenster Informationen angezeigt werden können. Zur Vertiefung des Wissens über in-game Fenster, schaut man sich am Besten die Artikel zu der Klasse Window_Base an:

• Window_Base im RPG Maker XP
• Window_Base im RPG Maker VX
• Window_Base im RPG Maker VX Ace

Wichtig: Das eigene Window in einer Scene unterzubringen ist nicht Teil dieses Tutorials.

Im Folgenden, wird anstatt "in-game Fenster" nurnoch "Fenster" geschrieben.

Das eigene Window

Wir leiten unser Fenster von der Klasse Window_Base ab, wodurch wir nützliche Methoden und grundlegende Routinen erhalten. Nach Konvention, benennen wir alle Subklassen der Klasse Window (und da Window_Base eine Subklasse von Window ist, ist auch unser Fenster eine) mit dem Prefix "Window_", was auf den Programmablauf keinerlei Einfluss hat, dem Programmierer aber sofort verrät, was für eine Art von Subklasse er hier hat. Eine weitere Konvention für Window-Subklassen ist die Methode refresh, in die wir das Wissen aus diesem Tutorial fließen lassen.

In der Refreshmethode entfernen wir alles, was auf dem Contentbitmap mal drauf war und zeichnen dann unseren Fensterinhalt. Das einleitende "säubern" des Contentbitmap hat den Grund, das falls refresh mehr als einmal aufgerufen wird, wir nicht über bestehende Grafiken drüberzeichnen, was besonders bei Text nicht gut aussieht.

Das wir mehrfach die refresh Methode aufrufen (müssen) kommt vor, wenn der Wert sich dynamisch ändert, wie die Uhrzeit, oder durch Userinput oder die Spielmechanik verändert wird (ein HUD beispielsweise). Dann wollen wir die angezeigten Informationen natürlich aktuallisieren.

Nun noch ein paar spezielle Worte zu den Windows in den einzelnen Makerversionen:

im RMXP

Das Fenster ist recht einfach aufgebaut, es müssen nur zwei Methoden definiert werden, initialize und refresh.

In der Initializemethode geben wir Position und Größe unseres Fensters an, wobei die Position meistens in der jeweiligen Scene festgelegt wird. Bei der Größenangabe müssen wir darauf achten, dass hierbei der 16 Pixel breite Rahmen mitgezählt wird, geben wir also eine Breite und Höhe von 160x96 Pixel an, wird im Fenster nur ein Bereich der Größe 128x64 Pixel angezeigt. Das wir in der Höhe ein Vielfaches von 32 wählen liegt daran, das wir normalerweise beim Zeichnen von Text eine Zeilenhöhe von 32 Pixeln haben.

Danach erzeugen wir ein Bitmap als Contentsbitmap (darauf werden wir unseren Fensterinhalt zeichnen) und zwar direkt in der perfekten Größe. Wir könnten auch ein größeres erzeugen, und im Fenster herumscrollen, allerdings erforderte dies Userinput und wir wollen nur am Rande ein paar Informationen liefern. Abschließend rufen wir die Methode refresh auf, die unser Fenster mit Informationen füllt.

(Für ein Fenster mit dem der User interagieren kann, wählt man als Superklasse Window_Selectable, aber dies wird in diesem Tutorial nicht vertieft.)

#==============================================================================
# ** Window_RMXP
#------------------------------------------------------------------------------
#  Ein Fenster, nach der Konvention des RPG Maker XP.
#==============================================================================
class Window_RMXP < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 160, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    # an dieser stelle, zeichnen wir den Fensterinhalt unserer Windows
  end
end

Dies ist auch schon aller Rahmencode den wir brauchen, uns fehlt dann nur noch eine Scene in der wir unser Fenster anzeigen können, was zum Beispiel die Scene_Menu seien könnte.

im RMVX

Nichts kompliziertes, wir haben hier das Grundgerüst eines Fensters. Wie im RPG Maker XP müssen wir nur zwei Methoden definieren initialize und refresh.

In der Initializemethode geben wir Position und Größe unseres Fensters an, wobei auch hier der jeweils 16 Pixel breite Rahmen mitgezählt wird (siehe weiter Oben den Abschnitt zum RMXP), weswegen wir auf Breite und Höhe 32 Pixel addieren. Die Konstante WLH, die wir im Initialize benutzen wird in der Klasse Window_Base definiert und gibt die Zeilenhöhe an, wir erzeugen also ein Fenster was genug Platz in der Höhe bietet um zwei Zeilen zu zeichnen.

Das erzeugen des Contentbitmaps, was im RMXP noch von Hand mussten, übernimmt nun die Superklasse, weswegen wir uns nicht darum kümmern brauchen. Wir müssen also nurnoch die Methode refresh aufrufen.

#==============================================================================
# ** Window_RMVX
#------------------------------------------------------------------------------
#  Ein Fenster, nach der Konvention des RPG Maker VX.
#    Die Fensterposition kann beim erzeugen bestimmt
#    werden.
#==============================================================================
 
class Window_RMVX < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 160, 2*WLH + 32)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    # an dieser stelle, zeichnen wir den Fensterinhalt unserer Windows
  end
end

Dies ist auch schon aller Rahmencode den wir brauchen, uns fehlt dann nur noch eine Scene in der wir unser Fenster anzeigen können, was zum Beispiel die Scene_Menu seien könnte.

im RMVX Ace

Im Ace haben wir mehr einzelne Methoden; dies wurde ermöglicht durch das Update auf Rubyversion 1.9, wodurch das Aufrufen von Methoden, weniger Zeit kostet. Der klare Vorteil ist die einfache Erweiterbarkeit, weswegen für unser Fenster drei Methoden zu definieren sind.

In der Initializemethode machen wir immernoch das gleiche: Wir geben Position und Größe unseres Fensters an und rufen abschließend refresh auf. Die Breite geben wir aber nicht direkt an, sondern verweisen auf die Methode window_width, zu der gleich mehr gesagt wird. Bisher mussten wir die Höhe immer ausrechnen und schrieben dann einen Rechenterm, wie 32 + 2*24 hin. Dies wird uns jetzt von der Methode fitting_height abgenommen, der wir nur mitteilen müssen, wieviele Zeilen wir im Fenster brauchen und den Rest berechnet diese Methode. Ein weiterer Vorteil ist, dass ein fremder Programmierer sofort sieht, was wir tun und nicht sich durch magic numbers durcharbeiten muss.

In der Methode window_width tun wir nicht mehr, als die von uns gewünschte Fensterbreite zurückzugeben. Diese Methodedefinition ist Konvention im RPG Maker VX Ace.

#==============================================================================
# ** Window_RMVXace
#------------------------------------------------------------------------------
#  Ein Fenster, nach der Konvention des RPG Maker VX Ace.
#==============================================================================
 
class Window_RMVXace < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     Wir erstellen unser Fenster von der Höhe her so, dass wir genug Platz
  #     für zwei Zeilen Text haben.
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, window_width, fitting_height(2))
    refresh
  end
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    return 160
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    # an dieser stelle, zeichnen wir den Fensterinhalt unserer Windows
  end
end

Dies ist auch schon aller Rahmencode den wir brauchen, uns fehlt dann nur noch eine Scene in der wir unser Fenster anzeigen können, was zum Beispiel die Scene_Menu wäre.

Informationen anzeigen

Allgemeines

Wie wir beim initialisieren unseres Fensters sehen, gibt es ein Bitmap namens contents. Auf dieses wird der gesammte Fensterinhalt gezeichnet.

• Text können wir mithilfe der Methode draw_text zeichnen.
• Bilder können wir mithilfe der Methode blt zeichnen.
• Linien können wir mithilfe der Funktion fill_rect zeichnen, oder wir Zeichnen einen Text der nur aus Unterstrichen besteht.

All diese Methoden werden auf das Contentbitmap ausgeführt, also self.contents.draw_text(...) zum Beispiel. Im RMVX Ace gibt es für Windows eine Methode draw_text, die mit den selben Parametern die gleichnamige Methode für das Contentbitmap aufruft, es handelt sich also nur um eine Vereinfachung der Schreibweise, es passiert aber das Selbe.

Zeilenhöhe

Wenn wir Text zeichnen geben wir ein Textfeld an, in das gezeichnet wird. Hierfür geben wir eine x und y Koordinate an, sowie Breite und Höhe des Feldes, wobei der Text am unteren Rand des Feldes gezeichnet wird. Im RMXP ist es konvention für die Höhe 32 Pixel zu wählen und wenn man eine Zeile tiefer zeichnen möchte, die y Koordinate um 32 Pixel zu erhöhen. Der Text nimmt bei einer Standardeinstellung diese Höhe aber nicht ein, wodurch ein gewisser Zeilenabstand gewahrt wird.

Im RMVX hat man sich entschieden, anstatt immer 32 als magic number in den Quellcode zu schreiben, eine Konstante WLH, für Window Line Height einzuführen. Diese ist im Standard mit 24 belegt und wird bei draw_text für die Höhe eingetragen.

Im RMVX Ace löst die Methode line_height die Konstante ab, gibt aber den selben Wert zurück.

farbiger Text

Wir können die Farbe in der wir den Text zeichnen vorher festlegen. Unser Contentbitmap hat das Attribut font, bei dem wir unter anderem die Farbe einstellen können. Es gibt von der Superklasse Window_Base schon vorgefertige Farbwerte: In jedem der drei Maker bekommt man über normal_color die normale Schriftfarbe zum Schreiben und mit system_color die Farbe in der konstante Beschreibungen, wie zum Beispiel des Wortes "HP" hinter dem Wert der Lebenspunkte eines Helden gezeichnet werden. Über text_color( nummer ) bekommt man die gleiche Farbe, wie bei Show Text unter dieser Nummer. Weitere Farben kann man im jeweiligen Window_Base Skript nachgucken.

Wichtig ist die Farbe vor dem Zeichnen des Textes zu ändern, im Nachhinein ist dies nichtmehr möglich, da der Text gezeichnet wird und danach nurnoch als viele Pixel in einer Bitmap existiert.

Beispiel:

self.contents.font.color = system_color

ausgegrauter Text

Dies wird dadurch realisiert, den Text mit weniger Deckkraft zu zeichnen, weswegen er blasser und schwächer wirkt. Im RMXP gibt es dafür noch von Window_Base unter disabled_color einen eigenen Farbwert. Im RMVX wird nach dem Festlegen der Farbe manuell der Alpha Wert der Schriftfarbe geändert. Dies geschieht so:

self.contents.font.color.alpha = 128 # Halbe Deckkraft für ausgegrauten Text

Im VX Ace gibt es eine Methode, um die Schrift zu ändern.

  #--------------------------------------------------------------------------
  # * Change Text Drawing Color
  #     enabled : Enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def change_color(color, enabled = true)
    contents.font.color.set(color)
    contents.font.color.alpha = translucent_alpha unless enabled
  end

Dort kann man als zweiten Parameter angeben, ob der Text mit verringerter Deckkraft gezeichnet werden soll.

Beispiel:

change_color(normal_color, false) # Zeichne ausgegrauten, normalen Text im RMVX Ace
 
self.contents.font.color = disabled_color # Zeichne ausgegrauten, normalen Text im RMXP

eigener konstanter Text

Hierfür kann man in der Scriptcode einfach einen String schreiben.

Beispiel:

self.contents.draw_text( 0, 0, 128, 32, "Hallo Welt." ) # RMXP
self.contents.draw_text( 0, 0, 128, WLH, "Hallo Welt." ) # RMVX
self.contents.draw_text( 0, 0, 128, line_height, "Hallo Welt.") # RMVX Ace

Was vorallem darin Anwendung findet, zu Beschreiben welche Zahl der Spieler nebendran sieht.

Gold

In allen drei Makern ist der aktuelle Goldvorrat über $game_party.gold abfragbar. Allerdings bekommt man ihn als Zahl, muss ihn im RMXP also noch in einen String konvertieren.

Je weiter man in der Makergeneration vorranschreitet, desto feiner werden die Möglichkeiten den Goldwert zu zeichnen.

RMXP

Im RMXP muss man alles von Hand machen: self.contents.draw_text(0, 0, 128, 32, $game_party.gold.to_s, 2) Um den in der Database festgelegten Term für die Währung, also Gold, Münzen, Rubine, was auch immer, anzuzeigen, fragt man ihn über $data_system.words.gold ab. Möchte man nun die Währung direkt hinter den Goldvorrat schreiben, so kann man das wie folgt machen: Mit der Bitmapfunktion text_size( string ) bekommt man ein Rect zurück, welches angibt wieviel Platz der String auf dem Bitmap bräuchte. Auf diese Weise können wir gucken wie Breit der Term ist:

breite_des_wortes = self.contents.text_size( $data_system.words.gold ).width

Wenn wir nun unseren Goldvorrat zeichnen, können wir ihn um diesen Wert weiter links zeichnen, sodass wir anschließend rechts daneben unser Wort "Gold" schreiben können:

 bdw = self.contents.text_size( $data_system.words.gold ).width # Breite des Wortes aus der Database
 adz = 4 # Abstand zwischen Wort und Zahl
 self.contents.font.color = normal_color # Den Goldvorrat in normaler Farbe zeichnen
 self.contents.draw_text(0, 0, 128 - bdw - adz, 32, $game_party.gold.to_s, 2) #rechtsbündig zeichnen
 self.contents.font.color = system_color # Den Databaseterm in Systemfarbe
 self.contents.draw_text(128 - bdw, 0, bdw, 32, $data_system.words.gold, 2) #rechtsbündig zeichnen

RMVX

Im RMVX kann man zwar immernoch wie im RMXP alles von Hand machen, es gibt nun aber auch eine einfache Methode dafür, die aber praktisch das selbe macht - man selber muss nur nichtmehr soviel schreiben. Die Methode heißt draw_currency_value und ist wie folgt implementiert:

  #--------------------------------------------------------------------------
  # * Draw number with currency unit
  #     value : Number (gold, etc)
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : Width
  #--------------------------------------------------------------------------
  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

Im RMVX müssen wir um unser Gold anzuzeigen also nurnoch schreiben:

draw_currency_value( $game_party.gold , 0, 0, 128)

RMVX Ace

Hier haben wir noch eine Verfeinerung: Wir können selber bestimmen, welche Einheit, also welches Wort wir hinter der Zahl haben wollen, wodurch wir so auch simpel andere Variablen mit Einheiten versehen können. Die Methode draw_currency_value wurde um einen Parameter unit erweitert:

  #--------------------------------------------------------------------------
  # * Draw Number (Gold Etc.) with Currency Unit
  #--------------------------------------------------------------------------
  def draw_currency_value(value, unit, x, y, width)
    cx = text_size(unit).width
    change_color(normal_color)
    draw_text(x, y, width - cx - 2, line_height, value, 2)
    change_color(system_color)
    draw_text(x, y, width, line_height, unit, 2)
  end

Wir können also schreiben:

draw_currency_value($game_party.gold, Vocab::currency_unit, 0, 0, 128)

Spielvariable

In allen drei Makern kann man über $game_variables[NUMMER] auf die Spielvariablen, also die, die wir über den Eventbefehl Control Variables beeinflussen können, zugreifen.

Im RMXP müssen wir deren Wert vor dem Zeichnen noch in einen String umwandeln, indem wir schreiben:

self.contents.draw_text( 0, 0, 128, 32, $game_variables[ 54 ].to_s)

Beim RMVX und RMVX Ace kann man das to_s weglassen.

Switch

Die Switches werden in allen drei Makern in der globalen Variable $game_switches gespeichert. Man greift darauf genauso zu, wie auf die Spielvariablen. Allerdings wird hier keine Zahl gespeichert, die man ausgeben könnte, sondern ein Wahrheitswert: true oder false. Wir müssen uns also entscheiden, je nachdem ob der Switch eingeschaltet (true) oder ausgeschaltet (false) ist, welchen Text wir zeichnen. Dies kann man entweder über eine if-Verzweigung lösen, oder kürzer mit dem tertiären Operator:

Beispiel:

string = $game_switches[54] ? "Der Switch 54 ist eingeschaltet" : "Der Switch 54 ist abgeschaltet"
self.contents.draw_text( 0, 0, 128, line_height, string )

Oder ein Beispiel für den RMVX Ace:

change_color(system_color)
self.contents.draw_text( 0, 0, 128, line_height, "NightVision" )
if $game_switches[54]
  string = "Aktiviert"
else
  string = "Deaktiviert"
end
change_color(normal_color, $game_switches[54]) #Wenn Switch==OFF: ausgegraut zeichnen
self.contents.draw_text( 0, line_height, 128, line_height, string )

Name der Map

Im RMVX Ace gibt es für jede Map das Attribut Display Name, welches für die aktuelle Map in der Variable $game_map.display_name gespeichert ist. Möchte man allerdings den Namen anzeigen, der im Maker im Maptree unten links angezeigt wird, so findet man diesen String in der MapInfos Datei. Im RMVX Ace wird diese bereits vom DataManager geladen und in die Variable $data_mapinfos gespeichert, in den anderen Makern müssen wir diese erst laden, oder können es auch seien lassen und die Datei nur dann lesen, wenn wir sie auch brauchen.

Im RMXP

map_infos = load_data("Data/MapInfos.rxdata")
map_name = map_infos[ MAP_ID ].name
self.contents.draw_text( 0, 0, 128, 32, map_name )

Im RMVX

map_infos = load_data("Data/MapInfos.rxdata")
map_name = map_infos[ MAP_ID ].name
self.contents.draw_text( 0, 0, 128, WLH, map_name )

Im RMVX Ace

map_name = $data_mapinfos[ MAP_ID ].name
draw_text( 0, 0, 128, line_height, map_name )

Battle Counter

Im RMXP und RMVX

Leider gibt es in beiden Makern nichts vorgefertigtes dafür und wir müssen den Zähler erstmal selber einpflegen. Dafür gibt es diese Scripterweiterung.

#==============================================================================
# ** Game_System
#==============================================================================
class Game_System
  attr_accessor :battle_count
end
#==============================================================================
# ** Scene_Map
#==============================================================================
class Scene_Map
  #--------------------------------------------------------------------------
  # * Battle Call
  #--------------------------------------------------------------------------
  alias_method( :org_call_battle_wo_bce, :call_battle )
  def call_battle
    $game_system.battle_count  = 0 if $game_system.battle_count.nil?
    $game_system.battle_count += 1
    org_call_battle_wo_bce
  end
end

Anschließend können wir aber schreiben:

self.contents.draw_text( 0, 0, 128, 32, $game_system.battle_count )

Im RMVX Ace

Hier gibt es bereits einen vorgefertigten Zähler, unter dem Namen $game_system.battle_count. Wir können also hier einfach schreiben:

draw_text( 0, 0, 128, line_height, $game_system.battle_count )

Battle Win Counter

Dieser Zähler hebt sich vom Battle Counter dahingehend ab, das er nur die Siege zählt. Allerdings ist von Haus aus, keiner der drei Maker mit dieser Funktion ausgestattet, weswegen es zum Beispiel folgende Skripterweiterung benötigt:

#==============================================================================
# ** Game_System
#==============================================================================
class Game_System
  attr_accessor :battle_win_count
end
#==============================================================================
# ** Scene_Battle
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # * End Battle
  #     result : Results (0: win, 1: escape, 2:lose)
  #--------------------------------------------------------------------------
  alias_method( :org_battle_end_wo_bce, :battle_end )
  def battle_end(result)
    if result == 0
      $game_system.battle_win_count  = 0 if $game_system.battle_win_count.nil?
      $game_system.battle_win_count += 1
    end
    org_battle_end_wo_bce(result)
  end
end

Im RPG Maker VX Ace ist die Methode battle_end im Modul BattleManager. Man muss anstatt Scene_Battle also diesen erweitern:

#==============================================================================
# ** Battle_Manager
#==============================================================================
module BattleManager
  #--------------------------------------------------------------------------
  #   singleton class access for alias
  #--------------------------------------------------------------------------
  class << self
   #--------------------------------------------------------------------------
   # * End Battle
   #     result : Results (0: win, 1: escape, 2:lose)
   #--------------------------------------------------------------------------
   alias_method( :org_battle_end_wo_bce, :battle_end )
   def battle_end(result)
     if result == 0
       $game_system.battle_win_count  = 0 if $game_system.battle_win_count.nil?
       $game_system.battle_win_count += 1
     end
     org_battle_end_wo_bce(result)
   end
  end
end

Nach dieser Erweiterung, finden wir die Anzahl der gewonnen Kämpfe in der Variable $game_system.battle_win_count. Für den RMXP muss man diese Zahl noch in einen String umwandeln, aber ansonsten können wir einfach schreiben:

self.contents.draw_text( 0, 0, 128, WLH, $game_party.battle_win_count, 2)

Save Counter

Die Anzahl der Speichervorgänge wird in allen drei Makern unter $game_system.save_count gespeichert. Für den RMXP muss man diese Zahl noch in einen String umwandeln, ansonsten kann man sie ganz normal zeichnen:

self.contents.draw_text( 0, 0, 128, WLH, $game_party.save_count, 2)

Step Counter

Die Anzahl der gegangenen Schritte findet man in allen drei Makern unter $game_party.steps. Für den RMXP muss man diese Zahl noch in einen String umwandeln, ansonsten kann man sie ganz normal zeichnen:

self.contents.draw_text( 0, 0, 128, WLH, $game_party.steps, 2)

Im Spiel vergangene Zeit

Die im Spiel vergangene Zeit kann man gut errechnen. Das Modul Graphics zählt, wie viele Frames vergangen sind, in seinem Attribut Graphics.frame_count. Ausserdem können wir die Framerate nachgucken Graphics.frame_rate, die angibt wieviele Frames pro Sekunde gezeichnet werden. Daraus kann man nun die im Spiel vergangenen Sekunden bestimmen: vergangene_sekunden = Graphics.frame_count / Graphics.frame_rate Im RMXP und RMVX muss man dies per Hand ausrechnen, im RMVX Ace gibt es dafür die Methode $game_system.playtime. Ausserdem gibt es dort die Methode $game_system.playtime_s, die uns einen vorformatierten String zurückgibt, indem die vergangenen Sekunden bereits in das Format "hh:mm:ss" gebracht wurden. Im RMXP und RMVX muss man dies noch per Hand machen. Beispiel aus dem RMXP:

    @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.font.color = normal_color
    self.contents.draw_text(4, 32, 120, 32, text, 2)

Beispiel für den RMVX Ace:

    change_color(normal_color)
    draw_text(4, line_height, 120, line_height, $game_system.playtime_s, 2)

aktuelle Computerzeit

Die Rubyklasse Time bietet Zugriff auf die aktuelle Systemzeit. Mit

aktuelle_zeit = Time.now

bekommt man ein Timeobjekt, welches Informationen über die aktuelle Zeit enthält. Zum Anzeigen der Zeit bietet das Timeobjekt die Methode strftime( formatstring ) an, welche einen Formatstring als Parameter erhält und dazu die Zeitinformationen als String zurückgibt.

Formatstring	Ausgabe	Beispiel	Formatstring	Ausgabe	Beispiel
"%d.%m. %Y"	DD.MM. YYYY	25.07. 2015	"%c"	MM/DD/YY hh:mm:ss	07/25/15 19:24:56
"%H:%M"	hh:mm	12:06	"%H:%M:%S"	hh:mm:ss	12:06:54
"%X"	hh:mm:ss	12:06:54	"%a, %X"	day of week, hh:mm:ss	"Sun, 12:06:54"

Beispiel:

aktuelle_zeit = Time.now
zeit_string = aktuelle_zeit.strftime("%a, %X")
self.contents.draw_text( 16, 32, 128, 32, zeit_string )

Alle möglichen Formate und weitere Informationen zur Klasse Time findet man auf rubydoc.org

einen Icon anzeigen

Im RMXP

gibt es leider keine vorgefertige Methode dafür und wir müssen es von Hand machen. Wir holen uns das Bitmap über den Cache:

icon_bitmap = RPG::Cache.icon( "Name der Grafik im Iconordner" )

und zeichnen diese auf das Content Bitmap

self.contents.blt( 4, 4, icon_bitmap, Rect.new(0, 0, 24, 24))

Die ersten beiden Zahlen geben hierbei die x und y Koordinate an, an der wir unser Bild zeichnen und das Rect am Ende den Bildausschnitt, den wir von unserem Icon zeichnen wollen, wobei 24x24 die Standardgröße des Icon ist.

Im RMVX und RMVX Ace

Hier gibt es die Methode

draw_icon(icon_index, x, y, enabled = true)

deren optionaler und letzter Parameter angibt, ob das Icon deckend, oder halbtransparent gezeichnet werden soll.

Daten eines Partymember

Da es häufig nötig ist, bestimmte Daten eines Mitglieds der Gruppe anzuzeigen, wie zum Beispiel dessen Namen, Klasse oder Lebenspunkte, stellt die Superklasse Window_Base dafür einige Methoden bereit. Ein paar davon werden hier aufgeführt, sind zusammen mit den anderen aber leicht im ScriptEditor nachschlagbar.

Zuerstmal braucht man für die Methode aber den Helden als Objekt (dieser hat die Klasse Game_Actor). Für einen beliebigen Helden aus der Database benutzt man den Code:

mein_held = $game_actors[ Nummer_in_der_Database ]

Man kann anstatt über die DatabaseID auch über die Partynummer gehen, wofür die folgende Variable angesprochen wird:

• mein_held = $game_party.actors[ NUMMER_IN_DER_GRUPPE_BEGINNEND_BEI_NULL ] für den RMXP
• mein_held = $game_party.members[ NUMMER_IN_DER_GRUPPE_BEGINNEND_BEI_NULL ] für den RMVX
• mein_held = $game_party.members[ NUMMER_IN_DER_GRUPPE_BEGINNEND_BEI_NULL ] für den RMVX Ace

Dieses Objekt übergibt man nun den vorgefertigten Methoden, als actor-Parameter:

Funktion	Name im RMXP	Name im RMVX	Name im RMVXace
Name des Helden	draw_actor_name( actor, x, y)	draw_actor_name( actor, x, y)	draw_actor_name( actor, x, y, width=112)
Spitzname des Helden	X	X	draw_actor_nickname( actor, x, y, width=180)
Klasse des Helden	draw_actor_class( actor, x, y)	draw_actor_class( actor, x, y)	draw_actor_class(actor, x, y, width=112)
Level des Helden	draw_actor_level( actor, x, y)	draw_actor_level( actor, x, y)	draw_actor_level( actor, x, y)
HP des Helden *	draw_actor_hp(actor, x, y, width=144)	draw_actor_hp(actor, x, y, width=120)	draw_actor_hp(actor, x, y, width=124)
SP des Helden *	draw_actor_sp(actor, x, y, width=144)	draw_actor_mp(actor, x, y, width=120)	draw_actor_mp(actor, x, y, width=124)
TP des Helden	X	X	draw_actor_tp( actor, x, y, width=124)
Grafik des Helden	draw_actor_graphic( actor, x, y)	draw_actor_graphic( actor, x, y)	draw_actor_graphic( actor, x, y)

* Wenn die angegebene Breite groß genug ist, werden sowohl die aktuellen als auch die maximalen Punkte, getrennt durch einen Schrägstrich gezeichnet. Welcher Wert für die Breite mindestens angegeben werden muss, kann im ScriptEditor eingesehen werden. Ein X bedeutet, das Attribut existiert in dieser Makerversion nicht.

Es gibt noch weitere Methoden, sowie Kurzversionen im RMVX Ace, welche aber leicht im ScriptEditor eingesehen werden können und deswegen hier nicht extra erwähnt werden.

Verwandte Artikel

• Die Window Klasse des RGSS
• Liste aller Windowsubklassen
• Tutorial: Ein Balken HUD selber erstellen
• Tutorial: Die Standardschriftfarben erweitern