Merge pull request #14 from devharts/object-layers

Object layers

Author: MikeMnD

export_to_godot_tilemap.js

@@ -10,6 +10,7 @@ class GodotTilemapExporter {
         this.tileOffset = 65536;
         this.tileMapsString = "";
         this.tilesetsString = "";
+        this.extResourceId = 0;
 
         /**
          * Tiled doesn't have tileset ID so we create a map
@@ -48,11 +49,11 @@ class GodotTilemapExporter {
         for (let index = 0; index < this.map.tilesets.length; ++index) {
             // noinspection JSUnresolvedVariable
             const tileset = this.map.tilesets[index];
-            const tilesetID = index + 1;
-            this.tilesetsIndex.set(tileset.name, tilesetID);
+            this.extResourceId = index + 1;
+            this.tilesetsIndex.set(tileset.name, this.extResourceId);
             // noinspection JSUnresolvedVariable
             let tilesetPath = tileset.asset.fileName.replace(this.projectRoot, "").replace('.tsx', '.tres');
-            this.tilesetsString += this.getTilesetResourceTemplate(tilesetID, tilesetPath);
+            this.tilesetsString += this.getTilesetResourceTemplate(this.extResourceId, tilesetPath, "TileSet");
         }
 
     }
@@ -78,6 +79,39 @@ class GodotTilemapExporter {
                         this.tileMapsString += this.getTileMapTemplate(tileMapName, ld.tilesetID, ld.poolIntArrayString, ld.parent, layer.map.tileWidth, layer.map.tileHeight);
                     }
                 }
+            } else if (layer.isObjectLayer) {
+                this.tileMapsString += `
+
+[node name="${layer.name}" type="Node2D" parent="."]`;
+                for (const object of layer.objects) {
+                    if (object.tile) {
+                        let tilesetsIndexKey = object.tile.tileset.name + "_Image";
+                        let textureResourceId = 0;
+                        if (!this.tilesetsIndex.get(tilesetsIndexKey)) {
+                            this.extResourceId = this.extResourceId + 1;
+                            textureResourceId = this.extResourceId;
+                            this.tilesetsIndex.set(tilesetsIndexKey, this.extResourceId);
+                            let tilesetPath = object.tile.tileset.image.replace(this.projectRoot, "");
+                            this.tilesetsString += this.getTilesetResourceTemplate(this.extResourceId, tilesetPath, "Texture");
+                        } else {
+                            textureResourceId = this.tilesetsIndex.get(tilesetsIndexKey);
+                        }
+
+                        let tileOffset = this.getTileOffset(object.tile.tileset, object.tile.id);
+
+                        // Account for anchoring in Godot (corner vs. middle):
+                        let objectPositionX = object.x + (object.tile.width / 2);
+                        let objectPositionY = object.y - (object.tile.height / 2);
+
+                        this.tileMapsString += `
+ 
+[node name="${object.name}" type="Sprite" parent="${layer.name}"]
+position = Vector2( ${objectPositionX}, ${objectPositionY} )
+texture = ExtResource( ${textureResourceId} )
+region_enabled = true
+region_rect = Rect2( ${tileOffset.x}, ${tileOffset.y}, ${object.tile.width}, ${object.tile.height} )`;
+                    }
+                }
             }
         }
     }
@@ -305,6 +339,26 @@ class GodotTilemapExporter {
         return Math.floor(calculatedColumnCount);
     }
 
+    /**
+     * Calculate the X and Y offset (in pixels) for the specified tile
+     * ID within the specified tileset image.
+     * 
+     * @param {Tileset} tileset - The full Tileset object
+     * @param {int} tileId - Id for the tile to extract offset for
+     * @returns {object} - An object with pixel offset in the format {x: int, y: int}
+     */
+    getTileOffset(tileset, tileId) {
+        let columnCount = this.getTilesetColumns(tileset);
+        let row = Math.floor(tileId / columnCount);
+        let col = tileId % columnCount;
+        let xOffset = tileset.margin + (tileset.tileSpacing * col);
+        let yOffset = tileset.margin + (tileset.tileSpacing * row);
+        return {
+            x: (col * tileset.tileWidth) + xOffset,
+            y: (row * tileset.tileHeight) + yOffset
+        };
+    }
+
     /**
      * Template for a scene
      * @returns {string}
@@ -322,8 +376,10 @@ ${this.tileMapsString}
      * Template for a tileset resource
      * @returns {string}
      */
-    getTilesetResourceTemplate(id, path) {
-        return `[ext_resource path="res://${path}" type="TileSet" id=${id}]
+    getTilesetResourceTemplate(id, path, type) {
+        // Strip leading slashes to prevent invalid triple slashes in Godot res:// path:
+        path = path.replace(/^\/+/, '');
+        return `[ext_resource path="res://${path}" type="${type}" id=${id}]
 `;
     }
 

export_to_godot_tileset.js

@@ -8,6 +8,8 @@ class GodotTilesetExporter {
         // noinspection JSUnresolvedFunction
         this.projectRoot = getResPath(this.tileset.property("projectRoot"), fileName);
         this.spriteImagePath = this.tileset.image.replace(this.projectRoot, "");
+        // Strip leading slashes to prevent invalid triple slashes in Godot res:// path:
+        this.spriteImagePath = this.spriteImagePath.replace(/^\/+/, '');
         this.shapesResources = "";
         this.shapes = "";
         this.firstShapeID = "0";
@@ -30,7 +32,7 @@ class GodotTilesetExporter {
 
     iterateTiles() {
 
-        let autotileCoordinates = {x: 0, y: 0};
+        let autotileCoordinates = { x: 0, y: 0 };
 
         // noinspection JSUnresolvedVariable
         let tiles = this.tileset.tiles;
@@ -166,10 +168,10 @@ points = PoolVector2Array( ${coordinateString} )
     }
 
     getCollisionShapeRectangle(id, object) {
-        const topLeft = {x: object.x, y: object.y};
-        const topRight = {x: (object.x + object.width), y: object.y};
-        const bottomRight = {x: (object.x + object.width), y: (object.y + object.height)};
-        const bottomLeft = {x: object.x, y: (object.y + object.height)};
+        const topLeft = { x: object.x, y: object.y };
+        const topRight = { x: (object.x + object.width), y: object.y };
+        const bottomRight = { x: (object.x + object.width), y: (object.y + object.height) };
+        const bottomLeft = { x: object.x, y: (object.y + object.height) };
 
         return `[sub_resource type="ConvexPolygonShape2D" id=${id}]
 points = PoolVector2Array( ${topLeft.x}, ${topLeft.y}, ${topRight.x}, ${topRight.y}, ${bottomRight.x}, ${bottomRight.y}, ${bottomLeft.x}, ${bottomLeft.y} )

utils.js

@@ -3,14 +3,14 @@ var Flatted=function(a,l){return{parse:function(n,t){var e=JSON.parse(n,i).map(f
 
 var log = console.log.bind(console);
 
-function logf(data){
-    console.log(Flatted.stringify(data));
+function logf(data) {
+  console.log(Flatted.stringify(data));
 }
-function logk(data){
-    console.log(Object.keys(data));
+function logk(data) {
+  console.log(Object.keys(data));
 }
 
-function getResPath (projectRoot, outputPath) {
+function getResPath(projectRoot, outputPath) {
   const p = outputPath.split('/').slice(0, -1)
   // check for projectRoot
   // If projectRoot is not set, set it to current file's location