1

#ifndef PHYSICS_OBJECT_HH

     2

#define PHYSICS_OBJECT_HH

     3

     4

     5

// Forward declares

     6

class PhysicsObject;

     7

struct Derivative;

     8

     9

#include "PhysicsWorld.hh"

    10

#include "Vector.hh"

    11

#include "Timer.hh"

    12

#include "Config.hh"

    13

    14

#include <utility>

    15

#include <queue>

    16

    17

// Type definitions

    18

typedef Vector Force;

    19

    20

/** Specifies possible object types. */

    21

enum ObjectType { PLAYER, PROJECTILE, ROPE };

    22

    23

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

    24

enum FacingDirection {

    25

    FACING_LEFT,

    26

    FACING_RIGHT

    27

};

    28

    29

/**

    30

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

    31

 */

    32

class PhysicsObject {

    33

protected:

    34

    /** Reference to PhysicsWorld. */

    35

    PhysicsWorld &world;

    36

    37

private:

    38

    /** Position */

    39

    Vector position;

    40

    41

    /** Position at previous tick */

    42

    Vector previousPosition;

    43

    44

    /** Velocity */

    45

    Vector velocity;

    46

    47

    /** Mass */

    48

    float mass; 

    49

    50

    /** Object's shape, polygon vertices */

    51

    std::vector<Vector> shape;

    52

    53

    /** Force queue, emptied on every physics tick */

    54

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

    55

    56

    57

protected:

    58

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

    59

    bool inAir;

    60

    61

    /** Object elasticity */

    62

    float collision_elasticity;

    63

    64

    /** Aim angle in radians */

    65

    float aim; 

    66

    67

    /** Player facing */

    68

    FacingDirection facing; 

    69

    70

    /** Specifies if the object should be simulated */

    71

    bool alive;

    72

    73

    /** True if !alive, and the object can be delete'd */

    74

    bool shouldDelete;

    75

    76

    /** Type of the object */

    77

    ObjectType type;

    78

    79

    /** Pivot object for this object */

    80

    PhysicsObject *pivot;

    81

    82

    /** 

    83

     * Class constructor

    84

     *

    85

     * @param world Reference to PhysicsWorld

    86

     * @param mass Object mass

    87

     * @param position Object position

    88

     * @param velocity Object velocity

    89

     * @param type Object type

    90

     * @param collision_elasticity Object elasticity

    91

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

    92

     */

    93

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

    94

            float collision_elasticity, bool enabled = true);

    95

    96

    /**

    97

     * Virtual destructor

    98

     */

    99

    virtual ~PhysicsObject (void);

   100

   101

    /**

   102

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

   103

     * on the next physics tick.

   104

     *

   105

     * @param force Force vector

   106

     */

   107

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

   108

   109

    /**

   110

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

   111

     * stays inside limits.

   112

     *

   113

     * @param da Aim angle change in radians

   114

     */

   115

    void changeAim (float da);

   116

   117

    /**

   118

     * Set player facing.

   119

     *

   120

     * @param facingRight True if player is facing right.

   121

     */

   122

    void setFacing (FacingDirection facing) {

   123

        this->facing = facing;

   124

    }

   125

   126

    /**

   127

     * Makes the player jump in the air.

   128

     *

   129

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

   130

     */

   131

    void jump (int direction);

   132

   133

    /** 

   134

     * Handle object bounce.

   135

     *

   136

     * @param normal Normal vector relative to which to bounce

   137

     */

   138

    void bounce (Vector normal);

   139

   140

    /**

   141

     * Called on network clients to sync state from server

   142

     *

   143

     * @param position New position

   144

     * @param velocity New velocity

   145

     * @param inAir New inAir value

   146

     * @param facingRight New facingRight value

   147

     * @param aim New aim

   148

     */

   149

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

   150

   151

    /**

   152

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

   153

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

   154

     */

   155

    void enable (void);

   156

   157

    /**

   158

     * Remove object from the objects physics simulation. When the

   159

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

   160

     * its movements will not be calculated.

   161

     */

   162

    void disable (void);

   163

   164

private:

   165

    /**

   166

     * Handle player movement and apply forces.

   167

     *

   168

     * @param dt Time intervall

   169

     */

   170

    void updatePosition (TimeMS dt);

   171

   172

    /**

   173

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

   174

     *

   175

     * @param force Force to integrate

   176

     * @param dt Time intervall

   177

     * @param posAfterTick Reference to object postition after integration.

   178

     * @param velAfterTick Reference to object velocity after integration.

   179

     */

   180

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

   181

   182

    /**

   183

     * Evaluate the value of the derivative at given time

   184

     *

   185

     * @param force Force

   186

     * @param dt Time

   187

     * @param d Previous derivative

   188

     * @return Derivative

   189

     */

   190

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

   191

   192

    /**

   193

     * Return object acceleration with given force.

   194

     *

   195

     * @param force Force

   196

     * @return Acceleration

   197

     */

   198

    Vector acceleration (const Force &force);

   199

   200

     /**

   201

     * Handle ground movement.

   202

     *

   203

     * @param right Boolean describing the movement direction.

   204

     * @return New position

   205

     */

   206

    void walk (TimeMS, bool right);

   207

   208

    /*

   209

     * Undocumented private method

   210

     */

   211

    Vector walk_one_step (float, bool);

   212

   213

