[VX-Ace] Script zeigt Bild nicht an

[Elster]

Ein wenig entwirren konnte ich bis jetzt das Ganze.... ok ein ganz klein wenig.
Ich hatte noch den alten Code wo stehen, so dass ich Klassen doppelt hatte, womit das Script versucht hat die Klasse Memory aus meinem alten Code zu starten.
Beeindruckender Weise hat das irgendwann funktioniert wodurch ich diesen Fehler erst realisiert habe o_o
Mittlerweile habe die Klasse auch unbenannt...

Nun nachdem ich diesen Fehler weg habe, hänge ich wieder.
Und zwar hänge ich am Methodenaufruf.

Beispiel:

Code:

A)
class Scene_Memory < Scene_Base
  def start
    super
    initialize_graphics
  end
end

B)
class Scene_Memory < Scene_Base
   def self.start
      super
      initialize_graphics
   end
end

Wenn ich nun in der Klasse Game_Memory, in der Methode initialize am Ende folgenden Befehl aufrufe "SceneManager.call(Scene_Memory.start)" wird ja aus der Klasse "Scene_Memory" die Methode "start" aufgerufen. Ja... und hier komme ich zu meinem Knackpunkt. Bei A) gilt die Methode als nicht initialisiert, bei B) kann ich kein super darauf anwenden, da nun start von Scene_Memory erbt. Dafür komme ich in die Methode rein, nützt mir nur nicht viel, da nun die Methode "get_cards" die in "initialize_graphics" aufgerufen wird, nicht initialisiert ist oder leer ist.

Ich habe in der Methode initialize schon mit verschiedensten Aufrufen versucht an die Methode start zu kommen. Unter anderem "SceneManager.call(Scene_Memory.start.new)" was auch geht... nur eben mit den selben Problemen. Auch ein einfacher Aufruf aller "start" oder "Scene_Memory.start" bringt mich in die selbe Lage.
Mein Versuch einfach "SceneManager.call(Scene_Memory)" aufzurufen ... lief darauf hinaus, dass er nicht in die Methode rein ging... habe auch nichts anderes erwartet.

Ich poste hier einfach noch mal Alles rein, großartige Änderungen zum Code von -KD- gibt es noch nicht, ich will erstmal das es so weit läuft. Klar... im Nachhinein andere Sachen einbauen ist nie die klügste Idee... aber wenn es nicht läuft ist es auch doof groß dran herumzuschrauben.

Bei dieser Variante des Codes handelt es sich um jene, wo er keine Daten in get_cards findet.

Code:

class Game_Memory
  # hier kommen alle Attribute rein die dein Spiel so hat
  @modus = 0
  @move = 50
  
  # 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.new)
    #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

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

# Erbebt von Scene_Base
class Scene_Memory < Scene_Base
  #class << self 
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------
  def self.start
    #super
    initialize_graphics
    update
  end
  
#-------------------------------------------------------------------------------
# überschreibt  terminate Scene_Base
#-------------------------------------------------------------------------------
  def terminate
    super
    dispose_graphics
  end
  
#-------------------------------------------------------------------------------
# überschreibt update Scene_Base
#-------------------------------------------------------------------------------
  def update
    super
    update_graphics
  end

#end
end
#end

Die Fehlermeldung lautet um genau zu sein:

