[VX-Ace] Script zeigt Bild nicht an

**Elster** · 25.06.2015, 13:59

Und da melde ich mich wieder ^^

Es sind ein paar neue Probleme aufgetaucht.
Das erste und größste Problem, ich weiß nicht wie ich gescheit meine beiden Klassen "Memory_Picture_Changer" und "Memory_Game_Navigate" starten soll.
Dadurch weiß ich natürlich auch noch nicht, ob das was ich mir gedacht habe so überhaupt funktioniert....

Auch habe ich noch eine Frage, kann man eigentlich ein Bild hier noch über die anderen Bilder legen?
Damit man z.B. einen Rahmen immer über eine Karte legen kann, oder einen Mauszeiger um zu sehen wo man eigentlich ist.

Wenn schon jemand Lust hat sich das "Grauen" anzuschauen, bitte schön XD

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
    
    #Deckkarten
    @figure_wrapper = [
    "Grundkarte.png", "Grundkarte.png", #1
    "Grundkarte.png", "Grundkarte.png", #2
    "Grundkarte.png", "Grundkarte.png", #3
    "Grundkarte.png", "Grundkarte.png", #4
    "Grundkarte.png", "Grundkarte.png", #5
    "Grundkarte.png", "Grundkarte.png", #6
    "Grundkarte.png", "Grundkarte.png", #7
    "Grundkarte.png", "Grundkarte.png", #8
    ]
    
    #Bilderkarten
    @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", 
    ].shuffle
    
    #Sounds für die Tonvariante
    @sound_names = [
    "Up1", "Up1",           #1
    "Thunder3", "Thunder3", #2
    "Sword4", "Sword4",     #3
    "Switch2", "Switch2",   #4
    "Stare", "Stare",       #5
    "Shop", "Shop",         #6
    "Saint9", "Saint9",     #7
    "Miss", "Miss"          #8
    ].shuffle
    
    @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 = 136
    @card_height = 104
    # distance between cards
    @margin = 0
    # number of possible moves
    @move = 32
    # number of right pairs found. Win at 8
    # change in def change_card for your game
    @win = 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
    [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[index]
    @figure_wrapper [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
  # füge Memory als Attribut hinzu
  attr_accessor :memory
end


# Erbebt von Scene_Base
class Scene_Memory < 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
  
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------  
  def start #(start)
    super 
    initialize_graphics
    update
  end

end

#-------------------------------------------------------------------------------
# Hier findet das Verändern der Deckbilder statt.
# Ich sollte nach gleichen Namen schauen und wenn diese gleich sind, wird das
# Deckblatt entgültig entfernt.
#-------------------------------------------------------------------------------

class Memory_Picture_Changer
  
  def initialize
    @pic_ID1 = -1
    @pic_ID2 = -2
    p "wupi"
  end
  
  
  #Ändert die angezeigten Bilder.
  # TODO Tonvariante einpflegen
  def change_card
    
    #zeigt die erste umgedeckte Karte an.
    if @pic_ID1 != -1
      a = @figure_names.select[@pic_ID1]
      #ersetzen des Bildes an Stelle @pic_ID1 durch a
      @figure_wrapper.map! {|x| x == @pic_ID1 ? a : x}.flatter
      update_graphics()
    end
    
    #zeigt die zweite umgedeckte Karte an.
    if @pic_ID2 != -2
      b = @figure_names.select[@pic_ID2]
      @figure_wrapper.map! {|y| y == @pic_ID1 ? b : y}.flatter
      update_graphics()
    end
    
    if (@pic_ID1 != -1 && @pic_ID2 != -2)
      #Wenn die Karten gleich sind!
      if @pic1 == @pic2
        Audio.se_play("Chime2", 80, 100) 
        @pic_ID1 = -1
        @pic_ID2 = -2
        @win +1
      #Wenn die Karten ungleich sind!
      else #(@pic1 != @pic2)
        Audio.se_play("Buzzer2", 80, 100)
        pic = "Grundkarte.png"
        @figure_wrapper.map! {|x| x == @pic_ID1 ? pic : x}.flatter 
        @figure_wrapper.map! {|y| y == @pic_ID2 ? pic : y}.flatter 
        @pic_ID1 = -1
        @pic_ID2 = -2
        update_graphics()
      end
    end
  end
end



# Hier findet die Navigation statt.
class Memory_Game_Navigate
  def navigate
    @x_nav = 0
    @y_nav = 0
    @id = 0
    
    if Input.trigger?(:DOWN)
      if @y_nav == 312
        #Hier wird der Ton für den 2. Modus abgespielt.
        if $game_switches[2] == true
          Audio.se_play("Earth6", 80, 100) 
        end
        #Wert wird nicht vergrößert.
      elsif
        @y_nav = @y_nax + 104
        @id = @id + 4
      end
    end
    
    if Input.trigger?(:LEFT)
      if @x_nav == 0
        if $game_switches[2] == true
          Audio.se_play("Earth6", 80, 100) 
        end
        #Wert wird nich verkleinert.
      elsif
        @x_nav = @x_nav - 136
        @id = @id - 1
      end
    end
    
    if Input.trigger?(:UP)
      if @y_nav == 0
        #Hier wird der Ton für den 2. Modus abgespielt.
        if $game_switches[2] == true
          Audio.se_play("Earth6", 80, 100) 
        end
        #Wert wird nicht verkleinert.
      elsif
        @y_nav = @y_nax - 104
        @id = @id - 4
      end
    end
    
    if Input.trigger?(:RIGHT)
      if @x_nav == 408
        if $game_switches[2] == true
          Audio.se_play("Earth6", 80, 100) 
        end
        #Wert wird nich vergrößert.
      elsif
        @x_nav = @x_nav + 136
        @id = @id + 1
      end
    end
    
    if Input.trigger?(:C)
      a = @figure_names.select[@id]
      if a == "Grundkarte"
        if @pic_ID1 == -1
          @pic_ID1 = @id
          $game_variables[10] = $game_variables[10] + 1
          change_card()
        elsif @pic_ID == -2
          @pic_ID2 = @id
          $game_variables[10] = $game_variables[10] + 1
          change_card()
        end
      else
        #Falls der Spieler blind ist, wird hier ein Signal abgespielt
        #sonst wird in beiden Fällen die Variable für die Züge
        #hochgezählt.
        if $game_switches[2] == true
          Audio.se_play("Buzzer1", 80, 100) 
        end
        $game_variables[10] = $game_variables[10] + 1
      end
      
    end
  end
  
end

**Linkey** · 25.06.2015, 15:03

Habe gerade nicht viel Zeit, daher antworte ich erst einmal nur auf die Teilfrage:

Zitat von Elster

Auch habe ich noch eine Frage, kann man eigentlich ein Bild hier noch über die anderen Bilder legen?
Damit man z.B. einen Rahmen immer über eine Karte legen kann, oder einen Mauszeiger um zu sehen wo man eigentlich ist.

Das geht ganz einfach. Wenn dein Cursor z.B. ein Sprite/Window/Viewport ist, kannst du diesem einen höhreren "z"-Wert zuordnen und schon ist dieser über deinen anderen Bildern.
Wenn ich später zu Hause bin kann ich dir anhand deines Codes auch gerne ein Beispiel generieren.

**Linkey** · 25.06.2015, 21:45

So, sorry für den Doppelpost. Ich habe mir dein Script gerade einmal angeschaut. Erst einmal als Anmerkung, du hast in der Navigate Klasse noch Schreibfehler. Schau mal in die Left/Right/Up/Down Methoden - dort steht teilweise @y_nax anstelle von @y_nav

Was deine Navigierungsklasse angeht, soll diese ja scheinbar für die Bewegungen zuständig sein. Ich würde dir empfehlen, hier eine init Methode anzulegen, in der du deinen Cursor-Sprite definierst (wenn du es ganz hart trenenn willst, kannst du den Cursor-Sprite natürlich auch in der Scene-Klasse mit anlegen und dir nur die x/y Werte über die Navigate-Klasse holen). Auf jeden Fall solltest du die x/y-Werte in der Init Methode initialisieren und nicht in "navigate". Denn sonst schreibst du die Werte immer auf 0. In den einzelnen Tastenabfragen rufst du dann zum Schluss eine Methode auf, die die Cursor Postion = x/y_nav setzt (siehe blaue Markierung).
Außerdem kannst du aus deinen Methoden die "Fehlerbehandlung" in eine eigene Methode auslagern (siehe grüne Markierungen).

Zu den roten Markierungen schreib ich dir weiter unten noch etwas.

Die Navigate-Klasse wäre dann bspw. so angepasst:

Code:

class Memory_Game_Navigate
  def initialize
    @cursor = Sprite.new
    @cursor.z = 500 #Kommentar: Die meisten Sprites liegen im Z-Wert zwischen 0 und 300. Mit 500 solltest du auf jeden Fall auf der obersten Ebene sein, wodurch dein Cursor über allem steht.
    @cursor.bitmap = Cache.picture("XXXXXXXXXXX.PNG")
    @x_nav = 0
    @y_nav = 0
    @id = 0
  end
  
  def navigate    
    if Input.trigger?(:DOWN)
      if @y_nav == 312
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error
        #Wert wird nicht vergrößert.
      elsif
        @y_nav = @y_nav + 104
        @id = @id + 4
        move_cursor
      end
    end
    
    if Input.trigger?(:LEFT)
      if @x_nav == 0
        move_error
        #Wert wird nich verkleinert.
      elsif
        @x_nav = @x_nav - 136
        @id = @id - 1
        move_cursor
      end
    end
    
    if Input.trigger?(:UP)
      if @y_nav == 0
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error
        #Wert wird nicht verkleinert.
      elsif
        @y_nav = @y_nav - 104
        @id = @id - 4
        move_cursor
      end
    end
    
    if Input.trigger?(:RIGHT)
      if @x_nav == 408
        move_error
        #Wert wird nich vergrößert.
      elsif
        @x_nav = @x_nav + 136
        @id = @id + 1
        move_cursor
      end
    end
    
    if Input.trigger?(:C)
      a = @figure_names.select[@id]
      if a == "Grundkarte"
        if @pic_ID1 == -1
          @pic_ID1 = @id
          $game_variables[10] = $game_variables[10] + 1
          change_card()
        elsif @pic_ID == -2
          @pic_ID2 = @id
          $game_variables[10] = $game_variables[10] + 1
          change_card()
        end
      else
        #Falls der Spieler blind ist, wird hier ein Signal abgespielt
        #sonst wird in beiden Fällen die Variable für die Züge
        #hochgezählt.
        if $game_switches[2] == true
          Audio.se_play("Buzzer1", 80, 100) 
        end
        $game_variables[10] = $game_variables[10] + 1
      end
      
    end
    
  end
  
  def move_cursor
    @cursor.x = @x_nav
    @cursor.y = @y_nav
  end
  
  def move_error
    if $game_switches[2] == true
      Audio.se_play("Earth6", 80, 100) 
    end
  end
end

Die Klasse Memory_Game_Navigate muss dann als Objekt in deiner Scene erstellt werden (bspw. so in der init-Methode):

Code:

class Scene_Memory < 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
    @navi = Memory_Game_Navigate.new
  end

Damit die Methode navigate der Klasse Memory_Game_Navigate auch ständig durchlaufen (und somit abgefragt wird), solltest du diese in der Update-Methode deiner Scene verwenden:

Code:

#-------------------------------------------------------------------------------
# überschreibt update Scene_Base
#-------------------------------------------------------------------------------
  def update
    super
    update_graphics
    @navi.navigate
  end

Bezüglich der roten Markierung weiter oben:
Du versuchst viele Klassen zu verwenden - toll. Allerdings muss dir bewusst sein, dass du nicht Klassen übergreifend irgendwelche Attribute/Methoden einfach so zur Verfügung gestellt hast. Du versuchst in deiner navigate-Methode der Navigations-Klasse z.B. auf die "change_card()"-Methode zuzugreifen. Diese ist der Klasse aber nicht bekannt. Du müsstest dann schon ein Objekt der "Change" Klasse erzeugen (@pic_changer = Memory_Picture_Changer.new), und dann über das Objekt auf die Methoden zugreifen (@pic_changer.change_card()).
Da du allerdings in der Memory_Picture_Changer Klasse auch wiederum Objekte der Memory-Klasse verwendest, die allerdings nur der Memory-Klasse bei dir bekannt sind, würde das auch nicht laufen. Du müsstest dann auf den "figure_wrapper" per $game_system.memory.figure_wrapper zugreifen und diesen vorher auch noch als attribute accessor in deiner Memory-Klasse definieren.

**Elster** · 28.06.2015, 15:03

YAYI Danke ^^
Der Mauszeiger funktioniert wunderbar

Nur habe ich jetzt ein weiteres Problem.
Die Arrays liegen in einer privaten Methode... wie komme ich denn jetzt da an die Bilder?^^"
Habs ja erst versucht indem ich dafür auch ein neues Objekt der Klasse angelegt habe und dann auf die Methode zugreife... aber ist halt unzulässig.

**Linkey** · 28.06.2015, 15:17

Zeig mal, was du versucht hast.
Deine Arrays liegen ja eigentlich nicht in einer privaten Methode, sondern als Instanz-Variablen deiner Klasse vor. Du kannst...
... der Klasse eine Methode hinzufügen, welche die Arrays ausgibt (lesender Zugriff) oder eine Methode mit Parameter hinzufügen, welche das Array dann verändert (schreibender Zugriff). In dem Fall könntest du dann per $game_system.memory.METHODEN_NAME(PARAMETER) auf die Methode zugreifen.
... die Arrays als Attribut-Reader (falls nur lesender Zugriff benötigt wird) oder Attribut-Accessor (falls auch schreiben drauf zugegriffen werden muss) deklarieren. In dem Falle könntest du dann per $game_system.memory.ARRAY_NAME auf das Objekt zugreifen.

**Elster** · 28.06.2015, 16:17

Also ich habe es jetzt mal wie folgt versucht:

Folgende Methode habe ich unter der Klasse "Game_Memory" und unter der Methode "initialize"
Ich hoffe mal... dass das so funktioniert. (anscheinend nicht... wie du unten sehen wirst bei der Fehlermeldung)

Code:

  def get_arrays
    @wrapper = @figure_wrapper
    @names = @figure_names
    @sounds = @sound_names
  end

So... hier hakt es dann halt.
Wo es rot makiert ist.

Code:

def navigate
    @pic_changer = Memory_Picture_Changer.new
    @get_id = Game_Memory.new
    @h = $game_system.memory.get_arrays(@wrapper)
    #@h = $game_system.memory.initialize(@figure_wrapper)
    
    if Input.trigger?(:DOWN)
      if @y_nav == 312
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht vergrößert.
      elsif
        @y_nav = @y_nav + 104
        @id = @id + 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:LEFT)
      if @x_nav == 0
        move_error()
        #Wert wird nich verkleinert.
      elsif
        @x_nav = @x_nav - 136
        @id = @id - 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:UP)
      if @y_nav == 0
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht verkleinert.
      elsif
        @y_nav = @y_nav - 104
        @id = @id - 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:RIGHT)
      if @x_nav == 408
        move_error()
        #Wert wird nich vergrößert.
      elsif
        @x_nav = @x_nav + 136
        @id = @id + 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:C)
      a = @figure_names.select[@id] 
      if a == "Grundkarte"
        if @pic_ID1 == -1
          @pic_ID1 = @id
          $game_variables[10] = $game_variables[10] + 1
          @pic_changer.change_card()
          #change_card()
        elsif @pic_ID == -2
          @pic_ID2 = @id
          $game_variables[10] = $game_variables[10] + 1
          @pic_changer.change_card()
          #change_card()
        end
      else
        #Falls der Spieler blind ist, wird hier ein Signal abgespielt
        #sonst wird in beiden Fällen die Variable für die Züge
        #hochgezählt.
        if $game_switches[2] == true
          Audio.se_play("Buzzer1", 80, 100) 
        end
        $game_variables[10] = $game_variables[10] + 1
      end
      
    end
    
  end

