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
#========================================================================
# ** 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:
#========================================================================
# ** 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