Quelltext der Seite RGSS/Tutorials/Scene Erklärung

==Einleitung==

Ich habe mich mal hingesetzt und eine Mini Skript geschrieben und wirklich zu allem einem Kommentar verfasst.ich werd noch weitere davon hier reinstellen, es soll nur für totale Anfäger verständlich sein wie so etwas Funktioniertund wie man es erweitern kann.


Also wenn es was unklar ist dann frag [http://forum.rpgxp.de/project/topic.php?id=6123& hier drin] einfach.ich möchte hier kein Danke für etwas, denn ohne weiteres Ausbauen des Skriptes kann man es für gar nichts verwenden.

===Einbau===

Aufgerufen wird es ganz einfach mit einem Normalen Event und Call Skript: 
 $scene = Scene_Test1.new
Beenden kann man es noch nicht, es wie gesagt nur ein Test Skript Grundgerüst zur Verständniss von Scenen und Windows später noch genaue Erklärung einzelner Begriffe.

Hier noch ein Bild wie es in etwa bei euch dann aussehen sollte: 

http://img462.imageshack.us/img462/8865/test9br.jpg

==Code==
 #==============================================================================
 class Scene_Test1
 #==============================================================================
  def main # definiert den Hauptteil der Scene    
    @Test1 = Window_Test1.new # Window_test1 wird in dieser Scene gestartet
    @Test1.x = 0 # X Postion von Window_test1
    @Test1.y = 0 # Y Postion von Window_test1    
    Graphics.transition # Übergang ausführen    
    loop do # eine Schleife wird gestartet      
      Graphics.update # Bildschirmgrafiken Aktuallisieren      
      Input.update # Update input information      
      if $scene != self # die Schleife Beenden, wenn sich der Bildschirm verändert
        break # Schleife wird abgebrochen
      end # Ende der Bedingung      
    end # Ende der Schleife    
    Graphics.freeze # Vorbereitung auf einen Übergang    
    @Window_Test1.dispose # Window_Test1 verschwinden lassen
  end
 end
 # hier demonstriere ich, das man nicht unbedingt alles in ein Neues Skript machen muss.
 # man könnte also alle Skripts in ein Skript packen, es dient nur der Übersicht, das man es nicht macht.
 #==============================================================================
 class Window_Test1 < Window_Base #der Windows_Base Standard wird auf das Window angewendet
 #==============================================================================  
  def initialize # definiert den Start des Windows    
    super(0, 0, 640, 480) # Postion und Maße des Fensters (X, Y, Breite, Höhe)    
    self.contents = Bitmap.new(width - 32, height - 32) # kann ich nich erklären, is einfach so ^^
    #---------------------------------------------------------------------------
    # als nächtes nur weitere möglichkeiten die man für Fenster hat
    #---------------------------------------------------------------------------
    #self.back_opacity = 0 # Fenster inerhalb des Fensterrahmens wird Transparent    
    #self.contents_opacity = 160 # Fensterinhalte werden Tranzparent / hier auf 160 weil nur Halbtransparent    
    #self.opacity = 0 # Komplettes Fenster wird Transparent    
    refresh # Aktualliesieren  
  end # Ende von def initalize
 #---------------------------------------------------------------------------
  def refresh # definiert eine Aktuallisierung, was beim Aktuallisieren angezeigt / erneuert wird    
    self.contents.clear # die eigenen(self) Inhalte(contents) werden geleert(clear)    
    # jetz wird ein Bild angezeigt, dieses habt ihr nich, ersetzt es am besten mit einem Eigenen und macht dann das # weg
    #self.contents.blt(4, 4, RPG::Cache.picture('arrow'), Rect.new(0, 0, 96, 96)) # mehr dazu später    
    #hier wird ein Text angezeigt
    self.contents.draw_text(10, 5, 118, 32, "Test") # mehr dazu später    
  end # Ende von def refresh
 end

==Erklärung==

 def main
 #---------------------------------------------------------------------------1
    @Test1 = Window_Test1.new 
    @Test1.x = 0 
    @Test1.y = 0 
    Graphics.transition 
    #---------------------------------------------------------------------------2
    loop do
      Graphics.update 
      Input.update
      if $scene != self 
        break 
      end
    end 
    #---------------------------------------------------------------------------3
    Graphics.freeze 
    #---------------------------------------------------------------------------4
    @Window_Test1.dispose 
 end


so der 1. teil des Skripts ist aufgeteilt in 4 Bereiche (siehe Zahlen)

===Scene===
====Bereich 1====
Start, das was eigentlich passiert, z.b. Windows aufrufen oder Befehle definieren.

Das [[Graphics.transition]] startet einen Übergang, ohne den es nicht möglich wäre das sich etwas verändert

====Bereich 2====
Bedingungen, hier ist es eine Schleife die überprüft ob sich das Fenster verändert.
mit [[Graphics.update]] werden die Grafiken erneuert
Begriffe:
*'''if''' - eine [[Bedingung]], einfach übersetzt bedeuted es falls/wenn das und das passiert
*'''!=''' - das ist ein Vergleich, hierbei bedeuted es "verändert"
*'''self''' - Übersetzt ganz einfach selbst, eigene.

Zusammen kann man es wie einen Satz lesen, den man gedanklich zusammensetzthier der lesbar sich ergebende Satz: Falls sich die eigene $scene verändert

*'''loop''' - Schleife , eine sich endlos wiederholende Schleife
*'''do''' - tun, hierbei heißt es aber " bis "
*'''break''' brechen - die Schleife wird ohne Nachfragen sofort abgebrochen

ganz einfach gesagt, " Loop do " heißt das es nur mit einem " break " abgebrochenwerden kann weil es zusammen so zu lesen ist, " Schleife bis abbruch",es wiederholt sich also solange bis ein Break kommt, ohne das, ist es nichtmöglich eine Scene zu benutzen, das sie sich nicht verändern könnte

====Bereich 3====
Endvorbereitung

das Ende wird vorbereitet da sich jetzt die Grafiken nicht mehr verändern, kann man sie einfrieren damit sie nicht mehr genutzt werden, so erreicht man einen Übergang und da die Grafiken nicht mehr genutzt werden (wie z.b. Windows, aber keine Bilder), werden sie einfach so eingefroren wenn eine Neue Szene startet. 

====Bereich 4====
Endehier kommt dann alles rein was beim beenden der Szene passieren soll,hierbei wird das Window beendet.

===Window_Test1===

 def initialize 
    #---------------------------------------------------------------------------1
    super(0, 0, 640, 480) 
    #---------------------------------------------------------------------------2
    self.contents = Bitmap.new(width - 32, height - 32) 
    self.contents.font.name = "Arial" 
    self.contents.font.size = 24
    #self.back_opacity = 0 
    #self.contents_opacity = 160 
    #self.opacity = 0 
    #---------------------------------------------------------------------------3
    refresh 
    #---------------------------------------------------------------------------4
 end

====Bereich 1====
Position

'''super(X, Y, Breite, Höhe)'''

Mit [[super]] wird die gleiche [[Funktion]] der [[Superklasse]] aufgerufen, und übergibt dabei die Parameter für X-Achse, Y-achse, Breite und Höhe des Fensters

====Bereich 2==== 
Contents Eigenschaften

hier werden die Eigenschaften der Contents (Objekte) definiert

*'''self''' - Übersetzt ganz einfach: selbst, eigene.
*'''contents''' - Enthält ein [[Bitmap]], dient als Zeichenfläche für alle Befehle, siehe auch [[Window]]
*'''font''' - Fonteigenschaft
*'''name''' - Untereigenschaft von [[Font]], hier der Name der Schrift, z.B. "Arial"
*'''size''' - Untereigenschaft von Font, hier die Größe der Schrift
*'''opacity''' - einfach übersetzt: [[Opazität]] = Undurchsichtigkeit (das Gegenteil von Transparenz!)
*'''Bitmap.new(width - 32, height - 32)''' " - self.contents wird die Klasse Bitmap.new zugewiesen, dies wird durch .new ausgedrückt, danach werden der neuen Klasse noch 2 Parameter übergeben, die Länge und die Breite. Damit das Script weiß wie groß das Bitmal sein soll wird dort die vorhandere Länge(width) und Breite(height) eingesetzt. Zur Besonderheit gehört das immer ein 16 pixel rand eingeplant wird, deswegen -32. Den Startpunkt (die 16/16) kann man, meiner Meinung nach, nicht anpassen. Die sind die der Klasse Window fest.

Es könnte auch so heißen:
 self.contents = Bitmap.new(self.width - 32, self.height - 32)
oder
 contents = Bitmap.new(width - 32, height - 32)
denn self. ist optional (verweißt nur auf sich selbst), aber manchmal notwendig, damit gewisse Funktionen (contents) laufen.

====Bereich 3====
Refresh ausführen

das was in " def refresh " steht wird ausgeführt

====Bereich 4====
Ende
Hier endet die Funktion def initialize.

==Links==
*[[Scene]]
*[[Window]]