dumb_physics.h File Reference

#include "entity.h"

Include dependency graph for dumb_physics.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	physics_laws_t {   PHYSICS_NULL = 0,   PHYSICS_BASE_FRICTION = 1,   PHYSICS_BASE_SPEED_X = 5,   PHYSICS_BASE_SPEED_Y = 10,   PHYSICS_MAX_SPEED = 16,   PHYSICS_MAX }

Functions
void	RunPhysics ()
int	CheckCollision (entity_t *self, entity_t *other)
void	DoCollision (entity_t *self, entity_t *other)
void	ApplySpeedLimit (vec2_t *a)
void	ApplyBounds (entity_t *ent)
void	ApplyFriction (vec2_t *a)

Enumeration Type Documentation

enum physics_laws_t

Defines the Preset Physics values

Enumerator
PHYSICS_NULL
PHYSICS_BASE_FRICTION	An enum constant representing the physics base friction option
PHYSICS_BASE_SPEED_X	An enum constant representing the physics base speed in x direction
PHYSICS_BASE_SPEED_Y	An enum constant representing the physics base speed in y direction
PHYSICS_MAX_SPEED	An enum constant representing the physics maximum speed
PHYSICS_MAX

Definition at line 7 of file dumb_physics.h.

{
        PHYSICS_NULL                    = 0,
        PHYSICS_BASE_FRICTION   = 1,    /**< An enum constant representing the physics base friction option */
        PHYSICS_BASE_SPEED_X    = 5,    /**< An enum constant representing the physics base speed in x direction */
        PHYSICS_BASE_SPEED_Y    = 10,   /**< An enum constant representing the physics base speed in y direction */
        PHYSICS_MAX_SPEED               = 16,   /**< An enum constant representing the physics maximum speed  */
        PHYSICS_MAX
}physics_laws_t;

Function Documentation

void ApplyBounds

(

entity_t *

ent

)

Applies the bounds to specified ent, defined by the screen dimensions.

Parameters

[in,out]

ent

If non-null, the ent.

Author

Anthony Rios

Date

3/29/2016

Definition at line 168 of file dumb_physics.c.

References gScreenHeight, gScreenWidth, and PHYSICS_MAX_SPEED.

Referenced by RunPhysics().

{
        if(ent->mPosition.x < 0)
        {
                ent->mPosition.x = 0;
                ent->mVelocity.x = 0;
                ent->mAccel.x = 0;
        } else if (ent->mPosition.x > gScreenWidth)
        {
                ent->mPosition.x = gScreenWidth - PHYSICS_MAX_SPEED;
                ent->mVelocity.x = 0;
                ent->mAccel.x = 0;
        }
        if(ent->mPosition.y < 0)
        {
                ent->mPosition.y = 0;
                ent->mVelocity.y = 0;
                ent->mAccel.y = 0;
        } else if (ent->mPosition.y > gScreenHeight)
        {
                ent->mPosition.y = gScreenHeight - PHYSICS_MAX_SPEED;
                ent->mVelocity.y = 0;
                ent->mAccel.y = 0;
        }
}

void ApplyFriction

(

vec2_t *

a

)

Applies the friction to vector a, for the nonzero values. Uses Physics_base_friction for friction coefficient.

Parameters

[in,out]

a

If non-null, the vec2_t to process.

Author

Anthony Rios

Date

3/29/2016

Definition at line 194 of file dumb_physics.c.

References PHYSICS_BASE_FRICTION, vec2_t::x, and vec2_t::y.

Referenced by RunPhysics().

{
        if(abs(a->x))
        {
                a->x += a->x < 0 ? PHYSICS_BASE_FRICTION : -PHYSICS_BASE_FRICTION;
        }
        if(abs(a->y))
        {
                a->y += a->y < 0 ? PHYSICS_BASE_FRICTION : -PHYSICS_BASE_FRICTION;
        }
}

void ApplySpeedLimit

(

vec2_t *

a

)

Applies the speed limit to vector a, defined by physics max speed.

Parameters

[in,out]

a

If non-null, the vec2_t to process.

Author

Anthony Rios

Date

3/29/2016

Definition at line 162 of file dumb_physics.c.

References PHYSICS_MAX_SPEED, vec2_t::x, and vec2_t::y.

Referenced by RunPhysics().

{
        a->x = abs(a->x) > PHYSICS_MAX_SPEED ? (a->x < 0 ? -PHYSICS_MAX_SPEED : PHYSICS_MAX_SPEED) : a->x;
        a->y = abs(a->y) > PHYSICS_MAX_SPEED ? (a->y < 0 ? -PHYSICS_MAX_SPEED : PHYSICS_MAX_SPEED) : a->y;
}

int CheckCollision	(	entity_t *	self,
		entity_t *	other
	)

Check collision between entities. (AABB)

Parameters

[in,out]	self	If non-null, the class instance that this method operates on.
[in,out]	other	If non-null, the other.

Returns

An int 1 if colliding, 0 if not.

Author

Anthony Rios

Date

3/20/2016

Definition at line 57 of file dumb_physics.c.

References COLLISION_TYPE_CLIP.

Referenced by RunPhysics().

