import dibo.*;

//--------------------------------------------------------------
// Klasse Metamorphose-Spiel (Metamorphose) / Hauptprogramm
//--------------------------------------------------------------

public class Metamorphose {

// Attribute
  protected MetamorphoseSpieler spieler_a, spieler_b;
  protected MetamorphoseBrett brett;
  protected MetamorphoseRegeln regeln;

// Methoden
 
  // Konstruktor (Initialisierung eines Spiels)
  public Metamorphose(MetamorphoseSpieler a, 
                      MetamorphoseSpieler b, 
                      MetamorphoseBrett   brett, 
                      MetamorphoseRegeln  regeln
                     ) {
    this.spieler_a = a; 
    this.spieler_b = b;
    this.brett = brett; 
    this.regeln = regeln;
  }

  // Hauptprogramm; 
  // hier startet das Metamorphose-Programm
  public static void main(String[] args) {
    MetamorphoseSpieler a = 
      new MetamorphoseSpieler(MetamorphoseSpieler.WEISS);
    MetamorphoseSpieler b = 
      new MetamorphoseProgramm(MetamorphoseSpieler.SCHWARZ);
    MetamorphoseBrett brett = new MetamorphoseBrett();
    MetamorphoseRegeln regeln = new MetamorphoseRegeln(brett);

    Metamorphose metamorphose = new Metamorphose(a,b,brett,regeln);
    metamorphose.spielen();
  }

  // Durchfuehrung eines Spiels
  public void spielen() {
    // Spieler A beginnt
    MetamorphoseSpieler akt_spieler = this.spieler_a;
    MetamorphoseSpielzug zug = null;

    // Koenige eingeben:
    int spalte = this.spieler_a.liefereKoenig();
    this.brett.liefereFigur(6, spalte).setzeKoenig();

    spalte = this.spieler_b.liefereKoenig();
    this.brett.liefereFigur(0, spalte).setzeKoenig();

    this.brett.gebeSpielbrettAus();
 
 
    // abwechselndes Ziehen bis Spielende erreicht ist
    do {
      if (akt_spieler == this.spieler_a) 
        System.out.println("Spieler A ist am Zug!");
      else 
        System.out.println("Spieler B ist am Zug!");

      // legalen Spielzug ermitteln und ausfuehren
      MetamorphoseSpielzug gegner_zug = zug;
      zug = akt_spieler.liefereNaechstenSpielzug(gegner_zug);
      while (!this.regeln.spielzugOK(zug, akt_spieler))
      {
        System.out.println("Ungueltig; neue Eingabe!");
        zug = akt_spieler.liefereNaechstenSpielzug(gegner_zug);
      }
      this.brett.fuehreSpielzugAus(zug);
      this.brett.gebeSpielbrettAus();
 
      // der andere Spieler ist nun ab Zug
      if (akt_spieler == spieler_a)
        akt_spieler = this.spieler_b;
      else
        akt_spieler = this.spieler_a;
    } while (!this.regeln.spielEnde());
 
    // Spiel ist zuende
    this.regeln.gebeSiegerBekannt();
  }

}


//-----------------------------------------------------
// Klasse Metamorphose-Brett (MetamorphoseBrett)
//-----------------------------------------------------

