1

#include "Terrain.hh"

     2

#include "Graphics.hh"

     3

#include "Engine.hh"

     4

     5

#include <cmath>

     6

#include <cassert>

     7

#include <algorithm>

     8

#include <ClanLib/display.h>

     9

    10

const Vector DIRECTIONS[] = {

    11

    Vector(0,-1),

    12

    Vector(1,-1),

    13

    Vector(1,0),

    14

    Vector(1,1),

    15

    Vector(0,1),

    16

    Vector(-1,1),

    17

    Vector(-1,0),

    18

    Vector(-1,-1)

    19

};

    20

    21

Terrain::Terrain (void) :

    22

    terrain_buf(NULL), width(0), height(0)

    23

{

    24

}

    25

    26

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

    27

    terrain_buf(NULL),

    29

{

    30

    // allocate+generate random terrain

    31

    generateTerrain(seed);

    32

}

    33

    42

Terrain::~Terrain (void) {

    43

    // free terrain data

    44

    delete[] terrain_buf;

    45

}

    46

    47

void Terrain::generateTerrain (int seed) {

    48

    // shouldn't be generated yet

    49

    assert(!terrain_buf);

    50

    51

    // set random number generator seed.

    52

    srand(seed); 

    53

    54

    // allocate terrain buffer

    55

    terrain_buf = new TerrainPixel[width * height];

    56

    57

    // fill with dirt

    58

    memset(terrain_buf, TERRAIN_DIRT, width * height);

    59

    60

    // some constants to control random generation

    61

    const int min_range = 25;

    62

    const int max_range = 80;

    63

    const int num = 50;

    64

    const int rock_rarity = 4;

    65

    66

    // generate \a num random circles

    67

    for (int i = 0; i < num; i++) {

    68

        // circle origin

    69

        PixelCoordinate mid (rand() % width, rand() % height);

    70

    71

        // radius

    72

        int range = rand() % (max_range - min_range) + min_range;

    73

    74

        // circle type

    75

        TerrainType type = TERRAIN_EMPTY;

    76

    77

        // tweak to make sure that there's a circle in the midle of the cave

    78

        if (i == 0) {

    79

            mid.x = width / 2;

    80

            mid.y = height / 2;

    81

            range = 150;

    82

    83

        } else if (rand() % rock_rarity == 0) {

    84

            // some rock

    85

           type = TERRAIN_ROCK;

    86

        }

    87

    88

        // iterate over the area of the circle

    89

        for (

    90

            PixelDimension y = std::max((PixelDimension) 0, mid.y - range);

    91

            y < std::min(height, mid.y + range);

    92

            y++

    93

        ) {

    94

            for (

    95

                PixelDimension x = std::max((PixelDimension) 0, mid.x - range); 

    96

                x < std::min(width, mid.x + range); 

    97

                x++

    98

            ) {

    99

                // inside radius?

   100

                if ((x - mid.x) * (x - mid.x) + (y - mid.y) * (y - mid.y) < range * range) 

   101

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

   102

            }

   103

        } 

   104

    }

   105

   106

    // update pixel buffer

   107

    generatePixelBuffer();

   108

}

   109

   110

void Terrain::generatePixelBuffer (void) {

   111

    // initialize textures

   112

    generateTexture();

   113

   114

    // create the pixel buffer of the correct size

   115

    pixbuf = CL_PixelBuffer(width, height, 4 * width, CL_PixelFormat::rgba8888);

   116

   117

    // iterate over each pixel

   118

    for (PixelDimension x = 0; x < width; x++) {

   119

        for (PixelDimension y = 0; y < height; y++) {

   120

            // draw textureized pixel color

   121

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

   122

        }

   123

    }

   124

}

   125

   126

/*

   127

 * Texture generation utility functions

   128

 */

   129

static void fractal_step (std::vector<double>& land, int size, double str, int dist) {

   130

    for (int i = 0; i < size; i += dist * 2) {

   131

        for (int j = dist; j < size; j += dist * 2) {

   132

            double sum = 0;

   133

            sum += land[(i + size - dist) % size + j * size];

   134

            sum += land[i + ((j + size - dist) % size) * size];

   135

            sum += land[(i + dist) % size + j * size];

   136

            sum += land[i + ((j + dist) % size) * size];

   137

            land[i + j * size] = sum / 4 + (rand() % 10000 - 5000) * str;

   138

        }

   139

    }

   140

    for (int i = dist; i < size; i += dist * 2) {

   141

        for (int j = 0; j < size; j += dist * 2) {

   142

            double sum = 0;

   143

            sum += land[(i + size - dist) % size + j * size];

   144

            sum += land[i + ((j + size - dist) % size) * size];

   145

            sum += land[(i + dist) % size + j * size];

   146

            sum += land[i + ((j + dist)  % size) * size];

   147

            land[i + j * size] = sum / 4 + (rand() % 10000 - 5000) * str;

   148

        }

   149

    }

   150

}

   151

   152

