public class StoneModel implements Cloneable {
  boolean[][] rockOn;
  int[][] sum;
  int size, blue, red;
  
  public StoneModel(int size) {
    this.size = size;
    blue = red = 0;
    rockOn = new boolean[size][size];
    sum = new int[size][size];
    for (int x = 0; x < size; x++)
      for (int y = 0; y < size; y++) {
	sum[x][y] = FREE;
	rockOn[x][y] = false;
      };
  }
  
  public StoneModel(StoneModel model) {
    size = model.getSize();
    blue = model.getBlue();
    red = model.getRed();
    rockOn = new boolean[size][size];
    sum = new int[size][size];
    for (int x = 0; x < size; x++)
      for (int y = 0; y < size; y++) {
	sum[x][y] = model.getSum(x, y);
	rockOn[x][y] = model.isRockOn(x, y);
      };
    /* -- a zakey ovo ne radi !?!
       try {
       rockOn = (boolean[][]) model.rockOn.clone();
       sum = (int[][]) model.sum.clone();
       } catch (CloneNotSupportedException e) {
       System.out.println("nece moci");
       };
       -- kraj citata */
  }

  boolean makeMove(int xx, int yy, int player, int side) {
    int maxX = 0, maxY = 0, maxS = 0;
    if (player == 0) return placeRockOn(side, xx, yy);
    
  out: for (int y = 0; y < getSize(); y++)
    for (int x = 0; x < getSize(); x++)
      if (canPlaceRockOn(side, x, y)) {
	StoneModel model = new StoneModel(this);
	model.placeRockOn(side, x, y);
	int s = 0;
	switch (player) {
	case 1:
	  s = 8;
	  break;
	case 2:
	  s = (side == RED)? 
	    (model.getRed() - getRed()): (model.getBlue() - getBlue());
	  break;
	case 3:
	  s = ((side == RED)? (model.getRed() - getRed()):
	       (model.getBlue() - getBlue())) + getFree() - model.getFree();
	  break;
	case 4:
	  s = ((side * -1) * ((model.getRed() - getRed())
			      - (model.getBlue() - getBlue())));
	  break;
	default:
	  return false;
	};
	
	if (maxS <= s) {
	  maxS = s; maxX = x; maxY = y;
	};
	if (maxS * Math.random() > 7.5) break out;
      };
  return placeRockOn(side, maxX, maxY);
  }
  
  public boolean placeRockOn(int side, int x, int y) {
    if (!canPlaceRockOn(side, x, y)) return false;
    if (!incSum(side, x, y)) return false;
    incSum(side, x    , y - 1);
    incSum(side, x    , y + 1);
    incSum(side, x - 1, y - 1);
    incSum(side, x - 1, y    );
    incSum(side, x - 1, y + 1);
    incSum(side, x + 1, y - 1);
    incSum(side, x + 1, y    );
    incSum(side, x + 1, y + 1);
    rockOn[x][y] = true;
    return true;
  }
  
  protected boolean incSum(int r, int x, int y) {
    if (x < 0 || y < 0 || x >= size || y >= size) return false;
    if (r * r > 1) return false;
    if (rockOn[x][y]) return false;
    int oldsum = sum[x][y];
    sum[x][y] += r;
    if (oldsum == FREE) {
      if (r == RED)  red++;
      if (r == BLUE) blue++;
    };
    if (oldsum == RED  && r == BLUE) red--;
    if (oldsum == BLUE && r == RED)  blue--;
    return true;
  }
  
  public int getSum(int x, int y) {
    return sum[x][y];
  }
  
  public int getRed() {
    return red;
  }
  
  public int getBlue() {
    return blue;
  }
  
  public boolean isGameOver() {
    return getFree() == 0;
  }
  
  public int getFree() {
    return size * size - (red + blue);
  }
  
  public boolean isRockOn(int x, int y) {
    return rockOn[x][y];
  }
  
  public boolean canPlaceRockOn(int side, int x, int y) {
    return !isRockOn(x, y) && (sum[x][y] * side >= 0);
  }
  
  public int getSize() {
    return size;
  }
  
  public static final String[] playerNames = { 
    "Human", "Gojkoo", "Matee", "Franjoo", "Ivica"
  };
  
  public static final int RED = -1, FREE = 0, BLUE = 1;
}