Zweidim. Array richtig auswerten



  • Hallo, ich bin dabei mir ein Spiel zu programmieren (4Gewinnt)
    Nur leider hängt es noch bei der Auswertung des Gewinners.
    Muss die Matrix auswerten nach 4 gleichen Char-Zeichen.

    4x Senkrecht habe ich soweit gelöst.

    Nur bei waagerecht und diagonal habe ich keine Ideen mehr, wie man dies geschickt lösen könnte.

    Tipps sind erwünscht.



  • Klingt bei 4gewinnt vielleicht übertrieben, aber ich würds rekursiv lösen. Du gehst jeden Stein vom Spielfeld durch und probierst rekursiv jede Richtung aus. Wenn du ein gleiches Feld findest machst du in der Richtung weiter. Ansonsten brichst du diese Richtung ab und versuchst die Nächste usw.



  • probiers einmal so

    int merkeSteine1 = 0;
    int merkeSteine2 = 0;
    
    for (int y=0; y<ZEILE; y++)
    {
       for (int x=0; x<SPALTE; x++)
       {
         if(spielfeld[x][y] == '*')
         {
            merkeSteine1 ++;
            merkeSteine2 = 0;
         }
    
         if(spielfeld[x][y] == '0')
         {
            merkeSteine2 ++;
            merkeSteine1 = 0;
         }
    
         if (merkeSteine1 == 4 || merkeSteine2 ==4) {break}
        }
    }
    

    so hast du alle Steine schon einmal waagerecht sotiert. Für die senkrechten musst du einfach nur die X und Y Richtung vertauschen.

    Bei den Diagonalen wird es ein wenig schwerer. Da brauchst du 4 for Schleifen ineineander. Aber das Prinzip ist das gleiche. Du musst dir einfach nur eine Position im Feld anschauen und dann mit (x+1) und (y+1) bzw. (x-1) und (y+1) dir die Werte der Diagonalen anschauen und überprüfen welcher Stein darin liegt.

    Mehr dazu in meiner näcsten Pause oder heute Abend. Aber vielleicht kommst du auch so damit schon klar.



  • DarthZiu schrieb:

    Klingt bei 4gewinnt vielleicht übertrieben, aber ich würds rekursiv lösen. Du gehst jeden Stein vom Spielfeld durch und probierst rekursiv jede Richtung aus. Wenn du ein gleiches Feld findest machst du in der Richtung weiter. Ansonsten brichst du diese Richtung ab und versuchst die Nächste usw.

    Hört sich interessant an, wie würde sowas aussehn?



  • Achtung! NICHT getestet, nur kompiliert.

    Feld Farbe nicht initialisiert.

    #define AnzReihen   20
    #define AnzSpalten  20
    
    const int BenoetigteAnz = 4 ;
    
    const int Leer  = 0 ;
    const int Rot   = 1 ;
    const int Blau  = 2 ;
    
    int Farbe[AnzReihen][AnzSpalten] ;
    
    int AnzNachbarnGleicherFarbe( int CurrentX
                                , int CurrentY
                                , int OffsetX
                                , int OffsetY
                                , int BisherigeAnzNachbarn )
    {
       if( ( 0 <= CurrentX + OffsetX    &&   CurrentX + OffsetX < AnzSpalten  )
         &&( 0 <= CurrentY + OffsetY    &&   CurrentY + OffsetY < AnzReihen  ) )
       {
    
          if(    Farbe[CurrentX + OffsetX][CurrentY + OffsetY]
              == Farbe[CurrentX][CurrentY]  )
          {
    
             BisherigeAnzNachbarn++ ;
    
             if( BisherigeAnzNachbarn < BenoetigteAnz )
             {
                // Noch nicht genug. =>  Nächster Nachbar
    
                BisherigeAnzNachbarn
                   = AnzNachbarnGleicherFarbe( CurrentX + OffsetX
                                             , CurrentY + OffsetY
                                             , OffsetX
                                             , OffsetY
                                             , BisherigeAnzNachbarn ) ;
             }
             // else :  Genug in einer Reihe.  => Abbruch
          }
          // else :  Nachbar hat eine andere Farbe.  => Abbruch
       }
       // else :   Nachbarplatz nicht mehr auf dem Spielfeld. => Abbruch
    
       return BisherigeAnzNachbarn ;
    }
    //---------------------------------------------------------------------------
    int main(void)
    {
       int SiegerGefunden = 0 ;
    
       int x = 0 ;
       int y = 0 ;
       int Offset_x = 0 ;
       int Offset_y = 0 ;
    
       for( x = 0
          ; x < AnzSpalten && SiegerGefunden == 0
          ; x++ )
       {
          for( y = 0
             ; y < AnzReihen && SiegerGefunden == 0
             ; y++ )
          {
             if( Farbe[x][y] != Leer )
             {
    
                for( Offset_x = -1
                   ; Offset_x <= 1  && SiegerGefunden == 0
                   ; Offset_x++ )
                {
                   for( Offset_y = -1
                      ; Offset_y <= 1  && SiegerGefunden == 0
                      ; Offset_y++ )
                   {
    
                      if(   !(Offset_x == 0 && Offset_y == 0 ) // um nicht das
                                                               // aktuelle Feld
                                                               // zu testen
                         && AnzNachbarnGleicherFarbe( x
                                                    , y
                                                    , Offset_x
                                                    , Offset_y
                                                    , 1 )
                          >= BenoetigteAnz )
                      {
                         SiegerGefunden = 1 ;
    
                         // Siegerfarbe ist Farbe[x][y] .
                      }
    
                   }  // for( Offset_y
    
                }  // for( Offset_x
    
             }  // else :  Kein Stein. => Keine Prüfung.
    
          }  //for( int y = 0
    
       }  //for( int x = 0
    
       return 0 ;
    }
    


  • Danke für die ganzen Antworten.
    Senkrechte und Waagerechte habe ich nun gelöst.
    Nur mit der Diagonale tue ich mir noch recht schwer.
    Habe das mit den 4 Schleifen noch nicht hinbekommen.
    Bekomme immer "Speicherzugriffsfehler"

    @DarthZiu: Könntest du mir evtl ein Beispiel mit der Rekursion posten?



  • gravis schrieb:

    @DarthZiu: Könntest du mir evtl ein Beispiel mit der Rekursion posten?

    Ist Dir mein Beispiel nicht rekursiv genug? 😞



  • Sorry, aber das kann ich dir jetzt nicht einfach so aus dem Stehgreif hinplotten, weil Rekursion ziemlich komplex ist.




Anmelden zum Antworten