openttd-ottdgrfs: comparison src/map.cpp

equal deleted inserted replaced

-:e782b59f1f6a
+:d2a6acdbd665
 Tile *_m = NULL;          ///< Tiles of the map
 TileExtended *_me = NULL; ///< Extended Tiles of the map
-/**
+/*!
 * (Re)allocates a map with the given dimension
 * @param size_x the width of the map along the NE/SW edge
 * @param size_y the 'height' of the map along the SE/NW edge
 */
 void AllocateMap(uint size_x, uint size_y)
 	return TileXY(x, y);
 }
 #endif
-/**
+/*!
 * Scales the given value by the map size, where the given value is
-* for a 256 by 256 map
+* for a 256 by 256 map.
 * @param n the value to scale
 * @return the scaled size
 */
 uint ScaleByMapSize(uint n)
 {
 	 * Add (1<<4)-1 to round upwards. */
 	return (n * (MapSize() >> 12) + (1 << 4) - 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
 */
 	 * (1<<9) - 1 is there to scale upwards. */
 	return (n * (MapSizeX() + MapSizeY()) + (1 << 9) - 1) >> 9;
 }
-/**
+/*!
 * This function checks if we add addx/addy to tile, if we
-*  do wrap around the edges. For example, tile = (10,2) and
+* do wrap around the edges. For example, tile = (10,2) and
-*  addx = +3 and addy = -4. This function will now return
+* addx = +3 and addy = -4. This function will now return
-*  INVALID_TILE, because the y is wrapped. This is needed in
+* INVALID_TILE, because the y is wrapped. This is needed in
-*  for example, farmland. When the tile is not wrapped,
+* for example, farmland. When the tile is not wrapped,
-*  the result will be tile + TileDiffXY(addx, addy)
+* the result will be tile + TileDiffXY(addx, addy)
+*
 * @param tile the 'starting' point of the adding
 * @param addx the amount of tiles in the X direction to add
 * @param addy the amount of tiles in the Y direction to add
 * @return translated tile, or INVALID_TILE when it would've wrapped.
 */
 	{ 1,  0}, ///< DIR_SW
 	{ 1, -1}, ///< DIR_W
 	{ 0, -1}  ///< DIR_NW
 };
-/**
+/*!
 * Gets the Manhattan distance between the two given tiles.
 * The Manhattan distance is the sum of the delta of both the
 * X and Y component.
 * Also known as L1-Norm
 * @param t0 the start tile
 	const uint dy = delta(TileY(t0), TileY(t1));
 	return dx + dy;
 }
-/**
+/*!
 * Gets the 'Square' distance between the two given tiles.
 * The 'Square' distance is the square of the shortest (straight line)
 * distance between the two tiles.
 * Also known as euclidian- or L2-Norm squared.
 * @param t0 the start tile
 	const int dy = TileY(t0) - TileY(t1);
 	return dx * dx + dy * dy;
 }
-/**
+/*!
 * Gets the biggest distance component (x or y) between the two given tiles.
 * Also known as L-Infinity-Norm.
 * @param t0 the start tile
 * @param t1 the end tile
 * @return the distance
 	const uint dy = delta(TileY(t0), TileY(t1));
 	return dx > dy ? dx : dy;
 }
-/**
+/*!
 * Gets the biggest distance component (x or y) between the two given tiles
 * plus the Manhattan distance, i.e. two times the biggest distance component
 * and once the smallest component.
 * @param t0 the start tile
 * @param t1 the end tile
 	const uint dx = delta(TileX(t0), TileX(t1));
 	const uint dy = delta(TileY(t0), TileY(t1));
 	return dx > dy ? 2 * dx + dy : 2 * dy + dx;
 }
-/**
+/*!
 * Param the minimum distance to an edge
 * @param tile the tile to get the distance from
 * @return the distance from the edge in tiles
 */
 uint DistanceFromEdge(TileIndex tile)
 	const uint minl = xl < yl ? xl : yl;
 	const uint minh = xh < yh ? xh : yh;
 	return minl < minh ? minl : minh;
 }
-/**
+/*!
 * Function performing a search around a center tile and going outward, thus in circle.
 * Although it really is a square search...
 * Every tile will be tested by means of the callback function proc,
 * which will determine if yes or no the given tile meets criteria of search.
 * @param tile to start the search from

branch	noai
changeset 9703	d2a6acdbd665
parent 9701	d1ac22c62f64
child 9722	ebf0ece7d8f6