FollowerBrain.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Jypeli
{
    public class FollowerBrain : AbstractMoverBrain
    {
        double _logicDelay = 0;
        double remainingDelay = 0;
        Vector targetPosition;

        #region Properties

        public List<string> TagsToFollow { get; set; }

        public List<IGameObject> ObjectsToFollow { get; set; }

        public Comparison<IGameObject> FollowComparer { get; set; }

        public IGameObject CurrentTarget { get; protected set; }

        public DoubleMeter DistanceToTarget { get; protected set; }

        public double DistanceClose { get; set; }

        public double DistanceFar { get; set; }

        public Brain FarBrain { get; set; }

        public Brain CloseBrain { get; set; }

        public event Action TargetClose;

        public bool StopWhenTargetClose { get; set; }

        public double Delay
        {
            get { return _logicDelay; }
            set
            {
                _logicDelay = value;
                remainingDelay = ( Owner == null ) ? 0 : value;
            }
        }

        #endregion

        #region Comparers

        public Comparison<IGameObject> CreateDistanceComparer( double changeTargetDistance )
        {
            return delegate ( IGameObject obj1, IGameObject obj2 )
            {
                if ( Owner == null ) return 0;
                if ( obj1 == null ) return 1;
                if ( obj2 == null ) return -1;

                double d1 = Vector.Distance( Owner.AbsolutePosition, obj1.AbsolutePosition );
                double d2 = Vector.Distance( Owner.AbsolutePosition, obj2.AbsolutePosition );
                double diff = Math.Abs( d1 - d2 );

                if ( CurrentTarget == obj1 && diff < changeTargetDistance ) return -1;
                if ( CurrentTarget == obj2 && diff < changeTargetDistance ) return 1;

                return d1.CompareTo( d2 );
            };
        }

        #endregion

        public FollowerBrain()
            : this( null )
        {
        }

        public FollowerBrain( params object[] targets )
            : base()
        {
            ObjectsToFollow = new List<IGameObject>();
            TagsToFollow = new List<string>();
            DistanceToTarget = new DoubleMeter( double.PositiveInfinity, 0, double.PositiveInfinity );
            FollowComparer = CreateDistanceComparer( 20 );
            DistanceFar = double.PositiveInfinity;
            DistanceClose = 100.0;
            StopWhenTargetClose = false;
            FarBrain = Brain.None;

            if (targets == null)
                return;

            for (int i = 0; i < targets.Length; i++)
            {
                if (targets[i] is IGameObject)
                    ObjectsToFollow.Add((IGameObject)targets[i]);
                else if (targets[i] is string)
                    TagsToFollow.Add((string)targets[i]);
                else
                    throw new ArgumentException(string.Format("Target type not recognized: {0} ({1})", targets[i].ToString(), targets[i].GetType().Name));
            }
        }

        private void SelectTarget()
        {
            CurrentTarget = null;

            foreach ( var layer in Game.Instance.Layers )
            {
                foreach ( var obj in layer.Objects )
                {
                    if (obj == Owner || obj.IsDestroyed)
                        continue;

                    if ( !ObjectsToFollow.Contains( obj ) && !TagsToFollow.Contains( obj.Tag as string ) )
                        continue;

                    if ( CurrentTarget == null || FollowComparer( CurrentTarget, obj ) > 0 )
                        CurrentTarget = obj;
                }
            }

            if ( Owner != null && CurrentTarget != null )
                DistanceToTarget.Value = Vector.Distance( Owner.AbsolutePosition, CurrentTarget.AbsolutePosition );
            else
                DistanceToTarget.Value = double.PositiveInfinity;
        }

        private void SetTargetPosition( double dt )
        {
            targetPosition = CurrentTarget.AbsolutePosition;

            if ( Delay > 0 && DistanceToTarget.Value > float.Epsilon )
            {
                double maxlength = Math.Sqrt( Math.Pow( Game.Instance.Level.Width, 2 ) + Math.Pow( Game.Instance.Level.Height, 2 ) );
                targetPosition += Vector.FromLengthAndAngle( maxlength, ( CurrentTarget.AbsolutePosition - Owner.AbsolutePosition ).Angle );
            }

            IPhysicsObject physTarget = CurrentTarget as IPhysicsObject;

            if ( physTarget != null )
            {
                // Take speed and acceleration into account
                targetPosition += ( ( physTarget.Acceleration * dt ) + physTarget.Velocity ) * dt;
            }
        }

        protected override void Update( Time time )
        {
            double dt = Game.Time.SinceLastUpdate.TotalSeconds;
            if ( dt <= 0 ) return;
            
            remainingDelay -= dt;
            if ( remainingDelay <= 0 || CurrentTarget == null || !CurrentTarget.IsAddedToGame )
            {
                SelectTarget();
                if ( CurrentTarget == null )
                    return;

                SetTargetPosition( dt );
                remainingDelay = Delay;
            }
            else
            {
                DistanceToTarget.Value = Vector.Distance( Owner.AbsolutePosition, CurrentTarget.AbsolutePosition );

                if ( TurnWhileMoving )
                {
                    Vector realDist = CurrentTarget.AbsolutePosition - Owner.AbsolutePosition;
                    if ( !double.IsNaN( realDist.Magnitude ) && !double.IsInfinity( realDist.Magnitude ) )
                        Turn( realDist.Angle );
                }
            }
            
            double distance = DistanceToTarget.Value;
            bool targetClose = Math.Abs( distance ) < DistanceClose;
            bool targetFar = Math.Abs( distance ) > DistanceFar;
            if ( targetClose && TargetClose != null ) TargetClose();

            if ( targetClose )
            {
                if ( StopWhenTargetClose )
                {
                    if ( Owner is PhysicsObject )
                        ( (PhysicsObject)Owner ).Stop();

                    return;
                }

                if (CloseBrain != null)
                {
                    CloseBrain.Owner = this.Owner;
                    CloseBrain.DoUpdate(time);
                    return;
                }
            }

            if ( targetFar )
            {
                FarBrain.Owner = this.Owner;
                FarBrain.DoUpdate( time );
                return;
            }

            Vector d = targetPosition - Owner.AbsolutePosition;
            if ( d.Magnitude > float.Epsilon )
                Move( d / dt );
            else if ( Owner is PhysicsObject )
                ( (PhysicsObject)Owner ).Stop();
            
            base.Update( time );
        }
    }
}