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

    Vector getNormal(Vector hitPoint, Vector prevPoint);

    52

    53

    TerrainType getType(Vector pos) const;

    54

};

    55

    56

class PhysicsObject {

    57

protected:

    58

    PhysicsWorld &world;

    59

    60

    float mass;

    61

    Vector position;

    62

    Vector velocity;

    63

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

    64

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

    65

    bool inAir;

    66

    67

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

    68

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

    69

	// are relative to the center point.

    70

	std::vector<Vector> shape;

    71

    72

    // Force queue that is emptied on every tick

    73

    std::queue<Force> forceq;

    74

    Vector posAfterTick;

    75

    Vector velAfterTick;

    76

    77

	/**

    78

	 * @param shape Corners of the four sided polygon.

    79

	 */

    80

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

    81

    82

    /**

    83

     * Used to handle in-air movement

    84

     */    

    85

    virtual void applyForce (Force force, TimeMS dt);

    86

    87

    /**

    88

     * Called on network clients to sync state from server

    89

     */

    90

    void updatePhysics (Vector position, Vector velocity);

    91

    92

    /**

    93

     * Handle ground movement

    94

     *

    95

     * @return new position

    96

     */

    97

    Vector walk (bool right);

    98

    99

    /**

   100

     * Handle ground-jumping

   101

     */

   102

    void jump (void);

   103

   104

    /**

   105

     * Handle ground-bounce

   106

     */

   107

    void bounce (Vector normal);

   108

   109

private:

   110

    void updatePosition (void);

   111

	bool possibleLocation (Vector loc);

   112

   113

    /**

   114

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

   115

     */

   116

    void integrate(Force force, TimeMS dt);

   117

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

   118

    Vector acceleration(const Force &force);

   119

   120

public:

   121

    Vector getPosition (void);

   122

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

   123

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

   124

   125

    void tick (void);

   126

};

   127

   128

struct Derivative {

   129

    Vector dx; // Velocity

   130

    Vector dv; // Acceleration

   131

};

   132

   133

   134

   135

#endif