1

#ifndef PHYSICS_OBJECT_HH

     2

#define PHYSICS_OBJECT_HH

     3

     4

#include <ClanLib/display.h>

     5

#include <utility>

     6

     7

// Forward declares

     8

class PhysicsObject;

     9

struct Derivative;

    10

    11

#include "PhysicsWorld.hh"

    12

#include "Vector.hh"

    13

#include "Timer.hh"

    14

#include "Config.hh"

    15

    16

// Type definitions

    17

typedef Vector Force;

    18

    19

/** Specifies possible object types. */

    20

enum ObjectType { PLAYER, PROJECTILE, ROPE };

    21

    22

/** Specifies possible facing directions for objects. */

    23

enum FacingDirection {

    24

    FACING_LEFT,

    25

    FACING_RIGHT

    26

};

    27

    28

/**

    29

 * PhysicsObject class. Represents an object in the physics simulation.

    30

 */

    31

class PhysicsObject {

    32

public:

    33

    /** Reference to PhysicsWorld. */

    34

    PhysicsWorld &world;

    35

    36

protected:

    37

    /** Object position. */

    38

    Vector position;

    39

    /** Object position on previous physics tick. */

    40

    Vector previousPosition;

    41

    /** Object velocity */

    42

    Vector velocity;

    43

    /** Object mass. */

    44

    float mass;

    45

    /** Tells if the object is "on the ground" */

    46

    bool inAir;

    47

    /** Object elasticity. */

    48

    float collision_elasticity;

    49

    50

    // Attributes for players

    51

    /** Aim angle in radians. */

    52

    float aim; 

    53

    /** Player facing. */

    54

    FacingDirection facing; 

    55

    56

    /** Specifies if the player is alive (or dead). */

    57

    bool alive;

    58

    /** True if player object should be removed from the game. */

    59

    bool shouldDelete;

    60

    61

    /** Type of the object */

    62

    ObjectType type;

    63

    64

    /** Pivot object for this object. */

    65

    PhysicsObject *pivot;

    66

    67

    /** 

    68

     * Class constructor

    69

     *

    70

     * @param world Reference to PhysicsWorld

    71

     * @param mass Object mass

    72

     * @param position Object position

    73

     * @param velocity Object velocity

    74

     * @param type Object type

    75

     * @param collision_elasticity Object elasticity

    76

     * @param enabled Is the object currently part of the simulation

    77

     */

    78

    PhysicsObject (PhysicsWorld &world, float mass, Vector position, Vector velocity, ObjectType type, 

    79

            float collision_elasticity, bool enabled = true);

    80

    virtual ~PhysicsObject (void);

    81

    82

    83

    /**

    84

     * Apply a force to the object. The force is applied to the object

    85

     * on the next physics tick.

    86

     *

    87

     * @param force Force vector

    88

     */

    89

    void applyForce(Force force, TimeMS dt = PHYSICS_TICK_MS);

    90

    91

    /**

    92

     * Change player aim. This function takes care that aim angle

    93

     * stays inside limits.

    94

     *

    95

     * @param da Aim angle change in radians

    96

     */

    97

    void changeAim(float da);

    98

    99

    /**

   100

     * Set player facing.

   101

     *

   102

     * @param facingRight True if player is facing right.

   103

     */

   104

    void setFacing (FacingDirection facing);

   105

   106

    /**

   107

     * Makes the player jump in the air.

   108

     *

   109

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

   110

     */

   111

    void jump (int direction);

   112

   113

    /** 

   114

     * Handle object bounce.

   115

     *

   116

     * @param normal Normal vector relative to which to bounce

   117

     */

   118

    void bounce (Vector normal);

   119

   120

    /**

   121

     * Called on network clients to sync state from server

   122

     *

   123

     * @param position New position

   124

     * @param velocity New velocity

   125

     * @param inAir New inAir value

   126

     * @param facingRight New facingRight value

   127

     * @param aim New aim

   128

     */

   129

    virtual void updatePhysics (Vector position, Vector velocity, bool inAir, FacingDirection facing, float aim);

   130

   131

    /**

   132

     * Put the object in the physics simulation. When the object is in

   133

     * the physics simulation it's movements will be calculated.

   134

     */

   135

    void enable (void);

   136

   137

    /**

   138

     * Remove object from the objects physics simulation. When the

   139

     * object isn't in the physics simulation it won't be deleted but

   140

     * its movements will not be calculated.

   141

     */

   142

    void disable (void);

   143

   144

private:

   145

    /** Objects shape. Edgepoints of the polygon */

   146

    std::vector<Vector> shape;

   147

   148

    /** Object force queue. The queue is emptied on every physics

   149

        tick.*/

   150

    std::queue<std::pair<Force, TimeMS> > forceq;

   151

   152

    /**

   153

     * Handle player movement and apply forces.

   154

     *

   155

     * @param dt Time intervall

   156

     */

   157

    void updatePosition (TimeMS dt);

   158

   159

    /**

   160

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

   161

     *

   162

     * @param force Force to integrate

   163

     * @param dt Time intervall

   164

     * @param posAfterTick Reference to object postition after integration.

   165

     * @param velAfterTick Reference to object velocity after integration.

   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

     * @return Derivative

   176

     */

