コード例 #1
0
ファイル: Map.cs プロジェクト: msruzy/WickedEngine-1
        /// <summary>
        /// Returns the set of all objects in the map.
        /// </summary>
        /// <returns>A new set of all objects in the map.</returns>
        public IEnumerable <MapObject> GetAllObjects()
        {
            foreach (var layer in Layers)
            {
                MapObjectLayer objLayer = layer as MapObjectLayer;
                if (objLayer == null)
                {
                    continue;
                }

                foreach (var obj in objLayer.Objects)
                {
                    yield return(obj);
                }
            }
        }
コード例 #2
0
ファイル: Map.cs プロジェクト: msruzy/WickedEngine-1
        /// <summary>
        /// Finds a collection of objects in the map using a delegate.
        /// </summary>
        /// <remarks>
        /// This method performs basically the same process as FindObject, but instead
        /// of returning the first object for which the delegate returns true, it returns
        /// a collection of all objects for which the delegate returns true.
        /// </remarks>
        /// <param name="finder">The delegate used to search for the object.</param>
        /// <returns>A collection of all MapObjects for which the delegate returned true.</returns>
        public IEnumerable <MapObject> FindObjects(MapObjectFinder finder)
        {
            foreach (var layer in Layers)
            {
                MapObjectLayer objLayer = layer as MapObjectLayer;
                if (objLayer == null)
                {
                    continue;
                }

                foreach (var obj in objLayer.Objects)
                {
                    if (finder(objLayer, obj))
                    {
                        yield return(obj);
                    }
                }
            }
        }
コード例 #3
0
ファイル: Map.cs プロジェクト: msruzy/WickedEngine-1
        /// <summary>
        /// Finds an object in the map using a delegate.
        /// </summary>
        /// <remarks>
        /// This method is used when an object is desired, but there is no specific
        /// layer to find the object on. The delegate allows the caller to create
        /// any logic they want for finding the object. A simple example for finding
        /// the first object named "goal" in any layer would be this:
        ///
        /// var goal = map.FindObject((layer, obj) => return obj.Name.Equals("goal"));
        ///
        /// You could also use the layer name or any other logic to find an object.
        /// The first object for which the delegate returns true is the object returned
        /// to the caller. If the delegate never returns true, the method returns null.
        /// </remarks>
        /// <param name="finder">The delegate used to search for the object.</param>
        /// <returns>The MapObject if the delegate returned true, null otherwise.</returns>
        public MapObject FindObject(MapObjectFinder finder)
        {
            foreach (var layer in Layers)
            {
                MapObjectLayer objLayer = layer as MapObjectLayer;
                if (objLayer == null)
                {
                    continue;
                }

                foreach (var obj in objLayer.Objects)
                {
                    if (finder(objLayer, obj))
                    {
                        return(obj);
                    }
                }
            }

            return(null);
        }
