Tictactoe

[Godzilla]

Hallo an alle!
Ich hoffe ihr koennt mir helfen.
Zurzeit machen wir im Informatikunterricht ein kleines Projekt.
Wir wurden in Gruppen aufgeteilt und müssen selber ein Spiel programmieren.
(Die Entwicklungsumgebung ist BlueJ)
Wir haben das Spiel TicTacToe gewählt und es funktioniert einigermaßen bis auf ein paar Probleme.
Der Lehrer hilft zwar den Gruppen beim Programmieren, aber er bringt auch verwirrende Inhalte mit ein.
Also die Probleme wären jetzt:

1.Die Gewinnueberpruefung funktioniert nicht, keine Ahnung wie man das anders machen kann(habe nicht soviel Erfahrung mit Java , machen wir erst seit diesem Schuljahr)

2. Im TicTacToe Spiel gibt es bei mir ja 9 Felder.Das Problem ist , dass man ein Feld zweimal mit einem Symbol(Kreis, kleinerer Kreis(als ersatz für ein x)belegen kann.

Das Spiel besteht aus 2 Klassen(oder wie sich die Dateien nennen) und hier sind die Quelltexte:

import sum.kern.*;
/**
 * @author 
 * @version 
 */
public class TicTacToe3
{
    // Objekte
    Bildschirm derBildschirm;
    Stift meinStift;
    Tastatur  dieTastatur;
    Maus dieMaus;
    Symbol[] symbole;
    int aktiverspieler =1;     


    // Konstruktor
    public TicTacToe3()
    {
        derBildschirm = new Bildschirm(400,550);
        meinStift = new Stift();
        dieTastatur = new Tastatur();
        dieMaus = new Maus();
        symbole = new Symbol[10];
    }
    public void spielfeld2()
    {
        meinStift.bewegeBis(50,0);
        // Punkteanzeige für den Spieler 1
        meinStift.zeichneRechteck(100,25);
        meinStift.bewegeBis(250,0);
        //Punkteanzeige für den zweiten Spieler
        meinStift.zeichneRechteck(100,25);
        //hier ist das eigentliche Spielfeld
        meinStift.bewegeBis(50,100);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(150,100);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(250,100);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(50,200);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(150,200);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(250,200);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(50,300);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(150,300);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(250,300);
        meinStift.zeichneRechteck(100,100);
        meinStift.bewegeBis(100,450);
        meinStift.zeichneRechteck(200,50);
        
    }
  

        
    public void zeichneSymbole(){
      
            //Kreis oder Kreuz

            for (int i=1; i<10;i++){
               
             if(symbole[i].getSymbolort()==1)
             {
                meinStift.bewegeBis(100,350);
             } 
             else if(symbole[i].getSymbolort()==2)
             {
                meinStift.bewegeBis(200,350);
             } 
             else if(symbole[i].getSymbolort()==3)
             {
                meinStift.bewegeBis(300,350);
             } 
             else if(symbole[i].getSymbolort()==4)
             {
                meinStift.bewegeBis(100,250);
             }
             else if(symbole[i].getSymbolort()==5)
             {
                meinStift.bewegeBis(200,250);
             } 
             else if(symbole[i].getSymbolort()==6)
             {
                meinStift.bewegeBis(300,250);
             } 
             else if(symbole[i].getSymbolort()==7)
             {
                meinStift.bewegeBis(100,150);
             } 
             else if(symbole[i].getSymbolort()==8)
             {
                meinStift.bewegeBis(200,150);
             } 
              else if(symbole[i].getSymbolort()==9)
             {
                meinStift.bewegeBis(300,150);
             } 
               if (symbole[i].getSymbolart()==1)
               {
                meinStift.zeichneKreis(50);   

   
        
                }//bewege zur Position des Symbolortes. symbole[i].getSymbolort()
                else if (symbole[i].getSymbolart()==2){
                    meinStift.zeichneKreis(20);
                 
      
                }
            

                //zeichne Kreis oder Kreuz dorthin
            }
        
        }
       
       public void wechselSpieler()
       {
                   if (aktiverspieler==1)
                   {
                     aktiverspieler= 2;
                   }  
            else if (aktiverspieler == 2)
                   {
                    aktiverspieler = 1;
                   }

       }
    public void gewinnpruefung()
    {
               if (symbole[1].getSymbolort()== 1 && symbole[2].getSymbolort()== 2 && symbole[3].getSymbolort()== 3
                   ||symbole[1].getSymbolort()== 1 && symbole[4].getSymbolort()== 4 && symbole[7].getSymbolort()== 7
                   ||symbole[7].getSymbolort()== 7 && symbole[8].getSymbolort()== 8 && symbole[9].getSymbolort()== 9
                   ||symbole[4].getSymbolort()== 4 && symbole[5].getSymbolort()== 5 && symbole[6].getSymbolort()== 6
                   ||symbole[9].getSymbolort()== 9 && symbole[6].getSymbolort()== 6 && symbole[3].getSymbolort()== 3
                   ||symbole[7].getSymbolort()== 7 && symbole[5].getSymbolort()== 5 && symbole[3].getSymbolort()== 3
                   ||symbole[1].getSymbolort()== 1 && symbole[5].getSymbolort()== 5 && symbole[9].getSymbolort()== 9
                   
                   )
            {System.out.println(dieTastatur.zeichen()+"gewonnen");
            }
    }
        
    public void ueberpruefeTastatur(){
        while (dieTastatur.wurdeGedrueckt())
        {
            if (dieTastatur.zeichen() == '1'){
                symbole[1] = new Symbol(aktiverspieler, 1);
                 this.zeichneSymbole(); 
                 this.wechselSpieler();
                 
            }
            else if (dieTastatur.zeichen() == '2'){
              symbole[2] = new Symbol(aktiverspieler, 2);
                 this.zeichneSymbole(); 
                 this.wechselSpieler();         
                 
            }
            else if(dieTastatur.zeichen() == '3')
            {
            symbole[3] = new Symbol(aktiverspieler, 3);
             this.zeichneSymbole(); 
             this.wechselSpieler();

            }
            else if (dieTastatur.zeichen() == '4'){
                symbole[4] = new Symbol(aktiverspieler, 4);
                 this.zeichneSymbole(); 
                 this.wechselSpieler();
                            }
            else if (dieTastatur.zeichen() == '5'){
                symbole[5] = new Symbol(aktiverspieler, 5);
                
                this.zeichneSymbole(); 
                this.wechselSpieler();
                            }
            else if (dieTastatur.zeichen() == '6'){
               symbole[6] = new Symbol(aktiverspieler, 6);
                
         this.zeichneSymbole(); 
         this.wechselSpieler();
                            }
            else if (dieTastatur.zeichen() == '7'){
               symbole[7] = new Symbol(aktiverspieler, 7);
               this.zeichneSymbole(); 
              this.wechselSpieler();
                            }
            else if (dieTastatur.zeichen() == '8'){
                symbole[8] = new Symbol(aktiverspieler, 8);
                 this.zeichneSymbole(); 
                 this.wechselSpieler();

                            }
            else if (dieTastatur.zeichen() == '9'){
              symbole[9] = new Symbol(aktiverspieler, 9);
                
                this.zeichneSymbole(); 
                this.wechselSpieler();
            }else{
                System.out.println(dieTastatur.zeichen()+" wurde gedruckt.Bitte drücke eine Zahl von 1 bis 9.Bevorzugt auf dem Numpad :)))))))");
            }
            //Löschen des obersten Zeichens im Tastaturspeicher.
            dieTastatur.weiter();
        }  
    }      
    // Dienste
    public void fuehreAus()
    {
        this.spielfeld2();
        for (int i=1; i<10;i++){
            symbole[i] = new Symbol(0,i);
        }        
        

        while (!(dieMaus.doppelKlick()))
        {
           ueberpruefeTastatur();             
        }
        this.gewinnpruefung();
        // Aufraeumen
      
    }
}

/**
 * @author 
 * @version 
 */
public class Symbol
{
    //Art des Symbols: 0: nicht vergeben, 1:Kreuz, 2: Kreis
    private int symbolart=0;
    //7 oben link, 8 oben mitte, 9 oben rechts
    //4 mitte links, 5 mitte mitte, 6 mitte rechts
    //....
    private int symbolort;
    
    public Symbol(int pSymbolart, int pSymbolort){
        this.symbolart = pSymbolart;
        this.symbolort = pSymbolort;
    }   
    
    public int getSymbolart(){
        return symbolart;
    }
    
    public int getSymbolort(){
        return symbolort;
    }
    public void setSymbolart(int pSymbolart)
    {
        this.symbolart= pSymbolart;
    }
    
}

 

[Mofi]

Ganz grob gesagt, da ich kein BlueJ habe und auch nicht die ganzen Klassen und daher es nicht ausprobieren kann:

Bei deiner Gewinnüberprüfungen scheinen einfach Klammern zu fehlen. Versuche mal die Verknüpfungen durch Klammern zuschachteln, dann sollte es auch funktionieren. Musste evtl mal ein wenig rumprobieren.

Wegen den Symbolen. Ich nehme an du meinst, dass man schon ein vorhandenes Symbol überschreiben kann?
Dann prüfe doch einfach VOR dem malen des Symbols, ob schon eins vorhanden ist. Wenn ja -> mal keins; wenn nein -> mal eins.

Ich hoffe, dass hilft ein wenig

 

[W9ND3R]

Hallo.
Ein identisches Projekt hatte ich zu erledigen in meinem ersten Jahr Java. Ist eigentlich ganz schön so ...
Nun aber zu deinem Problem:

1) Du hast ja bereits eine Überprüfung implementiert. Jedoch versteh ich nicht ganz, was diese so bewirken soll? Ich würde einfach jede einzelne Gewinnmöglichkeit mit einer if-Abfrage überprüfen. Sind ja beim TicTacToe nur neun Bedingungen oder so.

