[VX-Ace] Script zeigt Bild nicht an

[Linkey]

Hey Elster :)

Wenn ich das richtig sehe, verwendest du "Blanco" nur bei der Sound-Methode. Daher gibt es das Problem, dass egal in welchem Modi du bist, die andere Abfrage dann funktioniert - da hier die Felder alle immer entweder Blanco oder Grundkarte sind. Du musst daher in deine Input:C Abfrage auch noch den Switch[2] abfragen:

Code:

[...]
if b == "Grundkarte.png" && $game_switches[2] == false
[....]
elsif c == "Blanco.png" && $game_switches[2]
[....]

Dazu kommt noch, dass du einen Fehler eingebaut hast, in der Changer Methode. Dort verwendest du bei einer der beiden pIDs den f_wrapper anstelle des f_wrapper_2 für die Sound-Methode. Wenn du die beiden Dinger korrigierst, sollte es gleich funktionieren.

Folgendes macht übrigens wenig Sinn (es sei denn das ist ein Platzhalter und es wird dort noch eine Sonderabfrage (unentschieden?) stattfinden in Zukunft):

Code:

if @win == 8 && @zug != 32
      if $game_switches[2] == true
        # TODO klar machen das der Spieler gewonnen hat.
      end
      $game_switches[17] = true
      SceneManager.return
    end
    
    #Spiel gewonnen
    if @win == 8 && @zug == 32
      if $game_switches[2] == true
        # TODO klar machen das der Spieler gewonnen hat.
      end
      $game_switches[17] = true
      SceneManager.return
    end

Sobald @win == 8 ist, trifft eine der beiden Abfragen zu. Da diese den gleichen Inhalt haben, ist die Doppelung durch die Abfragen auf @zug = 32 oder != 32 überflüssig.

Außerdem ist dein "Else" bei der Navigate Methode sinnlos. Dort zählst du Variable[10] hoch - diese wird aber nirgends verwendet. Warum auch? Ist es tatsächlich ein Zug, wenn man eine bereits aufgedeckte Karte anklickt? Hier scheint ein Logikfehler vorzuliegen.

@Schönheitsfehler:
Ein einfaches sleep reicht dort nicht. Du bist darauf angewiesen, dass deine Methode etwas zurückgibt, damit das Update durchgeführt wird.

Code:

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

D.h. wenn du innerhalb des navigate Aufrufes ein sleep setzt, wird auch die Rückgabe an deine update Methode verzögert. Du musst es also so umsetzen, dass die Karte umgedreht wird - die Methode einen Wert zurückliefert - und erneut in die Methode springt und dort dann das Umdrehen beider Karten vornimmt.
Hierfür bietet es sich an, einen Timer oder eine Tastenabfrage einzubauen.

