leave holes in the wall

ddimport.js

@@ -12,8 +12,8 @@ Hooks.on("getSceneDirectoryEntryContext", (html, list) => {
 class DDImporter {
 
 
-static Prompt(scene) 
+  static Prompt(scene) 
-{
+  {
     if (canvas.scene._id != scene.data._id)
     {
       ui.notifications.error("Move to this scene to import");
@@ -35,10 +35,10 @@ static Prompt(scene)
       },
       default: "confirm"
     }).render(true);
-}
+  }
 
-static async DDImport(scene, file)
+  static async DDImport(scene, file)
-{
+  {
     let level = 0;
     if (file.world.levels[1])
     {
@@ -80,13 +80,10 @@ static async DDImport(scene, file)
       scene.update({"lights" : this.GetLights(file, level)});
     }
 
+  }
 
-
+  static GetWalls(file, level)
- 
+  {
-}
-
-static GetWalls(file, level)
-{
     let walls = [];
     let ddPortalList = [];
     for (let index in file.world.levels[level].walls)
@@ -97,54 +94,88 @@ static GetWalls(file, level)
         let wallSet = []
         let ddPointString = ddWalls.points;
         let points = ddPointString.substring(18, ddPointString.length-2).split(", ").map(a => Number(a))
+
         let offsetX = canvas.dimensions.paddingX;
         let offsetY = canvas.dimensions.paddingY;
         let ddScale = canvas.grid.size/256
 
-         /*   if (ddWalls.portals)
+
+        if (ddWalls.portals)
         {
           for(let i = 0; i < points.length-3; i+=2)
           {
+            for (let portal of ddWalls.portals){
+              console.log(portal);
+              let portalCenterPoint = portal.position.substring(8, portal.position.length-2).split(", ").map(a => Number(a))
+              let portalDirection = portal.direction.substring(8, portal.direction.length-2).split(", ").map(a => Number(a))
+              let portalPoint1 = [portalCenterPoint[0] + portal.radius*portalDirection[0], portalCenterPoint[1] + portal.radius*portalDirection[1]] 
+              let portalPoint2 = [portalCenterPoint[0] - portal.radius*portalDirection[0], portalCenterPoint[1] - portal.radius*portalDirection[1]] 
+              console.log(portalCenterPoint)
+              console.log(portalPoint1)
+              console.log(portalPoint2)
+              let wall = new Wall({
+                c : [point1[0], point1[1], point2[0], point2[1]],
+              });
+              wall.data.door = CONST.WALL_DOOR_TYPES.DOOR
+              walls.push(wall.data) 
               let point1 = [(points[i]*ddScale)+offsetX, (points[i+1]*ddScale)+offsetY]
               let point2 = [(points[i+2]*ddScale)+offsetX, (points[i+3]*ddScale)+offsetY]
-
+              let line = [point1,point2]
-                    let portal = ddWalls.portals[0];
+              if (this.pointIsOnLine(portalCenterPoint,line))
-                    let portalPoints = this.findDoorPoints(portal);
-                    if (this.pointIsOnLine([portalPoints[0], portalPoints[1]], point1.concat(point2)))
               {
-
+                console.log('yes');
-                    }
+                console.log(this.getNearerPoint(point1, [portalPoint1, portalPoint2]));
-                    else if (this.pointIsOnLine([portalPoints[2], portalPoints[3]], point1.concat(point2)))
+                console.log(this.getNearerPoint(point2, [portalPoint1, portalPoint2]));
-                    {
+                topoint1 = this.getNearerPoint(point1, [portalPoint1, portalPoint2]);
-                        
+                topoint2 = this.getNearerPoint(point2, [portalPoint1, portalPoint2]);
-                    }
-
                 let wall = new Wall({
-                        c : [(points[i]*ddScale)+offsetX, (points[i+1]*ddScale)+offsetY, (points[i+2]*ddScale)+offsetX, (points[i+3]*ddScale)+offsetY],
+                  c : [
+                    point1[0],
+                    point1[1],
+                    topoint1[0],
+                    topoint1[1],
+                  });            
+                wallSet.push(wall.data)
+                let wall = new Wall({
+                  c : [
+                    point2[0],
+                    point2[1],
+                    topoint2[0],
+                    topoint2[1],
                   });            
                 wallSet.push(wall.data)
               }
-
+              else{
-                if (wallSet.length % 2 != 0)
+                let wall = new Wall({
-                    wallSet.push(new Wall({
+                  c : [
-                        c: [wallSet[0].c[0], wallSet[0].c[1], wallSet[wallSet.length-1].c[2], wallSet[wallSet.length-1].c[3]]
+                    (points[i]*ddScale)+offsetX, 
-                    }).data)
+                    (points[i+1]*ddScale)+offsetY, 
-                    
+                    (points[i+2]*ddScale)+offsetX, 
-                walls = walls.concat(wallSet);
+                    (points[i+3]*ddScale)+offsetY],
-            }*/
+                });            
+                wallSet.push(wall.data)
+              }
+            }
+          }
+        }
+        else 
+        {
           for(let i = 0; i < points.length-3; i+=2)
           {
-                        
             let wall = new Wall({
-                        c : [(points[i]*ddScale)+offsetX, (points[i+1]*ddScale)+offsetY, (points[i+2]*ddScale)+offsetX, (points[i+3]*ddScale)+offsetY],
+              c : [
+                (points[i]*ddScale)+offsetX, 
+                (points[i+1]*ddScale)+offsetY, 
+                (points[i+2]*ddScale)+offsetX, 
+                (points[i+3]*ddScale)+offsetY],
             });            
             wallSet.push(wall.data)
           }
-
           if (wallSet.length % 2 != 0)
             wallSet.push(new Wall({
-                        c: [wallSet[0].c[0], wallSet[0].c[1], wallSet[wallSet.length-1].c[2], wallSet[wallSet.length-1].c[3]]
+              c: [wallSet[0].c[0], wallSet[0].c[1], wallSet[wallSet.length-1].c[2], wallSet[wallSet.length-1].c[3]], 
             }).data)
+        }
 
         walls = walls.concat(wallSet);
       }
