# 4 gewinnt KI Spieler gegen Computer



## cr3m4 (26. Mai 2009)

Hallo zusammen,

4Gewinnt-Beispiele gibts ja schon genug und funktioniert soweit auch bei mir, allerdings soll bei meinem Programm der Computer als Gegenspieler her halten. Dazu muss es ja dann die Methoden geben die Spielzüge des Humanplayers verhindern und prüft ob 3Steine des KI schon nebeneinander liegen.


Habe momentan dazu noch keine richtigen Ansätze, bzw ich verlauf mich da recht schnell in der Logik.

Hier auch mal die Grundsätzlichen Methoden der Abprüfung nach Horizontal, vertikal und Diagonal:


```
//Vertikaler Check nach 4 gleichen nebeneinander
public boolean checkVertikal(int x, int y) 
	   {
		   int hasFour=0;
		   boolean win=false;
		   
           for (int i = 0; i < anzX; i++)
           {
        	   if (fButton[i][y].getChar() == fButton[x][y].getChar())
               {
        		   hasFour++;
                       System.out.println("Horizontal: "+hasFour);
               }
               else
            	   hasFour = 0;
        	   
        	   if(hasFour==4)
            	   win=true;
           }
           return win;
	}

//horizontaler Check nach 4 gleichen nebeneinander
	      public boolean checkHorizontal(int x, int y)
	      {
              int hasFour = 0;
              boolean win=false;
              
              for (int i = 0; i < anzY; i++) 
              {
                      if (fButton[x][i].getChar() == fButton[x][y].getChar())
                      {
                    	  hasFour++;
                              System.out.println("Horizontal: "+hasFour);
                      }
                      else
                    	  hasFour = 0;
                      
                      if(hasFour==4)
                    	  win = true;
              }
              return win;
	      }

//Diagonaler Check nach Rechts unten auf 4 gleiche nebeneinander
	      public boolean checkDiagRU(int x, int y)
	      {
              char playerSymbol = fButton[x][y].getChar();
              int i = x;
              int j = y;
              int hasFour = 0;
              boolean win=false;
              while ((i > 0) && (j > 0)) 
              {
                      i--;
                      j--;
              }
              while ((i <= anzX-1) && (j <= anzY-1)) 
              {
                      if (fButton[i][j].getChar() == playerSymbol)
                      {
                    	  hasFour++;
                              System.out.println("DiagonalRU: "+hasFour);

                      }
                      else
                    	  hasFour = 0;
                      
                      i++;
                      j++;

                      if(hasFour==4)
                        	win = true;
              }
              return win;
      }
	      
//Diagonaler Check nach Links unten auf 4 gleiche nebeneinander
	      public boolean checkDiagLU(int x, int y)
	      {
              char playerSymbol = fButton[x][y].getChar();
              int i = x;
              int j = y;
              int hasFour = 0;
              boolean win=false;
              while ((i >0) && (j < anzY-1)) 
              {
                      i--;
                      j++;
              }
              while ((i <= anzX-1) && (j >= 0)) 
              {
                      if (fButton[i][j].getChar() == playerSymbol)
                      {
                    	  hasFour++;
                              System.out.println("DiagonalLU: "+hasFour);
                      }
                      else
                    	  hasFour = 0;
                      i++;
                      j--;
                      
                      if(hasFour==4)
                      	win= true;
              }
              
              return win;
         
      }

//Prüfung ob eine der Prüfungsmethoden Gewonnen zurückliefert.
	      public boolean hasWon(int x, int y) 
	      {
    	          if(  ( checkHorizontal(x, y) || checkVertikal(x, y) || checkDiagRU (x, y) || checkDiagLU (x, y) )) 
	    		  return true;
	    	  else
	    		  return false;
              }
```

Vielleicht habt ihr ja nen guten Ansatz.

tnx


----------



## Marco13 (30. Mai 2009)

Der "gute Ansatz" wurde schon vor ... zug Jahren entwickelt, und nennt sich Alpha-beta pruning - Wikipedia, the free encyclopedia, als Erweiterung/Verbesserung von Minimax - Wikipedia, the free encyclopedia

Bisher klingt es, als wolltest du nur versuchen, die KI so spielen zu lassen, dass sie 3 in einer Reihe erkennt, und dann zu verhindern versucht, dass der Spieler 4 daraus macht. Das wäre aber ziemlich dumm. Um eine gute KI zu schreiben brauchst du bei so einem einfachen Spiel nicht viel mehr als:


Eine Methode, um einen Zug "x" zu machen (d.h. einen Stein in die x-te Spalte zu werfend)
Eine Methode, um einen Zug "x" rückgängig zu machen
Eine Methode, die das Spielbrett bewertet.
Die Bewertung könnte dabei recht einfach sein. Als erster Ansatz reicht schon:
- Die Bewertung ist -1 wenn Weiß 4 in einer Reihe hat
- Die Bewertung ist +1 wenn Schwarz 4 in einer Reihe hat

Damit kannst du oben verlinkte Algorithmen implementieren. Fang' ggf. mit dem Minimax an, der ist viel, viel einfacher, und dürfte schon eine "ganz gute" KI liefern.


----------

