Example #1
0
        /// <summary>
        /// Updates the player.
        /// </summary>
        /// <param name="gameTime"> Provides a snapshot of timing values. </param>
        /// <param name="level"> The level in progress. </param>
        public override void Update(GameTime gameTime, Level level)
        {
            foreach (var playerUnit in this.PlayerUnits)
            {
                playerUnit.Update(gameTime);
            }

            // Stupid AI
            // TODO: Improve
            if (gameTime.TotalGameTime.Seconds % 10 == 0)
            {
                this.IsTurnFinished = true;
            }
        }
Example #2
0
        /// <summary>
        /// Draws the unit as a player unit
        /// </summary>
        /// <param name="gameTime"> A snapshot of timing values. </param>
        /// <param name="level"> The current level. </param>
        /// <param name="playerUnit"> The unit </param>
        private void DrawPlayerUnit(GameTime gameTime, Level level, Unit playerUnit)
        {
            var unitOffsetX = (Engine.TileHeight / 2)
                                 - (playerUnit.Sprite.Height / 2);
            var unitOffsetY = (Engine.TileWidth / 2)
                          - (playerUnit.Sprite.Width / 2);

            // Converts the position of the unit to a vector that represents a
            // location on the gamescreen.
            var vect = new Vector2(
                (playerUnit.Sprite.Position.Y * Engine.TileHeight) - level.Camera.Position.X + unitOffsetY,
                (playerUnit.Sprite.Position.X * Engine.TileWidth) - level.Camera.Position.Y + unitOffsetX);

            // Draws the unit.
            playerUnit.Draw(
                gameTime,
                Game1.SpriteBatch,
                vect);
        }
Example #3
0
        /// <summary>
        /// Draws the unit as a npc unit
        /// </summary>
        /// <param name="gameTime"> A snapshot of timing values. </param>
        /// <param name="level"> The current level. </param>
        /// <param name="npcUnit"> The unit </param>
        private void DrawNPCUnit(GameTime gameTime, Level level, Unit npcUnit)
        {
            // Draws the NPC is Fog of War is not enabled.
            if (!this.FowEnabled)
            {
                var unitOffsetX = (Engine.TileHeight / 2)
                              - (npcUnit.Sprite.Height / 2);
                var unitOffsetY = (Engine.TileWidth / 2)
                              - (npcUnit.Sprite.Width / 2);

                // Converts the position of the unit to a vector that represents a
                // location on the gamescreen.
                var vect = new Vector2(
                (npcUnit.Sprite.Position.Y * Engine.TileHeight) - level.Camera.Position.X + unitOffsetY,
                (npcUnit.Sprite.Position.X * Engine.TileWidth) - level.Camera.Position.Y + unitOffsetX);

                // Draws the unit.
                npcUnit.Draw(
                    gameTime,
                    Game1.SpriteBatch,
                    vect);

                return;
            }

            // If FoW is enabled and the square the npc unit is on is visible, draw the unit.
            if (this.IsVisible(npcUnit.Location.X, npcUnit.Location.Y))
            {
                var unitOffsetX = (Engine.TileHeight / 2)
                              - (npcUnit.Sprite.Height / 2);
                var unitOffsetY = (Engine.TileWidth / 2)
                              - (npcUnit.Sprite.Width / 2);

                // Converts the position of the unit to a vector that represents a
                // location on the gamescreen.
                var vect = new Vector2(
                (npcUnit.Sprite.Position.Y * Engine.TileHeight) - level.Camera.Position.X + unitOffsetY,
                (npcUnit.Sprite.Position.X * Engine.TileWidth) - level.Camera.Position.Y + unitOffsetX);

                // Draws the unit.
                npcUnit.Draw(
                    gameTime,
                    Game1.SpriteBatch,
                    vect);
            }
        }
