Map.hpp

/*********************************************************************
Matt Marchant 2016
http://trederia.blogspot.com

tmxlite - Zlib license.

This software is provided 'as-is', without any express or
implied warranty. In no event will the authors be held
liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute
it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented;
you must not claim that you wrote the original software.
If you use this software in a product, an acknowledgment
in the product documentation would be appreciated but
is not required.

2. Altered source versions must be plainly marked as such,
and must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any
source distribution.
*********************************************************************/

#ifndef TMXLITE_MAP_HPP_
#define TMXLITE_MAP_HPP_

#include <tmxlite/Tileset.hpp>
#include <tmxlite/Layer.hpp>
#include <tmxlite/Property.hpp>
#include <tmxlite/Types.hpp>

#include <string>
#include <vector>

namespace tmx
{
    struct TMXLITE_EXPORT_API Version
    {
        //major/minor are apparently reserved by gcc            
        std::uint16_t upper;
        std::uint16_t lower;
        Version(std::uint16_t maj = 0, std::uint16_t min = 0)
            : upper(maj), lower(min) {}
    };
        
    enum class Orientation
    {
        Orthogonal,
        Isometric,
        Staggered,
        Hexagonal,
        None
    };

    enum class RenderOrder
    {
        RightDown,
        RightUp,
        LeftDown,
        LeftUp,
        None
    };

    enum class StaggerAxis
    {
        X, Y, None
    };

    enum class StaggerIndex
    {
        Even, Odd, None
    };

    class TMXLITE_EXPORT_API Map final
    {
    public:
            
        Map();
        ~Map() = default;
        Map(const Map&) = delete;
        Map& operator  = (const Map&) = delete;
        Map(Map&&) = default;
        Map& operator = (Map&&) = default;

        bool load(const std::string&);

        const Version& getVersion() const { return m_version; }
        Orientation getOrientation() const { return m_orientation; }
        RenderOrder getRenderOrder() const { return m_renderOrder; }
        const Vector2u& getTileCount() const { return m_tileCount; }
        const Vector2u& getTileSize() const { return m_tileSize; }
        FloatRect getBounds() const { return FloatRect(0.f, 0.f, static_cast<float>(m_tileCount.x * m_tileSize.x), static_cast<float>(m_tileCount.y * m_tileSize.y)); }
        float getHexSideLength() const { return m_hexSideLength; }
        StaggerAxis getStaggerAxis() const { return m_staggerAxis; }
        StaggerIndex getStaggerIndex() const { return m_staggerIndex; }
        const Colour& getBackgroundColour() const { return m_backgroundColour; }
        const std::vector<Tileset>& getTilesets() const { return m_tilesets; }
        const std::vector<Layer::Ptr>& getLayers() const { return m_layers; }
        const std::vector<Property>& getProperties() const { return m_properties; }


    private:
        Version m_version;
        Orientation m_orientation;
        RenderOrder m_renderOrder;

        Vector2u m_tileCount;
        Vector2u m_tileSize;

        float m_hexSideLength;
        StaggerAxis m_staggerAxis;
        StaggerIndex m_staggerIndex;

        Colour m_backgroundColour;

        std::string m_workingDirectory;

        std::vector<Tileset> m_tilesets;
        std::vector<Layer::Ptr> m_layers;
        std::vector<Property> m_properties;

        //always returns false so we can return this
        //on load failure
        bool reset();

        struct Key {};
    };
}
#endif //TMXLITE_MAP_HPP_