Files
@ r16729:482bfc615285
Branch filter:
Location: cpp/openttd-patchpack/source/src/map_func.h
r16729:482bfc615285
12.4 KiB
text/x-c
(svn r21472) -Fix [FS#4298] (r21459-ish): make sure the query window is only opened once per parent window / callback.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 | /* $Id$ */
/*
* This file is part of OpenTTD.
* 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.
* 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.
* 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/>.
*/
/** @file map_func.h Functions related to maps. */
#ifndef MAP_FUNC_H
#define MAP_FUNC_H
#include "core/math_func.hpp"
#include "tile_type.h"
#include "map_type.h"
#include "direction_func.h"
extern uint _map_tile_mask;
/**
* 'Wraps' the given tile to it is within the map. It does
* this by masking the 'high' bits of.
* @param x the tile to 'wrap'
*/
#define TILE_MASK(x) ((x) & _map_tile_mask)
/**
* Pointer to the tile-array.
*
* This variable points to the tile-array which contains the tiles of
* the map.
*/
extern Tile *_m;
/**
* Pointer to the extended tile-array.
*
* This variable points to the extended tile-array which contains the tiles
* of the map.
*/
extern TileExtended *_me;
/**
* Allocate a new map with the given size.
*/
void AllocateMap(uint size_x, uint size_y);
/**
* Logarithm of the map size along the X side.
* @note try to avoid using this one
* @return 2^"return value" == MapSizeX()
*/
static inline uint MapLogX()
{
extern uint _map_log_x;
return _map_log_x;
}
/**
* Logarithm of the map size along the y side.
* @note try to avoid using this one
* @return 2^"return value" == MapSizeY()
*/
static inline uint MapLogY()
{
extern uint _map_log_y;
return _map_log_y;
}
/**
* Get the size of the map along the X
* @return the number of tiles along the X of the map
*/
static inline uint MapSizeX()
{
extern uint _map_size_x;
return _map_size_x;
}
/**
* Get the size of the map along the Y
* @return the number of tiles along the Y of the map
*/
static inline uint MapSizeY()
{
extern uint _map_size_y;
return _map_size_y;
}
/**
* Get the size of the map
* @return the number of tiles of the map
*/
static inline uint MapSize()
{
extern uint _map_size;
return _map_size;
}
/**
* Gets the maximum X coordinate within the map, including MP_VOID
* @return the maximum X coordinate
*/
static inline uint MapMaxX()
{
return MapSizeX() - 1;
}
/**
* Gets the maximum Y coordinate within the map, including MP_VOID
* @return the maximum Y coordinate
*/
static inline uint MapMaxY()
{
return MapSizeY() - 1;
}
/**
* Scales the given value by the map size, where the given value is
* for a 256 by 256 map.
* @param n the value to scale
* @return the scaled size
*/
static inline uint ScaleByMapSize(uint n)
{
/* Subtract 12 from shift in order to prevent integer overflow
* for large values of n. It's safe since the min mapsize is 64x64. */
return CeilDiv(n << (MapLogX() + MapLogY() - 12), 1 << 4);
}
/**
* Scales the given value by the maps circumference, where the given
* value is for a 256 by 256 map
* @param n the value to scale
* @return the scaled size
*/
static inline uint ScaleByMapSize1D(uint n)
{
/* Normal circumference for the X+Y is 256+256 = 1<<9
* Note, not actually taking the full circumference into account,
* just half of it. */
return CeilDiv((n << MapLogX()) + (n << MapLogY()), 1 << 9);
}
/**
* An offset value between to tiles.
*
* This value is used fro the difference between
* to tiles. It can be added to a tileindex to get
* the resulting tileindex of the start tile applied
* with this saved difference.
*
* @see TileDiffXY(int, int)
*/
typedef int32 TileIndexDiff;
/**
* Returns the TileIndex of a coordinate.
*
* @param x The x coordinate of the tile
* @param y The y coordinate of the tile
* @return The TileIndex calculated by the coordinate
*/
static inline TileIndex TileXY(uint x, uint y)
{
return (y << MapLogX()) + x;
}
/**
* Calculates an offset for the given coordinate(-offset).
*
* This function calculate an offset value which can be added to an
* #TileIndex. The coordinates can be negative.
*
* @param x The offset in x direction
* @param y The offset in y direction
* @return The resulting offset value of the given coordinate
* @see ToTileIndexDiff(TileIndexDiffC)
*/
static inline TileIndexDiff TileDiffXY(int x, int y)
{
/* Multiplication gives much better optimization on MSVC than shifting.
* 0 << shift isn't optimized to 0 properly.
* Typically x and y are constants, and then this doesn't result
* in any actual multiplication in the assembly code.. */
return (y * MapSizeX()) + x;
}
static inline TileIndex TileVirtXY(uint x, uint y)
{
return (y >> 4 << MapLogX()) + (x >> 4);
}
/**
* Get the X component of a tile
* @param tile the tile to get the X component of
* @return the X component
*/
static inline uint TileX(TileIndex tile)
{
return tile & MapMaxX();
}
/**
* Get the Y component of a tile
* @param tile the tile to get the Y component of
* @return the Y component
*/
static inline uint TileY(TileIndex tile)
{
return tile >> MapLogX();
}
/**
* Return the offset between to tiles from a TileIndexDiffC struct.
*
* This function works like #TileDiffXY(int, int) and returns the
* difference between two tiles.
*
* @param tidc The coordinate of the offset as TileIndexDiffC
* @return The difference between two tiles.
* @see TileDiffXY(int, int)
*/
static inline TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
{
return (tidc.y << MapLogX()) + tidc.x;
}
#ifndef _DEBUG
/**
* Adds to tiles together.
*
* @param x One tile
* @param y Another tile to add
* @return The resulting tile(index)
*/
#define TILE_ADD(x, y) ((x) + (y))
#else
extern TileIndex TileAdd(TileIndex tile, TileIndexDiff add,
const char *exp, const char *file, int line);
#define TILE_ADD(x, y) (TileAdd((x), (y), #x " + " #y, __FILE__, __LINE__))
#endif
/**
* Adds a given offset to a tile.
*
* @param tile The tile to add an offset on it
* @param x The x offset to add to the tile
* @param y The y offset to add to the tile
*/
#define TILE_ADDXY(tile, x, y) TILE_ADD(tile, TileDiffXY(x, y))
/**
* Adds an offset to a tile and check if we are still on the map.
*/
TileIndex TileAddWrap(TileIndex tile, int addx, int addy);
/**
* Returns the TileIndexDiffC offset from a DiagDirection.
*
* @param dir The given direction
* @return The offset as TileIndexDiffC value
*/
static inline TileIndexDiffC TileIndexDiffCByDiagDir(DiagDirection dir)
{
extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];
assert(IsValidDiagDirection(dir));
return _tileoffs_by_diagdir[dir];
}
/**
* Returns the TileIndexDiffC offset from a Direction.
*
* @param dir The given direction
* @return The offset as TileIndexDiffC value
*/
static inline TileIndexDiffC TileIndexDiffCByDir(Direction dir)
{
extern const TileIndexDiffC _tileoffs_by_dir[DIR_END];
assert(IsValidDirection(dir));
return _tileoffs_by_dir[dir];
}
/**
* Add a TileIndexDiffC to a TileIndex and returns the new one.
*
* Returns tile + the diff given in diff. If the result tile would end up
* outside of the map, INVALID_TILE is returned instead.
*
* @param tile The base tile to add the offset on
* @param diff The offset to add on the tile
* @return The resulting TileIndex
*/
static inline TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)
{
int x = TileX(tile) + diff.x;
int y = TileY(tile) + diff.y;
/* Negative value will become big positive value after cast */
if ((uint)x >= MapSizeX() || (uint)y >= MapSizeY()) return INVALID_TILE;
return TileXY(x, y);
}
/**
* Returns the diff between two tiles
*
* @param tile_a from tile
* @param tile_b to tile
* @return the difference between tila_a and tile_b
*/
static inline TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)
{
TileIndexDiffC difference;
difference.x = TileX(tile_a) - TileX(tile_b);
difference.y = TileY(tile_a) - TileY(tile_b);
return difference;
}
/* Functions to calculate distances */
uint DistanceManhattan(TileIndex, TileIndex); ///< also known as L1-Norm. Is the shortest distance one could go over diagonal tracks (or roads)
uint DistanceSquare(TileIndex, TileIndex); ///< euclidian- or L2-Norm squared
uint DistanceMax(TileIndex, TileIndex); ///< also known as L-Infinity-Norm
uint DistanceMaxPlusManhattan(TileIndex, TileIndex); ///< Max + Manhattan
uint DistanceFromEdge(TileIndex); ///< shortest distance from any edge of the map
uint DistanceFromEdgeDir(TileIndex, DiagDirection); ///< distance from the map edge in given direction
/**
* A loop which iterates to a square of tiles
*
* This macro starts 2 nested loops which iterates over a square of tiles.
*
* @param var The name of the variable which contains the current tile
* @param w The width (x-width) of the square
* @param h The heigth (y-width) of the square
* @param tile The start tile of the square
*/
#define TILE_LOOP(var, w, h, tile) \
for (uint var = tile, cur_h = (h); cur_h > 0; --cur_h, var += TileDiffXY(0, 1) - (w)) \
for (uint cur_w = (w); cur_w > 0; --cur_w, var++)
/**
* A loop which iterates over the tiles of a TileArea
*
* This macro starts 2 nested loops which iterates over a square of tiles.
*
* @param var The name of the variable which contains the current tile
* @param ta The tile area to search over
*/
#define TILE_AREA_LOOP(var, ta) TILE_LOOP(var, ta.w, ta.h, ta.tile)
/**
* Convert a DiagDirection to a TileIndexDiff
*
* @param dir The DiagDirection
* @return The resulting TileIndexDiff
* @see TileIndexDiffCByDiagDir
*/
static inline TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
{
extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];
assert(IsValidDiagDirection(dir));
return ToTileIndexDiff(_tileoffs_by_diagdir[dir]);
}
/**
* Convert a Direction to a TileIndexDiff.
*
* @param dir The direction to convert from
* @return The resulting TileIndexDiff
*/
static inline TileIndexDiff TileOffsByDir(Direction dir)
{
extern const TileIndexDiffC _tileoffs_by_dir[DIR_END];
assert(IsValidDirection(dir));
return ToTileIndexDiff(_tileoffs_by_dir[dir]);
}
/**
* Adds a DiagDir to a tile.
*
* @param tile The current tile
* @param dir The direction in which we want to step
* @return the moved tile
*/
static inline TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
{
return TILE_ADD(tile, TileOffsByDiagDir(dir));
}
/**
* Determines the DiagDirection to get from one tile to another.
* The tiles do not necessarily have to be adjacent.
* @param tile_from Origin tile
* @param tile_to Destination tile
* @return DiagDirection from tile_from towards tile_to, or INVALID_DIAGDIR if the tiles are not on an axis
*/
static inline DiagDirection DiagdirBetweenTiles(TileIndex tile_from, TileIndex tile_to)
{
int dx = (int)TileX(tile_to) - (int)TileX(tile_from);
int dy = (int)TileY(tile_to) - (int)TileY(tile_from);
if (dx == 0) {
if (dy == 0) return INVALID_DIAGDIR;
return (dy < 0 ? DIAGDIR_NW : DIAGDIR_SE);
} else {
if (dy != 0) return INVALID_DIAGDIR;
return (dx < 0 ? DIAGDIR_NE : DIAGDIR_SW);
}
}
/**
* A callback function type for searching tiles.
*
* @param tile The tile to test
* @param user_data additional data for the callback function to use
* @return A boolean value, depend on the definition of the function.
*/
typedef bool TestTileOnSearchProc(TileIndex tile, void *user_data);
/**
* Searches for some cirumstances of a tile around a given tile with a helper function.
*/
bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data);
/**
* Searches for some cirumstances of a tile around a given rectangle with a helper function.
*/
bool CircularTileSearch(TileIndex *tile, uint radius, uint w, uint h, TestTileOnSearchProc proc, void *user_data);
/**
* Get a random tile out of a given seed.
* @param r the random 'seed'
* @return a valid tile
*/
static inline TileIndex RandomTileSeed(uint32 r)
{
return TILE_MASK(r);
}
/**
* Get a valid random tile.
* @note a define so 'random' gets inserted in the place where it is actually
* called, thus making the random traces more explicit.
* @return a valid tile
*/
#define RandomTile() RandomTileSeed(Random())
/**
* Finds the distance for the closest tile with water/land given a tile
*/
uint GetClosestWaterDistance(TileIndex tile, bool water);
#endif /* MAP_FUNC_H */
|