Пример #1
0
        private void TranslateMap(int x, int y, Editor editor)
        {
            editor.DeselectItem();

            foreach (var child in editor.Map.Children.OfType<Shape>())
            {
                if (child is Rectangle)
                {
                    Canvas.SetLeft(child, Canvas.GetLeft(child) + x);
                    Canvas.SetTop(child, Canvas.GetTop(child) + y);

                    var t = editor.TileList.FirstOrDefault(z => z.Rectangle == child);
                    if (t != null)
                    {
                        t.X += x / Gc.TILE_SIZE;
                        t.Y += y / Gc.TILE_SIZE;
                    }
                }
                else if (child is Line)
                {
                    var c = child as Line;
                    c.X1 += x;
                    c.X2 += x;
                    c.Y1 += y;
                    c.Y2 += y;
                }
            }
        }
Пример #2
0
 public void OnMouseUp(Editor editor, UIView view)
 {
     editor.RemoveExistingTilesBetween(editor.startPoint, editor.currentPoint);
     editor.RemoveWallsBetween(
         editor.startPoint.ConvertToTilePosition(Gc.TILE_SIZE),
         editor.currentPoint.ConvertToTilePosition(Gc.TILE_SIZE));
 }
Пример #3
0
        public void OnMouseUp(Editor editor, UIView view)
        {
            var x = (int)(editor.startPoint.ConvertToTilePosition(Gc.TILE_SIZE).X -
                          editor.currentPoint.ConvertToTilePosition(Gc.TILE_SIZE).X);
            var y = (int)(editor.startPoint.ConvertToTilePosition(Gc.TILE_SIZE).Y -
                          editor.currentPoint.ConvertToTilePosition(Gc.TILE_SIZE).Y);

            TranslateMap(x, y, editor);
        }
Пример #4
0
        public MainWindow()
        {
            InitializeComponent();
            editor = new Editor(this, Map);

            LoadTiles();
            LoadItems();
            LoadTools();
        }
Пример #5
0
        public static void Load(Editor editor, string fileLoc)
        {
            editor.Clear(); // clean up anything the user might have been working on before

            var doc = new XmlDocument();
            doc.Load(fileLoc);
            var level = doc.SelectSingleNode("Level");

            // Floor Tiles
            var rows = level.SelectNodes("Row");
            var yOffset = rows.Count - 1;
            var x = 0;
            var y = 0;
            foreach (XmlNode row in rows)
            {
                foreach (XmlNode column in row.SelectNodes("Column"))
                {
                    var tile = column.SelectSingleNode("Tile");

                    editor.SelectTileChoice(tile.InnerText);
                    editor.PlaceTile(new Point(x * Gc.TILE_SIZE, (yOffset - y) * Gc.TILE_SIZE));

                    x++;
                }
                y++;
                x = 0;
            }

            // Walls
            var walls = level.SelectSingleNode("Walls");
            foreach (XmlNode wall in walls.SelectNodes("Wall"))
            {
                // wall pattern is: x,y x1,y2
                string[] parts = wall.InnerText.Split(new[] {" "}, StringSplitOptions.RemoveEmptyEntries);
                var p1 = parts[0].Split(',');
                var p2 = parts[1].Split(',');

                var isHor = p1[1] == p2[1];

                editor.PlaceWall(
                    new Point(int.Parse(p1[0]) * Gc.TILE_SIZE, (yOffset - int.Parse(p1[1]) + (isHor ? 1 : 0)) * Gc.TILE_SIZE),
                    new Point((int.Parse(p2[0]) - (isHor ? 1 : 0)) * Gc.TILE_SIZE, (yOffset - int.Parse(p2[1]) + (isHor ? 1 : -1)) * Gc.TILE_SIZE));
            }

            // Doors
            var doors = level.SelectSingleNode("Doors");
            foreach (XmlNode door in doors.SelectNodes("Door"))
            {
                // door is stored as x,y,rotation
                var parts = door.InnerText.Split(',');
                var dx = int.Parse(parts[0]);
                var dy = int.Parse(parts[1]);
                var drot = int.Parse(parts[2]);

                // when placing doors, you need to put it closer to left or top side of tile it's on or else it will mess up
                if(drot == 0)
                    editor.PlaceDoor(new Point(dx * Gc.TILE_SIZE + 1, (yOffset - dy + 1) * Gc.TILE_SIZE));
                if (drot == 90)
                    editor.PlaceDoor(new Point(dx * Gc.TILE_SIZE, (yOffset - dy) * Gc.TILE_SIZE + 1));
            }

            // Items
            var items = level.SelectSingleNode("Items");
            foreach (XmlNode item in items.SelectNodes("Item"))
            {
                var ix = float.Parse(item.Attributes["X"].InnerText);
                var iy = float.Parse(item.Attributes["Y"].InnerText);
                var irot = float.Parse(item.Attributes["Rot"].InnerText);

                editor.SelectItemChoice(item.InnerText);
                editor.PlaceItem(new Point(
                    ix.FromEditorCoordX(editor) - editor.SelectedItemChoice.Image.Source.Width,
                    yOffset * Gc.TILE_SIZE - iy.FromEditorCoordY(editor) - editor.SelectedItemChoice.Image.Source.Height + Gc.TILE_SIZE),
                    irot);
                editor.EditingItem.Rotation = irot;
            }
        }
