public override void RefreshObject()
{
if (AvoidanceCache.IgnoreAvoidance(AvoidanceType))
{
return;
}
//Only update position of Movement Avoidances!
if (IsProjectileAvoidance)
{
//Blacklisted updates
if (BlacklistRefreshCounter > 0 &&
!CheckUpdateForProjectile)
{
BlacklistRefreshCounter--;
}
//If we need to avoid, than enable travel avoidance flag also.
if (UpdateProjectileRayTest())
{
FunkyGame.Targeting.Cache.Environment.TriggeringAvoidances.Add(this);
FunkyGame.Targeting.Cache.Environment.TriggeringAvoidanceRAGUIDs.Add(RAGUID);
FunkyGame.Targeting.Cache.TravellingAvoidance = true;
FunkyGame.Targeting.Cache.RequiresAvoidance = true;
}
}
else
{
if (CentreDistance < 50f)
{
FunkyGame.Targeting.Cache.Environment.NearbyAvoidances.Add(RAGUID);
}
if (Position.Distance(FunkyGame.Hero.Position) <= Radius)
{
FunkyGame.Targeting.Cache.Environment.TriggeringAvoidances.Add(this);
FunkyGame.Targeting.Cache.Environment.TriggeringAvoidanceRAGUIDs.Add(RAGUID);
FunkyGame.Targeting.Cache.RequiresAvoidance = true;
}
}
}
//
///<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);
}
public double UpdateWeight(out int monstercount, out int avoidcount, ref List <int> UsedRAGUIDs, bool ResetIndex = false)
{
monstercount = 0;
avoidcount = 0;
if (ResetIndex)
{
LastIndexUsed = 0;
}
OccupiedObjects.Clear();
Vector3 sectorCenter = this.Center;
//Get the Diagonal Length between start and end, multiply by 2.5 since each point represents an area of 5f than Divide the total by 2 for the radius range.
double range = GridPoint.GetDistanceBetweenPoints(this.StartPoint, this.CornerPoint);
int TotalGridPoints = this.ContainedPoints.Count;
this.ThisWeight = 0d;
//We use 2D Distance and subtract the obstacles radius
IEnumerable <CacheObstacle> obstaclesContained = ObjectCache.Obstacles.Values
.Where(obs => Math.Max(0f, sectorCenter.Distance2D(obs.Position) - obs.Radius) <= range);
double maxaverage = ObjectCache.Objects.MaximumHitPointAverage;
if (obstaclesContained.Any())
{
//reset weight
this.ThisWeight = 0;
//copy SectorPoints
//GridPoint[] SectorPoints=new GridPoint[this.ContainedPoints.Count];
//this.ContainedPoints.CopyTo(SectorPoints);
List <GridPoint> NonNavPoints = new List <GridPoint>();
foreach (CacheObstacle item in obstaclesContained)
{
OccupiedObjects.Add(item.RAGUID);
if (item is CacheServerObject)
{
//Monsters should add 10% of its weight
//if (item.Obstacletype.Value==ObstacleType.Monster)
//{
// if (Bot.Settings.Fleeing.EnableFleeingBehavior&& Bot.Targeting.Environment.FleeTrigeringRAGUIDs.Contains(item.RAGUID))
// {
// }
//}
if (item.Obstacletype.Value == ObstacleType.ServerObject)
{
//give +1 to weight
this.ThisWeight++;
}
}
else if (item is CacheAvoidance)
{
if (!UsedRAGUIDs.Contains(item.RAGUID))
{
AvoidanceType thisAvoidanceType = ((CacheAvoidance)item).AvoidanceType;
if (AvoidanceCache.IgnoringAvoidanceType(thisAvoidanceType))
{
continue;
}
AvoidanceValue AV = Bot.Settings.Avoidance.Avoidances[(int)thisAvoidanceType];
avoidcount++;
float BaseWeight = AV.Weight;
//if ((AvoidanceType.ArcaneSentry|AvoidanceType.Dececrator|AvoidanceType.MoltenCore|AvoidanceType.TreeSpore).HasFlag(thisAvoidanceType))
// BaseWeight=1f;
//else
// BaseWeight=0.5f;
this.ThisWeight += (BaseWeight / Bot.Character.Data.dCurrentHealthPct);
UsedRAGUIDs.Add(item.RAGUID);
}
}
}
////Now add a base score for non-nav points. (25 being 100% non-navigable)
//int PointMultiplier=(25/TotalGridPoints);
//int RemainingPoints=SectorPoints.Length;
//this.ThisWeight+=25-(RemainingPoints*PointMultiplier);
//Logger.DBLog.InfoFormat("Weight assigned to this sector {0}. \r\n"
//+"Total Points {1} with {2} Remaining points Valid!", this.ThisWeight, this.ContainedPoints.Count, SectorPoints.Length);
}
return(this.ThisWeight);
//(Total Points / Non-Navigable Points Ratio)
}
///<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);
}
