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); }