public static bool CachedResultFor(ReachabilityCache __instance, ref BoolUnknown __result, District A, District B, TraverseParms traverseParams)
#endif
{
if (A == null || B == null)
{
return(false);
}
Dictionary <ReachabilityCache.CachedEntry, bool> cacheDict = getCacheDict(__instance);
lock (cacheDict)
{
if (cacheDict.TryGetValue(new ReachabilityCache.CachedEntry(A.ID, B.ID, traverseParams), out bool value))
{
if (!value)
{
__result = BoolUnknown.False;
return(false);
}
__result = BoolUnknown.True;
return(false);
}
}
__result = BoolUnknown.Unknown;
return(false);
}
private BoolUnknown GetCachedResult(TraverseParms traverseParams)
{
bool flag = false;
for (int i = 0; i < this.startingRegions.Count; i++)
{
for (int j = 0; j < this.destRegions.Count; j++)
{
if (this.destRegions[j] == this.startingRegions[i])
{
return(BoolUnknown.True);
}
BoolUnknown boolUnknown = this.cache.CachedResultFor(this.startingRegions[i].Room, this.destRegions[j].Room, traverseParams);
if (boolUnknown == BoolUnknown.True)
{
return(BoolUnknown.True);
}
if (boolUnknown == BoolUnknown.Unknown)
{
flag = true;
}
}
}
if (!flag)
{
return(BoolUnknown.False);
}
return(BoolUnknown.Unknown);
}
private ResultOrError <T> GetResultOrError <T>(XmlElement node)
{
string nodeResult = node.Attributes["result"]?.Value;
string errorCodeStr = node.Attributes["error"]?.Value;
string throwsStr = node.Attributes["throws"]?.Value;
int errorCode = 0;
if (errorCodeStr != null)
{
errorCode = int.Parse(errorCodeStr, CultureInfo.InvariantCulture);
if (throwsStr != null)
{
bool throws = bool.Parse(throwsStr);
return(new ResultOrError <T>(errorCode, throws));
}
}
if (nodeResult != null)
{
if (typeof(BoolUnknown).IsAssignableFrom(typeof(T)))
{
BoolUnknown buResult = (BoolUnknown)Enum.Parse(typeof(BoolUnknown), nodeResult, true);
return(new ResultOrError <T>((T)Convert.ChangeType(buResult, typeof(T)), errorCode));
}
else if (typeof(int).IsAssignableFrom(typeof(T)))
{
int iResult = int.Parse(nodeResult, CultureInfo.InvariantCulture);
return(new ResultOrError <T>((T)Convert.ChangeType(iResult, typeof(T)), errorCode));
}
else if (typeof(bool).IsAssignableFrom(typeof(T)))
{
bool bResult = bool.Parse(nodeResult);
return(new ResultOrError <T>((T)Convert.ChangeType(bResult, typeof(T)), errorCode));
}
else if (typeof(string).IsAssignableFrom(typeof(T)))
{
return(new ResultOrError <T>((T)Convert.ChangeType(nodeResult, typeof(T)), errorCode));
}
else
{
return(null);
}
}
else
{
return(new ResultOrError <T>(errorCode, false));
}
}
public static bool CachedResultFor(ReachabilityCache __instance, ref BoolUnknown __result, Room A, Room B, TraverseParms traverseParams)
{
cacheDict = getCacheDict(__instance);
if (cacheDict.TryGetValue(new CachedEntry2(A.ID, B.ID, traverseParams), out bool value))
{
if (!value)
{
__result = BoolUnknown.False;
return(false);
}
__result = BoolUnknown.True;
return(false);
}
__result = BoolUnknown.Unknown;
return(false);
}
public bool CanReach(IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams)
{
if (this.working)
{
Log.ErrorOnce("Called CanReach() while working. This should never happen. Suppressing further errors.", 7312233, false);
return(false);
}
if (traverseParams.pawn != null)
{
if (!traverseParams.pawn.Spawned)
{
return(false);
}
if (traverseParams.pawn.Map != this.map)
{
Log.Error(string.Concat(new object[]
{
"Called CanReach() with a pawn spawned not on this map. This means that we can't check his reachability here. Pawn's current map should have been used instead of this one. pawn=",
traverseParams.pawn,
" pawn.Map=",
traverseParams.pawn.Map,
" map=",
this.map
}), false);
return(false);
}
}
if (ReachabilityImmediate.CanReachImmediate(start, dest, this.map, peMode, traverseParams.pawn))
{
return(true);
}
if (!dest.IsValid)
{
return(false);
}
if (dest.HasThing && dest.Thing.Map != this.map)
{
return(false);
}
if (!start.InBounds(this.map) || !dest.Cell.InBounds(this.map))
{
return(false);
}
if ((peMode == PathEndMode.OnCell || peMode == PathEndMode.Touch || peMode == PathEndMode.ClosestTouch) && traverseParams.mode != TraverseMode.NoPassClosedDoorsOrWater && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater)
{
Room room = RegionAndRoomQuery.RoomAtFast(start, this.map, RegionType.Set_Passable);
if (room != null && room == RegionAndRoomQuery.RoomAtFast(dest.Cell, this.map, RegionType.Set_Passable))
{
return(true);
}
}
if (traverseParams.mode == TraverseMode.PassAllDestroyableThings)
{
TraverseParms traverseParams2 = traverseParams;
traverseParams2.mode = TraverseMode.PassDoors;
if (this.CanReach(start, dest, peMode, traverseParams2))
{
return(true);
}
}
dest = (LocalTargetInfo)GenPath.ResolvePathMode(traverseParams.pawn, dest.ToTargetInfo(this.map), ref peMode);
this.working = true;
bool result;
try
{
this.pathGrid = this.map.pathGrid;
this.regionGrid = this.map.regionGrid;
this.reachedIndex += 1u;
this.destRegions.Clear();
if (peMode == PathEndMode.OnCell)
{
Region region = dest.Cell.GetRegion(this.map, RegionType.Set_Passable);
if (region != null && region.Allows(traverseParams, true))
{
this.destRegions.Add(region);
}
}
else if (peMode == PathEndMode.Touch)
{
TouchPathEndModeUtility.AddAllowedAdjacentRegions(dest, traverseParams, this.map, this.destRegions);
}
if (this.destRegions.Count == 0 && traverseParams.mode != TraverseMode.PassAllDestroyableThings && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater)
{
this.FinalizeCheck();
result = false;
}
else
{
this.destRegions.RemoveDuplicates <Region>();
this.openQueue.Clear();
this.numRegionsOpened = 0;
this.DetermineStartRegions(start);
if (this.openQueue.Count == 0 && traverseParams.mode != TraverseMode.PassAllDestroyableThings && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater)
{
this.FinalizeCheck();
result = false;
}
else
{
if (this.startingRegions.Any <Region>() && this.destRegions.Any <Region>() && this.CanUseCache(traverseParams.mode))
{
BoolUnknown cachedResult = this.GetCachedResult(traverseParams);
if (cachedResult == BoolUnknown.True)
{
this.FinalizeCheck();
result = true;
return(result);
}
if (cachedResult == BoolUnknown.False)
{
this.FinalizeCheck();
result = false;
return(result);
}
if (cachedResult != BoolUnknown.Unknown)
{
}
}
if (traverseParams.mode == TraverseMode.PassAllDestroyableThings || traverseParams.mode == TraverseMode.PassAllDestroyableThingsNotWater || traverseParams.mode == TraverseMode.NoPassClosedDoorsOrWater)
{
bool flag = this.CheckCellBasedReachability(start, dest, peMode, traverseParams);
this.FinalizeCheck();
result = flag;
}
else
{
bool flag2 = this.CheckRegionBasedReachability(traverseParams);
this.FinalizeCheck();
result = flag2;
}
}
}
}
finally
{
this.working = false;
}
return(result);
}
public void Notify_SkillDisablesChanged()
{
this.cachedTotallyDisabled = BoolUnknown.Unknown;
}
public bool CanReachShip(IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParms)
{
if (working)
{
Log.ErrorOnce("Called CanReach() while working for Ships. This should never happen. Suppressing further errors.", 7312233);
return(false);
}
if (!map.terrainGrid.TerrainAt(dest.Cell).IsWater)
{
return(false);
}
if (!(traverseParms.pawn is null))
{
if (!traverseParms.pawn.Spawned)
{
return(false);
}
if (traverseParms.pawn.Map != map)
{
Log.Error(string.Concat(new object[]
{
"Called CanReach() with a ship spawned not on this map. This means that we can't check its reachability here. Pawn's" +
"current map should have been used instead of this one. pawn=", traverseParms.pawn,
" pawn.Map=", traverseParms.pawn.Map,
" map=", map
}));
return(false);
}
}
if (!dest.IsValid)
{
return(false);
}
if (dest.HasThing && dest.Thing.Map != map)
{
return(false);
}
if (!start.InBoundsShip(map) || !dest.Cell.InBoundsShip(map))
{
return(false);
}
if ((peMode == PathEndMode.OnCell || peMode == PathEndMode.Touch || peMode == PathEndMode.ClosestTouch) && traverseParms.mode != TraverseMode.NoPassClosedDoorsOrWater &&
traverseParms.mode != TraverseMode.PassAllDestroyableThingsNotWater)
{
VehicleRoom room = VehicleRegionAndRoomQuery.RoomAtFast(start, map, RegionType.Set_Passable);
if (!(room is null) && room == VehicleRegionAndRoomQuery.RoomAtFast(dest.Cell, map, RegionType.Set_Passable))
{
return(true);
}
}
if (traverseParms.mode == TraverseMode.PassAllDestroyableThings)
{
TraverseParms traverseParms2 = traverseParms;
traverseParms.mode = TraverseMode.PassDoors;
if (CanReachShip(start, dest, peMode, traverseParms2))
{
return(true);
}
}
dest = (LocalTargetInfo)GenPathVehicles.ResolvePathMode(traverseParms.pawn, dest.ToTargetInfo(map), ref peMode);
working = true;
bool result;
try
{
pathGrid = map.GetCachedMapComponent <VehicleMapping>().VehiclePathGrid;
regionGrid = map.GetCachedMapComponent <VehicleMapping>().VehicleRegionGrid;
reachedIndex += 1u;
destRegions.Clear();
if (peMode == PathEndMode.OnCell)
{
VehicleRegion region = VehicleGridsUtility.GetRegion(dest.Cell, map, RegionType.Set_Passable);
if (!(region is null) && region.Allows(traverseParms, true))
{
destRegions.Add(region);
}
}
else if (peMode == PathEndMode.Touch)
{
TouchPathEndModeUtilityVehicles.AddAllowedAdjacentRegions(dest, traverseParms, map, destRegions);
}
if (destRegions.Count == 0 && traverseParms.mode != TraverseMode.PassAllDestroyableThings && traverseParms.mode !=
TraverseMode.PassAllDestroyableThingsNotWater)
{
FinalizeCheck();
result = false;
}
else
{
destRegions.RemoveDuplicates();
openQueue.Clear();
numRegionsOpened = 0;
DetermineStartRegions(start);
if (openQueue.Count == 0 && traverseParms.mode != TraverseMode.PassAllDestroyableThings && traverseParms.mode !=
TraverseMode.PassAllDestroyableThingsNotWater)
{
FinalizeCheck();
result = false;
}
else
{
if (startingRegions.Any() && destRegions.Any() && CanUseCache(traverseParms.mode))
{
BoolUnknown cachedResult = GetCachedResult(traverseParms);
if (cachedResult == BoolUnknown.True)
{
FinalizeCheck();
return(true);
}
if (cachedResult == BoolUnknown.False)
{
FinalizeCheck();
return(false);
}
}
if (traverseParms.mode == TraverseMode.PassAllDestroyableThings || traverseParms.mode == TraverseMode.PassAllDestroyableThingsNotWater ||
traverseParms.mode == TraverseMode.NoPassClosedDoorsOrWater)
{
bool flag = CheckCellBasedReachability(start, dest, peMode, traverseParms);
FinalizeCheck();
result = flag;
}
else
{
bool flag2 = CheckRegionBasedReachability(traverseParms);
//bool flag2 = CheckCellBasedReachability(start, dest, peMode, traverseParms); //REDO?
FinalizeCheck();
result = flag2;
}
}
}
}
finally
{
working = false;
}
return(result);
}
public static bool CachedResultFor(ReachabilityCache __instance, ref BoolUnknown __result, Room A, Room B, TraverseParms traverseParams)
