TileManager Class Reference

This class holds all the information about tileIDs gathered from TileData.json. More...

#include <TileManager.hxx>

Inheritance diagram for TileManager:

Collaboration diagram for TileManager:

Public Member Functions
	TileManager (TileManager const &)=delete
TileManager &	operator= (TileManager const &)=delete
SDL_Texture *	getTexture (const std::string &tileID) const
	Get the Texture for the tileID. More...
TileData *	getTileData (const std::string &id) noexcept
	Get the TileData struct for this tileID and all information associated with it. More...
Layer	getTileLayer (const std::string &tileID) const
	Get the Layer that is associated with a tileID. The Tile will be placed on this layer. More...
size_t	calculateSlopeOrientation (unsigned char bitMaskElevation)
	Calculates the slope orientation for elevated tiles to pick the correct slope Sprite. More...
TileOrientation	calculateTileOrientation (unsigned char bitMaskElevation)
	Calculates the TileOrientation for elevated tiles to pick the correct Sprite. More...
const std::unordered_map< std::string, TileData > &	getAllTileData () const
std::vector< std::string >	getAllTileIDsForZone (ZoneType zone, ZoneDensity zoneDensity, TileSize tileSize={1, 1})
	Get the All Tile IDs for a zone with a certain tileSize. More...
std::optional< std::string >	getRandomTileIDForZoneWithRandomSize (ZoneType zone, ZoneDensity zoneDensity, TileSize maxTileSize={1, 1})
	Pick a single random tileID for a zone with a random tilesize within the supplied max Size. More...
std::vector< Point >	getTargetCoordsOfTileID (const Point &targetCoordinates, const std::string &tileID)
	Return a vector of Points on a target node (origin corner) that would be occupied by a given tileID if the placement is valid. More...
bool	isTileIDAutoTile (const std::string &tileID)
	check if given TileID can autotile (meaning there are textures that look differently according to the position of tiles to each other). More...
void	init ()
	Parse the tileData JSON and set up the tileManager. More...

Public Attributes
friend	Singleton< TileManager >

Private Member Functions
	TileManager ()
	~TileManager ()=default
void	addJSONObjectToTileData (const nlohmann::json &tileDataJSON, size_t idx, const std::string &id)

Private Attributes
std::unordered_map< std::string, TileData >	m_tileData
std::unordered_set< TileSize >	m_tileSizeCombinations

Additional Inherited Members
Static Public Member Functions inherited from Singleton< TileManager >
static TileManager &	instance (void)
	Get an instance of the singleton. More...
Protected Member Functions inherited from Singleton< TileManager >
	Singleton () noexcept=default
	~Singleton () noexcept=default

Detailed Description

This class holds all the information about tileIDs gathered from TileData.json.

Definition at line 71 of file TileManager.hxx.

Constructor & Destructor Documentation

TileManager() [1/2]

TileManager::TileManager ( TileManager const &  )

delete

TileManager() [2/2]

TileManager::TileManager ( )

private

Definition at line 15 of file TileManager.cxx.

{ init(); }

Here is the call graph for this function:

~TileManager()

TileManager::~TileManager ( )

privatedefault

Member Function Documentation

addJSONObjectToTileData()

void TileManager::addJSONObjectToTileData ( const nlohmann::json &  tileDataJSON, size_t  idx, const std::string &  id  )

private

Definition at line 372 of file TileManager.cxx.

