/*
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 App3 extends Applet implements ActionListener
{
//	Box b,b2;
//	Line l,l2;
	Timer t;
	final double FRAMERATE = 50; //Frames per second
	final int WIDTH = 800, HEIGHT = 600;
	final double PI=Math.PI,ANGLE=30.0;
	public final int CX = WIDTH/2,CY = HEIGHT/2;
//	public int CX,CY;
	public final double PX=0,PY=1500,PZ=1000;
	public final double FACTOR = 1,CLOSERANGE=10;
	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);
	public KeyStates key;
	//Prism c1 = new Prism(new Point(60,60,-60),new Point(100,100,60),Color.blue),
	//	c2 = new Prism(new Point(-30,-30,-30),new Point(30,30,30),Color.red),
	//	c3 = new Prism(new Point(0,-50,0),new Point(20,-70,20),Color.green);
	public final int NUMOFCUBES=30;
	Prism c[] = new Prism[NUMOFCUBES];
//	Point[] lp1 = new Point[50],lp2 = new Point[50];
//	Graphics gr;
//	Image img;
//	Graphics dblBuffer;
/*	public void update()
	{
	//	paint(this.getGraphics());;
	}
	public void repaint()
	{//Define as null to prevent it from doing anything
	}*/
	public void init()
	{
//	l = new Line(0,-100000,0,100000);
//		l2 = new Line(-100000,0,100000,0);
//		b = new Box(new Point(20,20,0),new Point(40,40,0));
  // 	    b2 = new Box(new Point(10,-10,0),new Point(-10,10,0));
//	for (int a=0;a<50;a++)
//	{
//		lp1[a] = new Point((a-25)*50,1000,0);
//		lp2[a] = new Point((a-25)*50,-1000,0);
//	}

		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));
		} 
		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);
//		Image img = createImage(WIDTH,HEIGHT);
//		dblBuffer = img.getGraphics();
//		gr =this.getGraphics();
//		updateObjs();
	//	img = createImage(WIDTH,HEIGHT);
	//	dblBuffer = img.getGraphics();
	//	setBackground(Color.blue);
	}
  /*  public Box[] bubbleSort(Box[] arr)
	{
		Box tmp;
		boolean done = false;
		while(!done)
		{
			done = true;
			for(int a=0;a<arr.length-1;a++)
			{
				if (arr[a].getDistPP()>arr[a+1].getDistPP());
				{//SWITCH:
					tmp = arr[a];
					arr[a]=arr[a+1];
					arr[a+1]=tmp;
					done = false;
				}
			}
		}
		return arr;
	}*/
    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();
	//	Buffer.img = createImage(WIDTH,HEIGHT);
	//	Buffer.g = Buffer.img.getGraphics();
	//	PP= new Point(PX,PY,PZ);
	//	LP=PP;
		Point lpp1,lpp2;
		Buffer.g.clearRect(0,0,WIDTH,HEIGHT);
		Buffer.g.setColor(Color.black);
//		for (int a=0;a<50;a++)
//		{
//			lpp1=lp1[a].point2D();
//			lpp2=lp2[a].point2D();
//			Buffer.g.drawLine((int)(CX+lpp1.x),(int)(CY-lpp1.y),(int)(CX+lpp2.x),(int)(CY-lpp2.y));
//		}
		
		
		double[] cc = new double[NUMOFCUBES];
		for (int count=0;count<NUMOFCUBES;count++)
//			cc[count] = c[count].center.dist(PP);
			cc[count] = c[count].dist[0]; //Shortest dist to cube
		double[] arr = bubbleSort(cc);
		for (int a=NUMOFCUBES-1;a>=0;a--)
			for (int b=0;b<NUMOFCUBES;b++)
				if (cc[b]==arr[a]&&cc[b]>1) c[b].draw(Buffer.g); 
				
				
				
//		System.out.println();
/*		c1.draw(dblBuffer);
		c2.draw(dblBuffer);
		c3.draw(dblBuffer); */
	//	g.clearRect(0,0,WIDTH,HEIGHT);
		g.drawImage(Buffer.img,0,0,this);
