An XTiled TMX Map
Example #1
0
        public SnakeLevel(Map map)
        {
            TiledMap = map;

            LevelType = (SnakeLevelType)Enum.Parse(typeof(SnakeLevelType), map.Properties["LevelType"].Value);
            switch (LevelType)
            {
                case SnakeLevelType.Arcade:
                    break;
                case SnakeLevelType.Puzzle:
                    IsCollectLimited = map.Properties.ContainsKey("IsCollectLimited") ? bool.Parse(map.Properties["IsCollectLimited"].Value) : false;
                    IsScoreLimited = map.Properties.ContainsKey("IsScoreLimited") ? bool.Parse(map.Properties["IsScoreLimited"].Value) : false;
                    IsTimeLimited = map.Properties.ContainsKey("IsTimeLimited") ? bool.Parse(map.Properties["IsTimeLimited"].Value) : false;
                    FoodVanish = map.Properties.ContainsKey("FoodVanish") ? bool.Parse(map.Properties["FoodVanish"].Value) : false;
                    FoodAddsSpeed = map.Properties.ContainsKey("FoodAddsSpeed") ? bool.Parse(map.Properties["FoodAddsSpeed"].Value) : false;

                    FoodRequired = IsCollectLimited ? (int?)int.Parse(map.Properties["FoodRequired"].Value) : null;
                    ScoreRequired = IsScoreLimited ? (int?)int.Parse(map.Properties["ScoreRequired"].Value) : null;
                    TimeLimit = IsTimeLimited ? (int?)int.Parse(map.Properties["TimeLimit"].Value) : null;
                    RemainingTime = TimeLimit;
                    break;
                case SnakeLevelType.Timed:
                    IsTimeLimited = bool.Parse(map.Properties["IsTimeLimited"].Value);
                    TimeLimit = int.Parse(map.Properties["TimeLimit"].Value);
                    RemainingTime = TimeLimit;
                    break;
                default:
                    break;
            }
        }
Example #2
0
 public static void Init(GraphicsDevice device, Map tiledMap)
 {
     if (!init)
     {
         offset = new Point((device.PresentationParameters.BackBufferWidth - (tiledMap.Width * tiledMap.TileWidth)) / 2,
                         (device.PresentationParameters.BackBufferHeight - (tiledMap.Height * tiledMap.TileHeight)) / 4);
     }
 }
Example #3
0
 public void LoadMap(string mapName)
 {
     map = Content.Load<Map>(@"Levels\1");
     foreach (ObjectLayer objectLayer in map.ObjectLayers)
     {
         foreach (MapObject mapObject in objectLayer.MapObjects)
         {
             LoadObject(mapObject);
         }
     }
 }
Example #4
0
        /// <summary>
        /// Allows the game component to perform any initialization it needs to before starting
        /// to run.  This is where it can query for any required services and load content.
        /// </summary>
        public void Initialize(Rectangle viewBounds, Map map)
        {
            this.map = map;
             mapView = new Rectangle(0, 0, viewBounds.Width, viewBounds.Height);

             for (int i = 0; i < map.ObjectLayers.Count; i++)
             {
            switch (map.ObjectLayers[i].Name)
            {
               case "Collision":
                  collisionLayer = i;
                  break;
               case "Death":
                  deathLayer = i;
                  break;
               case "Objective":
                  objectiveLayer = i;
                  break;
               default:
                  break;
            }
             }
        }
Example #5
0
        public void getDrawTranslation(ref Matrix mx, ref Rectangle viewPort, ref Map mp)
        {
            float cameraX, cameraY;

            if (mx == null || focusEntity == null)
            {
                return;
            }

            if (focusEntity.Position.X < viewPort.Width / 2)
            {
                cameraX = -viewPort.Width / 2;
            }
            else if (focusEntity.Position.X > (mp.TileWidth * mp.Width) - viewPort.Width / 2)
            {
                cameraX = (-1)*((mp.TileWidth * mp.Width) - viewPort.Width / 2);
            }
            else
            {
                cameraX = -focusEntity.Position.X;
            }

            if (focusEntity.Position.Y < viewPort.Height / 2)
            {
                cameraY = -viewPort.Height / 2;
            }
            else if (focusEntity.Position.Y > (mp.TileHeight * mp.Height) - viewPort.Height / 2)
            {
                cameraY = (-1) * ((mp.TileHeight * mp.Height) - viewPort.Height / 2);
            }
            else
            {
                cameraY = -focusEntity.Position.Y;
            }

            mx = Matrix.CreateTranslation(cameraX, cameraY, 0.0f) * Matrix.CreateScale(1.0f) * Matrix.CreateTranslation(viewPort.Width / 2, viewPort.Height / 2, 0.0f);
        }