Example #4
0
        /// <summary>
        /// Draws the Fog of War on the map.
        /// </summary>
        /// <param name="level"> The level in progress. </param>
        private void DrawFoW(Level level)
        {
            // Finds the square that is to the top-left.
            var firstSquare = new Vector2(
                level.Camera.Position.X / Engine.TileWidth,
                level.Camera.Position.Y / Engine.TileHeight);
            var firstX = (int)firstSquare.X;
            var firstY = (int)firstSquare.Y;

            // Figured out what how far the tiles have been offset.
            var squareOffset = new Vector2(
                level.Camera.Position.X % Engine.TileWidth,
                level.Camera.Position.Y % Engine.TileHeight);
            var offsetX = (int)squareOffset.X;
            var offsetY = (int)squareOffset.Y;

            // Iterates over all tiles that are to be drawn on the screen. Ignores all tiles that are
            // outside the bounds of the scrren.
            for (int y = 0; y <= level.Camera.ViewportRectangle.Width / Engine.TileWidth; y++)
            {
                for (int x = 0; x <= level.Camera.ViewportRectangle.Height / Engine.TileHeight; x++)
                {
                    // Finds the actual location
                    int currentX = x + firstX < this.MapWidth ? x + firstX : this.MapWidth - 1;
                    int currentY = y + firstY < this.MapHeight ? y + firstY : this.MapHeight - 1;

                    // If the tile is not visible by a unit...
                    if (!this.IsVisible(currentY, currentX))
                    {
                        // ...draw the Fog of War texture on it.
                        Game1.SpriteBatch.Draw(
                            Engine.FoWTexture,
                            new Rectangle(
                                (x * Engine.TileWidth) - offsetX,
                                (y * Engine.TileHeight) - offsetY,
                                Engine.TileWidth,
                                Engine.TileHeight),
                            Color.White);
                    }
                }
            }
        }
Example #5
0
        /// <summary>
        /// Adds FoW to the area surrounding the unit.
        /// Mainly used when a unit is moved.
        /// </summary>
        /// <param name="unit"> The unit to add FoW around. </param>
        /// <param name="level"> The level in progress. </param>
        private void AddFoW(Unit unit, Level level)
        {
            if (this.FowEnabled)
            {
                for (int x = 0 - unit.ViewRange; x < unit.ViewRange + 1; x++)
                {
                    for (int y = 0 - unit.ViewRange; y < unit.ViewRange + 1; y++)
                    {
                        if (this.dataMap.WithinViewAndMap(x, y, unit))
                        {
                            this.SetVisibility(unit.Location.X + x, unit.Location.Y + y, false);
                        }
                    }
                }

                foreach (var playerUnit in level.PlayerController.CurrentPlayer.PlayerUnits)
                {
                    playerUnit.HasProcessedFoW = false;
                    this.RemoveFoW(playerUnit);
                }
            }
        }
Example #6
0
        /// <summary>
        /// Calls the methods that are needed for when a unit is moved away.
        /// </summary>
        /// <param name="unit"> The unit that is moving. </param>
        /// <param name="level"> The level in progress. </param>
        public void MoveUnitAway(Unit unit, Level level)
        {
            this.SetOccupationStatus(unit.Location.X, unit.Location.Y, false);

            if (this.PersistentFoW)
            {
                if (unit is PlayerUnit)
                {
                    this.AddFoW(unit, level);
                }
            }
        }
Example #7
0
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        /// <param name="level"> The level in progress. </param>
        public void DrawMap(GameTime gameTime, Level level)
        {
            this.DrawTiles(level);
            this.DrawUnits(gameTime, level);

            if (this.FowEnabled)
            {
                this.DrawFoW(level);
            }
        }
Example #8
0
 /// <summary>
 /// Updates the player.
 /// </summary>
 /// <param name="gameTime"> Provides a snapshot of timing values. </param>
 /// <param name="level"> The level in progress. </param>
 public abstract void Update(GameTime gameTime, Level level);
        /// <summary>
        /// Updates the Controller.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        /// <param name="level">The level currently in progress.</param>
        public void Update(GameTime gameTime, Level level)
        {
            foreach (var player in this.players)
            {
                player.Update(gameTime, level);
            }

            if (this.currentPlayer.Value.IsTurnFinished)
            {
                this.currentPlayer.Value.EndTurn();
                this.currentPlayer = this.currentPlayer.Next ?? this.players.First;
                this.currentPlayer.Value.StartTurn();
            }
        }
