1

     2

// XXX: must include Player first, as it contains an instance of Rope

     3

#include "Player.hh"

     4

#include "Rope.hh"      

     5

#include "Engine.hh"

     6

#include "Error.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) {

    32

    state = ROPE_FLYING;

    33

    34

    // XXX: this should probably be more dynamic?

    35

    length = ROPE_LENGTH;

    36

    37

    // copy position + velocity from player

    40

    41

    // we are FLYING

    42

    inAir = true;

    43

    44

    // enable the physics object

    45

    enable();

    46

    47

    // inform network

    48

    player.handleRopeState(state);

    49

}

    50

    51

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

    52

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

    53

    if (other != NULL) {

    54

        // we collided with another object

    55

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

    56

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

    57

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

    58

    59

            // ignore if the rope hits ourself

    60

            if (target == &this->player)

    61

                return;

    62

    63

            // set player's pivot to the other player

    64

            player.setPivot(target);

    65

    66

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

    67

            disable();

    68

    69

        } else {

    70

            // ignore other objects

    71

            return;

    72

        }

    73

    74

    } else { 

    75

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

    76

        player.setPivot(this);

    77

    }

    78

    79

    // attached to something!

    80

    state = ROPE_FIXED;

    81

    velocity = Vector(0,0);

    82

    83

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

    84

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

    85

    setPosition(collisionPoint);

    86

    87

    // inform network

    88

    player.handleRopeState(state);

    89

}

    90

    91

void Rope::release (void) {

    92

    // Remove the rope from the PhysicsWorld

    93

    disable();

    94

    95

    state = ROPE_FOLDED;

    96

    97

    // player doesn't have a pivot anymore

    98

    player.setPivot(NULL);

    99

   100

    // inform network

   101

    player.handleRopeState(state);

   102

}

   103

   104

void Rope::changeLength (float delta) {

   105

    // change length

   106

    length += delta;

   107

   108

    // minimum length

   109

    if (length < 0)

   110

        length = 0;

   111

   112

    // inform network

   113

    player.handleRopeLength(length);

   114

}

   115

   116

RopeState Rope::getState (void) {

   117

    return state;

   118

}

   119

   120

float Rope::getLength (void) {

   121

    return length;

   122

}

   123

   124

Player *Rope::getPivotPlayer (void) {

   125

    if (player.getPivot() == this)

   126

        return NULL;

   127

    else

   128

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

   129

}

   130

   131

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

   132

    // update physics enabled/disabled state

   133

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

   134

        disable();

   135

   136

    else // new_state == ROPE_FLYING

   137

        enable();

   138

   139

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

   140

    if (new_state == ROPE_FIXED) {

   141

        if (pivot_player)

   142

            player.setPivot(pivot_player);

   143

        else

   144

            player.setPivot(this);

   145

   146

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

   147

        player.setPivot(NULL);

   148

   149

    // update position stuff

   150

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

   151

   152

    // update vars

   153

    this->state = new_state;

   154

    this->length = new_length;

   155

}

   156

   157

void Rope::updateLength (float length) {

   158

    // update length

   159

    this->length = length;

   160

}

   161

   162

#if GRAPHICS_ENABLED

   163

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

   164

    PixelCoordinate player_pos = player.getCoordinate() - camera;

   165

    PixelCoordinate target_pos;

   166

   167

    // figure out what target is

   168

    if (state == ROPE_FOLDED) {

   169

        return;

   170

   171

    } else if (state == ROPE_FLYING) {

   172

        // target is us

   173

        target_pos = getCoordinate();

   174

   175

    } else {    // state == ROPE_FIXED

   176

        // sanity-check

   177

        if (player.getPivot() == NULL)

   178

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

   179

   180

        // target is our pivot

   181

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

   182

    }

   183

   184

    // align with camera

   185

    target_pos -= camera;

   186

   187

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

   188

    display.get_gc()->draw_line(

   189

        player_pos.x, player_pos.y,

   190

        target_pos.x, target_pos.y,

   191

        ROPE_COLOR_DARK

   192

    );

   193

}

   194

#endif

   195

   196

void Rope::tick (TimeMS dt) {

   197

    if (state == ROPE_FLYING) {

   198

        // let PhysicsObject handle the flying stage

   199

        PhysicsObject::tick(dt); 

   200

   201

    } else if (state == ROPE_FIXED) {

   202

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

   203

        if (player.getPivot() != this)

   204

            return;

   205

   206

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

   207

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

   208

            // XXX: move to some new method

   209

            state = ROPE_FLYING;

   210

            length = ROPE_LENGTH;

   211

            inAir = true;

   212

            player.setPivot(NULL);

   213

            player.handleRopeState(state);

   214

        }

   215

    } else { // state == ROPE_FOLDED

   216

        // ignore ticks when folded

   217

    }

   218

}

   219