tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Optimise marker spawning (#17922)

Browse Source
This commit is contained in:
metalgearsloth
2023-07-10 17:15:59 +10:00
committed by GitHub
parent 2057ff0028
commit 48276eb00a
3 changed files with 158 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
Content.Server/Parallax/BiomeSystem.cs
View File

@@ -1,4 +1,5 @@
using System.Numerics;
using System.Threading.Tasks;
using Content.Server.Decals;
using Content.Server.Ghost.Roles.Components;
using Content.Server.Shuttles.Events;
@@ -6,6 +7,7 @@ using Content.Shared.Decals;
using Content.Shared.Parallax.Biomes;
using Content.Shared.Parallax.Biomes.Layers;
using Content.Shared.Parallax.Biomes.Markers;
using Microsoft.Extensions.ObjectPool;
using Robust.Server.Player;
using Robust.Shared;
using Robust.Shared.Collections;
@@ -17,6 +19,8 @@ using Robust.Shared.Noise;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Serialization.Manager;
using Robust.Shared.Threading;
using Robust.Shared.Utility;
namespace Content.Server.Parallax;
@@ -26,9 +30,11 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
[Dependency] private readonly IConfigurationManager _configManager = default!;
[Dependency] private readonly IConsoleHost _console = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IParallelManager _parallel = default!;
[Dependency] private readonly IPlayerManager _playerManager = default!;
[Dependency] private readonly IPrototypeManager _proto = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly ISerializationManager _serManager = default!;
[Dependency] private readonly DecalSystem _decals = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
@@ -36,6 +42,9 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
private const float DefaultLoadRange = 16f;
private float _loadRange = DefaultLoadRange;
private ObjectPool<HashSet<Vector2i>> _tilePool =
new DefaultObjectPool<HashSet<Vector2i>>(new SetPolicy<Vector2i>(), 256);
/// <summary>
/// Load area for chunks containing tiles, decals etc.
/// </summary>
@@ -265,7 +274,7 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
while (biomes.MoveNext(out var biome))
{
_activeChunks.Add(biome, new HashSet<Vector2i>());
_activeChunks.Add(biome, _tilePool.Get());
_markerChunks.GetOrNew(biome);
}
@@ -321,6 +330,12 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
}
_handledEntities.Clear();
foreach (var tiles in _activeChunks.Values)
{
_tilePool.Return(tiles);
}
_activeChunks.Clear();
_markerChunks.Clear();
}
@@ -364,100 +379,53 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
{
var markers = _markerChunks[component];
var loadedMarkers = component.LoadedMarkers;
var spawnSet = new HashSet<Vector2i>();
var spawns = new List<Vector2i>();
var frontier = new ValueList<Vector2i>();
foreach (var (layer, chunks) in markers)
{
foreach (var chunk in chunks)
Parallel.ForEach(chunks, new ParallelOptions() { MaxDegreeOfParallelism = _parallel.ParallelProcessCount }, chunk =>
{
if (loadedMarkers.TryGetValue(layer, out var mobChunks) && mobChunks.Contains(chunk))
continue;
return;
var noiseCopy = new FastNoiseLite();
_serManager.CopyTo(component.Noise, ref noiseCopy, notNullableOverride: true);
var spawnSet = _tilePool.Get();
var frontier = new ValueList<Vector2i>(32);
// Make a temporary version and copy back in later.
var pending = new Dictionary<Vector2i, Dictionary<string, List<Vector2i>>>();
spawns.Clear();
spawnSet.Clear();
var layerProto = _proto.Index<BiomeMarkerLayerPrototype>(layer);
var buffer = layerProto.Radius / 2f;
mobChunks ??= new HashSet<Vector2i>();
mobChunks.Add(chunk);
loadedMarkers[layer] = mobChunks;
var rand = new Random(noise.GetSeed() + chunk.X * 8 + chunk.Y + layerProto.GetHashCode());
// We treat a null entity mask as requiring nothing else on the tile
var lower = (int) Math.Floor(buffer);
var upper = (int) Math.Ceiling(layerProto.Size - buffer);
// TODO: Okay this is inefficient as FUCK
// I think the ideal is pick a random tile then BFS outwards from it probably ig
// It will bias edge tiles significantly more but will make the CPU cry less.
for (var x = lower; x <= upper; x++)
{
for (var y = lower; y <= upper; y++)
{
var index = new Vector2i(x + chunk.X, y + chunk.Y);
TryGetEntity(index, component.Layers, component.Noise, grid, out var proto);
if (proto != layerProto.EntityMask)
{
continue;
}
spawns.Add(index);
spawnSet.Add(index);
}
}
// Load NOW
// TODO: Need poisson but crashes whenever I use moony's due to inputs or smth idk
var count = (int) ((layerProto.Size - buffer) * (layerProto.Size - buffer) / (layerProto.Radius * layerProto.Radius));
var count = (int) ((layerProto.Size - buffer) * (layerProto.Size - buffer) /
(layerProto.Radius * layerProto.Radius));
count = Math.Min(count, layerProto.MaxCount);
// Pick a random tile then BFS outwards from it
// It will bias edge tiles significantly more but will make the CPU cry less.
for (var i = 0; i < count; i++)
{
if (spawns.Count == 0)
break;
var index = rand.Next(spawns.Count);
var point = spawns[index];
spawns.RemoveSwap(index);
// Point was potentially used in BFS search below but we hadn't updated the list yet.
if (!spawnSet.Remove(point))
{
i--;
continue;
}
// BFS search
frontier.Add(point);
var groupCount = layerProto.GroupCount;
var startNodeX = rand.Next(lower, upper + 1);
var startNodeY = rand.Next(lower, upper + 1);
var startNode = new Vector2i(startNodeX, startNodeY);
frontier.Clear();
frontier.Add(startNode);
while (frontier.Count > 0 && groupCount > 0)
while (groupCount > 0 && frontier.Count > 0)
{
var frontierIndex = _random.Next(frontier.Count);
var frontierIndex = rand.Next(frontier.Count);
var node = frontier[frontierIndex];
frontier.RemoveSwap(frontierIndex);
var enumerator = grid.GetAnchoredEntitiesEnumerator(node);
if (enumerator.MoveNext(out _))
continue;
// Need to ensure the tile under it has loaded for anchoring.
if (TryGetBiomeTile(node, component.Layers, component.Noise, grid, out var tile))
{
grid.SetTile(node, tile.Value);
}
// If it is a ghost role then purge it
// TODO: This is *kind* of a bandaid but natural mobs spawns needs a lot more work.
// Ideally we'd just have ghost role and non-ghost role variants for some stuff.
var uid = EntityManager.CreateEntityUninitialized(layerProto.Prototype, new EntityCoordinates(gridUid, node));
RemComp<GhostTakeoverAvailableComponent>(uid);
RemComp<GhostRoleComponent>(uid);
EntityManager.InitializeAndStartEntity(uid);
groupCount--;
// Add neighbors regardless.
for (var x = -1; x <= 1; x++)
{
for (var y = -1; y <= 1; y++)
@@ -467,25 +435,85 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
var neighbor = new Vector2i(x + node.X, y + node.Y);
if (!spawnSet.Contains(neighbor))
// Check if it's inbounds.
if (neighbor.X < lower ||
neighbor.Y < lower ||
neighbor.X > upper ||
neighbor.Y > upper)
{
continue;
}
frontier.Add(neighbor);
// Rather than doing some uggo remove check on the list we'll defer it until later
spawnSet.Remove(neighbor);
}
}
}
// Add the unused nodes back in
foreach (var node in frontier)
var actualNode = node + chunk;
if (!spawnSet.Add(actualNode))
continue;
// Check if it's a valid spawn, if so then use it.
var enumerator = grid.GetAnchoredEntitiesEnumerator(actualNode);
if (enumerator.MoveNext(out _))
continue;
// Check if mask matches.
TryGetEntity(actualNode, component.Layers, noiseCopy, grid, out var proto);
if (proto != layerProto.EntityMask)
{
spawnSet.Add(node);
continue;
}
frontier.Clear();
var chunkOrigin = SharedMapSystem.GetChunkIndices(actualNode, ChunkSize) * ChunkSize;
if (!pending.TryGetValue(chunkOrigin, out var pendingMarkers))
{
pendingMarkers = new Dictionary<string, List<Vector2i>>();
pending[chunkOrigin] = pendingMarkers;
}
if (!pendingMarkers.TryGetValue(layer, out var layerMarkers))
{
layerMarkers = new List<Vector2i>();
pendingMarkers[layer] = layerMarkers;
}
// Log.Info($"Added node at {actualNode} for chunk {chunkOrigin}");
layerMarkers.Add(actualNode);
groupCount--;
}
}
lock (component.PendingMarkers)
{
if (!loadedMarkers.TryGetValue(layer, out var lockMobChunks))
{
lockMobChunks = new HashSet<Vector2i>();
loadedMarkers[layer] = lockMobChunks;
}
lockMobChunks.Add(chunk);
foreach (var (chunkOrigin, layers) in pending)
{
if (!component.PendingMarkers.TryGetValue(chunkOrigin, out var lockMarkers))
{
lockMarkers = new Dictionary<string, List<Vector2i>>();
component.PendingMarkers[chunkOrigin] = lockMarkers;
}
foreach (var (lockLayer, nodes) in layers)
{
lockMarkers[lockLayer] = nodes;
}
}
_tilePool.Return(spawnSet);
}
});
}
var active = _activeChunks[component];
@@ -515,7 +543,36 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
EntityQuery<TransformComponent> xformQuery)
{
component.ModifiedTiles.TryGetValue(chunk, out var modified);
modified ??= new HashSet<Vector2i>();
modified ??= _tilePool.Get();
// Load any pending marker tiles first.
if (component.PendingMarkers.TryGetValue(chunk, out var layers))
{
foreach (var (layer, nodes) in layers)
{
var layerProto = _proto.Index<BiomeMarkerLayerPrototype>(layer);
foreach (var node in nodes)
{
// Need to ensure the tile under it has loaded for anchoring.
if (TryGetBiomeTile(node, component.Layers, component.Noise, grid, out var tile))
{
grid.SetTile(node, tile.Value);
}
// If it is a ghost role then purge it
// TODO: This is *kind* of a bandaid but natural mobs spawns needs a lot more work.
// Ideally we'd just have ghost role and non-ghost role variants for some stuff.
var uid = EntityManager.CreateEntityUninitialized(layerProto.Prototype, grid.GridTileToLocal(node));
RemComp<GhostTakeoverAvailableComponent>(uid);
RemComp<GhostRoleComponent>(uid);
EntityManager.InitializeAndStartEntity(uid);
modified.Add(node);
}
}
component.PendingMarkers.Remove(chunk);
}
// Set tiles first
for (var x = 0; x < ChunkSize; x++)
@@ -606,6 +663,7 @@ public sealed partial class BiomeSystem : SharedBiomeSystem
if (modified.Count == 0)
{
_tilePool.Return(modified);
component.ModifiedTiles.Remove(chunk);
}
else

6
Content.Shared/Parallax/Biomes/BiomeComponent.cs
View File

@@ -58,6 +58,12 @@ public sealed partial class BiomeComponent : Component
#region Markers
/// <summary>
/// Work out entire marker tiles in advance but only load the entities when in range.
/// </summary>
[DataField("pendingMarkers")]
public Dictionary<Vector2i, Dictionary<string, List<Vector2i>>> PendingMarkers = new();
/// <summary>
/// Track what markers we've loaded already to avoid double-loading.
/// </summary>

20
Content.Shared/Parallax/Biomes/SharedBiomeSystem.cs
View File

@@ -28,20 +28,22 @@ public abstract class SharedBiomeSystem : EntitySystem
component.Noise.SetSeed(component.Seed);
}
protected T Pick<T>(List<T> collection, float value)
private T Pick<T>(List<T> collection, float value)
{
DebugTools.Assert(value is >= 0f and <= 1f);
// Listen I don't need this exact and I'm too lazy to finetune just for random ent picking.
value %= 1f;
value = Math.Clamp(value, 0f, 1f);
if (collection.Count == 1)
return collection[0];
value *= collection.Count;
var randValue = value * collection.Count;
foreach (var item in collection)
{
value -= 1f;
randValue -= 1f;
if (value <= 0f)
if (randValue <= 0f)
{
return item;
}
@@ -50,9 +52,10 @@ public abstract class SharedBiomeSystem : EntitySystem
throw new ArgumentOutOfRangeException();
}
protected int Pick(int count, float value)
private int Pick(int count, float value)
{
DebugTools.Assert(value is >= 0f and <= 1f);
value %= 1f;
value = Math.Clamp(value, 0f, 1f);
if (count == 1)
return 0;
@@ -234,7 +237,8 @@ public abstract class SharedBiomeSystem : EntitySystem
return false;
}
entity = Pick(biomeLayer.Entities, (noise.GetNoise(indices.X, indices.Y, i) + 1f) / 2f);
var noiseValue = noise.GetNoise(indices.X, indices.Y, i);
entity = Pick(biomeLayer.Entities, (noiseValue + 1f) / 2f);
noise.SetSeed(oldSeed);
return true;
}