MapFunctions Class Reference

#include <MapFunctions.hxx>

Inheritance diagram for MapFunctions:

Collaboration diagram for MapFunctions:

Public Member Functions
	MapFunctions ()
Map *	getMap ()
void	changeHeight (const Point &isoCoordinates, const bool elevate)
	Change map node height. More...
bool	updateHeight (Point coordinate, const bool elevate)
	Change map node height. More...
void	levelHeight (const Point &startCoordinate, const std::vector< Point > levelArea)
	level area of map nodes. More...
MapNode &	getMapNode (Point isoCoords)
	Get pointer to a single mapNode at specific iso coordinates. More...
const std::vector< MapNode > &	getMapNodes ()
	Get all mapnodes as a vector. More...
std::vector< NeighborNode >	getNeighborNodes (const Point &isoCoordinates, const bool includeCentralNode)
	Get all neighbor nodes from provided map node. More...
unsigned char	getElevatedNeighborBitmask (Point centerCoordinates)
	Get elevated bit mask of the map node. More...
bool	isPlacementOnNodeAllowed (const Point &isoCoordinates, const std::string &tileID) const
	check if Tile is occupied More...
bool	isPlacementOnAreaAllowed (const std::vector< Point > &targetCoordinates, const std::string &tileID) const
	check if Tile can be placed in an area More...
bool	setTileID (const std::string &tileID, Point coordinate)
	Set the Tile ID Of Node object. More...
bool	setTileID (const std::string &tileID, const std::vector< Point > &coordinates)
	Set the Tile ID Of multiple Node objects. More...
void	demolishNode (const std::vector< Point > &isoCoordinates, bool updateNeighboringTiles=false, Layer layer=Layer::NONE)
	Demolish a node. More...
Point	getNodeOrigCornerPoint (const Point &isoCoordinates, Layer layer=Layer::NONE)
	Get original corner point of given point within building borders. More...
void	getNodeInformation (const Point &isoCoordinates) const
	Debug MapNodeData to Console. More...
void	highlightNode (const Point &isoCoordinates, const SpriteRGBColor &rgbColor)
	Sets a node to be highlighted. More...
void	unHighlightNode (const Point &isoCoordinates)
	Sets a node to be unhighlighred. More...
Point	findNodeInMap (const SDL_Point &screenCoordinates, const Layer &layer=Layer::NONE)
	Returns the node at given screen coordinates. More...
std::string	getTileID (const Point &isoCoordinates, Layer layer)
	get Tile ID of specific layer of specific iso coordinates More...
void	refreshVisibleMap ()
	Refresh the visible part of the map. More...
void	newMap (bool generateTerrain=true)
	Creates a new map object with terrain gen. More...
void	loadMapFromFile (const std::string &fileName)
	Load Map from file. More...

Private Member Functions
void	updateNodeNeighbors (const std::vector< Point > &nodes)
	Update the nodes and all affected node with the change. More...
void	updateAllNodes ()
	Update all mapNodes. More...
bool	isClickWithinTile (const SDL_Point &screenCoordinates, Point isoCoordinate, const Layer &layer) const
	Check if a click is within a non transparent part of a sprite. More...
void	saveMapToFile (const std::string &fileName)
	Save Map to file. More...
std::vector< uint8_t >	calculateAutotileBitmask (Point coordinate)
	Get a bitmask that represents same-tile neighbors. More...

Private Attributes
Map *	m_map

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

Detailed Description

Definition at line 12 of file MapFunctions.hxx.

Constructor & Destructor Documentation

MapFunctions()

MapFunctions::MapFunctions

(

)

Definition at line 16 of file MapFunctions.cxx.

{ SignalMediator::instance().registerCbSaveGame(Signal::slot(this, &MapFunctions::saveMapToFile)); }

Here is the call graph for this function:

Member Function Documentation

calculateAutotileBitmask()

std::vector< uint8_t > MapFunctions::calculateAutotileBitmask ( Point  coordinate )

private

Get a bitmask that represents same-tile neighbors.

Checks all neighboring tiles and returns the elevated neighbors in a bitmask: [ BR BL TR TL R L B T ] [ 0 0 0 0 0 0 0 0 ]

Parameters

coordinate

Point on the map to calculate bitmask for.

Returns

Uint that represents a bitmask of the neighbor tiles and their elevation to the center coordinate

Definition at line 336 of file MapFunctions.cxx.

