Meter.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.Collections.Generic;

namespace Jypeli
{
    public enum TriggerDirection
    {
        Up,

        Down,
        
        Irrelevant
    };

    public abstract class Meter
    {
        public abstract double RelativeValue { get; set; }

        internal abstract double GetValue();
        internal abstract double GetMinValue();
        internal abstract double GetMaxValue();

        public Meter<T> OfType<T>() where T : struct, IComparable<T>, IEquatable<T>
        {
            Type meterType = this.GetType();
            Type[] genargs = meterType.GetGenericArguments();

            if ( genargs.Length < 1 ) throw new ArgumentException( "This meter is not typed" );
            if ( genargs[0] != typeof( T ) ) throw new ArgumentException( String.Format( "This meter measures {0}, not {1}", genargs[0].Name, typeof( T ).Name ) );

            return (Meter<T>)this;
        }
    }

    [Save]
    public abstract class Meter<ValueType> : Meter where ValueType : struct, IComparable<ValueType>, IEquatable<ValueType>
    {
        private struct Trigger
        {
            public ValueType value;
            public TriggerDirection direction;
            public Action method;

            public Trigger(ValueType value, TriggerDirection direction, Action method)
            {
                this.value = value;
                this.direction = direction;
                this.method = method;
            }
        }

        private bool valueSet;

        private ValueType val;
        private ValueType minval;
        private ValueType maxval;
        private ValueType defval;

        private List<Trigger> triggers;

        [Save]
        public ValueType Value
        {
            get { return val; }
            set
            {
                if ( value.Equals( val ) )
                    return;

                ValueType oldval = val;
                valueSet = true;

                if (value.CompareTo(minval) < 0) value = minval;
                if (value.CompareTo(maxval) > 0) value = maxval;

                val = value;
                OnChange(oldval, value);
                CheckLimits( oldval, value );
                CheckTriggers(oldval, value);
            }
        }

        public ValueType DefaultValue
        {
            get { return defval; }
            set
            {
                defval = clampValue( value, minval, maxval );
                if ( !valueSet ) Value = value;
            }
        }

        public ValueType MinValue
        {
            get { return minval; }
            set { minval = value; updateBounds(); }
        }

        public ValueType MaxValue
        {
            get { return maxval; }
            set { maxval = value; updateBounds(); }
        }

        #region Events

        public delegate void ChangeHandler( ValueType oldValue, ValueType newValue );

        public event ChangeHandler Changed;

        public event Action LowerLimit;

        public event Action UpperLimit;


        private void OnChange( ValueType oldValue, ValueType newValue )
        {
            if ( Changed != null )
                Changed( oldValue, newValue );
        }

        private void CheckLimits( ValueType oldValue, ValueType newValue )
        {
            if ( LowerLimit != null && newValue.CompareTo(minval) <= 0 && oldValue.CompareTo(minval) > 0 )
            {
                LowerLimit();
                return;
            }

            if ( UpperLimit != null && newValue.CompareTo(maxval) >= 0 && oldValue.CompareTo(maxval) < 0 )
            {
                UpperLimit();
                return;
            }
        }

        private void CheckTriggers( ValueType oldValue, ValueType newValue )
        {
            if ( triggers == null ) return;

            foreach ( Trigger t in triggers )
            {
                if ( t.direction != TriggerDirection.Down && oldValue.CompareTo( t.value ) < 0 && newValue.CompareTo( t.value ) >= 0 )
                    t.method();
                
                else if ( t.direction != TriggerDirection.Up && oldValue.CompareTo( t.value ) > 0 && newValue.CompareTo( t.value ) <= 0 )
                    t.method();
            }
        }

        #endregion

        public Meter( ValueType defaultVal, ValueType minVal, ValueType maxVal )
        {
            minval = minVal;
            maxval = maxVal;
            defval = defaultVal;
            val = defaultVal;
            updateBounds();
        }

        public Meter( Meter<ValueType> src )
        {
            minval = src.minval;
            maxval = src.maxval;
            defval = src.defval;
            val = src.val;
            updateBounds();
        }

        public void Reset()
        {
            Value = DefaultValue;
        }

        public void SetValue( ValueType value )
        {
            Value = value;
        }

        public void AddTrigger( ValueType value, TriggerDirection direction, Action method )
        {
            if ( triggers == null ) triggers = new List<Trigger>();
            triggers.Add( new Trigger( value, direction, method ) );
        }

        public void AddTrigger( ValueType value, TriggerDirection direction, Action<ValueType> method )
        {
            AddTrigger( value, direction, delegate() { method( this.Value ); } );
        }

