public HRegion Extract(HImage image)
{
HRegion region;
if (RegionExtractor != null)
{
region = RegionExtractor.Extract(image);
}
else
{
region = image.GetDomain();
}
HRegion processedRegion;
if (RegionProcessor != null)
{
processedRegion = RegionProcessor.Process(region);
region.Dispose();
}
else
{
processedRegion = region;
}
return(processedRegion);
}
public void BreadthFirstTraverse(
Region root,
RegionEntryPredicate entryCondition,
RegionProcessor regionProcessor,
int maxRegions = 999999,
RegionType traversableRegionTypes = RegionType.Set_Passable)
{
if (freeWorkers.Count == 0)
{
Log.Error("No free workers for breadth-first traversal. Either BFS recurred deeper than " + (object)NumWorkers + ", or a bug has put this system in an inconsistent state. Resetting.", false);
}
else if (root == null)
{
Log.Error("BreadthFirstTraverse with null root region.", false);
}
else
{
BFSWorker_Patch bfsWorker = freeWorkers.Dequeue();
try
{
bfsWorker.BreadthFirstTraverseWork(root, entryCondition, regionProcessor, maxRegions, traversableRegionTypes);
}
catch (Exception ex)
{
Log.Error("Exception in BreadthFirstTraverse: " + ex.ToString(), false);
}
finally
{
bfsWorker.Clear();
freeWorkers.Enqueue(bfsWorker);
}
}
}
public static bool WithinRegions(this IntVec3 A, IntVec3 B, Map map, int regionLookCount, TraverseParms traverseParams, RegionType traversableRegionTypes = RegionType.Set_Passable)
{
Region region = A.GetRegion(map, traversableRegionTypes);
if (region == null)
{
return(false);
}
Region regB = B.GetRegion(map, traversableRegionTypes);
if (regB == null)
{
return(false);
}
if (region == regB)
{
return(true);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, isDestination: false);
bool found = false;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r == regB)
{
found = true;
return(true);
}
return(false);
};
BreadthFirstTraverse(region, entryCondition, regionProcessor, regionLookCount, traversableRegionTypes);
return(found);
}
private static Region ClosestRegionWithinTemperatureRange(IntVec3 root, Map map, FloatRange tempRange, TraverseParms traverseParms, RegionType traversableRegionTypes = RegionType.Set_Passable)
{
Region region = root.GetRegion(map, traversableRegionTypes);
if (region == null)
{
return(null);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, false);
Region foundReg = null;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r.IsDoorway)
{
return(false);
}
if (tempRange.Includes(r.Room.Temperature))
{
foundReg = r;
return(true);
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999, traversableRegionTypes);
return(foundReg);
}
public static Room FloodAndSetRooms(Region root, Map map, Room existingRoom)
{
Room floodingRoom;
if (existingRoom == null)
{
floodingRoom = Room.MakeNew(map);
}
else
{
floodingRoom = existingRoom;
}
root.Room = floodingRoom;
if (!root.type.AllowsMultipleRegionsPerRoom())
{
return(floodingRoom);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.type == root.type && r.Room != floodingRoom;
RegionProcessor regionProcessor = delegate(Region r)
{
r.Room = floodingRoom;
return(false);
};
BreadthFirstTraverse(root, entryCondition, regionProcessor, 999999, RegionType.Set_All);
return(floodingRoom);
}
private static Region ClosestRegionWithinTemperatureRange(IntVec3 root, Map map, TraverseParms traverseParms, RegionType traversableRegionTypes = RegionType.Set_Passable)
{
Region region = root.GetRegion(map, traversableRegionTypes);
MapComp_Noise mapComp = map.GetComponent <MapComp_Noise>();
if (region == null || mapComp == null)
{
return(null);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, false);
Region foundReg = null;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r.IsDoorway)
{
return(false);
}
if (NoiseUtility.IsSilentEnough(region))
{
foundReg = r;
return(true);
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999, traversableRegionTypes);
return(foundReg);
}
public HRegion Extract(HImage image)
{
var region = image.GetDomain();
var modDomain = RegionProcessor.Process(region);
region.Dispose();
return(modDomain);
}
public bool CanReachMapEdge(IntVec3 c, TraverseParms traverseParms)
{
if (traverseParms.pawn != null)
{
if (!traverseParms.pawn.Spawned)
{
return(false);
}
if (traverseParms.pawn.Map != this.map)
{
Log.Error(string.Concat(new object[]
{
"Called CanReachMapEdge() 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=",
traverseParms.pawn,
" pawn.Map=",
traverseParms.pawn.Map,
" map=",
this.map
}), false);
return(false);
}
}
Region region = c.GetRegion(this.map, RegionType.Set_Passable);
bool result;
if (region == null)
{
result = false;
}
else if (region.Room.TouchesMapEdge)
{
result = true;
}
else
{
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, false);
bool foundReg = false;
RegionProcessor regionProcessor = delegate(Region r)
{
bool result2;
if (r.Room.TouchesMapEdge)
{
foundReg = true;
result2 = true;
}
else
{
result2 = false;
}
return(result2);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999, RegionType.Set_Passable);
result = foundReg;
}
return(result);
}
public void BreadthFirstTraverseWork(
Region root,
RegionEntryPredicate entryCondition,
RegionProcessor regionProcessor,
int maxRegions,
RegionType traversableRegionTypes)
{
if ((root.type & traversableRegionTypes) == RegionType.None)
{
return;
}
++this.closedIndex;
this.open.Clear();
this.numRegionsProcessed = 0;
this.QueueNewOpenRegion(root);
while (this.open.Count > 0)
{
Region region1 = this.open.Dequeue();
if (DebugViewSettings.drawRegionTraversal)
{
region1.Debug_Notify_Traversed();
}
if (regionProcessor != null && regionProcessor(region1))
{
this.FinalizeSearch();
return;
}
if (!region1.IsDoorway)
{
++this.numRegionsProcessed;
}
if (this.numRegionsProcessed >= maxRegions)
{
this.FinalizeSearch();
return;
}
for (int index1 = 0; index1 < region1.links.Count; ++index1)
{
RegionLink link = region1.links[index1];
for (int index2 = 0; index2 < 2; ++index2)
{
Region region2 = link.regions[index2];
if (null != region2 && regionTraverser.regionClosedIndex.ContainsKey(region2) == false)
{
regionTraverser.regionClosedIndex.Add(region2, new uint[8]);
}
if (region2 != null && (int)regionTraverser.regionClosedIndex[region2][this.closedArrayPos] != (int)this.closedIndex && (region2.type & traversableRegionTypes) != RegionType.None && (entryCondition == null || entryCondition(region1, region2)))
{
this.QueueNewOpenRegion(region2);
}
}
}
}
this.FinalizeSearch();
}
public static Thing RegionwiseBFSWorker(IntVec3 root, Map map, ThingRequest req, PathEndMode peMode, TraverseParms traverseParams, Predicate <Thing> validator, Func <Thing, float> priorityGetter, int minRegions, int maxRegions, float maxDistance, RegionType traversableRegionTypes = RegionType.Set_Passable, bool ignoreEntirelyForbiddenRegions = false)
{
if (traverseParams.mode == TraverseMode.PassAllDestroyableThings)
{
Log.Error("RegionwiseBFSWorker with traverseParams.mode PassAllDestroyableThings. Use ClosestThingGlobal.");
return(null);
}
Region region = root.GetRegion(map, traversableRegionTypes);
if (region == null)
{
return(null);
}
float maxDistSquared = maxDistance * maxDistance;
RegionEntryPredicate entryCondition = (Region from, Region to) => to.Allows(traverseParams, false) && (maxDistance > 5000f || to.extentsClose.ClosestDistSquaredTo(root) < maxDistSquared);
Thing closestThing = null;
float closestDistSquared = 9999999f;
float bestPrio = -3.40282347E+38f;
int regionsSeen = 0;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r.portal == null && !r.Allows(traverseParams, true))
{
return(false);
}
if (!ignoreEntirelyForbiddenRegions || !r.IsForbiddenEntirely(traverseParams.pawn))
{
List <Thing> list = r.ListerThings.ThingsMatching(req);
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (ReachabilityWithinRegion.ThingFromRegionListerReachable(thing, r, peMode, traverseParams.pawn))
{
float num = (priorityGetter == null) ? 0f : priorityGetter(thing);
if (num >= bestPrio)
{
float num2 = (float)(thing.Position - root).LengthHorizontalSquared;
if ((num > bestPrio || num2 < closestDistSquared) && num2 < maxDistSquared && (validator == null || validator(thing)))
{
closestThing = thing;
closestDistSquared = num2;
bestPrio = num;
}
}
}
}
}
regionsSeen++;
return(regionsSeen >= minRegions && closestThing != null);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, maxRegions, traversableRegionTypes);
return(closestThing);
}
private static List <Thing> FindAllFuel(Pawn pawn, Thing refuelable)
{
int quantity = refuelable.TryGetComp <CompFilteredRefuelable>().GetFuelCountToFullyRefuel();
ThingFilter filter = refuelable.TryGetComp <CompFilteredRefuelable>().FuelFilter;
Predicate <Thing> validator = (Thing x) => !x.IsForbidden(pawn) && pawn.CanReserve(x, 1, -1, null, false) && filter.Allows(x);
IntVec3 position = refuelable.Position;
Region region = position.GetRegion(pawn.Map, RegionType.Set_Passable);
TraverseParms traverseParams = TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false);
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, false);
List <Thing> chosenThings = new List <Thing>();
int accumulatedQuantity = 0;
RegionProcessor regionProcessor = delegate(Region r)
{
List <Thing> list = r.ListerThings.ThingsMatching(ThingRequest.ForGroup(ThingRequestGroup.HaulableEver));
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
bool flag2 = validator(thing);
if (flag2)
{
bool flag3 = !chosenThings.Contains(thing);
if (flag3)
{
bool flag4 = ReachabilityWithinRegion.ThingFromRegionListerReachable(thing, r, PathEndMode.ClosestTouch, pawn);
if (flag4)
{
chosenThings.Add(thing);
accumulatedQuantity += thing.stackCount;
bool flag5 = accumulatedQuantity >= quantity;
if (flag5)
{
return(true);
}
}
}
}
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 99999, RegionType.Set_Passable);
bool flag = accumulatedQuantity >= quantity;
List <Thing> result;
if (flag)
{
result = chosenThings;
}
else
{
result = null;
}
return(result);
}
public bool CanReachUnfogged(IntVec3 c, TraverseParms traverseParms)
{
if (traverseParms.pawn != null)
{
if (!traverseParms.pawn.Spawned)
{
return(false);
}
if (traverseParms.pawn.Map != this.map)
{
Log.Error(string.Concat(new object[]
{
"Called CanReachUnfogged() 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=",
traverseParms.pawn,
" pawn.Map=",
traverseParms.pawn.Map,
" map=",
this.map
}));
return(false);
}
}
if (!c.InBounds(this.map))
{
return(false);
}
if (!c.Fogged(this.map))
{
return(true);
}
Region region = c.GetRegion(this.map, RegionType.Set_Passable);
if (region == null)
{
return(false);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, false);
bool foundReg = false;
RegionProcessor regionProcessor = delegate(Region r)
{
if (!r.AnyCell.Fogged(this.map))
{
foundReg = true;
return(true);
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999, RegionType.Set_Passable);
return(foundReg);
}
public static void FloodAndSetNewRegionIndex(Region root, int newRegionGroupIndex)
{
root.newRegionGroupIndex = newRegionGroupIndex;
if (root.type.AllowsMultipleRegionsPerRoom())
{
RegionEntryPredicate entryCondition = (Region from, Region r) => r.type == root.type && r.newRegionGroupIndex < 0;
RegionProcessor regionProcessor = delegate(Region r)
{
r.newRegionGroupIndex = newRegionGroupIndex;
return(false);
};
BreadthFirstTraverse(root, entryCondition, regionProcessor, 999999, RegionType.Set_All);
}
}
private async Task <MonochromeCell[, ]> ConvertColorRegionsIntoGridData(ColorRegion[,] regions, ImageGridBuilder builder)
{
RegionProcessor regionProcessor = null;
var initProcessorTask = Task.Run(() =>
regionProcessor = new RegionProcessor(builder.ColorStats));
await initProcessorTask;
MonochromeCell[,] gridData = null;
var buildCellsTask = Task.Run(() =>
gridData = regionProcessor.BuildMonochromeCells(regions));
await buildCellsTask;
return(gridData);
}
private static List <Thing> FindAllFuel(Pawn pawn, Thing refuelable)
{
int quantity = refuelable.TryGetComp <CompRefuelable>().GetFuelCountToFullyRefuel();
ThingFilter filter = refuelable.TryGetComp <CompRefuelable>().Props.fuelFilter;
Predicate <Thing> validator = delegate(Thing x)
{
if (x.IsForbidden(pawn) || !pawn.CanReserve(x))
{
return(false);
}
if (!filter.Allows(x))
{
return(false);
}
return(true);
};
IntVec3 position = refuelable.Position;
Region region = position.GetRegion(pawn.Map);
TraverseParms traverseParams = TraverseParms.For(pawn);
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, isDestination: false);
List <Thing> chosenThings = new List <Thing>();
int accumulatedQuantity = 0;
RegionProcessor regionProcessor = delegate(Region r)
{
List <Thing> list = r.ListerThings.ThingsMatching(ThingRequest.ForGroup(ThingRequestGroup.HaulableEver));
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (validator(thing) && !chosenThings.Contains(thing) && ReachabilityWithinRegion.ThingFromRegionListerReachable(thing, r, PathEndMode.ClosestTouch, pawn))
{
chosenThings.Add(thing);
accumulatedQuantity += thing.stackCount;
if (accumulatedQuantity >= quantity)
{
return(true);
}
}
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 99999);
if (accumulatedQuantity >= quantity)
{
return(chosenThings);
}
return(null);
}
public void BreadthFirstTraverse(
IntVec3 start,
Map map,
RegionEntryPredicate entryCondition,
RegionProcessor regionProcessor,
int maxRegions = 999999,
RegionType traversableRegionTypes = RegionType.Set_Passable)
{
Region region = start.GetRegion(map, traversableRegionTypes);
if (region == null)
{
return;
}
BreadthFirstTraverse(region, entryCondition, regionProcessor, maxRegions, traversableRegionTypes);
}
private static List <Thing> FindAllFuel(Pawn pawn, Thing refuelable)
{
CompRefuelable comp = refuelable.TryGetComp <CompRefuelable>();
int quantity = GetFuelCountToFullyRefuel(comp);
ThingFilter filter = new ThingFilter();
filter = refuelable.TryGetComp <CompSelectFuel>().FuelSettings.filter;
Predicate <Thing> validator = (Thing x) => !x.IsForbidden(pawn) && pawn.CanReserve(x, 1, -1, null, false) && filter.Allows(x);
IntVec3 position = refuelable.Position;
Region region = position.GetRegion(pawn.Map, RegionType.Set_Passable); // NOTE: comes out null if refuelable is inside a wall, even with matching RegionType. Why?
TraverseParms traverseParams = TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false);
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, false);
List <Thing> chosenThings = new List <Thing>();
int accumulatedQuantity = 0;
RegionProcessor regionProcessor = delegate(Region r)
{
List <Thing> list = r.ListerThings.ThingsMatching(ThingRequest.ForGroup(ThingRequestGroup.HaulableEver));
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (validator(thing))
{
if (!chosenThings.Contains(thing))
{
if (ReachabilityWithinRegion.ThingFromRegionListerReachable(thing, r, PathEndMode.ClosestTouch, pawn))
{
chosenThings.Add(thing);
accumulatedQuantity += thing.stackCount;
if (accumulatedQuantity >= quantity)
{
return(true);
}
}
}
}
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 99999, RegionType.Set_Passable);
if (accumulatedQuantity >= quantity)
{
return(chosenThings);
}
return(null);
}
protected override Job TryGiveJob(Pawn pawn)
{
if (!pawn.Position.IsForbidden(pawn))
{
return(null);
}
if (this.HasJobWithSpawnedAllowedTarget(pawn))
{
return(null);
}
Region region = pawn.GetRegion(RegionType.Set_Passable);
if (region == null)
{
return(null);
}
TraverseParms traverseParms = TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false);
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, false);
Region reg = null;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r.portal != null)
{
return(false);
}
if (!r.IsForbiddenEntirely(pawn))
{
reg = r;
return(true);
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999, RegionType.Set_Passable);
if (reg == null)
{
return(null);
}
IntVec3 c;
if (!reg.TryFindRandomCellInRegionUnforbidden(pawn, null, out c))
{
return(null);
}
return(new Job(JobDefOf.Goto, c));
}
public static bool BreadthFirstTraverse(
Region root,
RegionEntryPredicate entryCondition,
RegionProcessor regionProcessor,
int maxRegions = 999999,
RegionType traversableRegionTypes = RegionType.Set_Passable)
{
RegionTraverser2 regionTraverser;
int t = Thread.CurrentThread.ManagedThreadId;
lock (regionTraverser2Dict)
{
if (!regionTraverser2Dict.TryGetValue(t, out regionTraverser))
{
regionTraverser = new RegionTraverser2();
regionTraverser2Dict.Add(t, regionTraverser);
}
}
if (regionTraverser.freeWorkers.Count == 0)
{
Log.Error("No free workers for breadth-first traversal. Either BFS recurred deeper than " + regionTraverser.NumWorkers + ", or a bug has put this system in an inconsistent state. Resetting.", false);
}
else if (root == null)
{
Log.Error("BreadthFirstTraverse with null root region.", false);
}
else
{
BFSWorker_Patch bfsWorker = regionTraverser.freeWorkers.Dequeue();
try
{
bfsWorker.BreadthFirstTraverseWork(root, entryCondition, regionProcessor, maxRegions, traversableRegionTypes);
}
catch (Exception ex)
{
Log.Error("Exception in BreadthFirstTraverse: " + ex.ToString(), false);
}
finally
{
bfsWorker.Clear();
regionTraverser.freeWorkers.Enqueue(bfsWorker);
}
}
return(false);
}
protected override Job TryGiveJob(Pawn pawn)
{
if (!pawn.Position.IsForbidden(pawn))
{
return(null);
}
if (HasJobWithSpawnedAllowedTarget(pawn))
{
return(null);
}
Region region = pawn.GetRegion();
if (region == null)
{
return(null);
}
TraverseParms traverseParms = TraverseParms.For(pawn);
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, isDestination: false);
Region reg = null;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r.IsDoorway)
{
return(false);
}
if (!r.IsForbiddenEntirely(pawn))
{
reg = r;
return(true);
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999);
if (reg != null)
{
if (!reg.TryFindRandomCellInRegionUnforbidden(pawn, null, out IntVec3 result))
{
return(null);
}
return(JobMaker.MakeJob(JobDefOf.Goto, result));
}
return(null);
}
public static bool WithinRegions(this IntVec3 A, IntVec3 B, Map map, int regionLookCount, TraverseParms traverseParams, RegionType traversableRegionTypes = RegionType.Set_Passable)
{
Region region = A.GetRegion(map, traversableRegionTypes);
bool result;
if (region == null)
{
result = false;
}
else
{
Region regB = B.GetRegion(map, traversableRegionTypes);
if (regB == null)
{
result = false;
}
else if (region == regB)
{
result = true;
}
else
{
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, false);
bool found = false;
RegionProcessor regionProcessor = delegate(Region r)
{
bool result2;
if (r == regB)
{
found = true;
result2 = true;
}
else
{
result2 = false;
}
return(result2);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, regionLookCount, traversableRegionTypes);
result = found;
}
}
return(result);
}
public bool CanReachUnfogged(IntVec3 c, TraverseParms traverseParms)
{
if (traverseParms.pawn != null)
{
if (!traverseParms.pawn.Spawned)
{
return(false);
}
if (traverseParms.pawn.Map != map)
{
Log.Error("Called CanReachUnfogged() 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=" + traverseParms.pawn + " pawn.Map=" + traverseParms.pawn.Map + " map=" + map);
return(false);
}
}
if (!c.InBounds(map))
{
return(false);
}
if (!c.Fogged(map))
{
return(true);
}
Region region = c.GetRegion(map);
if (region == null)
{
return(false);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, isDestination: false);
bool foundReg = false;
RegionProcessor regionProcessor = delegate(Region r)
{
if (!r.AnyCell.Fogged(map))
{
foundReg = true;
return(true);
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999);
return(foundReg);
}
public Room FloodAndSetRooms(Region root, Map map, Room existingRoom)
{
Room floodingRoom = existingRoom != null ? existingRoom : Room.MakeNew(map);
root.Room = floodingRoom;
if (!root.type.AllowsMultipleRegionsPerRoom())
{
return(floodingRoom);
}
RegionEntryPredicate entryCondition = ((from, r) => r.type == root.type && r.Room != floodingRoom);
RegionProcessor regionProcessor = (r =>
{
r.Room = floodingRoom;
return(false);
});
BreadthFirstTraverse(root, entryCondition, regionProcessor, 999999, RegionType.Set_All);
return(floodingRoom);
}
public static bool TryFindPrisonerReleaseCell(Pawn prisoner, Pawn warden, out IntVec3 result)
{
if (prisoner.Map != warden.Map)
{
result = IntVec3.Invalid;
return(false);
}
Region region = prisoner.GetRegion();
if (region == null)
{
result = default(IntVec3);
return(false);
}
TraverseParms traverseParms = TraverseParms.For(warden);
bool needMapEdge = prisoner.Faction != warden.Faction;
IntVec3 foundResult = IntVec3.Invalid;
RegionProcessor regionProcessor = delegate(Region r)
{
if (needMapEdge)
{
if (!r.Room.TouchesMapEdge)
{
return(false);
}
}
else if (r.Room.isPrisonCell)
{
return(false);
}
foundResult = r.RandomCell;
return(true);
};
RegionTraverser.BreadthFirstTraverse(region, (Region from, Region r) => r.Allows(traverseParms, isDestination: false), regionProcessor, 999);
if (foundResult.IsValid)
{
result = foundResult;
return(true);
}
result = default(IntVec3);
return(false);
}
public HRegion Extract(HImage image)
{
HImage targetFilterImage = ImageFilter != null?ImageFilter.Process(image) : image;
HRegion targetRegion = RegionExtractor != null?RegionExtractor.Extract(targetFilterImage) : targetFilterImage.GetDomain();
HRegion targetProcessedRegion = RegionProcessor != null?RegionProcessor.Process(targetRegion) : targetRegion;
if (ImageFilter != null)
{
targetFilterImage.Dispose();
}
if (RegionProcessor != null)
{
targetRegion.Dispose();
}
return(targetProcessedRegion);
}
private bool TryFindBestItem(Pawn pawn, ThingDef thingDef, int need, List <ThingCount> chosen)
{
chosen.Clear();
Region rootReg = Position.GetRegion(pawn.Map);
if (rootReg == null)
{
return(false);
}
Predicate <Thing> baseValidator = (Thing t) => t.Spawned && !t.IsForbidden(pawn) && pawn.CanReserve(t);
TraverseParms traverseParams = TraverseParms.For(pawn);
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, isDestination: false);
int adjacentRegionsAvailable = rootReg.Neighbors.Count((Region region) => entryCondition(rootReg, region));
bool found = false;
RegionProcessor regionProcessor = delegate(Region r)
{
List <Thing> list = r.ListerThings.ThingsOfDef(thingDef);
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
int count = Mathf.Min(thing.stackCount, need);
chosen.Add(new ThingCount(thing, count));
need -= count;
if (need <= 0)
{
found = true;
return(true);
}
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(rootReg, entryCondition, regionProcessor, 99999);
return(found);
}
public bool CanReachMapEdge(IntVec3 c, TraverseParms traverseParms)
{
if (traverseParms.pawn != null)
{
if (!traverseParms.pawn.Spawned)
{
return(false);
}
if (traverseParms.pawn.Map != map)
{
Log.Error(string.Concat("Called CanReachMapEdge() 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=", traverseParms.pawn, " pawn.Map=", traverseParms.pawn.Map, " map=", map));
return(false);
}
}
Region region = c.GetRegion(map);
if (region == null)
{
return(false);
}
if (region.Room.TouchesMapEdge)
{
return(true);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParms, isDestination: false);
bool foundReg = false;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r.Room.TouchesMapEdge)
{
foundReg = true;
return(true);
}
return(false);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, 9999);
return(foundReg);
}
public bool WithinRegions(
IntVec3 A,
IntVec3 B,
Map map,
int regionLookCount,
TraverseParms traverseParams,
RegionType traversableRegionTypes = RegionType.Set_Passable)
{
Region region = A.GetRegion(map, traversableRegionTypes);
if (region == null)
{
return(false);
}
Region regB = B.GetRegion(map, traversableRegionTypes);
if (regB == null)
{
return(false);
}
if (region == regB)
{
return(true);
}
RegionEntryPredicate entryCondition = ((from, r) => r.Allows(traverseParams, false));
bool found = false;
RegionProcessor regionProcessor = (r =>
{
if (r != regB)
{
return(false);
}
found = true;
return(true);
});
BreadthFirstTraverse(region, entryCondition, regionProcessor, regionLookCount, traversableRegionTypes);
return(found);
}
public static bool WithinRegions(this IntVec3 A, IntVec3 B, Map map, int regionLookCount, TraverseParms traverseParams, RegionType traversableRegionTypes = RegionType.Set_Passable)
{
if (traverseParams.mode == TraverseMode.PassAllDestroyableThings)
{
throw new ArgumentException("traverseParams (PassAllDestroyableThings not supported)");
}
Region region = A.GetRegion(map, traversableRegionTypes);
if (region == null)
{
return(false);
}
Region regB = B.GetRegion(map, traversableRegionTypes);
if (regB == null)
{
return(false);
}
if (region == regB)
{
return(true);
}
RegionEntryPredicate entryCondition = (Region from, Region r) => r.Allows(traverseParams, false);
bool found = false;
RegionProcessor regionProcessor = delegate(Region r)
{
if (r == regB)
{
found = true;
return(true);
}
return(false);
};
newRegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, regionLookCount, traversableRegionTypes);
return(found);
}
private HighCfgNode ProcessSubRegion(HighRegion region, RegionStack regionStack, bool isTry)
{
HighCfgNode cfgNode = region.EntryNode.Value;
RegionProcessor processor = new RegionProcessor(m_initPass, regionStack, isTry, false);
processor.QueueNode(cfgNode);
processor.Run();
return cfgNode;
}
public static Thing RegionwiseBFSWorker(IntVec3 root, Map map, ThingRequest req, PathEndMode peMode, TraverseParms traverseParams, Predicate <Thing> validator, Func <Thing, float> priorityGetter, int minRegions, int maxRegions, float maxDistance, out int regionsSeen, RegionType traversableRegionTypes = RegionType.Set_Passable, bool ignoreEntirelyForbiddenRegions = false)
{
regionsSeen = 0;
if (traverseParams.mode == TraverseMode.PassAllDestroyableThings)
{
Log.Error("RegionwiseBFSWorker with traverseParams.mode PassAllDestroyableThings. Use ClosestThingGlobal.");
return(null);
}
if (traverseParams.mode == TraverseMode.PassAllDestroyableThingsNotWater)
{
Log.Error("RegionwiseBFSWorker with traverseParams.mode PassAllDestroyableThingsNotWater. Use ClosestThingGlobal.");
return(null);
}
if (!req.IsUndefined && !req.CanBeFoundInRegion)
{
Log.ErrorOnce(string.Concat("RegionwiseBFSWorker with thing request group ", req.group, ". This group is never stored in regions. Most likely a global search should have been used."), 385766189);
return(null);
}
Region region = root.GetRegion(map, traversableRegionTypes);
if (region == null)
{
return(null);
}
float maxDistSquared = maxDistance * maxDistance;
RegionEntryPredicate entryCondition = delegate(Region from, Region to)
{
if (!to.Allows(traverseParams, isDestination: false))
{
return(false);
}
return(maxDistance > 5000f || to.extentsClose.ClosestDistSquaredTo(root) < maxDistSquared);
};
Thing closestThing = null;
float closestDistSquared = 9999999f;
float bestPrio = float.MinValue;
int regionsSeenScan = 0;
RegionProcessor regionProcessor = delegate(Region r)
{
if (RegionTraverser.ShouldCountRegion(r))
{
regionsSeenScan++;
}
if (!r.IsDoorway && !r.Allows(traverseParams, isDestination: true))
{
return(false);
}
if (!ignoreEntirelyForbiddenRegions || !r.IsForbiddenEntirely(traverseParams.pawn))
{
List <Thing> list = r.ListerThings.ThingsMatching(req);
for (int i = 0; i < list.Count; i++)
{
Thing thing = list[i];
if (ReachabilityWithinRegion.ThingFromRegionListerReachable(thing, r, peMode, traverseParams.pawn))
{
float num = ((priorityGetter != null) ? priorityGetter(thing) : 0f);
if (!(num < bestPrio))
{
float num2 = (thing.Position - root).LengthHorizontalSquared;
if ((num > bestPrio || num2 < closestDistSquared) && num2 < maxDistSquared && (validator == null || validator(thing)))
{
closestThing = thing;
closestDistSquared = num2;
bestPrio = num;
}
}
}
}
}
return(regionsSeenScan >= minRegions && closestThing != null);
};
RegionTraverser.BreadthFirstTraverse(region, entryCondition, regionProcessor, maxRegions, traversableRegionTypes);
regionsSeen = regionsSeenScan;
return(closestThing);
}
public void Run()
{
RegionProcessor processor = new RegionProcessor(this, null, false, m_methodBody.ReturnType is TypeSpecVoidTag);
processor.QueueNode(m_methodBody.EntryRegion.EntryNode.Value);
processor.Run();
}
