1

     2

#include "GameState.hh"

     3

#include "Engine.hh"

     4

#include "Config.hh"

     5

     6

/**

     7

 * shoots the selected weapon.

     8

 * TODO: selection and weapon information

     9

 */

    10

void Player::shoot (void) {

    11

    // here should be somehow considered which projectile it is

    12

    if(!canShoot())

    13

        return;

    14

    reloadTimer += 0;

    15

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

    16

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

    17

    float shotspeed = 100*PHYSICS_TICK_MS;

    18

    Vector shotRelativeVelocity = unitVectorAim * shotspeed;

    19

    Vector shotVelocity = this->velocity + shotRelativeVelocity;

    20

    this->state.addProjectile(new Shot(this->state, this->position, shotVelocity, true));

    21

}

    22

    23

void Player::handleMove (PlayerInput_Move input) {

    24

    float fx = 0; // Force in x-direction

    25

    float da = 0; // Crosshair angle

    26

    27

    // handle left/right

    28

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

    29

        fx -= PLAYER_MOVE_FORCE;

    30

    31

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

    32

        fx += PLAYER_MOVE_FORCE;

    33

    34

    if (input & INPUT_MOVE_UP)

    35

        da += CROSSHAIR_ANGLE_SPEED;

    36

    37

    if (input & INPUT_MOVE_DOWN)

    38

        da -= CROSSHAIR_ANGLE_SPEED;

    39

    40

    if (input & INPUT_MOVE_JUMP) {

    41

        if ((input & INPUT_MOVE_LEFT))

    42

            jump(-1);

    43

        else if ((input & INPUT_MOVE_RIGHT))

    44

            jump(1);

    45

        else

    46

            jump(0);

    47

    }

    48

    49

    if (input & INPUT_MOVE_DIG) {

    50

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

    51

        // but it doesn't.

    52

        // But this now just segfaults

    53

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

    54

    55

        world.removeGround(position, 15);

    56

    }

    57

    58

    if (input & INPUT_SHOOT) {

    59

        this->shoot();

    60

    }

    74

}

    75

    76

void Player::debugInfo (void) {

    77

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

    78

}

    79

    80

void Shot::onCollision() {

    81

    world.removeGround(position, 20);

    82

}

    83

    84

void Shot::draw(CL_GraphicContext *gc) {

    85

    86

    87

    CL_Quad player(

    88

                   (position).x+1, (position).y+1,

    89

                   (position).x-1, (position).y+1,

    90

                   (position).x+1, (position).y-1,

    91

                   (position).x-1, (position).y-1

    92

                   );

    93

    94

    gc->fill_quad(player, CL_Color::green);

    95

    96

    const uint16_t chlen = 10;

    97

    uint16_t x = player.center().x;

    98

    uint16_t y = player.center().y;

    99

    if(target_visible) {

   100

        if (facingRight) {

   101

            gc->draw_line(x, y,

   102

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

   103

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

   104

                          CL_Color::black);

   105

        } else {

   106

            gc->draw_line(x, y,

   107

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

   108

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

   109

                          CL_Color::black);

   110

        }

   111

    }

   112

}

   113