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

Terrain::Terrain (void) :

    11

    map_width(0), map_height(0)

    12

{

    13

}

    14

    15

Terrain::Terrain (PixelDimension map_width, PixelDimension map_height, int seed) :

    16

    terrain(map_width, std::vector<TerrainType>(map_height, TERRAIN_DIRT)),

    17

    map_width(map_width), 

    18

    map_height(map_height)

    19

{

    20

    generateTerrain(seed);

    21

}

    22

    23

Terrain::Terrain (const Terrain &t) 

    24

{

    25

    map_width = t.map_width;

    26

    map_height = t.map_height;

    27

    terrain = t.terrain;

    28

    29

    generatePixelBuffer();

    30

}

    31

    32

/*

    33

 * Texture generation util functions

    34

 */

    35

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

    36

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

    37

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

    38

            double sum = 0;

    39

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

    40

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

    41

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

    42

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

    43

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

    44

        }

    45

    }

    46

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

    47

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

    48

            double sum = 0;

    49

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

    50

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

    51

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

    52

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

    53

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

    54

        }

    55

    }

    56

}

    57

    58

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

    59

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

    60

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

    61

            double sum = 0;

    62

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

    63

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

    64

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

    65

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

    66

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

    67

        }

    68

    }

    69

}

    70

    71

/**

    72

 * Algorithm read from http://www.gameprogrammer.com/fractal.html

    73

 */

    74

void Terrain::generate_texture (void) {

    75

    int texturesize = 128;

    76

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

    77

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

    78

    double str = 0.8;

    79

    double H = 0.8;

    80

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

    81

        fractal_diamond(land, texturesize, str, i);

    82

        fractal_step(land, texturesize, str, i);

    83

        str *= H;

    84

    }

    85

    double min = 100000;

    86

    double max = -100000;

    87

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

    88

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

    89

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

    90

    }

    91

    max -= min;

    92

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

    93

        land[i] -= min;

    94

    }

    95

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

    96

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

    97

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

    98

    }

    99

}

   100

   101

/**

   102

 * Changes color depending on x and y values

   103

 * x and y should be valid coordinates (not outside)

   104

 */

   105

void Terrain::noisifyPixel(CL_Color& color, PixelCoordinate pc) {

   106

    int tx = pc.x % texture.size();

   107

    int ty = pc.y % texture[0].size();

   108

    int red = color.get_red();

   109

    int green = color.get_green();

   110

    int blue = color.get_blue();

   111

   112

    red += texture[tx][ty] / 8 - 16;

   113

    green += texture[tx][ty] / 8 - 16;

   114

    blue += texture[tx][ty] / 8 - 16;

   115

   116

    if (red < 0)

   117

        red = 0;

   118

    else if (red >= 256)

   119

        red = 255;

   120

   121

    if (green < 0)

   122

        green = 0;

   123

    else if (green >= 256)

   124

        green = 255;

   125

   126

    if (blue < 0)

   127

        blue = 0;

   128

    else if (blue >= 256)

   129

        blue = 255;

   130

   131

    color = CL_Color(red, green, blue);

   132

}

   133

   134

/**

   135

 * Sets to color the correct color of pixel in (x,y)

   136

 */

   137

void Terrain::loadPixelColor(CL_Color& color, PixelCoordinate pc) {

   138

    if ((pc.x < 0) || (pc.y < 0) || (pc.x >= map_width) || (pc.y >= map_height)) {

   139

        color = CL_Color(0, 0, 0);

   140

        return;

   141

    }

   142

   143

    switch (terrain[pc.x][pc.y]) {

   144

    case TERRAIN_EMPTY:

   145

        color = COLOR_EMPTY;

   146

        break;

   147

   148

    case TERRAIN_DIRT:

   149

        color = COLOR_DIRT;

   150

        break;

   151

   152

    case TERRAIN_ROCK:

   153

        color = COLOR_ROCK;

   154

        break;

   155

    }

   156

   157

    noisifyPixel(color, pc);

   158

}

   159

   160

void Terrain::generatePixelBuffer (void) {

   161

    // initialze texture

   162

    generate_texture();

   163

   164

    // create pixel buffer

   165

    pixbuf = CL_PixelBuffer(map_width, map_height, 4 * map_width, CL_PixelFormat::rgba8888);

   166

   167

    CL_Color color;

   168

   169

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

   170

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

   171

            PixelCoordinate pc(x, y);

   172

   173

            loadPixelColor(color, pc);

   174

   175

            pixbuf.draw_pixel(pc.x, pc.y, color);

   176

        }

   177

    }

   178

}

   179

   180

PixelCoordinate Terrain::getPixelCoordinate (Vector point) const {

   181

    // XXX: assume 1:1

   182

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

   183

}

   184

   185

PixelCoordinate Terrain::getDimensions (void) const {

   186

    return PixelCoordinate(map_width, map_height);

   187

}

   188

   189

TerrainType Terrain::getType (PixelDimension px, PixelDimension py) const {

   190

    if ((px < 0) || (py < 0) ||(px >= map_width) || (py >= map_height))

   191

        return TERRAIN_ROCK;

   192

   193

    return terrain[px][py];

   194

}

   195

   196

TerrainType Terrain::getType (PixelCoordinate pc) const {

   197

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

   198

}

   199

   200

