/*
* 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;
}
}
}