1

#include "Player.hh"

     2

#include "PhysicsObject.hh"

     3

#include "Engine.hh"

     4

     5

#include <cmath>

     6

     7

PhysicsObject::PhysicsObject (PhysicsWorld &world, float mass, 

     8

                              Vector position, Vector velocity)

     9

    : world(world), position(position), velocity(velocity),

    10

      mass(mass), inAir(true), aim(0), facingRight(true), reloadTimer(0) {

    11

    // TODO: Is thir the right way to do this?

    12

    //world.addPlayerObject(this);

    13

}

    14

    15

/**

    16

 * Player walks on floor.

    17

 */

    18

Vector PhysicsObject::walk_one_step (float partial, bool right) {

    19

    // which way we are walking

    20

    float deltaX = right ? partial : -partial;

    21

    Vector reached = this->position;

    22

    if(reached.roundToInt() == (reached+Vector(deltaX, 0)).roundToInt()) {

    23

        return reached+Vector(deltaX, 0);

    24

    }

    25

    // Is there upward ramp

    26

    if(!possibleLocation(position+Vector(deltaX, 0))) {

    27

        // Yes. Then we check n pixels up

    28

        for(int i = 1; i < 3; i++) {

    29

            if(possibleLocation(position+Vector(deltaX, -i))) {

    30

                // and when there is finally EMPTY, we can walk

    31

                reached = position+Vector(deltaX, -i);

    32

                break;

    33

            }

    34

        }

    35

    } else {

    36

        // Or downward ramp or flat

    37

        for(int i = 0; 1; i++) {

    38

    39

            // And when there is finally ground we can step on

    40

            // it. If there is no gound we still step there,

    41

            // but will fall one pixel down

    42

            if(possibleLocation(position+Vector(deltaX, i))) {

    43

                reached = position+Vector(deltaX, i);

    44

            } else {

    45

                break;

    46

            }

    47

    48

            // If the fall is big enough, set the worm in the air

    49

            if (i >= 2) {

    50

//                Vector back = walk(dt, !right);

    51

                this->inAir = true;

    52

//                this->velocity.x = right ? velocity : -velocity;

    53

                // Avoid stepping two pixels down when it starts to free fall

    54

                reached.y -= 2;

    55

//                this->velocity = (reached-back)*1000/dt;

    56

                break;

    57

            }

    58

        }

    59

    }

    60

    // And we return where we got

    61

    return reached;

    62

}

    63

void PhysicsObject::walk (TimeMS dt, bool right) {

    64

    float velocity = PLAYER_WALK_SPEED;

    65

    float walkAmount = (velocity*dt)/1000;

    66

    Vector reached = this->position;

    67

    while(walkAmount > 0 && !this->inAir) {

    68

        this->position = walk_one_step((1 < walkAmount ? 1 : walkAmount), right);

    69

        walkAmount--;

    70

    }

    71

    // TODO: Should the remaining walkAmount be handled somehow?

    72

}

    73

    74

/**

    75

 * Makes the player jump in the air.

    76

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

    77

 */

    78

void PhysicsObject::jump (int direction) {

    79

    // Jump only if player is "on the ground"

    80

    if (!this->inAir) {

    81

 	    velocity.y = -100;

    82

        switch (direction) {

    83

            case 1:

    84

                velocity.x += 20;

    85

                break;

    86

            case -1:

    87

                velocity.x -= 20;

    88

                break;

    89

            case 0:

    90

                break;

    91

            default:

    92

                throw std::logic_error("Invalid jump direction");

    93

        }

    94

	    inAir = true;

    95

    }

    96

}

    97

    98

bool PhysicsObject::possibleLocation (Vector loc) {

    99

    for(unsigned int i = 0; i < this->shape.size(); i++) {

   100

        if(world.collides(loc+shape[i]))

   101

            return false;

   102

    }

   103

    return true;

   104

}

   105

   106

void func1() {

   107

   108

}

   109

   110

/**

   111

 * Updates object speed and position. This function organises force

   112

 * integration and collision detection.

   113

 */   

   114

