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

    53

public:

    54

    /**

    55

     * Constructor.

    56

     *

    57

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

    58

     */

    59

    Terrain(const Vector &scale);

    60

    /**

    61

     * Constructor.

    62

     *

    63

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

    64

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

    65

     * terrain.

    66

     */

    67

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

    68

    /**

    69

     * Copy constructor.

    70

     *

    71

     * @param t Terrain to be copied.

    72

     */

    73

    Terrain(const Terrain &t);

    74

    /**

    75

     * Destructor

    76

     */

    77

    ~Terrain();

    78

    79

    /**

    80

     * Check if given point has some terrain.

    81

     *

    82

     * @param point Point that is in scaled units.

    83

     */

    84

    bool collides(const Vector &point) const;

    85

    /**

    86

     * Check if given line collides with terrain.

    87

     *

    88

     * @param begin Line begin point in scaled units.

    89

     * @param end Line end point in scaled units.

    90

     */

    91

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

    92

    93

    /**

    94

     * Remove a circular area from terrain.

    95

     *

    96

     * @param pos Circle center

    97

     * @param r Circle radius

    98

     */ 

    99

    void removeGround(Vector pos, float r);

   100

   101

    /**

   102

     * Get tangent for the given point.

   103

     *

   104

     * @param point Point where the tangent is calculated

   105

     * @param n Accuracy in pixels 

   106

     */

   107

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

   108

    /**

   109

     * Get tangent for the given point.

   110

     *

   111

     * @param point Point where the tangent is calculated

   112

     * @param a Accuracy in scaled units.

   113

     */

   114

    Vector getTangent(Vector point, float a) const;

   115

   116

    /**

   117

     * Return normal for the given point.

   118

     *

   119

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

   120

     * @param n Accuracy in pixels

   121

     */

   122

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

   123

    /**

   124

     * Return a normal for the given point.

   125

     *

   126

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

   127

     * @param a Accuracy in scaled units

   128

     */

   129

    Vector getNormal(Vector point, float a) 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

    void draw(CL_GraphicContext *gc) const;

   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

#endif