Zitat

Script 'Memory_3' line 353: ArgumentError occurred.
wrong number of arguments (1 for 0)

Vermutlich habe ich nicht wirklich verstanden was du mir eben geschrieben hast ._.

**Cepanks** · 28.06.2015, 17:49

Scheint, als hättest du die Teile aus Linkeys Antwort irgendwie zusammengemixt.

Vergleiche mal, wie du die Methode geschrieben hast, und wie du sie aufrufen willst. Es wird versucht @wrapper als Parameter zu übergeben, die Methode akzeptiert aber gar keine Parameter. Du willst an dieser Stelle aber nichts überschreiben (was denn auch?) oder sonst was tun, wofür ein Wert aus nötig wäre. Also weg damit.

Code:

@h = $game_system.memory.get_arrays

Nächste Baustelle:

Code:

def get_arrays
  @wrapper = @figure_wrapper
  @names = @figure_names
  @sounds = @sound_names
end

Was passiert hier? So wie du es geschrieben hast, besitzt jetzt jetzt Game_Memory die Instanzvariablen @wrapper, @names, @sound, @figure_wrapper, @figure_names, @sound_names. Macht keinen Sinn, oder? Du willst die Sachen ja von außerhalb nutzen, jetzt haben wir hingegen die Arrays in doppelter Ausführung in Game_Memory.

