private static void RegenerateNewRegionsFromDirtyCells2(RegionAndRoomUpdater __instance)
{
newRegions(__instance).Clear(); //already cleared at end of method TryRebuildDirtyRegionsAndRooms()
//List<IntVec3> dirtyCells = map(__instance).regionDirtyer.DirtyCells;
Map localMap = map(__instance);
RegionDirtyer regionDirtyer = localMap.regionDirtyer;
ConcurrentQueue <IntVec3> dirtyCells = RegionDirtyer_Patch.get_DirtyCells(regionDirtyer);
//HashSet<IntVec3> oldDirtyCells = getOldDirtyCells(__instance);
while (dirtyCells.TryDequeue(out IntVec3 dirtyCell))
{
if (dirtyCell.GetRegion(localMap, RegionType.Set_All) == null)
{
Region region;
lock (regionMakerLock) //TODO OPTIMIZE for multithreading
{
region = localMap.regionMaker.TryGenerateRegionFrom(dirtyCell);
}
//Region region = regionTryGenerateRegionFrom2(map(__instance).regionMaker, intVec);
if (region != null)
{
//lock (newRegions(__instance))
//{
newRegions(__instance).Add(region);
//}
}
}
//oldDirtyCells.Add(dirtyCell);
localMap.temperatureCache.ResetCachedCellInfo(dirtyCell);
}
}
public static bool Notify_WalkabilityChanged(RegionDirtyer __instance, IntVec3 c)
{
List <Region> regionsToDirty = new List <Region>();
//regionsToDirty.Clear();
for (int i = 0; i < 9; i++)
{
IntVec3 c2 = c + GenAdj.AdjacentCellsAndInside[i];
if (c2.InBounds(map(__instance)))
{
Region regionAt_NoRebuild_InvalidAllowed = map(__instance).regionGrid.GetRegionAt_NoRebuild_InvalidAllowed(c2);
if (regionAt_NoRebuild_InvalidAllowed != null && regionAt_NoRebuild_InvalidAllowed.valid)
{
map(__instance).temperatureCache.TryCacheRegionTempInfo(c, regionAt_NoRebuild_InvalidAllowed);
regionsToDirty.Add(regionAt_NoRebuild_InvalidAllowed);
}
}
}
for (int j = 0; j < regionsToDirty.Count; j++)
{
SetRegionDirty(__instance, regionsToDirty[j]);
}
//regionsToDirty.Clear();
ConcurrentQueue <IntVec3> dirtyCells = get_DirtyCells(__instance);
if (c.Walkable(map(__instance)) && !dirtyCells.Contains(c))
{
dirtyCells.Enqueue(c);
}
return(false);
}
public static bool SetRegionDirty(RegionDirtyer __instance, Region reg, bool addCellsToDirtyCells = true)
{
if (!reg.valid)
{
return(false);
}
reg.valid = false;
reg.Room = null;
for (int i = 0; i < reg.links.Count; i++)
{
reg.links[i].Deregister(reg);
}
reg.links.Clear();
if (!addCellsToDirtyCells)
{
return(false);
}
ConcurrentQueue <IntVec3> dirtyCells = get_DirtyCells(__instance);
foreach (IntVec3 cell in reg.Cells)
{
dirtyCells.Enqueue(cell);
if (DebugViewSettings.drawRegionDirties)
{
map(__instance).debugDrawer.FlashCell(cell);
}
}
return(false);
}
public static ConcurrentQueue <IntVec3> get_DirtyCells(RegionDirtyer __instance)
{
if (!dirtyCellsDict.TryGetValue(__instance, out ConcurrentQueue <IntVec3> dirtyCells))
{
dirtyCells = new ConcurrentQueue <IntVec3>();
lock (dirtyCellsDict)
{
dirtyCellsDict.SetOrAdd(__instance, dirtyCells);
}
}
return(dirtyCells);
}
public static bool SetAllClean(RegionDirtyer __instance)
{
ConcurrentQueue <IntVec3> dirtyCells = get_DirtyCells(__instance);
while (dirtyCells.TryDequeue(out IntVec3 dirtyCell))
{
map(__instance).temperatureCache.ResetCachedCellInfo(dirtyCell);
}
//dirtyCells.Clear();
return(false);
}
public static bool SetAllClean(RegionDirtyer __instance)
{
lock (regionDirtyerLock)
{
List <IntVec3> dirtyCells = get_DirtyCells(__instance);
foreach (IntVec3 dirtyCell in dirtyCells)
{
__instance.map.temperatureCache.ResetCachedCellInfo(dirtyCell);
}
dirtyCellsDict.SetOrAdd(__instance, new List <IntVec3>());
}
return(false);
}
public static bool SetAllClean(RegionDirtyer __instance)
{
lock (regionDirtyerLock)
{
List <IntVec3> dirtyCells = get_DirtyCells(__instance);
foreach (IntVec3 dirtyCell in dirtyCells)
{
map(__instance).temperatureCache.ResetCachedCellInfo(dirtyCell);
}
dirtyCells.Clear();
}
return(false);
}
public static bool Notify_ThingAffectingRegionsDespawned(RegionDirtyer __instance, Thing b)
{
//regionsToDirty.Clear();
List <Region> regionsToDirty = new List <Region>();
Region validRegionAt_NoRebuild = map(__instance).regionGrid.GetValidRegionAt_NoRebuild(b.Position);
if (validRegionAt_NoRebuild != null)
{
map(__instance).temperatureCache.TryCacheRegionTempInfo(b.Position, validRegionAt_NoRebuild);
regionsToDirty.Add(validRegionAt_NoRebuild);
}
foreach (IntVec3 item2 in GenAdj.CellsAdjacent8Way(b))
{
if (item2.InBounds(map(__instance)))
{
Region validRegionAt_NoRebuild2 = map(__instance).regionGrid.GetValidRegionAt_NoRebuild(item2);
if (validRegionAt_NoRebuild2 != null)
{
map(__instance).temperatureCache.TryCacheRegionTempInfo(item2, validRegionAt_NoRebuild2);
regionsToDirty.Add(validRegionAt_NoRebuild2);
}
}
}
for (int i = 0; i < regionsToDirty.Count; i++)
{
SetRegionDirty(__instance, regionsToDirty[i]);
}
regionsToDirty.Clear();
ConcurrentQueue <IntVec3> dirtyCells = get_DirtyCells(__instance);
if (b.def.size.x == 1 && b.def.size.z == 1)
{
dirtyCells.Enqueue(b.Position);
return(false);
}
CellRect cellRect = b.OccupiedRect();
for (int j = cellRect.minZ; j <= cellRect.maxZ; j++)
{
for (int k = cellRect.minX; k <= cellRect.maxX; k++)
{
IntVec3 item = new IntVec3(k, 0, j);
dirtyCells.Enqueue(item);
}
}
return(false);
}
public static List <IntVec3> get_DirtyCells(RegionDirtyer __instance)
{
List <IntVec3> dirtyCells;
lock (regionDirtyerLock)
{
if (!dirtyCellsDict.TryGetValue(__instance, out dirtyCells))
{
dirtyCells = new List <IntVec3>();
dirtyCellsDict.SetOrAdd(__instance, dirtyCells);
}
}
return(dirtyCells);
}
public static bool SetAllDirty(RegionDirtyer __instance)
{
ConcurrentQueue <IntVec3> dirtyCells = new ConcurrentQueue <IntVec3>();
foreach (IntVec3 item in map(__instance))
{
dirtyCells.Enqueue(item);
}
dirtyCellsDict.SetOrAdd(__instance, dirtyCells);
foreach (Region item2 in map(__instance).regionGrid.AllRegions_NoRebuild_InvalidAllowed)
{
SetRegionDirty(__instance, item2, addCellsToDirtyCells: false);
}
return(false);
}
public static void SetAllClean2(RegionDirtyer __instance)
{
List <IntVec3> dirtyCells = __instance.DirtyCells;
for (int i = 0; i < dirtyCells.Count; i++)
{
IntVec3 dirtyCell;
try
{
dirtyCell = dirtyCells[i];
}
catch (ArgumentOutOfRangeException) { break; }
maprd(__instance).temperatureCache.ResetCachedCellInfo(dirtyCell);
}
dirtyCells.Clear();
}
public static bool SetAllDirty(RegionDirtyer __instance)
{
lock (regionDirtyerLock)
{
List <IntVec3> dirtyCells = new List <IntVec3>();
foreach (IntVec3 item in __instance.map)
{
dirtyCells.Add(item);
}
dirtyCellsDict.SetOrAdd(__instance, dirtyCells);
foreach (Region item2 in __instance.map.regionGrid.AllRegions_NoRebuild_InvalidAllowed)
{
SetRegionDirty(__instance, item2, addCellsToDirtyCells: false);
}
}
return(false);
}
public static bool SetRegionDirty(RegionDirtyer __instance, Region reg, bool addCellsToDirtyCells = true)
{
lock (regionDirtyerLock)
{
if (!reg.valid)
{
return(false);
}
reg.valid = false;
#if RW12
reg.Room = null;
#endif
#if RW13
reg.District = null;
#endif
List <RegionLink> links = reg.links;
for (int i = 0; i < links.Count; i++)
{
links[i].Deregister(reg);
}
reg.links = new List <RegionLink>();
if (!addCellsToDirtyCells)
{
return(false);
}
List <IntVec3> dirtyCells = get_DirtyCells(__instance);
foreach (IntVec3 cell in reg.Cells)
{
//RegionAndRoomUpdater_Patch.cellsWithNewRegions.Remove(cell);
dirtyCells.Add(cell);
if (DebugViewSettings.drawRegionDirties)
{
__instance.map.debugDrawer.FlashCell(cell);
}
}
}
return(false);
}
public static bool Notify_WalkabilityChanged(RegionDirtyer __instance, IntVec3 c)
{
lock (regionDirtyerLock)
{
regionsToDirty.Clear();
for (int i = 0; i < 9; i++)
{
IntVec3 c2 = c + GenAdj.AdjacentCellsAndInside[i];
if (c2.InBounds(__instance.map))
{
Region regionAt_NoRebuild_InvalidAllowed = __instance.map.regionGrid.GetRegionAt_NoRebuild_InvalidAllowed(c2);
if (regionAt_NoRebuild_InvalidAllowed != null && regionAt_NoRebuild_InvalidAllowed.valid)
{
__instance.map.temperatureCache.TryCacheRegionTempInfo(c, regionAt_NoRebuild_InvalidAllowed);
regionsToDirty.Add(regionAt_NoRebuild_InvalidAllowed);
}
}
}
for (int j = 0; j < regionsToDirty.Count; j++)
{
SetRegionDirty(__instance, regionsToDirty[j]);
}
//regionsToDirty.Clear();
List <IntVec3> dirtyCells = get_DirtyCells(__instance);
if (c.Walkable(__instance.map))
{
lock (regionDirtyerLock)
{
if (!dirtyCells.Contains(c))
{
dirtyCells.Add(c);
}
}
}
}
return(false);
}
public static bool Notify_ThingAffectingRegionsSpawned(RegionDirtyer __instance, Thing b)
{
lock (regionDirtyerLock)
{
regionsToDirty.Clear();
foreach (IntVec3 item in b.OccupiedRect().ExpandedBy(1).ClipInsideMap(b.Map))
{
Region validRegionAt_NoRebuild = b.Map.regionGrid.GetValidRegionAt_NoRebuild(item);
if (validRegionAt_NoRebuild != null)
{
b.Map.temperatureCache.TryCacheRegionTempInfo(item, validRegionAt_NoRebuild);
regionsToDirty.Add(validRegionAt_NoRebuild);
}
}
for (int i = 0; i < regionsToDirty.Count; i++)
{
SetRegionDirty(__instance, regionsToDirty[i]);
}
}
return(false);
}
public static void SetAllClean2(RegionDirtyer __instance)
{
ConcurrentQueue <IntVec3> dirtyCells = RegionDirtyer_Patch.get_DirtyCells(__instance);
while (dirtyCells.TryDequeue(out IntVec3 dirtyCell))
{
//IntVec3 dirtyCell;
//try
//{
//dirtyCell = dirtyCells[i];
//}
//catch(ArgumentOutOfRangeException) { break; }
maprd(__instance).temperatureCache.ResetCachedCellInfo(dirtyCell);
}
//dirtyCells.Clear();
dirtyCells = new ConcurrentQueue <IntVec3>();
lock (RegionDirtyer_Patch.dirtyCellsDict)
{
RegionDirtyer_Patch.dirtyCellsDict.SetOrAdd(__instance, dirtyCells);
}
}
