1

#include "Terrain.hh"

     2

#include "Engine.hh"

     3

     4

#include <cmath>

     5

#include <cassert>

     6

#include <algorithm>

     7

#include <ClanLib/display.h>

     8

     9

Terrain::Terrain() {}

    10

Terrain::Terrain(const int &seed) 

    11

    : terrain(MAP_WIDTH, std::vector<TerrainType>(MAP_HEIGHT, DIRT)){

    12

    this->generateTerrain(seed);

    13

}

    14

Terrain::Terrain(const Terrain &t) {

    15

    this->terrain = t.getTerrain();

    16

    this->generatePixelBuffer();

    17

}

    18

    19

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

    20

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

    21

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

    22

            double sum = 0;

    23

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

    24

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

    25

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

    26

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

    27

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

    28

        }

    29

    }

    30

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

    31

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

    32

            double sum = 0;

    33

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

    34

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

    35

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

    36

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

    37

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

    38

        }

    39

    }

    40

}

    41

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

    42

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

    43

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

    44

            double sum = 0;

    45

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

    46

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

    47

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

    48

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

    49

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

    50

        }

    51

    }

    52

}

    53

    57

void Terrain::generate_texture() {

    58

    int texturesize = 128;

    59

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

    60

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

    61

    double str = 0.8;

    63

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

    64

        fractal_diamond(land, texturesize, str, i);

    65

        fractal_step(land, texturesize, str, i);

    66

        str *= H;

    67

    }

    68

    double min = 100000;

    69

    double max = -100000;

    70

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

    71

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

    72

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

    73

    }

    74

    max -= min;

    75

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

    76

        land[i] -= min;

    77

    }

    78

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

    79

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

    80

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

    81

    }

    82

}

    83

    84

/**

    85

 * Changes color depending on x and y values

    86

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

    87

 */

    88

void Terrain::noisifyPixel(CL_Color& color, int x, int y) {

    89

    int tx = x%texture.size();

    90

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

    91

    int red = color.get_red();

    92

    int green = color.get_green();

    93

    int blue = color.get_blue();

    94

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

    95

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

    96

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

    97

    if(red < 0)

    98

        red = 0;

    99

    if(red >= 256)

   100

        red = 255;

   101

    if(green < 0)

   102

        green = 0;

   103

    if(blue >= 256)

   104

        blue = 255;

   105

    if(blue < 0)

   106

        blue = 0;

   107

    if(green >= 256)

   108

        green = 255;

   109

   110

    color = CL_Color(red, green, blue);

   111

}

   112

   113

/**

   114

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

   115

 */

   116

void Terrain::loadPixelColor(CL_Color& color, int x, int y) {

   117

    if ((x < 0) || (y < 0) ||(x >= MAP_WIDTH) || (y >= MAP_HEIGHT)) {

   118

        color = CL_Color(0, 0, 0);

   119

        return;

   120

    }

   121

    switch(terrain[x][y]) {

   122

    case EMPTY:

   123

        color = COLOR_EMPTY;

   124

        noisifyPixel(color, x, y);

   125

        break;

   126

    case DIRT:

   127

        color = COLOR_DIRT;

   128

        noisifyPixel(color, x, y);

   129

        break;

   130

    case ROCK:

   131

        color = COLOR_ROCK;

   132

        noisifyPixel(color, x, y);

   133

        break;

   134

    }

   135

}

   136

   137

void Terrain::generatePixelBuffer() {

   138

    generate_texture();

   139

    this->pixbuf = CL_PixelBuffer(MAP_WIDTH, MAP_HEIGHT, 4*MAP_WIDTH, 

   140

                                  CL_PixelFormat::rgba8888);

   141

   142

    CL_Color color;

   143

    for (uint16_t i = 0; i < MAP_WIDTH; i++) {

   144

        for (uint16_t j = 0; j < MAP_HEIGHT; j++) {

   145

            switch(terrain[i][j]) {

   146

            case EMPTY:

   147

                color = COLOR_EMPTY;

   148

                break;

   149

            case DIRT:

   150

                color = COLOR_DIRT;

   151

                break;

   152

            case ROCK:

   153

                color = COLOR_ROCK;

   154

                break;

   155

            default: // TODO: Shouldn't be here.

   156

                break; 

   157

            }

   158

            loadPixelColor(color, i, j);

   159

            this->pixbuf.draw_pixel(i, j, color);

   160

        }

   161

    }

   162

}

   163

   164

Vector Terrain::getPixelLocation(Vector point) const{

   165

    return Vector(scale(point.x), 

   166

                  scale(point.y));

   167

}

   168

   169

uint16_t Terrain::scale(float x) const {

   170

    return (uint16_t)(x/MAP_SCALE);

   171

}

   172

   173

TerrainType Terrain::getType(int32_t x, int32_t y) const {

   174

    if ((x < 0) || (y < 0) ||(x >= MAP_WIDTH) || (y >= MAP_HEIGHT)) {

   175

        return ROCK;

   176

    }

   177

    return terrain[x][y];

   178

}

   179