//		System.out.println();
	//	g.drawLine(CX-1,CY-1,CX+1,CY+1); //Draw Origin
	}
/*	public double per(Point p1,Point p2,Point pp)
	{
			double d1,d2,d3;
			d1=pp.dist(p1);
			d2=pp.dist(p2);
			d3=p1.dist(p2);
			return 2.0*triArea(d1,d2,d3)/(d1>d2?d1:d2);
	} 
	double triArea(double s1,double s2,double s3)
	{
		double s = (s1+s2+s3)/2.0;
		return Math.sqrt(s*(s-s1)*(s-s2)*(s-s3));
	} */
	public boolean isInView(Point p)
	{
		return (p.y<PP.y-CLOSERANGE);
	}
	public void actionPerformed(ActionEvent ae)
	{
	//	undraw(gr);
		updateObjs();
//	update();
//repaint();
		paint(this.getGraphics());
//		gr.setColor(Color.black);
//Don't use repaint bc it causes a complete refresh, causing annoying flicker
	}
/*	void undraw(Graphics g)
	{	
		g.setColor(Color.white);
		paint(g);
	}*/
	void updateObjs()
	{
	//	PP.y++;
		if (key.UP)PP.y--;
		if (key.DOWN)PP.y++;
		if (key.LEFT)PP.x++;
		if (key.RIGHT)PP.x--;
		//PY++;
	//	PP.z+=1;
//		PY++;
//		PP= new Point(PX,PY,PZ);
//		LP.y--;
		LP = 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);
			//c[a].update(); 
	}
	class Prism
	{
		Point[] p = new Point[8];
		Point[] p2D = new Point[8];
		Face [] f = new Face[6];
		double[] dist;
		Point center;
		public Prism(Point pp1, Point pp2,Color col)
		{//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);
			f[1] = new Face(new int[] {5,6,7,8},p,p2D,col);
			f[2] = new Face(new int[] {4,3,7,8},p,p2D,col);
			f[3] = new Face(new int[] {1,2,6,5},p,p2D,col);
			f[4] = new Face(new int[] {2,6,7,3},p,p2D,col);
			f[5] = new Face(new int[] {1,5,8,4},p,p2D,col);
			dist = new double[4];
			update();
		}
		public void draw(Graphics g)
		{
		double[] fc = new double[6];
		for (int a=0;a<f.length;a++)
			fc[a] = f[a].getDistPP();
//		System.out.println(b1c+","+b2c+","+b3c+","+b4c+","+b5c+","+b6c);
	/*	Box[] arr = {b1,b2,b3,b4,b5,b6}; */
		double[] arr = bubbleSort(fc);
//		int one=0,two=0,three=0,four=0,five=0,six=0;
		for (int a=5;a>=0;a--)
		{
			for (int b=0;b<6;b++)
			{
				if (arr[a]==fc[b])
				{
					//System.out.println("Face num: "+b);
					f[b].draw(g,center);
				}
			}
	
		}
		//	System.out.println("one: "+one+", two: "+two+", three: "
		//	+ three+", four: "+four+", five: "+five+", six: "+six+"\n");
			/*
			b1.draw(g);
			b2.draw(g);
			b3.draw(g);
			b4.draw(g);
			b5.draw(g);
			b6.draw(g);*/
		}
		public void rot(double d)
		{
			for (int a=0;a<8;a++)
			{
				p[a].rot(d);
			}
			update();
		}
		void update()
		{
			update2D();
		 for (int a=0;a<4;a++)
		 	dist[a]=f[a].getDistPP();
		 dist=bubbleSort(dist);
		 center = p[0].midPoint(p[6]);
		}
		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;
		//	Color shade;
			Color shade;
		//	Vector norm,light;
		/*	public Face()
			{
				new Face(new Point(0,0,0),new Point(0,0,0));
			}
			public void update()
			{
				center = p1.midPoint(p2).midPoint(p3.midPoint(p4));//new Point((p1.x+p3.x)/2,(p1.y+p3.y)/2,(p1.z+p3.z)/2);
			}
		/*	public void movAwayY(int d)
			{
				p1.y+=d;
				p2.y+=d;
				p3.y+=d;
				p4.y+=d;
				update();
			}
			public void movAwayX(int d)
			{
				p1.x+=d;
				p2.x+=d;
				p3.x+=d;
				p4.x+=d;
				update();
			}*/
			public boolean equals(Face f)
			{
				return (f.p==p&&f.pp==pp);
			}
			public Face(int[] pts,Point[] ppp,Point[] pp2,Color col)
			{
				len=pts.length;
				p = pts;
				for (int a=0;a<len;a++)
					p[a]--;
				pp=ppp;
				p2=pp2;
			//	faceColor = col;
				red = col.getRed();
				green = col.getGreen();
				blue = col.getBlue();
				/*
				p1 = new Point(pp1.x,pp1.y,0);
				p3 = new Point(pp2.x,pp2.y,0);
				p2 = new Point(pp2.x,pp1.y,0);
				p4 = new Point(pp1.x,pp2.y,0);
				update();*/
			}
			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;
			//	Point c= pp[p[0]].midPoint(pp[p[2]]).midPoint(pp[p[1]].midPoint(pp[p[2]]));
			//	return c;
			}
			/*
			public Box(Point pp1,Point pp2,Point pp3,Point pp4)
			{
				p1 =pp1;
				p2 = pp2;
				p3 = pp3;
				p4 = pp4;
				update();
			}*/
			public Point getPoint(int index)
			{
				return pp[p[index]];
			}
			public Point get2DPoint(int index)
			{
				return p2[p[index]];
			}
			public void draw(Graphics graph,Point 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;
	//			g.drawLine(xx1,yy1,xx2,yy2);
	//			g.drawLine(xx2,yy2,xx3,yy3);
	//			g.drawLine(xx3,yy3,xx4,yy4);
	//			g.drawLine(xx4,yy4,xx1,yy1); 
			//	norm= new Vector(getPoint(0),getPoint(1),getPoint(2));
				norm = new Vector(center,center());
				light = new Vector(center(),LP);
				double shadeFactor = light.getCosofAngle(norm);
				shadeFactor = (shadeFactor+1)/2;
				//System.out.println("SHADEFACTOR="+shadeFactor);
				//System.out.println("Red="+red+" Blue:"+ blue+" Green:" +green);
				int rr=(int)(red*shadeFactor),gg=(int)(green*shadeFactor),bb=(int)(blue*shadeFactor);
				//System.out.println("Red="+rr+" Blue:"+ bb+" Green:" +gg);
				Color shade = new Color(rr,gg,bb);
				int[] arrx = {xx1,xx2,xx3,xx4},arry={yy1,yy2,yy3,yy4};
//							graph.setColor(Cols.shade);
//				Cols.shade=graph.getColor();
	//System.out.println("Red="+Cols.shade.getRed()+" Blue:"+ Cols.shade.getBlue()+" Green:" +Cols.shade.getGreen());
		//System.out.println("LP="+LP);
				graph.setColor(shade);
				graph.fillPolygon(arrx,arry,len);
		//g.setColor(shade);
				graph.drawPolygon(arrx,arry,len);
				//System.out.println("Color = "+graph.getColor());
			}
	/*		public void rot(int d)
			{//Rotates the box d degrees around (CX,CY)	
				p1.rot(d);
				p2.rot(d);
				p3.rot(d);
				p4.rot(d);
				update();
			}*/
			public double getDistLP()
			{
				return getDistPP();
			}
			public double getDistPP()
			{
				return PP.distRel(this.center());
			}
