1

     2

#include "Engine.hh"

     3

#include "Player.hh" 

     4

     5

#include <cstdlib>

     6

#include <ClanLib/display.h>

     7

#include <string>

     8

#include <cassert>

     9

    10

// player static state

    11

bool Player::skin_loaded = false;

    12

CL_Surface Player::skin_surface;

    13

    14

// XXX: give these better names and move elsewhere

    15

const int img_num_aim = 9;

    16

const int img_num_step = 4;

    17

const int img_height = 9;

    18

const int img_width = 10;

    19

    20

Player::Player(GameState &state, Vector position, bool visible) : 

    21

    PhysicsObject(state.world, PLAYER_MASS, position, Vector(0, 0)), state(state), visible(visible), arsenal(), selectedWeapon(0), changing(false), animation_step(0) {

    22

    // TODO: arsenal's size should be affected by some value

    23

    // and weapons should be loaded from somewhere, not generated here

    24

    for (int i = 0; i < 5; i++) {

    26

    }

    27

    28

    // build the player's shape

    29

    // XXX: these dimensions are incorrect...

    30

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

    31

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

    32

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

    33

    shape[2] = Vector(0,9); 

    34

    shape[3] = Vector(-6,0);

    35

    36

    // Initialize the shape of the player (salmiakki shape)

    37

    setShape(shape);

    38

    39

    // XXX: this should be a PhysicsObject constructor arg

    40

    collision_elasticity = PLAYER_COLLISION_ELASTICITY;

    41

    42

    // add to player-object list

    43

    world.addPlayerObject(this);

    44

}

    45

    46

void Player::handleDig (Vector position, float radius) {

    47

    Vector unitVectorAim = facingRight ? Vector(std::cos(aim), -std::sin(aim)) : 

    48

            Vector(-std::cos(aim), -std::sin(aim));

    49

    float shotspeed = 0*PHYSICS_TICK_MS;

    50

    Vector shotVelocity = unitVectorAim*shotspeed;

    51

    new Projectile(this->state, this->position, shotVelocity, false, radius, 1);

    52

    53

}

    54

    63

    64

    Vector shotRelativeVelocity = unitVectorAim * shotspeed;

    65

    Vector shotVelocity = this->velocity + shotRelativeVelocity;

    69

}

    70

    82

    86

    89

   113

            jump(-1);

   116

            jump(1);

   118

        else

   119

            jump(0);

   120

    }

   125

   126

        // Should create Projectile which destroys ground, but also should be destroyed then,

   127

        // but it doesn't.

   128

        // But this now just segfaults

   129

//        world.addObject(new Projectile(state, position, true));

   130

    }

   133

    if (input & INPUT_CHANGE) {

   135

   136

        } else {

   137

            changing = true;

   139

            Engine::log(DEBUG, "Player.cc:input ") << "changed weapon " << selectedWeapon;

   140

        }

   141

    } else {

   142

        changing = false;

   143

    }

   148

    }

   153

   157

   161

}

   162

   163

Weapon& Player::getWeapon() {

   165

}

   166

   168

    int aim_img_idx = (int)((1 - (getAim()+KG_PI/2)/KG_PI)*img_num_aim);

   169

    int step_img_idx = animation_step%img_num_step;

   170

   171

    // load skin image if not yet loaded

   172

    if (!skin_loaded) {

   173

        skin_surface = CL_Surface(PLAYER_SKIN_PATH);

   174

        skin_loaded = true;

   175

    }

   178

    CL_Rectf destination(position.x - 4, position.y - 4, position.x + 5, position.y + 4);

   179

   180

    if (!getFacing()) {

   181

        destination = CL_Rect(position.x + 5, position.y - 4, position.x - 4, position.y + 4);

   182

    }

   183

   184

    skin_surface.draw_subpixel(

   193

   194

    const uint16_t chlen = 10;

   195

    uint16_t x = position.x;

   196

    uint16_t y = position.y;

   197

   198

    // draw "crosshair"

   199

    if (facingRight) {

   200

        gc->draw_line(x + std::cos(aim)*chlen/2, 

   201

                      y - std::sin(aim)*chlen/2,

   202

                      x + std::cos(aim)*chlen,

   203

                      y - std::sin(aim)*chlen,

   204

                      CL_Color::black);

   205

    } else {

   206

        gc->draw_line(x - std::cos(aim)*chlen/2, 

   207

                      y - std::sin(aim)*chlen/2,

   208

                      x - std::cos(aim)*chlen,

   209

                      y - std::sin(aim)*chlen,

   210

                      CL_Color::black);

   211

    }

   212

}

   213

   214