package composited;
import fields.*;
//---
import javax.swing.*;
import java.awt.*;
import java.util.*;
/**
* Das gesammte Spielfeld, mit der Menge der Feldern, und der Reihen
* zur graphischen Darstellung. Die Auswertung wird hier gestartet, beginnend
* mit der Erstellung der Reihen usw...
*
* Eimalige ERstellung der Reihen noch nicht geklärt, vll später neue (rekursive)
* Reihen erstellen, ist noch nciht geklrt
* @author Robin
*
*/
public class Ground extends JPanel{
//Die Felder des Spielfeldes
private Field[][] fields = null;
private LinkedList<FreeField> freeFields = null; //Liste mit freien Felden
private LinkedList<PredefField> preFields = null; //Liste mit vorgebenden Feldern
private Field markedOne = null; //DAS EINE markerite Feld
//Länge und Breite des Feldes
private int height = -1, width = -1;
//Liste der Reihen
private LinkedList<Row> rows = null;
//Konstrukoren
/**
* Konstruktor
* erstellt ein Feld mit gegeberner änge und Breite, erzeugt die Felder und
* fügt sie hinzu
* macht weiter erstmal nichts
*/
public Ground(int width, int height){
//Übernehme die Maße
this.width = width;
this.height = height;
//Die Reihenfolge der Größen geprüt und er sah, dass es gut war
this.setLayout(new GridLayout(height, width));
//Erzeuge das Feld von Feldern (jaha, genau so!)
fields = new Field[width][height];
for(int h = 0; h < height; h++){
for (int w = 0; w < width; w++){
fields[w][h] = new Field(this, w,h); //Feld wird erstellt
this.add(fields[w][h]); //Feld wird auf Ground gezogen^^ (Verstehen Sie meine Damen un Herren? Was ist denn da passiert?)
}
}
this.repaint();
//TODO verzweifelter versuch, dass irgendwas passiert
//Feld wird zur Bearbeitung vorbereitet
//is ja irgendwie Quatsch, es gibt ja nur die Defaultfelder im Moment
createFieldLists(); //Erstelle die Listen der Feldtypen
createRows(); //Erzeuge daraus die Reihen
printFieldLists(); //Gib die oben erzeugten Listen zur Kontrolle aus
}
//erzeugt aus den Felden die Reihen
/**
* TODO geht noch nciht --> warum?
*/
private void createRows(){
//erstelle ersmal die Liste, in die die Reihen reinkommen
this.rows = new LinkedList<Row>(); //TODO das hier ist der Übeltäter
Row tempRow = null; //eine leere Reihe, die erstmal beschrieben wird
//und am Ende verlinkt, das macht die Erstellung einfacher
//Welche Felder gehören zu der Reihe
LinkedList<FreeField> fieldz = null;
Field tempField = null;
//klappere alle vorgebenden Felder ab
for (PredefField pfield: preFields){
System.out.println("Es werden nun Reihen erzeugt");
//Das Feld zeigt nach UNTEN -> X-Coord ist konstant
if(pfield.isActive(0)){
//Menge der Felder wird zurückgesetzt
fieldz = new LinkedList<FreeField>();
//Startfeld zum Durchlaufen der Spalte = Nachfolger des pfield
tempField = getField(tempField.get_Coord_X(), tempField.getY()+1);
//erstelle eine neue Reihe
tempRow = new Row(pfield, 1, fieldz);
//suche alle nachfolgenden freien Felder
while(tempField != null && tempField instanceof FreeField){
//dem Feld wird eine Reihe zugewiesen
((FreeField)tempField).addRow(tempRow, 0);
//das nächste Feld wird untersucht
tempField = getField(tempField.get_Coord_X(), tempField.getY()+1);
}
//Erstellte Reihe wird hinzugefügt
rows.add(tempRow);
} //Ende der SPALTE
//Das Feld zeigt nach RECHTS -> Y-Coord ist konstant
if(pfield.isActive(1)){
//Menge der Felder wird zurückgesetzt
fieldz = new LinkedList<FreeField>();
//Startfeld zum Durchlaufen der Zeile = Nachfolger des pfield
tempField = getField(tempField.get_Coord_X(),tempField.getY()+1);
//erstelle eine neue Reihe
tempRow = new Row(pfield, 1, fieldz);
//suche alle nachfolgenden freien Felder
while(tempField != null && tempField instanceof FreeField){
//dem Feld wird eine Reihe zugewiesen
((FreeField)tempField).addRow(tempRow, 1);
//das nächste Feld wird untersucht
tempField = getField(tempField.get_Coord_X()+1,tempField.getY());
}
//Erstellte Reihe wird hinzugefügt
rows.add(tempRow);
} //Ende der ZEILE
} //Ende der Forschleife: alle vorgebenden Felder durch
}
/**
* Ändert den Typ eines Feldes
* @param f welches Feld
* @param type zu welchem Typ
*/
public void changeType(Field f, String type){
if (f==null){ //da kann man nichts machen :D
return;
}
int x = f.get_Coord_X();
int y = f.get_Coord_Y();
Field toChange = this.getField(x, y);
if (type.toUpperCase().equals("FREE")){
toChange = new FreeField(this, x, y);
}
else if (type.toUpperCase().equals("PREDEF")){
toChange = new PredefField(this, x, y);
}
else if (type.toUpperCase().equals("DEFAULT")){
toChange = new Field(this, x, y);
}
else {
System.out.println("No type to change found...");
}
toChange.repaint();
System.out.println(this.getField(x, y).getClass().getName());
//TODO wieder ras
}
/**
* Markiert EIN Feld, demarkiert alle anderen
* @param f das zu markierende Feld
*/
public void markField(Field f){
//setze die Markierung für ALLE Felder erstmal auf false
unmarkAll();
//danach wird die neue markierung gesetzt
markedOne = f;
markedOne.mark();
}
/**
* Demarkeirt alle Felder
*/
private void unmarkAll(){
for (Field[] fa: fields){
for(Field f: fa){
f.unMark();
}
}
}
/**
* Gibt das markerite Feld zurück, eigentlich nur zu Überprüfungszwecken gedacht
* @return
*/
//TODO gaanz am Ende wieder raus
public Field getMarked(){
return markedOne;
}
/**
* Eigene Methode um ArrayIndexOutOfBounds-Exceptions zu verhindern,
* wenns nicht passt, gibts halt ein null zurück
* Ansonsten gehts wie der Arrayzugriff
* @param x x-Koord
* @param y y-Koord
* @return das gesuchte Feld, falls es existiert
*/
private Field getField(int x, int y){
if (x < this.width && y < this.height){
return fields[x][y];
}
else{
return null;
}
//return (x < this.width && y < this.height)?fields[x][y]:null;
//Die coole Einzeilervariante
}
/**
* Erzeugt erstmal die Listen mit den einzelnen Feldarten
*/
private void createFieldLists(){
freeFields = new LinkedList<FreeField>();
preFields = new LinkedList<PredefField>();
//Durchläuft das zweidimensionale Array
for(int l = 0; l < this.height; l++){
for(int w = 0; w <this.width ;w++){
if (fields[w][l] instanceof FreeField){
freeFields.add((FreeField) fields[w][l]);
}
if (fields[w][l] instanceof PredefField){
preFields.add((PredefField) fields[w][l]);
}
}
}
}
private void printFieldLists(){
StringBuffer sb = new StringBuffer();
if (preFields != null){
//Vorgebende Felder
sb.append("Vorgebende:\n");
for(PredefField pField: this.preFields){
sb.append(pField + ", ");
}
sb.append("\n---\n");
}
if(freeFields != null){
//Freie Felder
sb.append("Freie:\n");
for(FreeField fField: this.freeFields){
sb.append(fField + ", ");
}
sb.append("\n---\n");
}
if (rows != null){
//Reihen
sb.append("Reihen: \n");
for (Row r : rows){
sb.append(r+ "\n");
}
sb.append("\n---------------\n");
}
System.out.println(sb.toString());
}
/**
* Prüft ob alle Reihen, wenn die alle passen, dann gibts true zurück
*
* TODO wird am Anfang aufgerufen, ich hab aber keine Ahnung warum
* --> ist Methode von JPanel..., müsste sie also umbenennen
* --> TODO TODO TBD
*/
public boolean check(){
//gibts die reihen überhaupt?
if (fields == null|| freeFields == null || preFields == null || rows == null){
return false;
}
//überprüfe die reihen
for (Row r : rows){
if (r == null || !r.isCorrect()){
return false;
}
}
return true;
}
/**
* Setzt das gesamte Feld zurück,
* die native Resetmethode wird aufgerufen
*/
public void reset(){
if (freeFields != null){
for (FreeField f : freeFields){
f.reset();
}
}
}
/**
* Löst den Plan soweit eindeutig möglich, hauptsächlich durch Ausschluss
*/
public void solve_excluding(){
}
/**
* Löst den Plan vollautomatisch
* 1. über Ausschluss
* 2. wenn nötig über Raten
*/
public void solve_auto(){
//1. Lösen
solve_excluding();
//2. Raten
}
}