Script 'Game_Interpreter' line 1144: NoMethodError occurred.
undefined method `get_cards' for nil:NilClass

...

Ergo wurde wohl wieder etwas noch nicht aufgerufen, wodurch ich noch nicht an die Daten komme.
Der Methode zufolge sollte es sich hierbei ja um get_card und den index davon handeln.
Jedoch kann das so wie es da ist, sowieso noch nicht stimmen, immerhin kann ich kein "super" ausführen.
Wie merkt meine Klasse, dass die Methode da ist, ohne das ich self.start schreiben muss?
Das würde dann hoffentlich auch die Folgeprobleme beheben...

[-KD-]

Code:

B)
class Scene_Memory < Scene_Base
   def self.start
      super
      initialize_graphics
   end
end

...

Wenn du self.xxx bei einer Methodendefinition schreibst, wird die Methode zur Klassenmethode (du kannst sie also über Klassenname.methodenname aufrufen). Klassenmethoden können ihrerseits keine Instanzmethoden aufrufen, sie beziehen sich nur auf die Klasse. Klassenmethoden braucht man eher selten. In deinem Fall brauchst du sie jedenfalls gar nicht. Also weg mit den self.

Code:

class Game_Memory
  # hier kommen alle Attribute rein die dein Spiel so hat
  @modus = 0
  @move = 50

...

Dieser Code macht was völlig anderes als du wahrscheinlich vermutest. Instanzvariablen, die du in den Klassenblock schreibst, werden zu Klassenvariablen (die du dann innerhalb einer Klassenmethode nutzen kannst). Das ist eigentlich NIE das was du willst. Daher gleich abgewöhnen! Instanzvariablen schreibst du in die Initialize-Methode rein.

Code:

p @positions
    SceneManager.call(Scene_Memory.start.new)
    #Scene_Memory.start
    #SceneManager.call(Scene_Memory.start)

...

Das hat nichts in der initialize Methode zu suchen. Wenn du deine Memory-Szene starten willst, mache das entweder über ein Event im Spiel (mit dem Call Script Befehl). Oder, wenn du willst das das Spiel direkt mit dem Memory-Spiel beginnt, du schreibst

Code:

module SceneManager
  # hier ist das self. ausnahmsweise mal erlaubt...
  def self.first_scene_class
    Scene_Memory
  end
end

Das Problem warum dein Code nicht funktioniert ist, dass die Methoden initialize_graphics, update_graphics und dispose_graphics nicht in der Scene_Memory Klasse stehen. Du hast sie einfach lose in den Scripteditor eingefügt.

[Elster]

Entschudige bitte -KD- das ich hier so lange geschwiegen habe ^^" Mein Rechner hat den Geist aufgegeben... teilweise -.-
Danke so weit für deine großartige Hilfe ^^

Ich hab mit hier noch mal das Meiste durchgelesen um mit meinem jetzigen Problem klar zu kommen.
Habe brav die Methoden in die Klasse ingepflegt und "start" ganz nach unten gepackt. Mir Videos zu Programmierung mit Ruby im Verbindung mit dem VX Ace angeschaut (speziell zu Verbung) und aaaaah ... ich glaube ich scheitere am Aufruf.

Code:

$game_system.memory = Game_Memory.new

Ist ja der Code mit dem ich über Event -> Script halt Game_Memory starte.

So und mit:

Code:

SceneManager.call(Scene_Memory)

sollte ich rein theoretisch doch Scene_Memory starten können oder?

Also im Prinziep sollte es insgesammt wie folgt aussehen.
In einem Event mit dem Script Befehl folgendes ausführen:

Code:

$game_system.memory = Game_Memory.new
SceneManager.call(Scene_Memory)

Joar... Game_Memory wird dann auch einmal gestartet... was dann passiert verwundert mich jedoch etwas.
Folgende Fehlermeldung taucht dann auf:

Script 'Game_Interpreter' line 1411: NoMethodError occurred.
undefined method `memory='for nil:NilClass

...

Was natürlich auch noch sein kann ist, dass er meint in der Klasse stünde nichts drin.
Bedeutet ich müsste vermutlich am Ende der Klasse "start" aufrufen.
Also wie folgt:

Code:

b = Scene_Memory.new
b.start

Wobei er sich dann über folgenden Codeteil beschwert.

Code:

 @card_sprites = $game_system.memory.get_cards.map do |x, y, image|

Da kommt dann folgende Fehlermeldung.

Code:

Script 'Memory_3' line 118: NoMethodError occurred.
undefined method `memory' for nil:NilClass

memory scheint aus der Klasse Game_System zu kommen.

Code:

class Game_System
  # füge Memory als Attribut hinzu
  attr_accessor :memory
end

muss ich das auch noch irgendwie starten und wenn ja wo?

[Kelven]

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?

[Elster]

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.

Yanfly Engine:
- Ace Message System
- Ace Menu Engine

Lone Wolf:
- Gamepad Extender

MOG
- MOG_Animated_Title_A

Khas Arcthunder:
- Pathfinding

...

Und dann halt noch eigene Scripte. Aber da bin ich mir recht sicher, dass da kein "Memory" oder "memory" drin vorhanden ist.
Bei den anderen auch... Suchfunktion und so.

[Kelven]

Kannst du vielleicht doch mal deine eigenen Scripte posten, also Game_Memory und Scene_Memory?

[Elster]

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

#-------------------------------------------------------------------------------

Code:

#b = Scene_Memory.new
#b.start

Das ist momentan auskommentiert damit das Spiel startet und ich an anderen Sachen werkeln kann.

[Kelven]

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.

[Elster]

Ja, das geht... aber jetzt wird mein Stack zu groß XD
Wie kann ich das abfangen, dass mir nicht der Speicher ausgeht?

[Kelven]

Rufst du Scene_Manager.call(Scene_Memory) vielleicht mehrmals auf? Das muss du eigentlich nur einmal machen.

[Elster]

So weit ich es beurteilen kann nur einmal.
Halt in einem Event mit "Parallel Prozess" ein Skriptbefehl mit den beiden Befehlen:

Code:

$game_system.memory = Game_Memory.new
Scene_Manager.call(Scene_Memory)

und da drauner wird ein Selfswitch aktiviert. Dann eben eine Seite 2 die durch den Self-Switch aktiviert wird.
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.

[Cepanks]

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.

[-KD-]

Ja, das geht... aber jetzt wird mein Stack zu groß XD
Wie kann ich das abfangen, dass mir nicht der Speicher ausgeht?

...

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.

Am besten du zeigst nochmal deinen Code so wie er jetzt aussieht.

[Elster]

Gut ja, dann liegt eindeutig hier der Fehler... gleich der letzte Befehl der Methode.

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

Habe ich wohl etwas mal wieder falsch verstanden...

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

[Kelven]

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:

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

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

    @memory = Game_Memory.new
  end