{
  m_tileData[id].author = tileDataJSON[idx].value("author", "");
  m_tileData[id].title = tileDataJSON[idx].value("title", "");
  m_tileData[id].description = tileDataJSON[idx].value("description", "");
  m_tileData[id].category = tileDataJSON[idx].value("category", "");
  m_tileData[id].subCategory = tileDataJSON[idx].value("subCategory", "");
  m_tileData[id].price = tileDataJSON[idx].value("price", 0);
  m_tileData[id].power = tileDataJSON[idx].value("power", 0);
  m_tileData[id].water = tileDataJSON[idx].value("water", 0);
  m_tileData[id].upkeepCost = tileDataJSON[idx].value("upkeepCost", 0);
  m_tileData[id].isOverPlacable = tileDataJSON[idx].value("isOverPlacable", false);
  m_tileData[id].placeOnWater = tileDataJSON[idx].value("placeOnWater", false);
  m_tileData[id].inhabitants = tileDataJSON[idx].value("inhabitants", 0);
  m_tileData[id].happiness = tileDataJSON[idx].value("happiness", 0);
  m_tileData[id].fireHazardLevel = tileDataJSON[idx].value("fireHazardLevel", 0);
  m_tileData[id].educationLevel = tileDataJSON[idx].value("educationLevel", 0);
  m_tileData[id].crimeLevel = tileDataJSON[idx].value("crimeLevel", 0);
  m_tileData[id].pollutionLevel = tileDataJSON[idx].value("pollutionLevel", 0);
 
  std::string tileTypeStr = tileDataJSON[idx].value("tileType", "default");
 
  if (TileType::_is_valid_nocase(tileTypeStr.c_str()))
  {
    m_tileData[id].tileType = TileType::_from_string_nocase(tileTypeStr.c_str());
  }
  else
  {
    throw ConfigurationError(TRACE_INFO "In TileData.json in field with ID " + id +
                             " the field tileType uses the unsupported value " + tileTypeStr);
  }
 
  if (tileDataJSON[idx].find("zoneDensity") != tileDataJSON[idx].end())
  {
    for (auto zoneDensity : tileDataJSON[idx].at("zoneDensity").items())
    {
      if (ZoneDensity::_is_valid_nocase(zoneDensity.value().get<std::string>().c_str()))
      {
        m_tileData[id].zoneDensity.push_back(ZoneDensity::_from_string_nocase(zoneDensity.value().get<std::string>().c_str()));
      }
      else
      {
        throw ConfigurationError(TRACE_INFO "In TileData.json in field with ID " + id +
                                 " the field zoneDensity uses the unsupported value " + zoneDensity.value().get<std::string>());
      }
    }
  }
 
  if (tileDataJSON[idx].find("zoneType") != tileDataJSON[idx].end())
  {
    for (auto zoneType : tileDataJSON[idx].at("zoneType").items())
    {
      if (ZoneType::_is_valid_nocase(zoneType.value().get<std::string>().c_str()))
      {
        m_tileData[id].zoneTypes.push_back(ZoneType::_from_string_nocase(zoneType.value().get<std::string>().c_str()));
      }
      else
      {
        throw ConfigurationError(TRACE_INFO "In TileData.json in field with ID " + id +
                                 " the field zone uses the unsupported value " + zoneType.value().get<std::string>());
      }
    }
  }
 
  if (tileDataJSON[idx].find("style") != tileDataJSON[idx].end())
  {
    for (auto style : tileDataJSON[idx].at("style").items())
    {
      if (Style::_is_valid_nocase(style.value().get<std::string>().c_str()))
      {
        m_tileData[id].style.push_back(Style::_from_string_nocase(style.value().get<std::string>().c_str()));
      }
      else
      {
        throw ConfigurationError(TRACE_INFO "In TileData.json in field with ID " + id +
                                 " the field style uses the unsupported value " + style.value().get<std::string>());
      }
    }
  }
 
  if (tileDataJSON[idx].find("biomes") != tileDataJSON[idx].end())
  {
    for (auto biome : tileDataJSON[idx].at("biomes").items())
    {
      m_tileData[id].biomes.push_back(biome.value().get<std::string>());
    }
  }
 
  if (tileDataJSON[idx].find("groundDecoration") != tileDataJSON[idx].end())
  {
    for (auto groundDecoration : tileDataJSON[idx].at("groundDecoration").items())
    {
      m_tileData[id].groundDecoration.push_back(groundDecoration.value().get<std::string>());
    }
  }
 
  if (tileDataJSON[idx].find("RequiredTiles") != tileDataJSON[idx].end())
  {
    m_tileData[id].RequiredTiles.width = tileDataJSON[idx]["RequiredTiles"].value("width", 1);
    m_tileData[id].RequiredTiles.height = tileDataJSON[idx]["RequiredTiles"].value("height", 1);
  }
  else
  {
    m_tileData[id].RequiredTiles.width = 1;
    m_tileData[id].RequiredTiles.height = 1;
  }
 
  m_tileSizeCombinations.insert(m_tileData[id].RequiredTiles);
 
  m_tileData[id].tiles.fileName = tileDataJSON[idx]["tiles"].value("fileName", "");
  m_tileData[id].tiles.clippingHeight = tileDataJSON[idx]["tiles"].value("clip_height", 0);
  m_tileData[id].tiles.clippingWidth = tileDataJSON[idx]["tiles"].value("clip_width", 0);
 
  // offset value can be negative in the json, for the tiledata editor, but never in Cytopia
  int offset = tileDataJSON[idx]["tiles"].value("offset", 0);
  if (offset < 0)
  {
    offset = 0;
  }
  m_tileData[id].tiles.offset = offset;
  m_tileData[id].tiles.count = tileDataJSON[idx]["tiles"].value("count", 1);
  m_tileData[id].tiles.pickRandomTile = tileDataJSON[idx]["tiles"].value("pickRandomTile", true);
 
  if (!m_tileData[id].tiles.fileName.empty())
  {
    ResourcesManager::instance().loadTexture(id, m_tileData[id].tiles.fileName);
  }
 
  if (tileDataJSON[idx].find("shoreLine") != tileDataJSON[idx].end())
  {
    m_tileData[id].shoreTiles.fileName = tileDataJSON[idx]["shoreLine"].value("fileName", "");
    m_tileData[id].shoreTiles.count = tileDataJSON[idx]["shoreLine"].value("count", 1);
    m_tileData[id].shoreTiles.clippingWidth = tileDataJSON[idx]["shoreLine"].value("clip_width", 0);
    m_tileData[id].shoreTiles.clippingHeight = tileDataJSON[idx]["shoreLine"].value("clip_height", 0);
 
    // offset value can be negative in the json, for the tiledata editor, but never in Cytopia
    int offset = tileDataJSON[idx]["shoreLine"].value("offset", 0);
    if (offset < 0)
    {
      offset = 0;
    }
    m_tileData[id].shoreTiles.offset = offset;
 
    if (!m_tileData[id].shoreTiles.fileName.empty())
    {
      ResourcesManager::instance().loadTexture(id + "_shore", m_tileData[id].shoreTiles.fileName);
    }
  }
 
  if (tileDataJSON[idx].find("slopeTiles") != tileDataJSON[idx].end())
  {
 
    m_tileData[id].slopeTiles.fileName = tileDataJSON[idx]["slopeTiles"].value("fileName", "");
    m_tileData[id].slopeTiles.count = tileDataJSON[idx]["slopeTiles"].value("count", 1);
    m_tileData[id].slopeTiles.clippingWidth = tileDataJSON[idx]["slopeTiles"].value("clip_width", 0);
    m_tileData[id].slopeTiles.clippingHeight = tileDataJSON[idx]["slopeTiles"].value("clip_height", 0);
 
    // offset value can be negative in the json, for the tiledata editor, but never in Cytopia
    int offset = tileDataJSON[idx]["slopeTiles"].value("offset", 0);
    if (offset < 0)
    {
      offset = 0;
    }
    m_tileData[id].slopeTiles.offset = offset;
 
    if (!m_tileData[id].slopeTiles.fileName.empty())
    {
      ResourcesManager::instance().loadTexture(id, m_tileData[id].slopeTiles.fileName);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

calculateSlopeOrientation()

size_t TileManager::calculateSlopeOrientation

(

unsigned char

bitMaskElevation

)

Calculates the slope orientation for elevated tiles to pick the correct slope Sprite.

Parameters

bitMaskElevation

a bitmask of neighboring tiles and their elevation

Returns

Elevation bitmask

Definition at line 147 of file TileManager.cxx.

{
  // initialize with DEFAULT_ORIENTATION which elevationMask.none()
  size_t orientation = TileSlopes::DEFAULT_ORIENTATION;
  const std::bitset<8> elevationMask(bitMaskElevation);
 
  // Bits:
  // 0 = 2^0 = 1   = TOP
  // 1 = 2^1 = 2   = BOTTOM
  // 2 = 2^2 = 4   = LEFT
  // 3 = 2^3 = 8   = RIGHT
  // 4 = 2^4 = 16  = TOP LEFT
  // 5 = 2^5 = 32  = TOP RIGHT
  // 6 = 2^6 = 64  = BOTTOM LEFT
  // 7 = 2^7 = 128 = BOTTOM RIGHT
 
  // check for all combinations
  if (elevationMask.test(3) && elevationMask.test(6))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::S_AND_E;
  }
  else if (elevationMask.test(2) && elevationMask.test(5))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::N_AND_W;
  }
  else if (elevationMask.test(3) && elevationMask.test(4))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::N_AND_E;
  }
  else if (elevationMask.test(2) && elevationMask.test(7))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::S_AND_W;
  }
 
  else if (elevationMask.test(0) && elevationMask.test(6))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::N_AND_W;
  }
  else if (elevationMask.test(1) && elevationMask.test(5))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::S_AND_E;
  }
  else if (elevationMask.test(0) && elevationMask.test(7))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::N_AND_E;
  }
  else if (elevationMask.test(1) && elevationMask.test(4))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::S_AND_W;
  }
 
  // diagonal combinations
  else if (elevationMask.test(0) && elevationMask.test(2))
  { // TOP && RIGHT
    orientation = TileSlopes::N_AND_W;
  }
  else if (elevationMask.test(0) && elevationMask.test(3))
  { // TOP && LEFT
    orientation = TileSlopes::N_AND_E;
  }
  else if (elevationMask.test(1) && elevationMask.test(2))
  { // BOTTOM && RIGHT
    orientation = TileSlopes::S_AND_W;
  }
  else if (elevationMask.test(1) && elevationMask.test(3))
  { // BOTTOM && LEFT
    orientation = TileSlopes::S_AND_E;
  }
 
  // default directions
  else if (elevationMask.test(0))
  { // TOP
    orientation = TileSlopes::N;
  }
  else if (elevationMask.test(1))
  { // BOTTOM
    orientation = TileSlopes::S;
  }
  else if (elevationMask.test(2))
  { // LEFT
    orientation = TileSlopes::W;
  }
  else if (elevationMask.test(3))
  { // RIGHT
    orientation = TileSlopes::E;
  }
  else if ((elevationMask.test(4) && elevationMask.test(7)) || (elevationMask.test(5) && elevationMask.test(6)))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::BETWEEN;
  }
  else if (elevationMask.test(4))
  { // TOP_LEFT
    orientation = TileSlopes::NW;
  }
  else if (elevationMask.test(5))
  { // TOP_RIGHT
    orientation = TileSlopes::NE;
  }
  else if (elevationMask.test(6))
  { // BOTTOM_LEFT
    orientation = TileSlopes::SW;
  }
  else if (elevationMask.test(7))
  { // BOTTOM_RIGHT
    orientation = TileSlopes::SE;
  }
 
  return orientation;
}

