# Model-View-Controller-Pattern



## styx665 (16. Mai 2012)

Hi,
ich bitte um Hilfe da ich eine Aufgabe bekommen hab diese jedoch nicht verstehe 
wir sollten TicTacToe Programmieren und das mit jeder neuen Aufgabe weiterentwickeln.

Nun weiss ich jedoch nicht wie ich meine bestehenden Klassen in das MVC-Pattern einpassen kann 
GUI ist nicht gefragt, die schlichte Text/Konsolen-Ausgabe genügt ..



Hier die Hauptanwendung

```
package spiel;

import java.io.Serializable;
import java.util.Scanner;

import strategie.ConcreteRandomMinimax;
import strategie.Minimax;
import strategie.Playercontrolled;


// **********************
//        VIEW  ??
// **********************

public class Hauptprogramm implements Serializable {
	
	private static final long serialVersionUID = 5221579436698655586L;
	private boolean gewonnen;
	private boolean XZieht;
	private Feld spielfeld;
	private transient ISpielregeln regeln = new Spielregeln();
	private Spieler spieler1;
	private Spieler spieler2;
	private String spielstand = "";
	private transient Filehandler fh = new Filehandler();
	private static String pfad="/User/me/Desktop";

	public Hauptprogramm() {
		this.gewonnen = false;
		this.XZieht = true;
		this.spielfeld = new Feld();
		spieler1 = new Spieler('X', new Playercontrolled(this));
		spieler2 = new Spieler('O', new ConcreteRandomMinimax(new Minimax()));
	}

	public boolean getGewonnen() {
		return gewonnen;
	}

	public void ziehen() {
		int[] zug;
		if (!gewonnen) {
			if (XZieht) {
				zug = spieler1.ziehen(spielfeld, spieler2.getZeichen());
			} else {
				zug = spieler2.ziehen(spielfeld, spieler1.getZeichen());
			}
			spielfeld.setMark(zug[0], zug[1], (XZieht ? 'X' : 'O'));
			spielstand += zug[0] + " " + zug[1] + " " + (XZieht ? 'X' : 'O') + "\n";
			System.out.println(spielfeld.toString());
			System.out.print(spielstand+"\n");
			spielende();
			XZieht = !XZieht;
		} else
			System.out.println("Das Spiel ist zu Ende");
	}
	

	private void spielende() {
		if (regeln.siegSpieler(spielfeld) != 0) {
			gewonnen = true;
			System.out
					.println(regeln.siegSpieler(spielfeld) + " hat gewonnen.");
		} else {
			if (regeln.unentschieden(spielfeld)) {
				gewonnen = true;
				System.out.println("Das Spiel ist unentschieden ausgegangen!");
			}
		}
	}

	public static void main(String[] args) {
		Hauptprogramm spiel = new Hauptprogramm();
		while (!spiel.getGewonnen()) {
			spiel.ziehen();
		}
	}
}
```


das Regelwerk ..


```
package spiel;



//**********************
//     CONTROLLER ??
//**********************

public class Spielregeln{

	/*
	 * private boolean sieg() { if (siegtest('X') == true) return true; else if
	 * (siegtest('O') == true) return true; else return false; }
	 */

	public boolean spielzugGueltig(int x, int y, Feld sp) {
		if (sp.getMark(x, y) == 0)
			return true;
		else
			return false;
	}


	public boolean heigth(int x, Feld sp) {
		if (x >= 0 && x < sp.getHeight())
			return true;
		else
			return false;
	}

	public boolean width(int y, Feld sp) {
		if (y >= 0 && y < sp.getWidth())
			return true;
		else
			return false;
	}

	public char siegSpieler(Feld sp) {
		for (int i = 0; i < 3; i++) {
			if (sp.getMark(i, 0) == sp.getMark(i, 1)
					&& sp.getMark(i, 1) == sp.getMark(i, 2)
					&& sp.getMark(i, 0) != 0) {
				return sp.getMark(i, 0);
			}
			if (sp.getMark(0, i) == sp.getMark(1, i)
					&& sp.getMark(1, i) == sp.getMark(2, i)
					&& sp.getMark(0, i) != 0) {
				return sp.getMark(0, i);
			}
		}
		if (sp.getMark(0, 0) == sp.getMark(1, 1)
				&& sp.getMark(0, 1) == sp.getMark(2, 2)
				&& sp.getMark(0, 0) != 0) {
			return sp.getMark(0, 0);
		}
		if (sp.getMark(2, 0) == sp.getMark(1, 1)
				&& sp.getMark(1, 1) == sp.getMark(0, 2)
				&& sp.getMark(2, 0) != 0) {
			return sp.getMark(2, 0);
		}
		return 0;
	}

	public boolean unentschieden(Feld sp) {
		int volleReihen = 0;
		for (int i = 0; i < 3; i++) {
			if (sp.getMark(i, 0) != 0 && sp.getMark(i, 1) != 0
					&& sp.getMark(i, 2) != 0) {
				volleReihen += 1;
			}
		}
		if (volleReihen == 3) {
			return true;
		} else {
			return false;
		}
	}

}
```