Example #10
0
        /// <summary>
        /// Checks if a unit belonging to the player is at the clicked location
        /// and selects it if there is.
        /// </summary>
        /// <param name="level"> The level. </param>
        private void SelectUnit(Level level)
        {
            if (InputHandler.LeftMouseClicked()
                && !this.unitSelected
                && !this.justClicked)
            {
                // Note! MouseState.X is the horizontal position and MouseState.Y is the vertical position.
                // I want Y to be the horizontal coordinate (the width) and X to be the vertical coordinate
                // (the height), so tileY is using the X values and tileX is using the Y values.
                var tileY = (int)(InputHandler.MouseState.X + level.Camera.Position.X) / Engine.TileHeight;
                var tileX = (int)(InputHandler.MouseState.Y + level.Camera.Position.Y) / Engine.TileWidth;

                foreach (var playerUnit in this.PlayerUnits)
                {
                    // Checks if the unit matches the tile that was clicked.
                    if (playerUnit.Location.X == tileX && playerUnit.Location.Y == tileY)
                    {
                        // Selects the unit and thereby changes the animation of the unit.
                        playerUnit.Select();
                        this.unitSelected = true;
                        this.selectedUnit = playerUnit;

                        // Finds the area which the unit can walk to.
                        level.LevelMap.MarkValidMoves(this.selectedUnit);
                    }
                }

                // Ensures that other parts in the update method won't be triggered.
                this.justClicked = true;
            }
        }
Example #11
0
        /// <summary>
        /// Updates the player.
        /// </summary>
        /// <param name="gameTime"> Provides a snapshot of timing values. </param>
        /// <param name="level"> The level in progress. </param>
        public override void Update(GameTime gameTime, Level level)
        {
            foreach (var playerUnit in this.PlayerUnits)
            {
                playerUnit.Update(gameTime);
            }

            if (!this.IsCurrentPlayer)
            {
                return;
            }

            this.justClicked = false;

            // Just testing stuff
            if (InputHandler.KeyPressed(Keys.K))
            {
                var random = new Random();
                var toChange = random.Next(this.PlayerUnits.Count);
                var unit = this.PlayerUnits[toChange];
                unit.CurrentHealth = unit.CurrentHealth / 2;

                this.PlayerUnits.Remove(unit);
                level.LevelMap.MoveUnitAway(unit, level);
            }

            this.SelectUnit(level);
            this.DeselectUnit(level);
            this.MoveUnit(level);
            this.EndPlayersTurn(level);
        }
Example #12
0
        /// <summary>
        /// Moves the selected unit to the clicked location, assuming the location
        /// is within range of the unit.
        /// </summary>
        /// <param name="level"> The level. </param>
        private void MoveUnit(Level level)
        {
            if (InputHandler.LeftMouseClicked()
                && this.unitSelected
                && !this.justClicked)
            {
                // Note! MouseState.X is the horizontal position and MouseState.Y is the vertical position.
                // I want Y to be the horizontal coordinate (the width) and X to be the vertical coordinate
                // (the height), so tileY is using the X values and tileX is using the Y values.
                var tileY = (int)(InputHandler.MouseState.X + level.Camera.Position.X) / Engine.TileHeight;
                var tileX = (int)(InputHandler.MouseState.Y + level.Camera.Position.Y) / Engine.TileWidth;

                var tempVector = new Vector(tileX, tileY);

                // Checks if the chosen tile is occupied or not.
                if (!level.LevelMap.IsOccupied(tileX, tileY)
                    && this.selectedUnit.CanTraverse(level.LevelMap.GetCollisionType(tileX, tileY))
                    && this.selectedUnit.PointWithinMoveRange(tempVector))
                {
                    var pathToTarget = level.LevelMap.FindShortestPathWithinReach(this.selectedUnit, tempVector).Count;
                    if (pathToTarget != 0 && pathToTarget <= this.selectedUnit.MoveRange)
                    {
                        // Removes the unit from the list, as we need to change the
                        // position of the unit.
                        this.PlayerUnits.Remove(this.selectedUnit);

                        // Notifies the map that the unit is disappearing from its current
                        // location.
                        level.LevelMap.MoveUnitAway(this.selectedUnit, level);

                        // Changes the unit's location.
                        this.selectedUnit.Location = (Vector)tempVector.Clone();
                        this.selectedUnit.MoveUnit();

                        // Notifies the map that the unit has arrived at its target
                        // location and adds the unit to the unit list again.
                        level.LevelMap.MoveUnitToNewPosition(this.selectedUnit);
                        this.PlayerUnits.Add(this.selectedUnit);

                        this.unitSelected = false;
                        this.selectedUnit = null;
                    }
                }

                // Ensures that other parts in the update method won't be triggered.
                this.justClicked = true;
            }
        }
Example #13
0
        /// <summary>
        /// Ends the player's turn
        /// </summary>
        /// <param name="level"> The level. </param>
        private void EndPlayersTurn(Level level)
        {
            if (InputHandler.KeyPressed(Keys.G))
            {
                this.IsTurnFinished = true;

                this.selectedUnit.MoveUnit();
                level.LevelMap.MoveUnitToNewPosition(this.selectedUnit);
                this.unitSelected = false;
                this.selectedUnit = null;

                // Ensures that other parts in the update method won't be triggered.
                this.justClicked = true;
            }
        }
