1

     2

#include "Player.hh"

     3

#include "Weapons.hh"

     4

#include "Engine.hh"

     7

     8

#include <cstdlib>

     9

#include <ClanLib/display.h>

    10

#include <algorithm>

    11

#include <string>

    12

#include <cassert>

    13

    14

    15

// player static state

    16

bool Player::skin_loaded = false;

    17

CL_Surface Player::skin_surface;

    18

    19

// XXX: give these better names and move elsewhere

    20

const int img_num_aim = 5;

    21

const int img_num_step = 4;

    22

const int img_height = 20;

    23

const int img_width = 17;

    24

    25

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

    26

    PhysicsObject(state.world, PLAYER_MASS, position, Vector(0, 0), PLAYER, PLAYER_COLLISION_ELASTICITY), 

    27

    state(state), 

    28

    visible(visible), 

    29

    weapons(buildWeaponsList()), 

    30

    selectedWeapon(0), 

    31

    rope(*this),

    32

    health(PLAYER_HEALTH),

    33

    respawn_timer(PLAYER_RESPAWN_DELAY),

    34

    animation_step(0),

    35

    kills(0),

    36

    deaths(0)

    37

{

    38

    // XXX: populate weapons from somewhere else

    39

    40

    // build the player's shape

    41

    // XXX: these dimensions are incorrect...

    42

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

    43

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

    44

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

    45

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

    46

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

    47

    48

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

    49

    setShape(shape);

    50

    51

    // add to GameState players list

    52

    state.addPlayer(this);

    53

    54

    // connect respawn timer

    55

    respawn_slot = respawn_timer.sig_tick().connect(this, &Player::respawn);

    56

    57

    // spawn

    58

    spawn(position);

    59

}

    60

    61

Player::~Player (void) {

    62

    state.removePlayer(this);

    63

}

    64

    65

void Player::spawn (Vector position) {

    66

    // dig hole

    67

    world.terrain.removeGround(position, PLAYER_DIG_RADIUS);

    68

    69

    // update position

    70

    setPosition(position);

    71

    72

    // reset health

    73

    health = PLAYER_HEALTH;

    74

    75

    // XXX: reload weapons

    76

    77

    // enable

    78

    enable();

    79

}

    80

    81

void Player::die (bool start_timer) {

    82

    83

    deaths++; // Increment death counter

    84

    85

    // we don't have a rope anymore

    86

    rope.release();

    87

    88

    // disable our PhysicsObject

    89

    disable();

    90

    91

    // XXX: PhysicsObject::reset

    92

    this->velocity = Vector(0, 0);

    93

    94

    if (start_timer) {

    95

        // start respawn timer

    96

        respawn_timer.fire_once();

    97

    }

    98

}

    99

   100

void Player::respawn (TimeMS dt) {

   101

    (void) dt;

   102

   103

    // spawn in the middle of the world

   104

    spawn(world.dimensions / 2); 

   105

}

   106

   107

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

   108

    // calculate new position and velocity

   109

    Vector digPosition = pos + getDirection() * PROJECTILE_START_DISTANCE;

   110

   111

    // remove directly

   112

    world.terrain.removeGround(digPosition, radius);

   113

}

   114

   115

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

   116

    weaponFired(weapon);

   117

   118

    new Projectile(this, position, velocity, weapon);

   119

}

   120

   121

void Player::handleChangeWeapon (unsigned int weaponIndex) {

   122

    assert(weaponIndex < weapons.size());

   123

   124

    selectedWeapon = weaponIndex;

   125

}

   126

   127

void Player::weaponFired (Weapon *weapon) {

   128

    // apply recoil

   129

    applyForce(-getDirection() * weapon->getRecoil());

   130

   131

    // reload weapon

   132

    weapon->reload();

   133

}

   134

   135

void Player::printDebugInfo (void) {

   136

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

   137

}

   138

   139

void Player::tick (TimeMS dt) {

   140

    // let PhysicsObject execute

   141

    PhysicsObject::tick(dt);

   142

   143

    // tick current weapon reload

   144

    if (getCurrentWeapon())

   145

        getCurrentWeapon()->tickReload(dt);

   146

}

   147

   148