Weil Ruby aber immer den letzten Wert aus einer Methode zurück gibt, hat es tatsächlich auch was in deine @h-Variable geschafft. Die würde jetzt das Array mit den Sound-Namen enthalten, allerdings auch nur dieses eine Array.

Wenn du alle drei haben willst, kannst du die Methode so umschreiben, dass sie ein "Array mit Arrays" liefert.

Code:

def get_arrays
  # Das "return" ist wie gesagt optional
  return [@figure_wrapper, @figure_names, @sound_names]
end

Dann die andere Variante, die Linkey vorgschlagen hat. Wenn du dir schon mal die anderen Klassen im Maker angesehen hast, bist du da bestimmt schon darüber gestolpert. Damit kannst du den Zugriff auf Instanzvariablen nach außen hin erlauben, ohne explizit Methoden dafür zu schreiben.

Entweder nur lesbar: attr_reader :figure_wrapper, :figure_names, :sound_names

nur schreibbar: attr_writer :figure_wrapper, :figure_names, :sound_names (macht in deinem Fall gerade keinen Sinn)

Oder les- und schreibbar: attr_accessor :figure_wrapper, :figure_names, :sound_names

Schau mal in Game_Memory in die 4. Zeile, auf @figure_names ist sogar schon zugreifbar.

Das Endergebnis sollte also so aussehen.

Code:

### Variante mit der geänderten get_array-Methode
def navigate
  # Sieht auf den ersten Blick seltsam aus, aber wir ziehen hier die drei Werte aus dem zurückggebenen Array direkt in drei Instanzvariablen
  @figure_wrapper, @figure_names, @sound_names = $game_system.memory.get_arrays
end


### Variante mit attr_reader oder attr_accessor
def navigate
  @figure_wrapper = $game_system.memory.figure_wrapper
  @figure_names = $game_system.memory.figure_names
  @sound_names = $game_system.memory.sound_names
end

**Linkey** · 28.06.2015, 17:51

Ja, so kann es nicht funktionieren.
Du rufst die Methode "get_arrays" von $game_system.memory auf (eine Instanz von Game_Memory), was erst einmal okay ist.

Wenn du dir die Methode "get_array" aber einmal anschaust, so hat diese keine Parameter. Du versucht den Aufruf aber mit einer Parameterübergabe (@wrapper) durchzuführen. Dies kann nicht funktionieren, da "get_array" kein Parameter vorsieht. Daher der Fehler "wrong number of arguments" - welcher aussagt, dass du zuviele oder zuwenige Parameter übergeben hast.
Deine Methode würde aber auch nicht das geben, was du willst. Deine Methode hat kein "return"-Statement. Deshalb würde der letzte Wert zurückgegeben werden. D.h. in deinem Fall, dass dein @h das Ergebnis von "
@sounds = @sound_names" zugewiesen bekommt. Du könntest die Methode wiefolgt schreiben:

Code:

def get_arrays
return @figure_wrapper, @figure_names, @sound_names
end

