tb_tile_system.h

#ifndef _TurtleBrains_TileSystem_h_
#define _TurtleBrains_TileSystem_h_

#include "../core/tb_string.h"
#include "../core/tb_dynamic_structure.h"
#include "../graphics/tb_graphic_list.h"
#include "../graphics/tb_sprite_map.h"
#include "../math/tb_vector.h"

#include <vector>
#include <map>

namespace tbImplementation
{
    class TileSystemRenderer;
};

namespace TurtleBrains { namespace Game { namespace Unstable { class TileSystemCollider; }; }; };
namespace TurtleBrains { namespace Math { namespace Unstable { class BoundingVolume; }; }; };

namespace TurtleBrains
{
    namespace Game
    {

        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; 
            tbCore::tbString mTileSetName;  
            tbCore::tbString 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);
            
            tbCore::tbString GetMapPropertyAsString(const tbCore::tbString& propertyName) const;

            int GetMapPropertyAsInteger(const tbCore::tbString& propertyName) const;

            bool GetMapPropertyAsBoolean(const tbCore::tbString& propertyName) const;

            void SetPropertiesForMap(const tbCore::DynamicStructure& mapProperties);

            void AddTileSet(const tbCore::tbString& tilesetName, const tbGraphics::SpriteMap& spriteMap,
                const tbCore::DynamicStructure& tileSetProperties = tbCore::DynamicStructure::kNullValue);

//          void SetFlagsForTile(const tbCore::tbString& tileSetName, const TileIndex& tileIndex, const TileFlags& tileFlags);

            AboutTileContainer FindTilesWithProperty(const tbCore::tbString& tileProperty, bool onlyVisibleLayers = false) const;

            AboutTileContainer FindTilesWithPropertyEquals(const tbCore::tbString& tileProperty, bool propertyValue, bool onlyVisibleLayers = false) const;

            AboutTileContainer FindTilesWithPropertyEquals(const tbCore::tbString& tileProperty, int propertyValue, bool onlyVisibleLayers = false) const;

            AboutTileContainer FindTilesWithPropertyEquals(const tbCore::tbString& tileProperty, const tbCore::tbString& propertyValue, bool onlyVisibleLayers = false) const;

            void SetPropertiesForTile(const tbCore::tbString& tileSetName, const TileIndex& tileIndex, const tbCore::DynamicStructure& tileProperties);

            tbCore::tbString GetTilePropertyAsString(const tbCore::tbString& tileSetName, const TileIndex& tileIndex, const tbCore::tbString& propertyName) const;

            int GetTilePropertyAsInteger(const tbCore::tbString& tileSetName, const TileIndex& tileIndex, const tbCore::tbString& propertyName) const;

            bool GetTilePropertyAsBoolean(const tbCore::tbString& tileSetName, const TileIndex& tileIndex, const tbCore::tbString& propertyName) const;

            void SetTileProperty(const tbCore::tbString& tileSetName, const TileIndex& tileIndex,
                const tbCore::tbString& propertyName, const tbCore::tbString& propertyValue);

            void SetTileProperty(const tbCore::tbString& tileSetName, const TileIndex& tileIndex,
                const tbCore::tbString& propertyName, const int propertyValue);

            void SetTileProperty(const tbCore::tbString& tileSetName, const TileIndex& tileIndex,
                const tbCore::tbString& propertyName, const bool propertyValue);

            void AddTileLayer(const tbCore::tbString& tileLayerName, const std::vector<TileIndex>& tileData,
                const tbCore::tbString& tileSetName, const TileLocation& columnCount, const TileLocation& rowCount);

            void AddTileLayer(const tbCore::tbString& tileLayerName, const std::vector<TileIndex>& tileData,
                                                const std::vector<TileSetIndex>& tileSetData, const TileLocation& columnCount, const TileLocation& rowCount);

            void SetLayerVisible(const tbCore::tbString& tileLayerName, const bool isVisible);

            void SetTile(const tbCore::tbString& 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 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 tbCore::tbString& tileSetName, const TileIndex& tileIndex) const;
            tbCore::DynamicStructure& GetTileProperties(const tbCore::tbString& 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<tbCore::tbString> NameContainer;
            typedef std::map<tbCore::tbString, TileLayer> TileLayerTable;
            TileLayerTable mTileLayers;
            NameContainer mOrderedLayerNames;
            NameContainer mOrderedTileSetNames;

            typedef std::map<tbCore::tbString, TileSet> TileSetTable;
            TileSetTable mTileSets;
            tbCore::DynamicStructure mMapProperties;

            typedef std::map<tbCore::tbString, tbImplementation::TileSystemRenderer*> LayerRendererTable;
            mutable LayerRendererTable mLayerRenderers;

            TurtleBrains::Game::Unstable::TileSystemCollider* mCollider;
        };

        namespace Extensions
        {
            bool LoadTileSystemFromTiled(TileSystem& tileSystem, const tbCore::tbString& tiledFilepath);
        };

    }; /* namespace Game */
}; /* namespace TurtleBrains */

namespace tbGame = TurtleBrains::Game;

#endif /* _TurtleBrains_TileSystem_h_ */