1

#include "Terrain.hh"

     2

#include "Engine.hh"

     3

     4

#include <cmath>

     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)round(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

    60

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

    61

    Vector coor = getPixelLocation(point);

    62

    return (getType(coor.x, coor.y) != EMPTY);

    63

}

    64

    65

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

    66

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

    67

    // returns the point where we collided.

    68

    69

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

    70

    // "pixels" of the line.

    71

    Vector b = getPixelLocation(begin);

    72

    Vector e = getPixelLocation(end);

    73

    74

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

    75

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

    76

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

    77

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

    78

    }

    79

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

    80

        std::swap(b, e);

    81

    }

    82

    uint16_t dx = e.x - b.x;

    83

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

    84

    int32_t err = dx/2;

    85

    uint16_t ystep;

    86

    uint16_t y = b.y;

    87

    // Is the line ascending or descending

    88

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

    89

    else ystep = -1;

    90

    // Go trough the line

    91

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

    92

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

    93

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

    94

                return true;

    95

            }

    96

        } else {

    97

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

    98

                return true;

    99

            }

   100

        }

   101

        err = err - dy;

   102

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

   103

            y = y + ystep;

   104

            err = err + dx;

   105

        }

   106

    }

   107

    return false; // No Collision

   108

}

   109

   110

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

   111

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

   112

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

   113

   114

    Vector mid = getPixelLocation(pos);

   115

    uint16_t r = scale(radius);

   116

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

   117

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

   118

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

   119

                                         // out of bounds

   120

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

   121

                    terrain[i][j] = EMPTY;

   122

                    pixbuf.draw_pixel(i, j, COLOR_EMPTY);

   123

                }

   124

            }

   125

        }

   126

    }

   127

}

   128

   130

    Vector p = getPixelLocation(point);

   131

   132

    Vector normal(0,0);

   133

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

   134

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

   135

            normal += DIRECTIONS[i];

   136

        }

   137

    }

   139

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

   140

    return normal;

   141

}

   142

   143

// TODO: This could better :)

   144

// TODO: And this need some cleaning :)

   145

void Terrain::generateTerrain(int seed) {

   146

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

   147

   148

    // Some constants to control random generation

   149

    const int min_range = 25;

   150

    const int max_range = 80;

   151

    const int num = 50;

   152

    const int rock_rarity = 4;

   153

   154

    // Generate circles (or whatever)

   155

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

   156

        // Random generate circle attributes

   157

        int midx = rand()%MAP_WIDTH;

   158

        int midy = rand()%MAP_HEIGHT;

   159

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

   160

   161

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

   162

        if (i == 0) {

   163

            midx = MAP_WIDTH/2;

   164

            midy = MAP_WIDTH/2;

   165

            range = 150;

   166

        }

   167

   168

        TerrainType type = EMPTY;

   169

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

   170

            type = ROCK;

   171

        }

   172

   173

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

   174

        // now)

   175

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

   176

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

   177

             x++) {

   178

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

   179

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

   180

                 y++) {

   181

                terrain[x][y] = type;

   182

            }

   183

   184

        } 

   185

   186

    }

   187

   188

    this->generatePixelBuffer();

   189

}

   190

   191

void Terrain::draw(CL_GraphicContext *gc) {

   192

    CL_Surface surf(this->pixbuf);

   193

    surf.draw(0,0,gc);

   194

}

   195

   196

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

   197

    return terrain;

   198

}