Kleines TickTackTou

[Schrubber]

Hallo Leute.

Ich hab mal versucht, ein kleines Konsolenspiel, TickTackTou, zu schreiben.

import java.io.*;
 
public class TickTackTou
{
  public static void main(String[] args)
  throws IOException
  {
      BufferedReader in = new BufferedReader(
              new InputStreamReader(System.in));
      int spielen;
      int game = 1;
      
      while (game == 1)
      {
    //Tick-Tack-Toe 3x3 Felder
      String feld1 = "_";
      String feld2 = "_";
      String feld3 = "_";
      String feld4 = "_";
      String feld5 = "_";
      String feld6 = "_";
      String feld7 = "_";
      String feld8 = "_";
      String feld9 = "_";
      int spielingange = 1;
      
	  	System.out.println("Tic-Tack-Toe.");
	  	System.out.println("Das X ist der Computer. Das Q bist du!");
	  	System.out.println("");
	  	
	  	while (spielingange == 1)
	  	{
	  	
	  	//Felder Ausgabe
	  	System.out.print(feld1);System.out.print(" ");
	  	System.out.print(feld2);System.out.print(" ");
	  	System.out.println(feld3);
	  	System.out.print(feld4);System.out.print(" ");
	  	System.out.print(feld5);System.out.print(" ");
	  	System.out.println(feld6);
	  	System.out.print(feld7);System.out.print(" ");
	  	System.out.print(feld8);System.out.print(" ");
	  	System.out.println(feld9);
	  	//Felder Ausgabe Ende
	  		

	  	//Spielzug
	    int gegnerzug = (int) (Math.random()*9+1);
	    if (gegnerzug == 1)
	    {
	    	if (feld1 == "_")
	    	{
	    		feld1= "X";
	    	}
	    		if (gegnerzug == 2)
	    {
	    	feld2 = "X";
	    }
	    if (gegnerzug == 3)
	    {
	    	feld3 = "X";
	    }
	    if (gegnerzug == 4)
	    {
	    	feld4 = "X";
	    }
	    if (gegnerzug == 5)
	    {
	    	feld5 = "X";
	    }
	    if (gegnerzug == 6)
	    {
	    	feld6 = "X";
	    }
	    if (gegnerzug == 7)
	    {
	    	feld7 = "X";
	    }
	    if (gegnerzug == 8)
	    {
	    	feld8 = "X";
	    }
	    if (gegnerzug == 9)
	    {
	    	feld9 = "X";
	    }
	    
	  	String input = in.readLine();
	  	int meinzug = Integer.parseInt(input);
	  	
	 	
	    if (meinzug == 2)
	    {
if (feld2 != "X" && feld2 != "Q")
	    	feld2 = "Q";
	    }
	    if (meinzug == 3)
	    {
if (feld3 != "X" && feld3 != "Q")
	    	feld3 = "Q";
	    }
	    if (meinzug == 4)
	    {
if (feld4 != "X" && feld4 != "Q")
	    	feld4 = "Q";
	    }
	    if (meinzug == 5)
	    {
if (feld5 != "X" && feld5 != "Q")
	    	feld5 = "Q";
	    }
	    if (meinzug == 6)
	    {
if (feld6 != "X" && feld6 != "Q")
	    	feld6 = "Q";
	    }
	    if (meinzug == 7)
	    {
if (feld7 != "X" && feld7 != "Q")
	    	feld7 = "Q";
	    }
	    if (meinzug == 8)
	    {
if (feld8 != "X" && feld8 != "Q")
	    	feld8 = "Q";
	    }
	    if (meinzug == 9)
	    {
if (feld9 != "X" && feld9 != "Q")
	    	feld9 = "Q";
	    }
	    
	    
	    //Gewonnen/Verloren Gegner
	    if (feld1 == "X")
	    {
	    if (feld2 == "x")
	    {
	    if (feld3 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }

	    if (feld4 == "x")
	    {
	    if (feld5 == "x")
	    {
	    if (feld6 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }

	    if (feld7 == "x")
	    {
	    if (feld8 == "x")
	    {
	    if (feld9 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }

	    if (feld1 == "x")
	    {
	    if (feld4 == "x")
	    {
	    if (feld7 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }

	    if (feld2 == "x")
	    {
	    if (feld5 == "x")
	    {
	    if (feld8 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }

	    if (feld3 == "x")
	    {
	    if (feld6 == "x")
	    {
	    if (feld9 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }

	    if (feld1 == "x")
	    {
	    if (feld5 == "x")
	    {
	    if (feld9 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }

	    if (feld3 == "x")
	    {
	    if (feld5 == "x")
	    {
	    if (feld7 == "x")
	    {
	    System.out.println("Der Computer hat gewonnen");
	    }
	    }
	    }
	  	
	    //Gewonnen/Verloren Spieler
	    if (feld1 == "Q")
	    {
	    if (feld2 == "Q")
	    {
	    if (feld3 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }

	    if (feld4 == "Q")
	    {
	    if (feld5 == "Q")
	    {
	    if (feld6 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }

	    if (feld7 == "Q")
	    {
	    if (feld8 == "Q")
	    {
	    if (feld9 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }

	    if (feld1 == "Q")
	    {
	    if (feld4 == "Q")
	    {
	    if (feld7 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }

	    if (feld2 == "Q")
	    {
	    if (feld5 == "Q")
	    {
	    if (feld8 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }

	    if (feld3 == "Q")
	    {
	    if (feld6 == "Q")
	    {
	    if (feld9 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }

	    if (feld1 == "Q")
	    {
	    if (feld5 == "Q")
	    {
	    if (feld9 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }

	    if (feld3 == "Q")
	    {
	    if (feld5 == "Q")
	    {
	    if (feld7 == "Q")
	    {
	    System.out.println("Der Spieler hat gewonnen");
	    }
	    }
	    }
	  	
	  	}
      }
      }
  }
}

Das Problem daran ist, dass ich nicht weiß, wie ich das problem umgehen kann, dass der Computer die bisher vorher genommenen Felder erneut nimmt. Also wenn ich bereits mit Q drauf bin, soll ers nicht mit einem X überschreiben können. <Und ja, ich weiß, dass der Code ziemlich lang ist. Ist auch erst mein erster Versuch


Ich hoffe, ihr könnt mir helfen

 

[Gast2]

Um das ganze etwas übersichtlicher zu halten würde ich zuerst einmal eine Klasse Spielfeld erstellen. In dieser Klasse kannst du dann auch eine Abfrage einfügen ob ein Feld schon belegt wurde.

Falls du diese Abfrage jetzt direkt in dein Programm basteln willst würde ich ein 3x3 boolean-Array nehmen. Dies initialisierst du überall mit false, wenn jetzt du oder der Computer ein Feld auswählt belegst du den entsprechenden Wert mit true. Bevor du oder der Comp ein Feld nehmen möchste prüfst du einfach auf false.

//initialisieren
boolean[][] belegt = new boolean[3][3];
//so würde ich auch das Spielfeld aufbauen und nicht aus 9 einzelnen Strings ;)
[...]
//Computerzug könnte dann so aussehen:
do {
                int i = (int)Math.random()*3;
                int j = (int)Math.random()*3;
} while (belegt[x][y]);

//Feld markieren
feld[x][y] = "X";

(Code habe ich nicht getestet)
Ich würde dir aber wirklich dazu raten eine Spielfeldklasse anzulegen, kannst dir ne Menge code mit sparen :bae:

 

[Schrubber]

Gar nicht damit gerechnet, dass so früh noch jemand wach ist


Nun ja, bin noch seeeehr frischer Anfänger. Bin an Java erst 5 Tage dran. Aber ich versuchs erstmal mit der Spielfeld class. Also müsste das ca. so aussehen?

import java.io.*;
 
public class Spielfeld
{
  public static void main(String[] args)
{
//Alle Abfragen
}
}

public class TickTackToe
{
  public static void main(String[] args)
{
//Ablauf usw.
}
}

Oder hab ich da nen Denkfehler?

 

[Gast2]

Ja Denkfehler

Schonmal mit Objekt Orientierter Programmierung beschäftigt?

 

[Schrubber]

Nein Sorry :S

 

[Gast2]

Ich denke du solltest dich dann zunächst mal mit den Basics befassen.

Galileo Computing :: Java ist auch eine Insel (8. Auflage)
Da steht eine ganze Menge drin, könntest du dir mal anschauen.
Ich kann dir morgen auch mal nen Quellcode zu deinem TicTacToe reinstellen wenn du magst (als kleines Beispiel).

 

[Schrubber]

Das wäre schön Ich werd mich dann mal in die Basics einlesen. ^^

 

[darkeye2]

erstmal, darfst du nur eine main klasse haben!! (diese sollne nach möglichkeit auch nur andere klassen aufrufen und nicht gleich das ganze zeug beinhalten, würde etwa so aussehen:

class Spielfeld{
//dein spielfeld am besten auch noch mit methoden zum eintragen der jeweiligen x und o 
//und abgleich ob feld  besetzt ist
}

und dann erine andere klasse, etwa so:

class TickTackTou{
TickTachTou() {
Spielfeld sp = new Spielfeld()
//der code für dein spiel
}
public static void main(String[] args)
{
new TickTackTou();
}

}

Und ohne, dass ich jetzt viel drüber nachgedacht habe, würde ich dir raten bei der abfrage, ob jemand gewonnen hat eine if abfrage mit OR zu nutzen, also etwa so:

boolean isWinner(String who){
boolean won = false;
If(feld[0][0] = who AND feld[0][1] = who AND feld[0][2] = who OR feld[1][0] = who 
AND feld[1][1] = who AND feld[1][2] = who OR feld[2][0] = who AND feld[2][1] = who
 AND feld[2][2] = who OR feld[0][0] = who AND feld[1][0] = who AND feld[2][0] = who
 OR feld[0][1] = who AND feld[1][1] = who AND feld[2][1] = who OR feld[0][2] = who 
AND feld[1][2] = who AND feld[2[2] = who  OR feld[0][0] = who AND feld[1][1] = who
 AND feld[2][2] = who OR feld[0][2] = who AND feld[1][1] = who AND feld[2][0] = who)
{won = true;}
return(won);
}

 

[Landei]

Weil heute Sonntag ist, gibts das Spielfeld gratis:

public class Spielfeld {

    private char[] feld = {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '};

    public boolean istBesetzt(int index) {
        return feld[index] != ' ';
    }

    public char inhalt(int index) {
        return feld[index];
    }

    public void setze(int index, boolean einX) {
        if (istBesetzt(index)) {
            throw new IllegalArgumentException("Feld " + index + " ist bereits belegt");
        }
        feld[index] = einX ? 'X' : 'O';
    }

    public boolean hatGewonnen(boolean mitX) {
        char testChar = mitX ? 'X' : 'O';
        //Zeilen testen
        for (int zeile = 0; zeile < 3; zeile++) {
          if (feld[3*zeile]== testChar && feld[3*zeile+1] == testChar && feld[3*zeile+2] == testChar) {
             return true;
          }
        }
        //Spalten testen
        for (int spalte = 0; spalte < 3; spalte++) {
          if (feld[spalte]== testChar && feld[spalte+3] == testChar && feld[spalte+6] == testChar) {
             return true;
          }
        }
        //Diagonalen testen
        if (feld[0]== testChar && feld[4] == testChar && feld[8] == testChar) {
            return true;
        }
        if (feld[2]== testChar && feld[4] == testChar && feld[6] == testChar) {
            return true;
        }
        return false;
    }
    
    @Override
    public String toString() {
        return "" + feld[0] + feld[1] + feld[2] + '\n' + 
                    feld[3] + feld[4] + feld[5] + '\n' +
                    feld[6] + feld[7] + feld[8] + '\n';
    }
}

 

[Marco13]

...

[...]
//Computerzug könnte dann so aussehen:
do {
                int i = (int)Math.random()*3;
                int j = (int)Math.random()*3;
} while (belegt[x][y]);

Sowas geht in der Praxis, ist aber "theoretisch" ganz ungünstig. Wie oft wird die Schleife durchlaufen? 10 mal? 100000 mal? [c]ackermann(graham, graham)[/c] mal? Es ist nicht sichergestellt, dass die Schleife irgendwann endet.

Für solche Fälle ist es günstiger, sowas zu machen wie (pseudocode!!!) :

Position freiePositionen[] = findeFreiePositionen();
if (freiePositionen.length==0) return null;
return freiePositionen[randomIndex];

Dieses [c]freiePositionen[] = findeFreiePositionen()[/c] braucht man auch spätestens, wenn man eine einfache MinMax- oder AlphaBeta-KI schreiben will.

 

[Gast2]

Hi,
hier noch der Versprochene Quellcode.
Wenn du das komplett verstanden hast biste auf nem guten weg

package tictactoe;

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        TicTacToe ttt = new TicTacToe(3);

        char player1 = ttt.PLAYER1;
        char player2 = ttt.PLAYER2;

        int[] move;

        while (!ttt.isGameOver()) {
            if (ttt.getWhosTurn() == player1) {
                /* Spieler 1 ist dran
                 * Konsole lesen wenn man selbst spielen möchte */
                move = ttt.doAITurn();
                System.out.println("Spieler 1 wählt (" + move[0] + ", " + move[1] + ")");
            } else if (ttt.getWhosTurn() == player2) {
                /* Spieler 2 ist dran */
                move = ttt.doAITurn();
                System.out.println("Spieler 2 wählt (" + move[0] + ", " + move[1] + ")");
            }

            /* Spielfeld ausgeben */
            System.out.println(ttt+"\n");
        }
        
        /* Spiel vorbei */
        System.out.println("Game Over, Gewinner ist: " + ttt.getWinner());

    }

}

package tictactoe;

import java.util.Random;

public class TicTacToe {
    private int size;
    private static final int DEFAULT_SIZE = 3;

    private char[][] feld;
    private boolean[][] belegt;

    public static final char PLAYER1 = 'X';
    public static final char PLAYER2 = 'O';
    private static final char EMPTY = '_';

    private char whosTurn;
    private int fieldsFree;

    private Random rand = new Random();

    public TicTacToe() {
        init(DEFAULT_SIZE);
    }

    public TicTacToe(int size) {
        init(size);
    }

    private void init(int size) {
        this.size = size;

        feld = new char[size][size];
        belegt = new boolean[size][size];

        //belebt mit false vorbelegen
        //feld mit "_" vorbelegen
        for (int i=0; i < size; i++)
            for (int j=0; j < size; j++) {
                belegt[i][j] = false;
                feld[i][j] = ' ';
            }

        whosTurn = PLAYER1;
        
        fieldsFree = size*size;
    }

    public char getWhosTurn() {
        return whosTurn;
    }

    public boolean isBelegt(int i, int j) {
        return belegt[i][j];
    }

    public int getFieldsFreeCount() {
        return fieldsFree;
    }

    public boolean setMarker(int row, int col, char player) {
        if (whosTurn != player || isBelegt(row, col) || row >= size || col >= size) return false;

        //Variablen setzen
        feld[row][col] = player;
        belegt[row][col] = true;
        fieldsFree--;

        //Playerwechsel
        if (whosTurn == PLAYER1) whosTurn = PLAYER2;
        else whosTurn = PLAYER1;
        
        return true;
    }

    public char getWinner() {
        String line;

        //Reihen prüfen
        for (int i = 0; i < size; i++){
            line = "";
            for (int j = 0; j < size; j++) {
                line += (feld[i][j] == ' ' ? "" : feld[i][j]);;
            }
            // Prüfen ob gewonnen
            if (checkLine(line) != ' ') return checkLine(line);
        }

        //Zeilen prüfen
        for (int j = 0; j < size; j++){
            line = "";
            for (int i = 0; i < size; i++) {
                line += (feld[i][j] == ' ' ? "" : feld[i][j]);
            }
            // Prüfen ob gewonnen
            if (checkLine(line) != ' ') return checkLine(line);
        }

        //Diagonalen Prüfen
        /* Oben links -> unten rechts */
        line = "";
        for (int i = 0; i < size; i++) {
            line += feld[i][i];
        }
        // Prüfen ob gewonnen
        if (checkLine(line) != ' ') return checkLine(line);

        /* Oben rechts -> unten links */
        line = "";
        for (int i = 0; i < size; i++) {
            line += (feld[size-i-1][i] == ' ' ? "" : feld[size-i-1][i]);
        }
        // Prüfen ob gewonnen
        if (checkLine(line) != ' ') return checkLine(line);

        //Kein Gewinner
        return ' ';
    }

    public boolean isGameOver() {
        /* Spiel ist zuende wenn keine Felder mehr frei sind oder ein Spieler gewonnen hat */
        return (fieldsFree == 0 || getWinner() != ' ');
    }

    private char checkLine(String line) {
        // Zeile auf Gewinner prüfen
        int len_p1 = line.replaceAll("[^" + PLAYER1 + "]","").length();
        int len_p2 = line.replaceAll("[^" + PLAYER2 + "]","").length();

        if (len_p1 == size) return PLAYER1;
        else if (len_p2 == size) return PLAYER2;

        //Kein Gewinner
        return ' ';
    }


    public int[] doAITurn() {
        /* Zufälliges Feld wählen
         * Hier könnte man ein wenig Intelligenz reinbasteln:
         * - Feld wählen damit Computer gewinnt
         * - Sieg des Gegenspielers verhindern
         * - etc. */

        int i;
        int j;
        do {
            i = (int)(Math.random()*size);
            j = (int)(Math.random()*size);
        } while (isBelegt(i,j) && fieldsFree > 0);

        int[] move = {i, j};

        // Zug durchführen
        setMarker(i, j, whosTurn);

        return move;
    }

    @Override
    public String toString() {
        String result = "";

        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                result += (feld[i][j] != ' ' ? feld[i][j] : EMPTY) + " ";
            }
            result += "\n";
        }

        return result;
    }
}

Sowas geht in der Praxis, ist aber "theoretisch" ganz ungünstig. Wie oft wird die Schleife durchlaufen? 10 mal? 100000 mal? ackermann(graham, graham) mal? Es ist nicht sichergestellt, dass die Schleife irgendwann endet.

Das das nicht optimal ist ist mir klar War auch schon 4Uhr nachts :bae: Sollte halt nur die Grundlegende Idee klar machen... Suche solange bis du nen freies Feld hast.
Deine Lösung ist auf jedenfall besser, vor allem wenn man noch ein wenig AI reinproggen will.