1

#ifndef PHYSICS_HH

     2

#define PHYSICS_HH

     3

     4

#include <vector>

     5

#include <queue>

     6

#include <ClanLib/core.h>

     7

     8

#include "Vector.hh"

    10

    11

// Forward declares

    12

class PhysicsWorld;

    13

class PhysicsObject;

    14

class PlayerObject;

    15

class ProjectileObject;

    16

class Shape;

    17

struct Derivative;

    18

    19

// Type definitions

    20

typedef uint16_t TimeMS;

    21

typedef Vector Force;

    22

    23

// TODO: Random definitions. Should these be somewhere else?

    24

enum TerrainType {EMPTY, DIRT, ROCK};

    25

    26

// Yeah?!?!?! Atleast this could be documented. Contains vectors

    27

// presenting all the 8 directions in a square grid?

    28

const Vector DIRECTIONS[] = { Vector(0,-1), Vector(1,-1), Vector(1,0), 

    29

                              Vector(1,1), Vector(0,1), Vector(-1,1), 

    30

                              Vector(-1,0), Vector(-1,-1) };

    31

    32

    33

/**

    34

 * PhysicsWorld class. PhysicsWorld contains PhysicsObjects that are

    35

 * simulated in the PhysicsWorld.

    36

 */

    37

class PhysicsWorld {

    38

    friend class PhysicsObject;

    39

    40

private:

    41

    CL_Timer tick_timer;

    42

    uint32_t tick_counter;

    43

    44

protected:

    45

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

    46

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

    47

    std::vector<PhysicsObject*> objects;

    48

    49

    // Contains connections between signals and slots

    50

    CL_SlotContainer slots;

    51

    52

    PhysicsWorld(Vector gravity, Vector dimensions);

    53

    54

    // TODO: Should these be somewhere else?

    55

    Vector dimensions;

    56

    Vector gravity;

    57

    58

    // TODO: Should this be it's own class?

    59

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

    60

    61

public:

    62

    // TODO: Replace addObject with these?

    63

    //void addPlayerObject(PlayerObject *object);

    64

    //void addProjectileObject(ProjectileObject *object);

    65

    66

    /**

    67

     * Add object to the PhysicsWorld.

    68

     *

    69

     * @param object Pointer to the PhysicsObject to add.

    70

     */

    71

    void addObject(PhysicsObject *object);

    72

    73

    /**

    74

     * Advance one time step in physics simulation.

    75

     */

    76

    void tick();

    77

    78

    /**

    79

     * Get current tick in physics simulation.

    80

     *

    81

     * @return tick Current simulation tick.

    82

     */

    83

    uint32_t getTick();

    84

    85

    // ?!!?!?!?!?!?!

    86

    // TODO: If there were a terrain class, these could it's members.

    87

    /**

    88

     * Generate random terrain.

    89

     *

    90

     * @param seed Random generator seed.

    91

     */

    92

    void generateTerrain(int seed);

    93

    /**

    94

     * Remove ground from the terrain. Removes a circle.

    95

     *

    96

     * @param x Circle x-coordinate

    97

     * @param y Circle y-coordinate

    98

     * @param r Circle radius

    99

     */

   100

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

   101

    /**

   102

     * Remove ground from the terrain. Removes a circle.

   103

     *

   104

     * @param pos Circle location

   105

     * @param r Circle radius

   106

     */

   107

    void removeGround(Vector pos, float r);

   108

    /**

   109

     * Return normal for the wall that has been hit.

   110

     *

   111

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

   112

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

   113

     */

   114

    Vector getNormal(Vector hitPoint, Vector prevPoint);

   115

    /**

   116

     * Return terrain type in given position.

   117

     *

   118

     * @param x X-coordinate

   119

     * @param y Y-coordinate

   120

     */

   121

    TerrainType getType(int x, int y) const;

   122

    /**

   123

     * Return terrain type in given position.

   124

     *

   125

     * @param pos Coordinate vector

   126

     */

   127

    TerrainType getType(Vector pos) const;

   128

   129

};

   130

   131

/**

   132

 * PhysicObject class. A basic PhysicsObject class.

   133

 */

   134

class PhysicsObject {

   135

protected:

   136

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

   137

    PhysicsWorld &world;

   138

   139

    Vector position;

   140

    Vector velocity;

   141

    float mass;

   142

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