void Player::handleRopeState (RopeState state) {

   149

    (void) state;

   150

}

   151

   152

void Player::handleRopeLength (float length) {

   153

    (void) length;

   154

}

   155

   156

/*

   157

 * LocalPlayer

   158

 */

   159

void LocalPlayer::fireWeapon (Weapon *weapon) {

   160

    // calculate new position and velocity

   161

    Vector shotPosition = position + getDirection() * PROJECTILE_START_DISTANCE;

   162

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

   163

   164

    // execute

   165

    handleFireWeapon(weapon, shotPosition, shotVelocity);

   166

}

   167

   168

void LocalPlayer::changeWeapon (int delta) {

   169

    // need to handle negative deltas

   170

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

   171

}

   172

   173

void LocalPlayer::handleInput (PlayerInput input, TimeMS dt) {

   174

    // if we are dead, we can't do anything

   175

    if (!isAlive())

   176

        return;

   177

   178

    // Movement force, vertical is always zero

   179

    Vector move_force = Vector(0, 0); 

   180

   181

    // Crosshair angle change

   182

    float aim_delta = 0; 

   183

   184

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

   185

    // also update facing if needed

   186

    if (!((input & INPUT_MOVE_LEFT) && (input & INPUT_MOVE_RIGHT))) {

   187

        if (input & INPUT_MOVE_LEFT) {

   188

            if (velocity.x > -PLAYER_MAX_SPEED)

   189

                move_force.x -= PLAYER_MOVE_FORCE;

   190

   191

            setFacing(FACING_LEFT);

   192

        }

   193

   194

        if (input & INPUT_MOVE_RIGHT) {

   195

            if (velocity.x < PLAYER_MAX_SPEED)

   196

                move_force.x += PLAYER_MOVE_FORCE;

   197

   198

            setFacing(FACING_RIGHT);

   199

        }

   200

    }

   201

   202

    // handle aim by creating a aim angle delta

   203

    if (input & INPUT_AIM_UP)

   204

        aim_delta += CROSSHAIR_ANGLE_SPEED*dt;

   205

   206

    if (input & INPUT_AIM_DOWN)

   207

        aim_delta -= CROSSHAIR_ANGLE_SPEED*dt;

   208

   209

    // handle jumping by invoking the jump method

   210

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

   211

    if (input & INPUT_JUMP) {

   212

        if (input & INPUT_MOVE_LEFT)

   213

            jump(-1);

   214

   215

        else if (input & INPUT_MOVE_RIGHT)

   216

            jump(1);

   217

   218

        else

   219

            jump(0);

   220

    }

   221

   222

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

   223

    if (input & INPUT_DIG)

   224

        handleDig(position, PLAYER_DIG_RADIUS);

   225

   226

    // change weapon back/forth

   227

    if (input & INPUT_CHANGE_PREV)

   228

        changeWeapon(-1);

   229

   230

    if (input & INPUT_CHANGE_NEXT)

   231

        changeWeapon(+1);

   232

   233

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

   234

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

   235

        fireWeapon(getCurrentWeapon());

   236

   237

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

   238

    if (input & INPUT_ROPE)

   239

        rope.throwRope();

   240

   241

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

   242

        rope.release();

   243

   244

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

   245

        rope.changeLength(-ROPE_GROWTH_RATE);

   246

   247

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

   248

        rope.changeLength(ROPE_GROWTH_RATE);

   249

   250

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

   251

    if (move_force.x != 0) 

   252

        animation_step = (animation_step + 1) % img_num_step;

   253

   254

    // apply aim delta

   255

    if (aim_delta)

   256

        changeAim(aim_delta);

   257

   258

    // apply force

   259

    if (!move_force.zero())

   260

        applyForce(move_force, dt);

   261

   262

    // suicide?

   263

    if (input & INPUT_SUICIDE)

   264

        die();

   265

}

   266

   267

Weapon* Player::getCurrentWeapon() {

   268

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

   269

}

   270

   271

