src/com/replica/replicaisland/GameObjectCollisionSystem.java - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.replica.replicaisland;

 import java.util.Comparator;

 import com.replica.replicaisland.CollisionParameters.HitType;

 /**
  * A system for calculating collisions between moving game objects.  This system accepts collision
  * volumes from game objects each frame and performs a series of tests to see which of them
  * overlap.  Collisions are only considered between offending "attack" volumes and receiving
  * "vulnerability" volumes.  This implementation works by using a sweep-and-prune algorithm:
  * objects to be considered are sorted in the x axis and then compared in one dimension for
  * overlaps.  A bounding volume that encompasses all attack and vulnerability volumes is used for
  * this test, and when an intersection is found the actual offending and receiving volumes are
  * compared.  If an intersection is detected both objects receive notification via a
  * HitReactionComponent, if one has been specified.
  */
 public class GameObjectCollisionSystem extends BaseObject {
     private static final int MAX_COLLIDING_OBJECTS = 256;
     private static final int COLLISION_RECORD_POOL_SIZE = 256;
     private static final CollisionVolumeComparator sCollisionVolumeComparator
         = new CollisionVolumeComparator();
     private static CollisionVolume.FlipInfo sFlip = new CollisionVolume.FlipInfo();
     private static CollisionVolume.FlipInfo sOtherFlip = new CollisionVolume.FlipInfo();

     FixedSizeArray<CollisionVolumeRecord> mObjects;
     CollisionVolumeRecordPool mRecordPool;
 	private boolean mDrawDebugBoundingVolume = false;
 	private boolean mDrawDebugCollisionVolumes = false;


     public GameObjectCollisionSystem() {
         super();
         mObjects = new FixedSizeArray<CollisionVolumeRecord>(MAX_COLLIDING_OBJECTS);
         mObjects.setComparator(sCollisionVolumeComparator);
         //mObjects.setSorter(new ShellSorter<CollisionVolumeRecord>());
         mRecordPool = new CollisionVolumeRecordPool(COLLISION_RECORD_POOL_SIZE);
     }

     @Override
     public void reset() {
         final int count = mObjects.getCount();

         for (int x = 0; x < count; x++) {
             mRecordPool.release(mObjects.get(x));
         }
         mObjects.clear();

         mDrawDebugBoundingVolume = false;
         mDrawDebugCollisionVolumes = false;
     }

     /**
      * Adds a game object, and its related volumes, to the dynamic collision world for one frame.
      * Once registered for collisions the object may damage other objects via attack volumes or
      * receive damage from other volumes via vulnerability volumes.
      * @param object  The object to consider for collision.
      * @param reactionComponent  A HitReactionComponent to notify when an intersection is calculated.
      * If null, the intersection will still occur and no notification will be sent.
      * @param boundingVolume  A volume that describes the game object in space.  It should encompass
      * all of the attack and vulnerability volumes.
      * @param attackVolumes  A list of volumes that can hit other game objects.  May be null.
      * @param vulnerabilityVolumes  A list of volumes that can receive hits from other game objects.
      * May be null.
      */
     public void registerForCollisions(GameObject object,
             HitReactionComponent reactionComponent,
             CollisionVolume boundingVolume,
             FixedSizeArray<CollisionVolume> attackVolumes,
             FixedSizeArray<CollisionVolume> vulnerabilityVolumes) {
         CollisionVolumeRecord record = mRecordPool.allocate();
         if (record != null && object != null && boundingVolume != null
                 && (attackVolumes != null || vulnerabilityVolumes != null)) {
             record.object = object;
             record.boundingVolume = boundingVolume;
             record.attackVolumes = attackVolumes;
             record.vulnerabilityVolumes = vulnerabilityVolumes;
             record.reactionComponent = reactionComponent;
             mObjects.add(record);
         }
     }

     @Override
     public void update(float timeDelta, BaseObject parent) {
         // Sort the objects by their x position.
         mObjects.sort(true);

         final int count = mObjects.getCount();
         for (int x = 0; x < count; x++) {
             final CollisionVolumeRecord record = mObjects.get(x);
             final Vector2 position = record.object.getPosition();
             sFlip.flipX = (record.object.facingDirection.x < 0.0f);
             sFlip.flipY = (record.object.facingDirection.y < 0.0f);
             sFlip.parentWidth = record.object.width;
             sFlip.parentHeight = record.object.height;

             if (sSystemRegistry.debugSystem != null) {
             	drawDebugVolumes(record);
             }

             final float maxX = record.boundingVolume.getMaxXPosition(sFlip) + position.x;
             for (int y = x + 1; y < count; y++) {
                 final CollisionVolumeRecord other = mObjects.get(y);
                 final Vector2 otherPosition = other.object.getPosition();
                 sOtherFlip.flipX = (other.object.facingDirection.x < 0.0f);
                 sOtherFlip.flipY = (other.object.facingDirection.y < 0.0f);
                 sOtherFlip.parentWidth = other.object.width;
                 sOtherFlip.parentHeight = other.object.height;

                 if (otherPosition.x + other.boundingVolume.getMinXPosition(sOtherFlip) > maxX) {
                     // These objects can't possibly be colliding.  And since the list is sorted,
                     // there are no potentially colliding objects after this object
                     // either, so we're done!
                     break;
                 } else {
                 	final boolean testRequired = (record.attackVolumes != null && other.vulnerabilityVolumes != null) ||
                 		(record.vulnerabilityVolumes != null && other.attackVolumes != null);
                     if (testRequired && record.boundingVolume.intersects(position, sFlip,
                         other.boundingVolume, otherPosition, sOtherFlip)) {
                         // These two objects are potentially colliding.
                         // Now we must test all attack vs vulnerability boxes.
                         final int hit = testAttackAgainstVulnerability(
                                 record.attackVolumes,
                                 other.vulnerabilityVolumes,
                                 position,
                                 otherPosition,
                                 sFlip,
                                 sOtherFlip);
                         if (hit != HitType.INVALID) {
                             boolean hitAccepted = false;
                             if (other.reactionComponent != null) {
                                 hitAccepted = other.reactionComponent.receivedHit(
                                         other.object, record.object, hit);
                             }
                             if (record.reactionComponent != null) {
                                 record.reactionComponent.hitVictim(
                                         record.object, other.object, hit, hitAccepted);
                             }

                         }

                         final int hit2 = testAttackAgainstVulnerability(
                                 other.attackVolumes,
                                 record.vulnerabilityVolumes,
                                 otherPosition,
                                 position,
                                 sOtherFlip,
                                 sFlip);
                         if (hit2 != HitType.INVALID) {
                             boolean hitAccepted = false;
                             if (record.reactionComponent != null) {
                                 hitAccepted = record.reactionComponent.receivedHit(
                                         record.object, other.object, hit2);
                             }
                             if (other.reactionComponent != null) {
                                 other.reactionComponent.hitVictim(
                                         other.object, record.object, hit2, hitAccepted);
                             }

                         }
                     }
                 }
             }
             // This is a little tricky.  Since we always sweep forward in the list it's safe
             // to invalidate the current record after we've tested it.  This way we don't have to
             // iterate over the object list twice.
             mRecordPool.release(record);
         }

         mObjects.clear();
     }

     /** Compares the passed list of attack volumes against the passed list of vulnerability volumes
      * and returns a hit type if an intersection is found.
      * @param attackVolumes  Offensive collision volumes.
      * @param vulnerabilityVolumes  Receiving collision volumes.
      * @param attackPosition  The world position of the attacking object.
      * @param vulnerabilityPosition  The world position of the receiving object.
      * @return  The hit type of the first attacking volume that intersects a vulnerability volume,
      * or HitType.INVALID if no intersections are found.
      */
     private int testAttackAgainstVulnerability(
             FixedSizeArray<CollisionVolume> attackVolumes,
             FixedSizeArray<CollisionVolume> vulnerabilityVolumes,
             Vector2 attackPosition,
             Vector2 vulnerabilityPosition,
             CollisionVolume.FlipInfo attackFlip,
             CollisionVolume.FlipInfo vulnerabilityFlip) {
         int intersectionType = HitType.INVALID;
         if (attackVolumes != null && vulnerabilityVolumes != null) {
             final int attackCount = attackVolumes.getCount();
             for (int x = 0; x < attackCount && intersectionType == HitType.INVALID; x++) {
                 final CollisionVolume attackVolume = attackVolumes.get(x);
                 final int hitType = attackVolume.getHitType();
                 if (hitType != HitType.INVALID) {
                     final int vulnerabilityCount = vulnerabilityVolumes.getCount();
                     for (int y = 0; y < vulnerabilityCount; y++) {
                         final CollisionVolume vulnerabilityVolume = vulnerabilityVolumes.get(y);
                         final int vulnerableType = vulnerabilityVolume.getHitType();
                         if (vulnerableType == HitType.INVALID || vulnerableType == hitType) {
                             if (attackVolume.intersects(attackPosition, attackFlip,
                                     vulnerabilityVolume, vulnerabilityPosition,
                                     vulnerabilityFlip)) {
                                 intersectionType = hitType;
                                 break;
                             }
                         }
                     }
                 }
             }
         }

         return intersectionType;
     }

     private final void drawDebugVolumes(CollisionVolumeRecord record) {
     	final Vector2 position = record.object.getPosition();
     	if (mDrawDebugBoundingVolume) {
 	    	final CollisionVolume boundingVolume = record.boundingVolume;
 	    	sSystemRegistry.debugSystem.drawShape(
 	    			position.x + boundingVolume.getMinXPosition(sFlip), position.y + boundingVolume.getMinYPosition(sFlip),
 	    			boundingVolume.getMaxX() - boundingVolume.getMinX(),
 	    			boundingVolume.getMaxY() - boundingVolume.getMinY(),
 	    			DebugSystem.SHAPE_CIRCLE,
 	    			DebugSystem.COLOR_OUTLINE);
     	}
     	if (mDrawDebugCollisionVolumes) {
 	    	if (record.attackVolumes != null) {
 	    		final int attackVolumeCount = record.attackVolumes.getCount();
 	    		for (int y = 0; y < attackVolumeCount; y++) {
 	    			CollisionVolume volume = record.attackVolumes.get(y);
 	    			sSystemRegistry.debugSystem.drawShape(
 	    					position.x + volume.getMinXPosition(sFlip), position.y + volume.getMinYPosition(sFlip),
 	    					volume.getMaxX() - volume.getMinX(),
 	    					volume.getMaxY() - volume.getMinY(),
 	    	    			volume.getClass() == AABoxCollisionVolume.class ? DebugSystem.SHAPE_BOX : DebugSystem.SHAPE_CIRCLE,
 	    	    			DebugSystem.COLOR_RED);
 	    		}
 	    	}

 	    	if (record.vulnerabilityVolumes != null) {
 	    		final int vulnVolumeCount = record.vulnerabilityVolumes.getCount();
 	    		for (int y = 0; y < vulnVolumeCount; y++) {
 	    			CollisionVolume volume = record.vulnerabilityVolumes.get(y);
 	    			sSystemRegistry.debugSystem.drawShape(
 	    					position.x + volume.getMinXPosition(sFlip), position.y + volume.getMinYPosition(sFlip),
 	    					volume.getMaxX() - volume.getMinX(),
 	    					volume.getMaxY() - volume.getMinY(),
 	    	    			volume.getClass() == AABoxCollisionVolume.class ? DebugSystem.SHAPE_BOX : DebugSystem.SHAPE_CIRCLE,
 	    	    			DebugSystem.COLOR_BLUE);
 	    		}
 	    	}
     	}
     }

     public void setDebugPrefs(boolean drawBoundingVolumes, boolean drawCollisionVolumes) {
 		mDrawDebugBoundingVolume = drawBoundingVolumes;
 		mDrawDebugCollisionVolumes = drawCollisionVolumes;
 	}

     /** A record of a single game object and its associated collision info.  */
     private class CollisionVolumeRecord extends AllocationGuard {
         public GameObject object;
         public HitReactionComponent reactionComponent;
         public CollisionVolume boundingVolume;
         public FixedSizeArray<CollisionVolume> attackVolumes;
         public FixedSizeArray<CollisionVolume> vulnerabilityVolumes;

         public void reset() {
             object = null;
             attackVolumes = null;
             vulnerabilityVolumes = null;
             boundingVolume = null;
             reactionComponent = null;
         }
     }

     /** A pool of collision volume records.  */
     private class CollisionVolumeRecordPool extends TObjectPool<CollisionVolumeRecord> {

         public CollisionVolumeRecordPool(int count) {
             super(count);
         }

         @Override
         protected void fill() {
             for (int x = 0; x < getSize(); x++) {
                 getAvailable().add(new CollisionVolumeRecord());
             }
         }

         @Override
         public void release(Object entry) {
             ((CollisionVolumeRecord)entry).reset();
             super.release(entry);
         }

     }

     /**
      * Comparator for game objects that considers the world position of the object's bounding
      * volume and sorts objects from left to right on the x axis. */
     public final static class CollisionVolumeComparator implements Comparator<CollisionVolumeRecord> {
         private static CollisionVolume.FlipInfo sCompareFlip = new CollisionVolume.FlipInfo();
         public int compare(CollisionVolumeRecord object1, CollisionVolumeRecord object2) {
             int result = 0;
             if (object1 == null && object2 != null) {
                 result = 1;
             } else if (object1 != null && object2 == null) {
                 result = -1;
             } else if (object1 != null && object2 != null) {
                 sCompareFlip.flipX = (object1.object.facingDirection.x < 0.0f);
                 sCompareFlip.flipY = (object1.object.facingDirection.y < 0.0f);
                 sCompareFlip.parentWidth = object1.object.width;
                 sCompareFlip.parentHeight = object1.object.height;

                 final float minX1 = object1.object.getPosition().x
                     + object1.boundingVolume.getMinXPosition(sCompareFlip);

                 sCompareFlip.flipX = (object2.object.facingDirection.x < 0.0f);
                 sCompareFlip.flipY = (object2.object.facingDirection.y < 0.0f);
                 sCompareFlip.parentWidth = object2.object.width;
                 sCompareFlip.parentHeight = object2.object.height;

                 final float minX2 = object2.object.getPosition().x
                     + object2.boundingVolume.getMinXPosition(sCompareFlip);

                 final float delta = minX1 - minX2;
                 if (delta < 0.0f) {
                     result = -1;
                 } else if (delta > 0.0f) {
                     result = 1;
                 }
             }
             return result;
         }
     }


 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.replica.replicaisland;

	import java.util.Comparator;

	import com.replica.replicaisland.CollisionParameters.HitType;

	/**
	* A system for calculating collisions between moving game objects. This system accepts collision
	* volumes from game objects each frame and performs a series of tests to see which of them
	* overlap. Collisions are only considered between offending "attack" volumes and receiving
	* "vulnerability" volumes. This implementation works by using a sweep-and-prune algorithm:
	* objects to be considered are sorted in the x axis and then compared in one dimension for
	* overlaps. A bounding volume that encompasses all attack and vulnerability volumes is used for
	* this test, and when an intersection is found the actual offending and receiving volumes are
	* compared. If an intersection is detected both objects receive notification via a
	* HitReactionComponent, if one has been specified.
	*/
	public class GameObjectCollisionSystem extends BaseObject {
	private static final int MAX_COLLIDING_OBJECTS = 256;
	private static final int COLLISION_RECORD_POOL_SIZE = 256;
	private static final CollisionVolumeComparator sCollisionVolumeComparator
	= new CollisionVolumeComparator();
	private static CollisionVolume.FlipInfo sFlip = new CollisionVolume.FlipInfo();
	private static CollisionVolume.FlipInfo sOtherFlip = new CollisionVolume.FlipInfo();

	FixedSizeArray<CollisionVolumeRecord> mObjects;
	CollisionVolumeRecordPool mRecordPool;
	private boolean mDrawDebugBoundingVolume = false;
	private boolean mDrawDebugCollisionVolumes = false;


	public GameObjectCollisionSystem() {
	super();
	mObjects = new FixedSizeArray<CollisionVolumeRecord>(MAX_COLLIDING_OBJECTS);
	mObjects.setComparator(sCollisionVolumeComparator);
	//mObjects.setSorter(new ShellSorter<CollisionVolumeRecord>());
	mRecordPool = new CollisionVolumeRecordPool(COLLISION_RECORD_POOL_SIZE);
	}

	@Override
	public void reset() {
	final int count = mObjects.getCount();

	for (int x = 0; x < count; x++) {
	mRecordPool.release(mObjects.get(x));
	}
	mObjects.clear();

	mDrawDebugBoundingVolume = false;
	mDrawDebugCollisionVolumes = false;
	}

	/**
	* Adds a game object, and its related volumes, to the dynamic collision world for one frame.
	* Once registered for collisions the object may damage other objects via attack volumes or
	* receive damage from other volumes via vulnerability volumes.
	* @param object The object to consider for collision.
	* @param reactionComponent A HitReactionComponent to notify when an intersection is calculated.
	* If null, the intersection will still occur and no notification will be sent.
	* @param boundingVolume A volume that describes the game object in space. It should encompass
	* all of the attack and vulnerability volumes.
	* @param attackVolumes A list of volumes that can hit other game objects. May be null.
	* @param vulnerabilityVolumes A list of volumes that can receive hits from other game objects.
	* May be null.
	*/
	public void registerForCollisions(GameObject object,
	HitReactionComponent reactionComponent,
	CollisionVolume boundingVolume,
	FixedSizeArray<CollisionVolume> attackVolumes,
	FixedSizeArray<CollisionVolume> vulnerabilityVolumes) {
	CollisionVolumeRecord record = mRecordPool.allocate();
	if (record != null && object != null && boundingVolume != null
	&& (attackVolumes != null \|\| vulnerabilityVolumes != null)) {
	record.object = object;
	record.boundingVolume = boundingVolume;
	record.attackVolumes = attackVolumes;
	record.vulnerabilityVolumes = vulnerabilityVolumes;
	record.reactionComponent = reactionComponent;
	mObjects.add(record);
	}
	}

	@Override
	public void update(float timeDelta, BaseObject parent) {
	// Sort the objects by their x position.
	mObjects.sort(true);

	final int count = mObjects.getCount();
	for (int x = 0; x < count; x++) {
	final CollisionVolumeRecord record = mObjects.get(x);
	final Vector2 position = record.object.getPosition();
	sFlip.flipX = (record.object.facingDirection.x < 0.0f);
	sFlip.flipY = (record.object.facingDirection.y < 0.0f);
	sFlip.parentWidth = record.object.width;
	sFlip.parentHeight = record.object.height;

	if (sSystemRegistry.debugSystem != null) {
	drawDebugVolumes(record);
	}

	final float maxX = record.boundingVolume.getMaxXPosition(sFlip) + position.x;
	for (int y = x + 1; y < count; y++) {
	final CollisionVolumeRecord other = mObjects.get(y);
	final Vector2 otherPosition = other.object.getPosition();
	sOtherFlip.flipX = (other.object.facingDirection.x < 0.0f);
	sOtherFlip.flipY = (other.object.facingDirection.y < 0.0f);
	sOtherFlip.parentWidth = other.object.width;
	sOtherFlip.parentHeight = other.object.height;

	if (otherPosition.x + other.boundingVolume.getMinXPosition(sOtherFlip) > maxX) {
	// These objects can't possibly be colliding. And since the list is sorted,
	// there are no potentially colliding objects after this object
	// either, so we're done!
	break;
	} else {
	final boolean testRequired = (record.attackVolumes != null && other.vulnerabilityVolumes != null) \|\|
	(record.vulnerabilityVolumes != null && other.attackVolumes != null);
	if (testRequired && record.boundingVolume.intersects(position, sFlip,
	other.boundingVolume, otherPosition, sOtherFlip)) {
	// These two objects are potentially colliding.
	// Now we must test all attack vs vulnerability boxes.
	final int hit = testAttackAgainstVulnerability(
	record.attackVolumes,
	other.vulnerabilityVolumes,
	position,
	otherPosition,
	sFlip,
	sOtherFlip);
	if (hit != HitType.INVALID) {
	boolean hitAccepted = false;
	if (other.reactionComponent != null) {
	hitAccepted = other.reactionComponent.receivedHit(
	other.object, record.object, hit);
	}
	if (record.reactionComponent != null) {
	record.reactionComponent.hitVictim(
	record.object, other.object, hit, hitAccepted);
	}

	}

	final int hit2 = testAttackAgainstVulnerability(
	other.attackVolumes,
	record.vulnerabilityVolumes,
	otherPosition,
	position,
	sOtherFlip,
	sFlip);
	if (hit2 != HitType.INVALID) {
	boolean hitAccepted = false;
	if (record.reactionComponent != null) {
	hitAccepted = record.reactionComponent.receivedHit(
	record.object, other.object, hit2);
	}
	if (other.reactionComponent != null) {
	other.reactionComponent.hitVictim(
	other.object, record.object, hit2, hitAccepted);
	}

	}
	}
	}
	}
	// This is a little tricky. Since we always sweep forward in the list it's safe
	// to invalidate the current record after we've tested it. This way we don't have to
	// iterate over the object list twice.
	mRecordPool.release(record);
	}

	mObjects.clear();
	}

	/** Compares the passed list of attack volumes against the passed list of vulnerability volumes
	* and returns a hit type if an intersection is found.
	* @param attackVolumes Offensive collision volumes.
	* @param vulnerabilityVolumes Receiving collision volumes.
	* @param attackPosition The world position of the attacking object.
	* @param vulnerabilityPosition The world position of the receiving object.
	* @return The hit type of the first attacking volume that intersects a vulnerability volume,
	* or HitType.INVALID if no intersections are found.
	*/
	private int testAttackAgainstVulnerability(
	FixedSizeArray<CollisionVolume> attackVolumes,
	FixedSizeArray<CollisionVolume> vulnerabilityVolumes,
	Vector2 attackPosition,
	Vector2 vulnerabilityPosition,
	CollisionVolume.FlipInfo attackFlip,
	CollisionVolume.FlipInfo vulnerabilityFlip) {
	int intersectionType = HitType.INVALID;
	if (attackVolumes != null && vulnerabilityVolumes != null) {
	final int attackCount = attackVolumes.getCount();
	for (int x = 0; x < attackCount && intersectionType == HitType.INVALID; x++) {
	final CollisionVolume attackVolume = attackVolumes.get(x);
	final int hitType = attackVolume.getHitType();
	if (hitType != HitType.INVALID) {
	final int vulnerabilityCount = vulnerabilityVolumes.getCount();
	for (int y = 0; y < vulnerabilityCount; y++) {
	final CollisionVolume vulnerabilityVolume = vulnerabilityVolumes.get(y);
	final int vulnerableType = vulnerabilityVolume.getHitType();
	if (vulnerableType == HitType.INVALID \|\| vulnerableType == hitType) {
	if (attackVolume.intersects(attackPosition, attackFlip,
	vulnerabilityVolume, vulnerabilityPosition,
	vulnerabilityFlip)) {
	intersectionType = hitType;
	break;
	}
	}
	}
	}
	}
	}

	return intersectionType;
	}

	private final void drawDebugVolumes(CollisionVolumeRecord record) {
	final Vector2 position = record.object.getPosition();
	if (mDrawDebugBoundingVolume) {
	final CollisionVolume boundingVolume = record.boundingVolume;
	sSystemRegistry.debugSystem.drawShape(
	position.x + boundingVolume.getMinXPosition(sFlip), position.y + boundingVolume.getMinYPosition(sFlip),
	boundingVolume.getMaxX() - boundingVolume.getMinX(),
	boundingVolume.getMaxY() - boundingVolume.getMinY(),
	DebugSystem.SHAPE_CIRCLE,
	DebugSystem.COLOR_OUTLINE);
	}
	if (mDrawDebugCollisionVolumes) {
	if (record.attackVolumes != null) {
	final int attackVolumeCount = record.attackVolumes.getCount();
	for (int y = 0; y < attackVolumeCount; y++) {
	CollisionVolume volume = record.attackVolumes.get(y);
	sSystemRegistry.debugSystem.drawShape(
	position.x + volume.getMinXPosition(sFlip), position.y + volume.getMinYPosition(sFlip),
	volume.getMaxX() - volume.getMinX(),
	volume.getMaxY() - volume.getMinY(),
	volume.getClass() == AABoxCollisionVolume.class ? DebugSystem.SHAPE_BOX : DebugSystem.SHAPE_CIRCLE,
	DebugSystem.COLOR_RED);
	}
	}

	if (record.vulnerabilityVolumes != null) {
	final int vulnVolumeCount = record.vulnerabilityVolumes.getCount();
	for (int y = 0; y < vulnVolumeCount; y++) {
	CollisionVolume volume = record.vulnerabilityVolumes.get(y);
	sSystemRegistry.debugSystem.drawShape(
	position.x + volume.getMinXPosition(sFlip), position.y + volume.getMinYPosition(sFlip),
	volume.getMaxX() - volume.getMinX(),
	volume.getMaxY() - volume.getMinY(),
	volume.getClass() == AABoxCollisionVolume.class ? DebugSystem.SHAPE_BOX : DebugSystem.SHAPE_CIRCLE,
	DebugSystem.COLOR_BLUE);
	}
	}
	}
	}

	public void setDebugPrefs(boolean drawBoundingVolumes, boolean drawCollisionVolumes) {
	mDrawDebugBoundingVolume = drawBoundingVolumes;
	mDrawDebugCollisionVolumes = drawCollisionVolumes;
	}

	/** A record of a single game object and its associated collision info. */
	private class CollisionVolumeRecord extends AllocationGuard {
	public GameObject object;
	public HitReactionComponent reactionComponent;
	public CollisionVolume boundingVolume;
	public FixedSizeArray<CollisionVolume> attackVolumes;
	public FixedSizeArray<CollisionVolume> vulnerabilityVolumes;

	public void reset() {
	object = null;
	attackVolumes = null;
	vulnerabilityVolumes = null;
	boundingVolume = null;
	reactionComponent = null;
	}
	}

	/** A pool of collision volume records. */
	private class CollisionVolumeRecordPool extends TObjectPool<CollisionVolumeRecord> {

	public CollisionVolumeRecordPool(int count) {
	super(count);
	}

	@Override
	protected void fill() {
	for (int x = 0; x < getSize(); x++) {
	getAvailable().add(new CollisionVolumeRecord());
	}
	}

	@Override
	public void release(Object entry) {
	((CollisionVolumeRecord)entry).reset();
	super.release(entry);
	}

	}

	/**
	* Comparator for game objects that considers the world position of the object's bounding
	* volume and sorts objects from left to right on the x axis. */
	public final static class CollisionVolumeComparator implements Comparator<CollisionVolumeRecord> {
	private static CollisionVolume.FlipInfo sCompareFlip = new CollisionVolume.FlipInfo();
	public int compare(CollisionVolumeRecord object1, CollisionVolumeRecord object2) {
	int result = 0;
	if (object1 == null && object2 != null) {
	result = 1;
	} else if (object1 != null && object2 == null) {
	result = -1;
	} else if (object1 != null && object2 != null) {
	sCompareFlip.flipX = (object1.object.facingDirection.x < 0.0f);
	sCompareFlip.flipY = (object1.object.facingDirection.y < 0.0f);
	sCompareFlip.parentWidth = object1.object.width;
	sCompareFlip.parentHeight = object1.object.height;

	final float minX1 = object1.object.getPosition().x
	+ object1.boundingVolume.getMinXPosition(sCompareFlip);

	sCompareFlip.flipX = (object2.object.facingDirection.x < 0.0f);
	sCompareFlip.flipY = (object2.object.facingDirection.y < 0.0f);
	sCompareFlip.parentWidth = object2.object.width;
	sCompareFlip.parentHeight = object2.object.height;

	final float minX2 = object2.object.getPosition().x
	+ object2.boundingVolume.getMinXPosition(sCompareFlip);

	final float delta = minX1 - minX2;
	if (delta < 0.0f) {
	result = -1;
	} else if (delta > 0.0f) {
	result = 1;
	}
	}
	return result;
	}
	}



	}