src/Game.cs - fna-workbench Git Source Tree

#region License
/* FNA - XNA4 Reimplementation for Desktop Platforms
 * Copyright 2009-2016 Ethan Lee and the MonoGame Team
 *
 * Released under the Microsoft Public License.
 * See LICENSE for details.
 */
#endregion
 
#region BASIC_PROFILER Option
// #define BASIC_PROFILER
/* Sometimes you need a really quick way to determine if performance is either
 * CPU- or GPU-bound. For XNA games, the fastest generic way is to just time the
 * Update() and Draw() functions, respectively. This is not to say that each
 * function can only have problems for either the CPU or GPU, but the graph can
 * say a lot about one of the two processes if either is notably slower than the
 * other one.
 *
 * This option will draw a rectangle on the right side of the screen. The two
 * colors indicate a rough percentage of time spent in both Update() and Draw().
 * Blue is Update(), Red is Draw(). There may be time spent in other parts of
 * the frame (usually GraphicsDevice.Present if you're faster than the display's
 * refresh rate), but compares to these two functions, the time spent is likely
 * marginal in comparison.
 *
 * If you want _real_ profile data, use a _real_ profiler!
 * -flibit
 */
#endregion
 
#region Using Statements
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
 
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
#endregion
 
namespace Microsoft.Xna.Framework
{
    public class Game : IDisposable
    {
        #region Public Properties
 
        public LaunchParameters LaunchParameters
        {
            get;
            private set;
        }
 
        public GameComponentCollection Components
        {
            get
            {
                return _components;
            }
        }
 
        public TimeSpan InactiveSleepTime
        {
            get
            {
                return _inactiveSleepTime;
            }
            set
            {
                if (value < TimeSpan.Zero)
                {
                    throw new ArgumentOutOfRangeException(
                        "The time must be positive.",
                        default(Exception)
                    );
                }
                if (_inactiveSleepTime != value)
                {
                    _inactiveSleepTime = value;
                }
            }
        }
 
        public bool IsActive
        {
            get
            {
                return _isActive;
            }
            internal set
            {
                if (_isActive != value)
                {
                    _isActive = value;
                    Raise(_isActive ? Activated : Deactivated, EventArgs.Empty);
                }
            }
        }
 
        public bool IsMouseVisible
        {
            get
            {
                return _isMouseVisible;
            }
            set
            {
                if (_isMouseVisible != value)
                {
                    _isMouseVisible = value;
                    FNAPlatform.OnIsMouseVisibleChanged(value);
                }
            }
        }
 
        public TimeSpan TargetElapsedTime
        {
            get
            {
                return _targetElapsedTime;
            }
            set
            {
                if (value <= TimeSpan.Zero)
                {
                    throw new ArgumentOutOfRangeException(
                        "The time must be positive and non-zero.",
                        default(Exception)
                    );
                }
 
                _targetElapsedTime = value;
            }
        }
 
        public bool IsFixedTimeStep
        {
            get
            {
                return _isFixedTimeStep;
            }
            set
            {
                _isFixedTimeStep = value;
            }
        }
 
        public GameServiceContainer Services
        {
            get
            {
                return _services;
            }
        }
 
        public ContentManager Content
        {
            get
            {
                return _content;
            }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException();
                }
                _content = value;
            }
        }
 
        public GraphicsDevice GraphicsDevice
        {
            get
            {
                if (_graphicsDeviceService == null)
                {
                    _graphicsDeviceService = (IGraphicsDeviceService)
                        Services.GetService(typeof(IGraphicsDeviceService));
 
                    if (_graphicsDeviceService == null)
                    {
                        throw new InvalidOperationException(
                            "No Graphics Device Service"
                        );
                    }
                }
                return _graphicsDeviceService.GraphicsDevice;
            }
        }
 
        public GameWindow Window
        {
            get
            {
                return _window;
            }
            internal set
            {
                if (_window == null)
                {
                    Mouse.WindowHandle = value.Handle;
                }
 
                _window = value;
            }
        }
 
        #endregion
 
        #region Internal Fields
 
        /* This variable solely exists for the VideoPlayer -flibit */
        internal static Game Instance = null;
 
        internal bool RunApplication;
 
        #endregion
 
        #region Private Fields
 
        private GameComponentCollection _components;
        private GameServiceContainer _services;
        private ContentManager _content;
 
        private SortingFilteringCollection<IDrawable> _drawables =
            new SortingFilteringCollection<IDrawable>(
                d => d.Visible,
                (d, handler) => d.VisibleChanged += handler,
                (d, handler) => d.VisibleChanged -= handler,
                (d1, d2) => Comparer<int>.Default.Compare(d1.DrawOrder, d2.DrawOrder),
                (d, handler) => d.DrawOrderChanged += handler,
                (d, handler) => d.DrawOrderChanged -= handler
            );
 
        private SortingFilteringCollection<IUpdateable> _updateables =
            new SortingFilteringCollection<IUpdateable>(
                u => u.Enabled,
                (u, handler) => u.EnabledChanged += handler,
                (u, handler) => u.EnabledChanged -= handler,
                (u1, u2) => Comparer<int>.Default.Compare(u1.UpdateOrder, u2.UpdateOrder),
                (u, handler) => u.UpdateOrderChanged += handler,
                (u, handler) => u.UpdateOrderChanged -= handler
            );
 
        private IGraphicsDeviceService _graphicsDeviceService;
 
        private GameWindow _window;
 
        private bool _isActive = true;
        private bool _isMouseVisible = false;
 
        private bool _initialized = false;
        private bool _isFixedTimeStep = true;
 
        private TimeSpan _targetElapsedTime = TimeSpan.FromTicks(166667); // 60fps
 
        private TimeSpan _inactiveSleepTime = TimeSpan.FromSeconds(0.02);
 
        private readonly TimeSpan _maxElapsedTime = TimeSpan.FromMilliseconds(500);
 
        private bool _suppressDraw;
 
#if BASIC_PROFILER
        private long drawStart;
        private long drawTime;
        private long updateStart;
        private long updateTime;
        private BasicEffect profileEffect;
        private Matrix projection;
        private VertexPositionColor[] profilePrimitives;
#endif
 
        #endregion
 
        #region Public Constructors
 
        public Game()
        {
            Instance = this;
 
            AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
 
            LaunchParameters = new LaunchParameters();
            _services = new GameServiceContainer();
            _components = new GameComponentCollection();
            _content = new ContentManager(_services);
 
            Window = FNAPlatform.CreateWindow();
 
            AudioDevice.Initialize();
 
            // Ready to run the loop!
            RunApplication = true;
        }
 
        #endregion
 
        #region Deconstructor
 
        ~Game()
        {
            Dispose(false);
        }
 
        #endregion
 
        #region IDisposable Implementation
 
        private bool _isDisposed;
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
            Raise(Disposed, EventArgs.Empty);
        }
 
        protected virtual void Dispose(bool disposing)
        {
            if (!_isDisposed)
            {
                if (disposing)
                {
                    // Dispose loaded game components.
                    for (int i = 0; i < _components.Count; i += 1)
                    {
                        IDisposable disposable = _components[i] as IDisposable;
                        if (disposable != null)
                        {
                            disposable.Dispose();
                        }
                    }
                    _components = null;
 
                    if (_content != null)
                    {
                        _content.Dispose();
                        _content = null;
                    }
 
 
                    if (_graphicsDeviceService != null)
                    {
                        // FIXME: Does XNA4 require the GDM to be disposable? -flibit
                        (_graphicsDeviceService as IDisposable).Dispose();
                        _graphicsDeviceService = null;
                    }
 
                    AudioDevice.Dispose();
 
                    if (Window != null)
                    {
                        FNAPlatform.DisposeWindow(Window);
                        Window = null;
                    }
                    Mouse.WindowHandle = IntPtr.Zero;
 
                    ContentTypeReaderManager.ClearTypeCreators();
                }
 
                AppDomain.CurrentDomain.UnhandledException -= OnUnhandledException;
 
                _isDisposed = true;
                Instance = null;
            }
        }
 
        [DebuggerNonUserCode]
        private void AssertNotDisposed()
        {
            if (_isDisposed)
            {
                string name = GetType().Name;
                throw new ObjectDisposedException(
                    name,
                    string.Format(
                        "The {0} object was used after being Disposed.",
                        name
                    )
                );
            }
        }
 
        #endregion
 
        #region Events
 
        public event EventHandler<EventArgs> Activated;
        public event EventHandler<EventArgs> Deactivated;
        public event EventHandler<EventArgs> Disposed;
        public event EventHandler<EventArgs> Exiting;
 
        #endregion
 
        #region Public Methods
 
        public void Exit()
        {
            RunApplication = false;
            _suppressDraw = true;
        }
 
        public void ResetElapsedTime()
        {
            if (_initialized)
            {
                _gameTimer.Reset();
                _gameTimer.Start();
                _accumulatedElapsedTime = TimeSpan.Zero;
                _gameTime.ElapsedGameTime = TimeSpan.Zero;
                _previousTicks = 0L;
            }
        }
 
        public void SuppressDraw()
        {
            _suppressDraw = true;
        }
 
        public void RunOneFrame()
        {
            if (!_initialized)
            {
                DoInitialize();
                _gameTimer = Stopwatch.StartNew();
                _initialized = true;
            }
 
            BeginRun();
 
            // FIXME: Not quite right..
            Tick();
 
            EndRun();
        }
 
        public void Run()
        {
            AssertNotDisposed();
 
            if (!_initialized)
            {
                DoInitialize();
                _initialized = true;
            }
 
            BeginRun();
            _gameTimer = Stopwatch.StartNew();
 
            FNAPlatform.RunLoop(this);
 
            EndRun();
 
            OnExiting(this, EventArgs.Empty);
            UnloadContent();
        }
 
        private TimeSpan _accumulatedElapsedTime;
        private readonly GameTime _gameTime = new GameTime();
        private Stopwatch _gameTimer;
        private long _previousTicks = 0;
        private int _updateFrameLag;
 
        public void Tick()
        {
            /* NOTE: This code is very sensitive and can break very badly,
             * even with what looks like a safe change. Be sure to test
             * any change fully in both the fixed and variable timestep
             * modes across multiple devices and platforms.
             */
 
        RetryTick:
 
            // Advance the accumulated elapsed time.
            long currentTicks = _gameTimer.Elapsed.Ticks;
            _accumulatedElapsedTime += TimeSpan.FromTicks(currentTicks - _previousTicks);
            _previousTicks = currentTicks;
 
            /* If we're in the fixed timestep mode and not enough time has elapsed
             * to perform an update we sleep off the the remaining time to save battery
             * life and/or release CPU time to other threads and processes.
             */
            if (IsFixedTimeStep && _accumulatedElapsedTime < TargetElapsedTime)
            {
                int sleepTime = (
                    (int) (TargetElapsedTime - _accumulatedElapsedTime).TotalMilliseconds
                );
 
                /* NOTE: While sleep can be inaccurate in general it is
                 * accurate enough for frame limiting purposes if some
                 * fluctuation is an acceptable result.
                 */
                System.Threading.Thread.Sleep(sleepTime);
 
                goto RetryTick;
            }
 
            // Do not allow any update to take longer than our maximum.
            if (_accumulatedElapsedTime > _maxElapsedTime)
            {
                _accumulatedElapsedTime = _maxElapsedTime;
            }
 
            if (IsFixedTimeStep)
            {
                _gameTime.ElapsedGameTime = TargetElapsedTime;
                int stepCount = 0;
 
                // Perform as many full fixed length time steps as we can.
                while (_accumulatedElapsedTime >= TargetElapsedTime)
                {
                    _gameTime.TotalGameTime += TargetElapsedTime;
                    _accumulatedElapsedTime -= TargetElapsedTime;
                    stepCount += 1;
 
                    DoUpdate(_gameTime);
                }
 
                // Every update after the first accumulates lag
                _updateFrameLag += Math.Max(0, stepCount - 1);
 
                /* If we think we are running slowly, wait
                 * until the lag clears before resetting it
                 */
                if (_gameTime.IsRunningSlowly)
                {
                    if (_updateFrameLag == 0)
                    {
                        _gameTime.IsRunningSlowly = false;
                    }
                }
                else if (_updateFrameLag >= 5)
                {
                    /* If we lag more than 5 frames,
                     * start thinking we are running slowly.
                     */
                    _gameTime.IsRunningSlowly = true;
                }
 
                /* Every time we just do one update and one draw,
                 * then we are not running slowly, so decrease the lag.
                 */
                if (stepCount == 1 && _updateFrameLag > 0)
                {
                    _updateFrameLag -= 1;
                }
 
                /* Draw needs to know the total elapsed time
                 * that occured for the fixed length updates.
                 */
                _gameTime.ElapsedGameTime = TimeSpan.FromTicks(TargetElapsedTime.Ticks * stepCount);
            }
            else
            {
                // Perform a single variable length update.
                _gameTime.ElapsedGameTime = _accumulatedElapsedTime;
                _gameTime.TotalGameTime += _accumulatedElapsedTime;
                _accumulatedElapsedTime = TimeSpan.Zero;
 
                DoUpdate(_gameTime);
            }
 
            // Draw unless the update suppressed it.
            if (_suppressDraw)
            {
                _suppressDraw = false;
            }
            else
            {
                /* Draw/EndDraw should not be called if BeginDraw returns false.
                 * http://stackoverflow.com/questions/4054936/manual-control-over-when-to-redraw-the-screen/4057180#4057180
                 * http://stackoverflow.com/questions/4235439/xna-3-1-to-4-0-requires-constant-redraw-or-will-display-a-purple-screen
                 */
                if (BeginDraw())
                {
                    Draw(_gameTime);
                    EndDraw();
                }
            }
        }
 
        #endregion
 
        #region Protected Methods
 
        protected virtual bool BeginDraw()
        {
#if BASIC_PROFILER
            drawStart = _gameTimer.ElapsedTicks;
#endif
            return true;
        }
 
        protected virtual void EndDraw()
        {
#if BASIC_PROFILER
            drawTime = _gameTimer.ElapsedTicks - drawStart;
            Viewport viewport = GraphicsDevice.Viewport;
            float top = 50;
            float bottom = viewport.Height - 50;
            float middle = 50 + (bottom - top) * (updateTime / (float) (updateTime + drawTime));
            float left = viewport.Width - 100;
            float right = left + 50;
            profilePrimitives[0].Position.X = left;
            profilePrimitives[0].Position.Y = top;
            profilePrimitives[1].Position.X = right;
            profilePrimitives[1].Position.Y = top;
            profilePrimitives[2].Position.X = left;
            profilePrimitives[2].Position.Y = middle;
            profilePrimitives[3].Position.X = right;
            profilePrimitives[3].Position.Y = middle;
            profilePrimitives[4].Position.X = left;
            profilePrimitives[4].Position.Y = middle;
            profilePrimitives[5].Position.X = right;
            profilePrimitives[5].Position.Y = top;
            profilePrimitives[6].Position.X = left;
            profilePrimitives[6].Position.Y = middle;
            profilePrimitives[7].Position.X = right;
            profilePrimitives[7].Position.Y = middle;
            profilePrimitives[8].Position.X = left;
            profilePrimitives[8].Position.Y = bottom;
            profilePrimitives[9].Position.X = right;
            profilePrimitives[9].Position.Y = bottom;
            profilePrimitives[10].Position.X = left;
            profilePrimitives[10].Position.Y = bottom;
            profilePrimitives[11].Position.X = right;
            profilePrimitives[11].Position.Y = middle;
            projection.M11 = (float) (2.0 / (double) viewport.Width);
            projection.M22 = (float) (-2.0 / (double) viewport.Height);
            profileEffect.Projection = projection;
            profileEffect.CurrentTechnique.Passes[0].Apply();
            GraphicsDevice.DrawUserPrimitives(
                PrimitiveType.TriangleList,
                profilePrimitives,
                0,
                12
            );
#endif
            if (GraphicsDevice != null)
            {
                GraphicsDevice.Present();
            }
        }
 
        protected virtual void BeginRun()
        {
#if BASIC_PROFILER
            profileEffect = new BasicEffect(GraphicsDevice);
            profileEffect.FogEnabled = false;
            profileEffect.LightingEnabled = false;
            profileEffect.TextureEnabled = false;
            profileEffect.VertexColorEnabled = true;
            projection = new Matrix(
                1337.0f,
                0.0f,
                0.0f,
                0.0f,
                0.0f,
                -1337.0f,
                0.0f,
                0.0f,
                0.0f,
                0.0f,
                1.0f,
                0.0f,
                -1.0f,
                1.0f,
                0.0f,
                1.0f
            );
            profilePrimitives = new VertexPositionColor[12];
            int i = 0;
            do
            {
                profilePrimitives[i].Position = Vector3.Zero;
                profilePrimitives[i].Color = Color.Blue;
            } while (++i < 6);
            do
            {
                profilePrimitives[i].Position = Vector3.Zero;
                profilePrimitives[i].Color = Color.Red;
            } while (++i < 12);
#endif
        }
 
        protected virtual void EndRun()
        {
#if BASIC_PROFILER
            profileEffect.Dispose();
#endif
        }
 
        protected virtual void LoadContent()
        {
        }
 
        protected virtual void UnloadContent()
        {
        }
 
        protected virtual void Initialize()
        {
            /* According to the information given on MSDN, all GameComponents
             * in Components at the time Initialize() is called are initialized:
             *
             * http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.game.initialize.aspx
             *
             * Note, however, that we are NOT using a foreach. It's actually
             * possible to add something during initialization, and those must
             * also be initialized. There may be a safer way to account for it,
             * considering it may be possible to _remove_ components as well,
             * but for now, let's worry about initializing everything we get.
             * -flibit
             */
            for (int i = 0; i < Components.Count; i += 1)
            {
                Components[i].Initialize();
            }
 
            _graphicsDeviceService = (IGraphicsDeviceService)
                Services.GetService(typeof(IGraphicsDeviceService));
 
            /* FIXME: If this test fails, is LoadContent ever called?
             * This seems like a condition that warrants an exception more
             * than a silent failure.
             */
            if (    _graphicsDeviceService != null &&
                _graphicsDeviceService.GraphicsDevice != null   )
            {
                LoadContent();
            }
        }
 
        private static readonly Action<IDrawable, GameTime> DrawAction =
            (drawable, gameTime) => drawable.Draw(gameTime);
 
        protected virtual void Draw(GameTime gameTime)
        {
            _drawables.ForEachFilteredItem(DrawAction, gameTime);
        }
 
        private static readonly Action<IUpdateable, GameTime> UpdateAction =
            (updateable, gameTime) => updateable.Update(gameTime);
 
        protected virtual void Update(GameTime gameTime)
        {
            _updateables.ForEachFilteredItem(UpdateAction, gameTime);
        }
 
        protected virtual void OnExiting(object sender, EventArgs args)
        {
            Raise(Exiting, args);
        }
 
        protected virtual void OnActivated(object sender, EventArgs args)
        {
            AssertNotDisposed();
            Raise(Activated, args);
        }
 
        protected virtual void OnDeactivated(object sender, EventArgs args)
        {
            AssertNotDisposed();
            Raise(Deactivated, args);
        }
 
        protected virtual bool ShowMissingRequirementMessage(Exception exception)
        {
            if (exception is NoAudioHardwareException)
            {
                FNAPlatform.ShowRuntimeError(
                    Window.Title,
                    "Could not find a suitable audio device. " +
                    " Verify that a sound card is\ninstalled," +
                    " and check the driver properties to make" +
                    " sure it is not disabled."
                );
                return true;
            }
            if (exception is NoSuitableGraphicsDeviceException)
            {
                FNAPlatform.ShowRuntimeError(
                    Window.Title,
                    "Could not find a suitable graphics device." +
                    " More information:\n\n" + exception.Message
                );
                return true;
            }
            return false;
        }
 
        #endregion
 
        #region Private Methods
 
        /* FIXME: We should work toward eliminating internal methods. They
         * could eliminate the possibility that additional platforms could
         * be added by third parties without changing FNA itself.
         */
 
        private void DoUpdate(GameTime gameTime)
        {
            AssertNotDisposed();
#if BASIC_PROFILER
            updateStart = _gameTimer.ElapsedTicks;
#endif
            AudioDevice.Update();
 
            Update(gameTime);
#if BASIC_PROFILER
            updateTime = _gameTimer.ElapsedTicks - updateStart;
#endif
        }
 
        private void DoInitialize()
        {
            AssertNotDisposed();
 
            if (GraphicsDevice == null)
            {
                IGraphicsDeviceManager graphicsDeviceManager = Services.GetService(
                    typeof(IGraphicsDeviceManager)
                ) as IGraphicsDeviceManager;
 
                graphicsDeviceManager.CreateDevice();
            }
 
            FNAPlatform.BeforeInitialize();
            Initialize();
 
            /* We need to do this after virtual Initialize(...) is called.
             * 1. Categorize components into IUpdateable and IDrawable lists.
             * 2. Subscribe to Added/Removed events to keep the categorized
             * lists synced and to Initialize future components as they are
             * added.
             */
            CategorizeComponents();
            _components.ComponentAdded += Components_ComponentAdded;
            _components.ComponentRemoved += Components_ComponentRemoved;
        }
 
        private void CategorizeComponents()
        {
            DecategorizeComponents();
            for (int i = 0; i < Components.Count; i += 1)
            {
                CategorizeComponent(Components[i]);
            }
        }
 
        /* FIXME: I am open to a better name for this method.
         * It does the opposite of CategorizeComponents.
         */
        private void DecategorizeComponents()
        {
            _updateables.Clear();
            _drawables.Clear();
        }
 
        private void CategorizeComponent(IGameComponent component)
        {
            IUpdateable updateable = component as IUpdateable;
 
            if (updateable != null)
            {
                _updateables.Add(updateable);
            }
 
            IDrawable drawable = component as IDrawable;
 
            if (drawable != null)
            {
                _drawables.Add(drawable);
            }
        }
 
        /* FIXME: I am open to a better name for this method.
         * It does the opposite of CategorizeComponent.
         */
        private void DecategorizeComponent(IGameComponent component)
        {
            IUpdateable updateable = component as IUpdateable;
 
            if (updateable != null)
            {
                _updateables.Remove(updateable);
            }
 
            IDrawable drawable = component as IDrawable;
 
            if (drawable != null)
            {
                _drawables.Remove(drawable);
            }
        }
 
        private void Raise<TEventArgs>(EventHandler<TEventArgs> handler, TEventArgs e)
            where TEventArgs : EventArgs
        {
            if (handler != null)
            {
                handler(this, e);
            }
        }
 
        #endregion
 
        #region Private Event Handlers
 
        private void Components_ComponentAdded(
            object sender,
            GameComponentCollectionEventArgs e
        ) {
            /* Since we only subscribe to ComponentAdded after the graphics
             * devices are set up, it is safe to just blindly call Initialize.
             */
            e.GameComponent.Initialize();
            CategorizeComponent(e.GameComponent);
        }
 
        private void Components_ComponentRemoved(
            object sender,
            GameComponentCollectionEventArgs e
        ) {
            DecategorizeComponent(e.GameComponent);
        }
 
        private void OnUnhandledException(
            object sender,
            UnhandledExceptionEventArgs args
        ) {
            ShowMissingRequirementMessage(args.ExceptionObject as Exception);
        }
 
        #endregion
 
        #region SortingFilteringCollection class
 
        /// <summary>
        /// The SortingFilteringCollection class provides efficient, reusable
        /// sorting and filtering based on a configurable sort comparer, filter
        /// predicate, and associate change events.
        /// </summary>
        class SortingFilteringCollection<T> : ICollection<T>
        {
            private readonly List<T> _items;
            private readonly List<AddJournalEntry<T>> _addJournal;
            private readonly Comparison<AddJournalEntry<T>> _addJournalSortComparison;
            private readonly List<int> _removeJournal;
            private readonly List<T> _cachedFilteredItems;
            private bool _shouldRebuildCache;
 
            private readonly Predicate<T> _filter;
            private readonly Comparison<T> _sort;
            private readonly Action<T, EventHandler<EventArgs>> _filterChangedSubscriber;
            private readonly Action<T, EventHandler<EventArgs>> _filterChangedUnsubscriber;
            private readonly Action<T, EventHandler<EventArgs>> _sortChangedSubscriber;
            private readonly Action<T, EventHandler<EventArgs>> _sortChangedUnsubscriber;
 
            public SortingFilteringCollection(
                Predicate<T> filter,
                Action<T, EventHandler<EventArgs>> filterChangedSubscriber,
                Action<T, EventHandler<EventArgs>> filterChangedUnsubscriber,
                Comparison<T> sort,
                Action<T, EventHandler<EventArgs>> sortChangedSubscriber,
                Action<T, EventHandler<EventArgs>> sortChangedUnsubscriber
            ) {
                _items = new List<T>();
                _addJournal = new List<AddJournalEntry<T>>();
                _removeJournal = new List<int>();
                _cachedFilteredItems = new List<T>();
                _shouldRebuildCache = true;
 
                _filter = filter;
                _filterChangedSubscriber = filterChangedSubscriber;
                _filterChangedUnsubscriber = filterChangedUnsubscriber;
                _sort = sort;
                _sortChangedSubscriber = sortChangedSubscriber;
                _sortChangedUnsubscriber = sortChangedUnsubscriber;
 
                _addJournalSortComparison = CompareAddJournalEntry;
            }
 
            private int CompareAddJournalEntry(AddJournalEntry<T> x, AddJournalEntry<T> y)
            {
                int result = _sort(x.Item, y.Item);
                if (result != 0)
                {
                    return result;
                }
                return x.Order - y.Order;
            }
 
            public void ForEachFilteredItem<TUserData>(
                Action<T, TUserData> action,
                TUserData userData
            ) {
                if (_shouldRebuildCache)
                {
                    ProcessRemoveJournal();
                    ProcessAddJournal();
 
                    // Rebuild the cache.
                    _cachedFilteredItems.Clear();
                    for (int i = 0; i < _items.Count; i += 1)
                        if (_filter(_items[i]))
                        {
                            _cachedFilteredItems.Add(_items[i]);
                        }
 
                    _shouldRebuildCache = false;
                }
 
                for (int i = 0; i < _cachedFilteredItems.Count; i += 1)
                {
                    action(_cachedFilteredItems[i], userData);
                }
 
                /* If the cache was invalidated as a result of processing items,
                 * now is a good time to clear it and give the GC (more of) a
                 * chance to do its thing.
                 */
                if (_shouldRebuildCache)
                {
                    _cachedFilteredItems.Clear();
                }
            }
 
            public void Add(T item)
            {
                /* NOTE: We subscribe to item events after items in _addJournal
                 * have been merged.
                 */
                _addJournal.Add(new AddJournalEntry<T>(_addJournal.Count, item));
                InvalidateCache();
            }
 
            public bool Remove(T item)
            {
                if (_addJournal.Remove(AddJournalEntry<T>.CreateKey(item)))
                {
                    return true;
                }
 
                int index = _items.IndexOf(item);
                if (index >= 0)
                {
                    UnsubscribeFromItemEvents(item);
                    _removeJournal.Add(index);
                    InvalidateCache();
                    return true;
                }
                return false;
            }
 
            public void Clear()
            {
                for (int i = 0; i < _items.Count; i += 1)
                {
                    _filterChangedUnsubscriber(_items[i], Item_FilterPropertyChanged);
                    _sortChangedUnsubscriber(_items[i], Item_SortPropertyChanged);
                }
 
                _addJournal.Clear();
                _removeJournal.Clear();
                _items.Clear();
 
                InvalidateCache();
            }
 
            public bool Contains(T item)
            {
                return _items.Contains(item);
            }
 
            public void CopyTo(T[] array, int arrayIndex)
            {
                _items.CopyTo(array, arrayIndex);
            }
 
            public int Count
            {
                get
                {
                    return _items.Count;
                }
            }
 
            public bool IsReadOnly
            {
                get
                {
                    return false;
                }
            }
 
            public IEnumerator<T> GetEnumerator()
            {
                return _items.GetEnumerator();
            }
 
            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return ((System.Collections.IEnumerable) _items).GetEnumerator();
            }
 
            // Sort high to low.
            private static readonly Comparison<int> RemoveJournalSortComparison =
                (x, y) => Comparer<int>.Default.Compare(y, x);
 
            private void ProcessRemoveJournal()
            {
                if (_removeJournal.Count == 0)
                {
                    return;
                }
 
                /* Remove items in reverse. (Technically there exist faster
                 * ways to bulk-remove from a variable-length array, but List<T>
                 * does not provide such a method.)
                 */
                _removeJournal.Sort(RemoveJournalSortComparison);
                for (int i = 0; i < _removeJournal.Count; i += 1)
                {
                    _items.RemoveAt(_removeJournal[i]);
                }
                _removeJournal.Clear();
            }
 
            private void ProcessAddJournal()
            {
                if (_addJournal.Count == 0)
                {
                    return;
                }
 
                /* Prepare the _addJournal to be merge-sorted with _items.
                 * _items is already sorted (because it is always sorted).
                 */
                _addJournal.Sort(_addJournalSortComparison);
 
                int iAddJournal = 0;
                int iItems = 0;
 
                while (iItems < _items.Count && iAddJournal < _addJournal.Count)
                {
                    T addJournalItem = _addJournal[iAddJournal].Item;
                    /* If addJournalItem is less than (belongs before)
                     * _items[iItems], insert it.
                     */
                    if (_sort(addJournalItem, _items[iItems]) < 0)
                    {
                        SubscribeToItemEvents(addJournalItem);
                        _items.Insert(iItems, addJournalItem);
                        iAddJournal += 1;
                    }
                    /* Always increment iItems, either because we inserted and
                     * need to move past the insertion, or because we didn't
                     * insert and need to consider the next element.
                     */
                    iItems += 1;
                }
 
                // If _addJournal had any "tail" items, append them all now.
                for (; iAddJournal < _addJournal.Count; iAddJournal += 1)
                {
                    T addJournalItem = _addJournal[iAddJournal].Item;
                    SubscribeToItemEvents(addJournalItem);
                    _items.Add(addJournalItem);
                }
 
                _addJournal.Clear();
            }
 
            private void SubscribeToItemEvents(T item)
            {
                _filterChangedSubscriber(item, Item_FilterPropertyChanged);
                _sortChangedSubscriber(item, Item_SortPropertyChanged);
            }
 
            private void UnsubscribeFromItemEvents(T item)
            {
                _filterChangedUnsubscriber(item, Item_FilterPropertyChanged);
                _sortChangedUnsubscriber(item, Item_SortPropertyChanged);
            }
 
            private void InvalidateCache()
            {
                _shouldRebuildCache = true;
            }
 
            private void Item_FilterPropertyChanged(object sender, EventArgs e)
            {
                InvalidateCache();
            }
 
            private void Item_SortPropertyChanged(object sender, EventArgs e)
            {
                T item = (T)sender;
                int index = _items.IndexOf(item);
 
                _addJournal.Add(new AddJournalEntry<T>(_addJournal.Count, item));
                _removeJournal.Add(index);
 
                /* Until the item is back in place, we don't care about its
                 * events. We will re-subscribe when _addJournal is processed.
                 */
                UnsubscribeFromItemEvents(item);
                InvalidateCache();
            }
        }
 
        #endregion
 
        #region AddJournalEntry struct
 
        private struct AddJournalEntry<T>
        {
            public readonly int Order;
            public readonly T Item;
 
            public AddJournalEntry(int order, T item)
            {
                Order = order;
                Item = item;
            }
 
            public static AddJournalEntry<T> CreateKey(T item)
            {
                return new AddJournalEntry<T>(-1, item);
            }
 
            public override int GetHashCode()
            {
                return Item.GetHashCode();
            }
 
            public override bool Equals(object obj)
            {
                if (!(obj is AddJournalEntry<T>))
                {
                    return false;
                }
 
                return object.Equals(Item, ((AddJournalEntry<T>) obj).Item);
            }
        }
 
        #endregion
 
        #region FNA Extensions
 
        public static void LogHookEXT(Action<string> logFunc)
        {
            if (logFunc == null)
            {
                FNAPlatform.UnhookLogger();
            }
            else
            {
                FNAPlatform.Log = logFunc;
            }
        }
 
        #endregion
    }
}
Download this file
fna-workbench

fna-workbench Git Source Tree

Root/src/Game.cs

Branches
