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

/**

    12

 * Different types of terrain available

    13

 */

    14

enum TerrainType {

    15

    /** Empty space, air */

    16

    TERRAIN_EMPTY   = 0x00,

    17

    18

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

    19

    TERRAIN_DIRT    = 0x01,

    20

    21

    /** Indestructible rock */

    22

    TERRAIN_ROCK    = 0x02

    23

};

    24

    25

/**

    26

 * Terrain "pixel" type

    27

 */

    28

typedef uint8_t TerrainPixel;

    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:

    43

    TerrainPixel *terrain_buf;

    44

    45

    /** Terrain dimensions */

    46

    PixelDimension width, height;

    47

    48

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

    49

    CL_PixelBuffer pixbuf;

    50

    51

    // XXX: terrain texture

    52

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

    53

    55

    /**

    56

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

    57

     */

    58

    Terrain (void);

    59

    60

    /**

    62

     *

    63

     * @param width terrain width

    64

     * @param height terrain height

    66

     */

    67

    Terrain (PixelDimension width, PixelDimension height, int seed);

    68

    69

    /**

    83

     */

    84

    ~Terrain (void);

    85

    86

private:

    87

    /* No copying */

    88

    Terrain (const Terrain &copy);

    89

    Terrain &operator= (const Terrain &copy);

    90

    91

protected:

    92

    /**

    93

     * Set induvidual pixel value, updates both terrain_buf and pixbuf

    94

     */

    95

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

    96

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

    97

    98

        // XXX: locking?

    99

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

   100

    }

   101

   102

    /**

   103

     * Generate random terrain using given seed

   104

     *

   105

     * @param seed seed for the random number generator

   106

     */

   107

    void generateTerrain (int seed);

   108

   109

    /**

   110

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

   111

     * greatly speeds up drawing.

   112

     */

   113

    void generatePixelBuffer (void);

   114

   115

    /**

   116

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

   117

     * pixels using noisifyPixel

   118

     */

   119

    void generateTexture();

   120

   121

    /**

   122

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

   123

     * at \a pc.

   124

     */

   125

    CL_Color getTexturePixel (PixelDimension x, PixelDimension y);

   126

   127

    /**

   128

     * Scale parameter to "pixels"

   129

     *

   130

     * @param x Scaled value

   131

     * @return Corresponding value in pixels

   132

     */

   133

    inline PixelDimension scale (float x) const {

   134

        return (int) x;

   135

    }

   136

   137

 public:

   138

    /**

   139

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

   140

     *

   141

     * @param point Point in "real" units

   142

     * @return Int vector

   143

     */

   144

    inline PixelCoordinate getPixelCoordinate (Vector point) const {

   145

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

   146

    }

   147

   148

    /**

   149

     * Return the terrain dimensions à la a PixelCoordinate

   150

     */

   152

        return PixelCoordinate(width, height);

   153

    }

   154

   155

    /**

   167

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

   168

     *

   169

     * @param x terrain x coordinate

   170

     * @param y terrain x coordinate

   171

     * @return terrain pixel type

   172

     */

   173

    TerrainType getType (PixelDimension x, PixelDimension y) const {

   174

        // XXX: optimize access by removing error checking?

   175

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

   176

            return TERRAIN_ROCK;

   177

   178

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

   179

    }

   180

   181

    inline TerrainType getType (PixelCoordinate pc) const {

   182

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

   183

    }

   184

   185

   186

    inline TerrainType getType (Vector point) const {

   187

        return getType(getPixelCoordinate(point));

   188

    }

   189

   190

    /**

   191

     * Get raw read-only terrain data buffer

   192

     *

   193

     * @see terrain_buf

   194

     */

   195

    const TerrainPixel* getTerrainBuffer (void) const;

   196

   197

    /**

   198

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

   199

     *

   200

     * @see terrain_buf

   201

     */

   202

    void loadFromBuffer (const TerrainPixel *buf);

   203

   204

    /**

   205

     * Check if the given point is terrain

   206

     */

   207

    bool collides (const Vector &point) const;

   208

   209

    /**

   210

     * Check if the given line collides with terrain

   211

     *

   212

     * @param begin line starting point

   213

     * @param end line ending point

   214

     */

   215

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

   216

   217

    /**

   218

     * Remove a circular area of terrain

   219

     *

   220

     * @param pos circle center

   221

     * @param r circle radius

   222

     */ 

   223

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

   224

   225

    /**

   226

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

   227

     *

   228

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

   229

     *

   230

     * @param point the ground that we collided into

   231

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

   232

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

   233

     */

   234

    Vector getNormal (Vector point, Vector prevPoint) const;

   235

   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 *g, PixelCoordinate camera = PixelCoordinate(0, 0));

   243

};

   244

   245

#endif