#include <CUComplexObstacle.h>

Inheritance diagram for ComplexObstacle:

Public Member Functions
virtual b2BodyType	getBodyType () const override

virtual void	setBodyType (b2BodyType value) override

virtual Vec2	getPosition () const override

virtual void	setPosition (const Vec2 &value) override

virtual void	setPosition (float x, float y) override

virtual float	getX () const override

virtual void	setX (float value) override

virtual float	getY () const override

virtual void	setY (float value) override

virtual float	getAngle () const override

virtual void	setAngle (float value) override

virtual Vec2	getLinearVelocity () const override

virtual void	setLinearVelocity (const Vec2 &value) override

virtual void	setLinearVelocity (float x, float y) override

virtual float	getVX () const override

virtual void	setVX (float value) override

virtual float	getVY () const override

virtual void	setVY (float value) override

virtual float	getAngularVelocity () const override

virtual void	setAngularVelocity (float value) override

virtual bool	isActive () const override

virtual void	setActive (bool value) override

virtual bool	isAwake () const override

virtual void	setAwake (bool value) override

virtual bool	isSleepingAllowed () const override

virtual void	setSleepingAllowed (bool value) override

virtual bool	isBullet () const override

virtual void	setBullet (bool value) override

virtual bool	isFixedRotation () const override

virtual void	setFixedRotation (bool value) override

virtual float	getGravityScale () const override

virtual void	setGravityScale (float value) override

virtual float	getLinearDamping () const override

virtual void	setLinearDamping (float value) override

virtual float	getAngularDamping () const override

virtual void	setAngularDamping (float value) override

virtual void	setDensity (float value) override

virtual void	setFriction (float value) override

virtual void	setRestitution (float value) override

virtual void	setSensor (bool value) override

virtual void	setFilterData (b2Filter value) override

virtual Vec2	getCentroid () const override

virtual void	setCentroid (const Vec2 &value) override

virtual void	setCentroid (float x, float y) override

virtual float	getInertia () const override

virtual void	setInertia (float value) override

virtual float	getMass () const override

virtual void	setMass (float value) override

virtual void	resetMass () override

virtual b2Body *	getBody () const override

const vector< Obstacle * > &	getBodies ()

const vector< b2Joint * > &	getJoints ()

virtual bool	activatePhysics (b2World &world) override

virtual void	deactivatePhysics (b2World &world) override

virtual void	createFixtures ()

virtual void	releaseFixtures ()

virtual bool	createJoints (b2World &world)

virtual void	update (float delta) override

virtual void	setDrawScale (const Vec2 &value) override

virtual void	setDrawScale (float x, float y) override

bool	isSceneTracking ()

void	setSceneTracking (bool track)

virtual void	positionSceneNode () override

virtual void	positionDebugNode () override

CC_CONSTRUCTOR_ACCESS	_body (nullptr)

CC_CONSTRUCTOR_ACCESS	_tracking (false)

virtual	~ComplexObstacle ()

Public Member Functions inherited from Obstacle
void	setBodyState (const b2Body &body)

float	getDensity () const

float	getFriction () const

float	getRestitution () const

bool	isSensor () const

b2Filter	getFilterData () const

bool	isRemoved () const

void	markRemoved (bool value)

bool	isDirty () const

void	markDirty (bool value)

const Vec2 &	getDrawScale () const

Node *	getSceneNode () const

void	setSceneNode (Node *node)

WireNode *	getDebugNode () const

void	setDebugNode (WireNode *node)

string	getName () const

void	setName (string value)

string	toString () const

virtual	~Obstacle ()

virtual bool	init ()

virtual bool	init (const Vec2 &vec)

Public Attributes
CC_CONSTRUCTOR_ACCESS	__pad0__: ComplexObstacle() : Obstacle()

Public Attributes inherited from Obstacle
CC_CONSTRUCTOR_ACCESS	__pad0__: Obstacle(void)

Protected Attributes
b2Body *	_body

vector< Obstacle * >	_bodies

vector< b2Joint * >	_joints

bool	_tracking

Protected Attributes inherited from Obstacle
b2BodyDef	_bodyinfo

