[VX-Ace] Script zeigt Bild nicht an

**Kelven** · 11.05.2015, 13:20

Ja und zwar passiert Folgendes: Eine neue Instanz von Game_Memory wird angelegt. Dabei wird initialize aufgerufen, doch Methode legt dann wegen dem Aufruf @memory = Game_Memory.new gleich nochmal eine weitere Instanz an und das unendlich lang. Der Aufruf sollte bei Game_System in die Initialize-Methode geschrieben werden und der Aufruf bei Game_Memory sollte wieder entfernt werden.

Normalerweise (falls du nicht schon etwas geändert hast, steht bei Game_System Folgendes:

Code:

  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    @save_disabled = false
    @menu_disabled = false
    @encounter_disabled = false
    @formation_disabled = false
    @battle_count = 0
    @save_count = 0
    @version_id = 0
    @window_tone = nil
    @battle_bgm = nil
    @battle_end_me = nil
    @saved_bgm = nil
  end

Daraus machst du:

Code:

  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    @save_disabled = false
    @menu_disabled = false
    @encounter_disabled = false
    @formation_disabled = false
    @battle_count = 0
    @save_count = 0
    @version_id = 0
    @window_tone = nil
    @battle_bgm = nil
    @battle_end_me = nil
    @saved_bgm = nil

    @memory = Game_Memory.new
  end

**Elster** · 02.06.2015, 15:32

Entschuldigt bitte das ich mir hier mit den Antworten so viel Zeit gelassen habe (RL und so).

Jedenfalls... ich habe nun die Sachen wie empfohlen geändert.
Nun habe ich jedoch wieder ein weiteres Problem.

Ich starte das Memory ja über die beiden Befehle hier:

Code:

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

Aus mir nun etwas unerfindlichen Gründen hat er nun wieder Probleme mit dem unteren Aufruf.
Das äußert sich mal wieder so...

Zitat

Script 'GameInterpreter' line 1411: NameError occurred.
uninitialized constant Game_Interpreter::Scene_Manager

Wenn ich jetzt "Scene_Mager.call(Scene_Memory)" auskommentiere verschwindet der Fehler natürlich, aber ich bekomme halt auch keine Bilder angezeigt.

**Linkey** · 02.06.2015, 19:47

Ohne jetzt deine Skripte anzuschauen, das Objekt heißt (ohne "_"): SceneManager

Versuch es mal damit (:

**Elster** · 04.06.2015, 15:14

Oh man, manchmal hat man wirklich ein Brett vor dem Kopf

Dennoch, irgendwas scheint er wieder nicht finden zu wollen.

Zitat

Script 'Cache' line 88: NoMethodError occurred.
undefined method `empty?' for nil:NilClass

Die Meldung taucht dann auf, wenn [card_x(index), card_y(index), card_image(index)] (Mathode get_card index) keine Werte mehr aus dem Koordinatenarray bekommt.
Nachdem der letzte Wert geschrieben wurde... zack Meldung.
Hab jedenfalls mal am Anfang jeder Methode mir eine "Ausgabe" machen lassen und mal die Consolenausgabe kopiert.
Der Länge wegen steht es halt in einem Spoiler, sonst erschlägt es einen.

Rein theoretisch sollte es nun ja nach "get_cards" gehen .... an meine lieben Unterstützer, ich müsste hier vermutlich einen Aufruf von "get_card index" tätigen ... oder?

**Linkey** · 04.06.2015, 15:43

Der Fehler wird erzeugt, da du die Cache.Picture mit nil aufrufst.
Dies geschieht durch deinen folgenden Code:

Code:

def card_image index
     @figure_names[@positions[index]]
  end

Ich vermute mal, du möchtest, je nach Index das figure_names Array ansprechen. Demnach sollte dein Code wie folgt lauten:

Code:

def card_image index
     @figure_names[index]
  end

Durch deinen aktuellen Code wird bpsw. bei Index = 3 nicht @figure_names[3] angesprochen (so wäre es beim unteren code), sondern @figure_names[136]. Dieser Wert ist im Array nicht vorhanden und daher nil.
(@positions[3] = 136)

Edit:
Desweiteren wird dein Code nicht funktionieren, da dein @positions 16 Koordinaten (je X und Y) beinhaltet, du aber nur 15 Grafiken in @figure_names gepflegt hast. Die 16. Koordinate wird daher auch "nil" als image wählen.

**Elster** · 06.06.2015, 19:49

Okay, so weit geändert. Dennoch, der Fehler bleibt der selbe.
Durch ein wenig rumprobieren sind mir ein paar "Merkwürdigkeiten" aufgefallen, welche ich mir selber kaum erklären kann.
Erstmal habe ich mir mehr Sachen über die Konsole ausgeben lassen, so ist mir aufgefallen, dass bei den ganzen Koordinaten wirklich zu wenig Bilder (wie angemerkt) vorhanden waren. (irgendwann stand halt nil bei Werten drin, wie du bereits gesagt hast Likey)
Darüber hinaus ist mir aber was viel interessanteres ins Auge gefallen... so bald ich das Array @positions leer lasse, stürzt es nicht ab. So bald aber Werte drin stehen taucht halt der Fehler am Ende auf....
Ich könnte es mir so erklären das er halt mault weil bestimmte Werte nicht übereinstimmen... aber sicher bin ich mir da gerade wirklich nicht.

Mein momentaner Code:

Code:

class Game_Memory
  # hier kommen alle Attribute rein die dein Spiel so hat
  
  # filenames of the pictures of your cards
  attr_accessor :figure_names

  def initialize
    @figure_names = ["Spinne1.png", "Spinne1.png", 
    "Spinne2.png", "Spinne2.png", 
    "Spinne3.png", "Spinne3.png", 
    "Spinne4.png", "Spinne4.png", 
    "Spinne5.png", "Spinne5.png", 
    "Spinne6.png", "Spinne6.png", 
    "Spinne7.png", "Spinne7.png", 
    "Spinne8.png", "Spinne8.png", 
    "Spinne9.png", "Spinne9.png", 
    "Spinne10.png", "Spinne10.png", 
    "Spinne11.png", "Spinne11.png", 
    "Spinne12.png", "Spinne12.png", 
    "Spinne13.png", "Spinne13.png", 
    "Spinne14.png", "Spinne14.png", 
    "Spinne15.png", "Spinne15.png", 
    "Spinne16.png", "Spinne16.png"
    ]
    
    @positions = [
    0, 0, 
    136, 0, 
    272, 0, 
    408, 0,
    #
    0, 104, 
    136, 104, 
    272, 104, 
    408, 104,
    #
    0, 208, 
    136, 208, 
    272, 208, 
    408, 208,
    #
    0, 312, 
    136, 312, 
    272, 312, 
    408, 312
    ]
    # number of cards horizontal
    @max_number_of_cols = 3 
    # size of cards
    @card_width = 136
    @card_height = 104
    # distance between cards
    @margin = 0
    p @figure_names
    p @positions

  end

  # returns x, y coordinates as well as the image name of
  # the card with the given index
  def get_card index
    p "get_card index"
    [card_x(index), card_y(index), card_image(index)]
    p card_x(index)
    p card_y(index)
    p card_image(index)
  end

  # return all cards
  def get_cards
    p "get_cards"
    # create a new array with elements
    # for all indizes from 0 upto @positions.size
    (0...@positions.size).map do |index|
      # each element contains the result value of
      # get_card
      get_card index
      end
  end
  
  # x coordinate for a given card index
  def card_x index
    p "card_x index"
    col_num = index % @max_number_of_cols
    col_num * (@card_width + @margin)
  end
  
  # y coordinate for a given card index
  def card_y index
    p "card_y index"
    row_num = index / @max_number_of_cols
    row_num * (@card_height+@margin)
  end
  
  # filename of card image
  def card_image index
    p "card_image index"
     @figure_names[index] 
     #@figure_names[@positions[index]]
  end
  
  # number of different figures/cards
  def number_of_pictures
    p "number_of_pictures"
    @figure_names.size
  end
   
  # add 2 cards for each figure into the field
  # shuffle the positions of all cards
  def shuffle_cards
    p "shuffle_cards"
    @positions.clear
    # this loop is invoked as often as the number
    # of different cards
    number_of_pictures.times do |picture_id|
      # for each invocation, two cards are added
      # into the array 
      @positions << picture_id << picture_id
    end
    # shuffle the array at the end
    @positions.shuffle!
  end
  
end

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


# Erbebt von Scene_Base
class Scene_Memory < Scene_Base
  p "Scene_Memory"
  #class << self 
#-------------------------------------------------------------------------------
# Überschreibt start von Scene_Base
#-------------------------------------------------------------------------------
  def initialize_graphics
    p "initialize_graphics"
  # for each card in the game
  @card_sprites = $game_system.memory.get_cards.map do |x, y, image|
    # create a new sprite
    sprite = Sprite.new
    # set its graphic and coordinates
    sprite.bitmap = Cache.picture(image)
    sprite.x, sprite.y = x, y
    # and "return" the sprite into the array
    sprite
  end
end

def update_graphics
  p "update_graphics"
  # update attributes of all sprites
  @card_sprites.each_with_index do |sprite, index|
    x, y, image = $game_system.memory.get_card(index)
    sprite.bitmap = Cache.picture(image)
    sprite.x, sprite.y = x,y
  end
end

def dispose_graphics
  p "dispose_grapics"
  @card_sprites.each do |sprite|
    sprite.dispose
  end
end
  
#-------------------------------------------------------------------------------
# überschreibt  terminate Scene_Base
#-------------------------------------------------------------------------------
  def terminate
    p "terminate"
    super
    dispose_graphics
  end
  
#-------------------------------------------------------------------------------
# überschreibt update Scene_Base
#-------------------------------------------------------------------------------
  def update
    p "update"
    super
    update_graphics
  end
  
  def start #(start)
    p "start"
    super 
    initialize_graphics
    update
  end

end
#end

Eine tollkühne Vermutung meinerseits ist, dass er mosert das die Koordinaten aus @positions momentan einfach nicht zu den Werten aus @card_width und @card_height passen... wobei ich da momentan wirklich keinen Grund für sehe.

**Linkey** · 07.06.2015, 10:28

Hey Elster,
du hast dir deine Methode "def get_card index" selbst zerschossen. Du arbeitest in deinen Methoden ohne ein explizites "return" - was vollkommen okay ist. Allerdings solltest du dies nicht machen, da du ja scheinbar noch anfänger bist (was das Skripten mit Ruby angeht) und - wie man hier merkt - dir ein Eigentor geschossen hast.
Wenn du kein Return-Statement verwendest, gibt eine Methode in Ruby das letzte Statement zurück. In deinem Fall gibt die Methode also nicht mehr das Array zurück, sondern "p card_image(index)".
Wenn du die 3 Ausgaben also haben möchtest, musst du die über dein Array schreiben, damit das Array zurückgegeben wird:

Code:

  def get_card index
    p "get_card index"
    p card_x(index)
    p card_y(index)
    p card_image(index)
    [card_x(index), card_y(index), card_image(index)]
  end

Edit:
Vielleicht erklärst du mal ganz genau, was du eigentlich vor hast. Irgendwie macht dein Code aktuell wenig Sinn. Was bezweckst du mit @positions eigentlich? Denn die Werte, die du in dem Array stehen hast, werden nie verwendet.

**Elster** · 08.06.2015, 19:51

Es funktioniert tatsächlich ohne die Ausgaben.... yayi
Ich sehe Bilder <3

Mja was Ruby angeht bin ich echt ein absoluter Neuling...

Also was es einmal werden soll ist ein Memory. Wo man halt Paare von Karten finden soll. (soll dann noch auf sounds ausgeweitet werden, also zusätzlich ein Soundmemory.)
Das ist die Grundidee. Klar, dafür müssen vorher noch die Karten verdeckt sein/ werden.

Mein Gedankengang des Aufbaus war halt, dass man eben Koordinaten braucht um die Bilder zu plazieren, zudem IDs um die Paare ausfindig zu machen.
Das Skript stammt größtenteils von -KD- (danke noch einmal dafür :3) und darauf baue ich halt auf und wusel mich da halt durch.

In naher Zukunft folgt dann noch die Steuerung (Navigation über das Spielfeld) und Identifizierung der einzelnen Karten. Wie genau ich das mache weiß ich noch nicht.
Aber ich muss etwas zum "anklicken" haben, damit halt das Bild gezeigt wird oder ein Sound abgespielt wird, vielleicht geht es auch ohne Objekte auf der Map... hoffentlich.

Das Array benötige ich sicherlich später noch für die Steuerrung. Also dem Ansteuern eben jener Koordinaten um dann Dinge zu tun. [Bilder umdrehen, Sounds abspielen... oder was mir sonst so noch im Zusammenhang mit Anklicken einfällt]

Ich hoffe ich konnte mich hier halbwegs verständlich ausdrücken ^^" wenn ich mehr ins Detail gehen soll, kann ich das gerne tun.

**Linkey** · 08.06.2015, 20:15

Alles klar. Ist ja super, dass es nun bis hierhin schon einmal funktioniert.

Aktuell berechnest du die Koordinaten ja komplett über die Methoden card_x und card_y.
In Zugriffen über @postions verwendest du lediglich den Index des Arrays, aber nie die Werte. Und wenn du später noch Dinge im Script einbaust, wirst du sicherlich auch hier die Methoden card_x und card_y verwenden (können).

Aber super, dass du dir Anhand der hier im Forum gegebene Unterstützung selbst an den Skripten versuchst.
Kannst dein fertiges Skript ja mal irgendwann vorstellen - ansonsten bis zum nächsten Problem~

**Elster** · 25.06.2015, 12: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, 14: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, 20: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.

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

Themen-Optionen

Anzeige

Hybrid-Darstellung

Stichworte

Berechtigungen