2) Bevor du das neue Symbol auf eine Fläche setzt solltest du einfach überprüfen, ob sich nicht schon ein Anderes an dieser Stelle befindet. Wenn dies der Fall ist, dann solltest du den Spieler einfach nochmal ran lassen, ansonsten setzt du das Symbol einfach hin.

Grüße.

EDIT ... Wohl zu langsam ;-)

 

[Firephoenix]

Hi,
für mein google-code-svn habe ich vor ein paar tagen ein kleines tictactoe geschrieben,
falls dir der Ansatz irgendwie weiterhilft:
Für die Feld-Typen wurde ein enum gewählt,
das Feld wird in der Klasse LogicField gespeichert,
das Spiel läuft in der Klasse LogicGame ab und angezeigt wird das ganze in der GuiGame
gestartet wird das ganze indem die main in TicTacToe start ausgeführt wird.

Bitte beim Verwenden die GPL beachten, Copy-Paste hat wenig Lernzwecke

LogicField:

//This file is part of java-examples42 on code.google.com .
//
//java-examples42 is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//java-examples42 is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with java-examples42.  If not, see <http://www.gnu.org/licenses/>.
//
//In case of further questions please contact [email]oniatus@googlemail.com[/email]

/**
 * Class which representates the Logic field for TicTacToe
 * and which consists the enums for the fieldTypes (FREE, CIRCLE or CROSS)
 */
