public void LoadLevel(LevelSave levelSave)
        {
            Room room = OrbIt.game.room;
            //room.worldWidth = levelSave.levelWidth;
            //room.worldHeight = levelSave.levelHeight;
            v = new Vector2(levelSave.levelWidth, levelSave.levelHeight);
            room.resize(v, true);
            room.waitTimeCounter = 0;
            if (!levelSaves.ContainsKey(levelSave))
            {
                ObservableHashSet<Node> nodes = new ObservableHashSet<Node>();
                for (int i = 0; i < levelSave.polygonVertices.Count; i++)
                {
                    Node newNode = new Node(sidebar.ui.game.room, ShapeType.Polygon);
                    Polygon poly = (Polygon)newNode.body.shape;
                    //poly.SetCenterOfMass(vertices);
                    float[] list = levelSave.polygonVertices[i];
                    for (int j = 0; j < list.Length / 2; j++)
                    {
                        poly.vertices[j] = new Vector2(list[j * 2], list[(j * 2) + 1]);
                    }
                    poly.vertexCount = list.Length / 2;
                    newNode.body.pos = new Vector2(levelSave.polygonPositions[i][0], levelSave.polygonPositions[i][1]);
                    newNode.body.SetStatic();
                    newNode.body.orient = 0;
                    newNode.movement.mode = movemode.free;
                    newNode.body.restitution = 1f;
                    newNode.body.texture = textures.rock1;
                    newNode.meta.maxHealth.enabled = false;
                    poly.ComputeNormals();
                    poly.CalibrateTexture();
                    nodes.Add(newNode);
                }
                levelSaves[levelSave] = nodes;
            }
            ObservableHashSet<Node> incomingNodes = levelSaves[levelSave];
            foreach (Node n in wallGroup.entities.ToList())
            {
                wallGroup.DiscludeEntity(n);
            }

            foreach (Node n in incomingNodes)
            {
                wallGroup.IncludeEntity(n);
            }
        }
        public static void SaveLevel(Group group, int levelWidth, int levelHeight, string name)
        {
            if (name.Equals("")) return;
            name = name.Trim();
            //string filename = "Presets//Nodes//" + name + ".xml";
            string filename = Assets.levelsFilepath + "/" + name + ".xml";
            Action completeSave = delegate
            {
                LevelSave levelSave = new LevelSave(group, levelWidth, levelHeight, name);
                OrbIt.game.serializer = new Polenter.Serialization.SharpSerializer();
                OrbIt.game.serializer.Serialize(levelSave, filename);
                //Assets.NodePresets.Add(serializenode);
            };

            if (File.Exists(filename))
            { //we must be overwriting, therefore don't update the live presetList
                PopUp.Prompt("OverWrite?", "O/W?", delegate(bool c, object a) { if (c) { completeSave(); PopUp.Toast("Level '" + name + "' was overwritten."); } return true; });
            }
            else { PopUp.Toast("Level Saved as " + name); completeSave(); }
        }
        public static void LoadLevelSpider(LevelSave levelSave)
        {
            Room room = OrbIt.game.room;
            //room.worldWidth = levelSave.levelWidth;
            //room.worldHeight = levelSave.levelHeight;
            Vector2 v = new Vector2(levelSave.levelWidth, levelSave.levelHeight);
            room.resize(v, true);
            room.waitTimeCounter = 0;
            ObservableHashSet<Node> nodes = new ObservableHashSet<Node>();
            for (int i = 0; i < levelSave.polygonVertices.Count; i++)
            {
                Node newNode = new Node(OrbIt.ui.game.room, ShapeType.Polygon);
                Polygon poly = (Polygon)newNode.body.shape;
                //poly.SetCenterOfMass(vertices);
                float[] list = levelSave.polygonVertices[i];
                for (int j = 0; j < list.Length / 2; j++)
                {
                    poly.vertices[j] = new Vector2(list[j * 2], list[(j * 2) + 1]);
                }
                poly.vertexCount = list.Length / 2;
                newNode.body.pos = new Vector2(levelSave.polygonPositions[i][0], levelSave.polygonPositions[i][1]);
                newNode.body.SetStatic();
                newNode.body.orient = 0;
                newNode.movement.mode = movemode.free;
                newNode.body.restitution = 1f;
                newNode.body.texture = textures.rock1;
                newNode.meta.maxHealth.enabled = false;
                poly.ComputeNormals();
                poly.CalibrateTexture();
                nodes.Add(newNode);
            }
                foreach (var dd in levelSave.Diodes)
                {
                    var dict = new Dictionary<dynamic, dynamic>() { { typeof(Diode), true }, { nodeE.texture, textures.gradient1 } };
                    Node lastSpawnedDiode = Node.ContructLineWall(room, new Vector2(dd.start[0], dd.start[1]), new Vector2(dd.end[0], dd.end[1]), DiodeSpawner.diodeThickness, dict, false);
                    lastSpawnedDiode.SetColor(new Color(255, 255, 255, 255));
                    lastSpawnedDiode.Comp<Diode>().start = new Vector2(dd.start[0], dd.start[1]);
                    lastSpawnedDiode.Comp<Diode>().end = new Vector2(dd.end[0], dd.end[1]);
                    lastSpawnedDiode.Comp<Diode>().semaphore = dd.isSemaphore;
                    lastSpawnedDiode.Comp<Diode>().maxTickets = dd.tickets;
                    lastSpawnedDiode.body.orient = dd.orientation;

                    room.masterGroup.IncludeEntity(lastSpawnedDiode);
                    lastSpawnedDiode.OnSpawn();
                }

            ObservableHashSet<Node> incomingNodes = nodes;
            foreach (Node n in room.groups.walls.entities.ToList())
            {
                room.groups.walls.DiscludeEntity(n);
            }

            foreach (Node n in incomingNodes)
            {
                room.groups.walls.IncludeEntity(n);
            }
            foreach (Node n in room.groups.walls.entities)
            {
                n.collision.UpdateCollisionSet();
            }
            finalizeLevelLoad(v);
        }