Game.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */

using System;
using System.ComponentModel;
using System.Xml;
using System.Xml.Serialization;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework.Content;

#if WINDOWS
using System.Runtime.InteropServices;
#endif

#if XBOX
using Microsoft.Xna.Framework.GamerServices;
#endif

using Jypeli.Widgets;
using Jypeli.Effects;
using Jypeli.Controls;
using Jypeli.WP7;

using XnaColor = Microsoft.Xna.Framework.Color;
using XnaSoundEffect = Microsoft.Xna.Framework.Audio.SoundEffect;
using XnaRectangle = Microsoft.Xna.Framework.Rectangle;
using System.Reflection;
using System.Diagnostics;


namespace Jypeli
{
    [Save]
    public partial class Game : Microsoft.Xna.Framework.Game, ControlContexted, IDisposable, GameObjectContainer
    {
#if WINDOWS
        [DllImport( "user32.dll" )]
        private static extern int GetSystemMetrics( int smIndex );

        [DllImport("user32.dll")]
        private static extern bool SetProcessDPIAware();

        [DllImport("gdi32.dll")]
        static extern int GetDeviceCaps(IntPtr hdc, int nIndex);

        enum DeviceCap
        {
            VERTRES = 10,
            DESKTOPVERTRES = 117,
        }
#endif

        Queue<Action> PendingActions = new Queue<Action>();

        public bool IsPaused { get; set; }

        public SynchronousList<Layer> Layers { get; private set; }

        public IList<Layer> StaticLayers
        {
            get { return Layers.FindAll( l => l.IgnoresZoom && l.RelativeTransition == Vector.Zero ).AsReadOnly(); }
        }

        public IList<Layer> DynamicLayers
        {
            get { return Layers.FindAll( l => !l.IgnoresZoom || l.RelativeTransition != Vector.Zero ).AsReadOnly(); }
        }

        public int MinLayer
        {
            get { return Layers.FirstIndex; }
        }

        public int MaxLayer
        {
            get { return Layers.LastIndex; }
        }

        public int LayerCount
        {
            get { return Layers.Count; }
        }

        public static string Name { get; private set; }

        // TJ: Since there is only one isntance of the
        // game class in practice, its useful to have it available as
        // a static member. This way, we avoid passing a reference to the
        // game in lots of places.
        //
        // In addition, some often-used things, such as Time or GraphicsDevice,
        // are available as static properties (public or internal) as well.
        public static Game Instance { get; private set; }

        public static event Action InstanceInitialized;

        public static new event Action Exiting;

        [Save]
        public Camera Camera { get; set; }

        public bool DrawPerimeter { get; set; }

        public Color PerimeterColor { get; set; }

        public static bool SmoothTextures { get; set; }

        internal static ResourceContentManager ResourceContent { get; private set; }

        public static ScreenView Screen
        {
            get { return Instance.screen; }
        }

        public static new JypeliWindow Window { get; private set; }

        public static Jypeli.Controls.Controls Controls
        {
            get { return Instance.controls; }
        }

        private ListenContext _context = new ListenContext() { Active = true };

        public ListenContext ControlContext
        {
            get { return Instance._context; }
        }

        public bool IsModal
        {
            get { return false; }
        }

        public MessageDisplay MessageDisplay { get; set; }

        public static FileManager DataStorage { get { return Instance.dataStorage; } }

        public bool AcceptsFocus { get { return true; } }

        public Keyboard Keyboard { get { return controls.Keyboard; } }

        public Mouse Mouse { get { return controls.Mouse; } }

        public TouchPanel TouchPanel { get { return controls.TouchPanel; } }

        public PhoneBackButton PhoneBackButton { get { return controls.PhoneBackButton; } }

        public GamePad ControllerOne { get { return controls.GameControllers[0]; } }

        public GamePad ControllerTwo { get { return controls.GameControllers[1]; } }

        public GamePad ControllerThree { get { return controls.GameControllers[2]; } }

        public GamePad ControllerFour { get { return controls.GameControllers[3]; } }

        public Accelerometer Accelerometer { get { return controls.Accelerometer; } }