b2FixtureDef	_fixture

b2MassData	_massdata

Vec2	_drawScale

bool	_masseffect

Node *	_node

WireNode *	_debug

string	_tag

Additional Inherited Members
Protected Member Functions inherited from Obstacle
virtual void	resetSceneNode ()

virtual void	resetDebugNode ()

Detailed Description

Composite model class to support collisions.

ComplexObstacle instances are built of many bodies, and are assumed to be connected by joints (though this is not actually a requirement). This is the class to use for chains, ropes, levers, and so on. This class does not provide Shape information, and cannot be instantiated directly. There are no default complex objects. You will need to create your own subclasses to use this class.

ComplexObstacle is a hierarchical class. It groups children as Obstacles, not not bodies. So you could have a ComplexObstacle made up of other ComplexObstacles. However, it is not the same as a scene graph. Children have absolute, not relative, position data. Indeed, this class illustrates the need for decoupling the physics representation from the scene graph.

Transformations to an object of this class are restricted to the root body. They do not automatically effect the children (like a scene graph). If you want changes to the root body to effect the children, you should connect them with joints and allow Box2D to handle this.

Many of the method comments in this class are taken from the Box2d manual by Erin Catto (2011).

Constructor & Destructor Documentation

ComplexObstacle::~ComplexObstacle ( )

virtual

Deletes this physics object and all of its resources.

We have to make the destructor public so that we can polymorphically delete physics objects.

The purpose of this destructor is to warn us if we delete an object pre-maturely.

Member Function Documentation

bool ComplexObstacle::activatePhysics ( b2World & world )

overridevirtual

Creates the physics Body(s) for this object, adding them to the world.

This method invokes ActivatePhysics for the individual PhysicsObjects in the list. It also calls the internal method createJoints() to link them all together. You should override that method, not this one, for specific physics objects.

Parameters

world Box2D world to store body

Returns: true if object allocation succeeded

Creates the physics Body(s) for this object, adding them to the world.

Implementations of this method should NOT retain a reference to World. That is a tight coupling that we should avoid.

Parameters

world Box2D world to store body

Returns: true if object allocation succeeded

Reimplemented from Obstacle.

virtual void ComplexObstacle::createFixtures ( )

inlinevirtual

Create new fixtures for this body, defining the shape

This method is typically undefined for complex objects. While they need a root body, they rarely need a root shape. However, we provide this method for maximum flexibility.

virtual bool ComplexObstacle::createJoints ( b2World & world )

inlinevirtual

Creates the joints for this object.

This method is executed as part of activePhysics. This is the primary method to override for custom physics objects.

Parameters

world Box2D world to store joints

Returns: true if object allocation succeeded

void ComplexObstacle::deactivatePhysics ( b2World & world )

overridevirtual

Destroys the physics Body(s) of this object if applicable, removing them from the world.

Parameters

world Box2D world that stores body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getAngle ( ) const

inlineoverridevirtual

Returns the angle of rotation for this body (about the center).

The value is determined by the angle of the root object of this composite structure. The value returned is in radians.

Returns: the angle of rotation for this body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getAngularDamping ( ) const

inlineoverridevirtual

Returns the angular damping for this body.

Angular damping is use to reduce the angular velocity. Damping is different than friction because friction only occurs with contact. Damping is not a replacement for friction and the two effects should be used together.

Damping parameters should be between 0 and infinity, with 0 meaning no damping, and infinity meaning full damping. Normally you will use a damping value between 0 and 0.1.

This method only grabs the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: the angular damping for this body.

Reimplemented from Obstacle.

virtual float ComplexObstacle::getAngularVelocity ( ) const

inlineoverridevirtual

Returns the angular velocity for this physics body

This method uses the velocity for the root object of this composite structure. The rate of change is measured in radians per step

Returns: the angular velocity for this physics body

Reimplemented from Obstacle.

const vector<Obstacle*>& ComplexObstacle::getBodies ( )

inline

Returns the collection of component physics objects.

While the vector does not allow you to modify the list, it is possible to modify the individual objects.

Returns: the collection of component physics objects.

