1

#ifndef GAMESTATE_HH

     2

#define GAMESTATE_HH

     3

     4

#include "Dimension.hh"

     5

     6

#include <list>

     7

#include <stdexcept>

     8

     9

enum PlayerType {

    10

    PLAYER_LOCAL,

    11

    PLAYER_REMOTE

    12

};

    13

    14

#define PLAYER_DIM_W 10

    15

#define PLAYER_DIM_H 10

    16

#define MAP_DIM_W 800

    17

#define MAP_DIM_H 640

    18

    19

// forward-declare GameState

    20

class GameState;

    21

    22

class Player {

    23

    protected:

    24

        Coordinate position;

    25

    26

        GameState &state;

    27

    28

    public:

    29

    30

        Player(GameState &state, Coordinate c, bool visible) : position(c), state(state), dimensions(PLAYER_DIM_W, PLAYER_DIM_H), visible(visible) {}

    31

    32

        PlayerType type;

    33

        Dimension dimensions;

    34

        bool visible;

    35

    36

        Coordinate getPosition (void) const {

    37

            return position;

    38

        }

    39

    40

    protected:

    41

        /*

    42

         * Update position to the given value.

    43

         *

    44

         * Returns true if valid move (not out of bounds), false otherwise (doesn't change position)

    45

         */

    46

        bool updatePosition (Coordinate p);

    47

    48

};

    49

    50

class LocalPlayer : public Player {

    51

    protected:

    52

        LocalPlayer (GameState &state, Coordinate c, bool visible) : Player(state, c, visible) { }

    53

    54

    public:

    55

        virtual bool move (PositionDelta d) {

    56

            return updatePosition(position + d);

    57

        }

    58

};

    59

    60

class RemotePlayer : public Player {

    61

    protected:

    62

        RemotePlayer (GameState &state, Coordinate c, bool visible) : Player(state, c, visible) { }

    63

    64

};

    65

    66

class GameState {

    67

    public:

    68

        Dimension map_dimensions;

    69

        std::list<Player*> player_list;

    70

    71

        // only one local player is supported

    72

        LocalPlayer *local_player;

    73

    74

        GameState (void) : map_dimensions(MAP_DIM_W, MAP_DIM_H), local_player(NULL) {

    75

    76

        }

    77

    78

        /*

    79

         * Check if the given coordinate is valid

    80

         */

    81

        bool isValidCoordinate (const Coordinate &p) {

    82

            // unsigned...

    83

            return !(p.x > map_dimensions.w || p.y > map_dimensions.h);

    84

        }

    85

    86

        /*

    87

         * This will return NULL if we don't have a local player - yet

    88

         */

    89

        LocalPlayer *getLocalPlayer (void) {

    90

            return local_player;

    91

        }

    92

    93

        void newLocalPlayer (LocalPlayer *player) {

    94

            if (local_player)

    95

                throw std::logic_error("newLocalPlayer called even though we already have a local player");

    96

    97

            player_list.push_back(player);

    98

    99

            local_player = player;

   100

        }

   101

   102

        void newRemotePlayer (RemotePlayer *player) {

   103

            player_list.push_back(player);

   104

        }

   105

   106

        void removePlayer (Player *player) {

   107

            player_list.remove(player);

   108

        }

   109

};

   110

   111

#endif