public async Task Test() { var serverOptions = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(serverOptions); await server.WaitIdleAsync(); var sMapManager = server.ResolveDependency <IMapManager>(); var sEntityManager = server.ResolveDependency <IEntityManager>(); var broady = server.ResolveDependency <IEntitySystemManager>().GetEntitySystem <SharedBroadphaseSystem>(); await server.WaitAssertion(() => { var mapId = new MapId(1); var grid = sMapManager.GetGrid(new GridId(1)); grid.SetTile(new Vector2i(0, 0), new Tile(1)); var gridEnt = sEntityManager.GetEntity(grid.GridEntityId); var gridPos = gridEnt.Transform.WorldPosition; var entityCoordinates = new EntityCoordinates(grid.GridEntityId, 0, 0); // Nothing blocking it, only entity is the grid Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable, out var entity)); Assert.NotNull(entity); var mapCoordinates = new MapCoordinates(gridPos.X, gridPos.Y, mapId); // Nothing blocking it, only entity is the grid Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable, out entity)); Assert.NotNull(entity); // Spawn a blocker with an Impassable mask sEntityManager.SpawnEntity(BlockerDummyId, entityCoordinates); broady.Update(0.016f); // Cannot spawn something with an Impassable layer Assert.Null(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable)); Assert.False(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable, out entity)); Assert.Null(entity); Assert.Null(sEntityManager.SpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable)); Assert.False(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable, out entity)); Assert.Null(entity); // Other layers are fine Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.MobImpassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.MobImpassable, out entity)); Assert.NotNull(entity); Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.MobImpassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.MobImpassable, out entity)); Assert.NotNull(entity); }); }
public async Task TryAllTest() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(options); await server.WaitIdleAsync(); var entityManager = server.ResolveDependency <IEntityManager>(); var prototypeManager = server.ResolveDependency <IPrototypeManager>(); var mapManager = server.ResolveDependency <IMapManager>(); var coordinates = GetMainEntityCoordinates(mapManager); foreach (var reactionPrototype in prototypeManager.EnumeratePrototypes <ReactionPrototype>()) { //since i have no clue how to isolate each loop assert-wise im just gonna throw this one in for good measure Console.WriteLine($"Testing {reactionPrototype.ID}"); EntityUid beaker; Solution component = null; server.Assert(() => { beaker = entityManager.SpawnEntity("TestSolutionContainer", coordinates); Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryGetSolution(beaker, "beaker", out component)); foreach (var(id, reactant) in reactionPrototype.Reactants) { Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryAddReagent(beaker, component, id, reactant.Amount, out var quantity)); Assert.That(reactant.Amount, Is.EqualTo(quantity)); } EntitySystem.Get <SolutionContainerSystem>().SetTemperature(beaker, component, reactionPrototype.MinimumTemperature); }); await server.WaitIdleAsync(); server.Assert(() => { //you just got linq'd fool //(i'm sorry) var foundProductsMap = reactionPrototype.Products .Concat(reactionPrototype.Reactants.Where(x => x.Value.Catalyst).ToDictionary(x => x.Key, x => x.Value.Amount)) .ToDictionary(x => x, _ => false); foreach (var reagent in component.Contents) { Assert.That(foundProductsMap.TryFirstOrNull(x => x.Key.Key == reagent.ReagentId && x.Key.Value == reagent.Quantity, out var foundProduct)); foundProductsMap[foundProduct.Value.Key] = true; } Assert.That(foundProductsMap.All(x => x.Value)); }); } }
public async Task NoSuffocationTest() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(options); await server.WaitIdleAsync(); var mapLoader = server.ResolveDependency <IMapLoader>(); var mapManager = server.ResolveDependency <IMapManager>(); var entityManager = server.ResolveDependency <IEntityManager>(); MapId mapId; IMapGrid grid = null; RespiratorComponent respirator = null; EntityUid human = default; var testMapName = "Maps/Test/Breathing/3by3-20oxy-80nit.yml"; await server.WaitPost(() => { mapId = mapManager.CreateMap(); grid = mapLoader.LoadBlueprint(mapId, testMapName); }); Assert.NotNull(grid, $"Test blueprint {testMapName} not found."); await server.WaitAssertion(() => { var center = new Vector2(0.5f, -1.5f); var coordinates = new EntityCoordinates(grid.GridEntityId, center); human = entityManager.SpawnEntity("HumanBodyAndBloodstreamDummy", coordinates); Assert.True(entityManager.HasComponent <SharedBodyComponent>(human)); Assert.True(entityManager.TryGetComponent(human, out respirator)); Assert.False(respirator.Suffocating); }); var increment = 10; for (var tick = 0; tick < 600; tick += increment) { await server.WaitRunTicks(increment); await server.WaitAssertion(() => { Assert.False(respirator.Suffocating, $"Entity {entityManager.GetComponent<MetaDataComponent>(human).EntityName} is suffocating on tick {tick}"); }); } await server.WaitIdleAsync(); }
public async Task Test() { var serverOptions = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(serverOptions); await server.WaitIdleAsync(); var sMapManager = server.ResolveDependency <IMapManager>(); var sEntityManager = server.ResolveDependency <IEntityManager>(); await server.WaitAssertion(() => { var grid = sMapManager.GetGrid(new GridId(1)); var entityCoordinates = new EntityCoordinates(grid.GridEntityId, 0, 0); // Nothing blocking it, only entity is the grid Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable, out var entity)); Assert.NotNull(entity); var mapId = new MapId(1); var mapCoordinates = new MapCoordinates(0, 0, mapId); // Nothing blocking it, only entity is the grid Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable, out entity)); Assert.NotNull(entity); // Spawn a blocker with an Impassable mask sEntityManager.SpawnEntity(BlockerDummyId, entityCoordinates); // Cannot spawn something with an Impassable layer Assert.Null(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable)); Assert.False(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable, out entity)); Assert.Null(entity); Assert.Null(sEntityManager.SpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable)); Assert.False(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.Impassable, out entity)); Assert.Null(entity); // Other layers are fine Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.MobImpassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.MobImpassable, out entity)); Assert.NotNull(entity); Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.MobImpassable)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.MobImpassable, out entity)); Assert.NotNull(entity); }); }
public async Task TryMixAndOverflowTooMuchReagent() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(options); await server.WaitIdleAsync(); var entityManager = server.ResolveDependency <IEntityManager>(); var mapManager = server.ResolveDependency <IMapManager>(); var coordinates = GetMainEntityCoordinates(mapManager); EntityUid beaker; server.Assert(() => { int ratio = 9; int threshold = 20; var waterQuantity = FixedPoint2.New(10); var oilQuantity = FixedPoint2.New(ratio * waterQuantity.Int()); var oilAdded = new Solution("Oil", oilQuantity); var originalWater = new Solution("Water", waterQuantity); beaker = entityManager.SpawnEntity("SolutionTarget", coordinates); Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryGetSolution(beaker, "beaker", out var solution)); solution.AddSolution(originalWater); Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryMixAndOverflow(beaker, solution, oilAdded, threshold, out var overflowingSolution)); Assert.That(solution.CurrentVolume, Is.EqualTo(FixedPoint2.New(threshold))); solution.ContainsReagent("Water", out var waterMix); solution.ContainsReagent("Oil", out var oilMix); Assert.That(waterMix, Is.EqualTo(FixedPoint2.New(threshold / (ratio + 1)))); Assert.That(oilMix, Is.EqualTo(FixedPoint2.New(threshold / (ratio + 1) * ratio))); Assert.That(overflowingSolution.CurrentVolume, Is.EqualTo(FixedPoint2.New(80))); overflowingSolution.ContainsReagent("Water", out var waterOverflow); overflowingSolution.ContainsReagent("Oil", out var oilOverFlow); Assert.That(waterOverflow, Is.EqualTo(waterQuantity - waterMix)); Assert.That(oilOverFlow, Is.EqualTo(oilQuantity - oilMix)); }); await server.WaitIdleAsync(); }
public async Task AnchoredNoPullTest() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServerDummyTicker(options); await server.WaitIdleAsync(); var mapManager = server.ResolveDependency <IMapManager>(); var entityManager = server.ResolveDependency <IEntityManager>(); await server.WaitAssertion(() => { mapManager.CreateNewMapEntity(MapId.Nullspace); var pullerEntity = entityManager.SpawnEntity("PullTestPullerDummy", MapCoordinates.Nullspace); var pullableEntity = entityManager.SpawnEntity("PullTestPullableDummy", MapCoordinates.Nullspace); var puller = pullerEntity.GetComponent <SharedPullerComponent>(); var pullable = pullableEntity.GetComponent <PullableComponent>(); var pullablePhysics = pullableEntity.GetComponent <PhysicsComponent>(); pullablePhysics.Anchored = false; Assert.That(pullable.TryStartPull(puller.Owner)); Assert.That(pullable.Puller, Is.EqualTo(puller.Owner)); Assert.That(pullable.BeingPulled); Assert.That(puller.Pulling, Is.EqualTo(pullable.Owner)); Assert.That(pullable.TryStopPull); Assert.That(pullable.Puller, Is.Null); Assert.That(pullable.BeingPulled, Is.False); Assert.That(puller.Pulling, Is.Null); pullablePhysics.Anchored = true; Assert.That(pullable.TryStartPull(puller.Owner), Is.False); Assert.That(pullable.Puller, Is.Null); Assert.That(pullable.BeingPulled, Is.False); Assert.That(puller.Pulling, Is.Null); }); }
public async Task TryAddTooMuchNonReactiveReagent() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(options); await server.WaitIdleAsync(); var entityManager = server.ResolveDependency <IEntityManager>(); var mapManager = server.ResolveDependency <IMapManager>(); var coordinates = GetMainEntityCoordinates(mapManager); EntityUid beaker; server.Assert(() => { var oilQuantity = FixedPoint2.New(1500); var waterQuantity = FixedPoint2.New(10); var oilAdded = new Solution("Oil", oilQuantity); var originalWater = new Solution("Water", waterQuantity); beaker = entityManager.SpawnEntity("SolutionTarget", coordinates); Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryGetSolution(beaker, "beaker", out var solution)); solution.AddSolution(originalWater); Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryAddSolution(beaker, solution, oilAdded), Is.False); solution.ContainsReagent("Water", out var water); solution.ContainsReagent("Oil", out var oil); Assert.That(water, Is.EqualTo(waterQuantity)); Assert.That(oil, Is.EqualTo(FixedPoint2.Zero)); }); await server.WaitIdleAsync(); }
public async Task TryMixAndOverflowTooBigOverflow() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(options); await server.WaitIdleAsync(); var entityManager = server.ResolveDependency <IEntityManager>(); var mapManager = server.ResolveDependency <IMapManager>(); var coordinates = GetMainEntityCoordinates(mapManager); EntityUid beaker; server.Assert(() => { int ratio = 9; int threshold = 60; var waterQuantity = FixedPoint2.New(10); var oilQuantity = FixedPoint2.New(ratio * waterQuantity.Int()); var oilAdded = new Solution("Oil", oilQuantity); var originalWater = new Solution("Water", waterQuantity); beaker = entityManager.SpawnEntity("SolutionTarget", coordinates); Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryGetSolution(beaker, "beaker", out var solution)); solution.AddSolution(originalWater); Assert.That(EntitySystem.Get <SolutionContainerSystem>() .TryMixAndOverflow(beaker, solution, oilAdded, threshold, out _), Is.False); }); await server.WaitIdleAsync(); }
public async Task AirConsistencyTest() { // --- Setup var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(options); await server.WaitIdleAsync(); var mapLoader = server.ResolveDependency <IMapLoader>(); var mapManager = server.ResolveDependency <IMapManager>(); var entityManager = server.ResolveDependency <IEntityManager>(); RespiratorSystem respSys = default; MetabolizerSystem metaSys = default; MapId mapId; IMapGrid grid = null; SharedBodyComponent body = default; EntityUid human = default; GridAtmosphereComponent relevantAtmos = default; float startingMoles = 0.0f; var testMapName = "Maps/Test/Breathing/3by3-20oxy-80nit.yml"; await server.WaitPost(() => { mapId = mapManager.CreateMap(); grid = mapLoader.LoadBlueprint(mapId, testMapName); }); Assert.NotNull(grid, $"Test blueprint {testMapName} not found."); float GetMapMoles() { var totalMapMoles = 0.0f; foreach (var tile in relevantAtmos.Tiles.Values) { totalMapMoles += tile.Air?.TotalMoles ?? 0.0f; } return(totalMapMoles); } await server.WaitAssertion(() => { var coords = new Vector2(0.5f, -1f); var coordinates = new EntityCoordinates(grid.GridEntityId, coords); human = entityManager.SpawnEntity("HumanBodyDummy", coordinates); respSys = EntitySystem.Get <RespiratorSystem>(); metaSys = EntitySystem.Get <MetabolizerSystem>(); relevantAtmos = entityManager.GetComponent <GridAtmosphereComponent>(grid.GridEntityId); startingMoles = GetMapMoles(); Assert.True(entityManager.TryGetComponent(human, out body)); Assert.True(entityManager.HasComponent <RespiratorComponent>(human)); }); // --- End setup var inhaleCycles = 100; for (var i = 0; i < inhaleCycles; i++) { await server.WaitAssertion(() => { // inhale respSys.Update(2.0f); Assert.That(GetMapMoles(), Is.LessThan(startingMoles)); // metabolize + exhale metaSys.Update(1.0f); metaSys.Update(1.0f); respSys.Update(2.0f); Assert.That(GetMapMoles(), Is.EqualTo(startingMoles).Within(0.0001)); }); } await server.WaitIdleAsync(); }
public async IAsyncEnumerable <Image> Paint(string map) { var stopwatch = new Stopwatch(); stopwatch.Start(); var clientOptions = new ClientContentIntegrationOption { CVarOverrides = { [CVars.NetPVS.Name] = "false" }, Pool = false, FailureLogLevel = LogLevel.Fatal }; var serverOptions = new ServerContentIntegrationOption { CVarOverrides = { [CCVars.GameMap.Name] = map, [CVars.NetPVS.Name] = "false" }, Pool = false, FailureLogLevel = LogLevel.Fatal }; var(client, server) = await StartConnectedServerClientPair(clientOptions, serverOptions); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); await RunTicksSync(client, server, 10); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); Console.WriteLine($"Loaded client and server in {(int) stopwatch.Elapsed.TotalMilliseconds} ms"); stopwatch.Restart(); var cEntityManager = client.ResolveDependency <IClientEntityManager>(); var cPlayerManager = client.ResolveDependency <Robust.Client.Player.IPlayerManager>(); await client.WaitPost(() => { if (cEntityManager.TryGetComponent(cPlayerManager.LocalPlayer !.ControlledEntity !, out Robust.Client.GameObjects.SpriteComponent? sprite)) { sprite.Visible = false; } }); var sEntityManager = server.ResolveDependency <IServerEntityManager>(); var sPlayerManager = server.ResolveDependency <IPlayerManager>(); await server.WaitPost(() => { if (sEntityManager.TryGetComponent(sPlayerManager.ServerSessions.Single().AttachedEntity !, out SpriteComponent? sprite)) { sprite.Visible = false; } }); await RunTicksSync(client, server, 10); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); var sMapManager = server.ResolveDependency <IMapManager>(); var tilePainter = new TilePainter(client, server); var entityPainter = new GridPainter(client, server); IMapGrid[] grids = null !; await server.WaitPost(() => { var playerEntity = sPlayerManager.ServerSessions.Single().AttachedEntity; if (playerEntity.HasValue) { sEntityManager.DeleteEntity(playerEntity.Value); } grids = sMapManager.GetAllMapGrids(new MapId(1)).ToArray(); foreach (var grid in grids) { grid.WorldRotation = Angle.Zero; } }); await RunTicksSync(client, server, 10); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); foreach (var grid in grids) { var tileXSize = grid.TileSize * TilePainter.TileImageSize; var tileYSize = grid.TileSize * TilePainter.TileImageSize; var bounds = grid.LocalBounds; var left = bounds.Left; var right = bounds.Right; var top = bounds.Top; var bottom = bounds.Bottom; var w = (int)Math.Ceiling(right - left) * tileXSize; var h = (int)Math.Ceiling(top - bottom) * tileYSize; var gridCanvas = new Image <Rgba32>(w, h); await server.WaitPost(() => { tilePainter.Run(gridCanvas, grid); entityPainter.Run(gridCanvas, grid); gridCanvas.Mutate(e => e.Flip(FlipMode.Vertical)); }); yield return(gridCanvas); } // We don't care if it fails as we have already saved the images. try { await OneTimeTearDown(); } catch { // ignored } }
public async Task WiredNetworkDeviceSendAndReceive() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes, ContentBeforeIoC = () => { IoCManager.Resolve <IEntitySystemManager>().LoadExtraSystemType <DeviceNetworkTestSystem>(); } }; var server = StartServer(options); await server.WaitIdleAsync(); var mapManager = server.ResolveDependency <IMapManager>(); var entityManager = server.ResolveDependency <IEntityManager>(); var deviceNetSystem = entityManager.EntitySysManager.GetEntitySystem <DeviceNetworkSystem>(); var deviceNetTestSystem = entityManager.EntitySysManager.GetEntitySystem <DeviceNetworkTestSystem>(); EntityUid device1 = default; EntityUid device2 = default; DeviceNetworkComponent networkComponent1 = null; DeviceNetworkComponent networkComponent2 = null; WiredNetworkComponent wiredNetworkComponent = null; IMapGrid grid = null; var testValue = "test"; var payload = new NetworkPayload { ["Test"] = testValue, ["testnumber"] = 1, ["testbool"] = true }; await server.WaitRunTicks(1); await server.WaitIdleAsync(); server.Assert(() => { var map = mapManager.CreateNewMapEntity(MapId.Nullspace); grid = mapManager.CreateGrid(MapId.Nullspace); device1 = entityManager.SpawnEntity("DummyWiredNetworkDevice", MapCoordinates.Nullspace); Assert.That(entityManager.TryGetComponent(device1, out networkComponent1), Is.True); Assert.That(entityManager.TryGetComponent(device1, out wiredNetworkComponent), Is.True); Assert.That(networkComponent1.Open, Is.True); Assert.That(networkComponent1.Address, Is.Not.EqualTo(string.Empty)); device2 = entityManager.SpawnEntity("DummyWiredNetworkDevice", new MapCoordinates(new Robust.Shared.Maths.Vector2(0, 2), MapId.Nullspace)); Assert.That(entityManager.TryGetComponent(device2, out networkComponent2), Is.True); Assert.That(networkComponent2.Open, Is.True); Assert.That(networkComponent2.Address, Is.Not.EqualTo(string.Empty)); Assert.That(networkComponent1.Address, Is.Not.EqualTo(networkComponent2.Address)); deviceNetSystem.QueuePacket(device1, networkComponent2.Address, networkComponent2.Frequency, payload); }); await server.WaitRunTicks(1); await server.WaitIdleAsync(); server.Assert(() => { //CollectionAssert.AreNotEqual(deviceNetTestSystem.LastPayload, payload); entityManager.SpawnEntity("CableApcExtension", grid.MapToGrid(new MapCoordinates(new Robust.Shared.Maths.Vector2(0, 1), MapId.Nullspace))); deviceNetSystem.QueuePacket(device1, networkComponent2.Address, networkComponent2.Frequency, payload); }); await server.WaitRunTicks(1); await server.WaitIdleAsync(); server.Assert(() => { CollectionAssert.AreEqual(deviceNetTestSystem.LastPayload, payload); }); await server.WaitIdleAsync(); }
public async IAsyncEnumerable <Image> Paint(string map) { map = map.Substring(10); // Resources/ var stopwatch = new Stopwatch(); stopwatch.Start(); var clientOptions = new ClientContentIntegrationOption { CVarOverrides = { [CVars.NetPVS.Name] = "false" } }; var serverOptions = new ServerContentIntegrationOption { CVarOverrides = { [CCVars.GameMap.Name] = map, [CVars.NetPVS.Name] = "false" } }; var(client, server) = await StartConnectedServerClientPair(clientOptions, serverOptions); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); await RunTicksSync(client, server, 10); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); Console.WriteLine($"Loaded client and server in {(int) stopwatch.Elapsed.TotalMilliseconds} ms"); stopwatch.Restart(); var cPlayerManager = client.ResolveDependency <Robust.Client.Player.IPlayerManager>(); await client.WaitPost(() => { if (cPlayerManager.LocalPlayer !.ControlledEntity !.TryGetComponent(out Robust.Client.GameObjects.SpriteComponent? sprite)) { sprite.Visible = false; } }); var sPlayerManager = server.ResolveDependency <IPlayerManager>(); await server.WaitPost(() => { if (sPlayerManager.GetAllPlayers().Single().AttachedEntity !.TryGetComponent(out SpriteComponent? sprite)) { sprite.Visible = false; } }); await RunTicksSync(client, server, 2); var sMapManager = server.ResolveDependency <IMapManager>(); var tilePainter = new TilePainter(client, server); var entityPainter = new EntityPainter(client, server); IMapGrid[] grids = null !; await server.WaitPost(() => { sPlayerManager.GetAllPlayers().Single().AttachedEntity?.Delete(); grids = sMapManager.GetAllMapGrids(new MapId(1)).ToArray(); }); foreach (var grid in grids) { var tileXSize = 32; var tileYSize = 32; var bounds = grid.WorldBounds; var left = Math.Abs(bounds.Left); var right = Math.Abs(bounds.Right); var top = Math.Abs(bounds.Top); var bottom = Math.Abs(bounds.Bottom); var w = (int)Math.Ceiling(left + right) * tileXSize; var h = (int)Math.Ceiling(top + bottom) * tileYSize; var gridCanvas = new Image <Rgba32>(w, h); await server.WaitPost(() => { tilePainter.Run(gridCanvas, grid); entityPainter.Run(gridCanvas, grid); gridCanvas.Mutate(e => e.Flip(FlipMode.Vertical)); }); yield return(gridCanvas); } // We don't care if it fails as we have already saved the images. try { #pragma warning disable 4014 TearDown(); #pragma warning restore 4014 } catch (InvalidOperationException) { } }
public async Task AirlockBlockTest() { var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; var server = StartServer(options); await server.WaitIdleAsync(); var mapManager = server.ResolveDependency <IMapManager>(); var entityManager = server.ResolveDependency <IEntityManager>(); IPhysBody physBody = null; EntityUid physicsDummy = default; EntityUid airlock = default; DoorComponent doorComponent = null; var physicsDummyStartingX = -1; server.Assert(() => { var mapId = mapManager.CreateMap(); var humanCoordinates = new MapCoordinates((physicsDummyStartingX, 0), mapId); physicsDummy = entityManager.SpawnEntity("PhysicsDummy", humanCoordinates); airlock = entityManager.SpawnEntity("AirlockDummy", new MapCoordinates((0, 0), mapId)); Assert.True(entityManager.TryGetComponent(physicsDummy, out physBody)); Assert.True(entityManager.TryGetComponent(airlock, out doorComponent)); Assert.That(doorComponent.State, Is.EqualTo(DoorState.Closed)); }); await server.WaitIdleAsync(); // Push the human towards the airlock await server.WaitAssertion(() => Assert.That(physBody != null)); await server.WaitPost(() => physBody.LinearVelocity = (0.5f, 0)); for (var i = 0; i < 240; i += 10) { // Keep the airlock awake so they collide server.Post(() => entityManager.GetComponent <IPhysBody>(airlock).WakeBody()); await server.WaitRunTicks(10); await server.WaitIdleAsync(); } // Sanity check // Sloth: Okay I'm sorry but I hate having to rewrite tests for every refactor // If you see this yell at me in discord so I can continue to pretend this didn't happen. // REMINDER THAT I STILL HAVE TO FIX THIS TEST EVERY OTHER PHYSICS PR // Assert.That(physicsDummy.Transform.MapPosition.X, Is.GreaterThan(physicsDummyStartingX)); // Blocked by the airlock await server.WaitAssertion(() => Assert.That(Math.Abs(entityManager.GetComponent <TransformComponent>(physicsDummy).MapPosition.X - 1) > 0.01f)); }