Seite 4 von 4 ErsteErste 1234
Ergebnis 61 bis 71 von 71

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

  1. #61
    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

    Geändert von Elster (08.07.2015 um 16:53 Uhr)

  2. #62
    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.

    Geändert von Linkey (08.07.2015 um 21:18 Uhr)

  3. #63
    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

  4. #64
    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

  5. #65
    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.

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

  7. #67
    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).

  8. #68
    Das hat so funktioniert ^^


    Dennoch habe ich gerade ein anderes, mich arg verwirrendes Problem.
    Die Kartenvariante funktioniert noch immer ohne Probleme (ok sie hat einen Schönheitsfehler und vielleicht hat einer von euch eine Idee wie man den beseitigen kann)

    Dennoch, in meiner Klangvariante gibt es etwas, das mich wirklich stutzig macht.
    Das passiert, jetzt zumindest nur noch, beim ersten Zug. Hier kann ich einmalig eine einzige Karte zwei mal anklicken um ein Paar zu finden... und dann ist die auch umgeschrieben so das ich unmöglich mit der anderen, gleichen Karte noch ein Paar bilden kann.
    Weiterhin kann ich (das gesammte Spiel über) zwei Mal auf die selben Stelle im Memory klicken und ich kann zwei mal ein Paar finden, erst danach wird es endgültig als gefunden deklariert und die Karten können nicht mehr angeklickt werden.
    Genauer erklärt: ich drücke auf A1 u. A2 (da liegen nun zusammen ein paar und ich höre das Geräusch für gefunden und der Zähler um zu gewinnen wird einen hoch gezählt) jetzt kann ich noch einmal A1 u. A2 anklicken... danach kann ich sie aber nicht mehr anklicken. Beim besten Willen, ich kann mir das nicht erklären
    Ich kann also mit einem Paar Doppel abräumen. Hilfe ^^"

    So und nun zum kleinen "Schönheitsfehler". In der Bildvariante wird die zweite Karte nicht umgedreht, wenn ein Kartenpaar nicht zusammen passt. Ergo sieht der Spieler nicht, was sich unter Karte 2 befindet. Ich habe versucht, da ein Programm ja extrem schnell arbeitet, den Prozess des Zurückdrehens mit einem "sleep" herauszuzögern... aber da wartet das Programm nur doof ab und zeigt auch kein Bild an, egal wo ich es einbaue.
    Jemand eine Idee wie ich dem Spieler noch kurzzeitig Karte 2 zeigen kann?
    Ansonsten hier einmal der komplette Code, mit der schönen verbugten Tonvariante... wenn jemand den Fehler findet, warum ich ein paar zweimal finden kann, wäre ich sehr danbar. Für den anderen Fehler natürlich auch.

    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.map!.with_index {|y,i| i == pID2 ? @d3 : y}.flatten 
          end
          
        end
        
        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
      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_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" #|| 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)
            end
          elsif c == "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)
            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

  9. #69
    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.

    Geändert von Linkey (26.07.2015 um 23:23 Uhr)

  10. #70
    Vielen lieben Dank ^^
    Es funktioniert wunderbar

    Variable[10] brauche ich außerhalb des Memorys
    Damit kann man dann Sachen bekommen, je nachdem wie viele Züge man gebraucht hat, fällt die Belohnung besser, oder eben schlechter aus.
    Lässt sich mit einer einfachen Variable außerhalb des Memorys weit einfacher lösen.

    Oder man könnte damit jetzt auch eine Rangliste noch erstellen. "Dein bestes Spiel" oder was einem noch so einfällt.

  11. #71
    Freut mich zu hören
    Die Züge werden aber ja auch erhöht, wenn man auf bereits geöffnete Bilder klickt. Das macht ja nicht unbedingt Sinn. Da könntest du lieber die Variable[10] zum Ende füllen, wenn die Sieg- oder Niederlage-Bedingung erfüllt ist.

    Viel Erfolg beim weiteren Skripten und vielleicht bis zur nächsten Fragestellung

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •