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

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

    71

     *

    72

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

    73

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

    74

     */

    75

    Vector getNormal(Vector hitPoint, Vector prevPoint);

    76

    77

    /**

    78

     * Return terrain type in specific position.

    79

     *

    80

     * @param x x-coordinate

    81

     * @param y y-coordinate

    82

     */

    83

    TerrainType getType(int x, int y) const;

    84

    /**

    85

     * Return terrain type in specific position.

    86

     *

    87

     * @param pos Position vector

    88

     */

    89

    TerrainType getType(Vector pos) const;

    90

    91

    /**

    92

     * Remove ground from the terrain. Removes a circle with given

    93

     * radius.

    94

     *

    95

     * @param x center x coordinate

    96

     * @param y center y coordinate

    97

     * @param r circle radius

    98

     */

    99

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

   100

   101

    /**

   102

     * Remove ground from the terrain. Removes a circle with given

   103

     * radius.

   104

     *

   105

     * @param pos circle center

   106

     * @param r circle radius

   107

     */

   108

    void removeGround(Vector pos, float r);

   109

};

   110

   111

class PhysicsObject {

   112

protected:

   113

    PhysicsWorld &world;

   114

   115

    float mass;

   116

    Vector position;

   117

    Vector velocity;

   118

    float aim; // Aim direction (half circle)

   119

    bool facingRight; // Player facing

   120

    bool inAir; // Is the object "on the ground"

   121

   122

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

   123

    ~PhysicsObject() {}   

   124

   125

    /**

   126

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

   127

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

   128

     * function is only used to handle in air movement.

   129

     *

   130

     * @param force Force vector.  

   131

     */

   132

    void applyForce (Force force);

   133

   134

    /**

   135

     * Changes player aim

   136

     *

   137

     * @param da Aim angle change

   138

     */

   139

    void changeAim(float da);

   140

   141

    /**

   142

     * Set player facing.

   143

     *

   144

     * @param facingRight True if player is facing right.

   145

     */ 

   146

    void setFacing(bool facingRight);

   147

   148

    /**

   149

     * Called on network clients to sync state from server

   150

     */

   151

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

   152

   153

    /**

   154

     * Handle ground-jumping

   155

     */

   156

    void jump (void);

   157

   158

    /**

   159

     * Handle ground-bounce

   160

     *

   161

     * @param normal Normal vector relative to which to bounce

   162

     */

   163

    void bounce (Vector normal);

   164

   165

private:

   166

    /**

   167

     * Handle player movement and applying forces.

   168

     */

   169

    void updatePosition (void);

   170

   171

    /*

   172

     * TODO: Documentation

   173

     */

   174

    bool possibleLocation (Vector loc);

   175

   176

    /**

   177

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

   178

     *

   179

     * @param force Force to integrate

   180

     * @param dt Time intervall

   181

     */

   182

    void integrate(Force force, TimeMS dt);

   183

   184

    /**

   185

     * Evaluate the value of the derivative at given time

   186

     *

   187

     * @param force Force

   188

     * @param dt Time

   189

     * @param d Last derivative

   190

     */

   191

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

   192

   193

    /**

   194

     * Return object acceleration with given force.

   195

     *

   196

     * @param force Force

   197

     * @return acceleration

   198

     */

   199

    Vector acceleration(const Force &force);

   200

   209

    /*

   210

     * Handle collision. TODO: This is not used. It probably should be?

   211

     */

   212

    virtual void onCollision() {}

   213

   214

    // Shape of the object. The vector contains the polygon edge

   215

    // points relative to the object location.

   216

    std::vector<Vector> shape;

   217

   218

    // Force queue that is emptied on every tick

   219

    std::queue<Force> forceq;

   220

    // Helper variables for integration (TODO: should these be

   221

    // somewhere else?)

   222

    Vector posAfterTick;

   223

    Vector velAfterTick;

   224

   225

public:

   226

    /**

   227

     * Get current object position.

   228

   229

     * @return position vector

   230

     */

   231

    Vector getPosition (void);

   232

   233

    /**

   234

     * Return object shape.

   235

     *

   236

     * @return Polygon points

   237

     */

   238

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

   239

   240

    /**

   241

     * Set object shape.

   242

     *

   243

     * @param shape Vector containing polygon points

   244

     */

   245

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

   246

   247

    /**

   248

     * Return object facing.

   249

     *

   250

     * @return Object facing (true if facing is right)

   251

     */

   252

    bool getFacing(void);

   253

   254

    /**

   255

     * Return object aim angle.

   256

     *

   257

     * @return Object aim angle

   258

     */

   259

    float getAim(void);

   260

   261

    /**

   262

     * Update object in physics simulation.

   263

     */

   264

    void tick (void);

   265

};

   266

   267

struct Derivative {

   268

    Vector dx; // Velocity

   269

    Vector dv; // Acceleration

   270

};

   271

   272

   273

   274

#endif