        private Phone phone;

        public Phone Phone { get { return phone; } }


        public Level Level
        {
            get { return theLevel; }
        }

        public static Time Time
        {
            get { return currentTime; }
        }

        public static Time RealTime
        {
            get { return currentTime; }
        }

        public static Vector Wind { get; set; }

        public string Title
        {
            get { return Window.Title; }
            set { Window.Title = value; }
        }

        internal int ObjectCount
        {
            get
            {
                return Layers.Sum<Layer>( l => l.Objects.Count );
            }
        }

        public bool IsFullScreen
        {
            get { return Window.Fullscreen; }
            set { Window.Fullscreen = value; }
        }

        public MediaPlayer MediaPlayer { get; private set; }

        private Jypeli.Controls.Controls controls;
        private FileManager dataStorage;
        private ScreenView screen;

        [EditorBrowsable( EditorBrowsableState.Never )]
        public static new GraphicsDevice GraphicsDevice
        {
            get { return ( (Microsoft.Xna.Framework.Game)Instance ).GraphicsDevice; }
        }

        internal static GraphicsDeviceManager GraphicsDeviceManager { get; private set; }

#if !WINDOWS_PHONE
        internal static List<Light> Lights { get { return lights; } }
#endif

#if !WINDOWS_PHONE
        private static List<Light> lights = new List<Light>();
#endif

        private Level theLevel;

        private bool loadContentHasBeenCalled = false;
        private bool beginHasBeenCalled = false;

        // Real time passed, including paused time
        private static Time currentRealTime = new Time();

        // Game time passed
        private static Time currentTime = new Time();


        public Game()
            : this( 1 )
        {
        }

        public Game( int device )
        {
            if ( Instance != null )
                throw new Exception( "Only one instance of the Game class can be created." );

            Instance = this;
            Name = this.GetType().Assembly.FullName.Split( ',' )[0];

            InitializeLayers();
            InitializeContent();

            Camera = new Camera();
            controls = new Jypeli.Controls.Controls();

            InitializeGraphics( device );
            Window = new JypeliWindow( base.Window, Game.GraphicsDeviceManager );
            Window.Resizing += new JypeliWindow.ResizeEvent( WindowResized );
            Window.Resized += new JypeliWindow.ResizeEvent( WindowResized );

#if WINDOWS
            this.dataStorage = new WindowsFileManager( WindowsLocation.DataPath, WindowsLocation.MyDocuments ); ;
            SetProcessDPIAware();
#elif WINDOWS_PHONE
            dataStorage = new IsolatedStorageManager();
#elif XBOX
            Components.Add( new GamerServicesComponent( this ) );
            dataStorage = new XboxFileManager();
#endif

            dataStorage.ReadAccessDenied += delegate (Exception ex)
            {
                ShowErrorMessage("Could not read from data directory. " + ex.Message);
            };
            dataStorage.WriteAccessDenied += delegate (Exception ex)
            {
                ShowErrorMessage("Could not write to data directory. " + ex.Message);
            };

            DrawPerimeter = false;
            PerimeterColor = Color.DarkGray;

            phone = new Phone();
            Phone.Tombstoning = true;
        }

        private void WindowResized( int oldWidth, int oldHeight, int newWidth, int newHeight )
        {
            if ( GraphicsDevice == null )
                return;

            Viewport view = new Viewport( 0, 0, newWidth, newHeight );

            if ( Mouse != null )
                Mouse.Viewport = view;

            if ( screen != null )
                screen.viewPort = view;
        }

        private void ShowErrorMessage(string message)
        {
            MessageDisplay.Add( "ERROR: " + message, Color.Red );

            /*bool mouseVisible = IsMouseVisible;
            IsMouseVisible = true;

            MessageWindow errWindow = new MessageWindow( message );
            errWindow.Color = Color.Red;
            errWindow.Message.TextColor = Color.White;
            errWindow.Closed += delegate { IsMouseVisible = mouseVisible; };
            Add( errWindow );*/
        }

        public void ShowMessageWindow( string message )
        {
            MessageWindow w = new MessageWindow( message );
            Add( w );
        }