コード例 #4
0
        //private Layer collisionLayer;

        internal Map(ContentReader reader)
        {
            // read in the basic map information
            Version     = new Version(reader.ReadString());
            Orientation = (Orientation)reader.ReadByte();
            Width       = reader.ReadInt32();
            Height      = reader.ReadInt32();
            TileWidth   = reader.ReadInt32();
            TileHeight  = reader.ReadInt32();
            Properties  = new PropertyCollection();
            Properties.Read(reader);

            // create a list for our tiles
            List <Tile> tiles = new List <Tile>();

            Tiles = new Collection <Tile>(tiles);

            // read in each tile set
            int numTileSets = reader.ReadInt32();

            for (int i = 0; i < numTileSets; i++)
            {
                // get the id and texture
                int    firstId      = reader.ReadInt32();
                string tilesetName  = reader.ReadString();
                bool   collisionSet = reader.ReadBoolean();

                Texture2D texture      = reader.ReadExternalReference <Texture2D>();
                Texture2D whiteTexture = reader.ReadExternalReference <Texture2D>();

                // Read in color data for collision purposes
                // You'll probably want to limit this to just the tilesets that are used for collision
                // I'm checking for the name of my tileset that contains wall tiles
                // Color data takes up a fair bit of RAM
                Color[] collisionData    = null;
                bool[]  collisionBitData = null;
                if (collisionSet)
                {
                    collisionData    = new Color[texture.Width * texture.Height];
                    collisionBitData = new bool[texture.Width * texture.Height];
                    texture.GetData <Color>(collisionData);
                    for (int col = 0; col < collisionData.Length; col++)
                    {
                        if (collisionData[col].A > 0)
                        {
                            collisionBitData[col] = true;
                        }
                    }
                    collisionData = null;
                }

                // read in each individual tile
                int numTiles = reader.ReadInt32();
                for (int j = 0; j < numTiles; j++)
                {
                    int                id     = firstId + j;
                    Rectangle          source = reader.ReadObject <Rectangle>();
                    PropertyCollection props  = new PropertyCollection();
                    props.Read(reader);

                    Tile t = new Tile(texture, whiteTexture, source, props, collisionBitData);
                    while (id >= tiles.Count)
                    {
                        tiles.Add(null);
                    }
                    tiles.Insert(id, t);
                }
            }

            // read in all the layers
            List <Layer> layers = new List <Layer>();

            Layers = new ReadOnlyCollection <Layer>(layers);
            int numLayers = reader.ReadInt32();

            for (int i = 0; i < numLayers; i++)
            {
                Layer layer = null;

                // read generic layer data
                string             type    = reader.ReadString();
                string             name    = reader.ReadString();
                int                width   = reader.ReadInt32();
                int                height  = reader.ReadInt32();
                bool               visible = reader.ReadBoolean();
                float              opacity = reader.ReadSingle();
                PropertyCollection props   = new PropertyCollection();
                props.Read(reader);

                // using the type, figure out which object to create
                if (type == "layer")
                {
                    int[] data = reader.ReadObject <int[]>();
                    layer = new TileLayer(name, width, height, visible, opacity, props, this, data);
                }
                else if (type == "objectgroup")
                {
                    List <MapObject> objects = new List <MapObject>();

                    // read in all of our objects
                    int numObjects = reader.ReadInt32();
                    for (int j = 0; j < numObjects; j++)
                    {
                        string             objName   = reader.ReadString();
                        string             objType   = reader.ReadString();
                        Rectangle          objLoc    = reader.ReadObject <Rectangle>();
                        List <Point>       objPoints = reader.ReadObject <List <Point> >();
                        PropertyCollection objProps  = new PropertyCollection();
                        objProps.Read(reader);

                        objects.Add(new MapObject(objName, objType, objLoc, objPoints, objProps));
                    }

                    layer = new MapObjectLayer(name, width, height, visible, opacity, props, objects);
                }
                else
                {
                    throw new Exception("Invalid type: " + type);
                }

                layers.Add(layer);
                namedLayers.Add(name, layer);
            }
        }
