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

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 (void) :

    22

    map_width(0), map_height(0)

    23

{

    24

}

    25

    26

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

    27

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

    28

    map_width(map_width), 

    29

    map_height(map_height)

    30

{

    31

    generateTerrain(seed);

    32

}

    33

    34

Terrain::Terrain (const Terrain &t) 

    35

{

    36

    map_width = t.map_width;

    37

    map_height = t.map_height;

    38

    terrain = t.terrain;

    39

    40

    generatePixelBuffer();

    41

}

    42

    43

/*

    44

 * Texture generation util functions

    45

 */

    46

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

    47

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

    48

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

    49

            double sum = 0;

    50

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

    51

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

    52

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

    53

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

    54

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

    55

        }

    56

    }

    57

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

    58

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

    59

            double sum = 0;

    60

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

    61

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

    62

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

    63

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

    64

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

    65

        }

    66

    }

    67

}

    68

    69

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

    70

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

    71

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

    72

            double sum = 0;

    73

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

    74

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

    75

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

    76

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

    77

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

    78

        }

    79

    }

    80

}

    81

    82

void Terrain::generate_texture (void) {

    83

    int texturesize = 128;

    84

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

    85

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

    86

    double str = 0.8;

    87

    double H = 0.8;

    88

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

    89

        fractal_diamond(land, texturesize, str, i);

    90

        fractal_step(land, texturesize, str, i);

    91

        str *= H;

    92

    }

    93

    double min = 100000;

    94

    double max = -100000;

    95

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

    96

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

    97

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

    98

    }

    99

    max -= min;

   100

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

   101

        land[i] -= min;

   102

    }

   103

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

   104

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

   105

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

   106

    }

   107

}

   108

   109

/**

   110

 * Changes color depending on x and y values

   111

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

   112

 */

   113

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

   114

    int texture_fade = 8;

   115

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

   116

    case TERRAIN_EMPTY:

   117

        break;

   118

    case TERRAIN_DIRT:

   119

        texture_fade = 4;

   120

        break;

   121

    case TERRAIN_ROCK:

   122

        texture_fade = 2;

   123

        break;

   124

    }

   125

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

   126

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

   127

    int red = color.get_red();

   128

    int green = color.get_green();

   129

    int blue = color.get_blue();

   130

   131

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

   132

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

   133

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

   134

   135

    if (red < 0)

   136

        red = 0;

   137

    else if (red >= 256)

   138

        red = 255;

   139

   140

    if (green < 0)

   141

        green = 0;

   142

    else if (green >= 256)

   143

        green = 255;

   144

   145

    if (blue < 0)

   146

        blue = 0;

   147

    else if (blue >= 256)

   148

        blue = 255;

   149

   150

    color = CL_Color(red, green, blue);

   151

}

   152

   153

/**

   154

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

   155

 */

   156

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

   157

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

   158

        color = CL_Color(0, 0, 0);

   159

        return;

   160

    }

   161

   162

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

   163

    case TERRAIN_EMPTY:

   164

        color = COLOR_EMPTY;

   165

        break;

   166

   167

    case TERRAIN_DIRT:

   168

        color = COLOR_DIRT;

   169

        break;

   170

   171

    case TERRAIN_ROCK:

   172

        color = COLOR_ROCK;

   173

        break;

   174

    }

   175

   176

    noisifyPixel(color, pc);

   177

}

   178

   179

void Terrain::generatePixelBuffer (void) {

   180

    // initialze texture

   181

    generate_texture();

   182

   183

    // create pixel buffer

   184

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

   185

   186

    CL_Color color;

   187

   188

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

   189

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

   190

            PixelCoordinate pc(x, y);

   191

   192

            loadPixelColor(color, pc);

   193

   194

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

   195

        }

   196

    }

   197

}

   198

   199

PixelCoordinate Terrain::getPixelCoordinate (Vector point) const {

   200

    // XXX: assume 1:1

   201

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

   202

}

   203

   204

PixelCoordinate Terrain::getDimensions (void) const {

   205

    return PixelCoordinate(map_width, map_height);

   206

}

   207

   208

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

   209

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

   210

        return TERRAIN_ROCK;

   211

   212

    return terrain[px][py];

   213

}

   214

   215

TerrainType Terrain::getType (PixelCoordinate pc) const {

   216

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

   217

}

   218

   219