In deine andere Methode, die diese Werte erhalten soll, schreibst du dann anstelle von "@h = ..." (namen der variablen sind nur beispiele:

Code:

f_wrapper, f_names, s_names = $game_system.memory.get_arrays()

Edit:
Ach, 1-2 Minuten zu langsam. Hätte ich mal nicht gegessen

Edit 2:
Da hat Gepanks dir das noch einmal ausführlich erklärt. Nur der Vollständigkeit wegen:
Wie Gepanks schon sagt, kannst du das return statement weglassen (warum du es nicht machen solltest, habe ich ja bereits erwähnt und anhand deiner Fehler hast du ja auch gemerkt, was durch dieses Weglassen alles schiefgehen kann

). Du könntest die Klammern beim Return auch weglassen, Ruby gibt die Werte automatisch als Array zurück, wenn diese durch Komma getrennt angegeben sind.
Solltest du die Werte auch nur in der Methode "navigate" benötigen, brauchst du auch nicht unbedingt Instanzvariablen (bspw.: @figure_names = $game_system.memory.figure_names), sondern kannst einfache temporäre Variablen nehmen (bspw.: figure_names = $game_system.memory.figure_names).

Wie gesagt, es empfiehlt sich, gerade am Anfang, das Coding so zu schreiben, dass du auch nicht den Überblick verlierst. Daher solltest du den Code nur dort vereinfach schreiben, wo du dir auch sicher bist, was du da machst

**Elster** · 29.06.2015, 21:00

Arg... langsam bekomme ich Kopfschmerzen.

Ich versuche gerade mein Konstrukt im Kopf zu entwirren...
Also jetzt wo ich da alles so schön bei sammen habe, rufe ich ja die Klasse "Memory_Picture_Changer" auf, um dort eben die Bilder zu aktualisieren. Leider habe ich dort weder die Namen noch die IDs zur Verfügung welche ich mitlerweile in der Klasse "Memory_Game_Navigate" relativ einfach herraussuchen kann. Wäre es nicht an und für sich logischer das in einem Rutsch zu erledigen, oder ist es besser das in verschiedenen Klassen zu lassen?
So wie ich es nun gedacht habe, also mit getrennten Klassen, stolpere ich wiedermal darüber, dass ich an Werte von Variablen rankommen muss (@pic_ID1 und @pic_ID2). Um dann die Werte der beiden Variablen wieder auf -1 und -2 zu setzen wenn ich kein Paar gefunden habe und sie an "Memory_Game_Navigate" senden muss. (für mich als Anfänger klingt das nach viel böser Arbeit...)
Hinzukommt... das ich eh "update_graphics()" aufrufe um mein Array zu aktualisieren, wobei ich mich da auch gerade frage... arbeite ich da überhaupt auf dem "richtigen" Array? So wie ich das bis jetzt verstanden habe, würde das Array der Methode nicht die Bohne verstehen was ich eigentlich von ihm will und einfach das ausgeben, was es eh schon die ganze Zeit über hatte, unverändert versteht sich.

Ich hab ja auch mit dem Gedanken gespielt einfach "Memory_Picture_Changer" von "Memory_Game_Navigate" erben zu lassen, dann sollte ich ja an die aktuellen Werte rankommen.... dachte ich. Hilft mir leider auch nicht dabei weiter, wie ich "Memory_Game_Navigate" sage, dass die beiden Variablen nun wieder ihre Ursprungswerte haben.

Kann jemand meinen armen Kopf entwirren?

Momentan sieht das Ganze wie folgt aus:
(Klar, das wirft noch Fehler wenn man was anklickt, weil Variablen in der Klasse "Memory_Picture_Changer" fehlen.)

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
    
    #Deckkarten
    @figure_wrapper = [
    "Grundkarte.png", "Grundkarte.png", #1
    "Grundkarte.png", "Grundkarte.png", #2
    "Grundkarte.png", "Grundkarte.png", #3
    "Grundkarte.png", "Grundkarte.png", #4
    "Grundkarte.png", "Grundkarte.png", #5
    "Grundkarte.png", "Grundkarte.png", #6
    "Grundkarte.png", "Grundkarte.png", #7
    "Grundkarte.png", "Grundkarte.png", #8
    ]
    
    #Bilderkarten
    @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", 
    ].shuffle
    
    #Sounds für die Tonvariante
    @sound_names = [
    "Up1", "Up1",           #1
    "Thunder3", "Thunder3", #2
    "Sword4", "Sword4",     #3
    "Switch2", "Switch2",   #4
    "Stare", "Stare",       #5
    "Shop", "Shop",         #6
    "Saint9", "Saint9",     #7
    "Miss", "Miss"          #8
    ].shuffle
    
    @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 = 136
    @card_height = 104
    # distance between cards
    @margin = 0
    # number of possible moves
    @move = 32
    # number of right pairs found. Win at 8
    # change in def change_card for your game
    @win = 0
    #p @figure_names
    #p @positions

  end
  
  def get_arrays
      return @figure_wrapper, @figure_names, @sound_names
  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[index]
    @figure_wrapper [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
  # füge Memory als Attribut hinzu
  attr_accessor :memory
end


# Erbebt von Scene_Base
class Scene_Memory < 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
  @navi = Memory_Game_Navigate.new
  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
    @navi.navigate
  end
  
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------  
  def start #(start)
    super 
    initialize_graphics
    update
  end

end

#-------------------------------------------------------------------------------
# Hier findet das Verändern der Deckbilder statt.
# Ich sollte nach gleichen Namen schauen und wenn diese gleich sind, wird das
# Deckblatt entgültig entfernt.
#-------------------------------------------------------------------------------

class Memory_Picture_Changer
  
  #def initialize
    #@navigater = Memory_Game_Navigate.new
    #@pic_ID1 = -1
    #@pic_ID2 = -2
  #end
  
  
  #Ändert die angezeigten Bilder.
  # TODO Tonvariante einpflegen
  def change_card
    #@navigater = Memory_Game_Navigate.new
    #f_wrapper, f_names, s_names = $game_system.memory.get_arrays()
    
    #zeigt die erste umgedeckte Karte an.
    if @pic_ID1 != -1
      @c = f_names[@pic_ID1]
      #@figure_wrapper.map! {|x| x == @pic_ID1 ? a : x}.flatter
      @f_wrapper.map! {|x| x == @pic_ID1 ? @c : x}.flatter
      update_graphics()
    end
    
    #zeigt die zweite umgedeckte Karte an.
    if @pic_ID2 != -2
      @d = f_names[@pic_ID2]
      @f_wrapper.map! {|x| x == @pic_ID1 ? @d : x}.flatter
      #@figure_wrapper.map! {|y| y == @pic_ID1 ? b : y}.flatter
      update_graphics()
    end
    
    if (@pic_ID1 != -1 && @pic_ID2 != -2)
      #Wenn die Karten gleich sind!
      if @pic1 == @pic2
        Audio.se_play("Chime2", 80, 100) 
        @pic_ID1 = -1
        @pic_ID2 = -2
        @win +1
      #Wenn die Karten ungleich sind!
      else #(@pic1 != @pic2)
        Audio.se_play("Buzzer2", 80, 100)
        pic = "Grundkarte.png"
        @f_wrapper.map! {|x| x == @pic_ID1 ? pic : x}.flatter
        @f_wrapper.map! {|y| y == @pic_ID2 ? pic : x}.flatter
        #@figure_wrapper.map! {|x| x == @pic_ID1 ? pic : x}.flatter 
        #@figure_wrapper.map! {|y| y == @pic_ID2 ? pic : y}.flatter 
        @pic_ID1 = -1
        @pic_ID2 = -2
        update_graphics()
      end
    end
  end
  
    
end



# Hier findet die Navigation statt.
class Memory_Game_Navigate
  
  def initialize
    @cursor = Sprite.new
    #Kommentar: Die meisten Sprites liegen im Z-Wert zwischen 0 und 300. 
    #Mit 500 solltest du auf jeden Fall auf der obersten Ebene sein, wodurch 
    #dein Cursor über allem steht.
    @cursor.z = 500 
    @cursor.bitmap = Cache.picture("Zeiger.PNG")
    @x_nav = 0
    @y_nav = 0
    @id = 0
    @pic_ID1 = -1
    @pic_ID2 = -2
    @win = 0
  end
  
  
  def navigate
    @pic_changer = Memory_Picture_Changer.new
    @get_id = Game_Memory.new
    # f_wrapper enthält die Deckblätter
    # f_names enthält die Bilder
    # s_names enthält die Sounds
    f_wrapper, f_names, s_names = $game_system.memory.get_arrays()
    #p f_names
    #@h = $game_system.memory.initialize(@figure_wrapper)
    
    if Input.trigger?(:DOWN)
      if @y_nav == 312
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht vergrößert.
      elsif
        @y_nav = @y_nav + 104
        @id = @id + 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:LEFT)
      if @x_nav == 0
        move_error()
        #Wert wird nich verkleinert.
      elsif
        @x_nav = @x_nav - 136
        @id = @id - 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:UP)
      if @y_nav == 0
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht verkleinert.
      elsif
        @y_nav = @y_nav - 104
        @id = @id - 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:RIGHT)
      if @x_nav == 408
        move_error()
        #Wert wird nich vergrößert.
      elsif
        @x_nav = @x_nav + 136
        @id = @id + 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:C)
      a = f_names[@id]
      b = f_wrapper[@id]
      #a = @figure_names.select[@id] 
      if b == "Grundkarte.png"
        if @pic_ID1 == -1
          $game_variables[10] = $game_variables[10] + 1
          @pic_ID1 = @id
          @pic_changer.change_card()
          #change_card()
        elsif @pic_ID2 == -2
          $game_variables[10] = $game_variables[10] + 1
          @pic_ID2 = @id
          @pic_changer.change_card()
          #change_card()
        end
      else
        #Falls der Spieler blind ist, wird hier ein Signal abgespielt
        #sonst wird in beiden Fällen die Variable für die Züge
        #hochgezählt.
        if $game_switches[2] == true
          Audio.se_play("Buzzer1", 80, 100) 
        end
        $game_variables[10] = $game_variables[10] + 1
      end
      
    end
    
  end
  
  #Hier findet die Bewegung des Mauszeigers statt.
  def move_cursor
    @cursor.x = @x_nav
    @cursor.y = @y_nav
  end
  
  #hier wird der Ton abegespielt wenn sich der Spieler nicht mehr bewegen kann.
  def move_error
    if $game_switches[2] == true
      Audio.se_play("Earth6", 80, 100) 
    end
  end
  
