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, 
  ClearRocks = 4, 
  CoastRocks = 5, 
};

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, TileType::Water));
  return static_cast<WaterTileType>(GB(t.m5(), WBL_TYPE_BEGIN, WBL_TYPE_COUNT));
}

inline void SetWaterTileType(Tile t, WaterTileType type)
{
  assert(IsTileType(t, TileType::Water));
  SB(t.m5(), WBL_TYPE_BEGIN, WBL_TYPE_COUNT, to_underlying(type));
}

inline bool HasTileWaterClass(Tile t)
{
  return IsTileType(t, TileType::Water) || IsTileType(t, TileType::Station) || IsTileType(t, TileType::Industry) || IsTileType(t, TileType::Object) || IsTileType(t, TileType::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, TileType::Water) && IsWater(t);
}

inline bool IsCoast(Tile t)
{
  WaterTileType wtt = GetWaterTileType(t);
  return wtt == WaterTileType::Coast || wtt == WaterTileType::CoastRocks;
}

inline bool IsCoastTile(Tile t)
{
  return (IsTileType(t, TileType::Water) && IsCoast(t)) || (IsTileType(t, TileType::Trees) && GetWaterClass(t) != WaterClass::Invalid);
}

inline bool IsShipDepot(Tile t)
{
  return GetWaterTileType(t) == WaterTileType::Depot;
}

inline bool IsShipDepotTile(Tile t)
{
  return IsTileType(t, TileType::Water) && IsShipDepot(t);
}

inline Axis GetShipDepotAxis(Tile t)
{
  assert(IsShipDepotTile(t));
  return static_cast<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 static_cast<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, TileType::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, TileType::Water) || IsTileType(t, TileType::Railway) || IsTileType(t, TileType::Station) || IsTileType(t, TileType::TunnelBridge));
  AssignBit(t.m1(), 7, b);
}

inline bool IsDockingTile(Tile t)
{
  return (IsTileType(t, TileType::Water) || IsTileType(t, TileType::Railway) || IsTileType(t, TileType::Station) || IsTileType(t, TileType::TunnelBridge)) && HasBit(t.m1(), 7);
}
 

inline void MakeShore(Tile t, bool rocks = false)
{
  SetTileType(t, TileType::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, rocks ? WaterTileType::CoastRocks : 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, bool rocks = false)
{
  SetTileType(t, TileType::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, rocks ? WaterTileType::ClearRocks : WaterTileType::Clear);
  SB(t.m6(), 2, 6, 0);
  t.m7() = 0;
  t.m8() = 0;
}

inline void MakeSea(Tile t, bool rocks = false)
{
  MakeWater(t, OWNER_WATER, WaterClass::Sea, 0, rocks);
}

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, TileType::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 | to_underlying(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, TileType::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 | to_underlying(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, TileType::Water));
  AssignBit(t.m3(), 0, b);
}

inline bool IsNonFloodingWaterTile(Tile t)
{
  assert(IsTileType(t, TileType::Water));
  return HasBit(t.m3(), 0);
}
 
#endif /* WATER_MAP_H */