        private void InitializeLayers()
        {
            Layers = new SynchronousList<Layer>( -3 );
            Layers.ItemAdded += OnLayerAdded;
            Layers.ItemRemoved += OnLayerRemoved;

            for ( int i = 0; i < 7; i++ )
            {
                Layers.Add( new Layer() );
            }

            // This is the widget layer
            Layers.Add( Layer.CreateStaticLayer() );

            Layers.UpdateChanges();
        }

        private void InitializeContent()
        {
#if WINDOWS_PHONE
            
            ResourceContent = new ResourceContentManager( this.Services, WindowsPhoneResources.ResourceManager );
#elif XBOX
            ResourceContent = new ResourceContentManager( this.Services, XBox360Resources.ResourceManager );
#else
            ResourceContent = new ResourceContentManager( this.Services, Resources.ResourceManager );
#endif

            Content.RootDirectory = "Content";
        }

        private void InitializeGraphics( int device )
        {
#if WINDOWS
            if ( device == 1 )
                GraphicsDeviceManager = new GraphicsDeviceManager( this );
            else
                GraphicsDeviceManager = new TargetedGraphicsDeviceManager( this, device );
#else
            GraphicsDeviceManager = new GraphicsDeviceManager( this );
#endif
            GraphicsDeviceManager.PreferredDepthStencilFormat = Jypeli.Graphics.SelectStencilMode();
            SmoothTextures = true;
        }

        private void ActivateObject( ControlContexted obj )
        {
            obj.ControlContext.Active = true;

            if ( obj.IsModal )
            {
                Game.Instance.ControlContext.SaveFocus();
                Game.Instance.ControlContext.Active = false;

                foreach ( Layer l in Layers )
                {
                    foreach ( IGameObject lo in l.Objects )
                    {
                        ControlContexted co = lo as ControlContexted;
                        if ( lo == obj || co == null )
                            continue;

                        co.ControlContext.SaveFocus();
                        co.ControlContext.Active = false;
                    }
                }
            }
        }

        private void DeactivateObject( ControlContexted obj )
        {
            obj.ControlContext.Active = false;

            if ( obj.IsModal )
            {
                Game.Instance.ControlContext.RestoreFocus();

                foreach ( Layer l in Layers )
                {
                    foreach ( IGameObject lo in l.Objects )
                    {
                        ControlContexted co = lo as ControlContexted;
                        if ( lo == obj || co == null )
                            continue;

                        co.ControlContext.RestoreFocus();
                    }
                }
            }
        }

        protected virtual void OnObjectAdded( IGameObject obj )
        {
            IGameObjectInternal iObj = obj as IGameObjectInternal;
            if ( iObj == null ) return;
            iObj.IsAddedToGame = true;
            iObj.OnAddedToGame();

            ControlContexted cObj = obj as ControlContexted;
            if ( cObj != null ) ActivateObject( cObj );
        }

        protected virtual void OnObjectRemoved( IGameObject obj )
        {
            IGameObjectInternal iObj = obj as IGameObjectInternal;
            if ( iObj == null ) return;
            iObj.IsAddedToGame = false;
            iObj.OnRemoved();

            ControlContexted cObj = obj as ControlContexted;
            if ( cObj != null ) DeactivateObject( cObj );
        }

        internal static void OnAddObject( IGameObject obj )
        {
            Debug.Assert( Instance != null );
            Instance.OnObjectAdded( obj );
        }

        internal static void OnRemoveObject( IGameObject obj )
        {
            Debug.Assert( Instance != null );
            Instance.OnObjectRemoved( obj );
        }

        private void OnLayerAdded( Layer l )
        {
            l.Objects.ItemAdded += this.OnObjectAdded;
            l.Objects.ItemRemoved += this.OnObjectRemoved;
        }

        private void OnLayerRemoved( Layer l )
        {
            l.Objects.ItemAdded -= this.OnObjectAdded;
            l.Objects.ItemRemoved -= this.OnObjectRemoved;
        }

        public static void AssertInitialized( Action actionMethod )
        {
            if ( Instance != null )
                actionMethod();
            else
                InstanceInitialized += actionMethod;
        }

        public static void DoNextUpdate( Action action )
        {
            if ( Instance != null )
                Instance.PendingActions.Enqueue( action );
            else
                InstanceInitialized += action;
        }

        public static void DoNextUpdate<T1>( Action<T1> action, T1 p1 )
        {
            DoNextUpdate( delegate { action( p1 ); } );
        }

        public static void DoNextUpdate<T1, T2>( Action<T1, T2> action, T1 p1, T2 p2 )
        {
            DoNextUpdate( delegate { action( p1, p2 ); } );
        }

        public static void AssertInitialized<T1>( Action<T1> actionMethod, T1 o1 )
        {
            if ( Instance != null )
                actionMethod( o1 );
            else
                InstanceInitialized += delegate { actionMethod( o1 ); };
        }

        public void Add( IGameObject o )
        {
            if ( o.Layer != null && o.Layer.Objects.WillContain( o ) )
            {
                if ( o.Layer == Layers[0] )
                {
                    throw new NotSupportedException( "Object cannot be added twice" );
                }
                else
                    throw new NotSupportedException( "Object cannot be added to multiple layers" );
            }

            if ( o is Widget ) Add( o, MaxLayer );
            else Add( o, 0 );
        }

#if !WINDOWS_PHONE
        public void Add( Light light )
        {
            if ( light == null ) throw new NullReferenceException( "Tried to add a null light to game" );

            if ( lights.Count >= 1 )
                throw new NotSupportedException( "Only one light is supported" );

            lights.Add( light );
        }
#endif

        public virtual void Add( IGameObject o, int layer )
        {
            if ( o == null ) throw new NullReferenceException( "Tried to add a null object to game" );
            Layers[layer].Add( o );
        }

        internal static IList<IGameObject> GetObjectsAboutToBeAdded()
        {
            List<IGameObject> result = new List<IGameObject>();

            foreach ( Layer layer in Game.Instance.Layers )
            {
                layer.GetObjectsAboutToBeAdded( result );
            }

            return result;
        }

        public void Add( Layer l )
        {
            Layers.Add( l );
            Layers.UpdateChanges();
        }

        public void Remove( IGameObject o )
        {
            if ( !o.IsAddedToGame )
                return;

            foreach ( Layer l in Layers )
                l.Remove( o );
        }
          
        public void Remove( Layer l )
        {
            Layers.Remove( l );
            Layers.UpdateChanges();
        }

        public List<GameObject> GetObjects( Predicate<GameObject> condition )
        {
            List<GameObject> objs = new List<GameObject>();

            for ( int i = MaxLayer; i >= MinLayer; i-- )
            {
                foreach ( var obj in Layers[i].Objects )
                {
                    GameObject gobj = obj as GameObject;

                    if ( gobj != null && condition( gobj ) )
                        objs.Add( gobj );
                }
            }

            return objs;
        }

        public List<GameObject> GetObjectsWithTag( params string[] tags )
        {
            return GetObjects( o => tags.Contains<string>( o.Tag as string ) );
        }

        public GameObject GetFirstObject( Predicate<GameObject> condition )
        {
            for ( int i = MaxLayer; i >= MinLayer; i-- )
            {
                foreach ( var obj in Layers[i].Objects )
                {
                    GameObject gobj = obj as GameObject;

                    if ( gobj != null && condition( gobj ) )
                        return gobj;
                }
            }

            return null;
        }

        public Widget GetFirstWidget( Predicate<Widget> condition )
        {
            return (Widget)GetFirstObject( obj => obj is Widget && condition( (Widget)obj ) );
        }

        public List<GameObject> GetObjectsAt( Vector position )
        {
            return GetObjects( obj => obj.IsInside( position ) );
        }

        public GameObject GetObjectAt( Vector position )
        {
            return GetFirstObject( obj => obj.IsInside( position ) && !(obj is MessageDisplay) );
        }

        public Widget GetWidgetAt( Vector position )
        {
            return (Widget)GetFirstObject( obj => obj is Widget && obj.IsInside( position ) && !( obj is MessageDisplay ) );
        }