コード例 #5
0
ファイル: Map.cs プロジェクト: msruzy/WickedEngine-1
        internal Map(ContentReader reader)
        {
            // read in the basic map information
            Version       = new Version(reader.ReadString());
            Orientation   = (Orientation)reader.ReadByte();
            WidthInTiles  = reader.ReadInt32();
            HeightInTiles = reader.ReadInt32();
            TileWidth     = reader.ReadInt32();
            TileHeight    = reader.ReadInt32();
            Properties    = new PropertyCollection(reader);
            bool makeTilesUnique = reader.ReadBoolean();

            // create a list for our tiles
            List <Tile> tiles = new List <Tile>();

            Tiles = new ReadOnlyCollection <Tile>(tiles);

            // read in each tile set
            int numTileSets = reader.ReadInt32();

            for (int i = 0; i < numTileSets; i++)
            {
                // get the id and texture
                int       firstId = reader.ReadInt32();
                Texture2D texture = reader.ReadExternalReference <Texture2D>();

                // read in each individual tile
                int numTiles = reader.ReadInt32();
                for (int j = 0; j < numTiles; j++)
                {
                    int                id     = firstId + j;
                    Rectangle          source = reader.ReadObject <Rectangle>();
                    PropertyCollection props  = new PropertyCollection(reader);

                    Tile t = new Tile(texture, source, props);
                    while (id >= tiles.Count)
                    {
                        tiles.Add(null);
                    }
                    tiles.Insert(id, t);
                }
            }

            // read in all the layers
            List <Layer> layers = new List <Layer>();

            Layers = new ReadOnlyCollection <Layer>(layers);
            int numLayers = reader.ReadInt32();

            for (int i = 0; i < numLayers; i++)
            {
                Layer layer = null;

                // read generic layer data
                string             type    = reader.ReadString();
                string             name    = reader.ReadString();
                int                width   = reader.ReadInt32();
                int                height  = reader.ReadInt32();
                bool               visible = reader.ReadBoolean();
                float              opacity = reader.ReadSingle();
                PropertyCollection props   = new PropertyCollection(reader);

                // calculate the default layer depth of the layer
                float layerDepth = 1f - (LayerDepthSpacing * i);

                // using the type, figure out which object to create
                if (type == "layer")
                {
                    uint[] data = reader.ReadObject <uint[]>();
                    layer = new TileLayer(name, width, height, layerDepth, visible, opacity, props, this, data, makeTilesUnique);
                }
                else if (type == "objectgroup")
                {
                    List <MapObject> objects = new List <MapObject>();

                    // read in all of our objects
                    int numObjects = reader.ReadInt32();
                    for (int j = 0; j < numObjects; j++)
                    {
                        string             objName  = reader.ReadString();
                        string             objType  = reader.ReadString();
                        Rectangle          objLoc   = reader.ReadObject <Rectangle>();
                        PropertyCollection objProps = new PropertyCollection(reader);

                        objects.Add(new MapObject(objName, objType, objLoc, objProps));
                    }

                    layer = new MapObjectLayer(name, width, height, layerDepth, visible, opacity, props, objects);

                    // read in the layer's color
                    (layer as MapObjectLayer).Color = reader.ReadColor();
                }
                else
                {
                    throw new Exception("Invalid type: " + type);
                }

                layers.Add(layer);
                namedLayers.Add(name, layer);
            }
        }
