http://www.panelmonkey.org/sprite.php?id=213&theme=3

http://www.panelmonkey.org/sprite.php?id=297

http://sdb.drshnaps.com/sheets/Sega/StreetsOfRage/StreetsOfRage2/SOR2Max.gif

http://www.panelmonkey.org/sprite.php?id=568

http://www.newgrounds.com/audio/listen/25770 [Standard Music]

http://simplythebest.net/sounds/WAV/events_WAV/alarm_wavs.html



Path edits:
public class Path {
	private Coords[] firstpoints = new Coords[2];//This is the one variable to hold the original path points...
	public Coords[] path;//This variable holds all points that are to be followed to.
	private double backgroundlayer = 0.0;
	private double defaultlayer = backgroundlayer + 1.0;
	private double h = 1.0;

	public Path(int[] x, int[] y)
	{
		for (int a = 0; a<x.length; a++)
		{
			firstpoints[a] = new Coords(x[a], y[a], defaultlayer, h);
		}
		path = firstpoints;
	}
	
	public Path(int[] x, int[] y, int[] z)
	{
		for (int a = 0; a<x.length; a++)
		{
			firstpoints[a] = new Coords(x[a], y[a], z[a], h);
		}
		path = firstpoints;
	}
	public Path(int[] x, int[] y, int[] z, int[] h)
	{
		for (int a = 0; a<x.length; a++)
		{
			firstpoints[a] = new Coords(x[a], y[a], z[a], h[a]);
		}
		path = firstpoints;
	}
	
	public Path(double[] x, double[] y)
	{
		for (int a = 0; a<x.length; a++)
		{
			firstpoints[a] = new Coords(x[a], y[a], defaultlayer, h);
		}
		path = firstpoints;
	}
	public Path(double[] x, double[] y, double[] z)
	{
		for (int a = 0; a<x.length; a++)
		{
			firstpoints[a] = new Coords(x[a], y[a], z[a], h);
		}
		path = firstpoints;
	}
	public Path(double[] x, double[] y, double[] z, double[] h)
	{
		for (int a = 0; a<x.length; a++)
		{
			firstpoints[a] = new Coords(x[a], y[a], z[a], h[a]);
		}
		path = firstpoints;
	}
	public Path(int[][]coords)
	{
		
		for (int a = 0; a<coords.length; a++)
		{
			firstpoints[a] = new Coords(coords[a]);	
		}
		path = firstpoints;
	}
	
	public Path(double[][]coords)
	{
		
		for (int a = 0; a<coords.length; a++)
		{
			firstpoints[a] = new Coords(coords[a]);	
		}
		path = firstpoints;
	}
	public Path(Coords coords1, Coords coords2)
	{
		firstpoints[0] = coords1;
		firstpoints[1] = coords2;
		path = firstpoints;
	}
	public Path(Coords[]coords)
	{
		
		for (int a = 0; a<coords.length; a++)
		{
			firstpoints[a] = coords[a];	
		}
		path = firstpoints;
	}
	public Coords[] getPath()
	{
		return path;
	}
	
	public void setPath(int userMoveLen)
	{
		int timesToMove = (int)((distance())/userMoveLen);
		if(timesToMove == 0)
		{
			return;
		}
		path = beizercurve(firstpoints, timesToMove);
	}
	public void setPath(double userMoveLen)
	{
		int timesToMove = (int)((distance(path[0], path[1]))/userMoveLen);
		if(timesToMove == 0)
		{
			return;
		}
		path = beizercurve(firstpoints, timesToMove);
	}
	
	//All below are functions interpreted from my attempt at applying principles from Math 130 to Python, now put to Java.
	//The main idea is that from these functions, you can calculate 'n' points along a line; where this is useful is when the application involves curved lines.
	public double distance(Coords point1, Coords point2)//From previous experiments in Python regarding Math 130: Geometry in Computer Graphics.
	{
		double x = Math.abs((point2.getX()/point2.getH()) - (point1.getX()/point1.getH()));
		double y = Math.abs((point2.getY()/point2.getH()) - (point1.getY()/point1.getH()));
		double z = Math.abs((point2.getZ()/point2.getH()) - (point1.getZ()/point1.getH()));
		double dist = Math.sqrt((Math.pow(x, 2.0)) + (Math.pow(y, 2.0)) + (Math.pow(z, 2.0)));
		return dist;
	}
	public double distance()
	{
		double a = 0.0;
		for (int b = 0; b<firstpoints.length-1; b++)
		{
			a += distance(firstpoints[b], firstpoints[b+1]);
		}
		return a;
	}
	public Coords[] beizercurve(Coords[] points, int tm)
	{
//		Coords[] apara = new Coords[tm+1];
//		apara[0] = points[0];
//		apara[tm] = points[points.length-1];
		Coords[] npoints = new Coords[tm+1];
		for (int a = 0; a<=tm; a++)
		{
			double fraction = a/tm;
			npoints[a] = deCasteljau(points, fraction);
			
		}
		return npoints;
	}
	public Coords deCasteljau(Coords[] points, double fractionOfLen)
	{
		int[] pasca = pascals_ans(points.length-1);
		
		Coords[] newa = new Coords[points.length];
		for (int g = 0; g<newa.length -1; g++)
		{
			double it = pasca[g]*(Math.pow((1-(fractionOfLen)), g))*(Math.pow(fractionOfLen, ((newa.length-1)-g)))*points[((newa.length-1)-g)].getX();
			double jt = pasca[g]*(Math.pow((1-(fractionOfLen)), g))*(Math.pow(fractionOfLen, ((newa.length-1)-g)))*points[((newa.length-1)-g)].getY();
			double kt = pasca[g]*(Math.pow((1-(fractionOfLen)), g))*(Math.pow(fractionOfLen, ((newa.length-1)-g)))*points[((newa.length-1)-g)].getZ();
			newa[g] = new Coords(it, jt, kt);
		}
		double i = 0;
		double j = 0;
		double k = 0;
		
		for (int p = 0; p<newa.length -1; p++)
		{
			i += newa[p].getX();
			j += newa[p].getY();
			k += newa[p].getZ();
		}
		Coords newar = new Coords(i, j, k);
		return newar;
	}
	public int[] pascals_ans(int o)
	{
		int[] pasca = {1};
		if(o != 0)
		{
			for(int a = 0; a<o-1; a++)
			{
				pasca = pascals_increment(pasca);
			}
		}
		return pasca;
	}
	public int[] pascals_increment(int[] list)
	{
		int[] pas = (int[])list.clone();
		pas[0] = 1;
		for (int instance = 0; instance<list.length-1; instance++)
		{
		    pas[instance+1] = list[instance] + list[instance + 1];
		}
//	    pas[list.length] = 1; 
		return pas;
	}//End of Math 130 conversion
}


BallPanel: Tried waits of 6, 50, 5000.