static void fractal_diamond (std::vector<double>& land, int size, double str, int dist) {

   153

    for (int i = dist; i < size; i += dist*2) {

   154

        for (int j = dist; j < size; j += dist*2) {

   155

            double sum = 0;

   156

            sum += land[(i + size - dist) % size + ((j + size - dist) % size) * size];

   157

            sum += land[(i + dist) % size + ((j + size - dist) % size) * size];

   158

            sum += land[(i + size - dist) % size + ((j + dist) % size) * size];

   159

            sum += land[(i + dist) % size + ((j + dist) % size) * size];

   160

            land[i + j * size] = sum / 4 + (rand() % 10000 - 5000) * str;

   161

        }

   162

    }

   163

}

   164

   165

void Terrain::generateTexture (void) {

   166

    // texture is a 128x128 px pattern

   167

    int texturesize = 128;

   168

   169

    // store the generated texture

   170

    texture = std::vector<std::vector<int> >(texturesize, std::vector<int>(texturesize));

   171

   172

    // generate texture into this

   173

    std::vector<double> land(texture.size() * texture.size());

   174

   175

    // XXX: magic constants with unintelligble names

   176

    double str = 0.8;

   177

    double H = 0.8;

   178

   179

    // do some magic

   180

    for (int i = 512; i >= 1; i /= 2) {

   181

        fractal_diamond(land, texturesize, str, i);

   182

        fractal_step(land, texturesize, str, i);

   183

        str *= H;

   184

    }

   185

   186

    double min = 100000;

   187

    double max = -100000;

   188

   189

    // find the range of minimum and maximum values

   190

    for (int i = 0; i < texturesize * texturesize; i++) {

   191

        if (land[i] < min) min = land[i];

   192

        if (land[i] > max) max = land[i];

   193

    }

   194

   195

    // normalize min down to zero

   196

    max -= min;

   197

   198

    // normalize values to [0, max]

   199

    for (int i = 0; i < texturesize * texturesize; i++) {

   200

        land[i] -= min;

   201

    }

   202

   203

    // copy+mangle land to texture as integers

   204

    for (int i = 0; i < texturesize * texturesize; i++) {

   205

        land[i] = land[i] * 255 / max;

   206

        texture[i % texturesize][i / texturesize] = (int) land[i];

   207

    }

   208

}

   209

   210

static int normalizeRange (int min, int val, int max) {

   211

    if (val < min)

   212

        return min;

   213

   214

    else if (val > max)

   215

        return max;

   216

   217

    else 

   218

        return val;

   219

}

   220

   221

CL_Color Terrain::getTexturePixel (PixelDimension x, PixelDimension y) {

   222

    CL_Color color;

   223

    int texture_fade = 8;

   224

   225

    // determine fade constant

   226

    switch (getType(x, y)) {

   227

        case TERRAIN_EMPTY:

   228

            color = COLOR_EMPTY;

   229

            break;

   230

   231

        case TERRAIN_DIRT:

   232

            color = COLOR_DIRT;

   233

            texture_fade = 4;

   234

            break;

   235

   236

        case TERRAIN_ROCK:

   237

            color = COLOR_ROCK;

   238

            texture_fade = 2;

   239

            break;

   240

    }

   241

   242

    // calculate texture coordinate

   243

    int tx = (x + texture_fade * 37) % texture.size();

   244

    int ty = (y + texture_fade * 37) % texture[0].size();

   245

   246

    // get color components

   247

    int red = color.get_red();

   248

    int green = color.get_green();

   249

    int blue = color.get_blue();

   250

   251

    // apply noise from texture

   252

    red += (texture[tx][ty] - 128) / texture_fade;

   253

    green += (texture[tx][ty] - 128) / texture_fade;

   254

    blue += (texture[tx][ty] - 128) / texture_fade;

   255

   256

    // normalize colors to within range and return new color    

   257

    return CL_Color(

   258

            normalizeRange(0, red, 255),

   259

            normalizeRange(0, green, 255),

   260

            normalizeRange(0, blue, 255)

   261

    );

   262

}

   263

   264

const TerrainPixel* Terrain::getTerrainBuffer (void) const {

   265

    return terrain_buf;

   266

}

   267

   268

void Terrain::loadFromBuffer (const TerrainPixel *buf) {

   269

    // copy bytes

   270

    memcpy(terrain_buf, buf, width * height);

   271

   272

    // regenerate pixbuf

   273

    generatePixelBuffer();

   274

}

   275

   276

bool Terrain::collides (const Vector &point) const {

   277

    return (getType(point) != TERRAIN_EMPTY);

   278

}

   279

   280