/*				Point min = new Point(pp[p[0]]),
					  max = new Point(pp[p[0]]);
				for (int a=1;a<len;a++)
				{
					xx = pp[p[a]].x;
					yy = pp[p[a]].y;
					zz = pp[p[a]].z;
					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 = PX;
				yy = PY;
				zz = PZ;
				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.x)yy=min.y;
				if (zz<min.z)zz=min.z;
				double dist= PP.dist(new Point(xx,yy,zz));/*
	//			System.out.println(pp[p[0]]+"\t"+pp[p[1]]+"\t"+pp[p[2]]+"\t"+pp[p[3]]+"\tmin:"+min+"\tmax:"+max+"\n");
				return dist;
			}
			/*	Point ptmin=pp[p[0]],pointCur;
				double distMin,dist;
				for (int a=1;a<len;a++)
				{
					distMin = ptmin.distYZ(PP);
					pointCur = pp[p[a]];
					dist = pointCur.distYZ(PP);
					if (Math.abs(dist-distMin)<0.001)ptmin = ptmin.midPoint(pointCur);
					if (dist<distMin)ptmin=pointCur;
				}
				return ptmin.distYZ(PP);
			//	update();
			//	Point c = this.center();
			//	Point pointCenter = new Point(0,c.y,c.z);
			//	return pointCenter.dist(PP);
			//	return (new Point(0,center.y,center.z)).dist(PP);
			}*/
			
		}
		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)
			{
			double h = Math.sqrt(x*x+y*y);
			int quad = getQuadrant(x,y);
			double add= (quad==1||quad==4)?0:PI;
			double dd = Math.atan(y/x)+d*PI/180+add;
		//	System.out.println(dd/PI*180+","+quad); //DEBUG STATEMENT
			x = h*Math.cos(dd);
			y = h*Math.sin(dd);
			}
			public Point point2D()
			{
				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);
	/*			double xx,yy,yyy,zz,t,a,b,c,a2,b2,c2;
				a = PX-x;
				b = PY-y;
				c = PZ-z;
				a2= PX- OP.x;
				b2 = PY-OP.y;
				c2 = PZ-OP.z;
				t=(a2*(x-PX)+b2*(y-PY)+c2*(z-PZ))/(a*a2+b*b2+c*c2);
			//	t = -((x-OP.x)*PX+(y-OP.y)*PY+(z-OP.z)*PZ)/(a*PX+b*PY+c*PZ);
				xx = x+a*t;
				yy = y+b*t;
				zz = z+c*t;
				yyy = Math.sqrt(yy*yy+zz*zz);
				Point twoD = new Point(xx,yyy,0);
				return twoD;  */
