/// <summary>
        /// When Fan of Knives should be cast
        /// </summary>
        private static bool FanOfKnivesCondition(SkillMeta meta)
        {
            meta.CastRange = 25f;

            if (TargetUtil.EliteOrTrashInRange(15) || TargetUtil.AnyTrashInRange(15f, 5, false))
            {
                return(true);
            }

            return(false);
        }
        public static TrinityPower GetPower()
        {
            TrinityPower power = null;

            if (!UseOOCBuff && IsCurrentlyAvoiding)
            {
                if (CanCastSteedChargeOutOfCombat())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_SteedCharge));
                }
            }

            if (!UseOOCBuff && !IsCurrentlyAvoiding && CurrentTarget != null)
            {
                /*
                 *  Laws for Active Buff
                 */

                //There are doubles?? not sure which is correct yet
                // Laws of Hope
                // Laws of Hope2
                if (CanCast(SNOPower.X1_Crusader_LawsOfHope2) && (TargetUtil.EliteOrTrashInRange(16f) || TargetUtil.AnyMobsInRange(15f, 5)))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_LawsOfHope2));
                }

                // LawsOfJustice
                // LawsOfJustice2
                if (CanCast(SNOPower.X1_Crusader_LawsOfJustice2) && (TargetUtil.EliteOrTrashInRange(16f) || Player.CurrentHealthPct <= CrusaderSettings.LawsOfJusticeHpPct || TargetUtil.AnyMobsInRange(15f, 5)))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_LawsOfJustice2));
                }

                // LawsOfValor
                // LawsOfValor2
                if (CanCast(SNOPower.X1_Crusader_LawsOfValor2) && (TargetUtil.EliteOrTrashInRange(16f) || TargetUtil.AnyMobsInRange(15f, 5)))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_LawsOfValor2));
                }

                // Judgement
                if (CanCastJudgement())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Judgment, 20f, TargetUtil.GetBestClusterPoint(20f)));
                }

                // Shield Glare
                if (CanCastShieldGlare())
                {
                    var arcTarget = TargetUtil.GetBestArcTarget(45f, 70f);
                    if (arcTarget != null && arcTarget.Position != Vector3.Zero)
                    {
                        return(new TrinityPower(SNOPower.X1_Crusader_ShieldGlare, 15f, arcTarget.Position));
                    }
                }

                // Iron Skin
                if (CanCastIronSkin())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_IronSkin));
                }

                // Provoke
                if (CanCast(SNOPower.X1_Crusader_Provoke) && (TargetUtil.EliteOrTrashInRange(15f) || TargetUtil.AnyMobsInRange(15f, CrusaderSettings.ProvokeAoECount)))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Provoke));
                }

                // Consecration
                if (CanCastConsecration())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Consecration));
                }

                // Akarats when off Cooldown
                if (CrusaderSettings.UseAkaratsOffCooldown && CanCast(SNOPower.X1_Crusader_AkaratsChampion))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_AkaratsChampion));
                }

                // AkaratsChampion
                if (CanCastAkaratsChampion())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_AkaratsChampion));
                }

                // Bombardment
                if (CanCastBombardment())
                {
                    Vector3 bestPoint = CurrentTarget.IsEliteRareUnique ?
                                        CurrentTarget.Position :
                                        TargetUtil.GetBestClusterPoint();
                    return(new TrinityPower(SNOPower.X1_Crusader_Bombardment, 16f, bestPoint));
                }

                // FallingSword
                if (CanCastFallingSword())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_FallingSword, 16f, TargetUtil.GetBestClusterPoint(15f, 65f, false)));
                }

                // HeavensFury
                if (CanCastHeavensFury())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_HeavensFury3, 16f, TargetUtil.GetBestClusterPoint()));
                }

                // Condemn
                if (CanCastCondemn())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Condemn));
                }

                // Phalanx
                if (CanCastPhalanx())
                {
                    return(new TrinityPower(SNOPower.x1_Crusader_Phalanx3, 45f, TargetUtil.GetBestClusterPoint(15f, 45f)));
                }

                // Blessed Shield : Piercing Shield
                bool hasPiercingShield = HotbarSkills.AssignedSkills.Any(s => s.Power == SNOPower.X1_Crusader_BlessedShield && s.RuneIndex == 5);
                if (CanCastBlessedShieldPiercingShield(hasPiercingShield))
                {
                    var bestPierceTarget = TargetUtil.GetBestPierceTarget(45f);
                    if (bestPierceTarget != null)
                    {
                        return(new TrinityPower(SNOPower.X1_Crusader_BlessedShield, 14f, bestPierceTarget.ACDGuid));
                    }
                }

                // Blessed Shield
                if (CanCastBlessedShield() && !hasPiercingShield)
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_BlessedShield, 14f, TargetUtil.GetBestClusterUnit().ACDGuid));
                }

                // Fist of Heavens
                if (CanCastFistOfHeavens())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_FistOfTheHeavens, 65f, TargetUtil.GetBestClusterUnit(8f).Position));
                }

                // Blessed Hammer
                if (CanCastBlessedHammer())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_BlessedHammer, 20f, TargetUtil.GetBestClusterUnit(8f, 20f).Position));
                }

                // Provoke
                if (CanCast(SNOPower.X1_Crusader_Provoke) && TargetUtil.AnyMobsInRange(15f, 4))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Provoke));
                }

                // Shield Bash
                if (CanCast(SNOPower.X1_Crusader_ShieldBash2))
                {
                    var bestPierceTarget = TargetUtil.GetBestClusterUnit(15f, 65f, 1, false, false);
                    if (bestPierceTarget != null)
                    {
                        return(new TrinityPower(SNOPower.X1_Crusader_ShieldBash2, 65f, bestPierceTarget.ACDGuid));
                    }
                }

                // Blessed Hammer, spin outwards
                // Limitless rune can spawn new hammers
                if (CanCast(SNOPower.X1_Crusader_BlessedHammer) && (TargetUtil.EliteOrTrashInRange(20f) || TargetUtil.AnyTrashInRange(20f, 3)))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_BlessedHammer));
                }

                // Sweep Attack
                if (CanCastSweepAttack())
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_SweepAttack, 5f, TargetUtil.GetBestClusterUnit(18f, 18f).ACDGuid));
                }

                /*
                 *  Basic Attacks
                 */


                //Blessed Shield
                if (CanCast(SNOPower.X1_Crusader_BlessedShield))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_BlessedShield, 14f, CurrentTarget.ACDGuid));
                }

                // Justice
                if (CanCast(SNOPower.X1_Crusader_Justice))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Justice, 7f, CurrentTarget.ACDGuid));
                }

                // Smite
                if (CanCast(SNOPower.X1_Crusader_Smite))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Smite, 15f, TargetUtil.GetBestClusterUnit(15f, 15f).ACDGuid));
                }

                // Slash
                if (CanCast(SNOPower.X1_Crusader_Slash))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Slash, 15f, TargetUtil.GetBestClusterUnit(5f, 8f).ACDGuid));
                }

                // Punish
                if (CanCast(SNOPower.X1_Crusader_Punish))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_Punish, 7f, CurrentTarget.ACDGuid));
                }
            }

            // Buffs
            if (UseOOCBuff)
            {
                if (CanCast(SNOPower.X1_Crusader_SteedCharge) && CrusaderSettings.SteedChargeOOC)
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_SteedCharge));
                }

                /*
                 *  Laws
                 */

                //There are doubles?? not sure which is correct yet
                // Laws of Hope2
                if (CanCast(SNOPower.X1_Crusader_LawsOfHope2) && Player.CurrentHealthPct <= CrusaderSettings.LawsOfHopeHpPct)
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_LawsOfHope2));
                }

                // LawsOfJustice2
                if (CanCast(SNOPower.X1_Crusader_LawsOfJustice2) && (TargetUtil.EliteOrTrashInRange(16f) || Player.CurrentHealthPct <= CrusaderSettings.LawsOfJusticeHpPct))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_LawsOfJustice2));
                }

                // LawsOfValor2
                if (CanCast(SNOPower.X1_Crusader_LawsOfValor2) && TargetUtil.EliteOrTrashInRange(16f))
                {
                    return(new TrinityPower(SNOPower.X1_Crusader_LawsOfValor2));
                }
            }

            // Default Attacks
            if (IsNull(null))
            {
                power = DefaultPower;
            }

            return(power);
        }