1

#ifndef PLAYER_HH

     2

#define PLAYER_HH

     3

     4

class Player;

     5

class LocalPlayer;

     6

class RemotePlayer;

     7

     8

#include "Weapon.hh"

     9

#include "Projectile.hh"

    10

#include "GameState.hh"

    11

#include "PhysicsObject.hh"

    12

#include "Rope.hh"

    13

#include "Types.hh"

    14

#include "Input.hh"

    15

    16

#include "Graphics/Drawable.hh"

    17

    18

#include <vector>

    19

    20

/**

    21

 * A Player is a PhysicsObject that represents a player - a remote client on the server, a local singleplayer player, a

    22

 * local network-client player, a remote network-client player, etc.

    23

 */

    24

class Player : public PhysicsObject {

    25

    friend class Rope;

    26

    27

public:

    28

    GameState &state;

    29

    30

protected:

    31

    // XXX: not used

    32

    bool visible;

    33

    34

    // our weapons

    35

    std::vector<Weapon*> weapons;

    36

    37

    // the index of the currently selected weapon

    38

    unsigned int selectedWeapon;

    39

    40

    // we have a rope

    41

    Rope rope;

    42

    43

    /** Our current health */

    44

    Health health;

    45

    46

    /** Our respawn-timer */

    47

    Timer respawn_timer;

    48

    CL_Slot respawn_slot;

    49

    50

    // XXX: updated where?

    51

    int animation_step;

    52

    53

    //Player stats

    54

    uint16_t kills;

    55

    uint16_t deaths;

    56

    57

    /**

    58

     * Default constructor for use with virtual inheritance... it's not defined, and must not be called

    59

     */

    60

    Player (void);

    61

    62

    /**

    63

     * Initialize params, and add ourselves to GameState

    64

     */

    65

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

    66

    67

    /**

    68

     * Remove player from state players list

    69

     */

    70

    ~Player (void);

    71

    72

    /**

    73

     * Move the worm to the given position, removeGround to dig a hole there, and enable ourselves

    74

     */

    75

    virtual void spawn (Vector position);

    76

    77

    /**

    78

     * We die. Disable and prepare respawn_timer

    79

     */

    80

    virtual void die (bool start_timer = true);

    81

    82

    /**

    83

     * Calculate a new position for the worm, and respawn there. Also set health back to 100%

    84

     */

    85

    virtual void respawn (TimeMS dt);

    86

    87

    /**

    88

     *  Used by the network code to execute various actions

    89

     */

    90

    virtual void handleDig (Vector position, float radius);

    91

    virtual void handleFireWeapon (Weapon *weapon, Vector position, Vector velocity);

    92

    virtual void handleChangeWeapon (unsigned int weaponIndex);

    93

    94

    // Called by rope to handle state changes, these don't do anything by default

    95

    virtual void handleRopeState (RopeState state);

    96

    virtual void handleRopeLength (float length);

    97

    98

public:

    99

    /**

   100

     * Called when a weapon is fired, this should apply recoil and reload the weapon

   101

     */

   102

    void weaponFired (Weapon *weapon);

   103

   104

    /**

   105

     * Get the currently selected weapon

   106

     *

   107

     * @return A pointer to the Weapon object

   108

     */

   109

    Weapon* getCurrentWeapon();

   110

   111

    /**

   112

     * Get the weapon with the given index

   113

     *

   114

     * @return A pointer to a Weapon object if found, NULL otherwise

   115

     */

   116

    Weapon* getWeapon (WeaponID id);

   117

   118

    /**

   119

     * Prints random things via Engine::log

   120

     */

   121

    void printDebugInfo ();

   122

   123

    /**

   124

     * Overrides PhysicsObject::tick to also advance game state

   125

     */

   126

    virtual void tick (TimeMS dt);

   127

   128

    /**

   129

     * This is called when the player collides with the terrain or with some other object.

   130

     */

   131

    void onCollision (Vector collisionPoint, PhysicsObject *other);

   132

   133

    /**

   134

     * We have been hit by something, and therefore take some damage.

   135

     *

   136

     * XXX: should this take the Projectile instead or somesuch?

   137

     */

   138

    void takeDamage (Projectile *source);

   139

   140

    /**

   141

     * If the player has a pivot calculate the force it causes.

   142

     */

   143

    Vector getPivotForce (void);

   144

   145

    /**

   146

     * Gives player's health in percents from maximum

   147

     */

   148

    float getHealthPercent() const;

   149

   150

    /**

   151

     * Increment player killcounter by one.

   152

     */

   153

    void addKill ();

   154

   155

#if GRAPHICS_ENABLED    

   156

    /*

   157

     * Drawing requires the skin texture, which is loaded on-demand when draw is called

   158

     */

   159

    static bool skin_loaded;

   160

    static CL_Surface skin_surface;

   161

   162

    /**

   163

     * Draw this player

   164

     */

   165

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

   166

#endif

   167

   168

    /**

   169

     * Returns statistics on the number of kills for this player

   170

     */

   171

    uint16_t getKills() { return kills; }

   172

   173

    /**

   174

     * Returns statistics on the number of deaths for this player

   175

     */

   176

    uint16_t getDeaths() { return deaths; }

   177

};

   178

   179

/**

   180

 * A LocalPlayer is a Player that we handle input for - so this is our own player on the client/singleplayer, or all

   181

 * the remote clients on a server - the name is a bit misleading.

   182

 *

   183

 * This inherits virtually from Player so that subclasses can also define custom behaviour for the base Player class.

   184

 */

   185

class LocalPlayer : public virtual Player {

   186

private:

   187

    /**

   188

     * Calculates projectil position/velocity and calls handleCreateProjectile

   189

     */

   190

    void fireWeapon (Weapon *weapon);

   191

   192

    /**

   193

     * Change weapon index, should be negative or positive 1

   194

     */

   195

    void changeWeapon (int delta);

   196

   197

public:

   198

    /**

   199

     * Called to invoke some action on this player that we control, either by Graphics or NetworkServer.

   200

     *

   201

     * NetworkClientLocalPlayer overrides this to send the input to the server, which then handles it

   202

     */

   203

    virtual void handleInput (PlayerInput input, TimeMS dt);

   204

   205

#if GRAPHICS_ENABLED    

   206

    /**

   207

     * As Player, but also draws the current weapon name if displayWeapon

   208

     */

   209

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

   210

#endif    

   211

};

   212

   213

/**

   214

 * A RemotePlayer is a Player that we don't handle input for - they are a remote client connected to a remote server.

   215

 *

   216

 * This inherits virtually from Player so that subclasses can also define custom behaviour for the base Player class.

   217

 */

   218

   219

class RemotePlayer : public virtual Player {

   220

protected:

   221

};

   222

   223

   224

#endif