source: 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Game.cs @ 4751

#region Information
/*  Castle Master by Denis Zhidkikh
 * 
 * Controls:
 * Use W, A, S, D to move around the map
 * Hold Shift while moving to move faster
 * Hold middle mouse button and drag to move the map
 * Scroll to zoom in/out
 * Click on unit with right mouse button to select it
 * Hold Ctrl while clicking to choose multiple units
 * Give orders to your units by clicking left mouse button (ordering button) on other units/entities
 * 
 * Classes:
 * Woodcutter:
 * - Costs 5 gold
 * - Has 20 health
 * - Really fast
 * - Order to cut by clicking on the tree with the ordering button
 * - Order to walk by clicking on the empty tile with the ordering button
 * - After cutting first tree woodcutter will begin looking for nearby trees to cut
 * 
 * Warrior:
 * - Costs 20 gold
 * - Has 50 health
 * - Slow
 * - Order to attack enemy units by clicking on them with the ordering button
 * - After killing will stay in place until he either gets another order or gets attacked by the enemy
 * 
 * Ranger:
 * - Costs 15 gold
 * - Has 30 health
 * - Medium speed
 * - Attacks the same way the warrior does
 * 
 * Units:
 * King (and the castle):
 * - Has 400 health
 * - Doesn't do anything
 * - The game ends after being destroyed
 * 
 * Store (large wooden building):
 * - Has 400 health
 * - Can exchange wood to gold
 * - Selecting it will open the exchange window
 * - Cannot exchange wood to gold after being destroyed
 * 
 * Armory (small stone building):
 * - Has 400 health
 * - Uses money to buy woodcutters, warriors and rangers
 * - Selecting it will open the armory window
 * - Cannot buy more units after being destroyed
 * 
 * Objective:
 * Win game by destroying enemy's castle. Make it easier by killing enemy's woodcutters and destroying the store and/or armory.
 * 
 */

#endregion

using CastleMaster.Graphics;
using CastleMaster.Input;
using CastleMaster.World;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using SharpNeatLib.Maths;
using System;
using System.Text;
using System.Windows.Forms;
using Keys = System.Windows.Forms.Keys;
using Viewport = CastleMaster.Graphics.Viewport;
using CastleMaster.Players;
using CastleMaster.Guis;

// NOTES:
// If VSYNC problems/Lag problems go to line 73 to enable/disable VSYNC
namespace CastleMaster
{
    public class Game : Microsoft.Xna.Framework.Game
    {
        public const int WIDTH = 800;
        public const int HEIGHT = 600;
        public const string TITLE = "Castle Master";
        public const string VERSION = "Alpha";

        private GraphicsDeviceManager graphics;
        private SpriteBatch spriteBatch;
        private InputHandler input;
        private RenderHelper renderer;
        private Camera camera;
        private LevelForest level;
        private static Player[] players;
        private static GuiManager guiManager;
        private GuiDebug debugScreen;
        private GuiPlayer ingame;
        private GuiMainScreen mainScreen;
        private bool isGameRunning = false;
        private static Game instance;

        #region Counter
        private readonly TimeSpan ONE_SECOND = TimeSpan.FromSeconds(1.0);
        private TimeSpan currentTime = TimeSpan.Zero;
        private int frames = 0, updates = 0, fps = 0, ups = 0;
        #endregion

        public static FastRandom Random { get; private set; }

        public static readonly Team TEAM1 = new Team("Team1", 0);
        public static readonly Team TEAM2 = new Team("Team2", 1);

        public Game()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            input = new InputHandler(Window);
            Random = new FastRandom();
            players = new Player[2];
            guiManager = new GuiManager();
            IsGamePaused = true;
            instance = this;
        }

        public static GuiManager GuiManager { get { return guiManager; } }

        public int FPS { get { return fps; } }

        public int UPS { get { return ups; } }

        public bool IsGameRunning { get { return isGameRunning; } }

        public bool IsGamePaused { get; set; }

        public static Game Instance { get { return instance; } }

        protected override void Initialize()
        {
            graphics.PreferredBackBufferWidth = WIDTH;
            graphics.PreferredBackBufferHeight = HEIGHT;
            // NOTE: If enabled on some computers, the FPS will drop too much to play
            graphics.SynchronizeWithVerticalRetrace = false;
            graphics.ApplyChanges();
            Window.Title = TITLE;

            InitializeInput();

            base.Initialize();
        }

