tb_tile_system.hpp

 
#ifndef TurtleBrains_TileSystem_hpp
#define TurtleBrains_TileSystem_hpp
 
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_dynamic_structure.hpp>
#include <turtle_brains/graphics/tb_graphic_list.hpp>
#include <turtle_brains/graphics/tb_sprite_map.hpp>
#include <turtle_brains/math/tb_vector.hpp>
 
#include <vector>
#include <map>
 
namespace TurtleBrains::Graphics::Implementation { class TileSystemRenderer; };
namespace TurtleBrains::Game::Unstable { class TileSystemCollider; };
namespace TurtleBrains::Math::Unstable { class BoundingVolume; };
 
namespace TurtleBrains::Game
{
    class Entity; //Forward declare for MoveEntity method.
 
    typedef tbCore::uint16 TileIndex;
 
    extern const TileIndex kInvalidTileIndex;
 
    typedef tbCore::uint16 TileLocation;
 
    extern const TileLocation kInvalidTileLocation; 
 
    typedef tbCore::uint8 TileSetIndex; 
 
    extern const TileSetIndex kInvalidTileSetIndex; 
 
    struct AboutTile
    {
        TileLocation mRow; 
        TileLocation mColumn; 
        TileIndex mTileIndex; 
        String mTileSetName;  
        String mLayerName;  
 
        float mCenterX; 
        float mCenterY; 
        float mTop; 
        float mLeft; 
        float mWidth; 
        float mHeight; 
        tbCore::DynamicStructure mPropertyValue; 
    };
 
    typedef std::vector<AboutTile> AboutTileContainer; 
 
    class TileSystem : public tbGraphics::Graphic, public tbCore::Noncopyable
    {
    public:
 
        TileSystem(void);
 
        virtual ~TileSystem(void);
 
        void ClearMap(void);
 
        String GetMapPropertyAsString(const String& propertyName) const;
 
        int GetMapPropertyAsInteger(const String& propertyName) const;
 
        bool GetMapPropertyAsBoolean(const String& propertyName) const;
 
        void SetPropertiesForMap(const tbCore::DynamicStructure& mapProperties);
 
        void AddTileSet(const String& tilesetName, const tbGraphics::SpriteMap& spriteMap,
            const tbCore::DynamicStructure& tileSetProperties = tbCore::DynamicStructure::kNullValue);
 
//          void SetFlagsForTile(const String& tileSetName, const TileIndex& tileIndex, const TileFlags& tileFlags);
 
        AboutTileContainer FindTilesWithProperty(const String& tileProperty, bool onlyVisibleLayers = false) const;
 
        AboutTileContainer FindTilesWithPropertyEquals(const String& tileProperty, bool propertyValue, bool onlyVisibleLayers = false) const;
 
        AboutTileContainer FindTilesWithPropertyEquals(const String& tileProperty, int propertyValue, bool onlyVisibleLayers = false) const;
 
        AboutTileContainer FindTilesWithPropertyEquals(const String& tileProperty, const String& propertyValue, bool onlyVisibleLayers = false) const;
 
        void SetPropertiesForTile(const String& tileSetName, const TileIndex& tileIndex, const tbCore::DynamicStructure& tileProperties);
 
        String GetTilePropertyAsString(const String& tileSetName, const TileIndex& tileIndex, const String& propertyName) const;
 
        int GetTilePropertyAsInteger(const String& tileSetName, const TileIndex& tileIndex, const String& propertyName) const;
 
        bool GetTilePropertyAsBoolean(const String& tileSetName, const TileIndex& tileIndex, const String& propertyName) const;
 
        void SetTileProperty(const String& tileSetName, const TileIndex& tileIndex,
            const String& propertyName, const String& propertyValue);
 
        void SetTileProperty(const String& tileSetName, const TileIndex& tileIndex,
            const String& propertyName, const int propertyValue);
 
        void SetTileProperty(const String& tileSetName, const TileIndex& tileIndex,
            const String& propertyName, const bool propertyValue);
 
        void AddTileLayer(const String& tileLayerName, const std::vector<TileIndex>& tileData,
            const String& tileSetName, const TileLocation& columnCount, const TileLocation& rowCount);
 