コード例 #6
0
ファイル: Map.cs プロジェクト: GarethIW/LDEngine
        //private Layer collisionLayer;
        // Construct a TiledLib.Map from a TmxReader.map
        public Map(ContentManager content, string mapName)
        {
            string mapPath = AppDomain.CurrentDomain.BaseDirectory +
                "Content/" +
                mapName +
                ".tmx";

            TmxMap tmx = new TmxMap(mapPath);

            Version = new Version(tmx.Version);

            switch(tmx.Orientation)
            {
                case TmxMap.OrientationType.Isometric:
                    Orientation = Orientation.Isometric;
                    break;
                case TmxMap.OrientationType.Orthogonal:
                    Orientation = Orientation.Orthogonal;
                    break;
                case TmxMap.OrientationType.Staggered:
                    throw new Exception(
                        "TiledLib doesn't support maps with Staggered " +
                        "orientation.");
            }

            Width = tmx.Width;
            Height = tmx.Height;
            TileWidth = tmx.TileWidth;
            TileHeight = tmx.TileHeight;

            Properties = new PropertyCollection();
            foreach(KeyValuePair<string, string> kvp in tmx.Properties)
            {
                Properties.Add(kvp);
            }

            // Create a list for our tiles
            List<Tile> tiles = new List<Tile>();
            Tiles = new Collection<Tile>(tiles);

            // Read in each TileSet
            foreach (TmxTileset ts in tmx.Tilesets)
            {
                string tilesetName = ts.Name;
                Texture2D texture = content.Load<Texture2D>(ts.Image.Source);

                bool collisionSet = ts.Properties.ContainsKey("CollisionSet") &&
                    ts.Properties["CollisionSet"] == "True" ?
                    true : false;

                /* TODO:  Add this intelligence to TiledSharp.
                 * If the texture is bigger than a individual tile, infer all the
                 * additional tiles that must be created.
                 */

                if (texture.Width > ts.TileWidth || texture.Height > ts.TileHeight)
                {
                    // Deconstruct tileset to individual tiles
                    int id = 0;
                    for (int y = 0; y < texture.Height / ts.TileHeight; y++)
                    {
                        for (int x = 0; x < texture.Width / ts.TileWidth; x++)
                        {
                            Rectangle source = new Rectangle(
                                x * ts.TileWidth,
                                y * ts.TileHeight,
                                ts.TileWidth,
                                ts.TileHeight
                            );

                            Color[] collisionData = null;
                            bool[] collisionBitData = null;
                            PropertyCollection props = new PropertyCollection();

                            TmxTilesetTile tsTile = ts.Tiles.Find(i => i.Id == id);
                            if(tsTile != null)
                            {
                                foreach (KeyValuePair<string, string> kvp in
                                    tsTile.Properties)
                                {
                                    props.Add(kvp);

                                    // Inherit tilesets collision
                                    bool collidable = collisionSet;
                                    if (kvp.Key == "CollisionSet")
                                    {
                                        // Allow override per tile
                                        if (kvp.Value == "True")
                                        {
                                            collidable = true;
                                        } else
                                        {
                                            collidable = false;
                                        }
                                    }
                                    if (collidable)
                                    {
                                        int numOfBytes = ts.TileWidth * ts.TileHeight;
                                        collisionData = new Color[numOfBytes];
                                        collisionBitData = new bool[numOfBytes];

                                        texture.GetData<Color>(
                                            0,
                                            source,
                                            collisionData,
                                            0,
                                            numOfBytes
                                        );

                                        for (int col = 0; col < numOfBytes; col++)
                                        {
                                            if (collisionData[col].A > 0)
                                            {
                                                collisionBitData[col] = true;
                                            }
                                        }
                                        collisionData = null;
                                    }
                                }
                            }

                            Tile t = new Tile(
                                texture,
                                source,
                                props,
                                collisionBitData
                            );

                            while (id >= tiles.Count)
                            {
                                tiles.Add(null);
                            }
                            tiles.Insert(id + ts.FirstGid, t);
                            id++;
                        }
                    }
                }
            }

            // Process Map Items (layers, objectgroups, etc.)
            List<Layer> layers = new List<Layer>();
            Layers = new Collection<Layer>(layers);

            foreach(TmxLayer l in tmx.Layers)
            {
                Layer layer = null;

                PropertyCollection props = new PropertyCollection();
                foreach(KeyValuePair<string, string> kvp in l.Properties)
                {
                    props.Add(kvp);
                }

                layer = new TileLayer(
                    l.Name,
                    tmx.Width,  // As of TiledQT always same as layer.
                    tmx.Height, // As of TiledQT always same as layer.
                    l.Visible,
                    (float) l.Opacity,
                    props,
                    this,
                    l.Tiles
                );
                layers.Add(layer);
                namedLayers.Add(l.Name, layer);
            }

            foreach(TmxObjectGroup og in tmx.ObjectGroups)
            {
                Layer layer = null;

                PropertyCollection props = new PropertyCollection();
                foreach(KeyValuePair<string, string> kvp in og.Properties)
                {
                    props.Add(kvp);
                }

                List<MapObject> objects = new List<MapObject>();

                // read in all of our objects
                foreach(TmxObjectGroup.TmxObject i in og.Objects)
                {
                    Rectangle objLoc = new Rectangle(
                        i.X,
                        i.Y,
                        i.Width,
                        i.Height
                    );

                    List<Point> objPoints = new List<Point>();
                    if (i.Points != null)
                    {
                        foreach (Tuple<int, int> tuple in i.Points)
                        {
                            objPoints.Add(new Point(tuple.Item1, tuple.Item2));
                        }
                    }

                    PropertyCollection objProps = new PropertyCollection();
                    foreach(KeyValuePair<string, string> kvp in i.Properties)
                    {
                        objProps.Add(kvp);
                    }

                    objects.Add(
                        new MapObject(
                            i.Name,
                            i.Type,
                            objLoc,
                            objPoints,
                            objProps)
                    );
                }

                layer = new MapObjectLayer(
                    og.Name,
                    tmx.Width,
                    tmx.Height,
                    og.Visible,
                    (float) og.Opacity,
                    props,
                    objects
                );

                layers.Add(layer);
                namedLayers.Add(og.Name, layer);
            }
        }