class MetamorphoseBrett {

// Konstanten
  public final static int GROESSE = 7;

// Attribute
  protected MetamorphoseFigur[][] brett;

// Methoden 
  // Konstruktor (Initialisierung des Metamorphose-Brettes)
  public MetamorphoseBrett() { 
    // Brett erzeugen
    this.brett = new MetamorphoseFigur[GROESSE][GROESSE];

    // die mittleren Felder sind leer
    for (int z=1; z<6; z++) 
      for (int s=0; s<GROESSE; s++) 
        this.brett[z][s] = null;

    // Erzeugung und Aufstellung der Figuren
    this.brett[0][0] = 
      new MetamorphoseFigur(MetamorphoseFigur.B_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 0, 0, this);
    this.brett[0][1] = 
      new MetamorphoseFigur(MetamorphoseFigur.B_FIGUR,
                            MetamorphoseFigur.KREIS,
                            false, 0, 1, this);
    this.brett[0][2] = 
      new MetamorphoseFigur(MetamorphoseFigur.B_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 0, 2, this);
    this.brett[0][3] = 
      new MetamorphoseFigur(MetamorphoseFigur.B_FIGUR,
                            MetamorphoseFigur.KREIS,
                            false, 0, 3, this);
    this.brett[0][4] = 
      new MetamorphoseFigur(MetamorphoseFigur.B_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 0, 4, this);
    this.brett[0][5] = 
      new MetamorphoseFigur(MetamorphoseFigur.B_FIGUR,
                            MetamorphoseFigur.KREIS,
                            false, 0, 5, this);
    this.brett[0][6] = 
      new MetamorphoseFigur(MetamorphoseFigur.B_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 0, 6, this);
                     
    this.brett[6][0] = 
      new MetamorphoseFigur(MetamorphoseFigur.A_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 6, 0, this);
    this.brett[6][1] = 
      new MetamorphoseFigur(MetamorphoseFigur.A_FIGUR,
                            MetamorphoseFigur.KREIS,
                            false, 6, 1, this);
    this.brett[6][2] = 
      new MetamorphoseFigur(MetamorphoseFigur.A_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 6, 2, this);
    this.brett[6][3] = 
      new MetamorphoseFigur(MetamorphoseFigur.A_FIGUR,
                            MetamorphoseFigur.KREIS,
                            false, 6, 3, this);
    this.brett[6][4] = 
      new MetamorphoseFigur(MetamorphoseFigur.A_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 6, 4, this);
    this.brett[6][5] = 
      new MetamorphoseFigur(MetamorphoseFigur.A_FIGUR,
                            MetamorphoseFigur.KREIS,
                            false, 6, 5, this);
    this.brett[6][6] = 
      new MetamorphoseFigur(MetamorphoseFigur.A_FIGUR,
                            MetamorphoseFigur.QUADRAT,
                            false, 6, 6, this);
                     
  } 

  // Ausfuehrung eines Spielzugs auf dem Brett
  public void fuehreSpielzugAus(MetamorphoseSpielzug zug) { 
    this.brett[zug.vonWelcherZeile()][zug.vonWelcherSpalte()].ziehen(zug);

    this.brett[zug.nachWelcherZeile()][zug.nachWelcherSpalte()] =
      this.brett[zug.vonWelcherZeile()][zug.vonWelcherSpalte()];
    this.brett[zug.vonWelcherZeile()][zug.vonWelcherSpalte()] = null;
  } 

  // Ausgabe des aktuellen Spielbretts
  public void gebeSpielbrettAus() { 
    System.out.println();
    System.out.println("  Spieler B");
    System.out.println();
    System.out.print("  ");
    for (int j=0; j<GROESSE; j++) {
      System.out.print(j); System.out.print(" ");
    }
    System.out.println();

    System.out.print("-");
    for (int j=0; j<GROESSE; j++) 
      System.out.print("--");
    System.out.println();
 
    for (int i=0; i<GROESSE; i++) {
      System.out.print(i);
      System.out.print("|");
      for (int j=0; j<GROESSE; j++) {
        if (this.brett[i][j] == null) {
          if (this.belegtDurchMauer(i, j)) {
            System.out.print("M");
          } else {
            System.out.print(" ");
          }
        } else if (this.brett[i][j].istAFigur()) {
          if (this.brett[i][j].istQuadrat()) {
            System.out.print("Q");
          } else {
            System.out.print("K");
          }
        } else {
          if (this.brett[i][j].istQuadrat()) {
            System.out.print("q");
          } else {
            System.out.print("k");
          }
        }
        System.out.print("|");
      }  
      System.out.println();
 
      System.out.print("-");
      for (int j=0; j<GROESSE; j++) 
        System.out.print("--");
      System.out.println();
    } 
    System.out.println();
    System.out.println("  Spieler A");
    System.out.println();
  }