Here is the caller graph for this function:

calculateTileOrientation()

TileOrientation TileManager::calculateTileOrientation

(

unsigned char

bitMaskElevation

)

Calculates the TileOrientation for elevated tiles to pick the correct Sprite.

Parameters

bitMaskElevation

a bitmask of neighboring tiles and their elevation

Returns

The orientation the tile should have to it's elevated neighbors.

Definition at line 257 of file TileManager.cxx.

{
  TileOrientation orientation;
  const std::bitset<8> elevationMask(bitMaskElevation);
 
  // Bits:
  // 0 = 2^0 = 1   = TOP
  // 1 = 2^1 = 2   = BOTTOM
  // 2 = 2^2 = 4   = LEFT
  // 3 = 2^3 = 8   = RIGHT
  // 4 = 2^4 = 16  = TOP LEFT
  // 5 = 2^5 = 32  = TOP RIGHT
  // 6 = 2^6 = 64  = BOTTOM LEFT
  // 7 = 2^7 = 128 = BOTTOM RIGHT
 
  // check for all combinations
  if (elevationMask.none())
  { // NONE
    orientation = TileOrientation::TILE_DEFAULT_ORIENTATION;
  }
  // special cases
  else if (elevationMask.test(0) && elevationMask.test(1) && elevationMask.test(2) && elevationMask.test(3))
  { // BOTTOM_RIGHT
    orientation = TileOrientation::TILE_ALL_DIRECTIONS;
  }
  else if (elevationMask.test(0) && elevationMask.test(2) && elevationMask.test(3))
  { // BOTTOM_RIGHT
    orientation = TileOrientation::TILE_N_AND_E_AND_W;
  }
  else if (elevationMask.test(0) && elevationMask.test(1) && elevationMask.test(3))
  { // BOTTOM_RIGHT
    orientation = TileOrientation::TILE_N_AND_E_AND_S;
  }
  else if (elevationMask.test(0) && elevationMask.test(1) && elevationMask.test(2))
  { // BOTTOM_RIGHT
    orientation = TileOrientation::TILE_N_AND_S_AND_W;
  }
  else if (elevationMask.test(1) && elevationMask.test(2) && elevationMask.test(3))
  { // BOTTOM_RIGHT
    orientation = TileOrientation::TILE_S_AND_E_AND_W;
  }
  else if (elevationMask.test(2) && elevationMask.test(3))
  { // BOTTOM_RIGHT
    orientation = TileOrientation::TILE_E_AND_W;
  }
  else if (elevationMask.test(0) && elevationMask.test(1))
  { // BOTTOM_RIGHT
    orientation = TileOrientation::TILE_N_AND_S;
  }
 
  // diagonal combinations
  else if (elevationMask.test(0) && elevationMask.test(2))
  { // TOP && RIGHT
    orientation = TileOrientation::TILE_N_AND_W;
  }
  else if (elevationMask.test(0) && elevationMask.test(3))
  { // TOP && LEFT
    orientation = TileOrientation::TILE_N_AND_E;
  }
  else if (elevationMask.test(1) && elevationMask.test(2))
  { // BOTTOM && RIGHT
    orientation = TileOrientation::TILE_S_AND_W;
  }
  else if (elevationMask.test(1) && elevationMask.test(3))
  { // BOTTOM && LEFT
    orientation = TileOrientation::TILE_S_AND_E;
  }
 
  // default directions
  else if (elevationMask.test(0))
  { // TOP
    orientation = TileOrientation::TILE_N;
  }
  else if (elevationMask.test(1))
  { // BOTTOM
    orientation = TileOrientation::TILE_S;
  }
  else if (elevationMask.test(2))
  { // LEFT
    orientation = TileOrientation::TILE_W;
  }
  else if (elevationMask.test(3))
  { // RIGHT
    orientation = TileOrientation::TILE_E;
  }
 
  else
  {
    orientation = TILE_DEFAULT_ORIENTATION;
  }
  return orientation;
}

