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

    uint32_t tick_counter;

    31

    32

protected:

    33

    std::vector<PhysicsObject*> objects;

    34

    Vector gravity;

    35

    Vector dimensions;

    36

    37

    38

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

    39

    40

    CL_SlotContainer slots;

    41

    42

    PhysicsWorld (Vector gravity, Vector dimensions);

    43

    44

    45

public:

    46

    47

    void addObject (PhysicsObject *object);

    48

    49

    void tick (void);

    50

    uint32_t getTick (void);

    51

    52

    void generateTerrain (int seed);

    53

    bool collided (Vector oldPos, Vector newPos);

    54

    55

    Vector getNormal(Vector hitPoint, Vector prevPoint);

    56

    57

    TerrainType getType(int x, int y) const;

    58

    TerrainType getType(Vector pos) const;

    59

    60

    void removeGround(int x, int y, float r);

    61

    void removeGround(Vector pos, float r);

    62

};

    63

    64

class PhysicsObject {

    65

protected:

    66

    PhysicsWorld &world;

    67

    68

    float mass;

    69

    Vector position;

    70

    Vector velocity;

    71

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

    72

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

    73

    bool inAir;

    74

    float aim;

    75

    uint8_t facing;

    76

    77

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

    78

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

    79

    // are relative to the center point.

    80

    std::vector<Vector> shape;

    81

    82

    // Force queue that is emptied on every tick

    83

    std::queue<Force> forceq;

    84

    Vector posAfterTick;

    85

    Vector velAfterTick;

    86

    87

    /**

    88

     * @param shape Corners of the four sided polygon.

    89

     */

    90

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

    91

    ~PhysicsObject() {}   

    92

    93

    /**

    94

     * Adds force to the force queue. Force queue is emptied on each

    95

     * tick. Forces that last over one tick are also handled. This

    96

     * function is only used to handle in air movement.

    97

     *

    98

     * @param force Force vector.  

    99

     * @param dt The time the force is applied.

   100

     */

   102

   103

    /**

   104

     * Changes player aim

   105

     */

   106

    void changeAim(float da);

   107

   108

    /**

   109

     * Set player facing.

   110

     */ 

   111

    void setFacing(bool right);

   112

   113

    /**

   114

     * Called on network clients to sync state from server

   115

     */

   116

    void updatePhysics (Vector position, Vector velocity, bool inAir);

   117

   118

    /**

   119

     * Handle ground movement

   120

     *

   121

     * @return new position

   122

     */

   123

    Vector walk (bool right);

   124

   125

    /**

   126

     * Handle ground-jumping

   127

     */

   128

    void jump (void);

   129

   130

    /**

   131

     * Handle ground-bounce

   132

     */

   133

    void bounce (Vector normal);

   134

   135

private:

   136

    void updatePosition (void);

   137

	bool possibleLocation (Vector loc);

   138

   139

    /**

   140

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

   141

     */

   142

    void integrate(Force force, TimeMS dt);

   143

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

   144

    Vector acceleration(const Force &force);

   145

   146

    virtual void onCollision() {}

   147

   148

public:

   149

    Vector getPosition (void);

   150

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

   151

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

   152

   153

    bool getFacing(void);

   154

    float getAim(void);

   155

   156

    void tick (void);

   157

};

   158

   159

struct Derivative {

   160

    Vector dx; // Velocity

   161

    Vector dv; // Acceleration

   162

};

   163

   164

   165

   166

#endif