Example #14
0
        /// <summary>
        /// Deselects the currently selected unit.
        /// </summary>
        /// <param name="level"> The level. </param>
        private void DeselectUnit(Level level)
        {
            if (InputHandler.RightMouseClicked()
                && this.unitSelected
                && !this.justClicked)
            {
                level.LevelMap.ClearValidMoves();
                this.selectedUnit.Deselect();

                this.unitSelected = false;
                this.selectedUnit = null;

                // Ensures that other parts in the update method won't be triggered.
                this.justClicked = true;
            }
        }
Example #15
0
        /// <summary>
        /// Draws the tiles on the DataMap.
        /// </summary>
        /// <param name="level"> The level in progress. </param>
        private void DrawTiles(Level level)
        {
            // Finds the square that is to the top-left.
            var firstSquare = new Vector2(
                level.Camera.Position.X / Engine.TileWidth,
                level.Camera.Position.Y / Engine.TileHeight);
            var firstX = (int)firstSquare.X;
            var firstY = (int)firstSquare.Y;

            // Figured out what how far the tiles have been offset.
            var squareOffset = new Vector2(
                level.Camera.Position.X % Engine.TileWidth,
                level.Camera.Position.Y % Engine.TileHeight);
            var offsetX = (int)squareOffset.X;
            var offsetY = (int)squareOffset.Y;

            // Iterates over all layers in mapLayers.
            foreach (var mapLayer in this.mapLayers)
            {
                // Ignores the collision layer.
                if (mapLayer.LayerName.Equals("collision"))
                {
                    continue;
                }

                // Iterates over all tiles that are to be drawn on the screen. Ignores all tiles that are
                // outside the bounds of the scrren.
                for (int y = 0; y <= level.Camera.ViewportRectangle.Width / Engine.TileWidth; y++)
                {
                    for (int x = 0; x <= level.Camera.ViewportRectangle.Height / Engine.TileHeight; x++)
                    {
                        // Finds the actual tile
                        int currentX = x + firstX < mapLayer.Width ? x + firstX : mapLayer.Width - 1;
                        int currentY = y + firstY < mapLayer.Height ? y + firstY : mapLayer.Height - 1;

                        Tile tile = mapLayer.GetTile(currentX, currentY);

                        // If the tile is transparent, don't bother drawing it.
                        if (tile.TileID == 0)
                        {
                            continue;
                        }

                        // Draws the tile.
                        Game1.SpriteBatch.Draw(
                            this.tilesets[tile.TileSet].Texture,
                            new Rectangle(
                                (x * Engine.TileWidth) - offsetX,
                                (y * Engine.TileHeight) - offsetY,
                                Engine.TileWidth,
                                Engine.TileHeight),
                            this.tilesets[tile.TileSet].SourceRectangles[tile.TileID],
                            Color.White);
                    }
                }
            }

            // If a unit is selected, the validMovesList is not null.
            if (this.validMovesList != null)
            {
                // Iterates over all vector2d in the valieMovesList
                foreach (var vector2 in this.validMovesList)
                {
                    // Converts the vector to a vector that represents the position on
                    // the screen.
                    var vect = new Vector2(
                        (vector2.Y * Engine.TileWidth) - level.Camera.Position.X,
                        (vector2.X * Engine.TileHeight) - level.Camera.Position.Y);

                    // Draws the location with a semi-transparent blue square, indicating that
                    // the currently selected unit can walk to those tiles.
                    Game1.SpriteBatch.Draw(
                        Engine.ValidMoveTexture,
                        vect,
                        Color.White);
                }
            }
        }
