示例#1
0
        /// <summary>
        /// Update the positions of the missile and, if applicable, updates the player's
        /// health if the player has been hit by a missile
        /// </summary>
        /// <param name="player">To update the player's health, if applicable</param>
        /// <param name="floorPlan">To determine if a missile is no longer in the map</param>
        /// <param name="gameState">The current state of the game</param>
        /// <remarks>
        /// If the player has lost all health, the game will transition to the end state
        /// </remarks>
        public void Update(Player player, int[,] floorPlan, ref GameConstants.GameState gameState)
        {
            // update each missile
            for (int i = 0; i < missileList.Count; i++)
            {
                missileList[i].Update();

                if (missileList[i].Position.Y < 0.0f ||
                    floorPlan[(int)missileList[i].Position.X, (int)-missileList[i].Position.Z] != 0)
                {
                    // this missile is off of the map (either ran into a building or under the map)
                    missileList.Remove(missileList[i]);
                    continue;
                }

                if (player.BoundingSphere.Contains(missileList[i].Position) != ContainmentType.Disjoint)
                {
                    // the player was hit
                    missileList.Remove(missileList[i]);
                    player.HitByMissile(ref gameState);
                    explosionEffect.Play();
                }
            }
        }
示例#2
0
        /// <summary>
        /// Update the player's attributes (called 60 times sec).
        /// </summary>
        /// <param name="keyboardState">Information about user keyboard input</param>
        /// <param name="gamePadState">Information about user gamepad input</param>
        /// <param name="gameTime">Information about time elapsed since last update</param>
        /// <param name="map">The map the player is within</param>
        /// <param name="gameState">The state of the game</param>
        /// <remarks>If the player runs out of fuel or is out of health, the gamestate will be changed to end</remarks>
        public void Update(KeyboardState keyboardState, GamePadState gamePadState, GameTime gameTime, 
                           ref Map map, ref GameConstants.GameState gameState)
        {
            Vector3 movement;

            float turnAmount = DetermineTurnAmount(keyboardState, gamePadState); // determine if the user wants to turn
            UpdateVelocity(keyboardState, gamePadState);                         // update the velocity of the player based on user input

            // Move the player to the next position based on the current position and movement amount
            ForwardDirection += turnAmount * velocity * TurnSpeed;  // note: the final turn amount takes velocity into account
            movement = Vector3.Transform(new Vector3(0.0f, 0.0f, -1.0f), Matrix.CreateRotationY(ForwardDirection));
            movement *= velocity;
            UpdatePositionAndBoundingSphere(Position + movement);

            // Check for collision with objects in the map
            GameConstants.CollisionType collision = map.CheckCollision(this.BoundingSphere);
            if (collision == GameConstants.CollisionType.Building)
            {
                // undo the movement and set velocity to zero since we ran into building
                // can cause "bounceback effect"
                UpdatePositionAndBoundingSphere(Position - movement);

                // Update the player's health based on the velocity the player was at during the crash
                // If player's health moves below zero, transition to ending gamestate
                healthMeter.HitBarrier(velocity, ref gameState);

                // Play crash sound effect (major or minor crash effect based on player velocity)
                soundEffects.PlayCrash(velocity);

                velocity = 0.0f;
            }
            else if (collision == GameConstants.CollisionType.Bonus)
            {
                // update the player's bonus score with the bonus amount
                bonusScore += 25;
            }

            // Update the gauges
            sped.Update(velocity);
            UpdateFuel(gameTime, collision, ref gameState);
        }
示例#3
0
        /// <summary>
        /// Update the amount of fuel the player has and the player's fuel gauges.
        /// </summary>
        /// <param name="gameTime">Lets us determine the amount of time since last update</param>
        /// <param name="collision">Lets us determine if the car collided with a fuel object</param>
        /// <param name="gameState">Current state of the game</param>
        /// <remarks>The gamestate is changed to end if the player runs out of fuel</remarks>
        private void UpdateFuel(GameTime gameTime, GameConstants.CollisionType collision, ref GameConstants.GameState gameState)
        {
            fuel -= (float) gameTime.ElapsedGameTime.TotalSeconds;  // decrement fuel usage based on time since last update

            if (fuel < 0)
            {
                // out of fuel, transition to ending
                fuel = 0;
                gameState = GameConstants.GameState.End;
            }
            else if (collision == GameConstants.CollisionType.Fuel)
            {
                // picked up fuel while driving
                fuel = MaxFuel;
            }

            fuelGauge.Update(fuel);
        }
