00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include <math.h>
00014 #include "clear_map.h"
00015 #include "void_map.h"
00016 #include "genworld.h"
00017 #include "core/random_func.hpp"
00018 #include "landscape_type.h"
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00154 typedef int16 height_t;
00155 static const int height_decimal_bits = 4;
00156 static const height_t _invalid_height = -32768;
00157
00159 typedef int amplitude_t;
00160 static const int amplitude_decimal_bits = 10;
00161
00163 struct HeightMap
00164 {
00165 height_t *h;
00166 uint dim_x;
00167 uint total_size;
00168 uint size_x;
00169 uint size_y;
00170
00177 inline height_t &height(uint x, uint y)
00178 {
00179 return h[x + y * dim_x];
00180 }
00181 };
00182
00184 static HeightMap _height_map = {NULL, 0, 0, 0, 0};
00185
00187 #define I2H(i) ((i) << height_decimal_bits)
00188
00189 #define H2I(i) ((i) >> height_decimal_bits)
00190
00192 #define I2A(i) ((i) << amplitude_decimal_bits)
00193
00194 #define A2I(i) ((i) >> amplitude_decimal_bits)
00195
00197 #define A2H(a) ((a) >> (amplitude_decimal_bits - height_decimal_bits))
00198
00199
00201 #define FOR_ALL_TILES_IN_HEIGHT(h) for (h = _height_map.h; h < &_height_map.h[_height_map.total_size]; h++)
00202
00204 static const int TGP_FREQUENCY_MAX = 6;
00205
00210 static const amplitude_t _amplitudes_by_smoothness_and_frequency[4][TGP_FREQUENCY_MAX + 1] = {
00211
00212
00213 {16000, 5600, 1968, 688, 240, 16, 16},
00214
00215 {16000, 16000, 6448, 3200, 1024, 128, 16},
00216
00217 {16000, 19200, 12800, 8000, 3200, 256, 64},
00218
00219 {24000, 16000, 19200, 16000, 8000, 512, 320},
00220 };
00221
00223 static const amplitude_t _water_percent[4] = {20, 80, 250, 400};
00224
00226 static const int8 _max_height[4] = {
00227 6,
00228 9,
00229 12,
00230 15,
00231 };
00232
00239 static inline bool IsValidXY(uint x, uint y)
00240 {
00241 return ((int)x) >= 0 && x < _height_map.size_x && ((int)y) >= 0 && y < _height_map.size_y;
00242 }
00243
00244
00249 static inline bool AllocHeightMap()
00250 {
00251 height_t *h;
00252
00253 _height_map.size_x = MapSizeX();
00254 _height_map.size_y = MapSizeY();
00255
00256
00257 _height_map.total_size = (_height_map.size_x + 1) * (_height_map.size_y + 1);
00258 _height_map.dim_x = _height_map.size_x + 1;
00259 _height_map.h = CallocT<height_t>(_height_map.total_size);
00260
00261
00262 FOR_ALL_TILES_IN_HEIGHT(h) *h = _invalid_height;
00263
00264 return true;
00265 }
00266
00268 static inline void FreeHeightMap()
00269 {
00270 if (_height_map.h == NULL) return;
00271 free(_height_map.h);
00272 _height_map.h = NULL;
00273 }
00274
00280 static inline height_t RandomHeight(amplitude_t rMax)
00281 {
00282 amplitude_t ra = (Random() << 16) | (Random() & 0x0000FFFF);
00283 height_t rh;
00284
00285 rh = A2H(ra % (2 * rMax + 1) - rMax);
00286 return rh;
00287 }
00288
00307 static bool ApplyNoise(uint log_frequency, amplitude_t amplitude)
00308 {
00309 uint size_min = min(_height_map.size_x, _height_map.size_y);
00310 uint step = size_min >> log_frequency;
00311 uint x, y;
00312
00313
00314 assert(_height_map.h != NULL);
00315
00316
00317 if (step == 0) return false;
00318
00319 if (log_frequency == 0) {
00320
00321 for (y = 0; y <= _height_map.size_y; y += step) {
00322 for (x = 0; x <= _height_map.size_x; x += step) {
00323 height_t height = (amplitude > 0) ? RandomHeight(amplitude) : 0;
00324 _height_map.height(x, y) = height;
00325 }
00326 }
00327 return true;
00328 }
00329
00330
00331
00332 for (y = 0; y <= _height_map.size_y; y += 2 * step) {
00333 for (x = 0; x < _height_map.size_x; x += 2 * step) {
00334 height_t h00 = _height_map.height(x + 0 * step, y);
00335 height_t h02 = _height_map.height(x + 2 * step, y);
00336 height_t h01 = (h00 + h02) / 2;
00337 _height_map.height(x + 1 * step, y) = h01;
00338 }
00339 }
00340
00341
00342 for (y = 0; y < _height_map.size_y; y += 2 * step) {
00343 for (x = 0; x <= _height_map.size_x; x += step) {
00344 height_t h00 = _height_map.height(x, y + 0 * step);
00345 height_t h20 = _height_map.height(x, y + 2 * step);
00346 height_t h10 = (h00 + h20) / 2;
00347 _height_map.height(x, y + 1 * step) = h10;
00348 }
00349 }
00350
00351
00352 for (y = 0; y <= _height_map.size_y; y += step) {
00353 for (x = 0; x <= _height_map.size_x; x += step) {
00354 _height_map.height(x, y) += RandomHeight(amplitude);
00355 }
00356 }
00357
00358 return (step > 1);
00359 }
00360
00362 static void HeightMapGenerate()
00363 {
00364 uint size_min = min(_height_map.size_x, _height_map.size_y);
00365 uint iteration_round = 0;
00366 amplitude_t amplitude;
00367 bool continue_iteration;
00368 int log_size_min, log_frequency_min;
00369 int log_frequency;
00370
00371
00372 for (log_size_min = TGP_FREQUENCY_MAX; (1U << log_size_min) < size_min; log_size_min++) { }
00373 log_frequency_min = log_size_min - TGP_FREQUENCY_MAX;
00374
00375
00376 assert(log_frequency_min >= 0);
00377
00378
00379 do {
00380 log_frequency = iteration_round - log_frequency_min;
00381 if (log_frequency >= 0) {
00382
00383 assert(log_frequency <= TGP_FREQUENCY_MAX);
00384 amplitude = _amplitudes_by_smoothness_and_frequency[_settings_game.game_creation.tgen_smoothness][log_frequency];
00385 } else {
00386
00387 amplitude = 0;
00388 }
00389 continue_iteration = ApplyNoise(iteration_round, amplitude);
00390 iteration_round++;
00391 } while (continue_iteration);
00392 assert(log_frequency == TGP_FREQUENCY_MAX);
00393 }
00394
00396 static void HeightMapGetMinMaxAvg(height_t *min_ptr, height_t *max_ptr, height_t *avg_ptr)
00397 {
00398 height_t h_min, h_max, h_avg, *h;
00399 int64 h_accu = 0;
00400 h_min = h_max = _height_map.height(0, 0);
00401
00402
00403 FOR_ALL_TILES_IN_HEIGHT(h) {
00404 if (*h < h_min) h_min = *h;
00405 if (*h > h_max) h_max = *h;
00406 h_accu += *h;
00407 }
00408
00409
00410 h_avg = (height_t)(h_accu / (_height_map.size_x * _height_map.size_y));
00411
00412
00413 if (min_ptr != NULL) *min_ptr = h_min;
00414 if (max_ptr != NULL) *max_ptr = h_max;
00415 if (avg_ptr != NULL) *avg_ptr = h_avg;
00416 }
00417
00419 static int *HeightMapMakeHistogram(height_t h_min, height_t h_max, int *hist_buf)
00420 {
00421 int *hist = hist_buf - h_min;
00422 height_t *h;
00423
00424
00425 FOR_ALL_TILES_IN_HEIGHT(h) {
00426 assert(*h >= h_min);
00427 assert(*h <= h_max);
00428 hist[*h]++;
00429 }
00430 return hist;
00431 }
00432
00434 static void HeightMapSineTransform(height_t h_min, height_t h_max)
00435 {
00436 height_t *h;
00437
00438 FOR_ALL_TILES_IN_HEIGHT(h) {
00439 double fheight;
00440
00441 if (*h < h_min) continue;
00442
00443
00444 fheight = (double)(*h - h_min) / (double)(h_max - h_min);
00445
00446 switch (_settings_game.game_creation.landscape) {
00447 case LT_TOYLAND:
00448 case LT_TEMPERATE:
00449
00450 fheight = 2 * fheight - 1;
00451
00452 fheight = sin(fheight * M_PI_2);
00453
00454 fheight = 0.5 * (fheight + 1);
00455 break;
00456
00457 case LT_ARCTIC:
00458 {
00459
00460
00461 double sine_upper_limit = 0.75;
00462 double linear_compression = 2;
00463 if (fheight >= sine_upper_limit) {
00464
00465 fheight = 1.0 - (1.0 - fheight) / linear_compression;
00466 } else {
00467 double m = 1.0 - (1.0 - sine_upper_limit) / linear_compression;
00468
00469 fheight = 2.0 * fheight / sine_upper_limit - 1.0;
00470
00471 fheight = sin(fheight * M_PI_2);
00472
00473 fheight = 0.5 * (fheight + 1.0) * m;
00474 }
00475 }
00476 break;
00477
00478 case LT_TROPIC:
00479 {
00480
00481
00482 double sine_lower_limit = 0.5;
00483 double linear_compression = 2;
00484 if (fheight <= sine_lower_limit) {
00485
00486 fheight = fheight / linear_compression;
00487 } else {
00488 double m = sine_lower_limit / linear_compression;
00489
00490 fheight = 2.0 * ((fheight - sine_lower_limit) / (1.0 - sine_lower_limit)) - 1.0;
00491
00492 fheight = sin(fheight * M_PI_2);
00493
00494 fheight = 0.5 * ((1.0 - m) * fheight + (1.0 + m));
00495 }
00496 }
00497 break;
00498
00499 default:
00500 NOT_REACHED();
00501 break;
00502 }
00503
00504 *h = (height_t)(fheight * (h_max - h_min) + h_min);
00505 if (*h < 0) *h = I2H(0);
00506 if (*h >= h_max) *h = h_max - 1;
00507 }
00508 }
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527 struct control_point_t {
00528 height_t x;
00529 height_t y;
00530 };
00531
00532 struct control_point_list_t {
00533 size_t length;
00534 const control_point_t *list;
00535 };
00536
00537 static const control_point_t _curve_map_1[] = {
00538 { 0, 0 }, { 48, 24 }, { 192, 32 }, { 240, 96 }
00539 };
00540
00541 static const control_point_t _curve_map_2[] = {
00542 { 0, 0 }, { 16, 24 }, { 128, 32 }, { 192, 64 }, { 240, 144 }
00543 };
00544
00545 static const control_point_t _curve_map_3[] = {
00546 { 0, 0 }, { 16, 24 }, { 128, 64 }, { 192, 144 }, { 240, 192 }
00547 };
00548
00549 static const control_point_t _curve_map_4[] = {
00550 { 0, 0 }, { 16, 24 }, { 96, 72 }, { 160, 192 }, { 220, 239 }, { 240, 239 }
00551 };
00552
00553 static const control_point_list_t _curve_maps[] = {
00554 { lengthof(_curve_map_1), _curve_map_1 },
00555 { lengthof(_curve_map_2), _curve_map_2 },
00556 { lengthof(_curve_map_3), _curve_map_3 },
00557 { lengthof(_curve_map_4), _curve_map_4 },
00558 };
00559
00560 static void HeightMapCurves(uint level)
00561 {
00562 height_t ht[lengthof(_curve_maps)];
00563
00564
00565 uint sx = Clamp(1 << level, 2, 32);
00566 uint sy = Clamp(1 << level, 2, 32);
00567 byte *c = (byte *)alloca(sx * sy);
00568
00569 for (uint i = 0; i < sx * sy; i++) {
00570 c[i] = Random() % lengthof(_curve_maps);
00571 }
00572
00573
00574 for (uint x = 0; x < _height_map.size_x; x++) {
00575
00576
00577 float fx = (float)(sx * x) / _height_map.size_x + 0.5f;
00578 uint x1 = (uint)fx;
00579 uint x2 = x1;
00580 float xr = 2.0f * (fx - x1) - 1.0f;
00581 xr = sin(xr * M_PI_2);
00582 xr = sin(xr * M_PI_2);
00583 xr = 0.5f * (xr + 1.0f);
00584 float xri = 1.0f - xr;
00585
00586 if (x1 > 0) {
00587 x1--;
00588 if (x2 >= sx) x2--;
00589 }
00590
00591 for (uint y = 0; y < _height_map.size_y; y++) {
00592
00593
00594 float fy = (float)(sy * y) / _height_map.size_y + 0.5f;
00595 uint y1 = (uint)fy;
00596 uint y2 = y1;
00597 float yr = 2.0f * (fy - y1) - 1.0f;
00598 yr = sin(yr * M_PI_2);
00599 yr = sin(yr * M_PI_2);
00600 yr = 0.5f * (yr + 1.0f);
00601 float yri = 1.0f - yr;
00602
00603 if (y1 > 0) {
00604 y1--;
00605 if (y2 >= sy) y2--;
00606 }
00607
00608 uint corner_a = c[x1 + sx * y1];
00609 uint corner_b = c[x1 + sx * y2];
00610 uint corner_c = c[x2 + sx * y1];
00611 uint corner_d = c[x2 + sx * y2];
00612
00613
00614
00615 uint corner_bits = 0;
00616 corner_bits |= 1 << corner_a;
00617 corner_bits |= 1 << corner_b;
00618 corner_bits |= 1 << corner_c;
00619 corner_bits |= 1 << corner_d;
00620
00621 height_t *h = &_height_map.height(x, y);
00622
00623
00624 for (uint t = 0; t < lengthof(_curve_maps); t++) {
00625 if (!HasBit(corner_bits, t)) continue;
00626
00627 const control_point_t *cm = _curve_maps[t].list;
00628 for (uint i = 0; i < _curve_maps[t].length - 1; i++) {
00629 const control_point_t &p1 = cm[i];
00630 const control_point_t &p2 = cm[i + 1];
00631
00632 if (*h >= p1.x && *h < p2.x) {
00633 ht[t] = p1.y + (*h - p1.x) * (p2.y - p1.y) / (p2.x - p1.x);
00634 break;
00635 }
00636 }
00637 }
00638
00639
00640 *h = (height_t)((ht[corner_a] * yri + ht[corner_b] * yr) * xri + (ht[corner_c] * yri + ht[corner_d] * yr) * xr);
00641 }
00642 }
00643 }
00644
00646 static void HeightMapAdjustWaterLevel(amplitude_t water_percent, height_t h_max_new)
00647 {
00648 height_t h_min, h_max, h_avg, h_water_level;
00649 int64 water_tiles, desired_water_tiles;
00650 height_t *h;
00651 int *hist;
00652
00653 HeightMapGetMinMaxAvg(&h_min, &h_max, &h_avg);
00654
00655
00656 int *hist_buf = CallocT<int>(h_max - h_min + 1);
00657
00658 hist = HeightMapMakeHistogram(h_min, h_max, hist_buf);
00659
00660
00661 desired_water_tiles = A2I(((int64)water_percent) * (int64)(_height_map.size_x * _height_map.size_y));
00662
00663
00664 for (h_water_level = h_min, water_tiles = 0; h_water_level < h_max; h_water_level++) {
00665 water_tiles += hist[h_water_level];
00666 if (water_tiles >= desired_water_tiles) break;
00667 }
00668
00669
00670
00671
00672
00673
00674
00675 FOR_ALL_TILES_IN_HEIGHT(h) {
00676
00677 *h = (height_t)(((int)h_max_new) * (*h - h_water_level) / (h_max - h_water_level)) + I2H(1);
00678
00679 if (*h < 0) *h = I2H(0);
00680 if (*h >= h_max_new) *h = h_max_new - 1;
00681 }
00682
00683 free(hist_buf);
00684 }
00685
00686 static double perlin_coast_noise_2D(const double x, const double y, const double p, const int prime);
00687
00708 static void HeightMapCoastLines(uint8 water_borders)
00709 {
00710 int smallest_size = min(_settings_game.game_creation.map_x, _settings_game.game_creation.map_y);
00711 const int margin = 4;
00712 uint y, x;
00713 double max_x;
00714 double max_y;
00715
00716
00717 for (y = 0; y <= _height_map.size_y; y++) {
00718 if (HasBit(water_borders, BORDER_NE)) {
00719
00720 max_x = abs((perlin_coast_noise_2D(_height_map.size_y - y, y, 0.9, 53) + 0.25) * 5 + (perlin_coast_noise_2D(y, y, 0.35, 179) + 1) * 12);
00721 max_x = max((smallest_size * smallest_size / 16) + max_x, (smallest_size * smallest_size / 16) + margin - max_x);
00722 if (smallest_size < 8 && max_x > 5) max_x /= 1.5;
00723 for (x = 0; x < max_x; x++) {
00724 _height_map.height(x, y) = 0;
00725 }
00726 }
00727
00728 if (HasBit(water_borders, BORDER_SW)) {
00729
00730 max_x = abs((perlin_coast_noise_2D(_height_map.size_y - y, y, 0.85, 101) + 0.3) * 6 + (perlin_coast_noise_2D(y, y, 0.45, 67) + 0.75) * 8);
00731 max_x = max((smallest_size * smallest_size / 16) + max_x, (smallest_size * smallest_size / 16) + margin - max_x);
00732 if (smallest_size < 8 && max_x > 5) max_x /= 1.5;
00733 for (x = _height_map.size_x; x > (_height_map.size_x - 1 - max_x); x--) {
00734 _height_map.height(x, y) = 0;
00735 }
00736 }
00737 }
00738
00739
00740 for (x = 0; x <= _height_map.size_x; x++) {
00741 if (HasBit(water_borders, BORDER_NW)) {
00742
00743 max_y = abs((perlin_coast_noise_2D(x, _height_map.size_y / 2, 0.9, 167) + 0.4) * 5 + (perlin_coast_noise_2D(x, _height_map.size_y / 3, 0.4, 211) + 0.7) * 9);
00744 max_y = max((smallest_size * smallest_size / 16) + max_y, (smallest_size * smallest_size / 16) + margin - max_y);
00745 if (smallest_size < 8 && max_y > 5) max_y /= 1.5;
00746 for (y = 0; y < max_y; y++) {
00747 _height_map.height(x, y) = 0;
00748 }
00749 }
00750
00751 if (HasBit(water_borders, BORDER_SE)) {
00752
00753 max_y = abs((perlin_coast_noise_2D(x, _height_map.size_y / 3, 0.85, 71) + 0.25) * 6 + (perlin_coast_noise_2D(x, _height_map.size_y / 3, 0.35, 193) + 0.75) * 12);
00754 max_y = max((smallest_size * smallest_size / 16) + max_y, (smallest_size * smallest_size / 16) + margin - max_y);
00755 if (smallest_size < 8 && max_y > 5) max_y /= 1.5;
00756 for (y = _height_map.size_y; y > (_height_map.size_y - 1 - max_y); y--) {
00757 _height_map.height(x, y) = 0;
00758 }
00759 }
00760 }
00761 }
00762
00764 static void HeightMapSmoothCoastInDirection(int org_x, int org_y, int dir_x, int dir_y)
00765 {
00766 const int max_coast_dist_from_edge = 35;
00767 const int max_coast_Smooth_depth = 35;
00768
00769 int x, y;
00770 int ed;
00771 int depth;
00772
00773 height_t h_prev = 16;
00774 height_t h;
00775
00776 assert(IsValidXY(org_x, org_y));
00777
00778
00779 for (x = org_x, y = org_y, ed = 0; IsValidXY(x, y) && ed < max_coast_dist_from_edge; x += dir_x, y += dir_y, ed++) {
00780
00781 if (_height_map.height(x, y) > 15) break;
00782
00783
00784 if (IsValidXY(x + dir_y, y + dir_x) && _height_map.height(x + dir_y, y + dir_x) > 0) break;
00785
00786
00787 if (IsValidXY(x - dir_y, y - dir_x) && _height_map.height(x - dir_y, y - dir_x) > 0) break;
00788 }
00789
00790
00791
00792 for (depth = 0; IsValidXY(x, y) && depth <= max_coast_Smooth_depth; depth++, x += dir_x, y += dir_y) {
00793 h = _height_map.height(x, y);
00794 h = min(h, h_prev + (4 + depth));
00795 _height_map.height(x, y) = h;
00796 h_prev = h;
00797 }
00798 }
00799
00801 static void HeightMapSmoothCoasts(uint8 water_borders)
00802 {
00803 uint x, y;
00804
00805 for (x = 0; x < _height_map.size_x; x++) {
00806 if (HasBit(water_borders, BORDER_NW)) HeightMapSmoothCoastInDirection(x, 0, 0, 1);
00807 if (HasBit(water_borders, BORDER_SE)) HeightMapSmoothCoastInDirection(x, _height_map.size_y - 1, 0, -1);
00808 }
00809
00810 for (y = 0; y < _height_map.size_y; y++) {
00811 if (HasBit(water_borders, BORDER_NE)) HeightMapSmoothCoastInDirection(0, y, 1, 0);
00812 if (HasBit(water_borders, BORDER_SW)) HeightMapSmoothCoastInDirection(_height_map.size_x - 1, y, -1, 0);
00813 }
00814 }
00815
00823 static void HeightMapSmoothSlopes(height_t dh_max)
00824 {
00825 int x, y;
00826 for (y = 0; y <= (int)_height_map.size_y; y++) {
00827 for (x = 0; x <= (int)_height_map.size_x; x++) {
00828 height_t h_max = min(_height_map.height(x > 0 ? x - 1 : x, y), _height_map.height(x, y > 0 ? y - 1 : y)) + dh_max;
00829 if (_height_map.height(x, y) > h_max) _height_map.height(x, y) = h_max;
00830 }
00831 }
00832 for (y = _height_map.size_y; y >= 0; y--) {
00833 for (x = _height_map.size_x; x >= 0; x--) {
00834 height_t h_max = min(_height_map.height((uint)x < _height_map.size_x ? x + 1 : x, y), _height_map.height(x, (uint)y < _height_map.size_y ? y + 1 : y)) + dh_max;
00835 if (_height_map.height(x, y) > h_max) _height_map.height(x, y) = h_max;
00836 }
00837 }
00838 }
00839
00847 static void HeightMapNormalize()
00848 {
00849 int sea_level_setting = _settings_game.difficulty.quantity_sea_lakes;
00850 const amplitude_t water_percent = sea_level_setting != (int)CUSTOM_SEA_LEVEL_NUMBER_DIFFICULTY ? _water_percent[sea_level_setting] : _settings_game.game_creation.custom_sea_level * 1024 / 100;
00851 const height_t h_max_new = I2H(_max_height[_settings_game.difficulty.terrain_type]);
00852 const height_t roughness = 7 + 3 * _settings_game.game_creation.tgen_smoothness;
00853
00854 HeightMapAdjustWaterLevel(water_percent, h_max_new);
00855
00856 byte water_borders = _settings_game.construction.freeform_edges ? _settings_game.game_creation.water_borders : 0xF;
00857 if (water_borders == BORDERS_RANDOM) water_borders = GB(Random(), 0, 4);
00858
00859 HeightMapCoastLines(water_borders);
00860 HeightMapSmoothSlopes(roughness);
00861
00862 HeightMapSmoothCoasts(water_borders);
00863 HeightMapSmoothSlopes(roughness);
00864
00865 HeightMapSineTransform(12, h_max_new);
00866
00867 if (_settings_game.game_creation.variety > 0) {
00868 HeightMapCurves(_settings_game.game_creation.variety);
00869 }
00870
00871 HeightMapSmoothSlopes(16);
00872 }
00873
00881 static double int_noise(const long x, const long y, const int prime)
00882 {
00883 long n = x + y * prime + _settings_game.game_creation.generation_seed;
00884
00885 n = (n << 13) ^ n;
00886
00887
00888 return 1.0 - (double)((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0;
00889 }
00890
00891
00895 static inline double linear_interpolate(const double a, const double b, const double x)
00896 {
00897 return a + x * (b - a);
00898 }
00899
00900
00905 static double interpolated_noise(const double x, const double y, const int prime)
00906 {
00907 const int integer_X = (int)x;
00908 const int integer_Y = (int)y;
00909
00910 const double fractional_X = x - (double)integer_X;
00911 const double fractional_Y = y - (double)integer_Y;
00912
00913 const double v1 = int_noise(integer_X, integer_Y, prime);
00914 const double v2 = int_noise(integer_X + 1, integer_Y, prime);
00915 const double v3 = int_noise(integer_X, integer_Y + 1, prime);
00916 const double v4 = int_noise(integer_X + 1, integer_Y + 1, prime);
00917
00918 const double i1 = linear_interpolate(v1, v2, fractional_X);
00919 const double i2 = linear_interpolate(v3, v4, fractional_X);
00920
00921 return linear_interpolate(i1, i2, fractional_Y);
00922 }
00923
00924
00931 static double perlin_coast_noise_2D(const double x, const double y, const double p, const int prime)
00932 {
00933 double total = 0.0;
00934 int i;
00935
00936 for (i = 0; i < 6; i++) {
00937 const double frequency = (double)(1 << i);
00938 const double amplitude = pow(p, (double)i);
00939
00940 total += interpolated_noise((x * frequency) / 64.0, (y * frequency) / 64.0, prime) * amplitude;
00941 }
00942
00943 return total;
00944 }
00945
00946
00948 static void TgenSetTileHeight(TileIndex tile, int height)
00949 {
00950 SetTileHeight(tile, height);
00951
00952
00953 if (TileX(tile) != MapMaxX() && TileY(tile) != MapMaxY() &&
00954 (!_settings_game.construction.freeform_edges || (TileX(tile) != 0 && TileY(tile) != 0))) {
00955 MakeClear(tile, CLEAR_GRASS, 3);
00956 }
00957 }
00958
00966 void GenerateTerrainPerlin()
00967 {
00968 uint x, y;
00969
00970 if (!AllocHeightMap()) return;
00971 GenerateWorldSetAbortCallback(FreeHeightMap);
00972
00973 HeightMapGenerate();
00974
00975 IncreaseGeneratingWorldProgress(GWP_LANDSCAPE);
00976
00977 HeightMapNormalize();
00978
00979 IncreaseGeneratingWorldProgress(GWP_LANDSCAPE);
00980
00981
00982 if (_settings_game.construction.freeform_edges) {
00983 for (y = 0; y < _height_map.size_y - 1; y++) MakeVoid(_height_map.size_x * y);
00984 for (x = 0; x < _height_map.size_x; x++) MakeVoid(x);
00985 }
00986
00987
00988 for (y = 0; y < _height_map.size_y; y++) {
00989 for (x = 0; x < _height_map.size_x; x++) {
00990 int height = H2I(_height_map.height(x, y));
00991 if (height < 0) height = 0;
00992 if (height > 15) height = 15;
00993 TgenSetTileHeight(TileXY(x, y), height);
00994 }
00995 }
00996
00997 IncreaseGeneratingWorldProgress(GWP_LANDSCAPE);
00998
00999 FreeHeightMap();
01000 GenerateWorldSetAbortCallback(NULL);
01001 }