map_func.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 MAP_FUNC_H
#define MAP_FUNC_H
 
#include "core/math_func.hpp"
#include "tile_type.h"
#include "map_type.h"
#include "direction_func.h"

class Tile {
private:
  friend struct Map;
  struct TileBase {
    uint8_t type = 0; 
    uint8_t height = 0; 
    uint16_t m2 = 0; 
    uint8_t m1 = 0; 
    uint8_t m3 = 0; 
    uint8_t m4 = 0; 
    uint8_t m5 = 0; 
  };
 
  static_assert(sizeof(TileBase) == 8);

  struct TileExtended {
    uint8_t m6 = 0; 
    uint8_t m7 = 0; 
    uint16_t m8 = 0; 
  };
 
  static std::unique_ptr<TileBase[]> base_tiles; 
  static std::unique_ptr<TileExtended[]> extended_tiles; 
 
  TileIndex tile; 
 
public:
  [[debug_inline]] inline Tile(TileIndex tile) : tile(tile) {}

  Tile(uint tile) : tile(tile) {}

  [[debug_inline]] inline constexpr operator TileIndex() const { return this->tile; }

  [[debug_inline]] inline constexpr operator uint() const { return this->tile.base(); }

  [[debug_inline]] inline uint8_t &type()
  {
    return base_tiles[this->tile.base()].type;
  }

  [[debug_inline]] inline uint8_t &height()
  {
    return base_tiles[this->tile.base()].height;
  }

  [[debug_inline]] inline uint8_t &m1()
  {
    return base_tiles[this->tile.base()].m1;
  }

  [[debug_inline]] inline uint16_t &m2()
  {
    return base_tiles[this->tile.base()].m2;
  }

  [[debug_inline]] inline uint8_t &m3()
  {
    return base_tiles[this->tile.base()].m3;
  }

  [[debug_inline]] inline uint8_t &m4()
  {
    return base_tiles[this->tile.base()].m4;
  }

  [[debug_inline]] inline uint8_t &m5()
  {
    return base_tiles[this->tile.base()].m5;
  }

  [[debug_inline]] inline uint8_t &m6()
  {
    return extended_tiles[this->tile.base()].m6;
  }

  [[debug_inline]] inline uint8_t &m7()
  {
    return extended_tiles[this->tile.base()].m7;
  }

  [[debug_inline]] inline uint16_t &m8()
  {
    return extended_tiles[this->tile.base()].m8;
  }
};

struct Map {
private:
  struct Iterator {
    typedef Tile value_type;
    typedef Tile *pointer;
    typedef Tile &reference;
    typedef size_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
 
    explicit Iterator(TileIndex index) : index(index) {}
    bool operator==(const Iterator &other) const { return this->index == other.index; }
    Tile operator*() const { return this->index; }
    Iterator & operator++() { this->index++; return *this; }
  private:
    TileIndex index;
  };
 
  /*
   * Iterable ensemble of all Tiles
   */
  struct IterateWrapper {
    Iterator begin() { return Iterator(TileIndex{}); }
    Iterator end() { return Iterator(TileIndex{Map::Size()}); }
    bool empty() { return false; }
  };
 
  static uint log_x;     
  static uint log_y;     
  static uint size_x;    
  static uint size_y;    
  static uint size;      
  static uint tile_mask; 
 
  static uint initial_land_count; 
 
public:
  static void Allocate(uint size_x, uint size_y);
  static void CountLandTiles();

  [[debug_inline]] inline static uint LogX()
  {
    return Map::log_x;
  }

  static inline uint LogY()
  {
    return Map::log_y;
  }

  [[debug_inline]] inline static uint SizeX()
  {
    return Map::size_x;
  }

  static inline uint SizeY()
  {
    return Map::size_y;
  }

  [[debug_inline]] inline static uint Size()
  {
    return Map::size;
  }

  [[debug_inline]] inline static uint MaxX()
  {
    return Map::SizeX() - 1;
  }

  static inline uint MaxY()
  {
    return Map::SizeY() - 1;
  }

  static inline uint ScaleByLandProportion(uint n)
  {
    /* Use 64-bit arithmetic to avoid overflow. */
    return static_cast<uint>(static_cast<uint64_t>(n) * Map::initial_land_count / Map::size);
  }

  static inline TileIndex WrapToMap(TileIndex tile)
  {
    return TileIndex{tile.base() & Map::tile_mask};
  }

  static inline uint ScaleBySize(uint n)
  {
    /* Subtract 12 from shift in order to prevent integer overflow
     * for large values of n. It's safe since the min mapsize is 64x64. */
    return CeilDiv(n << (Map::LogX() + Map::LogY() - 12), 1 << 4);
  }

  static inline uint ScaleBySize1D(uint n)
  {
    /* Normal circumference for the X+Y is 256+256 = 1<<9
     * Note, not actually taking the full circumference into account,
     * just half of it. */
    return CeilDiv((n << Map::LogX()) + (n << Map::LogY()), 1 << 9);
  }

  static bool IsInitialized()
  {
    return Tile::base_tiles != nullptr;
  }

  static IterateWrapper Iterate() { return IterateWrapper(); }
};

