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

    24

{

    27

    37

}

    38

    39

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

    40

    terrain_buf(terrain_buf),

    41

    width(width), height(height)

    42

{

    43

    // just generate the pixel buffer

    44

    generatePixelBuffer();

    45

}

    46

    47

Terrain::~Terrain (void) {

    48

    // free terrain data

    49

    delete[] terrain_buf;

    50

}

    51

    52

void Terrain::generateTerrain (int seed) {

    53

    // set random number generator seed.

    54

    srand(seed); 

    55

    56

    // some constants to control random generation

    57

    const int min_range = 25;

    58

    const int max_range = 80;

    59

    const int num = 50;

    60

    const int rock_rarity = 4;

    61

    62

    // generate \a num random circles

    63

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

    64

        // circle origin

    65

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

    66

    67

        // radius

    68

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

    69

    70

        // circle type

    71

        TerrainType type = TERRAIN_EMPTY;

    72

    73

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

    74

        if (i == 0) {

    75

            mid.x = width / 2;

    76

            mid.y = height / 2;

    77

            range = 150;

    78

    79

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

    80

            // some rock

    81

           type = TERRAIN_ROCK;

    82

        }

    83

    84

        // iterate over the area of the circle

    85

        for (

    86

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

    87

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

    88

            y++

    89

        ) {

    90

            for (

    91

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

    92

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

    93

                x++

    94

            ) {

    95

                // inside radius?

    96

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

    97

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

    98

            }

    99

        } 

   100

    }

   101

}

   102

   103

void Terrain::generatePixelBuffer (void) {

   104

    // initialize textures

   105

    generateTexture();

   106

   107

    // create the pixel buffer of the correct size

   108

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

   109

   110

    // iterate over each pixel

   111

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

   112

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

   113

            // draw textureized pixel color

   114

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

   115

        }

   116

    }

   117

}

   118

   119

/*

   120

 * Texture generation utility functions

   121

 */

   122

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

   123

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

   124

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

   125

            double sum = 0;

   126

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

   127

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

   128

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

   129

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

   130

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

   131

        }

   132

    }

   133

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

   134

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

   135

            double sum = 0;

   136

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

   137

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

   138

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

   139

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

   140

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

   141

        }

   142

    }

   143

}

   144

   145

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

   146

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

   147

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

   148

            double sum = 0;

   149

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

   150

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

   151

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

   152

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

   153

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

   154

        }

   155

    }

   156

}

   157

   158