Here is the caller graph for this function:

getAllTileData()

const std::unordered_map<std::string, TileData>& TileManager::getAllTileData ( ) const

inline

Definition at line 110 of file TileManager.hxx.

{ return m_tileData; };

getAllTileIDsForZone()

std::vector< std::string > TileManager::getAllTileIDsForZone	(	ZoneType	zone,
		ZoneDensity	zoneDensity,
		TileSize	tileSize = {1, 1}
	)

Get the All Tile IDs for a zone with a certain tileSize.

Parameters

zone	The Zone we want tileIDs for
zoneDensity
tileSize	Get buildings with a certain tile size

Returns

All tileIDs that match the zone and tileSize

Definition at line 29 of file TileManager.cxx.

{
  std::vector<std::string> results;
  for (auto &tileData : m_tileData)
  {
    if (std::find(tileData.second.zoneTypes.begin(), tileData.second.zoneTypes.end(), +zone) != tileData.second.zoneTypes.end() &&
        (zone == +ZoneType::AGRICULTURAL || std::find(tileData.second.zoneDensity.begin(), tileData.second.zoneDensity.end(),
                                                      +zoneDensity) != tileData.second.zoneDensity.end()) &&
        tileData.second.RequiredTiles.height == tileSize.height && tileData.second.RequiredTiles.width == tileSize.width &&
        tileData.second.tileType != +TileType::ZONE)
    {
      results.push_back(tileData.first);
    }
  }
  return results;
}

