1

#ifndef PHYSICS_HH

     2

#define PHYSICS_HH

     3

     4

#include <vector>

     5

#include <queue>

     6

#include <list>

     7

#include <ClanLib/core.h>

     8

#include <ClanLib/display.h>

     9

    10

#include "Vector.hh"

    11

#include "Config.hh"

    12

#include "Terrain.hh"

    13

    14

// Forward declares

    15

class PhysicsWorld;

    16

class PhysicsObject;

    17

class PlayerObject;

    18

class ProjectileObject;

    19

class Shape;

    20

struct Derivative;

    21

    22

// Type definitions

    23

typedef uint16_t TimeMS;

    24

typedef Vector Force;

    25

    26

/**

    27

 * PhysicsWorld class. PhysicsWorld contains PhysicsObjects that are

    28

 * simulated in the PhysicsWorld.

    29

 */

    30

class PhysicsWorld : public Terrain {

    31

    friend class PhysicsObject;

    32

    33

private:

    34

    CL_Timer tick_timer;

    35

    uint32_t tick_counter;

    36

    37

    //    Terrain terrain;

    38

    39

protected:

    40

    std::list<PhysicsObject*> players;

    41

    std::list<PhysicsObject*> projectiles;

    42

//    std::vector<PhysicsObject*> objects;

    43

    44

    // Contains connections between signals and slots

    45

    CL_SlotContainer slots;

    46

    47

    PhysicsWorld(Vector gravity, Vector dimensions);

    48

    49

    // TODO: Should these be somewhere else?

    50

    Vector dimensions;

    51

    Vector gravity;

    52

    53

    54

    55

public:

    56

    // TODO: Replace addObject with these?

    57

    //void addPlayerObject(PlayerObject *object);

    58

    //void addProjectileObject(ProjectileObject *object);

    59

    60

    /**

    61

     * Add object to the PhysicsWorld.

    62

     *

    63

     * @param object Pointer to the PhysicsObject to add.

    64

     */

    65

    void addPlayerObject(PhysicsObject *object);

    66

    67

    void addProjectile(PhysicsObject *projectile);

    68

    69

    /**

    70

     * Advance one time step in physics simulation.

    71

     */

    72

    void tick();

    73

    74

    /**

    75

     * Get current tick in physics simulation.

    76

     *

    77

     * @return tick Current simulation tick.

    78

     */

    79

    uint32_t getTick();

    80

    81

    virtual void draw(CL_GraphicContext *gc);

    82

    83

    // TODO This should probably be protected or in GameStat or in GameStatee

    84

};

    85

    86

/**

    87

 * PhysicObject class. A basic PhysicsObject class.

    88

 */

    89

class PhysicsObject {

    90

protected:

    91

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

    92

    PhysicsWorld &world;

    93

    94

    Vector position;

    95

    Vector velocity;

    96

    float mass;

    97

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

    98

    float collision_elasticity;

    99

   100

    // Attributes for players

   101

    float aim; // Aim direction (half circle)

   102

    bool facingRight; // Player facing

   103

   104

    //

   105

    int reloadTimer;

   106

   107

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

   108

                  Vector velocity);

   109

    ~PhysicsObject() {}

   110

   111

   112

    /**

   113

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

   114

     *

   115

     * @param force Force vector

   116

     */

   117

    void applyForce(Force force);

   118

   119

    /**

   120

     * Change player aim

   121

     *

   122

     * @param da Aim angle change

   123

     */

   124

    void changeAim(float da);

   125

   126

    /**

   127

     * Set player facing.

   128

     *

   129

     * @param facingRight True if player is facing right.

   130

     */

   131

    void setFacing(bool facingRight);

   132

   133

    /**

   134

     * Makes the player jump in the air.

   135

     * @param direction -1: jump left, 0: jump up, 1: jump right

   136

     */

   137

    void jump(int direction);

   138

   139

    /** 

   140

     * Handle ground-bounce

   141

     *

   142

     * @param normal Normal vector relative to which to bounce

   143

     */

   144

    void bounce(Vector normal);

   145

   146

    /**

   147

     * Called on network clients to sync state from server

   148

     *

   149

     * @param position New position

   150

     * @param velocity New velocity

   151

     * @param inAir New inAir value

   152

     */

   153

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

   154

   155

private:

   156

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

   157

    // here.  

   158

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

   159

    std::vector<Vector> shape;

   160

   161

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

   162

    // Force queue that is emptied on every tick

   163

    std::queue<Force> forceq;

   164

   165

    /**

   166

     * Handle player movement and apply forces.

   167

     */

   168

    void updatePosition();

   169

   170

    // TODO: Should these be moved to PhysicsWorld?

   171

    /**

   172

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

   173

     *

   174

     * @param force Force to integrate

   175

     * @param dt Time intervall

   176

     */

   177

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

   178

   179

    /**

   180

     * Evaluate the value of the derivative at given time

   181

     *

   182

     * @param force Force

   183

     * @param dt Time

   184

     * @param d Previous derivative

   185

     */

   186

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

   187

   188

    /**

   189

     * Return object acceleration with given force.

   190

     *

   191

     * @param force Force

   192

     * @return Acceleration

   193

     */

   194

    Vector acceleration(const Force &force);

   195

   196

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

   197

    // also move there.

   198

    /**

   199

     * Handle ground movement.

   200

     *

   201

     * @param right Boolean describing the movement direction.

   202

     * @return New position

   203

     */

   204

    Vector walk(TimeMS, bool right);

   205

   206

    /*

   207

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

   208

     * be?

   209

     */

   210

    virtual void onCollision() {}

   211

   212

    /*

   213

     * TODO: This probably does some kind of collision

   214

     * detection. Could be named/documented better.

   215

     */

   216

    bool possibleLocation(Vector loc);

   217

   218

public:

   219

    /**

   220

     * Get current object position.

   221

     *

   222

     * @return Position vector

   223

     */

   224

    Vector getPosition();

   225

   226

    /**

   227

     * Return object shape.

   228

     *

   229

     * @return Polygon points

   230

     */

   231

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

   232

   233

    /**

   234

     * Set object shape.

   235

     *

   236

     * @param shape Vector containing polygon poinst

   237

     */

   238

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

   239

   240

    /**

   241

     * Return object facing.

   242

     *

   243

     * @return Object facing (true if facing right)

   244

     */

   245

    bool getFacing();

   246

   247

    /**

   248

     * Return object aim angle.

   249

     *

   250

     * @return Object aim angle

   251

     */

   252

    float getAim();

   253

   254

    /**

   255

     * Update object in physics simulation.

   256

     */

   257

    void tick();

   258

   259

    /**

   260

     * @return whether this PhysicsObject can shoot or not

   261

     * This is in PhysicsObject for larpa-like shots

   262

     */

   263

    bool canShoot();

   264

   265

    /**

   266

     * Draw object

   267

     *

   268

     * @param gc CL_GraphicContext

   269

     */

   270

    virtual void draw(CL_GraphicContext *gc);

   271

};

   272

   273

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

   274

// completely.

   275

struct Derivative {

   276

    Vector dx; // Velocity

   277

    Vector dv; // Acceleration

   278

};

   279

   280

   281

// TODO: These are drafts

   282

/**

   283

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

   284

 */

   285

//class PlayerObject : public PhysicsObject {

   286

   287

//};

   288

   289

/**

   290

 * ProjectileObject class. Represents different projectiles in the

   291

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

   292

 */

   293

//class ProjectileObject : public PhysicsObject {

   294

   295

//};

   296

   297

#endif