TerrainType Terrain::getType(Vector point) const {

   180

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

   181

}

   182

   183

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

   184

    return (getType(point) != EMPTY);

   185

}

   186

   187

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

   188

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

   189

    // returns the point where we collided.

   190

   191

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

   192

    // "pixels" of the line.

   193

    Vector b = getPixelLocation(begin);

   194

    Vector e = getPixelLocation(end);

   195

   196

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

   197

    if (steep) { // Line is steep -> swap x and y coordinates

   198

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

   199

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

   200

    }

   201

    if (b.x > e.x) { // Line goes down -> make it go up

   202

        std::swap(b, e);

   203

    }

   204

    uint16_t dx = e.x - b.x;

   205

    uint16_t dy = abs(e.y - b.y);

   206

    int32_t err = dx/2;

   207

    uint16_t ystep;

   208

    uint16_t y = b.y;

   209

    // Is the line ascending or descending

   210

    if (b.y < e.y) ystep = 1;

   211

    else ystep = -1;

   212

    // Go trough the line

   213

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

   214

        if (steep) { // X and Y coordinates must be switched if steep

   215

            if (getType(y,x) != EMPTY) { // Collision!

   216

                return true;

   217

            }

   218

        } else {

   219

            if (getType(x,y) != EMPTY) { // Collision!

   220

                return true;

   221

            }

   222

        }

   223

        err = err - dy;

   224

        if (err < 0) { // Check if we want to make an ystep

   225

            y = y + ystep;

   226

            err = err + dx;

   227

        }

   228

    }

   229

    return false; // No Collision

   230

}

   231

   232

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

   233

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

   234

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

   235

   236

    Vector mid = getPixelLocation(pos);

   237

    uint16_t r = scale(radius);

   238

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

   239

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

   240

            if (getType(i, j) != ROCK) { // getType returns ROCK if

   241

                                         // out of bounds

   242

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

   243

                    terrain[i][j] = EMPTY;

   244

                    CL_Color color(0, 0, 0);

   245

                    loadPixelColor(color, i, j);

   246

                    pixbuf.draw_pixel(i, j, color);

   247

                }

   248

            }

   249

        }

   250

    }

   251

}

   252

   253

/**

   254

 * Gets the index of the given coordinate direction

   255

 * referring to the DIRECTIONS table in Physics.hh

   256

 */

   257

int getDirectionIndex (Vector direction) {

   258

    Vector dir = direction.roundToInt();

   259

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

   260

        return 0;

   261

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

   262

        return 1;

   263

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

   264

        return 2;

   265

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

   266

        return 3;

   267

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

   268

        return 4;

   269

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

   270

        return 5;

   271

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

   272

        return 6;

   273

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

   274

        return 7;

   275

    }

   276

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

   277

    return 0;

   278

}

   279

   280

/**

   281

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

   282

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

   283

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

   284

 */

   285

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

   286

    Vector p = getPixelLocation(point);

   287

   288

    assert(point != prevPoint);

   289

   290

    Vector normal(0,0);

   291

   292

    // These two must be rounded separately

   293

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

   294

//    dirIdx = (dirIdx+4)%8;

   295

   296

    normal += DIRECTIONS[dirIdx];

   297

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

   298

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

   299

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

   300

        }

   301

    }

   302

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

   303

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

   304

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

   305

        }

   306

    }

   307

   308

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

   309

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

   310

    }

   311

   312

   313

//    for (int i = 0; i < 8; i++) {

   314

//        if (getType(p.x+DIRECTIONS[i].x, p.y+DIRECTIONS[i].y) == EMPTY) {

   315

//            normal += DIRECTIONS[i];

   316

//        }

   317

//    }

   318

   319

   320

    // Special cases

   321

    /*    Vector tmp = direction(direction(prevPoint-point) + direction(normal));

   322

    Engine::log(DEBUG, "Terrain.getNormal") << "tmp: " << tmp;

   323

    if (normal.length() == 0 || (tmp.x != 0 && tmp.y != 0 && getType(tmp.x, tmp.y) != EMPTY)) 

   324

        normal = prevPoint - point; // Direct hit

   325

    */

   326

//    Engine::log(DEBUG, "Terrain.getNormal") << "Normal: " << normal;

   327

    return normal;

   328

    return Vector(0,-1);

   329

}

   330

   331

Vector direction(const Vector &v) {

   332

    Vector tmp(v);

   333

    if (tmp.length() > 0) tmp /= tmp.length();

   334

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

   335

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

   336

    return tmp;

   337

}

   338

   339

// TODO: This could better :)

   340

// TODO: And this need some cleaning :)

   341

void Terrain::generateTerrain(int seed) {

   342

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

   343

   344

    // Some constants to control random generation

   345

    const int min_range = 25;

   346

    const int max_range = 80;

   347

    const int num = 50;

   348

    const int rock_rarity = 4;

   349

   350

    // Generate circles (or whatever)

   351

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

   352

        // Random generate circle attributes

   353

        int midx = rand()%MAP_WIDTH;

   354

        int midy = rand()%MAP_HEIGHT;

   355

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

   356

   357

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

   358

        if (i == 0) {

   359

            midx = MAP_WIDTH/2;

   360

            midy = MAP_WIDTH/2;

   361

            range = 150;

   362

        }

   363

   364

        TerrainType type = EMPTY;

   365

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

   366

            type = ROCK;

   367

        }

   368

   369

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

   370

        // now)

   371

        for (int x = std::max(0, midx-range); 

   372

             x < std::min((int32_t)MAP_WIDTH, midx+range); 

   373

             x++) {

   374

            for (int y = std::max(0, midy-range);

   375

                    y < std::min((int32_t)MAP_HEIGHT, midy+range);

   376

                    y++) {

   377

   378

                //terrain[x][y] = type;

   379

   380

                if ((x-midx)*(x-midx)+(y-midy)*(y-midy) < range*range) {

   381

                    terrain[x][y] = type;

   382

                }

   383

            }

   384

   385

        } 

   386

   387

    }

   388

   389

    this->generatePixelBuffer();

   390

}

   391

   392

void Terrain::draw(CL_GraphicContext *gc) {

   393

    CL_Surface surf(this->pixbuf);

   394

    surf.draw(0,0,gc);

   395

}

   396

   397

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

   398

    return terrain;

   399

}

   400