00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include "debug.h"
00014 #include "core/alloc_func.hpp"
00015 #include "settings_type.h"
00016 #include "tile_map.h"
00017 #include "water_map.h"
00018
00019 #if defined(_MSC_VER)
00020
00021 extern "C" _CRTIMP void __cdecl _assert(void *, void *, unsigned);
00022 #endif
00023
00024 uint _map_log_x;
00025 uint _map_log_y;
00026 uint _map_size_x;
00027 uint _map_size_y;
00028 uint _map_size;
00029 uint _map_tile_mask;
00030
00031 Tile *_m = NULL;
00032 TileExtended *_me = NULL;
00033 TileHeightData *_map_heightdata = NULL;
00034
00035
00056 void AllocateMap(uint size_x, uint size_y, bool allocate_map_heightdata)
00057 {
00058 DEBUG(map, 2, "Min/max map size %d/%d, max map tiles %d", MIN_MAP_SIZE, MAX_MAP_SIZE, MAX_MAP_TILES);
00059 DEBUG(map, 1, "Allocating map of size %dx%d", size_x, size_y);
00060
00061
00062
00063 if (size_x * size_y > MAX_MAP_TILES ||
00064 size_x < MIN_MAP_SIZE ||
00065 size_y < MIN_MAP_SIZE ||
00066 (size_x & (size_x - 1)) != 0 ||
00067 (size_y & (size_y - 1)) != 0) {
00068 error("Invalid map size");
00069 }
00070
00071 _map_log_x = FindFirstBit(size_x);
00072 _map_log_y = FindFirstBit(size_y);
00073 _map_size_x = size_x;
00074 _map_size_y = size_y;
00075 _map_size = size_x * size_y;
00076 _map_tile_mask = _map_size - 1;
00077
00078 free(_m);
00079 free(_me);
00080
00081 _m = CallocT<Tile>(_map_size);
00082 _me = CallocT<TileExtended>(_map_size);
00083
00084 if (allocate_map_heightdata && AllowMoreHeightlevels()) {
00085 _map_heightdata = ReallocT<TileHeightData>(_map_heightdata, _map_size);
00086 }
00087 }
00088
00096 void CopyHeightlevelDataFromOldToExtended()
00097 {
00098 _map_heightdata = ReallocT<TileHeightData>(_map_heightdata, MapSize());
00099
00100 for (TileIndex i = 0; i < MapSize(); i++) {
00101 _map_heightdata[i].heightlevel = GB(_m[i].type_height, 0, 4);
00102 }
00103 }
00104
00115 bool CopyHeightlevelDataFromExtendedToOld()
00116 {
00117 for (TileIndex i = 0; i < MapSize(); i++) {
00118 uint heightlevel = _map_heightdata[i].heightlevel;
00119
00120 if (heightlevel >= 16) {
00121
00122
00123 return false;
00124 } else {
00125 SB(_m[i].type_height, 0, 4, heightlevel);
00126 }
00127 }
00128
00129 free(_map_heightdata);
00130 _map_heightdata = NULL;
00131
00132 return true;
00133 }
00134
00135 #ifdef _DEBUG
00136 TileIndex TileAdd(TileIndex tile, TileIndexDiff add,
00137 const char *exp, const char *file, int line)
00138 {
00139 int dx;
00140 int dy;
00141 uint x;
00142 uint y;
00143
00144 dx = add & MapMaxX();
00145 if (dx >= (int)MapSizeX() / 2) dx -= MapSizeX();
00146 dy = (add - dx) / (int)MapSizeX();
00147
00148 x = TileX(tile) + dx;
00149 y = TileY(tile) + dy;
00150
00151 if (x >= MapSizeX() || y >= MapSizeY()) {
00152 char buf[512];
00153
00154 snprintf(buf, lengthof(buf), "TILE_ADD(%s) when adding 0x%.4X and 0x%.4X failed",
00155 exp, tile, add);
00156 #if !defined(_MSC_VER) || defined(WINCE)
00157 fprintf(stderr, "%s:%d %s\n", file, line, buf);
00158 #else
00159 _assert(buf, (char*)file, line);
00160 #endif
00161 }
00162
00163 assert(TileXY(x, y) == TILE_MASK(tile + add));
00164
00165 return TileXY(x, y);
00166 }
00167 #endif
00168
00182 TileIndex TileAddWrap(TileIndex tile, int addx, int addy)
00183 {
00184 uint x = TileX(tile) + addx;
00185 uint y = TileY(tile) + addy;
00186
00187
00188 if (_settings_game.construction.freeform_edges && (x == 0 || y == 0)) return INVALID_TILE;
00189
00190
00191 if (x < MapMaxX() && y < MapMaxY()) return tile + TileDiffXY(addx, addy);
00192
00193 return INVALID_TILE;
00194 }
00195
00197 extern const TileIndexDiffC _tileoffs_by_diagdir[] = {
00198 {-1, 0},
00199 { 0, 1},
00200 { 1, 0},
00201 { 0, -1}
00202 };
00203
00205 extern const TileIndexDiffC _tileoffs_by_dir[] = {
00206 {-1, -1},
00207 {-1, 0},
00208 {-1, 1},
00209 { 0, 1},
00210 { 1, 1},
00211 { 1, 0},
00212 { 1, -1},
00213 { 0, -1}
00214 };
00215
00225 uint DistanceManhattan(TileIndex t0, TileIndex t1)
00226 {
00227 const uint dx = Delta(TileX(t0), TileX(t1));
00228 const uint dy = Delta(TileY(t0), TileY(t1));
00229 return dx + dy;
00230 }
00231
00232
00242 uint DistanceSquare(TileIndex t0, TileIndex t1)
00243 {
00244 const int dx = TileX(t0) - TileX(t1);
00245 const int dy = TileY(t0) - TileY(t1);
00246 return dx * dx + dy * dy;
00247 }
00248
00249
00257 uint DistanceMax(TileIndex t0, TileIndex t1)
00258 {
00259 const uint dx = Delta(TileX(t0), TileX(t1));
00260 const uint dy = Delta(TileY(t0), TileY(t1));
00261 return max(dx, dy);
00262 }
00263
00264
00273 uint DistanceMaxPlusManhattan(TileIndex t0, TileIndex t1)
00274 {
00275 const uint dx = Delta(TileX(t0), TileX(t1));
00276 const uint dy = Delta(TileY(t0), TileY(t1));
00277 return dx > dy ? 2 * dx + dy : 2 * dy + dx;
00278 }
00279
00285 uint DistanceFromEdge(TileIndex tile)
00286 {
00287 const uint xl = TileX(tile);
00288 const uint yl = TileY(tile);
00289 const uint xh = MapSizeX() - 1 - xl;
00290 const uint yh = MapSizeY() - 1 - yl;
00291 const uint minl = min(xl, yl);
00292 const uint minh = min(xh, yh);
00293 return min(minl, minh);
00294 }
00295
00302 uint DistanceFromEdgeDir(TileIndex tile, DiagDirection dir)
00303 {
00304 switch (dir) {
00305 case DIAGDIR_NE: return TileX(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
00306 case DIAGDIR_NW: return TileY(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
00307 case DIAGDIR_SW: return MapMaxX() - TileX(tile) - 1;
00308 case DIAGDIR_SE: return MapMaxY() - TileY(tile) - 1;
00309 default: NOT_REACHED();
00310 }
00311 }
00312
00326 bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
00327 {
00328 assert(proc != NULL);
00329 assert(size > 0);
00330
00331 if (size % 2 == 1) {
00332
00333
00334 if (proc(*tile, user_data)) return true;
00335
00336
00337
00338 *tile = TILE_ADD(*tile, TileOffsByDir(DIR_N));
00339 return CircularTileSearch(tile, size / 2, 1, 1, proc, user_data);
00340 } else {
00341 return CircularTileSearch(tile, size / 2, 0, 0, proc, user_data);
00342 }
00343 }
00344
00364 bool CircularTileSearch(TileIndex *tile, uint radius, uint w, uint h, TestTileOnSearchProc proc, void *user_data)
00365 {
00366 assert(proc != NULL);
00367 assert(radius > 0);
00368
00369 uint x = TileX(*tile) + w + 1;
00370 uint y = TileY(*tile);
00371
00372 const uint extent[DIAGDIR_END] = { w, h, w, h };
00373
00374 for (uint n = 0; n < radius; n++) {
00375 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
00376
00377 for (uint j = extent[dir] + n * 2 + 1; j != 0; j--) {
00378 if (x < MapSizeX() && y < MapSizeY()) {
00379 TileIndex t = TileXY(x, y);
00380
00381 if (proc(t, user_data)) {
00382
00383 *tile = t;
00384 return true;
00385 }
00386 }
00387
00388
00389 x += _tileoffs_by_diagdir[dir].x;
00390 y += _tileoffs_by_diagdir[dir].y;
00391 }
00392 }
00393
00394 x += _tileoffs_by_dir[DIR_W].x;
00395 y += _tileoffs_by_dir[DIR_W].y;
00396 }
00397
00398 *tile = INVALID_TILE;
00399 return false;
00400 }
00401
00408 uint GetClosestWaterDistance(TileIndex tile, bool water)
00409 {
00410 if (HasTileWaterGround(tile) == water) return 0;
00411
00412 uint max_dist = water ? 0x7F : 0x200;
00413
00414 int x = TileX(tile);
00415 int y = TileY(tile);
00416
00417 uint max_x = MapMaxX();
00418 uint max_y = MapMaxY();
00419 uint min_xy = _settings_game.construction.freeform_edges ? 1 : 0;
00420
00421
00422 for (uint dist = 1; dist < max_dist; dist++) {
00423
00424 y--;
00425
00426
00427 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
00428 static const int8 ddx[DIAGDIR_END] = { -1, 1, 1, -1};
00429 static const int8 ddy[DIAGDIR_END] = { 1, 1, -1, -1};
00430
00431 int dx = ddx[dir];
00432 int dy = ddy[dir];
00433
00434
00435 for (uint a = 0; a < dist; a++) {
00436
00437 if (IsInsideMM(x, min_xy, max_x) && IsInsideMM(y, min_xy, max_y)) {
00438 TileIndex t = TileXY(x, y);
00439 if (HasTileWaterGround(t) == water) return dist;
00440 }
00441 x += dx;
00442 y += dy;
00443 }
00444 }
00445 }
00446
00447 if (!water) {
00448
00449 for (TileIndex t = 0; t < MapSize(); t++) {
00450 if (!IsTileType(t, MP_VOID) && !IsTileType(t, MP_WATER)) return 0x1FF;
00451 }
00452 }
00453
00454 return max_dist;
00455 }