end

**Linkey** · 29.06.2015, 21:20

Bin gerade nicht so fit, deshalb habe ich deinen Text nur kurz überflogen. Ich hoffe, ich habe es richtig gelesen.
Die @pic-Variablen setzt du zwar in der Navigate Klasse, brauchst die dort aber praktisch gar nicht, wenn ich das richtig überflogen habe.
Wie wäre es, wenn du die ID einfach übergibst? Du könntest deine "change_card"-Methode anpassen:

Code:

 def change_card(pID1,pID2)
    #@navigater = Memory_Game_Navigate.new
    #f_wrapper, f_names, s_names = $game_system.memory.get_arrays()
    
    #zeigt die erste umgedeckte Karte an.
    if pID1 != -1
      @c = f_names[pID1]
      #@figure_wrapper.map! {|x| x == pID1 ? a : x}.flatter
      @f_wrapper.map! {|x| x == pID1 ? @c : x}.flatter
      update_graphics()
    end
    
    #zeigt die zweite umgedeckte Karte an.
    if pID2 != -2
      @d = f_names[pID2]
      @f_wrapper.map! {|x| x == pID1 ? @d : x}.flatter
      #@figure_wrapper.map! {|y| y == pID1 ? b : y}.flatter
      update_graphics()
    end
    
    if (pID1 != -1 && pID2 != -2)
      #Wenn die Karten gleich sind!
      if pID1 == pID2
        Audio.se_play("Chime2", 80, 100) 
        pID1 = -1
        pID2 = -2
        @win +1
      #Wenn die Karten ungleich sind!
      else #(pID1 != pID2)
        Audio.se_play("Buzzer2", 80, 100)
        pic = "Grundkarte.png"
        @f_wrapper.map! {|x| x == pID1 ? pic : x}.flatter
        @f_wrapper.map! {|y| y == pID2 ? pic : x}.flatter
        #@figure_wrapper.map! {|x| x == @pic_ID1 ? pic : x}.flatter 
        #@figure_wrapper.map! {|y| y == @pic_ID2 ? pic : y}.flatter 
        pID1 = -1
        pID2 = -2
        update_graphics()

      end
    end
    return pID1,pID2
  end

Die Methode rufst du dann in deiner Navigate-Klasse so auf:

Code:

@pic_ID1,@pic_ID2 = @pic_changer.change_card(@pic_ID1,@pic_ID2)

Edit:
Bezüglich der Klassen:
Du kannst tatsächlich auf weniger Klassen zugreifen. Generell ist es ein guter Gedanke, Dinge in einzelne Klassen zu packen. Der Maker macht es ja auch so:
Für einzelne Ausgaben gibt es Window_Klassen. Für die Steuerung über diese Menüs dann die Scene_Klassen.

Wenn du allerdings an einen Punkt kommst, an dem du nicht mehr weiter kommst, du permanent Werte hin- und herschieben musst und jegliche Übersicht verlierst, solltest du vielleicht ein bisschen weniger auslagern.

**Elster** · 30.06.2015, 10:26

Hm ne, ich denke nicht dass das so geht.
Ich habe dann ja am Anfang der Methode (pID1 und pID2) in denen "nil" drin steht, wodurch das Programm abschmieren wird. (Habe es auch ausprobiert, dass Programm schmiert ab)

Zudem hast du recht, ich brauche in meiner "Memory_Game_Navigate" Klasse die pic_ID1 und pic_ID2 nicht, ermittel sie jedoch dort um sie an "Memory_Picture_Changer" zu senden um dort mit den Werten arbeiten zu können.
Ergo... müsste ich dann nicht auch einen Aufruf aller:

Code:

@pID1,@pid2 = @naviagter.navigate(@pic_ID1, pic_ID2)

machen, damit ich mit den aktuellen Werten in "Memory_Picture_Changer" arbeiten kann?
Weil ich brauche ja dort die Werte.

Edit:
hum, er schmiert ab... unschön. "wrong number of arguments" ... habs mir wohl leichter gedacht als es ist....

Edit2:
Gut, hätte es mir denken können, ich arbeite ja nun nur mit "nil"... weil ja nirgends irgendwo etwas drin steht. Bedeutet, ich müsste es einmal mit den -Werten in Navigate anlegen und mir dann eine Variable anlegen, die ich erhöhe wenn ich Werte in pic_ID1 und pic_ID2 stehen habe.
Dann arbeite ich mit einer if-Abrage um mir am Anfang die Minuswerte wieder zu holen... und setze die Variable wieder auf 0 oder so...
Irgendwie kommt es mir so vor als hätte ich noch einen Denkfehler darin.

