MapNode.hxx

Go to the documentation of this file.

#ifndef MAPNODE_HXX_
#define MAPNODE_HXX_
 
#include <SDL.h>
 
#include <memory>
#include <string>
#include <algorithm>
#include <vector>
 
#include "../Sprite.hxx"
#include "../common/enums.hxx"
#include "../basics/Point.hxx"
 
#include "../TileManager.hxx"
 
struct MapNodeData
{
  std::string tileID;
  TileData *tileData = nullptr;
  int32_t tileIndex = 0;
  Point origCornerPoint = Point::INVALID();
  TileMap tileMap = TileMap::DEFAULT; // store information whether we use normal, slope or shore tiles
};
 
class MapNode
{
public:
  MapNode(Point isoCoordinates, const std::string &terrainID, const std::string &newTileID = "");
 
  MapNode(MapNode &&mn) noexcept
      : 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() = default;
 
  Sprite *getSprite() const { return m_sprite.get(); };
 
  const Point &getCoordinates() const { return m_isoCoordinates; };
 
  void setCoordinates(const Point &newIsoCoordinates);
 
  bool changeHeight(const bool higher);
 
  void render() const;
 
  void setBitmask(unsigned char elevationBitmask, std::vector<uint8_t> tileTypeBitmask);
 
  unsigned char getElevationBitmask() const { return m_elevationBitmask; };
 
  const TileData *getTileData(Layer layer) const { return m_mapNodeData[layer].tileData; };
 
  const std::string &getTileID(Layer layer) const { return m_mapNodeData[layer].tileID; };
 
  bool isPlacementAllowed(const std::string &newTileID) const;
 
  void setMapNodeData(std::vector<MapNodeData> &&mapNodeData);
 
  const std::vector<MapNodeData> &getMapNodeData() const { return m_mapNodeData; };
  const MapNodeData &getMapNodeDataForLayer(Layer layer) const { return m_mapNodeData[layer]; };
 
  const MapNodeData &getActiveMapNodeData() const;
 
  bool isPlacableOnSlope(const std::string &tileID) const;
 
  bool isSlopeNode(void) const;
 
  const bool isConductive() const;
 
  void demolishNode(const Layer &layer = Layer::NONE);
 
  void demolishLayer(const Layer &layer);
 
  void setTileID(const std::string &tileType, const Point &origPoint);
 
  const Point &getOrigCornerPoint(Layer layer) const { return getMapNodeDataForLayer(layer).origCornerPoint; }
 
  bool isOriginNode(Layer layer = Layer::BUILDINGS) const
  {
    return (m_isoCoordinates == getMapNodeDataForLayer(layer).origCornerPoint);
  }
 
  Layer getTopMostActiveLayer() const;
 
  bool isLayerOccupied(const Layer &layer) const { return m_mapNodeData[layer].tileData != nullptr; }
 
  inline void setElevationBitMask(const unsigned char bitMask) { m_elevationBitmask = bitMask; }
 
  inline void setAutotileBitMask(std::vector<unsigned char> &&bitMask) { m_autotileBitmask = std::move(bitMask); }
 
  void updateTexture(const Layer &layer = Layer::NONE);
 
  void setNodeTransparency(const float transparencyFactor, const Layer &layer) const;
 
  void setZIndex(int zIndex) { m_isoCoordinates.z = zIndex; };
 
  static const int maxHeight = 32;
 
private:
  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;
};
#endif