public class LogicField {
	/**
	 * Types for the field (free, circle or cross)
	 */
	public static enum fieldType{
		FREE, CIRCLE, CROSS
	}

	/**
	 * 2D-Array which saves the logical field
	 */
	private fieldType[][] field = new fieldType[][] {{fieldType.FREE, fieldType.FREE, fieldType.FREE},
			{fieldType.FREE, fieldType.FREE, fieldType.FREE},
			{fieldType.FREE, fieldType.FREE, fieldType.FREE}};

	/**
	 * Called if a cell is clicked and sets the Cell to Circle or Cross if it was free
	 * if Cross or Circle belongs to the playernumber (1 = Cross, 2 = Circle).
	 * @param x x-Coordinate of the Cell
	 * @param y y-Coordinate of the Cell
	 * @param playerNumber Playernumber (must be 1 or 2)
	 * @return true if the Cell was free, false if not
	 */
	public boolean cellClicked(int x, int y, int playerNumber){
		if(field[x][y] == fieldType.FREE){
			if(playerNumber == 1){
				field[x][y] = fieldType.CROSS;
			}if(playerNumber == 2){
				field[x][y] = fieldType.CIRCLE;
			}
			return true;
		}else{
			return false;
		}
	}

	/**
	 * @return Returns the Cellkind at the specified position (FREE, CIRCLE or CROSS)
	 */
	public fieldType getCellKind(int x, int y){
		return field[x][y];
	}

	
	