und das feld 


```
package spiel;

import java.io.Serializable;


//**********************
//       MODEL ??
//**********************



@SuppressWarnings("serial")
public class Feld implements Serializable{
	private char[][] spielfeld;
	
	public Feld(){
		this.spielfeld = new char[3][3];
	}
	
	public Feld(char[][] sp){
		this.spielfeld = sp;
	}
	

	public char getMark(int x, int y){
		return spielfeld[x][y];
	}
	

	public void setMark(int x, int y, char mark){
		spielfeld[x][y]= mark;
	}
	
	public int getHeight(){
		return this.spielfeld.length;
	}
	
	public int getWidth(){
		return this.spielfeld[0].length;
	}
	
	public Feld testMark(int x, int y, char mark){
		char[][] copyFeld = new char[spielfeld.length][spielfeld[0].length];
		for (int i = 0; i < spielfeld.length; i++){
			for (int j = 0; j < spielfeld[i].length; j++){
				copyFeld[i][j] = spielfeld[i][j]; 
			}
		}
		Feld returnFeld = new Feld(copyFeld);
		returnFeld.setMark(x, y, mark);
		return returnFeld;
	}
	
	public String toString(){
		String[] stringarray = { "", "", "" };
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				if (spielfeld[i][j] != 0)
					stringarray[i] += (spielfeld[i][j] + " ");
				else
					stringarray[i] += ("_ ");

			}
		}
		return (stringarray[0] + "\n" + stringarray[1] + "\n" + stringarray[2] + "\n");
	}
}
```


und noch eine Klasse die die ziehen()-Methode für Spieler bereitstellt ..


```
package spiel;
import java.io.Serializable;

import strategie.Strategie;


@SuppressWarnings("serial")
public class Spieler implements Serializable {
	private char zeichen;
	private Strategie strat;
	
	public Spieler(char zeichen, Strategie strat){
		this.zeichen = zeichen;
		this.strat = strat;
	}
	
	public int[] ziehen(Feld spielfeld, char enemyMark) {
		return strat.ziehen(spielfeld, zeichen, enemyMark);
	}
	
	public char getZeichen(){
		return this.zeichen;
	}
}
```


(SuFu && Google) hab ich bereits durch und kapier noch immer nich viel mehr als vorher ???:L


----------



## SlaterB (16. Mai 2012)

ist deine Frage nur, ob es MVC ist oder noch was anderes?
mein Vorschlag, wenn das so dringend ist:

erweitere das Model noch zum eine Klasse Spielzustand, dort Dinge ablegen wie wer aktuell dran ist,
wird wohl ne ziemlich kleine Klasse, notfalls reichts auch im Controller,

jedenfalls sollte die View meiner Ansicht nach weniger machen, eine Schleife für die Züge ist nicht verkehrt,
aber dort weniger Logik, nicht selber 'ausrechnen' wer dran ist, 

beim Spieler die Strategie zu verstecken ist auch bisschen kritisch, die könnte den Controller-Bereich wohl eher schmücken,
speichere im Spieler nur einen boolean oder Enum-Wert, welche Strategie zu wählen ist,
der Controller oder wer immer den Zug ausführt (durchaus von der View initialisiert, kann dennoch im Controller passieren)
sucht den Strategietyp und holt von seinem Bereich das passende Strategie-Objekt und läßt dort weiterarbeiten

alles eher nur meine Meinung, allzu sicher mag ich nicht beurteilen was der ein oder andere unter MVC versteht,
kann auch abweichen


----------



## styx665 (16. Mai 2012)

Die Aufgabe lautete das wir unser (alles unterschiedliche Implementierung von) tictactoe in das MVC-Pattern bringen 

Da ich grad ne krasse denkblockade zu haben scheine versteh ich es einfach nich 

ich weiss nich ob die klassen so wie sie da sind bereits in dem Pattern sind bzw. OB ich mir das richtig gedacht habe 

die kommentar kästen ganz oben in den klassen sind nur was ich mir gedacht hab was das sein könnte ...

ich hoffe ich könnte mein problem verständlich machen


----------



## hoangvm (16. Mai 2012)

Model View Controller ? Wikipedia

Du kansst aber erst mal in Wikie schauen.

Zu deinen Problemstellungen würde ich so mal vorschlagen:

- Model: Spielfeld,Feldstand,Gewinnen or nicht
- View: aber nur Aktionen aufruf (ziehen ...)
- Controlller: nach der Triggerung der Aktionen -> aktualisieren das Feld.

also im Hauptprogramm muss eine Modelinstance geben .

vg.


----------

