Inheritance: CacheObject
Esempio n. 1
0
 public DebugUnitEntry(CacheUnit entry)
 {
     SNOID = entry.SNOID;
     Name = entry.InternalName;
     ActorType = PluginActorType.Monster;
     UnitFlags = entry.UnitPropertyFlags.HasValue ? entry.UnitPropertyFlags.Value : UnitFlags.None;
     TargetType = TargetType.Unit;
 }
Esempio n. 2
0
        public void Update(ref CacheUnit unit, bool refreshproperties = false)
        {
            UnitCounter++;

            if (unit.UnitMaxHitPointAverageWeight < 0) WeakCounter++; else if (unit.UnitMaxHitPointAverageWeight > 0) StrongCounter++;

            if (unit.IsEliteRareUnique) ElitesCounter++; else if (unit.IsBoss) BossCounter++;

            if (unit.IsFast) FastCounter++;
            if (unit.IsRanged) RangedCounter++;

            if (FunkyGame.Hero.Class.UsesDOTDPSAbility && unit.HasDOTdps.HasValue && unit.HasDOTdps.Value) DOTDPSCounter++;

            if (refreshproperties) UpdateProperties();
        }
Esempio n. 3
0
        internal static TargetProperties EvaluateUnitProperties(CacheUnit unit)
        {
            TargetProperties properties = TargetProperties.None;

            if (unit.IsBoss)
                properties |= TargetProperties.Boss;

            if (unit.IsBurrowableUnit)
                properties |= TargetProperties.Burrowing;

            if (unit.MonsterMissileDampening)
                properties |= TargetProperties.MissileDampening;

            if (unit.IsMissileReflecting)
                properties |= TargetProperties.MissileReflecting;

            if (unit.MonsterShielding)
                properties |= TargetProperties.Shielding;

            if (unit.IsStealthableUnit)
                properties |= TargetProperties.Stealthable;

            if (unit.IsSucideBomber)
                properties |= TargetProperties.SucideBomber;

            if (unit.IsTreasureGoblin)
                properties |= TargetProperties.TreasureGoblin;

            if (unit.IsFast)
                properties |= TargetProperties.Fast;

            if (unit.IsEliteRareUnique)
                properties |= TargetProperties.RareElite;

            if (unit.MonsterUnique)
                properties |= TargetProperties.Unique;

            if (unit.CurrentHealthPct.HasValue && unit.CurrentHealthPct.Value == 1d)
                properties |= TargetProperties.FullHealth;

            if (unit.UnitMaxHitPointAverageWeight < 0)
                properties |= TargetProperties.Weak;

            if (unit.IsRanged)
                properties |= TargetProperties.Ranged;

            if (unit.IsTargetableAndAttackable)
                properties |= TargetProperties.TargetableAndAttackable;

            if (unit.HasDOTdps.HasValue && unit.HasDOTdps.Value)
                properties |= TargetProperties.DOTDPS;

            if (unit.RadiusDistance < 10f)
                properties |= TargetProperties.CloseDistance;

            if (unit.MonsterReflectDamage)
                properties |= TargetProperties.ReflectsDamage;

            if (unit.MonsterElectrified)
                properties |= TargetProperties.Electrified;

            if (unit.MonsterNormal)
                properties |= TargetProperties.Normal;

            if (unit.CurrentHealthPct.HasValue && unit.CurrentHealthPct.Value < 0.25d)
                properties |= TargetProperties.LowHealth;

            return properties;
        }