**Linkey** · 30.06.2015, 12:43

Sicher, dass es nicht ging? In der Intial-Methode hast du @pic_ID1 und @pic_ID2 auf Minuswerte gesetzt (hier dein Code):

Code:

  def initialize     @cursor = Sprite.new 
    #Kommentar: Die meisten Sprites liegen im Z-Wert zwischen 0 und 300.
      #Mit 500 solltest du auf jeden Fall auf der obersten Ebene sein, wodurch 
    #dein Cursor über allem steht.
    @cursor.z = 500      
@cursor.bitmap = Cache.picture("Zeiger.PNG") 
    @x_nav = 0 
    @y_nav = 0     
@id = 0     
@pic_ID1 = -1     
@pic_ID2 = -2     
@win = 0   
end

Dadurch sind die Variablen ja erst einmal gesetzt.

Nun rufst du die Changer-Methode "change_card" auf, und übergibst ja die IDs. Dementsprechend sind diese Variablen nicht nil. Sicher, dass es dewesegen abgeschmiert ist? Wenn ich mir deinen Code anschaue, sind dort einige andere Fehler drin, die das Programm zum Abschmieren bringen können (update_graphics() rufst du im change_card auf, obwohl diese Methode gar nicht der Klasse Pic_Changer bekannt ist....).

Welche Fehlermeldung hast du erhalten, als du versucht hast die Werte zu übergeben? Gib mir mal den Code davon, dann schaue ich mir das heute nach der Arbeit mal an.

Edit:
Noch einmal kurz als Erklärung. Du ermittelst in Klasse A die Variablen ID1 und ID2 und brauchst diese in Klasse B. Wenn du von Klasse A aus die Klasse B aufrufst (in deinem Fall die MEthode change_pic), macht es dann sinn, die Variablen an dieser Stelle zu übergeben. Daher rufst du von deiner Klasse aus die "change_pic" Methode mit den Variablen auf (change_pic(ID1,ID2)). Und nicht umgekehrt.

**Elster** · 02.07.2015, 15:44

Ja, kann natürlich auch daran liegen. Wirds wohl.

Zu dem Aufruf. Sollte der dann nicht eigentlich so aussehen?

Code:

@pic_ID1,@pic_ID2 = @pic_changer.change_card(@pID1,@pID2)

Weil change_card gibt ja @pID1 und pID2 zurück, oder sind die Bezeichner der Variablen in so fern irrelevant und Ruby weiß schon was es tun soll?

Wobei ich andere Fehler je nach Variante bekomme...
Wenn ich [@pic_ID1,@pic_ID2 = @pic_changer.change_card(@pic_ID1,@pic_ID2)] nutze, dann bleibt oben links in der Ecke mein Mauszeiger kleben... zumindest Einer. Einen anderen kann ich munter über die Karten bewegen.
Klicke ich dann etwas an, findet er in Zeile 423 einen Fehler (Wrong number of arguments (0 for 2)).
Das wäre dann der Befehl "@pic_changer.change_card()" in der Methode "def navigate".

Wenn ich [@pic_ID1,@pic_ID2 = @pic_changer.change_card(@pID1,@pID2)] nutze, dann bekomme ich eine mja... gravierendere Fehlermeldung.
"line288 type error occurred. no implicit conversion from nil to integer".
Dabei handelt es sich dann um die Zeile "@c = f_names[pID1]" aus der Methode "change_card". Kann natürlich mit einem vorher falsch ausgeführten Befehl zusammen hängen.

