1

#ifndef GAMESTATE_HH

     2

#define GAMESTATE_HH

     3

     4

#include "Physics.hh"

     5

#include "Input.hh"

     6

     7

#include <list>

     8

#include <stdexcept>

     9

    10

// in cells/kg

    11

const uint16_t MAP_WIDTH = 800;

    12

const uint16_t MAP_HEIGHT = 600;

    13

const float MAP_GRAVITY = 1200.0;

    14

const float PLAYER_MASS = 10.0;

    15

const float PLAYER_MOVE_FORCE = 5000.0;

    16

const float PLAYER_INITIAL_X = 400.0;

    17

const float PLAYER_INITIAL_Y = 300.0;

    18

    19

// forward-declare GameState

    20

class GameState;

    21

    22

class Player : public PhysicsObject {

    23

    protected:

    24

        GameState &state;

    25

        bool visible;

    26

    27

    public:

    28

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

    29

            PhysicsObject((PhysicsWorld &) state, PLAYER_MASS, position, Vector(0, 0)), state(state), visible(visible) {

    30

    31

			std::vector<Vector> shape(4);

    32

			shape[0] = Vector(0,-18);

    33

			shape[1] = Vector(6,-9);

    34

			shape[2] = Vector(0,0); 

    35

			shape[3] = Vector(-6,-9);

    36

			// Initialize the shape of the player (salmiakki shape)

    37

			setShape(shape);		

    38

		}

    39

    40

		void debugInfo ();

    41

    42

    public:

    43

        virtual void handleMove (PlayerInput_Move input);

    44

};

    45

    46

class LocalPlayer : public Player {

    47

    protected:

    48

        LocalPlayer (GameState &state, Vector pos, bool visible) : Player(state, pos, visible) { }

    49

};

    50

    51

class RemotePlayer : public Player {

    52

    protected:

    53

        RemotePlayer (GameState &state, Vector pos, bool visible) : Player(state, pos, visible) { }

    54

};

    55

    56

class GameState : public PhysicsWorld {

    57

    public:

    58

        std::list<Player*> player_list;

    59

    60

        // only one local player is supported

    61

        LocalPlayer *local_player;

    62

    63

        GameState (void) : PhysicsWorld(Vector(0, MAP_GRAVITY), Vector(MAP_WIDTH, MAP_HEIGHT)), local_player(NULL) {

    64

    65

        }

    66

    67

        /*

    68

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

    69

         */

    70

        LocalPlayer *getLocalPlayer (void) {

    71

            return local_player;

    72

        }

    73

    74

        void newLocalPlayer (LocalPlayer *player) {

    75

            if (local_player)

    76

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

    77

    78

            player_list.push_back(player);

    79

    80

            local_player = player;

    81

        }

    82

    83

        void newRemotePlayer (RemotePlayer *player) {

    84

            player_list.push_back(player);

    85

        }

    86

    87

        void removePlayer (Player *player) {

    88

            player_list.remove(player);

    89

        }

    90

};

    91

    92

#endif