示例#4
0
 /// <summary>
 /// Updates the player's health when the player is hit by a missile
 /// </summary>
 /// <param name="gameState">The current state of the game</param>
 /// <remarks>
 /// This method should only be called when a missile hits the player.
 /// If the player's health drops below zero, the game will transition
 /// to the end state.
 /// </remarks>
 public void HitByMissile(ref GameConstants.GameState gameState)
 {
     healthMeter.HitByMissile(ref gameState);
 }
示例#5
0
        /// <summary>
        /// Draw the player model and the player's gauges (if applicable)
        /// </summary>
        /// <param name="gameCamera">For view and projection matrices</param>
        /// <param name="gameState">State of the game</param>
        /// <remarks>The player's gauges are not drawn during the intro</remarks>
        public void Draw(Camera gameCamera, GameConstants.GameState gameState)
        {
            DrawModel(ref gameCamera);

            if (gameState != GameConstants.GameState.Intro)
            {
                sped.Draw();
                fuelGauge.Draw();
                healthMeter.Draw();
            }
        }
示例#6
0
        /// <summary>
        /// Moves the player around the map during the introduction without user input.
        /// </summary>
        /// <param name="gameState">The state of the game</param>
        /// <remarks>
        /// If the player makes a complete revolution of the map, the gameState transitions
        /// to ready.
        /// </remarks>
        public void AutoPilot(ref GameConstants.GameState gameState)
        {
            float turnAmount = 0.0f;
            velocity = IntroVelocity;

            for (int i = 0; i < pivots.Length; i++)
            {
                if (pivots[i].Contains((int)Position.X, (int)-Position.Z))
                {
                    // This a square the player should make a turn on
                    // Update the forward direction based on turn amount
                    turnAmount = IntroTurnAmount;
                    ForwardDirection += turnAmount * velocity * TurnSpeed;

                    // Only turn as far as required by this pivot
                    if (ForwardDirection > pivotForwardDirections[i])
                        ForwardDirection = pivotForwardDirections[i];
                }
            }

            // Check if player has made a complete reveloution and move into ready gamestate if so
            if (playerStartRect.Contains((int)Position.X, (int)-Position.Z) && ForwardDirection > 0)
            {
                gameState = GameConstants.GameState.Ready;
            }

            // Move the player to the next position based on the current position and movement amount
            Vector3 movement = Vector3.Transform(new Vector3(0.0f, 0.0f, -1.0f), Matrix.CreateRotationY(ForwardDirection));
            movement *= velocity;
            UpdatePositionAndBoundingSphere(Position + movement);

            // play the sound of the engine
            soundEffects.PlayEngine(0);
        }