	/**
	 * Will set all fieldTypes on FREE
	 */
	public void resetField(){
		for(int i = 0;i<field.length;i++){
			for(int j = 0; j < field[0].length;j++){
				field[i][j] = fieldType.FREE;
			}
		}
	}

	/**
	 * Returns a String-Represenation of the field
	 * as Line-Separator System.getProperty("line.separator") is used.
	 * at the last line no Line-Break will be added
	 * (X = fields of player 1, O = fields of player 2, _ = Free fields
	 * e.g: "_XO\n"+"O_X\n"+"XO_"
	 */
	@Override
	public String toString(){
		String lineBreak = System.getProperty("line.separator");
		StringBuilder sb = new StringBuilder();
		for(int y = 0;y<field.length;y++){
			for(int x = 0; x < field[0].length;x++){
				if(field[x][y] == fieldType.FREE)
					sb.append("_");
				if(field[x][y] == fieldType.CROSS)
					sb.append("X");
				if(field[x][y] == fieldType.CIRCLE)
					sb.append("O");
			}
			if(y < field.length -1)
				sb.append(lineBreak);
		}
		return sb.toString();
	}





}

LogicGame:

//This file is part of java-examples42 on code.google.com .
//
//java-examples42 is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//java-examples42 is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with java-examples42.  If not, see <http://www.gnu.org/licenses/>.
//
//In case of further questions please contact [email]oniatus@googlemail.com[/email]
import com.googlemail.oniatus.tictactoe.LogicField.fieldType;

/**
 * Class which representates the LogicGame
 * saves the player which is actual on turn (1 or 2) and the field.
 */
public class LogicGame {
	
	//Feld
	private LogicField field;
	//Welcher Spieler ist gerade dran
	private int playerOnTurn;
	
	/**
	 * Creates a new TicTacToe-Game
	 */
	public LogicGame(){
		this.field = new LogicField();
		this.playerOnTurn = 1;
	}
	
	/**
	 * Starts a new Game and reset the old one
	 */
	public void startGame(){
		this.field.resetField();
		this.playerOnTurn = 1;
	}
	
	/**
	 * Called if a cell is clicked on the given Position
	 */
	public void cellClicked(int x, int y){
		if(this.field.cellClicked(x, y, playerOnTurn))
			nextPlayer();
	}
	
	/**
	 * Returns the cellKind at the specified position
	 */
	public LogicField.fieldType getCellKind(int x, int y){
		return field.getCellKind(x, y);
	}
	
	/**
	 * switches to the next player (1 to 2 or 2 to 1)
	 */
	private void nextPlayer(){
		if(playerOnTurn == 1)
			playerOnTurn = 2;
		else
			playerOnTurn = 1;
	}
	
	/**
	 * Checks if the player with the specified fieldType has Won the game
	 */
	public boolean checkForWin(fieldType t){
		//TODO entsprechend ausfüllen
		if( (field.getCellKind(0, 0) == t && field.getCellKind(1, 0) == t && field.getCellKind(2, 0) == t)||//Gerade Oben
			(field.getCellKind(0, 1) == t && field.getCellKind(1, 1) == t && field.getCellKind(2, 1) == t)||//Gerade Mitte
			(field.getCellKind(0, 2) == t && field.getCellKind(1, 2) == t && field.getCellKind(2, 2) == t)||//Gerade Unten
			(field.getCellKind(0, 0) == t && field.getCellKind(0, 1) == t && field.getCellKind(0, 2) == t)||//Horizontale Links
			(field.getCellKind(1, 0) == t && field.getCellKind(1, 1) == t && field.getCellKind(1, 2) == t) ||//Horizontale Mitte
			(field.getCellKind(2, 0) == t && field.getCellKind(2, 1) == t && field.getCellKind(2, 2) == t) ||//Horizontale Rechts
				(field.getCellKind(0, 2) == t && field.getCellKind(1, 1) == t && field.getCellKind(2, 0) == t) ||//Diagonale UntenLinks->ObenRechts
				(field.getCellKind(0, 0) == t && field.getCellKind(1, 1) == t && field.getCellKind(2, 2) == t)//Diagonale ObenLinks->UntenRechts
		)
			return true;
		else
			return false;
	}