        void AddTileLayer(const String& tileLayerName, const std::vector<TileIndex>& tileData,
                                            const std::vector<TileSetIndex>& tileSetData, const TileLocation& columnCount, const TileLocation& rowCount);
 
        void SetLayerVisible(const String& tileLayerName, const bool isVisible);
 
        void SetTile(const String& tileLayerName, const TileLocation& tileColumn, const TileLocation& tileRow,
            const TileIndex& toTileIndex, const TileSetIndex& toTileSetIndex = kInvalidTileSetIndex);
 
        //
        //
        //
        //bool Move(const tbGame::Entity& entity, const tbMath::Vector2& from, tbMath::Vector2& to);
        //bool Move(const tbMath::Unstable::BoundingVolume& boundingVolume, const tbMath::Vector2& centerFrom, tbMath::Vector2& centerTo)
 
        bool MoveEntity(const tbMath::Vector2& currentPosition, tbMath::Vector2& finalPosition,
            const TurtleBrains::Math::Unstable::BoundingVolume& boundingVolume) const;
 
        bool MoveEntity(Entity& entity, const tbMath::Vector2& fromOldPosition, const tbMath::Vector2& toNewPosition) const;
 
        bool IsPointInSolid(const tbMath::Vector2& pointPosition) const;
 
        void UpdateColliderInformation(void);
 
//          TileLocation PixelSpaceToColumn(const float locationX) const;
//          TileLocation PixelSpaceToRow(const float locationY) const;
//          float ColumnToPixelSpace(const TileLocation& column) const;
//          float RowToPixelSpace(const TileLocation& row) const;
 
    protected:
 
        virtual void OnRender(void) const override;
 
    private:
        const tbCore::DynamicStructure& GetTileProperties(const String& tileSetName, const TileIndex& tileIndex) const;
        tbCore::DynamicStructure& GetTileProperties(const String& tileSetName, const TileIndex& tileIndex);
 
        struct TileLayer
        {
            tbMath::Vector2 mPosition;
            TileLocation mTileColumns;
            TileLocation mTileRows;
            typedef std::vector<TileIndex> TileContainer;
            TileContainer mTileData; //(TileIndex)-1 = no tile, 0 based on the TileSetData it lies upon.
            typedef std::vector<TileSetIndex> TileSetContainer;
            TileSetContainer mTileSetData; //Will be size 1 for a single Tileset, index into ordered names. Not yet implemented ...
 
            bool mIsVisible;
        };
 
        struct TileSet
        {
            TileSet(const tbGraphics::SpriteMap& spriteMap);
 
            tbGraphics::SpriteMap mSpriteMap;
            //TileIndex mStartTileID; //May be unneeded.
            //TileIndex mFinalTileID; //May be unneeded.
 
            //Stored as the index of the tile in this tile set, so 0 would be top-left most tile in SpriteMap.
//              typedef std::map<tbCore::uint16, std::pair<TileFlags, tbCore::DynamicStructure> > TilePropertyTable;
            typedef std::map<tbCore::uint16, tbCore::DynamicStructure> TilePropertyTable;
            TilePropertyTable mTileProperties;
            tbCore::DynamicStructure mTileSetProperties;
        };
 
        typedef std::vector<String> NameContainer;
        typedef std::map<String, TileLayer> TileLayerTable;
        TileLayerTable mTileLayers;
        NameContainer mOrderedLayerNames;
        NameContainer mOrderedTileSetNames;
 
        typedef std::map<String, TileSet> TileSetTable;
        TileSetTable mTileSets;
        tbCore::DynamicStructure mMapProperties;
 
        typedef std::map<String, TurtleBrains::Graphics::Implementation::TileSystemRenderer*> LayerRendererTable;
        mutable LayerRendererTable mLayerRenderers;
 
        TurtleBrains::Game::Unstable::TileSystemCollider* mCollider;
    };
 
}; /* namespace TurtleBrains::Game */
 
namespace tbGame = TurtleBrains::Game;
 
#endif /* TurtleBrains_TileSystem_hpp */