private static void DetermineStartRegions(Map map, IntVec3 start, List <Region> startingRegionsParam, PathGrid pathGrid, RegionGrid regionGrid, Queue <Region> openQueueParam, HashSet <Region> regionsReached) { startingRegionsParam.Clear(); if (pathGrid.WalkableFast(start)) { Region validRegionAt = regionGrid.GetValidRegionAt(start); QueueNewOpenRegion(validRegionAt, openQueueParam, regionsReached); startingRegionsParam.Add(validRegionAt); return; } else { for (int index = 0; index < 8; ++index) { IntVec3 intVec = start + GenAdj.AdjacentCells[index]; if (intVec.InBounds(map) && pathGrid.WalkableFast(intVec)) { Region validRegionAt2 = regionGrid.GetValidRegionAt(intVec); if (validRegionAt2 != null && !regionsReached.Contains(validRegionAt2)) { QueueNewOpenRegion(validRegionAt2, openQueueParam, regionsReached); startingRegionsParam.Add(validRegionAt2); } } } } }
public static void ReApplyThingToListerThings(IntVec3 cell, Thing thing) { if (cell == IntVec3.Invalid || thing == null || thing.Map == null || !thing.Spawned) { return; } Map map = thing.Map; // From ThingUtility.UpdateRegionListers(..) RegionGrid regionGrid = map.regionGrid; Region region = null; if (cell.InBounds(map)) { region = regionGrid.GetValidRegionAt(cell); } if (region != null) { if (!region.ListerThings.Contains(thing)) { region.ListerThings.Add(thing); //Log.Warning("ReAdded Robot to region.ListerThings.."); } } }
private static void DetermineStartRegions2(Reachability __instance, IntVec3 start, List <Region> this_startingRegions, PathGrid pathGrid, RegionGrid regionGrid, uint this_reachedIndex, Queue <Region> this_openQueue, ref int this_numRegionsOpened, HashSet <Region> regionsReached) { //this_startingRegions.Clear(); if (pathGrid.WalkableFast(start)) { Region validRegionAt = regionGrid.GetValidRegionAt(start); if (validRegionAt != null) { QueueNewOpenRegion(validRegionAt, this_reachedIndex, this_openQueue, ref this_numRegionsOpened, regionsReached); this_startingRegions.Add(validRegionAt); } else { Log.Warning("regionGrid.GetValidRegionAt returned null for start at: " + start.ToString()); } } else { for (int index = 0; index < 8; ++index) { IntVec3 intVec3 = start + GenAdj.AdjacentCells[index]; if (intVec3.InBounds(map(__instance)) && pathGrid.WalkableFast(intVec3)) { Region validRegionAt = regionGrid.GetValidRegionAt(intVec3); if (validRegionAt != null && (int)validRegionAt.reachedIndex != (int)this_reachedIndex) { QueueNewOpenRegion(validRegionAt, this_reachedIndex, this_openQueue, ref this_numRegionsOpened, regionsReached); this_startingRegions.Add(validRegionAt); } } } } }
public static bool GetValidRegionAt(RegionGrid __instance, ref Region __result, IntVec3 c) { Map map = __instance.map; if (!c.InBounds(map)) { Log.Error("Tried to get valid region out of bounds at " + c); __result = null; return(false); } if (!map.regionAndRoomUpdater.Enabled && map.regionAndRoomUpdater.AnythingToRebuild) { Log.Warning(string.Concat("Trying to get valid region at ", c, " but RegionAndRoomUpdater is disabled. The result may be incorrect.")); } Region region = __instance.regionGrid[map.cellIndices.CellToIndex(c)]; if (region == null || !region.valid) { map.regionAndRoomUpdater.TryRebuildDirtyRegionsAndRooms(); region = __instance.regionGrid[map.cellIndices.CellToIndex(c)]; } if (region != null && region.valid) { __result = region; return(false); } __result = null; return(false); }
public TrailblazerPather_HAStar(PathfindData pathfindData) : base(pathfindData) { regionGrid = pathfindData.map.regionGrid; int regions = regionGrid.AllRegions.Count(); // Worst case scenario - a large region where every single edge cell links to a different neighboring region maxLinks = Region.GridSize * 4 * regions; rraOpenSet = new Priority_Queue.FastPriorityQueue <LinkNode>(maxLinks); rraClosedSet = new Dictionary <LinkNode, int>(); destRegions.AddRange(from cell in pathfindData.DestRect.Cells let region = regionGrid.GetValidRegionAt(cell) where region != null select region); // Initialize the RRA* algorithm LinkNode.ClearCaches(); IEnumerable <LinkNode> initialNodes = (from region in destRegions from link in region.links from node in LinkNode.Both(link) select node).Distinct(); foreach (LinkNode node in initialNodes) { rraClosedSet[node] = RRAHeuristic(node, destCell); rraOpenSet.Enqueue(node, rraClosedSet[node]); } }
public static void ReApplyThingToListerThings(IntVec3 cell, Thing thing) { bool flag = cell == IntVec3.Invalid || thing == null || thing.Map == null || !thing.Spawned; if (!flag) { Map map = thing.Map; RegionGrid regionGrid = map.regionGrid; Region region = null; bool flag2 = GenGrid.InBounds(cell, map); if (flag2) { region = regionGrid.GetValidRegionAt(cell); } bool flag3 = region != null; if (flag3) { bool flag4 = !region.ListerThings.Contains(thing); if (flag4) { region.ListerThings.Add(thing); } } } }
public static bool Init(RegionCostCalculatorWrapper __instance, CellRect end, TraverseParms traverseParms, int moveTicksCardinal, int moveTicksDiagonal, ByteGrid avoidGrid, Area allowedArea, bool drafted, List <int> disallowedCorners) { moveTicksCardinalField(__instance) = moveTicksCardinal; moveTicksDiagonalField(__instance) = moveTicksDiagonal; endCell(__instance) = end.CenterCell; cachedRegion(__instance) = null; cachedBestLink(__instance) = null; cachedSecondBestLink(__instance) = null; cachedBestLinkCost(__instance) = 0; cachedSecondBestLinkCost(__instance) = 0; cachedRegionIsDestination(__instance) = false; Map map1 = map(__instance); RegionGrid regionGrid1 = map1.regionGrid; if (regionGrid1 == null) { Log.Error("regionGrid is null for map: " + map1.ToString()); return(false); } regionGrid(__instance) = regionGrid1.DirectGrid; destRegions(__instance).Clear(); if (end.Width == 1 && end.Height == 1) { Region region = endCell(__instance).GetRegion(map(__instance)); if (region != null) { destRegions(__instance).Add(region); } } else { foreach (IntVec3 item in end) { if (item.InBounds(map(__instance)) && !disallowedCorners.Contains(map(__instance).cellIndices.CellToIndex(item))) { Region region2 = item.GetRegion(map(__instance)); if (region2 != null && region2.Allows(traverseParms, isDestination: true)) { destRegions(__instance).Add(region2); } } } } if (destRegions(__instance).Count == 0) { Log.Error("Couldn't find any destination regions. This shouldn't ever happen because we've checked reachability."); } regionCostCalculator(__instance).Init( end, destRegions(__instance), traverseParms, moveTicksCardinal, moveTicksDiagonal, avoidGrid, allowedArea, drafted); return(false); }
public static void ReApplyThingToListerThings(IntVec3 cell, Thing thing) { if ((((cell != IntVec3.Invalid) && (thing != null)) && (thing.Map != null)) && thing.Spawned) { Map map = thing.Map; RegionGrid regionGrid = map.regionGrid; Region validRegionAt = null; if (cell.InBounds(map)) { validRegionAt = regionGrid.GetValidRegionAt(cell); } if ((validRegionAt != null) && !validRegionAt.ListerThings.Contains(thing)) { validRegionAt.ListerThings.Add(thing); } } }
public static bool CanReach(Reachability __instance, ref bool __result, IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams) { Map map = __instance.map; //if (working) //{ //Log.ErrorOnce("Called CanReach() while working. This should never happen. Suppressing further errors.", 7312233); //return false; //} if (traverseParams.pawn != null) { if (!traverseParams.pawn.Spawned) { __result = false; return(false); } if (traverseParams.pawn.Map != map) { Log.Error(string.Concat("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=", map)); __result = false; return(false); } } if (ReachabilityImmediate.CanReachImmediate(start, dest, map, peMode, traverseParams.pawn)) { __result = true; return(false); } if (!dest.IsValid) { __result = false; return(false); } if (dest.HasThing && dest.Thing.Map != map) { __result = false; return(false); } if (!start.InBounds(map) || !dest.Cell.InBounds(map)) { __result = false; return(false); } if ((peMode == PathEndMode.OnCell || peMode == PathEndMode.Touch || peMode == PathEndMode.ClosestTouch) && traverseParams.mode != TraverseMode.NoPassClosedDoorsOrWater && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater) { #if RW12 Room room = RegionAndRoomQuery.RoomAtFast(start, map); if (room != null && room == RegionAndRoomQuery.RoomAtFast(dest.Cell, map)) #endif #if RW13 District district = RegionAndRoomQuery.DistirctAtFast(start, map); if (district != null && district == RegionAndRoomQuery.DistirctAtFast(dest.Cell, map)) #endif { __result = true; return(false); } } if (traverseParams.mode == TraverseMode.PassAllDestroyableThings) { TraverseParms traverseParams2 = traverseParams; traverseParams2.mode = TraverseMode.PassDoors; bool canReachResult = false; CanReach(__instance, ref canReachResult, start, dest, peMode, traverseParams2); if (canReachResult) { __result = true; return(false); } } dest = (LocalTargetInfo)GenPath.ResolvePathMode(traverseParams.pawn, dest.ToTargetInfo(map), ref peMode); //working = true; try { #if RW12 __instance.pathGrid = map.pathGrid; PathGrid pathGrid = map.pathGrid; #endif #if RW13 __instance.pathGrid = map.pathing.For(traverseParams).pathGrid; PathGrid pathGrid = __instance.pathGrid; #endif __instance.regionGrid = map.regionGrid; RegionGrid regionGrid = map.regionGrid; destRegions.Clear(); switch (peMode) { case PathEndMode.OnCell: { Region region = dest.Cell.GetRegion(map); if (region != null && region.Allows(traverseParams, isDestination: true)) { destRegions.Add(region); } break; } case PathEndMode.Touch: TouchPathEndModeUtility.AddAllowedAdjacentRegions(dest, traverseParams, map, destRegions); break; } if (destRegions.Count == 0 && traverseParams.mode != TraverseMode.PassAllDestroyableThings && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater) { __result = false; return(false); } destRegions.RemoveDuplicates(); regionsReached.Clear(); openQueue.Clear(); startingRegions.Clear(); DetermineStartRegions(map, start, startingRegions, pathGrid, regionGrid, openQueue, regionsReached); if (openQueue.Count == 0 && traverseParams.mode != TraverseMode.PassAllDestroyableThings && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater) { __result = false; return(false); } if (startingRegions.Any() && destRegions.Any() && __instance.CanUseCache(traverseParams.mode)) { switch (GetCachedResult(__instance, traverseParams, startingRegions, destRegions)) { case BoolUnknown.True: __result = true; return(false); case BoolUnknown.False: __result = false; return(false); } } if (traverseParams.mode == TraverseMode.PassAllDestroyableThings || traverseParams.mode == TraverseMode.PassAllDestroyableThingsNotWater || traverseParams.mode == TraverseMode.NoPassClosedDoorsOrWater) { bool result = __instance.CheckCellBasedReachability(start, dest, peMode, traverseParams); __result = result; return(false); } bool result2 = CheckRegionBasedReachability(__instance, traverseParams, openQueue, regionsReached, startingRegions, destRegions); __result = result2; return(false); } finally { //working = false; } }
public static bool BMixRegionIsInRange(Region r, Thing billGiver, Bill bill) { if (!Controller.Settings.IncludeRegionLimiter) { return(true); } if (!IsValidForComp(billGiver)) { return(true); } CompBestMix compBMix = billGiver.TryGetComp <CompBestMix>(); if (compBMix != null) { //if (compBMix.CurMode == "DIS") if (BMBillUtility.UseBMixMode(compBMix, billGiver, bill) == "DIS") { return(true); } } else { return(true); } /* * List<IntVec3> cells = r?.Cells.ToList<IntVec3>(); * if ((cells != null) && (cells.Count > 0)) * { * foreach (IntVec3 cell in cells) * { * if (((float)((cell - billGiver.Position).LengthHorizontalSquared)) < ((float)(bill.ingredientSearchRadius * bill.ingredientSearchRadius))) * { * return true; * } * } * } */ // optimised to region corners Map map = billGiver?.Map; if (map != null) { RegionGrid regions = map?.regionGrid; // * if (regions != null) { IntVec3 chkcell = IntVec3.Zero; for (var i = 0; i < 4; i++) { switch (i) { case 0: chkcell = new IntVec3(r.extentsClose.minX, 0, r.extentsClose.minZ); break; case 3: chkcell = new IntVec3(r.extentsClose.minX, 0, r.extentsClose.maxZ); break; case 2: chkcell = new IntVec3(r.extentsClose.maxX, 0, r.extentsClose.minZ); break; case 1: chkcell = new IntVec3(r.extentsClose.maxX, 0, r.extentsClose.maxZ); break; } //if (chkcell.GetRegion(map) == r) if (regions.GetRegionAt_NoRebuild_InvalidAllowed(chkcell) == r) // * More direct check { var scaleToCell = (float)(chkcell - billGiver.Position).LengthHorizontalSquared; var scaleSearchRadius = (float)(bill.ingredientSearchRadius * bill.ingredientSearchRadius); if (Controller.Settings.UseRadiusLimit) { var RadiusLimit = (float)Controller.Settings.RadiusLimit; var scaleLimit = RadiusLimit * RadiusLimit; if (scaleLimit < scaleSearchRadius) { scaleSearchRadius = scaleLimit; } } if (scaleToCell <= scaleSearchRadius) { return(true); } } } } } return(false); }
public bool CanReach(IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams) { if (this.working) { Log.ErrorOnce("Called ReachableBetween while working. This should never happen. Suppressing further errors.", 7312233); 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 })); 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) { 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) { 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) { this.FinalizeCheck(); result = false; } else { if (this.startingRegions.Any <Region>() && this.destRegions.Any <Region>()) { 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) { 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); }
private static bool CheckCellBasedReachability( IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams, RegionGrid regionGrid, Reachability __instance, List <Region> this_startingRegions, ReachabilityCache this_cache, List <Region> this_destRegions) { IntVec3 foundCell = IntVec3.Invalid; Region[] directRegionGrid = regionGrid.DirectGrid; PathGrid pathGrid = map(__instance).pathGrid; CellIndices cellIndices = map(__instance).cellIndices; map(__instance).floodFiller.FloodFill(start, (Predicate <IntVec3>)(c => { int index = cellIndices.CellToIndex(c); if ((traverseParams.mode == TraverseMode.PassAllDestroyableThingsNotWater || traverseParams.mode == TraverseMode.NoPassClosedDoorsOrWater) && c.GetTerrain(map(__instance)).IsWater) { return(false); } if (traverseParams.mode == TraverseMode.PassAllDestroyableThings || traverseParams.mode == TraverseMode.PassAllDestroyableThingsNotWater) { if (!pathGrid.WalkableFast(index)) { Building edifice = c.GetEdifice(map(__instance)); if (edifice == null || !PathFinder.IsDestroyable((Thing)edifice)) { return(false); } } } else if (traverseParams.mode != TraverseMode.NoPassClosedDoorsOrWater) { Log.ErrorOnce("Do not use this method for non-cell based modes!", 938476762, false); if (!pathGrid.WalkableFast(index)) { return(false); } } Region region = directRegionGrid[index]; return(region == null || region.Allows(traverseParams, false)); }), (Func <IntVec3, bool>)(c => { if (!ReachabilityImmediate.CanReachImmediate(c, dest, map(__instance), peMode, traverseParams.pawn)) { return(false); } foundCell = c; return(true); }), int.MaxValue, false, (IEnumerable <IntVec3>)null); if (foundCell.IsValid) { if (CanUseCache(traverseParams.mode)) { Region validRegionAt = regionGrid.GetValidRegionAt(foundCell); if (validRegionAt != null) { for (int index = 0; index < this_startingRegions.Count; ++index) { this_cache.AddCachedResult(this_startingRegions[index].Room, validRegionAt.Room, traverseParams, true); } } } return(true); } if (CanUseCache(traverseParams.mode)) { for (int index1 = 0; index1 < this_startingRegions.Count; ++index1) { for (int index2 = 0; index2 < this_destRegions.Count; ++index2) { this_cache.AddCachedResult(this_startingRegions[index1].Room, this_destRegions[index2].Room, traverseParams, false); } } } return(false); }
public static bool CanReach(Reachability __instance, ref bool __result, IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams) { /* * if (working) * { * Log.ErrorOnce("Called CanReach() while working. This should never happen. Suppressing further errors.", 7312233); * return false; * } */ Map this_map = map(__instance); if (traverseParams.pawn != null) { if (!traverseParams.pawn.Spawned) { __result = false; return(false); } if (traverseParams.pawn.Map != this_map) { Log.Error("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=" + (object)traverseParams.pawn + " pawn.Map=" + (object)traverseParams.pawn.Map + " map=" + (object)map(__instance), false); __result = false; return(false); } } if (ReachabilityImmediate.CanReachImmediate(start, dest, this_map, peMode, traverseParams.pawn)) { __result = true; return(false); } if (!dest.IsValid || dest.HasThing && dest.Thing.Map != this_map || (!start.InBounds(this_map) || !dest.Cell.InBounds(this_map))) { __result = false; 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)) { __result = true; return(false); } } if (traverseParams.mode == TraverseMode.PassAllDestroyableThings) { TraverseParms traverseParams1 = traverseParams; traverseParams1.mode = TraverseMode.PassDoors; if (__instance.CanReach(start, dest, peMode, traverseParams1)) { __result = true; return(false); } } dest = (LocalTargetInfo)GenPath.ResolvePathMode(traverseParams.pawn, dest.ToTargetInfo(this_map), ref peMode); //working = true; try { uint this_reachedIndex; //Replaced reachedIndex lock (reachedIndexLock) //Added { this_reachedIndex = offsetReachedIndex; //Added offsetReachedIndex += 100000; //Added } HashSet <Region> regionsReached = new HashSet <Region>(); //Added PathGrid pathGrid = this_map.pathGrid; //Replaced pathGrid RegionGrid regionGrid = this_map.regionGrid; //Replaced regionGrid ++this_reachedIndex; //Replaced reachedIndex //this_destRegions.Clear(); List <Region> this_destRegions = new List <Region>(); //Replaced destRegions switch (peMode) { case PathEndMode.OnCell: Region region = dest.Cell.GetRegion(this_map, RegionType.Set_Passable); if (region != null && region.Allows(traverseParams, true)) { this_destRegions.Add(region); break; } break; case PathEndMode.Touch: TouchPathEndModeUtility.AddAllowedAdjacentRegions(dest, traverseParams, this_map, this_destRegions); break; } if (this_destRegions.Count == 0 && traverseParams.mode != TraverseMode.PassAllDestroyableThings && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater) { //this.FinalizeCheck(); __result = false; return(false); } this_destRegions.RemoveDuplicates <Region>(); //this_openQueue.Clear(); Queue <Region> this_openQueue = new Queue <Region>(); //Replaced openQueue int this_numRegionsOpened = 0; //Replaced numRegionsOpened List <Region> this_startingRegions = new List <Region>(); DetermineStartRegions2(__instance, start, this_startingRegions, pathGrid, regionGrid, this_reachedIndex, this_openQueue, ref this_numRegionsOpened, regionsReached); if (this_openQueue.Count == 0 && traverseParams.mode != TraverseMode.PassAllDestroyableThings && traverseParams.mode != TraverseMode.PassAllDestroyableThingsNotWater) { //this.FinalizeCheck(); __result = false; return(false); } ReachabilityCache this_cache = cache(__instance); if (this_startingRegions.Any <Region>() && this_destRegions.Any <Region>() && CanUseCache(traverseParams.mode)) { switch (GetCachedResult2(traverseParams, this_startingRegions, this_destRegions, this_cache)) { case BoolUnknown.True: //this.FinalizeCheck(); __result = true; return(false); case BoolUnknown.False: //this.FinalizeCheck(); __result = false; return(false); } } if (traverseParams.mode == TraverseMode.PassAllDestroyableThings || traverseParams.mode == TraverseMode.PassAllDestroyableThingsNotWater || traverseParams.mode == TraverseMode.NoPassClosedDoorsOrWater) { int num = CheckCellBasedReachability(start, dest, peMode, traverseParams, regionGrid, __instance, this_startingRegions, this_cache, this_destRegions ) ? 1 : 0; //this.FinalizeCheck(); __result = num != 0; return(false); } int num1 = CheckRegionBasedReachability(traverseParams, this_openQueue, this_reachedIndex, this_destRegions, this_startingRegions, this_cache, ref this_numRegionsOpened, regionsReached ) ? 1 : 0; //this.FinalizeCheck(); __result = num1 != 0; return(false); } finally { } }