private static void NotifyFileLoadedAsync(DataManager me, DataManager.DataManagerLoadRequest request)
{
if (request.Prewarm != null)
{
if (DebugLog)
{
Trace("Notified Prewarm Async: " + GetKey(request));
}
List <PrewarmRequest> pre = (List <PrewarmRequest>)prewarmRequests.GetValue(me);
pre.Remove(request.Prewarm);
}
if (DebugLog)
{
Trace("Notified Done Async: " + GetKey(request));
}
CheckMechDefDependencies(request);
if (CheckAsyncRequestsComplete())
{
if (DebugLog)
{
Verbo("Background queue cleared by {0}.", GetKey(request));
}
isLoadingAsync.SetValue(me, false);
SaveCache.Invoke(me, null);
background.Clear();
center.PublishMessage(new DataManagerAsyncLoadCompleteMessage());
}
}
private static void CheckMechDefDependencies(DataManager.DataManagerLoadRequest request)
{
string key = GetKey(request);
if (!dependee.TryGetValue(key, out HashSet <object> dependents))
{
return;
}
dependee.Remove(key);
foreach (object dependent in dependents)
{
if (depender.TryGetValue(dependent, out HashSet <string> list) && list.Remove(key))
{
if (list.Count > 0)
{
if (DebugLog)
{
Trace("Found MechDef dependency. Check {0} of {1}. {2} remains.", key, GetName(dependent), list.Count);
}
continue;
}
if (DebugLog)
{
Verbo("All depencency loaded for {0}.\n{1}", GetName(dependent));
}
checkingMech = null;
if (dependent is MechDef mech)
{
mech.CheckDependenciesAfterLoad(new DataManagerLoadCompleteMessage());
}
}
}
}
public static bool Override_UpdateRequestsTimeout(DataManager __instance, float deltaTime)
{
try {
if (UnpatchManager)
{
return(true);
}
if (!EnableTimeout)
{
return(false);
}
DataManager me = __instance;
if (currentTimeout >= 0f)
{
if (queue.Any(IsProcessing))
{
if (DebugLog)
{
Warn("Foreground request timeout.");
}
DataManager.DataManagerLoadRequest[] list = queue.Where(IsProcessing).ToArray();
currentTimeout += deltaTime;
if (currentTimeout > list.Count() * 0.2f)
{
foreach (DataManager.DataManagerLoadRequest dataManagerLoadRequest in list)
{
logger.LogWarning(string.Format("DataManager Request for {0} has taken too long. Cancelling request. Your load will probably fail", dataManagerLoadRequest.ResourceId));
dataManagerLoadRequest.NotifyLoadFailed();
}
currentTimeout = -1f;
}
}
}
if (currentAsyncTimeout >= 0f && background.Count > 0)
{
currentAsyncTimeout += deltaTime;
if (currentAsyncTimeout > 20f)
{
if (DebugLog)
{
Warn("Background request timeout.");
}
DataManager.DataManagerLoadRequest dataManagerLoadRequest = background.Values.First(IsProcessing);
if (dataManagerLoadRequest != null)
{
logger.LogWarning(string.Format("DataManager Async Request for {0} has taken too long. Cancelling request. Your load will probably fail", dataManagerLoadRequest.ResourceId));
dataManagerLoadRequest.NotifyLoadFailed();
}
currentAsyncTimeout = -1f;
}
}
return(false);
} catch (Exception ex) { return(KillManagerPatch(__instance, ex)); }
}
public static bool Override_NotifyFileLoadedAsync(DataManager __instance, DataManager.DataManagerLoadRequest request)
{
try {
if (UnpatchManager)
{
return(true);
}
NotifyFileLoadedAsync(__instance, request);
return(false);
} catch (Exception ex) { return(KillManagerPatch(__instance, ex)); }
}
private static void NotifyFileLoaded(DataManager me, DataManager.DataManagerLoadRequest request, ref bool isLoading)
{
if (request.Prewarm != null)
{
if (DebugLog)
{
Trace("Notified Prewarm: {0}", GetKey(request));
}
List <PrewarmRequest> pre = (List <PrewarmRequest>)prewarmRequests.GetValue(me);
pre.Remove(request.Prewarm);
}
if (DebugLog)
{
Trace("Notified Done: {0}", GetKey(request));
}
CheckMechDefDependencies(request);
if (LoadingQueue && request.IsComplete())
{
foregroundLoading.Remove(request);
}
if (CheckRequestsComplete())
{
if (foreground.Count > 0)
{
stopwatch.Stop();
Info("Foreground queue ({0}) cleared. {1:n0}ms this queue, {2:n0}ms total.", foreground.Count, stopwatch.ElapsedMilliseconds, totalLoadTime += stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
}
else if (DebugLog)
{
Verbo("Empty foreground queue cleared by {0}.", GetKey(request));
}
isLoading = false;
SaveCache.Invoke(me, null);
foreground.Clear();
if (LoadingQueue)
{
foregroundLoading.Clear();
}
depender.Clear();
dependee.Clear();
center.PublishMessage(new DataManagerLoadCompleteMessage());
}
}
public static bool Override_ProcessRequests(DataManager __instance, List <DataManager.DataManagerLoadRequest> ___foregroundRequestsList, uint ___foregroundRequestsCurrentAllowedWeight)
{
try {
if (UnpatchManager)
{
return(true);
}
for (int i = 0, len = ___foregroundRequestsList.Count; i < len; i++)
{
DataManager.DataManagerLoadRequest request = ___foregroundRequestsList[i];
if (request.State != DataManager.DataManagerLoadRequest.RequestState.Requested)
{
continue;
}
request.RequestWeight.SetAllowedWeight(___foregroundRequestsCurrentAllowedWeight);
if (request.IsMemoryRequest)
{
__instance.RemoveObjectOfType(request.ResourceId, request.ResourceType);
}
if (!request.ManifestEntryValid)
{
LogManifestEntryValid(request);
}
else if (!request.RequestWeight.RequestAllowed)
{
request.NotifyLoadComplete();
}
else
{
if (DebugLog)
{
Trace("Loading {0} {1}", request.ResourceType, request.ResourceId);
}
request.Load();
}
}
return(false);
} catch (Exception ex) { return(KillManagerPatch(ex)); }
}
public static bool Override_NotifyFileLoadFailed(DataManager __instance, DataManager.DataManagerLoadRequest request, ref bool ___isLoading)
{
try {
if (UnpatchManager)
{
return(true);
}
string key = GetKey(request);
if (DebugLog)
{
Trace("Notified Failed: {0}", key);
}
if (foreground.Remove(key))
{
NotifyFileLoaded(__instance, request, ref ___isLoading);
}
else if (background.Remove(key))
{
NotifyFileLoadedAsync(__instance, request);
}
return(false);
} catch (Exception ex) { return(KillManagerPatch(__instance, ex)); }
}
private static bool IsProcessing(DataManager.DataManagerLoadRequest e)
{
return(e.State == DataManager.DataManagerLoadRequest.RequestState.Processing);
}
private static bool IsComplete(DataManager.DataManagerLoadRequest e)
{
return(e.IsComplete());
}
internal static string GetKey(DataManager.DataManagerLoadRequest request)
{
return(GetKey(request.ResourceType, request.ResourceId));
}
private static void LogManifestEntryValid(DataManager.DataManagerLoadRequest request)
{
logger.LogError(string.Format("LoadRequest for {0} of type {1} has an invalid manifest entry. Any requests for this object will fail.", request.ResourceId, request.ResourceType));
request.NotifyLoadFailed();
}