Controller.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2013 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.Collections.Generic;
 
namespace Jypeli.Controls
{
    public interface Controller
    {
        void Clear();
 
        void Update();
 
        IEnumerable<string> GetHelpTexts();
    }
 
    public abstract class Controller<ControllerState, Control> : Controller where Control : IComparable
    {
        protected static readonly ChangePredicate<ControllerState> AlwaysTrigger
            = delegate { return true; };
        protected static readonly ChangePredicate<ControllerState> NeverTrigger
            = delegate { return false; };
 
        private SynchronousList<Listener<ControllerState, Control>> listeners = new SynchronousList<Listener<ControllerState, Control>>();
        private SynchronousList<Listener<ControllerState, Control>> disabledListeners = new SynchronousList<Listener<ControllerState, Control>>();
 
        public ControllerState PrevState { get; protected set; }
 
        public ControllerState CurrentState { get; protected set; }
 
        internal abstract ControllerState GetState();
 
        public void Update()
        {
            PrevState = CurrentState;
            CurrentState = GetState();
 
            listeners.Update( Game.Time );
            disabledListeners.Update(Game.Time);
            listeners.ForEach( l => l.CheckAndInvoke( PrevState, CurrentState ) );
        }
 
        protected Listener AddListener( ChangePredicate<ControllerState> rule, Control control, string controlName, string helpText, Delegate handler, params object[] args )
        {
            var l = new Listener<ControllerState, Control>( rule, Game.Instance.ControlContext, control, controlName, helpText, handler, args );
            listeners.Add( l );
            return l;
        }
 
        public void Clear()
        {
            listeners.Clear();
        }
 
        public void Disable( Predicate<Listener<ControllerState, Control>> predicate )
        {
            foreach ( var l in listeners )
            {
                if ( predicate( l ) )
                {
                    // Note: synchronous list, does not actually change the list while iterating
                    listeners.Remove( l );
                    disabledListeners.Add( l );
                }
            }
        }
 
        public void Enable( Predicate<Listener<ControllerState, Control>> predicate )
        {
            foreach ( var l in disabledListeners )
            {
                if ( predicate( l ) )
                {
                    // Note: synchronous list, does not actually change the list while iterating
                    listeners.Add( l );
                    disabledListeners.Remove( l );
                }
            }
        }
 
        public void Disable( Control c )
        {
            Disable( l => l.Control.Equals( c ) );
        }
 
        public void Enable( Control c )
        {
            Enable( l => l.Control.Equals( c ) );
        }
 
        public void EnableAll()
        {
            Enable( x => true );
        }
 
        public void DisableAll()
        {
            Disable( x => true );
        }
 
        public IEnumerable<string> GetHelpTexts()
        {
            foreach ( var l in listeners )
            {
                if ( l.ControlName != null && l.HelpText != null )
                    yield return String.Format( "{0} - {1}", l.ControlName, l.HelpText );
            }
        }
    }
}