bool Terrain::collides (const Vector &begin, const Vector &end) const {

   281

    // TODO: Maybe there should be another function that also returns the point where we collided.

   282

   283

    // use Bresenhams line algorithm to go trough all the "pixels" of the line.

   284

    PixelCoordinate b = getPixelCoordinate(begin);

   285

    PixelCoordinate e = getPixelCoordinate(end);

   286

   287

    // steepness of line (large angle against horizontal)

   288

    bool steep = (abs(e.y - b.y) > abs(e.x - b.x)); // k > 1

   289

   290

    // if the line is steep, swap the x and y coordinates

   291

    if (steep) { 

   292

        std::swap(b.x, b.y);

   293

        std::swap(e.x, e.y);

   294

    }

   295

   296

    // normalize so that the line goes upwards

   297

    if (b.x > e.x)

   298

        std::swap(b, e);

   299

   300

    // line length

   301

    PixelDimension dx = e.x - b.x, dy = abs(e.y - b.y);

   302

    PixelDimension err = dx / 2;

   303

    PixelDimension y = b.y;

   304

   305

    // ascending or descending line?

   306

    PixelDimension ystep = b.y < e.y ? 1 : -1;

   307

   308

    // iterate through the pixels on the line

   309

    for (PixelDimension x = b.x; x <= e.x; x++) {

   310

        if (steep) { 

   311

            // x and y coordinates must be switched if steep

   312

            if (getType(y, x) != TERRAIN_EMPTY)

   313

                return true;

   314

   315

        } else {

   316

            if (getType(x, y) != TERRAIN_EMPTY) 

   317

                return true;

   318

   319

        }

   320

   321

        err = err - dy;

   322

   323

        if (err < 0) { 

   324

            // check if we want to make an ystep

   325

            y = y + ystep;

   326

            err = err + dx;

   327

        }

   328

    }

   329

   330

    // no collision

   331

    return false; 

   332

}

   333

   334

void Terrain::removeGround (const Vector &pos, float radius) {

   335

    // scale arguments to pixel units

   336

    PixelCoordinate mid = getPixelCoordinate(pos);

   337

    PixelDimension r = scale(radius); 

   338

   339

    // iterate through the circle's pixels

   340

    for (PixelDimension j = mid.y - r; j < mid.y + r; j++) {

   341

        for (PixelDimension i = mid.x - r; i < mid.x + r; i++) {

   342

            // getType also returns TERRAIN_ROCK if out-of-bounds

   343

            if (getType(i, j) != TERRAIN_ROCK) { 

   344

   345

                // within radius?

   346

                if ((i - mid.x) * (i - mid.x) + (j - mid.y) * (j - mid.y) < r * r) {

   347

                    // update terrain buf

   348

                    setType(i, j, TERRAIN_EMPTY);

   349

                }

   350

            }

   351

        }

   352

    }

   353

}

   354

   355

/**

   359

 */

   360

static int getDirectionIndex (Vector direction) {

   361

    Vector dir = direction.roundToInt();

   362

   363

    if (dir.x == 0 && dir.y == -1) {

   364

        return 0;

   365

    } else if (dir.x == 1 && dir.y == -1) {

   366

        return 1;

   367

    } else if (dir.x == 1 && dir.y == 0) {

   368

        return 2;

   369

    } else if (dir.x == 1 && dir.y == 1) {

   370

        return 3;

   371

    } else if (dir.x == 0 && dir.y == 1) {

   372

        return 4;

   373

    } else if (dir.x == -1 && dir.y == 1) {

   374

        return 5;

   375

    } else if (dir.x == -1 && dir.y == 0) {

   376

        return 6;

   377

    } else if (dir.x == -1 && dir.y == -1) {

   378

        return 7;

   379

    }

   380

   381

    Engine::log(DEBUG, "Terrain.getDirectionIndex ") << "invalid direction: " << direction;

   382

    return 0;

   383

}

   384

   385

Vector Terrain::getNormal(Vector point, Vector prevPoint) const {

   387

    PixelCoordinate p = getPixelCoordinate(point);

   390

    assert(point != prevPoint);

   393

    int dirIdx = getDirectionIndex(prevPoint.roundToInt() - point.roundToInt());

   399

    for (int i = 1; i <= 2; i++) {

   400

        if (getType(point + DIRECTIONS[(dirIdx + i + 8) % 8]) == TERRAIN_EMPTY) {

   401

            normal += DIRECTIONS[(dirIdx + i + 8) % 8];

   402

        }

   403

    }

   406

    for (int i = 1; i <= 2; i++) {

   407

        if (getType(point + DIRECTIONS[(dirIdx - i + 8) % 8]) == TERRAIN_EMPTY) {

   408

            normal += DIRECTIONS[(dirIdx - i + 8) % 8];

   409

        }

   410

    }

   413

    if (getType(point) == TERRAIN_EMPTY || getType(prevPoint) != TERRAIN_EMPTY) {

   415

    }

   416

   417

    return normal;

   418

}

   419

   420

void Terrain::draw (Graphics *g, PixelCoordinate camera) {

   421

    // XXX: can we optimize this somehow?

   422

   423

    // load the terrain pixbuf as a surface

   424

    CL_Surface surf (pixbuf);

   425

   426

    // draw it onto the graphics, offset by camera position

   427

    surf.draw(-camera.x, -camera.y, g->get_gc());

   428

}

   429