	/**
	 * Checks if the game has ended with a draw (will return true if there is a draw)
	 */
	public boolean checkForDraw(){
		//Es darf kein Spieler gewonnen haben
		if(!checkForWin(fieldType.CROSS) && !checkForWin(fieldType.CIRCLE)){
			//Und kein Feld darf mehr frei sein
			for(int x = 0; x < 3; x++){
				for(int y = 0; y < 3; y++){
					if(field.getCellKind(x, y) == fieldType.FREE)
						return false;
				}
			}
			//erst dann ist das Spiel unentschieden
			return true;
		}
		return false;
	}

	/**
	 * @return the playerOnTurn
	 */
	public int getPlayerOnTurn() {
		return playerOnTurn;
	}
	
	/**
	 * Resets the game
	 */
	public void resetGame(){
		playerOnTurn = 1;
		field.resetField();
	}
}

GuiGame

//This file is part of java-examples42 on code.google.com .
//
//java-examples42 is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//java-examples42 is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with java-examples42.  If not, see <http://www.gnu.org/licenses/>.
//
//In case of further questions please contact [email]oniatus@googlemail.com[/email]
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
 * Class which representates the Gui for TicTacToe
 * the class is also used for controlling the game-cycle
 */
public class GuiGame 
{
	//JFrame in dem das Spiel angezeigt wird
	private JFrame gui = new JFrame();
	//Buttons für das 3*3 Spielfeld
	private JButton[][] buttons = new JButton[3][3];
	//Spiel, das die nötigen informationen hält und das Spiel verwaltet
	private LogicGame game = new LogicGame();
	//TextField für die Nachrichten
	private JTextField messages = new JTextField();
	//Speichert ob das Spiel im gange ist oder ob ein neues gestartet werden muss
	private boolean gameRunning;

	/**
	 * Constructor for a new GUI-Game
	 */
	public GuiGame(){
		//Fenster wird beim schließen disposed
		gui.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		//Menü wird über die Methode createMenu eingefügt
		gui.setJMenuBar(createMenu());
		//Konfiguration von dem JTextField (standardtext, größe, Textausrichtung,
		//Textformatierung und nicht editierbar)
		messages.setText("Please start a new Game");
		messages.setPreferredSize(new Dimension(0,100));
		messages.setHorizontalAlignment(JTextField.CENTER);
		messages.setFont(new Font("helvetica",Font.BOLD,40));
		messages.setEditable(false);
		//Grafikkomponenten werden in einem JFrame standard in der ContentPane abgelegt
		Container cp = gui.getContentPane();
		//BorderLayout für das Standard-Fenster
		cp.setLayout(new BorderLayout());
		cp.add(messages, BorderLayout.NORTH);
		//Das Panel für das Spielfeld wird über eine extra-Methode erzeugt
		JPanel playPanel = createPlayPanel();
		cp.add(playPanel);
		//JFrame konfigurieren (feste Größe)
		gui.setSize(600, 700);
		gui.setResizable(false);
		gameRunning = false;
		//JFrame anzeigen
		gui.setVisible(true);
	}

	/**
	 * Creates the Menu
	 */
	private JMenuBar createMenu(){
		//MenuBar die zurückgegeben wird
		JMenuBar ret = new JMenuBar();
		//Der erste Menüpunkt
		JMenu game = new JMenu("Spiel");
		//MenüItem für das Spiel-Menü
		JMenuItem newGame = new JMenuItem("Neues Spiel");
		//Innere anonyme Klasse für den ActionListener
		newGame.addActionListener(new ActionListener(){
			//Wird ausgeführt wenn auf den Button geklickt wird
			@Override
			public void actionPerformed(ActionEvent arg0) {
				newGame();
			}
		});
		//Zweites MenüItem für das Spiel-Menü
		JMenuItem exitGame = new JMenuItem("Beenden");
		exitGame.addActionListener(new ActionListener(){
			@Override
			public void actionPerformed(ActionEvent arg0) {
				gui.setVisible(false);
				gui.dispose();
			}
		});
		//Untermenüpunkte zum Menüpunkt hinzufügen
		game.add(newGame);
		game.add(exitGame);
		//Menüpunkt zur MenuBar hinzufügen
		ret.add(game);
		//fertige Menübar zurückgeben
		return ret;
	}

