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

    26

    if (state == ROPE_FIXED) {

    27

        // unset pivot if we re-throw rope

    28

        player.setPivot(NULL);

    29

    }

    30

    31

    // update state

    32

    state = ROPE_FLYING;

    33

    34

    // XXX: this should probably be more dynamic?

    35

    length = ROPE_LENGTH;

    36

    37

    // copy position + velocity from player

    38

    setPosition(player.getPosition());

    39

    setVelocity(player.getVelocity() + player.getDirection() * ROPE_VELOCITY);

    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

    82

    // XXX: reset, except we override tick() in ugly ways

    83

    setVelocity(Vector(0,0));

    84

    85

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

    86

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

    87

    setPosition(collisionPoint);

    88

    89

    // inform network

    90

    player.handleRopeState(state);

    91

}

    92

    93

void Rope::release (void) {

    94

    // Remove the rope from the PhysicsWorld

    95

    disable();

    96

    97

    state = ROPE_FOLDED;

    98

    99

    // player doesn't have a pivot anymore

   100

    player.setPivot(NULL);

   101

   102

    // inform network

   103

    player.handleRopeState(state);

   104

}

   105

   106

void Rope::changeLength (float delta) {

   107

    // change length

   108

    length += delta;

   109

   110

    // minimum length

   111

    if (length < 0)

   112

        length = 0;

   113

   114

    // inform network

   115

    player.handleRopeLength(length);

   116

}

   117

   118

RopeState Rope::getState (void) {

   119

    return state;

   120

}

   121

   122

float Rope::getLength (void) {

   123

    return length;

   124

}

   125

   126

Player *Rope::getPivotPlayer (void) {

   127

    if (player.getPivot() == this)

   128

        return NULL;

   129

    else

   130

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

   131

}

   132

   133

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

   134

    // update physics enabled/disabled state

   135

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

   136

        disable();

   137

   138

    else // new_state == ROPE_FLYING

   139

        enable();

   140

   141

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

   142

    if (new_state == ROPE_FIXED) {

   143

        if (pivot_player)

   144

            player.setPivot(pivot_player);

   145

        else

   146

            player.setPivot(this);

   147

   148

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

   149

        player.setPivot(NULL);

   150

   151

    // update position stuff

   152

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

   153

   154

    // update vars

   155

    this->state = new_state;

   156

    this->length = new_length;

   157

}

   158

   159

void Rope::updateLength (float length) {

   160

    // update length

   161

    this->length = length;

   162

}

   163

   164

#if GRAPHICS_ENABLED

   165

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

   166

    PixelCoordinate player_pos = player.getCoordinate() - camera;

   167

    PixelCoordinate target_pos;

   168

   169

    // figure out what target is

   170

    if (state == ROPE_FOLDED) {

   171

        return;

   172

   173

    } else if (state == ROPE_FLYING) {

   174

        // target is us

   175

        target_pos = getCoordinate();

   176

   177

    } else {    // state == ROPE_FIXED

   178

        // sanity-check

   179

        if (player.getPivot() == NULL)

   180

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

   181

   182

        // target is our pivot

   183

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

   184

    }

   185

   186

    // align with camera

   187

    target_pos -= camera;

   188

   189

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

   190

    display.get_gc()->draw_line(

   191

        player_pos.x, player_pos.y,

   192

        target_pos.x, target_pos.y,

   193

        ROPE_COLOR_DARK

   194

    );

   195

}

   196

#endif

   197

   198

void Rope::tick (TimeMS dt) {

   199

    if (state == ROPE_FLYING) {

   200

        // let PhysicsObject handle the flying stage

   201

        PhysicsObject::tick(dt); 

   202

   203

    } else if (state == ROPE_FIXED) {

   204

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

   205

        if (player.getPivot() != this)

   206

            return;

   207

   208

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

   209

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

   210

            // XXX: move to some new method

   211

            state = ROPE_FLYING;

   212

            length = ROPE_LENGTH;

   213

            inAir = true;

   214

            player.setPivot(NULL);

   215

            player.handleRopeState(state);

   216

        }

   217

    } else { // state == ROPE_FOLDED

   218

        // ignore ticks when folded

   219

    }

   220

}

   221