/*				double xx,yy,x2,y2,z2;
				double a = PP.x, b = PP.y, c = PP.z;
				x2=x+OP.x;
				y2=y+OP.y;
				z2=z+OP.z;
				xx = (-b/(y2-b))*(x2-a);
				yy = (y2/(y2-b))*c+(-b/(y2-b))*z2;*/
			//	xx = getX(this);
			//	xx = per(new Point(0,y,z),this,PP);//x
			//	yy = per(new Point(x,y,0),this,PP);//z
			//	yy = per(new Point(xx,0,0),this,PP);//y
			//	yy = getY(this,xx);
//				System.out.println(x+","+y+","+z+":\t"+xx+","+yy);
//				return new Point(xx,yy,0);
			}
			public String toString()
			{
				String s = x+","+y+","+z;
				return s;
			}
			public double distRel(Point p)
			{
				double disty=y-p.y,sign=Math.abs(disty)/disty;
				return dist(p)*sign;
			}
			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);
			}
			int getQuadrant(double xx,double yy)
			{//returns the quadrant num that angle (radians) is in
				if (Math.abs(x)/x==Math.abs(y)/y)//if the signs are equal...
				{//Quadrants 1,3
					if (Math.abs(x)==x)
						return 1;
					return 3;
				}
				else
				{//Quadrants 2,4
					if (Math.abs(x)==x)
						return 4;
				}
				return 2;
			}
/*			public double distYZ(Point p)
			{
				return (new Point(0,y,z)).dist(new Point(0,p.y,p.z));
			}*/
			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;
		}
	}
}