1

     2

#include "Player.hh"

     3

#include "Weapons.hh"

     4

#include "Engine.hh"

     5

#include "Graphics.hh"

     6

     7

#include <cstdlib>

     8

#include <ClanLib/display.h>

     9

#include <string>

    10

#include <cassert>

    11

    12

// player static state

    13

bool Player::skin_loaded = false;

    14

CL_Surface Player::skin_surface;

    15

    16

// XXX: give these better names and move elsewhere

    17

const int img_num_aim = 9;

    18

const int img_num_step = 4;

    19

const int img_height = 9;

    20

const int img_width = 10;

    21

    22

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

    23

    PhysicsObject(state.world, PLAYER_MASS, position, Vector(0, 0)), state(state), visible(visible),

    24

    weapons(buildWeaponsList()), selectedWeapon(0), animation_step(0), rope(*this) 

    25

{

    26

    // XXX: populate weapons from somewhere else

    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

    43

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

    44

    // XXX: clean this bit up

    45

    float shotspeed = 1; //0*PHYSICS_TICK_MS;

    46

    47

    Vector shotVelocity = getDirection() * shotspeed;

    48

    49

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

    50

}

    51

    52

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

    53

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

    54

}

    55

    56

void Player::handleChangeWeapon (unsigned int weaponIndex) {

    57

    assert(weaponIndex < weapons.size());

    58

    59

    selectedWeapon = weaponIndex;

    60

}

    61

    62

void Player::printDebugInfo (void) {

    63

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

    64

}

    65

    66

void Player::tick (TimeMS dt) {

    67

    // let PhysicsObject execute

    68

    PhysicsObject::tick(dt);

    69

    70

    // tick current weapon reload

    71

    if (getCurrentWeapon())

    72

        getCurrentWeapon()->tickReload(dt);

    73

}

    74

    75

void Player::handleRopeState (RopeState state) {

    76

    77

}

    78

    79

void Player::handleRopeLength (float length) {

    80

    81

}

    82

    83

void LocalPlayer::fireWeapon (Weapon *weapon) {

    84

    // update reload timer

    85

    weapon->reload();

    86

    87

    // calculate new position and velocity

    88

    Vector shotPosition = position + getDirection() * PROJECTILE_START_DISTANCE;

    89

    Vector shotVelocity = velocity + getDirection() * weapon->getSpeed();

    90

    91

    // execute

    92

    handleCreateProjectile(weapon, shotPosition, shotVelocity);

    93

}

    94

    95

void LocalPlayer::changeWeapon (int delta) {

    96

    // need to handle negative deltas

    97

    handleChangeWeapon((weapons.size() + selectedWeapon + delta) % weapons.size());

    98

}

    99

   100

void LocalPlayer::handleInput (PlayerInput input) {

   101

    // Movement force, vertical is always zero

   102

    Vector move_force = Vector(0, 0); 

   103

   104

    // Crosshair angle change

   105

    float aim_delta = 0; 

   106

   107

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

   108

    // also update facing if needed

   109

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

   110

        setFacing(false);

   111

        move_force.x -= PLAYER_MOVE_FORCE;

   112

   113

    }

   114

   115

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

   116

        setFacing(true);

   117

        move_force.x += PLAYER_MOVE_FORCE;

   118

    }

   119

   120

    // handle aim by creating a aim angle delta

   121

    if (input & INPUT_AIM_UP)

   122

        aim_delta += CROSSHAIR_ANGLE_SPEED;

   123

   124

    if (input & INPUT_AIM_DOWN)

   125

        aim_delta -= CROSSHAIR_ANGLE_SPEED;

   126

   127

    // handle jumping by invoking the jump method

   128

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

   129

    if (input & INPUT_JUMP) {

   130

        if (input & INPUT_MOVE_LEFT)

   131

            jump(-1);

   132

   133

        else if (input & INPUT_MOVE_RIGHT)

   134

            jump(1);

   135

   136

        else

   137

            jump(0);

   138

    }

   139

   140

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

   141

    if (input & INPUT_DIG)

   142

        handleDig(position, 15);

   143

   144

    // change weapon back/forth

   145

    if (input & INPUT_CHANGE_PREV)

   146

        changeWeapon(-1);

   147

   148

    if (input & INPUT_CHANGE_NEXT)

   149

        changeWeapon(+1);

   150

   151

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

   152

    if ((input & INPUT_SHOOT) && getCurrentWeapon()->canShoot())

   153

        fireWeapon(getCurrentWeapon());

   154

   155

    // rope throw+release+changeLength, but supress spurious events

   156

    if (input & INPUT_ROPE)

   157

        rope.throwRope();

   158

   159

    if (input & INPUT_UNROPE && rope.getState() != ROPE_FOLDED)

   160

        rope.release();

   161

   162

    if (input & INPUT_ROPE_UP && rope.getState() == ROPE_FIXED)

   163

        rope.changeLength(-ROPE_GROWTH_RATE);

   164

   165

    if (input & INPUT_ROPE_DOWN && rope.getState() == ROPE_FIXED)

   166

        rope.changeLength(ROPE_GROWTH_RATE);

   167

   168

    // XXX: how should this be written? What does this do? Probably broken under network play

   169

    if (move_force.x != 0) 

   170

        animation_step = (animation_step + 1) % img_num_step;

   171

   172

    // apply aim delta

   173

    if (aim_delta)

   174

        changeAim(aim_delta);

   175

   176

    // apply force

   177

    if (!move_force.zero())

   178

        applyForce(move_force);

   179

}

   180

   181

Weapon* Player::getCurrentWeapon() {

   182

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

   183

}

   184

   185

void Player::draw (Graphics *g) {

   186

    CL_GraphicContext *gc = g->get_gc();

   187

   188

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

   189

    int step_img_idx = animation_step%img_num_step;

   190

   191

    // load skin image if not yet loaded

   192

    if (!skin_loaded) {

   193

        skin_surface = CL_Surface(PLAYER_SKIN_PATH);

   194

        skin_loaded = true;

   195

    }

   196

   197

    // XXX: this logic looks weird

   198

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

   199

   200

    if (!getFacing()) {

   201

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

   202

    }

   203

   204

    skin_surface.draw_subpixel(

   205

            CL_Rectf(

   206

                1 + step_img_idx * img_width, 

   207

                aim_img_idx * img_height + 1, 

   208

                1 + (1 + step_img_idx) * img_width, 

   209

                (aim_img_idx + 1) * img_height + 1

   210

            ), 

   211

            destination, gc

   212

    );

   213

   214

    const uint16_t chlen = 10;

   215

    uint16_t x = position.x;

   216

    uint16_t y = position.y;

   217

   218

    // draw "crosshair"

   219

    if (facingRight) {

   220

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

   221

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

   222

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

   223

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

   224

                      CL_Color::black);

   225

    } else {

   226

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

   227

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

   228

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

   229

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

   230

                      CL_Color::black);

   231

    }

   232

   233

    rope.draw(g);

   234

}

   235

   236

void LocalPlayer::draw (Graphics *g, bool displayWeapon) {

   237

    // superclass draw

   238

    Player::draw(g);

   239

   240

    // display weapon name?

   241

    if (displayWeapon && getCurrentWeapon()) {

   242

        const std::string weaponName = getCurrentWeapon()->getName();

   243

   244

        g->getSimpleFont().draw(

   245

                position.x - g->getSimpleFont().get_width(weaponName) / 2,

   246

                position.y - 20,

   247

                weaponName,

   248

                g->get_gc()

   249

        );

   250

    }

   251

}

   252