virtual b2Body* ComplexObstacle::getBody ( ) const

inlineoverridevirtual

Returns the Box2D body for this object.

This method only returrns the root body in this composite structure. For more fine-grain control, you should use the iterator methods.

Returns: the Box2D body for this object.

Reimplemented from Obstacle.

virtual b2BodyType ComplexObstacle::getBodyType ( ) const

inlineoverridevirtual

Returns the body type for Box2D physics

If you want to lock a body in place (e.g. a platform) set this value to STATIC. KINEMATIC allows the object to move (and some limited collisions), but ignores external forces (e.g. gravity). DYNAMIC makes this is a full-blown physics object.

This method returns the body type for the root object of this composite structure.

Returns: the body type for Box2D physics

Reimplemented from Obstacle.

virtual Vec2 ComplexObstacle::getCentroid ( ) const

inlineoverridevirtual

Returns the center of mass of this body

This method does NOT return a reference to the centroid position. Changes to this vector will not affect the body. However, it returns the same vector each time its is called, and so cannot be used as an allocator.

This method returns the centroid for the root object of this composite structure. While it would make more sense to use the true centroid, that is much more computationally expensive, as that centroid is not rigid.

Returns: the center of mass for this physics body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getGravityScale ( ) const

inlineoverridevirtual

Returns the gravity scale to apply to this body

This allows isolated objects to float. Be careful with this, since increased gravity can decrease stability.

This method only grabs the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: the gravity scale to apply to this body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getInertia ( ) const

inlineoverridevirtual

Returns the rotational inertia of this body

For static bodies, the mass and rotational inertia are set to zero. When a body has fixed rotation, its rotational inertia is zero.

This method only grabs the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: the rotational inertia of this body

Reimplemented from Obstacle.

const vector<b2Joint*>& ComplexObstacle::getJoints ( )

inline

Returns the collection of joints for this object (may be empty).

While the iterable does not allow you to modify the list, it is possible to modify the individual joints.

Returns: the collection of joints for this object.

virtual float ComplexObstacle::getLinearDamping ( ) const

inlineoverridevirtual

Returns the linear damping for this body.

Linear damping is use to reduce the linear velocity. Damping is different than friction because friction only occurs with contact. Damping is not a replacement for friction and the two effects should be used together.

Damping parameters should be between 0 and infinity, with 0 meaning no damping, and infinity meaning full damping. Normally you will use a damping value between 0 and 0.1. Most people avoid linear damping because it makes bodies look floaty.

This method only grabs the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: the linear damping for this body.

Reimplemented from Obstacle.

virtual Vec2 ComplexObstacle::getLinearVelocity ( ) const

inlineoverridevirtual

Returns the linear velocity for this physics body

This method does NOT return a reference to the velocity vector. Changes to this vector will not affect the body. However, it returns the same vector each time its is called, and so cannot be used as an allocator.

This method returns the velocity for the root of this composite structure.

Returns: the linear velocity for this physics body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getMass ( ) const

inlineoverridevirtual

Returns the mass of this body

The value is usually in kilograms. This method only grabs the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: the mass of this body

Reimplemented from Obstacle.

virtual Vec2 ComplexObstacle::getPosition ( ) const

inlineoverridevirtual

Returns the current position for this physics body

This method does NOT return a reference to the position vector. Changes to this vector will not affect the body. However, it returns the same vector each time its is called, and so cannot be used as an allocator.

This method returns the position for the root object of this composite structure.

Returns: the current position for this physics body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getVX ( ) const

inlineoverridevirtual

Returns the x-velocity for this physics body

This method uses the velocity for the root of this composite structure.

Returns: the x-velocity for this physics body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getVY ( ) const

inlineoverridevirtual

Returns the y-velocity for this physics body

Returns: the y-velocity for this physics body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getX ( ) const

inlineoverridevirtual

Returns the x-coordinate for this physics body

This method uses the position for the root object of this composite structure.

Returns: the x-coordinate for this physics body

Reimplemented from Obstacle.

virtual float ComplexObstacle::getY ( ) const

inlineoverridevirtual

Returns the y-coordinate for this physics body