Esempio n. 4
0
        ///<summary>
        ///Selects first Ability that is successful in precast and combat testing.
        ///</summary>
        private Skill AbilitySelector(ConditionCriteraTypes criteria = ConditionCriteraTypes.All, bool IgnoreOutOfRange = false, CacheUnit unit = null)
        {
            Skill returnAbility = DefaultAttack;
            foreach (var item in SortedAbilities)
            {
                //Check precast conditions
                if (!item.CheckPreCastConditionMethod()) continue;

                //Check Combat Conditions!
                if (!item.CheckCombatConditionMethod(criteria, unit))
                {
                    continue;
                }

                //Check if we can execute or if it requires movement
                if (IgnoreOutOfRange)
                {
                    if (item.DestinationVector != FunkyGame.Hero.Position)
                        continue;
                }

                returnAbility = item;
                break;
            }

            //Setup Ability (sets vars according to current cache)
            Skill.SetupAbilityForUse(ref returnAbility, unit);
            return returnAbility;
        }
Esempio n. 5
0
        internal List<Skill> ReturnAllUsableAbilities(CacheUnit obj, bool IgnoreOutOfRange = false)
        {
            //Reset default attack can use
            CanUseDefaultAttack = !Abilities.ContainsKey(DefaultAttack.Power) ? false : true;

            ConditionCriteraTypes criterias = ConditionCriteraTypes.All;

            //Although the unit is a cluster exception.. we should verify it is not a clustered object.
            if (obj.IsClusterException && obj.BeingIgnoredDueToClusterLogic)
            {
                criterias = ConditionCriteraTypes.SingleTarget;
            }

            List<Skill> UsableAbilities = new List<Skill>();
            foreach (var item in SortedAbilities)
            {
                //Check precast conditions
                if (!item.CheckPreCastConditionMethod()) continue;

                //Check Combat Conditions!
                if (!item.CheckCombatConditionMethod(conditions: criterias))
                {
                    continue;
                }

                //Check if we can execute or if it requires movement
                if (IgnoreOutOfRange)
                {
                    if (item.DestinationVector != FunkyGame.Hero.Position)
                        continue;
                }

                Skill ability = item;
                Skill.SetupAbilityForUse(ref ability, obj);
                UsableAbilities.Add(ability);
            }

            return UsableAbilities;
        }
Esempio n. 6
0
 ///<summary>
 ///Returns a power for Combat Buffing.
 ///</summary>
 internal bool FindCombatBuffPower(CacheUnit unit,out Skill BuffAbility)
 {
     BuffAbility = null;
     foreach (var item in Abilities.Values.Where(A => A.IsBuff && A.UseageType.HasFlag(SkillUseage.Combat | SkillUseage.Anywhere)))
     {
         if (item.CheckPreCastConditionMethod())
         {
             if (item.CheckCombatConditionMethod(unit: unit))
             {
                 BuffAbility = item;
                 Skill.SetupAbilityForUse(ref BuffAbility, unit);
                 return true;
             }
         }
     }
     return false;
 }
Esempio n. 7
0
        ///<summary>
        ///Sets criteria based on object given.
        ///</summary>
        internal virtual Skill AbilitySelector(CacheUnit obj, bool IgnoreOutOfRange = false)
        {
            //Reset default attack can use
            CanUseDefaultAttack = !Hotbar.HasPower(DefaultAttack.Power) ? false : true;
            //Reset waiting for special!
            bWaitingForSpecial = false;

            ConditionCriteraTypes criterias = ConditionCriteraTypes.All;

            //Although the unit is a cluster exception.. we should verify it is not a clustered object.
            if (obj.IsClusterException && obj.BeingIgnoredDueToClusterLogic)
            {
                criterias = ConditionCriteraTypes.SingleTarget;
            }

            return AbilitySelector(criterias, IgnoreOutOfRange, obj);
        }
