1

#ifndef PROJECTILE_HH

     2

#define PROJECTILE_HH

     3

     4

class Projectile;

     5

     6

#include "GameState.hh"

     7

#include "Player.hh"

     8

#include "PhysicsObject.hh"

     9

#include "Timer.hh"

    10

#include "Types.hh"

    11

    12

#include "Graphics/Drawable.hh"

    13

    14

/**

    15

 * A projectile is a flying PhysicsObject, created by firing a player's weapon. It has an initial velocity, is

    16

 * represented as a diamond-shape with the given "radius", can explode or bounce on collisions, expires at some point,

    17

 * and can remove ground around it upon exploding.

    18

 */

    19

class Projectile : public PhysicsObject {

    20

protected:

    21

    /**

    22

     * Which player fired this projectile?

    23

     */

    24

    Player *player;

    25

    26

    /**

    27

     * Projectiles can be inivisble, e.g. for digging

    28

     */

    29

    bool visible;

    30

    31

    Weapon *weapon;

    32

    33

    /**

    34

     * The tick we were spawned at

    35

     */

    36

    TickCount birth_tick;

    37

    38

public:

    39

    /**

    40

     * Constructs this projectile using the given position/velocity, pulling the rest of the parameter values from the

    41

     * given weapon. The given player is assigned to this projectile. 

    42

     */

    43

    Projectile (Player *player, Vector position, Vector velocity, Weapon *weapon, bool visible = true);

    44

    45

    /**

    46

     * Removes this from the world's list of projectiles

    47

     */

    48

    virtual ~Projectile (void);

    49

    50

    /**

    51

     * Get damage inflicted by this projectile.

    52

     *

    53

     * @return Damage inflicted by projectile.

    54

     */

    55

    Health getDamage (void);

    56

    57

    /**

    58

     * Adds one kill to projectile owner.

    59

     */

    60

    void addKillToOwner (void);

    61

    62

    /**

    63

     * Return the owner of the projectile.

    64

     */

    65

    const Player* getOwner (void) const {

    66

        return player;

    67

    }

    68

    69

    /**

    70

     * Return the weapon that fired this Projectile

    71

     */

    72

    const Weapon* getWeapon (void) const {

    73

        return weapon;

    74

    }

    75

    76

protected:

    77

    /**

    78

     * Removes ground at given position if applicable, and destroys this PhysicsObject.

    79

     *

    80

     * This is overriden by Network.

    81

     */

    82

    virtual void onDestroy (Vector position, bool removeGround);

    83

    84

    /**

    85

     * This Projectile has hit the given player.

    86

     *

    87

     * This Projectile inflicts a certain amount of damage on the player. We are not destroyed, this can be called

    88

     * multiple times...

    89

     */

    90

    virtual void onHitPlayer (Player *player);

    91

    92

    /**

    93

     * Call onDestroy, removingGround

    94

     */

    95

    virtual void onCollision (Vector collisionPoint, PhysicsObject *other);

    96

    97

    /**

    98

     * If we have expired, call onDestory and removeGround

    99

     */

   100

    virtual void tick (TimeMS dt);

   101

   102

public:

   103

   104

#if GRAPHICS_ENABLED    

   105

    /**

   106

     * Draw

   107

     */

   108

    virtual void draw (graphics::Display &display, PixelCoordinate camera) const;

   109

   110

#endif

   111

   112

   113

};

   114

   115

#endif