generalrelativity

/**
 * Detects whether 2 {@link CircleParticle} instances will collide within an implicit timestep of 1
 *
 
 * 		Given collision, {@link #t} is set to the percentage of the interval at which collision occurs.
 * 		ie: 0 if collision occurs at the beginning of the interval and 1.0 at the end of the interval
 *
 * 		The event of collision is given by the quadratic equation ax^2 + 2bx + c = 0 offers the resolution:
 * 		x = ( -b - Math.sqrt( b^2 - ac ) ) / a, the smaller of 2 possible roots
 *
 * 		Note that we return from the algorithm before declaring/defining any unnecessary variables
 * 
 
 *
 * @return {@code true} if collision is detected, {@code false} otherwise
 * */
public function detect() : Boolean
{
 
	//difference vector of the 2 circles' positions
	var cDiff:Vector = c2.position.getDifference( c1.position );
 
	/**
	 * {@code c} the squared distance between circles minus the squared sum of their radii
	 * this offers a means to check for intersection at the start of the interval
	 * without making an expensive square root call
	 *
	 * ie: if the sum of the circles' radii squared > the distance between them squared,
	 * they are overlapping
	 * */
	var c:Number = cDiff.dot( cDiff ) - ( c1.radius + c2.radius ) * ( c1.radius + c2.radius );
	if( c < 0 )
	{
		//initial overlap condition- return with time 0
		t = 0;
		return true;
	}
 
	//difference between circles' velocities
	var vDiff:Vector = c2.velocity.getDifference( c1.velocity );
 
	var a:Number = vDiff.dot( vDiff );
	if( a < Collision.OMEGA ) return false; //circles not moving relative each other
 
	var b:Number = vDiff.dot( cDiff );
	if( b >= 0 ) return false; //circles moving apart
 
	var d:Number = b * b - a * c;
	if( d < 0 ) return false; //no solution to the quadratic equation- circles don't intersect
 
	//evaluate the time of collision
	t = ( -b - Math.sqrt( d ) ) / a;
	return t <= 1;
 
}

/**
 * Reacts to a collision between {@link #c1} and {@link #c2} at specified time {@link #t}
 *
 *
 
 * 		We project the ghost particles along the velocity vector of c1 and c2 by
 *		t * circle.velocity.
 *         (Description is outdated- needs updating)
 * 		Then we normalize the collision vector and amplify by the magnitude of the
 * 		opposing circle's velocity to obtain each ghost's velocity. Their velocities
 * 		are then multiplied by 1 - t to give us each reaction vector in reference to the
 * 		remaining span of the interval.
 * 
 
 *
 * @param g1 ghost particle representative of {@link c1} at moment of collision
 * @param g2 ghost particle representative of {@link c2} at moment of collision
 * */
public function react( g1:CircleParticle, g2:CircleParticle ) : void
{
 
	//assign the position at percentage t along each velocity vector to each ghost
	g1.position = c1.position.getSum( c1.velocity.getProduct( t ) );
	g2.position = c2.position.getSum( c2.velocity.getProduct( t ) );
 
	//difference vector between circles at time of collision
	var cDiff:Vector = g2.position.getDifference( g1.position );
	//normalized
	var collisionNormal:Vector = cDiff.getUnit();
 
	//relative velocity of circles
	var relativeVelocity:Vector = c1.velocity.getDifference( c2.velocity );
	//coefficient of restitution range of 0 - 1.0
	//0 is completely inelastic (lump of clay) and 1 is purely elastic (superball)
	var restitution:Number = Math.sqrt( c1.elasticity * c2.elasticity );
 
	//the impulse created at collision-
	//this is given by the following equation (j is used to represent impulse)
	//j = -( 1 + e )vAB . n / n . n( 1 / mA + 1 / mB )
	//where e is the coefficient of restitution, vAB is the relative velocity
	//n is the collision normal and mA/mB are the respective masses of the different circles
	// "."s represent the vector dot product
	var impulse:Number = collisionNormal.dot( relativeVelocity.getProduct( -( 1 + restitution ) ) );
	impulse /= collisionNormal.dot( collisionNormal.getProduct( 1 / c1.mass + 1 / c2.mass ) );
 
	//scale each impulse along the collision normal by the circles' respective masses
	var reactionA:Vector = collisionNormal.getProduct( impulse / c1.mass );
	var reactionB:Vector = collisionNormal.getProduct( -impulse / c2.mass );
 
	//Multiply this by the the remainder of the interval (1 - t)
	g1.velocity = c1.velocity.getSum( reactionA ).getProduct( 1 - t );
	g2.velocity = c2.velocity.getSum( reactionB ).getProduct( 1 - t );
 
}