1

#include "Terrain.hh"

     3

#include "Engine.hh"

     4

     5

#include <cmath>

     6

#include <cassert>

     7

#include <algorithm>

     8

#include <ClanLib/display.h>

     9

    13

}

    14

    34

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

    35

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

    36

            double sum = 0;

    37

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

    38

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

    39

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

    40

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

    41

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

    42

        }

    43

    }

    44

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

    45

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

    46

            double sum = 0;

    47

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

    48

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

    49

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

    50

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

    51

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

    52

        }

    53

    }

    54

}

    57

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

    58

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

    59

            double sum = 0;

    60

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

    61

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

    62

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

    63

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

    64

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

    65

        }

    66

    }

    67

}

    68

    69

/**

    70

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

    71

 */

    73

    int texturesize = 128;

    74

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

    75

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

    76

    double str = 0.8;

    77

    double H = 0.8;

    78

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

    79

        fractal_diamond(land, texturesize, str, i);

    80

        fractal_step(land, texturesize, str, i);

    81

        str *= H;

    82

    }

    83

    double min = 100000;

    84

    double max = -100000;

    85

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

    86

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

    87

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

    88

    }

    89

    max -= min;

    90

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

    91

        land[i] -= min;

    92

    }

    93

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

    94

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

    95

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

    96

    }

    97

}

    98

    99

/**

   100

 * Changes color depending on x and y values

   101

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

   102

 */

   106

    int red = color.get_red();

   107

    int green = color.get_green();

   108

    int blue = color.get_blue();

   115

        red = 0;

   117

        red = 255;

   120

        green = 0;

   127

        blue = 255;

   128

   129

    color = CL_Color(red, green, blue);

   130

}

   131

   132

/**

   133

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

   134

 */

   137

        color = CL_Color(0, 0, 0);

   138

        return;

   139

    }

   143

        color = COLOR_EMPTY;

   144

        break;

   147

        color = COLOR_DIRT;

   148

        break;

   151

        color = COLOR_ROCK;

   152

        break;

   153

    }

   156

}

   157

   160

    generate_texture();

   164

   165

    CL_Color color;

   174

        }

   175

    }

   176

}

   177

   180

}

   181

   184

}

   185

   191

}

   192

   206

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

   207

    // returns the point where we collided.

   208

   209

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

   210

    // "pixels" of the line.

   213

   214

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

   218

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

   219

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

   220

    }

   224

        std::swap(b, e);

   225

    }

   231

    // Is the line ascending or descending

   238

    // Go trough the line

   244

                return true;

   245

            }

   246

        } else {

   249

                return true;

   250

            }

   251

        }

   253

        err = err - dy;

   257

            y = y + ystep;

   258

            err = err + dx;

   259

        }

   260

    }

   262

    return false; // No Collision

   263

}

   264

   266

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

   267

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

   268

   285

                }

   286

            }

   287

        }

   288

    }

   289

}

   290

   291

/**

   292

 * Gets the index of the given coordinate direction

   293

 * referring to the DIRECTIONS table in Physics.hh

   294

 */

   296

    Vector dir = direction.roundToInt();

   297

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

   298

        return 0;

   300

        return 1;

   302

        return 2;

   304

        return 3;

   306

        return 4;

   308

        return 5;

   310

        return 6;

   312

        return 7;

   313

    }

   315

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

   316

    return 0;

   317

}

   318

   319

/**

   320

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

   321

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

   322

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

   323

 */

   324

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

   326

   327

    assert(point != prevPoint);

   328

   329

    Vector normal(0,0);

   330

   331

    // These two must be rounded separately

   332

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

   333

   334

    normal += DIRECTIONS[dirIdx];

   336

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

   338

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

   339

        }

   340

    }

   342

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

   344

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

   345

        }

   346

    }

   347

   349

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

   350

    }

   351

   352

    return normal;

   353

}

   354

   357

    Vector tmp(v);

   362

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

   363

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

   365

    return tmp;

   366

}

   367

   368

// TODO: This could better :)

   369

// TODO: And this need some cleaning :)

   371

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

   372

   373

    // Some constants to control random generation

   374

    const int min_range = 25;

   375

    const int max_range = 80;

   376

    const int num = 50;

   377

    const int rock_rarity = 4;

   378

   379

    // Generate circles (or whatever)

   380

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

   381

        // Random generate circle attributes

   384

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

   385

   386

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

   387

        if (i == 0) {

   390

            range = 150;

   391

        }

   392

   397

        }

   398

   399

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

   400

        // now)

   412

                    terrain[x][y] = type;

   413

                }

   414

            }

   415

        } 

   416

    }

   417

   419

    this->generatePixelBuffer();

   420

}

   421

   425

}

   426

   427

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

   428

    return terrain;

   429

}

   430