[VX-Ace] Script zeigt Bild nicht an

[Linkey]

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]

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.

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]

@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]

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]

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]

@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]

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.

[Elster]

Gut, sieht schon mal besser aus, danke.
Nur... wenn ich etwas anklicke, habe ich wieder den zweiten Mauszeiger, oben links in der Ecke.

Auch wird das Bild an der Koordinate nicht geändert.

ebenso dachte ich, ich würde schon abfangen, dass man Karten nicht doppelt anklicken kann =/
Gut, sollte eigentlich auch mit:

Code:

if b == "Grundkarte.png"

funktionieren... nur werden eben die Karten im Array nicht geändert...
Eigentlich sollten das doch folgende Codezeilen hinbekommen oder?

Code:

if pID1 != -1
      @c = f_names[pID1]
      f_wrapper.map! {|x| x == pID1 ? @c : x}.flatten
    end

Was mir auch noch Sorgen bereitet, das Memory findet Paare nicht. Nur wenn ich zwei mal auf die selbe Stelle klicke, meint es ich hätte was passendes gefunden, dabei sollte es doch gleiche Kartennamen erkennen.
Wenn... ich mir aber meinen Code anschaue.... oh mist.... ich arbeite mit den IDs bezüglich der Paarfindung... dann kann das natürlich nicht gehen.
Also haut meine Werte Abfrage...

Code:

if pID1 == pID2

... tatsächlich nur dann hin... wenn ich zweimal auf die selbe Stelle klicke... (warum ist mir das nicht eher aufgefallen? *facepalm*)
Hab ich auch mal einen Fehler gefunden..... und tatsächlich beseitigt bekommen O_O

Naja aber die anderen bereiten mir echt Kopfzerbrechen...

Momentan sieht der Code im Ganzen so aus und... läuft auch... nur eben mit "n" Mauszeigern und keiner Bildanpassung.

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 if(@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
    @win = 0
  end
  
  #Ändert die angezeigten Bilder.
  # TODO Tonvariante einpflegen
  def change_card(pID1,pID2)
    @navigater = Memory_Game_Navigate.new
    f_wrapper, f_names, s_names = $game_system.memory.get_arrays()
    p pID1, pID2
    #zeigt die erste umgedeckte Karte an.
    if pID1 != -1
      @c = f_names[pID1]
      f_wrapper.map! {|x| x == pID1 ? @c : x}.flatten
      #$game_system.memory.update_graphics
    end
    
    #zeigt die zweite umgedeckte Karte an.
    if pID2 != -2
      @d = f_names[pID2]
      f_wrapper.map! {|x| x == pID1 ? @d : x}.flatten #flatter
      #$game_system.memory.update_graphics
    end
    
    if (pID1 != -1 && pID2 != -2)
      #Wenn die Karten gleich sind!
      p @c, @d
      if @c == @d
        RPG::SE.new("Chime2", 80, 100).play
        pID1 = -1
        pID2 = -2
        @win = @win + 1
      #Wenn die Karten ungleich sind!
      else #(pID1 != pID2)
        RPG::SE.new("Buzzer2", 80, 100).play
        pic = "Grundkarte.png"
        f_wrapper.map! {|x| x == pID1 ? pic : x}.flatten
        f_wrapper.map! {|y| y == pID2 ? pic : y}.flatten
        pID1 = -1
        pID2 = -2
        #$game_system.memory.update_graphics
      end
    end
    return pID1,pID2
  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
    
    @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]
      if b == "Grundkarte.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)
        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)
        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
      return true
    end
    #return @pic_ID1, @pic_ID2
    return false
  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]

Hallo Elster,

das Problem mit den mehrfachen Zeigern, du erstellst - unnötig - ein Objekt der Navigate Klasse direkt in der change Methode. Diese musst du rausnehmen:

Code:

def change_card(pID1,pID2)
    @navigater = Memory_Game_Navigate.new

Edit:
So, habe mir den Rest mal schnell überflogen. Folgendes Problem hast du noch in deiner change_pic Methode:
Die folgende Zeile:

Code:

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

Geht über das Array und prüft dann jedes Element auf "pID1". Die Elemente sind aber alle "Grundkarte.png" und daher ist die Abfrage nie richtig.

Richtig lautet es wie folgt:

Code:

f_wrapper.map!.with_index {|x,i|i == pID1 ? @c : x}.flatten

Durch den Zusatz "with_index" wird der Index der Position des Arrays mit gegeben. Diese wird durch die Variable "i" dann im Befehl festgehalten und du prüft dann pID1 auf i. So klappt es dann, dass pID mit der Array-Position verglichen wird.

Das musst du in den anderen ".map!"-Verwendungen in der Change_Pic-Methode so anpassen.

[Elster]

Omg es funktioniert!!!!!
ES FUNKTIONIERT!!!!!!

DANKE! DANKE! DANKE! DANKE! DANKE!

Ich weiß das ich damit noch nicht ganz fertig bin und ein paar Sachen fehlen... aber ES FUNKTIONERT!
Jetzt muss ich nur ein Ende einbauen wenn ich alle Karten umgedreht habe oder zu viele Züge gemacht wurden. (Gut und ich wollte eine zweite Variante Einfügen... aber das sollte nachdem das steht nicht mehr das Problem sein)

DANKE!!!!!

Linkey, Cepanks, -KD- und Kelven durchknuddel

[Linkey]

Immer wieder gerne. Wir sind ja hier, weil wir gerne bei technischen Fragestellungen helfen.
Wenn du dabei noch etwas gelernt hast ist es wunderbar (:

Ich hoffe, wir bekommen was zu sehen, wenn es irgendwann mal komplett fertig ist und es ein "Spiel" dazu gibt

[Elster]

Okay, ich bin äußerst gut darin mein Skript zu beenden, sehr gut so gar..... ich würde fast sagen zu gut!
Ich kann hervorragend das gesammte Spiel beenden... wunderbar oder?

Mal so am Rande... gibt es eine Möglichkeit ein Skript einfach zu stoppen ohne das gesammte Spiel abzuschalten oder den Bildschirm dabei einzufrieren?
Für so ein "Minispiel" wirklich ärgerlich... wenn man es nicht beenden/gewinnen kann O_o

Ich finde im Netz auch nur was wie ich es halt davon abhalte zu starten... was ich ja nicht will.

[Kelven]

Eigentlich müsstest du nur wieder zur Map-Szene zurückwechseln können. Und zwar mit der Methode return_scene.

[Linkey]

Diese Methode funktioniert aber nur, wenn du diese in Scene_Memory verwendest, da die Methode in Scene_Base deklariert ist (und Scene_Memory von Scene_Base erbt).