1

#include "Player.hh"

     2

#include "Rope.hh"      

     3

#include "Engine.hh"

     4

#include "Graphics.hh"

     5

#include <math.h>

     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

    41

    // attached to something!

    42

    state = ROPE_FIXED;

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

    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, Vector cam) const {

   124

    if (state == ROPE_FOLDED)

   125

        return;

   126

   127

    g->get_gc()->draw_line(

   128

            player.getPosition().x-cam.x, player.getPosition().y-cam.y,

   129

            position.x-cam.x, position.y-cam.y, 

   130

            CL_Color::black

   131

    );

   132

}

   133