void Terrain::generateTexture (void) {

   159

    // texture is a 128x128 px pattern

   160

    int texturesize = 128;

   161

   162

    // store the generated texture

   163

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

   164

   165

    // generate texture into this

   166

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

   167

   168

    // XXX: magic constants with unintelligble names

   169

    double str = 0.8;

   170

    double H = 0.8;

   171

   172

    // do some magic

   173

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

   174

        fractal_diamond(land, texturesize, str, i);

   175

        fractal_step(land, texturesize, str, i);

   176

        str *= H;

   177

    }

   178

   179

    double min = 100000;

   180

    double max = -100000;

   181

   182

    // find the range of minimum and maximum values

   183

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

   184

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

   185

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

   186

    }

   187

   188

    // normalize min down to zero

   189

    max -= min;

   190

   191

    // normalize values to [0, max]

   192

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

   193

        land[i] -= min;

   194

    }

   195

   196

    // copy+mangle land to texture as integers

   197

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

   198

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

   199

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

   200

    }

   201

}

   202

   203

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

   204

    if (val < min)

   205

        return min;

   206

   207

    else if (val > max)

   208

        return max;

   209

   210

    else 

   211

        return val;

   212

}

   213

   214

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

   215

    CL_Color color;

   216

    int texture_fade = 8;

   217

   218

    // determine fade constant

   219

    switch (getType(x, y)) {

   220

        case TERRAIN_EMPTY:

   221

            color = COLOR_EMPTY;

   222

            break;

   223

   224

        case TERRAIN_DIRT:

   225

            color = COLOR_DIRT;

   226

            texture_fade = 4;

   227

            break;

   228

   229

        case TERRAIN_ROCK:

   230

            color = COLOR_ROCK;

   231

            texture_fade = 2;

   232

            break;

   233

    }

   234

   235

    // calculate texture coordinate

   236

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

   237

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

   238

   239

    // get color components

   240

    int red = color.get_red();

   241

    int green = color.get_green();

   242

    int blue = color.get_blue();

   243

   244

    // apply noise from texture

   245

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

   246

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

   247

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

   248

   249

    // normalize colors to within range and return new color    

   250

    return CL_Color(

   251

            normalizeRange(0, red, 255),

   252

            normalizeRange(0, green, 255),

   253

            normalizeRange(0, blue, 255)

   254

    );

   255

}

   256

   257

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

   258

    return terrain_buf;

   259

}

   260

   261

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

   262

    // copy bytes

   263

    memcpy(terrain_buf, buf, width * height);

   264

   265

    // regenerate pixbuf

   266

    generatePixelBuffer();

   267

}

   268

   269

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

   270

    return (getType(point) != TERRAIN_EMPTY);

   271

}

   272

   273

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

   274

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

   275

   276

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

   277

    PixelCoordinate b = getPixelCoordinate(begin);

   278

    PixelCoordinate e = getPixelCoordinate(end);

   279

   280

    // steepness of line (large angle against horizontal)

   281

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

   282

   283

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

   284

    if (steep) { 

   285

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

   286

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

   287

    }

   288

   289

    // normalize so that the line goes upwards

   290

    if (b.x > e.x)

   291

        std::swap(b, e);

   292

   293

    // line length

   294

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

   295

    PixelDimension err = dx / 2;

   296

    PixelDimension y = b.y;

   297

   298

    // ascending or descending line?

   299

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

   300

   301

    // iterate through the pixels on the line

   302

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

   303

        if (steep) { 

   304

            // x and y coordinates must be switched if steep

   305

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

   306

                return true;

   307

   308

        } else {

   309

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

   310

                return true;

   311

   312

        }

   313

   314

        err = err - dy;

   315

   316

        if (err < 0) { 

   317

            // check if we want to make an ystep

   318

            y = y + ystep;

   319

            err = err + dx;

   320

        }

   321

    }

   322

   323

    // no collision

   324

    return false; 

   325

}

   326

   327

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

   328

    // scale arguments to pixel units

   329

    PixelCoordinate mid = getPixelCoordinate(pos);

   330

    PixelDimension r = scale(radius); 

   331

   332

    // iterate through the circle's pixels

   333

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

   334

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

   335

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

   336

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

   337

   338

                // within radius?

   339

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

   340

                    // update terrain buf

   341

                    setType(i, j, TERRAIN_EMPTY);

   342

                }

   343

            }

   344

        }

   345

    }

   346

}

   347

   348

/**

   349

 * Gets the index of the given coordinate direction referring to the DIRECTIONS table in Physics.hh

   350

 *

   351

 * XXX: ugly little "lookup table"

   352

 */

   353

static int getDirectionIndex (Vector direction) {

   354

    Vector dir = direction.roundToInt();

   355

   356

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

   357

        return 0;

   358

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

   359

        return 1;

   360

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

   361

        return 2;

   362

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

   363

        return 3;

   364

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

   365

        return 4;

   366

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

   367

        return 5;

   368

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

   369

        return 6;

   370

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

   371

        return 7;

   372

    }

   373

   374

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

   375

    return 0;

   376

}

   377

   378

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

   379

    // convert location to coordinate

   380

    PixelCoordinate p = getPixelCoordinate(point);

   381

   382

    // sanity check

   383

    assert(point != prevPoint);

   384

   385

    // round and subtract to get an integer direction vector, and turn this into a direction index

   386

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

   387

   388

    // always add our own direction to normal

   389

    Vector normal = DIRECTIONS[dirIdx];

   390

   391

    // check the two pixels clockwise from the impact direction

   392

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

   393

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

   394

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

   395

        }

   396

    }

   397

   398

    // check the two pixels counterclockwise from the impact direction

   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

    }

   404

   405

    // sanity check

   406

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

   407

        Engine::log(DEBUG, "Physics.getNormal ") << "silly collision";

   408

    }

   409

   410

    return normal;

   411

}

   412

   413

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

   414

    // XXX: can we optimize this somehow?

   415

   416

    // load the terrain pixbuf as a surface

   417

    CL_Surface surf (pixbuf);

   418

   419

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

   420

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

   421

}

   422