   143

   144

    // Attributes for players

   145

    float aim; // Aim direction (half circle)

   146

    bool facingRight; // Player facing

   147

   148

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

   149

                  Vector velocity);

   150

    ~PhysicsObject() {}

   151

   152

   153

    /**

   154

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

   155

     *

   156

     * @param force Force vector

   157

     */

   158

    void applyForce(Force force);

   159

   160

    /**

   161

     * Change player aim

   162

     *

   163

     * @param da Aim angle change

   164

     */

   165

    void changeAim(float da);

   166

   167

    /**

   168

     * Set player facing.

   169

     *

   170

     * @param facingRight True if player is facing right.

   171

     */

   172

    void setFacing(bool facingRight);

   173

   174

    /**

   175

     * Handle ground-jumping

   176

     */

   177

    void jump();

   178

   179

    /** 

   180

     * Handle ground-bounce

   181

     *

   182

     * @param normal Normal vector relative to which to bounce

   183

     */

   184

    void bounce(Vector normal);

   185

   186

    /**

   187

     * Called on network clients to sync state from server

   188

     *

   189

     * @param position New position

   190

     * @param velocity New velocity

   191

     * @param inAir New inAir value

   192

     */

   193

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

   194

   195

private:

   196

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

   197

    // here.  

   198

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

   199

    std::vector<Vector> shape;

   200

   201

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

   202

    // Force queue that is emptied on every tick

   203

    std::queue<Force> forceq;

   204

    // Helper variables for integration

   205

    Vector posAfterTick;

   206

    Vector velAfterTick;

   207

   208

    /**

   209

     * Handle player movement and apply forces.

   210

     */

   211

    void updatePosition();

   212

   213

    // TODO: Should these be moved to PhysicsWorld?

   214

    /**

   215

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

   216

     *

   217

     * @param force Force to integrate

   218

     * @param dt Time intervall

   219

     */

   220

    void integrate(Force force, TimeMS dt);

   221

   222

    /**

   223

     * Evaluate the value of the derivative at given time

   224

     *

   225

     * @param force Force

   226

     * @param dt Time

   227

     * @param d Previous derivative

   228

     */

   229

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

   230

   231

    /**

   232

     * Return object acceleration with given force.

   233

     *

   234

     * @param force Force

   235

     * @return Acceleration

   236

     */

   237

    Vector acceleration(const Force &force);

   238

   239

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

   240

    // also move there.

   241

    /**

   242

     * Handle ground movement.

   243

     *

   244

     * @param right Boolean describing the movement direction.

   245

     * @return New position

   246

     */

   247

    Vector walk(bool right);

   248

   249

    /*

   250

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

   251

     * be?

   252

     */

   253

    virtual void onCollision() {}

   254

   255

    /*

   256

     * TODO: This probably does some kind of collision

   257

     * detection. Could be named/documented better.

   258

     */

   259

    bool possibleLocation(Vector loc);

   260

   261

public:

   262

    /**

   263

     * Get current object position.

   264

     *

   265

     * @return Position vector

   266

     */

   267

    Vector getPosition();

   268

   269

    /**

   270

     * Return object shape.

   271

     *

   272

     * @return Polygon points

   273

     */

   274

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

   275

   276

    /**

   277

     * Set object shape.

   278

     *

   279

     * @param shape Vector containing polygon poinst

   280

     */

   281

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

   282

   283

    /**

   284

     * Return object facing.

   285

     *

   286

     * @return Object facing (true if facing right)

   287

     */

   288

    bool getFacing();

   289

   290

    /**

   291

     * Return object aim angle.

   292

     *

   293

     * @return Object aim angle

   294

     */

   295

    float getAim();

   296

   297

    /**

   298

     * Update object in physics simulation.

   299

     */

   300

    void tick();

   301

};

   302

   303

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

   304

// completely.

   305

struct Derivative {

   306

    Vector dx; // Velocity

   307

    Vector dv; // Acceleration

   308

};

   309

   310

   311

// TODO: These are drafts

   312

/**

   313

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

   314

 */

   315

//class PlayerObject : public PhysicsObject {

   316

   317

//};

   318

   319

/**

   320

 * ProjectileObject class. Represents different projectiles in the

   321

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

   322

 */

   323

//class ProjectileObject : public PhysicsObject {

   324

   325

//};

   326

   327

#endif