FollowerBrain.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
 
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.Position, obj1.Position );
                double d2 = Vector.Distance( Owner.Position, obj2.Position );
                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.Position, CurrentTarget.Position );
            else
                DistanceToTarget.Value = double.PositiveInfinity;
        }
 
        private void SetTargetPosition( double dt )
        {
            targetPosition = CurrentTarget.Position;
 
            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.Position - Owner.Position ).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.Position, CurrentTarget.Position );
 
                if ( TurnWhileMoving )
                {
                    Vector realDist = CurrentTarget.Position - Owner.Position;
                    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 (CloseBrain != null)
                {
                    CloseBrain.Owner = this.Owner;
                    CloseBrain.DoUpdate(time);
                }
 
                if (StopWhenTargetClose)
                {
                    if (Owner is PhysicsObject)
                        ((PhysicsObject)Owner).Stop();
 
                    return;
                }
            }
 
            if ( targetFar )
            {
                FarBrain.Owner = this.Owner;
                FarBrain.DoUpdate( time );
                return;
            }
 
            Vector d = targetPosition - Owner.Position;
            if ( d.Magnitude > float.Epsilon )
                Move( d / dt );
            else if ( Owner is PhysicsObject )
                ( (PhysicsObject)Owner ).Stop();
            
            base.Update( time );
        }
    }
}