Here is the caller graph for this function:

getRandomTileIDForZoneWithRandomSize()

std::optional< std::string > TileManager::getRandomTileIDForZoneWithRandomSize	(	ZoneType	zone,
		ZoneDensity	zoneDensity,
		TileSize	maxTileSize = {1, 1}
	)

Pick a single random tileID for a zone with a random tilesize within the supplied max Size.

Parameters

zone	The Zone we want tileIDs for
zoneDensity
maxTileSize	maximum tileSize we want

Returns

A random tileID matching the supplied parameters

Definition at line 72 of file TileManager.cxx.

{
  std::vector<TileSize> elligibleTileSizes;
 
  // filter out the tilesizes that are below the maximum from all available tilesizes
  for (auto tileSize : m_tileSizeCombinations)
  {
    // for now only pick square buildings. non square buildings don't work yet.
    if (tileSize.height <= maxTileSize.height && tileSize.width <= maxTileSize.width && tileSize.height == tileSize.width)
    {
      elligibleTileSizes.push_back(tileSize);
    }
  }
 
  // pick a random tilesize from the new set of elligible tilesizes
  auto &randomizer = Randomizer::instance();
  TileSize randomTileSize = *randomizer.choose(elligibleTileSizes.begin(), elligibleTileSizes.end());
 
  // get all tile IDs for the according zone and tilesize
  const auto &tileIDsForThisZone = getAllTileIDsForZone(zone, zoneDensity, randomTileSize);
 
  if (tileIDsForThisZone.empty())
  {
    return std::nullopt;
  }
 
  // return a random tileID
  return *randomizer.choose(tileIDsForThisZone.begin(), tileIDsForThisZone.end());
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTargetCoordsOfTileID()

std::vector< Point > TileManager::getTargetCoordsOfTileID	(	const Point &	targetCoordinates,
		const std::string &	tileID
	)

Return a vector of Points on a target node (origin corner) that would be occupied by a given tileID if the placement is valid.

Parameters

targetCoordinates	the origin node where the tile should be placed
tileID	the tileID to place

Returns

vector of points that will be occupied by this tileID, empty if placement is not allowed

Definition at line 46 of file TileManager.cxx.

{
  std::vector<Point> occupiedCoords;
  TileData *tileData = getTileData(tileID);
 
  if (!tileData)
  {
    return occupiedCoords;
  }
 
  for (int i = 0; i < tileData->RequiredTiles.width; i++)
  {
    for (int j = 0; j < tileData->RequiredTiles.height; j++)
    {
      Point coords = {targetCoordinates.x - i, targetCoordinates.y + j};
      if (!coords.isWithinMapBoundaries())
      { // boundary check
        occupiedCoords.clear();
        return occupiedCoords;
      }
      occupiedCoords.emplace_back(coords);
    }
  }
  return occupiedCoords;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTexture()

SDL_Texture * TileManager::getTexture

(

const std::string &

tileID

)

const

Get the Texture for the tileID.

Parameters

tileID

TileID

Returns

An SDL Texture we can render

Definition at line 17 of file TileManager.cxx.

{
  return ResourcesManager::instance().getTileTexture(tileID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTileData()

TileData * TileManager::getTileData ( const std::string &  id )

noexcept

Get the TileData struct for this tileID and all information associated with it.

Parameters

id

TileID

Returns

A pointer to the TileData Struct

Definition at line 22 of file TileManager.cxx.

{
  if (m_tileData.count(id))
    return &m_tileData[id];
  return nullptr;
}

Here is the caller graph for this function:

getTileLayer()

Layer TileManager::getTileLayer

(

const std::string &

tileID

)

const

Get the Layer that is associated with a tileID. The Tile will be placed on this layer.

Parameters

tileID

the tileID to get the Layer for

Returns

The layer this tileID has to be placed on

Definition at line 104 of file TileManager.cxx.

{
  Layer layer = Layer::TERRAIN;
  TileData *tileData = TileManager::instance().getTileData(tileID);
  if (tileData)
  {
    switch (tileData->tileType)
    {
    case TileType::TERRAIN:
      layer = Layer::TERRAIN;
      break;
    case TileType::BLUEPRINT:
      layer = Layer::BLUEPRINT;
      break;
    case TileType::WATER:
      layer = Layer::WATER;
      break;
    case TileType::UNDERGROUND:
      layer = Layer::UNDERGROUND;
      break;
    case TileType::GROUNDDECORATION:
      layer = Layer::GROUND_DECORATION;
      break;
    case TileType::ZONE:
      layer = Layer::ZONE;
      break;
    case TileType::ROAD:
      layer = Layer::ROAD;
      break;
    case TileType::POWERLINE:
      layer = Layer::POWERLINES;
      break;
    case TileType::FLORA:
      layer = Layer::FLORA;
      break;
    default:
      layer = Layer::BUILDINGS;
      break;
    }
  }
  return layer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void TileManager::init

(

)

Parse the tileData JSON and set up the tileManager.

Exceptions

ConfigurationError

when loading tile data file results in an error

Definition at line 350 of file TileManager.cxx.

{
  std::string jsonFile = fs::readFileAsString(Settings::instance().tileDataJSONFile.get());
  const json tileDataJSON = json::parse(jsonFile, nullptr, false);
 
  // check if json file can be parsed
  if (tileDataJSON.is_discarded())
    throw ConfigurationError(TRACE_INFO "Error parsing JSON File " + Settings::instance().tileDataJSONFile.get());
 
  std::string key;
 
  size_t idx = 0;
 
  for (const auto &element : tileDataJSON.items())
  {
    std::string id;
    id = element.value().value("id", "");
    addJSONObjectToTileData(tileDataJSON, idx, id);
    idx++;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

isTileIDAutoTile()

bool TileManager::isTileIDAutoTile

(

const std::string &

tileID

)

check if given TileID can autotile (meaning there are textures that look differently according to the position of tiles to each other).

Parameters

tileID

Returns

bool whether Tile Data item can be autotiled.

Definition at line 544 of file TileManager.cxx.

{
  TileData *tileData = getTileData(tileID);
  if (tileData)
    switch (tileData->tileType)
    {
    case +TileType::ROAD:
    case +TileType::AUTOTILE:
    case +TileType::UNDERGROUND:
    case +TileType::POWERLINE:
      return true;
    default:
      return false;
    }
 
  return false;
}

Here is the call graph for this function:

operator=()

TileManager& TileManager::operator= ( TileManager const &  )

delete

Member Data Documentation

m_tileData

std::unordered_map<std::string, TileData> TileManager::m_tileData

private

Definition at line 153 of file TileManager.hxx.

m_tileSizeCombinations

std::unordered_set<TileSize> TileManager::m_tileSizeCombinations

private

Definition at line 154 of file TileManager.hxx.

Singleton< TileManager >

friend TileManager::Singleton< TileManager >

Definition at line 74 of file TileManager.hxx.

---

The documentation for this class was generated from the following files:

• src/engine/TileManager.hxx
• src/engine/TileManager.cxx