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"
 
enum WaterTileTypeBitLayout {
  WBL_TYPE_BEGIN        = 4,   
  WBL_TYPE_COUNT        = 4,   
 
  WBL_TYPE_NORMAL       = 0x0, 
  WBL_TYPE_LOCK         = 0x1, 
  WBL_TYPE_DEPOT        = 0x8, 
 
  WBL_COAST_FLAG        = 0,   
 
  WBL_LOCK_ORIENT_BEGIN = 0,   
  WBL_LOCK_ORIENT_COUNT = 2,   
  WBL_LOCK_PART_BEGIN   = 2,   
  WBL_LOCK_PART_COUNT   = 2,   
 
  WBL_DEPOT_PART        = 0,   
  WBL_DEPOT_AXIS        = 1,   
};
 
enum WaterTileType {
  WATER_TILE_CLEAR, 
  WATER_TILE_COAST, 
  WATER_TILE_LOCK,  
  WATER_TILE_DEPOT, 
};
 
enum WaterClass : byte {
  WATER_CLASS_SEA,     
  WATER_CLASS_CANAL,   
  WATER_CLASS_RIVER,   
  WATER_CLASS_INVALID, 
};
template <> struct EnumPropsT<WaterClass> : MakeEnumPropsT<WaterClass, byte, WATER_CLASS_SEA, WATER_CLASS_INVALID, WATER_CLASS_INVALID, 2> {};
 
static inline bool IsValidWaterClass(WaterClass wc)
{
  return wc < WATER_CLASS_INVALID;
}
 
enum DepotPart {
  DEPOT_PART_NORTH = 0, 
  DEPOT_PART_SOUTH = 1, 
  DEPOT_PART_END
};
 
enum LockPart {
  LOCK_PART_MIDDLE = 0, 
  LOCK_PART_LOWER  = 1, 
  LOCK_PART_UPPER  = 2, 
};
 
bool IsPossibleDockingTile(TileIndex t);
 
static inline WaterTileType GetWaterTileType(TileIndex t)
{
  assert(IsTileType(t, MP_WATER));
 
  switch (GB(_m[t].m5, WBL_TYPE_BEGIN, WBL_TYPE_COUNT)) {
    case WBL_TYPE_NORMAL: return HasBit(_m[t].m5, WBL_COAST_FLAG) ? WATER_TILE_COAST : WATER_TILE_CLEAR;
    case WBL_TYPE_LOCK:   return WATER_TILE_LOCK;
    case WBL_TYPE_DEPOT:  return WATER_TILE_DEPOT;
    default: NOT_REACHED();
  }
}
 
static inline bool HasTileWaterClass(TileIndex t)
{
  return IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_TREES);
}
 
static inline WaterClass GetWaterClass(TileIndex t)
{
  assert(HasTileWaterClass(t));
  return (WaterClass)GB(_m[t].m1, 5, 2);
}
 
static inline void SetWaterClass(TileIndex t, WaterClass wc)
{
  assert(HasTileWaterClass(t));
  SB(_m[t].m1, 5, 2, wc);
}
 
static inline bool IsTileOnWater(TileIndex t)
{
  return (GetWaterClass(t) != WATER_CLASS_INVALID);
}
 
static inline bool IsWater(TileIndex t)
{
  return GetWaterTileType(t) == WATER_TILE_CLEAR;
}
 
static inline bool IsSea(TileIndex t)
{
  return IsWater(t) && GetWaterClass(t) == WATER_CLASS_SEA;
}
 
static inline bool IsCanal(TileIndex t)
{
  return IsWater(t) && GetWaterClass(t) == WATER_CLASS_CANAL;
}
 
static inline bool IsRiver(TileIndex t)
{
  return IsWater(t) && GetWaterClass(t) == WATER_CLASS_RIVER;
}
 
static inline bool IsWaterTile(TileIndex t)
{
  return IsTileType(t, MP_WATER) && IsWater(t);
}
 
static inline bool IsCoast(TileIndex t)
{
  return GetWaterTileType(t) == WATER_TILE_COAST;
}
 
static inline bool IsCoastTile(TileIndex t)
{
  return (IsTileType(t, MP_WATER) && IsCoast(t)) || (IsTileType(t, MP_TREES) && GetWaterClass(t) != WATER_CLASS_INVALID);
}
 
static inline bool IsShipDepot(TileIndex t)
{
  return GetWaterTileType(t) == WATER_TILE_DEPOT;
}
 
static inline bool IsShipDepotTile(TileIndex t)
{
  return IsTileType(t, MP_WATER) && IsShipDepot(t);
}
 
static inline Axis GetShipDepotAxis(TileIndex t)
{
  assert(IsShipDepotTile(t));
  return (Axis)GB(_m[t].m5, WBL_DEPOT_AXIS, 1);
}
 
static inline DepotPart GetShipDepotPart(TileIndex t)
{
  assert(IsShipDepotTile(t));
  return (DepotPart)GB(_m[t].m5, WBL_DEPOT_PART, 1);
}
 
static inline DiagDirection GetShipDepotDirection(TileIndex t)
{
  return XYNSToDiagDir(GetShipDepotAxis(t), GetShipDepotPart(t));
}
 
