/*----------------------------------------------------------------------*/
/* Board
                                                                        */
/*----------------------------------------------------------------------*/
/*         Jim Morey -- morey@math.ubc.ca -- February 15, 1997          */
/*----------------------------------------------------------------------*/

import java.io.*;
import java.awt.*;
import java.lang.*;
import java.awt.Color;
import java.net.*;
import Omatrix;
import Vertex;

public class Board{
  final static double Acon=0.292893218,Bcon=0.478072579,R3=1.732050808;
  final static int THRESHOLD=10000000;
  double STONE_RAD=0.04;
  private Vertex verts[][][];
  public int size,W,H,dim[],ncolour=25;
  public double Scale,Zeye=8;
  public Omatrix orient;
  Color colours[][];

  Board(int size_,int wid,int hei) {
    size=size_;
    STONE_RAD/=Math.sqrt(size);
    dim = new int[3];
    dim[0]=2*size+1;
    dim[1]=size+1;
    dim[2]=size;
    orient= new Omatrix();
  
    W = wid / 2;
    H = hei / 2;
 
    int i,j,k;
    verts = new Vertex[dim[0]][dim[1]][dim[2]];
    
    for (k=0;k<dim[2];k++)
      for (j=0;j<dim[1];j++)
        for (i=0;i<dim[0];i++)
          verts[i][j][k] = new Vertex();

    setupBoard();

    centreBoard();
    setScale(wid,hei);
    
    setColours();
    CalcScrPts(H,W,0);
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public void Draw(Graphics offscreen,int x0,int y0,double z,boolean calc){
    if (calc) CalcScrPts((double)x0,(double)y0,z);

    int p[],pn[],c,p1,p2,p3,x[],y[],xdif,ydif,dist;
    double d1,d2,d3;
    boolean n1,n2,n3;
    Vertex here,there;
    p = new int[3];
    pn = new int[3];
    x= new int[4];
    y= new int[4];
    
    d1 = verts[3][0][0].z -verts[2][0][0].z;
    d2 = verts[2][2][0].z -verts[2][0][0].z;
    d3 = verts[2][0][2].z -verts[2][0][0].z;
    n1 = (d1<0);
    n2 = (d2<0);
    n3 = (d3<0);
    d1 = Math.abs(d1);
    d2 = Math.abs(d2);
    d3 = Math.abs(d3);

    if (d3 > d2){
      if (d3 > d1){
        if (d2 > d1){
          p1=2; p2=1; p3=0;
        } else{
          p1=2; p2=0; p3=1;
        }
      } else {
        p1=0; p2=2; p3=1;
      }
    } else{
      if (d2 > d1){
        if (d3 > d1){
           p1=1; p2=2; p3=0;
        } else{
           p1=1; p2=0; p3=2;
        }
      } else {
        p1=0; p2=1; p3=2;
      }
    }

    for (int k=0;k<dim[2];k++)
      for (int j=0;j<dim[1];j++)
        for (int i=0;i<dim[0];i++)
          verts[i][j][k].drawn=false;
    
    for (p[p1]=0;p[p1]<dim[p1];p[p1]++)
      for (p[p2]=0;p[p2]<dim[p2];p[p2]++)
        for (p[p3]=0;p[p3]<dim[p3];p[p3]++){
          if(n1) pn[0] = dim[0]-p[0]-1;
          else pn[0] = p[0];
          if(n2) pn[1] = dim[1]-p[1]-1;
          else pn[1] = p[1];
          if(n3) pn[2] = dim[2]-p[2]-1;
          else pn[2] = p[2];
          here = verts[pn[0]][pn[1]][pn[2]];

          here.drawn=true;
          for (c=0;c<here.ncons;c++){
           
            there = here.connections[c];
            if (!there.drawn){ 
              xdif = here.x - there.x;
              ydif = here.y - there.y;
              dist = (int)Math.sqrt(xdif*xdif +ydif*ydif);
              if (dist==0) dist=1;
              x[0] = here.x - ydif*here.stone/dist;
              x[1] = 2*here.x - x[0];
              y[0] = here.y + xdif*here.stone/dist;
              y[1] = 2*here.y - y[0];
              x[3] = there.x - ydif*there.stone/dist;
              x[2] = 2*there.x - x[3];
              y[3] = there.y + xdif*there.stone/dist;
              y[2] = 2*there.y - y[3];
              offscreen.setColor(getColour(0,(here.z+there.z)/2)); 
              offscreen.fillPolygon(x,y,4);
/*              offscreen.setColor(Color.black); 
              offscreen.drawLine(x[0],y[0],x[3],y[3]);
              offscreen.drawLine(x[1],y[1],x[2],y[2]);
*/
            }
          }
          switch (here.state){
            case Vertex.BLACK:
              offscreen.setColor(getColour(2,here.z)); 
              drawStone(offscreen,here);
              break;
            case Vertex.WHITE:
              offscreen.setColor(getColour(1,here.z)); 
              drawStone(offscreen,here);
              break;
            case Vertex.EMPTY:
              offscreen.setColor(getColour(0,here.z)); 
              offscreen.fillArc(here.x-here.stone,here.y-here.stone,
                  2*here.stone,2*here.stone,0,360);
              break;
            case Vertex.PTR_BLACK:
              offscreen.setColor(getColour(2,here.z)); 
              drawStone(offscreen,here);
              drawPtr(offscreen,here);
              break;
            case Vertex.PTR_WHITE:
              offscreen.setColor(getColour(1,here.z)); 
              drawStone(offscreen,here);
              drawPtr(offscreen,here);
              break;
            case Vertex.PTR_EMPTY:
              offscreen.setColor(getColour(0,here.z)); 
              offscreen.fillArc(here.x-here.stone,here.y-here.stone,
                  2*here.stone,2*here.stone,0,360);
              drawPtr(offscreen,here);
              break;
            default:
          }

        }
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  private void drawPtr(Graphics offscreen,Vertex here){
    offscreen.setColor(Color.red); 
    offscreen.drawArc(here.x-3*here.stone/2,here.y-3*here.stone/2,
        3*here.stone,3*here.stone,0,360);
    offscreen.drawLine(here.x,here.y-3*here.stone,
        here.x,here.y+3*here.stone);
    offscreen.drawLine(here.x-3*here.stone,here.y,
        here.x+3*here.stone,here.y);
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  private void drawStone(Graphics offscreen,Vertex here){
    offscreen.fillArc(here.x-2*here.stone,here.y-2*here.stone,
        4*here.stone,4*here.stone,0,360);
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  Color getColour(int i,double z){
    int thing = (int)((z+0.5)*ncolour); 
    if (thing<0) thing =0;
    if (thing>=ncolour) thing =ncolour-1;
    return colours[i][thing];
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public void setColours(){
    colours = new Color[3][ncolour];
    for (int i=0;i<ncolour;i++){
      colours[0][i]= new Color(225 -(ncolour-1-i)*60/ncolour,
        225 -(ncolour-1-i)*60/ncolour,100);
      colours[1][i]= new Color(255 -(ncolour-1-i)*50/ncolour,255 -(ncolour-1-i)*50/ncolour,255 -(ncolour-1-i)*50/ncolour);
      colours[2][i]= new Color((ncolour-1-i)*100/ncolour,(ncolour-1-i)*100/ncolour,(ncolour-1-i)*100/ncolour);
/*      colours[0][i]= new Color(225 -(ncolour-1-i)*80/ncolour,
        225 -(ncolour-1-i)*80/ncolour,225 -(ncolour-1-i)*80/ncolour);
      colours[1][i]= new Color(255 -(ncolour-1-i)*100/ncolour,0,0);
      colours[2][i]= new Color(i*100/ncolour,i*100/ncolour,i*100/ncolour);
*/
    }
  }
 
 /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public void CalcScrPts(double x,double y,double z){
    int i,j,k;
    Vertex here;
    double persp;
 
    for (k=0;k<dim[2];k++)
      for (j=0;j<dim[1];j++)
        for (i=0;i<dim[0];i++){
          here = verts[i][j][k];
          here.z = here.coord[0]*orient.M[2][0] +
                   here.coord[1]*orient.M[2][1] +
                   here.coord[2]*orient.M[2][2] + z;
          persp = (Zeye - here.z)/(Scale*Zeye);
          if (persp == 0){
            System.out.println("Solid: CalcScrPts: Problems with persp = 0!");
            persp = 0.01;
          }
          here.x = (int)((here.coord[0]*orient.M[0][0] +
                          here.coord[1]*orient.M[0][1] +
                          here.coord[2]*orient.M[0][2])/persp + x);
          here.y = (int)((here.coord[0]*orient.M[1][0] +
                          here.coord[1]*orient.M[1][1] +
                          here.coord[2]*orient.M[1][2])/persp + y);
          here.stone = (int)(STONE_RAD/persp); 
       }
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public Vertex PointerAt(int x,int y){
    int mindist,dist,xdif,ydif;
    Vertex min,here;
 
    mindist = 100000000;
    dist =0;
    min = verts[0][0][0];
    for (int k=0;k<dim[2];k++)
      for (int j=0;j<dim[1];j++)
        for (int i=0;i<dim[0];i++){
          here = verts[i][j][k];
          xdif =here.x-x; 
          ydif =here.y-y; 
          dist = xdif*xdif+ydif*ydif;
          if (dist<mindist){  
            mindist = dist;
            min = here;
          } 
        }
    if (mindist<THRESHOLD) return min;
    else return null;
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */

  void setupBoard() {
    int i,j,k;
    /* .. lop off corners .. */

    for (i=0;i<size-1;i++){
      for (j=0;j<size-1-i;j++){
        for (k=0;k<size-1-j-i;k++){
          verts[i][size-j][k].state = Vertex.N_USED;
          verts[2*size-i][size-j][k].state = Vertex.N_USED;
          verts[i][j][size-1-k].state = Vertex.N_USED;
          verts[2*size-i][j][size-1-k].state = Vertex.N_USED;
        }
      }
    }

    Vertex here;
    verts[0][0][0].state= Vertex.EMPTY;
    for (k=0;k<dim[2];k++)
      for (j=0;j<dim[1];j++)
        for (i=0;i<dim[0];i++){
          here = verts[i][j][k];
          if (here.state != Vertex.N_USED){
            if ((i+j+k)%2==1){
              if (inArray(i-1,j,k))
                Vertex.giveCoord(here,verts[i-1][j][k],-Bcon,R3*Bcon,-Acon);
              if (inArray(i+1,j,k))
                Vertex.giveCoord(here,verts[i+1][j][k],Bcon*2,0.0,-Acon);
              if (inArray(i,j-1,k))
                Vertex.giveCoord(here,verts[i][j-1][k],-Bcon,-R3*Bcon,-Acon);
              if (inArray(i,j,k+1))
                Vertex.giveCoord(here,verts[i][j][k+1],0.0,0.0,1.0);
            }
            else{
              if (inArray(i-1,j,k))
                Vertex.giveCoord(here,verts[i-1][j][k],-Bcon*2,0.0,Acon);
              if (inArray(i+1,j,k))
                Vertex.giveCoord(here,verts[i+1][j][k],Bcon,-R3*Bcon,Acon);
              if (inArray(i,j+1,k))
                Vertex.giveCoord(here,verts[i][j+1][k],Bcon,R3*Bcon,Acon);
              if (inArray(i,j,k-1))
                Vertex.giveCoord(here,verts[i][j][k-1],0.0,0.0,-1.0);
            }
          }
        }
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  void centreBoard(){
    int i,j,k,c;
    double[][] bound;

    bound = new double[3][2];
    double len;
    for (i=0;i<3;i++){
      bound[i][0]= 100000;
      bound[i][1]= -100000;
    }

    for (k=0;k<dim[2];k++)
      for (j=0;j<dim[1];j++)
        for (i=0;i<dim[0];i++)
          for (c=0;c<3;c++){
            if (bound[c][0]> verts[i][j][k].coord[c]) 
              bound[c][0] = verts[i][j][k].coord[c];
            if (bound[c][1]< verts[i][j][k].coord[c]) 
              bound[c][1] = verts[i][j][k].coord[c];
          }
 
    double max=0;
    for (i=0;i<3;i++){
      max+= (bound[i][1]-bound[i][0])*(bound[i][1]-bound[i][0]);
      bound[i][0] = (bound[i][0]+bound[i][1])/2;
    }
    max = Math.sqrt(max)/2.4;
    for (k=0;k<dim[2];k++)
      for (j=0;j<dim[1];j++)
        for (i=0;i<dim[0];i++)
          for (c=0;c<3;c++){
            verts[i][j][k].coord[c]-=bound[c][0];
            verts[i][j][k].coord[c]/=max;
          }
  } 
  
  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  void setScale(int W,int H){
    if (W>H) Scale= (double)H/2;
    else Scale= (double)W/2;
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  boolean inArray(int i,int j, int k){
    return ((i>=0 && i<dim[0])&&(j>=0 && j<dim[1])&&(k>=0 && k<dim[2]));
  }

  /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */
  public String toString() {
    String str;
    int i,j,k;
    str = "";

    for (k=0;k<dim[2];k++){
      for (j=0;j<dim[1];j++){
        for (i=0;i<dim[0];i++){
          switch (verts[i][j][k].state){
            case Vertex.BLACK:
              str = str.concat("+");
              break;
            case Vertex.WHITE:
              str = str.concat("o");
              break;
            case Vertex.EMPTY:
              str = str.concat("'");
              break;
            default:
              str = str.concat(" ");
          }
        }
        str = str.concat("\n"); 
      }
      str = str.concat("\n"); 
    }

    return str;
  }
}