MapNode Class Reference

Class that holds map nodes. More...

#include <MapNode.hxx>

Collaboration diagram for MapNode:

Public Member Functions
	MapNode (Point isoCoordinates, const std::string &terrainID, const std::string &newTileID="")
	MapNode (MapNode &&mn) noexcept
	Move constructor. More...
	~MapNode ()=default
	Destroys the MapNode object. More...
Sprite *	getSprite () const
	get Sprite More...
const Point &	getCoordinates () const
	get iso coordinates of this node More...
void	setCoordinates (const Point &newIsoCoordinates)
	sets the iso coordinates of this node More...
bool	changeHeight (const bool higher)
	Change Height. More...
void	render () const
	Render MapNode. More...
void	setBitmask (unsigned char elevationBitmask, std::vector< uint8_t > tileTypeBitmask)
unsigned char	getElevationBitmask () const
const TileData *	getTileData (Layer layer) const
const std::string &	getTileID (Layer layer) const
	get TileID of specific layer inside NodeData. More...
bool	isPlacementAllowed (const std::string &newTileID) const
void	setMapNodeData (std::vector< MapNodeData > &&mapNodeData)
	Overwrite m_mapData with the one loaded from a savegame. This function to be used only by loadGame. More...
const std::vector< MapNodeData > &	getMapNodeData () const
const MapNodeData &	getMapNodeDataForLayer (Layer layer) const
const MapNodeData &	getActiveMapNodeData () const
bool	isPlacableOnSlope (const std::string &tileID) const
	check if tileID placeable on slope tile. More...
bool	isSlopeNode (void) const
	check if current Node Terrain is Slope Terrain. More...
const bool	isConductive () const
	check the conductivity of the node More...
void	demolishNode (const Layer &layer=Layer::NONE)
	Demolish a node. More...
void	demolishLayer (const Layer &layer)
	demolish specific layer of a Node. More...
void	setTileID (const std::string &tileType, const Point &origPoint)
const Point &	getOrigCornerPoint (Layer layer) const
	Get the Origin Corner Point of a multitile building. More...
bool	isOriginNode (Layer layer=Layer::BUILDINGS) const
	If this is the origin node of a multitile building. More...
Layer	getTopMostActiveLayer () const
	return topmost active layer. More...
bool	isLayerOccupied (const Layer &layer) const
void	setElevationBitMask (const unsigned char bitMask)
	Set elevation bit mask. More...
void	setAutotileBitMask (std::vector< unsigned char > &&bitMask)
	Set autotile bit mask. More...
void	updateTexture (const Layer &layer=Layer::NONE)
	Update texture. More...
void	setNodeTransparency (const float transparencyFactor, const Layer &layer) const
	Sets a node to be Transparent. More...
void	setZIndex (int zIndex)
	Update the Z-Index of this mapNode. More...

Static Public Attributes
static const int	maxHeight = 32
	Maximum height of the node. More...

Private Attributes
Point	m_isoCoordinates
std::unique_ptr< Sprite >	m_sprite
std::string	m_previousTileID = "terrain"
std::vector< TileOrientation >	m_autotileOrientation
size_t	m_elevationOrientation = TileSlopes::DEFAULT_ORIENTATION
int	m_clippingWidth = 0
std::vector< MapNodeData >	m_mapNodeData
std::vector< unsigned char >	m_autotileBitmask
unsigned char	m_elevationBitmask = 0

Detailed Description

Class that holds map nodes.

Each tile is represented by the map nodes class.

Definition at line 30 of file MapNode.hxx.

Constructor & Destructor Documentation

MapNode() [1/2]

MapNode::MapNode	(	Point	isoCoordinates,
		const std::string &	terrainID,
		const std::string &	newTileID = ""
	)

Definition at line 9 of file MapNode.cxx.

    : m_isoCoordinates(std::move(isoCoordinates)), m_sprite{std::make_unique<Sprite>(m_isoCoordinates)},
      m_autotileOrientation(LAYERS_COUNT, TileOrientation::TILE_DEFAULT_ORIENTATION),
      m_mapNodeData{std::vector(LAYERS_COUNT, MapNodeData{"", nullptr, 0, m_isoCoordinates, TileMap::DEFAULT})},
      m_autotileBitmask(LAYERS_COUNT)
{
  setTileID(terrainID, isoCoordinates);
  if (!tileID.empty()) // in case tileID is not supplied skip it
  {
    setTileID(tileID, isoCoordinates);
  }
  // always add blueprint tiles too when creating the node
  setTileID("terrain_blueprint", isoCoordinates);
  const Layer layer = TileManager::instance().getTileLayer(tileID);
  updateTexture(layer);
}

