com.ucd.comp41690.team21.zenze.game.components

Class PhysicsComponent

java.lang.Object

com.ucd.comp41690.team21.zenze.game.components.PhysicsComponent

Direct Known Subclasses:

AttackPhysics, EnemyPhysics, PlayerPhysics

public class PhysicsComponent
extends java.lang.Object

controlls the physical behaviour of the game's objects

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	PhysicsComponent.AABB a rectangular bounding volume
class	PhysicsComponent.BoundingVolume a super class for bounding volumes
static class	PhysicsComponent.Collision reflects the type or position of a collision
class	PhysicsComponent.Sphere a spherical bounding volume

Field Summary

Fields

Modifier and Type	Field and Description
float	acceleration
PhysicsComponent.BoundingVolume	boundingVolume
float	gravity
static int	RECTANGULAR
static int	SPHERE
float	x_Vel
float	y_Vel

Constructor Summary

Constructors

Constructor and Description
PhysicsComponent(int boundingVolume, float x, float y, float scale) creates a new physics component

Method Summary

Modifier and Type	Method and Description
float[]	getCollisionPoint(PhysicsComponent.Sphere a, PhysicsComponent.Sphere b) returns the point to which to reset the first object in case of collision
void	handlePhysics(GameObject object, double elapsedTime) updates an objects bounding volume, position and reactes to collisions
PhysicsComponent.Collision	intersects(PhysicsComponent.BoundingVolume a, PhysicsComponent.BoundingVolume b) checking for intersection between two bounding volumes
PhysicsComponent.Collision	intersects(PhysicsComponent.Sphere sphere, PhysicsComponent.AABB rect) collision detection between a sphere and an axis aligned rectangle
PhysicsComponent.Collision	intersects(PhysicsComponent.Sphere a, PhysicsComponent.Sphere b) checks for collsions between two spherical bounding volumes
void	leapFrogIntegration(GameObject object, double elapsedTime, float damping) updates an objects position using leap frog integration for more stable results than euler
void	resolveSolidCollision(PhysicsComponent.Collision col, GameObject player, GameObject o) resolves a collision with a solid object and a spherical one

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

SPHERE

public static final int SPHERE

See Also:

Constant Field Values

RECTANGULAR

public static final int RECTANGULAR

See Also:

Constant Field Values

x_Vel

public float x_Vel

y_Vel

public float y_Vel

gravity

public float gravity

acceleration

public float acceleration

boundingVolume

public PhysicsComponent.BoundingVolume boundingVolume

Constructor Detail

PhysicsComponent

public PhysicsComponent(int boundingVolume,
                        float x,
                        float y,
                        float scale)

creates a new physics component

Parameters:

boundingVolume - indicates the objects bounding volume, either spherical or rectangular

x - the x position of the bounding volume, should match the objects one

y - the y position of the bounding volume, should match the objects one

scale - the scale of the bounding volume

Method Detail

handlePhysics

public void handlePhysics(GameObject object,
                          double elapsedTime)

updates an objects bounding volume, position and reactes to collisions

Parameters:

object - the object to update

elapsedTime - the elapsed time since the last update

leapFrogIntegration

public void leapFrogIntegration(GameObject object,
                                double elapsedTime,
                                float damping)

updates an objects position using leap frog integration for more stable results than euler

Parameters:

object - the object whose position should be updated

elapsedTime - the elapsed time since the last update

damping - a damping factor that can be used to slow down the object eg. incase of jumping

resolveSolidCollision

public void resolveSolidCollision(PhysicsComponent.Collision col,
                                  GameObject player,
                                  GameObject o)

resolves a collision with a solid object and a spherical one

Parameters:

col - the type of collision to resolve

player - the object with a spherical bounding volume

o - the solid object, can be spherical or rectangular

intersects

public PhysicsComponent.Collision intersects(PhysicsComponent.BoundingVolume a,
                                             PhysicsComponent.BoundingVolume b)

checking for intersection between two bounding volumes

Parameters:

a - the first bounding volume

b - the second bounding volume

Returns:

the type of collision

intersects

public PhysicsComponent.Collision intersects(PhysicsComponent.Sphere sphere,
                                             PhysicsComponent.AABB rect)

collision detection between a sphere and an axis aligned rectangle

Parameters:

sphere - a spherical bounding volume

rect - an axis aligned rectangular bounding volume

Returns:

the type of collision between the two volumes

intersects

public PhysicsComponent.Collision intersects(PhysicsComponent.Sphere a,
                                             PhysicsComponent.Sphere b)

checks for collsions between two spherical bounding volumes

Parameters:

a - the first sphere

b - the second sphere

Returns:

the type of collision between the two volumes

getCollisionPoint

public float[] getCollisionPoint(PhysicsComponent.Sphere a,
                                 PhysicsComponent.Sphere b)

returns the point to which to reset the first object in case of collision

Parameters:

a - the first colliding sphere which should be moved out of the second object

b - the second bounding volume which remains in place

Returns:

an array containing x and y coordinates for the new object position