   177

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

   178

   179

    /**

   180

     * Return object acceleration with given force.

   181

     *

   182

     * @param force Force

   183

     * @return Acceleration

   184

     */

   185

    Vector acceleration (const Force &force);

   186

   187

     /**

   188

     * Handle ground movement.

   189

     *

   190

     * @param right Boolean describing the movement direction.

   191

     * @return New position

   192

     */

   193

    void walk (TimeMS, bool right);

   194

    Vector walk_one_step (float, bool);

   195

   196

public:

   197

    /**

   198

     * Define object behaviour on collisions.

   199

     *

   200

     * @param collisionPoint Point of collision.

   201

     * @param other The other object we have collided with.

   202

     */

   203

    virtual void onCollision (Vector collisionPoint, PhysicsObject *other = NULL);

   204

   205

    /**

   206

     * Get object type.

   207

     *

   208

     * @return Object type

   209

     */

   210

    ObjectType getType (void) const;

   211

   212

    /**

   213

     * Checks if it is possible for the object to be in the given

   214

     * location.

   215

     *

   216

     * @param loc Location

   217

     */

   218

    bool possibleLocation (Vector loc);

   219

   220

    /**

   221

     * Get current object position.

   222

     *

   223

     * @return Position vector

   224

     */

   225

    Vector getPosition (void) const;

   226

   227

    /**

   228

     * Set previous object position.

   229

     *

   230

     * @param Position vector

   231

     */

   232

    void setPosition (Vector pos);

   233

   234

    /**

   235

     * Get previous object position.

   236

     *

   237

     * @return Position vector

   238

     */

   239

    Vector getPreviousPosition (void) const;

   240

   241

    /**

   242

     * Get current object screen coordinates

   243

     *

   244

     * @return PixelCoordinate position

   245

     */

   246

    PixelCoordinate getCoordinate (void) const;

   247

   248

    /**

   249

     * Get current object velocity.

   250

     *

   251

     * @return Velocity vector

   252

     */

   253

    Vector getVelocity (void) const;

   254

   255

    /**

   256

     * Return object shape.

   257

     *

   258

     * @return Polygon points

   259

     */

   260

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

   261

   262

    /**

   263

     * Set object shape.

   264

     *

   265

     * @param shape Vector containing polygon points

   266

     */

   267

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

   268

   269

    /**

   270

     * Return object facing.

   271

     *

   272

     * @return Object facing (true if facing right)

   273

     */

   274

    FacingDirection getFacing() const;

   275

   276

    /**

   277

     * Return object aim angle.

   278

     *

   279

     * @return Object aim angle

   280

     */

   281

    float getAim() const;

   282

   283

    /**

   284

     * Get object direction.

   285

     *

   286

     * @return Unit vector to facing+aim

   287

     */

   288

    Vector getDirection (void) const;

   289

   290

    /**

   291

     *  Mark object as destroyed, it will be delete'd later

   292

     */

   293

    void destroy (void);

   294

   295

    /**

   296

     * Check if the object is alive.

   297

     *

   298

     * @return Is the object alive?

   299

     */

   300

    bool isAlive (void);

   301

   302

    /**

   303

     * Tells the state of the object.

   304

     *

   305

     * @return True if object has been destroyed.

   306

     */

   307

    bool removeIfDestroyed (void);

   308

   309

    /**

   310

     * Set object pivot.

   311

     *

   312

     * @param pivot Pivot object

   313

     */

   314

    void setPivot (PhysicsObject *pivot);

   315

   316

    /**

   317

     * Return the pivot object pointer.

   318

     */

   319

    PhysicsObject *getPivot (void);

   320

   321

    /**

   322

     * Checks if object collides with other objects

   323

     *

   324

     * @param obj Other PhysicsObject

   325

     * @return Did we collide?

   326

     */

   327

    bool collides (const PhysicsObject &obj);

   328

   329

    /**

   330

     * Compute the force that this object (as a pivot) exerts on the given object

   331

     *

   332

     * @param bob Othe object

   333

     * @return Force

   334

     */

   335

    virtual Vector getPivotForce (void);

   336

   337

    /**

   338

     * Update object in physics simulation.

   339

     *

   340

     * @param tick_length Length of the physics tick

   341

     */

   342

    virtual void tick (TimeMS tick_length);

   343

};

   344

   345

/** Helper struct for the integration */

   346

struct Derivative {

   347

    Vector dx; // Velocity

   348

    Vector dv; // Acceleration

   349

};

   350

   351

/**

   352

 * Returns the "sign" of the cross product between given points. In

   353

 * practice the sign of the return value tels on which side of the

   354

 * line drawn between p1 and p2 the point p3 is.

   355

 *

   356

 * @param p1 Line start point

   357

 * @param p2 Line end point

   358

 * @param p3 Point

   359

 * @return Variable, the sign of which tells on which side of the line p3 is.

   360

 */

   361

int8_t crossProduct(const Vector &p1, const Vector &p2, const Vector &p3);

   362

   363

#endif