	/**
	 * Creates the playPanel with the 3*3 Buttons
	 */
	private JPanel createPlayPanel(){
		//Panel das zurückgegeben wird
		JPanel ret = new JPanel();
		//Es wird ein Gridlayout verwendet
		ret.setLayout(new GridLayout(3,3));
		//Schleifen, die die Buttons erzeugen
		for(int y = 0; y < 3; y++){
			for(int x = 0; x < 3; x++){
				//Jeder Button kennt seine x und y Position
				final int xcor = x;
				final int ycor = y;
				buttons[x][y] = new JButton();
				//Schriftformatierung des Buttons
				buttons[x][y].setFont(new Font("helvetica",Font.BOLD,40));
				buttons[x][y].addActionListener(new ActionListener(){
					//Wird aufgerufen wenn auf den Button geklickt wird
					@Override
					public void actionPerformed(ActionEvent arg0) {
						//Es passiert nur etwas wenn gerade ein Spiel läuft
						if(gameRunning){
							//Dem logischem Spiel wird die Zelle mitgeteilt auf die geklickt wurde
							game.cellClicked(xcor, ycor);
							//Der Button wird aktualisiert
							actualizeButton(xcor,ycor);
							//Die Messages werden aktualisiert
							messages.setText("Spieler "+game.getPlayerOnTurn()+" ist dran!");
							//Es wird auf mögliche Spielende geprüft
							if(game.checkForDraw()){
								messages.setText("Unentschieden");
								gameRunning = false;
							}else if(game.checkForWin(LogicField.fieldType.CROSS)){
								messages.setText("Spieler 1 hat gewonnen");
								gameRunning = false;
							}else if(game.checkForWin(LogicField.fieldType.CIRCLE)){
								messages.setText("Spieler 2 hat gewonnen");
								gameRunning = false;
							}
						}

					}
				});
				//die erzeugten Buttons werden dem Panel übergeben
				ret.add(buttons[x][y]);
			}

		}
		//Das fertige Panel wird zurückgegeben
		return ret;
	}

	/**
	 * Method which actualize the Button at the given Position
	 */
	private void actualizeButton(int x, int y){
		//Es wird der Zelltyp des Buttons ermittelt
		//Je nach Typ wird der Text des Buttons neu gesetzt
		switch(game.getCellKind(x, y)){
		case FREE: 
			buttons[x][y].setText(new String(""));
			break;
		case CIRCLE:
			buttons[x][y].setText(new String("O"));
			break;
		case CROSS:
			buttons[x][y].setText(new String("X"));
			break;
		default:
			buttons[x][y].setText(new String(""));
		}
	}

	/**
	 * Starts a new Game
	 */
	private void newGame(){
		//das logische Spiel wird zurückgesetzt
		game.resetGame();
		//die Nachrichten werden aktualisiert
		messages.setText("Spieler "+game.getPlayerOnTurn()+" ist dran!");
		//alle Buttons werden aktualisiert
		for(int i = 0; i < 3; i++){
			for(int j = 0; j < 3; j++){
				actualizeButton(i,j);
			}

		}
		//und gameRunning wird wieder auf true gesetzt
		gameRunning = true;
	}

}

TicTacToeStart

//This file is part of java-examples42 on code.google.com .
//
//java-examples42 is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//java-examples42 is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with java-examples42.  If not, see <http://www.gnu.org/licenses/>.
//
//In case of further questions please contact [email]oniatus@googlemail.com[/email]
/**
 * Starter-Class for the tic-tac-toe game
 */
public class TicTacToeStart {

	public static void main(String[] args) {
		new GuiGame();
	}
}

Ich hab dir auch noch ein kleines UML angehängt,
Gruß

 

[kirax]

2-5-8 hast du glaub ich in der Überprüfung vergessen.
&& hat eine höhere Priorität als ||. Von daher passt das auch ohne Klammern.

Aber musst du nicht auch überprüfen, dass die Symbole jeweils vom gleichen Spieler sind?

 

