public TilesetDocument Load(FilePath filePath)
 {
     var tilesetReader = _core.Reader.GetTilesetReader(filePath);
     var tileset = tilesetReader.Load(filePath);
     var tilesetDocument = new TilesetDocument(tileset);
     return tilesetDocument;
 }
示例#2
0
        public Tileset Load(FilePath path)
        {
            var tileset = new Tileset();

            tileset.FilePath = path;

            var doc = XDocument.Load(path.Absolute);
            var reader = doc.Element("Tileset");
            if (reader == null)
                throw new Exception("The specified tileset definition file does not contain a Tileset tag.");

            var sheetPath = FilePath.FromRelative(reader.Attribute("tilesheet").Value, path.BasePath);
            tileset.ChangeSheetPath(sheetPath.Absolute);

            int size;
            if (!int.TryParse(reader.Attribute("tilesize").Value, out size))
                throw new Exception("The tileset definition does not contain a valid tilesize attribute.");
            tileset.TileSize = size;

            var propParent = reader.Element("TileProperties");
            if (propParent != null)
            {
                foreach (XElement propNode in propParent.Elements("Properties"))
                {
                    var prop = new TileProperties(propNode);
                    tileset.AddProperties(prop);
                }
            }

            foreach (XElement tileNode in reader.Elements("Tile"))
            {
                int id = int.Parse(tileNode.Attribute("id").Value);
                string name = tileNode.Attribute("name").Value;

                var spriteNode = tileNode.Element("Sprite");
                if (spriteNode == null)
                    throw new GameXmlException(tileNode, "All Tile tags must contain a Sprite tag.");

                var sprite = LoadSprite(spriteNode);
                var tileSprite = new TileSprite(tileset, sprite);

                Tile tile = new Tile(id, tileSprite);

                string propName = "Default";
                XAttribute propAttr = tileNode.Attribute("properties");
                if (propAttr != null)
                    propName = propAttr.Value;

                tile.Properties = tileset.GetProperties(propName);

                tile.Sprite.Play();
                tileset.Add(tile);
            }

            return tileset;
        }
示例#3
0
 public static FilePath FromRelative(string relative, string basepath)
 {
     FilePath fp = new FilePath
     {
         basepath = Path.GetFullPath(basepath),
         relative = relative,
         absolute = Path.Combine(basepath, relative)
     };
     return fp;
 }
        public TilesetDocument CreateNew(FilePath filePath)
        {
            var tileset = new Tileset()
            {
                FilePath = filePath,
                TileSize = 16
            };

            var document = new TilesetDocument(tileset);
            AddDefaultTileProperties(document);

            return document;
        }
示例#5
0
        private ScreenInfo LoadScreenXml(XElement node, FilePath stagePath, Tileset tileset)
        {
            string id = node.RequireAttribute("id").Value;

            var screen = new ScreenInfo(id, tileset);

            screen.Layers.Add(LoadScreenLayer(node, stagePath.Absolute, id, tileset, 0, 0, false));

            foreach (var overlay in node.Elements("Overlay"))
            {
                var name = overlay.RequireAttribute("name").Value;
                var x = overlay.TryAttribute<int>("x");
                var y = overlay.TryAttribute<int>("y");
                bool foreground = overlay.TryAttribute<bool>("foreground");
                bool parallax = overlay.TryAttribute<bool>("parallax");

                var layer = LoadScreenLayer(overlay, stagePath.Absolute, name, tileset, x, y, foreground);
                layer.Parallax = parallax;

                screen.Layers.Add(layer);
            }

            foreach (XElement teleport in node.Elements("Teleport"))
            {
                TeleportInfo info;
                int from_x = teleport.TryAttribute<int>("from_x");
                int from_y = teleport.TryAttribute<int>("from_y");
                int to_x = teleport.TryAttribute<int>("to_x");
                int to_y = teleport.TryAttribute<int>("to_y");
                info.From = new Point(from_x, from_y);
                info.To = new Point(to_x, to_y);
                info.TargetScreen = teleport.Attribute("to_screen").Value;

                screen.Teleports.Add(info);
            }

            var blocks = new List<BlockPatternInfo>();

            foreach (XElement blockNode in node.Elements("Blocks"))
            {
                BlockPatternInfo pattern = _blockReader.FromXml(blockNode);
                screen.BlockPatterns.Add(pattern);
            }

            screen.Commands = HandlerXmlReader.LoadCommands(node, stagePath.BasePath);

            return screen;
        }
 private Texture2D GetTextureFromPath(FilePath path)
 {
     StreamReader sr = new StreamReader(path.Absolute);
     return Texture2D.FromStream(_graphicsDevice, sr.BaseStream);
 }
        public IResourceImage LoadResource(FilePath texturePath, string paletteName = null)
        {
            if (!_loadedResources.ContainsKey(texturePath))
            {
                var texture = GetTextureFromPath(texturePath);
                var resource = AddTexture(texture, paletteName);
                _loadedResources[texturePath] = resource;
            }

            return _loadedResources[texturePath];
        }
 public ITilesetReader GetTilesetReader(FilePath path)
 {
     var reader = new TilesetXmlReader();
     reader.Init(_dataSource);
     return reader;
 }
 public IStageReader GetStageReader(FilePath path)
 {
     var reader = new StageXmlReader(this, new EntityPlacementXmlReader(), new HandlerCommandXmlReader());
     reader.Init(_dataSource);
     return reader;
 }