TerrainType Terrain::getType (Vector point) const {

   201

    return getType((PixelDimension) point.x, (PixelDimension) point.y);

   202

}

   203

   204

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

   205

    return (getType(point) != TERRAIN_EMPTY);

   206

}

   207

   208

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

   209

    // TODO: Maybe we should have another function prototype that also

   210

    // returns the point where we collided.

   211

   212

    // We'll use Bresenhams line algorithm to go trough all the

   213

    // "pixels" of the line.

   214

    PixelCoordinate b = getPixelCoordinate(begin);

   215

    PixelCoordinate e = getPixelCoordinate(end);

   216

   217

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

   218

   219

    if (steep) { 

   220

        // Line is steep -> swap x and y coordinates

   221

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

   222

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

   223

    }

   224

   225

    if (b.x > e.x) { 

   226

        // Line goes down -> make it go up

   227

        std::swap(b, e);

   228

    }

   229

   230

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

   231

    PixelDimension err = dx / 2;

   232

    PixelDimension ystep, y = b.y;

   233

   234

    // Is the line ascending or descending

   235

    if (b.y < e.y) 

   236

        ystep = 1;

   237

   238

    else 

   239

        ystep = -1;

   240

   241

    // Go trough the line

   242

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

   243

        if (steep) { 

   244

            // X and Y coordinates must be switched if steep

   245

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

   246

                // Collision!

   247

                return true;

   248

            }

   249

        } else {

   250

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

   251

                // Collision!

   252

                return true;

   253

            }

   254

        }

   255

   256

        err = err - dy;

   257

   258

        if (err < 0) { 

   259

            // Check if we want to make an ystep

   260

            y = y + ystep;

   261

            err = err + dx;

   262

        }

   263

    }

   264

   265

    return false; // No Collision

   266

}

   267

   268

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

   269

    // TODO: Implement. Some circle algoritmh should be usefull here,

   270

    // though the current impelementation doesn't seem too bad either.

   271

   272

    PixelCoordinate mid = getPixelCoordinate(pos);

   273

    PixelDimension r = (unsigned int) radius; // XXX: scale

   274

   275

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

   276

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

   277

            PixelCoordinate pc(i, j);

   278

   279

            if (getType(pc) != TERRAIN_ROCK) { 

   280

                // getType returns ROCK if out of bounds

   281

   282

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

   283

                    terrain[i][j] = TERRAIN_EMPTY;

   284

   285

                    CL_Color color;

   286

                    loadPixelColor(color, pc);

   287

                    pixbuf.draw_pixel(pc.x, pc.y, color);

   288

                }

   289

            }

   290

        }

   291

    }

   292

}

   293

   294

/**

   295

 * Gets the index of the given coordinate direction

   296

 * referring to the DIRECTIONS table in Physics.hh

   297

 */

   298

static int getDirectionIndex (Vector direction) {

   299

    Vector dir = direction.roundToInt();

   300

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

   301

        return 0;

   302

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

   303

        return 1;

   304

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

   305

        return 2;

   306

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

   307

        return 3;

   308

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

   309

        return 4;

   310

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

   311

        return 5;

   312

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

   313

        return 6;

   314

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

   315

        return 7;

   316

    }

   317

   318

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

   319

    return 0;

   320

}

   321

   322

/**

   323

 * point should be ground and prevPoint air, but it's easy to assure that

   324

 * @param point - pixel on ground to which was collided

   325

 * @param prevPoint - pixel where we are when we collide

   326

 */

   327

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

   328

    PixelCoordinate p = getPixelCoordinate(point);

   329

   330

    assert(point != prevPoint);

   331

   332

    Vector normal(0,0);

   333

   334

    // These two must be rounded separately

   335

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

   336

   337

    normal += DIRECTIONS[dirIdx];

   338

   339

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

   340

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

   341

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

   342

        }

   343

    }

   344

   345

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

   346

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

   347

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

   348

        }

   349

    }

   350

   351

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

   352

        Engine::log(DEBUG, "Physics.getNormal ") << "logic ground error";

   353

    }

   354

   355

    return normal;

   356

}

   357

   358

// XXX: weird vectors

   359

Vector direction (const Vector &v) {

   360

    Vector tmp(v);

   361

   362

    if (tmp.length() > 0) 

   363

        tmp /= tmp.length();

   364

   365

    tmp.x = (uint16_t)(tmp.x);

   366

    tmp.y = (uint16_t)(tmp.y);

   367

   368

    return tmp;

   369

}

   370

   371

// TODO: This could better :)

   372

// TODO: And this need some cleaning :)

   373

void Terrain::generateTerrain (int seed) {

   374

    srand(seed); // Set random number generator seed.

   375

   376

    // Some constants to control random generation

   377

    const int min_range = 25;

   378

    const int max_range = 80;

   379

    const int num = 50;

   380

    const int rock_rarity = 4;

   381

   382

    // Generate circles (or whatever)

   383

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

   384

        // Random generate circle attributes

   385

        PixelCoordinate mid(rand() % map_width, rand() % map_width);

   386

   387

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

   388

   389

        // Make sure that there's a circle in the midle of the cave

   390

        if (i == 0) {

   391

            mid.x = map_width / 2;

   392

            mid.y = map_height / 2;

   393

            range = 150;

   394

        }

   395

   396

        TerrainType type = TERRAIN_EMPTY;

   397

   398

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

   399

            type = TERRAIN_ROCK;

   400

        }

   401

   402

        // Loops for every pixel of the cirlcle (or square as it seems

   403

        // now)

   404

        for (

   405

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

   406

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

   407

            x++

   408

        ) {

   409

            for (

   410

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

   411

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

   412

                y++

   413

            ) {

   414

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

   415

                    terrain[x][y] = type;

   416

                }

   417

            }

   418

        } 

   419

    }

   420

   421

    // regenerate pixel buffer

   422

    this->generatePixelBuffer();

   423

}

   424

   425

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

   426

    CL_Surface surf (pixbuf);

   427

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

   428

}

   429

   430

std::vector<std::vector<TerrainType> > Terrain::getTerrain() const {

   431

    return terrain;

   432

}

   433