1

#include "Player.hh"

     2

#include "Rope.hh"      

     3

#include "Engine.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

        // we collided with another object

    46

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

    47

            // set our player's pivot to the object that we collided with

    48

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

    49

    50

            // ignore if the rope hits ourself

    51

            if (target == &this->player)

    52

                return;

    53

    54

            // set player's pivot to the other player

    55

            player.setPivot(target);

    56

    57

            // disable ourselves as we're no longer relevant, don't keep colliding with the player

    58

            disable();

    59

    60

        } else {

    61

            // ignore other objects

    62

            return;

    63

        }

    64

    65

    } else { 

    66

        // Collided with terrain, set player's pivot to ourselves

    67

        player.setPivot(this);

    68

    }

    69

    70

    // attached to something!

    71

    state = ROPE_FIXED;

    72

    velocity = Vector(0,0);

    73

    74

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

    75

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

    76

    setPosition(collisionPoint);

    77

    78

    // inform network

    79

    player.handleRopeState(state);

    80

}

    81

    82

void Rope::release (void) {

    83

    // Remove the rope from the PhysicsWorld

    84

    disable();

    85

    86

    state = ROPE_FOLDED;

    87

    88

    // player doesn't have a pivot anymore

    89

    player.setPivot(NULL);

    90

    91

    // inform network

    92

    player.handleRopeState(state);

    93

}

    94

    95

void Rope::changeLength (float delta) {

    96

    // change length

    97

    length += delta;

    98

    99

    // minimum length

   100

    if (length < 0)

   101

        length = 0;

   102

   103

    // inform network

   104

    player.handleRopeLength(length);

   105

}

   106

   107

RopeState Rope::getState (void) {

   108

    return state;

   109

}

   110

   111

float Rope::getLength (void) {

   112

    return length;

   113

}

   114

   115

Player *Rope::getPivotPlayer (void) {

   116

    if (player.getPivot() == this)

   117

        return NULL;

   118

    else

   119

        return dynamic_cast<Player*>(player.getPivot());

   120

}

   121

   122

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

   123

    // update physics enabled/disabled state

   124

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

   125

        disable();

   126

   127

    else // new_state == ROPE_FLYING

   128

        enable();

   129

   130

    // update player.pivot to either the given pivot_player, or this rope

   131

    if (new_state == ROPE_FIXED) {

   132

        if (pivot_player)

   133

            player.setPivot(pivot_player);

   134

        else

   135

            player.setPivot(this);

   136

   137

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

   138

        player.setPivot(NULL);

   139

   140

    // update position stuff

   141

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

   142

   143

    // update vars

   144

    this->state = new_state;

   145

    this->length = new_length;

   146

}

   147

   148

void Rope::updateLength (float length) {

   149

    // update length

   150

    this->length = length;

   151

}

   152

   154

    PixelCoordinate player_pos = player.getCoordinate() - camera;

   155

    PixelCoordinate target_pos;

   156

   157

    // figure out what target is

   158

    if (state == ROPE_FOLDED) {

   159

        return;

   160

   161

    } else if (state == ROPE_FLYING) {

   162

        // target is us

   163

        target_pos = getCoordinate();

   164

   165

    } else {    // state == ROPE_FIXED

   166

        // sanity-check

   167

        if (player.getPivot() == NULL)

   168

            throw Error("Rope::draw in state ROPE_FIXED, yet player.getPivot() is NULL");

   169

   170

        // target is our pivot

   171

        target_pos = player.getPivot()->getCoordinate();

   172

    }

   173

   174

    // align with camera

   175

    target_pos -= camera;

   176

   177

    // draw a line from the player to the target chosen above

   179

        player_pos.x, player_pos.y,

   180

        target_pos.x, target_pos.y,

   181

        ROPE_COLOR_DARK

   182

    );

   183

}

   184

   185

void Rope::tick (TimeMS dt) {

   186

    if (state == ROPE_FLYING) {

   187

        // let PhysicsObject handle the flying stage

   188

        PhysicsObject::tick(dt); 

   189

   190

    } else if (state == ROPE_FIXED) {

   191

        // if player's pivot is some other player, then don't re-check the terrain

   192

        if (player.getPivot() != this)

   193

            return;

   194

   195

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

   196

        if (!world.terrain.collides(position)) { 

   197

            // XXX: move to some new method

   198

            state = ROPE_FLYING;

   199

            length = ROPE_LENGTH;

   200

            inAir = true;

   201

            player.setPivot(NULL);

   202

            player.handleRopeState(state);

   203

        }

   204

    } else { // state == ROPE_FOLDED

   205

        // ignore ticks when folded

   206

    }

   207

}

   208