Weapon* Player::getWeapon (WeaponID id) {

   272

    if (id < weapons.size())

   273

        return weapons[id];

   274

    else

   275

        return NULL;

   276

}

   277

   278

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

   279

    (void) collisionPoint;

   280

   281

    if (other == NULL)

   282

        return;

   283

   284

    // Currently we handle only player-player collision here.

   285

    // Player-projectile collision is handled in projectile's onCollision.

   286

    // XXX: not completely network-safe

   287

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

   288

        //Vector normal = this->getPosition() - other->getPosition();

   289

        //this->bounce(normal);

   290

   291

        // Move the player back to its previous position so that players won't

   292

        // stuff inside each others when having a collision walk, e.g.

   293

        //this->setPosition(this->getPreviousPosition());

   294

    }

   295

}

   296

   297

Vector Player::getPivotForce () {

   298

    Vector direction = this->pivot->getPosition() - this->getPosition();

   299

    float dirLength = direction.length();

   300

    if (dirLength >= this->rope.getLength())

   301

        return direction / dirLength * ROPE_FORCE;

   302

    else

   303

        return Vector(0,0);

   304

}

   305

   306

void Player::takeDamage (Projectile *source) {

   307

    health -= source->getDamage();

   308

   309

    if (health <= 0) {

   310

        if (this != source->getOwner()) { 

   311

            source->addKillToOwner();

   312

        }

   313

        die();

   314

    }

   315

   316

    Engine::log(DEBUG, "player.take_damage") << this << ": damage=" << source->getDamage() << ", health=" << health;

   317

    Engine::log(DEBUG, "player.take_damage") << this << ": kills=" << kills << ", deaths=" << deaths;

   318

}

   319

   320

float Player::getHealthPercent () const {

   321

    return std::max(0.0f, this->health * 100 / (float) PLAYER_HEALTH);

   322

}

   323

   324

void Player::addKill () {

   325

    kills++;

   326

}

   327

   330

   331

    if (!isAlive())

   332

        return;

   333

   334

    // draw rope behind player

   336

   337

    // animation indexes

   338

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

   339

    int step_img_idx = animation_step % img_num_step;

   340

   341

    // load skin image if not yet loaded

   342

    if (!skin_loaded) {

   343

        skin_surface = CL_Surface(PLAYER_SKIN_PATH);

   344

        skin_loaded = true;

   345

    }

   346

   347

    // calulate where to draw the worm

   348

    CL_Rectf destination(

   349

        position.x + (facing == FACING_RIGHT ? -1 : 1) * img_width / 2  - camera.x, 

   350

        position.y - img_height / 2                                     - camera.y, 

   351

        position.x + (facing == FACING_RIGHT ? 1 : -1) * img_width / 2  - camera.x, 

   352

        position.y + img_height / 2                                     - camera.y

   353

    );

   354

   355

    // draw the correct animation frame from the skin

   356

//    skin_surface.set_color(CL_Color(255, 0, 255));

   357

    skin_surface.draw_subpixel(

   358

        CL_Rectf(

   359

            step_img_idx * img_width, 

   360

            aim_img_idx * img_height, 

   361

            (1 + step_img_idx) * img_width, 

   362

            (aim_img_idx + 1) * img_height

   363

        ), destination, gc

   364

    );

   365

   366

    // draw a proper crosshair-box

   367

    PixelCoordinate crosshair = getCoordinate() + world.terrain.getPixelCoordinate(getDirection() * PLAYER_CROSSHAIR_DISTANCE) - camera;

   368

   369

    gc->draw_rect(

   370

        CL_Rectf(

   371

            crosshair.x - PLAYER_CROSSHAIR_WIDTH / 2,

   372

            crosshair.y - PLAYER_CROSSHAIR_WIDTH / 2,

   373

            crosshair.x + PLAYER_CROSSHAIR_WIDTH / 2,

   374

            crosshair.y + PLAYER_CROSSHAIR_WIDTH / 2

   375

        ), CL_Color::red

   376

    );    

   377

}

   378

   380

    // superclass draw

   382

   383

    // display weapon name?

   384

    if (isAlive() && displayWeapon && getCurrentWeapon()) {

   385

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

   389

   392

   393

        // XXX: fix magic constants once we know how big the worm is

   399

        );

   400

    }

   401

}

   402