module Codec.Tiled.Map
  ( Map(..)
  , empty
  , pattern ORTHOGONAL
  , pattern ISOMETRIC
  , pattern STAGGERED
  , pattern HEXAGONAL
  ) where

import Codec.Tiled.Aeson (FromJSON(..), ToJSON(..), genericParseJSON, genericToJSON)
import Data.Text (Text)
import Data.Vector (Vector)
import GHC.Generics (Generic)

import Codec.Tiled.Layer (Layer)
import Codec.Tiled.Property (Property)
import Codec.Tiled.Tileset.Ref (TilesetRef)

data Map = Map
  { Map -> Maybe Text
backgroundColor  :: Maybe Text              -- ^ Hex-formatted color (#RRGGBB or #AARRGGBB) (optional)
  , Map -> Maybe Int
compressionLevel :: Maybe Int               -- ^ The compression level to use for tile layer data (defaults to -1, which means to use the algorithm default)
  , Map -> Int
height           :: Int                     -- ^ Number of tile rows
  , Map -> Maybe Int
hexSideLength    :: Maybe Int               -- ^ Length of the side of a hex tile in pixels (hexagonal maps only)
  , Map -> Maybe Bool
infinite         :: Maybe Bool              -- ^ Whether the map has infinite dimensions
  , Map -> Vector Layer
layers           :: Vector Layer            -- ^ Array of Layers
  , Map -> Int
nextLayerId      :: Int                     -- ^ Auto-increments for each layer
  , Map -> Int
nextObjectId     :: Int                     -- ^ Auto-increments for each placed object
  , Map -> Text
orientation      :: Text                    -- ^ @orthogonal@, @isometric@, @staggered@ or @hexagonal@
  , Map -> Maybe Double
parallaxOriginX  :: Maybe Double            -- ^ X coordinate of the parallax origin in pixels (default: 0)
  , Map -> Maybe Double
parallaxOriginY  :: Maybe Double            -- ^ Y coordinate of the parallax origin in pixels (default: 0)
  , Map -> Maybe (Vector Property)
properties       :: Maybe (Vector Property) -- ^ Array of Properties
  , Map -> Maybe Text
renderOrder      :: Maybe Text              -- ^ @right-down@ (the default), @right-up@, @left-down@ or @left-up@ (currently only supported for orthogonal maps)
  , Map -> Maybe Text
staggerAxis      :: Maybe Text              -- ^ x or y (staggered / hexagonal maps only)
  , Map -> Maybe Text
staggerIndex     :: Maybe Text              -- ^ odd or even (staggered / hexagonal maps only)
  , Map -> Text
tiledVersion     :: Text                    -- ^ The Tiled version used to save the file
  , Map -> Int
tileHeight       :: Int                     -- ^ Map grid height
  , Map -> Vector TilesetRef
tilesets         :: Vector TilesetRef       -- ^ Array of Tilesets
  , Map -> Int
tileWidth        :: Int                     -- ^ Map grid width
  , Map -> Text
type_            :: Text                    -- ^ @map@
  , Map -> Text
version          :: Text                    -- ^ The JSON format version
  , Map -> Int
width            :: Int                     -- ^ Number of tile columns
  }
  deriving (Map -> Map -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Map -> Map -> Bool
$c/= :: Map -> Map -> Bool
== :: Map -> Map -> Bool
$c== :: Map -> Map -> Bool
Eq, Int -> Map -> ShowS
[Map] -> ShowS
Map -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Map] -> ShowS
$cshowList :: [Map] -> ShowS
show :: Map -> String
$cshow :: Map -> String
showsPrec :: Int -> Map -> ShowS
$cshowsPrec :: Int -> Map -> ShowS
Show, forall x. Rep Map x -> Map
forall x. Map -> Rep Map x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Map x -> Map
$cfrom :: forall x. Map -> Rep Map x
Generic)

instance FromJSON Map where
  parseJSON :: Value -> Parser Map
parseJSON = forall a. (Generic a, GFromJSON Zero (Rep a)) => Value -> Parser a
genericParseJSON

instance ToJSON Map where
  toJSON :: Map -> Value
toJSON = forall a. (Generic a, GToJSON' Value Zero (Rep a)) => a -> Value
genericToJSON

empty :: Map
empty :: Map
empty = Map
    { backgroundColor :: Maybe Text
backgroundColor  = forall a. Maybe a
Nothing
    , compressionLevel :: Maybe Int
compressionLevel = forall a. Maybe a
Nothing
    , height :: Int
height           = Int
0
    , hexSideLength :: Maybe Int
hexSideLength    = forall a. Maybe a
Nothing
    , infinite :: Maybe Bool
infinite         = forall a. Maybe a
Nothing
    , layers :: Vector Layer
layers           = forall a. Monoid a => a
mempty
    , nextLayerId :: Int
nextLayerId      = Int
0
    , nextObjectId :: Int
nextObjectId     = Int
0
    , orientation :: Text
orientation      = Text
""
    , parallaxOriginX :: Maybe Double
parallaxOriginX  = forall a. Maybe a
Nothing
    , parallaxOriginY :: Maybe Double
parallaxOriginY  = forall a. Maybe a
Nothing
    , properties :: Maybe (Vector Property)
properties       = forall a. Maybe a
Nothing
    , renderOrder :: Maybe Text
renderOrder      = forall a. Maybe a
Nothing
    , staggerAxis :: Maybe Text
staggerAxis      = forall a. Maybe a
Nothing
    , staggerIndex :: Maybe Text
staggerIndex     = forall a. Maybe a
Nothing
    , tiledVersion :: Text
tiledVersion     = Text
""
    , tileHeight :: Int
tileHeight       = Int
0
    , tilesets :: Vector TilesetRef
tilesets         = forall a. Monoid a => a
mempty
    , tileWidth :: Int
tileWidth        = Int
0
    , type_ :: Text
type_            = Text
"map"
    , version :: Text
version          = Text
""
    , width :: Int
width            = Int
0
    }

pattern ORTHOGONAL :: Text
pattern $bORTHOGONAL :: Text
$mORTHOGONAL :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
ORTHOGONAL = "orthogonal"

pattern ISOMETRIC :: Text
pattern $bISOMETRIC :: Text
$mISOMETRIC :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
ISOMETRIC = "isometric"

pattern STAGGERED :: Text
pattern $bSTAGGERED :: Text
$mSTAGGERED :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
STAGGERED = "staggered"

pattern HEXAGONAL :: Text
pattern $bHEXAGONAL :: Text
$mHEXAGONAL :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
HEXAGONAL = "hexagonal"