示例#10
0
 public Map(FilePath path)
     : this()
 {
     LoadMapXml(path);
 }
示例#11
0
        /// <summary>
        /// Changes the tileset by specifying an absolute path to the new tileset XML file.
        /// </summary>
        /// <param name="path">If it's not absolute, I'll make it so.</param>
        public void ChangeTileset(string path)
        {
            tilePath = FilePath.FromAbsolute(path, StagePath.Absolute);
            Tileset = new Tileset(tilePath.Absolute);

            foreach (Screen s in Screens.Values) s.Tileset = Tileset;
        }
 public StageDocument CreateNew(FilePath filePath)
 {
     throw new NotImplementedException();
 }
示例#13
0
 public StageInfo(FilePath filePath)
 {
     StagePath = filePath;
     Screens = new Dictionary<string, ScreenInfo>();
     Joins = new List<Join>();
     continuePoints = new Dictionary<string, Point>();
 }
示例#14
0
 public TilesetDocument Load(FilePath filePath)
 {
     var tileset = _reader.Load(filePath);
     var tilesetDocument = new TilesetDocument(tileset);
     return tilesetDocument;
 }
示例#15
0
        public StageInfo LoadStageXml(FilePath path)
        {
            _info = new StageInfo();

            _info.StagePath = path;

            var mapXml = XElement.Load(Path.Combine(_info.StagePath.Absolute, "map.xml"));
            _info.Name = Path.GetFileNameWithoutExtension(_info.StagePath.Absolute);

            string tilePathRel = mapXml.Attribute("tiles").Value;
            var tilePath = FilePath.FromRelative(tilePathRel, _info.StagePath.BasePath);

            var tileset = new TilesetXmlReader().Load(tilePath);
            _info.ChangeTileset(tileset);

            _info.PlayerStartX = 3;
            _info.PlayerStartY = 3;

            LoadMusicXml(mapXml);
            LoadScreens(mapXml);

            XElement start = mapXml.Element("Start");
            if (start != null)
            {
                _info.StartScreen = start.RequireAttribute("screen").Value;
                _info.PlayerStartX = start.GetAttribute<int>("x");
                _info.PlayerStartY = start.GetAttribute<int>("y");
            }

            foreach (XElement contPoint in mapXml.Elements("Continue"))
            {
                string screen = contPoint.GetAttribute<string>("screen");
                int x = contPoint.GetAttribute<int>("x");
                int y = contPoint.GetAttribute<int>("y");
                _info.AddContinuePoint(screen, new Point(x, y));
            }

            foreach (XElement join in mapXml.Elements("Join"))
            {
                string t = join.Attribute("type").Value;
                JoinType type;
                if (t.ToLower() == "horizontal") type = JoinType.Horizontal;
                else if (t.ToLower() == "vertical") type = JoinType.Vertical;
                else throw new GameXmlException(join, "map.xml file contains invalid join type.");

                string s1 = join.RequireAttribute("s1").Value;
                string s2 = join.RequireAttribute("s2").Value;
                int offset1 = join.GetAttribute<int>("offset1");
                int offset2 = join.GetAttribute<int>("offset2");
                int size = join.GetAttribute<int>("size");

                JoinDirection direction;
                XAttribute dirAttr = join.Attribute("direction");
                if (dirAttr == null || dirAttr.Value.ToUpper() == "BOTH") direction = JoinDirection.Both;
                else if (dirAttr.Value.ToUpper() == "FORWARD") direction = JoinDirection.ForwardOnly;
                else if (dirAttr.Value.ToUpper() == "BACKWARD") direction = JoinDirection.BackwardOnly;
                else throw new GameXmlException(dirAttr, "map.xml file contains invalid join direction.");

                string bosstile = null;
                XAttribute bossAttr = join.Attribute("bossdoor");
                bool bossdoor = (bossAttr != null);
                if (bossdoor) bosstile = bossAttr.Value;

                Join j = new Join();
                j.direction = direction;
                j.screenOne = s1;
                j.screenTwo = s2;
                j.offsetOne = offset1;
                j.offsetTwo = offset2;
                j.type = type;
                j.Size = size;
                j.bossDoor = bossdoor;
                j.bossEntityName = bosstile;

                _info.Joins.Add(j);
            }

            return _info;
        }