MapNode() [2/2]

MapNode::MapNode ( MapNode &&  mn )

inlinenoexcept

Move constructor.

Definition at line 37 of file MapNode.hxx.

      : m_isoCoordinates(std::move(mn.m_isoCoordinates)), m_sprite(std::move(mn.m_sprite)),
        m_previousTileID(std::move(mn.m_previousTileID)), m_autotileOrientation(std::move(mn.m_autotileOrientation)),
        m_elevationOrientation(mn.m_elevationOrientation), m_clippingWidth(mn.m_clippingWidth),
        m_mapNodeData(std::move(mn.m_mapNodeData)), m_autotileBitmask(std::move(mn.m_autotileBitmask)),
        m_elevationBitmask(mn.m_elevationBitmask){};

~MapNode()

MapNode::~MapNode ( )

default

Destroys the MapNode object.

Member Function Documentation

changeHeight()

bool MapNode::changeHeight

(

const bool

higher

)

Change Height.

Increases or decrease the height of the node and its sprite. This function should not be called directly, but only from where the neighboring nodes slopes are determined.

Parameters

higher

pass true in case that height should be increased or false in case that height should be decreased.

Returns

true in case that height is changed, otherwise false.

Definition at line 26 of file MapNode.cxx.

{
  constexpr int minHeight = 0;
  auto &height = m_isoCoordinates.height;
 
  if ((higher && (height < maxHeight)) || (!higher && (height > minHeight)))
  {
    higher ? ++height : --height;
    m_sprite->isoCoordinates = m_isoCoordinates;
    return true;
  }
 
  return false;
}

Here is the caller graph for this function:

demolishLayer()

void MapNode::demolishLayer

(

const Layer &

layer

)

demolish specific layer of a Node.

Parameters

layer

what layer should be demolished.

Definition at line 454 of file MapNode.cxx.