This method uses the position for the root object of this composite structure.

Returns: the y-coordinate for this physics body

Reimplemented from Obstacle.

virtual bool ComplexObstacle::isActive ( ) const

inlineoverridevirtual

Returns true if the body is active

An inactive body not participate in collision or dynamics. This state is similar to sleeping except the body will not be woken by other bodies and the body's fixtures will not be placed in the broad-phase. This means the body will not participate in collisions, ray casts, etc.

This method only tests the activity of the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: true if the body is active

Reimplemented from Obstacle.

virtual bool ComplexObstacle::isAwake ( ) const

inlineoverridevirtual

Returns true if the body is awake

An sleeping body is one that has come to rest and the physics engine has decided to stop simulating it to save CPU cycles. If a body is awake and collides with a sleeping body, then the sleeping body wakes up. Bodies will also wake up if a joint or contact attached to them is destroyed. You can also wake a body manually.

This method only tests the status of the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: true if the body is awake

Reimplemented from Obstacle.

virtual bool ComplexObstacle::isBullet ( ) const

inlineoverridevirtual

Returns true if this body is a bullet

By default, Box2D uses continuous collision detection (CCD) to prevent dynamic bodies from tunneling through static bodies. Normally CCD is not used between dynamic bodies. This is done to keep performance reasonable. In some game scenarios you need dynamic bodies to use CCD. For example, you may want to shoot a high speed bullet at a stack of dynamic bricks. Without CCD, the bullet might tunnel through the bricks.

Fast moving objects in Box2D can be labeled as bullets. Bullets will perform CCD with both static and dynamic bodies. You should decide what bodies should be bullets based on your game design.

This method only tests the status of the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: true if this body is a bullet

Reimplemented from Obstacle.

virtual bool ComplexObstacle::isFixedRotation ( ) const

inlineoverridevirtual

Returns true if this body be prevented from rotating

This is very useful for characters that should remain upright. This method only tests the status of the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: true if this body be prevented from rotating

Reimplemented from Obstacle.

bool ComplexObstacle::isSceneTracking ( )

inline

Returns whether the scene/debug node tracks the root body.

If this value is true, the top-level scene graph for this object will move according to this object. In general, this is undesirable, because the individual components are likely in the same world space. It is often better for the scene node to be fixed and for the individual children to track instead.

This value is false by default.

Returns: whether the scene/debug node tracks the root body.

virtual bool ComplexObstacle::isSleepingAllowed ( ) const

inlineoverridevirtual

Returns false if this body should never fall asleep

An sleeping body is one that has come to rest and the physics engine has decided to stop simulating it to save CPU cycles. If a body is awake and collides with a sleeping body, then the sleeping body wakes up. Bodies will also wake up if a joint or contact attached to them is destroyed. You can also wake a body manually.

This method only tests the status of the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Returns: false if this body should never fall asleep

Reimplemented from Obstacle.

void ComplexObstacle::positionDebugNode ( )

overridevirtual

Repositions the debug node so that it agrees with the physics object.

By default, the position of a node should be the body position times the draw scale. However, for some obstacles (particularly complex obstacles), it may be desirable to turn the default functionality off. Hence we have made this virtual.

Reimplemented from Obstacle.

void ComplexObstacle::positionSceneNode ( )

overridevirtual

Repositions the scene node so that it agrees with the physics object.

By default, the position of a node should be the body position times the draw scale. However, for some obstacles (particularly complex obstacles), it may be desirable to turn the default functionality off. Hence we have made this virtual.

Reimplemented from Obstacle.

virtual void ComplexObstacle::releaseFixtures ( )

inlinevirtual

Release the fixtures for this body, reseting the shape

This method is typically undefined for complex objects. While they need a root body, they rarely need a root shape. However, we provide this method for maximum flexibility.

virtual void ComplexObstacle::resetMass ( )

inlineoverridevirtual

Resets this body to use the mass computed from the its shape and density.

This method only modifies the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Reimplemented from Obstacle.

virtual void ComplexObstacle::setActive ( bool value )

inlineoverridevirtual

Sets whether the body is active

