/*
Will Dietz
dtzTech.com
(c) 2004
This is subject to the GNU GPL license
see http://www.gnu.org/licenses/gpl.txt 
for a copy of the license
*/

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class App7 extends Applet implements ActionListener
{
	Timer t;
	final double FRAMERATE = 50,CUBE=10; //Frames per second
	final double SCALE_K=150*CUBE,SCALE_C=20*CUBE,SCALE_A=1.8;
	final int WIDTH = 1024, HEIGHT = 768;
	final double PI=Math.PI,ANGLE=30.0;
	public final int CX = WIDTH/2,CY = HEIGHT/2;//Middle of screen
	public final double ROTFACTOR=4,MOVFACTOR=6,ANG=.4;
	public final double PX=0,PY=800,PZ=1;
	public final double FACTOR = .2,CLOSERANGE=30;
	public Point PP= new Point(PX,PY,PZ);//,VP= new Point(PX,PY-200,PZ-100);
	public final double OFFX = 0, OFFY = -PY,OFFZ = -PZ;
	public Point LP= new Point(PX,PY,PZ);
	public Point OP = new Point(0,0,0),origin = new Point(0,0,0);
	public KeyStates key;
	public Vector vDir;
	public double[] arr,cc;
	public final int NUMOFCUBES=9;
	Prism c[] = new Prism[NUMOFCUBES];
	Face f[] = new Face[NUMOFCUBES*6];
	public void init()
	{
	//	for (int a=0;a<NUMOFCUBES;a++)
	//	{
	//		c[a] = new Prism(new Point(-150+20*a,-10,-10),new Point(-140+20*a,10,10),new Color(8*a,0,255-8*a));
	//	} 
		c[0] = makePrism(7,0,0,5,2,2,Color.blue,0);
		c[1] = makePrism(6,0,2,5,2,4,Color.blue,1);
		c[2] = makePrism(3,0,0,2,2,4,Color.red,2);
		c[3] = makePrism(4,0,2,3,2,3,Color.red,3);
		c[4] = makePrism(2,0,2,1,2,3,Color.red,4);
		c[5] = makePrism(0,0,0,-3,2,1,Color.cyan,5);
		c[6] = makePrism(0,0,2,-3,2,3,Color.cyan,6);
		c[7] = makePrism(-0.5,0,1,-1.5,2,1.5,Color.cyan,7);
		c[8] = makePrism(-1.5,0,1.5,-2.5,2,2,Color.cyan,8);
		Buffer.img = createImage(WIDTH,HEIGHT);
		Buffer.g = Buffer.img.getGraphics();
	
		key = new KeyStates();
		t = new Timer((int)(1000.0/FRAMERATE),this);
		t.start();
		addKeyListener(key);
		for (int a=0;a<NUMOFCUBES;a++)
			for (int b=0;b<6;b++)
				f[a*6+b]=c[a].f[b];
	}
	public Prism makePrism(double x1,double y1,double z1,double x2,double y2,double z2,Color col,int a)
		{
			return new Prism(new Point(x1*CUBE,y1*CUBE,z1*CUBE),new Point(x2*CUBE,y2*CUBE,z2*CUBE), col,a);
		} 

	public Face[] sort(Face[] arr)
	{
		double len = arr.length;
		int a,b;
		Face tmp;
		Face[] fce = new Face[(int)len];
		boolean done = false;
		for (a=0;a<len;a++)
		{
			arr[a].updMins();
			fce[a]=arr[a];
		}
		while(!done)
		{
//			System.out.println();
			done = true;
			for (a=0;a<len-1;a++)
			{
				b = fce[a].compareTo(fce[a+1]);
			//	System.out.println(b);
				if (b>0)//is this farther??
				{
					tmp = fce[a];
					fce[a] = fce[a+1];
					fce[a+1]=tmp;
					done = false;
				}
			}
		}
		System.out.println("sort done");
		return fce;
	}
    public double[] bubbleSort(double[] dbl)
	{
		double[] arr = new double[dbl.length];
		for (int a=0;a<dbl.length;a++)
		{
			arr[a]=dbl[a];
		}
		double tmp;
		boolean done = false;
		while(!done)
		{
			done = true;
			for(int a=0;a<arr.length-1;a++)
				if (arr[a]>arr[a+1])
				{//SWITCH:
					tmp = arr[a];
					arr[a]=arr[a+1];
					arr[a+1]=tmp;
					done = false;
				}
		}
		return arr;
	}

	public void paint(Graphics g)
	{
	//	updateObjs();

		Point lpp1,lpp2;
		Buffer.g.setColor(Color.black);
		Buffer.g.fillRect(0,0,WIDTH,HEIGHT);

		
//		Prism[] psm = sort(c);
		Face[] fce = sort(f);
//		for (int a=NUMOFCUBES-1;a>=0;a--)
//			for (int b=0;b<NUMOFCUBES;b++)
//				if (cc[b]==arr[a]&&isInView(c[b].center)) c[b].draw(Buffer.g); //cc[b]>1
		for (int a=fce.length-1;a>=0;a--)
			if (isInView(fce[a].center()))fce[a].draw(Buffer.g);
		
		
		g.drawImage(Buffer.img,0,0,this);
	}
	public boolean isMoveInvalid(double x,double y,double z)
	{
		Point p = new Point(PP.x+x,PP.y+y,PP.z+z);
		boolean bool;
		for (int i=0;i<NUMOFCUBES;i++)
		{
			bool=c[i].isTooClose(p);
			if (bool)return true;
		}
		return false;
	}
	public boolean isInView(Point p)
	{
		Vector v1= new Vector(PP,p);
		return (v1.getCosofAngle(vDir)>ANG);
	}
	public void actionPerformed(ActionEvent ae)
	{
		updateObjs();
		paint(this.getGraphics());
	}
	void mov()
	{
		double yDiff=0;
		if (key.UP && arr[0]>CLOSERANGE)yDiff=-MOVFACTOR;//PP.y-=MOVFACTOR;
		if (key.DOWN)yDiff=MOVFACTOR;//PP.y+=MOVFACTOR;
		if (key.LEFT)rot(-ROTFACTOR,PP);//PP.x++;
		if (key.RIGHT)rot(ROTFACTOR,PP);//PP.x--;
		if(!isMoveInvalid(0,yDiff,0))PP.y+=yDiff;
	//	Point p = new Point(PP.x,PP.y+yDiff,PP.z);
		cc = new double[NUMOFCUBES];
		for (int count=0;count<NUMOFCUBES;count++)
			cc[count] = c[count].center.dist(PP); //Shortest dist to cube
		arr = bubbleSort(cc);
//
//		if(arr[0]>CLOSERANGE)PP.y+=yDiff;
	}
	void updateObjs()
	{
		mov();
		
		
		LP = PP;
		vDir = new Vector(OP,PP);
		OP = new Point(PP.x-OFFX,PP.y-OFFY,PP.z-OFFZ);
		for (double a=0;a<NUMOFCUBES;a++)
		//		c[(int)a].rot(a/5,origin);
			c[(int)a].update(); 
	}
	public void rot(double d,Point relO)
	{
		for (int a=0;a<NUMOFCUBES;a++)
			c[a].rot(d,relO);
		origin.rot(d,relO);
	}
	class Prism implements Comparable
	{
		Point[] p = new Point[8];
		Point[] p2D = new Point[8];
		Face [] f = new Face[6];
		double[] dist;
		double minX;
		double minY;
		double minZ;
		Point center;
		final double LIMIT=.001;
		public Prism(Point pp1, Point pp2, Color col,int a)
		{//p1 and p2 are opp corners of the cube
			double x1=pp1.x,y1=pp1.y,z1=pp1.z,x2=pp2.x,y2=pp2.y,z2=pp2.z;
			Point p1=new Point(x1,y1,z1);
			Point p7=new Point(x2,y2,z2);
			Point p3=new Point(x2,y1,z2),p4=new Point(x2,y1,z1),p5=new Point(x1,y2,z1),
			p6=new Point(x1,y2,z2),p2=new Point(x1,y1,z2),p8=new Point(x2,y2,z1);
			p[0]=p1;
			p[1]=p2;
			p[2]=p3;
			p[3]=p4;
			p[4]=p5;
			p[5]=p6;
			p[6]=p7;
			p[7]=p8;
			update2D();
			f[0] = new Face(new int[] {1,2,3,4},p,p2D,col,a);
			f[1] = new Face(new int[] {5,6,7,8},p,p2D,col,a);
			f[2] = new Face(new int[] {4,3,7,8},p,p2D,col,a);
			f[3] = new Face(new int[] {1,2,6,5},p,p2D,col,a);
			f[4] = new Face(new int[] {2,6,7,3},p,p2D,col,a);
			f[5] = new Face(new int[] {1,5,8,4},p,p2D,col,a);
			dist = new double[4];
			update();
		}
		public int compareTo(Object obj)//is this obj closer than the obj passed??
		{
			Prism psm=(Prism)obj;
	//		Point oo = new Point (0,0,0);
	//		return ((new Point(minX,minY,minZ)).dist(oo)<(new Point(psm.minX,psm.minY,psm.minZ)).dist(oo))?1:-1;
		//	if (true)return -1;
			double dx1= minX,dy1=minY,dz1=minZ;
			double dx2=psm.minX,dy2=psm.minY,dz2=psm.minZ;
	//		double xy1 = Math.sqrt(dx1*dx1+dy1*dy1),xy2=Math.sqrt(dx2*dx2+dy2*dy2);
			int xx=doubleComp(dx1,dx2),yy=doubleComp(dy1,dy2),zz=doubleComp(dz1,dz2);
	//		int xy = doubleComp(xy1,xy2);
	//		if (xy!=0)return xy;
			if (yy!=0)return -yy;
			if (xx!=0)return xx;
			if (zz!=0)return zz;
			return -1; 
		}
		int doubleComp(double dbl1,double dbl2)
		{
			return (Math.abs(dbl1-dbl2)<LIMIT)?0:((dbl1>dbl2+LIMIT)?1:-1);
		}

		public void rot(double d,Point relO)
		{
			for (int a=0;a<8;a++)
			{
				p[a].rot(d,relO);
			}
			update();
		}
		void update()
		{
			update2D();
		 for (int a=0;a<4;a++)
		 	dist[a]=f[a].getDist(PP);
		 dist=bubbleSort(dist);
		 center = p[0].midPoint(p[6]);
		 updMins();
		}
		void updMins()
		{
			minX=10000000;
			minY=10000000;
			minZ=10000000;
			for (int a=0;a<4;a++)
			{
				f[a].updMins();	
				if (f[a].minX<minX)minX=f[a].minX;
				if (f[a].minY<minY)minY=f[a].minY;
				if (f[a].minZ<minZ)minZ=f[a].minZ;
			}
		}
		boolean isTooClose(Point pointp)
		{
			double minD=10000000,dis;
		for (int a=0;a<4;a++)
		{
			dis = Math.abs(f[a].getDist(pointp));	
		 	if (minD>dis)minD=dis;
		}
		 return (minD<CLOSERANGE);
		}
		void update2D()
		{
		 for (int a=0;a<8;a++)
		 {
		 	p2D[a]=p[a].point2D();
		 }
		}
}
	class Face
		{
		//	int[] p;
			int[] p;
			int len;
			Point[] pp,p2;
		//	Color faceColor;
			int red,green,blue,a;
		//	Color shade;
			Color shade;
			public double minX,minY,minZ,maxX,maxY,maxZ;
			final double LIMIT=.001;
			public boolean equals(Face f)
			{
				return (f.p==p&&f.pp==pp);
			}
			public int compareTo(Object obj)//is this obj closer than the obj passed??
			{
				Face psm=(Face)obj;
				Point c1=centerDist(),c2=psm.centerDist();
				Point o = new Point(0,0,0);
				double dist1 = c1.dist(o), dist2 = c2.dist(o);
			//	double dist1 = (new Point(minX,minY,minZ)).dist(PP);
			//	double dist2 = (new Point(psm.minX,psm.minY,psm.minZ)).dist(PP);
				return doubleComp(dist1,dist2);
	 		//	Point oo = new Point (0,0,0);
			//	return ((new Point(minX,minY,minZ)).dist(oo)<(new Point(psm.minX,psm.minY,psm.minZ)).dist(oo))?1:-1;
			//	if (true)return -1;	
	//			double dx1= minX,dy1=minY,dz1=minZ;
	//			double dx2=psm.minX,dy2=psm.minY,dz2=psm.minZ;
			//	double xy1 = Math.sqrt(c1.x*c1.x+c1.y*c1.y),xy2=Math.sqrt(c2.x*c2.x+c2.y*c2.y);
	/*			int xx=doubleComp(c1.x,c2.x),yy=doubleComp(c1.y,c2.y),zz=doubleComp(c1.z,c2.z);
			//	int xy = doubleComp(xy1,xy2);
				if (yy!=0)return yy;
		//		if (xy!=0)return xy;
				if (xx!=0)return xx;
				if (zz!=0)return zz;
				return -1; */
			}
			int doubleComp(double dbl1,double dbl2)
			{
				if (Math.abs(dbl1-dbl2)<LIMIT) return 0;
				if (dbl1>dbl2) return 1;
				return -1;
			//	return (Math.abs(dbl1-dbl2)<LIMIT)?0:((dbl1>dbl2+LIMIT)?1:-1);
			}
			public Face(int[] pts,Point[] ppp,Point[] pp2,Color col,int aa)
			{
				a=aa;
				len=pts.length;
				p = pts;
				for (int a=0;a<len;a++)
					p[a]--;
				pp=ppp;
				p2=pp2;
				red = col.getRed();
				green = col.getGreen();
				blue = col.getBlue();
			}
			public Point center()
			{
				double xx=0,yy=0,zz=0;
				for (int a=0;a<len;a++)
				{
					xx+=getPoint(a).x;
					yy+=getPoint(a).y;
					zz+=getPoint(a).z;
				}
				xx/=len;
				yy/=len;
				zz/=len;
				Point c = new Point(xx,yy,zz);
				return c;
			}
			public Point centerDist()
			{
				double xx=0,yy=0,zz=0;
				for (int a=0;a<len;a++)
				{
					xx+=getPoint(a).x;
					yy+=getPoint(a).y;
					zz+=getPoint(a).z;
				}
				xx/=len;
				yy/=len;
				zz/=len;
				xx = Math.abs(xx-PP.x);
				yy = Math.abs(yy-PP.y);
				zz = Math.abs(zz-PP.z);
				Point c = new Point(xx,yy,zz);
				return c;
			}
			void updMins()
			{
/*				minX=10000000;
				minY=10000000;
				minZ=10000000;
				Point pointp;
				for (int a=0;a<len;a++)
				{
					pointp=getPoint(a);	
					if (pointp.distX(PP)<minX)minX=pointp.distX(PP);
					if (pointp.distY(PP)<minY)minY=pointp.distY(PP);
					if (pointp.distZ(PP)<minZ)minZ=pointp.distZ(PP);
				}*/
				double  xx=0,yy=0,zz=0,xxx,yyy,zzz;
//				Point min = new Point(pp[p[0]]),
//					  max = new Point(pp[p[0]]);
				Point min = pp[p[0]],max= new Point(0,0,0);
				min = new Point(Math.abs(min.x-PP.x),Math.abs(min.y-PP.y),Math.abs(min.z-PP.z));
				for (int a=1;a<len;a++)
				{
					xx = Math.abs(pp[p[a]].x-PP.x);
					yy = Math.abs(pp[p[a]].y-PP.y);
					zz = Math.abs(pp[p[a]].z-PP.y);
					if (xx>max.x)max.x=xx;
					if (yy>max.y)max.y=yy;
					if (zz>max.z)max.z=zz;
					if (xx<min.x)min.x=xx;
					if (yy<min.y)min.y=yy;
					if (zz<min.z)min.z=zz;
				}
				xx = PP.x;
				yy = PP.y;
				zz = PP.z;
				if (xx>max.x)xx=max.x;
				if (yy>max.y)yy=max.y;
				if (zz>max.z)zz=max.z;
				if (xx<min.x)xx=min.x;
				if (yy<min.y)yy=min.y;
				if (zz<min.z)zz=min.z;
				minX = Math.abs(xx-PP.x);
				minY = Math.abs(yy-PP.y);
				minZ = Math.abs(zz-PP.z);
				xx = Math.abs(min.x-PP.x);
				yy = Math.abs(min.y-PP.y);
				zz = Math.abs(min.z-PP.z);
				xxx = Math.abs(max.x-PP.x);
				yyy = Math.abs(max.y-PP.y);
				zzz = Math.abs(max.z-PP.z);
				maxX = xx>xxx?xx:xxx;
				maxY = yy>yyy?yy:yyy;
				maxZ = zz>zzz?zz:zzz;
			}
			public Point getPoint(int index)
			{
				return pp[p[index]];
			}
			public Point get2DPoint(int index)
			{
				return p2[p[index]];
			}
			public void draw(Graphics graph)
			{
				int b = a/6;
				Point center=c[a].center;
				Point[] pp2 = new Point[len];
				Vector norm,light;
				for (int a=0;a<len;a++)
					pp2[a]=get2DPoint(a);
				int xx1=(int)pp2[0].x+CX,yy1=-(int)pp2[0].y+CY,xx2=(int)pp2[1].x+CX,yy2=-(int)pp2[1].y+CY;
				int xx3=(int)pp2[2].x+CX,yy3=-(int)pp2[2].y+CY,xx4=(int)pp2[3].x+CX,yy4=-(int)pp2[3].y+CY;
				norm = new Vector(center,center());
				light = new Vector(center(),LP);
				double shadeFactor = light.getCosofAngle(norm);
				shadeFactor = (shadeFactor+1)/2;
				int rr=(int)(red*shadeFactor),gg=(int)(green*shadeFactor),bb=(int)(blue*shadeFactor);
				Color shade = new Color(rr,gg,bb);
				int[] arrx = {xx1,xx2,xx3,xx4},arry={yy1,yy2,yy3,yy4};
				graph.setColor(shade);
				graph.fillPolygon(arrx,arry,len);
				graph.drawPolygon(arrx,arry,len);
			}
			public double getDistLP()
			{
				return getDist(PP);
			}
			public double getDist(Point pointp)
			{
				return pointp.dist(this.center());
			}

			
		}
		class Point
		{
			public double x,y,z;
			public Point(double xx,double yy,double zz)
			{
				x=xx;
				y=yy;
				z=zz;
			}
			public Point(Point p)
			{
				x = p.x;
				y = p.y;
				z = p.z;
			}
			public void rot(double d,Point p)
			{
			x-=p.x;
			y-=p.y;
			double theta,xx,yy;
			theta = d*PI/180;
			xx = x*Math.cos(theta)-y*Math.sin(theta);
			yy = y*Math.cos(theta)+x*Math.sin(theta);
			x=xx;
			y=yy;
			x+=p.x;
			y+=p.y;
			}
			public Point point2D()
			{
/*				double xd,yd,zd,xx,yy,scale;
				xd = PP.x-x;
				yd = y-PP.y;
				zd = PP.z-z;
				scale = Math.pow(SCALE_A,(yd+SCALE_K)/SCALE_C);
				xx = scale*xd;
				yy = -scale*zd;*/
				double xp,yp,zp,xx,yy,t;
				Vector vO = new Vector(this,OP);
				Vector vL = new Vector(this,PP);
				Vector vP = new Vector(OP,PP);
				t = vP.dotProduct(vO)/vP.dotProduct(vL);
				xp = x+ vL.xx*t;
				yp = y + vL.yy*t;
				zp = z + vL.zz*t;
				xx = xp-OP.x;
				yp -= OP.y;
				yy = Math.sqrt(Math.pow(yp,2)+Math.pow(zp-OP.z,2))*Math.abs(yp)/yp;
				return new Point(FACTOR*xx,FACTOR*yy,0);
			}
			public String toString()
			{
				String s = x+","+y+","+z;
				return s;
			}
			public double distX(Point p)
			{
				return Math.abs(p.x-x);
			}
			public double distY(Point p)
			{
				return Math.abs(p.y-y);
			} 
			public double distZ(Point p)
			{
				return Math.abs(p.z-z);
			}
			public double dist(Point p)
			{
			 double xx,yy,zz;
			 xx = (x-p.x)*(x-p.x);
			 yy = (y-p.y)*(y-p.y);
			 zz = (z-p.z)*(z-p.z);
			 return Math.sqrt(xx+yy+zz);
			}
			public Point midPoint(Point p)
			{
				return new Point((x+p.x)/2.0,(y+p.y)/2.0,(z+p.z)/2.0);
			}

	}
	public class Vector
	{
		double xx,yy,zz;
	/*	public Vector(Point p1,Point p2,Point p3)
		{//creates Vector normal to plane defined by three points
			double x1,x2,y1,y2,z1,z2;
			x1 = p2.x-p1.x;
			x2 = p3.x-p1.x;
			y1 = p2.y-p1.y;
			y2 = p3.y-p1.y;
			z1 = p2.z-p1.z;
			z2 = p3.z-p1.z;
			xx = y1*z2-z1*y2;
			yy = x1*z2-z1*x2;
			zz = x1*y2-y1*x2;
		}*/
		public Vector(Point p1,Point p2)
		{
			xx = p2.x-p1.x;
			yy = p2.y-p1.y;
			zz = p2.z-p1.z;
		}
		public double getCosofAngle(Vector v)
		{/* equals: (u is the vector defined by this)
				 u  dot  v
				-----------
				||u||*||v||		*/
		  return dotProduct(v)/(magnitude()*v.magnitude());
			
		}
		public double dotProduct(Vector v)
		{
			return xx*v.xx+yy*v.yy+zz*v.zz;
		}
		public double magnitude()
		{
			return Math.sqrt(xx*xx+yy*yy+zz*zz);
		}
	}
}

class Buffer
{
	public static Graphics g;
	public static Image img;
}
/*class Cols
{
	public static Color shade;	
}*/

class KeyStates implements KeyListener
{
	public boolean UP,DOWN,LEFT,RIGHT;
	private final int U=38,D=40,L=37,R=39;
	public KeyStates()
	{
		UP=false;
		DOWN=false;
		LEFT=false;
		RIGHT=false;
	}
	public void keyTyped(KeyEvent e){}
	public void keyPressed(KeyEvent e)
	{
		switch(e.getKeyCode())
		{
			case U:
				UP=true;
				break;
			case D:
				DOWN=true;
				break;
			case L:
				LEFT = true;
				break;
			case R:
				RIGHT=true;
				break;
		}
	}
	public void keyReleased(KeyEvent e)
	{
		switch(e.getKeyCode())
		{
			case U:
				UP=false;
				break;
			case D:
				DOWN=false;
				break;
			case L:
				LEFT = false;
				break;
			case R:
				RIGHT=false;
				break;
		}
	}
}