evilsatellites/EvilSatellites/Screens/GameScreen.cs

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using SynthySound;
using System.Linq;
using EvilSatellites.Objects;
using DavyKager;
using EvilSatellites.Quadtree;

namespace EvilSatellites.Screens
{
    public class GameScreen : IScreen
    {
        public ScreenManager Manager { get; set; }
        public ScreenState State { get; set; }
        private InputManager Input = new InputManager();
        public List<IGameObject> Objects = new List<IGameObject>();
        public List<IGameObject> Removable = new List<IGameObject>();
        public List<IGameObject> Addable = new List<IGameObject>();
        private Quadtree<IGameObject> objtree = new Quadtree<IGameObject>(new Vector3(50000, 50000, 50000), 10, 20);
        private float Theta = 0;
        private Player _player;
        private Radar ObjectRadar;
        private SatelliteSpawner Spawner;
        private bool GameOver = false;
        public void Activate()
        {
            State = ScreenState.Active;
            Player player = new Player(this);
            Objects.Add(player);
            _player = player;
            ObjectRadar = new Radar(_player, this);
            Spawner = new SatelliteSpawner(this);
            Spawner.Spawn();
            GameStats.Reset();
            Manager.Music.Play("game1");
            Manager.Computer.Play("GameStart");
            return;
        }

        public void Deactivate()
        {
            State = ScreenState.Hidden;
            return;
        }

        public void Update(GameTime gameTime)
        {
            if (GameOver == true)
            {
                foreach (var obj in Objects)
                {
                    obj.Destroy();
                }
                ObjectRadar.Destroy();
                Spawner.Destroy();
                // TODO: figure out why cleanup doesn't work
                Manager.Sound.Cleanup();
                HandleGameOver(gameTime);

            }
            foreach (var obj in Removable)
            {
                Objects.Remove(obj);
            }
            if (Addable.Count > 0)
            {
                foreach (var obj in Addable)
                {
                    Objects.Add(obj);
                }
                Addable.Clear();
            }
            Removable.Clear();
            objtree.Clear();
            foreach (var obj            in Objects)
            {
                obj.Update(gameTime);
                objtree.Add(obj);
                if (obj.Type == ObjectType.Player)
                {
                    Manager.Sound.ListenerPosition = new System.Numerics.Vector3(obj.Position.X+obj.Dimensions.X/2, obj.Position.Y+obj.Dimensions.Y/2, obj.Position.Z+obj.Dimensions.Z/2);
                    Manager.Sound.ListenerOrientationForward = System.Numerics.Vector3.Normalize(new System.Numerics.Vector3(obj.Rotation.Forward.X, obj.Rotation.Forward.Y, obj.Rotation.Forward.Z));
                    Manager.Sound.ListenerOrientationUpwards = System.Numerics.Vector3.Normalize(new System.Numerics.Vector3(obj.Rotation.Up.X, obj.Rotation.Up.Y, obj.Rotation.Up.Z));
                }
                if (obj.ShouldDestroy)
                {
                    Removable.Add(obj);
                }
            }
            UpdateRadar();
            CheckCollisions();
            Spawner.Update(gameTime);
            return;
        }

        private void UpdateRadar()
        {
            var candidates = objtree.Find(_player.Position, new Vector3(1000, 1000, 1000));
            ObjectRadar.Update(Objects);
        }