Example #16
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);

            // Makes a rectangle that is used to tell the Camera how much of the game
            // it is supposed to show at any given time.
            var screenRectangle = new Rectangle(0, 0, this.graphics.PreferredBackBufferHeight, this.graphics.PreferredBackBufferWidth);

            // Loads the texture for Fog of War and Valid Move, which are used during the game.
            // Instead of saving it in the tilemap, it is saved with the Engine, as both of them
            // are tilesets consisting of only one tile. No point in saving them as a full tileset in the map.
            Engine.FoWTexture = this.Content.Load<Texture2D>(@"Textures\TileSets\fow_of_war");
            Engine.ValidMoveTexture = this.Content.Load<Texture2D>(@"Textures\TileSets\move_range");

            Font = this.Content.Load<SpriteFont>(@"Fonts\OwnFont");

            var tempMap = this.mapLoader.LoadTmxFile("Test_1.tmx", this);
            tempMap.FowEnabled = true;
            tempMap.PersistentFoW = true;

            var tempPlayerUnits = new List<Unit>();
            var tempNPCUnits = new List<Unit>();

            // Makes an AnimatedSprite from a spritesheet, makes a PlayerUnit from it and
            // adds it to the playerUnits list.
            var sprite = this.MakeSprite("Ally", "Lin28px", 28, 28);
            var playerUnit = new PlayerUnit(Unit.GenerateUniqueID(tempPlayerUnits), "Akai", new Vector(5, 3), sprite, new BladesmasterClass());
            tempPlayerUnits.Add(playerUnit);

            sprite = this.MakeSprite("Ally", "FemaleAssassin28px", 28, 28);
            playerUnit = new PlayerUnit(Unit.GenerateUniqueID(tempPlayerUnits), "Kitai", new Vector(5, 2), sprite, new AssassinClass());
            tempPlayerUnits.Add(playerUnit);

            sprite = this.MakeSprite("Ally", "FlyingUnit32px", 32, 32);
            playerUnit = new PlayerUnit(Unit.GenerateUniqueID(tempPlayerUnits), "Flyer", new Vector(9, 10), sprite, new FlyingUnitClass());
            tempPlayerUnits.Add(playerUnit);

            sprite = this.MakeSprite("Enemy", "FlyingUnit32px", 32, 32);
            var enemyUnit = new NPCUnit(Unit.GenerateUniqueID(tempNPCUnits), "Flyer", new Vector(10, 10), sprite, new FlyingUnitClass());
            tempNPCUnits.Add(enemyUnit);

            tempMap.LoadUnits(new List<Unit>(tempPlayerUnits));
            tempMap.LoadUnits(new List<Unit>(tempNPCUnits));

            this.CurrentLevel = new Level(
                new Camera(screenRectangle),
                tempMap);
            this.CurrentLevel.AddPlayer(new PlayerHuman(tempPlayerUnits));
            this.CurrentLevel.AddPlayer(new PlayerNPC(tempNPCUnits));
        }
Example #17
0
        /// <summary>
        /// Draws the units on the DataMap.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        /// <param name="level"> The level in progress. </param>
        private void DrawUnits(GameTime gameTime, Level level)
        {
            // Iterates over every player in the level's playercontroller
            // and draws the units belonging to each player.
            foreach (var player in level.PlayerController.Players)
            {
                foreach (var unit in player.PlayerUnits)
                {
                    if (unit is PlayerUnit)
                    {
                        this.DrawPlayerUnit(gameTime, level, unit);
                    }

                    if (unit is NPCUnit)
                    {
                        this.DrawNPCUnit(gameTime, level, unit);
                    }
                }
            }
        }
Example #18
0
        /// <summary>
        /// Updates the camera by responding to user input.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        /// <param name="level"> The level in progress. </param>
        public void Update(GameTime gameTime, Level level)
        {
            // Moves the camera to the left, but makes sure it does nto leave the screen.
            if (InputHandler.KeyDown(Keys.Left))
            {
                this.position.X = MathHelper.Clamp(
                    this.Position.X - this.speed, 0, (level.LevelMap.MapWidth - Engine.SquaresAcross) * Engine.TileWidth);
            }

            // Moves the camera to the right, but makes sure it does nto leave the screen.
            if (InputHandler.KeyDown(Keys.Right))
            {
                this.position.X = MathHelper.Clamp(
                    this.Position.X + this.speed, 0, (level.LevelMap.MapWidth - Engine.SquaresAcross) * Engine.TileWidth);
            }

            // Moves the camera up, but makes sure it does nto leave the screen.
            if (InputHandler.KeyDown(Keys.Up))
            {
                this.position.Y = MathHelper.Clamp(
                    this.Position.Y - this.speed, 0, (level.LevelMap.MapHeight - Engine.SquaresDown) * Engine.TileHeight);
            }

            // Moves the camera down, but makes sure it does nto leave the screen.
            if (InputHandler.KeyDown(Keys.Down))
            {
                this.position.Y = MathHelper.Clamp(
                    this.Position.Y + this.speed, 0, (level.LevelMap.MapHeight - Engine.SquaresDown) * Engine.TileHeight);
            }
        }