tile_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 TILE_MAP_H
#define TILE_MAP_H
 
#include "slope_type.h"
#include "map_func.h"
#include "core/bitmath_func.hpp"
#include "settings_type.h"
 
debug_inline static uint TileHeight(Tile tile)
{
  assert(tile < Map::Size());
  return tile.height();
}
 
inline uint TileHeightOutsideMap(int x, int y)
{
  return TileHeight(TileXY(Clamp(x, 0, Map::MaxX()), Clamp(y, 0, Map::MaxY())));
}
 
inline void SetTileHeight(Tile tile, uint height)
{
  assert(tile < Map::Size());
  assert(height <= MAX_TILE_HEIGHT);
  tile.height() = height;
}
 
inline uint TilePixelHeight(Tile tile)
{
  return TileHeight(tile) * TILE_HEIGHT;
}
 
inline uint TilePixelHeightOutsideMap(int x, int y)
{
  return TileHeightOutsideMap(x, y) * TILE_HEIGHT;
}
 
debug_inline static TileType GetTileType(Tile tile)
{
  assert(tile < Map::Size());
  return (TileType)GB(tile.type(), 4, 4);
}
 
inline bool IsInnerTile(Tile tile)
{
  assert(tile < Map::Size());
 
  uint x = TileX(tile);
  uint y = TileY(tile);
 
  return x < Map::MaxX() && y < Map::MaxY() && ((x > 0 && y > 0) || !_settings_game.construction.freeform_edges);
}
 
inline void SetTileType(Tile tile, TileType type)
{
  assert(tile < Map::Size());
  /* VOID tiles (and no others) are exactly allowed at the lower left and right
   * edges of the map. If _settings_game.construction.freeform_edges is true,
   * the upper edges of the map are also VOID tiles. */
  assert(IsInnerTile(tile) == (type != MP_VOID));
  SB(tile.type(), 4, 4, type);
}
 
debug_inline static bool IsTileType(Tile tile, TileType type)
{
  return GetTileType(tile) == type;
}
 
inline bool IsValidTile(Tile tile)
{
  return tile < Map::Size() && !IsTileType(tile, MP_VOID);
}
 
inline Owner GetTileOwner(Tile tile)
{
  assert(IsValidTile(tile));
  assert(!IsTileType(tile, MP_HOUSE));
  assert(!IsTileType(tile, MP_INDUSTRY));
 
  return (Owner)GB(tile.m1(), 0, 5);
}
 
inline void SetTileOwner(Tile tile, Owner owner)
{
  assert(IsValidTile(tile));
  assert(!IsTileType(tile, MP_HOUSE));
  assert(!IsTileType(tile, MP_INDUSTRY));
 
  SB(tile.m1(), 0, 5, owner);
}
 
inline bool IsTileOwner(Tile tile, Owner owner)
{
  return GetTileOwner(tile) == owner;
}
 
inline void SetTropicZone(Tile tile, TropicZone type)
{
  assert(tile < Map::Size());
  assert(!IsTileType(tile, MP_VOID) || type == TROPICZONE_NORMAL);
  SB(tile.type(), 0, 2, type);
}
 
inline TropicZone GetTropicZone(Tile tile)
{
  assert(tile < Map::Size());
  return (TropicZone)GB(tile.type(), 0, 2);
}
 
inline uint8_t GetAnimationFrame(Tile t)
{
  assert(IsTileType(t, MP_HOUSE) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_STATION));
  return t.m7();
}
 
inline void SetAnimationFrame(Tile t, uint8_t frame)
{
  assert(IsTileType(t, MP_HOUSE) || IsTileType(t, MP_OBJECT) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_STATION));
  t.m7() = frame;
}
 
std::tuple<Slope, int> GetTileSlopeZ(TileIndex tile);
int GetTileZ(TileIndex tile);
int GetTileMaxZ(TileIndex tile);
 
bool IsTileFlat(TileIndex tile, int *h = nullptr);
 
inline Slope GetTileSlope(TileIndex tile)
{
  return std::get<0>(GetTileSlopeZ(tile));
}
 
inline std::tuple<Slope, int> GetTilePixelSlope(TileIndex tile)
{
  auto [s, h] = GetTileSlopeZ(tile);
  return {s, h * TILE_HEIGHT};
}
 
std::tuple<Slope, int> GetTilePixelSlopeOutsideMap(int x, int y);
 
inline int GetTilePixelZ(TileIndex tile)
{
  return GetTileZ(tile) * TILE_HEIGHT;
}
 
inline int GetTileMaxPixelZ(TileIndex tile)
{
  return GetTileMaxZ(tile) * TILE_HEIGHT;
}
 
inline uint TileHash(uint x, uint y)
{
  uint hash = x >> 4;
  hash ^= x >> 6;
  hash ^= y >> 4;
  hash -= y >> 6;
  return hash;
}
 
inline uint TileHash2Bit(uint x, uint y)
{
  return GB(TileHash(x, y), 0, 2);
}
 
#endif /* TILE_MAP_H */