1

#ifndef PHYSICS_OBJECT_HH

     2

#define PHYSICS_OBJECT_HH

     3

     4

#include <ClanLib/display.h>

     5

     6

// Forward declares

     7

class PhysicsObject;

     8

struct Derivative;

     9

    10

#include "PhysicsWorld.hh"

    11

#include "Vector.hh"

    12

#include "Timer.hh"

    13

#include "Config.hh"

    14

    15

// Type definitions

    16

typedef Vector Force;

    19

    20

enum FacingDirection {

    21

    FACING_LEFT,

    22

    FACING_RIGHT

    23

};

    24

    25

/**

    26

 * PhysicObject class. A basic PhysicsObject class.

    27

 */

    28

class PhysicsObject {

    29

protected:

    30

    Vector position;

    31

    Vector velocity;

    32

    float mass;

    33

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

    34

    float collision_elasticity;

    35

    36

    // Attributes for players

    37

    float aim; // Aim direction (half circle)

    38

    FacingDirection facing; // Player facing

    39

    40

    bool alive;

    41

    bool shouldDelete;

    44

    45

    PhysicsObject *pivot;

    46

    47

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

    49

    virtual ~PhysicsObject (void);

    50

    51

    52

    /**

    53

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

    54

     *

    55

     * @param force Force vector

    56

     */

    57

    void applyForce(Force force);

    58

    59

    /**

    60

     * Change player aim

    61

     *

    62

     * @param da Aim angle change

    63

     */

    64

    void changeAim(float da);

    65

    66

    /**

    67

     * Set player facing.

    68

     *

    69

     * @param facingRight True if player is facing right.

    70

     */

    71

    void setFacing (FacingDirection facing);

    72

    73

    /**

    74

     * Makes the player jump in the air.

    75

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

    76

     */

    77

    void jump(int direction);

    78

    79

    /** 

    80

     * Handle ground-bounce

    81

     *

    82

     * @param normal Normal vector relative to which to bounce

    83

     */

    84

    void bounce(Vector normal);

    85

    86

    /**

    87

     * Called on network clients to sync state from server

    88

     *

    89

     * @param position New position

    90

     * @param velocity New velocity

    91

     * @param inAir New inAir value

    92

     * @param facingRight New facingRight value

    93

     * @param aim New aim

    94

     */

    95

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

    96

    97

    /**

    98

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

    99

     */

   100

    void enable (void);

   101

   102

    /**

   103

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

   104

     */

   105

    void disable (void);

   106

   107

private:

   108

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

   109

    std::vector<Vector> shape;

   110

   111

    // Force queue that is emptied on every tick

   112

    std::queue<Force> forceq;

   113

   114

    /**

   115

     * Handle player movement and apply forces.

   116

     */

   117

    void updatePosition(TimeMS dt);

   118

   119

    // TODO: Should these be moved to PhysicsWorld?

   120

    /**

   121

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

   122

     *

   123

     * @param force Force to integrate

   124

     * @param dt Time intervall

   125

     */

   126

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

   127

   128

    /**

   129

     * Evaluate the value of the derivative at given time

   130

     *

   131

     * @param force Force

   132

     * @param dt Time

   133

     * @param d Previous derivative

   134

     */

   135

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

   136

   137

    /**

   138

     * Return object acceleration with given force.

   139

     *

   140

     * @param force Force

   141

     * @return Acceleration

   142

     */

   143

    Vector acceleration(const Force &force);

   144

   145

     /**

   146

     * Handle ground movement.

   147

     *

   148

     * @param right Boolean describing the movement direction.

   149

     * @return New position

   150

     */

   151

    void walk(TimeMS, bool right);

   152

    Vector walk_one_step(float, bool);

   153

   154

    /**

   155

     * Define object behaviour on collisions.

   156

     */

   157

    virtual void onCollision (Vector collisionPoint) {}

   158

   159

    /**

   160

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

   161

     * location.

   162

     */

   163

    bool possibleLocation(Vector loc);

   164

   165

public:

   166

    PhysicsWorld &world;

   167

   168

    /**

   169

     * Get current object position.

   170

     *

   171

     * @return Position vector

   172

     */

   173

    Vector getPosition (void) const;

   174

   175

    /**

   176

     * Get current object screen coordinates

   177

     *

   178

     * @return PixelCoordinate position

   179

     */

   180

    PixelCoordinate getCoordinate (void) const;

   181

   182

    /**

   183

     * Get current object velocity.

   184

     *

   185

     * @return Velocity vector

   186

     */

   187

    Vector getVelocity() const;

   188

   189

    /**

   190

     * Return object shape.

   191

     *

   192

     * @return Polygon points

   193

     */

   194

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

   195

   196

    /**

   197

     * Set object shape.

   198

     *

   199

     * @param shape Vector containing polygon poinst

   200

     */

   201

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

   202

   203

    /**

   204

     * Return object facing.

   205

     *

   206

     * @return Object facing (true if facing right)

   207

     */

   208

    FacingDirection getFacing() const;

   209

   210

    /**

   211

     * Return object aim angle.

   212

     *

   213

     * @return Object aim angle

   214

     */

   215

    float getAim() const;

   216

   217

    /**

   218

     * Returns facing+aim as a unit vector

   219

     */

   220

    Vector getDirection (void) const;

   221

   222

    /**

   223

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

   224

     */

   225

    void destroy (void);

   226

   227

    /*

   228

     * Had the object been destroyed?

   229

     */

   230

    bool isDestroyed (void);

   231

   232

    /**

   233

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

   234

     */

   235

    bool removeIfDestroyed (void);

   236

   237

    /**

   238

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

   239

     */

   240

    void setPivot (PhysicsObject *pivot);

   241

   242

    /**

   243

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

   244

     */

   245

    virtual float getPivotForce (PhysicsObject *bob);

   246

   247

    /**

   248

     * Update object in physics simulation.

   249

     */

   250

    virtual void tick (TimeMS tick_length);

   251

};

   252

   253

struct Derivative {

   254

    Vector dx; // Velocity

   255

    Vector dv; // Acceleration

   256

};

   257

   258

#endif