  // Lieferung der Figur an der Stelle zeile/spalte
  public MetamorphoseFigur liefereFigur(int zeile, int spalte) { 
    return this.brett[zeile][spalte];
  }

  // Uebepruefung, ob an der Stelle zeile/spalte eine Mauer steht
  public boolean belegtDurchMauer(int zeile, int spalte) { 
    return 
      (zeile == 1) && (spalte == 1) ||
      (zeile == 1) && (spalte == 3) ||
      (zeile == 1) && (spalte == 5) ||
      (zeile == 3) && (spalte == 0) ||
      (zeile == 3) && (spalte == 2) ||
      (zeile == 3) && (spalte == 4) ||
      (zeile == 3) && (spalte == 6) ||
      (zeile == 5) && (spalte == 1) ||
      (zeile == 5) && (spalte == 3) ||
      (zeile == 5) && (spalte == 5);
  }

}

//-----------------------------------------------------
// Klasse Metamorphose-Figur (MetamorphoseFigur)
//-----------------------------------------------------

class MetamorphoseFigur {

// Konstanten
  public final static boolean A_FIGUR = MetamorphoseSpieler.WEISS;
  public final static boolean B_FIGUR = MetamorphoseSpieler.SCHWARZ;

  public final static boolean QUADRAT = true;
  public final static boolean KREIS   = false;

// Attribute
  protected boolean a_oder_b;         // a == true
  protected boolean quad_oder_kreis;  // quadrat == true
  protected boolean ist_koenig;       // Koenig?
  protected int zeile;                // 0 - 6
  protected int spalte;               // 0 - 6
  protected MetamorphoseBrett brett;

// Methoden
  public MetamorphoseFigur(boolean           a_oder_b,
                           boolean           quad_oder_kreis,
                           boolean           ist_koenig,
                           int               zeile, 
                           int               spalte,
                           MetamorphoseBrett brett
                          ) {
    this.a_oder_b = a_oder_b; 
    this.quad_oder_kreis = quad_oder_kreis; 
    this.ist_koenig = ist_koenig; 
    this.brett = brett;
    this.zeile = zeile; 
    this.spalte = spalte;
  }

  public boolean istAFigur() { return this.a_oder_b; }
  public boolean istBFigur() { return !this.a_oder_b; }

  public boolean istQuadrat() { return this.quad_oder_kreis; }
  public boolean istKreis() { return !this.quad_oder_kreis; }

  public boolean istKoenig() { return this.ist_koenig; }
  public void setzeKoenig() { this.ist_koenig = true; }

  public int welcheZeile() { return this.zeile; }
  public int welcheSpalte() { return this.spalte; }

  public void ziehen(MetamorphoseSpielzug zug) {
    this.zeile = zug.nachWelcherZeile();
    this.spalte = zug.nachWelcherSpalte();
    this.quad_oder_kreis = !this.quad_oder_kreis;
  }

}


//-----------------------------------------------------
// Klasse Metamorphose-Regeln (MetamorphoseRegeln)
//-----------------------------------------------------

class MetamorphoseRegeln {

// Attribute
  protected MetamorphoseBrett brett;
  protected MetamorphoseFigur geschlagene_figur;

// Methoden
  // Konstruktor (Initialisierung der Regeln)
  public MetamorphoseRegeln(MetamorphoseBrett brett) {
    this.brett = brett;
  }

  // Ueberpruefung eines Spielzugs
  public boolean spielzugOK(MetamorphoseSpielzug zug,
                            MetamorphoseSpieler  spieler
                           ) {
    return this.spielzugOK(zug, spieler.istSpielerA());
  }