        public void HandleInput(GameTime gameTime, KeyboardState inputs)
        {
            Input.Update();
            Vector3 move = new Vector3(0, 0, 0);
            if (Input.IsPressed(Keys.W) || Input.IsPressed(Buttons.LeftThumbstickUp))
            {
                move.Z = -_player.Acceleration.Z;
            }
            if (Input.IsPressed(Keys.S) || Input.IsPressed(Buttons.LeftThumbstickDown))
            {
                move.Z = _player.Acceleration.Z;
            }
            if (Input.IsPressed(Keys.A) || Input.IsPressed(Buttons.LeftThumbstickLeft))
            {
                move.X = -_player.Acceleration.X;
            }
            if (Input.IsPressed(Keys.D) || Input.IsPressed(Buttons.LeftThumbstickRight))
            {
                move.X = _player.Acceleration.X;
            }
            if (Input.IsJustPressed(Keys.A) || Input.IsJustPressed(Keys.S) || Input.IsJustPressed(Keys.D) || Input.IsJustPressed(Keys.W))
            {
                _player.PlayTap();
            }
            if (Input.IsJustPressed(Keys.Left) || Input.IsJustPressed(Buttons.RightThumbstickLeft))
            {
                _player.StartTurning(-1, gameTime);
            }
            if (Input.IsJustPressed(Keys.Right) || Input.IsJustPressed(Buttons.RightThumbstickRight))
            {
                _player.StartTurning(1, gameTime);
            }
            if (Input.IsJustReleased(Keys.Left) || Input.IsJustReleased(Keys.Right) || Input.IsJustReleased(Buttons.RightThumbstickLeft) || Input.IsJustReleased(Buttons.RightThumbstickRight))
            {
                _player.StopTurning();
            }
            if (Input.IsJustPressed(Keys.Up) || Input.IsJustPressed(Buttons.RightThumbstickUp))
            {
                _player.StartElevating(-1, gameTime);
            }
            if (Input.IsJustPressed(Keys.Down) || Input.IsJustPressed(Buttons.RightThumbstickDown))
            {
                _player.StartElevating(1, gameTime);
            }
            if (Input.IsJustReleased(Keys.Up) || Input.IsJustReleased(Keys.Down) || Input.IsJustReleased(Buttons.RightThumbstickUp) || Input.IsJustReleased(Buttons.RightThumbstickDown))
            {
                _player.StopElevating();
            }
            if (Input.IsJustPressed(Keys.V) || Input.IsJustPressed(Buttons.LeftTrigger))
            {
                _player.StartVacuuming(gameTime);
            }
            if (Input.IsJustReleased(Keys.V) || Input.IsJustReleased(Buttons.LeftTrigger))
            {
                _player.StopVacuuming();
            }
            _player.Accelerate(move);
            if (Input.IsJustPressed(Keys.Space) || Input.IsJustPressed(Buttons.RightTrigger))
            {
                _player.CurrentWeapon.Shoot(gameTime);
                _player.PlayTap();
            }
            if (Input.IsJustReleased(Keys.Space) || Input.IsJustReleased(Buttons.RightTrigger))
            {
                _player.CurrentWeapon.Stop();
            }
            if (Input.IsJustPressed(Keys.R) || Input.IsJustPressed(Buttons.LeftShoulder))
            {
                _player.PlayTap();
                if (ObjectRadar.Active)
                {
                    ObjectRadar.Stop();
                } else
                {
                    ObjectRadar.Start();
                }
            }
            if (Input.IsJustPressed(Keys.T) || Input.IsJustPressed(Buttons.RightShoulder))
            {
                _player.PlayTap();
                if (ObjectRadar.Filter == ObjectType.Satellite)
                {
                    ObjectRadar.SetObjectType(ObjectType.Debris);
                    Tolk.Output("Debris");
                } else
                {
                    ObjectRadar.SetObjectType(ObjectType.Satellite);
                    Tolk.Output("Satellites");
                }
            }
            if (Input.IsJustPressed(Keys.H) || Input.IsJustPressed(Buttons.B))
            {
                _player.PlayTap();
                Tolk.Output(Math.Round(_player.Health).ToString() + " health", true);
            }
            if (Input.IsJustPressed(Keys.X) || Input.IsJustPressed(Buttons.A))
            {
                _player.PlayTap();
                Tolk.Output(_player.CurrentWeapon.RemainingAmmo.ToString() + " rounds", true);
            }
            if (Input.IsJustPressed(Keys.Y) || Input.IsJustPressed(Buttons.X))
            {
                _player.PlayTap();
                if (ObjectRadar.Target != null)
                {
                    Tolk.Output(Math.Round(Vector3.Distance(_player.Position, ObjectRadar.Target.Position)).ToString() + " units", true);
                    var radarYaw = (float)System.Math.Atan2(ObjectRadar.RadarOrientation.M13, ObjectRadar.RadarOrientation.M33);
                    var radarPitch = (float)System.Math.Asin(-ObjectRadar.RadarOrientation.M23);
                    var playerYaw = (float)System.Math.Atan2(_player.Rotation.M13, _player.Rotation.M33);
                    var playerPitch = (float)System.Math.Asin(-_player.Rotation.M23);
                    var totalYaw = MathHelper.ToDegrees(MathHelper.WrapAngle(radarYaw - playerYaw + MathHelper.Pi));
                    var totalPitch = MathHelper.ToDegrees(MathHelper.WrapAngle(radarPitch - playerPitch));
                    Tolk.Output(Math.Round(totalYaw).ToString() + " horizontal, " + Math.Round(totalPitch).ToString() + " vertical");
                }
            }
            if (Input.IsJustPressed(Keys.O))
            {
                DavyKager.Tolk.Output(Objects.Count.ToString());
            }
            if (Input.IsJustPressed(Keys.PageUp))
            {
                Manager.Music.Volume = Manager.Music.Volume + 0.05f;
            }
            if (Input.IsJustPressed(Keys.PageDown))
            {
                Manager.Music.Volume = Manager.Music.Volume - 0.05f;
            }
            if (Input.IsJustPressed(Keys.Escape) || Input.IsJustPressed(Buttons.Start))
            {
                EndGame();
            }
        }

        private void CheckCollisions()
        {
            foreach (var obj in Objects)
            {
                if (!obj.Active) continue;
                var candidates = objtree.Find(obj.Position, obj.Dimensions);
                foreach (var target in candidates)
                {
                    if (obj == target || !target.Active) continue;
                    if (Intersects(obj, target))
                    {
                        obj.OnCollision(target);
                        target.OnCollision(obj);
                    }
                }
            }
        }

        public bool Intersects(IGameObject obj1, IGameObject obj2)
        {
            return (obj1.Position.X <= (obj2.Position.X + obj2.Dimensions.X) && (obj1.Position.X + obj1.Dimensions.X) >= obj2.Position.X) && (obj1.Position.Y <= (obj2.Position.Y + obj2.Dimensions.Y) && (obj1.Position.Y + obj1.Dimensions.Y) >= obj2.Position.Y) && (obj1.Position.Z <= (obj2.Position.Z + obj2.Dimensions.Z) && (obj1.Position.Z + obj1.Dimensions.Z) >= obj2.Position.Z);
        }

        public void AddObject(IGameObject obj)
        {
            Addable.Add(obj);
        }

        public Player GetPlayer()
        {
            return _player;
        }

        public void HandleGameOver(GameTime time)
        {
            GameStats.TotalPlayTime = time.TotalGameTime.TotalSeconds;
            Manager.RemoveScreen(this);
            Manager.AddScreen(new StatsScreen());
        }

        public void EndGame()
        {
            GameOver = true;
            Manager.Computer.Play("GameOver");
        }
    }
}