C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/PendulumGame/GamePlayer.cs

//-----------------------------------------------------------------------------
// GamePlayer.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace PendulumGame
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Text;

    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Graphics;

    using NewGamePhysics.Utilities;
    using NewGamePhysics.Mathematics;
    using NewGamePhysics.Physics;
    using NewGamePhysics.PhysicalElements;

    public class GamePlayer
    {
        private const int ActionIntensityQueueSize = 32;

        private int points;

        private int selectedIndicator;

        private DoublePendulumHinges actionMarker;

        private double actionIntensity;

        private ButterworthFilter filter;

        private EdgeDetector detector;

        private Queue<double> actionIntensityQueue;

        public GamePlayer()
        {
            this.selectedIndicator = 0;
            this.points = 0;
            this.actionIntensityQueue = 
                new Queue<double>(ActionIntensityQueueSize);
            this.filter =
                new ButterworthFilter(ButterworthFilterType.HighPass, 100, 20);
            this.detector =
                new EdgeDetector(EdgeDetectionType.Rising, 0.4);
        }

        #region Properties

        public int SelectedIndicator
        {
            get { return this.selectedIndicator; }
            set { this.selectedIndicator = value; }
        }

        public int Points
        {
            get { 
                return this.points; 
            }
            set 
            {
                this.points = value;
            }
        }

        public DoublePendulumHinges ActionMarker
        {
            get { 
                return this.actionMarker; 
            }
            set { 
                this.actionMarker = value; 
            }
        }

        public double ActionIntensity
        {
            get { 
                return this.actionIntensity; 
            }
            set {
                if (value < -1.0)
                {
                    this.actionIntensity = -1.0;
                }
                else if (value > 1.0)
                {
                    this.actionIntensity = 1.0;
                }
                else
                {
                    this.actionIntensity = value;
                }
            }
        }

        #endregion

        public void TrackActionIntensity()
        {
            // Keep queue the same size by dropping off items
            if (this.actionIntensityQueue.Count == ActionIntensityQueueSize)
            {
                this.actionIntensityQueue.Dequeue();
            }

            // Add new sample
            this.actionIntensityQueue.Enqueue(this.actionIntensity);
        }

        public bool ActionIntensityChanged()
        {
            // Only process if we have enough samples in our queue
            if (this.actionIntensityQueue.Count == ActionIntensityQueueSize)
            {
                double[] samples = this.actionIntensityQueue.ToArray();

                // High-pass filter samples
                double[] filteredSamples = this.filter.Calculate(samples);

                // Edge-detect samples
                double[] detectedSamples = this.detector.Calculate(samples);

                // Return result by checking the last sample
                if (detectedSamples[ActionIntensityQueueSize - 1] > 0.0)
                {
                    return true;
                }
            }

            return false;
        }
    }
}

---