void PhysicsObject::updatePosition () {

   115

   116

    // Reloads weapon if not reloaded

   117

    reloadTimer -= PHYSICS_TICK_MS;

   118

    if(reloadTimer < 0)

   119

        reloadTimer = 0;

   120

   121

    // Add gravity to the force queue

   122

    forceq.push(world.gravity);

   123

   124

    // Go trough every force in the queue

   125

    Force total;

   126

    while (!forceq.empty()) {

   127

        total += forceq.front();

   128

        forceq.pop();

   129

    }

   130

   131

    // If the player has stopped and there's some ground under some of the 3 some of the 3t

   132

    // set inAir false

   133

    if (this->velocity == Vector(0,0)) {

   134

        this->inAir = !world.collides(this->position+shape[1]+Vector(0, 1))

   135

                      && !world.collides(this->position+shape[2]+Vector(0, 1))

   136

                      && !world.collides(this->position+shape[3]+Vector(0, 1));

   137

        // If, however, there's a force caused by a bomb, e.g., set it in air.

   138

        // Still, we have to be able to separate forces caused by walking attempts

   139

        // and bombs etc (+0.1 because float comparison can be dangerous)

   140

        if (total.y < 0 || abs(total.x) > PLAYER_MOVE_FORCE + 0.1)

   141

            this->inAir = true;

   142

    }

   143

   144

    if(!possibleLocation(position)) {

   145

        //if we are trapped in ground form dirtball or something

   146

        //we might want to just return and set velocity to some value

   147

        //return;

   148

    }

   149

   150

    // If the worm is not in the air make it walk,

   151

    // otherwise integrate the new position and velocity

   152

    if (!this->inAir) {

   153

        //std::cout << "Tryin to walk" << std::endl;

   154

        // It walks only if there's some vertical force

   155

        if (total.x != 0) {

   156

            std::cout << "Succeeding to walk" << std::endl;

   157

            walk(PHYSICS_TICK_MS, total.x > 0);

   158

            this->velocity = Vector(0,0);

   159

        }

   160

    }

   161

   162

    if(!possibleLocation(position)) {

   163

        Engine::log(DEBUG, "great failure") << "great failure";

   164

        func1();

   165

    }

   166

    Vector newPosition;

   167

    Vector velAfterTick;

   168

    // Calculate new position and velocity to the given references

   169

    integrate(total, PHYSICS_TICK_MS, newPosition, velAfterTick);

   170

    this->velocity = velAfterTick;

   171

   172

   173

    // Collision detection

   174

    bool collided = false;

   175

   176

    const Vector diffVec = newPosition-position;

   177

    const Vector unitVector = diffVec / diffVec.length();

   178

    Vector reached = position;

   179

   180

    while ((position-reached).sqrLength() < diffVec.sqrLength()) {

   181

        reached += unitVector;

   182

        // Check if any of the shapes points collide

   183

        for (uint64_t i = 0; i < shape.size(); i++) {

   184

            if (world.collides(reached+shape[i])) {  // Collision

   185

                if (inAir) {

   186

                    //                    Engine::log(DEBUG, "Here");

   187

                    this->bounce(world.getNormal(reached+shape[i], 

   188

                                                 reached-unitVector+shape[i]));

   189

                    //this->velocity *= COLLISION_ELASTICITY;

   190

                }

   191

                reached = reached - unitVector; // Return to last point

   192

                collided = true;

   193

                if (this->velocity.sqrLength() < PLAYER_MIN_SPEED * PLAYER_MIN_SPEED) {

   194

                    this->velocity = Vector(0,0);

   195

                }

   196

                break;

   197

            }

   198

        }

   199

        if (collided)

   200

            break;

   201

//        reached += unitVector;

   202

    }

   203

   204

   205

    if(!possibleLocation(reached)) {

   206

        Engine::log(DEBUG, "PhysicsObject.updatePosition") << "logic error reached should not be possible to be impossible.. diffVec: " << diffVec;

   207

        func1();

   208

    }

   209

   210

    // In case of some float error check the final coordinate

   211

    if(!collided) {

   212

        if(!possibleLocation(newPosition)) {

   213

            newPosition = reached;

   214

        } else {

   215

            // This means everything was ok, so no need to do anything

   216

        }

   217

    } else {

   218

        newPosition = reached;

   219

        onCollision();

   220

        //this->velocity = Vector(0, 0);

   221

        //TODO: it shouldn't just stop on collision

   222

    }

   223

    if(!possibleLocation(newPosition)) {

   224

        Engine::log(DEBUG, "great failure") << "great failure";

   225

        func1();

   226

    }

   227

    this->position = newPosition;

   228

    if(!possibleLocation(position)) {

   229

        Engine::log(DEBUG, "great failure") << "great failure";

   230

        func1();

   231

    }

   232

//    Engine::log(DEBUG, "PhysicsObject.updatePosition") << "Pos: " << this->position;

   233

}

   234

   235

/**

   236

 * Bounces from straight wall in any direction.

   237

 * Direction given as normal of that wall

   238

 */

   239

void PhysicsObject::bounce (Vector normal) {

   240

    // normal.sqrLength can't be 0 when got from getNormal()

   241

    if (normal.sqrLength() != 0) {

   242

        Vector nvel = velocity;

   243

        // We project the velocity on normal and remove twice that much from velocity

   244

        nvel = nvel - ((2)*((nvel*normal)/(normal*normal))*normal);

   245

        velocity = nvel;

   246

        // We lose some of our speed on collision

   247

        this->velocity *= this->collision_elasticity;

   248

    }

   249

}

   250

   251

/**

   252

 * Integrates given force over time and stores new position to

   253

 * posAfterTick and new velocity to velAfterTick.

   254

 * @param force Force vector.

   255

 * @param dt The time the force is applied (<=PHYSICS_TICK_MS)

   256

 */

   257

