package tiled

Json_Map :: struct {
  backgroundcolor: string,
  class: string,
  compressionlevel: i32,
  width: i32,
  height: i32,
  infinite: bool,
  layers: []Json_Layer,
  nextlayerid: i32,
  nextobjectid: i32,
  orientation: string,
  parallaxoriginx: f64,
  parallaxoriginy: f64,
  properties: []Json_Property,
  renderorder: string,
  staggeraxis: string,
  staggerindex: string,
  tilewidth: i32,
  tileheight: i32,
  tilesets: []Json_Tile_Set,
}

Json_Layer :: struct {
  class: string,
  compression: string,
  data: union {
    []i32,
    string,
  },
  draworder: string,
  encoding: string,
  id: i32,
  image: string,
  image_width: i32,
  image_height: i32,
  layers: []Json_Layer,
  // locked: bool,
  name: string,
  objects: []Json_Object,
  offsetx: f64,
  offsety: f64,
  opacity: f32,
  parallaxx: f64,
  parallaxy: f64,
  properties: []Json_Property,
  repeatx: bool,
  repeaty: bool,
  tintcolor: string,
  transparentcolor: string,
  type: string,
  visible: bool,
  x: i32,
  y: i32,
  width: i32,
  height: i32,
}

Json_Object :: struct {
  ellipse: bool,
  gid: i32,
  width: f64,
  height: f64,
  id: i32,
  name: string,
  point: bool,
  polygon: []Json_Point,
  polyline: []Json_Point,
  properties: []Json_Property,
  rotation: f64,
  template: string,
  text: Maybe(struct {
    fontfamily: string,
    color: string,
    text: string,
    halign: string,
    valign: string,
    pixelsize: i32,
    wrap: bool,
    underline: bool,
    bold: bool,
    italic: bool,
    kerning: bool,
    strikeout: bool,
  }),
  type: string,
  visible: bool,
  x: f64,
  y: f64,
}

Json_Tile_Set :: struct {
  background_color: string,
  class: string,
  rows: i32,
  columns: i32,
  fillmode: string,
  firstgid: i32,
  grid: Maybe(Json_Grid),
  image: string,
  imagewidth: i32,
  imageheight: i32,
  margin: i32,
  name: string,
  objectalignment: string,
  properties: []Json_Property,
  source: string,
  spacing: i32,
  terrains: []Json_Terrain,
  tilecount: i32,
  tilewidth: i32,
  tileheight: i32,
  tileoffset: Json_Tile_Offset,
  tilerendersize: string,
  tiles: []Json_Tile,
  transformations: Json_Transformations,
  transparentcolor: string,
  type: string,
  wangsets: []Json_Wang_Set,
}

Json_Grid :: struct {
  width: i32,
  height: i32,
  orientation: string,
}

Json_Tile_Offset :: struct {
  x: i32,
  y: i32,
}

Json_Transformations :: struct {
  hflip: bool,
  vflip: bool,
  rotate: bool,
  preferuntransformed: bool,
}

Json_Tile :: struct {
  animation: []Json_Frame,
  id: i32,
  image: string,
  imagewidth: i32,
  imageheight: i32,
  x: i32,
  y: i32,
  width: i32,
  height: i32,
  objectgroup: Json_Layer,
  probability: f64,
  properties: []Json_Property,
  terrain: []i32,
  type: string,
}

Json_Frame :: struct {
  duration: i32, 
  tileid: i32,
}

Json_Terrain :: struct {
  name: string,
  properties: []Json_Property,
  tile: i32,
}

Json_Wang_Set :: struct {
  class: string,
  colors: []Json_Wang_Color,
  name: string,
  properties: []Json_Property,
  tile: i32,
  type: string,
  wangtiles: []Json_Wang_Tile,
}

Json_Wang_Color :: struct {
  class: string,
  color: string,
  name: string,
  probability: f64,
  properties: []Json_Property,
  tile: i32,
}

Json_Wang_Tile :: struct {
  tileid: i32,
  wangid: []u8,
}

Json_Object_Template :: struct {
  tileset: Maybe(Json_Tile_Set),
  object: Json_Object,
}

Json_Property :: struct {
  name: string,
  type: string,
  propertytype: string,
  value: any,
}

Json_Point :: struct {
  x: f64,
  y: f64,
}