TmxMap.h

//-----------------------------------------------------------------------------
// TmxMap.h
//
// Copyright (c) 2010-2014, Tamir Atias
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL TAMIR ATIAS BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Tamir Atias
//-----------------------------------------------------------------------------
#pragma once

#include <vector>
#include <string>

#include "TmxPropertySet.h"

namespace Tmx
{
    class Layer;
    class TileLayer;
    class ImageLayer;
    class ObjectGroup;
    class GroupLayer;
    class Tileset;

    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    enum MapError
    {
        TMX_COULDNT_OPEN = 0x01,

        TMX_PARSING_ERROR = 0x02,

        TMX_INVALID_FILE_SIZE = 0x04
    };

    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    enum MapOrientation
    {
        TMX_MO_ORTHOGONAL = 0x01,

        TMX_MO_ISOMETRIC = 0x02,

        TMX_MO_STAGGERED = 0x03,

        TMX_MO_HEXAGONAL = 0x04
    };

    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    enum MapRenderOrder
    {
        TMX_RIGHT_DOWN = 0x01,
        TMX_RIGHT_UP = 0x02,
        TMX_LEFT_DOWN = 0x03,
        TMX_LEFT_UP= 0x03
    };

    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    enum MapStaggerAxis
    {
        TMX_SA_NONE = 0x00,  // if the map is not hexagonal
        TMX_SA_X = 0x01,
        TMX_SA_Y = 0x02
    };

    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    enum MapStaggerIndex
    {
        TMX_SI_NONE = 0x00,  // if the map is not hexagonal
        TMX_SI_EVEN = 0x01,
        TMX_SI_ODD = 0x02
    };

    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    class Map
    {
    private:
        // Prevent copy constructor.
        Map(const Map &_map);

    public:
        Map();
        ~Map();

        void ParseFile(const std::string &fileName);

        void ParseText(const std::string &text);

        const std::string &GetFilename() const { return file_name; }

        const std::string &GetFilepath() const { return file_path; }

        Tmx::Color GetBackgroundColor() const { return background_color; }

        double GetVersion() const { return version; }

        Tmx::MapOrientation GetOrientation() const { return orientation; }

        Tmx::MapRenderOrder GetRenderOrder() const { return render_order; }

        Tmx::MapStaggerAxis GetStaggerAxis() const { return stagger_axis; }

        Tmx::MapStaggerIndex GetStaggerIndex() const { return stagger_index; }

        int GetWidth() const { return width; }

        int GetHeight() const { return height; }

        int GetTileWidth() const { return tile_width; }

        int GetTileHeight() const { return tile_height; }

        int GetNextObjectId() const { return next_object_id; }

        int GetHexsideLength() const { return hexside_length; }

        const Tmx::Layer *GetLayer(int index) const { return layers.at(index); }

        int GetNumLayers() const { return layers.size(); }

        const std::vector< Tmx::Layer* > &GetLayers() const { return layers; }

        const Tmx::TileLayer *GetTileLayer(int index) const { return tile_layers.at(index); }

        int GetNumTileLayers() const { return tile_layers.size(); }

        const std::vector< Tmx::TileLayer* > &GetTileLayers() const { return tile_layers; }

        const Tmx::ObjectGroup *GetObjectGroup(int index) const { return object_groups.at(index); }

        int GetNumObjectGroups() const { return object_groups.size(); }

        const std::vector< Tmx::ObjectGroup* > &GetObjectGroups() const { return object_groups; }

        const Tmx::ImageLayer *GetImageLayer(int index) const { return image_layers.at(index); }

        int GetNumImageLayers() const { return image_layers.size(); }

        const std::vector< Tmx::ImageLayer* > &GetImageLayers() const { return image_layers; }

        const Tmx::GroupLayer *GetGroupLayer(int index) const { return group_layers.at(index); }
        int GetNumGroupLayers() const { return group_layers.size(); }
        const std::vector< Tmx::GroupLayer* > &GetGroupLayers() const { return group_layers; }

        int FindTilesetIndex(int gid) const;

        const Tmx::Tileset *FindTileset(int gid) const;

        const Tmx::Tileset *GetTileset(int index) const { return tilesets.at(index); }

        int GetNumTilesets() const { return tilesets.size(); }

        const std::vector< Tmx::Tileset* > &GetTilesets() const { return tilesets; }

        bool HasError() const { return has_error; }

        const std::string &GetErrorText() const { return error_text; }

        unsigned char GetErrorCode() const { return error_code; }

        const Tmx::PropertySet &GetProperties() const { return properties; }

    private:
        std::string file_name;
        std::string file_path;

        Tmx::Color background_color;

        double version;
        Tmx::MapOrientation orientation;
        Tmx::MapRenderOrder render_order;
        Tmx::MapStaggerAxis stagger_axis;
        Tmx::MapStaggerIndex stagger_index;

        int width;
        int height;
        int tile_width;
        int tile_height;
        int next_object_id;
        int hexside_length;

        std::vector< Tmx::Layer* > layers;
        std::vector< Tmx::TileLayer* > tile_layers;
        std::vector< Tmx::ImageLayer* > image_layers;
        std::vector< Tmx::ObjectGroup* > object_groups;
        std::vector< Tmx::GroupLayer* > group_layers;
        std::vector< Tmx::Tileset* > tilesets;

        bool has_error;
        unsigned char error_code;
        std::string error_text;

        Tmx::PropertySet properties;

        // Parse a 'map' node.
        void Parse(tinyxml2::XMLNode *mapNode);
    };
}