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 "Input.hh"

    13

#include "Rope.hh"

    14

#include "GraphicsPointer.hh"

    15

#include "Types.hh"

    16

#include <vector>

    17

    18

/**

    19

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

    20

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

    21

 */

    22

class Player : public PhysicsObject {

    23

    friend class Rope;

    24

    25

public:

    26

    GameState &state;

    27

    28

protected:

    29

    // XXX: not used

    30

    bool visible;

    31

    32

    // our weapons

    33

    std::vector<Weapon*> weapons;

    34

    35

    // the index of the currently selected weapon

    36

    unsigned int selectedWeapon;

    37

    38

    // we have a rope

    39

    Rope rope;

    40

    41

    /** Our current health */

    42

    Health health;

    43

    44

    /** Our respawn-timer */

    45

    Timer respawn_timer;

    46

    CL_Slot respawn_slot;

    47

    49

    int animation_step;

    50

    51

    //Player stats

    52

    uint16_t kills;

    53

    uint16_t deaths;

    54

    55

    /**

    56

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

    57

     */

    58

    Player (void);

    59

    60

    /**

    61

     * Initialize params, and add ourselves to GameState

    62

     */

    63

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

    64

    65

    /**

    66

     * Remove player from state players list

    67

     */

    68

    ~Player (void);

    69

    70

    /**

    71

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

    72

     */

    73

    virtual void spawn (Vector position);

    74

    75

    /**

    76

     * We die. Disable and prepare respawn_timer

    77

     */

    78

    virtual void die (bool start_timer = true);

    79

    80

    /**

    81

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

    82

     */

    83

    virtual void respawn (TimeMS dt);

    84

    85

    /**

    86

     *  Used by the network code to execute various actions

    87

     */

    88

    virtual void handleDig (Vector position, float radius);

    89

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

    90

    virtual void handleChangeWeapon (unsigned int weaponIndex);

    91

    92

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

    93

    virtual void handleRopeState (RopeState state);

    94

    virtual void handleRopeLength (float length);

    95

    96

public:

    97

    /**

    98

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

    99

     */

   100

    void weaponFired (Weapon *weapon);

   101

   102

    /**

   103

     * Get the currently selected weapon

   104

     *

   105

     * @return A pointer to the Weapon object

   106

     */

   107

    Weapon* getCurrentWeapon();

   108

   109

    /**

   110

     * Get the weapon with the given index

   111

     *

   112

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

   113

     */

   114

    Weapon* getWeapon (WeaponID id);

   115

   116

    /**

   117

     * Prints random things via Engine::log

   118

     */

   119

    void printDebugInfo ();

   120

   121

    /**

   122

     * Overrides PhysicsObject::tick to also advance game state

   123

     */

   124

    virtual void tick (TimeMS dt);

   125

   126

    /**

   127

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

   128

     */

   129

    void onCollision (Vector collisionPoint, PhysicsObject *other);

   130

   131

    /**

   132

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

   133

     *

   134

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

   135

     */

   136

    void takeDamage (Projectile *source);

   137

   138

    /**

   139

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

   140

     */

   141

    Vector getPivotForce (void);

   142

   143

    /**

   144

     * Gives player's health in percents from maximum

   145

     */

   146

    float getHealthPercent() const;

   147

   148

    /**

   149

     * Increment player killcounter by one.

   150

     */

   151

    void addKill ();

   152

   153

    /*

   154

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

   155

     */

   156

    static bool skin_loaded;

   157

    static CL_Surface skin_surface;

   158

    virtual void draw (Graphics *g, PixelCoordinate camera);

   159

   160

    uint16_t getKills() { return kills; }

   161

    uint16_t getDeaths() { return deaths; }

   162

};

   163

   164

/**

   165

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

   166

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

   167

 *

   168

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

   169

 */

   170

class LocalPlayer : public virtual Player {

   171

private:

   172

    /**

   173

     * Calculates projectil position/velocity and calls handleCreateProjectile

   174

     */

   175

    void fireWeapon (Weapon *weapon);

   176

   177

    /**

   178

     * Change weapon index, should be negative or positive 1

   179

     */

   180

    void changeWeapon (int delta);

   181

   182

public:

   183

    /**

   184

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

   185

     *

   186

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

   187

     */

   188

    virtual void handleInput (PlayerInput input, TimeMS dt);

   189

   190

    /**

   191

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

   192

     */

   193

    virtual void draw (Graphics *g, bool displayWeapon, PixelCoordinate camera);

   194

};

   195

   196

/**

   197

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

   198

 *

   199

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

   200

 */

   201

   202

class RemotePlayer : public virtual Player {

   203

protected:

   204

};

   205

   206

   207

#endif