コード例 #7
0
ファイル: Map.cs プロジェクト: GarethIW/LDEngine
        internal Map(ContentReader reader)
        {
            // read in the basic map information
            Version = new Version(reader.ReadString());
            Orientation = (Orientation)reader.ReadByte();
            Width = reader.ReadInt32();
            Height = reader.ReadInt32();
            TileWidth = reader.ReadInt32();
            TileHeight = reader.ReadInt32();
            Properties = new PropertyCollection();
            Properties.Read(reader);

            // create a list for our tiles
            List<Tile> tiles = new List<Tile>();
            Tiles = new Collection<Tile>(tiles);

            // read in each tile set
            int numTileSets = reader.ReadInt32();
            for (int i = 0; i < numTileSets; i++)
            {
                // get the id and texture
                int firstId = reader.ReadInt32();
                string tilesetName = reader.ReadString();

                bool collisionSet = reader.ReadBoolean();

                Texture2D texture = reader.ReadExternalReference<Texture2D>();

                // read in each individual tile
                int numTiles = reader.ReadInt32();
                for (int j = 0; j < numTiles; j++)
                {
                    int id = firstId + j;

                    // Read the source rectangle from the file.
                    Rectangle source = reader.ReadObject<Rectangle>();

                    PropertyCollection props = new PropertyCollection();
                    props.Read(reader);

                    // Read in color data for collision purposes
                    // You'll probably want to limit this to just the tilesets that are used for collision
                    // I'm checking for the name of my tileset that contains wall tiles
                    // Color data takes up a fair bit of RAM
                    Color[] collisionData = null;
                    bool[] collisionBitData = null;
                    if (collisionSet)
                    {
                        int numOfBytes = TileWidth * TileHeight;
                        collisionData = new Color[numOfBytes];
                        collisionBitData = new bool[numOfBytes];

                        texture.GetData<Color>(
                            0,
                            source,
                            collisionData,
                            0,
                            numOfBytes
                        );

                        for (int col = 0; col < numOfBytes; col++)
                        {
                            if (collisionData[col].A > 0)
                            {
                                collisionBitData[col] = true;
                            }
                        }
                        collisionData = null;
                    }

                    Tile t = new Tile(texture, source, props, collisionBitData);
                    while (id >= tiles.Count)
                    {
                        tiles.Add(null);
                    }
                    tiles.Insert(id, t);
                }
            }

            // read in all the layers
            List<Layer> layers = new List<Layer>();
            Layers = new Collection<Layer>(layers);
            int numLayers = reader.ReadInt32();
            for (int i = 0; i < numLayers; i++)
            {
                Layer layer = null;

                // read generic layer data
                string type = reader.ReadString();
                string name = reader.ReadString();
                int width = reader.ReadInt32();
                int height = reader.ReadInt32();
                bool visible = reader.ReadBoolean();
                float opacity = reader.ReadSingle();
                PropertyCollection props = new PropertyCollection();
                props.Read(reader);

                // using the type, figure out which object to create
                if (type == "layer")
                {
                    int[] data = reader.ReadObject<int[]>();
                    layer = new TileLayer(name, width, height, visible, opacity, props, this, data);
                }
                else if (type == "objectgroup")
                {
                    List<MapObject> objects = new List<MapObject>();

                    // read in all of our objects
                    int numObjects = reader.ReadInt32();
                    for (int j = 0; j < numObjects; j++)
                    {
                        string objName = reader.ReadString();
                        string objType = reader.ReadString();
                        Rectangle objLoc = reader.ReadObject<Rectangle>();
                        List<Point> objPoints = reader.ReadObject<List<Point>>();
                        PropertyCollection objProps = new PropertyCollection();
                        objProps.Read(reader);

                        objects.Add(new MapObject(objName, objType, objLoc, objPoints, objProps));
                    }

                    layer = new MapObjectLayer(name, width, height, visible, opacity, props, objects);
                }
                else
                {
                    throw new Exception("Invalid type: " + type);
                }

                layers.Add(layer);
                namedLayers.Add(name, layer);
            }
        }
