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 Terrain::generatePixelBuffer() {

    20

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

    21

                                  CL_PixelFormat::rgba8888);

    22

    23

    CL_Color color;

    24

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

    25

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

    26

            switch(terrain[i][j]) {

    27

            case EMPTY:

    28

                color = COLOR_EMPTY;

    29

                break;

    30

            case DIRT:

    31

                color = COLOR_DIRT;

    32

                break;

    33

            case ROCK:

    34

                color = COLOR_ROCK;

    35

                break;

    36

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

    37

                break; 

    38

            }

    39

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

    40

        }

    41

    }

    42

}

    43

    44

Vector Terrain::getPixelLocation(Vector point) const{

    45

    return Vector(scale(point.x), 

    46

                  scale(point.y));

    47

}

    48

    49

uint16_t Terrain::scale(float x) const {

    50

    return (uint16_t)(x/MAP_SCALE);

    51

}

    52

    53

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

    54

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

    55

        return ROCK;

    56

    }

    57

    return terrain[x][y];

    58

}

    59

TerrainType Terrain::getType(Vector point) const {

    60

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

    61

}

    62

    63

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

    65

}

    66

    67

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

    68

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

    69

    // returns the point where we collided.

    70

    71

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

    72

    // "pixels" of the line.

    73

    Vector b = getPixelLocation(begin);

    74

    Vector e = getPixelLocation(end);

    75

    76

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

    77

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

    78

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

    79

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

    80

    }

    81

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

    82

        std::swap(b, e);

    83

    }

    84

    uint16_t dx = e.x - b.x;

    85

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

    86

    int32_t err = dx/2;

    87

    uint16_t ystep;

    88

    uint16_t y = b.y;

    89

    // Is the line ascending or descending

    90

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

    91

    else ystep = -1;

    92

    // Go trough the line

    93

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

    94

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

    95

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

    96

                return true;

    97

            }

    98

        } else {

    99

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

   100

                return true;

   101

            }

   102

        }

   103

        err = err - dy;

   104

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

   105

            y = y + ystep;

   106

            err = err + dx;

   107

        }

   108

    }

   109

    return false; // No Collision

   110

}

   111

   112

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

   113

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

   114

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

   115

   116

    Vector mid = getPixelLocation(pos);

   117

    uint16_t r = scale(radius);

   118

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

   119

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

   120

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

   121

                                         // out of bounds

   122

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

   123

                    terrain[i][j] = EMPTY;

   124

                    pixbuf.draw_pixel(i, j, COLOR_EMPTY);

   125

                }

   126

            }

   127

        }

   128

    }

   129

}

   130

   131

/**

   132

 * Gets the index of the given coordinate direction

   133

 * referring to the DIRECTIONS table in Physics.hh

   134

 */

   135

int getDirectionIndex (Vector direction) {

   136

    Vector dir = direction.roundToInt();

   137

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

   138

        return 0;

   139

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

   140

        return 1;

   141

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

   142

        return 2;

   143

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

   144

        return 3;

   145

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

   146

        return 4;

   147

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

   148

        return 5;

   149

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

   150

        return 6;

   151

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

   152

        return 7;

   153

    }

   154

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

   155

    return 0;

   156

}

   157

   158

/**

   159

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

   160

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

   161

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

   162

 */

   163

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

   164

    Vector p = getPixelLocation(point);

   165

   166

    assert(point != prevPoint);

   167

   168

    Vector normal(0,0);

   169

   170

    // These two must be rounded separately

   171

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

   172

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

   173

   174

    std::cout << (prevPoint.roundToInt()) - (point.roundToInt()) << prevPoint-point << std::endl;

   175

   176

    normal += DIRECTIONS[dirIdx];

   177

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

   178

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

   179

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

   180

        }

   181

    }

   182

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

   183

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

   184

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

   185

        }

   186

    }

   187

   188

    Engine::log(DEBUG, "Physics.getNormal ") << "normal: " << normal << "   dirIdx: " << dirIdx;

   189

   190

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

   191

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

   192

    }

   193

   194

   195

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

   196

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

   197

//            normal += DIRECTIONS[i];

   198

//        }

   199

//    }

   200

   201

   202

    // Special cases

   203

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

   204

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

   205

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

   206

        normal = prevPoint - point; // Direct hit

   207

    */

   208

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

   209

    return normal;

   210

    return Vector(0,-1);

   211

}

   212

   213

Vector direction(const Vector &v) {

   214

    Vector tmp(v);

   215

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

   216

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

   217

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

   218

    return tmp;

   219

}

   220

   221

// TODO: This could better :)

   222

// TODO: And this need some cleaning :)

   223

void Terrain::generateTerrain(int seed) {

   224

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

   225

   226

    // Some constants to control random generation

   227

    const int min_range = 25;

   228

    const int max_range = 80;

   229

    const int num = 50;

   230

    const int rock_rarity = 4;

   231

   232

    // Generate circles (or whatever)

   233

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

   234

        // Random generate circle attributes

   235

        int midx = rand()%MAP_WIDTH;

   236

        int midy = rand()%MAP_HEIGHT;

   237

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

   238

   239

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

   240

        if (i == 0) {

   241

            midx = MAP_WIDTH/2;

   242

            midy = MAP_WIDTH/2;

   243

            range = 150;

   244

        }

   245

   246

        TerrainType type = EMPTY;

   247

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

   248

            type = ROCK;

   249

        }

   250

   251

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

   252

        // now)

   253

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

   254

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

   255

             x++) {

   256

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

   257

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

   258

                    y++) {

   259

   260

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

   261

   262

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

   263

                    terrain[x][y] = type;

   264

                }

   265

            }

   266

   267

        } 

   268

   269

    }

   270

   271

    this->generatePixelBuffer();

   272

}

   273

   274

void Terrain::draw(CL_GraphicContext *gc) {

   275

    CL_Surface surf(this->pixbuf);

   276

    surf.draw(0,0,gc);

   277

}

   278

   279

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

   280

    return terrain;

   281

}

   282