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

enum ObjectType { PLAYER, PROJECTILE, ROPE };

    20

    21

enum FacingDirection {

    22

    FACING_LEFT,

    23

    FACING_RIGHT

    24

};

    25

    26

/**

    27

 * PhysicObject class. A basic PhysicsObject class.

    28

 */

    29

class PhysicsObject {

    30

public:

    31

    PhysicsWorld &world;

    32

    33

protected:

    34

    Vector position;

    35

    Vector previousPosition;

    36

    Vector velocity;

    37

    float mass;

    38

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

    39

    float collision_elasticity;

    40

    41

    // Attributes for players

    42

    float aim; // Aim direction (half circle)

    43

    FacingDirection facing; // Player facing

    44

    45

    bool alive;

    46

    bool shouldDelete;

    47

    48

    ObjectType type;

    49

    50

    PhysicsObject *pivot;

    51

    52

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

    53

            float collision_elasticity, bool enabled = true);

    54

    virtual ~PhysicsObject (void);

    55

    56

    57

    /**

    58

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

    59

     *

    60

     * @param force Force vector

    61

     */

    62

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

    63

    64

    /**

    65

     * Change player aim

    66

     *

    67

     * @param da Aim angle change

    68

     */

    69

    void changeAim(float da);

    70

    71

    /**

    72

     * Set player facing.

    73

     *

    74

     * @param facingRight True if player is facing right.

    75

     */

    76

    void setFacing (FacingDirection facing);

    77

    78

    /**

    79

     * Makes the player jump in the air.

    80

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

    81

     */

    82

    void jump (int direction);

    83

    84

    /** 

    85

     * Handle ground-bounce

    86

     *

    87

     * @param normal Normal vector relative to which to bounce

    88

     */

    89

    void bounce (Vector normal);

    90

    91

    /**

    92

     * Called on network clients to sync state from server

    93

     *

    94

     * @param position New position

    95

     * @param velocity New velocity

    96

     * @param inAir New inAir value

    97

     * @param facingRight New facingRight value

    98

     * @param aim New aim

    99

     */

   100

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

   101

   102

    /**

   103

     * Put object to the objects list so that its movement will be calculated.

   104

     */

   105

    void enable (void);

   106

   107

    /**

   108

     * Remove object from the objects list but don't delete the object itself.

   109

     */

   110

    void disable (void);

   111

   112

private:

   113

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

   114

    std::vector<Vector> shape;

   115

   116

    // Force queue that is emptied on every tick

   117

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

   118

   119

    /**

   120

     * Handle player movement and apply forces.

   121

     */

   122

    void updatePosition (TimeMS dt);

   123

   124

    // TODO: Should these be moved to PhysicsWorld?

   125

    /**

   126

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

   127

     *

   128

     * @param force Force to integrate

   129

     * @param dt Time intervall

   130

     */

   131

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

   132

   133

    /**

   134

     * Evaluate the value of the derivative at given time

   135

     *

   136

     * @param force Force

   137

     * @param dt Time

   138

     * @param d Previous derivative

   139

     */

   140

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

   141

   142

    /**

   143

     * Return object acceleration with given force.

   144

     *

   145

     * @param force Force

   146

     * @return Acceleration

   147

     */

   148

    Vector acceleration (const Force &force);

   149

   150

     /**

   151

     * Handle ground movement.

   152

     *

   153

     * @param right Boolean describing the movement direction.

   154

     * @return New position

   155

     */

   156

    void walk (TimeMS, bool right);

   157

    Vector walk_one_step (float, bool);

   158

   159

public:

   160

    /**

   161

     * Define object behaviour on collisions.

   162

     *

   163

     * XXX: make this pure-virtual

   164

     */

   165

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

   166

   167

    /**

   168

     * Return the type of the physics object (player, projectile...)

   169

     */

   170

    ObjectType getType (void) const;

   171

   172

    /**

   173

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

   174

     * location.

   175

     */

   176

    bool possibleLocation (Vector loc);

   177

   178

    /**

   179

     * Get current object position.

   180

     *

   181

     * @return Position vector

   182

     */

   183

    Vector getPosition (void) const;

   184

   185

    /**

   186

     * Set previous object position.

   187

     *

   188

     * @param Position vector

   189

     */

   190

    void setPosition (Vector pos);

   191

   192

    /**

   193

     * Get previous object position.

   194

     *

   195

     * @return Position vector

   196

     */

   197

    Vector getPreviousPosition (void) const;

   198

   199

    /**

   200

     * Get current object screen coordinates

   201

     *

   202

     * @return PixelCoordinate position

   203

     */

   204

    PixelCoordinate getCoordinate (void) const;

   205

   206

    /**

   207

     * Get current object velocity.

   208

     *

   209

     * @return Velocity vector

   210

     */

   211

    Vector getVelocity (void) const;

   212

   213

    /**

   214

     * Return object shape.

   215

     *

   216

     * @return Polygon points

   217

     */

   218

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

   219

   220

    /**

   221

     * Set object shape.

   222

     *

   223

     * @param shape Vector containing polygon poinst

   224

     */

   225

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

   226

   227

    /**

   228

     * Return object facing.

   229

     *

   230

     * @return Object facing (true if facing right)

   231

     */

   232

    FacingDirection getFacing() const;

   233

   234

    /**

   235

     * Return object aim angle.

   236

     *

   237

     * @return Object aim angle

   238

     */

   239

    float getAim() const;

   240

   241

    /**

   242

     * Returns facing+aim as a unit vector

   243

     */

   244

    Vector getDirection (void) const;

   245

   246

    /**

   247

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

   248

     */

   249

    void destroy (void);

   250

   251

    /*

   252

     * Had the object been destroyed?

   253

     */

   254

    bool isAlive (void);

   255

   256

    /**

   257

     * Delete ourselves if we've been destroyed and return true, else return false

   258

     */

   259

    bool removeIfDestroyed (void);

   260

   261

    /**

   262

     * Sets this object's pivot to the given value, which will then exert a force on this object

   263

     */

   264

    void setPivot (PhysicsObject *pivot);

   265

   266

    /**

   267

     * Checks if object collides with other objects

   268

     *

   269

     * @param obj Other PhysicsObject

   270

     */

   271

    bool collides (const PhysicsObject &obj);

   272

   273

    /**

   274

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

   275

     */

   276

    virtual float getPivotForce (PhysicsObject *bob);

   277

   278

    /**

   279

     * Update object in physics simulation.

   280

     */

   281

    virtual void tick (TimeMS tick_length);

   282

};

   283

   284

struct Derivative {

   285

    Vector dx; // Velocity

   286

    Vector dv; // Acceleration

   287

};

   288

   289

/**

   290

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

   291

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

   292

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

   293

 *

   294

 * @param p1 Line start point

   295

 * @param p2 Line end point

   296

 * @param p3 Point

   297

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

   298

 */

   299

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

   300

   301

#endif