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 <http://www.gnu.org/licenses/>.
 */
 
#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 WaterTileType : uint8_t {
  WATER_TILE_CLEAR, 
  WATER_TILE_COAST, 
  WATER_TILE_LOCK,  
  WATER_TILE_DEPOT, 
};
 
enum WaterClass : uint8_t {
  WATER_CLASS_SEA,     
  WATER_CLASS_CANAL,   
  WATER_CLASS_RIVER,   
  WATER_CLASS_INVALID, 
};
 
inline bool IsValidWaterClass(WaterClass wc)
{
  return wc < WATER_CLASS_INVALID;
}
 
enum DepotPart : uint8_t {
  DEPOT_PART_NORTH = 0, 
  DEPOT_PART_SOUTH = 1, 
  DEPOT_PART_END
};
 
enum LockPart : uint8_t {
  LOCK_PART_MIDDLE = 0, 
  LOCK_PART_LOWER  = 1, 
  LOCK_PART_UPPER  = 2, 
};
 
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 (WaterClass)GB(t.m1(), 5, 2);
}
 
inline void SetWaterClass(Tile t, WaterClass wc)
{
  assert(HasTileWaterClass(t));
  SB(t.m1(), 5, 2, wc);
}
 
inline bool IsTileOnWater(Tile t)
{
  return (GetWaterClass(t) != WATER_CLASS_INVALID);
}
 
inline bool IsWater(Tile t)
{
  return GetWaterTileType(t) == WATER_TILE_CLEAR;
}
 
inline bool IsSea(Tile t)
{
  return IsWater(t) && GetWaterClass(t) == WATER_CLASS_SEA;
}
 
inline bool IsCanal(Tile t)
{
  return IsWater(t) && GetWaterClass(t) == WATER_CLASS_CANAL;
}
 
inline bool IsRiver(Tile t)
{
  return IsWater(t) && GetWaterClass(t) == WATER_CLASS_RIVER;
}
 
inline bool IsWaterTile(Tile t)
{
  return IsTileType(t, MP_WATER) && IsWater(t);
}
 
inline bool IsCoast(Tile t)
{
  return GetWaterTileType(t) == WATER_TILE_COAST;
}
 
inline bool IsCoastTile(Tile t)
{
  return (IsTileType(t, MP_WATER) && IsCoast(t)) || (IsTileType(t, MP_TREES) && GetWaterClass(t) != WATER_CLASS_INVALID);
}
 
inline bool IsShipDepot(Tile t)
{
  return GetWaterTileType(t) == WATER_TILE_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 (DepotPart)GB(t.m5(), WBL_DEPOT_PART, 1);
}
 
inline DiagDirection GetShipDepotDirection(Tile t)
{
  return XYNSToDiagDir(GetShipDepotAxis(t), GetShipDepotPart(t));
}
 
inline TileIndex GetOtherShipDepotTile(Tile t)
{
  return TileIndex(t) + (GetShipDepotPart(t) != DEPOT_PART_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) == WATER_TILE_LOCK;
}
 
inline DiagDirection GetLockDirection(Tile t)
{
  assert(IsLock(t));
  return (DiagDirection)GB(t.m5(), WBL_LOCK_ORIENT_BEGIN, WBL_LOCK_ORIENT_COUNT);
}
 
inline uint8_t GetLockPart(Tile t)
{
  assert(IsLock(t));
  return 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, WATER_CLASS_SEA);
  SetDockingTile(t, false);
  t.m2() = 0;
  t.m3() = 0;
  t.m4() = 0;
  t.m5() = 0;
  SetWaterTileType(t, WATER_TILE_COAST);
  SB(t.m6(), 2, 4, 0);
  t.m7() = 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, WATER_TILE_CLEAR);
  SB(t.m6(), 2, 4, 0);
  t.m7() = 0;
}
 
inline void MakeSea(Tile t)
{
  MakeWater(t, OWNER_WATER, WATER_CLASS_SEA, 0);
}
 
inline void MakeRiver(Tile t, uint8_t random_bits)
{
  MakeWater(t, OWNER_WATER, WATER_CLASS_RIVER, random_bits);
}
 
inline void MakeCanal(Tile t, Owner o, uint8_t random_bits)
{
  assert(o != OWNER_WATER);
  MakeWater(t, o, WATER_CLASS_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() = part << WBL_DEPOT_PART | a << WBL_DEPOT_AXIS;
  SetWaterTileType(t, WATER_TILE_DEPOT);
  SB(t.m6(), 2, 4, 0);
  t.m7() = 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() = part << WBL_LOCK_PART_BEGIN | dir << WBL_LOCK_ORIENT_BEGIN;
  SetWaterTileType(t, WATER_TILE_LOCK);
  SB(t.m6(), 2, 4, 0);
  t.m7() = 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, LOCK_PART_MIDDLE, d, wc_middle);
  MakeLockTile(lower_tile, IsWaterTile(lower_tile) ? GetTileOwner(lower_tile) : o, LOCK_PART_LOWER, d, wc_lower);
  MakeLockTile(upper_tile, IsWaterTile(upper_tile) ? GetTileOwner(upper_tile) : o, LOCK_PART_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 */