Serialize, Deserialize

src/geo/edge.ts

@@ -2,6 +2,7 @@ class Edge {
 
     public start:Vertex;
     public end:Vertex;
+
     public edgeLink:Edge;
     public sector : Sector;
 

src/input.ts

@@ -131,10 +131,14 @@ function onMouseDown(e:MouseEvent) {
     if (Tool.activeTool.onMouseDown) {
         Tool.activeTool.onMouseDown(e);
     }
+
+    dirty = true;
 }
 
 function onMouseUp(e:MouseEvent) {
     if (Tool.activeTool.onMouseUp) {
         Tool.activeTool.onMouseUp(e);
     }
+
+    dirty = true;
 }

src/io/mapio.ts

@@ -0,0 +1,88 @@
+class MapIO {
+    static serialize(data:MapData):string {
+        let timer = Util.timer("serialize");
+        let output:string = "JZB01\n";
+        data.sectors.forEach(s => {
+            output += MapIO.serializeSector(s) + "\n";
+        });
+        // console.log(output);
+        timer.stop();
+        return output;
+    }
+
+    static serializeSector(sector:Sector):string {
+        let output:string = "s(";
+        for (let i = 0; i < sector.edges.length; i++) {
+            output += MapIO.serializeEdge(sector.edges[i]);
+        }
+        // sector.edges.forEach(e=> {
+        //     output+=MapIO.serializeEdge(e);
+        // });
+        return output;
+    }
+
+    static serializeEdge(edge:Edge):string {
+        return "e("+MapIO.serializeVertex(edge.start)+MapIO.serializeVertex(edge.end)+")";
+    }
+
+    static serializeVertex(vertex:Vertex):string {
+        return "v(" +vertex.x + "," + vertex.y + ")";
+    }
+
+
+    static unserialize(data:string):MapData {
+        let timer = Util.timer("unserialize");
+        let output:MapData = new MapData();
+        output.sectors.length = 0;
+        let lines:Array<string> = data.split('\n');
+        if (lines[0] != "JZB01") {
+            console.error("Incorrect version. Expected JZB01, got "+lines[0]);
+            return null;
+        }
+
+        for (let i = 1; i < lines.length; i++) {
+            output.sectors.push(MapIO.unserializeSector(lines[i]));
+        }
+
+        output.updateEdgePairs();
+        timer.stop();
+        return output;
+    }
+
+    static unserializeSector(data:string):Sector {
+
+        let output:Sector = new Sector();
+
+        // s(e(v(1,1)v(1,1))e(v(1,1)v(1,1))e(v(1,1)v(1,1)))
+
+        let edges:Array<string> = data.split('e');
+
+        // s( (v(1,1)v(1,1)) (v(1,1)v(1,1)) (v(1,1)v(1,1)))
+
+        for (let i = 1; i < edges.length; i++) {
+            output.edges.push(MapIO.unserializeEdge(edges[i]));
+        }
+
+        output.update();
+        return output;
+    }  
+
+    static unserializeEdge(data:string):Edge {
+        // (v(1,1)v(1,1))...
+
+        let vs:Array<string> = data.split('v');
+
+        // ( (1,1) (1,1))...
+        let e:Edge = new Edge(MapIO.unserializeVertex(vs[1]), MapIO.unserializeVertex(vs[2]));
+        // console.log(e);
+        return e;
+    }
+
+    static unserializeVertex(data:string):Vertex {
+        let output : Vertex = new Vertex(0, 0);
+        let commaIndex:number = data.indexOf(',');
+        output.x = Number(data.substr(1, commaIndex - 1));
+        output.y = Number(data.substr(commaIndex + 1, data.indexOf(')') - commaIndex - 1));
+        return output;
+    }
+}

src/mapdata.ts

@@ -176,6 +176,20 @@ class MapData {
 
     }
 
+    quicksaveData:string;
+
+    quicksave():void {
+        this.quicksaveData = MapIO.serialize(this);
+    }
+
+    quickload():void {
+        mapData = MapIO.unserialize(this.quicksaveData);
+    }
+
+    testload():void {
+        mapData = MapIO.unserialize(MapIO.serialize(this));
+    }
+
     // Keeping this in case there's something i can take from it
 
 //     createSplits(v:Vertex) {

src/tools/basetool.ts

@@ -65,20 +65,28 @@ class BaseTool implements ITool {
 
             } else if (Input.mode == InputMode.SECTOR && this.selectedSectors.length != 0) {
 
-                ContextMenu.create(
-                    new MenuItem(
-                        "Selected Sectors: " + this.selectedSectors.length,
-                        null
-                    )
-                );
+                // ContextMenu.create(
+                //     new MenuItem(
+                //         "Selected Sectors: " + this.selectedSectors.length,
+                //         null
+                //     )
+                // );
 
             } else {
                 // general menu!
 
                 ContextMenu.create(
                     new MenuItem(
-                        "Test",
-                        function() { console.log("clicked Test item") }
+                        "Testload",
+                        function() { mapData.testload(); }
+                    ),
+                    new MenuItem(
+                        "Quickload",
+                        function() { mapData.quickload(); }
+                    ),
+                    new MenuItem(
+                        "Quicksave",
+                        function() { mapData.quicksave(); }
                     )
                 );
 

src/util.ts

@@ -42,6 +42,17 @@ class Util {
         return Math.sqrt(Util.sqrDist(a, b));
     }
 
+    static timer(name:string) {
+        var start = new Date();
+        return {
+            stop: function() {
+                var end  = new Date();
+                var time = end.getTime() - start.getTime();
+                console.log('Timer:', name, 'finished in', time, 'ms');
+            }
+        }
+    };
+
     // From: https://stackoverflow.com/questions/849211/shortest-distance-between-a-point-and-a-line-segment
     static sqr(x) { return x * x }
     static dist2(v, w) { return Util.sqr(v.x - w.x) + Util.sqr(v.y - w.y) }