コード例 #8
0
        //private Layer collisionLayer;

        // Construct a TiledLib.Map from a TmxReader.map
        public Map(ContentManager content, string mapName)
        {
            string mapPath = AppDomain.CurrentDomain.BaseDirectory +
                             "Content/" +
                             mapName +
                             ".tmx";

            TmxMap tmx = new TmxMap(mapPath);

            Version = new Version(tmx.Version);

            switch (tmx.Orientation)
            {
            case TmxMap.OrientationType.Isometric:
                Orientation = Orientation.Isometric;
                break;

            case TmxMap.OrientationType.Orthogonal:
                Orientation = Orientation.Orthogonal;
                break;

            case TmxMap.OrientationType.Staggered:
                throw new Exception(
                          "TiledLib doesn't support maps with Staggered " +
                          "orientation.");
            }

            Width      = tmx.Width;
            Height     = tmx.Height;
            TileWidth  = tmx.TileWidth;
            TileHeight = tmx.TileHeight;

            Properties = new PropertyCollection();
            foreach (KeyValuePair <string, string> kvp in tmx.Properties)
            {
                Properties.Add(kvp);
            }

            // Create a list for our tiles
            List <Tile> tiles = new List <Tile>();

            Tiles = new Collection <Tile>(tiles);

            // Read in each TileSet
            foreach (TmxTileset ts in tmx.Tilesets)
            {
                string    tilesetName = ts.Name;
                Texture2D texture     = content.Load <Texture2D>(ts.Image.Source);

                bool collisionSet = ts.Properties.ContainsKey("CollisionSet") &&
                                    ts.Properties["CollisionSet"] == "True" ?
                                    true : false;

                /* TODO:  Add this intelligence to TiledSharp.
                 * If the texture is bigger than a individual tile, infer all the
                 * additional tiles that must be created.
                 */

                if (texture.Width > ts.TileWidth || texture.Height > ts.TileHeight)
                {
                    // Deconstruct tileset to individual tiles
                    int id = 0;
                    for (int y = 0; y < texture.Height / ts.TileHeight; y++)
                    {
                        for (int x = 0; x < texture.Width / ts.TileWidth; x++)
                        {
                            Rectangle source = new Rectangle(
                                x * ts.TileWidth,
                                y * ts.TileHeight,
                                ts.TileWidth,
                                ts.TileHeight
                                );

                            Color[]            collisionData    = null;
                            bool[]             collisionBitData = null;
                            PropertyCollection props            = new PropertyCollection();

                            TmxTilesetTile tsTile = ts.Tiles.Find(i => i.Id == id);
                            if (tsTile != null)
                            {
                                foreach (KeyValuePair <string, string> kvp in
                                         tsTile.Properties)
                                {
                                    props.Add(kvp);

                                    // Inherit tilesets collision
                                    bool collidable = collisionSet;
                                    if (kvp.Key == "CollisionSet")
                                    {
                                        // Allow override per tile
                                        if (kvp.Value == "True")
                                        {
                                            collidable = true;
                                        }
                                        else
                                        {
                                            collidable = false;
                                        }
                                    }
                                    if (collidable)
                                    {
                                        int numOfBytes = ts.TileWidth * ts.TileHeight;
                                        collisionData    = new Color[numOfBytes];
                                        collisionBitData = new bool[numOfBytes];

                                        texture.GetData <Color>(
                                            0,
                                            source,
                                            collisionData,
                                            0,
                                            numOfBytes
                                            );

                                        for (int col = 0; col < numOfBytes; col++)
                                        {
                                            if (collisionData[col].A > 0)
                                            {
                                                collisionBitData[col] = true;
                                            }
                                        }
                                        collisionData = null;
                                    }
                                }
                            }

                            Tile t = new Tile(
                                texture,
                                source,
                                props,
                                collisionBitData
                                );

                            while (id >= tiles.Count)
                            {
                                tiles.Add(null);
                            }
                            tiles.Insert(id + ts.FirstGid, t);
                            id++;
                        }
                    }
                }
            }

            // Process Map Items (layers, objectgroups, etc.)
            List <Layer> layers = new List <Layer>();

            Layers = new Collection <Layer>(layers);

            foreach (TmxLayer l in tmx.Layers)
            {
                Layer layer = null;

                PropertyCollection props = new PropertyCollection();
                foreach (KeyValuePair <string, string> kvp in l.Properties)
                {
                    props.Add(kvp);
                }


                layer = new TileLayer(
                    l.Name,
                    tmx.Width,  // As of TiledQT always same as layer.
                    tmx.Height, // As of TiledQT always same as layer.
                    l.Visible,
                    (float)l.Opacity,
                    props,
                    this,
                    l.Tiles
                    );
                layers.Add(layer);
                namedLayers.Add(l.Name, layer);
            }

            foreach (TmxObjectGroup og in tmx.ObjectGroups)
            {
                Layer layer = null;

                PropertyCollection props = new PropertyCollection();
                foreach (KeyValuePair <string, string> kvp in og.Properties)
                {
                    props.Add(kvp);
                }

                List <MapObject> objects = new List <MapObject>();

                // read in all of our objects
                foreach (TmxObjectGroup.TmxObject i in og.Objects)
                {
                    Rectangle objLoc = new Rectangle(
                        i.X,
                        i.Y,
                        i.Width,
                        i.Height
                        );

                    List <Point> objPoints = new List <Point>();
                    if (i.Points != null)
                    {
                        foreach (Tuple <int, int> tuple in i.Points)
                        {
                            objPoints.Add(new Point(tuple.Item1, tuple.Item2));
                        }
                    }

                    PropertyCollection objProps = new PropertyCollection();
                    foreach (KeyValuePair <string, string> kvp in i.Properties)
                    {
                        objProps.Add(kvp);
                    }

                    objects.Add(
                        new MapObject(
                            i.Name,
                            i.Type,
                            objLoc,
                            objPoints,
                            objProps)
                        );
                }

                layer = new MapObjectLayer(
                    og.Name,
                    tmx.Width,
                    tmx.Height,
                    og.Visible,
                    (float)og.Opacity,
                    props,
                    objects
                    );

                layers.Add(layer);
                namedLayers.Add(og.Name, layer);
            }
        }
