1

#ifndef PHYSICS_HH

     2

#define PHYSICS_HH

     3

     4

#include <vector>

     5

#include <queue>

     6

#include <ClanLib/core.h>

     7

#include <ClanLib/display.h>

     8

     9

#include "Vector.hh"

    10

#include "Config.hh"

    11

#include "Terrain.hh"

    12

    13

// Forward declares

    14

class PhysicsWorld;

    15

class PhysicsObject;

    16

class PlayerObject;

    17

class ProjectileObject;

    18

class Shape;

    19

struct Derivative;

    20

    21

// Type definitions

    22

typedef uint16_t TimeMS;

    23

typedef Vector Force;

    24

    25

/**

    26

 * PhysicsWorld class. PhysicsWorld contains PhysicsObjects that are

    27

 * simulated in the PhysicsWorld.

    28

 */

    29

class PhysicsWorld : public Terrain {

    30

    friend class PhysicsObject;

    31

    32

private:

    33

    CL_Timer tick_timer;

    34

    uint32_t tick_counter;

    35

    36

    //    Terrain terrain;

    37

    38

protected:

    39

    //std::vector<PlayerObject*> players;

    40

    //std::vector<ProjectileObject*> projectiles;

    41

    std::vector<PhysicsObject*> objects;

    42

    43

    // Contains connections between signals and slots

    44

    CL_SlotContainer slots;

    45

    46

    PhysicsWorld(Vector gravity, Vector dimensions);

    47

    48

    // TODO: Should these be somewhere else?

    49

    Vector dimensions;

    50

    Vector gravity;

    51

    52

    53

    54

public:

    55

    // TODO: Replace addObject with these?

    56

    //void addPlayerObject(PlayerObject *object);

    57

    //void addProjectileObject(ProjectileObject *object);

    58

    59

    /**

    60

     * Add object to the PhysicsWorld.

    61

     *

    62

     * @param object Pointer to the PhysicsObject to add.

    63

     */

    64

    void addObject(PhysicsObject *object);

    65

    66

    /**

    67

     * Advance one time step in physics simulation.

    68

     */

    69

    void tick();

    70

    71

    /**

    72

     * Get current tick in physics simulation.

    73

     *

    74

     * @return tick Current simulation tick.

    75

     */

    76

    uint32_t getTick();

    77

    78

};

    79

    80

/**

    81

 * PhysicObject class. A basic PhysicsObject class.

    82

 */

    83

class PhysicsObject {

    84

protected:

    85

    // This probably shouldn't be done this way.

    86

    PhysicsWorld &world;

    87

    88

    Vector position;

    89

    Vector velocity;

    90

    float mass;

    91

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

    92

    93

    // Attributes for players

    94

    float aim; // Aim direction (half circle)

    95

    bool facingRight; // Player facing

    96

    97

    PhysicsObject(PhysicsWorld &world, float mass, Vector position, 

    98

                  Vector velocity);

    99

    ~PhysicsObject() {}

   100

   101

   102

    /**

   103

     * Add force to the force queue to be applied on next tick.

   104

     *

   105

     * @param force Force vector

   106

     */

   107

    void applyForce(Force force);

   108

   109

    /**

   110

     * Change player aim

   111

     *

   112

     * @param da Aim angle change

   113

     */

   114

    void changeAim(float da);

   115

   116

    /**

   117

     * Set player facing.

   118

     *

   119

     * @param facingRight True if player is facing right.

   120

     */

   121

    void setFacing(bool facingRight);

   122

   123

    /**

   126

     */

   128

   129

    /** 

   130

     * Handle ground-bounce

   131

     *

   132

     * @param normal Normal vector relative to which to bounce

   133

     */

   134

    void bounce(Vector normal);

   135

   136

    /**

   137

     * Called on network clients to sync state from server

   138

     *

   139

     * @param position New position

   140

     * @param velocity New velocity

   141

     * @param inAir New inAir value

   142

     */

   143

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

   144

   145

private:

   146

    // TODO: I'd be tempted to use some already made ClanLib structure

   147

    // here.  

   148

    // Shape of the object. Edge points of the shape polygon.

   149

    std::vector<Vector> shape;

   150

   151

    // TODO: Should these operations be moved to PhysicsWorld?

   152

    // Force queue that is emptied on every tick

   153

    std::queue<Force> forceq;

   154

   155

    /**

   156

     * Handle player movement and apply forces.

   157

     */

   158

    void updatePosition();

   159

   160

    // TODO: Should these be moved to PhysicsWorld?

   161

    /**

   162

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

   163

     *

   164

     * @param force Force to integrate

   165

     * @param dt Time intervall

   166

     */

   167

    void integrate(Force force, TimeMS dt, Vector &posAfterTick, Vector &velAfterTick);

   168

   169

    /**

   170

     * Evaluate the value of the derivative at given time

   171

     *

   172

     * @param force Force

   173

     * @param dt Time

   174

     * @param d Previous derivative

   175

     */

   176

    Derivative evaluate(Force force, TimeMS dt, Derivative &d, const Vector &posAfterTick, const Vector &velAfterTick);

   177

   178

    /**

   179

     * Return object acceleration with given force.

   180

     *

   181

     * @param force Force

   182

     * @return Acceleration

   183

     */

   184

    Vector acceleration(const Force &force);

   185

   186

    // TODO: If integration is moved to PhysicsWorld then this should

   187

    // also move there.

   188

    /**

   189

     * Handle ground movement.

   190

     *

   191

     * @param right Boolean describing the movement direction.

   192

     * @return New position

   193

     */

   194

    Vector walk(bool right);

   195

   196

    /*

   197

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

   198

     * be?

   199

     */

   200

    virtual void onCollision() {}

   201

   202

    /*

   203

     * TODO: This probably does some kind of collision

   204

     * detection. Could be named/documented better.

   205

     */

   206

    bool possibleLocation(Vector loc);

   207

   208

public:

   209

    /**

   210

     * Get current object position.

   211

     *

   212

     * @return Position vector

   213

     */

   214

    Vector getPosition();

   215

   216

    /**

   217

     * Return object shape.

   218

     *

   219

     * @return Polygon points

   220

     */

   221

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

   222

   223

    /**

   224

     * Set object shape.

   225

     *

   226

     * @param shape Vector containing polygon poinst

   227

     */

   228

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

   229

   230

    /**

   231

     * Return object facing.

   232

     *

   233

     * @return Object facing (true if facing right)

   234

     */

   235

    bool getFacing();

   236

   237

    /**

   238

     * Return object aim angle.

   239

     *

   240

     * @return Object aim angle

   241

     */

   242

    float getAim();

   243

   244

    /**

   245

     * Update object in physics simulation.

   246

     */

   247

    void tick();

   248

   249

    /**

   250

     * Draw object

   251

     *

   252

     * @param gc CL_GraphicContext

   253

     */

   254

    void draw(CL_GraphicContext *gc);

   255

};

   256

   257

// TODO: This could probably be moved somewhere else or removed

   258

// completely.

   259

struct Derivative {

   260

    Vector dx; // Velocity

   261

    Vector dv; // Acceleration

   262

};

   263

   264

   265

// TODO: These are drafts

   266

/**

   267

 * PlayerObject class. Represents a player in the physics engine.

   268

 */

   269

//class PlayerObject : public PhysicsObject {

   270

   271

//};

   272

   273

/**

   274

 * ProjectileObject class. Represents different projectiles in the

   275

 * physics (i.e. not players) in the physics engine.

   276

 */

   277

//class ProjectileObject : public PhysicsObject {

   278

   279

//};

   280

   281

#endif