Example #6
0
        public void getDrawRectangle(ref Rectangle rx, ref Rectangle viewPort, ref Map mp)
        {
            float cameraX, cameraY;

            if (rx == null || focusEntity == null)
            {
                return;
            }

            if (focusEntity.Position.X < viewPort.Width / 2)
            {
                cameraX = 0;
            }
            else if (focusEntity.Position.X > (mp.TileWidth * mp.Width) - viewPort.Width / 2)
            {
                cameraX = ((mp.TileWidth * mp.Width) - viewPort.Width);
            }
            else
            {
                cameraX = focusEntity.Position.X - viewPort.Width / 2;
            }

            if (focusEntity.Position.Y < viewPort.Height / 2)
            {
                cameraY = 0;
            }
            else if (focusEntity.Position.Y > (mp.TileHeight * mp.Height) - viewPort.Height / 2)
            {
                cameraY = ((mp.TileHeight * mp.Height) - viewPort.Height);
            }
            else
            {
                cameraY = focusEntity.Position.Y - viewPort.Height / 2;
            }

            rx = new Rectangle((int)cameraX, (int)cameraY, viewPort.Width, viewPort.Height);
        }
Example #7
0
        public Hitbox(Map map)
        {
            hitboxes = new List<Rectangle>();
            foreach (var tiles in map.TileLayers[map.TileLayers.Count - 2].Tiles)
            {
                foreach (var tile in tiles)
                {
                    if (tile != null)
                    {
                        hitboxes.Add(tile.Target);
                    }
                }
            }
            doors = new List<List<Rectangle>>
                {
                    new List<Rectangle>(),
                    new List<Rectangle>(),
                    new List<Rectangle>(),
                    new List<Rectangle>(),
                    new List<Rectangle>()
                };

            for (int i = 0; i < 5; i++)
            {
                foreach (var tiles in map.TileLayers[i + 4].Tiles)
                {
                    foreach (var tile in tiles)
                    {
                        if (tile != null)
                        {
                            doors[i].Add(tile.Target);
                        }
                    }
                }
            }
        }
Example #8
0
        public override void LoadContent()
        {
            Intialize();
            ContentManager content = ScreenManager.Game.Content;
            Players.Add(SnakeFactory.CreateFromTemplate("default"));

            gameFont = ScreenManager.Game.Content.Load<SpriteFont>("gamefont");
            scoreFont = ScreenManager.Game.Content.Load<SpriteFont>("scorefont");
            //gameBackground = ScreenManager.Game.Content.Load<Texture2D>("sky_bg");
            //midGround = ScreenManager.Game.Content.Load<Texture2D>("midground_grasshill");
            cherryFood = ScreenManager.Game.Content.Load<Texture2D>("cherry");
            bananaFood = ScreenManager.Game.Content.Load<Texture2D>("bananas");

            tiledMap = content.Load<Map>(TiledMapName);

            SnakeHelper.Init(ScreenManager.GraphicsDevice, tiledMap);
            tiledMap.Offset = SnakeHelper.offset;
            CurrentLevel = new SnakeLevel(tiledMap);

            //GridMap needs to be last due to reliance on Map and SnakeLevel
            map = new GridMap(CurrentLevel);
        }
