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

/**

    12

 * Terrain class. Represents game terrain and contains member

    13

 * functions to manipulate terrain and get info about it.

    14

 * 

    15

 * Terrain resolution is a constant that is defined in

    16

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

    17

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

    18

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

    19

 * and it uses pixelcoordinates internally.

    20

 */ 

    21

class Terrain {

    22

private:

    23

    const Vector scale;

    24

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

    25

    26

    // Terrain graphic

    27

    CL_PixelBuffer pixbuf;

    28

    29

    /**

    30

     * Generates pixelbuffer from terrain. Should be used only on

    31

     * constructors because this is expected to be slow.

    32

     */

    33

    void generatePixelBuffer();

    34

    35

    /**

    36

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

    37

     *

    38

     * @param point Point in "real" units

    39

     * @return Int vector

    40

     */

    41

    Vector getPixelLocation(Vector point);

    42

    43

public:

    44

    /**

    45

     * Constructor.

    46

     *

    47

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

    48

     */

    49

    Terrain(const Vector &scale);

    50

    /**

    51

     * Constructor.

    52

     *

    53

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

    54

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

    55

     * terrain.

    56

     */

    57

    Terrain(const Vector &scale, const int &seed);

    58

    /**

    59

     * Copy constructor.

    60

     *

    61

     * @param t Terrain to be copied.

    62

     */

    63

    Terrain(const Terrain &t);

    64

    /**

    65

     * Destructor

    66

     */

    67

    ~Terrain();

    68

    69

    /**

    70

     * Check if given point has some terrain.

    71

     *

    72

     * @param point Point that is in scaled units.

    73

     */

    74

    bool collides(const Vector &point) const;

    75

    /**

    76

     * Check if given line collides with terrain.

    77

     *

    78

     * @param begin Line begin point in scaled units.

    79

     * @param end Line end point in scaled units.

    80

     */

    81

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

    82

    83

    /**

    84

     * Remove a circular area from terrain.

    85

     *

    86

     * @param pos Circle center

    87

     * @param r Circle radius

    88

     */ 

    89

    void removeGround(Vector pos, float r);

    90

    91

    /**

    92

     * Get tangent for the given point.

    93

     *

    94

     * @param point Point where the tangent is calculated

    95

     * @param n Accuracy in pixels 

    96

     */

    97

    Vector getTangent(Vector point, int n = 1) const;

    98

    /**

    99

     * Get tangent for the given point.

   100

     *

   101

     * @param point Point where the tangent is calculated

   102

     * @param a Accuracy in scaled units.

   103

     */

   104

    Vector getTangent(Vector point, float a) const;

   105

   106

    /**

   107

     * Return normal for the given point.

   108

     *

   109

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

   110

     * @param n Accuracy in pixels

   111

     */

   112

    Vector getNormal(Vector point, int n = 1) const;

   113

    /**

   114

     * Return a normal for the given point.

   115

     *

   116

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

   117

     * @param a Accuracy in scaled units

   118

     */

   119

    Vector getNormal(Vector point, float a) const;

   120

   121

    /**

   122

     * Generate random terrain.

   123

     *

   124

     * @param seed Seed for the randomnumber generator.

   125

     */

   126

    void generateTerrain(int seed);

   127

   128

    /**

   129

     * Draw the terrain for given graphicscontext.

   130

     *

   131

     * @param gc CL_GraphicContext

   132

     */

   134

    /**

   135

     * Draw part of the terrain for given graphiscontext.

   136

     *

   137

     * @param gc CL_GraphicContext

   138

     * @param center Center of the rectangle drawn.

   139

     * @param dimension Dimensions of the rectangle.

   140

     */

   141

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

   142

   143

    /**

   144

     * Set terrain.

   145

     *

   146

     * @param terrain Terrain.

   147

     */

   148

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

   149

    /**

   150

     * Get terrain.

   151

     *

   152

     * @return Terrain.

   153

     */

   154

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

   155

};

   156

   157

#endif