Momentan sieht der Code wie folgt aus:

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
    
    #Deckkarten
    @figure_wrapper = [
    "Grundkarte.png", "Grundkarte.png", #1
    "Grundkarte.png", "Grundkarte.png", #2
    "Grundkarte.png", "Grundkarte.png", #3
    "Grundkarte.png", "Grundkarte.png", #4
    "Grundkarte.png", "Grundkarte.png", #5
    "Grundkarte.png", "Grundkarte.png", #6
    "Grundkarte.png", "Grundkarte.png", #7
    "Grundkarte.png", "Grundkarte.png", #8
    ]
    
    #Bilderkarten
    @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", 
    ].shuffle
    
    #Sounds für die Tonvariante
    @sound_names = [
    "Up1", "Up1",           #1
    "Thunder3", "Thunder3", #2
    "Sword4", "Sword4",     #3
    "Switch2", "Switch2",   #4
    "Stare", "Stare",       #5
    "Shop", "Shop",         #6
    "Saint9", "Saint9",     #7
    "Miss", "Miss"          #8
    ].shuffle
    
    @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 = 136
    @card_height = 104
    # distance between cards
    @margin = 0
    # number of possible moves
    @move = 32
    # number of right pairs found. Win at 8
    # change in def change_card for your game
    @win = 0
    #p @figure_names
    #p @positions

  end
  
  def get_arrays
      return @figure_wrapper, @figure_names, @sound_names
  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[index]
    @figure_wrapper [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
  # füge Memory als Attribut hinzu
  attr_accessor :memory
end


# Erbebt von Scene_Base
class Scene_Memory < 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
  @navi = Memory_Game_Navigate.new
  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
    @navi.navigate
  end
  
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------  
  def start #(start)
    super 
    initialize_graphics
    update
  end

end

#-------------------------------------------------------------------------------
# Hier findet das Verändern der Deckbilder statt.
# Ich sollte nach gleichen Namen schauen und wenn diese gleich sind, wird das
# Deckblatt entgültig entfernt.
#-------------------------------------------------------------------------------

class Memory_Picture_Changer
  
  #def initialize
    #@navigater = Memory_Game_Navigate.new
    #@pic_ID1 = -1
    #@pic_ID2 = -2
  #end
  
  
  #Ändert die angezeigten Bilder.
  # TODO Tonvariante einpflegen
  def change_card(pID1,pID2)
    @navigater = Memory_Game_Navigate.new
    @memo = Game_Memory.new
    f_wrapper, f_names, s_names = $game_system.memory.get_arrays()
    #@pID1,@pid2 = @naviagter.navigate(@pic_ID1, pic_ID2)
    #pID1 = -1
    #pID2 = -2
    
    #zeigt die erste umgedeckte Karte an.
    if pID1 != -1
      @c = f_names[pID1]
      @f_wrapper.map! {|x| x == pID1 ? @c : x}.flatter
      memo.update_graphics()
    end
    
    #zeigt die zweite umgedeckte Karte an.
    if pID2 != -2
      @d = f_names[pID2]
      @f_wrapper.map! {|x| x == pID1 ? @d : x}.flatter
      memo.update_graphics()
    end
    
    if (pID1 != -1 && pID2 != -2)
      #Wenn die Karten gleich sind!
      if pID1 == pID2
        Audio.se_play("Chime2", 80, 100) 
        pID1 = -1
        pID2 = -2
        @win +1
      #Wenn die Karten ungleich sind!
      else #(pID1 != pID2)
        Audio.se_play("Buzzer2", 80, 100)
        pic = "Grundkarte.png"
        @f_wrapper.map! {|x| x == pID1 ? pic : x}.flatter
        @f_wrapper.map! {|y| y == pID2 ? pic : x}.flatter
        pID1 = -1
        pID2 = -2
        memo.update_graphics()
      end
    end
    return pID1,pID2
  end
  
    
    #also, ich muss irgendwie die Variablen da oben nutzen um da die Namen der
    #der Karten reinzuschreiben. Mit der ID arbeite ich dann um die Karten
    #zu zeigen oder wieder das Deckblatt draufzulegen.
    #ergo brauche ich noch ID Variablen.
    #dann muss ich noch an die IDs der Karten kommen. Das müsste ich wohl über
    #die Bewegung machen... die irgendwie weiter zählt. Geht man nach rechts 
    #halt + auf der x-Achse, geht man nach links - auf der x-Achse
    #geht man nach oben - auf der y-Achse geht man nach unten + auf der y-Achse
    #irgendwie muss ich den Spaß dann auch noch starten und symbolisieren
    #wie man sich bewegt, ich würde ja gerne einen roten Rahmen um das Bild
    #legen der dann da einfach auf dem aktuellen Standort auftaucht, nur wie?
    #erstmal muss ich eh herausfinden wie ich Elemente in einem Array an einer 
    #bestimmten Stelle verändere.
end



# Hier findet die Navigation statt.
class Memory_Game_Navigate
  
  def initialize
    @cursor = Sprite.new
    #Kommentar: Die meisten Sprites liegen im Z-Wert zwischen 0 und 300. 
    #Mit 500 solltest du auf jeden Fall auf der obersten Ebene sein, wodurch 
    #dein Cursor über allem steht.
    @cursor.z = 500 
    @cursor.bitmap = Cache.picture("Zeiger.PNG")
    @x_nav = 0
    @y_nav = 0
    @id = 0
    @pic_ID1 = -1
    @pic_ID2 = -2
    @win = 0
  end
  
  
  def navigate
    @pic_changer = Memory_Picture_Changer.new
    @get_id = Game_Memory.new
    # f_wrapper enthält die Deckblätter
    # f_names enthält die Bilder
    # s_names enthält die Sounds
    f_wrapper, f_names, s_names = $game_system.memory.get_arrays()
    #@pic_ID1,@pic_ID2 = @pic_changer.change_card(@pic_ID1,@pic_ID2)
    @pic_ID1,@pic_ID2 = @pic_changer.change_card(@pID1,@pID2)
    #@h = $game_system.memory.initialize(@figure_wrapper)
    
    if Input.trigger?(:DOWN)
      if @y_nav == 312
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht vergrößert.
      elsif
        @y_nav = @y_nav + 104
        @id = @id + 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:LEFT)
      if @x_nav == 0
        move_error()
        #Wert wird nich verkleinert.
      elsif
        @x_nav = @x_nav - 136
        @id = @id - 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:UP)
      if @y_nav == 0
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht verkleinert.
      elsif
        @y_nav = @y_nav - 104
        @id = @id - 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:RIGHT)
      if @x_nav == 408
        move_error()
        #Wert wird nich vergrößert.
      elsif
        @x_nav = @x_nav + 136
        @id = @id + 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:C)
      a = f_names[@id]
      b = f_wrapper[@id]
      #a = @figure_names.select[@id] 
      if b == "Grundkarte.png"
        if @pic_ID1 == -1
          $game_variables[10] = $game_variables[10] + 1
          @pic_ID1 = @id
          @pic_changer.change_card()
          #change_card()
        elsif @pic_ID2 == -2
          $game_variables[10] = $game_variables[10] + 1
          @pic_ID2 = @id
          @pic_changer.change_card()
          #change_card()
        end
      else
        #Falls der Spieler blind ist, wird hier ein Signal abgespielt
        #sonst wird in beiden Fällen die Variable für die Züge
        #hochgezählt.
        if $game_switches[2] == true
          Audio.se_play("Buzzer1", 80, 100) 
        end
        $game_variables[10] = $game_variables[10] + 1
      end
      
    end
    return @pic_ID1, @pic_ID2
  end
  
  #Hier findet die Bewegung des Mauszeigers statt.
  def move_cursor
    @cursor.x = @x_nav
    @cursor.y = @y_nav
  end
  
  #hier wird der Ton abegespielt wenn sich der Spieler nicht mehr bewegen kann.
  def move_error
    if $game_switches[2] == true
      Audio.se_play("Earth6", 80, 100) 
    end
  end
  
end

Sorry dass der Code erst jetzt kommt

**Linkey** · 02.07.2015, 17:15

Ich esse jetzt gleich erst einmal und bin noch was unterwegs, schaue mir das aber später noch an und editiere es hier rein. Erst einmal zur ersten Zeile vorab:

Beim Aufruf einer Methode, übergibst du nicht die Variable an sich, sondern den Wert, den sie besitzt. Beispiel:

Code:

def methode_a()
  methode_b(5)   # gibt aus: 5
  methode_b(iZahl) #gibt aus: nil, da iZahl in methode_a gar nicht vorhanden ist
  methode_b(rand(10)) #gibt eine zufällige Zahl zwischen 0 und 10 aus
 varzahl = 1
 methode_b(varzahl) #gibt 1 aus
end

def methode_b(iZahl)
  p(iZahl)
end

Das ist bei Methoden mit Rückgabenwerte auch so. Es ist "egal", wie die Variablen in der aufrufenden Methode heißen.

Edit:
Was mir direkt aufgefallen ist,du hast anstelle einer Init-Methode deine ganzen Befehle in die navigae Methode gehauen. D.h, immer wenn die Methode aufgerufen wird, erstellst du neue Game_Memory, Memory_Picture_Changer Objekte. Das sieht falsch aus. Pack das mal in eine Init-Methode. Ich kann es aber wie gesagt später noch korrigieren, wenn ich die Zeit dafür habe.

Edit2:
So, gerade fertig gegessen. So sollte deine Navigate Klasse dann mit den Korrekturen aussehen (warum du plötzlich in allen Methoden Objekte der "Memory_Klasse" anlegst, habe ich übrigens nicht verstanden):

Code:

