OpenTTD Source: src/map.cpp Source File

OpenTTD Source 14.0-beta3

map.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10 #include "stdafx.h"
11 #include "debug.h"
12 #include "core/alloc_func.hpp"
13 #include "water_map.h"
14 #include "error_func.h"
15 #include "string_func.h"
16 #include "pathfinder/water_regions.h"
17
18 #include "safeguards.h"
19
20 #if defined(_MSC_VER)
21 /* Why the hell is that not in all MSVC headers?? */
22 extern "C" _CRTIMP void __cdecl _assert(void *, void *, unsigned);
23 #endif
24
25 /* static */ uint Map::log_x;
26 /* static */ uint Map::log_y;
27 /* static */ uint Map::size_x;
28 /* static */ uint Map::size_y;
29 /* static */ uint Map::size;
30 /* static */ uint Map::tile_mask;
31
32 /* static */ Tile::TileBase *Tile::base_tiles = nullptr;
33 /* static */ Tile::TileExtended *Tile::extended_tiles = nullptr;
34
35
41 /* static */ void Map::Allocate(uint size_x, uint size_y)
42 {
43 /* Make sure that the map size is within the limits and that
44 * size of both axes is a power of 2. */
45 if (!IsInsideMM(size_x, MIN_MAP_SIZE, MAX_MAP_SIZE + 1) ||
46 !IsInsideMM(size_y, MIN_MAP_SIZE, MAX_MAP_SIZE + 1) ||
47 (size_x & (size_x - 1)) != 0 ||
48 (size_y & (size_y - 1)) != 0) {
49 FatalError("Invalid map size");
50 }
51
52 Debug(map, 1, "Allocating map of size {}x{}", size_x, size_y);
53
54 Map::log_x = FindFirstBit(size_x);
55 Map::log_y = FindFirstBit(size_y);
56 Map::size_x = size_x;
57 Map::size_y = size_y;
58 Map::size = size_x * size_y;
59 Map::tile_mask = Map::size - 1;
60
61 free(Tile::base_tiles);
62 free(Tile::extended_tiles);
63
64 Tile::base_tiles = CallocT<Tile::TileBase>(Map::size);
65 Tile::extended_tiles = CallocT<Tile::TileExtended>(Map::size);
66
67 AllocateWaterRegions();
68 }
69
70
71 #ifdef _DEBUG
72 TileIndex TileAdd(TileIndex tile, TileIndexDiff add,
73 const char *exp, const char *file, int line)
74 {
75 int dx;
76 int dy;
77 uint x;
78 uint y;
79
80 dx = add & Map::MaxX();
81 if (dx >= (int)Map::SizeX() / 2) dx -= Map::SizeX();
82 dy = (add - dx) / (int)Map::SizeX();
83
84 x = TileX(tile) + dx;
85 y = TileY(tile) + dy;
86
87 if (x >= Map::SizeX() || y >= Map::SizeY()) {
88 std::string message = fmt::format("TILE_ADD({}) when adding 0x{:04X} and 0x{:04X} failed",
89 exp, tile, add);
90 #if !defined(_MSC_VER)
91 fmt::print(stderr, "{}:{} {}\n", file, line, message);
92 #else
93 _assert(message.data(), (char*)file, line);
94 #endif
95 }
96
97 assert(TileXY(x, y) == Map::WrapToMap(tile + add));
98
99 return TileXY(x, y);
100 }
101 #endif
102
116 TileIndex TileAddWrap(TileIndex tile, int addx, int addy)
117 {
118 uint x = TileX(tile) + addx;
119 uint y = TileY(tile) + addy;
120
121 /* Disallow void tiles at the north border. */
122 if ((x == 0 || y == 0) && _settings_game.construction.freeform_edges) return INVALID_TILE;
123
124 /* Are we about to wrap? */
125 if (x >= Map::MaxX() || y >= Map::MaxY()) return INVALID_TILE;
126
127 return TileXY(x, y);
128 }
129
131 extern const TileIndexDiffC _tileoffs_by_diagdir[] = {
132 {-1, 0},
133 { 0, 1},
134 { 1, 0},
135 { 0, -1}
136 };
137
139 extern const TileIndexDiffC _tileoffs_by_dir[] = {
140 {-1, -1},
141 {-1, 0},
142 {-1, 1},
143 { 0, 1},
144 { 1, 1},
145 { 1, 0},
146 { 1, -1},
147 { 0, -1}
148 };
149
159 uint DistanceManhattan(TileIndex t0, TileIndex t1)
160 {
161 const uint dx = Delta(TileX(t0), TileX(t1));
162 const uint dy = Delta(TileY(t0), TileY(t1));
163 return dx + dy;
164 }
165
166
176 uint DistanceSquare(TileIndex t0, TileIndex t1)
177 {
178 const int dx = TileX(t0) - TileX(t1);
179 const int dy = TileY(t0) - TileY(t1);
180 return dx * dx + dy * dy;
181 }
182
183
191 uint DistanceMax(TileIndex t0, TileIndex t1)
192 {
193 const uint dx = Delta(TileX(t0), TileX(t1));
194 const uint dy = Delta(TileY(t0), TileY(t1));
195 return std::max(dx, dy);
196 }
197
198
207 uint DistanceMaxPlusManhattan(TileIndex t0, TileIndex t1)
208 {
209 const uint dx = Delta(TileX(t0), TileX(t1));
210 const uint dy = Delta(TileY(t0), TileY(t1));
211 return dx > dy ? 2 * dx + dy : 2 * dy + dx;
212 }
213
219 uint DistanceFromEdge(TileIndex tile)
220 {
221 const uint xl = TileX(tile);
222 const uint yl = TileY(tile);
223 const uint xh = Map::SizeX() - 1 - xl;
224 const uint yh = Map::SizeY() - 1 - yl;
225 const uint minl = std::min(xl, yl);
226 const uint minh = std::min(xh, yh);
227 return std::min(minl, minh);
228 }
229
236 uint DistanceFromEdgeDir(TileIndex tile, DiagDirection dir)
237 {
238 switch (dir) {
239 case DIAGDIR_NE: return TileX(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
240 case DIAGDIR_NW: return TileY(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
241 case DIAGDIR_SW: return Map::MaxX() - TileX(tile) - 1;
242 case DIAGDIR_SE: return Map::MaxY() - TileY(tile) - 1;
243 default: NOT_REACHED();
244 }
245 }
246
260 bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
261 {
262 assert(proc != nullptr);
263 assert(size > 0);
264
265 if (size % 2 == 1) {
266 /* If the length of the side is uneven, the center has to be checked
267 * separately, as the pattern of uneven sides requires to go around the center */
268 if (proc(*tile, user_data)) return true;
269
270 /* If tile test is not successful, get one tile up,
271 * ready for a test in first circle around center tile */
272 *tile = TileAddByDir(*tile, DIR_N);
273 return CircularTileSearch(tile, size / 2, 1, 1, proc, user_data);
274 } else {
275 return CircularTileSearch(tile, size / 2, 0, 0, proc, user_data);
276 }
277 }
278
298 bool CircularTileSearch(TileIndex *tile, uint radius, uint w, uint h, TestTileOnSearchProc proc, void *user_data)
299 {
300 assert(proc != nullptr);
301 assert(radius > 0);
302
303 uint x = TileX(*tile) + w + 1;
304 uint y = TileY(*tile);
305
306 const uint extent[DIAGDIR_END] = { w, h, w, h };
307
308 for (uint n = 0; n < radius; n++) {
309 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
310 /* Is the tile within the map? */
311 for (uint j = extent[dir] + n * 2 + 1; j != 0; j--) {
312 if (x < Map::SizeX() && y < Map::SizeY()) {
313 TileIndex t = TileXY(x, y);
314 /* Is the callback successful? */
315 if (proc(t, user_data)) {
316 /* Stop the search */
317 *tile = t;
318 return true;
319 }
320 }
321
322 /* Step to the next 'neighbour' in the circular line */
323 x += _tileoffs_by_diagdir[dir].x;
324 y += _tileoffs_by_diagdir[dir].y;
325 }
326 }
327 /* Jump to next circle to test */
328 x += _tileoffs_by_dir[DIR_W].x;
329 y += _tileoffs_by_dir[DIR_W].y;
330 }
331
332 *tile = INVALID_TILE;
333 return false;
334 }
335
342 uint GetClosestWaterDistance(TileIndex tile, bool water)
343 {
344 if (HasTileWaterGround(tile) == water) return 0;
345
346 uint max_dist = water ? 0x7F : 0x200;
347
348 int x = TileX(tile);
349 int y = TileY(tile);
350
351 uint max_x = Map::MaxX();
352 uint max_y = Map::MaxY();
353 uint min_xy = _settings_game.construction.freeform_edges ? 1 : 0;
354
355 /* go in a 'spiral' with increasing manhattan distance in each iteration */
356 for (uint dist = 1; dist < max_dist; dist++) {
357 /* next 'diameter' */
358 y--;
359
360 /* going counter-clockwise around this square */
361 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
362 static const int8_t ddx[DIAGDIR_END] = { -1, 1, 1, -1};
363 static const int8_t ddy[DIAGDIR_END] = { 1, 1, -1, -1};
364
365 int dx = ddx[dir];
366 int dy = ddy[dir];
367
368 /* each side of this square has length 'dist' */
369 for (uint a = 0; a < dist; a++) {
370 /* MP_VOID tiles are not checked (interval is [min; max) for IsInsideMM())*/
371 if (IsInsideMM(x, min_xy, max_x) && IsInsideMM(y, min_xy, max_y)) {
372 TileIndex t = TileXY(x, y);
373 if (HasTileWaterGround(t) == water) return dist;
374 }
375 x += dx;
376 y += dy;
377 }
378 }
379 }
380
381 if (!water) {
382 /* no land found - is this a water-only map? */
383 for (TileIndex t = 0; t < Map::Size(); t++) {
384 if (!IsTileType(t, MP_VOID) && !IsTileType(t, MP_WATER)) return 0x1FF;
385 }
386 }
387
388 return max_dist;
389 }
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:437
DIAGDIR_SE
@ DIAGDIR_SE
Southeast.
Definition: direction_type.h:76
Tile::TileBase
Data that is stored per tile.
Definition: map_func.h:32
Map::size_y
static uint size_y
Size of the map along the Y.
Definition: map_func.h:239
_tileoffs_by_dir
const TileIndexDiffC _tileoffs_by_dir[]
'Lookup table' for tile offsets given a Direction
MIN_MAP_SIZE
static const uint MIN_MAP_SIZE
Minimal map size = 64.
Definition: map_type.h:39
IsInsideMM
constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
Definition: math_func.hpp:268
TestTileOnSearchProc
bool TestTileOnSearchProc(TileIndex tile, void *user_data)
A callback function type for searching tiles.
Definition: map_func.h:636
Map::MaxX
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:297
Map::size_x
static uint size_x
Size of the map along the X.
Definition: map_func.h:238
GetClosestWaterDistance
uint GetClosestWaterDistance(TileIndex tile, bool water)
Finds the distance for the closest tile with water/land given a tile.
Definition: map.cpp:342
DIAGDIR_END
@ DIAGDIR_END
Used for iterations.
Definition: direction_type.h:79
Map::Allocate
static void Allocate(uint size_x, uint size_y)
(Re)allocates a map with the given dimension
Definition: map.cpp:41
Map::WrapToMap
static TileIndex WrapToMap(TileIndex tile)
'Wraps' the given "tile" so it is within the map.
Definition: map_func.h:317
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
DIAGDIR_NW
@ DIAGDIR_NW
Northwest.
Definition: direction_type.h:78
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
_tileoffs_by_diagdir
const TileIndexDiffC _tileoffs_by_diagdir[]
'Lookup table' for tile offsets given a DiagDirection
DIR_N
@ DIR_N
North.
Definition: direction_type.h:26
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition: map.cpp:159
DIAGDIR_SW
@ DIAGDIR_SW
Southwest.
Definition: direction_type.h:77
error_func.h
TileAddWrap
TileIndex TileAddWrap(TileIndex tile, int addx, int addy)
This function checks if we add addx/addy to tile, if we do wrap around the edges.
Definition: map.cpp:116
CircularTileSearch
bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
Function performing a search around a center tile and going outward, thus in circle.
Definition: map.cpp:260
free
void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:379
DistanceFromEdge
uint DistanceFromEdge(TileIndex tile)
Param the minimum distance to an edge.
Definition: map.cpp:219
Tile::extended_tiles
static TileExtended * extended_tiles
Pointer to the extended tile-array.
Definition: map_func.h:55
MP_WATER
@ MP_WATER
Water tile.
Definition: tile_type.h:54
water_regions.h
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
safeguards.h
DistanceFromEdgeDir
uint DistanceFromEdgeDir(TileIndex tile, DiagDirection dir)
Gets the distance to the edge of the map in given direction.
Definition: map.cpp:236
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition: settings_type.h:383
TileIndexDiff
int32_t TileIndexDiff
An offset value between two tiles.
Definition: map_func.h:376
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:73
stdafx.h
TileAddByDir
TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
Definition: map_func.h:592
Map::log_x
static uint log_x
2^_map_log_x == _map_size_x
Definition: map_func.h:236
DistanceMax
uint DistanceMax(TileIndex t0, TileIndex t1)
Gets the biggest distance component (x or y) between the two given tiles.
Definition: map.cpp:191
Map::log_y
static uint log_y
2^_map_log_y == _map_size_y
Definition: map_func.h:237
TileIndexDiffC
A pair-construct of a TileIndexDiff.
Definition: map_type.h:31
water_map.h
Map::SizeX
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition: map_func.h:270
DistanceSquare
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition: map.cpp:176
string_func.h
Map::MaxY
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:306
MP_VOID
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition: tile_type.h:55
alloc_func.hpp
Map::Size
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
DIAGDIR_BEGIN
@ DIAGDIR_BEGIN
Used for iterations.
Definition: direction_type.h:74
Map::tile_mask
static uint tile_mask
_map_size - 1 (to mask the mapsize)
Definition: map_func.h:241
AllocateWaterRegions
void AllocateWaterRegions()
Allocates the appropriate amount of water regions for the current map size.
Definition: water_regions.cpp:389
TileIndexDiffC::y
int16_t y
The y value of the coordinate.
Definition: map_type.h:33
Delta
constexpr T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
Definition: math_func.hpp:234
TileXY
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:385
Tile::base_tiles
static TileBase * base_tiles
Pointer to the tile-array.
Definition: map_func.h:54
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:620
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
DistanceMaxPlusManhattan
uint DistanceMaxPlusManhattan(TileIndex t0, TileIndex t1)
Gets the biggest distance component (x or y) between the two given tiles plus the Manhattan distance,...
Definition: map.cpp:207
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:427
MAX_MAP_SIZE
static const uint MAX_MAP_SIZE
Maximal map size = 4096.
Definition: map_type.h:40
DIAGDIR_NE
@ DIAGDIR_NE
Northeast, upper right on your monitor.
Definition: direction_type.h:75
Tile::TileExtended
Data that is stored per tile.
Definition: map_func.h:48
HasTileWaterGround
bool HasTileWaterGround(Tile t)
Checks whether the tile has water at the ground.
Definition: water_map.h:353
TileIndexDiffC::x
int16_t x
The x value of the coordinate.
Definition: map_type.h:32
Map::size
static uint size
The number of tiles on the map.
Definition: map_func.h:240
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition: map_func.h:279
debug.h
FindFirstBit
constexpr uint8_t FindFirstBit(T x)
Search the first set bit in a value.
Definition: bitmath_func.hpp:194