water_map.h

Go to the documentation of this file.

/*
 * 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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */
 
#ifndef WATER_MAP_H
#define WATER_MAP_H
 
#include "depot_type.h"
#include "tile_map.h"
 
static constexpr uint8_t WBL_TYPE_BEGIN = 4; 
static constexpr uint8_t WBL_TYPE_COUNT = 4; 
 
static constexpr uint8_t WBL_LOCK_ORIENT_BEGIN = 0; 
static constexpr uint8_t WBL_LOCK_ORIENT_COUNT = 2; 
static constexpr uint8_t WBL_LOCK_PART_BEGIN = 2; 
static constexpr uint8_t WBL_LOCK_PART_COUNT = 2; 
 
static constexpr uint8_t WBL_DEPOT_PART = 0; 
static constexpr uint8_t WBL_DEPOT_AXIS = 1; 
 
enum class WaterTileType : uint8_t {
  Clear = 0, 
  Coast = 1, 
  Lock = 2, 
  Depot = 3, 
};
 
enum class WaterClass : uint8_t {
  Sea = 0, 
  Canal = 1, 
  River = 2, 
  Invalid = 3, 
};
 
inline bool IsValidWaterClass(WaterClass wc)
{
  return wc < WaterClass::Invalid;
}
 
enum class DepotPart : uint8_t {
  North = 0, 
  South = 1, 
  End,
};
 
enum class LockPart : uint8_t {
  Middle = 0, 
  Lower = 1, 
  Upper = 2, 
  End,
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(LockPart);
 
bool IsPossibleDockingTile(Tile t);
 
inline WaterTileType GetWaterTileType(Tile t)
{
  assert(IsTileType(t, MP_WATER));
  return static_cast<WaterTileType>(GB(t.m5(), WBL_TYPE_BEGIN, WBL_TYPE_COUNT));
}
 
inline void SetWaterTileType(Tile t, WaterTileType type)
{
  assert(IsTileType(t, MP_WATER));
  SB(t.m5(), WBL_TYPE_BEGIN, WBL_TYPE_COUNT, to_underlying(type));
}
 
inline bool HasTileWaterClass(Tile t)
{
  return IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_TREES);
}
 
inline WaterClass GetWaterClass(Tile t)
{
  assert(HasTileWaterClass(t));
  return static_cast<WaterClass>(GB(t.m1(), 5, 2));
}
 
inline void SetWaterClass(Tile t, WaterClass wc)
{
  assert(HasTileWaterClass(t));
  SB(t.m1(), 5, 2, to_underlying(wc));
}
 
inline bool IsTileOnWater(Tile t)
{
  return (GetWaterClass(t) != WaterClass::Invalid);
}
 
inline bool IsWater(Tile t)
{
  return GetWaterTileType(t) == WaterTileType::Clear;
}
 
inline bool IsSea(Tile t)
{
  return IsWater(t) && GetWaterClass(t) == WaterClass::Sea;
}
 
inline bool IsCanal(Tile t)
{
  return IsWater(t) && GetWaterClass(t) == WaterClass::Canal;
}
 
inline bool IsRiver(Tile t)
{
  return IsWater(t) && GetWaterClass(t) == WaterClass::River;
}
 
inline bool IsWaterTile(Tile t)
{
  return IsTileType(t, MP_WATER) && IsWater(t);
}
 
inline bool IsCoast(Tile t)
{
  return GetWaterTileType(t) == WaterTileType::Coast;
}
 
inline bool IsCoastTile(Tile t)
{
  return (IsTileType(t, MP_WATER) && IsCoast(t)) || (IsTileType(t, MP_TREES) && GetWaterClass(t) != WaterClass::Invalid);
}
 
inline bool IsShipDepot(Tile t)
{
  return GetWaterTileType(t) == WaterTileType::Depot;
}
 
inline bool IsShipDepotTile(Tile t)
{
  return IsTileType(t, MP_WATER) && IsShipDepot(t);
}
 
inline Axis GetShipDepotAxis(Tile t)
{
  assert(IsShipDepotTile(t));
  return (Axis)GB(t.m5(), WBL_DEPOT_AXIS, 1);
}
 
inline DepotPart GetShipDepotPart(Tile t)
{
  assert(IsShipDepotTile(t));
  return static_cast<DepotPart>(GB(t.m5(), WBL_DEPOT_PART, 1));
}
 
inline DiagDirection GetShipDepotDirection(Tile t)
{
  return XYNSToDiagDir(GetShipDepotAxis(t), to_underlying(GetShipDepotPart(t)));
}
 
inline TileIndex GetOtherShipDepotTile(Tile t)
{
  return TileIndex(t) + (GetShipDepotPart(t) != DepotPart::North ? -1 : 1) * TileOffsByAxis(GetShipDepotAxis(t));
}
 
inline TileIndex GetShipDepotNorthTile(Tile t)
{
  assert(IsShipDepot(t));
  TileIndex tile2 = GetOtherShipDepotTile(t);
 
  return t < tile2 ? TileIndex(t) : tile2;
}
 
inline bool IsLock(Tile t)
{
  return GetWaterTileType(t) == WaterTileType::Lock;
}
 
