[Test]
public async Task TestCombatActionsAdded()
{
- await using var pair = await PoolManager.GetServerClient(new PoolSettings { Connected = true, DummyTicker = false});
+ await using var pair = await PoolManager.GetServerClient(new PoolSettings { Connected = true, DummyTicker = false });
var server = pair.Server;
var client = pair.Client;
var sEntMan = server.ResolveDependency<IEntityManager>();
namespace Content.IntegrationTests.Tests.Body;
[TestFixture]
-public sealed class GibTest
+public sealed class GibTest
{
[Test]
public async Task TestGib()
using Content.Shared.Rotation;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
-using Robust.Shared.Maths;
namespace Content.IntegrationTests.Tests.Body
{
var appearanceSystem = entityManager.System<SharedAppearanceSystem>();
var xformSystem = entityManager.System<SharedTransformSystem>();
+ var map = await pair.CreateTestMap();
+
await server.WaitAssertion(() =>
{
- var mapId = mapManager.CreateMap();
BodyComponent body = null;
human = entityManager.SpawnEntity("HumanBodyAndAppearanceDummy",
- new MapCoordinates(Vector2.Zero, mapId));
+ new MapCoordinates(Vector2.Zero, map.MapId));
Assert.Multiple(() =>
{
foreach (var leg in legs)
{
- xformSystem.DetachParentToNull(leg.Id, entityManager.GetComponent<TransformComponent>(leg.Id));
+ xformSystem.DetachEntity(leg.Id, entityManager.GetComponent<TransformComponent>(leg.Id));
}
});
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var mapLoader = entityManager.System<MapLoaderSystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
- MapId mapId;
EntityUid? grid = null;
BodyComponent body = default;
RespiratorComponent resp = default;
await server.WaitPost(() =>
{
- mapId = mapManager.CreateMap();
+ mapSys.CreateMap(out var mapId);
Assert.That(mapLoader.TryLoad(mapId, testMapName, out var roots));
var query = entityManager.GetEntityQuery<MapGridComponent>();
var entityManager = server.ResolveDependency<IEntityManager>();
var cfg = server.ResolveDependency<IConfigurationManager>();
var mapLoader = entityManager.System<MapLoaderSystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
- MapId mapId;
EntityUid? grid = null;
RespiratorComponent respirator = null;
EntityUid human = default;
await server.WaitPost(() =>
{
- mapId = mapManager.CreateMap();
+ mapSys.CreateMap(out var mapId);
Assert.That(mapLoader.TryLoad(mapId, testMapName, out var ents), Is.True);
var query = entityManager.GetEntityQuery<MapGridComponent>();
var mapLoader = entities.System<MapLoaderSystem>();
var bodySystem = entities.System<SharedBodySystem>();
var containerSystem = entities.System<SharedContainerSystem>();
+ var mapSys = entities.System<SharedMapSystem>();
await server.WaitAssertion(() =>
{
- var mapId = maps.CreateMap();
+ mapSys.CreateMap(out var mapId);
maps.CreateGrid(mapId);
var human = entities.SpawnEntity("HumanBodyDummy", new MapCoordinates(0, 0, mapId));
mapLoader.SaveMap(mapId, mapPath);
maps.DeleteMap(mapId);
- mapId = maps.CreateMap();
+ mapSys.CreateMap(out mapId);
Assert.That(mapLoader.TryLoad(mapId, mapPath, out _), Is.True);
var query = EnumerateQueryEnumerator(
await RunTicks(5);
Assert.That(buckle.Buckled, Is.True);
Assert.That(buckle.BuckledTo, Is.EqualTo(STarget));
- Assert.That(strap.BuckledEntities, Is.EquivalentTo(new[]{sUrist}));
+ Assert.That(strap.BuckledEntities, Is.EquivalentTo(new[] { sUrist }));
Assert.That(puller.Pulling, Is.Null);
Assert.That(pullable.Puller, Is.Null);
Assert.That(pullable.BeingPulled, Is.False);
// Start pulling, and thus unbuckle them
- await PressKey(ContentKeyFunctions.TryPullObject, cursorEntity:urist);
+ await PressKey(ContentKeyFunctions.TryPullObject, cursorEntity: urist);
await RunTicks(5);
Assert.That(buckle.Buckled, Is.False);
Assert.That(buckle.BuckledTo, Is.Null);
[TestFixture]
public sealed class CargoTest
{
- public static HashSet<ProtoId<CargoProductPrototype>> Ignored = new ()
- {
+ private static readonly HashSet<ProtoId<CargoProductPrototype>> Ignored =
+ [
// This is ignored because it is explicitly intended to be able to sell for more than it costs.
new("FunCrateGambling")
- };
+ ];
[Test]
public async Task NoCargoOrderArbitrage()
{
public sealed class FixedPoint2SerializationTest : SerializationTest
{
- protected override Assembly[] Assemblies => new[]
- {
+ protected override Assembly[] Assemblies =>
+ [
typeof(FixedPoint2SerializationTest).Assembly
- };
+ ];
[Test]
public void DeserializeNullTest()
[DataDefinition]
public sealed partial class FixedPoint2TestDefinition
{
- [DataField("unit")] public FixedPoint2? Unit { get; set; } = FixedPoint2.New(5);
+ [DataField] public FixedPoint2? Unit { get; set; } = FixedPoint2.New(5);
}
}
-using Content.Server.Chemistry.Containers.EntitySystems;
using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Chemistry.Reaction;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.FixedPoint;
await server.WaitPost(() =>
{
- var system = server.System<SolutionContainerSystem>();
+ var system = server.System<SharedSolutionContainerSystem>();
var beaker = server.EntMan.SpawnEntity("SolutionRoundingTestContainer", testMap.GridCoords);
system.TryGetSolution(beaker, "beaker", out var newSolutionEnt, out var newSolution);
-using Content.Server.Chemistry.Containers.EntitySystems;
using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.FixedPoint;
using Robust.Shared.GameObjects;
using Robust.Shared.Prototypes;
// To ensure volume(A) + volume(B) = volume(A+B)
// reactions can change this assumption
[TestFixture]
-[TestOf(typeof(SolutionContainerSystem))]
+[TestOf(typeof(SharedSolutionContainerSystem))]
public sealed class SolutionSystemTests
{
[TestPrototypes]
var entityManager = server.ResolveDependency<IEntityManager>();
var protoMan = server.ResolveDependency<IPrototypeManager>();
- var containerSystem = entityManager.System<SolutionContainerSystem>();
+ var containerSystem = entityManager.System<SharedSolutionContainerSystem>();
var testMap = await pair.CreateTestMap();
var coordinates = testMap.GridCoords;
var entityManager = server.ResolveDependency<IEntityManager>();
var protoMan = server.ResolveDependency<IPrototypeManager>();
- var containerSystem = entityManager.System<SolutionContainerSystem>();
+ var containerSystem = entityManager.System<SharedSolutionContainerSystem>();
var coordinates = testMap.GridCoords;
EntityUid beaker;
var entityManager = server.ResolveDependency<IEntityManager>();
var protoMan = server.ResolveDependency<IPrototypeManager>();
var testMap = await pair.CreateTestMap();
- var containerSystem = entityManager.System<SolutionContainerSystem>();
+ var containerSystem = entityManager.System<SharedSolutionContainerSystem>();
var coordinates = testMap.GridCoords;
EntityUid beaker;
var entityManager = server.ResolveDependency<IEntityManager>();
var protoMan = server.ResolveDependency<IPrototypeManager>();
- var containerSystem = entityManager.System<SolutionContainerSystem>();
+ var containerSystem = entityManager.System<SharedSolutionContainerSystem>();
var testMap = await pair.CreateTestMap();
var coordinates = testMap.GridCoords;
-using Content.Server.Chemistry.Containers.EntitySystems;
using Content.Shared.Chemistry.Reaction;
using Content.Shared.Chemistry.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
using System.Linq;
+using Content.Shared.Chemistry.EntitySystems;
namespace Content.IntegrationTests.Tests.Chemistry
{
var prototypeManager = server.ResolveDependency<IPrototypeManager>();
var testMap = await pair.CreateTestMap();
var coordinates = testMap.GridCoords;
- var solutionContainerSystem = entityManager.System<SolutionContainerSystem>();
+ var solutionContainerSystem = entityManager.System<SharedSolutionContainerSystem>();
foreach (var reactionPrototype in prototypeManager.EnumeratePrototypes<ReactionPrototype>())
{
Assert.That(netMan.IsConnected);
- Assert.That(sPlayerManager.Sessions.Count(), Is.EqualTo(1));
+ Assert.That(sPlayerManager.Sessions, Has.Length.EqualTo(1));
// No bans on record
Assert.Multiple(async () =>
{
var banReason = "test";
- Assert.That(sPlayerManager.Sessions.Count(), Is.EqualTo(1));
+ Assert.That(sPlayerManager.Sessions, Has.Length.EqualTo(1));
// Ban the client for 24 hours
await server.WaitPost(() => sConsole.ExecuteCommand($"ban {clientSession.Name} {banReason} 1440"));
});
await pair.RunTicksSync(5);
- Assert.That(sPlayerManager.Sessions.Count(), Is.EqualTo(0));
+ Assert.That(sPlayerManager.Sessions, Has.Length.EqualTo(0));
Assert.That(!netMan.IsConnected);
// Try to pardon a ban that does not exist
});
// Reconnect client. Slightly faster than dirtying the pair.
- Assert.That(sPlayerManager.Sessions.Count(), Is.EqualTo(0));
+ Assert.That(sPlayerManager.Sessions, Is.Empty);
client.SetConnectTarget(server);
await client.WaitPost(() => netMan.ClientConnect(null!, 0, null!));
await pair.RunTicksSync(5);
- Assert.That(sPlayerManager.Sessions.Count(), Is.EqualTo(1));
+ Assert.That(sPlayerManager.Sessions, Has.Length.EqualTo(1));
await pair.CleanReturnAsync();
}
var server = pair.Server;
var entManager = server.ResolveDependency<IEntityManager>();
var prototypeManager = server.ResolveDependency<IPrototypeManager>();
- var mobStateSystem = entManager.EntitySysManager.GetEntitySystem<MobStateSystem>();
- var damSystem = entManager.EntitySysManager.GetEntitySystem<DamageableSystem>();
- var rejuvenateSystem = entManager.EntitySysManager.GetEntitySystem<RejuvenateSystem>();
+ var mobStateSystem = entManager.System<MobStateSystem>();
+ var damSystem = entManager.System<DamageableSystem>();
+ var rejuvenateSystem = entManager.System<RejuvenateSystem>();
await server.WaitAssertion(() =>
{
var configManager = server.ResolveDependency<IConfigurationManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
- var gameTicker = entityManager.EntitySysManager.GetEntitySystem<GameTicker>();
+ var gameTicker = entityManager.System<GameTicker>();
await pair.RunTicksSync(5);
EntityUid dummy = default;
var mapManager = server.ResolveDependency<IMapManager>();
- var mapId = mapManager.CreateMap();
+ var map = await pair.CreateTestMap();
await server.WaitPost(() =>
{
- var pos = new MapCoordinates(Vector2.Zero, mapId);
+ var pos = new MapCoordinates(Vector2.Zero, map.MapId);
var entStorage = serverEntManager.EntitySysManager.GetEntitySystem<EntityStorageSystem>();
var container = serverEntManager.SpawnEntity("ContainerOcclusionA", pos);
dummy = serverEntManager.SpawnEntity("ContainerOcclusionDummy", pos);
EntityUid dummy = default;
var mapManager = server.ResolveDependency<IMapManager>();
- var mapId = mapManager.CreateMap();
+
+ var map = await pair.CreateTestMap();
await server.WaitPost(() =>
{
- var pos = new MapCoordinates(Vector2.Zero, mapId);
+ var pos = new MapCoordinates(Vector2.Zero, map.MapId);
var entStorage = serverEntManager.EntitySysManager.GetEntitySystem<EntityStorageSystem>();
var container = serverEntManager.SpawnEntity("ContainerOcclusionB", pos);
dummy = serverEntManager.SpawnEntity("ContainerOcclusionDummy", pos);
EntityUid dummy = default;
var mapManager = server.ResolveDependency<IMapManager>();
- var mapId = mapManager.CreateMap();
+
+ var map = await pair.CreateTestMap();
await server.WaitPost(() =>
{
- var pos = new MapCoordinates(Vector2.Zero, mapId);
+ var pos = new MapCoordinates(Vector2.Zero, map.MapId);
var entStorage = serverEntManager.EntitySysManager.GetEntitySystem<EntityStorageSystem>();
var containerA = serverEntManager.SpawnEntity("ContainerOcclusionA", pos);
var containerB = serverEntManager.SpawnEntity("ContainerOcclusionB", pos);
// Test basic math operations.
// I've already nearly broken these once. When editing the operators.
- DamageSpecifier input1 = new() { DamageDict = _input1 };
- DamageSpecifier input2 = new() { DamageDict = _input2 };
- DamageSpecifier output1 = new() { DamageDict = _output1 };
- DamageSpecifier output2 = new() { DamageDict = _output2 };
- DamageSpecifier output3 = new() { DamageDict = _output3 };
- DamageSpecifier output4 = new() { DamageDict = _output4 };
- DamageSpecifier output5 = new() { DamageDict = _output5 };
+ DamageSpecifier input1 = new() { DamageDict = Input1 };
+ DamageSpecifier input2 = new() { DamageDict = Input2 };
+ DamageSpecifier output1 = new() { DamageDict = Output1 };
+ DamageSpecifier output2 = new() { DamageDict = Output2 };
+ DamageSpecifier output3 = new() { DamageDict = Output3 };
+ DamageSpecifier output4 = new() { DamageDict = Output4 };
+ DamageSpecifier output5 = new() { DamageDict = Output5 };
Assert.Multiple(() =>
{
- Assert.That((-input1).Equals(output1));
- Assert.That((input1 / 2).Equals(output2));
- Assert.That((input1 * 2).Equals(output3));
+ Assert.That(-input1, Is.EqualTo(output1));
+ Assert.That(input1 / 2, Is.EqualTo(output2));
+ Assert.That(input1 * 2, Is.EqualTo(output3));
});
- var difference = (input1 - input2);
- Assert.That(difference.Equals(output4));
+ var difference = input1 - input2;
+ Assert.That(difference, Is.EqualTo(output4));
- var difference2 = (-input2) + input1;
- Assert.That(difference.Equals(difference2));
+ var difference2 = -input2 + input1;
+ Assert.That(difference, Is.EqualTo(difference2));
difference.Clamp(-0.25f, 0.25f);
- Assert.That(difference.Equals(output5));
+ Assert.That(difference, Is.EqualTo(output5));
}
- static Dictionary<string, FixedPoint2> _input1 = new()
+ private static readonly Dictionary<string, FixedPoint2> Input1 = new()
{
{ "A", 1.5f },
{ "B", 2 },
{ "C", 3 }
};
- static Dictionary<string, FixedPoint2> _input2 = new()
+ private static readonly Dictionary<string, FixedPoint2> Input2 = new()
{
{ "A", 1 },
{ "B", 2 },
{ "D", 0.05f }
};
- static Dictionary<string, FixedPoint2> _output1 = new()
+ private static readonly Dictionary<string, FixedPoint2> Output1 = new()
{
{ "A", -1.5f },
{ "B", -2 },
{ "C", -3 }
};
- static Dictionary<string, FixedPoint2> _output2 = new()
+ private static readonly Dictionary<string, FixedPoint2> Output2 = new()
{
{ "A", 0.75f },
{ "B", 1 },
{ "C", 1.5 }
};
- static Dictionary<string, FixedPoint2> _output3 = new()
+ private static readonly Dictionary<string, FixedPoint2> Output3 = new()
{
{ "A", 3f },
{ "B", 4 },
{ "C", 6 }
};
- static Dictionary<string, FixedPoint2> _output4 = new()
+ private static readonly Dictionary<string, FixedPoint2> Output4 = new()
{
{ "A", 0.5f },
{ "B", 0 },
{ "D", -0.05f }
};
- static Dictionary<string, FixedPoint2> _output5 = new()
+ private static readonly Dictionary<string, FixedPoint2> Output5 = new()
{
{ "A", 0.25f },
{ "B", 0 },
FixedPoint2 typeDamage;
+ var map = await pair.CreateTestMap();
+
await server.WaitPost(() =>
{
- var map = sMapManager.CreateMap();
- var coordinates = new MapCoordinates(0, 0, map);
+ var coordinates = map.MapCoords;
sDamageableEntity = sEntityManager.SpawnEntity("TestDamageableEntityId", coordinates);
sDamageableComponent = sEntityManager.GetComponent<DamageableComponent>(sDamageableEntity);
var xformSystem = entityManager.System<SharedTransformSystem>();
PhysicsComponent physBody = null;
- EntityUid AirlockPhysicsDummy = default;
+ EntityUid airlockPhysicsDummy = default;
EntityUid airlock = default;
DoorComponent doorComponent = null;
- var AirlockPhysicsDummyStartingX = -1;
+ var airlockPhysicsDummyStartingX = -1;
+
+ var map = await pair.CreateTestMap();
await server.WaitAssertion(() =>
{
- var mapId = mapManager.CreateMap();
-
- var humanCoordinates = new MapCoordinates(new Vector2(AirlockPhysicsDummyStartingX, 0), mapId);
- AirlockPhysicsDummy = entityManager.SpawnEntity("AirlockPhysicsDummy", humanCoordinates);
+ var humanCoordinates = new MapCoordinates(new Vector2(airlockPhysicsDummyStartingX, 0), map.MapId);
+ airlockPhysicsDummy = entityManager.SpawnEntity("AirlockPhysicsDummy", humanCoordinates);
- airlock = entityManager.SpawnEntity("AirlockDummy", new MapCoordinates(new Vector2(0, 0), mapId));
+ airlock = entityManager.SpawnEntity("AirlockDummy", new MapCoordinates(new Vector2(0, 0), map.MapId));
Assert.Multiple(() =>
{
- Assert.That(entityManager.TryGetComponent(AirlockPhysicsDummy, out physBody), Is.True);
+ Assert.That(entityManager.TryGetComponent(airlockPhysicsDummy, out physBody), Is.True);
Assert.That(entityManager.TryGetComponent(airlock, out doorComponent), Is.True);
});
Assert.That(doorComponent.State, Is.EqualTo(DoorState.Closed));
await server.WaitAssertion(() => Assert.That(physBody, Is.Not.EqualTo(null)));
await server.WaitPost(() =>
{
- physicsSystem.SetLinearVelocity(AirlockPhysicsDummy, new Vector2(0.5f, 0f), body: physBody);
+ physicsSystem.SetLinearVelocity(airlockPhysicsDummy, new Vector2(0.5f, 0f), body: physBody);
});
for (var i = 0; i < 240; i += 10)
// Blocked by the airlock
await server.WaitAssertion(() =>
{
- Assert.That(Math.Abs(xformSystem.GetWorldPosition(AirlockPhysicsDummy).X - 1), Is.GreaterThan(0.01f));
+ Assert.That(Math.Abs(xformSystem.GetWorldPosition(airlockPhysicsDummy).X - 1), Is.GreaterThan(0.01f));
});
await pair.CleanReturnAsync();
}
{
foreach (var proto in prototypeManager.EnumeratePrototypes<EntityPrototype>())
{
- if (proto.NoSpawn || proto.Abstract || pair.IsTestPrototype(proto) || !proto.Components.ContainsKey("Sprite"))
+ if (proto.HideSpawnMenu || proto.Abstract || pair.IsTestPrototype(proto) || !proto.Components.ContainsKey("Sprite"))
continue;
Assert.DoesNotThrow(() =>
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
-using Content.Server.Humanoid.Components;
-using Content.Shared.Coordinates;
-using Content.Shared.Prototypes;
using Robust.Shared;
using Robust.Shared.Configuration;
using Robust.Shared.GameObjects;
using Robust.Shared.Log;
using Robust.Shared.Map;
-using Robust.Shared.Map.Components;
using Robust.Shared.Maths;
using Robust.Shared.Prototypes;
foreach (var protoId in protoIds)
{
- var mapId = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId);
var grid = mapManager.CreateGridEntity(mapId);
// TODO: Fix this better in engine.
mapSystem.SetTile(grid.Owner, grid.Comp, Vector2i.Zero, new Tile(1));
var prototypeMan = server.ResolveDependency<IPrototypeManager>();
var mapManager = server.ResolveDependency<IMapManager>();
var sEntMan = server.ResolveDependency<IEntityManager>();
+ var mapSys = server.System<SharedMapSystem>();
Assert.That(cfg.GetCVar(CVars.NetPVS), Is.False);
{
foreach (var protoId in protoIds)
{
- var mapId = mapManager.CreateMap();
+ mapSys.CreateMap(out var mapId);
var grid = mapManager.CreateGridEntity(mapId);
var ent = sEntMan.SpawnEntity(protoId, new EntityCoordinates(grid.Owner, 0.5f, 0.5f));
foreach (var (_, component) in sEntMan.GetNetComponents(ent))
var settings = new PoolSettings { Connected = true, Dirty = true };
await using var pair = await PoolManager.GetServerClient(settings);
var mapManager = pair.Server.ResolveDependency<IMapManager>();
+ var mapSys = pair.Server.System<SharedMapSystem>();
var server = pair.Server;
var client = pair.Client;
await server.WaitPost(() =>
{
- mapId = mapManager.CreateMap();
+ mapSys.CreateMap(out mapId);
});
var coords = new MapCoordinates(Vector2.Zero, mapId);
[TestOf(typeof(SpreaderSystem))]
public sealed class FluidSpill
{
- private static PuddleComponent? GetPuddle(IEntityManager entityManager, MapGridComponent mapGrid, Vector2i pos)
+ private static PuddleComponent? GetPuddle(IEntityManager entityManager, Entity<MapGridComponent> mapGrid, Vector2i pos)
{
return GetPuddleEntity(entityManager, mapGrid, pos)?.Comp;
}
- private static Entity<PuddleComponent>? GetPuddleEntity(IEntityManager entityManager, MapGridComponent mapGrid, Vector2i pos)
+ private static Entity<PuddleComponent>? GetPuddleEntity(IEntityManager entityManager, Entity<MapGridComponent> mapGrid, Vector2i pos)
{
- foreach (var uid in mapGrid.GetAnchoredEntities(pos))
+ var mapSys = entityManager.System<SharedMapSystem>();
+ foreach (var uid in mapSys.GetAnchoredEntities(mapGrid, mapGrid.Comp, pos))
{
if (entityManager.TryGetComponent(uid, out PuddleComponent? puddleComponent))
return (uid, puddleComponent);
var server = pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
- var puddleSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<PuddleSystem>();
+ var puddleSystem = server.System<PuddleSystem>();
+ var mapSystem = server.System<SharedMapSystem>();
var gameTiming = server.ResolveDependency<IGameTiming>();
- MapId mapId;
EntityUid gridId = default;
/*
*/
await server.WaitPost(() =>
{
- mapId = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId);
var grid = mapManager.CreateGridEntity(mapId);
gridId = grid.Owner;
{
for (var y = 0; y < 3; y++)
{
- grid.Comp.SetTile(new Vector2i(x, y), new Tile(1));
+ mapSystem.SetTile(grid, new Vector2i(x, y), new Tile(1));
}
}
- entityManager.SpawnEntity("WallReinforced", grid.Comp.GridTileToLocal(new Vector2i(0, 1)));
- entityManager.SpawnEntity("WallReinforced", grid.Comp.GridTileToLocal(new Vector2i(1, 0)));
+ entityManager.SpawnEntity("WallReinforced", mapSystem.GridTileToLocal(grid, grid.Comp, new Vector2i(0, 1)));
+ entityManager.SpawnEntity("WallReinforced", mapSystem.GridTileToLocal(grid, grid.Comp, new Vector2i(1, 0)));
});
{
var grid = entityManager.GetComponent<MapGridComponent>(gridId);
var solution = new Solution("Blood", FixedPoint2.New(100));
- var tileRef = grid.GetTileRef(puddleOrigin);
+ var tileRef = mapSystem.GetTileRef(gridId, grid, puddleOrigin);
#pragma warning disable NUnit2045 // Interdependent tests
Assert.That(puddleSystem.TrySpillAt(tileRef, solution, out _), Is.True);
- Assert.That(GetPuddle(entityManager, grid, puddleOrigin), Is.Not.Null);
+ Assert.That(GetPuddle(entityManager, (gridId, grid), puddleOrigin), Is.Not.Null);
#pragma warning restore NUnit2045
});
await server.WaitAssertion(() =>
{
var grid = entityManager.GetComponent<MapGridComponent>(gridId);
- var puddle = GetPuddleEntity(entityManager, grid, puddleOrigin);
+ var puddle = GetPuddleEntity(entityManager, (gridId, grid), puddleOrigin);
#pragma warning disable NUnit2045 // Interdependent tests
Assert.That(puddle, Is.Not.Null);
}
var newPos = new Vector2i(x, y);
- var sidePuddle = GetPuddle(entityManager, grid, newPos);
+ var sidePuddle = GetPuddle(entityManager, (gridId, grid), newPos);
Assert.That(sidePuddle, Is.Null);
}
}
using Content.Shared.Fluids.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
-using Robust.Shared.Map.Components;
namespace Content.IntegrationTests.Tests.Fluids
{
var testMap = await pair.CreateTestMap();
- var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
- var spillSystem = entitySystemManager.GetEntitySystem<PuddleSystem>();
+ var spillSystem = server.System<PuddleSystem>();
await server.WaitAssertion(() =>
{
var server = pair.Server;
var testMap = await pair.CreateTestMap();
- var grid = testMap.Grid.Comp;
+ var grid = testMap.Grid;
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
- var spillSystem = entitySystemManager.GetEntitySystem<PuddleSystem>();
+ var spillSystem = server.System<PuddleSystem>();
+ var mapSystem = server.System<SharedMapSystem>();
// Remove all tiles
await server.WaitPost(() =>
{
- foreach (var tile in grid.GetAllTiles())
+ var tiles = mapSystem.GetAllTiles(grid.Owner, grid.Comp);
+ foreach (var tile in tiles)
{
- grid.SetTile(tile.GridIndices, Tile.Empty);
+ mapSystem.SetTile(grid, tile.GridIndices, Tile.Empty);
}
});
var mapMan = server.ResolveDependency<IMapManager>();
var sysMan = server.ResolveDependency<IEntitySystemManager>();
var logMan = server.ResolveDependency<ILogManager>();
+ var mapSys = server.System<SharedMapSystem>();
var logger = logMan.RootSawmill;
await server.WaitPost(() =>
var followerSystem = sysMan.GetEntitySystem<FollowerSystem>();
// Create a map to spawn the observers on.
- var map = mapMan.CreateMap();
+ mapSys.CreateMap(out var map);
// Spawn an observer to be followed.
var followed = entMan.SpawnEntity(GameTicker.ObserverPrototypeName, new MapCoordinates(0, 0, map));
followerSystem.StartFollowingEntity(follower, followed);
- entMan.DeleteEntity(mapMan.GetMapEntityId(map));
+ entMan.DeleteEntity(mapSys.GetMap(map));
});
await pair.CleanReturnAsync();
}
#nullable enable
-using System.Numerics;
using Content.Server.Cuffs;
using Content.Shared.Body.Components;
using Content.Shared.Cuffs.Components;
using Robust.Server.Console;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
-using Robust.Shared.Maths;
namespace Content.IntegrationTests.Tests.GameObjects.Components.ActionBlocking
{
var mapManager = server.ResolveDependency<IMapManager>();
var host = server.ResolveDependency<IServerConsoleHost>();
+ var map = await pair.CreateTestMap();
+
await server.WaitAssertion(() =>
{
- var mapId = mapManager.CreateMap();
- var coordinates = new MapCoordinates(Vector2.Zero, mapId);
+ var coordinates = map.MapCoords;
var cuffableSys = entityManager.System<CuffableSystem>();
var xformSys = entityManager.System<SharedTransformSystem>();
Assert.That(sys.IsEntityValid(client.AttachedEntity, def), Is.True);
// By default, traitor/antag preferences are disabled, so the pool should be empty.
- var sessions = new List<ICommonSession>{pair.Player!};
+ var sessions = new List<ICommonSession> { pair.Player! };
var pool = sys.GetPlayerPool(rule, sessions, def);
Assert.That(pool.Count, Is.EqualTo(0));
player = pair.Player!.AttachedEntity!.Value;
Assert.That(entMan.EntityExists(player));
- ticker.SetGamePreset((GamePresetPrototype?)null);
+ ticker.SetGamePreset((GamePresetPrototype?) null);
server.CfgMan.SetCVar(CCVars.GridFill, false);
server.CfgMan.SetCVar(CCVars.GameLobbyFallbackEnabled, true);
server.CfgMan.SetCVar(CCVars.GameLobbyDefaultPreset, "secret");
var testMap = await pair.CreateTestMap();
- EntityUid generator = default;
- var entityMan = server.ResolveDependency<IEntityManager>();
- var mapMan = server.ResolveDependency<IMapManager>();
+ var entityMan = server.EntMan;
+ var mapMan = server.MapMan;
var mapSys = entityMan.System<SharedMapSystem>();
- MapGridComponent grid1 = null;
- MapGridComponent grid2 = null;
- EntityUid grid1Entity = default!;
- EntityUid grid2Entity = default!;
+ EntityUid generator = default;
+ Entity<MapGridComponent> grid1 = default;
+ Entity<MapGridComponent> grid2 = default;
// Create grids
await server.WaitAssertion(() =>
{
var mapId = testMap.MapId;
- grid1 = mapMan.CreateGrid(mapId);
- grid2 = mapMan.CreateGrid(mapId);
- grid1Entity = grid1.Owner;
- grid2Entity = grid2.Owner;
+ grid1 = mapMan.CreateGridEntity(mapId);
+ grid2 = mapMan.CreateGridEntity(mapId);
- mapSys.SetTile(grid1Entity, grid1, Vector2i.Zero, new Tile(1));
- mapSys.SetTile(grid2Entity, grid2, Vector2i.Zero, new Tile(1));
+ mapSys.SetTile(grid1, grid1, Vector2i.Zero, new Tile(1));
+ mapSys.SetTile(grid2, grid2, Vector2i.Zero, new Tile(1));
- generator = entityMan.SpawnEntity("GridGravityGeneratorDummy", new EntityCoordinates(grid1Entity, 0.5f, 0.5f));
+ generator = entityMan.SpawnEntity("GridGravityGeneratorDummy", new EntityCoordinates(grid1, 0.5f, 0.5f));
Assert.Multiple(() =>
{
Assert.That(entityMan.HasComponent<GravityGeneratorComponent>(generator));
Assert.Multiple(() =>
{
Assert.That(generatorComponent.GravityActive, Is.True);
- Assert.That(!entityMan.GetComponent<GravityComponent>(grid1Entity).EnabledVV);
- Assert.That(entityMan.GetComponent<GravityComponent>(grid2Entity).EnabledVV);
+ Assert.That(!entityMan.GetComponent<GravityComponent>(grid1).EnabledVV);
+ Assert.That(entityMan.GetComponent<GravityComponent>(grid2).EnabledVV);
});
// Re-enable needs power so it turns off again.
Assert.Multiple(() =>
{
Assert.That(generatorComponent.GravityActive, Is.False);
- Assert.That(entityMan.GetComponent<GravityComponent>(grid2Entity).EnabledVV, Is.False);
+ Assert.That(entityMan.GetComponent<GravityComponent>(grid2).EnabledVV, Is.False);
});
});
var sysMan = server.ResolveDependency<IEntitySystemManager>();
var handSys = sysMan.GetEntitySystem<SharedHandsSystem>();
- var mapId = MapId.Nullspace;
- var coords = MapCoordinates.Nullspace;
- await server.WaitAssertion(() =>
- {
- mapId = mapManager.CreateMap();
- coords = new MapCoordinates(Vector2.Zero, mapId);
- });
+ var map = await pair.CreateTestMap();
+ var mapId = map.MapId;
+ var coords = map.MapCoords;
await server.WaitIdleAsync();
EntityUid user = default;
var sysMan = server.ResolveDependency<IEntitySystemManager>();
var handSys = sysMan.GetEntitySystem<SharedHandsSystem>();
- var mapId = MapId.Nullspace;
- var coords = MapCoordinates.Nullspace;
- await server.WaitAssertion(() =>
- {
- mapId = mapManager.CreateMap();
- coords = new MapCoordinates(Vector2.Zero, mapId);
- });
+ var map = await pair.CreateTestMap();
+ var mapId = map.MapId;
+ var coords = map.MapCoords;
await server.WaitIdleAsync();
EntityUid user = default;
var sysMan = server.ResolveDependency<IEntitySystemManager>();
var handSys = sysMan.GetEntitySystem<SharedHandsSystem>();
- var mapId = MapId.Nullspace;
- var coords = MapCoordinates.Nullspace;
- await server.WaitAssertion(() =>
- {
- mapId = mapManager.CreateMap();
- coords = new MapCoordinates(Vector2.Zero, mapId);
- });
+ var map = await pair.CreateTestMap();
+ var mapId = map.MapId;
+ var coords = map.MapCoords;
await server.WaitIdleAsync();
EntityUid user = default;
var sysMan = server.ResolveDependency<IEntitySystemManager>();
var handSys = sysMan.GetEntitySystem<SharedHandsSystem>();
- var mapId = MapId.Nullspace;
- var coords = MapCoordinates.Nullspace;
- await server.WaitAssertion(() =>
- {
- mapId = mapManager.CreateMap();
- coords = new MapCoordinates(Vector2.Zero, mapId);
- });
+ var map = await pair.CreateTestMap();
+ var mapId = map.MapId;
+ var coords = map.MapCoords;
await server.WaitIdleAsync();
EntityUid user = default;
var handSys = sysMan.GetEntitySystem<SharedHandsSystem>();
var conSystem = sysMan.GetEntitySystem<SharedContainerSystem>();
- var mapId = MapId.Nullspace;
- var coords = MapCoordinates.Nullspace;
- await server.WaitAssertion(() =>
- {
- mapId = mapManager.CreateMap();
- coords = new MapCoordinates(Vector2.Zero, mapId);
- });
+ var map = await pair.CreateTestMap();
+ var mapId = map.MapId;
+ var coords = map.MapCoords;
await server.WaitIdleAsync();
EntityUid user = default;
EntityUid other = default;
MapCoordinates mapCoordinates = default;
+ var map = await pair.CreateTestMap();
+
await server.WaitAssertion(() =>
{
- var mapId = mapManager.CreateMap();
- var coordinates = new MapCoordinates(Vector2.Zero, mapId);
+ var coordinates = map.MapCoords;
origin = sEntities.SpawnEntity(HumanId, coordinates);
other = sEntities.SpawnEntity(HumanId, coordinates);
var tile = Tile.Empty;
var serverCoords = SEntMan.GetCoordinates(coords ?? TargetCoords);
- var pos = serverCoords.ToMap(SEntMan, Transform);
+ var pos = Transform.ToMapCoordinates(serverCoords);
await Server.WaitPost(() =>
{
- if (MapMan.TryFindGridAt(pos, out _, out var grid))
- tile = grid.GetTileRef(serverCoords).Tile;
+ if (MapMan.TryFindGridAt(pos, out var gridUid, out var grid))
+ tile = MapSystem.GetTileRef(gridUid, grid, serverCoords).Tile;
});
Assert.That(tile.TypeId, Is.EqualTo(targetTile.TypeId));
/// <summary>
/// Set the tile at the target position to some prototype.
/// </summary>
- protected async Task SetTile(string? proto, NetCoordinates? coords = null, MapGridComponent? grid = null)
+ protected async Task SetTile(string? proto, NetCoordinates? coords = null, Entity<MapGridComponent>? grid = null)
{
var tile = proto == null
? Tile.Empty
: new Tile(TileMan[proto].TileId);
- var pos = SEntMan.GetCoordinates(coords ?? TargetCoords).ToMap(SEntMan, Transform);
+ var pos = Transform.ToMapCoordinates(SEntMan.GetCoordinates(coords ?? TargetCoords));
+ EntityUid gridUid;
+ MapGridComponent? gridComp;
await Server.WaitPost(() =>
{
- if (grid != null || MapMan.TryFindGridAt(pos, out var gridUid, out grid))
+ if (grid is { } gridEnt)
{
- grid.SetTile(SEntMan.GetCoordinates(coords ?? TargetCoords), tile);
+ MapSystem.SetTile(gridEnt, SEntMan.GetCoordinates(coords ?? TargetCoords), tile);
+ return;
+ }
+ else if (MapMan.TryFindGridAt(pos, out var gUid, out var gComp))
+ {
+ MapSystem.SetTile(gUid, gComp, SEntMan.GetCoordinates(coords ?? TargetCoords), tile);
return;
}
if (proto == null)
return;
- var gridEnt = MapMan.CreateGridEntity(MapData.MapId);
+ gridEnt = MapMan.CreateGridEntity(MapData.MapId);
grid = gridEnt;
gridUid = gridEnt;
+ gridComp = gridEnt.Comp;
var gridXform = SEntMan.GetComponent<TransformComponent>(gridUid);
Transform.SetWorldPosition(gridXform, pos.Position);
- grid.SetTile(SEntMan.GetCoordinates(coords ?? TargetCoords), tile);
+ MapSystem.SetTile((gridUid, gridComp), SEntMan.GetCoordinates(coords ?? TargetCoords), tile);
- if (!MapMan.TryFindGridAt(pos, out _, out grid))
+ if (!MapMan.TryFindGridAt(pos, out _, out _))
Assert.Fail("Failed to create grid?");
});
await AssertTile(proto, coords);
#nullable enable
-using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Numerics;
using Content.Client.Construction;
protected SharedItemToggleSystem ItemToggleSys = default!;
protected InteractionTestSystem STestSystem = default!;
protected SharedTransformSystem Transform = default!;
+ protected SharedMapSystem MapSystem = default!;
protected ISawmill SLogger = default!;
protected SharedUserInterfaceSystem SUiSys = default!;
[SetUp]
public virtual async Task Setup()
{
- Pair = await PoolManager.GetServerClient(new PoolSettings { Connected = true, Dirty = true});
+ Pair = await PoolManager.GetServerClient(new PoolSettings { Connected = true, Dirty = true });
// server dependencies
SEntMan = Server.ResolveDependency<IEntityManager>();
ItemToggleSys = SEntMan.System<SharedItemToggleSystem>();
DoAfterSys = SEntMan.System<SharedDoAfterSystem>();
Transform = SEntMan.System<SharedTransformSystem>();
+ MapSystem = SEntMan.System<SharedMapSystem>();
SConstruction = SEntMan.System<Server.Construction.ConstructionSystem>();
STestSystem = SEntMan.System<InteractionTestSystem>();
Stack = SEntMan.System<StackSystem>();
// Setup map.
await Pair.CreateTestMap();
- PlayerCoords = SEntMan.GetNetCoordinates(MapData.GridCoords.Offset(new Vector2(0.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan));
- TargetCoords = SEntMan.GetNetCoordinates(MapData.GridCoords.Offset(new Vector2(1.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan));
- await SetTile(Plating, grid: MapData.Grid.Comp);
+
+ PlayerCoords = SEntMan.GetNetCoordinates(Transform.WithEntityId(MapData.GridCoords.Offset(new Vector2(0.5f, 0.5f)), MapData.MapUid));
+ TargetCoords = SEntMan.GetNetCoordinates(Transform.WithEntityId(MapData.GridCoords.Offset(new Vector2(1.5f, 0.5f)), MapData.MapUid));
+ await SetTile(Plating, grid: MapData.Grid);
// Get player data
var sPlayerMan = Server.ResolveDependency<Robust.Server.Player.IPlayerManager>();
await TearDown();
}
- protected virtual async Task TearDown()
+ protected virtual Task TearDown()
{
+ return Task.CompletedTask;
}
}
protos.Add(kind, ids);
}
- Assert.That(protoMan.ValidateStaticFields(typeof(StringValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(StringArrayValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdArrayValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdTestValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdArrayValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdListValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdSetValid), protos).Count, Is.Zero);
- Assert.That(protoMan.ValidateStaticFields(typeof(PrivateProtoIdArrayValid), protos).Count, Is.Zero);
-
- Assert.That(protoMan.ValidateStaticFields(typeof(StringInvalid), protos).Count, Is.EqualTo(1));
- Assert.That(protoMan.ValidateStaticFields(typeof(StringArrayInvalid), protos).Count, Is.EqualTo(2));
- Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdInvalid), protos).Count, Is.EqualTo(1));
- Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdArrayInvalid), protos).Count, Is.EqualTo(2));
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdTestInvalid), protos).Count, Is.EqualTo(1));
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdArrayInvalid), protos).Count, Is.EqualTo(2));
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdListInvalid), protos).Count, Is.EqualTo(2));
- Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdSetInvalid), protos).Count, Is.EqualTo(2));
- Assert.That(protoMan.ValidateStaticFields(typeof(PrivateProtoIdArrayInvalid), protos).Count, Is.EqualTo(2));
-
+ Assert.That(protoMan.ValidateStaticFields(typeof(StringValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(StringArrayValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdArrayValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdTestValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdArrayValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdListValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdSetValid), protos), Is.Empty);
+ Assert.That(protoMan.ValidateStaticFields(typeof(PrivateProtoIdArrayValid), protos), Is.Empty);
+
+ Assert.That(protoMan.ValidateStaticFields(typeof(StringInvalid), protos), Has.Count.EqualTo(1));
+ Assert.That(protoMan.ValidateStaticFields(typeof(StringArrayInvalid), protos), Has.Count.EqualTo(2));
+ Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdInvalid), protos), Has.Count.EqualTo(1));
+ Assert.That(protoMan.ValidateStaticFields(typeof(EntProtoIdArrayInvalid), protos), Has.Count.EqualTo(2));
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdTestInvalid), protos), Has.Count.EqualTo(1));
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdArrayInvalid), protos), Has.Count.EqualTo(2));
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdListInvalid), protos), Has.Count.EqualTo(2));
+ Assert.That(protoMan.ValidateStaticFields(typeof(ProtoIdSetInvalid), protos), Has.Count.EqualTo(2));
+ Assert.That(protoMan.ValidateStaticFields(typeof(PrivateProtoIdArrayInvalid), protos), Has.Count.EqualTo(2));
+
await pair.CleanReturnAsync();
}
id: StaticFieldTestTag
";
- [Reflect(false)] private sealed class StringValid
+ [Reflect(false)]
+ private sealed class StringValid
{
[ValidatePrototypeId<TagPrototype>] public static string Tag = "StaticFieldTestTag";
}
- [Reflect(false)] private sealed class StringInvalid
+ [Reflect(false)]
+ private sealed class StringInvalid
{
[ValidatePrototypeId<TagPrototype>] public static string Tag = string.Empty;
}
- [Reflect(false)] private sealed class StringArrayValid
+ [Reflect(false)]
+ private sealed class StringArrayValid
{
- [ValidatePrototypeId<TagPrototype>] public static string[] Tag = {"StaticFieldTestTag", "StaticFieldTestTag"};
+ [ValidatePrototypeId<TagPrototype>] public static string[] Tag = ["StaticFieldTestTag", "StaticFieldTestTag"];
}
- [Reflect(false)] private sealed class StringArrayInvalid
+ [Reflect(false)]
+ private sealed class StringArrayInvalid
{
- [ValidatePrototypeId<TagPrototype>] public static string[] Tag = {string.Empty, "StaticFieldTestTag", string.Empty};
+ [ValidatePrototypeId<TagPrototype>] public static string[] Tag = [string.Empty, "StaticFieldTestTag", string.Empty];
}
- [Reflect(false)] private sealed class EntProtoIdValid
+ [Reflect(false)]
+ private sealed class EntProtoIdValid
{
public static EntProtoId Tag = "StaticFieldTestEnt";
}
- [Reflect(false)] private sealed class EntProtoIdInvalid
+ [Reflect(false)]
+ private sealed class EntProtoIdInvalid
{
public static EntProtoId Tag = string.Empty;
}
- [Reflect(false)] private sealed class EntProtoIdArrayValid
+ [Reflect(false)]
+ private sealed class EntProtoIdArrayValid
{
- public static EntProtoId[] Tag = {"StaticFieldTestEnt", "StaticFieldTestEnt"};
+ public static EntProtoId[] Tag = ["StaticFieldTestEnt", "StaticFieldTestEnt"];
}
- [Reflect(false)] private sealed class EntProtoIdArrayInvalid
+ [Reflect(false)]
+ private sealed class EntProtoIdArrayInvalid
{
- public static EntProtoId[] Tag = {string.Empty, "StaticFieldTestEnt", string.Empty};
+ public static EntProtoId[] Tag = [string.Empty, "StaticFieldTestEnt", string.Empty];
}
- [Reflect(false)] private sealed class ProtoIdTestValid
+ [Reflect(false)]
+ private sealed class ProtoIdTestValid
{
public static ProtoId<TagPrototype> Tag = "StaticFieldTestTag";
}
- [Reflect(false)] private sealed class ProtoIdTestInvalid
+ [Reflect(false)]
+ private sealed class ProtoIdTestInvalid
{
public static ProtoId<TagPrototype> Tag = string.Empty;
}
- [Reflect(false)] private sealed class ProtoIdArrayValid
+ [Reflect(false)]
+ private sealed class ProtoIdArrayValid
{
- public static ProtoId<TagPrototype>[] Tag = {"StaticFieldTestTag", "StaticFieldTestTag"};
+ public static ProtoId<TagPrototype>[] Tag = ["StaticFieldTestTag", "StaticFieldTestTag"];
}
- [Reflect(false)] private sealed class ProtoIdArrayInvalid
+ [Reflect(false)]
+ private sealed class ProtoIdArrayInvalid
{
- public static ProtoId<TagPrototype>[] Tag = {string.Empty, "StaticFieldTestTag", string.Empty};
+ public static ProtoId<TagPrototype>[] Tag = [string.Empty, "StaticFieldTestTag", string.Empty];
}
- [Reflect(false)] private sealed class ProtoIdListValid
+ [Reflect(false)]
+ private sealed class ProtoIdListValid
{
- public static List<ProtoId<TagPrototype>> Tag = new() {"StaticFieldTestTag", "StaticFieldTestTag"};
+ public static List<ProtoId<TagPrototype>> Tag = ["StaticFieldTestTag", "StaticFieldTestTag"];
}
- [Reflect(false)] private sealed class ProtoIdListInvalid
+ [Reflect(false)]
+ private sealed class ProtoIdListInvalid
{
- public static List<ProtoId<TagPrototype>> Tag = new() {string.Empty, "StaticFieldTestTag", string.Empty};
+ public static List<ProtoId<TagPrototype>> Tag = [string.Empty, "StaticFieldTestTag", string.Empty];
}
- [Reflect(false)] private sealed class ProtoIdSetValid
+ [Reflect(false)]
+ private sealed class ProtoIdSetValid
{
- public static HashSet<ProtoId<TagPrototype>> Tag = new() {"StaticFieldTestTag", "StaticFieldTestTag"};
+ public static HashSet<ProtoId<TagPrototype>> Tag = ["StaticFieldTestTag", "StaticFieldTestTag"];
}
- [Reflect(false)] private sealed class ProtoIdSetInvalid
+ [Reflect(false)]
+ private sealed class ProtoIdSetInvalid
{
- public static HashSet<ProtoId<TagPrototype>> Tag = new() {string.Empty, "StaticFieldTestTag", string.Empty, " "};
+ public static HashSet<ProtoId<TagPrototype>> Tag = [string.Empty, "StaticFieldTestTag", string.Empty, " "];
}
- [Reflect(false)] private sealed class PrivateProtoIdArrayValid
+ [Reflect(false)]
+ private sealed class PrivateProtoIdArrayValid
{
- private static ProtoId<TagPrototype>[] Tag = {"StaticFieldTestTag", "StaticFieldTestTag"};
+ private static readonly ProtoId<TagPrototype>[] Tag = ["StaticFieldTestTag", "StaticFieldTestTag"];
}
- [Reflect(false)] private sealed class PrivateProtoIdArrayInvalid
+ [Reflect(false)]
+ private sealed class PrivateProtoIdArrayInvalid
{
- private static ProtoId<TagPrototype>[] Tag = {string.Empty, "StaticFieldTestTag", string.Empty};
+ private static readonly ProtoId<TagPrototype>[] Tag = [string.Empty, "StaticFieldTestTag", string.Empty];
}
}
using System.Linq;
using Content.Server.Construction.Components;
using Content.Shared.Construction.Components;
-using Content.Shared.Prototypes;
using Robust.Shared.GameObjects;
using Robust.Shared.Prototypes;
var server = pair.Server;
var protoMan = server.ResolveDependency<IPrototypeManager>();
+ var compFact = server.ResolveDependency<IComponentFactory>();
await server.WaitAssertion(() =>
{
.Where(p => !pair.IsTestPrototype(p))
.Where(p => !_ignoredPrototypes.Contains(p.ID)))
{
- if (!p.TryGetComponent<MachineBoardComponent>(out var mbc))
+ if (!p.TryGetComponent<MachineBoardComponent>(out var mbc, compFact))
continue;
var mId = mbc.Prototype;
{
Assert.That(protoMan.TryIndex<EntityPrototype>(mId, out var mProto),
$"Machine board {p.ID}'s corresponding machine has an invalid prototype.");
- Assert.That(mProto.TryGetComponent<MachineComponent>(out var mComp),
+ Assert.That(mProto.TryGetComponent<MachineComponent>(out var mComp, compFact),
$"Machine board {p.ID}'s corresponding machine {mId} does not have MachineComponent");
Assert.That(mComp.Board, Is.EqualTo(p.ID),
$"Machine {mId}'s BoardPrototype is not equal to it's corresponding machine board, {p.ID}");
var server = pair.Server;
var protoMan = server.ResolveDependency<IPrototypeManager>();
+ var compFact = server.ResolveDependency<IComponentFactory>();
await server.WaitAssertion(() =>
{
.Where(p => !pair.IsTestPrototype(p))
.Where(p => !_ignoredPrototypes.Contains(p.ID)))
{
- if (!p.TryGetComponent<ComputerBoardComponent>(out var cbc))
+ if (!p.TryGetComponent<ComputerBoardComponent>(out var cbc, compFact))
continue;
var cId = cbc.Prototype;
Assert.That(cId, Is.Not.Null, $"Computer board \"{p.ID}\" does not have a corresponding computer.");
Assert.That(protoMan.TryIndex<EntityPrototype>(cId, out var cProto),
$"Computer board \"{p.ID}\"'s corresponding computer has an invalid prototype.");
- Assert.That(cProto.TryGetComponent<ComputerComponent>(out var cComp),
+ Assert.That(cProto.TryGetComponent<ComputerComponent>(out var cComp, compFact),
$"Computer board {p.ID}'s corresponding computer \"{cId}\" does not have ComputerComponent");
Assert.That(cComp.BoardPrototype, Is.EqualTo(p.ID),
$"Computer \"{cId}\"'s BoardPrototype is not equal to it's corresponding computer board, \"{p.ID}\"");
[Test]
public async Task MappingTest()
{
- await using var pair = await PoolManager.GetServerClient(new PoolSettings {Dirty = true, Connected = true, DummyTicker = false});
+ await using var pair = await PoolManager.GetServerClient(new PoolSettings { Dirty = true, Connected = true, DummyTicker = false });
var server = pair.Server;
var entMan = server.EntMan;
await server.WaitIdleAsync();
var entManager = server.ResolveDependency<IEntityManager>();
- var sysManager = server.ResolveDependency<IEntitySystemManager>();
var mapManager = server.ResolveDependency<IMapManager>();
- Assert.That(mapManager.IsMapInitialized(testMap.MapId));
-
var protoManager = server.ResolveDependency<IPrototypeManager>();
- var pricing = sysManager.GetEntitySystem<PricingSystem>();
- var stackSys = sysManager.GetEntitySystem<StackSystem>();
+
+ var pricing = entManager.System<PricingSystem>();
+ var stackSys = entManager.System<StackSystem>();
+ var mapSystem = server.System<SharedMapSystem>();
var compFact = server.ResolveDependency<IComponentFactory>();
+ Assert.That(mapSystem.IsInitialized(testMap.MapId));
+
var constructionName = compFact.GetComponentName(typeof(ConstructionComponent));
var compositionName = compFact.GetComponentName(typeof(PhysicalCompositionComponent));
var materialName = compFact.GetComponentName(typeof(MaterialComponent));
Dictionary<string, ConstructionComponent> constructionRecipes = new();
foreach (var proto in protoManager.EnumeratePrototypes<EntityPrototype>())
{
- if (proto.NoSpawn || proto.Abstract || pair.IsTestPrototype(proto))
+ if (proto.HideSpawnMenu || proto.Abstract || pair.IsTestPrototype(proto))
continue;
if (!proto.Components.TryGetValue(constructionName, out var destructible))
// Here we get the set of entities/materials spawned when destroying an entity.
foreach (var proto in protoManager.EnumeratePrototypes<EntityPrototype>())
{
- if (proto.NoSpawn || proto.Abstract || pair.IsTestPrototype(proto))
+ if (proto.HideSpawnMenu || proto.Abstract || pair.IsTestPrototype(proto))
continue;
if (!proto.Components.TryGetValue(destructibleName, out var destructible))
Dictionary<string, PhysicalCompositionComponent> physicalCompositions = new();
foreach (var proto in protoManager.EnumeratePrototypes<EntityPrototype>())
{
- if (proto.NoSpawn || proto.Abstract || pair.IsTestPrototype(proto))
+ if (proto.HideSpawnMenu || proto.Abstract || pair.IsTestPrototype(proto))
continue;
if (!proto.Components.TryGetValue(compositionName, out var composition))
[TestFixture]
public sealed class GhostTests
{
- struct GhostTestData
+ private struct GhostTestData
{
public IEntityManager SEntMan;
public Robust.Server.Player.IPlayerManager SPlayerMan;
public TestPair Pair = default!;
- public TestMapData MapData => Pair.TestMap!;
+ public readonly TestMapData MapData => Pair.TestMap!;
- public RobustIntegrationTest.ServerIntegrationInstance Server => Pair.Server;
- public RobustIntegrationTest.ClientIntegrationInstance Client => Pair.Client;
+ public readonly RobustIntegrationTest.ServerIntegrationInstance Server => Pair.Server;
+ public readonly RobustIntegrationTest.ClientIntegrationInstance Client => Pair.Client;
/// <summary>
/// Initial player coordinates. Note that this does not necessarily correspond to the position of the
private async Task<GhostTestData> SetupData()
{
- var data = new GhostTestData();
-
- // Client is needed to create a session for the ghost system. Creating a dummy session was too difficult.
- data.Pair = await PoolManager.GetServerClient(new PoolSettings
+ var data = new GhostTestData
{
- DummyTicker = false,
- Connected = true,
- Dirty = true
- });
+ // Client is needed to create a session for the ghost system. Creating a dummy session was too difficult.
+ Pair = await PoolManager.GetServerClient(new PoolSettings
+ {
+ DummyTicker = false,
+ Connected = true,
+ Dirty = true
+ })
+ };
data.SEntMan = data.Pair.Server.ResolveDependency<IServerEntityManager>();
data.SPlayerMan = data.Pair.Server.ResolveDependency<Robust.Server.Player.IPlayerManager>();
// Setup map.
await data.Pair.CreateTestMap();
- data.PlayerCoords = data.SEntMan.GetNetCoordinates(data.MapData.GridCoords.Offset(new Vector2(0.5f, 0.5f)).WithEntityId(data.MapData.MapUid, data.STransformSys, data.SEntMan));
+ var test = data.MapData.GridCoords.Offset(new Vector2(0.5f, 0.5f));
+ data.PlayerCoords = data.SEntMan.GetNetCoordinates(data.STransformSys.WithEntityId(data.MapData.GridCoords.Offset(new Vector2(0.5f, 0.5f)), data.MapData.MapUid));
if (data.Client.Session == null)
Assert.Fail("No player");
{
var netManager = pair.Client.ResolveDependency<IClientNetManager>();
var playerMan = pair.Server.ResolveDependency<IPlayerManager>();
- Assert.That(!playerMan.Sessions.Any());
+ Assert.That(playerMan.Sessions, Is.Empty);
await Task.WhenAll(pair.Client.WaitIdleAsync(), pair.Client.WaitIdleAsync());
pair.Client.SetConnectTarget(pair.Server);
Assert.That(Delta(), Is.InRange(-0.01f, 0.01f));
Assert.That(buckle.Buckled, Is.True);
Assert.That(buckle.BuckledTo, Is.EqualTo(STarget));
- Assert.That(strap.BuckledEntities, Is.EquivalentTo(new[]{SPlayer}));
+ Assert.That(strap.BuckledEntities, Is.EquivalentTo(new[] { SPlayer }));
Assert.That(cAlert.IsShowingAlert(CPlayer, strap.BuckledAlertType), Is.True);
Assert.That(sAlert.IsShowingAlert(SPlayer, strap.BuckledAlertType), Is.True);
Assert.That(Delta(), Is.InRange(-0.01f, 0.01f));
Assert.That(buckle.Buckled, Is.True);
Assert.That(buckle.BuckledTo, Is.EqualTo(STarget));
- Assert.That(strap.BuckledEntities, Is.EquivalentTo(new[]{SPlayer}));
+ Assert.That(strap.BuckledEntities, Is.EquivalentTo(new[] { SPlayer }));
Assert.That(cAlert.IsShowingAlert(CPlayer, strap.BuckledAlertType), Is.True);
Assert.That(sAlert.IsShowingAlert(SPlayer, strap.BuckledAlertType), Is.True);
for (var i = -Tiles; i <= Tiles; i++)
{
- await SetTile(Plating, SEntMan.GetNetCoordinates(pCoords.Offset(new Vector2(i, 0))), MapData.Grid.Comp);
+ await SetTile(Plating, SEntMan.GetNetCoordinates(pCoords.Offset(new Vector2(i, 0))), MapData.Grid);
}
AssertGridCount(1);
[TestFixture]
public sealed class PvsCommandTest
{
- public static EntProtoId TestEnt = "MobHuman";
+ private static readonly EntProtoId TestEnt = "MobHuman";
[Test]
public async Task TestPvsCommands()
{
- await using var pair = await PoolManager.GetServerClient(new PoolSettings { Connected = true, DummyTicker = false});
+ await using var pair = await PoolManager.GetServerClient(new PoolSettings { Connected = true, DummyTicker = false });
var (server, client) = pair;
await pair.RunTicksSync(5);
PredictionTestComponent clientComponent = default!;
var serverSystem = sEntityManager.System<PredictionTestEntitySystem>();
var clientSystem = cEntityManager.System<PredictionTestEntitySystem>();
+ var sMapSys = sEntityManager.System<SharedMapSystem>();
await server.WaitPost(() =>
{
// Spawn dummy component entity.
- var map = sMapManager.CreateMap();
+ sMapSys.CreateMap(out var map);
serverEnt = sEntityManager.SpawnEntity(null, new MapCoordinates(new Vector2(0, 0), map));
serverComponent = sEntityManager.AddComponent<PredictionTestComponent>(serverEnt);
});
Assert.That(sGameTiming.TickTimingAdjustment, Is.EqualTo(0));
// Check client buffer is full
- Assert.That(cGameStateManager.CurrentBufferSize, Is.EqualTo(cGameStateManager.TargetBufferSize));
+ Assert.That(cGameStateManager.GetApplicableStateCount(), Is.EqualTo(cGameStateManager.TargetBufferSize));
Assert.That(cGameStateManager.TargetBufferSize, Is.EqualTo(2));
// This isn't required anymore, but the test had this for the sake of "technical things", and I cbf shifting
// Client last ran tick 15 meaning it's ahead of the last server tick it processed (12)
Assert.That(cGameTiming.CurTick, Is.EqualTo(expected));
- Assert.That(cGameTiming.LastProcessedTick, Is.EqualTo(new GameTick((uint)(baseTick - cGameStateManager.TargetBufferSize))));
+ Assert.That(cGameTiming.LastProcessedTick, Is.EqualTo(new GameTick((uint) (baseTick - cGameStateManager.TargetBufferSize))));
});
// *** I am using block scopes to visually distinguish these sections of the test to make it more readable.
// Assert timing is still correct.
Assert.That(sGameTiming.CurTick, Is.EqualTo(new GameTick(baseTick + 8)));
Assert.That(cGameTiming.CurTick, Is.EqualTo(new GameTick(baseTick + 8 + delta)));
- Assert.That(cGameTiming.LastProcessedTick, Is.EqualTo(new GameTick((uint)(baseTick + 8 - cGameStateManager.TargetBufferSize))));
+ Assert.That(cGameTiming.LastProcessedTick, Is.EqualTo(new GameTick((uint) (baseTick + 8 - cGameStateManager.TargetBufferSize))));
});
{
var entManager = server.ResolveDependency<IEntityManager>();
var mapLoader = entManager.System<MapLoaderSystem>();
+ var mapSystem = entManager.System<SharedMapSystem>();
var mapManager = server.ResolveDependency<IMapManager>();
var cfg = server.ResolveDependency<IConfigurationManager>();
Assert.That(cfg.GetCVar(CCVars.GridFill), Is.False);
await server.WaitPost(() =>
{
- var mapId = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId);
try
{
#pragma warning disable NUnit2045
var mapManager = server.ResolveDependency<IMapManager>();
var entManager = server.ResolveDependency<IEntityManager>();
var mapLoader = entManager.System<MapLoaderSystem>();
+ var mapSystem = entManager.System<SharedMapSystem>();
var protoManager = server.ResolveDependency<IPrototypeManager>();
var ticker = entManager.EntitySysManager.GetEntitySystem<GameTicker>();
var shuttleSystem = entManager.EntitySysManager.GetEntitySystem<ShuttleSystem>();
await server.WaitPost(() =>
{
- var mapId = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId);
try
{
ticker.LoadGameMap(protoManager.Index<GameMapPrototype>(mapProto), mapId, null);
throw new Exception($"Failed to load map {mapProto}", ex);
}
- var shuttleMap = mapManager.CreateMap();
+ mapSystem.CreateMap(out var shuttleMap);
var largest = 0f;
EntityUid? targetGrid = null;
var memberQuery = entManager.GetEntityQuery<StationMemberComponent>();
.Select(x => x.Job!.Value);
jobs.ExceptWith(spawnPoints);
- Assert.That(jobs, Is.Empty,$"There is no spawnpoints for {string.Join(", ", jobs)} on {mapProto}.");
+ Assert.That(jobs, Is.Empty, $"There is no spawnpoints for {string.Join(", ", jobs)} on {mapProto}.");
}
try
var resourceManager = server.ResolveDependency<IResourceManager>();
var protoManager = server.ResolveDependency<IPrototypeManager>();
var cfg = server.ResolveDependency<IConfigurationManager>();
+ var mapSystem = server.System<SharedMapSystem>();
Assert.That(cfg.GetCVar(CCVars.GridFill), Is.False);
var gameMaps = protoManager.EnumeratePrototypes<GameMapPrototype>().Select(o => o.MapPath).ToHashSet();
{
foreach (var mapName in mapNames)
{
- var mapId = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId);
try
{
Assert.That(mapLoader.TryLoad(mapId, mapName, out _));
var server = pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
+ var mapSys = entityManager.System<SharedMapSystem>();
const float loadPower = 200;
PowerSupplierComponent supplier = default!;
PowerConsumerComponent consumer1 = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
-
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 3; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates());
- var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 1));
- var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 2));
+ var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates());
+ var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 1));
+ var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 2));
supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
var server = pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
+ var mapSys = entityManager.System<SharedMapSystem>();
const float loadPower = 200;
PowerSupplierComponent supplier = default!;
PowerConsumerComponent consumer1 = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
-
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 3; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates());
- var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 1));
- var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 2));
+ var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates());
+ var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 1));
+ var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 2));
supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
var server = pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
+ var mapSys = entityManager.System<SharedMapSystem>();
var gameTiming = server.ResolveDependency<IGameTiming>();
PowerSupplierComponent supplier = default!;
PowerConsumerComponent consumer = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 3; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates());
- var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 2));
+ var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates());
+ var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 2));
supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
const float startingCharge = 100_000;
PowerNetworkBatteryComponent netBattery = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 3; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var generatorEnt = entityManager.SpawnEntity("DischargingBatteryDummy", gridOwner.ToCoordinates());
- var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 2));
+ var generatorEnt = entityManager.SpawnEntity("DischargingBatteryDummy", grid.Owner.ToCoordinates());
+ var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 2));
netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(generatorEnt);
battery = entityManager.GetComponent<BatteryComponent>(generatorEnt);
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerSupplierComponent supplier = default!;
PowerNetworkBatteryComponent netBattery = default!;
BatteryComponent battery = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 3; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates());
- var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 1));
- var batteryEnt = entityManager.SpawnEntity("DischargingBatteryDummy", gridOwner.ToCoordinates(0, 2));
+ var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates());
+ var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 1));
+ var batteryEnt = entityManager.SpawnEntity("DischargingBatteryDummy", grid.Owner.ToCoordinates(0, 2));
netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt);
battery = entityManager.GetComponent<BatteryComponent>(batteryEnt);
supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
var gameTiming = server.ResolveDependency<IGameTiming>();
var entityManager = server.ResolveDependency<IEntityManager>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerSupplierComponent supplier = default!;
BatteryComponent battery = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 3; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates());
- var batteryEnt = entityManager.SpawnEntity("ChargingBatteryDummy", gridOwner.ToCoordinates(0, 2));
+ var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates());
+ var batteryEnt = entityManager.SpawnEntity("ChargingBatteryDummy", grid.Owner.ToCoordinates(0, 2));
supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
var netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt);
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerConsumerComponent consumer = default!;
PowerSupplierComponent supplier = default!;
PowerNetworkBatteryComponent netBattery = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 4; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var terminal = entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 1));
+ var terminal = entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 1));
entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
- var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 2));
- var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, 0));
- var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 3));
+ var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 2));
+ var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, 0));
+ var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 3));
consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerConsumerComponent consumer = default!;
PowerSupplierComponent supplier = default!;
PowerNetworkBatteryComponent netBattery = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 4; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var terminal = entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 1));
+ var terminal = entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 1));
entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
- var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 2));
- var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, 0));
- var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 3));
+ var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 2));
+ var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, 0));
+ var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 3));
consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerConsumerComponent consumer1 = default!;
PowerConsumerComponent consumer2 = default!;
PowerSupplierComponent supplier = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Map layout here is
// C - consumer
// Power only works when anchored
for (var i = 0; i < 5; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 2));
- var terminal = entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 2));
+ entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 2));
+ var terminal = entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 2));
entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
- var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 1));
- var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 3));
- var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, 2));
- var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 0));
- var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 4));
+ var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 1));
+ var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 3));
+ var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, 2));
+ var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 0));
+ var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 4));
consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
consumer2 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2);
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerConsumerComponent consumer = default!;
PowerSupplierComponent supplier1 = default!;
PowerSupplierComponent supplier2 = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Layout is two generators, two batteries, and one load. As to why two: because previously this test
// would fail ONLY if there were more than two batteries present, because each of them tries to supply
// Place cables
for (var i = -2; i <= 2; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 2));
- var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, -2));
+ var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 2));
+ var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, -2));
- var supplyEnt1 = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, 1));
- var supplyEnt2 = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, -1));
+ var supplyEnt1 = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, 1));
+ var supplyEnt2 = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, -1));
- var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 0));
+ var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 0));
consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
supplier1 = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt1);
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerConsumerComponent consumer1 = default!;
PowerConsumerComponent consumer2 = default!;
PowerSupplierComponent supplier = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Map layout here is
// C - consumer
// Power only works when anchored
for (var i = 0; i < 5; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 2));
- var terminal = entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 2));
+ entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 2));
+ var terminal = entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 2));
entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
- var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 1));
- var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 3));
- var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, 2));
- var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 0));
- var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 4));
+ var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 1));
+ var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 3));
+ var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, 2));
+ var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 0));
+ var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 4));
consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
consumer2 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2);
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerConsumerComponent consumer = default!;
PowerSupplierComponent supplier = default!;
PowerNetworkBatteryComponent netBattery = default!;
await server.WaitPost(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 4; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, i));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, i));
}
- var terminal = entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 1));
+ var terminal = entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 1));
entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
- var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 2));
- var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, 0));
- var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", gridOwner.ToCoordinates(0, 3));
+ var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 2));
+ var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, 0));
+ var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.Owner.ToCoordinates(0, 3));
consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var nodeContainer = entityManager.System<NodeContainerSystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
CableNode leftNode = default!;
CableNode rightNode = default!;
Node batteryInput = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 4; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
}
- var leftEnt = entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, 0));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, 1));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, 2));
- var rightEnt = entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, 3));
+ var leftEnt = entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, 0));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, 1));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, 2));
+ var rightEnt = entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, 3));
- var terminal = entityManager.SpawnEntity("CableTerminal", gridOwner.ToCoordinates(0, 1));
+ var terminal = entityManager.SpawnEntity("CableTerminal", grid.Owner.ToCoordinates(0, 1));
entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
- var battery = entityManager.SpawnEntity("FullBatteryDummy", gridOwner.ToCoordinates(0, 2));
+ var battery = entityManager.SpawnEntity("FullBatteryDummy", grid.Owner.ToCoordinates(0, 2));
var batteryNodeContainer = entityManager.GetComponent<NodeContainerComponent>(battery);
if (nodeContainer.TryGetNode<CableNode>(entityManager.GetComponent<NodeContainerComponent>(leftEnt),
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var batterySys = entityManager.System<BatterySystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerNetworkBatteryComponent substationNetBattery = default!;
BatteryComponent apcBattery = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
// Power only works when anchored
for (var i = 0; i < 3; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
}
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, 0));
- entityManager.SpawnEntity("CableHV", gridOwner.ToCoordinates(0, 1));
- entityManager.SpawnEntity("CableMV", gridOwner.ToCoordinates(0, 1));
- entityManager.SpawnEntity("CableMV", gridOwner.ToCoordinates(0, 2));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, 0));
+ entityManager.SpawnEntity("CableHV", grid.Owner.ToCoordinates(0, 1));
+ entityManager.SpawnEntity("CableMV", grid.Owner.ToCoordinates(0, 1));
+ entityManager.SpawnEntity("CableMV", grid.Owner.ToCoordinates(0, 2));
- var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", gridOwner.ToCoordinates(0, 0));
- var substationEnt = entityManager.SpawnEntity("SubstationDummy", gridOwner.ToCoordinates(0, 1));
- var apcEnt = entityManager.SpawnEntity("ApcDummy", gridOwner.ToCoordinates(0, 2));
+ var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.Owner.ToCoordinates(0, 0));
+ var substationEnt = entityManager.SpawnEntity("SubstationDummy", grid.Owner.ToCoordinates(0, 1));
+ var apcEnt = entityManager.SpawnEntity("ApcDummy", grid.Owner.ToCoordinates(0, 2));
var generatorSupplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
substationNetBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(substationEnt);
var entityManager = server.ResolveDependency<IEntityManager>();
var batterySys = entityManager.System<BatterySystem>();
var extensionCableSystem = entityManager.System<ExtensionCableSystem>();
+ var mapSys = entityManager.System<SharedMapSystem>();
PowerNetworkBatteryComponent apcNetBattery = default!;
ApcPowerReceiverComponent receiver = default!;
ApcPowerReceiverComponent unpoweredReceiver = default!;
await server.WaitAssertion(() =>
{
- var map = mapManager.CreateMap();
- var grid = mapManager.CreateGrid(map);
- var gridOwner = grid.Owner;
+ var map = mapSys.CreateMap(out var mapId);
+ var grid = mapManager.CreateGridEntity(mapId);
const int range = 5;
// Power only works when anchored
for (var i = 0; i < range; i++)
{
- grid.SetTile(new Vector2i(0, i), new Tile(1));
+ mapSys.SetTile(grid, new Vector2i(0, i), new Tile(1));
}
- var apcEnt = entityManager.SpawnEntity("ApcDummy", gridOwner.ToCoordinates(0, 0));
- var apcExtensionEnt = entityManager.SpawnEntity("CableApcExtension", gridOwner.ToCoordinates(0, 0));
+ var apcEnt = entityManager.SpawnEntity("ApcDummy", grid.Owner.ToCoordinates(0, 0));
+ var apcExtensionEnt = entityManager.SpawnEntity("CableApcExtension", grid.Owner.ToCoordinates(0, 0));
// Create a powered receiver in range (range is 0 indexed)
- var powerReceiverEnt = entityManager.SpawnEntity("ApcPowerReceiverDummy", gridOwner.ToCoordinates(0, range - 1));
+ var powerReceiverEnt = entityManager.SpawnEntity("ApcPowerReceiverDummy", grid.Owner.ToCoordinates(0, range - 1));
receiver = entityManager.GetComponent<ApcPowerReceiverComponent>(powerReceiverEnt);
// Create an unpowered receiver outside range
- var unpoweredReceiverEnt = entityManager.SpawnEntity("ApcPowerReceiverDummy", gridOwner.ToCoordinates(0, range));
+ var unpoweredReceiverEnt = entityManager.SpawnEntity("ApcPowerReceiverDummy", grid.Owner.ToCoordinates(0, range));
unpoweredReceiver = entityManager.GetComponent<ApcPowerReceiverComponent>(unpoweredReceiverEnt);
var battery = entityManager.GetComponent<BatteryComponent>(apcEnt);
var prototypeMan = server.ResolveDependency<IPrototypeManager>();
var seriMan = server.ResolveDependency<ISerializationManager>();
var compFact = server.ResolveDependency<IComponentFactory>();
+ var mapSystem = server.System<SharedMapSystem>();
var prototypes = new List<EntityPrototype>();
EntityUid uid;
await server.WaitAssertion(() =>
{
- Assert.That(!mapManager.IsMapInitialized(mapId));
+ Assert.That(!mapSystem.IsInitialized(mapId));
var testLocation = grid.Owner.ToCoordinates();
Assert.Multiple(() =>
IDependencyCollection dependencies, bool alwaysWrite = false,
ISerializationContext? context = null)
{
- if (WritingComponent != "Transform" && (Prototype?.NoSpawn == false))
+ if (WritingComponent != "Transform" && Prototype?.HideSpawnMenu == false)
{
// Maybe this will be necessary in the future, but at the moment it just indicates that there is some
// issue, like a non-nullable entityUid data-field. If a component MUST have an entity uid to work with,
{
foreach (var proto in protoManager.EnumeratePrototypes<EntityPrototype>())
{
- if (!proto.TryGetComponent(out PullerComponent? puller))
+ if (!proto.TryGetComponent(out PullerComponent? puller, compFactory))
continue;
if (!puller.NeedsHands)
using System.Linq;
using Content.Shared.Lathe;
using Content.Shared.Research.Prototypes;
+using Robust.Shared.GameObjects;
using Robust.Shared.Prototypes;
namespace Content.IntegrationTests.Tests;
var server = pair.Server;
var protoManager = server.ResolveDependency<IPrototypeManager>();
+ var compFact = server.ResolveDependency<IComponentFactory>();
await server.WaitAssertion(() =>
{
if (pair.IsTestPrototype(proto))
continue;
- if (!proto.TryGetComponent<LatheComponent>(out var lathe))
+ if (!proto.TryGetComponent<LatheComponent>(out var lathe, compFact))
continue;
allLathes.Add(lathe);
}
[TestFixture]
public sealed class JobTest
{
- private static ProtoId<JobPrototype> _passenger = "Passenger";
- private static ProtoId<JobPrototype> _engineer = "StationEngineer";
- private static ProtoId<JobPrototype> _captain = "Captain";
+ private static readonly ProtoId<JobPrototype> Passenger = "Passenger";
+ private static readonly ProtoId<JobPrototype> Engineer = "StationEngineer";
+ private static readonly ProtoId<JobPrototype> Captain = "Captain";
private static string _map = "JobTestMap";
[TestPrototypes]
- public static string JobTestMap = @$"
+ private static readonly string JobTestMap = @$"
- type: gameMap
id: {_map}
mapName: {_map}
mapNameTemplate: ""Empty""
- type: StationJobs
availableJobs:
- {_passenger}: [ -1, -1 ]
- {_engineer}: [ -1, -1 ]
- {_captain}: [ 1, 1 ]
+ {Passenger}: [ -1, -1 ]
+ {Engineer}: [ -1, -1 ]
+ {Captain}: [ 1, 1 ]
";
- public void AssertJob(TestPair pair, ProtoId<JobPrototype> job, NetUserId? user = null, bool isAntag = false)
+ private void AssertJob(TestPair pair, ProtoId<JobPrototype> job, NetUserId? user = null, bool isAntag = false)
{
var jobSys = pair.Server.System<SharedJobSystem>();
var mindSys = pair.Server.System<MindSystem>();
await pair.Server.WaitPost(() => ticker.StartRound());
await pair.RunTicksSync(10);
- AssertJob(pair, _passenger);
+ AssertJob(pair, Passenger);
await pair.Server.WaitPost(() => ticker.RestartRound());
await pair.CleanReturnAsync();
Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
Assert.That(pair.Client.AttachedEntity, Is.Null);
- await pair.SetJobPriorities((_passenger, JobPriority.Medium), (_engineer, JobPriority.High));
+ await pair.SetJobPriorities((Passenger, JobPriority.Medium), (Engineer, JobPriority.High));
ticker.ToggleReadyAll(true);
await pair.Server.WaitPost(() => ticker.StartRound());
await pair.RunTicksSync(10);
- AssertJob(pair, _engineer);
+ AssertJob(pair, Engineer);
await pair.Server.WaitPost(() => ticker.RestartRound());
Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
- await pair.SetJobPriorities((_passenger, JobPriority.High), (_engineer, JobPriority.Medium));
+ await pair.SetJobPriorities((Passenger, JobPriority.High), (Engineer, JobPriority.Medium));
ticker.ToggleReadyAll(true);
await pair.Server.WaitPost(() => ticker.StartRound());
await pair.RunTicksSync(10);
- AssertJob(pair, _passenger);
+ AssertJob(pair, Passenger);
await pair.Server.WaitPost(() => ticker.RestartRound());
await pair.CleanReturnAsync();
Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
Assert.That(pair.Client.AttachedEntity, Is.Null);
- var captain = pair.Server.ProtoMan.Index(_captain);
- var engineer = pair.Server.ProtoMan.Index(_engineer);
- var passenger = pair.Server.ProtoMan.Index(_passenger);
+ var captain = pair.Server.ProtoMan.Index(Captain);
+ var engineer = pair.Server.ProtoMan.Index(Engineer);
+ var passenger = pair.Server.ProtoMan.Index(Passenger);
Assert.That(captain.Weight, Is.GreaterThan(engineer.Weight));
Assert.That(engineer.Weight, Is.EqualTo(passenger.Weight));
- await pair.SetJobPriorities((_passenger, JobPriority.Medium), (_engineer, JobPriority.High), (_captain, JobPriority.Low));
+ await pair.SetJobPriorities((Passenger, JobPriority.Medium), (Engineer, JobPriority.High), (Captain, JobPriority.Low));
ticker.ToggleReadyAll(true);
await pair.Server.WaitPost(() => ticker.StartRound());
await pair.RunTicksSync(10);
- AssertJob(pair, _captain);
+ AssertJob(pair, Captain);
await pair.Server.WaitPost(() => ticker.RestartRound());
await pair.CleanReturnAsync();
var captain = engineers[3];
engineers.RemoveAt(3);
- await pair.SetJobPriorities(captain, (_captain, JobPriority.High), (_engineer, JobPriority.Medium));
+ await pair.SetJobPriorities(captain, (Captain, JobPriority.High), (Engineer, JobPriority.Medium));
foreach (var engi in engineers)
{
- await pair.SetJobPriorities(engi, (_captain, JobPriority.Medium), (_engineer, JobPriority.High));
+ await pair.SetJobPriorities(engi, (Captain, JobPriority.Medium), (Engineer, JobPriority.High));
}
ticker.ToggleReadyAll(true);
await pair.Server.WaitPost(() => ticker.StartRound());
await pair.RunTicksSync(10);
- AssertJob(pair, _captain, captain);
+ AssertJob(pair, Captain, captain);
Assert.Multiple(() =>
{
foreach (var engi in engineers)
{
- AssertJob(pair, _engineer, engi);
+ AssertJob(pair, Engineer, engi);
}
});
using System.Linq;
-using Content.Server.Salvage;
using Content.Shared.CCVar;
using Content.Shared.Salvage;
using Robust.Server.GameObjects;
var mapManager = server.ResolveDependency<IMapManager>();
var prototypeManager = server.ResolveDependency<IPrototypeManager>();
var cfg = server.ResolveDependency<IConfigurationManager>();
+ var mapSystem = entManager.System<SharedMapSystem>();
Assert.That(cfg.GetCVar(CCVars.GridFill), Is.False);
await server.WaitPost(() =>
{
var mapFile = salvage.MapPath;
- var mapId = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId);
try
{
Assert.That(mapLoader.TryLoad(mapId, mapFile.ToString(), out var roots));
var mapManager = server.ResolveDependency<IMapManager>();
var sEntities = server.ResolveDependency<IEntityManager>();
var mapLoader = sEntities.System<MapLoaderSystem>();
+ var mapSystem = sEntities.System<SharedMapSystem>();
var xformSystem = sEntities.EntitySysManager.GetEntitySystem<SharedTransformSystem>();
var resManager = server.ResolveDependency<IResourceManager>();
var cfg = server.ResolveDependency<IConfigurationManager>();
var dir = new ResPath(mapPath).Directory;
resManager.UserData.CreateDir(dir);
- var mapId = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId);
{
- var mapGrid = mapManager.CreateGrid(mapId);
- var mapGridEnt = mapGrid.Owner;
- xformSystem.SetWorldPosition(mapGridEnt, new Vector2(10, 10));
- mapGrid.SetTile(new Vector2i(0, 0), new Tile(1, (TileRenderFlag) 1, 255));
+ var mapGrid = mapManager.CreateGridEntity(mapId);
+ xformSystem.SetWorldPosition(mapGrid, new Vector2(10, 10));
+ mapSystem.SetTile(mapGrid, new Vector2i(0, 0), new Tile(1, (TileRenderFlag) 1, 255));
}
{
- var mapGrid = mapManager.CreateGrid(mapId);
- var mapGridEnt = mapGrid.Owner;
- xformSystem.SetWorldPosition(mapGridEnt, new Vector2(-8, -8));
- mapGrid.SetTile(new Vector2i(0, 0), new Tile(2, (TileRenderFlag) 1, 254));
+ var mapGrid = mapManager.CreateGridEntity(mapId);
+ xformSystem.SetWorldPosition(mapGrid, new Vector2(-8, -8));
+ mapSystem.SetTile(mapGrid, new Vector2i(0, 0), new Tile(2, (TileRenderFlag) 1, 254));
}
Assert.Multiple(() => mapLoader.SaveMap(mapId, mapPath));
Assert.Multiple(() =>
{
Assert.That(xformSystem.GetWorldPosition(gridXform), Is.EqualTo(new Vector2(10, 10)));
- Assert.That(mapGrid.GetTileRef(new Vector2i(0, 0)).Tile, Is.EqualTo(new Tile(1, (TileRenderFlag) 1, 255)));
+ Assert.That(mapSystem.GetTileRef(gridUid, mapGrid, new Vector2i(0, 0)).Tile, Is.EqualTo(new Tile(1, (TileRenderFlag) 1, 255)));
});
}
{
Assert.Multiple(() =>
{
Assert.That(xformSystem.GetWorldPosition(gridXform), Is.EqualTo(new Vector2(-8, -8)));
- Assert.That(mapGrid.GetTileRef(new Vector2i(0, 0)).Tile, Is.EqualTo(new Tile(2, (TileRenderFlag) 1, 254)));
+ Assert.That(mapSystem.GetTileRef(gridUid, mapGrid, new Vector2i(0, 0)).Tile, Is.EqualTo(new Tile(2, (TileRenderFlag) 1, 254)));
});
}
});
var server = pair.Server;
var entManager = server.ResolveDependency<IEntityManager>();
var mapLoader = entManager.System<MapLoaderSystem>();
+ var mapSystem = entManager.System<SharedMapSystem>();
var mapManager = server.ResolveDependency<IMapManager>();
var cfg = server.ResolveDependency<IConfigurationManager>();
Assert.That(cfg.GetCVar(CCVars.GridFill), Is.False);
await server.WaitPost(() =>
{
- var mapId0 = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId0);
// TODO: Properly find the "main" station grid.
- var grid0 = mapManager.CreateGrid(mapId0);
+ var grid0 = mapManager.CreateGridEntity(mapId0);
mapLoader.Save(grid0.Owner, "save load save 1.yml");
- var mapId1 = mapManager.CreateMap();
+ mapSystem.CreateMap(out var mapId1);
EntityUid grid1 = default!;
#pragma warning disable NUnit2045
Assert.That(mapLoader.TryLoad(mapId1, "save load save 1.yml", out var roots, new MapLoadOptions() { LoadMap = false }), $"Failed to load test map {TestMap}");
var server = pair.Server;
var mapLoader = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>();
var mapManager = server.ResolveDependency<IMapManager>();
+ var mapSystem = server.System<SharedMapSystem>();
MapId mapId = default;
var cfg = server.ResolveDependency<IConfigurationManager>();
// Load bagel.yml as uninitialized map, and save it to ensure it's up to date.
server.Post(() =>
{
- mapId = mapManager.CreateMap();
- mapManager.AddUninitializedMap(mapId);
+ mapSystem.CreateMap(out mapId, runMapInit: false);
mapManager.SetMapPaused(mapId, true);
Assert.That(mapLoader.TryLoad(mapId, TestMap, out _), $"Failed to load test map {TestMap}");
mapLoader.SaveMap(mapId, "load save ticks save 1.yml");
await using var pair = await PoolManager.GetServerClient();
var server = pair.Server;
- var mapLoader = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>();
+ var mapLoader = server.System<MapLoaderSystem>();
+ var mapSystem = server.System<SharedMapSystem>();
var mapManager = server.ResolveDependency<IMapManager>();
var userData = server.ResolveDependency<IResourceManager>().UserData;
var cfg = server.ResolveDependency<IConfigurationManager>();
// Load & save the first map
server.Post(() =>
{
- mapId = mapManager.CreateMap();
- mapManager.AddUninitializedMap(mapId);
+ mapSystem.CreateMap(out mapId, runMapInit: false);
mapManager.SetMapPaused(mapId, true);
Assert.That(mapLoader.TryLoad(mapId, TestMap, out _), $"Failed to load test map {TestMap}");
mapLoader.SaveMap(mapId, fileA);
server.Post(() =>
{
mapManager.DeleteMap(mapId);
- mapManager.CreateMap(mapId);
- mapManager.AddUninitializedMap(mapId);
+ mapSystem.CreateMap(out mapId, runMapInit: false);
mapManager.SetMapPaused(mapId, true);
Assert.That(mapLoader.TryLoad(mapId, TestMap, out _), $"Failed to load test map {TestMap}");
mapLoader.SaveMap(mapId, fileB);
Enum value = TestEnum.Bb;
- var node = seriMan.WriteValue(value, notNullableOverride:true);
+ var node = seriMan.WriteValue(value, notNullableOverride: true);
var valueNode = node as ValueDataNode;
Assert.That(valueNode, Is.Not.Null);
var errors = seriMan.ValidateNode<Enum>(valueNode).GetErrors();
Assert.That(errors.Any(), Is.False);
- var deserialized = seriMan.Read<Enum>(node, notNullableOverride:true);
+ var deserialized = seriMan.Read<Enum>(node, notNullableOverride: true);
Assert.That(deserialized, Is.EqualTo(value));
// Repeat test with enums in a data definitions.
var data = new TestData
{
Value = TestEnum.Cc,
- Sequence = new() {TestEnum.Dd, TestEnum.Aa}
+ Sequence = [TestEnum.Dd, TestEnum.Aa]
};
- node = seriMan.WriteValue(data, notNullableOverride:true);
+ node = seriMan.WriteValue(data, notNullableOverride: true);
errors = seriMan.ValidateNode<TestData>(node).GetErrors();
Assert.That(errors.Any(), Is.False);
- var deserializedData = seriMan.Read<TestData>(node, notNullableOverride:false);
+ var deserializedData = seriMan.Read<TestData>(node, notNullableOverride: false);
Assert.That(deserializedData.Value, Is.EqualTo(data.Value));
Assert.That(deserializedData.Sequence.Count, Is.EqualTo(data.Sequence.Count));
Enum genericValue = TestEnum.Bb;
TestEnum typedValue = TestEnum.Bb;
- var genericNode = seriMan.WriteValue(genericValue, notNullableOverride:true);
+ var genericNode = seriMan.WriteValue(genericValue, notNullableOverride: true);
var typedNode = seriMan.WriteValue(typedValue);
Assert.That(seriMan.ValidateNode<Enum>(genericNode).GetErrors().Any(), Is.False);
[DataDefinition]
private sealed partial class TestData
{
- [DataField("value")] public Enum Value = default!;
- [DataField("sequence")] public List<Enum> Sequence = default!;
+ [DataField] public Enum Value = default!;
+ [DataField] public List<Enum> Sequence = default!;
}
}
using Content.Server.Shuttles.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
-using Robust.Shared.Maths;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
var entManager = server.ResolveDependency<IEntityManager>();
var physicsSystem = entManager.System<SharedPhysicsSystem>();
- EntityUid gridEnt = default;
PhysicsComponent gridPhys = null;
+ var map = await pair.CreateTestMap();
+
await server.WaitAssertion(() =>
{
- var mapId = mapMan.CreateMap();
- var grid = mapMan.CreateGridEntity(mapId);
- gridEnt = grid.Owner;
+ var mapId = map.MapId;
+ var grid = map.Grid;
Assert.Multiple(() =>
{
- Assert.That(entManager.HasComponent<ShuttleComponent>(gridEnt));
- Assert.That(entManager.TryGetComponent(gridEnt, out gridPhys));
+ Assert.That(entManager.HasComponent<ShuttleComponent>(grid));
+ Assert.That(entManager.TryGetComponent(grid, out gridPhys));
});
Assert.Multiple(() =>
{
Assert.That(gridPhys.BodyType, Is.EqualTo(BodyType.Dynamic));
- Assert.That(entManager.GetComponent<TransformComponent>(gridEnt).LocalPosition, Is.EqualTo(Vector2.Zero));
+ Assert.That(entManager.GetComponent<TransformComponent>(grid).LocalPosition, Is.EqualTo(Vector2.Zero));
});
- physicsSystem.ApplyLinearImpulse(gridEnt, Vector2.One, body: gridPhys);
+ physicsSystem.ApplyLinearImpulse(grid, Vector2.One, body: gridPhys);
});
await server.WaitRunTicks(1);
await server.WaitAssertion(() =>
{
- Assert.That(entManager.GetComponent<TransformComponent>(gridEnt).LocalPosition, Is.Not.EqualTo(Vector2.Zero));
+ Assert.That(entManager.GetComponent<TransformComponent>(map.Grid).LocalPosition, Is.Not.EqualTo(Vector2.Zero));
});
await pair.CleanReturnAsync();
}
/// - Shouldn't have an item component
/// - Is missing the required sprite information.
/// If none of the abveo are true, it might need to be added to the list of ignored components, see
-/// <see cref="_ignored"/>
+/// <see cref="Ignored"/>
/// </remarks>
[TestFixture]
public sealed class PrototypeSaveTest
{
- private static HashSet<string> _ignored = new()
+ private static readonly HashSet<string> Ignored = new()
{
// The only prototypes that should get ignored are those that REQUIRE setup to get a sprite. At that point it is
// the responsibility of the spawner to ensure that a valid sprite is set.
[Test]
public async Task AllItemsHaveSpritesTest()
{
- var settings = new PoolSettings() {Connected = true}; // client needs to be in-game
+ var settings = new PoolSettings() { Connected = true }; // client needs to be in-game
await using var pair = await PoolManager.GetServerClient(settings);
- List<EntityPrototype> badPrototypes = new();
+ List<EntityPrototype> badPrototypes = [];
await pair.Client.WaitPost(() =>
{
- foreach (var proto in pair.GetPrototypesWithComponent<ItemComponent>(_ignored))
+ foreach (var proto in pair.GetPrototypesWithComponent<ItemComponent>(Ignored))
{
var dummy = pair.Client.EntMan.Spawn(proto.ID);
pair.Client.EntMan.RunMapInit(dummy, pair.Client.MetaData(dummy));
await TearDown();
}
- protected virtual async Task TearDown()
+ protected virtual Task TearDown()
{
Assert.That(_expectedErrors, Is.Empty);
ClearErrors();
+
+ return Task.CompletedTask;
}
[SetUp]
public virtual async Task Setup()
{
- Pair = await PoolManager.GetServerClient(new PoolSettings {Connected = Connected});
+ Pair = await PoolManager.GetServerClient(new PoolSettings { Connected = Connected });
Server = Pair.Server;
if (Connected)
);
}
- done:
+ done:
_errors.Add(err);
}
await server.WaitIdleAsync();
var prototypeManager = server.ResolveDependency<IPrototypeManager>();
+ var compFact = server.ResolveDependency<IComponentFactory>();
await server.WaitAssertion(() =>
{
// Collect all the prototypes with StorageFills referencing those entities.
foreach (var proto in prototypeManager.EnumeratePrototypes<EntityPrototype>())
{
- if (!proto.TryGetComponent<StorageFillComponent>(out var storage))
+ if (!proto.TryGetComponent<StorageFillComponent>(out var storage, compFact))
continue;
List<string> restockStore = new();
projects / space-station-14.git / commitdiff