1

#include "Player.hh"

     2

#include "Rope.hh"      

     3

#include "Engine.hh"

     4

#include "Graphics.hh"

     5

#include <math.h>

     6

#include <stdexcept>

     7

     8

Rope::Rope(Player &player) : 

     9

    PhysicsObject(player.state.world, ROPE_MASS, Vector(0,0), Vector(0,0), ROPE, 0.00, false), player(player), state(ROPE_FOLDED) 

    10

{

    11

    // XXX: better shape

    12

    std::vector<Vector> shape(4);

    13

    shape[0] = Vector(-1, -1);

    14

    shape[1] = Vector(-1, 1);

    15

    shape[2] = Vector(1, 1);

    16

    shape[3] = Vector(1, -1);

    17

    setShape(shape);

    18

}

    19

    20

void Rope::throwRope (void) {

    21

    state = ROPE_FLYING;

    22

    23

    // XXX: this should probably be more dynamic?

    24

    length = ROPE_LENGTH;

    25

    26

    // copy position + velocity from player

    27

    setPosition (player.getPosition());

    28

    velocity = player.getVelocity() + player.getDirection() * ROPE_VELOCITY;

    29

    30

    // we are FLYING

    31

    inAir = true;

    32

    33

    // enable the physics object

    34

    enable();

    35

    36

    // inform network

    37

    player.handleRopeState(state);

    38

}

    39

    40

void Rope::onCollision (Vector collisionPoint, PhysicsObject *other) {

    41

    (void) other;

    42

    43

    // attached to something!

    44

    state = ROPE_FIXED;

    45

    46

    // Ropes location will be used as the pivot point, so move the location to the collisionPoint.

    47

    // Currently the position is something like one pixel away from the collisionPoint where there isn't ground.

    48

    setPosition (collisionPoint);

    49

    50

    // set player's pivot

    51

    player.setPivot(this);

    52

    53

    // inform network

    54

    player.handleRopeState(state);

    55

}

    56

    57

void Rope::release (void) {

    58

    // Remove the rope from the PhysicsWorld

    59

    disable();

    60

    61

    state = ROPE_FOLDED;

    62

    63

    // player doesn't have a pivot anymore

    64

    player.setPivot(NULL);

    65

    66

    // inform network

    67

    player.handleRopeState(state);

    68

}

    69

    70

void Rope::changeLength (float delta) {

    71

    // change length

    72

    length += delta;

    73

    74

    // minimum length

    75

    if (length < 0)

    76

        length = 0;

    77

    78

    // inform network

    79

    player.handleRopeLength(length);

    80

}

    81

    82

RopeState Rope::getState (void) {

    83

    return state;

    84

}

    85

    86

float Rope::getLength (void) {

    87

    return length;

    88

}

    89

    90

void Rope::updateState (RopeState new_state, Vector position, Vector velocity, float new_length) {

    91

    // update physics enabled/disabled state

    92

    if (new_state == ROPE_FOLDED || new_state == ROPE_FIXED)

    93

        disable();

    94

    95

    else // new_state == ROPE_FLYING

    96

        enable();

    97

    98

    // update player.pivot

    99

    if (new_state == ROPE_FIXED)

   100

        player.setPivot(this);

   101

   102

    else if (this->state == ROPE_FIXED)

   103

        player.setPivot(NULL);

   104

   105

    // update position stuff

   106

    updatePhysics(position, velocity, true, FACING_RIGHT, 0);

   107

   108

    // update vars

   109

    this->state = new_state;

   110

    this->length = new_length;

   111

}

   112

   113

void Rope::updateLength (float length) {

   114

    // update length

   115

    this->length = length;

   116

}

   117

   118

float Rope::getPivotForce (PhysicsObject *bob) {

   119

    if ((position - bob->getPosition()).length() >= length)

   120

        return ROPE_FORCE;

   121

    else

   122

        return 0;

   123

}

   124

   125

void Rope::draw (Graphics *g, PixelCoordinate camera) {

   126

    if (state == ROPE_FOLDED)

   127

        return;

   128

   129

    PixelCoordinate player_pos = player.getCoordinate() - camera;

   130

    PixelCoordinate self_pos = getCoordinate() - camera;

   131

   132

    g->get_gc()->draw_line(

   133

        player_pos.x, player_pos.y,

   134

        self_pos.x, self_pos.y,

   135

        CL_Color::black

   136

    );

   137

}

   138

   139

void Rope::tick (TimeMS dt) {

   140

    if (this->state == ROPE_FLYING) {

   141

        // super

   142

        PhysicsObject::tick(dt); 

   143

    }

   144

    else if (this->state == ROPE_FIXED) {

   145

        // If there's not ground on the pivot point anymore, release the rope

   146

        if (!world.collides(position)) { 

   147

            this->state = ROPE_FLYING;

   148

            player.handleRopeState(state);

   149

        }

   150

    }

   151

    else { // ROPE_FOLDED

   152

        // Rope shouldn't be ticking if it is folded, but this can still happen

   153

        // immediately after the rope has been released

   154

    }

   155

}