C# UnitSelectionDelegate类代码示例

        /// <summary>
        /// Cast "Freeze" pet ability on a target.  Uses a local store for location to
        /// avoid target position changing during cast preparation and being out of
        /// range after range check
        /// </summary>
        /// <param name="onUnit">target to cast on</param>
        /// <returns></returns>
        public static Composite CastFreeze( UnitSelectionDelegate onUnit, SimpleBooleanDelegate require = null)
        {
            if (onUnit == null)
                return new ActionAlwaysFail();

            if (require == null)
                require = req => true;

            return new Sequence(
                ctx => onUnit(ctx),
                new Decorator(
                    req => req != null && (req as WoWUnit).SpellDistance() < 40 && require(req),
                    new Action( r =>
                    {
                        _locFreeze = (r as WoWUnit).Location;
                        if (StyxWoW.Me.Location.Distance(_locFreeze) > 45)
                            _locFreeze = WoWMathHelper.CalculatePointFrom(StyxWoW.Me.Location, _locFreeze, 7f + (r as WoWUnit).CombatReach);
                        if (StyxWoW.Me.Location.Distance(_locFreeze) > 45)
                            return RunStatus.Failure;
                        return RunStatus.Success;
                    })
                    ),
                new Throttle( TimeSpan.FromMilliseconds(250),
                    Pet.CastPetActionOnLocation(
                        "Freeze",
                        on => _locFreeze,
                        ret => !Me.CurrentTarget.TreatAsFrozen()
                        )
                    )
                );
        }

        public Composite MovementMoveBehind(UnitSelectionDelegate toUnit)
        {
            return
                new Decorator(
                    ret =>
                    THSettings.Instance.AutoMove &&
                    DateTime.Now > DoNotMove &&
                    !Me.Mounted &&
                    !IsOverrideModeOn &&
                    !Me.IsCasting &&
                    //!Me.IsChanneling &&
                    toUnit != null &&
                    toUnit(ret) != null &&
                    toUnit(ret) != Me &&
                    toUnit(ret).IsAlive &&
                    //only MovementMoveBehind if IsWithinMeleeRange
                    GetDistance(toUnit(ret)) <= 5 &&
                    !Me.IsBehind(toUnit(ret)) &&
                    //!IsTank(Me) &&
                    //Only Move again After a certain delay or target move 3 yard from original posision
                    (toUnit(ret).IsPlayer ||
                     !toUnit(ret).IsPlayer && toUnit(ret).CurrentTarget != Me && toUnit(ret).Combat),
                    new Action(ret =>
                        {
                            WoWPoint pointBehind =
                                toUnit(ret).Location.RayCast(
                                    toUnit(ret).Rotation + WoWMathHelper.DegreesToRadians(150), 3f);

                            Navigator.MoveTo(pointBehind);
                            return RunStatus.Failure;
                        }));
        }

 public static Composite CreateHunterTrapBehavior(string trapName, bool useLauncher, UnitSelectionDelegate onUnit)
 {
     return new PrioritySelector(
         new Decorator(
             ret => onUnit != null && onUnit(ret) != null && onUnit(ret).DistanceSqr < 40 * 40 &&
                    SpellManager.HasSpell(trapName) && !SpellManager.Spells[trapName].Cooldown,
             new PrioritySelector(
                 Spell.BuffSelf(trapName, ret => !useLauncher),
                 Spell.BuffSelf("Trap Launcher", ret => useLauncher),
                 new Decorator(
                     ret => StyxWoW.Me.HasAura("Trap Launcher"),
                     new Sequence(
                         new Switch<string>(ctx => trapName,
                             new SwitchArgument<string>("Immolation Trap",
                                 new Action(ret => LegacySpellManager.CastSpellById(82945))),
                             new SwitchArgument<string>("Freezing Trap",
                                 new Action(ret => LegacySpellManager.CastSpellById(60192))),
                             new SwitchArgument<string>("Explosive Trap",
                                 new Action(ret => LegacySpellManager.CastSpellById(82939))),
                             new SwitchArgument<string>("Ice Trap",
                                 new Action(ret => LegacySpellManager.CastSpellById(82941))),
                             new SwitchArgument<string>("Snake Trap",
                                 new Action(ret => LegacySpellManager.CastSpellById(82948)))
                             ),
                         new ActionSleep(200),
                         new Action(ret => LegacySpellManager.ClickRemoteLocation(onUnit(ret).Location)))))));
 }

 public static Composite CreateFaceTargetBehavior(UnitSelectionDelegate toUnit, float viewDegrees = 70f)
 {
     return new Decorator(
         ret =>
         !SingularSettings.Instance.DisableAllMovement && toUnit != null && toUnit(ret) != null &&
         !StyxWoW.Me.IsMoving && !toUnit(ret).IsMe &&
         !StyxWoW.Me.IsSafelyFacing(toUnit(ret), viewDegrees ),
         new Action(ret =>
                        {
                            StyxWoW.Me.CurrentTarget.Face();
                            return RunStatus.Failure;
                        }));
 }

 private static Composite Cast(string spell, UnitSelectionDelegate onUnit, Selection<bool> reqs = null)
 {
     return
         new Decorator(
             ret => onUnit != null && onUnit(ret) != null &&
                    ((reqs != null && reqs(ret)) || (reqs == null)) &&
                    SpellManager.CanCast(spell, onUnit(ret), true),
             new Sequence(
                 new Action(ret => SpellManager.Cast(spell, onUnit(ret))),
                 new Action(
                     ret =>
                         Log.Info(string.Format("[Casting:{0}] [Target:{1}] [Distance:{2:F1}yds]", spell,
                             onUnit(ret).SafeName, onUnit(ret).Distance)))
                 ));
 }

		public static Composite Cast(string spell, UnitSelectionDelegate onUnit, Selection<bool> reqs = null)
		{
			return
				new Decorator(
					ret =>
						(onUnit != null && onUnit(ret) != null && (reqs == null || reqs(ret)) &&
						 AbilityManager.CanCast(spell, onUnit(ret))),
					new PrioritySelector(
						new Action(delegate
						{
							Logger.Write(">> Casting <<   " + spell);
							return RunStatus.Failure;
						}),
						new Action(ret => AbilityManager.Cast(spell, onUnit(ret))))
					);
		}

        /// <summary>Creates an interrupt spell cast composite. This will attempt to use racials before any class/spec abilities. It will attempt to stun if possible!</summary>
        /// <remarks>Created 9/7/2011.</remarks>
        /// <param name="onUnit">The on unit.</param>
        /// <returns>.</returns>
        public static Composite CreateInterruptSpellCast(UnitSelectionDelegate onUnit)
        {
            return
                new Decorator(
                    // If the target is casting, and can actually be interrupted, AND we've waited out the double-interrupt timer, then find something to interrupt with.
                    ret => onUnit != null && onUnit(ret) != null && onUnit(ret).IsCasting && onUnit(ret).CanInterruptCurrentSpellCast
                    /* && PreventDoubleInterrupt*/,
                    new PrioritySelector(
                        Spell.Cast("Rebuke", onUnit),
                        Spell.Cast("Avenger's Shield", onUnit),
                        Spell.Cast("Hammer of Justice", onUnit),
                        Spell.Cast("Repentance", onUnit, 
                            ret =>  onUnit(ret).IsPlayer || onUnit(ret).IsDemon || onUnit(ret).IsHumanoid || 
                                    onUnit(ret).IsDragon || onUnit(ret).IsGiant || onUnit(ret).IsUndead),

                        Spell.Cast("Kick", onUnit),
                        Spell.Cast("Gouge", onUnit, ret => !onUnit(ret).IsBoss() && !onUnit(ret).MeIsSafelyBehind), // Can't gouge bosses.

                        Spell.Cast("Counterspell", onUnit),

                        Spell.Cast("Wind Shear", onUnit),

                        Spell.Cast("Pummel", onUnit),
                        // Gag Order only works on non-bosses due to it being a silence, not an interrupt!
                        Spell.Cast("Heroic Throw", onUnit, ret => TalentManager.GetCount(3, 7) == 2 && !onUnit(ret).IsBoss()),

                        Spell.Cast("Silence", onUnit),

                        Spell.Cast("Silencing Shot", onUnit),

                        // Can't stun most bosses. So use it on trash, etc.
                        Spell.Cast("Bash", onUnit, ret => !onUnit(ret).IsBoss()),
                        Spell.Cast("Skull Bash (Cat)", onUnit, ret => StyxWoW.Me.Shapeshift == ShapeshiftForm.Cat),
                        Spell.Cast("Skull Bash (Bear)", onUnit, ret => StyxWoW.Me.Shapeshift == ShapeshiftForm.Bear),
                        Spell.Cast("Solar Beam", onUnit, ret => StyxWoW.Me.Shapeshift == ShapeshiftForm.Moonkin),

                        Spell.Cast("Strangulate", onUnit),
                        Spell.Cast("Mind Freeze", onUnit),


                        // Racials last.
                        Spell.Cast("Arcane Torrent", onUnit),
                        // Don't waste stomp on bosses. They can't be stunned 99% of the time!
                        Spell.Cast("War Stomp", onUnit, ret => !onUnit(ret).IsBoss() && onUnit(ret).Distance < 8)
                        ));
        }

 /// <summary>
 /// Cast "Freeze" pet ability on a target.  Uses a local store for location to
 /// avoid target position changing during cast preparation and being out of
 /// range after range check
 /// </summary>
 /// <param name="onUnit">target to cast on</param>
 /// <returns></returns>
 public static Composite CastFreeze( UnitSelectionDelegate onUnit )
 {
     return new Sequence(
         new Decorator(
             ret => onUnit != null && onUnit(ret) != null,
             new Action( ret => _locFreeze = onUnit(ret).Location)
             ),
         new Throttle( TimeSpan.FromMilliseconds(250),
             Pet.CreateCastPetActionOnLocation(
                 "Freeze",
                 on => _locFreeze,
                 ret => Me.Pet.ManaPercent >= 12
                     && Me.Pet.Location.Distance(_locFreeze) < 45
                     && !Me.CurrentTarget.IsFrozen()
                 )
             )
         );
 }

 private static Composite MovementMoveStop(UnitSelectionDelegate toUnit, double range)
 {
     return new Decorator(
         ret =>
         THSettings.Instance.AutoMove &&
         !IsOverrideModeOn &&
         toUnit != null &&
         toUnit(ret) != null &&
         toUnit(ret) != Me &&
         toUnit(ret).IsAlive &&
         IsMoving(Me) &&
         IsEnemy(toUnit(ret)) &&
         GetDistance(toUnit(ret)) <= range &&
         InLineOfSpellSightCheck(toUnit(ret)),
         new Action(ret =>
             {
                 Navigator.PlayerMover.MoveStop();
                 return RunStatus.Failure;
             }));
 }

 /// <summary>
 ///   Creates a behavior to move within range, within LOS, and keep facing the specified target.
 /// </summary>
 /// <remarks>
 ///   Created 3/4/2011.
 /// </remarks>
 /// <param name = "maxRange">The maximum range.</param>
 /// <param name = "coneDegrees">The cone in degrees. (If we're facing +/- this many degrees from the target, we will face the target)</param>
 /// <param name = "unit">The unit.</param>
 /// <param name="noMovement"></param>
 /// <returns>.</returns>
 protected Composite CreateMoveToAndFace(float maxRange, float coneDegrees, UnitSelectionDelegate unit, bool noMovement)
 {
     return new Decorator(
         ret =>!SingularSettings.Instance.DisableAllMovement&& unit(ret) != null,
         new PrioritySelector(
             new Decorator(
                 ret =>(!unit(ret).InLineOfSightOCD || (!noMovement && unit(ret).DistanceSqr > maxRange * maxRange)),
                 new Action(ret => Navigator.MoveTo(unit(ret).Location))),
             //Returning failure for movestop for smoother movement
             //Rest should return success !
             new Decorator(
                 ret =>Me.IsMoving && unit(ret).DistanceSqr <= maxRange * maxRange,
                 new Action(delegate
                     {
                         Navigator.PlayerMover.MoveStop();
                         return RunStatus.Failure;
                     })),
             new Decorator(
                 ret => Me.CurrentTarget != null && Me.CurrentTarget.IsAlive && !Me.IsSafelyFacing(Me.CurrentTarget, coneDegrees),
                 new Action(ret => Me.CurrentTarget.Face()))
             ));
 }

 public static Composite Buff(string name, bool myBuff, UnitSelectionDelegate onUnit, params string[] buffNames)
 {
     return Buff(name, myBuff, onUnit, ret => true, buffNames);
 }

 /// <summary>
 /// Creates a composite to avoid double casting spells on specified unit. Mostly usable for spells like Immolate, Devouring Plague etc.
 /// </summary>
 /// <remarks>
 /// Created 19/12/2011 raphus
 /// </remarks>
 /// <param name="unit"> Unit to check </param>
 /// <param name="spellNames"> Spell names to check </param>
 /// <returns></returns>
 public static Composite PreventDoubleCast(UnitSelectionDelegate unit, params string[] spellNames)
 {
     return
         new PrioritySelector(
             new Decorator(
                 ret =>
                 StyxWoW.Me.IsCasting && spellNames.Contains(StyxWoW.Me.CastingSpell.Name) && unit != null &&
                 unit(ret) != null &&
                 unit(ret).Auras.Any(
                     a => a.Value.SpellId == StyxWoW.Me.CastingSpellId && a.Value.CreatorGuid == StyxWoW.Me.Guid),
                 new Action(ret => SpellManager.StopCasting())));
 }

 public static Composite Heal(string name, SimpleBooleanDelegate checkMovement, UnitSelectionDelegate onUnit,
     SimpleBooleanDelegate requirements, bool allowLagTollerance = false)
 {
     return Heal(name, checkMovement, onUnit, requirements,
         ret => onUnit(ret).HealthPercent > SingularSettings.Instance.IgnoreHealTargetsAboveHealth,
         false);
 }

 /// <summary>
 ///   Creates a behavior to cast a spell by ID, on a specific unit. Returns
 ///   RunStatus.Success if successful, RunStatus.Failure otherwise.
 /// </summary>
 /// <remarks>
 ///   Created 5/2/2011.
 /// </remarks>
 /// <param name = "spellId">Identifier for the spell.</param>
 /// <param name = "onUnit">The on unit.</param>
 /// <returns>.</returns>
 public static Composite Cast(int spellId, UnitSelectionDelegate onUnit)
 {
     return Cast(spellId, onUnit, ret => true);
 }

 private Composite Cast(string spell, SimpleBooleanDelegate requirements, UnitSelectionDelegate unit)
 {
     return new Decorator(ret => requirements != null && requirements(ret) && SpellManager.HasSpell(spell) && SpellManager.CanCast(spell, unit(ret), true, true),
         new Styx.TreeSharp.Action(ctx =>
         {
             SpellManager.Cast(spell, unit(ctx));
             Logging.Write(LogLevel.Normal, MONK_COLOR, "Casting Spell [{0}].", spell);
             return RunStatus.Success;
         })
     );
 }