private static void RegenerateNewRegionsFromDirtyCells2(RegionAndRoomUpdater __instance)
{
newRegions(__instance).Clear();
List <IntVec3> dirtyCells = map(__instance).regionDirtyer.DirtyCells;
for (int i = 0; i < dirtyCells.Count; i++)
{
IntVec3 intVec;
try
{
intVec = dirtyCells[i];
} catch (ArgumentOutOfRangeException)
{
break;
}
if (intVec.GetRegion(map(__instance), RegionType.Set_All) == null)
{
Region region = map(__instance).regionMaker.TryGenerateRegionFrom(intVec);
//Region region = regionTryGenerateRegionFrom2(map(__instance).regionMaker, intVec);
if (region != null)
{
newRegions(__instance).Add(region);
}
}
}
}
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 FloodAndSetRoomGroups(RegionAndRoomUpdater __instance, Room start, RoomGroup roomGroup)
{
//this.tmpRoomStack.Clear();
Stack <Room> tmpRoomStack = new Stack <Room>();
tmpRoomStack.Push(start);
//this.tmpVisitedRooms.Clear();
HashSet <Room> tmpVisitedRooms = new HashSet <Room>();
tmpVisitedRooms.Add(start);
while (tmpRoomStack.Count != 0)
{
Room a = tmpRoomStack.Pop();
a.Group = roomGroup;
foreach (Room neighbor in a.Neighbors)
{
if (!tmpVisitedRooms.Contains(neighbor) && ShouldBeInTheSameRoomGroup(a, neighbor))
{
tmpRoomStack.Push(neighbor);
tmpVisitedRooms.Add(neighbor);
}
}
}
//this.tmpVisitedRooms.Clear();
//this.tmpRoomStack.Clear();
return(false);
}
public static bool FloodAndSetRoomGroups(RegionAndRoomUpdater __instance, Room start, RoomGroup roomGroup)
{
if (tmpRoomStack == null)
{
tmpRoomStack = new Stack <Room>();
}
else
{
tmpRoomStack.Clear();
}
tmpRoomStack.Push(start);
if (tmpVisitedRooms == null)
{
tmpVisitedRooms = new HashSet <Room>();
}
else
{
tmpVisitedRooms.Clear();
}
tmpVisitedRooms.Add(start);
while (tmpRoomStack.Count != 0)
{
Room room = tmpRoomStack.Pop();
room.Group = roomGroup;
foreach (Room neighbor in room.Neighbors)
{
if (!tmpVisitedRooms.Contains(neighbor) && funcShouldBeInTheSameRoomGroup(__instance, room, neighbor))
{
tmpRoomStack.Push(neighbor);
tmpVisitedRooms.Add(neighbor);
}
}
}
return(false);
}
private static void FloodAndSetRoomGroups2(RegionAndRoomUpdater __instance, Room start, RoomGroup roomGroup)
{
Stack <Room> tmpRoomStack = new Stack <Room>();
//tmpRoomStack.Clear();
tmpRoomStack.Push(start);
HashSet <Room> tmpVisitedRooms = new HashSet <Room>();
//tmpVisitedRooms.Clear();
tmpVisitedRooms.Add(start);
while (tmpRoomStack.Count != 0)
{
Room room = tmpRoomStack.Pop();
room.Group = roomGroup;
foreach (Room neighbor in room.Neighbors)
{
if (!tmpVisitedRooms.Contains(neighbor) && ShouldBeInTheSameRoomGroup(room, neighbor))
{
tmpRoomStack.Push(neighbor);
tmpVisitedRooms.Add(neighbor);
}
}
}
tmpVisitedRooms.Clear();
tmpRoomStack.Clear();
}
private static Room FindCurrentRegionGroupNeighborWithMostRegions2(RegionAndRoomUpdater __instance, out bool multipleOldNeighborRooms)
{
multipleOldNeighborRooms = false;
Room room = null;
for (int i = 0; i < currentRegionGroup(__instance).Count; i++)
{
foreach (Region item in currentRegionGroup(__instance)[i].NeighborsOfSameType)
{
if (item.Room != null && !reusedOldRooms(__instance).Contains(item.Room))
{
if (room == null)
{
room = item.Room;
}
else if (item.Room != room)
{
multipleOldNeighborRooms = true;
if (item.Room.RegionCount > room.RegionCount)
{
room = item.Room;
}
}
}
}
}
return(room);
}
private static void NotifyAffectedRoomsAndRoomGroupsAndUpdateTemperature2(RegionAndRoomUpdater __instance)
{
foreach (Room reusedOldRoom in reusedOldRooms(__instance))
{
reusedOldRoom.Notify_RoomShapeOrContainedBedsChanged();
}
for (int i = 0; i < newRooms(__instance).Count; i++)
{
newRooms(__instance)[i].Notify_RoomShapeOrContainedBedsChanged();
}
foreach (RoomGroup reusedOldRoomGroup in reusedOldRoomGroups(__instance))
{
reusedOldRoomGroup.Notify_RoomGroupShapeChanged();
}
for (int j = 0; j < newRoomGroups(__instance).Count; j++)
{
RoomGroup roomGroup = newRoomGroups(__instance)[j];
roomGroup.Notify_RoomGroupShapeChanged();
if (map(__instance).temperatureCache.TryGetAverageCachedRoomGroupTemp(roomGroup, out float result))
{
roomGroup.Temperature = result;
}
}
}
private static RoomGroup FindCurrentRoomGroupNeighborWithMostRegions2(RegionAndRoomUpdater __instance, out bool multipleOldNeighborRoomGroups)
{
multipleOldNeighborRoomGroups = false;
RoomGroup roomGroup = null;
for (int i = 0; i < currentRoomGroup(__instance).Count; i++)
{
foreach (Room neighbor in currentRoomGroup(__instance)[i].Neighbors)
{
if (neighbor.Group != null && ShouldBeInTheSameRoomGroup(currentRoomGroup(__instance)[i], neighbor) && !reusedOldRoomGroups(__instance).Contains(neighbor.Group))
{
if (roomGroup == null)
{
roomGroup = neighbor.Group;
}
else if (neighbor.Group != roomGroup)
{
multipleOldNeighborRoomGroups = true;
if (neighbor.Group.RegionCount > roomGroup.RegionCount)
{
roomGroup = neighbor.Group;
}
}
}
}
}
return(roomGroup);
}
private static void CreateOrAttachToExistingRooms2(RegionAndRoomUpdater __instance, int numRegionGroups)
{
for (int i = 0; i < numRegionGroups; i++)
{
currentRegionGroup(__instance).Clear();
for (int j = 0; j < newRegions(__instance).Count; j++)
{
if (newRegions(__instance)[j].newRegionGroupIndex == i)
{
currentRegionGroup(__instance).Add(newRegions(__instance)[j]);
}
}
if (!currentRegionGroup(__instance)[0].type.AllowsMultipleRegionsPerRoom())
{
if (currentRegionGroup(__instance).Count != 1)
{
Log.Error("Region type doesn't allow multiple regions per room but there are >1 regions in this group.");
}
Room room = Room.MakeNew(map(__instance));
currentRegionGroup(__instance)[0].Room = room;
newRooms(__instance).Add(room);
continue;
}
bool multipleOldNeighborRooms;
Room room2 = FindCurrentRegionGroupNeighborWithMostRegions2(__instance, out multipleOldNeighborRooms);
if (room2 == null)
{
Room item = RegionTraverser.FloodAndSetRooms(currentRegionGroup(__instance)[0], map(__instance), null);
newRooms(__instance).Add(item);
}
else if (!multipleOldNeighborRooms)
{
for (int k = 0; k < currentRegionGroup(__instance).Count; k++)
{
currentRegionGroup(__instance)[k].Room = room2;
}
reusedOldRooms(__instance).Add(room2);
}
else
{
RegionTraverser.FloodAndSetRooms(currentRegionGroup(__instance)[0], map(__instance), room2);
reusedOldRooms(__instance).Add(room2);
}
}
}
private static HashSet <IntVec3> getOldDirtyCells(RegionAndRoomUpdater __instance)
{
if (!oldDirtyCellsDict.TryGetValue(__instance, out HashSet <IntVec3> oldDirtyCells))
{
oldDirtyCells = new HashSet <IntVec3>();
lock (oldDirtyCellsDict)
{
if (!oldDirtyCellsDict.TryGetValue(__instance, out oldDirtyCells))
{
oldDirtyCellsDict.Add(__instance, oldDirtyCells);
}
}
}
return(oldDirtyCells);
}
private static HashSet <int> getGate2ThreadSet(RegionAndRoomUpdater __instance)
{
if (!gate2ThreadSets.TryGetValue(__instance, out HashSet <int> gate2ThreadSet))
{
gate2ThreadSet = new HashSet <int>();
lock (gate2ThreadSets)
{
if (!gate2ThreadSets.TryGetValue(__instance, out gate2ThreadSet))
{
gate2ThreadSets.Add(__instance, gate2ThreadSet);
}
}
}
return(gate2ThreadSet);
}
private static int CombineNewRegionsIntoContiguousGroups2(RegionAndRoomUpdater __instance)
{
int num = 0;
for (int i = 0; i < newRegions(__instance).Count; i++)
{
if (newRegions(__instance)[i].newRegionGroupIndex < 0)
{
RegionTraverser.FloodAndSetNewRegionIndex(newRegions(__instance)[i], num);
num++;
}
}
return(num);
}
private static void CreateOrUpdateRooms2(RegionAndRoomUpdater __instance)
{
newRooms(__instance).Clear();
reusedOldRooms(__instance).Clear();
newRoomGroups(__instance).Clear();
reusedOldRoomGroups(__instance).Clear();
int numRegionGroups = funcCombineNewRegionsIntoContiguousGroups(__instance); //CombineNewRegionsIntoContiguousGroups2(__instance);
//actionCreateOrAttachToExistingRooms(__instance, numRegionGroups); //CreateOrAttachToExistingRooms2(__instance, numRegionGroups);
CreateOrAttachToExistingRooms2(__instance, numRegionGroups);
int numRoomGroups = CombineNewAndReusedRoomsIntoContiguousGroups2(__instance);
actionCreateOrAttachToExistingRoomGroups(__instance, numRoomGroups); //CreateOrAttachToExistingRoomGroups2(__instance, numRoomGroups);
actionNotifyAffectedRoomsAndRoomGroupsAndUpdateTemperature(__instance); //NotifyAffectedRoomsAndRoomGroupsAndUpdateTemperature2(__instance);
}
public static bool TryRebuildDirtyRegionsAndRooms(RegionAndRoomUpdater __instance)
{
if (!__instance.Enabled || working)
{
return(false);
}
lock (RegionDirtyer_Patch.regionDirtyerLock)
{
working = true;
if (!__instance.initialized)
{
__instance.RebuildAllRegionsAndRooms();
}
List <IntVec3> dirtyCells = RegionDirtyer_Patch.get_DirtyCells(__instance.map.regionDirtyer);
if (dirtyCells.Count == 0)
{
working = false;
return(false);
}
try
{
RegenerateNewRegionsFromDirtyCells2(__instance, dirtyCells);
__instance.CreateOrUpdateRooms();
}
catch (Exception arg) { Log.Error("Exception while rebuilding dirty regions: " + arg); }
foreach (IntVec3 dirtyCell in dirtyCells)
{
__instance.map.temperatureCache.ResetCachedCellInfo(dirtyCell);
}
dirtyCells.Clear();
foreach (Region region in regionsToReDirty)
{
RegionDirtyer_Patch.SetRegionDirty(region.Map.regionDirtyer, region);
}
regionsToReDirty.Clear();
__instance.initialized = true;
working = false;
//regionCleaning.Set();
if (DebugSettings.detectRegionListersBugs)
{
Autotests_RegionListers.CheckBugs(__instance.map);
}
}
return(false);
}
private static Room FindCurrentRegionGroupNeighborWithMostRegions2(RegionAndRoomUpdater __instance, out bool multipleOldNeighborRooms)
{
multipleOldNeighborRooms = false;
Room room = null;
for (int i = 0; i < currentRegionGroup(__instance).Count; i++)
{
foreach (Region item in currentRegionGroup(__instance)[i].NeighborsOfSameType)
{
Region currentRegionGroup3 = item;
Map map2 = currentRegionGroup3.Map;
CellIndices cellIndices = map2.cellIndices;
Region[] directGrid = map2.regionGrid.DirectGrid;
bool cellExists = false;
foreach (IntVec3 intVec3 in currentRegionGroup3.extentsClose)
{
if (directGrid[cellIndices.CellToIndex(intVec3)] == currentRegionGroup3)
{
cellExists = true;
break;
}
}
if (!cellExists)
{
Log.Error("still bad regions");
}
if (item.Room != null && !reusedOldRooms(__instance).Contains(item.Room))
{
if (room == null)
{
room = item.Room;
}
else if (item.Room != room)
{
multipleOldNeighborRooms = true;
if (item.Room.RegionCount > room.RegionCount)
{
room = item.Room;
}
}
}
}
}
return(room);
}
private static void CreateOrAttachToExistingRoomGroups2(RegionAndRoomUpdater __instance, int numRoomGroups)
{
for (int i = 0; i < numRoomGroups; i++)
{
currentRoomGroup(__instance).Clear();
foreach (Room reusedOldRoom in reusedOldRooms(__instance))
{
if (reusedOldRoom.newOrReusedRoomGroupIndex == i)
{
currentRoomGroup(__instance).Add(reusedOldRoom);
}
}
for (int j = 0; j < newRooms(__instance).Count; j++)
{
if (newRooms(__instance)[j].newOrReusedRoomGroupIndex == i)
{
currentRoomGroup(__instance).Add(newRooms(__instance)[j]);
}
}
bool multipleOldNeighborRoomGroups;
RoomGroup roomGroup = FindCurrentRoomGroupNeighborWithMostRegions2(__instance, out multipleOldNeighborRoomGroups);
if (roomGroup == null)
{
RoomGroup roomGroup2 = RoomGroup.MakeNew(map(__instance));
FloodAndSetRoomGroups2(__instance, currentRoomGroup(__instance)[0], roomGroup2);
newRoomGroups(__instance).Add(roomGroup2);
}
else if (!multipleOldNeighborRoomGroups)
{
for (int k = 0; k < currentRoomGroup(__instance).Count; k++)
{
currentRoomGroup(__instance)[k].Group = roomGroup;
}
reusedOldRoomGroups(__instance).Add(roomGroup);
}
else
{
FloodAndSetRoomGroups2(__instance, currentRoomGroup(__instance)[0], roomGroup);
reusedOldRoomGroups(__instance).Add(roomGroup);
}
}
}
private static void RegenerateNewRegionsFromDirtyCells2(RegionAndRoomUpdater __instance, List <IntVec3> dirtyCells)
{
newRegions(__instance).Clear();
Map localMap = map(__instance);
//while (dirtyCells.TryDequeue(out IntVec3 dirtyCell))
foreach (IntVec3 dirtyCell in dirtyCells)
{
if (dirtyCell.GetRegion(localMap, RegionType.Set_All) == null)
{
Region region = localMap.regionMaker.TryGenerateRegionFrom(dirtyCell);
if (region != null)
{
newRegions(__instance).Add(region);
}
}
}
}
private static EventWaitHandle getGate2WaitHandle(RegionAndRoomUpdater __instance)
{
if (!gate2WaitHandles.TryGetValue(__instance, out EventWaitHandle gate2WaitHandle))
{
gate2WaitHandle = new ManualResetEvent(false);
lock (gate2WaitHandles)
{
if (!gate2WaitHandles.TryGetValue(__instance, out EventWaitHandle gate2WaitHandle2))
{
gate2WaitHandles.SetOrAdd(__instance, gate2WaitHandle);
}
else
{
return(gate2WaitHandle2);
}
}
}
return(gate2WaitHandle);
}
private static int CombineNewAndReusedRoomsIntoContiguousGroups2(RegionAndRoomUpdater __instance)
{
int num = 0;
foreach (Room reusedOldRoom in reusedOldRooms(__instance))
{
reusedOldRoom.newOrReusedRoomGroupIndex = -1;
}
if (tmpRoomStack == null)
{
tmpRoomStack = new Stack <Room>();
}
else
{
tmpRoomStack.Clear();
}
foreach (Room item in reusedOldRooms(__instance).Concat(newRooms(__instance)))
{
if (item.newOrReusedRoomGroupIndex < 0)
{
tmpRoomStack.Clear();
tmpRoomStack.Push(item);
item.newOrReusedRoomGroupIndex = num;
while (tmpRoomStack.Count != 0)
{
Room room = tmpRoomStack.Pop();
foreach (Room neighbor in room.Neighbors)
{
if (neighbor.newOrReusedRoomGroupIndex < 0 && funcShouldBeInTheSameRoomGroup(__instance, room, neighbor))
{
neighbor.newOrReusedRoomGroupIndex = num;
tmpRoomStack.Push(neighbor);
}
}
}
num++;
}
}
return(num);
}
private static Integer getGate2Count(RegionAndRoomUpdater __instance)
{
if (!gate2Counts.TryGetValue(__instance, out Integer getGate2Count))
{
getGate2Count = new Integer
{
integer = 0
};
lock (gate2Counts)
{
if (!gate2Counts.TryGetValue(__instance, out Integer getGate2Count2))
{
gate2Counts.Add(__instance, getGate2Count);
}
else
{
return(getGate2Count2);
}
}
}
return(getGate2Count);
}
public static bool CombineNewAndReusedRoomsIntoContiguousGroups(RegionAndRoomUpdater __instance, ref int __result)
{
int num = 0;
foreach (Room reusedOldRoom in reusedOldRooms(__instance))
{
reusedOldRoom.newOrReusedRoomGroupIndex = -1;
}
Stack <Room> tmpRoomStack = new Stack <Room>();
foreach (Room room in reusedOldRooms(__instance).Concat(newRooms(__instance)))
{
if (room.newOrReusedRoomGroupIndex < 0)
{
tmpRoomStack.Clear();
tmpRoomStack.Push(room);
room.newOrReusedRoomGroupIndex = num;
while (tmpRoomStack.Count != 0)
{
Room a = tmpRoomStack.Pop();
foreach (Room neighbor in a.Neighbors)
{
if (neighbor != null)
{
if (neighbor.newOrReusedRoomGroupIndex < 0 && ShouldBeInTheSameRoomGroup(a, neighbor))
{
neighbor.newOrReusedRoomGroupIndex = num;
tmpRoomStack.Push(neighbor);
}
}
}
}
//tmpRoomStack.Clear();
++num;
}
}
__result = num;
return(false);
}
private static void RegenerateNewRegionsFromDirtyCells2(RegionAndRoomUpdater __instance, List <IntVec3> dirtyCells)
{
cellsWithNewRegions.Clear();
List <Region> newRegions = __instance.newRegions;
newRegions.Clear();
Map localMap = __instance.map;
//while (dirtyCells.TryDequeue(out IntVec3 dirtyCell))
for (int index = 0; index < dirtyCells.Count; index++)
{
IntVec3 dirtyCell = dirtyCells[index];
Region oldRegion = dirtyCell.GetRegion(localMap, RegionType.Set_All);
if (oldRegion == null)
{
Region region = localMap.regionMaker.TryGenerateRegionFrom(dirtyCell);
if (region != null)
{
newRegions.Add(region);
}
}
}
}
public static bool TryRebuildDirtyRegionsAndRooms(RegionAndRoomUpdater __instance)
{
//todo: optimize lock speedup fix
//lock (workingLock)
//{
//if (working(__instance) || !__instance.Enabled)
if (!__instance.Enabled)
{
return(false);
}
if (getThreadRebuilding())
{
return(false);
}
int workerId = Interlocked.Increment(ref workingInt);
if (workerId > 1)
{
regionCleaning.WaitOne();
//Interlocked.Decrement(ref workingInt);
return(false);
}
regionCleaning.Reset();
setThreadRebuilding(true);
//working(__instance) = true;
if (!initialized(__instance))
{
__instance.RebuildAllRegionsAndRooms();
}
if (!map(__instance).regionDirtyer.AnyDirty)
{
//working(__instance) = false;
resumeThreads();
return(false);
}
try
{
RegenerateNewRegionsFromDirtyCells2(__instance);
//RegenerateNewRegionsFromDirtyCells.Invoke(__instance, new object[] { });
CreateOrUpdateRooms2(__instance);
//CreateOrUpdateRooms.Invoke(__instance, new object[] { });
}
catch (Exception arg)
{
Log.Error("Exception while rebuilding dirty regions: " + arg);
}
newRegions(__instance).Clear();
SetAllClean2(map(__instance).regionDirtyer);
//SetAllClean.Invoke(map(__instance).regionDirtyer, new object[] { });
initialized(__instance) = true;
//working(__instance) = false;
resumeThreads();
//}
if (DebugSettings.detectRegionListersBugs)
{
Autotests_RegionListers.CheckBugs(map(__instance));
}
return(false);
}
public override void Generate()
{
Log.Message("GenStep_CaveRoof.Generate");
if (Find.Map.Biome != Util_CaveBiome.CaveBiomeDef)
{
// Nothing to do in other biomes.
return;
}
// Compute number of cave wells (5 for standard map 250x250, around 13 for bigest map 400x400).
caveWellsNumber = Mathf.CeilToInt((Find.Map.Size.x * Find.Map.Size.z) / 12500);
Log.Message("caveWellsNumber = " + caveWellsNumber);
MapGenFloatGrid elevationGrid = MapGenerator.Elevation;
foreach (IntVec3 cell in Find.Map.AllCells)
{
Thing thing = Find.EdificeGrid.InnerArray[CellIndices.CellToIndex(cell)];
if (thing != null && thing.def.holdsRoof)
{
Find.RoofGrid.SetRoof(cell, RoofDefOf.RoofRockThick);
}
else
{
// Spawn cave roof holder.
GenSpawn.Spawn(Util_CaveBiome.CaveRoofDef, cell);
}
}
// Update region and room to be able to use the CanReachMapEdge function.
DeepProfiler.Start("RebuildAllRegionsBeforeCaveWells");
RegionAndRoomUpdater.Enabled = true;
RegionAndRoomUpdater.RebuildAllRegionsAndRooms();
RegionAndRoomUpdater.Enabled = false;
DeepProfiler.End();
// Get cave wells position.
caveWellsPosition = GetCaveWellsPosition();
// Spawn cave wells.
// First cave well is always dry (to avoid starting thing scattering errors).
SpawnDryCaveWellAt(caveWellsPosition[0]);
SpawnAnimalCorpsesMaker(caveWellsPosition[0]);
for (int caveWellIndex = 1; caveWellIndex < caveWellsNumber; caveWellIndex++)
{
if (Rand.Value < 0.8f)
{
// Spawn aqueous cave well.
SpawnAqueousCaveWellAt(caveWellsPosition[caveWellIndex]);
}
else if (Rand.Value < 0.9f)
{
// Spawn dry cave well + fallen animal corpses.
SpawnDryCaveWellAt(caveWellsPosition[caveWellIndex]);
SpawnAnimalCorpsesMaker(caveWellsPosition[caveWellIndex]);
}
else
{
// Spawn dry cave well + sacrificial stone.
SpawnDryCaveWellAt(caveWellsPosition[caveWellIndex]);
SpawnRitualStone(caveWellsPosition[caveWellIndex]);
}
}
}
public static bool TryRebuildDirtyRegionsAndRooms2(RegionAndRoomUpdater __instance)
{
//if (working || !Enabled)
// return;
if (!__instance.Enabled)
{
return(false);
}
if (getThreadRebuilding())
{
return(false);
}
//working = true;
setThreadRebuilding(true);
if (!initialized(__instance))
{
lock (initializingLock)
{
if (!initialized(__instance))
{
__instance.RebuildAllRegionsAndRooms();
}
initialized(__instance) = true;
}
}
if (RegionDirtyer_Patch.get_DirtyCells(map(__instance).regionDirtyer).IsEmpty)
{
//working = false;
setThreadRebuilding(false);
return(false);
}
try
{
int tid = Thread.CurrentThread.ManagedThreadId;
//HashSet<int> gate1ThreadSet = getGate1ThreadSet(__instance);
//gate1ThreadSet.Add(tid);
Integer gate1Count = getGate1Count(__instance);
int gate1Ticket = Interlocked.Increment(ref gate1Count.integer);
EventWaitHandle gate1WaitHandle = getGate1WaitHandle(__instance);
gate1WaitHandle.WaitOne();
//EventWaitHandle gate2WaitHandle = getGate2WaitHandle(__instance);
//gate2WaitHandle.Reset();
if (gate1Ticket == 1)
{
RegenerateNewRegionsFromDirtyCells2(__instance);
CreateOrUpdateRooms2(__instance);
if (DebugSettings.detectRegionListersBugs)
{
Autotests_RegionListers.CheckBugs(map(__instance));
}
newRegions(__instance).Clear();
gate1WaitHandle.Reset();
}
//HashSet<int> gate2ThreadSet = getGate2ThreadSet(__instance);
//gate2ThreadSet.Add(tid);
Integer gate2Count = getGate2Count(__instance);
Interlocked.Increment(ref gate2Count.integer);
int gate1Remaining = Interlocked.Decrement(ref gate1Count.integer);
EventWaitHandle gate2WaitHandle = getGate2WaitHandle(__instance);
if (gate1Remaining == 0)
{
//CreateOrUpdateRooms2(__instance);
/*
* HashSet<IntVec3> oldDirtyCells = getOldDirtyCells(__instance);
* foreach(IntVec3 oldDirtyCell in oldDirtyCells)
* {
* map(__instance).temperatureCache.ResetCachedCellInfo(oldDirtyCell);
* }
*/
//if (DebugSettings.detectRegionListersBugs)
//{
//Autotests_RegionListers.CheckBugs(map(__instance));
//}
//newRegions(__instance).Clear();
gate2WaitHandle.Set();
}
gate2WaitHandle.WaitOne();
int gate2Remaining = Interlocked.Decrement(ref gate2Count.integer);
if (gate2Remaining == 0)
{
gate2WaitHandle.Reset();
gate1WaitHandle.Set();
}
}
catch (Exception arg)
{
Log.Error("Exception while rebuilding dirty regions: " + arg);
}
//newRegions.Clear();
//map.regionDirtyer.SetAllClean();
//initialized = true; //Moved to earlier code above
//working = false;
setThreadRebuilding(false);
return(false);
}
static bool Prefix(RegionAndRoomUpdater __instance)
{
Map map = __instance.map;
if (!copyFrom.TryGetValue(map.uniqueID, out RegionGrid oldRegions))
{
return(true);
}
__instance.initialized = true;
map.temperatureCache.ResetTemperatureCache();
oldRegions.map = map; // for access to cellIndices in the iterator
foreach (Region r in oldRegions.AllRegions_NoRebuild_InvalidAllowed)
{
r.cachedAreaOverlaps = null;
r.cachedDangers.Clear();
r.mark = 0;
r.reachedIndex = 0;
r.closedIndex = new uint[RegionTraverser.NumWorkers];
r.cachedCellCount = -1;
r.mapIndex = (sbyte)map.Index;
if (r.door != null)
{
r.door = map.ThingReplacement(r.door);
}
foreach (List <Thing> things in r.listerThings.listsByGroup.Concat(r.ListerThings.listsByDef.Values))
{
if (things != null)
{
for (int j = 0; j < things.Count; j++)
{
if (things[j] != null)
{
things[j] = map.ThingReplacement(things[j]);
}
}
}
}
Room rm = r.Room;
if (rm == null)
{
continue;
}
rm.mapIndex = (sbyte)map.Index;
rm.cachedCellCount = -1;
rm.cachedOpenRoofCount = -1;
rm.statsAndRoleDirty = true;
rm.stats = new DefMap <RoomStatDef, float>();
rm.role = null;
rm.uniqueNeighbors.Clear();
rm.uniqueContainedThings.Clear();
RoomGroup rg = rm.groupInt;
rg.tempTracker.cycleIndex = 0;
}
for (int i = 0; i < oldRegions.regionGrid.Length; i++)
{
map.regionGrid.regionGrid[i] = oldRegions.regionGrid[i];
}
copyFrom.Remove(map.uniqueID);
return(false);
}