  // Ueberpruefung eines Spielzugs
  public boolean spielzugOK(MetamorphoseSpielzug zug,
                            boolean              ist_a
                           ) {
    if (zug == null) return false;

    int von_zeile = zug.vonWelcherZeile();
    int von_spalte = zug.vonWelcherSpalte();
    int nach_zeile = zug.nachWelcherZeile();
    int nach_spalte = zug.nachWelcherSpalte();

    // Koordinaten ok
    if ((von_zeile < 0) || (von_zeile >= MetamorphoseBrett.GROESSE))
      return false;
    if ((von_spalte < 0) || (von_spalte >= MetamorphoseBrett.GROESSE))
      return false;
    if ((nach_zeile < 0) || (nach_zeile >= MetamorphoseBrett.GROESSE))
      return false;
    if ((nach_spalte < 0) || (nach_spalte >= MetamorphoseBrett.GROESSE))
      return false;

    // auf Mauern duerfen keine Figuren gezogen werden
    if (this.brett.belegtDurchMauer(nach_zeile, nach_spalte))
      return false;

    // es besteht Zugzwang
    if ((von_zeile == nach_zeile) && (von_spalte == nach_spalte))
      return false;

    MetamorphoseFigur figur = 
      this.brett.liefereFigur(zug.vonWelcherZeile(), zug.vonWelcherSpalte());

    if (figur == null)
      return false;

    // es duerfen nur eigene Figuren gezogen werden
    if (figur.istAFigur() != ist_a)
      return false;

    // Quadrate duerfen nur horizontal und vertikal bewegt werden
    // und es duerfen keine Mauern und Figuren uebersprungen werden
    if (figur.istQuadrat()) {
      if ((von_zeile != nach_zeile) && (von_spalte != nach_spalte))
        return false;
      if (von_zeile == nach_zeile) {
        int s_abstand = von_spalte-nach_spalte;
        for (int i=1; i<abs(s_abstand); i++) {
          int s = (s_abstand>0)?-i:+i;
          if ((this.brett.liefereFigur(von_zeile, von_spalte+s) != null) ||
              (this.brett.belegtDurchMauer(von_zeile, von_spalte+s)))
            return false;
        }
      } else { // von_spalte == nach_spalte
        int z_abstand = von_zeile-nach_zeile;
        for (int i=1; i<abs(z_abstand); i++) {
          int z = (z_abstand>0)?-i:+i;
          if ((this.brett.liefereFigur(von_zeile+z, von_spalte) != null) ||
              (this.brett.belegtDurchMauer(von_zeile+z, von_spalte)))
            return false;
        }
      }
    } else { // Figur ist Kreis
      // Kreise duerfen nur diagonal bewegt werden
      // und es duerfen keine Mauern und Figuren uebersprungen werden
      int z_abstand = 0;
      int s_abstand = 0;
      if (abs(z_abstand=von_zeile-nach_zeile) != 
          abs(s_abstand=von_spalte-nach_spalte))
        return false;
      for (int i=1; i<abs(z_abstand); i++) {
        int z = (z_abstand>0)?-i:+i;
        int s = (s_abstand>0)?-i:+i;
        if ((this.brett.liefereFigur(von_zeile+z, von_spalte+s) != null) ||
            (this.brett.belegtDurchMauer(von_zeile+z, von_spalte+s)))
          return false;
      }
    }

    this.geschlagene_figur = 
      this.brett.liefereFigur(zug.nachWelcherZeile(), zug.nachWelcherSpalte());

    // es duerfen keine eigenen Figuren geschlagen werden
    if ((this.geschlagene_figur != null) && 
        (this.geschlagene_figur.istAFigur() == ist_a)
       )
      return false;

    return true;
  }

