1

#ifndef TERRAIN_HH

     2

#define TERRAIN_HH

     3

     4

#include "Vector.hh"

     5

#include "Types.hh"

     6

#include "Config.hh"

     7

    10

/**

    11

 * Different types of terrain available

    12

 */

    13

enum TerrainType {

    14

    /** Empty space, air */

    15

    TERRAIN_EMPTY   = 0x00,

    16

    17

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

    18

    TERRAIN_DIRT    = 0x01,

    19

    20

    /** Indestructible rock */

    21

    TERRAIN_ROCK    = 0x02

    22

};

    23

    24

/**

    25

 * Terrain "pixel" type

    26

 */

    27

typedef uint8_t TerrainPixel;

    28

    29

/**

    30

 * Terrain configuration

    31

 */

    32

struct TerrainConfig {

    33

    /** Size of the terrain field*/

    34

    PixelDimensions dimensions;

    35

    36

    /** Set to nonzero to generate random map */

    37

    int random_seed;

    38

    39

    /** Defaults */

    40

    TerrainConfig (void) : dimensions(TERRAIN_WIDTH, TERRAIN_HEIGHT), random_seed(TERRAIN_RANDOM_SEED) { }

    41

};

    42

    43

#include <vector>

    44

    45

/**

    46

 * Terrain class. Represents game terrain and contains member

    47

 * functions to manipulate terrain and get info about it.

    48

 * 

    49

 * Terrain resolution is a constant that is defined in

    50

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

    51

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

    52

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

    53

 * and it uses pixelcoordinates internally.

    54

 */ 

    55

class Terrain {

    56

protected:

    57

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

    58

    TerrainPixel *terrain_buf;

    59

    60

    /** Terrain dimensions */

    61

    PixelDimension width, height;

    62

    63

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

    64

    CL_PixelBuffer pixbuf;

    65

    66

    // XXX: terrain texture

    67

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

    68

    69

public:    

    70

    /**

    71

     * Construct a new terrain based on the given configuration

    72

     *

    73

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

    74

     */

    75

    explicit Terrain (const TerrainConfig &config);

    76

    77

    /**

    78

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

    79

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

    80

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

    81

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

    82

     *

    83

     * @param width terrain width

    84

     * @param height terrain height

    85

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

    86

     */

    87

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

    88

    89

    /**

    90

     * Destructor, frees our terrain buffer

    91

     */

    92

    ~Terrain (void);

    93

    94

private:

    95

    /* No copying */

    96

    Terrain (const Terrain &copy);

    97

    Terrain &operator= (const Terrain &copy);

    98

    99

protected:

   100

    /**

   101

     * Set induvidual pixel value, updates both terrain_buf and pixbuf

   102

     */

   103

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

   104

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

   105

   106

        // XXX: locking?

   107

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

   108

    }

   109

   110

    /**

   111

     * Generate random terrain using given seed

   112

     *

   113

     * @param seed seed for the random number generator

   114

     */

   115

    void generateTerrain (int seed);

   116

   117

    /**

   118

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

   119

     * greatly speeds up drawing.

   120

     */

   121

    void generatePixelBuffer (void);

   122

   123

    /**

   124

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

   125

     * pixels using noisifyPixel

   126

     */

   127

    void generateTexture();

   128

   129

    /**

   130

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

   131

     * at \a pc.

   132

     */

   133

    CL_Color getTexturePixel (PixelDimension x, PixelDimension y);

   134

   135

    /**

   136

     * Scale parameter to "pixels"

   137

     *

   138

     * @param x Scaled value

   139

     * @return Corresponding value in pixels

   140

     */

   141

    inline PixelDimension scale (float x) const {

   142

        return (int) x;

   143

    }

   144

   145

 public:

   146

    /**

   147

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

   148

     *

   149

     * @param point Point in "real" units

   150

     * @return Int vector

   151

     */

   152

    inline PixelCoordinate getPixelCoordinate (Vector point) const {

   153

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

   154

    }

   155

   156

    /**

   157

     * Return the terrain dimensions à la a PixelCoordinate

   158

     */

   159

    PixelCoordinate getDimensions (void) const {

   160

        return PixelCoordinate(width, height);

   161

    }

   162

   163

    /**

   164

     * Return dimensions in component form

   165

     */

   166

    PixelDimension getWidth (void) const {

   167

        return width;

   168

    }

   169

   170

    PixelDimension getHeight (void) const {

   171

        return height;

   172

    }

   173

   174

    /**

   175

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

   176

     *

   177

     * @param x terrain x coordinate

   178

     * @param y terrain x coordinate

   179

     * @return terrain pixel type

   180

     */

   181

    TerrainType getType (PixelDimension x, PixelDimension y) const {

   182

        // XXX: optimize access by removing error checking?

   183

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

   184

            return TERRAIN_ROCK;

   185

   186

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

   187

    }

   188

   189

    inline TerrainType getType (PixelCoordinate pc) const {

   190

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

   191

    }

   192

   193

   194

    inline TerrainType getType (Vector point) const {

   195

        return getType(getPixelCoordinate(point));

   196

    }

   197

   198

    /**

   199

     * Get raw read-only terrain data buffer

   200

     *

   201

     * @see terrain_buf

   202

     */

   203

    const TerrainPixel* getTerrainBuffer (void) const;

   204

   205

    /**

   206

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

   207

     *

   208

     * @see terrain_buf

   209

     */

   210

    void loadFromBuffer (const TerrainPixel *buf);

   211

   212

    /**

   213

     * Check if the given point is terrain

   214

     */

   215

    bool collides (const Vector &point) const;

   216

   217

    /**

   218

     * Check if the given line collides with terrain

   219

     *

   220

     * @param begin line starting point

   221

     * @param end line ending point

   222

     */

   223

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

   224

   225

    /**

   226

     * Remove a circular area of terrain

   227

     *

   228

     * @param pos circle center

   229

     * @param r circle radius

   230

     */ 

   231

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

   232

   233

    /**

   234

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

   235

     *

   236

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

   237

     *

   238

     * @param point the ground that we collided into

   239

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

   240

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

   241

     */

   242

    Vector getNormal (Vector point, Vector prevPoint) const;

   243

   244

    /**

   245

     * Draw the terrain onto the given graphics context

   246

     *

   247

     * @param gc Graphics to draw on

   248

     * @param camera view position

   249

     */

   251

};

   252

   253

#endif