        private void InitializeInput()
        {
            input.RegisterKeyboardKey(Keys.Escape);
            input.RegisterKeyboardKey(Keys.W);
            input.RegisterKeyboardKey(Keys.A);
            input.RegisterKeyboardKey(Keys.S);
            input.RegisterKeyboardKey(Keys.D);
            input.RegisterKeyboardKey(Keys.F4);
            input.RegisterKeyboardKey(Keys.F1);
            input.RegisterKeyboardKey(Keys.F2);
            input.RegisterKeyboardKey(Keys.ShiftKey);
            input.RegisterKeyboardKey(Keys.ControlKey);
            input.RegisterKeyboardKey(Keys.Up);
            input.RegisterKeyboardKey(Keys.Down);
            input.RegisterKeyboardKey(Keys.Left);
            input.RegisterKeyboardKey(Keys.Right);
            input.RegisterKeyboardKey(Keys.Enter);
            input.RegisterKeyboardKey(Keys.X);

            input.RegisterMouseKey(MouseButtons.Middle);
            input.RegisterMouseKey(MouseButtons.Right);
            input.RegisterMouseKey(MouseButtons.Left);
        }

        public void OpenMainMenu()
        {
            ResetGame();
            guiManager.AddGui(mainScreen, true, true);
        }

        public void ResetGame()
        {
            IsGamePaused = true;
            isGameRunning = false;
            level = null;
            camera = null;
            players = new Player[2];
            if (ingame != null)
                ingame.Remove();
            GC.Collect();
        }

        public void StartGame()
        {
            if (isGameRunning)
                ResetGame();

            IsGamePaused = false;
            isGameRunning = true;

            mainScreen.Remove();

            level = new LevelForest(Content.Load<Texture2D>("levels/levelForest"));
            camera = new Camera(level);
            AddPlayer(new PlayerReal(TEAM1, level, camera));
            AddPlayer(new PlayerAI(TEAM2, level, camera, PlayerAI.DIFFICULTY_EASY, players[0]));
            level.InitLevel();
            foreach (Player p in players)
                if (p != null) p.OnLevelLoaded();
            camera.CenterOn(100 * Viewport.TILESIZE, 15 * Viewport.TILESIZE);

            ingame = new GuiPlayer(guiManager, players[0]);
            guiManager.AddGui(ingame, true);
        }

        private void AddPlayer(Player p)
        {
            players[p.Team.ID] = p;
            level.SetPlayer(p, p.Team.ID);
        }

        public static Team GetEnemyTeam(Team team)
        {
            return team == TEAM1 ? TEAM2 : TEAM1;
        }

        public static Player GetEnemyPlayer(Player player)
        {
            return player.Team == TEAM1 ? players[1] : players[0];
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
            renderer = new RenderHelper(spriteBatch);

            Resources.LoadResources(Content, renderer);
        }

        protected override void UnloadContent()
        {
            RenderHelper.EmptyTexture.Dispose();
        }

        protected override void BeginRun()
        {
            base.BeginRun();

            debugScreen = new GuiDebug(guiManager, this);
            guiManager.AddGui(debugScreen, false);

            mainScreen = new GuiMainScreen(guiManager, this);
            OpenMainMenu();
        }

        protected override void Update(GameTime gameTime)
        {
            input.Update();

            if (InputHandler.HasKeyBeenPressed(Keys.F1))
            {
                debugScreen.IsActive = !debugScreen.IsActive;
            }
            if (InputHandler.HasKeyBeenPressed(Keys.F4))
                IsFixedTimeStep = !IsFixedTimeStep;
            if (InputHandler.HasKeyBeenPressed(Keys.Escape) && (guiManager.ImportantGui == null || !(guiManager.ImportantGui is GuiWinLooseMessage)))
            {
                if (isGameRunning)
                {
                    if (!mainScreen.IsActive)
                        guiManager.AddGui(mainScreen, true, true);
                    else
                        mainScreen.Remove();

                    IsGamePaused = mainScreen.IsActive;
                }
                else Exit();
            }

            if (isGameRunning && !IsGamePaused)
            {
                if (InputHandler.MouseScrollDelta > 1)
                    camera.Zoom(Viewport.ZOOM_STEP);
                else if (InputHandler.MouseScrollDelta < 0)
                    camera.Zoom(-Viewport.ZOOM_STEP);

                foreach (Player p in players)
                    if (p != null)
                        p.Update();

                camera.Update();

                level.Update();
            }

            guiManager.Update();

            updates++;
            currentTime += gameTime.ElapsedGameTime;
            if (currentTime >= ONE_SECOND)
            {
                currentTime = TimeSpan.Zero;
                fps = frames;
                ups = updates;
                frames = updates = 0;
            }

            base.Update(gameTime);
        }

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);

            renderer.BeginRender();

            if (isGameRunning)
            {
                level.RenderBackground(camera, renderer);
                camera.RenderSelelctor(renderer);
                level.RenderEntities(camera, renderer);
            }

            guiManager.Render(renderer);
            if (isGameRunning)
                camera.RenderCursor(renderer);
            renderer.EndRender();

            frames++;
            base.Draw(gameTime);
        }
    }
}