Commit 741859e9 authored by alexander.waehling's avatar alexander.waehling
Browse files

Presets added Package: towerwarspp

parents
package towerwarspp.preset;
import java.util.HashMap;
/**
* Ein simpler Parser fuer Kommandozeilen Parameter.
* <h1>Verwendung</h1>
* <p>
* Erzeuge innerhalb deiner ausfuehrbaren Klasse eine Instanz dieser Klasse
* und uebergib im Konstruktor die Kommandozeilenargumente. Verwende diesen
* ArgumentParser um auf Kommandozeilen Parameter zu reagieren.
* </p>
* <p>
* Kommandozeilen Parameter sind entweder Schalter oder Einstellungen.
* </p>
* <h2>Schalter</h2>
* <p>
* Ein Schalter ist entweder ein- oder ausgeschaltet. Dementsprechend kann sein
* Zustand in einem {@code boolean} abgelegt werden. Schalter sind zu Beginn
* ausgeschaltet. Ein Schalter wird ueber den Parameter {@code --SCHALTERNAME}
* aktiviert. Ein Schalter kann ueber Kommandozeilen Parameter nicht deaktiviert
* werden, da er zu Beginn ohnehin deaktiviert ist.
* </p>
* <h2>Einstellungen</h2>
* <p>
* Eine Einstellung hat einen Namen und einen Wert. Ein gutes Beispiel ist hier
* die Spielfeldgroesse. Der Name dieser Einstellung ist {@code size}
* und der Wert kann eine Zahl zwischen {@code 6} und {@code 26} sein.
* Der Typ einer Einstellung richtet sich nach der Einstellung. Die Einstellung
* {@code size} zum Beispiel ist ein {@code int}. Einstellungen werden auf der
* Kommandozeile mit {@code -NAME WERT} gesetzt.
* </p>
* <p>
* Wird ein Schalter oder eine Einstellung abgefragt die nicht eingelesen wurde,
* wird eine {@link ArgumentParserException} geworfen, auf die sinnvoll reagiert
* werden muss.
* </p>
* <p>
* Alle Schalter und Einstellungen in dieser Klasse duerfen nicht geaendert
* werden. Es ist jedoch erlaubt weitere Schalter oder Einstellungen
* hinzuzufuegen,
* dies ist im Quellcode kenntlich gemacht.
* </p>
*
* @author Dominick Leppich
*/
public class ArgumentParser {
private HashMap<String, Object> params;
// ------------------------------------------------------------
/**
* Erzeuge einen neuen ArgumentParser aus einem String-Array mit
* Parametern. Hier sollte einfach das {@code args}
* Argument der {@code main}-Methode weitergerreicht werden.
*
* @param args
* Argumente
*
* @throws ArgumentParserException
* wenn das Parsen der Argumente fehlschlaegt
*/
public ArgumentParser(String[] args) throws ArgumentParserException {
params = new HashMap<>(); parseArgs(args);
}
// ------------------------------------------------------------
/**
* Parse die Argumente.
*
* @param args
* Argumente
*
* @throws ArgumentParserException
* wenn das Parsen der Argumente fehlschlaegt
*/
private void parseArgs(String[] args) throws ArgumentParserException {
// Index to parse
int index = 0;
try {
while (index < args.length) {
// Check if argument is a flag or setting
if (args[index].startsWith("--")) {
addFlag(args[index].substring(2)); index += 1;
}
else if (args[index].startsWith("-")) {
addSetting(args[index].substring(1), args[index + 1]);
index += 2;
}
else
throw new ArgumentParserException("Error parsing: " +
args[index]);
}
} catch (IndexOutOfBoundsException e) {
throw new ArgumentParserException("Missing parameter");
}
}
/**
* Fuege einen Schalter hinzu.
*
* @param flag
* Schalte
*
* @throws ArgumentParserException
* wenn der Schalter nicht existiert
*/
private void addFlag(String flag) throws ArgumentParserException {
// Check if a param with this name already exists
if (params.containsKey(flag))
throw new ArgumentParserException("Param already exists: " + flag);
params.put(flag, new Boolean(true));
}
/**
* Fuege eine Einstellung hinzu.
*
* @param key
* Name
* @param value
* Wert
*
* @throws ArgumentParserException
* wenn die Einstellung nicht existiert oder der Wert ein
* ungueltiges Format hat
*/
private void addSetting(String key, String value) throws
ArgumentParserException {
// Check if a param with this name already exists
if (params.containsKey(key))
throw new ArgumentParserException("Param already exists: " + key);
if (value.startsWith("-"))
throw new ArgumentParserException("Setting value wrong format: "
+ value);
params.put(key, value);
}
// ------------------------------------------------------------
/**
* Pruefe ob ein Parameter gesetzt ist.
*
* @param parameter
* Zu pruefender Parameter
*
* @return wahr, wenn der Parameter gesetzt wurde
*/
public boolean isSet(String parameter) {
return params.containsKey(parameter);
}
/**
* Gib den Wert eines Schalters zurueck.
*
* @param flag
* Name des Schalters
*
* @return Wert
*
* @throws ArgumentParserException
* wenn der Schalter den falschen Typ hat (falls eine Einstellung
* versucht wird als Schalter auszulesen)
*/
protected boolean getFlag(String flag) throws ArgumentParserException {
if (!params.containsKey(flag))
return false;
Object o = params.get(flag); if (!(o instanceof Boolean))
throw new ArgumentParserException("This is not a flag");
return (Boolean) params.get(flag);
}
/**
* Gib den Wert einer Einstellung als {@link Object} zurueck.
*
* @param key
* Name der Einstellung
*
* @return Wert als {@link Object}.
*
* @throws ArgumentParserException
* wenn die Einstellung nicht existiert
*/
protected Object getSetting(String key) throws ArgumentParserException {
if (!params.containsKey(key))
throw new ArgumentParserException("Setting " + key + " not " +
"defined");
return params.get(key);
}
// ------------------------------------------------------------
/**
* Interpretiere einen Spielertypen
*
* @param type
* Eingelesener Typ
*
* @return Spielertyp als {@link PlayerType}
*
* @throws ArgumentParserException
* wenn der eingelese Typ nicht passt
*/
private PlayerType parsePlayerType(String type) throws
ArgumentParserException {
switch (type) {
case "human": return PlayerType.HUMAN;
case "random": return PlayerType.RANDOM_AI;
case "simple": return PlayerType.SIMPLE_AI;
case "adv1": return PlayerType.ADVANCED_AI_1;
case "adv2": return PlayerType.ADVANCED_AI_2;
case "adv3": return PlayerType.ADVANCED_AI_3;
case "adv4": return PlayerType.ADVANCED_AI_4;
case "adv5": return PlayerType.ADVANCED_AI_5;
default: throw new ArgumentParserException("Unknown player type: " +
"" + type);
}
}
// ------------------------------------------------------------
public boolean isLocal() throws ArgumentParserException {
return getFlag("local");
}
public boolean isNetwork() throws ArgumentParserException {
return getFlag("network");
}
public boolean isGraphic() throws ArgumentParserException {
return getFlag("graphic");
}
public int getSize() throws ArgumentParserException {
return Integer.parseInt((String) getSetting("size"));
}
public int getDelay() throws ArgumentParserException {
return Integer.parseInt((String) getSetting("delay"));
}
public PlayerType getRed() throws ArgumentParserException {
return parsePlayerType((String) getSetting("red"));
}
public PlayerType getBlue() throws ArgumentParserException {
return parsePlayerType((String) getSetting("blue"));
}
// ********************************************************************
// Hier koennen weitere Schalter und Einstellungen ergaenzt werden...
// ********************************************************************
}
package towerwarspp.preset;
public class ArgumentParserException extends Exception {
public ArgumentParserException() {
}
public ArgumentParserException(String msg) {
super(msg);
}
public ArgumentParserException(String msg, Throwable cause) {
super(msg, cause);
}
}
package towerwarspp.preset;
import java.io.Serializable;
public class Move implements Serializable {
private Position start;
private Position end;
// ------------------------------------------------------------
public Move(Position start, Position end) {
setStart(start);
setEnd(end);
}
public Move(Move move) {
if (move == null)
throw new IllegalArgumentException("move == null");
setStart(move.getStart());
setEnd(move.getEnd());
}
// ------------------------------------------------------------
public Position getStart() {
return start;
}
private void setStart(Position start) {
if (start == null)
throw new IllegalArgumentException("start == null");
this.start = start;
}
public Position getEnd() {
return end;
}
private void setEnd(Position end) {
if (end == null)
throw new IllegalArgumentException("end == null");
this.end = end;
}
// ------------------------------------------------------------
public static Move parseMove(String str) throws IllegalArgumentException,
MoveFormatException {
if (str == null)
throw new IllegalArgumentException("str == null");
// Surrender move
if (str.isEmpty())
return null;
try {
String[] params = str.split("->");
return new Move(Position.parsePosition(params[0]),
Position.parsePosition(params[1]));
} catch (IndexOutOfBoundsException | PositionFormatException e) {
throw new MoveFormatException("Error parsing: \"" + str + "\"", e);
}
}
@Override
public String toString() {
return getStart() + "->" + getEnd();
}
@Override
public int hashCode() {
return getStart().hashCode() ^ getEnd().hashCode();
}
@Override
public boolean equals(Object o) {
if (o == null)
return false;
if (!(o instanceof Move))
return false;
Move m = (Move) o;
return m.getStart().equals(getStart()) && m.getEnd().equals(getEnd());
}
}
package towerwarspp.preset;
public class MoveFormatException extends IllegalArgumentException {
public MoveFormatException(String msg) {
super(msg);
}
public MoveFormatException(String msg, Throwable cause) {
super(msg, cause);
}
}
\ No newline at end of file
package towerwarspp.preset;
public interface Player {
Move request() throws Exception;
void confirm(Status boardStatus) throws Exception;
void update(Move opponentMove, Status boardStatus) throws Exception;
void init(int size, PlayerColor color) throws Exception;
}
package towerwarspp.preset;
public enum PlayerColor {
RED, BLUE
}
package towerwarspp.preset;
public enum PlayerType {
HUMAN,
RANDOM_AI,
SIMPLE_AI,
ADVANCED_AI_1,
ADVANCED_AI_2,
ADVANCED_AI_3,
ADVANCED_AI_4,
ADVANCED_AI_5
}
package towerwarspp.preset;
import java.io.Serializable;
public class Position implements Serializable {
private int letter, number;
// ------------------------------------------------------------
public Position(int letter, int number) {
setLetter(letter);
setNumber(number);
}
public Position(Position position) {
if (position == null)
throw new IllegalArgumentException("position == null");
setLetter(position.getLetter());
setNumber(position.getNumber());
}
// ------------------------------------------------------------
public int getLetter() {
return letter;
}
private void setLetter(int letter) {
if (letter <= 0 || letter > 26)
throw new IllegalArgumentException("letter " + letter + " out of range!");
this.letter = letter;
}
public int getNumber() {
return number;
}
private void setNumber(int number) {
if (number <= 0 || number > 26)
throw new IllegalArgumentException("number " + number + " out of range!");
this.number = number;
}
// ------------------------------------------------------------
public static Position parsePosition(String str)
throws IllegalArgumentException, PositionFormatException {
if (str == null)
throw new IllegalArgumentException("str == null");
try {
return new Position(Character.toUpperCase(str.charAt(0)) - 'A' + 1,
Integer.parseInt(str.substring(1)));
} catch (IndexOutOfBoundsException | NumberFormatException e) {
throw new PositionFormatException("Error parsing: \"" + str + "\"", e);
}
}
@Override
public String toString() {
return "" + (char) (getLetter() + 'A' - 1) + getNumber();
}
@Override
public int hashCode() {
return Integer.hashCode(getLetter()) ^ Integer.hashCode(getNumber());
}
@Override
public boolean equals(Object o) {
if (o == null)
return false;
if (!(o instanceof Position))
return false;
Position p = (Position) o;
return p.getLetter() == getLetter() && p.getNumber() == getNumber();
}
}
package towerwarspp.preset;
public class PositionFormatException extends IllegalArgumentException {
public PositionFormatException(String msg) {
super(msg);
}
public PositionFormatException(String msg, Throwable cause) {
super(msg, cause);
}
}
package towerwarspp.preset;
public interface Requestable {
Move deliver() throws Exception;
}
package towerwarspp.preset;
import java.io.Serializable;
public enum Status implements Serializable {
OK, RED_WIN, BLUE_WIN, ILLEGAL
}
package towerwarspp.preset;
public interface Viewable {
Viewer viewer();
}
package towerwarspp.preset;
public interface Viewer {
int getSize();
int getTurn();
Status getStatus();
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment