static void Postfix(MapRoomFunctionality __instance)
{
if (__instance.GetComponentInParent <HabitatPlatform.Tag>())
{
__instance.gameObject.AddComponent <MapRoomFixer>();
}
}
public static bool Prefix(MapRoomFunctionality __instance, ref float __result)
{
__result = Mathf.Min(BSRSettings.Instance.ScannerBlipRange,
BSRSettings.Instance.ScannerMinRange +
(float)__instance.storageContainer.container.GetCount(TechType.MapRoomUpgradeScanRange) *
BSRSettings.Instance.ScannerUpgradeAddedRange);
return(false);
}
public static bool GetScanRangePrefix(MapRoomFunctionality __instance, ref float __result)
{
if (__instance is ScannerChipFunctionality)
{
__result = Mathf.Min(5000f, 50f + (float)Inventory.main.container.GetCount(TechType.MapRoomUpgradeScanRange) * 50f);
return(false);
}
return(true);
}
public static bool StartScanningPrefix(MapRoomFunctionality __instance, TechType newTypeToScan)
{
if (__instance is ScannerChipFunctionality)
{
__instance.typeToScan = newTypeToScan;
__instance.ObtainResourceNodes(__instance.typeToScan);
__instance.scanActive = __instance.typeToScan > TechType.None;
return(false);
}
return(true);
}
public static bool OnResourceRemovedPrefix(MapRoomFunctionality __instance, ResourceTracker.ResourceInfo info)
{
if (__instance is ScannerChipFunctionality)
{
if (__instance.typeToScan == info.techType)
{
__instance.resourceNodes.Remove(info);
__instance.numNodesScanned--;
}
return(false);
}
return(true);
}
private GameObject FindUntaggedMapRoomFunctionality(Base latestBase)
{
foreach (Transform child in latestBase.transform)
{
NitroxEntity nitroxEntity = child.GetComponent <NitroxEntity>();
MapRoomFunctionality mapRoomFunctionality = child.GetComponent <MapRoomFunctionality>();
if (mapRoomFunctionality && !nitroxEntity)
{
return(child.gameObject);
}
}
throw new Exception("Unable to locate recently built map room");
}
static private bool AddResourceNodeIfWithinScanRange(MapRoomFunctionality mapRoom, List <ResourceTracker.ResourceInfo> resourceNodes, ResourceTracker.ResourceInfo info)
{
float scanRange = mapRoom.GetScanRange();
float sqrScanRange = scanRange * scanRange;
if (mapRoom.typeToScan == info.techType && (mapRoom.wireFrameWorld.position - info.position).sqrMagnitude <= sqrScanRange)
{
Logger.Debug(string.Format("Techtype \"{0}\" is within scan range.", info.techType));
resourceNodes.Add(info);
}
else
{
if (mapRoom.typeToScan == info.techType)
{
Logger.Debug(string.Format("Techtype \"{0}\" is out of scan range.", info.techType));
}
}
return(false);
}
public static bool StartPrefix(MapRoomFunctionality __instance)
{
if (__instance is ScannerChipFunctionality)
{
__instance.wireFrameWorld = Player.main.transform;
if (__instance.typeToScan != TechType.None)
{
__instance.StartScanning(__instance.typeToScan);
}
else
{
__instance.StartScanning(TechType.TimeCapsule);
}
ResourceTracker.onResourceDiscovered += __instance.OnResourceDiscovered;
ResourceTracker.onResourceRemoved += __instance.OnResourceRemoved;
MapRoomFunctionality.mapRooms.Add(__instance);
return(false);
}
return(true);
}
public static bool UpdatePrefix(MapRoomFunctionality __instance)
{
return(!(__instance is ScannerChipFunctionality));
}
public static bool Prefix(MapRoomFunctionality __instance, ref float __result)
{
__result = Mathf.Max(BSRSettings.Instance.ScannerSpeedMinimumInterval, BSRSettings.Instance.ScannerSpeedNormalInterval - __instance.storageContainer.container.GetCount(TechType.MapRoomUpgradeScanSpeed) * BSRSettings.Instance.ScannerSpeedIntervalPerModule);
return false;
}
public static bool Prefix(MapRoomFunctionality __instance, ref float __result)
{
__result = __instance.hologramRadius / BSRSettings.Instance.ScannerBlipRange;
return(false);
}
public ScannerRoomPowerConsumerInfo(MapRoomFunctionality scanner) : base(scanner.name)
{
this.scanner = scanner;
}
static bool Prefix(MapRoomFunctionality __instance, List <ResourceTracker.ResourceInfo> ___resourceNodes, ResourceTracker.ResourceInfo info)
{
return(MapRoomFunctionality_OnResourceDiscovered_Patch.AddResourceNodeIfWithinScanRange(__instance, ___resourceNodes, info));
}
public static IEnumerator ScanInSleepingBatchCellsNotQueuesCoroutine(this MapRoomFunctionality mapRoom, int numOfBatchRings)
{
var largeWorldStreamer = LargeWorldStreamer.main;
var cellManager = LargeWorldStreamer.main.cellManager;
Logger.Info(string.Format("Starting scan in sleeping/unloaded BatchCells"));
var batch2Cells = cellManager.GetBatch2Cells();
var containingBatch = largeWorldStreamer.GetContainingBatch(mapRoom.transform.position);
var scanBounds = new Int3.Bounds(containingBatch - numOfBatchRings, containingBatch + numOfBatchRings);
var orderedScanBatches = scanBounds.ToEnumerable()
.OrderBy(batch => (mapRoom.transform.position - largeWorldStreamer.GetBatchCenter(batch)).sqrMagnitude);
using (var serializerProxy = ProtobufSerializerPool.GetProxy())
{
foreach (var batch in orderedScanBatches)
{
Logger.Debug(string.Format("Now at batch \"{0}\"", batch));
var batchVisible = true;
if (!batch2Cells.TryGetValue(batch, out var batchCells))
{
Logger.Debug(string.Format("Loading cells of batch \"{0}\"", batch));
batchCells = BatchCells.GetFromPool(cellManager, largeWorldStreamer, batch);
var loadBatchCellsTask = new LoadBatchCellsTask(cellManager, batchCells);
UWE.Utils.EnqueueWrap(workerThread, loadBatchCellsTask);
yield return(new AsyncAwaiter(loadBatchCellsTask));
batchVisible = false;
}
for (int level = 0; level <= 3; level++)
{
Logger.Debug(string.Format("Getting cells level {0} of batch \"{1}\"", level, batchCells.batch));
var cellsTier = batchCells.GetCells(level);
var orderedCellsTier = cellsTier
.Where(cell => cell != null)
.OrderBy(cell => (mapRoom.transform.position - cell.GetCenter()).sqrMagnitude);
foreach (var entityCell in orderedCellsTier)
{
Logger.Debug(string.Format("Getting cell {0} of batch \"{1}\"", entityCell.CellId, batchCells.batch));
if (entityCell != null && !entityCell.IsProcessing())
{
SerialData serialData;
if (batchVisible)
{
serialData = new SerialData();
serialData.CopyFrom(entityCell.GetSerialData());
}
else
{
serialData = entityCell.GetSerialData();
}
if (serialData.Length > 0)
{
Logger.Debug(string.Format("Entity cell \"{0}\" is not awake and has serialData", entityCell.ToString()));
UnityEngine.GameObject liveRoot;
using (MemoryStream stream = new MemoryStream(serialData.Data.Array, serialData.Data.Offset, serialData.Data.Length, false))
{
bool headerDeserialized = serializerProxy.Value.TryDeserializeStreamHeader(stream);
if (headerDeserialized)
{
CoroutineTask <UnityEngine.GameObject> task = serializerProxy.Value.DeserializeObjectTreeAsync(stream, true, 0);
yield return(task);
liveRoot = task.GetResult();
}
else
{
liveRoot = null;
}
}
if (liveRoot)
{
Logger.Debug(string.Format("Entity cell \"{0}\" can have liveRoot {1}", entityCell.ToString(), liveRoot.ToString()));
var resourceTrackers = liveRoot.GetComponentsInChildren <ResourceTracker>(true);
foreach (var resourceTracker in resourceTrackers)
{
resourceTracker.Start();
Logger.Debug(string.Format("Entity cell \"{0}\" invoked \"Start\" for {1}", entityCell.ToString(), resourceTracker.gameObject.ToString()));
resourceTracker.OnDestroy();
}
UnityEngine.Object.Destroy(liveRoot);
}
else
{
Logger.Debug(string.Format("Entity cell \"{0}\" can't have liveRoot", entityCell.ToString()));
}
}
SerialData waiterData;
if (batchVisible)
{
waiterData = new SerialData();
waiterData.CopyFrom(entityCell.GetWaiterData());
}
else
{
waiterData = entityCell.GetWaiterData();
}
if (waiterData.Length > 0)
{
Logger.Debug(string.Format("Entity cell \"{0}\" is not awake and has waiterData", entityCell.ToString()));
UnityEngine.GameObject waiterRoot;
using (MemoryStream stream = new MemoryStream(waiterData.Data.Array, waiterData.Data.Offset, waiterData.Data.Length, false))
{
while (stream.Position < waiterData.Length)
{
CoroutineTask <UnityEngine.GameObject> task = serializerProxy.Value.DeserializeObjectTreeAsync(stream, true, 0);
yield return(task);
waiterRoot = task.GetResult();
if (waiterRoot)
{
Logger.Debug(string.Format("Entity cell \"{0}\" can have waiterRoot {1}", entityCell.ToString(), waiterRoot.ToString()));
var resourceTrackers = waiterRoot.GetComponentsInChildren <ResourceTracker>(true);
foreach (var resourceTracker in resourceTrackers)
{
resourceTracker.Start();
Logger.Debug(string.Format("Entity cell \"{0}\" invoked \"Start\" for {1}", entityCell.ToString(), resourceTracker.gameObject.ToString()));
resourceTracker.OnDestroy();
}
UnityEngine.Object.Destroy(waiterRoot);
}
}
}
}
SerialData legacyData;
if (batchVisible)
{
legacyData = new SerialData();
legacyData.CopyFrom(entityCell.GetLegacyData());
}
else
{
legacyData = entityCell.GetLegacyData();
}
if (legacyData.Length > 0)
{
Logger.Debug(string.Format("Entity cell \"{0}\" has legacyData", entityCell.ToString()));
UnityEngine.GameObject legacyRoot;
using (MemoryStream stream = new MemoryStream(legacyData.Data.Array, legacyData.Data.Offset, legacyData.Data.Length, false))
{
bool headerDeserialized = serializerProxy.Value.TryDeserializeStreamHeader(stream);
if (headerDeserialized)
{
CoroutineTask <UnityEngine.GameObject> task = serializerProxy.Value.DeserializeObjectTreeAsync(stream, true, 0);
yield return(task);
legacyRoot = task.GetResult();
}
else
{
legacyRoot = null;
}
}
if (legacyRoot)
{
Logger.Debug(string.Format("Entity cell \"{0}\" can have legacyRoot {1}", entityCell.ToString(), legacyRoot.ToString()));
var resourceTrackers = legacyRoot.GetComponentsInChildren <ResourceTracker>(true);
foreach (var resourceTracker in resourceTrackers)
{
resourceTracker.Start();
Logger.Debug(string.Format("Entity cell \"{0}\" invoked \"Start\" for {1}", entityCell.ToString(), resourceTracker.gameObject.ToString()));
resourceTracker.OnDestroy();
}
UnityEngine.Object.Destroy(legacyRoot);
}
}
}
}
}
if (!batchVisible)
{
Logger.Debug(string.Format("Unloading cells of batch \"{0}\"", batch));
BatchCells.ReturnToPool(batchCells);
}
;
yield return(null);
}
}
Logger.Info(string.Format("Finishing scan in sleeping/unloaded BatchCells"));
yield break;
}
void Awake()
{
$"MapRoomFixer: added".logDbg();
lastPosition = transform.position;
mrf = GetComponent <MapRoomFunctionality>();
}
