src/tile_map.h

   1 /* $Id: tile_map.h 25849 2013-10-12 22:07:58Z zuu $ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file tile_map.h Map writing/reading functions for tiles. */
  11
  12 #ifndef TILE_MAP_H
  13 #define TILE_MAP_H
  14
  15 #include "slope_type.h"
  16 #include "map_func.h"
  17 #include "core/bitmath_func.hpp"
  18 #include "settings_type.h"
  19
  20 /**
  21  * Returns the height of a tile
  22  *
  23  * This function returns the height of the northern corner of a tile.
  24  * This is saved in the global map-array. It does not take affect by
  25  * any slope-data of the tile.
  26  *
  27  * @param tile The tile to get the height from
  28  * @return the height of the tile
  29  * @pre tile < MapSize()
  30  */
  31 static inline uint TileHeight(TileIndex tile)
  32 {
  33         assert(tile < MapSize());
  34         return _m[tile].height;
  35 }
  36
  37 uint TileHeightOutsideMap(int x, int y);
  38
  39 /**
  40  * Sets the height of a tile.
  41  *
  42  * This function sets the height of the northern corner of a tile.
  43  *
  44  * @param tile The tile to change the height
  45  * @param height The new height value of the tile
  46  * @pre tile < MapSize()
  47  * @pre heigth <= MAX_TILE_HEIGHT
  48  */
  49 static inline void SetTileHeight(TileIndex tile, uint height)
  50 {
  51         assert(tile < MapSize());
  52         assert(height <= MAX_TILE_HEIGHT);
  53         _m[tile].height = height;
  54 }
  55
  56 /**
  57  * Returns the height of a tile in pixels.
  58  *
  59  * This function returns the height of the northern corner of a tile in pixels.
  60  *
  61  * @param tile The tile to get the height
  62  * @return The height of the tile in pixel
  63  */
  64 static inline uint TilePixelHeight(TileIndex tile)
  65 {
  66         return TileHeight(tile) * TILE_HEIGHT;
  67 }
  68
  69 /**
  70  * Returns the tile height for a coordinate outside map.  Such a height is
  71  * needed for painting the area outside map using completely black tiles.
  72  * The idea is descending to heightlevel 0 as fast as possible.
  73  * @param x The X-coordinate (same unit as TileX).
  74  * @param y The Y-coordinate (same unit as TileY).
  75  * @return The height in pixels in the same unit as TilePixelHeight.
  76  */
  77 static inline uint TilePixelHeightOutsideMap(int x, int y)
  78 {
  79         return TileHeightOutsideMap(x, y) * TILE_HEIGHT;
  80 }
  81
  82 /**
  83  * Get the tiletype of a given tile.
  84  *
  85  * @param tile The tile to get the TileType
  86  * @return The tiletype of the tile
  87  * @pre tile < MapSize()
  88  */
  89 static inline TileType GetTileType(TileIndex tile)
  90 {
  91         assert(tile < MapSize());
  92         return (TileType)GB(_m[tile].type, 4, 4);
  93 }
  94
  95 /**
  96  * Check if a tile is within the map (not a border)
  97  *
  98  * @param tile The tile to check
  99  * @return Whether the tile is in the interior of the map
 100  * @pre tile < MapSize()
 101  */
 102 static inline bool IsInnerTile(TileIndex tile)
 103 {
 104         assert(tile < MapSize());
 105
 106         uint x = TileX(tile);
 107         uint y = TileY(tile);
 108
 109         return x < MapMaxX() && y < MapMaxY() && ((x > 0 && y > 0) || !_settings_game.construction.freeform_edges);
 110 }
 111
 112 /**
 113  * Set the type of a tile
 114  *
 115  * This functions sets the type of a tile. If the type
 116  * MP_VOID is selected the tile must be at the south-west or
 117  * south-east edges of the map and vice versa.
 118  *
 119  * @param tile The tile to save the new type
 120  * @param type The type to save
 121  * @pre tile < MapSize()
 122  * @pre type MP_VOID <=> tile is on the south-east or south-west edge.
 123  */
 124 static inline void SetTileType(TileIndex tile, TileType type)
 125 {
 126         assert(tile < MapSize());
 127         /* VOID tiles (and no others) are exactly allowed at the lower left and right
 128          * edges of the map. If _settings_game.construction.freeform_edges is true,
 129          * the upper edges of the map are also VOID tiles. */
 130         assert(IsInnerTile(tile) == (type != MP_VOID));
 131         SB(_m[tile].type, 4, 4, type);
 132 }
 133
 134 /**
 135  * Checks if a tile is a give tiletype.
 136  *
 137  * This function checks if a tile got the given tiletype.
 138  *
 139  * @param tile The tile to check
 140  * @param type The type to check against
 141  * @return true If the type matches against the type of the tile
 142  */
 143 static inline bool IsTileType(TileIndex tile, TileType type)
 144 {
 145         return GetTileType(tile) == type;
 146 }
 147
 148 /**
 149  * Checks if a tile is valid
 150  *
 151  * @param tile The tile to check
 152  * @return True if the tile is on the map and not one of MP_VOID.
 153  */
 154 static inline bool IsValidTile(TileIndex tile)
 155 {
 156         return tile < MapSize() && !IsTileType(tile, MP_VOID);
 157 }
 158
 159 /**
 160  * Returns the owner of a tile
 161  *
 162  * This function returns the owner of a tile. This cannot used
 163  * for tiles which type is one of MP_HOUSE, MP_VOID and MP_INDUSTRY
 164  * as no company owned any of these buildings.
 165  *
 166  * @param tile The tile to check
 167  * @return The owner of the tile
 168  * @pre IsValidTile(tile)
 169  * @pre The type of the tile must not be MP_HOUSE and MP_INDUSTRY
 170  */
 171 static inline Owner GetTileOwner(TileIndex tile)
 172 {
 173         assert(IsValidTile(tile));
 174         assert(!IsTileType(tile, MP_HOUSE));
 175         assert(!IsTileType(tile, MP_INDUSTRY));
 176
 177         return (Owner)GB(_m[tile].m1, 0, 5);
 178 }
 179
 180 /**
 181  * Sets the owner of a tile
 182  *
 183  * This function sets the owner status of a tile. Note that you cannot
 184  * set a owner for tiles of type MP_HOUSE, MP_VOID and MP_INDUSTRY.
 185  *
 186  * @param tile The tile to change the owner status.
 187  * @param owner The new owner.
 188  * @pre IsValidTile(tile)
 189  * @pre The type of the tile must not be MP_HOUSE and MP_INDUSTRY
 190  */
 191 static inline void SetTileOwner(TileIndex tile, Owner owner)
 192 {
 193         assert(IsValidTile(tile));
 194         assert(!IsTileType(tile, MP_HOUSE));
 195         assert(!IsTileType(tile, MP_INDUSTRY));
 196
 197         SB(_m[tile].m1, 0, 5, owner);
 198 }
 199
 200 /**
 201  * Checks if a tile belongs to the given owner
 202  *
 203  * @param tile The tile to check
 204  * @param owner The owner to check against
 205  * @return True if a tile belongs the the given owner
 206  */
 207 static inline bool IsTileOwner(TileIndex tile, Owner owner)
 208 {
 209         return GetTileOwner(tile) == owner;
 210 }
 211
 212 /**
 213  * Set the tropic zone
 214  * @param tile the tile to set the zone of
 215  * @param type the new type
 216  * @pre tile < MapSize()
 217  */
 218 static inline void SetTropicZone(TileIndex tile, TropicZone type)
 219 {
 220         assert(tile < MapSize());
 221         assert(!IsTileType(tile, MP_VOID) || type == TROPICZONE_NORMAL);
 222         SB(_m[tile].type, 0, 2, type);
 223 }
 224
 225 /**
 226  * Get the tropic zone
 227  * @param tile the tile to get the zone of
 228  * @pre tile < MapSize()
 229  * @return the zone type
 230  */
 231 static inline TropicZone GetTropicZone(TileIndex tile)
 232 {
 233         assert(tile < MapSize());
 234         return (TropicZone)GB(_m[tile].type, 0, 2);
 235 }
 236
 237 /**
 238  * Get the current animation frame
 239  * @param t the tile
 240  * @pre IsTileType(t, MP_HOUSE) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_INDUSTRY) ||IsTileType(t, MP_STATION)
 241  * @return frame number
 242  */
 243 static inline byte GetAnimationFrame(TileIndex t)
 244 {
 245         assert(IsTileType(t, MP_HOUSE) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_INDUSTRY) ||IsTileType(t, MP_STATION));
 246         return _me[t].m7;
 247 }
 248
 249 /**
 250  * Set a new animation frame
 251  * @param t the tile
 252  * @param frame the new frame number
 253  * @pre IsTileType(t, MP_HOUSE) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_INDUSTRY) ||IsTileType(t, MP_STATION)
 254  */
 255 static inline void SetAnimationFrame(TileIndex t, byte frame)
 256 {
 257         assert(IsTileType(t, MP_HOUSE) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_INDUSTRY) ||IsTileType(t, MP_STATION));
 258         _me[t].m7 = frame;
 259 }
 260
 261 Slope GetTileSlope(TileIndex tile, int *h = nullptr);
 262 int GetTileZ(TileIndex tile);
 263 int GetTileMaxZ(TileIndex tile);
 264
 265 bool IsTileFlat(TileIndex tile, int *h = nullptr);
 266
 267 /**
 268  * Return the slope of a given tile
 269  * @param tile Tile to compute slope of
 270  * @param h    If not \c nullptr, pointer to storage of z height
 271  * @return Slope of the tile, except for the HALFTILE part
 272  */
 273 static inline Slope GetTilePixelSlope(TileIndex tile, int *h)
 274 {
 275         Slope s = GetTileSlope(tile, h);
 276         if (h != nullptr) *h *= TILE_HEIGHT;
 277         return s;
 278 }
 279
 280 Slope GetTilePixelSlopeOutsideMap(int x, int y, int *h);
 281
 282 /**
 283  * Get bottom height of the tile
 284  * @param tile Tile to compute height of
 285  * @return Minimum height of the tile
 286  */
 287 static inline int GetTilePixelZ(TileIndex tile)
 288 {
 289         return GetTileZ(tile) * TILE_HEIGHT;
 290 }
 291
 292 int GetTilePixelZOutsideMap(int x, int y);
 293
 294 /**
 295  * Get top height of the tile
 296  * @param t Tile to compute height of
 297  * @return Maximum height of the tile
 298  */
 299 static inline int GetTileMaxPixelZ(TileIndex tile)
 300 {
 301         return GetTileMaxZ(tile) * TILE_HEIGHT;
 302 }
 303
 304 int GetTileMaxPixelZOutsideMap(int x, int y);
 305
 306
 307 /**
 308  * Calculate a hash value from a tile position
 309  *
 310  * @param x The X coordinate
 311  * @param y The Y coordinate
 312  * @return The hash of the tile
 313  */
 314 static inline uint TileHash(uint x, uint y)
 315 {
 316         uint hash = x >> 4;
 317         hash ^= x >> 6;
 318         hash ^= y >> 4;
 319         hash -= y >> 6;
 320         return hash;
 321 }
 322
 323 /**
 324  * Get the last two bits of the TileHash
 325  *  from a tile position.
 326  *
 327  * @see TileHash()
 328  * @param x The X coordinate
 329  * @param y The Y coordinate
 330  * @return The last two bits from hash of the tile
 331  */
 332 static inline uint TileHash2Bit(uint x, uint y)
 333 {
 334         return GB(TileHash(x, y), 0, 2);
 335 }
 336
 337 #endif /* TILE_MAP_H */