void PhysicsObject::integrate(Force force, TimeMS dt, Vector &posAfterTick, Vector &velAfterTick) {

   258

    posAfterTick = position;

   259

    velAfterTick = velocity;

   260

    Derivative tmpd;

   261

    Derivative k1 = evaluate(force, 0, tmpd, posAfterTick, velAfterTick);

   262

    Derivative k2 = evaluate(force, 0.5f*dt, k1, posAfterTick, velAfterTick);

   263

    Derivative k3 = evaluate(force, 0.5f*dt, k2, posAfterTick, velAfterTick);

   264

    Derivative k4 = evaluate(force, dt, k3, posAfterTick, velAfterTick);

   265

   266

   267

    const Vector dxdt = (k1.dx + (k2.dx + k3.dx) * 2.0f + k4.dx) * 1.0f/6.0f;

   268

    const Vector dvdt = (k1.dv + (k2.dv + k3.dv) * 2.0f + k4.dv) * 1.0f/6.0f;

   269

   270

    //    Engine::log(DEBUG, "PhysicsObject.integrate") << "Changes: "<< dxdt << " " << dvdt << " Time: " <<dt;

   271

    posAfterTick = posAfterTick + (dxdt * dt)/1000;

   272

    velAfterTick = velAfterTick + (dvdt * dt)/1000;

   273

    //Engine::log(DEBUG, "PhysicsObject.integrate") << "velAfterTick: " << velAfterTick;

   274

}

   275

   276

Derivative PhysicsObject::evaluate(Force force, TimeMS dt, Derivative &d, const Vector &posAfterTick, const Vector &velAfterTick) {

   277

    Vector curPos = posAfterTick + (d.dx*dt)/1000;

   278

    Vector curVel = velAfterTick + (d.dv*dt)/1000;

   279

   280

    Derivative out;

   281

    out.dx = curVel;

   282

    out.dv = acceleration(force);

   283

    //Engine::log(DEBUG, "PhysicsObject.evaluate") << "Out.dx: " << out.dx;

   284

    return out;

   285

}

   286

   287

Vector PhysicsObject::acceleration(const Force &force) {

   288

    return (force/mass);

   289

}

   290

   291

void PhysicsObject::applyForce (Force force) {

   292

    // Add applied force to the queue

   293

    forceq.push(force);

   294

}

   295

   296

void PhysicsObject::changeAim(float da) {

   297

    this->aim += da;

   298

   299

    if (this->aim > PLAYER_AIM_MAX) this->aim = PLAYER_AIM_MAX;

   300

    if (this->aim < PLAYER_AIM_MIN) this->aim = PLAYER_AIM_MIN;

   301

    //Engine::log(DEBUG, "PhysicsObject.changeAim") << "Player aim: " << this->aim;

   302

}

   303

   304

void PhysicsObject::setFacing(bool facingRight) {

   305

    //Engine::log(DEBUG, "PhysicsObject.setFacing") << "Facing: " << right;

   306

    this->facingRight = facingRight;

   307

}

   308

   309

void PhysicsObject::updatePhysics (Vector position, Vector velocity, bool inAir) {

   310

    this->position = position;

   311

    this->velocity = velocity;

   312

    this->inAir = inAir;

   313

}

   314

   315

Vector PhysicsObject::getPosition () {

   316

    return this->position;

   317

}

   318

   319

bool PhysicsObject::getFacing() {

   320

    return this->facingRight;

   321

}

   322

   323

float PhysicsObject::getAim() {

   324

    return this->aim;

   325

}

   326

   327

std::vector<Vector>& PhysicsObject::getShape () {

   328

    return this->shape;

   329

}

   330

   331

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

   332

    this->shape = shape;

   333

}

   334

   335

void PhysicsObject::tick () {

   336

    this->updatePosition();

   337

}

   338

   339

bool PhysicsObject::canShoot() {

   340

    return this->reloadTimer <= 0;

   341

}

   342

   343

void PhysicsObject::draw(CL_GraphicContext *gc) {

   344

    CL_Quad player(

   345

                   (position+shape[0]).x, (position+shape[0]).y,

   346

                   (position+shape[1]).x, (position+shape[1]).y,

   347

                   (position+shape[2]).x, (position+shape[2]).y,

   348

                   (position+shape[3]).x, (position+shape[3]).y

   349

                   );

   350

   351

    gc->fill_quad(player, CL_Color::green);

   352

   353

    const uint16_t chlen = 10;

   354

    uint16_t x = player.center().x;

   355

    uint16_t y = player.center().y;

   356

    if (facingRight) {

   357

        gc->draw_line(x, y,

   358

                      x + std::cos(aim)*chlen,

   359

                      y - std::sin(aim)*chlen,

   360

                      CL_Color::black);

   361

    } else {

   362

        gc->draw_line(x, y,

   363

                      x - std::cos(aim)*chlen,

   364

                      y - std::sin(aim)*chlen,

   365

                      CL_Color::black);

   366

    }

   367

}

   368