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