1

     2

#include "Terrain.hh"

     3

#include "Engine.hh"

     4

     5

#include <cmath>

     6

#include <cstring>

     7

#include <cassert>

     8

#include <algorithm>

     9

    10

#if GRAPHICS_ENABLED

    11

    12

#include "Graphics/Drawable.hh"

    13

    14

#include <ClanLib/display.h>

    15

    16

#endif

    17

    18

const Vector DIRECTIONS[] = {

    19

    Vector(0,-1),

    20

    Vector(1,-1),

    21

    Vector(1,0),

    22

    Vector(1,1),

    23

    Vector(0,1),

    24

    Vector(-1,1),

    25

    Vector(-1,0),

    26

    Vector(-1,-1)

    27

};

    28

    29

Terrain::Terrain (const TerrainConfig &config) :

    30

    terrain_buf(NULL),

    31

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

    32

{

    33

    // allocate terrain_buf

    34

    terrain_buf = new TerrainPixel[width * height];

    35

    36

    // fill with dirt

    37

    memset(terrain_buf, TERRAIN_DIRT, width * height);

    38

    39

    // geneerate random map?

    40

    if (config.random_seed)

    41

        generateTerrain(config.random_seed);

    42

    43

    // update pixel buffer

    44

    generatePixelBuffer();

    45

}

    46

    47

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

    48

    terrain_buf(terrain_buf),

    49

    width(width), height(height)

    50

{

    51

    // just generate the pixel buffer

    52

    generatePixelBuffer();

    53

}

    54

    55

Terrain::~Terrain (void) {

    56

    // free terrain data

    57

    delete[] terrain_buf;

    58

}

    59

    60

void Terrain::generateTerrain (int seed) {

    61

    // set random number generator seed.

    62

    srand(seed); 

    63

    64

    // some constants to control random generation

    65

    const int min_range = 25;

    66

    const int max_range = 80;

    67

    const int num = 50;

    68

    const int rock_rarity = 4;

    69

    70

    // generate \a num random circles

    71

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

    72

        // circle origin

    73

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

    74

    75

        // radius

    76

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

    77

    78

        // circle type

    79

        TerrainType type = TERRAIN_EMPTY;

    80

    81

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

    82

        if (i == 0) {

    83

            mid.x = width / 2;

    84

            mid.y = height / 2;

    85

            range = 150;

    86

    87

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

    88

            // some rock

    89

           type = TERRAIN_ROCK;

    90

        }

    91

    92

        // iterate over the area of the circle

    93

        for (

    94

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

    95

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

    96

            y++

    97

        ) {

    98

            for (

    99

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

   100

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

   101

                x++

   102

            ) {

   103

                // inside radius?

   104

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

   105

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

   106

            }

   107

        } 

   108

    }

   109

}

   110

   111

void Terrain::generatePixelBuffer (void) {

   112

   113

#if GRAPHICS_ENABLED    

   114

    // initialize textures

   115

    generateTexture();

   116

   117

    // create the pixel buffer of the correct size

   118

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

   119

   120

    // iterate over each pixel

   121

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

   122

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

   123

            // draw textureized pixel color

   124

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

   125

        }

   126

    }

   127

   128

#else

   129

    // no-op

   130

   131

#endif    

   132

   133

}

   134

   135

// XXX: disable textures as well

   136

#if GRAPHICS_ENABLED

   137

/*

   138

 * Texture generation utility functions

   139

 */

   140

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

   141

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

   142

        for (int j = dist; 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

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

   152

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

   153

            double sum = 0;

   154

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

   155

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

   156

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

   157

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

   158

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

   159

        }

   160

    }

   161

}

   162

   163

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

   164

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

   165

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

   166

            double sum = 0;

   167

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

   168

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

   169

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

   170

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

   171

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

   172

        }

   173

    }

   174

}

   175

   176

