1

#ifndef TERRAIN_HH

     2

#define TERRAIN_HH

     3

     4

#include <vector>

     5

     6

#include "Vector.hh"

     7

#include "Config.hh"

     8

     9

enum TerrainType {EMPTY, DIRT, ROCK};

    10

    11

const Vector DIRECTIONS[] = {

    12

    Vector(0,-1),

    13

    Vector(1,-1),

    14

    Vector(1,0),

    15

    Vector(1,1),

    16

    Vector(0,1),

    17

    Vector(-1,1),

    18

    Vector(-1,0),

    19

    Vector(-1,-1)

    20

};

    21

    22

/**

    23

 * Terrain class. Represents game terrain and contains member

    24

 * functions to manipulate terrain and get info about it.

    25

 * 

    26

 * Terrain resolution is a constant that is defined in

    27

 * configuration. Terrain has a scale (i.e. the width and height in

    28

 * "real" units. Scaling is needed because physics simulation uses

    29

 * "real" units. The idea is that this class is used with "real" units

    30

 * and it uses pixelcoordinates internally.

    31

 */ 

    32

class Terrain {

    33

private:

    34

    std::vector<std::vector<TerrainType> > terrain;

    35

    36

    // Terrain graphic

    37

    CL_PixelBuffer pixbuf;

    38

    39

    /**

    40

     * Generates pixelbuffer from terrain. Should be used only on

    41

     * constructors because this is expected to be slow.

    42

     */

    43

    void generatePixelBuffer();

    44

    45

    /**

    46

     * Get pixel location of a point that is in "real" units.

    47

     *

    48

     * @param point Point in "real" units

    49

     * @return Int vector

    50

     */

    51

    Vector getPixelLocation(Vector point) const;

    52

    53

    /**

    54

     * Scale parameter to "pixels"

    55

     *

    56

     * @param x Scaled value

    57

     * @return Corresponding value in pixels

    58

     */

    59

    uint16_t scale(float x) const;

    60

    61

 public:

    62

    63

    // TODO: This should be private.

    64

    /**

    65

     * Return the type of terrain at given position. Returns ROCK if

    66

     * given point is not inside terrain area.

    67

     *

    68

     * @param x X coordinate

    69

     * @param y Y coordinate

    70

     * @return Terrain type

    71

     */

    72

    TerrainType getType(int32_t x, int32_t y) const;

    73

    //point is just rounded and redirected to that above

    74

    TerrainType getType(Vector point) const;

    75

    76

    /**

    77

     * Constructor.

    78

     *

    79

     * @param scale The "real" width and height of the terrain.

    80

     */

    81

    Terrain();

    82

    /**

    83

     * Constructor.

    84

     *

    85

     * @param scale The "real" width and height of the terrain.

    86

     * @param seed Random number generator seed used to create the

    87

     * terrain.

    88

     */

    89

    Terrain(const int &seed);

    90

    /**

    91

     * Copy constructor.

    92

     *

    93

     * @param t Terrain to be copied.

    94

     */

    95

    Terrain(const Terrain &t);

    96

    /**

    97

     * Destructor

    98

     */

    99

    ~Terrain() {}

   100

   101

    /**

   102

     * Check if given point has some terrain.

   103

     *

   104

     * @param point Point that is in scaled units.

   105

     */

   106

    bool collides(const Vector &point) const;

   107

    /**

   108

     * Check if given line collides with terrain.

   109

     *

   110

     * @param begin Line begin point in scaled units.

   111

     * @param end Line end point in scaled units.

   112

     */

   113

    bool collides(const Vector &begin, const Vector &end) const;

   114

   115

    /**

   116

     * Remove a circular area from terrain.

   117

     *

   118

     * @param pos Circle center

   119

     * @param r Circle radius

   120

     */ 

   121

    void removeGround(const Vector &pos, const float &r);

   122

   123

    /**

   124

     * Return normal for the given point.

   125

     *

   126

     * @param point Point for which the normal is calculated.

   127

     * @return Normal vector ((0,0) if there's no terrain)

   128

     */

   129

    Vector getNormal(Vector point, Vector prevPoint) const;

   130

   131

    /**

   132

     * Generate random terrain.

   133

     *

   134

     * @param seed Seed for the randomnumber generator.

   135

     */

   136

    void generateTerrain(int seed);

   137

   138

    /**

   139

     * Draw the terrain for given graphicscontext.

   140

     *

   141

     * @param gc CL_GraphicContext

   142

     */

   143

    virtual void draw(CL_GraphicContext *gc);

   144

    /**

   145

     * Draw part of the terrain for given graphiscontext.

   146

     *

   147

     * @param gc CL_GraphicContext

   148

     * @param center Center of the rectangle drawn.

   149

     * @param dimension Dimensions of the rectangle.

   150

     */

   151

    //void draw(CL_GraphicContext &gc, Vector center, Vector dimensions);

   152

   153

    /**

   154

     * Set terrain.

   155

     *

   156

     * @param terrain Terrain.

   157

     */

   158

    void setTerrain(const std::vector<std::vector<TerrainType> > &terrain);

   159

    /**

   160

     * Get terrain.

   161

     *

   162

     * @return Terrain.

   163

     */

   164

    std::vector<std::vector<TerrainType> > getTerrain() const;

   165

};

   166

   167

Vector direction(const Vector &v);

   168

   169

#endif