1

#ifndef PHYSICS_HH

     2

#define PHYSICS_HH

     3

     4

#include "Vector.hh"

     5

     6

#include <vector>

     7

#include <queue>

     8

#include <ClanLib/core.h>

     9

    10

typedef uint16_t TimeMS;

    11

    12

const TimeMS PHYSICS_TICK_MS = 10;

    13

    14

enum TerrainType {EMPTY, DIRT, ROCK};

    15

    16

const Vector DIRECTIONS[] = { Vector(0,-1), Vector(1,-1), Vector(1,0), Vector(1,1),

    17

							Vector(0,1), Vector(-1,1), Vector(-1,0), Vector(-1,-1) };

    18

    19

// forward-declare

    20

class PhysicsObject;

    21

typedef Vector Force;

    22

struct Derivative;

    23

    24

class PhysicsWorld {

    25

    friend class PhysicsObject;

    26

    27

private:

    28

    CL_Timer tick_timer;

    29

    30

protected:

    31

    std::vector<PhysicsObject*> objects;

    32

    Vector gravity;

    33

    Vector dimensions;

    34

    35

    36

    std::vector<std::vector<TerrainType> > terrain;

    37

    38

    CL_SlotContainer slots;

    39

    40

    PhysicsWorld (Vector gravity, Vector dimensions);

    41

    42

    43

public:

    44

    45

    void addObject (PhysicsObject *object);

    46

    47

    void tick (void);

    48

    void generateTerrain (int seed);

    49

    bool collided (Vector oldPos, Vector newPos);

    50

    51

    TerrainType getType(Vector pos) const;

    52

};

    53

    54

class PhysicsObject {

    55

protected:

    56

    PhysicsWorld &world;

    57

    58

    float mass;

    59

    Vector position;

    60

    Vector velocity;

    61

    // Whether the object (worms mainly) is in the air 

    62

    // or firmly on the ground. Affects to physics.

    63

    bool inAir;

    64

    65

	// Shape of the object. We use a polygon with 4 edges

    66

	// to make easy to draw with Clanlib. The coordinates

    67

	// are relative to the center point.

    68

	std::vector<Vector> shape;

    69

    70

    // Force queue that is emptied on every tick

    71

    std::queue<Force> forceq;

    72

    Vector posAfterTick;

    73

    Vector velAfterTick;

    74

    75

	/**

    76

	 * @param shape Corners of the four sided polygon.

    77

	 */

    78

    PhysicsObject (PhysicsWorld &world, float mass, Vector position, Vector velocity);

    79

    83

    virtual void applyForce (Force force, TimeMS dt);

    88

    void updatePhysics (Vector position, Vector velocity);

   100

	void jump (void);

   102

private:

   103

    void updatePosition (void);

   104

	bool possibleLocation (Vector loc);

   105

   106

    /**

   107

     * Use RK4 to integrate the effects of force over a time intervall.

   108

     */

   109

    void integrate(Force force, TimeMS dt);

   110

    Derivative evaluate(Force force, TimeMS dt, Derivative &d);

   111

    Vector acceleration(const Force &force);

   112

   113

public:

   114

    Vector getPosition (void);

   115

	std::vector<Vector>& getShape(void);

   116

	void setShape (std::vector<Vector> shape);

   117

   118

    void tick (void);

   119

};

   120

   121

struct Derivative {

   122

    Vector dx; // Velocity

   123

    Vector dv; // Acceleration

   124

};

   125

   126

   127

   128

#endif