3D TicTacToe - Unentschieden

P83x

Mitglied
Hallo!
Ich bin wieder bei einer Aufgabe hängen geblieben^^
Habe ich keine Ahnung wie ich Java klar machen soll, dass wenn alle felder besetzt sind, er ein unentschieden ausgeben soll. Ich könnte natürlich
if(x[0][0][0]*x[1][0][0]... != 0){

system.out.println("Unentschieden")
}

machen, doch finde ich diese Variante nicht schön. Ich habe auch versucht diese Regel durch 6 Schleifen zu erfüllen, doch das ist auch fehlerhaft.

P.s. Wenn ihr sonstige Fehler, Tipps wie man etwas übersichtlicher gestalten kann oder Tipps wie man etwas einfacher gestalten kann habt, dann her damit! :)

Java:
/**
  *
  * Beschreibung
  *
  * @version 1.0 vom 11.05.2011
  * @author
  */

public class TicTacToe_3D {

  public static void main(String[] args) {
    int repeat = 0, drei = 0, fünf = 0, switch1 = 0, x = 0, b = 0, z = 0, spielerwahl = 1;
    int[][][]TTT= new int[3][3][3];
    
    System.out.println("Spieler 1 hat die Zahl 3");
    System.out.println("Spieler 2 hat die Zahl 5");
    System.out.println();

    for(int l=0; l < TTT.length; l++){

        for(int n=0; n < TTT.length; n++){

                       for(int i=0; i < TTT.length; i++){
                           System.out.print(TTT[i][n][l]+" ");
                       }
         System.out.print("   ");
        }
     System.out.println(" ");

    }
    System.out.println();

    while(repeat < 27){


                              if(spielerwahl == 1){
                                 System.out.println("Spieler 1 ist an der Reihe");
                                    switch1 = 1;
                                    spielerwahl = 2;
                              }

                              else{
                                 System.out.println("Spieler 2 ist an der Reihe");
                                    switch1 = 2;
                                    spielerwahl = 1;
                              }

                              switch (switch1){
                                     case 1:

                                          System.out.println("Geben Sie die Position wo Sie ihr Zeichen hinmachen wollen an.");
                                          System.out.print("X-Achse: ");  x = Input.readInt();
                                          System.out.print("Dimension: ");b = Input.readInt();
                                          System.out.print("Y-Achse: ");  z = Input.readInt();
                                          System.out.println();

                                          if( TTT[x][b][z] == 0){

                                          TTT[x][b][z] = 3;
                                          }
                                          else do{

                                            System.out.println("Das Feld ist schon belegt, probieren Sie es noch einmal!");
                                            System.out.print("X-Achse: ");  x = Input.readInt();
                                            System.out.print("Dimension: ");b = Input.readInt();
                                            System.out.print("Y-Achse: ");  z = Input.readInt();
                                            System.out.println();


                                          }while( TTT[x][b][z] != 0);

                                          TTT[x][b][z] = 3;

                                     break;

                                     case 2:
                                          System.out.println("Geben Sie die Position wo Sie ihr Zeichen hinmachen wollen an.");
                                          System.out.print("X-Achse: ");  x = Input.readInt();
                                          System.out.print("Dimension: ");b = Input.readInt();
                                          System.out.print("Y-Achse: ");  z = Input.readInt();
                                          System.out.println();

                                          if( TTT[x][b][z] == 0){

                                          TTT[x][b][z] = 5;
                                          }
                                          else do{

                                            System.out.println("Das Feld ist schon belegt, probieren Sie es noch einmal!");
                                            System.out.print("X-Achse: ");  x = Input.readInt();
                                            System.out.print("Dimension: ");b = Input.readInt();
                                            System.out.print("Y-Achse: ");  z = Input.readInt();
                                            System.out.println();


                                          }while( TTT[x][b][z] != 0);

                                          TTT[x][b][z] = 5;
                                     break;

                              }

                              for(int l=0; l < TTT.length; l++){

                                      for(int n=0; n < TTT.length; n++){

                                               for(int i=0; i < TTT.length; i++){
                                                 System.out.print(TTT[i][n][l]+" ");
                                               }
                                        System.out.print("   ");
                                      }
                                  System.out.println(" ");

                              }
                              System.out.println();

                 repeat++;

                 
                 
                 

                 
                 
       //---------------------------------------------REGEL Diagonal 2D-------------------------------------
       for(int i = 0; i < TTT.length; i++){
         for(int l = 0; l == 0; l++){
           if((TTT[l][i][l])+(TTT[l+1][i][l+1])+(TTT[l+2][i][l+2]) == 9){
             System.out.println("Spieler 1 hat mit einer 2D Diagonalen gewonnen!");
             repeat = 27;
           }

           if((TTT[l][i][l])+(TTT[l+1][i][l+1])+(TTT[l+2][i][l+2]) == 15){
             System.out.println("Spieler 2 hat mit einer 2D Diagonalen gewonnen!");
             repeat = 27;
           }
         }
       }

       for(int i = 0; i < TTT.length; i++){
         for(int l = 0; l == 0; l++){
           if((TTT[l+2][i][l])+(TTT[l+1][i][l+1])+(TTT[l][i][l+2]) == 9){
             System.out.println("Spieler 1 hat mit einer 2D Diagonalen gewonnen!");
             repeat = 27;
           }

           if((TTT[l+2][i][l])+(TTT[l+1][i][l+1])+(TTT[l][i][l+2]) == 15){
             System.out.println("Spieler 2 hat mit einer 2D Diagonalen gewonnen!");
             repeat = 27;
           }
         }
       }



       //---------------------------------------------REGEL Diagonal 3D-------------------------------------

       for(int i = 0; i == 0; i++){

           if((TTT[i][i][i])+(TTT[i+1][i+1][i+1])+(TTT[i+2][i+2][i+2]) == 9){
             System.out.println("Spieler 1 hat mit einer 3D Diagonalen gewonnen!");
             repeat = 27;
           }

           if((TTT[i][i][i])+(TTT[i+1][i+1][i+1])+(TTT[i+2][i+2][i+2]) == 15){
             System.out.println("Spieler 2 hat mit einer 3D Diagonalen gewonnen!");
             repeat = 27;
           }

       }

       for(int i = 0; i == 0; i++){

           if((TTT[i+2][i+2][i])+(TTT[i+1][i+1][i+1])+(TTT[i][i][i+2]) == 9){
             System.out.println("Spieler 1 hat mit einer 3D Diagonalen gewonnen!");
             repeat = 27;
           }

           if((TTT[i+2][i+2][i])+(TTT[i+1][i+1][i+1])+(TTT[i][i][i+2]) == 15){
             System.out.println("Spieler 2 hat mit einer 3D Diagonalen gewonnen!");
             repeat = 27;
           }

       }
       
       //---------------------------------------------REGEL Horizontal 2D-------------------------------------

       for(int i = 0; i < TTT.length; i++){
         for(int l=0; l < TTT.length; l++){
           for(int u=0; u == 0; u++){

             if((TTT[u][i][l])+(TTT[u+1][i][l])+(TTT[u+2][i][l]) == 9){
              System.out.println("Spieler 1 hat mit einer 2D Horizontalen gewonnen!");
              repeat = 27;
             }

             if((TTT[u][i][l])+(TTT[u+1][i][l])+(TTT[u+2][i][l]) == 15){
              System.out.println("Spieler 2 hat mit einer 2D Horizontalen gewonnen!");
              repeat = 27;
             }

           }

         }
       }
       
       //---------------------------------------------REGEL Horizontal 3D-------------------------------------

       for(int i = 0; i == 0; i++){
         for(int l=0; l < TTT.length; l++){
           for(int u=0; u < TTT.length; u++){

             if((TTT[u][i][l])+(TTT[u][i+1][l])+(TTT[u][i+2][l]) == 9){
              System.out.println("Spieler 1 hat mit einer 3D Horizontalen gewonnen!");
              repeat = 27;
             }

             if((TTT[u][i][l])+(TTT[u][i+1][l])+(TTT[u][i+2][l]) == 15){
              System.out.println("Spieler 2 hat mit einer 3D Horizontalen gewonnen!");
              repeat = 27;
             }

           }

         }
       }


       //---------------------------------------------REGEL Vertikal 2D-------------------------------------

       for(int i = 0; i < TTT.length; i++){
         for(int l=0; l < TTT.length; l++){
           for(int u=0; u == 0; u++){

             if((TTT[l][i][u])+(TTT[l][i][u+1])+(TTT[l][i][u+2]) == 9){
              System.out.println("Spieler 1 hat mit einer 2D Vertikalen gewonnen!");
              repeat = 27;
             }

             if((TTT[l][i][u])+(TTT[l][i][u+1])+(TTT[l][i][u+2]) == 15){
              System.out.println("Spieler 2 hat mit einer 2D Vertikalen gewonnen!");
              repeat = 27;
             }

           }

         }
       }
       

       //---------------------------------------------REGEL Vertikal 3D-------------------------------------

       for(int i = 0; i == 0; i++){
         for(int l=0; l < TTT.length; l++){
           for(int u=0; u == 0; u++){

             if((TTT[l][i][u])+(TTT[l][i+1][u+1])+(TTT[l][i+2][u+2]) == 9){
              System.out.println("Spieler 1 hat mit einer 3D Vertikalen gewonnen!");
              repeat = 27;
             }

             if((TTT[u][i][l])+(TTT[u][i+1][l])+(TTT[u][i+2][l]) == 15){
              System.out.println("Spieler 2 hat mit einer 3D Vertikalen gewonnen!");
              repeat = 27;
             }

           }

         }
       }
       
       //---------------------------------------------REGEL Unentschieden-------------------------------------

       for(int i = 0; i < TTT.length; i++){
         for(int l=0; l < TTT.length; l++){
           for(int u=0; u == 0; u++){

             if((TTT[u][i][l])*(TTT[u+1][i][l])*(TTT[u+2][i][l]) != 0){

                for(int j=0; j < TTT.length; j++){
                  for(int n=0; n < TTT.length; n++){
                    for(int m=0; m == 0; m++){

                      if((TTT[n][j][m])*(TTT[n][j][m+1])*(TTT[n][j][m+2]) != 0){
                        System.out.println("Unentschieden!");
                      }

                    }
                  }
                }



             }

           }

         }
       }












    }







  }
}
 