        public void RemoveTriggers( ValueType value )
        {
            if ( triggers == null ) return;
            triggers.RemoveAll( t => t.value.Equals( value ) );
        }

        public void RemoveTriggers( Action method )
        {
            if ( triggers == null ) return;
            triggers.RemoveAll( t => t.method == method );
        }

        public void ClearTriggers()
        {
            if ( triggers == null ) return;
            triggers.Clear();
        }

        private static ValueType clampValue( ValueType v, ValueType min, ValueType max )
        {
            if (min.CompareTo(max) > 0)
            {
                // Maximum is less than minimum, don't clamp
                return v;
            }

            if ( v.CompareTo( min ) < 0 )
                return min;

            if ( v.CompareTo( max ) > 0 )
                return max;

            return v;
        }

        private static void clampValue( ref ValueType v, ValueType min, ValueType max )
        {
            if ( min.CompareTo( max ) > 0 )
            {
                // Maximum is less than minimum, don't clamp
                return;
            }

            if ( v.CompareTo( min ) < 0 )
                v = min;

            else if ( v.CompareTo( max ) > 0 )
                v = max;
        }

        private void updateBounds()
        {
            clampValue( ref val, minval, maxval );
            clampValue( ref defval, minval, maxval );
        }

        public override String ToString()
        {
            return Value.ToString();
        }
    }


    public class IntMeter : Meter<int>
    {
        private List<Operation> operations = new List<Operation>();

        public override double RelativeValue
        {
            get { return ( Value - MinValue ) / (double)( MaxValue - MinValue ); }
            set { Value = (int)( MinValue + value * ( MaxValue - MinValue ) ); }
        }

        public IntMeter( int defaultValue )
            : base( defaultValue, 0, int.MaxValue )
        {
        }

        public IntMeter(int defaultValue,int minValue, int MaxValue)
            : base(defaultValue, minValue,MaxValue)
        {
        }

        public static implicit operator int( IntMeter m )
        {
            return m.Value;
        }

        public static implicit operator double( IntMeter m )
        {
            return (double)m.Value;
        }

        public void AddValue( int change )
        {
            Value += change;
        }

        public void MultiplyValue( int multiplier )
        {
            Value *= multiplier;
        }

        public void MultiplyValue( double multiplier )
        {
            Value = (int)Math.Round( Value * multiplier );
        }

        public Operation AddOverTime( int change, double seconds, Action onComplete )
        {
            Operation op = AddOverTime( change, seconds );
            op.Finished += onComplete;
            return op;
        }

        public Operation AddOverTime( int change, double seconds )
        {
            Operation op = new IntMeterAddOperation( this, change, seconds );
            op.Finished += delegate { operations.Remove( op ); };
            op.Stopped += delegate { operations.Remove( op ); };
            operations.Add( op );
            return op;
        }

        public void Stop()
        {
            while ( operations.Count > 0 )
                operations[0].Stop();
        }

        internal override double GetValue()
        {
            return Value;
        }

        internal override double GetMinValue()
        {
            return MinValue;
        }

        internal override double GetMaxValue()
        {
            return MaxValue;
        }
    }

    public class DoubleMeter : Meter<double>
    {
        private List<Operation> operations = new List<Operation>();

        public override double RelativeValue
        {
            get { return ( Value - MinValue ) / ( MaxValue - MinValue ); }
            set { Value = MinValue + value * ( MaxValue - MinValue ); }
        }

        public DoubleMeter( double defaultValue )
            : base( defaultValue, 0.0, double.MaxValue )
        {
        }

        public DoubleMeter(double defaultValue,double minValue, double maxValue)
            : base(defaultValue,minValue, maxValue)
        {
        }

        public static implicit operator double( DoubleMeter m )
        {
            return m.Value;
        }

        public void AddValue( double change )
        {
            Value += change;
        }

        public void MultiplyValue( double multiplier )
        {
            Value *= multiplier;
        }

        public Operation AddOverTime( double change, double seconds, Action onComplete )
        {
            Operation op = AddOverTime( change, seconds );
            op.Finished += onComplete;
            return op;
        }

        public Operation AddOverTime( double change, double seconds )
        {
            Operation op = new DoubleMeterAddOperation( this, change, seconds );
            op.Finished += delegate { operations.Remove( op ); };
            op.Stopped += delegate { operations.Remove( op ); };
            operations.Add( op );
            return op;
        }

        public void Stop()
        {
            while ( operations.Count > 0 )
                operations[0].Stop();
        }

        internal override double GetValue()
        {
            return Value;
        }

        internal override double GetMinValue()
        {
            return MinValue;
        }

        internal override double GetMaxValue()
        {
            return MaxValue;
        }
    }
}