コード例 #9
0
ファイル: Map.cs プロジェクト: Wydra/WickedEngine
        internal Map(ContentReader reader)
        {
            // read in the basic map information
            Version = new Version(reader.ReadString());
            Orientation = (Orientation)reader.ReadByte();
            WidthInTiles = reader.ReadInt32();
            HeightInTiles = reader.ReadInt32();
            TileWidth = reader.ReadInt32();
            TileHeight = reader.ReadInt32();
            Properties = new PropertyCollection(reader);
            bool makeTilesUnique = reader.ReadBoolean();

            // create a list for our tiles
            List<Tile> tiles = new List<Tile>();
            Tiles = new ReadOnlyCollection<Tile>(tiles);

            // read in each tile set
            int numTileSets = reader.ReadInt32();
            for (int i = 0; i < numTileSets; i++)
            {
                // get the id and texture
                int firstId = reader.ReadInt32();
                Texture2D texture = reader.ReadExternalReference<Texture2D>();

                // read in each individual tile
                int numTiles = reader.ReadInt32();
                for (int j = 0; j < numTiles; j++)
                {
                    int id = firstId + j;
                    Rectangle source = reader.ReadObject<Rectangle>();
                    PropertyCollection props = new PropertyCollection(reader);

                    Tile t = new Tile(texture, source, props);
                    while (id >= tiles.Count)
                    {
                        tiles.Add(null);
                    }
                    tiles.Insert(id, t);
                }
            }

            // read in all the layers
            List<Layer> layers = new List<Layer>();
            Layers = new ReadOnlyCollection<Layer>(layers);
            int numLayers = reader.ReadInt32();
            for (int i = 0; i < numLayers; i++)
            {
                Layer layer = null;

                // read generic layer data
                string type = reader.ReadString();
                string name = reader.ReadString();
                int width = reader.ReadInt32();
                int height = reader.ReadInt32();
                bool visible = reader.ReadBoolean();
                float opacity = reader.ReadSingle();
                PropertyCollection props = new PropertyCollection(reader);

                // calculate the default layer depth of the layer
                float layerDepth = 1f - (LayerDepthSpacing * i);

                // using the type, figure out which object to create
                if (type == "layer")
                {
                    uint[] data = reader.ReadObject<uint[]>();
                    layer = new TileLayer(name, width, height, layerDepth, visible, opacity, props, this, data, makeTilesUnique);
                }
                else if (type == "objectgroup")
                {
                    List<MapObject> objects = new List<MapObject>();

                    // read in all of our objects
                    int numObjects = reader.ReadInt32();
                    for (int j = 0; j < numObjects; j++)
                    {
                        string objName = reader.ReadString();
                        string objType = reader.ReadString();
                        Rectangle objLoc = reader.ReadObject<Rectangle>();
                        PropertyCollection objProps = new PropertyCollection(reader);

                        objects.Add(new MapObject(objName, objType, objLoc, objProps));
                    }

                    layer = new MapObjectLayer(name, width, height, layerDepth, visible, opacity, props, objects);

                    // read in the layer's color
                    (layer as MapObjectLayer).Color = reader.ReadColor();
                }
                else
                {
                    throw new Exception("Invalid type: " + type);
                }

                layers.Add(layer);
                namedLayers.Add(name, layer);
            }
        }
コード例 #10
0
        public void LoadContent(ContentManager content, MapObjectLayer spawnLayer)
        {
            VoxelSprite asteroid = new VoxelSprite(16,16,16);
            LoadVoxels.LoadSprite(Path.Combine(content.RootDirectory, "enemies", "asteroids.vxs"), ref asteroid);
            spriteSheets.Add("Asteroid", asteroid);
            VoxelSprite omega = new VoxelSprite(15,15,15);
            LoadVoxels.LoadSprite(Path.Combine(content.RootDirectory, "enemies", "omega.vxs"), ref omega);
            spriteSheets.Add("Omega", omega);
            VoxelSprite turret = new VoxelSprite(15, 15, 15);
            LoadVoxels.LoadSprite(Path.Combine(content.RootDirectory, "enemies", "turret.vxs"), ref turret);
            spriteSheets.Add("Turret", turret);
            VoxelSprite squid = new VoxelSprite(15, 15, 15);
            LoadVoxels.LoadSprite(Path.Combine(content.RootDirectory, "enemies", "squid.vxs"), ref squid);
            spriteSheets.Add("Squid", squid);

            foreach (MapObject o in spawnLayer.Objects) Spawns.Add(o);
        }