Schnellscript-Funktionen

[FlipelyFlip]

Heyho,

ich möchte euch hier ein kleines aber denoch wirklich feines und nützliches Script präsentieren.
Es ist ein Script, mit dem das Eventen wohl um einiges erleichtert wird und auch viele Möglichkeiten bietet, Codes schlanker zu gestallten.

Was macht dieses Script?
Man kann mit diesen paar Funktionen die ich zurzeit drinen hab, viele "neue" Effekte verwenden, wie zB. das bestimmen der Zeit, die man für ein Fadeout bzw. Fadein verwenden.
Man kann mehrere Conditional Branches die nacheinander erfolgen in nur einer einzigen erledigen, durch meine kleine Methode.
Im großen und ganzen kann man sagen, es erleichtert einem das Eventen (=

Welche funktionen beinhaltet dieses Script?
Das Script beinhaltet folgende Funktionen:

• Variabeloperationen
• Variabelüberprüfungen
• löschen von Events (ich weiß das dafür auch ein Eventbefehl existiert, aber ich komme später nochmal dazu zurück)
• Fadein und Fadeout Zeitbestimmung
• Aufrüfen eines Menüs, obwohl das aufrufen des Menü gesperrt wurde (der eventbefehl funkt da auch nich, habs nachgeguckt q: ) selbiges gilt auch für das Save-Menü
• Switchoperationen
• "Self-Variablen" (genaueres findet ihr im Script), es sind 2 vorhanden, weitere können erstellt werden.
• Überprüfung der "Self-Variablen"

Das Script selbst

Spoiler for Hiden:

Code: [Auswählen]

#========================================================================
# ** Einfaches Eventen
#------------------------------------------------------------------------
# by FlipelyFlip
#========================================================================
=begin
Regeln zur Verwendung:
Verwendet es wie ihr wollt. Ihr müsst mir keine Credits geben (=
Das Script besteht sogesehen eigentlich nur aus 2 teilen, einmal
dieem hier und dem Message System Add-On. Wenn man dieses Script
mit einem anderen Messagesystem verwenden will, würde man einen
kleinen Konflikt bekommen. Wenn man weiß was man machen muss, dann
kann man es selbst machen, ansonsten stehe ich gerne für euch da,
um dies für euch einzubauen (=

lg flip

Was bewirkt dieses Script?
-------------------------------------------------------------------------
Mit diesem Script soll das Eventen um einiges vereinfacht werden.
Ebenso soll es auch einige problemchen Umgehen die mit verschiedenen
Eventbefehlen passieren können. Man kann zB. direkt ins Menü einsteigen,
obwohl man es vorher mit nem Eventbefehl ausgeschaltet hat, selbige
gilt auch für das Speichermenü.
Man kann aber auch die länge eines fadeouts/fadeins bestimmen. Man kann
mit einem kurzen Befehl auch ein Event löschen wenn man will ;)
Man kann auch mehrere Prüfungen gleichzeitig durchführen mit Conditional
Branches und der Scriptabfrage.

Wie wird es aufgerufen?
-------------------------------------------------------------------------
Es existieren folgende Befehle:

Flips.operate(var,zahl,op)
Flips.löschen(event_id)
Flips.fade(t)
Flips.fadein(t)
Flips.prüfen(var1,var2,op)
Flips.menü
Flips.speichern
Flips.switch(id,op)
Flips.imagine1(wert)
Flips.imagine2(wert)
Flips.imagines_prüfung(op)

Die Befehle werden weiter unten erklärt (=

Es existieren folgende Befehle im Messagesystem:

\cs[id,op]        Das id entspricht der Switch-ID und op steht entweder
                  für 0 oder 1. 0 = Switch an; 1 = Switch aus

\cv[id,zahl,op]   das id entspricht der Variabel-ID, zahl steht für einen
                  Wert und op entspricht durch eine kleine Wertgebung(0-5)
                  was mit dem Wert zahl passiert. Obs dazugezählt wird oder
                  nicht.
                  op-Variationen:
                  0 = Variabel wird dem Wert zahl gleichgesetzt
                  1 = Variabel wird um den Wert zahl erhöht
                  2 = Variabel wird um den Wert zahl vermindert
                  3 = Variabel wird um den Wert zahl multipliziert
                  4 = Variabel wird um den Wert zahl dividiert
                  5 = Variabel wird um den Wert zahl Rest-Gerechnet

\ci1[wert]        damit wird der imaginären Variable imagine1 der Wert wert
                  zugeteilt.
                 
\ci2[wert]        damit wird der imaginären Variable imagine2 der Wert wert
                  zugeteilt.
                 
Das waren alle Befehle zurzeit. Wenn euch noch ein weiterer Befehl einfällt,
könnt ihr es gerne nennen (=
=end
module Flips # NICHT VERÄNDERN!!! GANZ WICHTIG wenn ihr mein Messagesys
             # verwendet!
             
  #----------------------------------------------------------------------
  # * Variabelarbeiten
  #----------------------------------------------------------------------
  # var = Variabelnummer = ID der verwendeten Variable
  # zahl = Die Zahl um die es erhöht, vermindert, multipliziert oder sonst
  # was wird.
  # op = Operation. Damit bestimmt man was gemacht wird.
  def self.operate(var,zahl,op)
    if op == 0 # Variabel[ID] wird einer Zahl gleichgesetzt
      $game_variables[var] = zahl
    elsif op == 1 # Variabel[ID] wird um Zahl addiert
      $game_variables[var] += zahl
    elsif op == 2 # Variabel[ID] wird um Zahl subtrahiert
      $game_variables[var] -= zahl
    elsif op == 3 # Variabel[ID] wird um Zahl multipliziert
      $game_variables[var] *= zahl
    elsif op == 4 # Variabel[ID] wird um Zahl dividiert
      $game_variables[var] /= zahl
    elsif op == 5 # Variabel[ID] wird um Zahl restgerechnet
      $game_variables[var] %= zahl
    end
  end
  #----------------------------------------------------------------------
  # * Event löschen
  #----------------------------------------------------------------------
  # event_id = die ID des Events das gelöscht werden muss.
  def self.löschen(event_id)
    $game_map.events[event_id].erase # erledigt dann das Löschen
  end
  #----------------------------------------------------------------------
  # * Fadeout
  #----------------------------------------------------------------------
  # t = Zeit die benötigt wird, bis der Bildschirm schwarz ist. Wird in
  # Frames angegeben.
  def self.fade(t)
    screen.start_fadeout(t)
    @wait_count = t
  end
  #----------------------------------------------------------------------
  # * Fadein
  #----------------------------------------------------------------------
  # t = Zeit die benötigt wird, bis der Bildschirm wieder die normale Map
  # anzeigt.
  def self.fadein(t)
    screen.start_fadein(t)
    @wait_count = t
  end
  #----------------------------------------------------------------------
  # * Prüfungen mit Variablen
  #----------------------------------------------------------------------
=begin
Hier könnt ihr nun die ganzen Überprüfungen schnell und einfach machen.
Durch diesen Befehl könnt ihr mehrere Variablen gleichzeitig abfragen.
Nur wenn alle Kriterien übereinstimmen wirft es dann in der Conditional
Branche ein true zurück, ansonsten ist es false.
Um mehrere Abfragen zu machen wird das so gehandhabt:

>Conditional Branch: Script: Flips.prüfen?(1,2,1) and Flips.prüfen?(1,3,2)
 >
>else
 >
>end

Damit wird überprüft ob die Variable 1 größer oder gleich Variable 2 ist
und ob Variable 1 aber kleiner oder gleich Variable 3 ist. Treffen beide
Kriterien zu wird ein True zurückgegeben, ansonsten false.

var1 = Variable ID der ersten Variable
var2 = Variable ID der zweiten Variable
op = Operation, bzw. Bedingung, welche erfüllt werden muss für true

vorhandene Arten des OP:

0 = Equal
1 = Greater than, or equal
2 = Less than, or equal
3 = Greater than
4 = Less than
5 = not equal
=end
  def self.prüfen?(var1,var2,op)
    if op == 0 # Equal
     if $game_variables[var1] == $game_variables[var2]
       return true
     else
       return false
     end
   elsif op == 1 # Greater than, or equal
     if $game_variables[var1] >= $game_variables[var2]
       return true
     else
       return false
     end
   elsif op == 2 # Less than, or equal
     if $game_variables[var1] <= $game_variables[var2]
       return true
     else
       return false
     end
   elsif op == 3 # Greater than
     if $game_variables[var1] > $game_variables[var2]
       return true
     else
       return false
     end
   elsif op == 4 # Less than
     if $game_variables[var1] < $game_variables[var2]
       return true
     else
       return false
     end
   elsif op == 5 # not equal
     if $game_variables[var1] != $game_variables[var2]
       return true
     else
       return false
     end
   end
  end
 
  #----------------------------------------------------------------------
  # * Menücall
  #----------------------------------------------------------------------
  # wirkt im ersten Moment recht unnütz, ist aber trotzdem sehr nützlich,
  # da man das Menü trotzdem aufrufen kann, durch diesen Befehl, auch wenn
  # es eigentlich ausgestellt wurde.
  def self.menü
    $scene = Scene_Menu.new(0)
  end
 
  #----------------------------------------------------------------------
  # * Speicherncall
  #----------------------------------------------------------------------
  # selbes gilt wie oben beim Menü ;)
  def self.speichern
    $scene = Scene_File.new(false,false,true)
  end
 
  #----------------------------------------------------------------------
  # * Switch
  #----------------------------------------------------------------------
  # Damit kann man den Switch an und aus stellen ;)
  # id entspricht der Switch ID und das op entscheidet sich zwischen 0
  # und 1, 0 = on; 1 = off
  def self.switch(id,op)
    if op == 0
      $game_switches[id] = true
    elsif op == 1
      $game_switches[id] = false
    end
  end
 
  #----------------------------------------------------------------------
  # * "Self-Variable"
  #----------------------------------------------------------------------
  # Eigentlich ist dies eigentlich nichts weiter als eine Variable, die
  # einem Wert gleichgesetzt werden kann. Hier existieren die selben
  # Operationen wie bei den Variablen, es entfällt jedoch nur die
  # ID-Angabe und diese Variablen gelten nicht nur für ein Event sondern
  # ebenfalls allgemein^^"
  # Beschreibung gilt für self.imagines1(wert,op) sowie auch für
  # self.imagines2(wert,op)
  def self.imagines1(wert,op)
    if op == 0
      imagines1 = wert
    elsif op == 1
      imagines1 += wert
    elsif op == 2
      imagines1 -= wert
    elsif op == 3
      imagines1 *= wert
    elsif op == 4
      imagines1 /= wert
    elsif op == 5
      imagines1 %= wert
    end
  end
  def self.imagines2(wert,op)
    if op == 0
      imagines2= wert
    elsif op == 1
      imagines2 += wert
    elsif op == 2
      imagines2 -= wert
    elsif op == 3
      imagines2 *= wert
    elsif op == 4
      imagines2 /= wert
    elsif op == 5
      imagines2 %= wert
    end
  end
 
  #----------------------------------------------------------------------
  # * "Self-Variablen"-Prüfung
  #----------------------------------------------------------------------
  # Überprüft die beiden Variablen, je nach eingabe des op.
  # Eingabemöglichkeiten:
  # op = 0; ob beide imagines gleichgroß sind
  # op = 1; ob imagines1 größer oder gleichgroß ist wie imagines2
  # op = 2; ob imagines1 kleiner oder gleichgroß ist wie imagines2
  # op = 3; ob imagines1 größer ist als imagines2
  # op = 4; ob imagines1 kleiner als imagines2 ist
  # op = 5; ob imagines1 ungleich imagines2 ist
  def self.imagines_prüfung?(op)
    if op == 0 # Equal
      if Flips.imagines1 == Flips.imagines2
        return true
      else
        return false
      end
    elsif op == 1 # Greater than, or equal
      if Flips.imagines1 >= Flips.imagines2
        return true
      else
        return false
      end
    elsif op == 2 # Less than, or equal
      if Flips.imagines1 <= Flips.imagines2
        return true
      else
        return false
      end
    elsif op == 3 # Greater than
      if Flips.imagines1 > Flips.imagines2
        return true
      else
        return false
      end
    elsif op == 4 # Less than
      if Flips.imagines1 < Flips.imagines2
        return true
      else
        return false
      end
    elsif op == 5 # not equal
      if Flips.imagines1 != Flips.imagines2
        return true
      else
        return false
      end
    end
  end
end


Eventuelle Add-Ons
Jub, es existiert wirklich ein kleines Add-On!^^
Es ist eines für das Message System, welches einem erlaubt, variabeloperationen, "self-variabel"operationen, switchoperationen und das löschen von Eventbefehlen erlaubt.
Es ist nicht mit anderen Messagesystems kompatibel, wer es aber trotzdem haben will, aber in kombination mit anderen Messagesystems, der kann sich gerne bei mir melden
und ich werde ihm das ganze so zusammenschneiden dass es passt. Diejenigen die es selbst können, können es auch selbst machen.
Das Message-Script Add-On:

Spoiler for Hiden:

Code: [Auswählen]

#========================================================================
# ** Flips Anfangsmessage System
#------------------------------------------------------------------------
# * by FlipelyFlip
#========================================================================
=begin
WICHTIG!!!!!
Dieses Script wird nicht Funktionieren wenn das Script Einfaches Eventen
fehlt!!! Einfaches Eventen kann aber ohne diesem Script verwendet werden!

Bedingungen zur Verwendung gelten wie immer:
Credits sind nicht zwingend, aber sind gern gesehen.
Ihr dürft es verwenden wie ihr wollt, solange ihr es nicht als eigenes
ausgebt!

Veränderungen:

Ich habe lediglich nur 5 Befehle hinzugefügt, die eigentlich im großen
und ganzen wahrscheinlich von euch häufig benutzt werden, da es einfach
schneller geht!

Die Befehle findet ihr in der Beschreibung von Einfaches Eventen. Daher
liste ich sie hier nicht nocheinmal auf.

Dieses Script ist mit anderen Message Systems nicht kompatibel, wer denoch
diese Befehle verwenden will, aber nicht scripten kann, dem schreibe ich
gerne sein Messagesystem so um, dass er auch meine Befehle dort nutzen kann.
Wer sowas selber machen kann, der kanns ruhig machen (=

lg flip
=end

class Window_Message < Window_Selectable
 
  alias flips_convert_special_characters convert_special_characters
  def convert_special_characters
    flips_convert_special_characters
    @text.gsub!(/\\CS\[(\d+),(\d+)\]/i)         {"\x09[#{[$1]},#{[$2]}]"}
    @text.gsub!(/\\CV\[(\d+),(\d+),(\d+)\]/i)   {"\x10[#{[$1]},#{[$2]},#{[$2]}]"}
    @text.gsub!(/\\EE\[(\d+)\]/i)               {"\x11[#{[$1]}"}
    @text.gsub!(/\\CI1\[(\d+),(\d+)\]/i)        {"\x12[#{[$1]},#{[$2]}]"}
    @text.gsub!(/\\CI2\[(\d+),(\d+)\]/i)        {"\x13[#{[$1]},#{[$2]}]"}
  end
 
  def update_message
    loop do
      c = @text.slice!(/./m)            # Get next text character
      case c
      when nil                          # There is no text that must be drawn
        finish_message                  # Finish update
        break
      when "\x00"                       # New line
        new_line
        if @line_count >= MAX_LINE      # If line count is maximum
          unless @text.empty?           # If there is more
            self.pause = true           # Insert number input
            break
          end
        end
      when "\x01"                       # \C[n]  (text character color change)
        @text.sub!(/\[([0-9]+)\]/, "")
        contents.font.color = text_color($1.to_i)
        next
      when "\x02"                       # \G  (gold display)
        @gold_window.refresh
        @gold_window.open
      when "\x03"                       # \.  (wait 1/4 second)
        @wait_count = 15
        break
      when "\x04"                       # \|  (wait 1 second)
        @wait_count = 60
        break
      when "\x05"                       # \!  (Wait for input)
        self.pause = true
        break
      when "\x06"                       # \>  (Fast display ON)
        @line_show_fast = true
      when "\x07"                       # \<  (Fast display OFF)
        @line_show_fast = false
      when "\x08"                       # \^  (No wait for input)
        @pause_skip = true
      when "\x09"                       # \cs (control switch)
        @text.sub!(/\[(\d+),(\d+)\]/, "")
        Flips.switch($1.to_i, $2.to_i)
      when "\x10"                       # \cv (control variable)
        @text.sub!(/\[(\d+),(\d+),(\d+)\]/, "")
        Flips.operate($1.to_i,$2.to_i,$3.to_i)
      when "\x11"                       # \ee (erase event)
        @text.sub!(/\[(\d+)\]/,"")
        Flips.löschen($1.to_i)
      when "\x12"                       # \ci1 (control imagines1)
        @text.sub!(/\[(\d+),(\d+)\]/,"")
        Flips.imagine1($1.to_i,$2.to_i)
      when "\x13"                       # \ci2 (control imagines2)
        @text.sub!(/\[(\d+),(\d+)\]/,"")
        Flips.imagine2($1.to_i,$2.to_i)
      else                              # Normal text character
        contents.draw_text(@contents_x, @contents_y, 40, WLH, c)
        c_width = contents.text_size(c).width
        @contents_x += c_width
      end
      break unless @show_fast or @line_show_fast
    end
  end
end

Dieses Messagesystem benötigt das einfache Event-Code script!

Sonstiges

Ich habe eigentlich nichts mehr zu sagen, wenn jemand noch ideen dafür hat, soll er sie bitte sagen und ich werde mich mal ransetzten
und gucken obs machbar ist (=

lg flipely