3

#include "Player.hh"

     4

#include "Rope.hh"      

     5

#include "Engine.hh"

     7

     8

#include <math.h>

     9

#include <stdexcept>

    10

    11

Rope::Rope(Player &player) : 

    12

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

    13

    player(player), 

    14

    state(ROPE_FOLDED) 

    15

{

    16

    // XXX: better shape

    17

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

    18

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

    19

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

    20

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

    21

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

    22

    setShape(shape);

    23

}

    24

    25

void Rope::throwRope (void) {

    26

    state = ROPE_FLYING;

    27

    28

    // XXX: this should probably be more dynamic?

    29

    length = ROPE_LENGTH;

    30

    31

    // copy position + velocity from player

    32

    setPosition (player.getPosition());

    33

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

    34

    35

    // we are FLYING

    36

    inAir = true;

    37

    38

    // enable the physics object

    39

    enable();

    40

    41

    // inform network

    42

    player.handleRopeState(state);

    43

}

    44

    45

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

    46

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

    47

    if (other != NULL) {

    48

        // we collided with another object

    49

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

    50

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

    51

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

    52

    53

            // ignore if the rope hits ourself

    54

            if (target == &this->player)

    55

                return;

    56

    57

            // set player's pivot to the other player

    58

            player.setPivot(target);

    59

    60

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

    61

            disable();

    62

    63

        } else {

    64

            // ignore other objects

    65

            return;

    66

        }

    67

    68

    } else { 

    69

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

    70

        player.setPivot(this);

    71

    }

    72

    73

    // attached to something!

    74

    state = ROPE_FIXED;

    75

    velocity = Vector(0,0);

    76

    77

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

    78

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

    79

    setPosition(collisionPoint);

    80

    81

    // inform network

    82

    player.handleRopeState(state);

    83

}

    84

    85

void Rope::release (void) {

    86

    // Remove the rope from the PhysicsWorld

    87

    disable();

    88

    89

    state = ROPE_FOLDED;

    90

    91

    // player doesn't have a pivot anymore

    92

    player.setPivot(NULL);

    93

    94

    // inform network

    95

    player.handleRopeState(state);

    96

}

    97

    98

void Rope::changeLength (float delta) {

    99

    // change length

   100

    length += delta;

   101

   102

    // minimum length

   103

    if (length < 0)

   104

        length = 0;

   105

   106

    // inform network

   107

    player.handleRopeLength(length);

   108

}

   109

   110

RopeState Rope::getState (void) {

   111

    return state;

   112

}

   113

   114

float Rope::getLength (void) {

   115

    return length;

   116

}

   117

   118

Player *Rope::getPivotPlayer (void) {

   119

    if (player.getPivot() == this)

   120

        return NULL;

   121

    else

   122

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

   123

}

   124

   125

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

   126

    // update physics enabled/disabled state

   127

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

   128

        disable();

   129

   130

    else // new_state == ROPE_FLYING

   131

        enable();

   132

   133

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

   134

    if (new_state == ROPE_FIXED) {

   135

        if (pivot_player)

   136

            player.setPivot(pivot_player);

   137

        else

   138

            player.setPivot(this);

   139

   140

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

   141

        player.setPivot(NULL);

   142

   143

    // update position stuff

   144

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

   145

   146

    // update vars

   147

    this->state = new_state;

   148

    this->length = new_length;

   149

}

   150

   151

void Rope::updateLength (float length) {

   152

    // update length

   153

    this->length = length;

   154

}

   155

   157

void Rope::draw (graphics::Display &display, PixelCoordinate camera) {

   158

    PixelCoordinate player_pos = player.getCoordinate() - camera;

   159

    PixelCoordinate target_pos;

   160

   161

    // figure out what target is

   162

    if (state == ROPE_FOLDED) {

   163

        return;

   164

   165

    } else if (state == ROPE_FLYING) {

   166

        // target is us

   167

        target_pos = getCoordinate();

   168

   169

    } else {    // state == ROPE_FIXED

   170

        // sanity-check

   171

        if (player.getPivot() == NULL)

   172

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

   173

   174

        // target is our pivot

   175

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

   176

    }

   177

   178

    // align with camera

   179

    target_pos -= camera;

   180

   181

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

   182

    display.get_gc()->draw_line(

   183

        player_pos.x, player_pos.y,

   184

        target_pos.x, target_pos.y,

   185

        ROPE_COLOR_DARK

   186

    );

   187

}

   189

   190

void Rope::tick (TimeMS dt) {

   191

    if (state == ROPE_FLYING) {

   192

        // let PhysicsObject handle the flying stage

   193

        PhysicsObject::tick(dt); 

   194

   195

    } else if (state == ROPE_FIXED) {

   196

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

   197

        if (player.getPivot() != this)

   198

            return;

   199

   200

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

   201

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

   202

            // XXX: move to some new method

   203

            state = ROPE_FLYING;

   204

            length = ROPE_LENGTH;

   205

            inAir = true;

   206

            player.setPivot(NULL);

   207

            player.handleRopeState(state);

   208

        }

   209

    } else { // state == ROPE_FOLDED

   210

        // ignore ticks when folded

   211

    }

   212

}

   213