{
  std::vector<uint8_t> tileOrientationBitmask(LAYERS_COUNT, 0);
 
  for (auto currentLayer : allLayersOrdered)
  {
    auto pCurrentTileData = getMapNode(coordinate).getMapNodeDataForLayer(currentLayer).tileData;
 
    if (pCurrentTileData)
    {
      if (pCurrentTileData->tileType == +TileType::TERRAIN)
      {
        for (const auto &neighbor : getNeighborNodes(coordinate, false))
        {
          const auto pTileData = neighbor.pNode->getMapNodeDataForLayer(Layer::WATER).tileData;
 
          if (pTileData && pTileData->tileType == +TileType::WATER)
          {
            tileOrientationBitmask[currentLayer] |= neighbor.position;
          }
        }
      }
 
      // only auto-tile categories that can be tiled.
      const std::string &nodeTileId = getMapNode(coordinate).getMapNodeDataForLayer(currentLayer).tileID;
      if (TileManager::instance().isTileIDAutoTile(nodeTileId))
      {
        for (const auto &neighbor : getNeighborNodes(coordinate, false))
        {
          const MapNodeData &nodeData = neighbor.pNode->getMapNodeDataForLayer(currentLayer);
 
          if (nodeData.tileData && ((nodeData.tileID == nodeTileId) || (pCurrentTileData->tileType == +TileType::ROAD)))
          {
            tileOrientationBitmask[currentLayer] |= neighbor.position;
          }
        }
      }
    }
  }
  return tileOrientationBitmask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

changeHeight()

void MapFunctions::changeHeight	(	const Point &	isoCoordinates,
		const bool	elevate
	)

Change map node height.

Parameters

isoCoordinates	the Point on the map node to change height.
elevate	if set to true make node higher, otherwise lower.

Definition at line 36 of file MapFunctions.cxx.

{
  std::vector<Point> nodesToUpdate{isoCoordinates};
  std::vector<Point> neighorCoordinates = PointFunctions::getNeighbors(isoCoordinates, true);
 
  if (updateHeight(isoCoordinates, elevate))
  {
    // If lowering node height, than all nodes around should be lowered to be on same height with the central one.
    if (!elevate)
    {
      const int centerHeight = getMapNode(isoCoordinates).getCoordinates().height;
 
      for (const Point &neighborCoord : neighorCoordinates)
      {
        MapNode &neighborNode = getMapNode(neighborCoord);
        if (centerHeight < neighborNode.getCoordinates().height)
        {
          neighborNode.changeHeight(false);
          nodesToUpdate.push_back(neighborNode.getCoordinates());
        }
      }
    }
    demolishNode(neighorCoordinates);
    updateNodeNeighbors(nodesToUpdate);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

demolishNode()

void MapFunctions::demolishNode	(	const std::vector< Point > &	isoCoordinates,
		bool	updateNeighboringTiles = false,
		Layer	layer = Layer::NONE
	)

Demolish a node.

This function gathers all tiles that should be demolished and invokes the node's demolish function. When a building bigger than 1x1 is selected, all its coordinates are added to the demolishing points.

Parameters

isoCoordinates	all coordinates that should be demolished
updateNeighboringTiles	whether the adjacent tiles should be updated. (only relevant for autotiling)
layer	restrict demolish to a single layer

See also

MapNode::demolishNode

Definition at line 465 of file MapFunctions.cxx.

{
  std::vector<Point> nodesToDemolish;
 
  for (Point currentCoordinate : isoCoordinates)
  {
    if (currentCoordinate.isWithinMapBoundaries())
    {
      const MapNode &node = getMapNode(currentCoordinate);
 
      // Check for multi-node buildings first. Those are on the buildings layer, even if we want to demolish another layer than Buildings.
      // In case we add more Layers that support Multi-node, add a for loop here
      // If demolishNode is called for layer GROUNDECORATION, we'll still need to gather all nodes from the multi-node building to delete the decoration under the entire building
      auto pNodeTileData = node.getMapNodeDataForLayer(Layer::BUILDINGS).tileData;
 
      if (pNodeTileData && ((pNodeTileData->RequiredTiles.height > 1) || (pNodeTileData->RequiredTiles.width > 1)))
      {
        const Point origCornerPoint = node.getOrigCornerPoint(Layer::BUILDINGS);
 
        if (origCornerPoint.isWithinMapBoundaries())
        {
          const std::string &tileID = getMapNode(origCornerPoint).getTileID(Layer::BUILDINGS);
 
          // get all the occupied nodes and demolish them
          for (auto buildingCoords : TileManager::instance().getTargetCoordsOfTileID(origCornerPoint, tileID))
          {
            nodesToDemolish.push_back(buildingCoords);
          }
        }
      }
      // add the current coorindate
      nodesToDemolish.push_back(currentCoordinate);
    }
  }
 
  std::vector<Point> updateNodes;
  for (auto nodeCoordinate : nodesToDemolish)
  {
    getMapNode(nodeCoordinate).demolishNode(layer);
    SignalMediator::instance().signalDemolish.emit(&getMapNode(nodeCoordinate));
    // TODO: Play sound effect here
    if (updateNeighboringTiles)
    {
      updateNodes.push_back(nodeCoordinate);
    }
  }
 
  if (!updateNodes.empty())
  {
    updateNodeNeighbors(updateNodes);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

findNodeInMap()

Point MapFunctions::findNodeInMap	(	const SDL_Point &	screenCoordinates,
		const Layer &	layer = Layer::NONE
	)

Returns the node at given screen coordinates.

Parameters

screenCoordinates

Returns

Point

Definition at line 558 of file MapFunctions.cxx.

{
  // calculate clicked column (x coordinate) without height taken into account.
  const Point calculatedIsoCoords = calculateIsoCoordinates(screenCoordinates);
  int isoX = calculatedIsoCoords.x;
  int isoY = calculatedIsoCoords.y;
 
  // adjust calculated values that are outside of the map (which is legit, but they need to get pushed down)
  // only y can be out of bounds on our map
  if (isoY >= Settings::instance().mapSize)
  {
    int diff = isoY - Settings::instance().mapSize; // the diff to reset the value to the edge of the map
    // travel the column downwards.
    isoX += diff;
    isoY -= diff;
  }
 
  // Transverse a column form from calculated coordinates to the bottom of the map.
  // It is necessary to include 2 neighbor nodes from both sides.
  // Try to find map node in Z order.
  // Node with the highest Z order has highest X and lowest Y coordinate, so search will be conducted in that order.
  const int neighborReach = 2;
  const int mapSize = Settings::instance().mapSize;
 
  // Max X will reach end of the map or Y will reach 0.
  const int xMax = std::min(isoX + neighborReach + isoY, mapSize - 1);
  // Min X will reach 0 or x -2 neighbor node.
  const int xMin = std::max(isoX - neighborReach, 0);
 
  for (int x = xMax; x >= xMin; --x)
  {
    const int diff = x - isoX;
    const int yMiddlePoint = isoY - diff;
 
    // Move y up and down 2 neighbors.
    for (int y = std::max(yMiddlePoint - neighborReach, 0); (y <= yMiddlePoint + neighborReach) && (y < mapSize); ++y)
    {
      //get all coordinates for node at x,y
      Point coordinate = getMapNode(Point(x, y)).getCoordinates();
 
      if (isClickWithinTile(screenCoordinates, coordinate, layer))
      {
        return coordinate;
      }
    }
  }
 
  return Point{-1, -1, 0, 0};
}

Here is the call graph for this function:

Here is the caller graph for this function:

getElevatedNeighborBitmask()

unsigned char MapFunctions::getElevatedNeighborBitmask

(

Point

centerCoordinates

)

Get elevated bit mask of the map node.

Parameters

centerCoordinates

Point on the map node to calculate elevated bit mask.

Returns

Map node elevated bit mask.

Definition at line 310 of file MapFunctions.cxx.

{
  unsigned char bitmask = 0;
  const auto centralNodeHeight = getMapNode(centerCoordinates).getCoordinates().height;
 
  for (const auto &neighborCoordinates : PointFunctions::getNeighbors(centerCoordinates, false))
  {
    if (getMapNode(neighborCoordinates).getCoordinates().height > centralNodeHeight)
    {
      bitmask |= PointFunctions::getNeighborPositionToOrigin(neighborCoordinates, centerCoordinates);
    }
  }
 
  return bitmask;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getMap()

Map* MapFunctions::getMap ( )

inline

Definition at line 16 of file MapFunctions.hxx.

{ return m_map; };

Here is the caller graph for this function:

getMapNode()

MapNode& MapFunctions::getMapNode ( Point  isoCoords )

inline

Get pointer to a single mapNode at specific iso coordinates.

Parameters

isoCoords

The node to retrieve.

Definition at line 40 of file MapFunctions.hxx.

  {
    uint32_t index = isoCoords.toIndex();
    return m_map->mapNodes[index < m_map->mapNodes.size() ? index : 0];
  };

Here is the call graph for this function:

Here is the caller graph for this function:

getMapNodes()

const std::vector<MapNode>& MapFunctions::getMapNodes ( )

inline

Get all mapnodes as a vector.

Definition at line 48 of file MapFunctions.hxx.

{ return m_map->mapNodes; };

getNeighborNodes()

std::vector< NeighborNode > MapFunctions::getNeighborNodes	(	const Point &	isoCoordinates,
		const bool	includeCentralNode
	)

Get all neighbor nodes from provided map node.

Parameters

isoCoordinates	iso coordinates.
includeCentralNode	if set to true include the central node in the result.

Returns

All neighbor nodes.

Definition at line 253 of file MapFunctions.cxx.

{
  std::vector<NeighborNode> neighbors;
 
  for (auto it : PointFunctions::getNeighbors(isoCoordinates, includeCentralNode))
  {
    neighbors.push_back({&getMapNode(it), PointFunctions::getNeighborPositionToOrigin(it, isoCoordinates)});
  }
 
  return neighbors;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getNodeInformation()

void MapFunctions::getNodeInformation

(

const Point &

isoCoordinates

)

const

Debug MapNodeData to Console.

Used as Tile-Inspector until we implement a GUI variant

Parameters

isoCoordinates

Tile to inspect

Definition at line 518 of file MapFunctions.cxx.

{
  const MapNode &mapNode = m_map->mapNodes[isoCoordinates.toIndex()];
  const MapNodeData &mapNodeData = mapNode.getActiveMapNodeData();
  const TileData *tileData = mapNodeData.tileData;
  LOG(LOG_INFO) << "===== TILE at " << isoCoordinates.x << ", " << isoCoordinates.y << ", " << mapNode.getCoordinates().height
                << "=====";
  LOG(LOG_INFO) << "[Layer: TERRAIN] ID: " << mapNode.getMapNodeDataForLayer(Layer::TERRAIN).tileID;
  LOG(LOG_INFO) << "[Layer: WATER] ID: " << mapNode.getMapNodeDataForLayer(Layer::WATER).tileID;
  LOG(LOG_INFO) << "[Layer: BUILDINGS] ID: " << mapNode.getMapNodeDataForLayer(Layer::BUILDINGS).tileID;
  LOG(LOG_INFO) << "Category: " << tileData->category;
  LOG(LOG_INFO) << "FileName: " << tileData->tiles.fileName;
  LOG(LOG_INFO) << "PickRandomTile: " << tileData->tiles.pickRandomTile;
  LOG(LOG_INFO) << "TileMap: " << mapNodeData.tileMap;
  LOG(LOG_INFO) << "TileIndex: " << mapNodeData.tileIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getNodeOrigCornerPoint()

Point MapFunctions::getNodeOrigCornerPoint	(	const Point &	isoCoordinates,
		Layer	layer = Layer::NONE
	)

Get original corner point of given point within building borders.

Parameters

isoCoordinates	Point to get corner point of
layer

Returns

original corner point

Definition at line 326 of file MapFunctions.cxx.

{
  if ((layer != Layer::NONE) && isoCoordinates.isWithinMapBoundaries())
  {
    return getMapNode(isoCoordinates).getOrigCornerPoint(layer);
  }
 
  return Point::INVALID();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTileID()

std::string MapFunctions::getTileID	(	const Point &	isoCoordinates,
		Layer	layer
	)

get Tile ID of specific layer of specific iso coordinates

Parameters

isoCoordinates	Tile to inspect
layer	layer to check.

Definition at line 545 of file MapFunctions.cxx.

{
  return (isoCoordinates.isWithinMapBoundaries()) ? getMapNode(isoCoordinates).getTileID(layer) : "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

highlightNode()

void MapFunctions::highlightNode	(	const Point &	isoCoordinates,
		const SpriteRGBColor &	rgbColor
	)

Sets a node to be highlighted.

This sets a node to be highlighted. The highlighting is done during rendering

Parameters

isoCoordinates	which node should be highlit.
rgbColor	The SpriteRGBColor that should be used for highlighting

Definition at line 535 of file MapFunctions.cxx.

{
  if (isoCoordinates.isWithinMapBoundaries())
  {
    const auto pSprite = getMapNode(isoCoordinates).getSprite();
    pSprite->highlightColor = rgbColor;
    pSprite->highlightSprite = true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

isClickWithinTile()

bool MapFunctions::isClickWithinTile ( const SDL_Point &  screenCoordinates, Point  isoCoordinate, const Layer &  layer = Layer::NONE  ) const

private

Check if a click is within a non transparent part of a sprite.

Parameters

screenCoordinates	click coordinates on the scrren
isoCoordinate	isocoordinates of the mapnode to check
layer	layer to check

Returns

if a click is within this node

Definition at line 608 of file MapFunctions.cxx.

{
  if (!isoCoordinate.isWithinMapBoundaries())
  {
    return false;
  }
 
  const auto &node = m_map->mapNodes[isoCoordinate.toIndex()];
  auto pSprite = node.getSprite();
  std::vector<Layer> layersToGoOver;
 
  // Layers ordered for hitcheck
  if (layer == Layer::NONE)
  {
    std::vector<Layer> layersOrdered = {Layer::TERRAIN, Layer::WATER, Layer::UNDERGROUND, Layer::BLUEPRINT};
    layersToGoOver.insert(layersToGoOver.begin(), layersOrdered.begin(), layersOrdered.end());
  }
  else
  {
    layersToGoOver.push_back(layer);
  }
 
  for (const auto &curLayer : layersToGoOver)
  {
    if (!MapLayers::isLayerActive(curLayer))
    {
      continue;
    }
 
    SDL_Rect spriteRect = pSprite->getDestRect(curLayer);
    SDL_Rect clipRect = pSprite->getClipRect(curLayer);
 
    if (curLayer == Layer::TERRAIN)
    {
      clipRect.h += 1; //HACK: We need to increase clipRect height by one pixel to match the drawRect. Rounding issue?
    }
 
    if (SDL_PointInRect(&screenCoordinates, &spriteRect))
    {
      std::string tileID = node.getMapNodeDataForLayer(curLayer).tileID;
      assert(!tileID.empty());
 
      // Calculate the position of the clicked pixel within the surface and "un-zoom" the position to match the un-adjusted surface
      const int pixelX = static_cast<int>((screenCoordinates.x - spriteRect.x) / Camera::instance().zoomLevel()) + clipRect.x;
      const int pixelY = static_cast<int>((screenCoordinates.y - spriteRect.y) / Camera::instance().zoomLevel()) + clipRect.y;
 
      if ((curLayer == Layer::TERRAIN) && (node.getMapNodeDataForLayer(Layer::TERRAIN).tileMap == TileMap::SHORE))
      {
        tileID.append("_shore");
      }
 
      // Check if the clicked Sprite is not transparent (we hit a point within the pixel)
      if (ResourcesManager::instance().getColorOfPixelInSurface(tileID, pixelX, pixelY).a != SDL_ALPHA_TRANSPARENT)
      {
        return true;
      }
    }
  }
 
  // Nothing found
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isPlacementOnAreaAllowed()

bool MapFunctions::isPlacementOnAreaAllowed	(	const std::vector< Point > &	targetCoordinates,
		const std::string &	tileID
	)		const

check if Tile can be placed in an area

Parameters

targetCoordinates	Tile array to inspect
tileID	tileID which should be checked

Definition at line 270 of file MapFunctions.cxx.

{
  // This function can be divided into two policies:
  // Whether we need all nodes in the area to be placed or not
  bool shouldAllNodesPlaced = true;
  bool areaPlacementAllowed = true;
  bool tilePlacementAllowed = true;
 
  const Layer layer = TileManager::instance().getTileLayer(tileID);
  // Only buildings and roads has to be placed on all of the tile selected.
  // Other layers can be placed on part of tile in the area, such as zone, water, flora.
  if (layer == BUILDINGS)
  {
    shouldAllNodesPlaced = true;
  }
  else
  {
    shouldAllNodesPlaced = false;
  }
  areaPlacementAllowed = shouldAllNodesPlaced;
 
  for (auto coord : targetCoordinates)
  {
    tilePlacementAllowed = isPlacementOnNodeAllowed(coord, tileID);
 
    if (tilePlacementAllowed && !shouldAllNodesPlaced)
    {
      areaPlacementAllowed = true;
      break;
    }
    if (!tilePlacementAllowed && shouldAllNodesPlaced)
    {
      areaPlacementAllowed = false;
      break;
    }
  }
 
  return areaPlacementAllowed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isPlacementOnNodeAllowed()

bool MapFunctions::isPlacementOnNodeAllowed	(	const Point &	isoCoordinates,
		const std::string &	tileID
	)		const

check if Tile is occupied

Parameters

isoCoordinates	Tile to inspect
tileID	tileID which should be checked

Definition at line 265 of file MapFunctions.cxx.

{
  return m_map->mapNodes[isoCoordinates.toIndex()].isPlacementAllowed(tileID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

levelHeight()

void MapFunctions::levelHeight	(	const Point &	startCoordinate,
		const std::vector< Point >	levelArea
	)

level area of map nodes.

Parameters

startcoordinate	the starting point whose height is used for levelling
levelArea	the area that is to be leveled.

Definition at line 63 of file MapFunctions.cxx.

{
  const MapNode &startNode = getMapNode(startCoordinate);
  int initialHeight = startCoordinate.height;
 
  /* If the initial node is sloped, check if a majority of it's neighbors,
    * not counting other sloped nodes are elevated.
    * If so, the initial node should be regarded as elevated too,
    * i.e. the height should be incremented.
    * This seems to yield the most intuitive behavior on slopes.
    */
  if (startNode.isSlopeNode())
  {
    char directNeighbors =
        NeighborNodesPosition::LEFT | NeighborNodesPosition::TOP | NeighborNodesPosition::RIGHT | NeighborNodesPosition::BOTTOM;
    char elBitmask = startNode.getElevationBitmask();
 
    int nonSelectedNeighborsCount = 0;
    int elevatedNonSelectedNeighborsCount = 0;
 
    for (Point neighbor : PointFunctions::getNeighbors(startCoordinate, false))
    {
      const NeighborNodesPosition neighborPosToOrigin = PointFunctions::getNeighborPositionToOrigin(neighbor, startCoordinate);
      const bool isSloped = getMapNode(neighbor).isSlopeNode();
 
      // Only look at non-sloped direct neighbors not in the selection.
      if (!isSloped && (neighborPosToOrigin & directNeighbors) > 0 &&
          std::find(levelArea.begin(), levelArea.end(), neighbor) == levelArea.end())
      {
        nonSelectedNeighborsCount++;
 
        if ((neighborPosToOrigin & elBitmask) > 0)
          elevatedNonSelectedNeighborsCount++;
      }
    }
 
    if (elevatedNonSelectedNeighborsCount * 2 > nonSelectedNeighborsCount)
      // No need to check max height since there are elevated neighbors.
      initialHeight++;
  }
 
  std::vector<Point> neighborsToLower;
 
  for (const Point &levelPoint : levelArea)
  {
    // If a node gets lowered, save all it's neighbors to be lowered aswell.
    // We have to get the node first, since the coordinates in the area are generated with height=0
    if (getMapNode(levelPoint).getCoordinates().height > initialHeight)
    {
      // This possibly stores nodes that have already been processed for another round.
      // It's faster than checking if each node is in levelArea first though.
      std::vector<Point> neighbors = PointFunctions::getNeighbors(levelPoint, false);
      neighborsToLower.insert(neighborsToLower.end(), neighbors.begin(), neighbors.end());
    }
 
    Point newCoordinates = Point(levelPoint.x, levelPoint.y, levelPoint.z, initialHeight);
    MapNode &levelNode = getMapNode(levelPoint);
    levelNode.setCoordinates(newCoordinates);
  }
 
  for (const Point &levelPoint : neighborsToLower)
  {
    Point newCoordinates = Point(levelPoint.x, levelPoint.y, levelPoint.z, initialHeight);
    MapNode &levelNode = getMapNode(levelPoint);
    levelNode.setCoordinates(newCoordinates);
  }
 
  updateNodeNeighbors(levelArea);
  updateNodeNeighbors(neighborsToLower);
}

Here is the call graph for this function:

Here is the caller graph for this function:

loadMapFromFile()

void MapFunctions::loadMapFromFile

(

const std::string &

fileName

)

Load Map from file.

Deserializes the Map class from a json file, creates a new Map and updates m_map.

Parameters

fileName

The file the map is stored in

Exceptions

ConfigurationError	when loading savegame file results in an error
CytopiaError	when savegame version is not compatible with current version of Cytopia

Definition at line 684 of file MapFunctions.cxx.

{
  std::string jsonAsString = fs::readCompressedFileAsString(CYTOPIA_SAVEGAME_DIR + fileName);
 
  if (jsonAsString.empty())
  {
    throw ConfigurationError(TRACE_INFO "Failed to load savegame file " + fileName);
  }
 
  json saveGameJSON = json::parse(jsonAsString, nullptr, false);
 
  if (saveGameJSON.is_discarded())
    throw ConfigurationError(TRACE_INFO "Could not parse savegame file " + fileName);
 
  size_t saveGameVersion = saveGameJSON.value("Savegame version", 0);
 
  if (saveGameVersion != SAVEGAME_VERSION)
  {
    /* @todo Check savegame version for compatibility and add upgrade functions here later if needed */
    throw CytopiaError(TRACE_INFO "Trying to load a Savegame with version " + std::to_string(saveGameVersion) +
                       " but only save-games with version " + std::to_string(SAVEGAME_VERSION) + " are supported");
  }
 
  int columns = saveGameJSON.value("columns", -1);
  int rows = saveGameJSON.value("rows", -1);
 
  if (columns == -1 || rows == -1)
  {
    throw ConfigurationError(TRACE_INFO "Savegame file " + fileName + "is invalid!");
  }
 
  Map *map = new Map(columns, rows);
  map->mapNodes.reserve(columns * rows);
 
  for (const auto &it : saveGameJSON["mapNode"].items())
  {
    Point coordinates = json(it.value())["coordinates"].get<Point>();
    // set coordinates (height) of the map
    map->mapNodes.emplace_back(Point{coordinates.x, coordinates.y, coordinates.z, coordinates.height}, "");
    // load back mapNodeData (tileIDs, Buildins, ...)
    map->mapNodes.back().setMapNodeData(json(it.value())["mapNodeData"]);
  }
 
  // Now put those newly created nodes in correct drawing order
  for (int x = 0; x < columns; x++)
  {
    for (int y = columns - 1; y >= 0; y--)
    {
      map->mapNodesInDrawingOrder.emplace_back(&map->mapNodes[x * columns + y]);
    }
  }
 
  if (map)
  {
    delete m_map;
    m_map = map;
  }
  updateAllNodes();
  LOG(LOG_DEBUG) << "Load succesfully: " << CYTOPIA_SAVEGAME_DIR + fileName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

newMap()

void MapFunctions::newMap

(

bool

generateTerrain = true

)

Creates a new map object with terrain gen.

Parameters

generateTerrain

flat map or procedural

Definition at line 671 of file MapFunctions.cxx.

{
  const int mapSize = Settings::instance().mapSize;
  Map *newMap = new Map(mapSize, mapSize, generateTerrain);
 
  if (newMap)
  {
    delete m_map;
    m_map = newMap;
    updateAllNodes();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

refreshVisibleMap()

void MapFunctions::refreshVisibleMap

(

)

Refresh the visible part of the map.

See also

Sprite::refresh

Definition at line 764 of file MapFunctions.cxx.

{
  if (m_map)
  {
    m_map->refresh();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveMapToFile()

void MapFunctions::saveMapToFile ( const std::string &  fileName )

private

Save Map to file.

Serializes the Map class to json and writes the data to a file.

Parameters

fileName

The file the map should be written to

Definition at line 745 of file MapFunctions.cxx.

{
  // make sure savegame dir exists
  fs::createDirectory(CYTOPIA_SAVEGAME_DIR);
 
  //create savegame json string
  const json j = json{{"Savegame version", SAVEGAME_VERSION},
                      {"columns", m_map->m_columns},
                      {"rows", m_map->m_rows},
                      {"mapNode", m_map->mapNodes}};
 
#ifdef DEBUG
  // Write uncompressed savegame for easier debugging
  fs::writeStringToFile(CYTOPIA_SAVEGAME_DIR + fileName + ".txt", j.dump());
#endif
  fs::writeStringToFileCompressed(CYTOPIA_SAVEGAME_DIR + fileName, j.dump());
  LOG(LOG_DEBUG) << "Saved succesfully: " << CYTOPIA_SAVEGAME_DIR + fileName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setTileID() [1/2]

bool MapFunctions::setTileID	(	const std::string &	tileID,
		const std::vector< Point > &	coordinates
	)

Set the Tile ID Of multiple Node objects.

Also invokes all necessary texture updates (auto-tiling, slopes, ...)

Parameters

tileID	the new tileID to set
coordinates	a vector of Points where the tileIDs which should be set

Returns

setTileID success or not

Definition at line 455 of file MapFunctions.cxx.

{
  bool setTileResult = false;
  for (auto coord : coordinates)
  {
    setTileResult |= setTileID(tileID, coord);
  }
  return setTileResult;
}

Here is the call graph for this function:

setTileID() [2/2]

bool MapFunctions::setTileID	(	const std::string &	tileID,
		Point	coordinate
	)

Set the Tile ID Of Node object.

Also invokes all necessary texture updates (auto-tiling, slopes, ...)

Parameters

tileID	the new tileID to set
coordinate	Point where the tileID which should be set

Returns

setTileID success or not

Definition at line 378 of file MapFunctions.cxx.

{
  TileData *tileData = TileManager::instance().getTileData(tileID);
  std::vector<Point> targetCoordinates = TileManager::instance().getTargetCoordsOfTileID(coordinate, tileID);
 
  if (!tileData || targetCoordinates.empty())
  { // if the node would not outside of map boundaries, targetCoordinates would be empty
    return false;
  }
 
  if (!isPlacementOnAreaAllowed(targetCoordinates, tileID))
    return false;
 
  Layer layer = TileManager::instance().getTileLayer(tileID);
  std::string randomGroundDecorationTileID;
  std::vector<Point> nodesToBeUpdated;
 
  // if this building has groundDeco, grab a random tileID from the list
  if (!tileData->groundDecoration.empty())
  {
    randomGroundDecorationTileID =
        *Randomizer::instance().choose(tileData->groundDecoration.begin(), tileData->groundDecoration.end());
  }
 
  // for >1x1 buildings, clear all the nodes that are going to be occupied before placing anything.
  if (targetCoordinates.size() >= 1 && layer == +Layer::BUILDINGS)
  {
    demolishNode(targetCoordinates, false, Layer::FLORA);      // remove trees under the buildings
    demolishNode(targetCoordinates, false, Layer::POWERLINES); // remove power lines under buildings
  }
 
  for (auto coord : targetCoordinates)
  { // now we can place our building
 
    MapNode &currentMapNode = getMapNode(coord);
 
    if (coord != coordinate && targetCoordinates.size() > 1)
    { // for buildings >1x1 set every node on the layer that will be occupied to invisible exepct of the origin node
      currentMapNode.getSprite()->setRenderFlag(layer, false);
    }
    else
    { // 1x1 buildings should be set to visible
      currentMapNode.getSprite()->setRenderFlag(layer, true);
    }
 
    if ((!targetCoordinates.size()) == 1)
    { // if it's not a >1x1 building, place tileID on the current coordinate (e.g. ground decoration beneath a > 1x1 building)
      currentMapNode.setTileID(tileID, coord);
    }
    else
    { // set the tileID for the mapNode of the origin coordinates only on the origin coordinate
      currentMapNode.setTileID(tileID, coordinate);
    }
 
    // place ground deco if we have one
    if (!randomGroundDecorationTileID.empty())
    {
      currentMapNode.setTileID(randomGroundDecorationTileID, coord);
    }
 
    // For layers that autotile to each other, we need to update their neighbors too
    if (TileManager::instance().isTileIDAutoTile(tileID))
    {
      nodesToBeUpdated.push_back(currentMapNode.getCoordinates());
    }
 
    // emit a signal that setTileID has been called
    SignalMediator::instance().signalSetTileID.emit(currentMapNode);
  }
 
  if (!nodesToBeUpdated.empty())
  {
    updateNodeNeighbors(nodesToBeUpdated);
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unHighlightNode()

void MapFunctions::unHighlightNode

(

const Point &

isoCoordinates

)

Sets a node to be unhighlighred.

This sets a node to be unhighlighted, which is done during rendering

Parameters

isoCoordinates

which node should be unhighlit.

Definition at line 550 of file MapFunctions.cxx.

{
  if (isoCoordinates.isWithinMapBoundaries())
  {
    getMapNode(isoCoordinates).getSprite()->highlightSprite = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateAllNodes()

void MapFunctions::updateAllNodes ( )

private

Update all mapNodes.

Updates all mapNode and its adjacent tiles regarding height information, draws slopes for adjacent tiles and sets tiling for mapNode sprite if applicable

Definition at line 244 of file MapFunctions.cxx.

{
  std::vector<Point> allCoords(m_map->mapNodes.size());
  std::transform(m_map->mapNodes.begin(), m_map->mapNodes.end(), allCoords.begin(),
                 [](MapNode &mn) { return mn.getCoordinates(); });
  updateNodeNeighbors(allCoords);
  refreshVisibleMap();
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateHeight()

bool MapFunctions::updateHeight	(	Point	coordinate,
		const bool	elevate
	)

Change map node height.

Parameters

coordinate	the Point on the map node to change height
elevate	if set to true make node higher, otherwise lower.

Returns

true in case that height has been changed, otherwise false.

Definition at line 18 of file MapFunctions.cxx.

{
  if (getMapNode(coordinate).changeHeight(elevate))
  {
    for (const auto neighbor : PointFunctions::getNeighbors(coordinate, false))
    {
      if (getMapNode(neighbor).isLayerOccupied(Layer::ZONE))
      {
        getMapNode(neighbor).demolishLayer(Layer::ZONE);
      }
    }
 
    return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateNodeNeighbors()

void MapFunctions::updateNodeNeighbors ( const std::vector< Point > &  nodes )

private

Update the nodes and all affected node with the change.

Parameters

nodes

vector of coordinates to be updated.

Definition at line 134 of file MapFunctions.cxx.

{
  // those bitmask combinations require the tile to be elevated.
  constexpr unsigned char elevateTileComb[] = {
      NeighborNodesPosition::TOP | NeighborNodesPosition::BOTTOM,
      NeighborNodesPosition::LEFT | NeighborNodesPosition::RIGHT,
      NeighborNodesPosition::TOP_LEFT | NeighborNodesPosition::RIGHT | NeighborNodesPosition::BOTTOM,
      NeighborNodesPosition::TOP_RIGHT | NeighborNodesPosition::LEFT | NeighborNodesPosition::BOTTOM,
      NeighborNodesPosition::BOTTOM_LEFT | NeighborNodesPosition::RIGHT | NeighborNodesPosition::TOP,
      NeighborNodesPosition::BOTTOM_RIGHT | NeighborNodesPosition::LEFT | NeighborNodesPosition::TOP};
 
  std::vector<Point> nodesToBeUpdated;
  std::map<int, std::vector<Point>> nodeCache;
  std::queue<Point> updatedNodes;
  std::vector<Point> nodesToElevate;
  std::vector<Point> nodesToDemolish;
 
  for (auto currentNode : nodes)
  {
    updatedNodes.push(currentNode);
 
    while (!updatedNodes.empty() || !nodesToElevate.empty())
    {
      while (!updatedNodes.empty())
      {
        const Point pHeighChangedNode = getMapNode(updatedNodes.front()).getCoordinates();
        updatedNodes.pop();
        const int tileHeight = pHeighChangedNode.height;
 
        if (nodeCache.count(pHeighChangedNode.toIndex()) == 0)
        {
          nodeCache[pHeighChangedNode.toIndex()] = PointFunctions::getNeighbors(pHeighChangedNode, false);
        }
 
        if (std::find(nodesToElevate.begin(), nodesToElevate.end(), pHeighChangedNode) == nodesToElevate.end())
        {
          nodesToElevate.push_back(pHeighChangedNode);
        }
 
        for (auto neighbor : nodeCache[pHeighChangedNode.toIndex()])
        {
          // get real coords that include height
          const Point neighborCoords = getMapNode(neighbor).getCoordinates();
          const int heightDiff = tileHeight - neighborCoords.height;
 
          if (nodeCache.count(neighborCoords.toIndex()) == 0)
          {
            nodeCache[neighborCoords.toIndex()] = PointFunctions::getNeighbors(neighborCoords, false);
          }
 
          if (std::find(nodesToElevate.begin(), nodesToElevate.end(), neighborCoords) == nodesToElevate.end())
          {
            nodesToElevate.push_back(neighborCoords);
          }
 
          if (std::abs(heightDiff) > 1)
          {
            updatedNodes.push(getMapNode(neighborCoords).getCoordinates());
            updateHeight(neighborCoords, (heightDiff > 1) ? true : false);
          }
        }
      }
 
      while (updatedNodes.empty() && !nodesToElevate.empty())
      {
        Point nodeToElevate = nodesToElevate.back();
        nodesToBeUpdated.push_back(nodeToElevate);
        nodesToElevate.pop_back();
 
        if (nodeCache.count(nodeToElevate.toIndex()) == 0)
        {
          nodeCache[nodeToElevate.toIndex()] = PointFunctions::getNeighbors(nodeToElevate, false);
        }
        const unsigned char elevationBitmask = getElevatedNeighborBitmask(nodeToElevate);
 
        if (elevationBitmask != getMapNode(nodeToElevate).getElevationBitmask())
        {
          nodesToDemolish.push_back(nodeToElevate);
          getMapNode(nodeToElevate).setElevationBitMask(elevationBitmask);
        }
 
        for (const auto &elBitMask : elevateTileComb)
        {
          if ((elevationBitmask & elBitMask) == elBitMask)
          {
            updateHeight(nodeToElevate, true);
            updatedNodes.push(getMapNode(nodeToElevate).getCoordinates());
            break;
          }
        }
      }
    }
  }
 
  if (!nodesToDemolish.empty())
  {
    demolishNode(nodesToDemolish);
  }
 
  for (Point node : nodesToBeUpdated)
  {
    getMapNode(node).setAutotileBitMask(calculateAutotileBitmask(node));
  }
 
  for (Point node : nodesToBeUpdated)
  {
    getMapNode(node).updateTexture();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_map

Map* MapFunctions::m_map

private

Definition at line 168 of file MapFunctions.hxx.

---

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

• src/engine/map/MapFunctions.hxx
• src/engine/map/MapFunctions.cxx