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

    10

#include "PhysicsObject.hh"

    11

#include "Input.hh"

    12

#include "Rope.hh"

    13

#include "GraphicsPointer.hh"

    14

#include <vector>

    15

    16

/**

    17

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

    18

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

    19

 */

    20

class Player : public PhysicsObject {

    21

    friend class Rope;

    22

    23

public:

    24

    GameState &state;

    25

    26

protected:

    27

    // XXX: not used

    28

    bool visible;

    29

    30

    // our weapons

    31

    std::vector<Weapon*> weapons;

    32

    33

    // the index of the currently selected weapon

    34

    unsigned int selectedWeapon;

    35

    36

    // we have a rope

    37

    Rope rope;

    38

    39

    // XXX: hmm... updated where?

    40

    int animation_step;

    41

    42

    /**

    43

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

    44

     */

    45

    Player (void);

    46

    47

    /**

    48

     * Initialize params, and add ourselves to GameState

    49

     */

    50

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

    51

    52

    /**

    53

     * Remove player from state players list

    54

     */

    55

    ~Player (void);

    56

    57

    /*

    58

     *  Used by the network code to execute various actions

    59

     */

    60

    virtual void handleDig (Vector position, float radius);

    61

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

    62

    virtual void handleChangeWeapon (unsigned int weaponIndex);

    63

    64

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

    65

    virtual void handleRopeState (RopeState state);

    66

    virtual void handleRopeLength (float length);

    67

    68

public:

    69

    /**

    70

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

    71

     */

    72

    void weaponFired (Weapon *weapon);

    73

    74

    /**

    75

     * Get the currently selected weapon

    76

     *

    77

     * @return A pointer to the Weapon object

    78

     */

    79

    Weapon* getCurrentWeapon();

    80

    81

    /**

    82

     * Get the weapon with the given index

    83

     *

    84

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

    85

     */

    86

    Weapon* getWeapon (WeaponID id);

    87

    88

    /*

    89

     * Prints random things via Engine::log

    90

     */

    91

    void printDebugInfo ();

    92

    93

    /*

    94

     * Overrides PhysicsObject::tick to also advance game state

    95

     */

    96

    virtual void tick (TimeMS dt);

    97

    98

    /*

    99

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

   100

     */

   101

    static bool skin_loaded;

   102

    static CL_Surface skin_surface;

   103

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

   104

};

   105

   106

/**

   107

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

   108

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

   109

 *

   110

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

   111

 */

   112

class LocalPlayer : public virtual Player {

   113

private:

   114

    /*

   115

     * Calculates projectil position/velocity and calls handleCreateProjectile

   116

     */

   117

    void fireWeapon (Weapon *weapon);

   118

   119

    /*

   120

     * Change weapon index, should be negative or positive 1

   121

     */

   122

    void changeWeapon (int delta);

   123

   124

public:

   125

    /*

   126

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

   127

     *

   128

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

   129

     */

   130

    virtual void handleInput (PlayerInput input, TimeMS dt);

   131

   132

    /*

   133

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

   134

     */

   135

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

   136

};

   137

   138

/**

   139

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

   140

 *

   141

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

   142

 */

   143

   144

class RemotePlayer : public virtual Player {

   145

protected:

   146

};

   147

   148

   149

#endif