[[debug_inline]] inline static TileIndex TileXY(uint x, uint y)
{
  return TileIndex{(y << Map::LogX()) + x};
}

inline TileIndexDiff TileDiffXY(int x, int y)
{
  /* Multiplication gives much better optimization on MSVC than shifting.
   * 0 << shift isn't optimized to 0 properly.
   * Typically x and y are constants, and then this doesn't result
   * in any actual multiplication in the assembly code.. */
  return (y * Map::SizeX()) + x;
}

[[debug_inline]] inline static TileIndex TileVirtXY(uint x, uint y)
{
  return TileIndex{(y >> 4 << Map::LogX()) + (x >> 4)};
}
 

[[debug_inline]] inline static uint TileX(TileIndex tile)
{
  return tile.base() & Map::MaxX();
}

[[debug_inline]] inline static uint TileY(TileIndex tile)
{
  return tile.base() >> Map::LogX();
}

inline TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
{
  return TileDiffXY(tidc.x, tidc.y);
}
 
/* Helper functions to provide explicit +=/-= operators for TileIndex and TileIndexDiff. */
constexpr TileIndex &operator+=(TileIndex &tile, TileIndexDiff offset) { tile = tile + TileIndex(offset); return tile; }
constexpr TileIndex &operator-=(TileIndex &tile, TileIndexDiff offset) { tile = tile - TileIndex(offset); return tile; }

#ifndef _DEBUG
  constexpr TileIndex TileAdd(TileIndex tile, TileIndexDiff offset) { return tile + offset; }
#else
  TileIndex TileAdd(TileIndex tile, TileIndexDiff offset);
#endif

inline TileIndex TileAddXY(TileIndex tile, int x, int y)
{
  return TileAdd(tile, TileDiffXY(x, y));
}
 
TileIndex TileAddWrap(TileIndex tile, int addx, int addy);

inline TileIndexDiffC TileIndexDiffCByDiagDir(DiagDirection dir)
{
  extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];
 
  assert(IsValidDiagDirection(dir));
  return _tileoffs_by_diagdir[dir];
}

inline TileIndexDiffC TileIndexDiffCByDir(Direction dir)
{
  extern const TileIndexDiffC _tileoffs_by_dir[DIR_END];
 
  assert(IsValidDirection(dir));
  return _tileoffs_by_dir[dir];
}

inline TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)
{
  int x = TileX(tile) + diff.x;
  int y = TileY(tile) + diff.y;
  /* Negative value will become big positive value after cast */
  if ((uint)x >= Map::SizeX() || (uint)y >= Map::SizeY()) return INVALID_TILE;
  return TileXY(x, y);
}

inline TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)
{
  TileIndexDiffC difference;
 
  difference.x = TileX(tile_a) - TileX(tile_b);
  difference.y = TileY(tile_a) - TileY(tile_b);
 
  return difference;
}
 
/* Functions to calculate distances */
uint DistanceManhattan(TileIndex, TileIndex); 
uint DistanceSquare(TileIndex, TileIndex); 
uint DistanceMax(TileIndex, TileIndex); 
uint DistanceMaxPlusManhattan(TileIndex, TileIndex); 
uint DistanceFromEdge(TileIndex); 
uint DistanceFromEdgeDir(TileIndex, DiagDirection); 

inline TileIndexDiff TileOffsByAxis(Axis axis)
{
  extern const TileIndexDiffC _tileoffs_by_axis[];
 
  assert(IsValidAxis(axis));
  return ToTileIndexDiff(_tileoffs_by_axis[axis]);
}

inline TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
{
  extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];
 
  assert(IsValidDiagDirection(dir));
  return ToTileIndexDiff(_tileoffs_by_diagdir[dir]);
}

inline TileIndexDiff TileOffsByDir(Direction dir)
{
  extern const TileIndexDiffC _tileoffs_by_dir[DIR_END];
 
  assert(IsValidDirection(dir));
  return ToTileIndexDiff(_tileoffs_by_dir[dir]);
}

inline TileIndex TileAddByDir(TileIndex tile, Direction dir)
{
  return TileAdd(tile, TileOffsByDir(dir));
}

inline TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
{
  return TileAdd(tile, TileOffsByDiagDir(dir));
}

inline DiagDirection DiagdirBetweenTiles(TileIndex tile_from, TileIndex tile_to)
{
  int dx = (int)TileX(tile_to) - (int)TileX(tile_from);
  int dy = (int)TileY(tile_to) - (int)TileY(tile_from);
  if (dx == 0) {
    if (dy == 0) return INVALID_DIAGDIR;
    return (dy < 0 ? DIAGDIR_NW : DIAGDIR_SE);
  } else {
    if (dy != 0) return INVALID_DIAGDIR;
    return (dx < 0 ? DIAGDIR_NE : DIAGDIR_SW);
  }
}

inline TileIndex RandomTileSeed(uint32_t r)
{
  return Map::WrapToMap(TileIndex{r});
}

#define RandomTile() RandomTileSeed(Random())
 
uint GetClosestWaterDistance(TileIndex tile, bool water);
 
#endif /* MAP_FUNC_H */