inline DiagDirection GetLockDirection(Tile t)
{
  assert(IsLock(t));
  return (DiagDirection)GB(t.m5(), WBL_LOCK_ORIENT_BEGIN, WBL_LOCK_ORIENT_COUNT);
}
 
inline LockPart GetLockPart(Tile t)
{
  assert(IsLock(t));
  return static_cast<LockPart>(GB(t.m5(), WBL_LOCK_PART_BEGIN, WBL_LOCK_PART_COUNT));
}
 
inline uint8_t GetWaterTileRandomBits(Tile t)
{
  assert(IsTileType(t, MP_WATER));
  return t.m4();
}
 
inline bool HasTileWaterGround(Tile t)
{
  return HasTileWaterClass(t) && IsTileOnWater(t) && !IsCoastTile(t);
}
 
inline void SetDockingTile(Tile t, bool b)
{
  assert(IsTileType(t, MP_WATER) || IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE));
  AssignBit(t.m1(), 7, b);
}
 
inline bool IsDockingTile(Tile t)
{
  return (IsTileType(t, MP_WATER) || IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE)) && HasBit(t.m1(), 7);
}
 
 
inline void MakeShore(Tile t)
{
  SetTileType(t, MP_WATER);
  SetTileOwner(t, OWNER_WATER);
  SetWaterClass(t, WaterClass::Sea);
  SetDockingTile(t, false);
  t.m2() = 0;
  t.m3() = 0;
  t.m4() = 0;
  t.m5() = 0;
  SetWaterTileType(t, WaterTileType::Coast);
  SB(t.m6(), 2, 6, 0);
  t.m7() = 0;
  t.m8() = 0;
}
 
inline void MakeWater(Tile t, Owner o, WaterClass wc, uint8_t random_bits)
{
  SetTileType(t, MP_WATER);
  SetTileOwner(t, o);
  SetWaterClass(t, wc);
  SetDockingTile(t, false);
  t.m2() = 0;
  t.m3() = 0;
  t.m4() = random_bits;
  t.m5() = 0;
  SetWaterTileType(t, WaterTileType::Clear);
  SB(t.m6(), 2, 6, 0);
  t.m7() = 0;
  t.m8() = 0;
}
 
inline void MakeSea(Tile t)
{
  MakeWater(t, OWNER_WATER, WaterClass::Sea, 0);
}
 
inline void MakeRiver(Tile t, uint8_t random_bits)
{
  MakeWater(t, OWNER_WATER, WaterClass::River, random_bits);
}
 
inline void MakeCanal(Tile t, Owner o, uint8_t random_bits)
{
  assert(o != OWNER_WATER);
  MakeWater(t, o, WaterClass::Canal, random_bits);
}
 
inline void MakeShipDepot(Tile t, Owner o, DepotID did, DepotPart part, Axis a, WaterClass original_water_class)
{
  SetTileType(t, MP_WATER);
  SetTileOwner(t, o);
  SetWaterClass(t, original_water_class);
  SetDockingTile(t, false);
  t.m2() = did.base();
  t.m3() = 0;
  t.m4() = 0;
  t.m5() = to_underlying(part) << WBL_DEPOT_PART | a << WBL_DEPOT_AXIS;
  SetWaterTileType(t, WaterTileType::Depot);
  SB(t.m6(), 2, 6, 0);
  t.m7() = 0;
  t.m8() = 0;
}
 
inline void MakeLockTile(Tile t, Owner o, LockPart part, DiagDirection dir, WaterClass original_water_class)
{
  SetTileType(t, MP_WATER);
  SetTileOwner(t, o);
  SetWaterClass(t, original_water_class);
  SetDockingTile(t, false);
  t.m2() = 0;
  t.m3() = 0;
  t.m4() = 0;
  t.m5() = to_underlying(part) << WBL_LOCK_PART_BEGIN | dir << WBL_LOCK_ORIENT_BEGIN;
  SetWaterTileType(t, WaterTileType::Lock);
  SB(t.m6(), 2, 6, 0);
  t.m7() = 0;
  t.m8() = 0;
}
 
inline void MakeLock(Tile t, Owner o, DiagDirection d, WaterClass wc_lower, WaterClass wc_upper, WaterClass wc_middle)
{
  TileIndexDiff delta = TileOffsByDiagDir(d);
  Tile lower_tile = TileIndex(t) - delta;
  Tile upper_tile = TileIndex(t) + delta;
 
  /* Keep the current waterclass and owner for the tiles.
   * It allows to restore them after the lock is deleted */
  MakeLockTile(t, o, LockPart::Middle, d, wc_middle);
  MakeLockTile(lower_tile, IsWaterTile(lower_tile) ? GetTileOwner(lower_tile) : o, LockPart::Lower, d, wc_lower);
  MakeLockTile(upper_tile, IsWaterTile(upper_tile) ? GetTileOwner(upper_tile) : o, LockPart::Upper, d, wc_upper);
}
 
inline void SetNonFloodingWaterTile(Tile t, bool b)
{
  assert(IsTileType(t, MP_WATER));
  AssignBit(t.m3(), 0, b);
}
inline bool IsNonFloodingWaterTile(Tile t)
{
  assert(IsTileType(t, MP_WATER));
  return HasBit(t.m3(), 0);
}
 
#endif /* WATER_MAP_H */