# Problem mit 4 gewinnt(MinMax Algorithmus)



## Soper (14. Dez 2013)

Hallo,

Ich habe für die Schule das Spiel 4 gewinnt mit Hilfe des MinMax Algorithmus programmiert. 
Nur leider funktioniert mein Algorithmus nicht und ich komme einfach nicht weiter...

Es scheint als würde sich meine kI in einer Endlosschleife befinden.
Es wäre wirklich toll, wenn mir hier jemand bei meinem Problem helfen könnte und mir sagen könnte welche Fehler ich gemacht habe.

Hier ist der Code meines Algorithmus:

```
public  void minmax()
            {
                erstelleMatrix();
                 z=-1;
                 int gewuenschteTiefe = 2;
                 int bewertung = max(2, gewuenschteTiefe);
                 if (z == -1)
                 System.out.println("Fehler");
                 else 
                 getWorld().addObject(new Computer(),bewertung,1);
                
            } 
        
            int max(int spieler, int tiefe) {
      
          if (tiefe == 0 || keineZuegeMehr())
        return bewerten();
        int maxWert = -1000000;
       
    
            for(int x = 0; x <= 6; x++){
                for(int y=5; y>=0; y--)
                    {if(Spielbrett.board[x][y]==0)
                        {
                    Zug zug=new Zug(spieler,x,y);
                    Spielbrett.board[zug.getx()][zug.gety()]=spieler;
            
                
                    int wert = min(1 , tiefe-1);
                    Spielbrett.board[zug.getx()][zug.gety()]=0;
                if (wert > maxWert) {
                    maxWert = wert;
                    if (tiefe==0)
                    z= zug.getx();
                    }
                }
                
                } 
            }
  
     return z;
   }
 
   int min(int spieler, int tiefe) {
     if (tiefe == 0 || keineZuegeMehr())
       return bewerten();
       int minWert = 1000000;
      
        
            
   
      for(int x = 0; x <= 6; x++){
          {for(int y=5; y>=0; y--)
                    {if(Spielbrett.board[x][y]==0)
                         {
                        Zug zug=new Zug(spieler,x,y);
                        Spielbrett.board[zug.getx()][zug.gety()]=spieler;
            
                        int wert = max(2 , tiefe-1);
                        Spielbrett.board[zug.getx()][zug.gety()]=0;
      
                if (wert < minWert) {
                minWert = wert;
     
            }
           
                }
            }
        }
      }
        
    
    return minWert;
   }
```


Falls nötig kann ich auch mein ganzes Greenfootprojekt hochladen.


----------



## eMmiE (15. Dez 2013)

Wie soll der Algorithmus denn arbeiten?
Beschreibe es mal in eigenen Worten, bitte.

Gruß eMmiE


----------



## Soper (15. Dez 2013)

Erst einmal danke für die Antwort.

Also der Algorithmus soll alle verschiedenen Möglichkeiten bis zu einer bestimmten Tiefe durchgehen.  Dabei wird abwechselnd in Zug des Computers und des Spielers simuliert. Wenn die vorgegebene Tiefe erreicht wird, wird die aktuelle Spielsituation bewertet und es wird verglichen ob dieser Wert, der sich dadurch ergibt, kleiner als der bisherige MinWert(das ist der Wert für die Gewinnchance des Gegners, der möglichst gering sein soll) oder größer als der bisherige MaxWert( Gewinnchance des Computers -> möglichst hoch) ist. Der Zug mit den größten MaxWert wird jeweils gespeichert und wenn die alle Möglichkeiten bis zu der gegebenen Tiefe durchgangen worden sind wird der gespeicherte Zug ausgeführt.

Edit:
Hier ist der Allgemeine Code:

Hauptprogramm (Auszug):
[Java] gespeicherterZug = NULL;
 int gewuenschteTiefe = 4;
 int bewertung = max(+1, gewuenschteTiefe);
 if (gespeicherterZug == NULL)
    es gab keine weiteren Zuege mehr;
 else
    gespeicherterZug ausführen;

 int max(int spieler, int tiefe) {
    if (tiefe == 0 or keineZuegeMehr(spieler))
       return bewerten();
    int maxWert = -unendlich;
    generiereMoeglicheZuege(spieler);
    while (noch Zug da) {
       fuehreNaechstenZugAus();
       int wert = min(-spieler, tiefe-1);
       macheZugRueckgaengig();
       if (wert > maxWert) {
          maxWert = wert;
          if (tiefe == anfangstiefe)
             gespeicherterZug = Zug;
       }
    }
    return maxWert;
 }

 int min(int spieler, int tiefe) {
    if (tiefe == 0 or keineZuegeMehr(spieler))
       return bewerten();
    int minWert = unendlich;
    generiereMoeglicheZuege(spieler);
    while (noch Zug da) {
       fuehreNaechstenZugAus();
       int wert = max(-spieler, tiefe-1);
       macheZugRueckgaengig();
       if (wert < minWert) {
          minWert = wert;
       }
    }
    return minWert;
 }

[/code]


----------