@@ -170,18 +201,28 @@ static GetWalls(file, level)
 
 
     return walls
-}
+  }
 
-static pointIsOnLine(point, line)
+  static pointIsOnLine(point, line)
-{
+  {
-    slope = (line[1] - line[3])/(line[0] - line[2])
+    var slope = (line[0][1] - line[1][1])/(line[0][0] - line[1][0])
-    intercept = line[3] - slope * line[2]
+    var intercept = line[1][1] - slope * line[1][0]
 
     return (point[1] == (slope * point[0] + intercept))
-}
+  }
 
-static findDoorPoints(ddPortal)
+  static pointsDistance(point1, point2){
-{
+    return Math.sqrt(((point2[0] - point1[0])**2) + (point2[1] - point1[1])**2);
+  }
+
+  static getNearerPoint(from, points){
+    if (this.pointsDistance(from, points[0]) < this.pointsDistance(from, points[1]))
+      return points[0]
+    return points[1]
+  }
+
+  static findDoorPoints(ddPortal)
+  {
     let ddPortalString = ddPortals.position;
     let offsetX = canvas.dimensions.paddingX;
     let offsetY = canvas.dimensions.paddingY;
@@ -206,10 +247,10 @@ static findDoorPoints(ddPortal)
     point2[1]+=adjustY;
 
     return point1, point2
-}
+  }
 
-static GetLights(file, level)
+  static GetLights(file, level)
-{
+  {
     let lights = [];
     for (let index in file.world.levels[level].lights)
     {
@@ -237,7 +278,7 @@ static GetLights(file, level)
       }
     }
     return lights;
-}
+  }
 }
 
 Hooks.on("ready", ev => {

module.json

@@ -2,12 +2,19 @@
   "name": "dd-import",
   "title": "DungeonDraft Importer",
   "description": "Imports scene elements from Dungeon Draft map files",
-  "version": 0.3,
+  "version": "0.4.1",
-  "author": "Moo Man",
+  "authors": [
+    {
+      "name": "Moo Man"
+    },
+    {
+      "name": "m42e"
+    }
+  ],
   "scripts": ["./ddimport.js"],
   "styles": ["./styles.css"],
   "packs": [],
   "minimumCoreVersion": "0.5.1",
-  "manifest": "https://raw.githubusercontent.com/moo-man/FVTT-DD-Import/master/module.json",
+  "manifest": "https://raw.githubusercontent.com/m42e/FVTT-DD-Import/master/module.json",
-  "download": "https://github.com/moo-man/FVTT-DD-Import/archive/master.zip"
+  "download": "https://github.com/m42e/FVTT-DD-Import/archive/master.zip"
 }