Druckbare Version
Das ist seltsam, $game_system sollte es ja eigentlich schon geben. Die Fehlermeldung klingt im ersten Moment nämlich so, als ob $game_system noch nicht angelegt wurde, aber das sollte im laufenden Betrieb nicht der Fall sein. Oder benutzt du noch an anderer Stelle eine Variable oder Methode namens memory?
Ne, bin eben noch mal alle Scripte durchgegangen die ich verwende.
Nirgens findet sich auch nur das Wort "memory" oder "Memory"
Daher sollte es ja an und für sich auch keine Probleme mit anderen Scripten geben O_o (nicht in diesem Fall)
Falls es hilfreich ist, folgende Scripte sind noch im Einsatz. (Was euch ohne Code wenig hilft, aber irgendwie nehme ich auch mal an, dass ihr wenig Lust habt den durchzuschauen) ^^
...hätte ich auch nicht.
Und dann halt noch eigene Scripte. Aber da bin ich mir recht sicher, dass da kein "Memory" oder "memory" drin vorhanden ist.Zitat:
Yanfly Engine:
- Ace Message System
- Ace Menu Engine
Lone Wolf:
- Gamepad Extender
MOG
- MOG_Animated_Title_A
Khas Arcthunder:
- Pathfinding
Bei den anderen auch... Suchfunktion und so.
Kannst du vielleicht doch mal deine eigenen Scripte posten, also Game_Memory und Scene_Memory?
Also im Ganzen ist es halt das hier:
Code:class Game_Memory
# hier kommen alle Attribute rein die dein Spiel so hat
# filenames of the pictures of your cards
attr_accessor :figure_names
def initialize
@figure_names = ["Spinne1.png", "Spinne2.png", "Spinne3.png", "Spinne4.png",
"Spinne5.png",
"Spinne6.png", "Spinne7.png", "Spinne8.png", "Spinne9.png", "Spinne10.png",
"Spinne11.png",
"Spinne12.png", "Spinne13.png", "Spinne14.png", "Spinne15.png", "Spinne16.png"]
@positions = [
0, 0,
136, 0,
272, 0,
408, 0,
#
0, 104,
136, 104,
272, 104,
408, 104,
#
0, 208,
136, 208,
272, 208,
408, 208,
#
0, 312,
136, 312,
272, 312,
408, 312
]
# number of cards horizontal
@max_number_of_cols = 4
# size of cards
@card_width = 64
@card_height = 64
# distance between cards
@margin = 12
p @positions
#SceneManager.call(Scene_Memory.start)
#Scene_Memory.start
#SceneManager.call(Scene_Memory.start)
end
# returns x, y coordinates as well as the image name of
# the card with the given index
def get_card index
[card_x(index), card_y(index), card_image(index)]
end
# return all cards
def get_cards
# create a new array with elements
# for all indizes from 0 upto @positions.size
(0...@positions.size).map do |index|
# each element contains the result value of
# get_card
get_card index
end
end
# x coordinate for a given card index
def card_x index
col_num = index % @max_number_of_cols
col_num * (@card_width + @margin)
end
# y coordinate for a given card index
def card_y index
row_num = index / @max_number_of_cols
row_num * (@card_height+@margin)
end
# filename of card image
def card_image index
@figure_names[@positions[index]]
end
# number of different figures/cards
def number_of_pictures
@figure_names.size
end
# add 2 cards for each figure into the field
# shuffle the positions of all cards
def shuffle_cards
@positions.clear
# this loop is invoked as often as the number
# of different cards
number_of_pictures.times do |picture_id|
# for each invocation, two cards are added
# into the array
@positions << picture_id << picture_id
end
# shuffle the array at the end
@positions.shuffle!
end
end
class Game_System
# füge Memory als Attribut hinzu
attr_accessor :memory
end
# Erbebt von Scene_Base
class Scene_Memory < Scene_Base
#class << self
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------
def initialize_graphics
# for each card in the game
@card_sprites = $game_system.memory.get_cards.map do |x, y, image|
# create a new sprite
sprite = Sprite.new
# set its graphic and coordinates
sprite.bitmap = Cache.picture(image)
sprite.x, sprite.y = x, y
# and "return" the sprite into the array
sprite
end
end
def update_graphics
# update attributes of all sprites
@card_sprites.each_with_index do |sprite, index|
x, y, image = $game_system.memory.get_card(index)
sprite.bitmap = Cache.picture(image)
sprite.x, sprite.y = x,y
end
end
def dispose_graphics
@card_sprites.each do |sprite|
sprite.dispose
end
end
#-------------------------------------------------------------------------------
# überschreibt terminate Scene_Base
#-------------------------------------------------------------------------------
def terminate
super
dispose_graphics
end
#-------------------------------------------------------------------------------
# überschreibt update Scene_Base
#-------------------------------------------------------------------------------
def update
super
update_graphics
end
def start #(start)
super
initialize_graphics
update
end
#b = Scene_Memory.new
#b.start
end
#end
#-------------------------------------------------------------------------------
Das ist momentan auskommentiert damit das Spiel startet und ich an anderen Sachen werkeln kann.Code:#b = Scene_Memory.new
#b.start
In Game_System legst du noch gar keine Instanz von Game_Memory an, daher kommt wohl auch die Fehlermeldung. attr_accessor ermögtlich dir nur den Zugriff auf memory, sprich du kannst memory lesen und verändern. Angelegt wird memory dadurch noch nicht. Das ist zwar nicht die sauberste Art, aber du könntest ans Ende von initialize aus Game_System Folgendes setzen:
@memory = Game_Memory.new
Die Zeilen
#SceneManager.call(Scene_Memory.start)
#Scene_Memory.start
#SceneManager.call(Scene_Memory.start)
sind in der initialize-Methode von Game_Memory nicht so gut aufgehoben und syntaktisch denke ich auch nicht richtig. Auch
#b = Scene_Memory.new
#b.start
brauchst du nicht, weil der Scene_Manager das alles automatisch macht. Wenn ich den Ace richtig verstehe (ich kann mit der Lite-Version leider keine Scripts testen), dann müsstest du auf deiner ersten Map nur folgenden Aufruf machen:
Scene_Manager.call(Scene_Memory)
Falls ich etwas Falsches erzähle bitte gleich Bescheid sagen.
Ja, das geht... aber jetzt wird mein Stack zu groß XD
Wie kann ich das abfangen, dass mir nicht der Speicher ausgeht?
Rufst du Scene_Manager.call(Scene_Memory) vielleicht mehrmals auf? Das muss du eigentlich nur einmal machen.
So weit ich es beurteilen kann nur einmal.
Halt in einem Event mit "Parallel Prozess" ein Skriptbefehl mit den beiden Befehlen:
und da drauner wird ein Selfswitch aktiviert. Dann eben eine Seite 2 die durch den Self-Switch aktiviert wird.Code:$game_system.memory = Game_Memory.new
Scene_Manager.call(Scene_Memory)
Zur Sicherheit hab ich auf Seite 1 unten auch noch ein "Clear Event" eingebaut... der Speicher wird aber auch so zu groß.
Ergo... daran kann es nicht liegen.
Hast du schon mal überprüft, ob das Script auch Probleme macht, wenn du es in ein neues Projekt ohne sonstige Scripte von anderen einfügst?
Ansonsten wäre es vielleicht auch sinnvoll, wenn du dein Projekt, oder zumindest Data/Scripts.rvdata2, irgendwo hochladen könntest, damit nicht tröpfchenweise Ferndiagnose stattfinden muss. ;)
Du ruftst entweder innerhalb von Game_Memory ein Game_Memory.new auf oder innerhalb von Scene_Memory ein SceneManager.call(Scene_Memory). Das verursacht eine Endlosrekursion und dadurch den Stackoverflow.Zitat:
Zitat von Elster
Am besten du zeigst nochmal deinen Code so wie er jetzt aussieht.
Gut ja, dann liegt eindeutig hier der Fehler... gleich der letzte Befehl der Methode.
Habe ich wohl etwas mal wieder falsch verstanden...Code:def initialize
@figure_names = ["Spinne1.png", "Spinne2.png", "Spinne3.png", "Spinne4.png",
"Spinne5.png",
"Spinne6.png", "Spinne7.png", "Spinne8.png", "Spinne9.png", "Spinne10.png",
"Spinne11.png",
"Spinne12.png", "Spinne13.png", "Spinne14.png", "Spinne15.png", "Spinne16.png"]
@positions = [
0, 0,
136, 0,
272, 0,
408, 0,
#
0, 104,
136, 104,
272, 104,
408, 104,
#
0, 208,
136, 208,
272, 208,
408, 208,
#
0, 312,
136, 312,
272, 312,
408, 312
]
# number of cards horizontal
@max_number_of_cols = 4
# size of cards
@card_width = 64
@card_height = 64
# distance between cards
@margin = 12
p @positions
@memory = Game_Memory.new
end
Ansonsten noch mal der ganze Code.
Code:class Game_Memory
# hier kommen alle Attribute rein die dein Spiel so hat
# filenames of the pictures of your cards
attr_accessor :figure_names
def initialize
@figure_names = ["Spinne1.png", "Spinne2.png", "Spinne3.png", "Spinne4.png",
"Spinne5.png",
"Spinne6.png", "Spinne7.png", "Spinne8.png", "Spinne9.png", "Spinne10.png",
"Spinne11.png",
"Spinne12.png", "Spinne13.png", "Spinne14.png", "Spinne15.png", "Spinne16.png"]
@positions = [
0, 0,
136, 0,
272, 0,
408, 0,
#
0, 104,
136, 104,
272, 104,
408, 104,
#
0, 208,
136, 208,
272, 208,
408, 208,
#
0, 312,
136, 312,
272, 312,
408, 312
]
# number of cards horizontal
@max_number_of_cols = 4
# size of cards
@card_width = 64
@card_height = 64
# distance between cards
@margin = 12
p @positions
@memory = Game_Memory.new
end
# returns x, y coordinates as well as the image name of
# the card with the given index
def get_card index
[card_x(index), card_y(index), card_image(index)]
end
# return all cards
def get_cards
# create a new array with elements
# for all indizes from 0 upto @positions.size
(0...@positions.size).map do |index|
# each element contains the result value of
# get_card
get_card index
end
end
# x coordinate for a given card index
def card_x index
col_num = index % @max_number_of_cols
col_num * (@card_width + @margin)
end
# y coordinate for a given card index
def card_y index
row_num = index / @max_number_of_cols
row_num * (@card_height+@margin)
end
# filename of card image
def card_image index
@figure_names[@positions[index]]
end
# number of different figures/cards
def number_of_pictures
@figure_names.size
end
# add 2 cards for each figure into the field
# shuffle the positions of all cards
def shuffle_cards
@positions.clear
# this loop is invoked as often as the number
# of different cards
number_of_pictures.times do |picture_id|
# for each invocation, two cards are added
# into the array
@positions << picture_id << picture_id
end
# shuffle the array at the end
@positions.shuffle!
end
end
class Game_System
# füge Memory als Attribut hinzu
attr_accessor :memory
end
# Erbebt von Scene_Base
class Scene_Memory < Scene_Base
#class << self
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------
def initialize_graphics
# for each card in the game
@card_sprites = $game_system.memory.get_cards.map do |x, y, image|
# create a new sprite
sprite = Sprite.new
# set its graphic and coordinates
sprite.bitmap = Cache.picture(image)
sprite.x, sprite.y = x, y
# and "return" the sprite into the array
sprite
end
end
def update_graphics
# update attributes of all sprites
@card_sprites.each_with_index do |sprite, index|
x, y, image = $game_system.memory.get_card(index)
sprite.bitmap = Cache.picture(image)
sprite.x, sprite.y = x,y
end
end
def dispose_graphics
@card_sprites.each do |sprite|
sprite.dispose
end
end
#-------------------------------------------------------------------------------
# überschreibt terminate Scene_Base
#-------------------------------------------------------------------------------
def terminate
super
dispose_graphics
end
#-------------------------------------------------------------------------------
# überschreibt update Scene_Base
#-------------------------------------------------------------------------------
def update
super
update_graphics
end
def start #(start)
super
initialize_graphics
update
end
end
#end
Ja und zwar passiert Folgendes: Eine neue Instanz von Game_Memory wird angelegt. Dabei wird initialize aufgerufen, doch Methode legt dann wegen dem Aufruf @memory = Game_Memory.new gleich nochmal eine weitere Instanz an und das unendlich lang. Der Aufruf sollte bei Game_System in die Initialize-Methode geschrieben werden und der Aufruf bei Game_Memory sollte wieder entfernt werden.
Normalerweise (falls du nicht schon etwas geändert hast, steht bei Game_System Folgendes:
Daraus machst du:Code:#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
@save_disabled = false
@menu_disabled = false
@encounter_disabled = false
@formation_disabled = false
@battle_count = 0
@save_count = 0
@version_id = 0
@window_tone = nil
@battle_bgm = nil
@battle_end_me = nil
@saved_bgm = nil
end
Code:#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
@save_disabled = false
@menu_disabled = false
@encounter_disabled = false
@formation_disabled = false
@battle_count = 0
@save_count = 0
@version_id = 0
@window_tone = nil
@battle_bgm = nil
@battle_end_me = nil
@saved_bgm = nil
@memory = Game_Memory.new
end
Entschuldigt bitte das ich mir hier mit den Antworten so viel Zeit gelassen habe (RL und so).
Jedenfalls... ich habe nun die Sachen wie empfohlen geändert.
Nun habe ich jedoch wieder ein weiteres Problem.
Ich starte das Memory ja über die beiden Befehle hier:
Aus mir nun etwas unerfindlichen Gründen hat er nun wieder Probleme mit dem unteren Aufruf.Code:$game_system.memory = Game_Memory.new
Scene_Manager.call(Scene_Memory)
Das äußert sich mal wieder so...
Wenn ich jetzt "Scene_Mager.call(Scene_Memory)" auskommentiere verschwindet der Fehler natürlich, aber ich bekomme halt auch keine Bilder angezeigt.Zitat:
Script 'GameInterpreter' line 1411: NameError occurred.
uninitialized constant Game_Interpreter::Scene_Manager
Ohne jetzt deine Skripte anzuschauen, das Objekt heißt (ohne "_"): SceneManager
Versuch es mal damit (:
Oh man, manchmal hat man wirklich ein Brett vor dem Kopf :\
Dennoch, irgendwas scheint er wieder nicht finden zu wollen.
Die Meldung taucht dann auf, wenn [card_x(index), card_y(index), card_image(index)] (Mathode get_card index) keine Werte mehr aus dem Koordinatenarray bekommt.Zitat:
Script 'Cache' line 88: NoMethodError occurred.
undefined method `empty?' for nil:NilClass
Nachdem der letzte Wert geschrieben wurde... zack Meldung.
Hab jedenfalls mal am Anfang jeder Methode mir eine "Ausgabe" machen lassen und mal die Consolenausgabe kopiert.
Der Länge wegen steht es halt in einem Spoiler, sonst erschlägt es einen.
Rein theoretisch sollte es nun ja nach "get_cards" gehen .... an meine lieben Unterstützer, ich müsste hier vermutlich einen Aufruf von "get_card index" tätigen ... oder?
Der Fehler wird erzeugt, da du die Cache.Picture mit nil aufrufst.
Dies geschieht durch deinen folgenden Code:
Ich vermute mal, du möchtest, je nach Index das figure_names Array ansprechen. Demnach sollte dein Code wie folgt lauten:Code:def card_image index
@figure_names[@positions[index]]
end
Durch deinen aktuellen Code wird bpsw. bei Index = 3 nicht @figure_names[3] angesprochen (so wäre es beim unteren code), sondern @figure_names[136]. Dieser Wert ist im Array nicht vorhanden und daher nil.Code:def card_image index
@figure_names[index]
end
(@positions[3] = 136)
Edit:
Desweiteren wird dein Code nicht funktionieren, da dein @positions 16 Koordinaten (je X und Y) beinhaltet, du aber nur 15 Grafiken in @figure_names gepflegt hast. Die 16. Koordinate wird daher auch "nil" als image wählen.
Okay, so weit geändert. Dennoch, der Fehler bleibt der selbe.
Durch ein wenig rumprobieren sind mir ein paar "Merkwürdigkeiten" aufgefallen, welche ich mir selber kaum erklären kann.
Erstmal habe ich mir mehr Sachen über die Konsole ausgeben lassen, so ist mir aufgefallen, dass bei den ganzen Koordinaten wirklich zu wenig Bilder (wie angemerkt) vorhanden waren. (irgendwann stand halt nil bei Werten drin, wie du bereits gesagt hast Likey)
Darüber hinaus ist mir aber was viel interessanteres ins Auge gefallen... so bald ich das Array @positions leer lasse, stürzt es nicht ab. So bald aber Werte drin stehen taucht halt der Fehler am Ende auf....
Ich könnte es mir so erklären das er halt mault weil bestimmte Werte nicht übereinstimmen... aber sicher bin ich mir da gerade wirklich nicht.
Mein momentaner Code:
Eine tollkühne Vermutung meinerseits ist, dass er mosert das die Koordinaten aus @positions momentan einfach nicht zu den Werten aus @card_width und @card_height passen... wobei ich da momentan wirklich keinen Grund für sehe.Code:class Game_Memory
# hier kommen alle Attribute rein die dein Spiel so hat
# filenames of the pictures of your cards
attr_accessor :figure_names
def initialize
@figure_names = ["Spinne1.png", "Spinne1.png",
"Spinne2.png", "Spinne2.png",
"Spinne3.png", "Spinne3.png",
"Spinne4.png", "Spinne4.png",
"Spinne5.png", "Spinne5.png",
"Spinne6.png", "Spinne6.png",
"Spinne7.png", "Spinne7.png",
"Spinne8.png", "Spinne8.png",
"Spinne9.png", "Spinne9.png",
"Spinne10.png", "Spinne10.png",
"Spinne11.png", "Spinne11.png",
"Spinne12.png", "Spinne12.png",
"Spinne13.png", "Spinne13.png",
"Spinne14.png", "Spinne14.png",
"Spinne15.png", "Spinne15.png",
"Spinne16.png", "Spinne16.png"
]
@positions = [
0, 0,
136, 0,
272, 0,
408, 0,
#
0, 104,
136, 104,
272, 104,
408, 104,
#
0, 208,
136, 208,
272, 208,
408, 208,
#
0, 312,
136, 312,
272, 312,
408, 312
]
# number of cards horizontal
@max_number_of_cols = 3
# size of cards
@card_width = 136
@card_height = 104
# distance between cards
@margin = 0
p @figure_names
p @positions
end
# returns x, y coordinates as well as the image name of
# the card with the given index
def get_card index
p "get_card index"
[card_x(index), card_y(index), card_image(index)]
p card_x(index)
p card_y(index)
p card_image(index)
end
# return all cards
def get_cards
p "get_cards"
# create a new array with elements
# for all indizes from 0 upto @positions.size
(0...@positions.size).map do |index|
# each element contains the result value of
# get_card
get_card index
end
end
# x coordinate for a given card index
def card_x index
p "card_x index"
col_num = index % @max_number_of_cols
col_num * (@card_width + @margin)
end
# y coordinate for a given card index
def card_y index
p "card_y index"
row_num = index / @max_number_of_cols
row_num * (@card_height+@margin)
end
# filename of card image
def card_image index
p "card_image index"
@figure_names[index]
#@figure_names[@positions[index]]
end
# number of different figures/cards
def number_of_pictures
p "number_of_pictures"
@figure_names.size
end
# add 2 cards for each figure into the field
# shuffle the positions of all cards
def shuffle_cards
p "shuffle_cards"
@positions.clear
# this loop is invoked as often as the number
# of different cards
number_of_pictures.times do |picture_id|
# for each invocation, two cards are added
# into the array
@positions << picture_id << picture_id
end
# shuffle the array at the end
@positions.shuffle!
end
end
class Game_System
p "Game_system"
# füge Memory als Attribut hinzu
attr_accessor :memory
end
# Erbebt von Scene_Base
class Scene_Memory < Scene_Base
p "Scene_Memory"
#class << self
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------
def initialize_graphics
p "initialize_graphics"
# for each card in the game
@card_sprites = $game_system.memory.get_cards.map do |x, y, image|
# create a new sprite
sprite = Sprite.new
# set its graphic and coordinates
sprite.bitmap = Cache.picture(image)
sprite.x, sprite.y = x, y
# and "return" the sprite into the array
sprite
end
end
def update_graphics
p "update_graphics"
# update attributes of all sprites
@card_sprites.each_with_index do |sprite, index|
x, y, image = $game_system.memory.get_card(index)
sprite.bitmap = Cache.picture(image)
sprite.x, sprite.y = x,y
end
end
def dispose_graphics
p "dispose_grapics"
@card_sprites.each do |sprite|
sprite.dispose
end
end
#-------------------------------------------------------------------------------
# überschreibt terminate Scene_Base
#-------------------------------------------------------------------------------
def terminate
p "terminate"
super
dispose_graphics
end
#-------------------------------------------------------------------------------
# überschreibt update Scene_Base
#-------------------------------------------------------------------------------
def update
p "update"
super
update_graphics
end
def start #(start)
p "start"
super
initialize_graphics
update
end
end
#end
Hey Elster,
du hast dir deine Methode "def get_card index" selbst zerschossen. Du arbeitest in deinen Methoden ohne ein explizites "return" - was vollkommen okay ist. Allerdings solltest du dies nicht machen, da du ja scheinbar noch anfänger bist (was das Skripten mit Ruby angeht) und - wie man hier merkt - dir ein Eigentor geschossen hast.
Wenn du kein Return-Statement verwendest, gibt eine Methode in Ruby das letzte Statement zurück. In deinem Fall gibt die Methode also nicht mehr das Array zurück, sondern "p card_image(index)".
Wenn du die 3 Ausgaben also haben möchtest, musst du die über dein Array schreiben, damit das Array zurückgegeben wird:
Code:def get_card index
p "get_card index"
p card_x(index)
p card_y(index)
p card_image(index)
[card_x(index), card_y(index), card_image(index)]
end
Edit:
Vielleicht erklärst du mal ganz genau, was du eigentlich vor hast. Irgendwie macht dein Code aktuell wenig Sinn. Was bezweckst du mit @positions eigentlich? Denn die Werte, die du in dem Array stehen hast, werden nie verwendet.
Es funktioniert tatsächlich ohne die Ausgaben.... yayi
Ich sehe Bilder <3
Mja was Ruby angeht bin ich echt ein absoluter Neuling...
Also was es einmal werden soll ist ein Memory. Wo man halt Paare von Karten finden soll. (soll dann noch auf sounds ausgeweitet werden, also zusätzlich ein Soundmemory.)
Das ist die Grundidee. Klar, dafür müssen vorher noch die Karten verdeckt sein/ werden.
Mein Gedankengang des Aufbaus war halt, dass man eben Koordinaten braucht um die Bilder zu plazieren, zudem IDs um die Paare ausfindig zu machen.
Das Skript stammt größtenteils von -KD- (danke noch einmal dafür :3) und darauf baue ich halt auf und wusel mich da halt durch.
In naher Zukunft folgt dann noch die Steuerung (Navigation über das Spielfeld) und Identifizierung der einzelnen Karten. Wie genau ich das mache weiß ich noch nicht.
Aber ich muss etwas zum "anklicken" haben, damit halt das Bild gezeigt wird oder ein Sound abgespielt wird, vielleicht geht es auch ohne Objekte auf der Map... hoffentlich.
Das Array benötige ich sicherlich später noch für die Steuerrung. Also dem Ansteuern eben jener Koordinaten um dann Dinge zu tun. [Bilder umdrehen, Sounds abspielen... oder was mir sonst so noch im Zusammenhang mit Anklicken einfällt]
Ich hoffe ich konnte mich hier halbwegs verständlich ausdrücken ^^" wenn ich mehr ins Detail gehen soll, kann ich das gerne tun.
Alles klar. Ist ja super, dass es nun bis hierhin schon einmal funktioniert.
Aktuell berechnest du die Koordinaten ja komplett über die Methoden card_x und card_y.
In Zugriffen über @postions verwendest du lediglich den Index des Arrays, aber nie die Werte. Und wenn du später noch Dinge im Script einbaust, wirst du sicherlich auch hier die Methoden card_x und card_y verwenden (können).
Aber super, dass du dir Anhand der hier im Forum gegebene Unterstützung selbst an den Skripten versuchst.
Kannst dein fertiges Skript ja mal irgendwann vorstellen - ansonsten bis zum nächsten Problem~