package hexenschach.gameplay;
import java.util.prefs.Preferences;
import java.util.ArrayList;
import java.util.StringTokenizer;
import hexenschach.board.Board;
import hexenschach.player.*;
import hexenschach.figures.*;
import hexenschach.gui.UserInterfaceAPI;
/**
* Verwaltet die Möglichkeiten zum Speichern und Laden von Spielständen.
*
* @author Andreas Lorig
* @date 11.05.2010
*/
public class Persistence
{
// Mit der Preferences Klasse werden die Spielstände gespeichert.
private Preferences pref;
// Das Spielbrett
Board board;
/**
* Erstellt ein Spiel aus einem zuvor abgespeichertem Spielstand.
*
* @param gameName Der Name des Spielstandes, welcher geladen werden soll.
* @return ein Gameplay Objekt mit dem Zustand wie im File beschrieben.
*/
public Gameplay loadGame (String gameName, UserInterfaceAPI api)
{
// Der erste Spieler
Player player1;
// Der zweite Spieler
Player player2;
// Der dritte Spieler
Player player3;
// Das Gameplay das später zurück gegeben wird
Gameplay gameplay;
// Brett wird erzeugt
board = new Board();
pref = Preferences.userNodeForPackage(getClass());
// Der Eintrag wird zwischengespeichert. Wird keiner gefunden wird "nix gefunden" zurück gegeben
String loadedGameString = pref.get(gameName, "nix gefunden");
//System.out.println(loadedGameString);
// Ein StringTokenizer teilt den String in kleine Teile
StringTokenizer tokenizer = new StringTokenizer (loadedGameString, ";");
// Der erste String beschreibt den ersten Spieler und ob dieser null, Mensch oder Computer ist
String firstPlayer = tokenizer.nextToken();
if (firstPlayer.equals("null")) // Fall: Der erste Spieler ist schon ausgeschieden
{
player1 = null;
}
else if (firstPlayer.equals("true")) // Fall: Der erste Spieler ist ein Computer
{
int difficulty = Integer.valueOf(tokenizer.nextToken()).intValue();
player1 = new Computer (true, "white", difficulty);
}
else
player1 = new Human (false, "white"); //Fall: Der erste Spieler ist ein Mensch
// Der zweite String beschreibt den zweiten Spieler und ob dieser null, Mensch oder Computer ist
String secondPlayer = tokenizer.nextToken();
if (secondPlayer.equals("null")) // Fall: Der zweite Spieler ist schon ausgeschieden
{
player2 = null;
}
else if (secondPlayer.equals("true")) // Fall: Der zweite Spieler ist ein Computer
{
player2 = new Computer (true, "brown", 1);
}
else
player2 = new Human (false, "brown"); //Fall: Der zweite Spieler ist ein Mensch
// Der dritte String beschreibt den dritten Spieler und ob dieser null, Mensch oder Computer ist
String thirdPlayer = tokenizer.nextToken();
if (thirdPlayer.equals("null")) // Fall: Der dritte Spieler ist schon ausgeschieden
{
player3 = null;
}
else if (thirdPlayer.equals("true")) // Fall: Der dritte Spieler ist ein Computer
{
player3 = new Computer (true, "brown", 1);
}
else
player3 = new Human (false, "brown"); //Fall: Der dritte Spieler ist ein Mensch
// Der vierte String zeigt an welcher Spieler aktuell an der Reihe ist
String currentPlayer = tokenizer.nextToken(); // Die Zahl steht für einen Spieler
// Nach diesen vier festen Strings wird das Board erzeugt
while (tokenizer.hasMoreTokens())
{
// Zwischenspeichern der Koordinate
String coord = tokenizer.nextToken();
// Der zweite Teil des Strings muss immer darauf geprüft werden, ob es sich um einen Bauern handelt
String figure = tokenizer.nextToken();
// Zwischenspeichern des Spielers
String player = tokenizer.nextToken();
if (figure.equals("pawn"))
{
Figure figur;
String direct = tokenizer.nextToken();
int playerEnum = Integer.valueOf(player).intValue();
int direction = Integer.valueOf(direct).intValue();
String moved = tokenizer.nextToken();
boolean wasMoved;
if (moved.equals ("true"))
{
wasMoved = true;
} else wasMoved = false;
// ist es ein Bauer, so wird dieser mit seinem Konstruktor erzeugt
board.boardHM.get(coord).setFigure(figur = new Pawn(this.getPlayerColor(player), playerEnum, direction, wasMoved));
} else
this.setFigures(coord, figure, player);
}
// Der String des aktuellen Spielers wird in einen int gewandelt
int playerEnum2 = Integer.valueOf(currentPlayer).intValue();
// Erzeugen des Gameplays
gameplay = new Gameplay (player1, player2, player3, api, playerEnum2, board);
return gameplay;
}
/**
* Setzt eine Figur auf ein Feld des Spielbrettes
* @param field das Feld auf das die Figur gesetzt wird
* @param figure die Figur die auf das Feld gesetzt wird
* @param player der Spieler dem die Figur gehört
*/
private void setFigures(String field, String newFigure, String newPlayer)
{
Figure figure;
// Abfrage von welcher art die Figur für das Feld sein soll
if (newFigure.equals ("rook"))
{
int playerEnum = Integer.valueOf(newPlayer).intValue();
board.boardHM.get(field).setFigure(figure = new Rook(this.getPlayerColor(newPlayer), playerEnum));
} else if (newFigure.equals ("queen"))
{
int playerEnum = Integer.valueOf(newPlayer).intValue();
board.boardHM.get(field).setFigure(figure = new Queen(this.getPlayerColor(newPlayer), playerEnum));
} else if (newFigure.equals("king"))
{
int playerEnum = Integer.valueOf(newPlayer).intValue();
board.boardHM.get(field).setFigure(figure = new King(this.getPlayerColor(newPlayer), playerEnum));
} else if (newFigure.equals("bishop"))
{
int playerEnum = Integer.valueOf(newPlayer).intValue();
board.boardHM.get(field).setFigure(figure = new Bishop(this.getPlayerColor(newPlayer), playerEnum));
} else if (newFigure.equals("knight"))
{
int playerEnum = Integer.valueOf(newPlayer).intValue();
board.boardHM.get(field).setFigure(figure = new Knight(this.getPlayerColor(newPlayer), playerEnum));
} else if (newFigure.equals("neutral"))
{
board.boardHM.get(field).setFigure(null);
}
}
/**
* Gibt einen String zurück der die Farbe eines Spielers darstellt.
* Dieser wird anhand eines Eingangsstrings der die Werte "1", "2" oder "3" annehmen
* kann bestimmt. Diese Werte repräsentieren die drei Spieler.
* @param player der Spieler dessen Farbe ermittelt werden soll
* @return ein String der die Farbe eines Spielers darstellt ("white", "brown" oder "black")
*/
private String getPlayerColor (String player)
{
// Abfrage zum bestimmen der Farbe der Figuren
if (player.equals("1"))
{
return "White";
} else if (player.equals("2"))
{
return "Brown";
} else if (player.equals("3"))
{
return "Black";
} else return "null";
}
/**
* Speichert einen Spielstand in die Registry.
*
* @param gameName Gewünschter Name des Spielstandes.
* @param context Der Spielstand der gespeichert werden soll.
*/
public void saveGame (String gameName, GameContext context)
{
pref = Preferences.userNodeForPackage(getClass());
// Ist kein gameName angegeben, wird ein default name benutzt
if (gameName == null)
{
gameName = "default";
}
// Unter dem Schlüssel gameName wird der Kontext als String gespeichert
pref.put(gameName, context.toString());
}
/**
* Gibt die gespeicherten Spielstände in einem Array aus Strings zurück.
*
* @return Array mit dem Namen der Spielstände.
*/
public ArrayList <String> getSaveGames ()
{
pref = Preferences.userNodeForPackage (getClass());
// In diese ArrayList sollen die Spielstände gefügt werden
ArrayList <String> aList = new ArrayList <String> ();
// Das Stringarray in dem die ganzen Savegamenamen sind, wird zwischengespeichert
try{
String [] saveList = pref.keys();
for (int i = 0; i < saveList.length; i++)
{
aList.add(saveList[i]);
}
} catch (Exception e)
{
e.printStackTrace();
}
return aList;
}
/**
* Löscht ein Savegame
* @param name Der Name des Feldes
*/
public void deleteSaveGame(String name)
{
pref = Preferences.userNodeForPackage (getClass());
pref.remove(name);
}
}