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

class Player : public PhysicsObject {

    17

    friend class Rope;

    18

    19

    public:

    20

        GameState &state;

    21

    22

    protected:

    23

        // XXX: not used

    24

        bool visible;

    25

    26

        // our weapons

    27

        std::vector<Weapon*> weapons;

    28

    29

        // the index of the currently selected weapon

    30

        unsigned int selectedWeapon;

    31

    32

        // we have a rope

    33

        Rope rope;

    34

    35

        // XXX: hmm... updated where?

    36

        int animation_step;

    37

    38

        // default constructor for use with virtual inheritance... it's not defined

    39

        Player (void);

    40

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

    41

    42

        /*

    43

         *  Used by the network code to execute various actions

    44

         */

    45

        virtual void handleDig (Vector position, float radius);

    46

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

    47

        virtual void handleChangeWeapon (unsigned int weaponIndex);

    48

    49

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

    50

        virtual void handleRopeState (RopeState state);

    51

        virtual void handleRopeLength (float length);

    52

    53

        /*

    54

         * The currently selected weapon

    55

         */

    56

        Weapon* getCurrentWeapon();

    57

    58

    public:

    59

        /*

    60

         * Prints random things via Engine::log

    61

         */

    62

        void printDebugInfo ();

    63

    64

        /*

    65

         * Overrides PhysicsObject::tick to also advance game state

    66

         */

    67

        virtual void tick (TimeMS dt);

    68

    69

        /*

    70

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

    71

         */

    72

        static bool skin_loaded;

    73

        static CL_Surface skin_surface;

    74

        virtual void draw (Graphics *g, Vector camera = Vector(0, 0));

    75

};

    76

    77

class LocalPlayer : public virtual Player {

    78

    private:

    79

        /*

    80

         * Calculates projectil position/velocity and calls handleCreateProjectile

    81

         */

    82

        void fireWeapon (Weapon *weapon);

    83

    84

        /*

    85

         * Change weapon index, should be negative or positive 1

    86

         */

    87

        void changeWeapon (int delta);

    88

    89

    public:

    90

        /*

    91

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

    92

         *

    93

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

    94

         */

    95

        virtual void handleInput (PlayerInput input);

    96

    97

        /*

    98

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

    99

         */

   100

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

   101

};

   102

   103

class RemotePlayer : public virtual Player {

   104

    protected:

   105

};

   106

   107

   108

#endif