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), 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

    position = 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) {

    41

    // attached to something!

    42

    state = ROPE_FIXED;

    43

    44

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

    45

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

    46

    this->position = collisionPoint;

    47

    48

    // set player's pivot

    49

    player.setPivot(this);

    50

    51

    // inform network

    52

    player.handleRopeState(state);

    53

}

    54

    55

void Rope::release (void) {

    56

    // Remove the rope from the PhysicsWorld

    57

    disable();

    58

    59

    state = ROPE_FOLDED;

    60

    61

    // player doesn't have a pivot anymore

    62

    player.setPivot(NULL);

    63

    64

    // inform network

    65

    player.handleRopeState(state);

    66

}

    67

    68

void Rope::changeLength (float delta) {

    69

    // change length

    70

    length += delta;

    71

    72

    // minimum length

    73

    if (length < 0)

    74

        length = 0;

    75

    76

    // inform network

    77

    player.handleRopeLength(length);

    78

}

    79

    80

RopeState Rope::getState (void) {

    81

    return state;

    82

}

    83

    84

float Rope::getLength (void) {

    85

    return length;

    86

}

    87

    88

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

    89

    // update physics enabled/disabled state

    90

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

    91

        disable();

    92

    93

    else // new_state == ROPE_FLYING

    94

        enable();

    95

    96

    // update player.pivot

    97

    if (new_state == ROPE_FIXED)

    98

        player.setPivot(this);

    99

   100

    else if (this->state == ROPE_FIXED)

   101

        player.setPivot(NULL);

   102

   103

    // update position stuff

   104

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

   105

   106

    // update vars

   107

    this->state = new_state;

   108

    this->length = new_length;

   109

}

   110

   111

void Rope::updateLength (float length) {

   112

    // update length

   113

    this->length = length;

   114

}

   115

   116

float Rope::getPivotForce (PhysicsObject *bob) {

   117

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

   118

        return ROPE_FORCE;

   119

    else

   120

        return 0;

   121

}

   122

   123

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

   124

    if (state == ROPE_FOLDED)

   125

        return;

   126

   127

    PixelCoordinate player_pos = player.getCoordinate() - camera;

   128

    PixelCoordinate self_pos = getCoordinate() - camera;

   129

   130

    g->get_gc()->draw_line(

   131

        player_pos.x, player_pos.y,

   132

        self_pos.x, self_pos.y,

   133

        CL_Color::black

   134

    );

   135

}

   136

   137

void Rope::tick (TimeMS dt) {

   138

    if (this->state == ROPE_FLYING) {

   139

        // super

   140

        PhysicsObject::tick(dt); 

   141

    }

   142

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

   143

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

   144

        if (!world.collides(position)) { 

   145

            this->state = ROPE_FLYING;

   146

        }

   147

    }

   148

    else { // ROPE_FOLDED

   149

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

   150

        // immediately after the rope has been released

   151

    }

   152

}