P83x

Mitglied
das hab ich mir auch zuerst gedacht, doch es könnte trotzdem die möglichkeit bestehen das beim 3x3x3. versuch gewonnen wird^^ Dann würde "Spieler 1 hat gewonnen." und "Unentschieden!" erscheinen. Oder besteht die möglichkeit, die schleife vorzeitig zu unterbrechen?? Also die Repeat schleife?
 

Michael...

Top Contributor
Ich habe mir den Code nicht angeschaut, aber Du kannst ja nach dem letzten Zug prüfen, ob jemand gewonnen hat und wenn nicht gibt's Du unentschieden aus.
Du musst Dir ja nur in einem boolean merken, ob jemand gewonnen hat oder nicht.
 

XHelp

Top Contributor
dann prüf es eben bei 3x3x3+1. Zug am Anfang :bahnhof:
Ansonsten wenn du prüfen willst, ob in dem Array noch 0en sind, dann kannst du:
Java:
public static boolean istVoll(int[][][] array) {
  for (int i=0;i<array.length();i++) {
    for (int j=0;j<array[i].length();j++) {
      for (int k=0;k<array[i][j].length) {
        if (array[i][j][k]==0) {
          return false;
        }
      }
    }
  }
  return true;
}
benutzen
 

Michael...

Top Contributor
Hab gerade mal den Code kurz überflogen. Wenn Du in der ersten Schleife ab Zeile 126 bereits einen Gewinner feststellst, Macht es doch gar keinen Sinn die anderen Überprüfungen auch noch zu durchlaufen.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
J Anfänger TicTacToe, Problem bei Gewinnoption, sowohl Unentschieden Java Basics - Anfänger-Themen 8
A Überprüfung für unentschieden in TicTacToe Java Basics - Anfänger-Themen 10
K TicTacToe belegtes feld nicht neu besetzbar Java Basics - Anfänger-Themen 1
K TicTacToe belegtes Feld nicht neu besetzbar Java Basics - Anfänger-Themen 3
enesss tictactoe spiel Java Basics - Anfänger-Themen 5
Jxhnny.lpz TicTacToe Spiel vs Computer. (Probleme) Java Basics - Anfänger-Themen 7
TicTacToe Java Basics - Anfänger-Themen 6
C TicTacToe Java Basics - Anfänger-Themen 2
A Überprüfung in TicTacToe Java Basics - Anfänger-Themen 5
A TicTacToe Java Basics - Anfänger-Themen 8
tom.j85 TicTacToe - probleme beim Casten Java Basics - Anfänger-Themen 6
K Fehler beim Programmieren von TicTacToe Java Basics - Anfänger-Themen 12
J TicTacToe Java Basics - Anfänger-Themen 2
A TicTacToe funktioniert bis auf "schiefer" Sieg Java Basics - Anfänger-Themen 6
shiroX Input/Output TicTacToe-Savegame Java Basics - Anfänger-Themen 1
shiroX Methoden Mögliche Spielstände bei TicTacToe Java Basics - Anfänger-Themen 14
M Array und Objektorientierung? - TicTacToe Spiel Java Basics - Anfänger-Themen 43
P TicTacToe Problem mit Win Methode Java Basics - Anfänger-Themen 4
Z TicTacToe mit Array Java Basics - Anfänger-Themen 6
T TicTacToe Spielfeld Java Basics - Anfänger-Themen 7
B TicTacToe Java Basics - Anfänger-Themen 2
S TicTacToe Java Basics - Anfänger-Themen 4
I TicTacToe blöde KI Java Basics - Anfänger-Themen 2
I Fehler bei TicTacToe Java Basics - Anfänger-Themen 108
G TicTacToe KI Java Basics - Anfänger-Themen 15
C Problem TicTacToe Java Basics - Anfänger-Themen 6
G Tictactoe Java Basics - Anfänger-Themen 9
B TicTacToe Programmieren Java Basics - Anfänger-Themen 2
M Einfaches TicTacToe Programm Java Basics - Anfänger-Themen 19
H TicTacToe Fehler beim Compilieren Java Basics - Anfänger-Themen 7
cizzo TicTacToe Java Basics - Anfänger-Themen 6
W TicTacToe - Porblem mit dem Code.. Java Basics - Anfänger-Themen 5
H Hilfe bei TicTacToe mit jEdit Java Basics - Anfänger-Themen 7
0 TicTacToe, Problem mit den Checkbox-Aktionen Java Basics - Anfänger-Themen 6
N brauche hilfe zu tictactoe Java Basics - Anfänger-Themen 2
kulturfenster Problem bei TicTacToe Java Basics - Anfänger-Themen 11
P Ein einfaches Spiel: TicTacToe. Fehler und Vorschläge Java Basics - Anfänger-Themen 3
H TicTacToe: Zeit zwischen Zügen lassen Java Basics - Anfänger-Themen 9
M TicTacToe Java Basics - Anfänger-Themen 7
H TicTacToe-geeignete Klassenhierarchie Java Basics - Anfänger-Themen 3
G Hilfe bei TicTacToe Java Basics - Anfänger-Themen 2

Ähnliche Java Themen

Neue Themen


Oben