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 = 2;

    18

const int img_num_step = 4;

    19

const int img_height = 20;

    20

const int img_width = 17;

    21

    22

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

    23

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

    24

    state(state), 

    25

    visible(visible), 

    26

    weapons(buildWeaponsList()), 

    27

    selectedWeapon(0), 

    28

    rope(*this),

    29

    health(PLAYER_HEALTH),

    30

    respawn_timer(PLAYER_RESPAWN_DELAY),

    31

    animation_step(0)

    32

{

    33

    // XXX: populate weapons from somewhere else

    34

    35

    // build the player's shape

    36

    // XXX: these dimensions are incorrect...

    37

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

    38

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

    39

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

    40

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

    41

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

    42

    43

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

    44

    setShape(shape);

    45

    46

    // add to GameState players list

    47

    state.addPlayer(this);

    48

    49

    // connect respawn timer

    50

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

    51

    52

    // spawn

    53

    spawn(position);

    54

}

    55

    56

Player::~Player (void) {

    57

    state.removePlayer(this);

    58

}

    59

    60

void Player::spawn (Vector position) {

    61

    // dig hole

    62

    world.removeGround(position, PLAYER_DIG_RADIUS);

    63

    64

    // update position

    65

    setPosition(position);

    66

    67

    // enable

    68

    enable();

    69

}

    70

    71

void Player::die (bool start_timer) {

    72

    // we don't have a rope anymore

    73

    rope.release();

    74

    75

    // disable our PhysicsObject

    76

    disable();

    77

    78

    // XXX: PhysicsObject::reset

    79

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

    80

    81

    if (start_timer) {

    82

        // start respawn timer

    83

        respawn_timer.fire_once();

    84

    }

    85

}

    86

    87

void Player::respawn (TimeMS dt) {

    88

    (void) dt;

    89

    90

    // reset health

    91

    health = PLAYER_HEALTH;

    92

    93

    // XXX: reload weapons

    94

    95

    // XXX: ...

    96

    spawn(Vector(PLAYER_INITIAL_X, PLAYER_INITIAL_Y));

    97

}

    98

    99

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

   100

    // calculate new position and velocity

   101

    Vector digPosition = pos + getDirection() * PROJECTILE_START_DISTANCE;

   102

   103

    // remove directly

   104

    world.removeGround(digPosition, radius);

   105

}

   106

   107

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

   108

    weaponFired(weapon);

   109

   110

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

   111

}

   112

   113

void Player::handleChangeWeapon (unsigned int weaponIndex) {

   114

    assert(weaponIndex < weapons.size());

   115

   116

    selectedWeapon = weaponIndex;

   117

}

   118

   119

void Player::weaponFired (Weapon *weapon) {

   120

    // apply recoil

   121

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

   122

   123

    // reload weapon

   124

    weapon->reload();

   125

}

   126

   127

void Player::printDebugInfo (void) {

   128

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

   129

}

   130

   131

void Player::tick (TimeMS dt) {

   132

    // let PhysicsObject execute

   133

    PhysicsObject::tick(dt);

   134

   135

    // tick current weapon reload

   136

    if (getCurrentWeapon())

   137

        getCurrentWeapon()->tickReload(dt);

   138

}

   139

   140

void Player::handleRopeState (RopeState state) {

   141

    (void) state;

   142

}

   143

   144

void Player::handleRopeLength (float length) {

   145

    (void) length;

   146

}

   147

   148

/*

   149

 * LocalPlayer

   150

 */

   151

void LocalPlayer::fireWeapon (Weapon *weapon) {

   152

    // calculate new position and velocity

   153

    Vector shotPosition = position + getDirection() * PROJECTILE_START_DISTANCE;

   154

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

   155

   156

    // execute

   157

    handleFireWeapon(weapon, shotPosition, shotVelocity);

   158

}

   159

   160

