Exemple #1
0
        internal TileLayer(string name, int width, int height, bool visible, float opacity, PropertyCollection properties, Map map, int[] data)
            : base(name, width, height, visible, opacity, properties)
        {
            Tiles = new Tile[width, height];

            // data is left-to-right, top-to-bottom
            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    int index = data[y * width + x];
                    Tiles[x, y] = map.Tiles[index];
                }
            }
        }
        protected override void UpdateScreen(GameTime gameTime, DisplayOrientation displayOrientation)
        {
            if (player.CurrentHP < 1)
            {
                changeScreenDelegate(ScreenState.GameOver);
                this.LoadScreenContent(content);
            }

            if (playerCreated && !inBattle)
            {
                GameplayTurnCheck();
            }
            else if (inBattle)
            {
                if (!bossBattle)
                {
                    hud.Update(player);
                    minion.Update(gameTime);

                    if (input.CheckMouseRelease(attackButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed && player.TurnBattle && !minion.dead)
                    {
                        minion.HP -= random.Next(0, player.DAM);
                        player.TurnBattle = false;
                    }

                    if (input.CheckMouseRelease(magicButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed && player.TurnBattle && !minion.dead && player.CurrentMP >= player.MAGCOS)
                    {
                        minion.HP -= random.Next(0, player.MAGDAM);
                        player.CurrentMP -= player.MAGCOS;
                        player.TurnBattle = false;
                    }

                    if (input.CheckMouseRelease(potionButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed && player.TurnBattle && !minion.dead && player.Potions > 0)
                    {
                        player.CurrentHP = player.MaxHP;
                        player.TurnBattle = false;
                        player.Potions--;
                    }

                    if (!player.TurnBattle)
                    {
                        player.CurrentHP -= random.Next(0, minion.DAM);
                        player.TurnBattle = true;
                    }

                    if (minion.HP <= 0)
                    {
                        minion.dead = true;
                        player.CurrentXP += minion.XP;
                        inBattle = false;
                        minion.Reset();
                    }
                }
                else
                {
                    hud.Update(player);
                    boss.Update(gameTime);

                    if (input.CheckMouseRelease(attackButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed && player.TurnBattle && !boss.dead)
                    {
                        boss.HP -= random.Next(0, player.DAM);
                        player.TurnBattle = false;
                    }

                    if (input.CheckMouseRelease(magicButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed && player.TurnBattle && !boss.dead && player.CurrentMP >= player.MAGCOS)
                    {
                        boss.HP -= random.Next(0, player.MAGDAM);
                        player.CurrentMP -= player.MAGCOS;
                        player.TurnBattle = false;
                    }

                    if (input.CheckMouseRelease(potionButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed && player.TurnBattle && !boss.dead && player.Potions > 0)
                    {
                        player.CurrentHP = player.MaxHP;
                        player.TurnBattle = false;
                        player.Potions--;
                    }

                    if (!player.TurnBattle)
                    {
                        player.CurrentHP -= random.Next(0, boss.DAM);
                        player.TurnBattle = true;
                    }

                    if (boss.HP <= 0)
                    {
                        if (mapNumber < 6)
                        {
                            player.Potions += 2;
                            boss.dead = true;
                            player.Pieces++;
                            player.CurrentXP += boss.XP;
                            inBattle = false;
                            boss.Reset();
                            player.TilePosition = new Vector2(1, 17);
                            mapNumber++;
                            tileLayer = null;
                            copyTileLayer = map[mapNumber].GetLayer("Layer") as TileLayer;
                            tileLayer = copyTileLayer;
                            blankTile = tileLayer.Tiles[19, 0];
                            walkableTile = tileLayer.Tiles[19, 1];
                            enemyTile = tileLayer.Tiles[19, 2];
                            exitTile = tileLayer.Tiles[19, 3];
                            enemykilledTile = tileLayer.Tiles[19, 4];
                            bossBattle = false;
                            for (int y = 0; y < tileLayer.Height; y++)
                            {
                                for (int x = 0; x < 19; x++)
                                {
                                    if (tileLayer.Tiles[x, y] == enemykilledTile)
                                    {
                                        tileLayer.Tiles[x, y] = enemyTile;
                                    }
                                }
                            }
                        }
                        else
                        {
                            changeScreenDelegate(ScreenState.GameWin);
                            LoadScreenContent(content);
                        }
                    }
                }
            }
            else
            {
                if (!nameComplete)
                {
                    currentState = Keyboard.GetState();

                    if (currentState.IsKeyDown(Keys.Back))
                    {
                        keydown = '.';
                    }

                    if (currentState.IsKeyUp(Keys.Back) && keydown == '.' && charAmt >= 0)
                    {
                        keydown = (char)0;
                        enteredName[charAmt] = ' ';
                        if (charAmt != 0)
                            charAmt--;
                    }

                    char tempc = GetCharFromKeyboard(currentState);
                    if (charAmt < 8 && tempc != (char)0)
                    {
                        enteredName[charAmt] = tempc;
                        charAmt++;
                    }
                    enteredName[0] = char.ToUpper(enteredName[0]);
                    playername.ChangeText(new string(enteredName));

                    if (input.CheckMouseRelease(confirmnameButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed)
                    {
                        nameComplete = true;
                    }
                }
                else if (!classComplete)
                {
                    if (input.CheckMouseRelease(paladinButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed)
                    {
                        player.CreatePlayer(0, new string(enteredName).ToString());
                        classComplete = true;
                    }

                    if (input.CheckMouseRelease(casterButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed)
                    {
                        player.CreatePlayer(1, new string(enteredName).ToString());
                        classComplete = true;

                    }

                    if (input.CheckMouseRelease(rogueButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed)
                    {
                        player.CreatePlayer(2, new string(enteredName).ToString());
                        classComplete = true;
                    }
                }
                else
                {
                    if (input.CheckMouseRelease(storyContinueButton) && input.PreviousMouseState.LeftButton == ButtonState.Pressed)
                    {
                        if (storyCount < 2)
                        {
                            storyCount++;
                        }
                        else
                        {
                            playerCreated = true;
                        }
                    }
                }
            }
        }
        protected override void LoadScreenContent(ContentManager content)
        {
            background = new Background(content, "Images/GameplayBackground");
            map = new Map[7];
            map[0] = content.Load<Map>("Maps/map01");
            map[1] = content.Load<Map>("Maps/map02");
            map[2] = content.Load<Map>("Maps/map03");
            map[3] = content.Load<Map>("Maps/map04");
            map[4] = content.Load<Map>("Maps/map05");
            map[5] = content.Load<Map>("Maps/map06");
            map[6] = content.Load<Map>("Maps/map07");
            player = new Player(content);
            player.TilePosition = new Vector2(1, 17);
            hud = new HUD(content, player);
            mapNumber = 0;
            leftButton = new Button(content, "", new Vector2(800, 650), Color.White, Color.White, "Images/LeftButton");
            rightButton = new Button(content, "", new Vector2(900, 650), Color.White, Color.White, "Images/RightButton");
            upButton = new Button(content, "", new Vector2(850, 595), Color.White, Color.White, "Images/UpButton");
            downButton = new Button(content, "", new Vector2(850, 705), Color.White, Color.White, "Images/DownButton");

            copyTileLayer = map[mapNumber].GetLayer("Layer") as TileLayer;
            tileLayer = copyTileLayer;
            blankTile = tileLayer.Tiles[19, 0];
            walkableTile = tileLayer.Tiles[19, 1];
            enemyTile = tileLayer.Tiles[19, 2];
            exitTile = tileLayer.Tiles[19, 3];
            enemykilledTile = tileLayer.Tiles[19, 4];

            for (int y = 0; y < tileLayer.Height; y++)
            {
                for (int x = 0; x < 19; x++)
                {
                    if (tileLayer.Tiles[x, y] == enemykilledTile)
                    {
                        tileLayer.Tiles[x, y] = enemyTile;
                    }
                }
            }
            attackButton = new Button(content, "Attack", new Vector2(ScreenWidth / 2 + 220, 250), Color.Blue, Color.White);
            magicButton = new Button(content, "Magic", new Vector2(ScreenWidth / 2 + 220, 325), Color.Blue, Color.White);
            potionButton = new Button(content, "Potion", new Vector2(ScreenWidth / 2 + 220, 400), Color.Blue, Color.White);
            minion = new Minion(content);
            boss = new Boss(content);
            inBattle = false;
            bossBattle = false;

            #region Pregame
            playerCreated = false;
            keydown = (char)0;
            enterplayernameText = new Text(content.Load<SpriteFont>("Fonts/buttonFont"), "Enter Characters Name:", new Vector2(350, 200));
            confirmnameButton = new Button(content, "Enter", new Vector2(425, 550), Color.Blue, Color.White);
            textenterbox = content.Load<Texture2D>("Images/TextInputBar");
            playername = new Text(content.Load<SpriteFont>("Fonts/buttonFont"),"", new Vector2(375, 400), Color.Blue);
            charAmt = 0;
            nameComplete = false;
            enteredName = new char[8];
            for (int i = 0; i < enteredName.Length; i++)
            {
                enteredName[i] = ' ';
            }
            chooseclasstext = new Text(content.Load<SpriteFont>("Fonts/buttonFont"), "Choose Characters Class:", new Vector2(340, 200));
            paladinButton = new Button(content, "Paladin", new Vector2(425, 400), Color.Blue, Color.White);
            casterButton = new Button(content, "Caster", new Vector2(425, 500), Color.Blue, Color.White);
            rogueButton = new Button(content, "Rogue", new Vector2(425, 600), Color.Blue, Color.White);
            storyContinueButton = new Button(content, "Continue", new Vector2(800, 700), Color.Blue, Color.White);
            classComplete = false;
            storytexts = new Texture2D[3];
            storyCount = 0;
            storytexts[0] = content.Load<Texture2D>("Images/Storytext1");
            storytexts[1] = content.Load<Texture2D>("Images/Storytext2");
            storytexts[2] = content.Load<Texture2D>("Images/Storytext3");
            #endregion
        }
Exemple #4
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);
            }
        }
Exemple #5
0
        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);
            }
        }
        /// <summary>
        /// Iterates all tile sets and generates the correct source rectangles for all tiles inside the tilesets.
        /// Additionally reads in the property information for the tiles and stores them alongside the source rectangles
        /// in a Tile object stored in the TileSet's Tiles list.
        /// </summary>
        public static void GenerateTileSourceRectangles(MapContent input, string textureRoot = "")
        {
            // do some processing on tile sets to load external textures and figure out tile regions
            foreach (var tileSet in input.TileSets)
            {
                // get the real path to the image
                string path = Path.Combine(textureRoot, tileSet.Image);

                // load the image so we can compute the individual tile source rectangles
                int imageWidth = 0;
                int imageHeight = 0;
                using (Image image = Image.FromFile(path))
                {
                    imageWidth = image.Width;
                    imageHeight = image.Height;
                }

                // remove the margins from our calculations
                imageWidth -= tileSet.Margin * 2;
                imageHeight -= tileSet.Margin * 2;

                // figure out how many tiles fit on the X axis
                int tileCountX = 0;
                while (tileCountX * tileSet.TileWidth < imageWidth)
                {
                    tileCountX++;
                    imageWidth -= tileSet.Spacing;
                }

                // figure out how many tiles fit on the Y axis
                int tileCountY = 0;
                while (tileCountY * tileSet.TileHeight < imageHeight)
                {
                    tileCountY++;
                    imageHeight -= tileSet.Spacing;
                }

                // make our tiles. tiles are numbered by row, left to right.
                for (int y = 0; y < tileCountY; y++)
                {
                    for (int x = 0; x < tileCountX; x++)
                    {
                        Tile tile = new Tile();

                        // calculate the source rectangle
                        int rx = tileSet.Margin + x * (tileSet.TileWidth + tileSet.Spacing);
                        int ry = tileSet.Margin + y * (tileSet.TileHeight + tileSet.Spacing);
                        tile.Source = new Microsoft.Xna.Framework.Rectangle(rx, ry, tileSet.TileWidth, tileSet.TileHeight);

                        // get any properties from the tile set
                        int index = tileSet.FirstId + (y * tileCountX + x);
                        if (tileSet.TileProperties.ContainsKey(index))
                        {
                            tile.Properties = tileSet.TileProperties[index];
                        }

                        // save the tile
                        tileSet.Tiles.Add(tile);
                    }
                }
            }
        }
Exemple #7
0
        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);
            }
        }
Exemple #8
0
        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
            blank = new Texture2D(GraphicsDevice, 1, 1);
            blank.SetData(new[] { Color.White });

            // load the map
            map = Content.Load<Map>("Map");

            // find the "Box" and "Point" objects we made in the level
            MapObjectLayer objects = map.GetLayer("Objects") as MapObjectLayer;
            point = objects.GetObject("Point");
            box = objects.GetObject("Box");

            // attempt to read the box color from the box object properties
            try
            {
                boxColor.R = (byte)box.Properties["R"];
                boxColor.G = (byte)box.Properties["G"];
                boxColor.B = (byte)box.Properties["B"];
                boxColor.A = 255;
            }
            catch
            {
                // on failure, default to yellow
                boxColor = Color.Yellow;
            }

            // find one tile from our tile layer
            TileLayer tileLayer = map.GetLayer("Tiles") as TileLayer;
            tile = tileLayer.Tiles[0, 0];
        }