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(),

    22

    selectedWeapon(0), changing(false), animation_step(0), rope(*this) 

    23

{

    24

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

    25

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

    26

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

    27

        arsenal.push_back(Weapon(state, 10000, (5 - i) * 40 + 30, i * 6 + 5, i * 100 + 50, "asdf"));

    28

    }

    29

    30

    // build the player's shape

    31

    // XXX: these dimensions are incorrect...

    32

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

    33

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

    34

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

    35

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

    36

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

    37

    38

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

    39

    setShape(shape);

    40

    41

    // XXX: this should be a PhysicsObject constructor arg

    42

    collision_elasticity = PLAYER_COLLISION_ELASTICITY;

    43

}

    44

    45

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

    46

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

    47

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

    49

    Vector shotVelocity = unitVectorAim*shotspeed;

    50

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

    51

    52

}

    53

    54

void Player::handleCreateProjectile (Weapon &weapon, Vector position, Vector velocity) {

    55

    new Projectile(state, position, velocity, true, weapon.getExplosionRadius());

    56

}

    57

    58

void Player::printDebugInfo (void) {

    59

    Engine::log(DEBUG, "layer.debug") << "In air: " << this->inAir;

    60

}

    61

    62

void Player::tick (TimeMS dt) {

    63

    // let PhysicsObject execute

    64

    PhysicsObject::tick(dt);

    65

    66

    // tick current weapon reload

    67

    getWeapon().tickReload(dt);

    68

}

    69

    70

void LocalPlayer::fireWeapon (Weapon &weapon) {

    71

    // update reload timer

    72

    weapon.reload();

    73

    74

    // calculate unit vector

    75

    Vector unitVectorAim = (facingRight ? 

    76

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

    77

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

    78

    );

    79

    80

    // XXX: what does the PHYSICS_TICK_MS stuff mean?

    81

    float shotspeed = weapon.getVelocity() * PHYSICS_TICK_MS / 2;

    82

    83

    Vector shotRelativeVelocity = unitVectorAim * shotspeed;

    84

    Vector shotVelocity = this->velocity + shotRelativeVelocity;

    85

    Vector shotPosition = this->position + unitVectorAim * 10;

    86

    87

    // execute

    88

    handleCreateProjectile(weapon, shotPosition, shotVelocity);

    89

}

    90

    91

void LocalPlayer::handleInput (PlayerInput input) {

    92

    // Movement force, vertical is always zero

    93

    Vector move_force = Vector(0, 0); 

    94

    95

    // Crosshair angle change

    96

    float aim_delta = 0; 

    97

    98

    // handle movement left/right by applying a horizontal force, but limit the player's speed

    99

    if ((input & INPUT_MOVE_LEFT) && (velocity.x > -PLAYER_MAX_SPEED)) {

   100

        setFacing(false);

   101

        move_force.x -= PLAYER_MOVE_FORCE;

   102

   103

    }

   104

   105

    if ((input & INPUT_MOVE_RIGHT) && (velocity.x < PLAYER_MAX_SPEED)) {

   106

        setFacing(true);

   107

        move_force.x += PLAYER_MOVE_FORCE;

   108

    }

   109

   110

    // handle aim by creating a aim angle delta

   111

    if (input & INPUT_AIM_UP)

   112

        aim_delta += CROSSHAIR_ANGLE_SPEED;

   113

   114

    if (input & INPUT_AIM_DOWN)

   115

        aim_delta -= CROSSHAIR_ANGLE_SPEED;

   116

   117

    // handle jumping by invoking the jump method

   118

    // XXX: the direction should ideally be given using some other method

   119

    if (input & INPUT_JUMP) {

   120

        if (input & INPUT_MOVE_LEFT)

   121

            jump(-1);

   122

   123

        else if (input & INPUT_MOVE_RIGHT)

   124

            jump(1);

   125

   126

        else

   127

            jump(0);

   128

    }

   129

   130

    // outsource digging to Player::handleDig, since this modifies the Terrain and Network needs to know

   131

    if (input & INPUT_DIG) {

   132

        handleDig(position, 15);

   133

   134

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

   135

        // but it doesn't.

   136

        // But this now just segfaults

   137

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

   138

    }

   139

   140

    // XXX: currently not network safe

   141

    if (input & INPUT_CHANGE) {

   142

        if (changing) {

   143

   144

        } else {

   145

            changing = true;

   146

            selectedWeapon = (selectedWeapon + 1) % arsenal.size();

   147

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

   148

        }

   149

    } else {

   150

        changing = false;

   151

    }

   152

   153

    // validate shoot events, and then outsource to handleShoot so Network can intercept it

   154

    if (input & INPUT_SHOOT && getWeapon().canShoot())

   155

        fireWeapon(getWeapon());

   156

   157

    if (input & INPUT_ROPE)

   158

        rope.shoot();

   159

   160

    if (input & INPUT_UNROPE)

   161

        rope.release();

   162

   169

    // XXX: how should this be written?

   170

    if (move_force.x != 0) 

   171

        animation_step = (animation_step + 1) % img_num_step;

   172

   173

    // apply aim delta

   174

    if (aim_delta)

   175

        changeAim(aim_delta);

   176

   177

    // apply force

   178

    if (!move_force.zero())

   179

        applyForce(move_force);

   180

}

   181

   182

Weapon& Player::getWeapon() {

   183

    return arsenal[selectedWeapon % arsenal.size()];

   184

}

   185

   186

void Player::draw (CL_GraphicContext *gc) {

   187

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

   188

    int step_img_idx = animation_step%img_num_step;

   189

   190

    // load skin image if not yet loaded

   191

    if (!skin_loaded) {

   192

        skin_surface = CL_Surface(PLAYER_SKIN_PATH);

   193

        skin_loaded = true;

   194

    }

   195

   196

    // XXX: this logic looks weird

   197

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

   198

   199

    if (!getFacing()) {

   200

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

   201

    }

   202

   203

    skin_surface.draw_subpixel(

   204

            CL_Rectf(

   205

                1 + step_img_idx * img_width, 

   206

                aim_img_idx * img_height + 1, 

   207

                1 + (1 + step_img_idx) * img_width, 

   208

                (aim_img_idx + 1) * img_height + 1

   209

            ), 

   210

            destination, gc

   211

    );

   212

   213

    const uint16_t chlen = 10;

   214

    uint16_t x = position.x;

   215

    uint16_t y = position.y;

   216

   217

    // draw "crosshair"

   218

    if (facingRight) {

   219

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

   220

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

   221

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

   222

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

   223

                      CL_Color::black);

   224

    } else {

   225

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

   226

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

   227

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

   228

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

   229

                      CL_Color::black);

   230

    }

   231

}

   232

   233