TicTacToe-geeignete Klassenhierarchie

[Han]

Hallo....gegeben sei folgende Aufgabe:

Tic Tac Toe
Entwerfen und implementieren Sie das Spiel „Tic Tac Toe“ (auch bekannt als „Dodelschach“).
Spielregeln (von http://de.wikipedia.org/wiki/Tic_Tac_Toe): Auf einem 3×3 Felder großen
Spielfeld machen die beiden Spieler abwechselnd ihre Zeichen (Kreuze und Kreise). Der Spieler,
der als erstes drei seiner Zeichen in einer Reihe, Spalte oder einer der beiden Hauptdiagonalen
setzen kann, gewinnt.
Modellieren Sie das Spielfeld, dessen 3×3 Felder entweder Kreuze oder Kreise enthalten können,
und finden Sie einen Algorithmus, der den Gewinn eines Spielers erkennt. Die Ausgabe des
Spielfeldes soll textuell auf der Konsole erfolgen.
Es gibt verschiedene Arten von Spielern, die beliebig kombiniert werden können: Eine Person gibt
den nächsten Zug auf der Konsole ein, während der Computer automatisch seinen nächsten Zug
durchführt. Dabei kann der Computer nach unterschiedlichen Regeln setzen. Implementieren Sie
zumindest zwei verschiedene Algorithmen: Beim ersten soll der Computer rein zufällig setzen,
beim zweiten die aktuelle Stellung berücksichtigen (er muss nicht perfekt spielen, soll aber keine
Trivialfehler machen).
Hinweise:
• Das Hauptaugenmerk dieser Übung ist, eine gute Klassenhierarchie und
Methodenschnittstelle zu erstellen. Sie müssen ihre Datenstrukturen und den Weg, wie sie
dazu gekommen sind, in Ihrer Abgabe argumentieren.
• Achten Sie auf die Erweiterbarkeit Ihrer Lösung. Es soll z.B. einfach möglich sein, neue
Arten von Spielern und neue Benutzeroberflächen (z.B. eine graphische Oberfläche)
hinzuzufügen.
• Für die Speicherung der Daten, z.B. des Spielfeldes, steht Ihnen die Datenstruktur frei.
Begründen Sie, warum Sie Ihre Lösung gewählt haben.

Zuerst muss ich ja mal die Klassenhierarchie entwerfen sonst kann ich ja nicht mal anfangen....und die ist nicht gerade einfach finde ich....vielleicht könnt ihr mir ein paar Tipps geben:

Ich hab mir mal gedacht dass ich eine Hauptklasse TicTacToe implementiere:

public class TicTacToe {
//Konstruktor der das Board initialisiert    
//Methode um ein X am Board zu setzen
//Methode zum Auswählen der jeweiligen Computerspielerstrategie
//Methode welche bei jedem Zug prüft ob der Spieler oder Computerspieler gewonnen hat
}

...dann eine Klasse Computer

public class Computer {

}

...dazu jeweilige Algorithmen....
public class Algo1 extends Computer{

}

public class Algo2 extends Computer{

}

...und dann eine Klasse Board welche das Spielfeld implementieren soll....

public class Board{
}

public class textualBoard extends Board{
}

public class graphicalBoard extends Board{
//für später
}

Passt das so mal oder habt ihr da noch bessere Ideen...vor allem das mit der graphischen Implementierung für
später bzw. ob ich wirklich für jeden Algo in der Klasse Computer eine eigene Klasse machen soll bereitet mir Kopfzerbrechen.....

mfg,
Han

 

[mattulla]

Schaut meiner Ansicht nach recht gut aus. Wuerde das ganze Prinzip vll nach dem MVC-Prinzip umsetzen und auf Observable/Observer zurueckgreifen. Also deine Klasse TicTacToe erbt von Observable, Board und Algo implementieren dann das Interface Observer. Dadurch kannst du vor allem die leichte Entwicklung einer weiteren Benutzeroberflaeche oder eines weiteren Algorithmus sicherstellen.

Gruesse
mattulla

 

[Han]

Hallo...hab mir deinen Vorschlag mal zu Herzen genommen und bin auf folgende Aufteilung gekommen....allerdings kapier ich das mit dem Observer bzw. observable noch nicht so ganz....ich hab mir den Artikel auf JavaForum durchgelesen zu Observer/Observable aber wie soll ich das konkret implementieren bzw. was bringt mir das? (Ich weiß man kann mit der anderen Klasse kommunitizieren ohne sie zu kennen.....aber wie schaut das konkret in meinem Fall aus.....ein Ansatz wäre wieder eine gute Hilfe).....zudem bin ich mir nicht sicher ob ich die Benutzerschnittstelle sauber in getrennte Klassen gebracht habe....

package View;
import java.util.Observable; 
import java.util.Observer;

public class TextualInterface implements Observer{
	public String getStringForData(int d) { 
	.......
         } 
		    
	public void displayBoard(int[][] board) { 
	.......zeichnet mir das Board mit den aktuellen Daten auf die Konsole.....
	}
	
	public void update(Observable o, Object arg){
		..was soll da z.b rein?
	}
}

package Data;
public class Board {
	public int[][] board = ....3x3 Matrix
	
	public int[][] getBoard(){
		return board;
	}
	
	public void setDataAt(int x, int y, int data){
		board[x][y] = data;
	}
	
	public int getDataAt(int x,int y){
		return board[x][y];
	}
}

package Data;

public class Rules {

	public GameState boardState;
	
	public Rules(){
		this.boardState = GameState.inProgress;
	}
	
	public GameState getBoardState(){
		return boardState;
	}
	
	public boolean boardIsFull(int[][] board){
		...prüft ob eine Patsituation eintritt.....
	}
	
	public void checkGameState(int[][] board){
//		Der Spieler, der als erstes drei seiner Zeichen in einer Reihe,
//		Spalte oder einer der beiden Hauptdiagonalen setzen kann, 
//		gewinnt. Wenn allerdings beide Spieler das Spiel perfekt 
//		beherrschen, kann keiner gewinnen und es ist unentschieden.
		...Implementierung für meine Frage unwichtig....
 }

package Data;

public enum GameState {
	 inProgress,
	 Pendant,
	 ComputerWins,
	 HumanWins,
}

package Data;

public class ComputerKI {
}

package Data;

public class ComputerKI1 extends ComputerKI{
.....leichte PC KI.....
}

package Data;

public class ComputerKI2 {
.....schwierige PC KI...
}

package Controller;

public class TTTController {

	private Board board = new Board();
	private Rules rules = new Rules();
	private TextualInterface textInt = new TextualInterface();
	
	public void commandLoop() {
		Out.println("Welcome to the TicTacToe game\n");

		// display the command menu
		displayMenu();

		while (true) {
			............
		}
	}
	
	public void twoplayers(){
		............
		displayResult();
	
	}
	
	public void displayResult(){
		.....
	}
	public void displayMenu() {
		..........
	}
	
	public static void main(String[] args) {
		TTTController app = new TTTController();
		app.commandLoop();
	}	
}

...meine Frage richtet sich wie gesagt nicht der Implementierung sondern der Klassenaufteilung....vor allem beim User Interface hab ich noch nicht recht geschickt aufgeteilt....könntet ihr mir ein paar Tipps zur Verbesserung geben....das Spiel läuft jetzt einmal....aber halt noch nicht gschickt aufgeteilt vermute ich....

mfg,
Han

 

[mattulla]

Hab hier noch mal nen link fuer dich.....da wird das Prinzip vll noch mal etwas klarer: