1

#ifndef TERRAIN_HH

     2

#define TERRAIN_HH

     3

     4

#include "Vector.hh"

     5

#include "Types.hh"

     6

#include "Config.hh"

     8

     9

#include "Graphics/Drawable.hh"

    10

    13

/**

    14

 * Different types of terrain available

    15

 */

    16

enum TerrainType {

    17

    /** Empty space, air */

    18

    TERRAIN_EMPTY   = 0x00,

    19

    20

    /** Dirt, which can be destroyed/dug through */

    21

    TERRAIN_DIRT    = 0x01,

    22

    23

    /** Indestructible rock */

    24

    TERRAIN_ROCK    = 0x02

    25

};

    26

    27

/**

    28

 * Terrain class. Represents game terrain and contains member

    29

 * functions to manipulate terrain and get info about it.

    30

 * 

    31

 * Terrain resolution is a constant that is defined in

    32

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

    33

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

    34

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

    35

 * and it uses pixelcoordinates internally.

    36

 */ 

    37

class Terrain {

    38

protected:

    39

    /** The terrain data is stored as a linear array in row-major order, with width * height elements */

    40

    TerrainPixel *terrain_buf;

    41

    42

    /** Terrain dimensions */

    43

    PixelDimension width, height;

    46

    /** We pre-render the textured terrain data for display */

    47

    CL_PixelBuffer pixbuf;

    48

    51

    // XXX: terrain texture

    52

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

    53

    54

public:    

    55

    /**

    56

     * Construct a new terrain based on the given configuration

    57

     *

    58

     * @param config a TerrainConfig describing how to build the terrain

    59

     */

    60

    explicit Terrain (const TerrainConfig &config);

    61

    62

    /**

    63

     * Construct the terrain using the provided terrain data. The given \a terrain_buf must be a linear array in the

    64

     * same format as Terrain::terrain_buf, meaning a row-major order array with width * height elements. The buffer

    65

     * must be allocated on the heap using 'new []', and ownership will be transferred (i.e. the buffer is not copied,

    66

     * and will eventually be delete []'d).

    67

     *

    68

     * @param width terrain width

    69

     * @param height terrain height

    70

     * @param terrain_buf dynamically allocated width * height array of terrain data

    71

     */

    72

    Terrain (PixelDimension width, PixelDimension height, TerrainPixel *terrain_buf);

    73

    74

    /**

    75

     * Destructor, frees our terrain buffer

    76

     */

    77

    ~Terrain (void);

    78

    79

private:

    80

    /* No copying */

    81

    Terrain (const Terrain &copy);

    82

    Terrain &operator= (const Terrain &copy);

    83

    84

protected:

    85

    /**

    86

     * Set induvidual pixel value, updates both terrain_buf and pixbuf

    87

     */

    88

    inline void setType (PixelDimension x, PixelDimension y, TerrainType t) {

    89

        terrain_buf[y * width + x] = (TerrainPixel) t;

    90

    92

        // XXX: locking?

    93

        pixbuf.draw_pixel(x, y, getTexturePixel(x, y));

    95

    }

    96

    97

    /**

    98

     * Generate random terrain using given seed

    99

     *

   100

     * @param seed seed for the random number generator

   101

     */

   102

    void generateTerrain (int seed);

   103

   104

    /**

   105

     * Regenerates our pixbuf from the current terrain. This is a slow process, but using the pixbuffer directly

   106

     * greatly speeds up drawing.

   107

     */

   108

    void generatePixelBuffer (void);

   109

   110

    /**

   111

     * Generates an area of random texture using a fractal-based algorithm, this can then be applied to the terrain

   112

     * pixels using noisifyPixel

   113

     */

   114

    void generateTexture();

   115

   116

    /**

   117

     * Applies noise generated using generateTexture to generate a slightly varying color for the terrain pixel

   118

     * at \a pc.

   119

     */

   120

    CL_Color getTexturePixel (PixelDimension x, PixelDimension y);

   121

   122

    /**

   123

     * Scale parameter to "pixels"

   124

     *

   125

     * @param x Scaled value

   126

     * @return Corresponding value in pixels

   127

     */

   128

    inline PixelDimension scale (float x) const {

   129

        return (int) x;

   130

    }

   131

   132

 public:

   133

    /**

   134

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

   135

     *

   136

     * @param point Point in "real" units

   137

     * @return Int vector

   138

     */

   139

    inline PixelCoordinate getPixelCoordinate (Vector point) const {

   140

        return PixelCoordinate(scale(point.x), scale(point.y));

   141

    }

   142

   143

    /**

   144

     * Return the terrain dimensions à la a PixelCoordinate

   145

     */

   146

    PixelCoordinate getDimensions (void) const {

   147

        return PixelCoordinate(width, height);

   148

    }

   149

   150

    /**

   151

     * Return dimensions in component form

   152

     */

   153

    PixelDimension getWidth (void) const {

   154

        return width;

   155

    }

   156

   157

    PixelDimension getHeight (void) const {

   158

        return height;

   159

    }

   160

   161

    /**

   162

     * Return the type of terrain at given position. Returns TERRAIN_ROCK if given point is not inside terrain area.

   163

     *

   164

     * @param x terrain x coordinate

   165

     * @param y terrain x coordinate

   166

     * @return terrain pixel type

   167

     */

   168

    TerrainType getType (PixelDimension x, PixelDimension y) const {

   169

        // XXX: optimize access by removing error checking?

   170

        if (x < 0 || y < 0 || x >= width || y >= height)

   171

            return TERRAIN_ROCK;

   172

   173

        return (TerrainType) terrain_buf[y * width + x];

   174

    }

   175

   176

    inline TerrainType getType (PixelCoordinate pc) const {

   177

        return getType(pc.x, pc.y);

   178

    }

   179

   180

   181

    inline TerrainType getType (Vector point) const {

   182

        return getType(getPixelCoordinate(point));

   183

    }

   184

   185

    /**

   186

     * Get raw read-only terrain data buffer

   187

     *

   188

     * @see terrain_buf

   189

     */

   190

    const TerrainPixel* getTerrainBuffer (void) const;

   191

   192

    /**

   193

     * Load new terrain data from given buffer. Must be the right size

   194

     *

   195

     * @see terrain_buf

   196

     */

   197

    void loadFromBuffer (const TerrainPixel *buf);

   198

   199

    /**

   200

     * Check if the given point is terrain

   201

     */

   202

    bool collides (const Vector &point) const;

   203

   204

    /**

   205

     * Check if the given line collides with terrain

   206

     *

   207

     * @param begin line starting point

   208

     * @param end line ending point

   209

     */

   210

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

   211

   212

    /**

   213

     * Remove a circular area of terrain

   214

     *

   215

     * @param pos circle center

   216

     * @param r circle radius

   217

     */ 

   218

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

   219

   220

    /**

   221

     * Returns direction normal vector for the given \a point. 

   222

     *

   223

     * \a point should be ground, and \a prevPoint air.

   224

     *

   225

     * @param point the ground that we collided into

   226

     * @param prevPoint position in air where we were before the collision

   227

     * @return direction ormal vector, or (0,0) if there's no terrain

   228

     */

   229

    Vector getNormal (Vector point, Vector prevPoint) const;

   230

   232

    /**

   233

     * Draw the terrain onto the given graphics context

   234

     *

   235

     * @param gc Graphics to draw on

   236

     * @param camera view position

   237

     */

   238

    virtual void draw (graphics::Display &display, PixelCoordinate camera = PixelCoordinate(0, 0));

   240

};

   241

   242

#endif