1

#ifndef GAMESTATE_HH

     2

#define GAMESTATE_HH

     3

     4

#include "Physics.hh"

     5

#include "Input.hh"

     7

     8

#include <list>

     9

#include <stdexcept>

    10

#include <cmath>

    11

    12

// forward-declare GameState

    13

class GameState;

    14

    15

class Player : public PhysicsObject {

    16

protected:

    17

    GameState &state;

    18

    bool visible;

    19

    20

public:

    21

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

    22

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

    23

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

        setShape(shape);		

    31

    }

    32

    33

    void debugInfo ();

    34

    35

public:

    36

    virtual void handleMove (PlayerInput_Move input);

    37

    38

    39

};

    40

    41

class Shot : public PhysicsObject {

    42

protected:

    43

    GameState &state;

    44

    bool visible;

    45

    uint32_t birth_tick;

    46

    uint32_t death_tick;

    47

public:

    48

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

    49

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

    50

        // Looks kind of dumb, for ammunition to have shape

    51

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

    52

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

    53

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

    54

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

    55

        shape[3] = Vector(1, -1);

    56

        setShape(shape);

    57

    }

    58

private:

    59

    virtual void onCollision();

    60

};

    61

    62

class LocalPlayer : public Player {

    63

protected:

    64

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

    65

};

    66

    67

class RemotePlayer : public Player {

    68

protected:

    69

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

    70

};

    71

    72

class GameState : public PhysicsWorld {

    73

public:

    74

    std::list<Player*> player_list;

    75

    76

    // only one local player is supported

    77

    LocalPlayer *local_player;

    78

    79

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

    80

    81

    }

    82

    83

    /*

    84

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

    85

     */

    86

    LocalPlayer *getLocalPlayer (void) {

    87

        return local_player;

    88

    }

    89

    90

    void newLocalPlayer (LocalPlayer *player) {

    91

        if (local_player)

    92

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

    93

    94

        player_list.push_back(player);

    95

    96

        local_player = player;

    97

    }

    98

    99

    void newRemotePlayer (RemotePlayer *player) {

   100

        player_list.push_back(player);

   101

    }

   102

   103

    void removePlayer (Player *player) {

   104

        player_list.remove(player);

   105

    }

   106

};

   107

   108

#endif