void Terrain::generateTexture (void) {

   177

    // texture is a 128x128 px pattern

   178

    int texturesize = 128;

   179

   180

    // store the generated texture

   181

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

   182

   183

    // generate texture into this

   184

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

   185

   186

    // XXX: magic constants with unintelligble names

   187

    double str = 0.8;

   188

    double H = 0.8;

   189

   190

    // do some magic

   191

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

   192

        fractal_diamond(land, texturesize, str, i);

   193

        fractal_step(land, texturesize, str, i);

   194

        str *= H;

   195

    }

   196

   197

    double min = 100000;

   198

    double max = -100000;

   199

   200

    // find the range of minimum and maximum values

   201

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

   202

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

   203

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

   204

    }

   205

   206

    // normalize min down to zero

   207

    max -= min;

   208

   209

    // normalize values to [0, max]

   210

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

   211

        land[i] -= min;

   212

    }

   213

   214

    // copy+mangle land to texture as integers

   215

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

   216

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

   217

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

   218

    }

   219

}

   220

   221

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

   222

    if (val < min)

   223

        return min;

   224

   225

    else if (val > max)

   226

        return max;

   227

   228

    else 

   229

        return val;

   230

}

   231

   232

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

   233

    Color color;

   234

    int texture_fade = 8;

   235

   236

    // determine fade constant

   237

    switch (getType(x, y)) {

   238

        case TERRAIN_EMPTY:

   239

            color = COLOR_EMPTY;

   240

            break;

   241

   242

        case TERRAIN_DIRT:

   243

            color = COLOR_DIRT;

   244

            texture_fade = 4;

   245

            break;

   246

   247

        case TERRAIN_ROCK:

   248

            color = COLOR_ROCK;

   249

            texture_fade = 2;

   250

            break;

   251

    }

   252

   253

    // calculate texture coordinate

   254

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

   255

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

   256

   257

    // get color components

   258

    int red = color.get_red();

   259

    int green = color.get_green();

   260

    int blue = color.get_blue();

   261

   262

    // apply noise from texture

   263

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

   264

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

   265

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

   266

   267

    // normalize colors to within range and return new color    

   268

    return Color(

   269

            normalizeRange(0, red, 255),

   270

            normalizeRange(0, green, 255),

   271

            normalizeRange(0, blue, 255)

   272

    );

   273

}

   274

#endif /* GRAPHICS_ENABLED */

   275

   276

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

   277

    return terrain_buf;

   278

}

   279

   280

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

   281

    // copy bytes

   282

    memcpy(terrain_buf, buf, width * height);

   283

   284

    // regenerate pixbuf

   285

    generatePixelBuffer();

   286

}

   287

   288

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

   289

    return (getType(point) != TERRAIN_EMPTY);

   290

}

   291

   292

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

   293

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

   294

   295

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

   296

    PixelCoordinate b = getPixelCoordinate(begin);

   297

    PixelCoordinate e = getPixelCoordinate(end);

   298

   299

    // steepness of line (large angle against horizontal)

   300

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

   301

   302

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

   303

    if (steep) { 

   304

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

   305

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

   306

    }

   307

   308

    // normalize so that the line goes upwards

   309

    if (b.x > e.x)

   310

        std::swap(b, e);

   311

   312

    // line length

   313

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

   314

    PixelDimension err = dx / 2;

   315

    PixelDimension y = b.y;

   316

   317

    // ascending or descending line?

   318

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

   319

   320

    // iterate through the pixels on the line

   321

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

   322

        if (steep) { 

   323

            // x and y coordinates must be switched if steep

   324

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

   325

                return true;

   326

   327

        } else {

   328

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

   329

                return true;

   330

   331

        }

   332

   333

        err = err - dy;

   334

   335

        if (err < 0) { 

   336

            // check if we want to make an ystep

   337

            y = y + ystep;

   338

            err = err + dx;

   339

        }

   340

    }

   341

   342

    // no collision

   343

    return false; 

   344

}

   345

   346

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

   347

    // scale arguments to pixel units

   348

    PixelCoordinate mid = getPixelCoordinate(pos);

   349

    PixelDimension r = scale(radius); 

   350

   351

    // iterate through the circle's pixels

   352

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

   353

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

   354

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

   355

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

   356

   357

                // within radius?

   358

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

   359

                    // update terrain buf

   360

                    setType(i, j, TERRAIN_EMPTY);

   361

                }

   362

            }

   363

        }

   364

    }

   365

}

   366

   367

/**

   368

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

   369

 *

   370

 * XXX: ugly little "lookup table"

   371

 */

   372

static int getDirectionIndex (Vector direction) {

   373

    Vector dir = direction.roundToInt();

   374

   375

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

   376

        return 0;

   377

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

   378

        return 1;

   379

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

   380

        return 2;

   381

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

   382

        return 3;

   383

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

   384

        return 4;

   385

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

   386

        return 5;

   387

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

   388

        return 6;

   389

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

   390

        return 7;

   391

    }

   392

   393

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

   394

    return 0;

   395

}

   396

   397

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

   398

    // convert location to coordinate

   399

    PixelCoordinate p = getPixelCoordinate(point);

   400

   401

    // sanity check

   402

    assert(point != prevPoint);

   403

   404

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

   405

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

   406

   407

    // always add our own direction to normal

   408

    Vector normal = DIRECTIONS[dirIdx];

   409

   410

    // check the two pixels clockwise from the impact direction

   411

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

   412

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

   413

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

   414

        }

   415

    }

   416

   417

    // check the two pixels counterclockwise from the impact direction

   418

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

   419

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

   420

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

   421

        }

   422

    }

   423

   424

    // sanity check

   425

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

   426

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

   427

    }

   428

   429

    return normal;

   430

}

   431

   432

#if GRAPHICS_ENABLED

   433

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

   434

    // XXX: can we optimize this somehow?

   435

   436

    // load the terrain pixbuf as a surface

   437

    CL_Surface surf (pixbuf);

   438

   439

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

   440

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

   441

}

   442

#endif

   443