  // Ueberpruefung des Spielendes
  public boolean spielEnde() {
    if (!this.zuegeMoeglich(MetamorphoseSpieler.WEISS))
      return true;

    if (!this.zuegeMoeglich(MetamorphoseSpieler.SCHWARZ))
      return true;

    if ((this.geschlagene_figur != null) && this.geschlagene_figur.istKoenig())
      return true;

    int anzahl = 0;
    for (int z=0; z<MetamorphoseBrett.GROESSE; z++) {
      for (int s=0; s<MetamorphoseBrett.GROESSE; s++) {
        if (this.brett.liefereFigur(z, s) != null) {
          anzahl++;
        }
      }
    }

    if (anzahl <= 2) {
      this.geschlagene_figur = null;
      return true;
    }

    return false;
  }

  // Ausgabe des Siegers
  public void gebeSiegerBekannt() {
    if (!this.zuegeMoeglich(MetamorphoseSpieler.WEISS)) {
      System.out.println("Spieler B hat gewonnen!");
      return;
    }

    if (!this.zuegeMoeglich(MetamorphoseSpieler.SCHWARZ)) {
      System.out.println("Spieler A hat gewonnen!");
      return;
    }

    if (this.geschlagene_figur == null) {
      System.out.println("Unentschieden!");
    } else if (this.geschlagene_figur.istAFigur()) {
      System.out.println("Spieler B hat gewonnen!");
    } else {
      System.out.println("Spieler A hat gewonnen!");
    }
  }

  private static int abs(int value) {
    return (value > 0)?(value):(-value);
  }

  private boolean zuegeMoeglich(boolean ist_a)
  {
    for (int z=0; z<MetamorphoseBrett.GROESSE; z++) {
      for (int s=0; s<MetamorphoseBrett.GROESSE; s++) {
        if ((this.brett.liefereFigur(z, s) != null) &&
            (this.brett.liefereFigur(z, s).istAFigur() == ist_a)
           ) {
          for (int z2=0; z2<MetamorphoseBrett.GROESSE; z2++) {
            for (int s2=0; s2<MetamorphoseBrett.GROESSE; s2++) {
              MetamorphoseSpielzug zug =
                new MetamorphoseSpielzug(z, s, z2, s2);
              if (this.spielzugOK(zug, ist_a)) {
                return true;
              }  
            }
          }
        }
      }  
    }
    return false;
  }

}


//-----------------------------------------------------
// Klasse Metamorphose-Spielzug (MetamorphoseSpielzug)
//-----------------------------------------------------

class MetamorphoseSpielzug {

// Attribute
  protected int von_zeile;   // 0 - 6
  protected int von_spalte;  // 0 - 6

  protected int nach_zeile;  // 0 - 6
  protected int nach_spalte; // 0 - 6
 
// Methoden
  // Konstruktor (Initialisierung eines Spielzugs)
  public MetamorphoseSpielzug(int von_zeile, 
                              int von_spalte,
                              int nach_zeile,
                              int nach_spalte
                             ) {
    this.von_zeile = von_zeile; 
    this.von_spalte = von_spalte;
    this.nach_zeile = nach_zeile; 
    this.nach_spalte = nach_spalte;
  }

  public int vonWelcherZeile() { return this.von_zeile; }

  public int vonWelcherSpalte() { return this.von_spalte; }

  public int nachWelcherZeile() { return this.nach_zeile; }

  public int nachWelcherSpalte() { return this.nach_spalte; }

}
 

//-----------------------------------------------------
// Klasse Metamorphose-Spieler (MetamorphoseSpieler)
//-----------------------------------------------------

class MetamorphoseSpieler {

// Konstanten
  public final static boolean WEISS   = true;
  public final static boolean SCHWARZ = false;

// Attribute
  protected boolean ist_spieler_a;

// Methoden 
  // Konstruktor (Initialisierung eines Spielers)
  public MetamorphoseSpieler(boolean a_oder_b) {
    this.ist_spieler_a = a_oder_b;
  }

  // Ueberpruefung, ob es Spieler A ist
  public boolean istSpielerA() { 
    return this.ist_spieler_a; 
  }

