import java.awt.*;
import java.applet.*;
import GameState;

class RevPoint
{
  public int x;
  public int y;

  public RevPoint(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}

class RevState extends GameState {
  static final int EMPTY = 0; 
  static final int RED = 1;
  static final int BLUE = -1;
  static final int WIDTH = 8;
  static final int HEIGHT = WIDTH;
  static final int XS = WIDTH/2 - 1;
  static final int YS = HEIGHT/2 - 1;

  protected int [][] A;
  protected int activeColor;
 
  RevState () {
    A = new int [WIDTH][HEIGHT];
  }

  public void reset (int color) {
    for (int x=0; x<WIDTH; x++)
      for (int y=0; y<WIDTH; y++)
        A[x][y] = EMPTY;
        
    A[XS][YS] = BLUE;
    A[XS+1][YS] = RED;
    A[XS][YS+1] = RED;
    A[XS+1][YS+1] = BLUE;
    activeColor = color;
  }

  protected int nmoves (int color) {
    int n, x, y;
    n = 0;
    for (x=0; x<WIDTH; x++)
      for (y=0; y<HEIGHT; y++)
        if (isValidMove (x, y, color)) n++;
    return n;
  }

  public int nMoves()  { return nmoves (activeColor); }

  public void copy (RevState source) {
    for (int x=0; x<WIDTH; x++)
      for (int y=0; y<HEIGHT; y++)
        A[x][y] = source.A[x][y];
    activeColor = source.activeColor;
  }

  public GameState move (int i) { 
    RevState state = new RevState ();
    state.copy (this);

    RevPoint p = moveX(i);

    state.doMove (p.x, p.y); 
    return state;
  }

  public RevPoint moveX(int i) // gibt das Feld zurueck, auf dem der i-te
  {                            // Zug stattfinden kann
    int n = -1;

    for(int x = 0; x < WIDTH; x++)
      for(int y = 0; y < HEIGHT; y++)
      {
         if(isValidMove(x, y, activeColor))
           n++;

         if(n == i)
           return new RevPoint(x, y);
      }

    return new RevPoint(-1, -1);
  }

  public void doMove (int x, int y) {
    int a, b, u, v;
    for (u = -1; u<2; u++)
      for (v = -1; v<2; v++) {
        a = x+u;
        b = y+v;
        if (a >=0 && a<WIDTH && b>=0 && b<HEIGHT && A[a][b] == -activeColor) {                                                    // gegnerischer Nachbar
          while (a >=0 && a<WIDTH && b>=0 && b<HEIGHT && A[a][b] == -activeColor) {                                              // gegnerische Steine abgehen
            a += u;
            b += v;
          }
          if (a >=0 && a<WIDTH && b>=0 && b<HEIGHT && A[a][b] == activeColor)
            while (a != x || b != y) {
              A[a][b] = activeColor;
              a -= u;
              b -= v;    
            }
        }
      }   
    A[x][y] = activeColor; 
    activeColor = - activeColor;
  }

  public boolean isValidMove (int x, int y, int color) {
    int a, b, u, v;
    if (x>=0 && x<WIDTH && y>=0 && y<HEIGHT && A[x][y] == EMPTY) {
      for (u = -1; u<2; u++)
        for (v = -1; v<2; v++) {
          a = x+u;
          b = y+v;
          if (a >= 0 && a<WIDTH && b>=0 && b<HEIGHT && A[a][b] == -color) {                                            // gegnerischer Nachbar
            while (a >=0 && a<WIDTH && b>=0 && b<HEIGHT && A[a][b] == -color) {                                       // gegnerische Steine abgehen
              a += u;
              b += v;
            }
            if (a >=0 && a<WIDTH && b>=0 && b<HEIGHT && A[a][b] == color)                                             // es muß ein eigener Stein folgen
              return true;
          }
        }
    }
    return false;
  }

  public int column (int x) {
    return x / 40;
  }

  public int row (int y) {
    return (y-30) / 40;
  }

  private int stoneDiff()
  {
    int d = 0;

    for(int x = 0; x < WIDTH; x++)
      for(int y = 0; y < HEIGHT; y++)
        d += A[x][y];

    return d;
  }
 
  public void paint (Applet app, Graphics g) {
	g.setColor(Color.black);
	g.drawLine(0, 30, 0, 350);
	g.drawLine(0, 30, 320, 30);

    for (int x=0; x<WIDTH; x++)
      for (int y=0; y<HEIGHT; y++) {
        g.setColor (Color.black);
        g.drawLine ((x+1)*40, 30, (x+1)*40, 350);
        g.drawLine (0, (y+1)*40+30, 320, (y+1)*40+30); 
        
        switch (A[x][y]) {
            case RED: g.setColor (Color.red); break;
            case BLUE: g.setColor (Color.blue); break;
        }
        if (A[x][y] != EMPTY) g.fillOval (x*40+5, y*40+35, 30, 30);
      }

    if (nmoves(activeColor) == 0) {
      if (stoneDiff() == 0)
        app.showStatus ("Remis");
      else if (stoneDiff() < 0)
        app.showStatus ("Blau hat gewonnen");
      else
        app.showStatus ("Rot hat gewonnen");
    }
    else if (activeColor == RED)
      app.showStatus("Computer (rot) ist am Zug");
    else
      app.showStatus("Mensch (blau) ist am Zug");
  }

  // value()

/**********
  public int value()
  {
    int v = 0;

    for(int x = 0; x < WIDTH; x++)
      for(int y = 0; y < HEIGHT; y++)
        v += A[x][y];

    return v;
  }
**********/

  private int nFree()
  {
    int f = 0;

    for(int x = 0; x < WIDTH; x++)
      for(int y = 0; y < HEIGHT; y++)
        if(A[x][y] == EMPTY)
          f++;

    return f;
  }

  public int value() // advanced
  {
    int v = 0;
    int f = nFree();

    for(int x = 0; x < WIDTH; x++)
      for(int y = 0; y < HEIGHT; y++)
        if(x == 0 || x == WIDTH-1 || y == 0 || y == HEIGHT-1) // Randfeld
          if((x == 0 && y == 0) || (x == 0 && y == HEIGHT-1) ||
             (x == WIDTH-1 && y == 0) || (x == WIDTH-1 && y == HEIGHT-1))
               // Ecke
               v += 4 * A[x][y] * f;
          else // normales Randfeld
            v += A[x][y] * f;
        else if((x == 1 && y == 1) || (x == 1 && y == HEIGHT-2) ||
                (x == WIDTH-2 && y == 1) || (x == WIDTH-1 && y == HEIGHT-2))
                  // diagonal zu einer Ecke
                  v += 2 * A[x][y] * f;
        else // normales Feld
          v += A[x][y];

    return v;
  }

}