Esempio n. 8
0
        //
        ///<summary>
        ///Adds/Updates CacheObjects inside collection by Iteration of RactorList
        ///This is the method that caches all live data about an object!
        ///</summary>
        internal static bool UpdateCacheObjectCollection()
        {
            //Update Character (just incase it wasnt called before..)
            FunkyGame.Hero.Update(false, true);

            Obstacles.AttemptToClearEntries();

            HashSet<int> hashDoneThisRactor = new HashSet<int>();
            using (ZetaDia.Memory.AcquireFrame(true))
            {
                if (!ZetaDia.IsInGame || ZetaDia.IsLoadingWorld || !ZetaDia.Me.IsValid) return false;

                foreach (Actor thisActor in ZetaDia.Actors.RActorList)
                {
                    int tmp_raGUID;
                    DiaObject thisObj;

                    if (!thisActor.IsValid) continue;
                    //Convert to DiaObject
                    thisObj = (DiaObject)thisActor;
                    tmp_raGUID = thisObj.RActorGuid;

                    // See if we've already checked this ractor, this loop
                    if (hashDoneThisRactor.Contains(tmp_raGUID)) continue;
                    hashDoneThisRactor.Add(tmp_raGUID);

                    //Update RactorGUID and check blacklisting..
                    if (BlacklistCache.IsRAGUIDBlacklisted(tmp_raGUID)) continue;
                    CacheObject tmp_CachedObj;

                    if (!Objects.TryGetValue(tmp_raGUID, out tmp_CachedObj))
                    {

                        ActorType Actortype;
                        Vector3 tmp_position;
                        int tmp_acdguid;
                        int tmp_SNOID;

                        #region SNO
                        //Lookup SNO
                        try
                        {
                            tmp_SNOID = thisObj.ActorSNO;
                        }
                        catch (Exception ex)
                        {
                            Logger.Write(LogLevel.Cache, "Safely handled getting SNO for {0}", tmp_raGUID);
                            //Logger.DBLog.InfoFormat("Failure to get SNO from object! RaGUID: {0}", tmp_raGUID);
                            continue;
                        }
                        #endregion

                        //check our SNO blacklist (exclude pets?)
                        if (BlacklistCache.IsSNOIDBlacklisted(tmp_SNOID)) continue;

                        #region Position
                        try
                        {
                            tmp_position = thisObj.Position;
                        }
                        catch (Exception ex)
                        {
                            Logger.Write(LogLevel.Cache, "Safely handled getting Position for {0}", tmp_SNOID);
                            continue;
                        }

                        #endregion

                        #region AcdGUID
                        try
                        {
                            tmp_acdguid = thisObj.ACDGuid;
                        }
                        catch (Exception ex)
                        {
                            Logger.Write(LogLevel.Cache, "Safely handled getting ACDGuid for {0}", tmp_SNOID);
                            continue;
                        }

                        #endregion

                        tmp_CachedObj = new CacheObject(tmp_SNOID, tmp_raGUID, tmp_acdguid, tmp_position);
                    }
                    else
                        //Reset unseen var
                        tmp_CachedObj.LoopsUnseen = 0;

                    ////Validate (ignore special object SNO Ids)
                    //if (!CacheIDLookup.hashSNOSkipCommonDataCheck.Contains(tmp_CachedObj.SNOID))
                    //{
                    //    try
                    //    {
                    //        if (thisObj.CommonData == null)
                    //        {
                    //            Logger.Write(LogLevel.Cache, "CommonData is no longer valid! {0}", tmp_CachedObj.DebugStringSimple);
                    //            //BlacklistCache.AddObjectToBlacklist(tmp_CachedObj.RAGUID, BlacklistType.Temporary);
                    //            continue;
                    //        }
                    //        if (thisObj.CommonData.ACDGuid != thisObj.ACDGuid)
                    //        {
                    //            Logger.Write(LogLevel.Cache, "ACDGuid Mismatched! {0}", tmp_CachedObj.DebugStringSimple);
                    //            //BlacklistCache.AddObjectToBlacklist(tmp_CachedObj.RAGUID, BlacklistType.Temporary);
                    //            continue;
                    //        }
                    //    }
                    //    catch (Exception ex)
                    //    {
                    //        //Logger.Write(LogLevel.Cache, "Object is no longer valid! (Exception) SNOID {0}", tmp_CachedObj.DebugStringSimple);
                    //        //BlacklistCache.AddObjectToBlacklist(tmp_CachedObj.RAGUID, BlacklistType.Temporary);
                    //        continue;
                    //    }
                    //}

                    //Update any SNO Data.
                    #region SNO_Cache_Update
                    if (tmp_CachedObj.ref_DiaObject == null || tmp_CachedObj.ContainsNullValues())
                    {
                        if (!tmp_CachedObj.UpdateData(thisObj, tmp_CachedObj.RAGUID))
                        {
                            continue;
                        }
                    }
                    else if (!tmp_CachedObj.IsFinalized)
                    {//Finalize this data by recreating it and updating the Sno cache with a new finalized entry, this also clears our all Sno cache dictionaries since we no longer need them!
                        cacheSnoCollection.FinalizeEntry(tmp_CachedObj.SNOID);
                    }
                    #endregion

                    //Check if this object is a summoned unit by a player...
                    #region SummonedUnits
                    if (tmp_CachedObj.IsSummonedPet && CacheIDLookup.hashSNOSkipCommonDataCheck.Contains(tmp_CachedObj.SNOID))
                    {
                        PetTypes PetType = (PetTypes)TheCache.ObjectIDCache.UnitPetEntries[tmp_CachedObj.SNOID].ObjectType;
                        if (PetType== PetTypes.WIZARD_ArcaneOrbs)
                        {
                            FunkyGame.Targeting.Cache.Environment.HeroPets.WizardArcaneOrbs++;
                            tmp_CachedObj.NeedsRemoved = true;
                            continue;
                        }
                    }
                    #endregion

                    //Special Cache for Interactable Server Objects
                    if (CheckFlag(tmp_CachedObj.targetType.Value, TargetType.ServerInteractable))
                    {
                        if (!InteractableObjectCache.ContainsKey(tmp_CachedObj.RAGUID))
                        {
                            InteractableObjectCache.Add(tmp_CachedObj.RAGUID, tmp_CachedObj);

                            //Adventure Mode -- Rifting we add Exit to LOS movement!
                            //if (FunkyGame.AdventureMode && FunkyGame.Bounty.IsInRiftWorld && FunkyBaseExtension.Settings.AdventureMode.EnableAdventuringMode)
                            //{
                            //	if (tmp_CachedObj.InternalName.Contains("Exit"))
                            //	{
                            //		int index = FunkyGame.Bounty.CurrentBountyMapMarkers.Count;
                            //		FunkyGame.Bounty.CurrentBountyMapMarkers.Add(index, new BountyCache.BountyMapMarker(tmp_CachedObj.Position, FunkyGame.Hero.CurrentWorldDynamicID, index));
                            //	}
                            //}
                        }

                        //Whymsdal Portal!
                        if (tmp_CachedObj.SNOID == 405590)
                        {
                            GoblinBehavior.Portal = tmp_CachedObj;
                        }
                        else if (tmp_CachedObj.SNOID == 393030)
                        {
                            GoblinBehavior.Portal = tmp_CachedObj;
                        }

                        //Do not add to main cache!
                        continue;
                    }

                    //Objects with static positions already cached don't need to be updated here.
                    if (!tmp_CachedObj.NeedsUpdate) continue;

                    //Obstacles -- (Not an actual object we add to targeting.)
                    if (CheckFlag(tmp_CachedObj.targetType.Value, TargetType.Avoidance) || tmp_CachedObj.IsObstacle || tmp_CachedObj.HandleAsAvoidanceObject)
                    {
                        #region Obstacles

                        CacheObstacle thisObstacle;
                        //Do we have this cached?
                        if (!Obstacles.TryGetValue(tmp_CachedObj.RAGUID, out thisObstacle))
                        {
                            AvoidanceType AvoidanceType = AvoidanceType.None;
                            if (tmp_CachedObj.IsAvoidance)
                            {
                                AvoidanceType = AvoidanceCache.FindAvoidanceUsingSNOID(tmp_CachedObj.SNOID);
                                if (AvoidanceType == AvoidanceType.None)
                                {
                                    AvoidanceType = AvoidanceCache.FindAvoidanceUsingName(tmp_CachedObj.InternalName);
                                    if (AvoidanceType == AvoidanceType.None) continue;
                                }
                            }

                            if (tmp_CachedObj.IsAvoidance && tmp_CachedObj.IsProjectileAvoidance)
                            {//Ranged Projectiles require more than simple bounding points.. so we create it as avoidance zone to cache it with properties.
                                //Check for intersection..
                                try
                                {
                                    ActorMovement thisMovement = thisObj.Movement;
                                    Vector2 Direction = thisMovement.DirectionVector;
                                    Ray R = new Ray(tmp_CachedObj.Position, Direction.ToVector3());
                                    double Speed;
                                    //Lookup Cached Speed, or add new entry.
                                    if (!dictProjectileSpeed.TryGetValue(tmp_CachedObj.SNOID, out Speed))
                                    {
                                        Speed = thisMovement.DesiredSpeed;
                                        dictProjectileSpeed.Add(tmp_CachedObj.SNOID, Speed);
                                    }

                                    thisObstacle = new CacheAvoidance(tmp_CachedObj, AvoidanceType, R, Speed);
                                    Obstacles.Add(thisObstacle);
                                }
                                catch
                                {

                                        Logger.Write(LogLevel.Cache, "Failed to create projectile avoidance with rotation and speed. {0}", tmp_CachedObj.InternalName);
                                }
                            }
                            else if (tmp_CachedObj.IsAvoidance)
                            {
                                //Poison Gas Can Be Friendly...
                                if (AvoidanceType == AvoidanceType.PoisonGas)
                                {
                                    int TeamID = 0;
                                    try
                                    {
                                        TeamID = thisObj.CommonData.GetAttribute<int>(ActorAttributeType.TeamID);
                                    }
                                    catch
                                    {

                                        Logger.Write(LogLevel.Cache, "Failed to retrieve TeamID attribute for object {0}", tmp_CachedObj.InternalName);
                                    }

                                    //ID of 1 means its non-hostile! (-1?) 2??
                                    //if (TeamID==1||TeamID==-1)
                                    if (TeamID != 10)
                                    {
                                        //Logger.Write(LogLevel.None, "Ignoring Avoidance {0} due to Friendly TeamID match!", tmp_CachedObj.InternalName);
                                        BlacklistCache.AddObjectToBlacklist(tmp_CachedObj.RAGUID, BlacklistType.Permanent);
                                        continue;
                                    }
                                }

                                thisObstacle = new CacheAvoidance(tmp_CachedObj, AvoidanceType);
                                Obstacles.Add(thisObstacle);
                            }
                            else
                            {
                                //Obstacles.
                                thisObstacle = new CacheServerObject(tmp_CachedObj);
                                Obstacles.Add(thisObstacle);
                            }
                        }

                        continue;
                        #endregion
                    }

                    if (tmp_CachedObj.ObjectShouldBeRecreated)
                    {//This is where we create the real object after its done with SNO Update.

                        //Specific updates
                        if (tmp_CachedObj.Actortype.Value == ActorType.Item)
                        {
                            tmp_CachedObj = new CacheItem(tmp_CachedObj);
                        }
                        else if (tmp_CachedObj.Actortype.Value == ActorType.Monster)
                        {
                            if (!tmp_CachedObj.IsSummonedPet)
                                tmp_CachedObj = new CacheUnit(tmp_CachedObj);
                            else
                            {

                                PetTypes PetType = (PetTypes)TheCache.ObjectIDCache.UnitPetEntries[tmp_CachedObj.SNOID].ObjectType;

                                #region Summoner ID Check

                                // Get the summoned-by info, cached if possible
                                if (!tmp_CachedObj.SummonerID.HasValue)
                                {
                                    try
                                    {
                                        tmp_CachedObj.SummonerID = thisObj.CommonData.GetAttribute<int>(ActorAttributeType.SummonedByACDID);
                                    }
                                    catch (Exception ex)
                                    {
                                        //Logger.DBLog.InfoFormat("[Funky] Safely handled exception getting summoned-by info [" + tmp_CachedObj.SNOID.ToString(CultureInfo.InvariantCulture) + "]");
                                        //Logger.DBLog.DebugFormat(ex.ToString());
                                        continue;
                                    }
                                }

                                if (FunkyGame.Hero.iMyDynamicID != tmp_CachedObj.SummonerID.Value)
                                {
                                    BlacklistCache.IgnoreThisObject(tmp_CachedObj, false, false);
                                    tmp_CachedObj.NeedsRemoved = true;
                                    continue;
                                }

                                #endregion

                                tmp_CachedObj = new CachePet(tmp_CachedObj, PetType);
                            }
                        }
                        else if (tmp_CachedObj.Actortype.Value == ActorType.Gizmo)
                        {

                            if (CheckFlag(tmp_CachedObj.targetType.Value, TargetType.Interactables))
                                tmp_CachedObj = new CacheInteractable(tmp_CachedObj);
                            else
                                tmp_CachedObj = new CacheDestructable(tmp_CachedObj);
                        }

                        //Update Properties (currently only for units)

                        try
                        {
                            tmp_CachedObj.UpdateProperties();
                        }
                        catch
                        {
                            Logger.Write(LogLevel.Cache,"Failed to update properties for {0}", tmp_CachedObj.DebugStringSimple);
                        }
                    }

                    if (!tmp_CachedObj.UpdateData())
                    {
                        //Logger.Write(LogLevel.Cache, "Update Failed for {0}", tmp_CachedObj.DebugStringSimple);

                        if (!tmp_CachedObj.IsStillValid())
                            tmp_CachedObj.NeedsRemoved = true;

                        continue;
                    }

                    //Obstacle cache
                    if (tmp_CachedObj.Obstacletype.Value != ObstacleType.None
                          && (CheckFlag(tmp_CachedObj.targetType.Value, TargetType.ServerObjects)))
                    {
                        CacheObstacle thisObstacleObj;

                        if (!Obstacles.TryGetValue(tmp_CachedObj.RAGUID, out thisObstacleObj))
                        {
                            CacheServerObject newobj = new CacheServerObject(tmp_CachedObj);
                            Obstacles.Add(tmp_CachedObj.RAGUID, newobj);

                            //Add nearby objects to our collection (used in navblock/obstaclecheck methods to reduce queries)
                            if (CacheIDLookup.hashSNONavigationObstacles.Contains(newobj.SNOID))
                                Navigation.Navigation.MGP.AddCellWeightingObstacle(newobj.SNOID, newobj.Radius);
                        }
                        else
                        {
                            if (thisObstacleObj.targetType.Value == TargetType.Unit)
                            {
                                //Since units position requires updating, we update using the CacheObject
                                thisObstacleObj.Position = tmp_CachedObj.Position;
                                Obstacles[tmp_CachedObj.RAGUID] = thisObstacleObj;
                            }
                        }
                    }

                    //cache it
                    if (Objects.ContainsKey(tmp_CachedObj.RAGUID))
                        Objects[tmp_CachedObj.RAGUID] = tmp_CachedObj;
                    else
                        Objects.Add(tmp_CachedObj.RAGUID, tmp_CachedObj);

                } //End of Loop

            }// End of Framelock

            //Tally up unseen objects.
            var UnseenObjects = Objects.Keys.Where(O => !hashDoneThisRactor.Contains(O)).ToList();
            if (UnseenObjects.Any())
            {
                for (int i = 0; i < UnseenObjects.Count(); i++)
                {
                    Objects[UnseenObjects[i]].LoopsUnseen++;
                }
            }

            //Trim our collection every 5th refresh.
            UpdateLoopCounter++;
            if (UpdateLoopCounter > 4)
            {
                UpdateLoopCounter = 0;
                //Now flag any objects not seen for 5 loops. Gold/Globe only 1 loop.
                foreach (var item in Objects.Values.Where(CO =>
                    (CO.LoopsUnseen >= 5 || //5 loops max..
                    (CO.targetType.HasValue && (CheckFlag(CO.targetType.Value, TargetType.Gold | TargetType.Globe)) && CO.LoopsUnseen > 0)))) //gold/globe only 1 loop!
                {
                    item.NeedsRemoved = true;
                }

            }

            CheckForCacheRemoval();

            _lastUpdatedCacheCollection=DateTime.Now;
            return true;
        }