示例#16
0
        public static FilePath FromRelative(string relative, string basepath)
        {
            if (string.IsNullOrWhiteSpace(relative))
            {
                throw new ArgumentException("Path cannot be null or empty.", "relative");
            }

            if (string.IsNullOrWhiteSpace(basepath))
            {
                throw new ArgumentException("Path cannot be null or empty.", "basepath");
            }

            FilePath fp = new FilePath {
                basepath = Path.GetFullPath(basepath),
                relative = relative,
                absolute = Path.GetFullPath(Path.Combine(basepath, relative))
            };
            return fp;
        }
示例#17
0
        public void LoadMapXml(FilePath path)
        {
            StagePath = path;

            var mapXml = XElement.Load(Path.Combine(StagePath.Absolute, "map.xml"));
            Name = Path.GetFileNameWithoutExtension(StagePath.Absolute);

            string tilePathRel = mapXml.Attribute("tiles").Value;
            tilePath = FilePath.FromRelative(tilePathRel, StagePath.Absolute);

            Tileset = new Tileset(tilePath.Absolute);

            PlayerStartX = 3;
            PlayerStartY = 3;

            LoadMusicXml(mapXml);
            LoadScreenXml(mapXml);

            XElement start = mapXml.Element("Start");
            if (start != null)
            {
                int px, py;
                var screenAttr = start.Attribute("screen");
                if (screenAttr == null) throw new Exception("Start tag must have a screen attribute!");
                StartScreen = screenAttr.Value;
                if (!start.Attribute("x").Value.TryParse(out px)) throw new Exception("Start tag x is not a valid integer!");
                PlayerStartX = px;
                if (!start.Attribute("y").Value.TryParse(out py)) throw new Exception("Start tag y is not a valid integer!");
                PlayerStartY = py;
            }

            foreach (XElement contPoint in mapXml.Elements("Continue"))
            {
                string screen = contPoint.Attribute("screen").Value;
                int x;
                contPoint.Attribute("x").Value.TryParse(out x);
                int y;
                contPoint.Attribute("y").Value.TryParse(out y);
                continuePoints.Add(screen, new Point(x, y));
            }

            foreach (XElement join in mapXml.Elements("Join"))
            {
                string t = join.Attribute("type").Value;
                JoinType type;
                if (t.ToLower() == "horizontal") type = JoinType.Horizontal;
                else if (t.ToLower() == "vertical") type = JoinType.Vertical;
                else throw new Exception("map.xml file contains invalid join type.");

                string s1 = join.Attribute("s1").Value;
                string s2 = join.Attribute("s2").Value;
                int offset1;
                join.Attribute("offset1").Value.TryParse(out offset1);
                int offset2;
                join.Attribute("offset2").Value.TryParse(out offset2);
                int size;
                join.Attribute("size").Value.TryParse(out size);

                JoinDirection direction;
                XAttribute dirAttr = join.Attribute("direction");
                if (dirAttr == null || dirAttr.Value.ToUpper() == "BOTH") direction = JoinDirection.Both;
                else if (dirAttr.Value.ToUpper() == "FORWARD") direction = JoinDirection.ForwardOnly;
                else if (dirAttr.Value.ToUpper() == "BACKWARD") direction = JoinDirection.BackwardOnly;
                else throw new Exception("map.xml file contains invalid join direction.");

                string bosstile = null;
                XAttribute bossAttr = join.Attribute("bossdoor");
                bool bossdoor = (bossAttr != null);
                if (bossdoor) bosstile = bossAttr.Value;

                Join j = new Join();
                j.direction = direction;
                j.screenOne = s1;
                j.screenTwo = s2;
                j.offsetOne = offset1;
                j.offsetTwo = offset2;
                j.type = type;
                j.Size = size;
                j.bossDoor = bossdoor;
                j.bossEntityName = bosstile;

                Joins.Add(j);
            }
        }