Tmx.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 Julien Bernard
 *
 * 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 GF_TMX_H
#define GF_TMX_H

#include <cstdint>

#include <map>
#include <memory>
#include <string>
#include <vector>

#include "Flags.h"
#include "Flip.h"
#include "Id.h"
#include "Path.h"
#include "Portability.h"
#include "Rect.h"
#include "Stagger.h"
#include "Time.h"
#include "Vector.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  enum class TmxOrientation {
    Unknown,    
    Orthogonal, 
    Isometric,  
    Staggered,  
    Hexagonal,  
  };

  enum class TmxRenderOrder {
    RightDown, 
    RightUp,   
    LeftDown,  
    LeftUp,    
  };

  class GF_API TmxProperties {
  public:
    TmxProperties() = default;

    TmxProperties(TmxProperties&&) = default;

    TmxProperties& operator=(TmxProperties&&) = default;

    void addStringProperty(std::string name, std::string value);

    void addIntProperty(std::string name, int value);

    void addFloatProperty(std::string name, double value);

    void addBoolProperty(std::string name, bool value);

    void addColorProperty(std::string name, Color4u value);

    void addFileProperty(std::string name, Path value);

    std::string getStringProperty(const std::string& name, const std::string& def) const;

    int getIntProperty(const std::string& name, int def) const;

    double getFloatProperty(const std::string& name, double def) const;

    bool getBoolProperty(const std::string& name, bool def) const;

    Color4u getColorProperty(const std::string& name, const Color4u& def) const;

    Path getFileProperty(const std::string& name, const Path& def) const;

  private:
    std::map<std::string, std::string> m_stringProps;
    std::map<std::string, int> m_intProps;
    std::map<std::string, double> m_floatProps;
    std::map<std::string, bool> m_boolProps;
    std::map<std::string, Color4u> m_colorProps;
    std::map<std::string, Path> m_fileProps;
  };

  struct TmxLayers;

  struct TmxTileLayer;
  struct TmxObjectLayer;
  struct TmxImageLayer;
  struct TmxGroupLayer;

  class GF_API TmxVisitor {
  public:
    virtual ~TmxVisitor();

    virtual void visitTileLayer(const TmxLayers& map, const TmxTileLayer& layer);

    virtual void visitObjectLayer(const TmxLayers& map, const TmxObjectLayer& layer);

    virtual void visitImageLayer(const TmxLayers& map, const TmxImageLayer& layer);

    virtual void visitGroupLayer(const TmxLayers& map, const TmxGroupLayer& layer);
  };

  struct GF_API TmxLayer {
    virtual ~TmxLayer();

    virtual void accept(const TmxLayers& map, TmxVisitor& visitor) const = 0;

    TmxProperties properties; 
    std::string name;         
    double opacity;           
    bool visible;             
    Vector2i offset;          
  };

  struct GF_API TmxCell {
    unsigned gid;             
    Flags<Flip> flip = None;  
  };

  struct GF_API TmxChunk {
    Vector2i position;
    Vector2i size;
    std::vector<TmxCell> cells;
  };

  struct GF_API TmxTileLayer : public TmxLayer {
    std::vector<TmxCell> cells; 
    std::vector<TmxChunk> chunks; 

    virtual void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };

  enum class TmxDrawOrder {
    TopDown,  
    Index,    
  };


  struct GF_API TmxObject {
    virtual ~TmxObject();

    enum Kind {
      Rectangle,  
      Ellipse,    
      Polyline,   
      Polygon,    
      Tile,       
      Text,       
      Point,      
    };

    Kind kind;  

    TmxProperties properties; 

    int id;             
    std::string name;   
    std::string type;   
    Vector2f position;  
    double rotation;    
    bool visible;       
  };

  struct GF_API TmxRectangle : public TmxObject {
    Vector2f size;  
  };

  struct GF_API TmxEllipse : public TmxObject {
    Vector2f size;  
  };

  struct GF_API TmxTileObject : public TmxObject {
    unsigned gid;
    Flags<Flip> flip;
  };

  struct GF_API TmxPolyline : public TmxObject {
    std::vector<Vector2f> points; 
  };

  struct GF_API TmxPolygon : public TmxObject {
    std::vector<Vector2f> points; 
  };

  struct GF_API TmxText : public TmxObject {
    std::string text;       

    std::string fontFamily; 
    unsigned sizeInPixels;  
    bool wrap;              
    Color4u color;          
    bool bold;              
    bool italic;            
    bool underline;         
    bool strikeout;         
    bool kerning;           

    enum class HAlign {
      Left,   
      Center, 
      Right,  
    };

    HAlign halign;  

    enum class VAlign {
      Top,    
      Center, 
      Bottom, 
    };

    VAlign valign;  
  };

  struct GF_API TmxPoint : public TmxObject {
  };

  struct GF_API TmxObjectLayer : public TmxLayer {
    Color4u color;  
    TmxDrawOrder drawOrder; 
    std::vector<std::unique_ptr<TmxObject>> objects;  

    virtual void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };

  struct GF_API TmxImage {
    std::string format;   
    Path source;          
    Color4u transparent;  
    Vector2u size;        
  };

  struct GF_API TmxImageLayer : public TmxLayer {
    std::unique_ptr<TmxImage> image;  

    virtual void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };


  struct GF_API TmxGroupLayer : public TmxLayer {
    std::vector<std::unique_ptr<TmxLayer>> layers;  

    virtual void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };

  struct GF_API TmxFrame {
    unsigned tileId;
    Time duration;
  };

  struct GF_API TmxAnimation {
    std::vector<TmxFrame> frames; 
  };

  struct GF_API TmxTerrain {
    TmxProperties properties; 
    std::string name;         
    unsigned tile;            
  };

  struct GF_API TmxTile {
    TmxProperties properties; 
    unsigned id;              
    std::string type;         
    std::array<unsigned, 4> terrain;  
    unsigned probability;     

    std::unique_ptr<TmxImage> image;  
    std::unique_ptr<TmxObjectLayer> objects;  
    std::unique_ptr<TmxAnimation> animation;  
  };

  struct GF_API TmxTileset {
    TmxProperties properties; 

    unsigned firstGid;        
    std::string name;         
    Vector2u tileSize;        
    unsigned spacing;         
    unsigned margin;          
    unsigned tileCount;       
    unsigned columnCount;     

    Vector2i offset;          

    std::unique_ptr<TmxImage> image;  
    std::vector<TmxTerrain> terrains; 
    std::vector<TmxTile> tiles;       

  public:
    const TmxTile *getTile(unsigned id) const noexcept;

    RectU getSubTexture(unsigned id, Vector2u size) const noexcept;

  };

  struct GF_API TmxLayers {
    TmxProperties properties;   

    std::string version;        
    std::string tiledVersion;   
    TmxOrientation orientation; 
    TmxRenderOrder renderOrder; 

    bool infinite;              
    Vector2u mapSize;           
    Vector2u tileSize;          

    unsigned hexSideLength;     
    StaggerAxis staggerAxis;    
    StaggerIndex staggerIndex;  

    Color4u backgroundColor;    

    unsigned nextObjectId;      

    std::vector<TmxTileset> tilesets; 
    std::vector<std::unique_ptr<TmxLayer>> layers;  

  public:

    const TmxTileset *getTileSetFromGID(unsigned gid) const noexcept;

    void visitLayers(TmxVisitor& visitor) const;

    bool loadFromFile(const Path& filename);

  };

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_TMX_H