  // Ueberpruefung, ob es Spieler B ist
  public boolean istSpielerB() { 
    return !this.istSpielerA(); 
  }

  // erfragt die initiale Spaltenposition des Koenigs
  public int liefereKoenig() {
    System.out.println("Spieler A: Koenig?");
    System.out.println("Spalte eingeben (0-6): ");
    int spalte = Terminal.readInt();
    while ((spalte < 0) || (spalte >= MetamorphoseBrett.GROESSE)) {
      System.out.println("Ungueltig; neue Eingabe!");
      spalte = Terminal.readInt();
    }
    return spalte;
  }

  // erfragt und liefert naechsten Spielzug des 
  // Spielers; uebergeben wird der letzte Zug des
  // Gegners (bzw. null beim ersten Zug)
  public MetamorphoseSpielzug 
   liefereNaechstenSpielzug (MetamorphoseSpielzug gegner_zug) { 
    return this.erfrageNaechstenSpielzugBeimSpieler(); 
  } 
 
  // erfragt naechsten Spielzug beim Spieler
  protected 
   MetamorphoseSpielzug erfrageNaechstenSpielzugBeimSpieler() {
    System.out.println("von Zeile eingeben (0-6): ");
    int von_zeile = Terminal.readInt();
    System.out.println("von Spalte eingeben (0-6): ");
    int von_spalte = Terminal.readInt();
    System.out.println("nach Zeile eingeben (0-6): ");
    int nach_zeile = Terminal.readInt();
    System.out.println("nach Spalte eingeben (0-6): ");
    int nach_spalte = Terminal.readInt();
    return new MetamorphoseSpielzug(von_zeile, von_spalte, 
                                    nach_zeile, nach_spalte);
  }

}


//-----------------------------------------------------
// Klasse Metamorphose-Programm (MetamorphoseProgramm)
//-----------------------------------------------------

class MetamorphoseProgramm 
  extends MetamorphoseSpieler
{

// Attribute
  protected MetamorphoseBrett brett;
  protected MetamorphoseRegeln regeln;
 
// Methoden 
  // Konstruktor (Initialisierung eines Spielers)
  public MetamorphoseProgramm(boolean a_oder_b) {
    super(a_oder_b);
    this.brett = new MetamorphoseBrett();
    this.regeln = new MetamorphoseRegeln(this.brett);
  }

  // erfragt die initiale Spaltenposition des Koenigs
  public int liefereKoenig() {
    return (java.lang.Math.abs(new java.util.Random().nextInt())) %
             MetamorphoseBrett.GROESSE;
  }

  // erfragt und liefert naechsten Spielzug des 
  // Spielers; uebergeben wird der letzte Zug des
  // Gegners (bzw. null beim ersten Zug)
  public MetamorphoseSpielzug 
   liefereNaechstenSpielzug (MetamorphoseSpielzug gegner_zug) { 
    if (gegner_zug != null)
      this.brett.fuehreSpielzugAus(gegner_zug);
 
    MetamorphoseSpielzug eigener_zug = this.ermittleNaechstenSpielzug();
    this.brett.fuehreSpielzugAus(eigener_zug);
    return eigener_zug;
  }
 
  // berechnet naechsten Spielzug
  // (keine Strategie, nur blindes drauflos spielen)
  protected MetamorphoseSpielzug ermittleNaechstenSpielzug() {
    for (int i=0; i<MetamorphoseBrett.GROESSE; i++) {
      for (int j=0; j<MetamorphoseBrett.GROESSE; j++) {
        for (int k=0; k<MetamorphoseBrett.GROESSE; k++) {
          for (int l=0; l<MetamorphoseBrett.GROESSE; l++) {
            MetamorphoseSpielzug zug = 
              new MetamorphoseSpielzug(i, j, k, l);
            if (this.regeln.spielzugOK(zug, this)) {
              return zug;
            }
          }
        }
      }  
    }  
    return null; // nicht moeglich

  } 
 
}