Example #1
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);
        }
Example #2
0
        ///<summary>
        ///Updates SNO Cache Values
        ///</summary>
        public virtual bool UpdateData(DiaObject thisObj, int raguid)
        {
            bool failureDuringUpdate = false;

            if (InternalName == null)
            {
                try
                {
                    InternalName = thisObj.Name;
                }
                catch
                {
                    Logger.Write(LogLevel.Cache, "Failure to get internal name on object, SNO {0}", SNOID);

                    return(false);
                }
            }

            if (!Actortype.HasValue)
            {
                #region ActorType
                try
                {
                    Actortype = thisObj.ActorType;
                }
                catch
                {
                    Logger.Write(LogLevel.Cache, "Failure to get actorType for object, SNO: {0}", SNOID);

                    return(false);
                }
                #endregion
            }

            //Ignored actor types..
            if (BlacklistCache.IgnoredActorTypes.Contains(Actortype.Value))            //||!LootBehaviorEnabled&&this.Actortype.Value==ActorType.Item)
            {
                BlacklistCache.IgnoreThisObject(this, raguid);
                return(false);
            }

            if (!targetType.HasValue)
            {
                #region EvaluateTargetType
                try
                {
                    //Evaluate Target Type..
                    // See if it's an avoidance first from the SNO
                    if (IsAvoidance || IsObstacle)
                    {
                        targetType = TargetType.None;

                        if (IsAvoidance)
                        {
                            if (IsProjectileAvoidance)
                            {
                                Obstacletype = ObstacleType.MovingAvoidance;
                            }
                            else
                            {
                                Obstacletype = ObstacleType.StaticAvoidance;
                            }

                            AvoidanceType AT = AvoidanceCache.FindAvoidanceUsingSNOID(SNOID);

                            //Check if avoidance is enabled or if the avoidance type is set to 0
                            if (!Bot.Settings.Avoidance.AttemptAvoidanceMovements || AT != AvoidanceType.None && AvoidanceCache.IgnoringAvoidanceType(AT))
                            {
                                BlacklistCache.AddObjectToBlacklist(raguid, BlacklistType.Temporary);
                                return(false);
                            }

                            // Avoidance isn't disabled, so set this object type to avoidance
                            targetType = TargetType.Avoidance;
                        }
                        else
                        {
                            Obstacletype = ObstacleType.ServerObject;
                        }
                    }
                    else
                    {
                        // Calculate the object type of this object
                        if (Actortype.Value == ActorType.Monster ||
                            CacheIDLookup.hashActorSNOForceTargetUnit.Contains(SNOID))
                        {
                            targetType   = TargetType.Unit;
                            Obstacletype = ObstacleType.Monster;

                            if (CacheIDLookup.hashActorSNOForceTargetUnit.Contains(SNOID))
                            {
                                //Fill in monster data?
                                Actortype = ActorType.Monster;
                            }
                        }
                        else if (Actortype.Value == ActorType.Item ||
                                 CacheIDLookup.hashForceSNOToItemList.Contains(SNOID))
                        {
                            string testname = InternalName.ToLower();
                            //Check if this item is gold/globe..
                            if (testname.StartsWith("gold"))
                            {
                                targetType = TargetType.Gold;
                            }
                            else if (testname.StartsWith("healthglobe"))
                            {
                                targetType = TargetType.Globe;
                            }
                            else if (testname.StartsWith("console_powerglobe"))
                            {
                                targetType = TargetType.PowerGlobe;
                            }
                            else
                            {
                                targetType = TargetType.Item;
                            }
                            //Gold/Globe?
                        }
                        else if (Actortype.Value == ActorType.Gizmo)
                        {
                            GizmoType thisGizmoType;
                            try
                            {
                                thisGizmoType = thisObj.ActorInfo.GizmoType;
                            }
                            catch
                            {
                                Logger.Write(LogLevel.Cache, "Failure to get actor Gizmo Type!");
                                return(false);
                            }

                            if (thisGizmoType == GizmoType.DestroyableObject || thisGizmoType == GizmoType.BreakableChest)
                            {
                                targetType = TargetType.Destructible;
                            }
                            else if (thisGizmoType == GizmoType.PowerUp || thisGizmoType == GizmoType.HealingWell || thisGizmoType == GizmoType.PoolOfReflection)
                            {
                                targetType = TargetType.Shrine;
                            }
                            else if (thisGizmoType == GizmoType.Chest)
                            {
                                targetType = TargetType.Container;
                            }
                            else if (thisGizmoType == GizmoType.BreakableDoor)
                            {
                                targetType = TargetType.Barricade;
                            }
                            else if (thisGizmoType == GizmoType.Door)
                            {
                                targetType = TargetType.Door;
                            }
                            else if (thisGizmoType == GizmoType.Waypoint || thisGizmoType == GizmoType.Portal || thisGizmoType == GizmoType.DungeonPortal || thisGizmoType == GizmoType.BossPortal)
                            {                            //Special Interactive Object -- Add to special cache!
                                targetType = TargetType.ServerInteractable;
                            }
                            else if (thisGizmoType == GizmoType.Switch)
                            {
                                targetType = TargetType.CursedShrine;
                            }
                            else
                            {                            //All other gizmos should be ignored!
                                BlacklistCache.IgnoreThisObject(this, raguid);
                                return(false);
                            }

                            if (targetType.HasValue)
                            {
                                if (targetType.Value == TargetType.Destructible || targetType.Value == TargetType.Barricade || targetType.Value == TargetType.Door)
                                {
                                    Obstacletype = ObstacleType.Destructable;
                                }
                                else if (targetType.Value == TargetType.Shrine || IsChestContainer)
                                {
                                    Obstacletype = ObstacleType.ServerObject;
                                }
                            }

                            if (!Gizmotype.HasValue)
                            {
                                Gizmotype = thisGizmoType;
                            }
                        }
                        else if (CacheIDLookup.hashSNOInteractWhitelist.Contains(SNOID))
                        {
                            targetType = TargetType.Interactable;
                        }
                        else if (Actortype.Value == ActorType.ServerProp)
                        {
                            string TestString = InternalName.ToLower();
                            //Server props with Base in name are the destructibles "remains" which is considered an obstacle!
                            if (TestString.Contains("base") || TestString.Contains("fence"))
                            {
                                //Add this to the obstacle navigation cache
                                if (!IsObstacle)
                                {
                                    CacheIDLookup.hashSNONavigationObstacles.Add(SNOID);
                                }

                                Obstacletype = ObstacleType.ServerObject;

                                //Use unknown since we lookup SNO ID for server prop related objects.
                                targetType = TargetType.None;
                            }
                            else if (TestString.StartsWith("monsteraffix_"))
                            {
                                AvoidanceType T = AvoidanceCache.FindAvoidanceUsingName(TestString);
                                if (T == AvoidanceType.Wall)
                                {
                                    //Add this to the obstacle navigation cache
                                    if (!IsObstacle)
                                    {
                                        CacheIDLookup.hashSNONavigationObstacles.Add(SNOID);
                                    }

                                    Obstacletype = ObstacleType.ServerObject;

                                    //Use unknown since we lookup SNO ID for server prop related objects.
                                    targetType = TargetType.None;
                                }
                                //else if (Bot.AvoidancesHealth.ContainsKey(T))
                                //{
                                //	 Logger.DBLog.InfoFormat("Found Avoidance not recongized by SNO! Name {0} SNO {1}", TestString, this.SNOID);
                                //	 CacheIDLookup.hashAvoidanceSNOList.Add(this.SNOID);
                                //	 this.targetType=TargetType.Avoidance;
                                //}
                                else
                                {
                                    //Blacklist all other monster affixes
                                    BlacklistCache.IgnoreThisObject(this, raguid);
                                    return(false);
                                }
                            }
                            else
                            {
                                BlacklistCache.IgnoreThisObject(this, raguid);
                                return(false);
                            }
                        }
                        else
                        {                        //Misc?? Ignore it!
                            BlacklistCache.IgnoreThisObject(this, raguid);
                            return(false);
                        }
                    }
                }
                catch
                {
                    Logger.Write(LogLevel.Cache, "Failure to get actorType for object, SNO: {0}", SNOID);
                    return(false);
                }
                #endregion
            }


            if (!Obstacletype.HasValue)
            {
                Obstacletype = ObstacleType.None;
            }


            if (ObjectCache.CheckTargetTypeFlag(targetType.Value, TargetType.Unit))
            {
                SNORecordMonster monsterInfo;
                try
                {
                    monsterInfo = thisObj.CommonData.MonsterInfo;
                }
                catch
                {
                    Logger.Write(LogLevel.Cache, "Safely Handled MonsterInfo Exception for Object {0}", InternalName);
                    return(false);
                }


                if (!Monstertype.HasValue || ShouldRefreshMonsterType)
                {
                    #region MonsterType
                    try
                    {
                        Monstertype = monsterInfo.MonsterType;
                    }
                    catch
                    {
                        Logger.Write(LogLevel.Cache, "Failure to get MonsterType for SNO: {0}", SNOID);

                        failureDuringUpdate = true;
                    }
                    #endregion
                }
                if (!Monstersize.HasValue)
                {
                    #region MonsterSize
                    try
                    {
                        Monstersize = monsterInfo.MonsterSize;
                    }
                    catch
                    {
                        Logger.Write(LogLevel.Cache, "Failure to get MonsterSize for SNO: {0}", SNOID);

                        failureDuringUpdate = true;
                    }
                    #endregion
                }
            }


            if (Actortype.HasValue && targetType.HasValue &&
                (Actortype.Value != ActorType.Item && targetType.Value != TargetType.Avoidance && targetType.Value != TargetType.ServerInteractable))
            {
                //Validate sphere info
                Sphere sphereInfo = thisObj.CollisionSphere;

                if (!CollisionRadius.HasValue)
                {
                    #region CollisionRadius
                    try
                    {
                        CollisionRadius = sphereInfo.Radius;
                    }
                    catch
                    {
                        Logger.Write(LogLevel.Cache, "Failure to get CollisionRadius for SNO: {0}", SNOID);

                        failureDuringUpdate = true;
                    }
                    #endregion

                    if (CacheIDLookup.dictFixedCollisionRadius.ContainsKey(SNOID))
                    {                    //Override The Default Collision Sphere Value
                        CollisionRadius = CacheIDLookup.dictFixedCollisionRadius[SNOID];
                    }
                }

                if (!ActorSphereRadius.HasValue)
                {
                    #region ActorSphereRadius
                    try
                    {
                        ActorSphereRadius = thisObj.ActorInfo.Sphere.Radius;
                    }
                    catch
                    {
                        Logger.Write(LogLevel.Cache, "Safely handled getting attribute Sphere radius for gizmo {0}", InternalName);
                        failureDuringUpdate = true;
                    }
                    #endregion
                }

                #region GizmoProperties
                if (ObjectCache.CheckTargetTypeFlag(targetType.Value, TargetType.Destructible | TargetType.Interactable))
                {
                    //No Loot
                    if (!DropsNoLoot.HasValue)
                    {
                        #region DropsNoLoot
                        try
                        {
                            DropsNoLoot = thisObj.CommonData.GetAttribute <float>(ActorAttributeType.DropsNoLoot) <= 0;
                        }
                        catch
                        {
                            Logger.Write(LogLevel.Cache, "Safely handled reading DropsNoLoot for gizmo {0}", InternalName);
                            failureDuringUpdate = true;
                        }
                        #endregion
                    }
                    //No XP
                    if (!GrantsNoXP.HasValue)
                    {
                        #region GrantsNoXP
                        try
                        {
                            GrantsNoXP = thisObj.CommonData.GetAttribute <float>(ActorAttributeType.GrantsNoXP) <= 0;
                        }
                        catch
                        {
                            Logger.Write(LogLevel.Cache, "Safely handled reading GrantsNoXp for gizmo {0}", InternalName);
                            failureDuringUpdate = true;
                        }
                        #endregion
                    }
                    //Barricade flag
                    if (!IsBarricade.HasValue)
                    {
                        #region Barricade
                        try
                        {
                            IsBarricade = ((DiaGizmo)thisObj).IsBarricade;
                        }
                        catch
                        {
                            Logger.Write(LogLevel.Cache, "Safely handled getting attribute IsBarricade for gizmo {0}", InternalName);
                            failureDuringUpdate = true;
                        }
                        #endregion
                    }
                }
                #endregion
            }


            return(!failureDuringUpdate);
        }