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

    /**

    48

     * Adds objects to the physicsworld.

    49

     *

    50

     * @param object Pointer to PhysicsObject to add.

    51

     */

    52

    void addObject (PhysicsObject *object);

    53

    54

    /**

    55

     * Advance one time step in physics simulation.

    56

     */

    57

    void tick (void);

    58

    /**

    59

     * Get current tick in physics simulation.

    60

     */

    61

    uint32_t getTick (void);

    62

    63

    64

    /**

    65

     * Generate random terrain.

    66

     */

    67

    void generateTerrain (int seed);

    68

    69

    /**

    70

     * TODO: We'll have to think about this.

    71

     */

    72

    bool collided (Vector prevPos, Vector newPos);

    73

    74

    /**

    75

     * Return a normal for the wall that has been hit.

    76

     *

    77

     * @param hitPoint The point of the wall that has been hit.

    78

     * @param prevPoint The point from where we were coming.

    79

     */

    80

    Vector getNormal(Vector hitPoint, Vector prevPoint);

    81

    82

    /**

    83

     * Return terrain type in specific position.

    84

     *

    85

     * @param x x-coordinate

    86

     * @param y y-coordinate

    87

     */

    88

    TerrainType getType(int x, int y) const;

    89

    /**

    90

     * Return terrain type in specific position.

    91

     *

    92

     * @param pos Position vector

    93

     */

    94

    TerrainType getType(Vector pos) const;

    95

   104

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

   113

    void removeGround(Vector pos, float r);

   114

};

   115

   116

class PhysicsObject {

   117

protected:

   118

    PhysicsWorld &world;

   119

   120

    float mass;

   121

    Vector position;

   122

    Vector velocity;

   126

   127

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

   128

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

   129

    // are relative to the center point.

   130

    std::vector<Vector> shape;

   131

   132

    // Force queue that is emptied on every tick

   133

    std::queue<Force> forceq;

   134

    Vector posAfterTick;

   135

    Vector velAfterTick;

   136

   137

    /**

   138

     * @param shape Corners of the four sided polygon.

   139

     */

   140

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

   141

    ~PhysicsObject() {}   

   142

   143

    /**

   144

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

   145

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

   146

     * function is only used to handle in air movement.

   147

     *

   148

     * @param force Force vector.  

   149

     * @param dt The time the force is applied.

   150

     */

   151

    virtual void applyForce (Force force);

   152

   153

    /**

   154

     * Changes player aim

   155

     */

   156

    void changeAim(float da);

   157

   158

    /**

   159

     * Set player facing.

   160

     */ 

   161

    void setFacing(bool right);

   162

   163

    /**

   164

     * Called on network clients to sync state from server

   165

     */

   166

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

   167

   168

    /**

   169

     * Handle ground movement

   170

     *

   171

     * @return new position

   172

     */

   173

    Vector walk (bool right);

   174

   175

    /**

   176

     * Handle ground-jumping

   177

     */

   178

    void jump (void);

   179

   180

    /**

   181

     * Handle ground-bounce

   182

     */

   183

    void bounce (Vector normal);

   184

   185

private:

   186

    void updatePosition (void);

   187

	bool possibleLocation (Vector loc);

   188

   189

    /**

   190

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

   191

     */

   192

    void integrate(Force force, TimeMS dt);

   193

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

   194

    Vector acceleration(const Force &force);

   195

   196

    virtual void onCollision() {}

   197

   198

public:

   199

    Vector getPosition (void);

   200

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

   201

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

   202

   203

    bool getFacing(void);

   204

    float getAim(void);

   205

   206

    void tick (void);

   207

};

   208

   209

struct Derivative {

   210

    Vector dx; // Velocity

   211

    Vector dv; // Acceleration

   212

};

   213

   214

   215

   216

#endif