Habe dir das einmal in deinen Code eingefügt:

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
    ]
    
    #Deckkarten 2 ... für den blinden Spieler
    @figure_wrapper_2 = [
      "Blanco.png", "Blanco.png", #1
      "Blanco.png", "Blanco.png", #2
      "Blanco.png", "Blanco.png", #3
      "Blanco.png", "Blanco.png", #4
      "Blanco.png", "Blanco.png", #5
      "Blanco.png", "Blanco.png", #6
      "Blanco.png", "Blanco.png", #7
      "Blanco.png", "Blanco.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
    p @figure_names
    p @sound_names
  end
  
  def get_arrays
      return @figure_wrapper, @figure_wrapper_2, @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_wrapper [index]
    if $game_switches[2] != true
      @figure_wrapper [index]
    elsif $game_switches[2] == true
      @figure_wrapper_2 [index]
    end
  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
  
  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
    @zug = 0
    @c = "a"
    @d = "b"
    @c2 = "c"
    @d2 = "d"
    # Dient dazu, dass der erste Kartenklang nur einmal abgespielt wird, 
    # ohne @w wird er es sonst zweimal und überlagert halb den Klang der
    # zweiten Karte.
    @w = 2
    end
  
  #Ändert die angezeigten Bilder.
  # TODO Tonvariante einpflegen
  def change_card(pID1,pID2)
    f_wrapper, f_wrapper_2, f_names, s_names = $game_system.memory.get_arrays()
    #zeigt die erste umgedeckte Karte an.
    if pID1 != -1
      if $game_switches[2] != true
        @c = f_names[pID1]
        f_wrapper.map!.with_index {|x,i|i == pID1 ? @c : x}.flatten
      end
      if $game_switches[2] == true && @w != 1
        @c3 = "Blanco_2.png"
        @c2 = s_names[pID1]
        RPG::SE.new(@c2, 80, 100).play
        @w = 1
        f_wrapper_2.map!.with_index {|x,i|i == pID1 ? @c3 : x}.flatten
      end
    end
    
    #zeigt die zweite umgedeckte Karte an.
    if pID2 != -2
      if $game_switches[2] != true
        @d = f_names[pID2]
        @zug = @zug + 2
        f_wrapper.map!.with_index {|y,i| i == pID2 ? @d : y}.flatten 
      end
      
      if $game_switches[2] == true
        @d3 = "Blanco_2.png"
        @d2 = s_names[pID2]
        RPG::SE.new(@d2, 80, 100).play
        @zug = @zug + 2
        f_wrapper_2.map!.with_index {|y,i| i == pID2 ? @d3 : y}.flatten 
      end
      
    end    
    return pID1,pID2
  end
  
  def end_change(pID1,pID2)
    f_wrapper, f_wrapper_2, f_names, s_names = $game_system.memory.get_arrays()
    if (pID1 != -1 && pID2 != -2 )
      #Wenn die Karten gleich sind!
      if @c == @d #|| @c2 == @d2
        pID1 = -1
        pID2 = -2
        @win = @win + 1
        win_loose()
      #Wenn die Karten ungleich sind!
      elsif @c2 == @d2
        RPG::SE.new("Chime2", 80, 100).play
        pID1 = -1
        pID2 = -2
        @win = @win + 1
        @w = 2
        win_loose()
       else 
        #(pID1 != pID2)
        if $game_switches[2] != true
          pic = "Grundkarte.png"
          #sleep(1)
          f_wrapper.map!.with_index {|x,i| i == pID1 ? pic : x}.flatten
          f_wrapper.map!.with_index {|y,i| i == pID2 ? pic : y}.flatten
          pID1 = -1
          pID2 = -2
          win_loose()
        end
        if $game_switches[2] == true
          RPG::SE.new("Buzzer2", 80, 100).play
          pic = "Blanco.png"
          f_wrapper_2.map!.with_index {|x,i| i == pID1 ? pic : x}.flatten
          f_wrapper_2.map!.with_index {|y,i| i == pID2 ? pic : y}.flatten
          pID1 = -1
          pID2 = -2
          @w = 2
          win_loose()
        end
      end
    end
    return pID1,pID2
  end
  
  
  #Siegbedingungen des Spiels
  def win_loose
    p @zug 
    p "Züge"
    p @win
    #Spiel gewonnen
    if @win == 8 && @zug != 32
      if $game_switches[2] == true
        # TODO klar machen das der Spieler gewonnen hat.
      end
      $game_switches[17] = true
      SceneManager.return
    end
    
    #Spiel gewonnen
    if @win == 8 && @zug == 32
      if $game_switches[2] == true
        # TODO klar machen das der Spieler gewonnen hat.
      end
      $game_switches[17] = true
      SceneManager.return
    end
    
    #Spiel verloren
    if @win != 8 && @zug == 32
      if $game_switches[2] == true
        # TODO klar machen das der Spieler verloren hat.
      end
      #RPG::SE.new("Fire9", 80, 100).play
      $game_switches[16] = true
      SceneManager.return
    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 
    if $game_switches[2] == false
      @cursor.bitmap = Cache.picture("Zeiger.png")
    end
    @x_nav = 0
    @y_nav = 0
    @id = 0
    @pic_ID1 = -1
    @pic_ID2 = -2
    @pic_changer = Memory_Picture_Changer.new
    @wait = 0
  end
  
  
  def navigate    
    # f_wrapper enthält die Deckblätter
    # f_names enthält die Bilder
    # s_names enthält die Sounds
    if(@wait > 0)
      @wait -= 1
      if(@wait == 0)
        @pic_ID1,@pic_ID2 = @pic_changer.end_change(@pic_ID1,@pic_ID2)
        return true
      end
      return false
    end
    
    f_wrapper, f_wrapper_2, 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]
      c = f_wrapper_2[@id]
      if b == "Grundkarte.png" && $game_switches[2] == false#|| b == "Blanco.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)
          @wait = 30
        end
      elsif c == "Blanco.png" && $game_switches[2]
        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)
          @wait = 30
        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
          RPG::SE.new("Buzzer1", 80, 100).play
        end
        $game_variables[10] = $game_variables[10] + 1
      end
      return true
    end
    return false
  end
  
  #Hier findet die Bewegung des Mauszeigers statt.
  def move_cursor
    if $game_switches[2] == true
      RPG::SE.new("Switch1", 80, 100).play
    end
    @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
      RPG::SE.new("Earth6", 80, 100).play
    end
  end
end

Edit:
Als Eklärung:
In deiner Pic-Changer Klasse ist die "pic_change methode" nun geteilt wurden. In der Change Methode werden jetzt nur noch die Pictures gesetzt - die Abfrage, ob die Bilder gleich sind oder nicht, wurde in die "end_change" Methode gepackt. Dadurch haben wir die Möglichkeit, die Events "Karte umdrehen" und "Karte wieder verdecken falls kein Paar" zu trennen.

Deine Update-Methode ruft nun "navigate auf". Diese Methode prüft nun als aller erstes, ob @wait > 0 ist. Wenn dies der Fall ist, wird @wait um 1 verringert und anschließend die Methode direkt wieder (mit dem Wert false - da kein Update der Grafiken erforderlich ist) zurückgegeben. Sobald @wait aber auf 0 steht, wird die "end_change" Methode aufgerufen und anschließend durch ein return true die Grafik wieder geupdated. Beim nächsten Sprung in die Methode ist @wait nicht mehr größer 0 und dadurch wird die Methode jetzt wieder wie gewohnt fortgesetzt (Tastenabfragen).

Der Waitbefehl wird gesetzt, wenn die 2. Karte umgedreht wird. Diese habe ich jetzt auf 30 gestellt. Du kannst da je nach Belieben auch eine höhrere oder kleinere Zahl einstellen.
Du kannst anstelle eines Timers aber auch eine Variable setzen und dann anstelle der Abfrage "@wait > 0" ein "variable == true" reinsetzen und innerhalb dieser Methode per Tastenabfrage (z.B. C für Enter) die Sequenz fortführen. Somit könnte der Spieler solange auf die Karte schauen, bis er weiterdrückt.

Hoffe es war einigermaßen verständlich - wenn du noch Fragen hast kannst du dich ansonsten gerne melden.

Edit 2:
Post überarbeitet. Hatte da etwas falsch verstanden. Sollte jetzt stimmen.