Пример #6
0
        //TODO: Support levels that aren't perfect squares...maybe?  Maybe I don't care because this is a poc anyways...
        public static void Save(Editor editor, string fileLoc)
        {
            var offsetX = editor.TileList.Min(x => x.X) * Gc.TILE_SIZE;
            var offsetY = editor.TileList.Max(x => x.Y) * Gc.TILE_SIZE; // max because 0,0 in unity is botom left of screen instead of top left

            var file = new XmlDocument();

            string f = "<Level>";

            var lastTop = defaultLastTop;
            foreach (var tile in editor.TileList.OrderByDescending(x => x.Y).ThenBy(x => x.X))
            {
                var top = tile.Y;
                if (Math.Abs(top - lastTop) > .01)
                    f += lastTop != defaultLastTop ? "</Row><Row>" : "<Row>";
                lastTop = top;

                f += "<Column><Tile>";
                f += tile.Name;
                f += "</Tile></Column>";
            }
            f += "</Row>";

            f += "<Walls>";
            foreach (var wall in editor.WallList)
            {
                if (wall.Line.Y1 == wall.Line.Y2)
                    wall.Line.Y1 = wall.Line.Y2 = wall.Line.Y1 - Gc.TILE_SIZE;

                f += "<Wall>";
                f += "{0},{1} {2},{3}".ToFormat(
                    Math.Round((wall.Line.X1 - offsetX) / Gc.TILE_SIZE),
                    Math.Round((offsetY - wall.Line.Y1) / Gc.TILE_SIZE),
                    Math.Round((wall.Line.X2 - offsetX) / Gc.TILE_SIZE),
                    Math.Round((offsetY - wall.Line.Y2) / Gc.TILE_SIZE));
                f += "</Wall>";

                if (wall.Line.Y1 == wall.Line.Y2)
                    wall.Line.Y1 = wall.Line.Y2 = wall.Line.Y1 + Gc.TILE_SIZE;
            }
            f+="</Walls>";

            f += "<Doors>";
            foreach (var door in editor.DoorList)
            {
                if (door.Rotation == 0)
                    door.Line.Y1 = door.Line.Y2 = door.Line.Y1 - Gc.TILE_SIZE;

                f += "<Door>";
                f += "{0},{1},{2}".ToFormat(
                    Math.Round((door.Line.X1 - offsetX) / Gc.TILE_SIZE),
                    Math.Round((offsetY - door.Line.Y1) / Gc.TILE_SIZE),
                    door.Rotation);
                f += "</Door>";

                if (door.Rotation == 0)
                    door.Line.Y1 = door.Line.Y2 = door.Line.Y1 + Gc.TILE_SIZE;
            }
            f += "</Doors>";

            f += "<Items>";

            foreach (var item in editor.ItemList)
            {
                f += "<Item X='{0}' Y='{1}' Rot='{2}'>".ToFormat(
                    item.X.ToEditorCoordX(editor) + item.Image.Source.Width / Gc.TILE_SIZE,
                    offsetY/Gc.TILE_SIZE - item.Y.ToEditorCoordY(editor) - ((item.Image.Source.Height / Gc.TILE_SIZE) - 1),
                    item.Rotation);

                f += item.Name;

                f += "</Item>";
            }

            f += "</Items>";

            f += "</Level>";

            file.LoadXml(f);
            file.Save(fileLoc);
        }
Пример #7
0
 public void OnMouseUp(Editor editor, UIView view)
 {
     if (view.LeftClick) editor.PlaceTile(editor.startPoint, editor.currentPoint);
     else editor.RemoveExistingTilesBetween(editor.startPoint, editor.currentPoint);
 }
Пример #8
0
 public void OnMouseDown(Editor editor, UIView view)
 {
 }
Пример #9
0
 public void OnMouseUp(Editor editor, UIView view)
 {
 }
Пример #10
0
 public void OnMouseDown(Editor editor, UIView view)
 {
     editor.PlaceItem(editor.startPoint);
 }
Пример #11
0
 public void OnMouseUp(Editor editor, UIView view)
 {
     editor.PlaceWall(editor.startPoint, editor.currentPoint);
 }
Пример #12
0
 public static double ToEditorCoordY(this double d, Editor m)
 {
     var minY = m.TileList.Count == 0 ? 0 : m.TileList.Min(x => x.Y) * Gc.TILE_SIZE;
     return (d - minY) / Gc.TILE_SIZE;
 }
Пример #13
0
 public static double FromEditorCoordY(this float f, Editor m)
 {
     var minY = m.TileList.Count == 0 ? 0 : m.TileList.Min(x => x.Y) * Gc.TILE_SIZE;
     return f * Gc.TILE_SIZE + minY;
 }