{
        if(self->mCollisionType == COLLISION_TYPE_CLIP || other->mCollisionType == COLLISION_TYPE_CLIP)
        {
                return 0;
        }
        if(!self->mSprites || !self->mSprites)
        {
                return 0;
        }
        if(self->mPosition.x + self->mSprites[0]->mSize.x < other->mPosition.x || self->mPosition.y + self->mSprites[0]->mSize.y < other->mPosition.y
                || self->mPosition.x > other->mPosition.x + other->mSprites[0]->mSize.x || self->mPosition.y > other->mPosition.y + other->mSprites[0]->mSize.y)
        {
                return 0;
        }
        return 1;
}

void DoCollision	(	entity_t *	self,
		entity_t *	other
	)

Executes the collision operation. Place self farthest x or y away from other, vice versa. And negative the velocity to half of orginal collision vel, for bounce back.

Parameters

[in,out]	self	If non-null, the class instance that this method operates on.
[in,out]	other	If non-null, the other.

Author

Anthony Rios

Date

3/20/2016

Definition at line 75 of file dumb_physics.c.

References COLLISION_TYPE_RAGDOLL, Vec2Add(), vec2_t::x, and vec2_t::y.

Referenced by RunPhysics().

{
        vec2_t self_min, self_max, self_res, other_min, other_max, other_res;
        int left, right, bottom, top;
        if(self->Touch)
        {
                self->Touch(self, other, other->mCollisionType);
        }
        if(other->Touch)
        {
                other->Touch(other, self, self->mCollisionType);
        }
        if(strcmp(self->mName, other->mName))
        {
                printf("%s collided with %s \n", self->mName, other->mName);
        }
        self_min = self->mPosition;
        Vec2Add(&self->mPosition, &self->mSprites[0]->mSize, &self_max);
        other_min = other->mPosition;
        Vec2Add(&other->mPosition, &other->mSprites[0]->mSize, &other_max);

        left = other_min.x - self_max.x;
        right = other_max.x - self_min.x;
        top = other_min.y - self_max.y;
        bottom = other_max.y - self_min.y;
        if(abs(left) < right)
        {
                self_res.x = left;
                other_res.x = right;
        } else
        {
                self_res.x = right;
                other_res.x = left;
        }

        if(abs(top) < bottom)
        {
                self_res.y = top;
                other_res.y = bottom;
        } else
        {
                self_res.y = bottom;
                other_res.y = top;
        }
        
        if(abs(self_res.x) < abs(self_res.y))
        {
                self_res.y = 0;
        } else
        {
                self_res.x = 0;
        }

        if(abs(other_res.x) < abs(other_res.y))
        {
                other_res.y = 0;
        } else
        {
                other_res.x = 0;
        }

        if(self->mCollisionType == COLLISION_TYPE_RAGDOLL)
        {
                Vec2Add(&self->mPosition, &self_res, &self->mPosition);
                if(self_res.x)
                {
                        self->mVelocity.x = -self->mVelocity.x/2;
                } else
                {
                        self->mVelocity.y = -self->mVelocity.y/2;
                }
        }
        if(other->mCollisionType == COLLISION_TYPE_RAGDOLL)
        {
                Vec2Add(&other->mPosition, &other_res, &other->mPosition);
                if(other_res.x)
                {
                        other->mVelocity.x = -self->mVelocity.x/2;
                } else
                {
                        other->mVelocity.y = -self->mVelocity.y/2;
                }

        }

}

void RunPhysics

(

)

Executes physics. RunTime O( n(n+1)/2 ) Applies velocity, acceleration, gravity, and friction. Limits velocity, acceleration, and sets bounds.

Author

Anthony Rios

Date

3/20/2016

Definition at line 9 of file dumb_physics.c.

References ApplyBounds(), ApplyFriction(), ApplySpeedLimit(), CheckCollision(), COLLISION_TYPE_STATIC, DoCollision(), gEntities, MAX_ENTITIES, PHYSICS_LIMITER, Vec2Add(), and vec2_t::y.

Referenced by UpdatePlaying().

{
        int i, j;
        for(i = 0; i < MAX_ENTITIES; i++)
        {
                if(!gEntities[i].mName)
                {
                        continue;
                }
                if(!gEntities[i].mCollisionType == COLLISION_TYPE_STATIC)
                {
                        ApplyFriction(&gEntities[i].mVelocity);
                        gEntities[i].mPosition.x += gEntities[i].mVelocity.x/PHYSICS_LIMITER;
                        gEntities[i].mPosition.y += gEntities[i].mVelocity.y/PHYSICS_LIMITER;
                        Vec2Add(&gEntities[i].mAccel,&gEntities[i].mVelocity,&gEntities[i].mVelocity);
                        if(gEntities[i].mWeight)
                        {
                                gEntities[i].mAccel.y = gGravity.y;
                        }
                        ApplySpeedLimit(&gEntities[i].mVelocity);
                        ApplySpeedLimit(&gEntities[i].mAccel);
                        ApplyBounds(&gEntities[i]);
                }
                
                //Vec2Add(&friction,&gEntities[i].mVelocity,&gEntities[i].mVelocity);
                
        }
        //Collision Check
        for(i = 0; i < MAX_ENTITIES; i++)
        {
                if(!gEntities[i].mName)
                {
                        continue;
                }
                for(j = i; j < MAX_ENTITIES; j++)
                {
                        if(i == j || !gEntities[j].mName)
                        {
                                continue;
                        }
                        if(CheckCollision(&gEntities[i], &gEntities[j]))
                        {
                                DoCollision(&gEntities[i], &gEntities[j]);
                        }
                }
        }
}