Example #9
0
        // pass a map and a vector stating where you'd like to move to
        // this method checks against nearby walls and prevents you from overdoing boundaries
        // this method modifies step
        public void checkForWalls(Map checkMap, ref Vector2 delta)
        {
            if (this.horizontal_pos < 0 || this.vertical_pos < 0 || this.horizontal_pos + this.width >= checkMap.Width * checkMap.TileWidth || this.vertical_pos + this.height >= checkMap.Height * checkMap.TileHeight)
            {
                return;
            }

            foreach (TileLayer layer in checkMap.TileLayers)
            {
                bool isSolid = false;

                foreach (KeyValuePair<string, Property> p in layer.Properties)
                {
                    if (p.Key.Equals("solid") && p.Value.AsInt32 == 1)
                    {
                        isSolid = true;
                    }
                }

                if (isSolid == true)
                {
                    // horizontal map check
                    if (delta.X - horizontal_pos < -0.0001)
                    {
                        int i;
                        for (i = ((int)delta.X) / checkMap.TileWidth; i >= 0; i--)
                        {
                            if (layer.Tiles[i][((int)vertical_pos) / checkMap.TileHeight] != null || layer.Tiles[i][((int)(vertical_pos + height)) / checkMap.TileHeight] != null)
                            {
                                break;
                            }
                        }

                        if ((i + 1) * checkMap.TileWidth > delta.X)
                        {
                            velocity.X = 0.0f;
                        }

                        delta.X = Math.Max(delta.X, (i + 1) * checkMap.TileWidth);
                    }
                    else if (delta.X - horizontal_pos > 0.0001)
                    {
                        int i;
                        for (i = ((int)(delta.X + width)) / checkMap.TileWidth; i < checkMap.Width; i++)
                        {
                            if (layer.Tiles[i][((int)vertical_pos) / checkMap.TileHeight] != null || layer.Tiles[i][((int)(vertical_pos + height)) / checkMap.TileHeight] != null)
                            {
                                break;
                            }
                        }

                        if ((i) * checkMap.TileWidth < delta.X + width)
                        {
                            velocity.X = 0.0f;
                        }

                        delta.X = Math.Min(delta.X, (i - 1) * checkMap.TileWidth);
                    }

                    // vertical map check
                    if (delta.Y - vertical_pos < -0.0001)
                    {
                        int i;
                        for (i = ((int)delta.Y) / checkMap.TileHeight; i >= 0; i--)
                        {
                            if (layer.Tiles[((int)horizontal_pos) / checkMap.TileWidth][i] != null || layer.Tiles[((int)(horizontal_pos + width)) / checkMap.TileWidth][i] != null)
                            {
                                onTheGround = false;

                                break;
                            }
                        }

                        if ((i + 1) * checkMap.TileHeight > delta.Y)
                        {
                            velocity.Y = 0.0f;
                        }

                        delta.Y = Math.Max(delta.Y, (i + 1) * checkMap.TileHeight);
                    }
                    else if (delta.Y - vertical_pos > 0.0001)
                    {
                        int i;
                        for (i = ((int)(delta.Y + height)) / checkMap.TileHeight; i < checkMap.Height; i++)
                        {
                            if (layer.Tiles[((int)horizontal_pos) / checkMap.TileWidth][i] != null || layer.Tiles[((int)(horizontal_pos + width)) / checkMap.TileWidth][i] != null)
                            {
                                break;
                            }
                        }

                        if ((i - 1) * checkMap.TileHeight < delta.Y)
                        {
                            onTheGround = true;
                        }
                        else
                        {
                            onTheGround = false;
                        }

                        //if ((i + 1) * checkMap.TileHeight < delta.Y)
                        if (Math.Min(delta.Y, (i - 1) * checkMap.TileHeight) < delta.Y)
                        {
                            velocity.Y = 0.0f;
                        }

                        delta.Y = Math.Min(delta.Y, (i - 1) * checkMap.TileHeight);
                    }
                }
            }
        }
        private void loadLevelThread()
        {
            #if XBOX
            Thread.CurrentThread.SetProcessorAffinity(Game1.loadThread);
            #endif

            Monitor.Enter(levelEntities);
            grabbed = true;

            if (Entity.globalEntityList != null)
            {
                Entity.globalEntityList.Clear();
                Entity.globalEntityList.TrimExcess();
            }

            tagLineA = "LEVEL " + (Game1.CurrentLevel + 1);
            tagLineB = Game1.levelNames[Game1.CurrentLevel];

            switch (Game1.CurrentLevel)
            {
                case 0:
                    parallax1 = null;
                    parallax2 = "cityParallax2";
                    parallax3 = "cityParallax3";
                    levelSong = "songs/song0";
                    break;
                case 1:
                    levelSong = "songs/song1";
                    parallax1 = null;
                    parallax2 = "cityParallax2";
                    parallax3 = "cityParallax3";
                    break;
                case 2:
                    levelSong = "songs/song2";
                    parallax1 = "sewerParallax3";
                    parallax2 = "sewerParallax2";
                    parallax3 = "sewerParallax1";
                    break;
                case 3:
                    levelSong = "songs/song3";
                    parallax1 = "factoryParallax1";
                    parallax2 = "factoryParallax2";
                    parallax3 = "factoryParallax3";
                    break;
                case 4:
                    levelSong = "songs/song4";
                    parallax1 = "factoryParallax1";
                    parallax2 = "factoryParallax2";
                    parallax3 = "sewerParallax1";
                    break;
                default:
                    break;
            }

            levelMap = contentManager.Load<Map>(levelName);

            foreach (ObjectLayer layer in levelMap.ObjectLayers)
            {
                foreach (MapObject obj in layer.MapObjects)
                {
                    Entity en = null;

                    switch (obj.Name)
                    {
                        case "player":
                            if (checkPointTouched == false)
                            {
                                en = new Player(obj.Bounds.X, obj.Bounds.Y);
                                checkPointTime = 0.0f;
                                levelRecordTime = 0;
                            }
                            else
                            {
                                en = new Player(respawnPosition.X, respawnPosition.Y);
                                levelRecordTime = checkPointTime;
                            }
                            levelEntities.Add(en);
                            levelCamera.setNewFocus(ref en);
                            break;
                        case "wm_pos":
                            levelEntities.Add(new WallMagnet(obj.Bounds.X, obj.Bounds.Y, Entity.Polarity.Positive));
                            break;
                        case "wm_neg":
                            levelEntities.Add(new WallMagnet(obj.Bounds.X, obj.Bounds.Y, Entity.Polarity.Negative));
                            break;
                        case "walker_pos":
                            levelEntities.Add(new Enemy(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "walker_neg":
                            levelEntities.Add(new Enemy(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "jumper_pos":
                            levelEntities.Add(new JumpingEnemy(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "factory_conveyer_left":
                            levelEntities.Add(new ConveyerBelt(obj.Bounds.X, obj.Bounds.Y, ConveyerBelt.ConveyerSpot.Left));
                            break;
                        case "factory_conveyer_mid":
                            levelEntities.Add(new ConveyerBelt(obj.Bounds.X, obj.Bounds.Y, ConveyerBelt.ConveyerSpot.Mid));
                            break;
                        case "factory_conveyer_right":
                            levelEntities.Add(new ConveyerBelt(obj.Bounds.X, obj.Bounds.Y, ConveyerBelt.ConveyerSpot.Right));
                            break;
                        case "spikes_up":
                            levelEntities.Add(new Spikes(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "angrySaw":
                            levelEntities.Add(new AngrySaw(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "lava":
                            levelEntities.Add(new Lava(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "lavaDumper":
                            if (obj.Properties.ContainsKey("interval"))
                            {
                                levelEntities.Add(new LavaDumper(obj.Bounds.X, obj.Bounds.Y, (double)(obj.Properties["interval"].AsSingle)));
                            }
                            else
                            {
                                levelEntities.Add(new LavaDumper(obj.Bounds.X, obj.Bounds.Y));
                            }
                            break;
                        case "endLevelFlag":
                            levelEntities.Add(new EndLevelFlag(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "lolrus":
                            levelEntities.Add(new Lolrus(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "wallEntity":
                            levelEntities.Add(new climbWall(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "shieldDudeRight":
                            levelEntities.Add(new ShieldDude(obj.Bounds.X, obj.Bounds.Y, true));
                            break;
                        case "shieldDudeLeft":
                            levelEntities.Add(new ShieldDude(obj.Bounds.X, obj.Bounds.Y, false));
                            break;
                        case "heartItem":
                            levelEntities.Add(new HealthItem(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "boss":
                            levelEntities.Add(new Boss(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "flagDoor":
                            if (obj.Properties["color"].Value == "blue")
                            {
                                levelEntities.Add(new FlagDoor(obj.Bounds.X, obj.Bounds.Y, FlagColor.Blue));
                            }
                            else if (obj.Properties["color"].Value == "green")
                            {
                                levelEntities.Add(new FlagDoor(obj.Bounds.X, obj.Bounds.Y, FlagColor.Green));
                            }
                            else if (obj.Properties["color"].Value == "red")
                            {
                                levelEntities.Add(new FlagDoor(obj.Bounds.X, obj.Bounds.Y, FlagColor.Red));
                            }
                            else if (obj.Properties["color"].Value == "yellow")
                            {
                                levelEntities.Add(new FlagDoor(obj.Bounds.X, obj.Bounds.Y, FlagColor.Yellow));
                            }
                            else if (obj.Properties["color"].Value == "purple")
                            {
                                levelEntities.Add(new FlagDoor(obj.Bounds.X, obj.Bounds.Y, FlagColor.Purple));
                            }
                            break;
                        case "flagLock":
                            if (obj.Properties["color"].Value == "blue")
                            {
                                levelEntities.Add(new FlagLock(obj.Bounds.X, obj.Bounds.Y, FlagColor.Blue));
                            }
                            else if (obj.Properties["color"].Value == "green")
                            {
                                levelEntities.Add(new FlagLock(obj.Bounds.X, obj.Bounds.Y, FlagColor.Green));
                            }
                            else if (obj.Properties["color"].Value == "red")
                            {
                                levelEntities.Add(new FlagLock(obj.Bounds.X, obj.Bounds.Y, FlagColor.Red));
                            }
                            else if (obj.Properties["color"].Value == "yellow")
                            {
                                levelEntities.Add(new FlagLock(obj.Bounds.X, obj.Bounds.Y, FlagColor.Yellow));
                            }
                            else if (obj.Properties["color"].Value == "purple")
                            {
                                levelEntities.Add(new FlagLock(obj.Bounds.X, obj.Bounds.Y, FlagColor.Purple));
                            }
                            break;
                        case "flagKey":
                            if (obj.Properties["color"].Value == "blue")
                            {
                                levelEntities.Add(new FlagKey(obj.Bounds.X, obj.Bounds.Y, FlagColor.Blue));
                            }
                            else if (obj.Properties["color"].Value == "green")
                            {
                                levelEntities.Add(new FlagKey(obj.Bounds.X, obj.Bounds.Y, FlagColor.Green));
                            }
                            else if (obj.Properties["color"].Value == "red")
                            {
                                levelEntities.Add(new FlagKey(obj.Bounds.X, obj.Bounds.Y, FlagColor.Red));
                            }
                            else if (obj.Properties["color"].Value == "yellow")
                            {
                                levelEntities.Add(new FlagKey(obj.Bounds.X, obj.Bounds.Y, FlagColor.Yellow));
                            }
                            else if (obj.Properties["color"].Value == "purple")
                            {
                                levelEntities.Add(new FlagKey(obj.Bounds.X, obj.Bounds.Y, FlagColor.Purple));
                            }
                            break;
                        case "tutorialSign":
                            if (obj.Properties["message"].Value == "message1")
                            {
                                levelEntities.Add(new TutorialSign(obj.Bounds.X, obj.Bounds.Y, (TutorialSign.SignMessage)1));
                            }
                            else if (obj.Properties["message"].Value == "message2")
                            {
                                levelEntities.Add(new TutorialSign(obj.Bounds.X, obj.Bounds.Y, (TutorialSign.SignMessage)2));
                            }
                            else if (obj.Properties["message"].Value == "message3")
                            {
                                levelEntities.Add(new TutorialSign(obj.Bounds.X, obj.Bounds.Y, (TutorialSign.SignMessage)3));
                            }
                            else if (obj.Properties["message"].Value == "message4")
                            {
                                levelEntities.Add(new TutorialSign(obj.Bounds.X, obj.Bounds.Y, (TutorialSign.SignMessage)4));
                            }
                            else if (obj.Properties["message"].Value == "message5")
                            {
                                levelEntities.Add(new TutorialSign(obj.Bounds.X, obj.Bounds.Y, (TutorialSign.SignMessage)5));
                            }
                            else if (obj.Properties["message"].Value == "message6")
                            {
                                levelEntities.Add(new TutorialSign(obj.Bounds.X, obj.Bounds.Y, (TutorialSign.SignMessage)6));
                            }
                            break;
                        case "bossShield":
                            levelEntities.Add(new bossShield(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "walkMarker":
                            levelEntities.Add(new WalkMarker(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "goomba":
                            levelEntities.Add(new Goomba(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        case "flagCloseSwitch":
                            if (obj.Properties["color"].Value == "blue")
                            {
                                levelEntities.Add(new FlagCloseSwitch(obj.Bounds.X, obj.Bounds.Y, FlagColor.Blue));
                            }
                            else if (obj.Properties["color"].Value == "yellow")
                            {
                                levelEntities.Add(new FlagCloseSwitch(obj.Bounds.X, obj.Bounds.Y, FlagColor.Yellow));
                            }
                            else if (obj.Properties["color"].Value == "red")
                            {
                                levelEntities.Add(new FlagCloseSwitch(obj.Bounds.X, obj.Bounds.Y, FlagColor.Red));
                            }
                            else if (obj.Properties["color"].Value == "purple")
                            {
                                levelEntities.Add(new FlagCloseSwitch(obj.Bounds.X, obj.Bounds.Y, FlagColor.Purple));
                            }
                            else if (obj.Properties["color"].Value == "green")
                            {
                                levelEntities.Add(new FlagCloseSwitch(obj.Bounds.X, obj.Bounds.Y, FlagColor.Green));
                            }
                            break;
                        case "easterEgg":
                            levelEntities.Add(new EasterEgg(obj.Bounds.X, obj.Bounds.Y));
                            break;
                        default:
                            break;
                    }
                }
            }

            Thread.Sleep(1500);

            Monitor.Exit(levelEntities);
        }
Example #11
0
        private void DrawLayersInOrder(Map map, SpriteBatch spriteBatch, Rectangle viewport)
        {
            float layerDepth = 1.0f;
            float layerDepthDec = 1.0f / (float)map.LayerOrder.Length;

            foreach (var layer in map.LayerOrder)
            {
                switch (layer.LayerType)
                {
                    case LayerType.TileLayer:
                        map.DrawLayer(spriteBatch, layer.ID, viewport, layerDepth);
                        break;

                    case LayerType.ObjectLayer:
                        map.DrawObjectLayer(spriteBatch, layer.ID, viewport, layerDepth);
                        break;

                    case LayerType.ImageLayer:
                        map.DrawImageLayer(spriteBatch, layer.ID, viewport, layerDepth);
                        break;
                }

                layerDepth -= layerDepthDec;
            }
        }
Example #12
0
        private void InitCollisionCells(Map tiledMap)
        {
            int tileYIndex = tiledMap.TileLayers["Environment"].Tiles[0].Count();
            int tileXIndex = tiledMap.TileLayers["Environment"].Tiles.Count();
            for (int y = 0; y < tileYIndex; y++)
            {

                for (int x = 0; x < tileXIndex; x++)
                {
                    if (tiledMap.TileLayers["Environment"].Tiles[x][y] != null)
                    {
                        int sourceId = tiledMap.TileLayers["Environment"].Tiles[x][y].SourceID;
                        if (tiledMap.SourceTiles[sourceId].Properties.Keys.Contains("Col"))
                        {
                            cellsInUse.Add(this.Cells[y * this.Width + x]);
                        }
                    }
                }
            }
        }
Example #13
0
        public void DrawLayer(SpriteBatch spriteBatch, Map map, Int32 layerID, ref Rectangle region, Single layerDepth)
        {
            // Tiles are stored in a multidimensional array.
            // By converting the map coordinates to tile coordinates
            // we can eliminate the need for bound checking
            Int32 txMin = region.X / map.TileWidth;
            Int32 txMax = (region.X + region.Width) / map.TileWidth;
            Int32 tyMin = region.Y / map.TileHeight;
            Int32 tyMax = (region.Y + region.Height) / map.TileHeight;

            for (int y = tyMin; y <= tyMax; y++)
            {
                for (int x = txMin; x <= txMax; x++)
                {

                    // check that we aren't going outside the map, and that there is a tile at this location
                    if (x < map.TileLayers[layerID].Tiles.Length && y < map.TileLayers[layerID].Tiles[x].Length
                        && map.TileLayers[layerID].Tiles[x][y] != null)
                    {
                        map.TileLayers[layerID].OpacityColor = Color.White;

                        // adjust the tiles map coordinates to screen space
                        Rectangle tileTarget = map.TileLayers[layerID].Tiles[x][y].Target;
                        tileTarget.X = tileTarget.X - region.X;
                        tileTarget.Y = tileTarget.Y - region.Y;

                        spriteBatch.Draw(
                            // the texture (image) of the tile sheet is mapped by
                            // Tile.SourceID -> TileLayers.TilesetID -> Map.Tileset.Texture
                            map.Tilesets[map.SourceTiles[map.TileLayers[layerID].Tiles[x][y].SourceID].TilesetID].Texture,

                            // screen space of the tile
                            tileTarget,

                            // source of the tile in the tilesheet
                            map.SourceTiles[map.TileLayers[layerID].Tiles[x][y].SourceID].Source,

                            // layers can have an opacity value, this property is Color.White at the opacity of the layer
                            map.TileLayers[layerID].OpacityColor,

                            // tile rotation value
                            map.TileLayers[layerID].Tiles[x][y].Rotation,

                            // origin of the tile, this is always the center of the tile
                            map.SourceTiles[map.TileLayers[layerID].Tiles[x][y].SourceID].Origin,

                            // tile horizontal or vertical flipping value
                            map.TileLayers[layerID].Tiles[x][y].Effects,

                            // depth for SpriteSortMode
                            layerDepth);
                    }
                }
            }
        }
Example #14
0
        public void Update(GameTime gt, GraphicsDevice graphicsDevice, Map m)
        {
            //Do not display beyond the edge of the map
             Viewport vp = graphicsDevice.Viewport;
             float minX = m.Bounds.X+(vp.Width*0.5f);
             float minY = m.Bounds.Y+(vp.Height*0.5f);
             float maxX = m.Bounds.X+m.Bounds.Width-(vp.Width*0.5f);
             float maxY = m.Bounds.Y+m.Bounds.Height-(vp.Height*0.5f);

             //Following the sprite
             if (isFollowingSprite)
             {
            Vector2 newPos = pos;
            if (!fixedX)
               newPos.X = MathHelper.Clamp(sprite.pos.X, minX, maxX);
            if (!fixedY)
               newPos.Y = MathHelper.Clamp(sprite.pos.Y, minY, maxY);

            pos = newPos;
             }
        }
Example #15
0
        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            PlayerTexture = Content.Load<Texture2D>("Animations/AllCharacterAnimations");
            PlayerTextureDark = Content.Load<Texture2D>("Animations/AllCharacterAnimationsDark");
            DoctorTexture = Content.Load<Texture2D>("Animations/AllCharacterAnimationsDoctor");
            DoctorTextureDark = Content.Load<Texture2D>("Animations/AllCharacterAnimationsDoctorDark");
            NurseTexture = Content.Load<Texture2D>("Animations/AllCharacterAnimationsHoitsu");
            NurseTextureDark = Content.Load<Texture2D>("Animations/AllCharacterAnimationsHoitsuDark");

            WorldTileSheet = Content.Load<Texture2D>("Maps/worldsheet");
            WorldTileSheetDark = Content.Load<Texture2D>("Maps/hellworldsheet");
            PropsTileSheet = Content.Load<Texture2D>("Maps/props");
            PropsTileSheetDark = Content.Load<Texture2D>("Maps/hellprops");

            Menu = Content.Load<Texture2D>("titlescreenhearthand2");
            Credits = Content.Load<Texture2D>("Credits1");

            Start1 = Content.Load<Texture2D>("StartImages/start1");
            Start2 = Content.Load<Texture2D>("StartImages/start2");
            Start3 = Content.Load<Texture2D>("StartImages/start3");
            Start4 = Content.Load<Texture2D>("StartImages/start4");

            End1 = Content.Load<Texture2D>("StartImages/End1");
            End2 = Content.Load<Texture2D>("StartImages/End2");
            End3 = Content.Load<Texture2D>("StartImages/End3");

            MenuMusic = Content.Load<SoundEffect>("Music/1 musa v1");
            Musa1 = Content.Load<SoundEffect>("Music/1_musiikki");
            Musa2 = Content.Load<SoundEffect>("Music/2_musiikki");
            Musa3 = Content.Load<SoundEffect>("Music/3_musiikki");
            Musa4 = Content.Load<SoundEffect>("Music/4_musiikki");
            kirkuna = Content.Load<SoundEffect>("Music/kirkuna");

            instance = MenuMusic.CreateInstance();
            instance.IsLooped = true;
            instance.Volume = volume;
            instance.Play();

            player = new Player(PlayerTexture, new Vector2(55));

            enemies = new List<Enemy> ();

            Map.InitObjectDrawing(GraphicsDevice);
            map = Content.Load<Map>("Maps/Stage");
            mapView = map.Bounds;
            hitbox = new Hitbox(map);
            heartbeat = Content.Load<SoundEffect>("GGJ13_Theme");
            heartbeatInstance = heartbeat.CreateInstance();

            // TODO: use this.Content to load your game content here
        }