Пример #1
0
        public TiledTileInstance(TiledTile tile, Point position, string layer, TiledLayer.TileType.Flip flip)        // = TiledLayer.TileType.Flip.FLIP_NONE)
        {
            this.tile     = tile;
            this.position = position;
            this.layer    = layer;

            this.flip = flip;

            valid = true;
        }
Пример #2
0
        private TiledTile ParseTile(TmxTileset tileset, TmxTilesetTile tilesetTile)
        {
            string    texture         = GetTilesetTexture(tileset);
            Rectangle sourceRectangle = GetTilesetTileSourceRect(tilesetTile, tileset);

            TiledTile tiledTile = new TiledTile();

            tiledTile.Initialize(tilesetTile, 0, texture, sourceRectangle);

            return(tiledTile);
        }
Пример #3
0
        public void SetTile(string layer, Point pos, TiledTile tileType, bool flipH = false, bool flipV = false)
        {
            if (tileType == null)
            {
                Layers[layer].tiles[pos.X, pos.Y] = default;
            }
            else
            {
                TiledLayer.TileType.Flip flip = TiledLayer.TileType.Flip.FLIP_NONE;
                if (flipH)
                {
                    flip |= TiledLayer.TileType.Flip.FLIP_H;
                }
                if (flipV)
                {
                    flip |= TiledLayer.TileType.Flip.FLIP_V;
                }

                Layers[layer].tiles[pos.X, pos.Y] = new TiledLayer.TileType()
                {
                    id = (ushort)tileType.gid, flip = flip
                };
            }
        }
Пример #4
0
        private void LoadTiles(TmxMap map, TiledMap outMap)
        {
            Dictionary <int, TiledTile> allTiles = new Dictionary <int, TiledTile>();

            LoadMessage = "Loading tilesets...";
            foreach (TmxTileset tileset in map.Tilesets)
            {
                foreach (TmxTilesetTile tilesetTile in tileset.Tiles.Values)
                {
                    int       gid = tilesetTile.Id + tileset.FirstGid;
                    TiledTile t   = ParseTile(tileset, tilesetTile);
                    t.gid = gid;
                    allTiles.Add(gid, t);

                    if (outputLoadMessage)
                    {
                        LoadMessage = "Loading tilesets...\n" +
                                      "Tileset " + tileset.Name + ", gid: " + gid;
                    }
                }
            }

            int layerIndex = 0;

            foreach (TmxLayer layer in map.Layers)
            {
                if (!layer.Visible)
                {
                    continue;                       //invisible layers are not loaded.
                }
                float drawPriority = 0;
                if (layer.Properties.ContainsKey("draw_priority"))
                {
                    float.TryParse(layer.Properties["draw_priority"], out drawPriority);
                }

                outMap.AddLayer(layer.Name, new TiledLayer(layer.Name, drawPriority, (float)layer.OffsetY, (float)layer.OffsetX, allTiles, new TiledLayer.TileType[map.Width, map.Height], layer.Properties));

                LoadMessage = "Blanking tiles...";
                int iter = 0;
                //Create all tiles first
                for (int x = 0; x < map.Width; x++)
                {
                    for (int y = 0; y < map.Height; y++)
                    {
                        iter++;
                        outMap.SetTile(layer.Name, new Point(x, y), null);

                        if (outputLoadMessage)
                        {
                            LoadMessage = "Blanking tiles...\n(Layer: " + layer.Name + " (" + layerIndex + "/" + (map.Layers.Count - 1) + ") " + iter + "/" + layer.Tiles.Count + ")";
                        }
                    }
                }

                LoadMessage = "Initializing tiles...";

                Dictionary <int, TiledTile> setTiles = new Dictionary <int, TiledTile>();

                iter = 0;
                foreach (TmxLayerTile layerTile in layer.Tiles)
                {
                    if (layerTile.Gid != 0 && allTiles.ContainsKey(layerTile.Gid))
                    {
                        iter++;
                        outMap.SetTile(layer.Name, new Point(layerTile.X, layerTile.Y), allTiles[layerTile.Gid], layerTile.HorizontalFlip, layerTile.VerticalFlip);

                        if (outputLoadMessage)
                        {
                            LoadMessage = "Initializing tiles...\n(Layer: " + layer.Name + " (" + layerIndex + "/" + (map.Layers.Count - 1) + ") " + iter + "/" + layer.Tiles.Count + ")";
                        }

                        continue;
                    }
                }

                layerIndex++;
            }
        }