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

    30

    animation_step(0)

    31

{

    32

    // XXX: populate weapons from somewhere else

    33

    34

    // build the player's shape

    35

    // XXX: these dimensions are incorrect...

    36

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

    37

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

    38

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

    39

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

    40

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

    41

    42

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

    43

    setShape(shape);

    44

    45

    // add to GameState players list

    46

    state.addPlayer(this);

    47

}

    48

    49

Player::~Player (void) {

    50

    state.removePlayer(this);

    51

}

    52

    53

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

    54

    // calculate new position and velocity

    55

    Vector digPosition = pos + getDirection() * PROJECTILE_START_DISTANCE;

    56

    57

    // remove directly

    58

    world.removeGround(digPosition, radius);

    59

}

    60

    61

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

    62

    weaponFired(weapon);

    63

    64

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

    65

}

    66

    67

void Player::handleChangeWeapon (unsigned int weaponIndex) {

    68

    assert(weaponIndex < weapons.size());

    69

    70

    selectedWeapon = weaponIndex;

    71

}

    72

    73

void Player::weaponFired (Weapon *weapon) {

    74

    // apply recoil

    75

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

    76

    77

    // reload weapon

    78

    weapon->reload();

    79

}

    80

    81

void Player::printDebugInfo (void) {

    82

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

    83

}

    84

    85

void Player::tick (TimeMS dt) {

    86

    // let PhysicsObject execute

    87

    PhysicsObject::tick(dt);

    88

    89

    // tick current weapon reload

    90

    if (getCurrentWeapon())

    91

        getCurrentWeapon()->tickReload(dt);

    92

}

    93

    94

void Player::handleRopeState (RopeState state) {

    95

    (void) state;

    96

}

    97

    98

void Player::handleRopeLength (float length) {

    99

    (void) length;

   100

}

   101

   102

void LocalPlayer::fireWeapon (Weapon *weapon) {

   103

    // calculate new position and velocity

   104

    Vector shotPosition = position + getDirection() * PROJECTILE_START_DISTANCE;

   105

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

   106

   107

    // execute

   108

    handleFireWeapon(weapon, shotPosition, shotVelocity);

   109

}

   110

   111

void LocalPlayer::changeWeapon (int delta) {

   112

    // need to handle negative deltas

   113

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

   114

}

   115

   116

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

   117

    // Movement force, vertical is always zero

   118

    Vector move_force = Vector(0, 0); 

   119

   120

    // Crosshair angle change

   121

    float aim_delta = 0; 

   122

   123

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

   124

    // also update facing if needed

   125

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

   126

        if (input & INPUT_MOVE_LEFT) {

   127

            if (velocity.x > -PLAYER_MAX_SPEED)

   128

                move_force.x -= PLAYER_MOVE_FORCE;

   129

   130

            setFacing(FACING_LEFT);

   131

        }

   132

   133

        if (input & INPUT_MOVE_RIGHT) {

   134

            if (velocity.x < PLAYER_MAX_SPEED)

   135

                move_force.x += PLAYER_MOVE_FORCE;

   136

   137

            setFacing(FACING_RIGHT);

   138

        }

   139

    }

   140

   141

    // handle aim by creating a aim angle delta

   142

    if (input & INPUT_AIM_UP)

   143

        aim_delta += CROSSHAIR_ANGLE_SPEED*dt;

   144

   145

    if (input & INPUT_AIM_DOWN)

   146

        aim_delta -= CROSSHAIR_ANGLE_SPEED*dt;

   147

   148

    // handle jumping by invoking the jump method

   149

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

   150

    if (input & INPUT_JUMP) {

   151

        if (input & INPUT_MOVE_LEFT)

   152

            jump(-1);

   153

   154

        else if (input & INPUT_MOVE_RIGHT)

   155

            jump(1);

   156

   157

        else

   158

            jump(0);

   159

    }

   160

   161

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

   162

    if (input & INPUT_DIG)

   163

        handleDig(position, 15);

   164

   165

    // change weapon back/forth

   166

    if (input & INPUT_CHANGE_PREV)

   167

        changeWeapon(-1);

   168

   169

    if (input & INPUT_CHANGE_NEXT)

   170

        changeWeapon(+1);

   171

   172

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

   173

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

   174

        fireWeapon(getCurrentWeapon());

   175

   176

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

   177

    if (input & INPUT_ROPE)

   178

        rope.throwRope();

   179

   180

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

   181

        rope.release();

   182

   183

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

   184

        rope.changeLength(-ROPE_GROWTH_RATE);

   185

   186

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

   187

        rope.changeLength(ROPE_GROWTH_RATE);

   188

   189

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

   190

    if (move_force.x != 0) 

   191

        animation_step = (animation_step + 1) % img_num_step;

   192

   193

    // apply aim delta

   194

    if (aim_delta)

   195

        changeAim(aim_delta);

   196

   197

    // apply force

   198

    if (!move_force.zero())

   199

        applyForce(move_force, dt);

   200

}

   201

   202

Weapon* Player::getCurrentWeapon() {

   203

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

   204

}

   205

   206

Weapon* Player::getWeapon (WeaponID id) {

   207

    if (id < weapons.size())

   208

        return weapons[id];

   209

    else

   210

        return NULL;

   211

}

   212

   229

void Player::takeDamage(int damage) {

   235

}

   236

   237

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

   238

    CL_GraphicContext *gc = g->get_gc();

   239

   240

    // animation indexes

   241

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

   242

    int step_img_idx = animation_step % img_num_step;

   243

   244

    // load skin image if not yet loaded

   245

    if (!skin_loaded) {

   246

        skin_surface = CL_Surface(PLAYER_SKIN_PATH);

   247

        skin_loaded = true;

   248

    }

   249

   250

    // calulate where to draw the worm

   251

    CL_Rectf destination(

   252

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

   253

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

   254

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

   255

        position.y + img_height / 2                                     - camera.y

   256

    );

   257

   258

    // draw the correct animation frame from the skin

   259

    skin_surface.draw_subpixel(

   260

        CL_Rectf(

   261

            step_img_idx * img_width, 

   262

            aim_img_idx * img_height, 

   263

            (1 + step_img_idx) * img_width, 

   264

            (aim_img_idx + 1) * img_height

   265

        ), destination, gc

   266

    );

   267

   268

    // draw a proper crosshair-box

   269

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

   270

   271

    gc->draw_rect(

   272

        CL_Rectf(

   273

            crosshair.x - PLAYER_CROSSHAIR_WIDTH / 2,

   274

            crosshair.y - PLAYER_CROSSHAIR_WIDTH / 2,

   275

            crosshair.x + PLAYER_CROSSHAIR_WIDTH / 2,

   276

            crosshair.y + PLAYER_CROSSHAIR_WIDTH / 2

   277

        ), CL_Color::red

   278

    );

   279

   280

    // draw rope

   281

    rope.draw(g, camera);

   282

}

   283

   284

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

   285

    // superclass draw

   286

    Player::draw(g, camera);

   287

   288

    // display weapon name?

   289

    if (displayWeapon && getCurrentWeapon()) {

   290

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

   291

   292

        PixelCoordinate pc = getCoordinate() - camera;

   293

   294

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

   295

        g->getSimpleFont().draw(

   296

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

   297

                pc.y - 20,

   298

                weaponName,

   299

                g->get_gc()

   300

        );

   301

    }

   302

}

   303