/*
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.*;
//1152x 864
public class App6 extends Applet implements ActionListener
{
	Timer t;
	final double FRAMERATE = 50; //Frames per second
	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=.6;
	public final double PX=0,PY=800,PZ=1;
	public final double FACTOR = .6,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=30;
	Prism c[] = new Prism[NUMOFCUBES];

	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));
		} 
		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);

	}
  
    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);

		
		

		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

		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
	{
		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].getDist(PP);
		double[] arr = bubbleSort(fc);
		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);
				}
			}
	
		}
		}
		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]);
		}
		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;
		//	Color shade;
			Color shade;

			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;
				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 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;
				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 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 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);
			}
			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;
		}
	}
}