        public List<GameObject> GetObjectsAt( Vector position, double radius )
        {
            Predicate<GameObject> isInsideRadius = delegate ( GameObject obj )
            {
                if ( obj is MessageDisplay ) return false;

                Vector positionUp = new Vector( position.X, position.Y + radius );
                Vector positionDown = new Vector( position.X, position.Y - radius );
                Vector positionLeft = new Vector( position.X - radius, position.Y );
                Vector positionRight = new Vector( position.X + radius, position.Y );

                if ( obj.IsInside( position ) ) return true;
                if ( obj.IsInside( positionUp ) ) return true;
                if ( obj.IsInside( positionDown ) ) return true;
                if ( obj.IsInside( positionLeft ) ) return true;
                if ( obj.IsInside( positionRight ) ) return true;

                return false;
            };

            return GetObjects( isInsideRadius );
        }

        public GameObject GetObjectAt( Vector position, double radius )
        {
            var objs = GetObjectsAt( position, radius );
            return objs.Count > 0 ? objs[0] : null;
        }

        public List<GameObject> GetObjectsAt( Vector position, object tag )
        {
            return GetObjectsAt( position ).FindAll( obj => obj.Tag == tag );
        }

        public GameObject GetObjectAt( Vector position, object tag )
        {
            return GetObjectsAt( position ).Find( obj => obj.Tag == tag );
        }

        public List<GameObject> GetObjectsAt( Vector position, object tag, double radius )
        {
            return GetObjectsAt( position, radius ).FindAll<GameObject>( obj => obj.Tag == tag );
        }

        public GameObject GetObjectAt( Vector position, object tag, double radius )
        {
            return GetObjectsAt( position, radius ).Find( obj => obj.Tag == tag );
        }

        public List<GameObject> GetObjectsBetween( Vector pos1, Vector pos2 )
        {
            return GetObjects( obstacle => !( obstacle is Widget ) && obstacle.IsBlocking( pos1, pos2 ) );
        }

        public static Animation LoadAnimation( string name )
        {
            return Instance.Content.Load<Animation>( name );
        }

        public static Image LoadImage( string name )
        {
            return new Image( name );
        }

        public static Image[] LoadImages( params string[] names )
        {
            Image[] result = new Image[names.Length];
            for ( int i = 0; i < names.Length; i++ )
                result[i] = LoadImage( names[i] );
            return result;
        }

        public static Image[] LoadImages( string baseName, int startIndex, int endIndex, bool zeroPad = false )
        {
            if ( startIndex > endIndex ) throw new ArgumentException("Starting index must be smaller than ending index.");

            Image[] result = new Image[endIndex - startIndex];
            string format;

            if ( zeroPad )
            {
                int digits = endIndex.ToString().Length;
                format = "{0}{1:" + "0".Repeat( digits ) + "}";
            }
            else
            {
                format = "{0}{1}";
            }

            for ( int i = startIndex; i < endIndex; i++ )
            {
                string imgName = String.Format( format, baseName, i );
                result[i - startIndex] = LoadImage( imgName );
            }

            return result;
        }

        public static void PlaySound( string name )
        {
            LoadSoundEffect( name ).Play();
        }

        public static SoundEffect LoadSoundEffect( string name )
        {
            return new SoundEffect( name );
        }

        public static SoundEffect[] LoadSoundEffects( params string[] names )
        {
            SoundEffect[] result = new SoundEffect[names.Length];
            for ( int i = 0; i < names.Length; i++ )
                result[i] = LoadSoundEffect( names[i] );
            return result;
        }

        public void ClearTimers()
        {
            Timer.ClearAll();
        }

        public virtual void ClearAll()
        {
            Level.Clear();
            ResetLayers();
            ClearTimers();
#if !WINDOWS_PHONE
            ClearLights();
#endif
            ClearControls();
            GC.Collect();
            addMessageDisplay();
            ControlContext.Enable();
            Camera.Reset();
        }

        public void ResetLayers()
        {
            ClearGameObjects();
            InitializeLayers();
        }