示例#7
0
        /// <summary>
        /// Allows the client to move the enemy craft
        /// </summary>
        /// <param name="enemies">For positions of all of the other enemies in the game</param>
        /// <param name="player">Allows queries for attributes of the player</param>
        /// <param name="floorPlan">Gives the arrangement of the building in the city</param>
        ///<param name="gameTime">Information on the time since last update for missiles</param>
        /// <param name="gameState">Gives the current state of the game</param>
        /// <remarks>
        /// If the player is caught or the player is hit by a missile and runs
        /// out of health, the gamestate will transition to end
        /// </remarks>
        public void Update(Enemies enemies, Player player, int[,] floorPlan, GameTime gameTime, 
                           ref GameConstants.GameState gameState)
        {
            bool canMakeMovement = false;   // boolean for status if the player was able to make a move on this update
            Vector3 movement;               // the movement to be applied to the enemy

            // check if the player has been caught, that is the enemy craft and player are in the same
            // grid unit, and if so transition to game ending state
            if (((int)Position.X - (int)player.Position.X) == 0 && ((int)Position.Z - (int)player.Position.Z) == 0)
            {
                gameState = GameConstants.GameState.End;
                return;
            }

            // Update the missiles and time during chase
            missiles.Update(player, floorPlan, ref gameState);
            if (chasing)
            {
                // Update the timeOfChase with the elapsed time since the last update
                timeOfChase += gameTime.ElapsedGameTime.TotalSeconds;
            }

            if (ReadyForNextMove())
            {
                // mark the spots on the grid where the enemies are and where they are headed in the next move
                MarkEnemySquares(enemies, floorPlan);

                // the player is in the center of a grid square, and can decide on the next direction to face
                // now, check if the player is in the enemy's line of sight (no buildings or enemies obstructing view
                // from enemy to player), and, if so, set the chasing property
                // to true
                chasing = CheckIfInLineOfSight(player, floorPlan);

                if (chasing)
                {
                    // we are chasing the player, set direction toward the player
                    SetDirectionTowardPlayer(player);

                    // we can make a movement since nothing is obstructing between player and this enemy
                    canMakeMovement = true;

                    // Check if we are locked on to the player, and if so, attempt to fire
                    if (this.LockedOn)
                    {
                        missiles.FireAt(this.Position, FindTargetPosition(player), gameTime);
                    }
                }
                else
                {
                    // reset the time of chase to zero since we are not chasing
                    timeOfChase = 0.0;

                    // check to see if no other enemyies are chasing and this is the closest enemy
                    // in terms of linear distance
                    // If so, find an A* path to the player if possible.
                    // This makes the game more challenging since the player will always be under pressure
                    // from some enemy
                    if (ShouldMoveTowardPlayer(player, enemies))
                    {
                        List<Vector2> aStarPath = AStar.FindPath(floorPlan, Position, player.Position);
                        //Helpers.AStarDebugList = aStarPath;

                        if (aStarPath == null)
                        {
                            // We could not find an A* path to the player, move randomly
                            canMakeMovement = MoveRandomly(floorPlan); // returns true if a move was able to be made
                        }
                        else
                        {
                            // set the enemy direction to follow the A* path
                            UpdateDirectionFromPath(aStarPath);
                            canMakeMovement = true;
                        }
                    }
                    else
                    {
                        // we are not chasing or the closest enemy
                        // move randomly around the grid until we spot the player next
                        canMakeMovement = MoveRandomly(floorPlan); // returns true if a move was able to be made
                    }
                }

                // unmark the spots on the grid where the enemies are and where they are headed in the next move
                UnmarkEnemySquares(enemies, floorPlan);

                if (!canMakeMovement)
                {
                    // the enemy is surrounded and cannot make a move
                    // set velocity to zero and stay put for this move
                    speed = 0.0f;
                }
                else
                {
                    // update positionOfLastMove with grid square of current position
                    positionOfLastMove = new Rectangle((int)Position.X, (int)-Position.Z, 1, 1);

                    // update nextPosition with next grid space in the direction
                    // we are headed
                    nextPosition = new Rectangle(
                        (int)(Position.X - Math.Sin(ForwardDirection)),
                        (int)(Position.Z - Math.Cos(ForwardDirection)), 1, 1);

                    speed = EnemySpeed;
                }
            }

            // Make the movement
            movement = Vector3.Transform(new Vector3(0.0f, 0.0f, -1.0f), Matrix.CreateRotationY(ForwardDirection));
            movement *= speed;
            UpdatePositionAndBoundingSphere(Position + movement);
        }
示例#8
0
        /// <summary>
        /// Draw the enemy model and missiles
        /// </summary>
        /// <param name="device">Graphics card to draw the missiles</param>
        /// <param name="gameCamera">For view and projection matrices</param>
        /// <param name="gameState">For the state of the game (do not draw missiles once game over)</param>
        public void Draw(ref GraphicsDevice device, Camera gameCamera, GameConstants.GameState gameState)
        {
            // Draw the enemy model
            Matrix[] transforms = new Matrix[Model.Bones.Count];
            Model.CopyAbsoluteBoneTransformsTo(transforms);
            Matrix translateMatrix = Matrix.CreateTranslation(Position);    // move the model to the correct position
            Matrix worldMatrix = translateMatrix;   // setup world matrix based on translation

            foreach (ModelMesh mesh in Model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    // setup effect based on worldMatrix and properties of the camera
                    effect.World =
                        worldMatrix * transforms[mesh.ParentBone.Index];
                    effect.View = gameCamera.ViewMatrix;
                    effect.Projection = gameCamera.ProjectionMatrix;

                    effect.EnableDefaultLighting();
                    effect.PreferPerPixelLighting = true;
                }
                mesh.Draw();
            }

            // Draw the missiles if we are still playing
            if (gameState == GameConstants.GameState.Playing)
                missiles.Draw(ref device, gameCamera);
        }