[Godzilla]

Danke für Die Antworten, aber ich weiß immernoch nicht wo oder wie ich ueberpruefen kann, ob schon ein Symbol auf einem Feld liegt(Ja der Lehrer hat viel reinprogrammiert, was mir den überblick geraubt hat. eig das ganze mit den arrays, das haben wir ja garnicht im unterricht gemacht) und die wie ich bei der Gewinnueberpruefung auch ueberpruefe ob es sich um das gleiche Symbol handelt.

 

[kirax]

Danke für Die Antworten, aber ich weiß immernoch nicht wo oder wie ich ueberpruefen kann, ob schon ein Symbol auf einem Feld liegt(Ja der Lehrer hat viel reinprogrammiert, was mir den überblick geraubt hat. eig das ganze mit den arrays, das haben wir ja garnicht im unterricht gemacht) und die wie ich bei der Gewinnueberpruefung auch ueberpruefe ob es sich um das gleiche Symbol handelt.

Was habt ihr denn für nen Lehrer?!! Ich frag mich ernsthaft wie man bei einem solchen Lehrkonzept was lernen soll...

[c]if (symbole.getSymbolart()==1)[/c]
Damit kriegst du ja raus, was das Symbol für eine Symbolart hat (=von welchem Spieler es ist).
Und du musst eben prüfen, ob die Reihe jeweils aus gleichen Symbolen besteht.

Btw. frage ich mich gerade, warum die Information über den Ort des Symbols doppelt gespeichert wird? Im Arrayindex und im Objekt?
Für jedes Symbol gilt bei dir offensichtlich
[c]symbole.getSymbolort() == i[/c]
Ergo ist der Symbolort in der Klasse Symbol nutzlos.
Aber wenn ihr mit Arrays noch nicht gearbeitet habt bloed dann kannst du das nicht wissen. Frag mal deinen Lehrer. Der soll dir da mal ne sinnvolle Antwort drauf geben

Noch ein Tipp:
[c]getSymbolort()[/c] und [c]getSymbolart()[/c] sehen SEHR ähnlich aus. Das würde ich vielleicht ändern, denn dann ist die Fehlerschwelle nochmal höher

 

[W9ND3R]

Also gut ... Dann nochmal das Ganze mit Code:

Du kannst überprüfen, ob auf einem Feld bereits ein Zeichen ist, indem du es ungefähr so löst:

if(Symbol[0][0] == 'X' | Symbol[0][0] == 'O') { 
   return
   } else {
   ...
   }

Die Überprüfung fragt einfach ab, ob in dem Feld schon ein O oder ein X steht. Wenn ja, dann wird die Operation ausgeführt, sonst nicht!

Bei der Gewinnprüfung kannst du ungefähr so vor gehen:

if(Symbol[0][0] == Symbol[1][1] && Symbol[1][1] == Symbol[2][2])

Das prüft gleichzeitig mit, ob die Symbole alle gleich sind. Nach dieser Prüfung kannst du dann ja das zeichen auslesen, das sich in einem der geprüften Felder befindet. Die Prüfung vom Beispiel wäre diagonal von oben links nach rechts unten!

PS: Wenn du Arrays noch nicht gelernt hast, versuch es dir selbst beizubringen, ist zwar nicht ganz einfach, bringt dich aber weiter!

EDIT: Schon wieder zu langsam

 

[kirax]

if(Symbol[0][0] == 'X' | Symbol[0][0] == 'O')

Kleiner aber feiner Tipp am Rande (wirklich nix hochtrabendes ):
Wenn du das logische OR verwendest ([c]||[/c]) könntest du etwas Zeit sparen, da dann, wenn [c]Symbol[0][0]=='X'[/c] der hintere Teil gar nicht mehr ausgeführt wird (was er beim bitweisen OR aber wird )

 

[Simon_Flagg]

Was mir beim code noch aufgefallen ist/zur Übersichtlichkeit beitragen könnte, aber nichts an der fktweise ändern würde:
beim zeichnen: schleifen verwenden
in der methode zeichneSymbole: switch? kann man aus der nr. vllt. die position herleiten? (/3 für die Zeilennr. %3 für die x-koordinate, wenn ich mich nicht irre....-)

lg