// OLD - use Default RP instead?
        ///// <summary>
        ///// If null, throw an exception when trying to run a child with no IHasStatusRecurranceParameters
        ///// </summary>
        //TimeSpan? DefaultInterval = null;

        protected override void OnChildStatusChanged(IBehavior child, BehaviorStatus oldStatus, BehaviorStatus newStatus)
        {
            if (child.IsFinished)
            {
                var finishedChildrenCopy = finishedChildren;
                if (finishedChildrenCopy != null)
                {
                    finishedChildrenCopy.Add(child);
                }
                this.children.Remove(child);

#if LOG_TASK_FINISHED
                l.Info("Task finished: " + child.ToString());
#endif
            }
            
            switch (newStatus)
            {
                case BehaviorStatus.Uninitialized:
                    break;
                case BehaviorStatus.Initialized:
                    break;
                case BehaviorStatus.Running:
                    break;
                case BehaviorStatus.Failed:
                    break;
                case BehaviorStatus.Succeeded:
                    break;
                case BehaviorStatus.Disposed:
                    break;
                default:
                    break;
            }
        }        

        private void StartChild(IBehavior child)
        {
            child.Start();
            //IPolledStatus polledChild = child as IPolledStatus;

            //if (polledChild == null)
            //{
            //}
            //else
            //{
                
            //    RecurranceParameters rp = null;
            //    var hasRP = child as IHasStatusRecurranceParameters;
            //    if (hasRP != null)
            //    {
            //        rp = hasRP.StatusRecurranceParameters;
            //    }

            //    if (rp == null)
            //    {
            //        if (!DefaultInterval.HasValue)
            //        {
            //            throw new Exception("Children must have RecurranceParameters, or DefaultInterval must be set.");
            //        }
            //        else
            //        {
            //            rp = new RecurranceParameters() { Interval = DefaultInterval.Value };
            //        }
            //    }

            //    var poller = new StatusPoller(child, rp);
            //    poller.IsEnabled = true;
            //}
        }

        protected override void OnSelectedStatusChangedForTo(IBehavior child, BehaviorStatus oldStatus, BehaviorStatus status)
        {
#if SanityChecks
            if (child != SelectedChild)
            {
                l.Warn("child != SelectedChild");
                return;
            }
#endif

            switch (status)
            {
                //case BehaviorStatus.Uninitialized:
                //    break;
                //case BehaviorStatus.Initialized:
                //    break;
                case BehaviorStatus.Running:
                    // It is running as expected
                    break;
                case BehaviorStatus.Failed:
                    Fail(child.StatusMessage);
                    break;
                case BehaviorStatus.Succeeded:
                    if (Advance() == BehaviorStatus.Succeeded)
                    {
                        Succeed();
                    }
                    break;
                //case BehaviorStatus.Disposed:
                //    break;
                default:
                    l.Warn("UNEXPECTED Sequencer child state: " + child.ToString());
                    break;
            }
        }

 public PauseDirective(float duration, IBehavior caller)
 {
     Behavior = caller;
     this.duration = duration;
     this.pause_start = Time.time;
     Priority = 1;
 }

        public EnumerableBehavior(IBehavior behavior, IBehavior superclass, Machine machine)
            : base(behavior, superclass, machine, typeof(IEnumerable))
        {
            string dosource = @"
            do: aBlock
            | enumerator |

            enumerator := self !GetEnumerator.

            [enumerator !MoveNext] whileTrue:
            [ aBlock value: enumerator !Current ]
            ";
            string selectsource = @"
            select: aBlock
            | enumerator list |

            enumerator := self !GetEnumerator.
            list := @System.Collections.ArrayList !new.

            [enumerator !MoveNext] whileTrue:
            [ | item |
              item := enumerator !Current.
            (aBlock value: item) ifTrue:  [ list add: item ]
            ].
            ^list
            ";

            Parser parser = new Parser(dosource);
            this.DefineInstanceMethod(parser.CompileInstanceMethod(this));
            parser = new Parser(selectsource);
            this.DefineInstanceMethod(parser.CompileInstanceMethod(this));
            this.DefineInstanceMethod(new FunctionalMethod("includes:", this, this.IncludesMethod));
        }

 public NativeObjectBehavior(IBehavior behavior, IBehavior superclass, Machine machine)
     : base(behavior, superclass, machine, typeof(object))
 {
     this.DefineInstanceMethod(new FunctionalMethod("isNil", this, this.IsNil));
     this.DefineInstanceMethod(new FunctionalMethod("isNotNil", this, this.IsNotNil));
     this.DefineInstanceMethod(new FunctionalMethod("ifNil:", this, this.IfNil));
     this.DefineInstanceMethod(new FunctionalMethod("ifNotNil:", this, this.IfNotNil));
 }

 public bool AddBehavior(int position, IBehavior behavior)
 {
     if (position < 0 || position > this.Behaviors.Length)
         return false;
     if (behavior == null)
         return false;
     return true;
 }

        /// <summary>
        /// Unregisters the behavior.
        /// </summary>
        /// <param name="behavior">The behavior.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="behavior"/> is <c>null</c>.</exception>
        public void UnregisterBehavior(IBehavior behavior)
        {
            Argument.IsNotNull("behavior", behavior);

            //_behaviors.Remove(behavior);

            BehaviorUnloaded.SafeInvoke(this, new BehaviorEventArgs(behavior));
        }

        public BaseClassDescription(IBehavior behavior, IBehavior superclass, Machine machine, string varnames)
            : base(behavior, superclass, machine)
        {
            IEnumerable<string> names = AsNames(varnames);

            foreach (string name in names)
                this.DefineInstanceVariable(name);
        }

        /// <summary>
        /// Registers the behavior.
        /// </summary>
        /// <param name="behavior">The behavior.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="behavior"/> is <c>null</c>.</exception>
        public void RegisterBehavior(IBehavior behavior)
        {
            Argument.IsNotNull("behavior", behavior);

            //_behaviors.Add(behavior);

            BehaviorLoaded.SafeInvoke(this, new BehaviorEventArgs(behavior));
        }

 public Method CompileInstanceMethod(string text, IBehavior cls)
 {
     ModelParser parser = new ModelParser(text);
     var methodmodel = parser.ParseMethod();
     Method method = new Method(cls, methodmodel.Selector, text);
     BytecodeCompiler compiler = new BytecodeCompiler(method);
     compiler.CompileMethod(methodmodel);
     return method;
 }

        public static IMetaClass CreateMetaClass(IBehavior superclass, Machine machine)
        {
            IMetaClass metasuperclass = null;

            if (superclass != null)
                metasuperclass = superclass.MetaClass;

            return new BaseMetaClass(machine.MetaClassClass, metasuperclass, machine, string.Empty);
        }

 public Blob(string name, int health, int damage, IBehavior behaviorType, IAttack attackType)
 {
     this.Name = name;
     this.Health = health;
     this.Damage = damage;
     this.BehaviorType = behaviorType;
     this.AttackType = attackType;
     this.IsAlive = true;
 }

        public override void CopyInto(IBehavior newObject)
        {
            var projectileFiring = newObject as BasicProjectileFiringBehavior;

            Debug.Assert(projectileFiring != null, "BasicProjectileFiringBehavior is null in CopyInto");

            projectileFiring.TimeBetweenShots = TimeBetweenShots;

            base.CopyInto(newObject);
        }

        public override void CopyInto(IBehavior newObject)
        {
            var behavior = newObject as ParticleEffectDeathBehavior;

            Debug.Assert(behavior != null);

            behavior.ParticleEffectName = ParticleEffectName;

            base.CopyInto(newObject);
        }

 public Blob(string name, int health, int damage, IBehavior behavior, IAttack attack)
 {
     this.Name = name;
     this.Health = health;
     this.Damage = damage;
     this.Behavior = behavior;
     this.Attack = Attack;
     this.InitialDamage = damage;
     this.InitialHealth = health;
 }

 public Blob(int damage, int health, string name, IBehavior behavior, IAttack attackType)
 {
     this.Damage = damage;
     this.Health = health;
     this.Name = name;
     this.Behavior = behavior;
     this.AttackType = attackType;
     this.InitialDamage = damage;
     this.initialHealth = health;
     this.IsAlive = true;
 }

        public override void CopyInto(IBehavior newObject)
        {
            var behavior = newObject as BaseProjectileMovementBehavior;

            Debug.Assert(behavior != null, "BaseProjectileMovementBehavior was null in CopyInto");

            behavior.MoveSpeed = MoveSpeed;
            behavior.InitialDirection = InitialDirection;

            base.CopyInto(newObject);
        }

        public override void CopyInto(IBehavior newObject)
        {
            var behavior = newObject as LinearProjectileMovementBehavior;

            Debug.Assert(behavior != null, "LinearProjectileMovementBehavior was null in CopyInto");

            behavior.Angle = Angle;
            behavior.ActionFiring = false;

            base.CopyInto(newObject);
        }

 public Blob(string name, int health, int damage, IAttack attackType, IBehavior behaviorType)
 {
     this.Name = name;
     this.Health = health;
     this.InitialHealth = this.Health;
     this.Damage = damage;
     this.InitialDamage = this.Damage;
     this.AttackType = attackType;
     this.BehaviorType = behaviorType;
     this.HasUsedBehavior = false;
 }