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

    10

    player(player), 

    11

    state(ROPE_FOLDED) 

    12

{

    13

    // XXX: better shape

    14

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

    15

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

    16

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

    17

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

    18

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

    19

    setShape(shape);

    20

}

    21

    22

void Rope::throwRope (void) {

    23

    state = ROPE_FLYING;

    24

    25

    // XXX: this should probably be more dynamic?

    26

    length = ROPE_LENGTH;

    27

    28

    // copy position + velocity from player

    29

    setPosition (player.getPosition());

    30

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

    31

    32

    // we are FLYING

    33

    inAir = true;

    34

    35

    // enable the physics object

    36

    enable();

    37

    38

    // inform network

    39

    player.handleRopeState(state);

    40

}

    41

    42

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

    43

    // Fix the rope to another player if collided with it

    44

    if (other != NULL) {

    45

        if (other->getType() == PLAYER) {

    46

            Player *target = dynamic_cast<Player*>(other);

    47

            if (target == &(this->player))

    48

                return;

    49

            this->player.pivot = target;            

    50

        } else if (other->getType() == PROJECTILE) {

    51

            return;

    52

        }

    53

    } else { // Collided with terrain

    54

        player.setPivot(this);

    55

    }

    56

    57

    // attached to something!

    58

    state = ROPE_FIXED;

    59

    velocity = Vector(0,0);

    60

    61

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

    62

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

    63

    setPosition (collisionPoint);

    64

    65

    // inform network

    66

    player.handleRopeState(state);

    67

}

    68

    69

void Rope::release (void) {

    70

    // Remove the rope from the PhysicsWorld

    71

    disable();

    72

    73

    state = ROPE_FOLDED;

    74

    75

    // player doesn't have a pivot anymore

    76

    player.setPivot(NULL);

    77

    78

    // inform network

    79

    player.handleRopeState(state);

    80

}

    81

    82

void Rope::changeLength (float delta) {

    83

    // change length

    84

    length += delta;

    85

    86

    // minimum length

    87

    if (length < 0)

    88

        length = 0;

    89

    90

    // inform network

    91

    player.handleRopeLength(length);

    92

}

    93

    94

RopeState Rope::getState (void) {

    95

    return state;

    96

}

    97

    98

float Rope::getLength (void) {

    99

    return length;

   100

}

   101

   102

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

   103

    // update physics enabled/disabled state

   104

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

   105

        disable();

   106

   107

    else // new_state == ROPE_FLYING

   108

        enable();

   109

   110

    // update player.pivot

   111

    if (new_state == ROPE_FIXED)

   112

        player.setPivot(this);

   113

   114

    else if (this->state == ROPE_FIXED)

   115

        player.setPivot(NULL);

   116

   117

    // update position stuff

   118

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

   119

   120

    // update vars

   121

    this->state = new_state;

   122

    this->length = new_length;

   123

}

   124

   125

void Rope::updateLength (float length) {

   126

    // update length

   127

    this->length = length;

   128

}

   129

   130

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

   131

    if (state == ROPE_FOLDED)

   132

        return;

   133

   134

    PixelCoordinate player_pos = player.getCoordinate() - camera;

   135

    PixelCoordinate self_pos = getCoordinate() - camera;

   136

   137

    g->get_gc()->draw_line(

   138

        player_pos.x, player_pos.y,

   139

        self_pos.x, self_pos.y,

   140

        CL_Color::black

   141

    );

   142

}

   143

   144

void Rope::tick (TimeMS dt) {

   145

    if (this->state == ROPE_FLYING) {

   146

        // super

   147

        PhysicsObject::tick(dt); 

   148

    }

   149

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

   150

   151

        this->position = player.getPivot()->getPosition();

   152

   153

        // If players pivot is not this rope but some other player don't do anything 

   154

        // (though it should be released atleast when the player dies)

   155

        if (player.getPivot() != this)

   156

            return;

   157

   158

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

   159

        if (!world.collides(position)) { 

   160

            state = ROPE_FLYING;

   161

            length = ROPE_LENGTH;

   162

            inAir = true;

   163

            player.setPivot(NULL);

   164

            player.handleRopeState(state);

   165

        }

   166

    }

   167

    else { // ROPE_FOLDED

   168

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

   169

        // immediately after the rope has been released

   170

    }

   171

}