TerrainType Terrain::getType (Vector point) const {

   220

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

   221

}

   222

   223

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

   224

    return (getType(point) != TERRAIN_EMPTY);

   225

}

   226

   227

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

   228

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

   229

    // returns the point where we collided.

   230

   231

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

   232

    // "pixels" of the line.

   233

    PixelCoordinate b = getPixelCoordinate(begin);

   234

    PixelCoordinate e = getPixelCoordinate(end);

   235

   236

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

   237

   238

    if (steep) { 

   239

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

   240

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

   241

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

   242

    }

   243

   244

    if (b.x > e.x) { 

   245

        // Line goes down -> make it go up

   246

        std::swap(b, e);

   247

    }

   248

   249

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

   250

    PixelDimension err = dx / 2;

   251

    PixelDimension ystep, y = b.y;

   252

   253

    // Is the line ascending or descending

   254

    if (b.y < e.y) 

   255

        ystep = 1;

   256

   257

    else 

   258

        ystep = -1;

   259

   260

    // Go trough the line

   261

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

   262

        if (steep) { 

   263

            // X and Y coordinates must be switched if steep

   264

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

   265

                // Collision!

   266

                return true;

   267

            }

   268

        } else {

   269

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

   270

                // Collision!

   271

                return true;

   272

            }

   273

        }

   274

   275

        err = err - dy;

   276

   277

        if (err < 0) { 

   278

            // Check if we want to make an ystep

   279

            y = y + ystep;

   280

            err = err + dx;

   281

        }

   282

    }

   283

   284

    return false; // No Collision

   285

}

   286

   287

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

   288

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

   289

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

   290

   291

    PixelCoordinate mid = getPixelCoordinate(pos);

   292

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

   293

   294

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

   295

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

   296

            PixelCoordinate pc(i, j);

   297

   298

            if (getType(pc) != TERRAIN_ROCK) { 

   299

                // getType returns ROCK if out of bounds

   300

   301

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

   302

                    terrain[i][j] = TERRAIN_EMPTY;

   303

   304

                    CL_Color color;

   305

                    loadPixelColor(color, pc);

   306

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

   307

                }

   308

            }

   309

        }

   310

    }

   311

}

   312

   313

/**

   314

 * Gets the index of the given coordinate direction

   315

 * referring to the DIRECTIONS table in Physics.hh

   316

 */

   317

static int getDirectionIndex (Vector direction) {

   318

    Vector dir = direction.roundToInt();

   321

        return 0;

   322

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

   323

        return 1;

   324

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

   325

        return 2;

   326

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

   327

        return 3;

   328

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

   329

        return 4;

   330

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

   331

        return 5;

   332

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

   333

        return 6;

   334

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

   335

        return 7;

   336

    }

   337

   338

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

   339

    return 0;

   340

}

   341

   342

/**

   343

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

   344

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

   345

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

   346

 */

   347

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

   348

    PixelCoordinate p = getPixelCoordinate(point);

   349

   350

    assert(point != prevPoint);

   351

   352

    Vector normal(0,0);

   353

   354

    // These two must be rounded separately

   355

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

   356

   357

    normal += DIRECTIONS[dirIdx];

   358

   359

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

   360

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

   361

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

   362

        }

   363

    }

   364

   365

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

   366

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

   367

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

   368

        }

   369

    }

   370

   371

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

   372

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

   373

    }

   374

   375

    return normal;

   376

}

   377

   378

// TODO: This could better :)

   379

// TODO: And this need some cleaning :)

   380

void Terrain::generateTerrain (int seed) {

   381

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

   382

   383

    // Some constants to control random generation

   384

    const int min_range = 25;

   385

    const int max_range = 80;

   386

    const int num = 50;

   387

    const int rock_rarity = 4;

   388

   389

    // Generate circles (or whatever)

   390

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

   391

        // Random generate circle attributes

   392

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

   393

   394

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

   395

   396

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

   397

        if (i == 0) {

   398

            mid.x = map_width / 2;

   399

            mid.y = map_height / 2;

   400

            range = 150;

   401

        }

   402

   403

        TerrainType type = TERRAIN_EMPTY;

   404

   405

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

   406

            type = TERRAIN_ROCK;

   407

        }

   408

   409

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

   410

        // now)

   411

        for (

   412

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

   413

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

   414

            x++

   415

        ) {

   416

            for (

   417

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

   418

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

   419

                y++

   420

            ) {

   421

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

   422

                    terrain[x][y] = type;

   423

                }

   424

            }

   425

        } 

   426

    }

   427

   428

    // regenerate pixel buffer

   429

    this->generatePixelBuffer();

   430

}

   431

   432

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

   433

    CL_Surface surf (pixbuf);

   434

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

   435

}

   436

   437

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

   438

    return terrain;

   439

}

   440