public class Mensch extends Aerger {

	static int AMOUNT_PLAYERS = 2;  // kann geändert werden (2-4)!
	
	static int[][] figures = new int[4][]; // pro Spieler 1 Array für 4 Steine

	
	public static void main(String[] args) {
		reset();  // Alles auf Anfang, Feld erstmalig zeichnen
		
		
		int currentPlayer = 0; // Spieler, der gerade am Zug ist

		while (true) {
			int steps = dice(); // Würfeln...

			// Spielstein abfragen und Zug durchführen:			
			while (true) {
				int figure = read("Spieler " + (currentPlayer + 1) + " würfelt " 
								  + steps + ". Mit welcher Figur möchtest du um " 
								  + steps + " Felder nach vorne ziehen?");
				figure -= 1;
				
				if (figure < 0 || figure >= 4)  // ungültige Eingabe
					write("Es existieren nur die Figuren 1 bis 4!");
				else if (figures[currentPlayer][figure] >= 40)
					write("Nicht möglich, da die Figur bereits im Garten ist!");
				else if (move(currentPlayer, figure, steps))  // erfolgreich
					break;
				else  // ungültiger Zug
					write("Nicht möglich, denn du besetzt das Zielfeld bereits!");
			}
			
			// Feld mit Änderungen neuzeichnen:
			paintField(figures[0], figures[1], figures[2], figures[3]);
			
			// Prüfen, ob gewonnen:
			if (hasWon(currentPlayer)) {
				if (read("Spieler " + currentPlayer + " hat gewonnen!\n\n"
						+ "Neue Runde? (1 = Ja)") != 1) 
					break;
				// else:
				reset();
			}
			
			// Spieler wechseln:
			currentPlayer = (currentPlayer+1) % AMOUNT_PLAYERS;
		}
	}
	
	/**
	 * Setzt das Array zurück und zeichnet das Anfangsspielfeld.
	 */
	public static void reset() {
		for (int i = 0; i < figures.length; i++)
			figures[i] = new int[] {-1, -1, -1, -1};
		paintField(figures[0], figures[1], figures[2], figures[3]);
	}
	
	/**
	 * Gibt true zurück, falls Spieler <player> gewonnen hat, false sonst.
	 */
	public static boolean hasWon(int player) {
		for (int f : figures[player])
			if (f < 40)  // mindestens einer ist noch nicht im Ziel
				return false;
		return true;
	}

	/**
	 * Setzt Figur Nr. <fig> von Spieler <player> um <steps> Positionen nach vorne,
	 * d. h. die Position des entsprechenden Spielsteins wird verändert. Wird das
	 * Feld bereits blockiert, so wird der andere Spieler geschlagen (kommt ins
	 * Haus zurück). Es muss sichergestellt sein, dass der Stein noch nicht im
	 * Garten ist.
	 * 
	 * @return false, falls Zug nicht möglich (würde sich selbst schlagen);
	 * 		   true, falls erfolgreich (Positionen im Array wurden angepasst)
	 */
	public static boolean move(int player, int fig, int steps) {		
		int firstField = 10*player;
		
		// Potentielle neue Position berechnen, aber alte Position merken:
		int oldPos = figures[player][fig];
		if (oldPos == -1) {  // noch im Haus
			figures[player][fig] = firstField + steps;  // 0tes Feld wird übersprungen!
		} else {
			figures[player][fig] += steps;
			
			int tresholdField = firstField;
			if (player == 0)
				tresholdField = 40;
			
			// Grenzüberschreitung in den Garten?
			if (oldPos < tresholdField && figures[player][fig] >= tresholdField) {
				figures[player][fig] = 40;
				return true;
			}
			
			figures[player][fig] %= 40; // 39 -> 0
		}

		// Überprüfe Gültigkeit (darf sich nicht "selbst schlagen"),
		// und, ob ein anderer geschlagen wird (ggf. durchführen):
		for (int p = 0; p < figures.length; p++) {  // für alle Spieler
			for (int f = 0; f < figures[p].length; f++) {  // alle Figuren
				if (figures[p][f] == figures[player][fig])  { // Feld blockiert
					if (p == player) { // durch aktuellen Spieler
						if (f != fig) { // mit anderer Figur
							figures[player][fig] = oldPos;  // -> nicht möglich
							return false;
						}
					} else {  // durch anderen Spieler
						figures[p][f] = -1;  // -> anderen Spieler schlagen
						return true;
					}
				}
			}
		}
		return true;
	}

}