How to export infinite map to finite map?

[lowlighter]

I'm trying to make a custom export format with Javascript following this guide which would "crop" an infinite map (i.e. undefined tiles are removed).

The problem is that I can't find any way to get a layer's startx and starty (they're undefined) though it does exists on classic JSON export. Ideally, I'd also like to get a width and height which corresponds to endy-starty and endx-startx, but from TileLayer properties everything is non-revelant working with infinite map.

Any ideas on this?
Thanks a lot for the help 🙂

[bjorn]

I think you should be able to use TileLayer.region to get the region occupied by tiles. While the region doesn't currently provide much introspection, it does have a boundingRect property from which you can derive the values for startx, starty etc.

Are you writing a custom format entirely or would you actually like to just export as finite map in an existing format supported by Tiled? I think there's still a problem with doing that latter since you can't modify the map passed into the write function, so let me know if you need help with that.

[lowlighter]

Thanks for suggesting TileLayer.region, it seems to do exactly what I wanted 👍🏼

I'm writing a custom format entirely because I'd like to get a JSON with layered chunks instead of chunked layers.

I've got a working script though it's kind of slow (~15sec) but I guess it's because it's run in JS instead of C++
But maybe there was a native way to do it?

[bjorn]

But maybe there was a native way to do it?

To do what exactly? Do you have the script somewhere and do you know what is the slow part?

Of course you can also implement your export format in C++ entirely as a plugin. There's many plugins shipping with Tiled that you can look at for an example. If your format is generally useful I'd also consider shipping it with Tiled.

[lowlighter]

Wanted JSON format	Default JSON format
{ //... "chunks":[ { "layers":[ {"data":[]}, //.. ] }, //.. ] }	{ //... "layers":[ { "chunks":[ {"data":[]}, //.. ] }, //.. ] }

It's not a big deal of change, but it would make chunk rendering easier in some cases.
This way I can load a chunk and then render each layer for it.
Currently I must iterate over each layer and search for the chunk I want to render in each one.

I think it's normal it's kind of slow (though it's almost instant with Tiled default JSON exporter) since my map is currently 2000x2000x6 in size, but it may also come from the logic of my script I put below.

Script sample

//Note: this is just to show logic, actual script is a bit different
//Iterate through layers
for (let i = 0; i < map.layerCount; i++) {
  const layer = map.layerAt(i)
  if (layer.isTileLayer) {
    //Iterate through chunks
    const bounds = layer.region().boundingRect
    for (let X = Math.floor(bounds.left/CHUNK_SIZE); X <= Math.floor(bounds.right/CHUNK_SIZE); X++) {
      for (let Y = Math.floor(bounds.top/CHUNK_SIZE); Y <= Math.floor(bounds.bottom/CHUNK_SIZE); Y++) {
        //Iterate through cells
        for (let x = 0; x < CHUNK_SIZE; x++)
          for (let y = 0; y < CHUNK_SIZE; y++)
            data.push(layer.cellAt(X*CHUNK_SIZE+x, Y*CHUNK_SIZE+y).tileId)
      }
    }
  }
}

//Export
const file = new TextFile(fileName, TextFile.WriteOnly)
file.write(JSON.stringify(exported))
file.commit()

[bjorn]

Hmm, yeah I can't immediately see a good way to optimize this short of moving to a C++ plugin. The JS API is likely rather memory-allocation heavy so iterating a 2000x2000x6 map tile by tile could take its time (though 15 seconds is still rather more than I'd have expected).