static inline TileIndex GetOtherShipDepotTile(TileIndex t)
{
  return t + (GetShipDepotPart(t) != DEPOT_PART_NORTH ? -1 : 1) * (GetShipDepotAxis(t) != AXIS_X ? TileDiffXY(0, 1) : TileDiffXY(1, 0));
}
 
static inline TileIndex GetShipDepotNorthTile(TileIndex t)
{
  assert(IsShipDepot(t));
  TileIndex tile2 = GetOtherShipDepotTile(t);
 
  return t < tile2 ? t : tile2;
}
 
static inline bool IsLock(TileIndex t)
{
  return GetWaterTileType(t) == WATER_TILE_LOCK;
}
 
static inline DiagDirection GetLockDirection(TileIndex t)
{
  assert(IsLock(t));
  return (DiagDirection)GB(_m[t].m5, WBL_LOCK_ORIENT_BEGIN, WBL_LOCK_ORIENT_COUNT);
}
 
static inline byte GetLockPart(TileIndex t)
{
  assert(IsLock(t));
  return GB(_m[t].m5, WBL_LOCK_PART_BEGIN, WBL_LOCK_PART_COUNT);
}
 
static inline byte GetWaterTileRandomBits(TileIndex t)
{
  assert(IsTileType(t, MP_WATER));
  return _m[t].m4;
}
 
static inline bool HasTileWaterGround(TileIndex t)
{
  return HasTileWaterClass(t) && IsTileOnWater(t) && !IsCoastTile(t);
}
 
static inline void SetDockingTile(TileIndex t, bool b)
{
  assert(IsTileType(t, MP_WATER) || IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE));
  SB(_m[t].m1, 7, 1, b ? 1 : 0);
}
 
static inline bool IsDockingTile(TileIndex t)
{
  return (IsTileType(t, MP_WATER) || IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE)) && HasBit(_m[t].m1, 7);
}
 
 
static inline void MakeShore(TileIndex t)
{
  SetTileType(t, MP_WATER);
  SetTileOwner(t, OWNER_WATER);
  SetWaterClass(t, WATER_CLASS_SEA);
  SetDockingTile(t, false);
  _m[t].m2 = 0;
  _m[t].m3 = 0;
  _m[t].m4 = 0;
  _m[t].m5 = WBL_TYPE_NORMAL << WBL_TYPE_BEGIN | 1 << WBL_COAST_FLAG;
  SB(_me[t].m6, 2, 4, 0);
  _me[t].m7 = 0;
}
 
static inline void MakeWater(TileIndex t, Owner o, WaterClass wc, uint8 random_bits)
{
  SetTileType(t, MP_WATER);
  SetTileOwner(t, o);
  SetWaterClass(t, wc);
  SetDockingTile(t, false);
  _m[t].m2 = 0;
  _m[t].m3 = 0;
  _m[t].m4 = random_bits;
  _m[t].m5 = WBL_TYPE_NORMAL << WBL_TYPE_BEGIN;
  SB(_me[t].m6, 2, 4, 0);
  _me[t].m7 = 0;
}
 
static inline void MakeSea(TileIndex t)
{
  MakeWater(t, OWNER_WATER, WATER_CLASS_SEA, 0);
}
 
static inline void MakeRiver(TileIndex t, uint8 random_bits)
{
  MakeWater(t, OWNER_WATER, WATER_CLASS_RIVER, random_bits);
}
 
static inline void MakeCanal(TileIndex t, Owner o, uint8 random_bits)
{
  assert(o != OWNER_WATER);
  MakeWater(t, o, WATER_CLASS_CANAL, random_bits);
}
 
static inline void MakeShipDepot(TileIndex 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);
  _m[t].m2 = did;
  _m[t].m3 = 0;
  _m[t].m4 = 0;
  _m[t].m5 = WBL_TYPE_DEPOT << WBL_TYPE_BEGIN | part << WBL_DEPOT_PART | a << WBL_DEPOT_AXIS;
  SB(_me[t].m6, 2, 4, 0);
  _me[t].m7 = 0;
}
 
static inline void MakeLockTile(TileIndex 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);
  _m[t].m2 = 0;
  _m[t].m3 = 0;
  _m[t].m4 = 0;
  _m[t].m5 = WBL_TYPE_LOCK << WBL_TYPE_BEGIN | part << WBL_LOCK_PART_BEGIN | dir << WBL_LOCK_ORIENT_BEGIN;
  SB(_me[t].m6, 2, 4, 0);
  _me[t].m7 = 0;
}
 
static inline void MakeLock(TileIndex t, Owner o, DiagDirection d, WaterClass wc_lower, WaterClass wc_upper, WaterClass wc_middle)
{
  TileIndexDiff delta = TileOffsByDiagDir(d);
 
  /* 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(t - delta, IsWaterTile(t - delta) ? GetTileOwner(t - delta) : o, LOCK_PART_LOWER, d, wc_lower);
  MakeLockTile(t + delta, IsWaterTile(t + delta) ? GetTileOwner(t + delta) : o, LOCK_PART_UPPER, d, wc_upper);
}
 
#endif /* WATER_MAP_H */