1

#ifndef TERRAIN_HH

     2

#define TERRAIN_HH

     3

     4

#include "Vector.hh"

     5

#include "Types.hh"

     6

#include "Config.hh"

     7

#include "Configuration.hh"

     8

     9

#include <vector>

    10

    11

#if GRAPHICS_ENABLED

    12

    #include "Graphics/Drawable.hh"

    13

    14

#endif

    15

    16

/**

    17

 * Different types of terrain available

    18

 */

    19

enum TerrainType {

    20

    /** Empty space, air */

    21

    TERRAIN_EMPTY   = 0x00,

    22

    23

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

    24

    TERRAIN_DIRT    = 0x01,

    25

    26

    /** Indestructible rock */

    27

    TERRAIN_ROCK    = 0x02

    28

};

    29

    30

/**

    31

 * Terrain class. Represents game terrain and contains member

    32

 * functions to manipulate terrain and get info about it.

    33

 * 

    34

 * Terrain resolution is a constant that is defined in

    35

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

    36

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

    37

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

    38

 * and it uses pixelcoordinates internally.

    39

 */ 

    40

class Terrain {

    41

protected:

    42

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

    43

    TerrainPixel *terrain_buf;

    44

    45

    /** Terrain dimensions */

    46

    PixelDimension width, height;

    47

    48

#if GRAPHICS_ENABLED    

    49

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

    50

    CL_PixelBuffer pixbuf;

    51

    52

    /** Generated texture pattern */

    53

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

    54

#endif    

    55

    56

public:    

    57

    /**

    58

     * Construct a new terrain based on the given configuration

    59

     *

    60

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

    61

     */

    62

    explicit Terrain (const TerrainConfig &config);

    63

    64

    /**

    65

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

    66

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

    67

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

    68

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

    69

     *

    70

     * @param width terrain width

    71

     * @param height terrain height

    72

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

    73

     */

    74

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

    75

    76

    /**

    77

     * Destructor, frees our terrain buffer

    78

     */

    79

    ~Terrain (void);

    80

    81

private:

    82

    /* No copying */

    83

    Terrain (const Terrain &copy);

    84

    Terrain &operator= (const Terrain &copy);

    85

    86

protected:

    87

    /**

    88

     * Set induvidual pixel value, updates both terrain_buf and pixbuf

    89

     */

    90

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

    91

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

    92

    93

#if GRAPHICS_ENABLED        

    94

        // XXX: locking?

    95

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

    96

#endif        

    97

    }

    98

    99

    /**

   100

     * Generate random terrain using given seed

   101

     *

   102

     * @param seed seed for the random number generator

   103

     */

   104

    void generateTerrain (int seed);

   105

   106

    /**

   107

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

   108

     * greatly speeds up drawing.

   109

     */

   110

    void generatePixelBuffer (void);

   111

   112

#if GRAPHICS_ENABLED    

   113

    /**

   114

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

   115

     * pixels using noisifyPixel

   116

     */

   117

    void generateTexture();

   118

   119

    /**

   120

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

   121

     * at \a pc.

   122

     */

   123

    Color getTexturePixel (PixelDimension x, PixelDimension y);

   124

#endif

   125

   126

    /**

   127

     * Scale parameter to "pixels"

   128

     *

   129

     * @param x Scaled value

   130

     * @return Corresponding value in pixels

   131

     */

   132

    inline PixelDimension scale (float x) const {

   133

        return (int) x;

   134

    }

   135

   136

 public:

   137

    /**

   138

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

   139

     *

   140

     * @param point Point in "real" units

   141

     * @return Int vector

   142

     */

   143

    inline PixelCoordinate getPixelCoordinate (Vector point) const {

   144

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

   145

    }

   146

   147

    /**

   148

     * Return the terrain dimensions à la a PixelCoordinate

   149

     */

   150

    PixelCoordinate getDimensions (void) const {

   151

        return PixelCoordinate(width, height);

   152

    }

   153

   154

    /**

   155

     * Return dimensions in component form

   156

     */

   157

    PixelDimension getWidth (void) const {

   158

        return width;

   159

    }

   160

   161

    PixelDimension getHeight (void) const {

   162

        return height;

   163

    }

   164

   165

    /**

   166

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

   167

     *

   168

     * @param x terrain x coordinate

   169

     * @param y terrain x coordinate

   170

     * @return terrain pixel type

   171

     */

   172

    TerrainType getType (PixelDimension x, PixelDimension y) const {

   173

        // XXX: optimize access by removing error checking?

   174

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

   175

            return TERRAIN_ROCK;

   176

   177

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

   178

    }

   179

   180

    inline TerrainType getType (PixelCoordinate pc) const {

   181

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

   182

    }

   183

   184

   185

    inline TerrainType getType (Vector point) const {

   186

        return getType(getPixelCoordinate(point));

   187

    }

   188

   189

    /**

   190

     * Get raw read-only terrain data buffer

   191

     *

   192

     * @see terrain_buf

   193

     */

   194

    const TerrainPixel* getTerrainBuffer (void) const;

   195

   196

    /**

   197

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

   198

     *

   199

     * @see terrain_buf

   200

     */

   201

    void loadFromBuffer (const TerrainPixel *buf);

   202

   203

    /**

   204

     * Check if the given point is terrain

   205

     */

   206

    bool collides (const Vector &point) const;

   207

   208

    /**

   209

     * Check if the given line collides with terrain

   210

     *

   211

     * @param begin line starting point

   212

     * @param end line ending point

   213

     */

   214

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

   215

   216

    /**

   217

     * Remove a circular area of terrain

   218

     *

   219

     * @param pos circle center

   220

     * @param r circle radius

   221

     */ 

   222

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

   223

   224

    /**

   225

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

   226

     *

   227

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

   228

     *

   229

     * @param point the ground that we collided into

   230

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

   231

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

   232

     */

   233

    Vector getNormal (Vector point, Vector prevPoint) const;

   234

   235

#if GRAPHICS_ENABLED        

   236

    /**

   237

     * Draw the terrain onto the given graphics context

   238

     *

   239

     * @param gc Graphics to draw on

   240

     * @param camera view position

   241

     */

   242

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

   243

#endif    

   244

};

   245

   246

#endif