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

#include <cmath>

    10

    11

const float KG_PI = 3.14159265;

    12

    13

// in cells/kg

    14

const uint16_t MAP_WIDTH = 800;

    15

const uint16_t MAP_HEIGHT = 600;

    16

const float MAP_GRAVITY = 1200.0;

    17

const float COLLISION_ELASTICITY = 0.4;

    18

    19

const float PLAYER_MASS = 10.0;

    20

const float PLAYER_MOVE_FORCE = 5000.0;

    21

const float PLAYER_INITIAL_X = 400.0;

    22

const float PLAYER_INITIAL_Y = 300.0;

    23

const float PLAYER_MIN_SPEED = 10.0;

    24

    25

const float CROSSHAIR_ANGLE_SPEED = PI/40; // TODO: Adjust this

    26

const float PLAYER_AIM_MIN = -KG_PI/4; // TODO: -- || --

    27

const float PLAYER_AIM_MAX = KG_PI/2; // TODO: -- || --

    28

    29

// forward-declare GameState

    30

class GameState;

    31

    32

class Player : public PhysicsObject {

    33

protected:

    34

    GameState &state;

    35

    bool visible;

    36

    37

public:

    38

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

    39

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

    40

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

        setShape(shape);		

    48

    }

    49

    50

    void debugInfo ();

    51

    52

public:

    53

    virtual void handleMove (PlayerInput_Move input);

    54

    55

    56

};

    57

    58

class Shot : public PhysicsObject {

    59

protected:

    60

    GameState &state;

    61

    bool visible;

    62

    uint32_t birth_tick;

    63

    uint32_t death_tick;

    64

public:

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

        setShape(shape);

    74

    }

    75

private:

    76

    virtual void onCollision();

    77

};

    78

    79

class LocalPlayer : public Player {

    80

protected:

    81

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

    82

};

    83

    84

class RemotePlayer : public Player {

    85

protected:

    86

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

    87

};

    88

    89

class GameState : public PhysicsWorld {

    90

public:

    91

    std::list<Player*> player_list;

    92

    93

    // only one local player is supported

    94

    LocalPlayer *local_player;

    95

    96

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

    97

    98

    }

    99

   100

    /*

   101

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

   102

     */

   103

    LocalPlayer *getLocalPlayer (void) {

   104

        return local_player;

   105

    }

   106

   107

    void newLocalPlayer (LocalPlayer *player) {

   108

        if (local_player)

   109

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

   110

   111

        player_list.push_back(player);

   112

   113

        local_player = player;

   114

    }

   115

   116

    void newRemotePlayer (RemotePlayer *player) {

   117

        player_list.push_back(player);

   118

    }

   119

   120

    void removePlayer (Player *player) {

   121

        player_list.remove(player);

   122

    }

   123

};

   124

   125

#endif