# Hier findet die Navigation statt.
class Memory_Game_Navigate
  
  def initialize
    @cursor = Sprite.new
    #Kommentar: Die meisten Sprites liegen im Z-Wert zwischen 0 und 300. 
    #Mit 500 solltest du auf jeden Fall auf der obersten Ebene sein, wodurch 
    #dein Cursor über allem steht.
    @cursor.z = 500 
    @cursor.bitmap = Cache.picture("Stern_1.PNG")
    @x_nav = 0
    @y_nav = 0
    @id = 0
    @pic_ID1 = -1
    @pic_ID2 = -2
    @win = 0
    
    @pic_changer = Memory_Picture_Changer.new
  end
  
  
  def navigate    
    # f_wrapper enthält die Deckblätter
    # f_names enthält die Bilder
    # s_names enthält die Sounds
    f_wrapper, f_names, s_names = $game_system.memory.get_arrays()
    
    if Input.trigger?(:DOWN)
      if @y_nav == 312
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht vergrößert.
      elsif
        @y_nav = @y_nav + 104
        @id = @id + 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:LEFT)
      if @x_nav == 0
        move_error()
        #Wert wird nich verkleinert.
      elsif
        @x_nav = @x_nav - 136
        @id = @id - 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:UP)
      if @y_nav == 0
        #Hier wird der Ton für den 2. Modus abgespielt.
        move_error()
        #Wert wird nicht verkleinert.
      elsif
        @y_nav = @y_nav - 104
        @id = @id - 4
        move_cursor()
      end
    end
    
    if Input.trigger?(:RIGHT)
      if @x_nav == 408
        move_error()
        #Wert wird nich vergrößert.
      elsif
        @x_nav = @x_nav + 136
        @id = @id + 1
        move_cursor()
      end
    end
    
    if Input.trigger?(:C)
      a = f_names[@id]
      b = f_wrapper[@id]
      #a = @figure_names.select[@id] 
      if b == "Card_000.png"
        if @pic_ID1 == -1
          $game_variables[10] = $game_variables[10] + 1
          @pic_ID1 = @id
          @pic_ID1,@pic_ID2 = @pic_changer.change_card(@pic_ID1,@pic_ID2)
          #change_card()
        elsif @pic_ID2 == -2
          $game_variables[10] = $game_variables[10] + 1
          @pic_ID2 = @id
          @pic_ID1,@pic_ID2 = @pic_changer.change_card(@pic_ID1,@pic_ID2)
          #change_card()
        end
      else
        #Falls der Spieler blind ist, wird hier ein Signal abgespielt
        #sonst wird in beiden Fällen die Variable für die Züge
        #hochgezählt.
        if $game_switches[2] == true
          Audio.se_play("Buzzer1", 80, 100) 
        end
        $game_variables[10] = $game_variables[10] + 1
      end
      
    end
    return @pic_ID1, @pic_ID2
  end
  
  #Hier findet die Bewegung des Mauszeigers statt.
  def move_cursor
    @cursor.x = @x_nav
    @cursor.y = @y_nav
  end
  
  #hier wird der Ton abegespielt wenn sich der Spieler nicht mehr bewegen kann.
  def move_error
    if $game_switches[2] == true
      Audio.se_play("Earth6", 80, 100) 
    end
  end
  
end

**Elster** · 04.07.2015, 15:58

Danke für die schönen Änderungen in meiner Klasse Linkey :3

@Edit 2:
Öhm... teilweise zum herumprobieren. Zudem muss ich ja zumindest in der Methode "change_card" auf die Methode "update_graphics" zugreifen, welche in Game_Memory liegt.
Mag sein das da wieder ein Denkfehler meinerseits vorhanden ist.

Mjoar, hm, aber was ich gerade wirklich nicht verstehe ist ein Fehler in folgender Zeile:

Code:

@f_wrapper.map! {|x| x == pID1 ? @c : x}.flatter

Da soll jetzt irgndwo was "nil" sein, also irgendwo herrscht gähnende Leere... ich sehe aber rein gar nichts, dass hier leer sein könnte.

Zitat

undifined method `map!' for nil:NilClass

Was ich mir noch vorstellen könnte wäre, dass das Programm nicht so ganz mit "map" klar kommt.
Dann stellt sich aber bei mir die Frage, wie überschreibe ich denn dann die Einträge in dem Array?

**Kelven** · 04.07.2015, 16:55

@f_wrapper selbst ist nil. In deiner Methode "navigate" sehe ich eigentlich auch nur eine lokale Variable f_wrapper, also ohne @. Wo kommt denn der Aufruf, der im Code-Block steht?

**Linkey** · 04.07.2015, 17:40

Wie Kelven schon sagt, setzt du die Variable als lokale Variable (ohne @) hier:

Code:

f_wrapper, f_names, s_names = $game_system.memory.get_arrays()

f_wrapper sollte funktionieren - @f_wrapper ist nicht deklariert, also nil.

Bezüglich des mehrfachen anlegens von Game_Memory:
Die Game_Memory-Klasse sollte exakt ein Objekt für das Spiel verwenden (zumal du in Game_Memory dein Array mischst. Dadurch hat ja jede neuangelegte Instanz der Klasse ein anderes Array).
Du hast ja das erstellte Game_Memory Objekt bereits global im Zugriff:
$game_system.memory

D.h. wenn du nun die Update-Methode von Game_Memory verwenden willst, kannst du es wie folgt machen:

Code:

$game_system.memory.update_graphics

**Cepanks** · 04.07.2015, 18:17

Zitat von Elster

Code:

@f_wrapper.map! {|x| x == pID1 ? @c : x}.flatter

Noch was. Das "flatter" sollte vermutlich flatten heißen? Außer du hast irgendwo eine Methode "flatter" für die Array-Klasse geschrieben, dann passt es.

**Elster** · 07.07.2015, 16:38

@Cepanks
jab, meinte "flattern" ... kommt davon wenn man in den Weiten des Internets sucht und halbwegs richtige Lösungen für sein Problem findet ^^

@Linkey

Code:

$game_system.memory.update_graphics

Ich habe das mal an den entsprechenden Stellen eingefügt, jetzt mosert aber das Programm herum, dass die Methode nicht für Game_Memory definiert sei.
Liegt vermutlich daran, dass update_graphics in der Klasse "Scene_Memory" liegt.
Dann geht der Code wohl so nicht und ich müsste ein neues Objekt von Scene_Memory anlegen... oder?

**Linkey** · 07.07.2015, 17:54

Hallo Elster,

super, habe kurz noch einmal auf dein Coding geschaut. Du brauchst die update_graphic-Aufrufe gar nicht.Deine Scene_Memory wird ja permanent geupdated. Und in der Update-Methode hast du folgendes:

Code:

def update
    super
    update_graphics
    @navi.navigate
  end

Du rufst update_graphics also permanent auf. Es ist also nicht nötig, diese Methode noch mehrmals aufzurufen, wenn diese eh schon permanent aufgerufen wird.
Nimm den Befehl aus deinen anderen Klassen daher ganz raus.

Edit:
Kurz noch einmal drüber geflogen, dein Rückgabewert in der navigate-Methode ist nicht nötig. Du gibst dort "id1 und id2" zurück, was keinen sinn macht. Die Methode wird ja von der Scene_Memory über die Update-Methode aufgerufen.
Was du aus performance Gründen noch eventuell machen könntest, dass du von der Navigate-Methode ein "true" zurückgibst, wenn Input:

aktiviert wurde und die Methode an sonsten ein false zurück gibt (die letzten Zeilen der Navigate Methode sollten dann ungefähr so aussehen:

Code:

 return true
    end
    return false
  end
  
  #Hier findet die Bewegung des Mauszeigers statt.
  def move_cursor

Dann könntest du in der Scene_Memory Update-Methode folgendes machen:

Code:

def update
    super
    update_graphics if(@navi.navigate)
  end

Dadurch wird update_graphics nur ausgeführt, wenn Enter gedrückt wurde. Die Kartenbilder müssen ja nicht jede Sekunde geupdated werden, sondern nur bei Änderungen, welche ja eigentlich nur bei "Enter" geschehen können.

Thema: [VX-Ace] Script zeigt Bild nicht an

Themen-Optionen

Anzeige

Stichworte

Berechtigungen