void LocalPlayer::changeWeapon (int delta) {

   161

    // need to handle negative deltas

   162

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

   163

}

   164

   165

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

   166

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

   167

    if (!isAlive())

   168

        return;

   169

   170

    // Movement force, vertical is always zero

   171

    Vector move_force = Vector(0, 0); 

   172

   173

    // Crosshair angle change

   174

    float aim_delta = 0; 

   175

   176

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

   177

    // also update facing if needed

   178

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

   179

        if (input & INPUT_MOVE_LEFT) {

   180

            if (velocity.x > -PLAYER_MAX_SPEED)

   181

                move_force.x -= PLAYER_MOVE_FORCE;

   182

   183

            setFacing(FACING_LEFT);

   184

        }

   185

   186

        if (input & INPUT_MOVE_RIGHT) {

   187

            if (velocity.x < PLAYER_MAX_SPEED)

   188

                move_force.x += PLAYER_MOVE_FORCE;

   189

   190

            setFacing(FACING_RIGHT);

   191

        }

   192

    }

   193

   194

    // handle aim by creating a aim angle delta

   195

    if (input & INPUT_AIM_UP)

   196

        aim_delta += CROSSHAIR_ANGLE_SPEED*dt;

   197

   198

    if (input & INPUT_AIM_DOWN)

   199

        aim_delta -= CROSSHAIR_ANGLE_SPEED*dt;

   200

   201

    // handle jumping by invoking the jump method

   202

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

   203

    if (input & INPUT_JUMP) {

   204

        if (input & INPUT_MOVE_LEFT)

   205

            jump(-1);

   206

   207

        else if (input & INPUT_MOVE_RIGHT)

   208

            jump(1);

   209

   210

        else

   211

            jump(0);

   212

    }

   213

   214

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

   215

    if (input & INPUT_DIG)

   216

        handleDig(position, PLAYER_DIG_RADIUS);

   217

   218

    // change weapon back/forth

   219

    if (input & INPUT_CHANGE_PREV)

   220

        changeWeapon(-1);

   221

   222

    if (input & INPUT_CHANGE_NEXT)

   223

        changeWeapon(+1);

   224

   225

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

   226

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

   227

        fireWeapon(getCurrentWeapon());

   228

   229

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

   230

    if (input & INPUT_ROPE)

   231

        rope.throwRope();

   232

   233

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

   234

        rope.release();

   235

   236

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

   237

        rope.changeLength(-ROPE_GROWTH_RATE);

   238

   239

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

   240

        rope.changeLength(ROPE_GROWTH_RATE);

   241

   242

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

   243

    if (move_force.x != 0) 

   244

        animation_step = (animation_step + 1) % img_num_step;

   245

   246

    // apply aim delta

   247

    if (aim_delta)

   248

        changeAim(aim_delta);

   249

   250

    // apply force

   251

    if (!move_force.zero())

   252

        applyForce(move_force, dt);

   253

   254

    // suicide?

   255

    if (input & INPUT_SUICIDE)

   256

        die();

   257

}

   258

   259

Weapon* Player::getCurrentWeapon() {

   260

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

   261

}

   262

   263

Weapon* Player::getWeapon (WeaponID id) {

   264

    if (id < weapons.size())

   265

        return weapons[id];

   266

    else

   267

        return NULL;

   268

}

   269

   270

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

   271

    (void) collisionPoint;

   272

   273

    if (other == NULL)

   274

        return;

   275

   276

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

   277

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

   278

    // XXX: not completely network-safe

   279

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

   280

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

   281

        this->bounce(normal);

   282

   283

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

   284

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

   285

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

   286

    }

   287

}

   288

   289

void Player::takeDamage (Health damage) {

   290

    health -= damage;

   291

   292

    if (health <= 0)

   293

        die();

   294

   295

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

   296

}

   297

   298

void Player::draw (Graphics *g, PixelCoordinate camera) {

   299

    CL_GraphicContext *gc = g->get_gc();

   300

   301

    if (!isAlive())

   302

        return;

   303

   304

    // animation indexes

   305

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

   306

    int step_img_idx = animation_step % img_num_step;

   307

   308

    // load skin image if not yet loaded

   309

    if (!skin_loaded) {

   310

        skin_surface = CL_Surface(PLAYER_SKIN_PATH);

   311

        skin_loaded = true;

   312

    }

   313

   314

    // calulate where to draw the worm

   315

    CL_Rectf destination(

   316

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

   317

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

   318

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

   319

        position.y + img_height / 2                                     - camera.y

   320

    );

   321

   322

    // draw the correct animation frame from the skin

   323

    skin_surface.draw_subpixel(

   324

        CL_Rectf(

   325

            step_img_idx * img_width, 

   326

            aim_img_idx * img_height, 

   327

            (1 + step_img_idx) * img_width, 

   328

            (aim_img_idx + 1) * img_height

   329

        ), destination, gc

   330

    );

   331

   332

    // draw a proper crosshair-box

   333

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

   334

   335

    gc->draw_rect(

   336

        CL_Rectf(

   337

            crosshair.x - PLAYER_CROSSHAIR_WIDTH / 2,

   338

            crosshair.y - PLAYER_CROSSHAIR_WIDTH / 2,

   339

            crosshair.x + PLAYER_CROSSHAIR_WIDTH / 2,

   340

            crosshair.y + PLAYER_CROSSHAIR_WIDTH / 2

   341

        ), CL_Color::red

   342

    );

   343

   344

    // draw rope

   345

    rope.draw(g, camera);

   346

}

   347

   348

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

   349

    // superclass draw

   350

    Player::draw(g, camera);

   351

   352

    // display weapon name?

   353

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

   354

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

   355

   356

        PixelCoordinate pc = getCoordinate() - camera;

   357

   358

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

   359

        g->getSimpleFont().draw(

   360

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

   361

                pc.y - 20,

   362

                weaponName,

   363

                g->get_gc()

   364

        );

   365

    }

   366

}

   367