1

     2

#include "Terrain.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 (const TerrainConfig &config) :

    22

    terrain_buf(NULL),

    23

    width(config.dimensions.width), height(config.dimensions.height)

    24

{

    25

    // allocate terrain_buf

    26

    terrain_buf = new TerrainPixel[width * height];

    27

    28

    // fill with dirt

    29

    memset(terrain_buf, TERRAIN_DIRT, width * height);

    30

    31

    // geneerate random map?

    32

    if (config.random_seed)

    33

        generateTerrain(config.random_seed);

    34

    35

    // update pixel buffer

    36

    generatePixelBuffer();

    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) {

   106

    // initialize textures

   107

    generateTexture();

   108

   109

    // create the pixel buffer of the correct size

   110

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

   111

   112

    // iterate over each pixel

   113

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

   114

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

   115

            // draw textureized pixel color

   116

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

   117

        }

   118

    }

   125

}

   126

   127

/*

   128

 * Texture generation utility functions

   129

 */

   130

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

   131

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

   132

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

   133

            double sum = 0;

   134

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

   135

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

   136

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

   137

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

   138

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

   139

        }

   140

    }

   141

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

   142

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

   143

            double sum = 0;

   144

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

   145

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

   146

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

   147

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

   148

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

   149

        }

   150

    }

   151

}

   152

   153

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

   154

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

   155

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

   156

            double sum = 0;

   157

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

   158

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

   159

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

   160

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

   161

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

   162

        }

   163

    }

   164

}

   165

   166

void Terrain::generateTexture (void) {

   167

    // texture is a 128x128 px pattern

   168

    int texturesize = 128;

   169

   170

    // store the generated texture

   171

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

   172

   173

    // generate texture into this

   174

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

   175

   176

    // XXX: magic constants with unintelligble names

   177

    double str = 0.8;

   178

    double H = 0.8;

   179

   180

    // do some magic

   181

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

   182

        fractal_diamond(land, texturesize, str, i);

   183

        fractal_step(land, texturesize, str, i);

   184

        str *= H;

   185

    }

   186

   187

    double min = 100000;

   188

    double max = -100000;

   189

   190

    // find the range of minimum and maximum values

   191

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

   192

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

   193

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

   194

    }

   195

   196

    // normalize min down to zero

   197

    max -= min;

   198

   199

    // normalize values to [0, max]

   200

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

   201

        land[i] -= min;

   202

    }

   203

   204

    // copy+mangle land to texture as integers

   205

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

   206

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

   207

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

   208

    }

   209

}

   210

   211

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

   212

    if (val < min)

   213

        return min;

   214

   215

    else if (val > max)

   216

        return max;

   217

   218

    else 

   219

        return val;

   220

}

   221

   222

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

   223

    CL_Color color;

   224

    int texture_fade = 8;

   225

   226

    // determine fade constant

   227

    switch (getType(x, y)) {

   228

        case TERRAIN_EMPTY:

   229

            color = COLOR_EMPTY;

   230

            break;

   231

   232

        case TERRAIN_DIRT:

   233

            color = COLOR_DIRT;

   234

            texture_fade = 4;

   235

            break;

   236

   237

        case TERRAIN_ROCK:

   238

            color = COLOR_ROCK;

   239

            texture_fade = 2;

   240

            break;

   241

    }

   242

   243

    // calculate texture coordinate

   244

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

   245

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

   246

   247

    // get color components

   248

    int red = color.get_red();

   249

    int green = color.get_green();

   250

    int blue = color.get_blue();

   251

   252

    // apply noise from texture

   253

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

   254

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

   255

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

   256

   257

    // normalize colors to within range and return new color    

   258

    return CL_Color(

   259

            normalizeRange(0, red, 255),

   260

            normalizeRange(0, green, 255),

   261

            normalizeRange(0, blue, 255)

   262

    );

   263

}

   264

   265

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

   266

    return terrain_buf;

   267

}

   268

   269

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

   270

    // copy bytes

   271

    memcpy(terrain_buf, buf, width * height);

   272

   273

    // regenerate pixbuf

   274

    generatePixelBuffer();

   275

}

   276

   277

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

   278

    return (getType(point) != TERRAIN_EMPTY);

   279

}

   280

   281

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

   282

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

   283

   284

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

   285

    PixelCoordinate b = getPixelCoordinate(begin);

   286

    PixelCoordinate e = getPixelCoordinate(end);

   287

   288

    // steepness of line (large angle against horizontal)

   289

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

   290

   291

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

   292

    if (steep) { 

   293

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

   294

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

   295

    }

   296

   297

    // normalize so that the line goes upwards

   298

    if (b.x > e.x)

   299

        std::swap(b, e);

   300

   301

    // line length

   302

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

   303

    PixelDimension err = dx / 2;

   304

    PixelDimension y = b.y;

   305

   306

    // ascending or descending line?

   307

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

   308

   309

    // iterate through the pixels on the line

   310

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

   311

        if (steep) { 

   312

            // x and y coordinates must be switched if steep

   313

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

   314

                return true;

   315

   316

        } else {

   317

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

   318

                return true;

   319

   320

        }

   321

   322

        err = err - dy;

   323

   324

        if (err < 0) { 

   325

            // check if we want to make an ystep

   326

            y = y + ystep;

   327

            err = err + dx;

   328

        }

   329

    }

   330

   331

    // no collision

   332

    return false; 

   333

}

   334

   335

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

   336

    // scale arguments to pixel units

   337

    PixelCoordinate mid = getPixelCoordinate(pos);

   338

    PixelDimension r = scale(radius); 

   339

   340

    // iterate through the circle's pixels

   341

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

   342

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

   343

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

   344

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

   345

   346

                // within radius?

   347

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

   348

                    // update terrain buf

   349

                    setType(i, j, TERRAIN_EMPTY);

   350

                }

   351

            }

   352

        }

   353

    }

   354

}

   355

   356

/**

   357

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

   358

 *

   359

 * XXX: ugly little "lookup table"

   360

 */

   361

static int getDirectionIndex (Vector direction) {

   362

    Vector dir = direction.roundToInt();

   363

   364

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

   365

        return 0;

   366

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

   367

        return 1;

   368

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

   369

        return 2;

   370

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

   371

        return 3;

   372

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

   373

        return 4;

   374

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

   375

        return 5;

   376

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

   377

        return 6;

   378

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

   379

        return 7;

   380

    }

   381

   382

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

   383

    return 0;

   384

}

   385

   386

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

   387

    // convert location to coordinate

   388

    PixelCoordinate p = getPixelCoordinate(point);

   389

   390

    // sanity check

   391

    assert(point != prevPoint);

   392

   393

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

   394

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

   395

   396

    // always add our own direction to normal

   397

    Vector normal = DIRECTIONS[dirIdx];

   398

   399

    // check the two pixels clockwise from the impact direction

   400

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

   401

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

   402

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

   403

        }

   404

    }

   405

   406

    // check the two pixels counterclockwise from the impact direction

   407

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

   408

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

   409

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

   410

        }

   411

    }

   412

   413

    // sanity check

   414

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

   415

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

   416

    }

   417

   418

    return normal;

   419

}

   420

   422

void Terrain::draw (graphics::Display &display, PixelCoordinate camera) {

   423

    // XXX: can we optimize this somehow?

   424

   425

    // load the terrain pixbuf as a surface

   426

    CL_Surface surf (pixbuf);

   427

   428

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

   429

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

   430

}

   432