src/water_map.h

   1 /* $Id$ */
   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 water_map.h Map accessors for water tiles. */
  11
  12 #ifndef WATER_MAP_H
  13 #define WATER_MAP_H
  14
  15 #include "depot_type.h"
  16 #include "tile_map.h"
  17
  18 /**
  19  * Bit field layout of m5 for water tiles.
  20  */
  21 enum WaterTileTypeBitLayout {
  22         WBL_TYPE_BEGIN        = 4,   ///< Start of the 'type' bitfield.
  23         WBL_TYPE_COUNT        = 4,   ///< Length of the 'type' bitfield.
  24
  25         WBL_TYPE_NORMAL       = 0x0, ///< Clear water or coast ('type' bitfield).
  26         WBL_TYPE_LOCK         = 0x1, ///< Lock ('type' bitfield).
  27         WBL_TYPE_DEPOT        = 0x8, ///< Depot ('type' bitfield).
  28
  29         WBL_COAST_FLAG        = 0,   ///< Flag for coast.
  30
  31         WBL_LOCK_ORIENT_BEGIN = 0,   ///< Start of lock orientiation bitfield.
  32         WBL_LOCK_ORIENT_COUNT = 2,   ///< Length of lock orientiation bitfield.
  33         WBL_LOCK_PART_BEGIN   = 2,   ///< Start of lock part bitfield.
  34         WBL_LOCK_PART_COUNT   = 2,   ///< Length of lock part bitfield.
  35
  36         WBL_DEPOT_PART        = 0,   ///< Depot part flag.
  37         WBL_DEPOT_AXIS        = 1,   ///< Depot axis flag.
  38 };
  39
  40 /** Available water tile types. */
  41 enum WaterTileType {
  42         WATER_TILE_CLEAR, ///< Plain water.
  43         WATER_TILE_COAST, ///< Coast.
  44         WATER_TILE_LOCK,  ///< Water lock.
  45         WATER_TILE_DEPOT, ///< Water Depot.
  46 };
  47
  48 /** classes of water (for #WATER_TILE_CLEAR water tile type). */
  49 enum WaterClass {
  50         WATER_CLASS_SEA,     ///< Sea.
  51         WATER_CLASS_CANAL,   ///< Canal.
  52         WATER_CLASS_RIVER,   ///< River.
  53         WATER_CLASS_INVALID, ///< Used for industry tiles on land (also for oilrig if newgrf says so).
  54 };
  55 /** Helper information for extract tool. */
  56 template <> struct EnumPropsT<WaterClass> : MakeEnumPropsT<WaterClass, byte, WATER_CLASS_SEA, WATER_CLASS_INVALID, WATER_CLASS_INVALID, 2> {};
  57
  58 /** Sections of the water depot. */
  59 enum DepotPart {
  60         DEPOT_PART_NORTH = 0, ///< Northern part of a depot.
  61         DEPOT_PART_SOUTH = 1, ///< Southern part of a depot.
  62         DEPOT_PART_END
  63 };
  64
  65 /** Sections of the water lock. */
  66 enum LockPart {
  67         LOCK_PART_MIDDLE = 0, ///< Middle part of a lock.
  68         LOCK_PART_LOWER  = 1, ///< Lower part of a lock.
  69         LOCK_PART_UPPER  = 2, ///< Upper part of a lock.
  70 };
  71
  72 /**
  73  * Get the water tile type at a tile.
  74  * @param t Water tile to query.
  75  * @return Water tile type at the tile.
  76  */
  77 static inline WaterTileType GetWaterTileType(TileIndex t)
  78 {
  79         assert(IsTileType(t, MP_WATER));
  80
  81         switch (GB(_m[t].m5, WBL_TYPE_BEGIN, WBL_TYPE_COUNT)) {
  82                 case WBL_TYPE_NORMAL: return HasBit(_m[t].m5, WBL_COAST_FLAG) ? WATER_TILE_COAST : WATER_TILE_CLEAR;
  83                 case WBL_TYPE_LOCK:   return WATER_TILE_LOCK;
  84                 case WBL_TYPE_DEPOT:  return WATER_TILE_DEPOT;
  85                 default: NOT_REACHED();
  86         }
  87 }
  88
  89 /**
  90  * Checks whether the tile has an waterclass associated.
  91  * You can then subsequently call GetWaterClass().
  92  * @param t Tile to query.
  93  * @return True if the tiletype has a waterclass.
  94  */
  95 static inline bool HasTileWaterClass(TileIndex t)
  96 {
  97         return IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_OBJECT);
  98 }
  99
 100 /**
 101  * Get the water class at a tile.
 102  * @param t Water tile to query.
 103  * @pre IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_OBJECT)
 104  * @return Water class at the tile.
 105  */
 106 static inline WaterClass GetWaterClass(TileIndex t)
 107 {
 108         assert(HasTileWaterClass(t));
 109         return (WaterClass)GB(_m[t].m1, 5, 2);
 110 }
 111
 112 /**
 113  * Set the water class at a tile.
 114  * @param t  Water tile to change.
 115  * @param wc New water class.
 116  * @pre IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_OBJECT)
 117  */
 118 static inline void SetWaterClass(TileIndex t, WaterClass wc)
 119 {
 120         assert(HasTileWaterClass(t));
 121         SB(_m[t].m1, 5, 2, wc);
 122 }
 123
 124 /**
 125  * Tests if the tile was built on water.
 126  * @param t the tile to check
 127  * @pre IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_OBJECT)
 128  * @return true iff on water
 129  */
 130 static inline bool IsTileOnWater(TileIndex t)
 131 {
 132         return (GetWaterClass(t) != WATER_CLASS_INVALID);
 133 }
 134
 135 /**
 136  * Is it a plain water tile?
 137  * @param t Water tile to query.
 138  * @return \c true if any type of clear water like ocean, river, or canal.
 139  * @pre IsTileType(t, MP_WATER)
 140  */
 141 static inline bool IsWater(TileIndex t)
 142 {
 143         return GetWaterTileType(t) == WATER_TILE_CLEAR;
 144 }
 145
 146 /**
 147  * Is it a sea water tile?
 148  * @param t Water tile to query.
 149  * @return \c true if it is a sea water tile.
 150  * @pre IsTileType(t, MP_WATER)
 151  */
 152 static inline bool IsSea(TileIndex t)
 153 {
 154         return IsWater(t) && GetWaterClass(t) == WATER_CLASS_SEA;
 155 }
 156
 157 /**
 158  * Is it a canal tile?
 159  * @param t Water tile to query.
 160  * @return \c true if it is a canal tile.
 161  * @pre IsTileType(t, MP_WATER)
 162  */
 163 static inline bool IsCanal(TileIndex t)
 164 {
 165         return IsWater(t) && GetWaterClass(t) == WATER_CLASS_CANAL;
 166 }
 167
 168 /**
 169  * Is it a river water tile?
 170  * @param t Water tile to query.
 171  * @return \c true if it is a river water tile.
 172  * @pre IsTileType(t, MP_WATER)
 173  */
 174 static inline bool IsRiver(TileIndex t)
 175 {
 176         return IsWater(t) && GetWaterClass(t) == WATER_CLASS_RIVER;
 177 }
 178
 179 /**
 180  * Is it a water tile with plain water?
 181  * @param t Tile to query.
 182  * @return \c true if it is a plain water tile.
 183  */
 184 static inline bool IsWaterTile(TileIndex t)
 185 {
 186         return IsTileType(t, MP_WATER) && IsWater(t);
 187 }
 188
 189 /**
 190  * Is it a coast tile?
 191  * @param t Water tile to query.
 192  * @return \c true if it is a sea water tile.
 193  * @pre IsTileType(t, MP_WATER)
 194  */
 195 static inline bool IsCoast(TileIndex t)
 196 {
 197         return GetWaterTileType(t) == WATER_TILE_COAST;
 198 }
 199
 200 /**
 201  * Is it a coast tile
 202  * @param t Tile to query.
 203  * @return \c true if it is a coast.
 204  */
 205 static inline bool IsCoastTile(TileIndex t)
 206 {
 207         return IsTileType(t, MP_WATER) && IsCoast(t);
 208 }
 209
 210 /**
 211  * Is it a water tile with a ship depot on it?
 212  * @param t Water tile to query.
 213  * @return \c true if it is a ship depot tile.
 214  * @pre IsTileType(t, MP_WATER)
 215  */
 216 static inline bool IsShipDepot(TileIndex t)
 217 {
 218         return GetWaterTileType(t) == WATER_TILE_DEPOT;
 219 }
 220
 221 /**
 222  * Is it a ship depot tile?
 223  * @param t Tile to query.
 224  * @return \c true if it is a ship depot tile.
 225  */
 226 static inline bool IsShipDepotTile(TileIndex t)
 227 {
 228         return IsTileType(t, MP_WATER) && IsShipDepot(t);
 229 }
 230
 231 /**
 232  * Get the axis of the ship depot.
 233  * @param t Water tile to query.
 234  * @return Axis of the depot.
 235  * @pre IsShipDepotTile(t)
 236  */
 237 static inline Axis GetShipDepotAxis(TileIndex t)
 238 {
 239         assert(IsShipDepotTile(t));
 240         return (Axis)GB(_m[t].m5, WBL_DEPOT_AXIS, 1);
 241 }
 242
 243 /**
 244  * Get the part of a ship depot.
 245  * @param t Water tile to query.
 246  * @return Part of the depot.
 247  * @pre IsShipDepotTile(t)
 248  */
 249 static inline DepotPart GetShipDepotPart(TileIndex t)
 250 {
 251         assert(IsShipDepotTile(t));
 252         return (DepotPart)GB(_m[t].m5, WBL_DEPOT_PART, 1);
 253 }
 254
 255 /**
 256  * Get the direction of the ship depot.
 257  * @param t Water tile to query.
 258  * @return Direction of the depot.
 259  * @pre IsShipDepotTile(t)
 260  */
 261 static inline DiagDirection GetShipDepotDirection(TileIndex t)
 262 {
 263         return XYNSToDiagDir(GetShipDepotAxis(t), GetShipDepotPart(t));
 264 }
 265
 266 /**
 267  * Get the other tile of the ship depot.
 268  * @param t Tile to query, containing one section of a ship depot.
 269  * @return Tile containing the other section of the depot.
 270  * @pre IsShipDepotTile(t)
 271  */
 272 static inline TileIndex GetOtherShipDepotTile(TileIndex t)
 273 {
 274         return t + (GetShipDepotPart(t) != DEPOT_PART_NORTH ? -1 : 1) * (GetShipDepotAxis(t) != AXIS_X ? TileDiffXY(0, 1) : TileDiffXY(1, 0));
 275 }
 276
 277 /**
 278  * Get the most northern tile of a ship depot.
 279  * @param t One of the tiles of the ship depot.
 280  * @return The northern tile of the depot.
 281  * @pre IsShipDepotTile(t)
 282  */
 283 static inline TileIndex GetShipDepotNorthTile(TileIndex t)
 284 {
 285         assert(IsShipDepot(t));
 286         TileIndex tile2 = GetOtherShipDepotTile(t);
 287
 288         return t < tile2 ? t : tile2;
 289 }
 290
 291 /**
 292  * Is there a lock on a given water tile?
 293  * @param t Water tile to query.
 294  * @return \c true if it is a water lock tile.
 295  * @pre IsTileType(t, MP_WATER)
 296  */
 297 static inline bool IsLock(TileIndex t)
 298 {
 299         return GetWaterTileType(t) == WATER_TILE_LOCK;
 300 }
 301
 302 /**
 303  * Get the direction of the water lock.
 304  * @param t Water tile to query.
 305  * @return Direction of the lock.
 306  * @pre IsTileType(t, MP_WATER) && IsLock(t)
 307  */
 308 static inline DiagDirection GetLockDirection(TileIndex t)
 309 {
 310         assert(IsLock(t));
 311         return (DiagDirection)GB(_m[t].m5, WBL_LOCK_ORIENT_BEGIN, WBL_LOCK_ORIENT_COUNT);
 312 }
 313
 314 /**
 315  * Get the part of a lock.
 316  * @param t Water tile to query.
 317  * @return The part.
 318  * @pre IsTileType(t, MP_WATER) && IsLock(t)
 319  */
 320 static inline byte GetLockPart(TileIndex t)
 321 {
 322         assert(IsLock(t));
 323         return GB(_m[t].m5, WBL_LOCK_PART_BEGIN, WBL_LOCK_PART_COUNT);
 324 }
 325
 326 /**
 327  * Get the random bits of the water tile.
 328  * @param t Water tile to query.
 329  * @return Random bits of the tile.
 330  * @pre IsTileType(t, MP_WATER)
 331  */
 332 static inline byte GetWaterTileRandomBits(TileIndex t)
 333 {
 334         assert(IsTileType(t, MP_WATER));
 335         return _m[t].m4;
 336 }
 337
 338 /**
 339  * Checks whether the tile has water at the ground.
 340  * That is, it is either some plain water tile, or a object/industry/station/... with water under it.
 341  * @return true iff the tile has water at the ground.
 342  * @note Coast tiles are not considered waterish, even if there is water on a halftile.
 343  */
 344 static inline bool HasTileWaterGround(TileIndex t)
 345 {
 346         return HasTileWaterClass(t) && IsTileOnWater(t) && !IsCoastTile(t);
 347 }
 348
 349
 350 /**
 351  * Helper function to make a coast tile.
 352  * @param t The tile to change into water
 353  */
 354 static inline void MakeShore(TileIndex t)
 355 {
 356         SetTileType(t, MP_WATER);
 357         SetTileOwner(t, OWNER_WATER);
 358         SetWaterClass(t, WATER_CLASS_SEA);
 359         _m[t].m2 = 0;
 360         _m[t].m3 = 0;
 361         _m[t].m4 = 0;
 362         _m[t].m5 = WBL_TYPE_NORMAL << WBL_TYPE_BEGIN | 1 << WBL_COAST_FLAG;
 363         SB(_me[t].m6, 2, 4, 0);
 364         _me[t].m7 = 0;
 365 }
 366
 367 /**
 368  * Helper function for making a watery tile.
 369  * @param t The tile to change into water
 370  * @param o The owner of the water
 371  * @param wc The class of water the tile has to be
 372  * @param random_bits Eventual random bits to be set for this tile
 373  */
 374 static inline void MakeWater(TileIndex t, Owner o, WaterClass wc, uint8 random_bits)
 375 {
 376         SetTileType(t, MP_WATER);
 377         SetTileOwner(t, o);
 378         SetWaterClass(t, wc);
 379         _m[t].m2 = 0;
 380         _m[t].m3 = 0;
 381         _m[t].m4 = random_bits;
 382         _m[t].m5 = WBL_TYPE_NORMAL << WBL_TYPE_BEGIN;
 383         SB(_me[t].m6, 2, 4, 0);
 384         _me[t].m7 = 0;
 385 }
 386
 387 /**
 388  * Make a sea tile.
 389  * @param t The tile to change into sea
 390  */
 391 static inline void MakeSea(TileIndex t)
 392 {
 393         MakeWater(t, OWNER_WATER, WATER_CLASS_SEA, 0);
 394 }
 395
 396 /**
 397  * Make a river tile
 398  * @param t The tile to change into river
 399  * @param random_bits Random bits to be set for this tile
 400  */
 401 static inline void MakeRiver(TileIndex t, uint8 random_bits)
 402 {
 403         MakeWater(t, OWNER_WATER, WATER_CLASS_RIVER, random_bits);
 404 }
 405
 406 /**
 407  * Make a canal tile
 408  * @param t The tile to change into canal
 409  * @param o The owner of the canal
 410  * @param random_bits Random bits to be set for this tile
 411  */
 412 static inline void MakeCanal(TileIndex t, Owner o, uint8 random_bits)
 413 {
 414         assert(o != OWNER_WATER);
 415         MakeWater(t, o, WATER_CLASS_CANAL, random_bits);
 416 }
 417
 418 /**
 419  * Make a ship depot section.
 420  * @param t    Tile to place the ship depot section.
 421  * @param o    Owner of the depot.
 422  * @param did  Depot ID.
 423  * @param part Depot part (either #DEPOT_PART_NORTH or #DEPOT_PART_SOUTH).
 424  * @param a    Axis of the depot.
 425  * @param original_water_class Original water class.
 426  */
 427 static inline void MakeShipDepot(TileIndex t, Owner o, DepotID did, DepotPart part, Axis a, WaterClass original_water_class)
 428 {
 429         SetTileType(t, MP_WATER);
 430         SetTileOwner(t, o);
 431         SetWaterClass(t, original_water_class);
 432         _m[t].m2 = did;
 433         _m[t].m3 = 0;
 434         _m[t].m4 = 0;
 435         _m[t].m5 = WBL_TYPE_DEPOT << WBL_TYPE_BEGIN | part << WBL_DEPOT_PART | a << WBL_DEPOT_AXIS;
 436         SB(_me[t].m6, 2, 4, 0);
 437         _me[t].m7 = 0;
 438 }
 439
 440 /**
 441  * Make a lock section.
 442  * @param t Tile to place the water lock section.
 443  * @param o Owner of the lock.
 444  * @param part Part to place.
 445  * @param dir Lock orientation
 446  * @param original_water_class Original water class.
 447  * @see MakeLock
 448  */
 449 static inline void MakeLockTile(TileIndex t, Owner o, LockPart part, DiagDirection dir, WaterClass original_water_class)
 450 {
 451         SetTileType(t, MP_WATER);
 452         SetTileOwner(t, o);
 453         SetWaterClass(t, original_water_class);
 454         _m[t].m2 = 0;
 455         _m[t].m3 = 0;
 456         _m[t].m4 = 0;
 457         _m[t].m5 = WBL_TYPE_LOCK << WBL_TYPE_BEGIN | part << WBL_LOCK_PART_BEGIN | dir << WBL_LOCK_ORIENT_BEGIN;
 458         SB(_me[t].m6, 2, 4, 0);
 459         _me[t].m7 = 0;
 460 }
 461
 462 /**
 463  * Make a water lock.
 464  * @param t Tile to place the water lock section.
 465  * @param o Owner of the lock.
 466  * @param d Direction of the water lock.
 467  * @param wc_lower Original water class of the lower part.
 468  * @param wc_upper Original water class of the upper part.
 469  * @param wc_middle Original water class of the middle part.
 470  */
 471 static inline void MakeLock(TileIndex t, Owner o, DiagDirection d, WaterClass wc_lower, WaterClass wc_upper, WaterClass wc_middle)
 472 {
 473         TileIndexDiff delta = TileOffsByDiagDir(d);
 474
 475         /* Keep the current waterclass and owner for the tiles.
 476          * It allows to restore them after the lock is deleted */
 477         MakeLockTile(t, o, LOCK_PART_MIDDLE, d, wc_middle);
 478         MakeLockTile(t - delta, IsWaterTile(t - delta) ? GetTileOwner(t - delta) : o, LOCK_PART_LOWER, d, wc_lower);
 479         MakeLockTile(t + delta, IsWaterTile(t + delta) ? GetTileOwner(t + delta) : o, LOCK_PART_UPPER, d, wc_upper);
 480 }
 481
 482 #endif /* WATER_MAP_H */