Animation.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;
 
#if WINDOWS_STOREAPP
using ImageConverter = Jypeli.ListHelpers.Converter<Jypeli.Image, Jypeli.Image>;
#else
using ImageConverter = System.Converter<Jypeli.Image, Jypeli.Image>;
#endif
 
namespace Jypeli
{
    public class Animation : IEnumerable<Image>
    {
        private double secondsPerFrame;
        private TimeSpan startTime;
        private int currentIndex;
        private int repeatCount = -1; // When -1, animation repeats forever.
 
        // NOTES:
        //
        // Animation frames should be immutable, because that is what
        // the Layer class assumes. So, let's not provide
        // any methods to modify the images of an existing animation.
        //
        // This is not a big deal, as there rarely is any need
        // to modify animations at runtime and constructing new
        // animation objects is quite easy anyway.
 
        internal Image[] frames = null;
 
        public bool IsPlaying { get; set; }
 
        public int FrameCount
        {
            get { return frames.Length; }
        }
 
        int lastRepeat = 0;
 
        public int CurrentFrameIndex
        {
            get
            {
                if ( !IsPlaying ) return currentIndex;
 
                double secondsNow = Game.Time.SinceStartOfGame.TotalSeconds;
                double secondsAdvanced = secondsNow - startTime.TotalSeconds;
                int currentRepeat = (int)( secondsAdvanced / ( FrameCount * secondsPerFrame ) );
 
                if ( currentRepeat > lastRepeat )
                {
                    OnPlayed();
                    lastRepeat = currentRepeat;
                }
                    
                if ( repeatCount >= 0 && currentRepeat >= repeatCount )
                    Stop();
 
                return ( (int)( secondsAdvanced * FPS ) ) % FrameCount;
            }
        }
 
        public double FPS
        {
            get { return 1 / secondsPerFrame; }
            set
            {
                if ( value == 0 )
                    throw new ArgumentException( "FPS can not be zero" );
                secondsPerFrame = 1 / value;
            }
        }
 
        public Image CurrentFrame
        {
            get { return frames[CurrentFrameIndex]; }
        }
 
        public bool StopOnLastFrame { get; set; }
 
        public double Width
        {
            get { return FrameCount > 0 ? frames[0].Width : 0; }
        }
 
        public double Height
        {
            get { return FrameCount > 0 ? frames[0].Height : 0; }
        }
 
        public Vector Size
        {
            get { return new Vector( Width, Height ); }
        }
 
        public event Action Played;
 
        private void OnPlayed()
        {
            if ( Played != null ) Played();
        }
 
        public Animation( params Image[] frames )
        {
            if ( frames.Length == 0 )
                throw new ArgumentException( "Animation must have at least one frame." );
            FPS = 25;
            currentIndex = 0;
            startTime = Game.Time.SinceStartOfGame;
            this.frames = frames;
        }
 
        public static implicit operator Animation(Image image)
        {
            if ( image == null ) return null;
            return new Animation( image );
        }
 
        public Animation( Animation src )
        {
            FPS = src.FPS;
            IsPlaying = src.IsPlaying;
            startTime = src.startTime;
            currentIndex = src.currentIndex;
            repeatCount = src.repeatCount;
            frames = new Image[src.FrameCount];
 
            // Copy only the references to images.
            for ( int i = 0; i < src.FrameCount; i++ )
                frames[i] = src.frames[i];
        }
 
        public static Animation Apply( Animation anim, ImageConverter method )
        {
            Animation applied = new Animation( anim );
 
            for ( int i = 0; i < anim.frames.Length; i++ )
            {
                applied.frames[i] = method(anim.frames[i]);
            }
 
            return applied;
        }
 
        public static Animation Mirror( Animation anim )
        {
            return Apply( anim, Image.Mirror );
        }
 
        public static Animation Flip( Animation anim )
        {
            return Apply( anim, Image.Flip );
        }
 
        public static Animation Reverse( Animation anim )
        {
            Animation reversed = new Animation( anim );
 
            for ( int i = 0; i < anim.frames.Length / 2; i++ )
            {
                reversed.frames[i] = anim.frames[anim.frames.Length - 1 - i];
                reversed.frames[anim.frames.Length - 1 - i] = anim.frames[i];
            }
 
            return reversed;
        }
 
        public void Start()
        {
            Start( -1 );
        }
 
        public void Start( int repeatCount )
        {
            this.repeatCount = repeatCount;
            startTime = Game.Time.SinceStartOfGame;
            IsPlaying = true;
            lastRepeat = 0;
        }
 
        public void Pause()
        {
            IsPlaying = false;
        }
 
        public void Resume()
        {
            IsPlaying = true;
        }
 
        public void Stop()
        {
            IsPlaying = false;
            currentIndex = 0;
            if ( StopOnLastFrame )
                currentIndex = FrameCount - 1;
            repeatCount = -1;
        }
 
        public void Step( int numberOfFrames )
        {
            IsPlaying = false;
            currentIndex = currentIndex + numberOfFrames;
 
            if ( currentIndex >= FrameCount )
            {
                // Animation has reached its final frame
                if ( repeatCount > 0 ) repeatCount--;
 
                if ( repeatCount == 0 )
                    Stop();
                else
                {
                    // Play it again, Sam
                    currentIndex %= FrameCount;
                }
 
                OnPlayed();
            }
        }
 
        public void Step()
        {
            Step( 1 );
        }
 
        #region IEnumerable<Image> Members
 
        public IEnumerator<Image> GetEnumerator()
        {
            foreach ( Image frame in frames )
                yield return frame;
        }
 
        #endregion
 
        #region IEnumerable Members
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return frames.GetEnumerator();
        }
 
        #endregion
    }
}