public:

   214

    /**

   215

     * Define object behaviour on collisions.

   216

     *

   217

     * @param collisionPoint Point of collision.

   218

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

   219

     */

   220

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

   221

   222

    /**

   223

     * Get object type.

   224

     *

   225

     * @return Object type

   226

     */

   227

    ObjectType getType (void) const {

   228

        return type;

   229

    }

   230

   231

    /**

   232

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

   233

     * location.

   234

     *

   235

     * @param loc Location

   236

     */

   237

    bool possibleLocation (Vector loc);

   238

   239

    /**

   240

     * Get current object position.

   241

     *

   242

     * @return position vector

   243

     */

   244

    Vector getPosition (void) const {

   245

        return position;

   246

    }

   247

   248

    /**

   249

     * Get previous object position.

   250

     *

   251

     * @return position vector

   252

     */

   253

    Vector getPreviousPosition (void) const {

   254

        return previousPosition;

   255

    }

   256

   257

    /**

   258

     * Get current object screen coordinates

   259

     *

   260

     * @return PixelCoordinate position

   261

     */

   262

    PixelCoordinate getCoordinate (void) const;

   263

   264

    /**

   265

     * Get current object velocity.

   266

     *

   267

     * @return Velocity vector

   268

     */

   269

    Vector getVelocity (void) const {

   270

        return velocity;

   271

    }

   272

   273

    /**

   274

     * Return object facing.

   275

     *

   276

     * @return Object facing (true if facing right)

   277

     */

   278

    FacingDirection getFacing (void) const {

   279

        return facing;

   280

    }

   281

   282

    /**

   283

     * Return object aim angle.

   284

     *

   285

     * @return Object aim angle

   286

     */

   287

    float getAim (void) const {

   288

        return aim;

   289

    }

   290

   291

    /**

   292

     * Get object direction.

   293

     *

   294

     * @return Unit vector to facing+aim

   295

     */

   296

    Vector getDirection (void) const;

   297

   298

    /**

   299

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

   300

     */

   301

    void destroy (void);

   302

   303

    /**

   304

     * Check if the object is alive.

   305

     *

   306

     * @return Is the object alive?

   307

     */

   308

    bool isAlive (void) const {

   309

        return alive;

   310

    }

   311

   312

    /**

   313

     * Tells the state of the object.

   314

     *

   315

     * @return True if object has been destroyed.

   316

     */

   317

    bool removeIfDestroyed (void);

   318

   319

    /**

   320

     * Set object pivot.

   321

     *

   322

     * @param pivot Pivot object

   323

     */

   324

    void setPivot (PhysicsObject *pivot) {

   325

        this->pivot = pivot;

   326

    }

   327

   328

    /**

   329

     * Return the pivot object pointer.

   330

     */

   331

    PhysicsObject *getPivot (void) {

   332

        return pivot;

   333

    }

   334

   335

    /**

   336

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

   337

     *

   338

     * @param bob Othe object

   339

     * @return Force

   340

     */

   341

    virtual Vector getPivotForce (void);

   342

   343

    /**

   344

     * Checks if object collides with other objects

   345

     *

   346

     * @param obj Other PhysicsObject

   347

     * @return Did we collide?

   348

     */

   349

    bool collides (const PhysicsObject &obj);

   350

   351

    /**

   352

     * Update object in physics simulation.

   353

     *

   354

     * @param tick_length Length of the physics tick

   355

     */

   356

    virtual void tick (TimeMS tick_length);

   357

   358

protected:

   359

    /**

   360

     * Set object shape.

   361

     *

   362

     * XXX: constructor

   363

     *

   364

     * @param shape Vector containing polygon points

   365

     */

   366

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

   367

        this->shape = shape;

   368

    }

   369

   370

    /**

   371

     * Update object position, also updating our previous position

   372

     *

   373

     * @param pos new position

   374

     */

   375

    void setPosition (Vector pos);

   376

   377

    /**

   378

     * Update current object velocity.

   379

     *

   380

     * @param velocity new velocity

   381

     */

   382

    void setVelocity (Vector velocity) {

   383

        this->velocity = velocity;

   384

    }

   385

   386

    /**

   387

     * Reset state and disable, ready to be resume()'d again in a different place

   388

     */

   389

    void reset (void);

   390

   391

    /**

   392

     * Resume after a reset() at the given position with a zero velocity

   393

     */

   394

    void resume (Vector position);

   395

};

   396

   397

/** Helper struct for the integration */

   398

struct Derivative {

   399

    /**

   400

     * Velocity

   401

     */

   402

    Vector dx;

   403

   404

    /**

   405

     * Acceleration

   406

     */ 

   407

    Vector dv; 

   408

   409

    Derivative () : dx(), dv() { }

   410

    Derivative (Vector dx, Vector dv) : dx(dx), dv(dv) { }

   411

};

   412

   413

/**

   414

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

   415

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

   416

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

   417

 *

   418

 * @param p1 Line start point

   419

 * @param p2 Line end point

   420

 * @param p3 Point

   421

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

   422

 */

   423

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

   424

   425

#endif