An inactive body not participate in collision or dynamics. This state is similar to sleeping except the body will not be woken by other bodies and the body's fixtures will not be placed in the broad-phase. This means the body will not participate in collisions, ray casts, etc.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value whether the body is active

Reimplemented from Obstacle.

virtual void ComplexObstacle::setAngle ( float value )

inlineoverridevirtual

Sets the angle of rotation for this body (about the center).

This method sets the angle for the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

value the angle of rotation for this body (in radians)

Reimplemented from Obstacle.

virtual void ComplexObstacle::setAngularDamping ( float value )

inlineoverridevirtual

Sets the angular damping for this body.

Angular damping is use to reduce the angular velocity. Damping is different than friction because friction only occurs with contact. Damping is not a replacement for friction and the two effects should be used together.

Damping parameters should be between 0 and infinity, with 0 meaning no damping, and infinity meaning full damping. Normally you will use a damping value between 0 and 0.1.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value the angular damping for this body.

Reimplemented from Obstacle.

virtual void ComplexObstacle::setAngularVelocity ( float value )

inlineoverridevirtual

Sets the angular velocity for this physics body

This method sets the velocity for the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

value the angular velocity for this physics body (in radians)

Reimplemented from Obstacle.

virtual void ComplexObstacle::setAwake ( bool value )

inlineoverridevirtual

Sets whether the body is awake

An sleeping body is one that has come to rest and the physics engine has decided to stop simulating it to save CPU cycles. If a body is awake and collides with a sleeping body, then the sleeping body wakes up. Bodies will also wake up if a joint or contact attached to them is destroyed. You can also wake a body manually.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value whether the body is awake

Reimplemented from Obstacle.

virtual void ComplexObstacle::setBodyType ( b2BodyType value )

inlineoverridevirtual

Returns the body type for Box2D physics

If you want to lock a body in place (e.g. a platform) set this value to STATIC. KINEMATIC allows the object to move (and some limited collisions), but ignores external forces (e.g. gravity). DYNAMIC makes this is a full-blown physics object.

This sets the body type for the root body only. If you want to set the type of other objects in this class, iterate over the children.

Returns: the body type for Box2D physics

Reimplemented from Obstacle.

virtual void ComplexObstacle::setBullet ( bool value )

inlineoverridevirtual

Sets whether this body is a bullet

By default, Box2D uses continuous collision detection (CCD) to prevent dynamic bodies from tunneling through static bodies. Normally CCD is not used between dynamic bodies. This is done to keep performance reasonable. In some game scenarios you need dynamic bodies to use CCD. For example, you may want to shoot a high speed bullet at a stack of dynamic bricks. Without CCD, the bullet might tunnel through the bricks.

Fast moving objects in Box2D can be labeled as bullets. Bullets will perform CCD with both static and dynamic bodies. You should decide what bodies should be bullets based on your game design.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value whether this body is a bullet

Reimplemented from Obstacle.

virtual void ComplexObstacle::setCentroid ( const Vec2 & value )

inlineoverridevirtual

Sets the center of mass for this physics body

This method converts from a Cocos2D vector type to a Box2D vector type. This cuts down on the confusion between vector types.

Parameters

value the center of mass for this physics body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setCentroid	(	float	x,
		float	y
	)

inlineoverridevirtual

Sets the center of mass for this physics body

This method does not keep a reference to the parameter. This method sets the centroid for the root object of this composite structure. While it would make more sense to use the true centroid, that is much more computationally expensive, as that centroid is not rigid.

Parameters

value the center of mass for this physics body

Reimplemented from Obstacle.

NS_CC_BEGIN void ComplexObstacle::setDensity ( float value )

overridevirtual

Sets the density of this body

The density is typically measured in usually in kg/m^2. The density can be zero or positive. You should generally use similar densities for all your fixtures. This will improve stacking stability.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value the density of this body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setDrawScale ( const Vec2 & value )

inlineoverridevirtual

Sets the drawing scale for this physics object

The drawing scale is the number of pixels to draw before Box2D unit. Because mass is a function of area in Box2D, we typically want the physics objects to be small. So we decouple that scale from the physics object. However, we must track the scale difference to communicate with the scene graph.