{
  m_mapNodeData[layer].tileData = nullptr;
  m_mapNodeData[layer].tileID = "";
  m_autotileOrientation[layer] =
      TileOrientation::TILE_DEFAULT_ORIENTATION; // We need to reset TileOrientation, in case it's set (demolishing autotiles)
  m_mapNodeData[layer].origCornerPoint = this->getCoordinates();
  m_sprite->setRenderFlag(Layer::ZONE, true);
  m_sprite->clearSprite(layer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

demolishNode()

void MapNode::demolishNode

(

const Layer &

layer = Layer::NONE

)

Demolish a node.

Removes all tiles on a node. This effects all layers where something to demolish is placed (BUILDINGS, GROUND_DECORATION, UNDERGROUND) per default, but can be restricted to a single Layer.

Parameters

layer

restrict demolish to a single layer

See also

MapNode::demolishNode

Definition at line 465 of file MapNode.cxx.

{
  // allow to delete a single layer only
  std::vector<Layer> layersToDemolish;
  if (demolishLayer == Layer::NONE)
  {
    layersToDemolish = {Layer::BUILDINGS,  Layer::UNDERGROUND, Layer::GROUND_DECORATION, Layer::ZONE, Layer::ROAD,
                        Layer::POWERLINES, Layer::FLORA};
  }
  else
  {
    layersToDemolish.push_back(demolishLayer);
  }
 
  for (auto &layer : layersToDemolish)
  {
    if (MapLayers::isLayerActive(layer) && m_mapNodeData[layer].tileData)
    {
      if ((GameStates::instance().demolishMode == DemolishMode::DEFAULT &&
           m_mapNodeData[layer].tileData->tileType == +TileType::ZONE) ||
          (GameStates::instance().demolishMode == DemolishMode::DE_ZONE &&
           m_mapNodeData[layer].tileData->tileType != +TileType::ZONE) ||
          (GameStates::instance().demolishMode == DemolishMode::GROUND_DECORATION &&
           m_mapNodeData[layer].tileData->tileType != +TileType::GROUNDDECORATION))
      {
        continue;
      }
      this->demolishLayer(layer);
      if (layer == Layer::BUILDINGS)
      {
        this->setNodeTransparency(0, Layer::BLUEPRINT);
      }
      updateTexture(demolishLayer);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getActiveMapNodeData()

const MapNodeData & MapNode::getActiveMapNodeData

(

)

const

Definition at line 438 of file MapNode.cxx.

{ return m_mapNodeData[getTopMostActiveLayer()]; }

Here is the call graph for this function:

Here is the caller graph for this function:

getCoordinates()

const Point& MapNode::getCoordinates ( ) const

inline

get iso coordinates of this node

Returns

a pointer to the node's iso coordinates

Definition at line 59 of file MapNode.hxx.

{ return m_isoCoordinates; };

Here is the caller graph for this function:

getElevationBitmask()

unsigned char MapNode::getElevationBitmask ( ) const

inline

Definition at line 82 of file MapNode.hxx.

{ return m_elevationBitmask; };

Here is the caller graph for this function:

getMapNodeData()

const std::vector<MapNodeData>& MapNode::getMapNodeData ( ) const

inline

Definition at line 96 of file MapNode.hxx.

{ return m_mapNodeData; };

Here is the caller graph for this function:

getMapNodeDataForLayer()

const MapNodeData& MapNode::getMapNodeDataForLayer ( Layer  layer ) const

inline

Definition at line 97 of file MapNode.hxx.

{ return m_mapNodeData[layer]; };

Here is the caller graph for this function:

getOrigCornerPoint()

const Point& MapNode::getOrigCornerPoint ( Layer  layer ) const

inline

Get the Origin Corner Point of a multitile building.

Parameters

layer

the layer that should be checked

Returns

const Point&

Definition at line 136 of file MapNode.hxx.

{ return getMapNodeDataForLayer(layer).origCornerPoint; }

Here is the call graph for this function:

Here is the caller graph for this function:

getSprite()

Sprite* MapNode::getSprite ( ) const

inline

get Sprite

get the Sprite* object for this nodes

Returns

the Sprite of this node.

See also

Sprite

Definition at line 54 of file MapNode.hxx.

{ return m_sprite.get(); };

Here is the caller graph for this function:

getTileData()

const TileData* MapNode::getTileData ( Layer  layer ) const

inline

Definition at line 84 of file MapNode.hxx.

{ return m_mapNodeData[layer].tileData; };

Here is the caller graph for this function:

getTileID()

const std::string& MapNode::getTileID ( Layer  layer ) const

inline

get TileID of specific layer inside NodeData.

Parameters

layer

what layer should be checked on.

Definition at line 89 of file MapNode.hxx.

{ return m_mapNodeData[layer].tileID; };

Here is the caller graph for this function:

getTopMostActiveLayer()

Layer MapNode::getTopMostActiveLayer

(

)

const

return topmost active layer.

check layers in order of significance for the topmost active layer that has an active tile on that layer

Returns

Layer enum of the topmost active layer

Definition at line 105 of file MapNode.cxx.

{
  for (auto currentLayer : layersInActiveOrder)
  {
    if (MapLayers::isLayerActive(currentLayer) && m_mapNodeData[currentLayer].tileData)
    {
      return currentLayer;
    }
  }
  return Layer::NONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isConductive()

const bool MapNode::isConductive

(

)

const

check the conductivity of the node

Returns

true if the node conducts electricity/power, false if not

Definition at line 502 of file MapNode.cxx.

{
  if (getTileData(Layer::BUILDINGS) || getTileData(Layer::POWERLINES) || getTileData(Layer::ZONE))
  {
    return true;
  }
  else
  {
    return false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

isLayerOccupied()

bool MapNode::isLayerOccupied ( const Layer &  layer ) const

inline

Definition at line 155 of file MapNode.hxx.

{ return m_mapNodeData[layer].tileData != nullptr; }

Here is the caller graph for this function:

isOriginNode()

bool MapNode::isOriginNode ( Layer  layer = Layer::BUILDINGS ) const

inline

If this is the origin node of a multitile building.

Parameters

layer

the layer that should be checked, defaults to the BUILDINGS layer

Returns

wheter or not this is the origin node of a multitile building

Definition at line 144 of file MapNode.hxx.

  {
    return (m_isoCoordinates == getMapNodeDataForLayer(layer).origCornerPoint);
  }

Here is the call graph for this function:

isPlacableOnSlope()

bool MapNode::isPlacableOnSlope

(

const std::string &

tileID

)

const

check if tileID placeable on slope tile.

Parameters

tileID

the tileID which need to be checked whether allowing placement on slope or not.

Definition at line 124 of file MapNode.cxx.

{
  TileData *tileData = TileManager::instance().getTileData(tileID);
  if (tileData && tileData->tileType == +TileType::ZONE)
  {
    // zones are allowed to pass slopes.
    return true;
  }
  if (tileData && m_elevationOrientation != TileSlopes::DEFAULT_ORIENTATION)
  {
    // we need to check the terrain layer for it's orientation so we can calculate the resulting x offset in the spritesheet.
    const int clipRectX = tileData->slopeTiles.clippingWidth * static_cast<int>(m_autotileOrientation[Layer::TERRAIN]);
    // while loading game, m_previousTileID will be equal to "terrain" for terrin tiles while it's empty "" when starting new game.
    // so the check here on m_previousTileID is needed both (temporary), empty and "terrain", this will be fixed in new PR.
    if (clipRectX >= static_cast<int>(tileData->slopeTiles.count) * tileData->slopeTiles.clippingWidth &&
        (m_previousTileID.empty() || m_previousTileID == "terrain"))
    {
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isPlacementAllowed()

bool MapNode::isPlacementAllowed

(

const std::string &

newTileID

)

const

Definition at line 147 of file MapNode.cxx.

{
  TileData *tileData = TileManager::instance().getTileData(newTileID);
 
  if (tileData)
  {
    const Layer layer = TileManager::instance().getTileLayer(newTileID);
    // layer specific checks:
    switch (layer)
    {
    case Layer::ZONE:
      if (isLayerOccupied(Layer::WATER))
      {
        return tileData->placeOnWater;
      }
      return true;
    case Layer::POWERLINES:
      if (isLayerOccupied(Layer::POWERLINES) ||
          std::any_of(layersPowerlinesCanCross.begin(), layersPowerlinesCanCross.end(),
                      [this](const Layer &_layer) { return this->isLayerOccupied(_layer); }))
      { // powerlines can be placed over each other and over other low terrains
        return true;
      }
    case Layer::ROAD:
      if ((isLayerOccupied(Layer::BUILDINGS) && (m_mapNodeData[Layer::BUILDINGS].tileData->category != "Flora")) ||
          isLayerOccupied(Layer::WATER) || !isPlacableOnSlope(newTileID))
      { // roads cannot be placed:
        // - on buildings that are not category flora.
        // - on water
        // - on slopetiles that don't have a tileID
        return false;
      }
      return true;
    case Layer::GROUND_DECORATION:
      if (m_mapNodeData[Layer::GROUND_DECORATION].tileData || m_mapNodeData[Layer::BUILDINGS].tileData)
      { // allow placement of ground decoration on existing ground decoration and on buildings.
        return true;
      }
      break;
    case Layer::FLORA:
      if (m_mapNodeData[Layer::FLORA].tileData && m_mapNodeData[Layer::FLORA].tileData->isOverPlacable)
      { // flora with overplacable flag
        return true;
      }
      if (isLayerOccupied(Layer::ROAD) || isLayerOccupied(Layer::BUILDINGS) || isLayerOccupied(Layer::POWERLINES))
      { // don't allow placement of flora on buildings or roads
        return false;
      }
      break;
    case Layer::BUILDINGS:
    {
      TileData *tileDataBuildings = m_mapNodeData[Layer::BUILDINGS].tileData;
      if (tileDataBuildings && tileDataBuildings->isOverPlacable)
      { // buildings with overplacable flag
        return true;
      }
      if (isLayerOccupied(Layer::ROAD))
      { // buildings cannot be placed on roads
        return false;
      }
      break;
    }
    default:
      break;
    }
 
    // checks for all layers:
    if (isLayerOccupied(Layer::WATER))
    {
      if (tileData->tileType != +TileType::WATER && !tileData->placeOnWater)
      // Disallow placement on water for tiles that are:
      // not of tiletype water
      // not flag placeOnWater enabled
      {
        return false;
      }
    }
    else // not water
    {
      if (!tileData->placeOnGround)
      // Disallow placement on ground (meaning a tile that is not water) for tiles that have:
      // not flag placeOnGround enabled
      {
        return false;
      }
    }
 
    if (!isPlacableOnSlope(newTileID))
    { // Check if a tile has slope frames and therefore can be placed on a node with a slope
      return false;
    }
 
    if (tileData->tileType == +TileType::UNDERGROUND)
    { // Underground tiletype (pipes, metro tunnels, ... ) can overplace each other
      return true;
    }
 
    if (m_mapNodeData[layer].tileID.empty())
    { // of course allow placement on empty tiles
      return true;
    }
  }
  // every case that is not handled is false
  return false;
}

Here is the call graph for this function:

isSlopeNode()

bool MapNode::isSlopeNode

(

void

)

const

check if current Node Terrain is Slope Terrain.

Definition at line 430 of file MapNode.cxx.

{ return m_mapNodeData[Layer::TERRAIN].tileMap == TileMap::SLOPES; }

Here is the caller graph for this function:

render()

void MapNode::render

(

)

const

Render MapNode.

Renders the sprite object(s) of the node

Definition at line 41 of file MapNode.cxx.

{ m_sprite->render(); }

setAutotileBitMask()

void MapNode::setAutotileBitMask ( std::vector< unsigned char > &&  bitMask )

inline

Set autotile bit mask.

Parameters

bitMask

Definition at line 165 of file MapNode.hxx.

{ m_autotileBitmask = std::move(bitMask); }

Here is the caller graph for this function:

setBitmask()

void MapNode::setBitmask	(	unsigned char	elevationBitmask,
		std::vector< uint8_t >	tileTypeBitmask
	)

Definition at line 43 of file MapNode.cxx.

{
  m_elevationBitmask = elevationBitmask;
  m_autotileBitmask = autotileBitmask;
  updateTexture();
}

Here is the call graph for this function:

setCoordinates()

void MapNode::setCoordinates

(

const Point &

newIsoCoordinates

)

sets the iso coordinates of this node

Parameters

newIsoCoordinates

the new iso coordinates for the node

Definition at line 432 of file MapNode.cxx.

{
  m_isoCoordinates = newIsoCoordinates;
  m_sprite->isoCoordinates = m_isoCoordinates;
}

Here is the caller graph for this function:

setElevationBitMask()

void MapNode::setElevationBitMask ( const unsigned char  bitMask )

inline

Set elevation bit mask.

Parameters

bitMask

Definition at line 160 of file MapNode.hxx.

{ m_elevationBitmask = bitMask; }

Here is the caller graph for this function:

setMapNodeData()

void MapNode::setMapNodeData

(

std::vector< MapNodeData > &&

mapNodeData

)

Overwrite m_mapData with the one loaded from a savegame. This function to be used only by loadGame.

Definition at line 440 of file MapNode.cxx.

{
  m_mapNodeData.swap(mapNodeData);
  this->setNodeTransparency(Settings::instance().zoneLayerTransparency, Layer::ZONE);
 
  // updates the pointers to the tiles, after loading tileIDs from json
  for (auto &it : m_mapNodeData)
  {
    delete it.tileData;
 
    it.tileData = TileManager::instance().getTileData(it.tileID);
  }
}

Here is the call graph for this function:

setNodeTransparency()

void MapNode::setNodeTransparency	(	const float	transparencyFactor,
		const Layer &	layer
	)		const

Sets a node to be Transparent.

Parameters

transparencyFactor	(0-1.0) - The percentage of node transparency. 1 -> invisible, 0 -> opaque.
layer	what layer in Sprite should it's transparency altered.

Definition at line 117 of file MapNode.cxx.

{
  // TODO refactoring: Consider replacing magic number (255) with constexpr.
  unsigned char alpha = (1 - transparencyFactor) * 255;
  m_sprite->setSpriteTranparencyFactor(layer, alpha);
}

Here is the caller graph for this function:

setTileID()

void MapNode::setTileID	(	const std::string &	tileType,
		const Point &	origPoint
	)

set tileIndex to a rand between 1 and count, this will be the displayed image of the entire tileset if this tile has ordered frames, like roads then pickRandomTile must be set to 0.

must be reset to 0 otherwise overwritting tiles would keep the old tile's tileIndex which creates problems if it's supposed to be 0

Definition at line 50 of file MapNode.cxx.

{
  TileData *tileData = TileManager::instance().getTileData(tileID);
  if (tileData && !tileID.empty())
  {
    const Layer layer = TileManager::instance().getTileLayer(tileID);
    switch (layer)
    {
    case Layer::ZONE:
      this->setNodeTransparency(Settings::instance().zoneLayerTransparency, Layer::ZONE);
      break;
    case Layer::WATER:
      demolishLayer(Layer::ROAD);
      //TODO: we need to modify neighbors TileTypes to Shore.
      // no break on purpose.
    case Layer::ROAD:
      // in case it's allowed then maybe a Tree Tile already exist, so we remove it.
      demolishLayer(Layer::FLORA);
    case Layer::POWERLINES:
      break;
    case Layer::BUILDINGS:
      if (tileData->tileType != +TileType::FLORA)
      {
        this->setNodeTransparency(0.6, Layer::BLUEPRINT);
      }
      m_sprite->setRenderFlag(Layer::ZONE, false);
      break;
    default:
      break;
    }
 
    m_mapNodeData[layer].origCornerPoint = origCornerPoint;
    m_previousTileID = m_mapNodeData[layer].tileID;
    m_mapNodeData[layer].tileData = tileData;
    m_mapNodeData[layer].tileID = tileID;
 
    // Determine if the tile should have a random rotation or not.
    if (m_mapNodeData[layer].tileData->tiles.pickRandomTile && m_mapNodeData[layer].tileData->tiles.count > 1)
    {
      m_mapNodeData[layer].tileIndex = rand() % m_mapNodeData[layer].tileData->tiles.count;
    }
    else
    {
      m_mapNodeData[layer].tileIndex = 0;
    }
    updateTexture(layer);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setZIndex()

void MapNode::setZIndex ( int  zIndex )

inline

Update the Z-Index of this mapNode.

Parameters

the	new Z-Index

Definition at line 183 of file MapNode.hxx.

{ m_isoCoordinates.z = zIndex; };

updateTexture()

void MapNode::updateTexture

(

const Layer &

layer = Layer::NONE

)

Update texture.

Parameters

layer

Definition at line 253 of file MapNode.cxx.

{
  SDL_Rect clipRect{0, 0, 0, 0};
  //TODO: Refactor this
  m_elevationOrientation = TileManager::instance().calculateSlopeOrientation(m_elevationBitmask);
  std::vector<Layer> layersToGoOver;
  if (layer != Layer::NONE)
  {
    // in case this is not the default value (which is NONE), we need to update only 1 layer.
    layersToGoOver.push_back(layer);
  }
  else
  {
    layersToGoOver.insert(layersToGoOver.begin(), std::begin(allLayersOrdered), std::end(allLayersOrdered));
  }
 
  for (auto currentLayer : layersToGoOver)
  {
    if (m_mapNodeData[currentLayer].tileData)
    {
      size_t spriteCount = 1;
      m_mapNodeData[currentLayer].tileMap = TileMap::DEFAULT;
      if (m_elevationOrientation == TileSlopes::DEFAULT_ORIENTATION)
      {
        if (m_mapNodeData[currentLayer].tileData->tileType == +TileType::WATER ||
            m_mapNodeData[currentLayer].tileData->tileType == +TileType::TERRAIN ||
            m_mapNodeData[currentLayer].tileData->tileType == +TileType::BLUEPRINT)
        {
          m_autotileOrientation[currentLayer] = TileManager::instance().calculateTileOrientation(m_autotileBitmask[currentLayer]);
          m_mapNodeData[currentLayer].tileMap = TileMap::DEFAULT;
          if (currentLayer == Layer::TERRAIN && m_autotileOrientation[currentLayer] != TileOrientation::TILE_DEFAULT_ORIENTATION)
          {
            m_mapNodeData[Layer::TERRAIN].tileMap = TileMap::SHORE;
            // for shore tiles, we need to reset the tileIndex to 0, else a random tile would be picked. This is a little bit hacky.
            m_mapNodeData[Layer::TERRAIN].tileIndex = 0;
          }
        }
        // if the node can autotile, calculate it's tile orientation
        else if (TileManager::instance().isTileIDAutoTile(getTileID(currentLayer)))
        {
          m_autotileOrientation[currentLayer] = TileManager::instance().calculateTileOrientation(m_autotileBitmask[currentLayer]);
        }
      }
      else if (m_elevationOrientation >= TileSlopes::N && m_elevationOrientation <= TileSlopes::BETWEEN)
      {
        if (m_mapNodeData[currentLayer].tileData->slopeTiles.fileName.empty())
        {
          m_mapNodeData[currentLayer].tileMap = TileMap::DEFAULT;
          m_autotileOrientation[currentLayer] = TileOrientation::TILE_DEFAULT_ORIENTATION;
        }
        else
        {
          m_mapNodeData[currentLayer].tileMap = TileMap::SLOPES; // TileSlopes [N,E,w,S]
          m_autotileOrientation[currentLayer] = static_cast<TileOrientation>(m_elevationOrientation);
        }
      }
 
      switch (m_mapNodeData[currentLayer].tileMap)
      {
      case TileMap::DEFAULT:
        m_clippingWidth = m_mapNodeData[currentLayer].tileData->tiles.clippingWidth;
        if (m_mapNodeData[currentLayer].tileIndex != 0)
        {
          clipRect.x = m_clippingWidth * m_mapNodeData[currentLayer].tileIndex;
        }
        else
        {
          if (m_mapNodeData[currentLayer].tileData->tileType == +TileType::POWERLINE &&
              std::any_of(layersPowerlinesCanCross.begin(), layersPowerlinesCanCross.end(),
                          [this](const Layer &_layer) { return this->m_mapNodeData[_layer].tileData; }))
          { // if we place a power line cross low terrain (eg, roads, water, flora)
            switch (m_autotileOrientation[currentLayer])
            {
            case TileOrientation::TILE_N_AND_S:
              m_autotileOrientation[currentLayer] = TileOrientation::TILE_N_AND_S_CROSS;
              break;
            case TileOrientation::TILE_E_AND_W:
              m_autotileOrientation[currentLayer] = TileOrientation::TILE_E_AND_W_CROSS;
              break;
            default:
              break;
            }
          }
          // only check for rectangular roads when there are frames for it. Spritesheets with rect-roads have 20 items
          if (GameStates::instance().rectangularRoads && m_mapNodeData[currentLayer].tileData->tiles.count == 20)
          {
            switch (m_autotileOrientation[currentLayer])
            {
            case TileOrientation::TILE_S_AND_W:
              m_autotileOrientation[currentLayer] = TileOrientation::TILE_S_AND_W_RECT;
              break;
            case TileOrientation::TILE_S_AND_E:
              m_autotileOrientation[currentLayer] = TileOrientation::TILE_S_AND_E_RECT;
              break;
            case TileOrientation::TILE_N_AND_E:
              m_autotileOrientation[currentLayer] = TileOrientation::TILE_N_AND_E_RECT;
              break;
            case TileOrientation::TILE_N_AND_W:
              m_autotileOrientation[currentLayer] = TileOrientation::TILE_N_AND_W_RECT;
              break;
 
            default:
              break;
            }
          }
          clipRect.x = m_clippingWidth * static_cast<int>(m_autotileOrientation[currentLayer]);
        }
 
        if (!m_mapNodeData[currentLayer].tileID.empty())
        {
          m_sprite->setClipRect({clipRect.x + m_clippingWidth * m_mapNodeData[currentLayer].tileData->tiles.offset, 0,
                                 m_clippingWidth, m_mapNodeData[currentLayer].tileData->tiles.clippingHeight},
                                static_cast<Layer>(currentLayer));
          m_sprite->setTexture(TileManager::instance().getTexture(m_mapNodeData[currentLayer].tileID),
                               static_cast<Layer>(currentLayer));
        }
 
        spriteCount = m_mapNodeData[currentLayer].tileData->tiles.count;
        break;
      case TileMap::SHORE:
        m_clippingWidth = m_mapNodeData[currentLayer].tileData->shoreTiles.clippingWidth;
        if (m_mapNodeData[currentLayer].tileIndex != 0)
        {
          clipRect.x = m_clippingWidth * m_mapNodeData[currentLayer].tileIndex;
        }
        else
        {
          clipRect.x = m_clippingWidth * static_cast<int>(m_autotileOrientation[currentLayer]);
        }
 
        if (!m_mapNodeData[currentLayer].tileID.empty())
        {
          m_sprite->setClipRect({clipRect.x + m_clippingWidth * m_mapNodeData[currentLayer].tileData->shoreTiles.offset, 0,
                                 m_clippingWidth, m_mapNodeData[currentLayer].tileData->shoreTiles.clippingHeight},
                                static_cast<Layer>(currentLayer));
          m_sprite->setTexture(TileManager::instance().getTexture(m_mapNodeData[currentLayer].tileID + "_shore"),
                               static_cast<Layer>(currentLayer));
        }
 
        spriteCount = m_mapNodeData[currentLayer].tileData->shoreTiles.count;
        break;
      case TileMap::SLOPES:
        if (m_mapNodeData[currentLayer].tileData->slopeTiles.fileName.empty())
        {
          break;
        }
        m_clippingWidth = m_mapNodeData[currentLayer].tileData->slopeTiles.clippingWidth;
        clipRect.x = m_mapNodeData[currentLayer].tileData->slopeTiles.clippingWidth *
                     static_cast<int>(m_autotileOrientation[currentLayer]);
        spriteCount = m_mapNodeData[currentLayer].tileData->slopeTiles.count;
        if (clipRect.x <= static_cast<int>(spriteCount) * m_clippingWidth)
        {
          m_sprite->setClipRect({clipRect.x + m_mapNodeData[currentLayer].tileData->slopeTiles.offset * m_clippingWidth, 0,
                                 m_clippingWidth, m_mapNodeData[currentLayer].tileData->slopeTiles.clippingHeight},
                                static_cast<Layer>(currentLayer));
          m_sprite->setTexture(TileManager::instance().getTexture(m_mapNodeData[currentLayer].tileID),
                               static_cast<Layer>(currentLayer));
        }
        break;
      default:
        break;
      }
 
      if (clipRect.x >= static_cast<int>(spriteCount) * m_clippingWidth)
      {
        m_mapNodeData[currentLayer].tileID = m_previousTileID;
        if (m_previousTileID.empty())
        {
          m_mapNodeData[currentLayer].tileData = nullptr;
        }
        updateTexture(currentLayer);
      }
      m_sprite->spriteCount = spriteCount;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_autotileBitmask

std::vector<unsigned char> MapNode::m_autotileBitmask

private

Definition at line 196 of file MapNode.hxx.

m_autotileOrientation

std::vector<TileOrientation> MapNode::m_autotileOrientation

private

Definition at line 192 of file MapNode.hxx.

m_clippingWidth

int MapNode::m_clippingWidth = 0

private

Definition at line 194 of file MapNode.hxx.

m_elevationBitmask

unsigned char MapNode::m_elevationBitmask = 0

private

Definition at line 197 of file MapNode.hxx.

m_elevationOrientation

size_t MapNode::m_elevationOrientation = TileSlopes::DEFAULT_ORIENTATION

private

Definition at line 193 of file MapNode.hxx.

m_isoCoordinates

Point MapNode::m_isoCoordinates

private

Definition at line 189 of file MapNode.hxx.

m_mapNodeData

std::vector<MapNodeData> MapNode::m_mapNodeData

private

Definition at line 195 of file MapNode.hxx.

m_previousTileID

std::string MapNode::m_previousTileID = "terrain"

private

Definition at line 191 of file MapNode.hxx.

m_sprite

std::unique_ptr<Sprite> MapNode::m_sprite

private

Definition at line 190 of file MapNode.hxx.

maxHeight

const int MapNode::maxHeight = 32

static

Maximum height of the node.

Definition at line 186 of file MapNode.hxx.

---

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

• src/engine/GameObjects/MapNode.hxx
• src/engine/GameObjects/MapNode.cxx