        public void RemoveAllLayers()
        {
            ClearGameObjects();
            Layers.Clear();
        }

        public void ClearControls()
        {
            controls.Clear();
            TouchPanel.Clear();
        }

        public void ClearGameObjects()
        {
            foreach ( var layer in Layers )
                layer.Clear();

            addMessageDisplay();
        }

#if !WINDOWS_PHONE
        public void ClearLights()
        {
            lights.Clear();
        }
#endif

        protected virtual void PausedUpdate( Time time )
        {
            foreach ( var layer in Layers )
            {
                // Update the UI components only
                layer.Objects.Update( time, o => o is Widget );
            }

            Timer.UpdateAll( time, t => t.IgnorePause );
        }

        protected virtual void Update( Time time )
        {
            this.Camera.Update( time );
            Layers.Update( time );
            Timer.UpdateAll( time );
            UpdateHandlers( time );

            while (PendingActions.Count > 0)
            {
                PendingActions.Dequeue()();
            }
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        protected override void Initialize()
        {
            Jypeli.Graphics.Initialize();
            screen = new ScreenView( GraphicsDevice.Viewport );

#if WINDOWS_PHONE
            Phone.ResetScreen();
#else
            Point defaultSize = GetDefaultWindowSize();
            Window.Width = defaultSize.X;
            Window.Height = defaultSize.Y;
            Window.Update();
#endif

            theLevel = new Level( this );

            MediaPlayer = new MediaPlayer( Content );

            addMessageDisplay();
            InitDebugScreen();

            base.Initialize();
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        protected override void LoadContent()
        {
            if ( !loadContentHasBeenCalled )
            {
                if ( InstanceInitialized != null )
                    InstanceInitialized();

#if !WINDOWS_PHONE
                CallBegin();
#endif
                loadContentHasBeenCalled = true;
            }

#if DEBUG && !WINDOWS_PHONE
            MessageDisplay.Add( "F12 - Debug view" );
#endif
            base.LoadContent();

            GC.Collect();
        }

        internal void CallBegin()
        {
            Begin();
            beginHasBeenCalled = true;
        }

        public virtual void Begin()
        {
        }

        public virtual void Continue()
        {
        }

        protected override void OnExiting( object sender, EventArgs args )
        {
            if ( Exiting != null )
                Exiting();

            base.OnExiting( sender, args );
        }

        private void addMessageDisplay()
        {
            MessageDisplay = new MessageDisplay();
            MessageDisplay.BackgroundColor = Color.LightGray;
            Add( MessageDisplay );
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        protected override void Update( GameTime gameTime )
        {
            if ( !loadContentHasBeenCalled || !beginHasBeenCalled )
            {
                // No updates until both LoadContent and Begin have been called
                base.Update( gameTime );
                return;
            }

            Window.Update();
            currentRealTime.Advance( gameTime );

            if ( this.IsActive ) controls.Update();
            if ( DataStorage.IsUpdated )
                DataStorage.Update( currentRealTime );

            // The update in derived classes.
            if ( !IsPaused )
            {
                currentTime.Advance( gameTime );
                this.Update( currentTime );
            }
            else
            {
                this.PausedUpdate( currentRealTime );
            }

            UpdateDebugScreen( currentRealTime );

            base.Update( gameTime );
        }

        protected virtual void Paint( Canvas canvas )
        {
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        protected override void Draw( GameTime gameTime )
        {
            Time time = new Time( gameTime );

            GraphicsDevice.Clear( ClearOptions.Target, Level.Background.Color.AsXnaColor(), 1.0f, 0 );

            if ( Level.Background.Image != null && !Level.Background.MovesWithCamera )
            {
                SpriteBatch spriteBatch = Jypeli.Graphics.SpriteBatch;
                spriteBatch.Begin( SpriteSortMode.Deferred, BlendState.AlphaBlend );
                spriteBatch.Draw( Level.Background.Image.XNATexture, new XnaRectangle( 0, 0, (int)screen.Width, (int)screen.Height ), XnaColor.White );
                spriteBatch.End();
            }

            // The world matrix adjusts the position and size of objects according to the camera angle.
            var worldMatrix =
                Matrix.CreateTranslation( (float)-Camera.Position.X, (float)-Camera.Position.Y, 0 )
                * Matrix.CreateScale( (float)Camera.ZoomFactor, (float)Camera.ZoomFactor, 1f );

            // If the background should move with camera, draw it here.
            Level.Background.Draw( worldMatrix, Matrix.Identity );

            if ( DrawPerimeter )
            {
                Matrix m = Matrix.CreateScale( (float)Level.Width, (float)Level.Height, 1 ) * worldMatrix;
                Renderer.DrawRectangle( ref m, PerimeterColor );
            }

            foreach ( var layer in Layers )
            {
                layer.Draw( Camera );
            }

            Graphics.LineBatch.Begin( ref worldMatrix );
            Graphics.Canvas.Reset( Level );
            Paint( Graphics.Canvas );
            Graphics.LineBatch.End();

            DrawDebugScreen();

            base.Draw( gameTime );
        }

        [Obsolete( "Please set Window.Width, Window.Height and Window.Fullscreen instead." )]
        public bool SetWindowSize( int width, int height, bool fullscreen )
        {
            Window.Width = width;
            Window.Height = height;
            Window.Fullscreen = fullscreen;
            return true;
        }

        public bool SetWindowSize( int width, int height )
        {
            Window.Width = width;
            Window.Height = height;
            return true;
        }

        private Point GetDefaultWindowSize()
        {
            int xres = GraphicsDevice.DisplayMode.Width;
            int yres = GraphicsDevice.DisplayMode.Height;

#if WINDOWS
            System.Drawing.Graphics graphics = System.Drawing.Graphics.FromHwnd(IntPtr.Zero);
            IntPtr hdc = graphics.GetHdc();
            int logicalScreenHeight = GetDeviceCaps(hdc, (int)DeviceCap.VERTRES);
            int physicalScreenHeight = GetDeviceCaps(hdc, (int)DeviceCap.DESKTOPVERTRES);
            graphics.ReleaseHdc(hdc);
            graphics.Dispose();

            float scaleFactor = (float)logicalScreenHeight / (float)physicalScreenHeight;

            xres = (int)(xres * scaleFactor);
            yres = (int)(yres * scaleFactor);

            int borderwidth = GetSystemMetrics( 32 ); // SM_CXFRAME
            int titleheight = GetSystemMetrics( 30 ); // SM_CXSIZE
            yres -= borderwidth + titleheight;
#endif

            /*if ( xres > 1024 && yres > 768 ) return new Point( 1024, 768 );
            if ( xres > 800 && yres > 600 ) return new Point( 800, 600 );

            return new Point( 640, 480 );*/

            return new Point( xres, yres );
        }

        public void Pause()
        {
            IsPaused = !IsPaused;
        }

        public void Exit()
        {
            Phone.StopVibrating();
            base.Exit();
        }

        public void ConfirmExit()
        {
            bool cursorVisible = IsMouseVisible;
            IsMouseVisible = true;

            YesNoWindow kyselyIkkuna = new YesNoWindow( "Do you want to quit?" );
            kyselyIkkuna.Yes += Exit;
            kyselyIkkuna.Closed += delegate { IsMouseVisible = cursorVisible; IsPaused = false; };
            Add( kyselyIkkuna );

            IsPaused = true;
        }

        public void SaveGame( string tagName )
        {
            Type gameType = this.GetType();
            SaveState state = DataStorage.BeginSave( tagName );

            foreach ( PropertyInfo property in gameType.GetProperties( BindingFlags.GetProperty | StorageFile.AllOfInstance ) )
            {
                if ( property.GetCustomAttributes( typeof( SaveAttribute ), true ).Length == 0 )
                    continue;

                object propValue = property.GetValue( this, null );
                Type propType = property.PropertyType;
                //DataStorage.Save( propValue, propType, tagName + FileManager.SanitizeFileName( property.Name ) );
                state.Save( propValue, propType, FileManager.SanitizeFileName( property.Name ) + "Property" );
            }

            foreach ( FieldInfo field in gameType.GetFields( BindingFlags.GetField | StorageFile.AllOfInstance ) )
            {
                if ( field.GetCustomAttributes( typeof( SaveAttribute ), true ).Length == 0 )
                    continue;

                object fieldValue = field.GetValue( this );
                Type fieldType = field.FieldType;
                //DataStorage.Save( fieldValue, fieldType, tagName + FileManager.SanitizeFileName( field.Name ) );
                state.Save( fieldValue, fieldType, FileManager.SanitizeFileName( field.Name ) + "Field" );
            }

            state.EndSave();
        }

        public void LoadGame( string tagName )
        {
            if ( !DataStorage.Exists( tagName ) )
                return;

            Type gameType = this.GetType();

            LoadState state = DataStorage.BeginLoad( tagName );

            foreach ( PropertyInfo property in gameType.GetProperties( BindingFlags.GetProperty | StorageFile.AllOfInstance ) )
            {
                if ( property.GetCustomAttributes( typeof( SaveAttribute ), true ).Length == 0 )
                    continue;

                object oldValue = property.GetValue( this, null );
                Type propType = property.PropertyType;
                //object newValue = DataStorage.Load( oldValue, propType, tagName + FileManager.SanitizeFileName( property.Name ) );
                object newValue = state.Load( oldValue, propType, FileManager.SanitizeFileName( property.Name ) + "Property" );
                property.SetValue( this, newValue, null );
            }

            foreach ( FieldInfo field in gameType.GetFields( BindingFlags.GetField | StorageFile.AllOfInstance ) )
            {
                if ( field.GetCustomAttributes( typeof( SaveAttribute ), true ).Length == 0 )
                    continue;

                object oldValue = field.GetValue( this );
                Type fieldType = field.FieldType;
                //object newValue = DataStorage.Load( oldValue, fieldType, tagName + FileManager.SanitizeFileName( field.Name ) );
                object newValue = state.Load( oldValue, fieldType, FileManager.SanitizeFileName( field.Name ) + "Field" );
                field.SetValue( this, newValue );
            }

            state.EndLoad();
        }

        public void AddFactory<T>( string tag, Factory.FactoryMethod method )
        {
            Factory.AddFactory<T>( tag, method );
        }

        public void RemoveFactory<T>( string tag, Factory.FactoryMethod method )
        {
            Factory.RemoveFactory<T>( tag, method );
        }

        public T FactoryCreate<T>( string tag )
        {
            return Factory.FactoryCreate<T>( tag );
        }

        public void ShowControlHelp()
        {
            MessageDisplay.Add( "Ohjeet:" );

            foreach ( String message in controls.GetHelpTexts() )
            {
                MessageDisplay.Add( message );
            }
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        public void Dispose()
        {
        }

        private void BindControlHelp( params object[] keysOrButtons )
        {
            String nappaimet = "";

            foreach ( object o in keysOrButtons )
            {
                if ( o is Key )
                {
                    Key k = (Key)o;
                    controls.Keyboard.Listen( k, ButtonState.Pressed, ShowControlHelp, null );

                    nappaimet += k.ToString();
                }

                if ( o is Button )
                {
                    Button b = (Button)o;
                    for ( int i = 0; i < controls.GameControllers.Length; i++ )
                    {
                        controls.GameControllers[i].Listen( b, ButtonState.Pressed, ShowControlHelp, null );
                    }

                    nappaimet += b.ToString();
                }

                nappaimet += " / ";
            }

            MessageDisplay.Add( "Katso näppäinohje painamalla " + nappaimet.Substring( 0, nappaimet.Length - 3 ) );
        }

        public static Image LoadImageFromResources( string name )
        {
            return new Image( ResourceContent.Load<Texture2D>( name ) );
        }

        public static SoundEffect LoadSoundEffectFromResources( string name )
        {
            return new SoundEffect( ResourceContent.Load<XnaSoundEffect>( name ) );
        }

        public static Font LoadFont( string name )
        {
            return new Font( name, ContentSource.GameContent );
        }
    }
}