We allow for the scaling factor to be non-uniform.

Parameters

value the drawing scale for this physics object

Reimplemented from Obstacle.

void ComplexObstacle::setDrawScale	(	float	x,
		float	y
	)

overridevirtual

Sets the drawing scale for this physics object

The drawing scale is the number of pixels to draw before Box2D unit. Because mass is a function of area in Box2D, we typically want the physics objects to be small. So we decouple that scale from the physics object. However, we must track the scale difference to communicate with the scene graph.

We allow for the scaling factor to be non-uniform.

Parameters

x	the x-axis scale for this physics object
y	the y-axis scale for this physics object

Reimplemented from Obstacle.

void ComplexObstacle::setFilterData ( b2Filter value )

overridevirtual

Sets the filter data for this object

Collision filtering allows you to prevent collision between fixtures. For example, say you make a character that rides a bicycle. You want the bicycle to collide with the terrain and the character to collide with the terrain, but you don't want the character to collide with the bicycle (because they must overlap). Box2D supports such collision filtering using categories and groups.

A value of null removes all collision filters. This method affects ALL of the bodies in this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Parameters

value the filter data for this object

Reimplemented from Obstacle.

virtual void ComplexObstacle::setFixedRotation ( bool value )

inlineoverridevirtual

Sets whether this body be prevented from rotating

This is very useful for characters that should remain upright.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value whether this body be prevented from rotating

Reimplemented from Obstacle.

void ComplexObstacle::setFriction ( float value )

overridevirtual

Sets the friction coefficient of this body

The friction parameter is usually set between 0 and 1, but can be any non-negative value. A friction value of 0 turns off friction and a value of 1 makes the friction strong. When the friction force is computed between two shapes, Box2D must combine the friction parameters of the two parent fixtures. This is done with the geometric mean.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value the friction coefficient of this body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setGravityScale ( float value )

inlineoverridevirtual

Sets the gravity scale to apply to this body

This allows isolated objects to float. Be careful with this, since increased gravity can decrease stability.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value the gravity scale to apply to this body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setInertia ( float value )

inlineoverridevirtual

Sets the rotational inertia of this body

For static bodies, the mass and rotational inertia are set to zero. When a body has fixed rotation, its rotational inertia is zero.

This method only modifies the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Parameters

value the rotational inertia of this body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setLinearDamping ( float value )

inlineoverridevirtual

Sets the linear damping for this body.

Linear damping is use to reduce the linear velocity. Damping is different than friction because friction only occurs with contact. Damping is not a replacement for friction and the two effects should be used together.

Damping parameters should be between 0 and infinity, with 0 meaning no damping, and infinity meaning full damping. Normally you will use a damping value between 0 and 0.1. Most people avoid linear damping because it makes bodies look floaty.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value the linear damping for this body.

Reimplemented from Obstacle.

virtual void ComplexObstacle::setLinearVelocity ( const Vec2 & value )

inlineoverridevirtual

Sets the linear velocity for this physics body

This method converts from a Cocos2D vector type to a Box2D vector type. This cuts down on the confusion between vector types.

Parameters

value the linear velocity for this physics body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setLinearVelocity	(	float	x,
		float	y
	)

inlineoverridevirtual

Sets the linear velocity for this physics body

This method sets the linear velocity for the root of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

x	the x-coordinate of the linear velocity
y	the y-coordinate of the linear velocity

Reimplemented from Obstacle.

virtual void ComplexObstacle::setMass ( float value )

inlineoverridevirtual

Sets the mass of this body

The value is usually in kilograms. This method only modifies the parameter for the root object of this composite structure. For fine-grain control, you will need to loop over all elements in the composite structure.

Parameters

value the mass of this body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setPosition ( const Vec2 & value )

inlineoverridevirtual

Sets the current position for this physics body

This method converts from a Cocos2D vector type to a Box2D vector type. This cuts down on the confusion between vector types.

Parameters

value the current position for this physics body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setPosition	(	float	x,
		float	y
	)

inlineoverridevirtual

Sets the current position for this physics body

This method sets the position for the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