Esempio n. 9
0
 public void CheckEntry(CacheUnit entry)
 {
     var d = new DebugUnitEntry(entry);
     if (Units.Entries.Contains(d)) return;
     Units.Entries.Add(d);
     DebugData_Units.SerializeToXML(Units);
 }
Esempio n. 10
0
        public bool CheckCustomCombatMethod(CacheUnit unit)
        {
            foreach (Func<CacheUnit, bool> item in FcriteriaCombat.GetInvocationList())
                if (!item(unit)) return false;

            return true;
        }
Esempio n. 11
0
        ///<summary>
        ///Check Combat
        ///</summary>
        public bool CheckCombatConditionMethod(ConditionCriteraTypes conditions = ConditionCriteraTypes.All, CacheUnit unit = null)
        {
            //Order in which tests are conducted..

            //Units in Range (Not Cluster)
            //Clusters
            //Single Target

            //If all are null or any of them are successful, then we test Custom Conditions
            //Custom Condition

            //Reset Last Condition
            LastConditionPassed = ConditionCriteraTypes.None;
            bool TestCustomConditions = false;
            bool FailedCondition = false;

            if (conditions.HasFlag(ConditionCriteraTypes.Cluster) && ClusterConditions.Count > 0)
            {
                foreach (var condition in ClusterConditions)
                {
                    FailedCondition = false;

                    foreach (Func<bool> item in condition.Criteria.GetInvocationList())
                    {
                        if (!item())
                        {
                            FailedCondition = true;
                            break;
                        }
                    }

                    //Last Condition did not fail.. (Success!)
                    if (!FailedCondition)
                    {
                        LastConditionPassed = ConditionCriteraTypes.Cluster;
                        LastClusterConditionSuccessful=condition;
                        TestCustomConditions = true;
                        break;
                    }
                }
            }

            if ((!TestCustomConditions || FailedCondition) && conditions.HasFlag(ConditionCriteraTypes.SingleTarget) && SingleUnitCondition.Count > 0)
            {
                //We iterate each condition in the list and test the criteria.
                foreach (var condition in SingleUnitCondition)
                {
                    FailedCondition = false;

                    foreach (Func<CacheUnit,bool> item in condition.Criteria.GetInvocationList())
                    {
                        if (!item(unit))
                        {
                            FailedCondition = true;
                            break;
                        }
                    }

                    //Last Condition did not fail.. (Success!)
                    if (!FailedCondition)
                    {
                        LastConditionPassed = ConditionCriteraTypes.SingleTarget;
                        TestCustomConditions = true;
                        break;
                    }
                }
            }

            //If TestCustomCondtion failed, and FailedCondition is true.. then we tested a combat condition.
            //If FailedCondition is false, then we never tested a condition.
            if (!TestCustomConditions && !TestCustomCombatConditions) return false; //&&FailedCondition

            foreach (Func<CacheUnit, bool> item in FcriteriaCombat.GetInvocationList())
                if (!item(unit)) return false;

            return true;
        }