public static EntitySpawnPoint From(Int3 batchId, GameObject go, CellManager.CellHeader cellHeader)
{
// Why is this not a constructor?
EntitySpawnPoint esp = new EntitySpawnPoint
{
Level = cellHeader.level,
ClassId = go.ClassId,
BatchId = batchId,
CellId = cellHeader.cellId
};
EntitySlot entitySlot = go.GetComponent <EntitySlot>();
if (!ReferenceEquals(entitySlot, null))
{
esp.BiomeType = entitySlot.biomeType;
esp.Density = entitySlot.density;
esp.CanSpawnCreature = entitySlot.IsCreatureSlot();
}
Vector3 localPosition = go.GetComponent <Transform>().Position;
Int3.Bounds bounds = BatchCells.GetBlockBounds(batchId, cellHeader.cellId, 0, Map.BATCH_DIMENSIONS);
UnityEngine.Vector3 center = EntityCell.GetCenter(bounds);
esp.Position = new UnityEngine.Vector3(center.x + localPosition.x - Map.BATCH_DIMENSION_CENTERING.x,
center.y + localPosition.y - Map.BATCH_DIMENSION_CENTERING.y,
center.z + localPosition.z - Map.BATCH_DIMENSION_CENTERING.z);
return(esp);
}
[HarmonyPrefix] // We're attempting to replace the geometry building method
public static bool Prefix(ref Base __instance, Int3 cell)
{
Int3 v = Base.CellSize[7];
Int3.Bounds bounds = new Int3.Bounds(cell, cell + v - 1);
BaseDeconstructable parent = null;
if (__instance.GetCellMask(cell))
{
Transform transform = __instance.SpawnPiece(Base.Piece.Moonpool, cell);
parent = BaseDeconstructable.MakeCellDeconstructable(transform, bounds, TechType.BaseMoonpool);
transform.tag = "MainPieceGeometry";
}
for (int i = 0; i < Base.moonpoolFaces.Length; i++)
{
Base.RoomFace roomFace = Base.moonpoolFaces[i];
Base.Face face = new Base.Face(cell + roomFace.offset, roomFace.direction);
if (__instance.GetFaceMask(face))
{
Base.FaceType face2 = __instance.GetFace(face);
Base.Piece moonpoolPiece = __instance.GetMoonpoolPiece(face, face2);
if (moonpoolPiece != Base.Piece.Invalid)
{
Transform transform2 = __instance.SpawnPiece(moonpoolPiece, cell, roomFace.rotation, null);
transform2.localPosition = Int3.Scale(roomFace.offset, Base.cellSize) + roomFace.localOffset;
if (face2 != Base.FaceType.Solid)
{
TechType recipe = Base.FaceToRecipe[(int)face2];
BaseDeconstructable baseDeconstructable = BaseDeconstructable.MakeFaceDeconstructable(transform2, bounds, face, face2, recipe);
if (!__instance.isGhost)
{
transform2.GetComponentsInChildren <IBaseModuleGeometry>(true, Base.sBaseModulesGeometry);
int j = 0;
int count = Base.sBaseModulesGeometry.Count;
while (j < count)
{
IBaseModuleGeometry baseModuleGeometry = Base.sBaseModulesGeometry[j];
baseModuleGeometry.geometryFace = face;
j++;
}
Base.sBaseModulesGeometry.Clear();
if (face2 == Base.FaceType.UpgradeConsole)
{
baseDeconstructable.LinkModule(new Base.Face?(new Base.Face(face.cell - __instance.anchor, face.direction)));
}
}
}
else if (!__instance.isGhost)
{
BaseExplicitFace.MakeFaceDeconstructable(transform2, face, parent);
}
}
}
}
return(false);
}
public static void PerformOctreesEdit(this LargeWorldStreamer largeWorldStreamer, Int3.Bounds blockBounds, LargeWorldStreamer.DistanceField df, bool isAdd = false, byte type = 1)
{
VoxelandData.OctNode.BlendArgs args = new VoxelandData.OctNode.BlendArgs(isAdd ? VoxelandData.OctNode.BlendOp.Union : VoxelandData.OctNode.BlendOp.Subtraction, false, isAdd ? type : (byte)0);
var streamerV2 = largeWorldStreamer.streamerV2;
materialTypeOfLastOctreesEditAdd = 0;
blockBounds = blockBounds.Expanded(1);
foreach (Int3 @int in blockBounds / largeWorldStreamer.blocksPerTree)
{
if (largeWorldStreamer.CheckRoot(@int))
{
Octree octree = streamerV2.octreesStreamer.GetOctree(@int);
if (octree != null)
{
Int3.Bounds bounds = @int.Refined(largeWorldStreamer.blocksPerTree);
VoxelandData.OctNode root = octree.ToVLOctree();
foreach (Int3 int2 in bounds.Intersect(blockBounds))
{
Vector3 wsPos = largeWorldStreamer.land.transform.TransformPoint(int2 + UWE.Utils.half3);
float num = df(wsPos);
if (num >= 0f)
{
VoxelandData.OctNode i = new VoxelandData.OctNode(type, VoxelandData.OctNode.EncodeDensity(num));
int blocksPerTree = largeWorldStreamer.blocksPerTree;
int x = int2.x % blocksPerTree;
int y = int2.y % blocksPerTree;
int z = int2.z % blocksPerTree;
var node = root.GetNode(x, y, z, blocksPerTree / 2);
if (!isAdd && materialTypeOfLastOctreesEditAdd <= node.type)
{
materialTypeOfLastOctreesEditAdd = node.type;
}
VoxelandData.OctNode octNode = VoxelandData.OctNode.Blend(node, i, args);
root.SetNode(x, y, z, blocksPerTree / 2, octNode.type, octNode.density);
}
}
root.Collapse();
streamerV2.octreesStreamer.SetBatchOctree(@int, root);
root.Clear();
}
}
}
streamerV2.clipmapStreamer.AddToRangesEdited(blockBounds);
}
public static void Prefix(Base __instance)
{
if (__instance.gameObject.transform.parent?.name.Contains("(Clone)") ?? false)
{
if (__instance.isGhost)
{
return;
}
Int3.Bounds bounds = __instance.Bounds;
Int3 mins = bounds.mins;
Int3 maxs = bounds.maxs;
Int3 cell = default(Int3);
for (int i = mins.z; i <= maxs.z; i++)
{
cell.z = i;
for (int j = mins.x; j <= maxs.x; j++)
{
cell.x = j;
int k = mins.y;
while (k <= maxs.y)
{
cell.y = k;
if (__instance.GetCell(cell) != Base.CellType.Empty)
{
BaseFoundationPiece componentInChildren = __instance.GetCellObject(cell).GetComponentInChildren <BaseFoundationPiece>();
if (componentInChildren != null)
{
componentInChildren.maxPillarHeight = 0f;
break;
}
break;
}
else
{
k++;
}
}
}
}
}
}
static bool Prefix(LargeWorldStreamer __instance, Int3.Bounds blockBounds, LargeWorldStreamer.DistanceField df, bool isAdd = false, byte type = 1)
{
__instance.PerformOctreesEdit(blockBounds, df, isAdd, type);
return(false);
}
public static void AddToRangesEdited(this ClipmapStreamer clipmapStreamer, Int3.Bounds blockRange)
{
rangesEdited.Add(blockRange);
Logger.Info($"{blockRange} added. Currently has {rangesEdited.Count} ranges added.");
}
private static BaseDeconstructable FindBaseDeconstructable(string guid, string baseGuid, Base.FaceType faceType, Base.Face face, Int3.Bounds bounds)
{
var baseObject = GuidHelper.Find(baseGuid);
if (baseObject != null)
{
foreach (var item in baseObject.GetAllComponentsInChildren <BaseDeconstructable>())
{
if (item.faceType != faceType)
{
continue;
}
if (item.bounds != bounds)
{
continue;
}
if (item.face.GetValueOrDefault() != face)
{
continue;
}
GuidHelper.Set(item.gameObject, guid);
return(item);
}
}
if (string.IsNullOrEmpty(guid) == false)
{
Log.Warn("Couldn't find base deconstructable: " + guid);
}
return(null);
}
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;
}