x	the x-coordinate of the linear velocity
y	the y-coordinate of the linear velocity

Reimplemented from Obstacle.

void ComplexObstacle::setRestitution ( float value )

overridevirtual

Sets the restitution of this body

Restitution is used to make objects bounce. The restitution value is usually set to be between 0 and 1. Consider dropping a ball on a table. A value of zero means the ball won't bounce. This is called an inelastic collision. A value of one means the ball's velocity will be exactly reflected. This is called a perfectly elastic collision.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value the restitution of this body

Reimplemented from Obstacle.

void ComplexObstacle::setSceneTracking ( bool track )

inline

Sets whether the scene/debug node tracks the root body.

If this value is true, the top-level scene graph for this object will move according to this object. In general, this is undesirable, because the individual components are likely in the same world space. It is often better for the scene node to be fixed and for the individual children to track instead.

Parameters

track whether the scene/debug node tracks the root body.

void ComplexObstacle::setSensor ( bool value )

overridevirtual

Sets whether this object is a sensor.

Sometimes game logic needs to know when two entities overlap yet there should be no collision response. This is done by using sensors. A sensor is an entity that detects collision but does not produce a response.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value whether this object is a sensor.

Reimplemented from Obstacle.

virtual void ComplexObstacle::setSleepingAllowed ( bool value )

inlineoverridevirtual

Sets whether the body should ever fall asleep

An sleeping body is one that has come to rest and the physics engine has decided to stop simulating it to save CPU cycles. If a body is awake and collides with a sleeping body, then the sleeping body wakes up. Bodies will also wake up if a joint or contact attached to them is destroyed. You can also wake a body manually.

This method affects the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children.

Parameters

value whether the body should ever fall asleep

Reimplemented from Obstacle.

virtual void ComplexObstacle::setVX ( float value )

inlineoverridevirtual

Sets the x-velocity for this physics body

This method sets the velocity for the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

value the x-velocity for this physics body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setVY ( float value )

inlineoverridevirtual

Sets the y-velocity for this physics body

This method sets the velocity for the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

value the y-velocity for this physics body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setX ( float value )

inlineoverridevirtual

Sets the x-coordinate for this physics body

This method sets the position for the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

value the x-coordinate for this physics body

Reimplemented from Obstacle.

virtual void ComplexObstacle::setY ( float value )

inlineoverridevirtual

Sets the y-coordinate for this physics body

This method sets the position for the root body of this composite structure only. If you want to set the value for any of the child obstacles, iterate over the children. Alternatively attach the other children to the parent with joints so that they move together.

Parameters

value the y-coordinate for this physics body

Reimplemented from Obstacle.

void ComplexObstacle::update ( float delta )

overridevirtual

Updates the object's physics state (NOT GAME LOGIC).

This method is called AFTER the collision resolution state. Therefore, it should not be used to process actions or any other gameplay information. Its primary purpose is to adjust changes to the fixture, which have to take place after collision.

Parameters

dt	Timing values from parent loop

Updates the object's physics state (NOT GAME LOGIC).

This method is called AFTER the collision resolution state. Therefore, it should not be used to process actions or any other gameplay information. Its primary purpose is to adjust changes to the fixture, which have to take place after collision.

In other words, this is the method that updates the scene graph. If you forget to call it, it will not draw your changes.

Parameters

dt	Timing values from parent loop

Reimplemented from Obstacle.

Member Data Documentation

vector<Obstacle*> ComplexObstacle::_bodies

protected

A complex physics object has multiple bodies

b2Body* ComplexObstacle::_body

protected

A root body for this box 2d.

vector<b2Joint*> ComplexObstacle::_joints

protected

Potential joints for connecting the multiple bodies

bool ComplexObstacle::_tracking

protected

Whether to track the scene and debug nodes to the root body

The documentation for this class was generated from the following files:

/Users/wmwhite/Developer/cocos2d-cornell/cocos/cornell/CUComplexObstacle.h
/Users/wmwhite/Developer/cocos2d-cornell/cocos/cornell/CUComplexObstacle.cpp

Public Member Functions

Public Attributes

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation