1

#ifndef TERRAIN_HH

     2

#define TERRAIN_HH

     3

     4

#include <vector>

     5

     6

#include "Vector.hh"

     7

#include "GraphicsPointer.hh"

     8

#include "Types.hh"

     9

#include "Config.hh"

    10

    11

enum TerrainType {

    12

    TERRAIN_EMPTY, 

    13

    TERRAIN_DIRT, 

    14

    TERRAIN_ROCK

    15

};

    16

    17

/**

    18

 * Terrain class. Represents game terrain and contains member

    19

 * functions to manipulate terrain and get info about it.

    20

 * 

    21

 * Terrain resolution is a constant that is defined in

    22

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

    23

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

    24

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

    25

 * and it uses pixelcoordinates internally.

    26

 */ 

    27

class Terrain {

    28

public: // XXX: until we fix Network's access to this

    29

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

    30

    31

    /**

    32

     * Generates pixelbuffer from terrain. Should be used only on

    33

     * constructors because this is expected to be slow.

    34

     */

    35

    void generatePixelBuffer();

    36

    37

protected:

    38

    // terrain dimensions

    39

    PixelDimension map_width, map_height;

    40

    41

    // We can pre-render the terrain as a pixel buffer and then just modify this

    42

    CL_PixelBuffer pixbuf;

    43

    44

    // terrain texture

    45

    std::vector<std::vector<int> > texture;

    46

    47

    /**

    48

     * Default constructor. The width/height are set to zero and the terrain is invalid until it gets updated

    49

     *

    50

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

    51

     */

    52

    Terrain (void);

    53

    54

    /**

    55

     * Constructor.

    56

     *

    57

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

    58

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

    59

     * terrain.

    60

     */

    61

    Terrain (PixelDimension map_width, PixelDimension map_height, int seed);

    62

    63

    /**

    64

     * Copy constructor.

    65

     *

    66

     * @param t Terrain to be copied.

    67

     */

    68

    Terrain (const Terrain &t);

    69

    70

    /**

    71

     * Destructor

    72

     */

    73

    ~Terrain (void) {}

    74

    75

protected:

    76

    void generate_texture();

    77

    void noisifyPixel(CL_Color& col, PixelCoordinate pc);

    78

    79

    80

    /**

    81

     * Scale parameter to "pixels"

    82

     *

    83

     * @param x Scaled value

    84

     * @return Corresponding value in pixels

    85

     */

    86

    PixelDimension scale (float x) const;

    87

    88

    /**

    89

     * Sets to color the correct color of pixel in (x,y)

    90

     */

    91

    void loadPixelColor (CL_Color& color, PixelCoordinate pc);

    92

    93

 public:

    94

    /**

    95

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

    96

     *

    97

     * @param point Point in "real" units

    98

     * @return Int vector

    99

     */

   100

    PixelCoordinate getPixelCoordinate (Vector point) const;

   101

   102

    /**

   103

     * Return the terrain dimensions à la a PixelCoordinate

   104

     */

   105

    PixelCoordinate getDimensions (void) const;

   106

   107

    /**

   108

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

   109

     * given point is not inside terrain area.

   110

     *

   111

     * @param x X coordinate

   112

     * @param y Y coordinate

   113

     * @return Terrain type

   114

     */

   115

    TerrainType getType (PixelDimension px, PixelDimension py) const;

   116

    TerrainType getType (PixelCoordinate pc) const;

   117

    TerrainType getType (Vector point) const;

   118

   119

    /**

   120

     * Check if given point has some terrain.

   121

     *

   122

     * @param point Point that is in scaled units.

   123

     */

   124

    bool collides (const Vector &point) const;

   125

    /**

   126

     * Check if given line collides with terrain.

   127

     *

   128

     * @param begin Line begin point in scaled units.

   129

     * @param end Line end point in scaled units.

   130

     */

   131

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

   132

   133

    /**

   134

     * Remove a circular area from terrain.

   135

     *

   136

     * @param pos Circle center

   137

     * @param r Circle radius

   138

     */ 

   139

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

   140

   141

    /**

   142

     * Return normal for the given point.

   143

     *

   144

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

   145

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

   146

     */

   147

    Vector getNormal (Vector point, Vector prevPoint) const;

   148

   149

    /**

   150

     * Generate random terrain.

   151

     *

   152

     * @param seed Seed for the randomnumber generator.

   153

     */

   154

    void generateTerrain (int seed);

   155

   156

    /**

   157

     * Draw the terrain for given graphicscontext.

   158

     *

   159

     * @param gc CL_GraphicContext

   160

     * @param camera - upper left corner of screen

   161

     */

   162

    virtual void draw (Graphics *g, PixelCoordinate camera = PixelCoordinate(0, 0));

   163

   164

    /**

   165

     * Draw part of the terrain for given graphiscontext.

   166

     *

   167

     * @param gc CL_GraphicContext

   168

     * @param center Center of the rectangle drawn.

   169

     * @param dimension Dimensions of the rectangle.

   170

     */

   171

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

   172

   173

    /**

   174

     * Set terrain.

   175

     *

   176

     * @param terrain Terrain.

   177

     */

   178

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

   179

   180

    /**

   181

     * Get terrain.

   182

     *

   183

     * @return Terrain.

   184

     */

   185

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

   186

};

   187

   188

#endif