// tjhBuckets.java

import java.awt.*;
import java.util.*;

import tjhBucket;

/** a simple regular space-partitioning class to speed up collision detection */
public class tjhBuckets
{
	//--------------------------------------------------------------------------------
	// data
	//--------------------------------------------------------------------------------

	/** the 2D array of tjhBucket's */
	protected tjhBucket buckets[][];

	/** the width of each bucket */
	protected float bucket_scale;

	/** the number of buckets in each direction */
	protected int n_xBuckets,n_yBuckets;

	//--------------------------------------------------------------------------------
	// public methods
	//--------------------------------------------------------------------------------

	/** default constructor initializes bucket array */
	public tjhBuckets(float scale,int n_x,int n_y)
	{
		buckets = new tjhBucket[n_x][n_y];
		int x,y;
		for(x=0;x<n_x;x++) { for(y=0;y<n_y;y++) { buckets[x][y] = new tjhBucket(); buckets[x][y].has_cell=false; } }
		n_xBuckets = n_x;
		n_yBuckets = n_y;
		bucket_scale = scale;
	}

	/** remove the bucket reference for this cell (died or about to move) */
	public void RemoveCell(tjhCell cell)
	{
		tjhBucket bucket = FindBucket(cell.location);
		bucket.has_cell = false;
	}

	/** add the bucket reference for this cell (newly created or just moved) */
	public void PutCell(tjhCell cell)
	{
		tjhBucket bucket = FindBucket(cell.location);
		if(!bucket.has_cell)
		{
			bucket.has_cell = true;
			bucket.cell=cell;
		}
		else
		{
			// definitely shouldn't get here, buckets can only have one cell in
			buckets = new tjhBucket[0][0];
			// this line deliberately causes the applet to crash so at least you can tell 
			// that something in the code has gone wrong
			// (an error message would be nicer, how do you do those in java?)
		}
	}

	/** get a list of the collisions that would be caused (empty if none) */
	public Vector GetAllWithin(tjh2dVector loc,float dist)
	{
		Vector collisions = new Vector();

		// find containing bucket
		int bx = BCoord(loc.x);
		int by = BCoord(loc.y);
		// search surrounding buckets for cells that might collide
		int x,y;
		final int n_around=(int)Math.ceil(dist/bucket_scale);
		tjhBucket bucket;
		for(x=bx-n_around;x<=bx+n_around;x++)
		{
			for(y=by-n_around;y<=by+n_around;y++)
			{
				if(x>=0 && y>=0 && x<n_xBuckets && y<n_yBuckets)
				{	
					bucket = buckets[x][y];
					if(bucket.has_cell) 
					{
						// found nearby cell but only return collision if actually overlapping
						if((bucket.cell.location.x-loc.x)*(bucket.cell.location.x-loc.x) + 
							(bucket.cell.location.y-loc.y)*(bucket.cell.location.y-loc.y) < dist*dist)
								collisions.addElement(bucket.cell);
					}
				}
			}
		}

		return collisions;
	}

	/** would a tjhCell at the specified location be overlapping any existing one? */
	public boolean CollidesWithAny(tjh2dVector loc,float dist)
	{
		return GetAllWithin(loc,dist).size()>0;
	}

	/** draw a representation of which buckets contain cells */
	/*public void Draw(Graphics g)
	{
		g.setColor(Color.black);
		int x,y;
		for(x=0;x<n_xBuckets;x++)
		{
			for(y=0;y<n_yBuckets;y++)
			{
				if(buckets[x][y].has_cell)
				{
					g.drawOval((int)(x*bucket_scale+bucket_scale/2.0F-1),(int)(y*bucket_scale+bucket_scale/2.0F-1),
						2,2);
				}
			}
		}
	}*/

	//--------------------------------------------------------------------------------
	// protected methods
	//--------------------------------------------------------------------------------

	/** locate the bucket that contains the specified coordinate (x or y) */
	protected tjhBucket FindBucket(tjh2dVector pos)
	{
		return buckets[BCoord(pos.x)][BCoord(pos.y)];
	}

	/** returns the floor of the coord divided by the width of each bucket - 
	    the index on one axis of the bucket containing it */
	protected int BCoord(float coord)
	{
		return (int)(Math.floor(coord/bucket_scale));
	}
}