Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Puddles & spreader refactor (#15191)

Browse Source
This commit is contained in:
metalgearsloth
2023-04-10 15:37:03 +10:00
committed by GitHub
parent 3178ab83f6
commit 317a4013eb
141 changed files with 3046 additions and 3201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
Content.IntegrationTests/Tests/Fluids/FluidSpillTest.cs
View File

@@ -4,8 +4,10 @@ using System.Collections.Generic;
using System.Threading.Tasks;
using Content.Server.Fluids.Components;
using Content.Server.Fluids.EntitySystems;
using Content.Server.Spreader;
using Content.Shared.Chemistry.Components;
using Content.Shared.FixedPoint;
using Content.Shared.Fluids.Components;
using NUnit.Framework;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
@@ -16,7 +18,7 @@ using Robust.Shared.Timing;
namespace Content.IntegrationTests.Tests.Fluids;
[TestFixture]
[TestOf(typeof(FluidSpreaderSystem))]
[TestOf(typeof(SpreaderSystem))]
public sealed class FluidSpill
{
private static PuddleComponent? GetPuddle(IEntityManager entityManager, MapGridComponent mapGrid, Vector2i pos)
@@ -30,78 +32,6 @@ public sealed class FluidSpill
return null;
}
private readonly Direction[] _dirs =
{
Direction.East,
Direction.South,
Direction.West,
Direction.North,
};
private readonly Vector2i _origin = new(1, 1);
[Test]
public async Task SpillEvenlyTest()
{
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var spillSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<SpillableSystem>();
var gameTiming = server.ResolveDependency<IGameTiming>();
var puddleSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<PuddleSystem>();
MapId mapId;
EntityUid gridId = default;
await server.WaitPost(() =>
{
mapId = mapManager.CreateMap();
var grid = mapManager.CreateGrid(mapId);
gridId = grid.Owner;
for (var x = 0; x < 3; x++)
{
for (var y = 0; y < 3; y++)
{
grid.SetTile(new Vector2i(x, y), new Tile(1));
}
}
});
await server.WaitAssertion(() =>
{
var grid = mapManager.GetGrid(gridId);
var solution = new Solution("Water", FixedPoint2.New(100));
var tileRef = grid.GetTileRef(_origin);
var puddle = spillSystem.SpillAt(tileRef, solution, "PuddleSmear");
Assert.That(puddle, Is.Not.Null);
Assert.That(GetPuddle(entityManager, grid, _origin), Is.Not.Null);
});
var sTimeToWait = (int) Math.Ceiling(2f * gameTiming.TickRate);
await server.WaitRunTicks(sTimeToWait);
await server.WaitAssertion(() =>
{
var grid = mapManager.GetGrid(gridId);
var puddle = GetPuddle(entityManager, grid, _origin);
Assert.That(puddle, Is.Not.Null);
Assert.That(puddleSystem.CurrentVolume(puddle!.Owner, puddle), Is.EqualTo(FixedPoint2.New(20)));
foreach (var direction in _dirs)
{
var newPos = _origin.Offset(direction);
var sidePuddle = GetPuddle(entityManager, grid, newPos);
Assert.That(sidePuddle, Is.Not.Null);
Assert.That(puddleSystem.CurrentVolume(sidePuddle!.Owner, sidePuddle), Is.EqualTo(FixedPoint2.New(20)));
}
});
await pairTracker.CleanReturnAsync();
}
[Test]
public async Task SpillCorner()
{
@@ -109,7 +39,6 @@ public sealed class FluidSpill
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var spillSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<SpillableSystem>();
var puddleSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<PuddleSystem>();
var gameTiming = server.ResolveDependency<IGameTiming>();
MapId mapId;
@@ -117,9 +46,9 @@ public sealed class FluidSpill
/*
In this test, if o is spillage puddle and # are walls, we want to ensure all tiles are empty (`.`)
o # .
# . .
. . .
# . .
o # .
*/
await server.WaitPost(() =>
{
@@ -144,10 +73,9 @@ public sealed class FluidSpill
await server.WaitAssertion(() =>
{
var grid = mapManager.GetGrid(gridId);
var solution = new Solution("Water", FixedPoint2.New(100));
var solution = new Solution("Blood", FixedPoint2.New(100));
var tileRef = grid.GetTileRef(puddleOrigin);
var puddle = spillSystem.SpillAt(tileRef, solution, "PuddleSmear");
Assert.That(puddle, Is.Not.Null);
Assert.That(puddleSystem.TrySpillAt(tileRef, solution, out _), Is.True);
Assert.That(GetPuddle(entityManager, grid, puddleOrigin), Is.Not.Null);
});

126
Content.IntegrationTests/Tests/Fluids/PuddleTest.cs
View File

@@ -5,6 +5,7 @@ using Content.Server.Fluids.EntitySystems;
using Content.Shared.Chemistry.Components;
using Content.Shared.Coordinates;
using Content.Shared.FixedPoint;
using Content.Shared.Fluids.Components;
using NUnit.Framework;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
@@ -26,7 +27,7 @@ namespace Content.IntegrationTests.Tests.Fluids
var testMap = await PoolManager.CreateTestMap(pairTracker);
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
var spillSystem = entitySystemManager.GetEntitySystem<SpillableSystem>();
var spillSystem = entitySystemManager.GetEntitySystem<PuddleSystem>();
await server.WaitAssertion(() =>
{
@@ -35,9 +36,9 @@ namespace Content.IntegrationTests.Tests.Fluids
var gridUid = tile.GridUid;
var (x, y) = tile.GridIndices;
var coordinates = new EntityCoordinates(gridUid, x, y);
var puddle = spillSystem.SpillAt(solution, coordinates, "PuddleSmear");
var puddle = spillSystem.TrySpillAt(coordinates, solution, out _);
Assert.NotNull(puddle);
Assert.True(puddle);
});
await PoolManager.RunTicksSync(pairTracker.Pair, 5);
@@ -53,7 +54,7 @@ namespace Content.IntegrationTests.Tests.Fluids
var testMap = await PoolManager.CreateTestMap(pairTracker);
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
var spillSystem = entitySystemManager.GetEntitySystem<SpillableSystem>();
var spillSystem = entitySystemManager.GetEntitySystem<PuddleSystem>();
MapGridComponent grid = null;
@@ -74,124 +75,11 @@ namespace Content.IntegrationTests.Tests.Fluids
{
var coordinates = grid.ToCoordinates();
var solution = new Solution("Water", FixedPoint2.New(20));
var puddle = spillSystem.SpillAt(solution, coordinates, "PuddleSmear");
Assert.Null(puddle);
var puddle = spillSystem.TrySpillAt(coordinates, solution, out _);
Assert.False(puddle);
});
await pairTracker.CleanReturnAsync();
}
[Test]
public async Task PuddlePauseTest()
{
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
var sMapManager = server.ResolveDependency<IMapManager>();
var sTileDefinitionManager = server.ResolveDependency<ITileDefinitionManager>();
var sGameTiming = server.ResolveDependency<IGameTiming>();
var entityManager = server.ResolveDependency<IEntityManager>();
var metaSystem = entityManager.EntitySysManager.GetEntitySystem<MetaDataSystem>();
MapId sMapId = default;
MapGridComponent sGrid;
EntityUid sGridId = default;
EntityCoordinates sCoordinates = default;
// Spawn a paused map with one tile to spawn puddles on
await server.WaitPost(() =>
{
sMapId = sMapManager.CreateMap();
sMapManager.SetMapPaused(sMapId, true);
sGrid = sMapManager.CreateGrid(sMapId);
sGridId = sGrid.Owner;
metaSystem.SetEntityPaused(sGridId, true); // See https://github.com/space-wizards/RobustToolbox/issues/1444
var tileDefinition = sTileDefinitionManager["UnderPlating"];
var tile = new Tile(tileDefinition.TileId);
sCoordinates = sGrid.ToCoordinates();
sGrid.SetTile(sCoordinates, tile);
});
// Check that the map and grid are paused
await server.WaitAssertion(() =>
{
Assert.True(metaSystem.EntityPaused(sGridId));
Assert.True(sMapManager.IsMapPaused(sMapId));
});
float evaporateTime = default;
PuddleComponent puddle = null;
MetaDataComponent meta = null;
EvaporationComponent evaporation;
var amount = 2;
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
var spillSystem = entitySystemManager.GetEntitySystem<SpillableSystem>();
// Spawn a puddle
await server.WaitAssertion(() =>
{
var solution = new Solution("Water", FixedPoint2.New(amount));
puddle = spillSystem.SpillAt(solution, sCoordinates, "PuddleSmear");
meta = entityManager.GetComponent<MetaDataComponent>(puddle.Owner);
// Check that the puddle was created
Assert.NotNull(puddle);
evaporation = entityManager.GetComponent<EvaporationComponent>(puddle.Owner);
metaSystem.SetEntityPaused(puddle.Owner, true, meta); // See https://github.com/space-wizards/RobustToolbox/issues/1445
Assert.True(metaSystem.EntityPaused(puddle.Owner, meta));
// Check that the puddle is going to evaporate
Assert.Positive(evaporation.EvaporateTime);
// Should have a timer component added to it for evaporation
Assert.That(evaporation.Accumulator, Is.EqualTo(0f));
evaporateTime = evaporation.EvaporateTime;
});
// Wait enough time for it to evaporate if it was unpaused
var sTimeToWait = 5 + (int)Math.Ceiling(amount * evaporateTime * sGameTiming.TickRate);
await PoolManager.RunTicksSync(pairTracker.Pair, sTimeToWait);
// No evaporation due to being paused
await server.WaitAssertion(() =>
{
Assert.True(meta.EntityPaused);
// Check that the puddle still exists
Assert.False(meta.EntityDeleted);
});
// Unpause the map
await server.WaitPost(() => { sMapManager.SetMapPaused(sMapId, false); });
// Check that the map, grid and puddle are unpaused
await server.WaitAssertion(() =>
{
Assert.False(sMapManager.IsMapPaused(sMapId));
Assert.False(metaSystem.EntityPaused(sGridId));
Assert.False(meta.EntityPaused);
// Check that the puddle still exists
Assert.False(meta.EntityDeleted);
});
// Wait enough time for it to evaporate
await PoolManager.RunTicksSync(pairTracker.Pair, sTimeToWait);
// Puddle evaporation should have ticked
await server.WaitAssertion(() =>
{
// Check that puddle has been deleted
Assert.True(puddle.Deleted);
});
await pairTracker.CleanReturnAsync();
}
}
}