+using System.Diagnostics.CodeAnalysis;
using Content.Shared.Construction;
using Content.Shared.Construction.Prototypes;
using Content.Shared.Examine;
/// Creates a construction ghost at the given location.
/// </summary>
public void SpawnGhost(ConstructionPrototype prototype, EntityCoordinates loc, Direction dir)
+ => TrySpawnGhost(prototype, loc, dir, out _);
+
+ /// <summary>
+ /// Creates a construction ghost at the given location.
+ /// </summary>
+ public bool TrySpawnGhost(
+ ConstructionPrototype prototype,
+ EntityCoordinates loc,
+ Direction dir,
+ [NotNullWhen(true)] out EntityUid? ghost)
{
+ ghost = null;
if (_playerManager.LocalPlayer?.ControlledEntity is not { } user ||
!user.IsValid())
{
- return;
+ return false;
}
- if (GhostPresent(loc)) return;
+ if (GhostPresent(loc))
+ return false;
// This InRangeUnobstructed should probably be replaced with "is there something blocking us in that tile?"
var predicate = GetPredicate(prototype.CanBuildInImpassable, loc.ToMap(EntityManager));
if (!_interactionSystem.InRangeUnobstructed(user, loc, 20f, predicate: predicate))
- return;
+ return false;
foreach (var condition in prototype.Conditions)
{
if (!condition.Condition(user, loc, dir))
- return;
+ return false;
}
- var ghost = EntityManager.SpawnEntity("constructionghost", loc);
- var comp = EntityManager.GetComponent<ConstructionGhostComponent>(ghost);
+ ghost = EntityManager.SpawnEntity("constructionghost", loc);
+ var comp = EntityManager.GetComponent<ConstructionGhostComponent>(ghost.Value);
comp.Prototype = prototype;
comp.GhostId = _nextId++;
- EntityManager.GetComponent<TransformComponent>(ghost).LocalRotation = dir.ToAngle();
+ EntityManager.GetComponent<TransformComponent>(ghost.Value).LocalRotation = dir.ToAngle();
_ghosts.Add(comp.GhostId, comp);
- var sprite = EntityManager.GetComponent<SpriteComponent>(ghost);
+ var sprite = EntityManager.GetComponent<SpriteComponent>(ghost.Value);
sprite.Color = new Color(48, 255, 48, 128);
for (int i = 0; i < prototype.Layers.Count; i++)
}
if (prototype.CanBuildInImpassable)
- EnsureComp<WallMountComponent>(ghost).Arc = new(Math.Tau);
+ EnsureComp<WallMountComponent>(ghost.Value).Arc = new(Math.Tau);
+
+ return true;
}
/// <summary>
return false;
}
- private void TryStartConstruction(int ghostId)
+ public void TryStartConstruction(int ghostId)
{
var ghost = _ghosts[ghostId];
namespace Content.Client.Examine
{
[UsedImplicitly]
- internal sealed class ExamineSystem : ExamineSystemShared
+ public sealed class ExamineSystem : ExamineSystemShared
{
[Dependency] private readonly IUserInterfaceManager _userInterfaceManager = default!;
[Dependency] private readonly IPlayerManager _playerManager = default!;
using Content.IntegrationTests.Tests.Networking;
using Content.Server.GameTicking;
using Content.Shared.CCVar;
+using Microsoft.Diagnostics.Tracing.Parsers.Kernel;
using NUnit.Framework;
using Robust.Client;
using Robust.Server;
{
var mapManager = IoCManager.Resolve<IMapManager>();
mapData.MapId = mapManager.CreateMap();
+ mapData.MapUid = mapManager.GetMapEntityId(mapData.MapId);
mapData.MapGrid = mapManager.CreateGrid(mapData.MapId);
mapData.GridCoords = new EntityCoordinates(mapData.MapGrid.Owner, 0, 0);
var tileDefinitionManager = IoCManager.Resolve<ITileDefinitionManager>();
/// </summary>
public sealed class TestMapData
{
+ public EntityUid MapUid { get; set; }
public MapId MapId { get; set; }
public MapGridComponent MapGrid { get; set; }
public EntityCoordinates GridCoords { get; set; }
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class ComputerConstruction : InteractionTest
+{
+ private const string Computer = "Computer";
+ private const string ComputerId = "ComputerId";
+ private const string ComputerFrame = "ComputerFrame";
+ private const string IdBoard = "IDComputerCircuitboard";
+
+ [Test]
+ public async Task ConstructComputer()
+ {
+ // Place ghost
+ await StartConstruction(Computer);
+
+ // Initial interaction (ghost turns into real entity)
+ await Interact(Steel, 5);
+ AssertPrototype(ComputerFrame);
+
+ // Perform construction steps
+ await Interact(
+ Wrench,
+ IdBoard,
+ Screw,
+ (Cable, 5),
+ (Glass, 2),
+ Screw);
+
+ // Construction finished, target entity was replaced with a new one:
+ AssertPrototype(ComputerId);
+ }
+
+ [Test]
+ public async Task DeconstructComputer()
+ {
+ // Spawn initial entity
+ await StartDeconstruction(ComputerId);
+
+ // Initial interaction turns id computer into generic computer
+ await Interact(Screw);
+ AssertPrototype(ComputerFrame);
+
+ // Perform deconstruction steps
+ await Interact(
+ Pry,
+ Cut,
+ Screw,
+ Pry,
+ Wrench,
+ Weld);
+
+ // construction finished, entity no longer exists.
+ AssertDeleted();
+
+ // Check expected entities were dropped.
+ await AssertEntityLookup(
+ IdBoard,
+ (Cable, 5),
+ (Steel, 5),
+ (Glass, 2));
+ }
+
+ [Test]
+ public async Task ChangeComputer()
+ {
+ // Spawn initial entity
+ await SpawnTarget(ComputerId);
+
+ // Initial interaction turns id computer into generic computer
+ await Interact(Screw);
+ AssertPrototype(ComputerFrame);
+
+ // Perform partial deconstruction steps
+ await Interact(
+ Pry,
+ Cut,
+ Screw,
+ Pry);
+
+ // Entity should still exist
+ AssertPrototype(ComputerFrame);
+
+ // Begin re-constructing with a new circuit board
+ await Interact(
+ "CargoRequestComputerCircuitboard",
+ Screw,
+ (Cable, 5),
+ (Glass, 2),
+ Screw);
+
+ // Construction finished, target entity was replaced with a new one:
+ AssertPrototype("ComputerCargoOrders");
+ }
+}
+
--- /dev/null
+using System.Linq;
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Stacks;
+using NUnit.Framework;
+using Robust.Shared.Containers;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class CraftingTests : InteractionTest
+{
+ public const string ShardGlass = "ShardGlass";
+ public const string Spear = "Spear";
+
+ /// <summary>
+ /// Craft a simple instant recipe
+ /// </summary>
+ [Test]
+ public async Task CraftRods()
+ {
+ await PlaceInHands(Steel);
+ await CraftItem(Rod);
+ await FindEntity((Rod, 2));
+ }
+
+ /// <summary>
+ /// Craft a simple recipe with a DoAfter
+ /// </summary>
+ [Test]
+ public async Task CraftGrenade()
+ {
+ await PlaceInHands(Steel, 5);
+ await CraftItem("ModularGrenadeRecipe");
+ await FindEntity("ModularGrenade");
+ }
+
+ /// <summary>
+ /// Craft a complex recipe (more than one ingredient).
+ /// </summary>
+ [Test]
+ public async Task CraftSpear()
+ {
+ // Spawn a full tack of rods in the user's hands.
+ await PlaceInHands(Rod, 10);
+ await SpawnEntity((Cable, 10), PlayerCoords);
+
+ // Attempt (and fail) to craft without glass.
+ await CraftItem(Spear, shouldSucceed: false);
+ await FindEntity(Spear, shouldSucceed: false);
+
+ // Spawn three shards of glass and finish crafting (only one is needed).
+ await SpawnTarget(ShardGlass);
+ await SpawnTarget(ShardGlass);
+ await SpawnTarget(ShardGlass);
+ await CraftItem(Spear);
+ await FindEntity(Spear);
+
+ // Player's hands should be full of the remaining rods, except those dropped during the failed crafting attempt.
+ // Spear and left over stacks should be on the floor.
+ await AssertEntityLookup((Rod, 2), (Cable, 8), (ShardGlass, 2), (Spear, 1));
+ }
+
+ // The following is wrapped in an if DEBUG. This is because of cursed state handling bugs. Tests don't (de)serialize
+ // net messages and just copy objects by reference. This means that the server will directly modify cached server
+ // states on the client's end. Crude fix at the moment is to used modified state handling while in debug mode
+ // Otherwise, this test cannot work.
+#if DEBUG
+ /// <summary>
+ /// Cancel crafting a complex recipe.
+ /// </summary>
+ [Test]
+ public async Task CancelCraft()
+ {
+ var rods = await SpawnEntity((Rod, 10), TargetCoords);
+ var wires = await SpawnEntity((Cable, 10), TargetCoords);
+ var shard = await SpawnEntity(ShardGlass, TargetCoords);
+
+ var rodStack = SEntMan.GetComponent<StackComponent>(rods);
+ var wireStack = SEntMan.GetComponent<StackComponent>(wires);
+
+ await RunTicks(5);
+ var sys = SEntMan.System<SharedContainerSystem>();
+ Assert.That(sys.IsEntityInContainer(rods), Is.False);
+ Assert.That(sys.IsEntityInContainer(wires), Is.False);
+ Assert.That(sys.IsEntityInContainer(shard), Is.False);
+
+ await Server.WaitPost(() => SConstruction.TryStartItemConstruction(Spear, Player));
+ await RunTicks(1);
+
+ // DoAfter is in progress. Entity not spawned, stacks have been split and someingredients are in a container.
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+ Assert.That(sys.IsEntityInContainer(shard), Is.True);
+ Assert.That(sys.IsEntityInContainer(rods), Is.False);
+ Assert.That(sys.IsEntityInContainer(wires), Is.False);
+ Assert.That(rodStack.Count, Is.EqualTo(8));
+ Assert.That(wireStack.Count, Is.EqualTo(8));
+ await FindEntity(Spear, shouldSucceed: false);
+
+ // Cancel the DoAfter. Should drop ingredients to the floor.
+ await CancelDoAfters();
+ Assert.That(sys.IsEntityInContainer(rods), Is.False);
+ Assert.That(sys.IsEntityInContainer(wires), Is.False);
+ Assert.That(sys.IsEntityInContainer(shard), Is.False);
+ await FindEntity(Spear, shouldSucceed: false);
+ await AssertEntityLookup((Rod, 10), (Cable, 10), (ShardGlass, 1));
+
+ // Re-attempt the do-after
+ await Server.WaitPost(() => SConstruction.TryStartItemConstruction(Spear, Player));
+ await RunTicks(1);
+
+ // DoAfter is in progress. Entity not spawned, ingredients are in a container.
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+ Assert.That(sys.IsEntityInContainer(shard), Is.True);
+ await FindEntity(Spear, shouldSucceed: false);
+
+ // Finish the DoAfter
+ await AwaitDoAfters();
+
+ // Spear has been crafted. Rods and wires are no longer contained. Glass has been consumed.
+ await FindEntity(Spear);
+ Assert.That(sys.IsEntityInContainer(rods), Is.False);
+ Assert.That(sys.IsEntityInContainer(wires), Is.False);
+ Assert.That(SEntMan.Deleted(shard));
+ }
+#endif
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Construction.Prototypes;
+using NUnit.Framework;
+using Robust.Shared.Maths;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+/// <summary>
+/// Check that we can build grilles on top of windows, but not the other way around.
+/// </summary>
+public sealed class GrilleWindowConstruction : InteractionTest
+{
+ private const string Grille = "Grille";
+ private const string Window = "Window";
+
+ [Test]
+ public async Task WindowOnGrille()
+ {
+ // Construct Grille
+ await StartConstruction(Grille);
+ await Interact(Rod, 10);
+ AssertPrototype(Grille);
+
+ var grille = Target;
+
+ // Construct Window
+ await StartConstruction(Window);
+ await Interact(Glass, 10);
+ AssertPrototype(Window);
+
+ // Deconstruct Window
+ await Interact(Screw, Wrench);
+ AssertDeleted();
+
+ // Deconstruct Grille
+ Target = grille;
+ await Interact(Cut);
+ AssertDeleted();
+ }
+
+ [Test]
+ [TestCase(Grille, Grille)]
+ [TestCase(Window, Grille)]
+ [TestCase(Window, Window)]
+ public async Task ConstructionBlocker(string first, string second)
+ {
+ // Spawn blocking entity
+ await SpawnTarget(first);
+
+ // Further construction attempts fail - blocked by first entity interaction.
+ await Client.WaitPost(() =>
+ {
+ var proto = ProtoMan.Index<ConstructionPrototype>(second);
+ Assert.That(CConSys.TrySpawnGhost(proto, TargetCoords, Direction.South, out _), Is.False);
+ });
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class MachineConstruction : InteractionTest
+{
+ private const string MachineFrame = "MachineFrame";
+ private const string Unfinished = "UnfinishedMachineFrame";
+ private const string ProtolatheBoard = "ProtolatheMachineCircuitboard";
+ private const string Protolathe = "Protolathe";
+ private const string Beaker = "Beaker";
+
+ [Test]
+ public async Task ConstructProtolathe()
+ {
+ await StartConstruction(MachineFrame);
+ await Interact(Steel, 5);
+ AssertPrototype(Unfinished);
+ await Interact(Wrench, Cable);
+ AssertPrototype(MachineFrame);
+ await Interact(ProtolatheBoard, Bin1, Bin1, Manipulator1, Manipulator1, Beaker, Beaker, Screw);
+ AssertPrototype(Protolathe);
+ }
+
+ [Test]
+ public async Task DeconstructProtolathe()
+ {
+ await StartDeconstruction(Protolathe);
+ await Interact(Screw, Pry);
+ AssertPrototype(MachineFrame);
+ await Interact(Pry, Cut);
+ AssertPrototype(Unfinished);
+ await Interact(Wrench, Screw);
+ AssertDeleted();
+ await AssertEntityLookup(
+ (Steel, 5),
+ (Cable, 1),
+ (Beaker, 2),
+ (Manipulator1, 2),
+ (Bin1, 2),
+ (ProtolatheBoard, 1));
+ }
+
+ [Test]
+ public async Task ChangeMachine()
+ {
+ // Partially deconstruct a protolathe.
+ await SpawnTarget(Protolathe);
+ await Interact(Screw, Pry, Pry);
+ AssertPrototype(MachineFrame);
+
+ // Change it into an autolathe
+ await Interact("AutolatheMachineCircuitboard");
+ AssertPrototype(MachineFrame);
+ await Interact(Bin1, Bin1, Bin1, Manipulator1, Glass, Screw);
+ AssertPrototype("Autolathe");
+ }
+
+ [Test]
+ public async Task UpgradeLathe()
+ {
+ // Partially deconstruct a protolathe.
+ await SpawnTarget(Protolathe);
+
+ // Initially has all quality-1 parts.
+ foreach (var part in SConstruction.GetAllParts(Target!.Value))
+ {
+ Assert.That(part.Rating, Is.EqualTo(1));
+ }
+
+ // Partially deconstruct lathe
+ await Interact(Screw, Pry, Pry);
+ AssertPrototype(MachineFrame);
+
+ // Reconstruct with better parts.
+ await Interact(ProtolatheBoard, Bin4, Bin4, Manipulator4, Manipulator4, Beaker, Beaker);
+ await Interact(Screw);
+ AssertPrototype(Protolathe);
+
+ // Query now returns higher quality parts.
+ foreach (var part in SConstruction.GetAllParts(Target!.Value))
+ {
+ Assert.That(part.Rating, Is.EqualTo(4));
+ }
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Server.Power.Components;
+using Content.Shared.Wires;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class PanelScrewing : InteractionTest
+{
+ [Test]
+ public async Task ApcPanel()
+ {
+ await SpawnTarget("APCBasic");
+ var comp = Comp<ApcComponent>();
+
+ // Open & close panel
+ Assert.That(comp.IsApcOpen, Is.False);
+
+ await Interact(Screw);
+ Assert.That(comp.IsApcOpen, Is.True);
+ await Interact(Screw);
+ Assert.That(comp.IsApcOpen, Is.False);
+
+ // Interrupted DoAfters
+ await Interact(Screw, awaitDoAfters: false);
+ await CancelDoAfters();
+ Assert.That(comp.IsApcOpen, Is.False);
+ await Interact(Screw);
+ Assert.That(comp.IsApcOpen, Is.True);
+ await Interact(Screw, awaitDoAfters: false);
+ await CancelDoAfters();
+ Assert.That(comp.IsApcOpen, Is.True);
+ await Interact(Screw);
+ Assert.That(comp.IsApcOpen, Is.False);
+ }
+
+ // Test wires panel on both airlocks & tcomms servers. These both use the same component, but comms may have
+ // conflicting interactions due to encryption key removal interactions.
+ [Test]
+ [TestCase("Airlock")]
+ [TestCase("TelecomServerFilled")]
+ public async Task WiresPanelScrewing(string prototype)
+ {
+ await SpawnTarget(prototype);
+ var comp = Comp<WiresPanelComponent>();
+
+ // Open & close panel
+ Assert.That(comp.Open, Is.False);
+ await Interact(Screw);
+ Assert.That(comp.Open, Is.True);
+ await Interact(Screw);
+ Assert.That(comp.Open, Is.False);
+
+ // Interrupted DoAfters
+ await Interact(Screw, awaitDoAfters: false);
+ await CancelDoAfters();
+ Assert.That(comp.Open, Is.False);
+ await Interact(Screw);
+ Assert.That(comp.Open, Is.True);
+ await Interact(Screw, awaitDoAfters: false);
+ await CancelDoAfters();
+ Assert.That(comp.Open, Is.True);
+ await Interact(Screw);
+ Assert.That(comp.Open, Is.False);
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Placeable;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class PlaceableDeconstruction : InteractionTest
+{
+ /// <summary>
+ /// Checks that you can deconstruct placeable surfaces (i.e., placing a wrench on a table does not take priority).
+ /// </summary>
+ [Test]
+ public async Task DeconstructTable()
+ {
+ await StartDeconstruction("Table");
+ Assert.That(Comp<PlaceableSurfaceComponent>().IsPlaceable);
+ await Interact(Wrench);
+ AssertPrototype("TableFrame");
+ await Interact(Wrench);
+ AssertDeleted();
+ await AssertEntityLookup((Steel, 1), (Rod, 2));
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class WallConstruction : InteractionTest
+{
+ public const string Girder = "Girder";
+ public const string WallSolid = "WallSolid";
+ public const string Wall = "Wall";
+
+ [Test]
+ public async Task ConstructWall()
+ {
+ await StartConstruction(Wall);
+ await Interact(Steel, 2);
+ Assert.IsNull(Hands.ActiveHandEntity);
+ AssertPrototype(Girder);
+ await Interact(Steel, 2);
+ Assert.IsNull(Hands.ActiveHandEntity);
+ AssertPrototype(WallSolid);
+ }
+
+ [Test]
+ public async Task DeconstructWall()
+ {
+ await StartDeconstruction(WallSolid);
+ await Interact(Weld);
+ AssertPrototype(Girder);
+ await Interact(Wrench, Screw);
+ AssertDeleted();
+ await AssertEntityLookup((Steel, 4));
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class WindowConstruction : InteractionTest
+{
+ private const string Window = "Window";
+ private const string RWindow = "ReinforcedWindow";
+
+ [Test]
+ public async Task ConstructWindow()
+ {
+ await StartConstruction(Window);
+ await Interact(Glass, 5);
+ AssertPrototype(Window);
+ }
+
+ [Test]
+ public async Task DeconstructWindow()
+ {
+ await StartDeconstruction(Window);
+ await Interact(Screw, Wrench);
+ AssertDeleted();
+ await AssertEntityLookup((Glass, 2));
+ }
+
+ [Test]
+ public async Task ConstructReinforcedWindow()
+ {
+ await StartConstruction(RWindow);
+ await Interact(RGlass, 5);
+ AssertPrototype(RWindow);
+ }
+
+ [Test]
+ public async Task DeonstructReinforcedWindow()
+ {
+ await StartDeconstruction(RWindow);
+ await Interact(
+ Weld,
+ Screw,
+ Pry,
+ Weld,
+ Screw,
+ Wrench);
+ AssertDeleted();
+ await AssertEntityLookup((RGlass, 2));
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.FixedPoint;
+using NUnit.Framework;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class WindowRepair : InteractionTest
+{
+ [Test]
+ public async Task RepairReinforcedWindow()
+ {
+ await SpawnTarget("ReinforcedWindow");
+
+ // Damage the entity.
+ var sys = SEntMan.System<DamageableSystem>();
+ var comp = Comp<DamageableComponent>();
+ var damageType = Server.ResolveDependency<IPrototypeManager>().Index<DamageTypePrototype>("Blunt");
+ var damage = new DamageSpecifier(damageType, FixedPoint2.New(10));
+ Assert.That(comp.Damage.Total, Is.EqualTo(FixedPoint2.Zero));
+ await Server.WaitPost(() => sys.TryChangeDamage(Target, damage, ignoreResistances: true));
+ await RunTicks(5);
+ Assert.That(comp.Damage.Total, Is.GreaterThan(FixedPoint2.Zero));
+
+ // Repair the entity
+ await Interact(Weld);
+ Assert.That(comp.Damage.Total, Is.EqualTo(FixedPoint2.Zero));
+
+ // Validate that we can still deconstruct the entity (i.e., that welding deconstruction is not blocked).
+ await Interact(
+ Weld,
+ Screw,
+ Pry,
+ Weld,
+ Screw,
+ Wrench);
+ AssertDeleted();
+ await AssertEntityLookup((RGlass, 2));
+ }
+}
+
--- /dev/null
+using System.Linq;
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Construction.Interaction;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.IntegrationTests.Tests.Weldable;
+using Content.Server.Tools.Components;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.DoAfter;
+
+/// <summary>
+/// This class has various tests that verify that cancelled DoAfters do not complete construction or other interactions.
+/// It also checks that cancellation of a DoAfter does not block future DoAfters.
+/// </summary>
+public sealed class DoAfterCancellationTests : InteractionTest
+{
+ [Test]
+ public async Task CancelWallDeconstruct()
+ {
+ await StartDeconstruction(WallConstruction.WallSolid);
+ await Interact(Weld, awaitDoAfters:false);
+
+ // Failed do-after has no effect
+ await CancelDoAfters();
+ AssertPrototype(WallConstruction.WallSolid);
+
+ // Second attempt works fine
+ await Interact(Weld);
+ AssertPrototype(WallConstruction.Girder);
+
+ // Repeat for wrenching interaction
+ AssertAnchored();
+ await Interact(Wrench, awaitDoAfters:false);
+ await CancelDoAfters();
+ AssertAnchored();
+ AssertPrototype(WallConstruction.Girder);
+ await Interact(Wrench);
+ AssertAnchored(false);
+
+ // Repeat for screwdriver interaction.
+ AssertDeleted(false);
+ await Interact(Screw, awaitDoAfters:false);
+ await CancelDoAfters();
+ AssertDeleted(false);
+ await Interact(Screw);
+ AssertDeleted();
+ }
+
+ [Test]
+ public async Task CancelWallConstruct()
+ {
+ await StartConstruction(WallConstruction.Wall);
+ await Interact(Steel, 5, awaitDoAfters:false);
+ await CancelDoAfters();
+ Assert.That(Target.HasValue && Target.Value.IsClientSide());
+
+ await Interact(Steel, 5);
+ AssertPrototype(WallConstruction.Girder);
+ await Interact(Steel, 5, awaitDoAfters:false);
+ await CancelDoAfters();
+ AssertPrototype(WallConstruction.Girder);
+
+ await Interact(Steel, 5);
+ AssertPrototype(WallConstruction.WallSolid);
+ }
+
+ [Test]
+ public async Task CancelTilePry()
+ {
+ await SetTile(Floor);
+ await Interact(Pry, awaitDoAfters:false);
+ await CancelDoAfters();
+ await AssertTile(Floor);
+
+ await Interact(Pry);
+ await AssertTile(Plating);
+ }
+
+ [Test]
+ public async Task CancelRepeatedTilePry()
+ {
+ await SetTile(Floor);
+ await Interact(Pry, awaitDoAfters:false);
+ await RunTicks(1);
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+ await AssertTile(Floor);
+
+ // Second DoAfter cancels the first.
+ await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+ await AssertTile(Floor);
+
+ // Third do after will work fine
+ await Interact(Pry);
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+ await AssertTile(Plating);
+ }
+
+ [Test]
+ public async Task CancelRepeatedWeld()
+ {
+ await SpawnTarget(WeldableTests.Locker);
+ var comp = Comp<WeldableComponent>();
+
+ Assert.That(comp.Weldable, Is.True);
+ Assert.That(comp.IsWelded, Is.False);
+
+ await Interact(Weld, awaitDoAfters:false);
+ await RunTicks(1);
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+ Assert.That(comp.IsWelded, Is.False);
+
+ // Second DoAfter cancels the first.
+ // Not using helper, because it runs too many ticks & causes the do-after to finish.
+ await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+ Assert.That(comp.IsWelded, Is.False);
+
+ // Third do after will work fine
+ await Interact(Weld);
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+ Assert.That(comp.IsWelded, Is.True);
+
+ // Repeat test for un-welding
+ await Interact(Weld, awaitDoAfters:false);
+ await RunTicks(1);
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+ Assert.That(comp.IsWelded, Is.True);
+ await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+ Assert.That(comp.IsWelded, Is.True);
+ await Interact(Weld);
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+ Assert.That(comp.IsWelded, Is.False);
+ }
+}
--- /dev/null
+using System.Linq;
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Radio.Components;
+using Content.Shared.Wires;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.EncryptionKeys;
+
+public sealed class RemoveEncryptionKeys : InteractionTest
+{
+ [Test]
+ public async Task HeadsetKeys()
+ {
+ await SpawnTarget("ClothingHeadsetGrey");
+ var comp = Comp<EncryptionKeyHolderComponent>();
+
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(1));
+ Assert.That(comp.DefaultChannel, Is.EqualTo("Common"));
+ Assert.That(comp.Channels.Count, Is.EqualTo(1));
+ Assert.That(comp.Channels.First(), Is.EqualTo("Common"));
+
+ // Remove the key
+ await Interact(Screw);
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(0));
+ Assert.IsNull(comp.DefaultChannel);
+ Assert.That(comp.Channels.Count, Is.EqualTo(0));
+
+ // Checkl that the key was ejected and not just deleted or something.
+ await AssertEntityLookup(("EncryptionKeyCommon", 1));
+
+ // Re-insert a key.
+ await Interact("EncryptionKeyCentCom");
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(1));
+ Assert.That(comp.DefaultChannel, Is.EqualTo("CentCom"));
+ Assert.That(comp.Channels.Count, Is.EqualTo(1));
+ Assert.That(comp.Channels.First(), Is.EqualTo("CentCom"));
+ }
+
+ [Test]
+ public async Task CommsServerKeys()
+ {
+ await SpawnTarget("TelecomServerFilled");
+ var comp = Comp<EncryptionKeyHolderComponent>();
+ var panel = Comp<WiresPanelComponent>();
+
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.GreaterThan(0));
+ Assert.That(comp.Channels.Count, Is.GreaterThan(0));
+ Assert.That(panel.Open, Is.False);
+
+ // cannot remove keys without opening panel
+ await Interact(Pry);
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.GreaterThan(0));
+ Assert.That(comp.Channels.Count, Is.GreaterThan(0));
+ Assert.That(panel.Open, Is.False);
+
+ // Open panel
+ await Interact(Screw);
+ Assert.That(panel.Open, Is.True);
+
+ // Keys are still here
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.GreaterThan(0));
+ Assert.That(comp.Channels.Count, Is.GreaterThan(0));
+
+ // Now remove the keys
+ await Interact(Pry);
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(0));
+ Assert.That(comp.Channels.Count, Is.EqualTo(0));
+
+ // Reinsert a key
+ await Interact("EncryptionKeyCentCom");
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(1));
+ Assert.That(comp.DefaultChannel, Is.EqualTo("CentCom"));
+ Assert.That(comp.Channels.Count, Is.EqualTo(1));
+ Assert.That(comp.Channels.First(), Is.EqualTo("CentCom"));
+
+ // Remove it again
+ await Interact(Pry);
+ Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(0));
+ Assert.That(comp.Channels.Count, Is.EqualTo(0));
+
+ // Prying again will start deconstructing the machine.
+ AssertPrototype("TelecomServerFilled");
+ await Interact(Pry);
+ AssertPrototype("MachineFrame");
+ }
+}
+
Assert.That(interactUsing);
});
+ testInteractionSystem.ClearHandlers();
await pairTracker.CleanReturnAsync();
}
Assert.That(interactUsing, Is.False);
});
+ testInteractionSystem.ClearHandlers();
await pairTracker.CleanReturnAsync();
}
Assert.That(interactUsing);
});
+ testInteractionSystem.ClearHandlers();
await pairTracker.CleanReturnAsync();
}
Assert.That(interactUsing, Is.False);
});
+ testInteractionSystem.ClearHandlers();
await pairTracker.CleanReturnAsync();
}
Assert.That(interactUsing, Is.True);
});
+ testInteractionSystem.ClearHandlers();
await pairTracker.CleanReturnAsync();
}
SubscribeLocalEvent<InteractUsingEvent>((e) => InteractUsingEvent?.Invoke(e));
SubscribeLocalEvent<InteractHandEvent>((e) => InteractHandEvent?.Invoke(e));
}
+
+ public void ClearHandlers()
+ {
+ InteractUsingEvent = null;
+ InteractHandEvent = null;
+ }
}
}
--- /dev/null
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+// This partial class contains various constant prototype IDs common to interaction tests.
+// Should make it easier to mass-change hard coded strings if prototypes get renamed.
+public abstract partial class InteractionTest
+{
+ protected const string PlayerEntity = "AdminObserver";
+
+ // Tiles
+ protected const string Floor = "FloorSteel";
+ protected const string FloorItem = "FloorTileItemSteel";
+ protected const string Plating = "Plating";
+ protected const string Lattice = "Lattice";
+
+ // Tools/steps
+ protected const string Wrench = "Wrench";
+ protected const string Screw = "Screwdriver";
+ protected const string Weld = "WelderExperimental";
+ protected const string Pry = "Crowbar";
+ protected const string Cut = "Wirecutter";
+
+ // Materials/stacks
+ protected const string Steel = "Steel";
+ protected const string Glass = "Glass";
+ protected const string RGlass = "ReinforcedGlass";
+ protected const string Plastic = "Plastic";
+ protected const string Cable = "Cable";
+ protected const string Rod = "MetalRod";
+
+ // Parts
+ protected const string Bin1 = "MatterBinStockPart";
+ protected const string Bin4 = "BluespaceMatterBinStockPart";
+ protected const string Cap1 = "CapacitorStockPart";
+ protected const string Cap4 = "QuadraticCapacitorStockPart";
+ protected const string Manipulator1 = "MicroManipulatorStockPart";
+ protected const string Manipulator4 = "FemtoManipulatorStockPart";
+ protected const string Laser1 = "MicroLaserStockPart";
+ protected const string Laser2 = "QuadUltraMicroLaserStockPart";
+ protected const string Battery1 = "PowerCellSmall";
+ protected const string Battery4 = "PowerCellHyper";
+}
+
--- /dev/null
+#nullable enable
+using System.Threading.Tasks;
+using Content.Shared.Stacks;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+public abstract partial class InteractionTest
+{
+ /// <summary>
+ /// Utility class for working with prototypes ids that may refer to stacks or entities.
+ /// </summary>
+ /// <remarks>
+ /// Intended to make tests easier by removing ambiguity around "SheetSteel1", "SheetSteel", and "Steel". All three
+ /// should be treated identically by interaction tests.
+ /// </remarks>
+ protected sealed class EntitySpecifier
+ {
+ /// <summary>
+ /// Either the stack or entity prototype for this entity. Stack prototypes take priority.
+ /// </summary>
+ public string Prototype;
+
+ /// <summary>
+ /// The quantity. If the entity has a stack component, this is the total stack quantity.
+ /// Otherwise this is the number of entities.
+ /// </summary>
+ /// <remarks>
+ /// If used for spawning and this number is larger than the max stack size, only a single stack will be spawned.
+ /// </remarks>
+ public int Quantity;
+
+ /// <summary>
+ /// If true, a check has been performed to see if the prototype ia an entity prototype with a stack component,
+ /// in which case the specifier was converted into a stack-specifier
+ /// </summary>
+ public bool Converted;
+
+ public EntitySpecifier(string prototype, int quantity, bool converted = false)
+ {
+ Assert.That(quantity > 0);
+ Prototype = prototype;
+ Quantity = quantity;
+ Converted = converted;
+ }
+
+ public static implicit operator EntitySpecifier(string prototype)
+ => new(prototype, 1);
+
+ public static implicit operator EntitySpecifier((string, int) tuple)
+ => new(tuple.Item1, tuple.Item2);
+
+ /// <summary>
+ /// Convert applicable entity prototypes into stack prototypes.
+ /// </summary>
+ public void ConvertToStack(IPrototypeManager protoMan, IComponentFactory factory)
+ {
+ if (Converted)
+ return;
+
+ Converted = true;
+ if (protoMan.HasIndex<StackPrototype>(Prototype))
+ return;
+
+ if (!protoMan.TryIndex<EntityPrototype>(Prototype, out var entProto))
+ {
+ Assert.Fail($"Unknown prototype: {Prototype}");
+ return;
+ }
+
+ if (entProto.TryGetComponent<StackComponent>(factory.GetComponentName(typeof(StackComponent)),
+ out var stackComp))
+ {
+ Prototype = stackComp.StackTypeId;
+ }
+ }
+ }
+
+ protected async Task<EntityUid> SpawnEntity(EntitySpecifier spec, EntityCoordinates coords)
+ {
+ EntityUid uid = default!;
+ if (ProtoMan.TryIndex<StackPrototype>(spec.Prototype, out var stackProto))
+ {
+ await Server.WaitPost(() =>
+ {
+ uid = SEntMan.SpawnEntity(stackProto.Spawn, coords);
+ Stack.SetCount(uid, spec.Quantity);
+ });
+ return uid;
+ }
+
+ if (!ProtoMan.TryIndex<EntityPrototype>(spec.Prototype, out var entProto))
+ {
+ Assert.Fail($"Unkown prototype: {spec.Prototype}");
+ return default;
+ }
+
+ if (entProto.TryGetComponent<StackComponent>(Factory.GetComponentName(typeof(StackComponent)),
+ out var stackComp))
+ {
+ return await SpawnEntity((stackComp.StackTypeId, spec.Quantity), coords);
+ }
+
+ Assert.That(spec.Quantity, Is.EqualTo(1), "SpawnEntity only supports returning a singular entity");
+ await Server.WaitPost(() => uid = SEntMan.SpawnEntity(spec.Prototype, coords));;
+ return uid;
+ }
+
+ /// <summary>
+ /// Convert an entity-uid to a matching entity specifier. Usefull when doing entity lookups & checking that the
+ /// right quantity of entities/materials werre produced.
+ /// </summary>
+ protected EntitySpecifier ToEntitySpecifier(EntityUid uid)
+ {
+ if (SEntMan.TryGetComponent(uid, out StackComponent? stack))
+ return new EntitySpecifier(stack.StackTypeId, stack.Count) {Converted = true};
+
+ var meta = SEntMan.GetComponent<MetaDataComponent>(uid);
+ Assert.NotNull(meta.EntityPrototype);
+
+ return new (meta.EntityPrototype.ID, 1) { Converted = true };
+ }
+}
--- /dev/null
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using Content.Shared.Stacks;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+public abstract partial class InteractionTest
+{
+ /// <summary>
+ /// Data structure for representing a collection of <see cref="EntitySpecifier"/>s.
+ /// </summary>
+ protected sealed class EntitySpecifierCollection
+ {
+ public Dictionary<string, int> Entities = new();
+
+ /// <summary>
+ /// If true, a check has been performed to see if the prototypes correspond to entity prototypes with a stack
+ /// component, in which case the specifier was converted into a stack-specifier
+ /// </summary>
+ public bool Converted;
+
+ public EntitySpecifierCollection()
+ {
+ Converted = true;
+ }
+
+ public EntitySpecifierCollection(IEnumerable<EntitySpecifier> ents)
+ {
+ Converted = true;
+ foreach (var ent in ents)
+ {
+ Add(ent);
+ }
+ }
+
+ public static implicit operator EntitySpecifierCollection(string prototype)
+ {
+ var result = new EntitySpecifierCollection();
+ result.Add(prototype, 1);
+ return result;
+ }
+
+ public static implicit operator EntitySpecifierCollection((string, int) tuple)
+ {
+ var result = new EntitySpecifierCollection();
+ result.Add(tuple.Item1, tuple.Item2);
+ return result;
+ }
+
+ public void Remove(EntitySpecifier spec)
+ => Add(new EntitySpecifier(spec.Prototype, -spec.Quantity, spec.Converted));
+
+ public void Add(EntitySpecifier spec)
+ => Add(spec.Prototype, spec.Quantity, spec.Converted);
+
+ public void Add(string id, int quantity, bool converted = false)
+ {
+ Converted &= converted;
+
+ if (!Entities.TryGetValue(id, out var existing))
+ {
+ if (quantity != 0)
+ Entities.Add(id, quantity);
+ return;
+ }
+
+ var newQuantity = quantity + existing;
+ if (newQuantity == 0)
+ Entities.Remove(id);
+ else
+ Entities[id] = newQuantity;
+ }
+
+ public void Add(EntitySpecifierCollection collection)
+ {
+ var converted = Converted && collection.Converted;
+ foreach (var (id, quantity) in collection.Entities)
+ {
+ Add(id, quantity);
+ }
+ Converted = converted;
+ }
+
+ public void Remove(EntitySpecifierCollection collection)
+ {
+ var converted = Converted && collection.Converted;
+ foreach (var (id, quantity) in collection.Entities)
+ {
+ Add(id, -quantity);
+ }
+ Converted = converted;
+ }
+
+ public EntitySpecifierCollection Clone()
+ {
+ return new EntitySpecifierCollection()
+ {
+ Entities = Entities.ShallowClone(),
+ Converted = Converted
+ };
+ }
+
+ /// <summary>
+ /// Convert applicable entity prototypes into stack prototypes.
+ /// </summary>
+ public void ConvertToStacks(IPrototypeManager protoMan, IComponentFactory factory)
+ {
+ if (Converted)
+ return;
+
+ HashSet<string> toRemove = new();
+ List<(string, int)> toAdd = new();
+ foreach (var (id, quantity) in Entities)
+ {
+
+ if (protoMan.HasIndex<StackPrototype>(id))
+ continue;
+
+ if (!protoMan.TryIndex<EntityPrototype>(id, out var entProto))
+ {
+ Assert.Fail($"Unknown prototype: {id}");
+ continue;
+ }
+
+ if (!entProto.TryGetComponent<StackComponent>(factory.GetComponentName(typeof(StackComponent)),
+ out var stackComp))
+ {
+ continue;
+ }
+
+ toRemove.Add(id);
+ toAdd.Add((stackComp.StackTypeId, quantity));
+ }
+
+ foreach (var id in toRemove)
+ {
+ Entities.Remove(id);
+ }
+
+ foreach (var (id, quantity) in toAdd)
+ {
+ Add(id, quantity);
+ }
+
+ Converted = true;
+ }
+ }
+
+ protected EntitySpecifierCollection ToEntityCollection(IEnumerable<EntityUid> entities)
+ {
+ var collection = new EntitySpecifierCollection(entities.Select(uid => ToEntitySpecifier(uid)));
+ Assert.That(collection.Converted);
+ return collection;
+ }
+}
--- /dev/null
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Client.Construction;
+using Content.Server.Construction.Components;
+using Content.Server.Tools.Components;
+using Content.Shared.Construction.Prototypes;
+using Content.Shared.Item;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Log;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Maths;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+// This partial class defines various methods that are useful for performing & validating interactions
+public abstract partial class InteractionTest
+{
+ /// <summary>
+ /// Begin constructing an entity.
+ /// </summary>
+ protected async Task StartConstruction(string prototype, bool shouldSucceed = true)
+ {
+ var proto = ProtoMan.Index<ConstructionPrototype>(prototype);
+ Assert.That(proto.Type, Is.EqualTo(ConstructionType.Structure));
+
+ await Client.WaitPost(() =>
+ {
+ Assert.That(CConSys.TrySpawnGhost(proto, TargetCoords, Direction.South, out Target),
+ Is.EqualTo(shouldSucceed));
+
+ if (!shouldSucceed)
+ return;
+ var comp = CEntMan.GetComponent<ConstructionGhostComponent>(Target!.Value);
+ ConstructionGhostId = comp.GhostId;
+ });
+
+ await RunTicks(1);
+ }
+
+ /// <summary>
+ /// Craft an item.
+ /// </summary>
+ protected async Task CraftItem(string prototype, bool shouldSucceed = true)
+ {
+ Assert.That(ProtoMan.Index<ConstructionPrototype>(prototype).Type, Is.EqualTo(ConstructionType.Item));
+
+ // Please someone purge async construction code
+ Task<bool> task =default!;
+ await Server.WaitPost(() => task = SConstruction.TryStartItemConstruction(prototype, Player));
+
+ Task? tickTask = null;
+ while (!task.IsCompleted)
+ {
+ tickTask = PoolManager.RunTicksSync(PairTracker.Pair, 1);
+ await Task.WhenAny(task, tickTask);
+ }
+
+ if (tickTask != null)
+ await tickTask;
+
+#pragma warning disable RA0004
+ Assert.That(task.Result, Is.EqualTo(shouldSucceed));
+#pragma warning restore RA0004
+
+ await RunTicks(5);
+ }
+
+ /// <summary>
+ /// Spawn an entity entity and set it as the target.
+ /// </summary>
+ protected async Task SpawnTarget(string prototype)
+ {
+ await Server.WaitPost(() =>
+ {
+ Target = SEntMan.SpawnEntity(prototype, TargetCoords);
+ });
+
+ await RunTicks(5);
+ AssertPrototype(prototype);
+ }
+
+ /// <summary>
+ /// Spawn an entity in preparation for deconstruction
+ /// </summary>
+ protected async Task StartDeconstruction(string prototype)
+ {
+ await SpawnTarget(prototype);
+ Assert.That(SEntMan.TryGetComponent(Target, out ConstructionComponent? comp));
+ await Server.WaitPost(() => SConstruction.SetPathfindingTarget(Target!.Value, comp!.DeconstructionNode, comp));
+ await RunTicks(5);
+ }
+
+ /// <summary>
+ /// Drops and deletes the currently held entity.
+ /// </summary>
+ protected async Task DeleteHeldEntity()
+ {
+ if (Hands.ActiveHandEntity is {} held)
+ {
+ await Server.WaitPost(() =>
+ {
+ Assert.That(HandSys.TryDrop(Player, null, false, true, Hands));
+ SEntMan.DeleteEntity(held);
+ Logger.Debug($"Deleting held entity");
+ });
+ }
+
+ await RunTicks(1);
+ Assert.That(Hands.ActiveHandEntity == null);
+ }
+
+ /// <summary>
+ /// Place an entity prototype into the players hand. Deletes any currently held entity.
+ /// </summary>
+ /// <remarks>
+ /// Automatically enables welders.
+ /// </remarks>
+ protected async Task<EntityUid?> PlaceInHands(string? id, int quantity = 1, bool enableWelder = true)
+ => await PlaceInHands(id == null ? null : (id, quantity), enableWelder);
+
+ /// <summary>
+ /// Place an entity prototype into the players hand. Deletes any currently held entity.
+ /// </summary>
+ /// <remarks>
+ /// Automatically enables welders.
+ /// </remarks>
+ protected async Task<EntityUid?> PlaceInHands(EntitySpecifier? entity, bool enableWelder = true)
+ {
+ if (Hands.ActiveHand == null)
+ {
+ Assert.Fail("No active hand");
+ return default;
+ }
+
+ await DeleteHeldEntity();
+
+ if (entity == null)
+ {
+ await RunTicks(1);
+ Assert.That(Hands.ActiveHandEntity == null);
+ return null;
+ }
+
+ // spawn and pick up the new item
+ EntityUid item = await SpawnEntity(entity, PlayerCoords);
+ WelderComponent? welder = null;
+
+ await Server.WaitPost(() =>
+ {
+ Assert.That(HandSys.TryPickup(Player, item, Hands.ActiveHand, false, false, false, Hands));
+
+ // turn on welders
+ if (enableWelder && SEntMan.TryGetComponent(item, out welder) && !welder.Lit)
+ Assert.That(ToolSys.TryTurnWelderOn(item, Player, welder));
+ });
+
+ await RunTicks(1);
+ Assert.That(Hands.ActiveHandEntity, Is.EqualTo(item));
+ if (enableWelder && welder != null)
+ Assert.That(welder.Lit);
+
+ return item;
+ }
+
+ /// <summary>
+ /// Pick up an entity. Defaults to just deleting the previously held entity.
+ /// </summary>
+ protected async Task Pickup(EntityUid? uid = null, bool deleteHeld = true)
+ {
+ uid ??= Target;
+
+ if (Hands.ActiveHand == null)
+ {
+ Assert.Fail("No active hand");
+ return;
+ }
+
+ if (deleteHeld)
+ await DeleteHeldEntity();
+
+ if (!SEntMan.TryGetComponent(uid, out ItemComponent? item))
+ {
+ Assert.Fail($"Entity {uid} is not an item");
+ return;
+ }
+
+ await Server.WaitPost(() =>
+ {
+ Assert.That(HandSys.TryPickup(Player, uid!.Value, Hands.ActiveHand, false, false, false, Hands, item));
+ });
+
+ await RunTicks(1);
+ Assert.That(Hands.ActiveHandEntity, Is.EqualTo(uid));
+ }
+
+ /// <summary>
+ /// Drops the currently held entity.
+ /// </summary>
+ protected async Task Drop()
+ {
+ if (Hands.ActiveHandEntity == null)
+ {
+ Assert.Fail("Not holding any entity to drop");
+ return;
+ }
+
+ await Server.WaitPost(() =>
+ {
+ Assert.That(HandSys.TryDrop(Player, handsComp: Hands));
+ });
+
+ await RunTicks(1);
+ Assert.IsNull(Hands.ActiveHandEntity);
+ }
+
+ /// <summary>
+ /// Use the currently held entity.
+ /// </summary>
+ protected async Task UseInHand()
+ {
+ if (Hands.ActiveHandEntity is not {} target)
+ {
+ Assert.Fail("Not holding any entity");
+ return;
+ }
+
+ await Server.WaitPost(() =>
+ {
+ InteractSys.UserInteraction(Player, SEntMan.GetComponent<TransformComponent>(target).Coordinates, target);
+ });
+ }
+
+ /// <summary>
+ /// Place an entity prototype into the players hand and interact with the given entity (or target position)
+ /// </summary>
+ protected async Task Interact(string? id, int quantity = 1, bool shouldSucceed = true, bool awaitDoAfters = true)
+ => await Interact(id == null ? null : (id, quantity), shouldSucceed, awaitDoAfters);
+
+ /// <summary>
+ /// Place an entity prototype into the players hand and interact with the given entity (or target position)
+ /// </summary>
+ protected async Task Interact(EntitySpecifier? entity, bool shouldSucceed = true, bool awaitDoAfters = true)
+ {
+ // For every interaction, we will also examine the entity, just in case this breaks something, somehow.
+ // (e.g., servers attempt to assemble construction examine hints).
+ if (Target != null)
+ {
+ await Client.WaitPost(() => ExamineSys.DoExamine(Target.Value));
+ }
+
+ await PlaceInHands(entity);
+
+ if (Target == null || !Target.Value.IsClientSide())
+ {
+ await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+ await RunTicks(1);
+ }
+ else
+ {
+ // The entity is client-side, so attempt to start construction
+ var ghost = CEntMan.GetComponent<ConstructionGhostComponent>(Target.Value);
+ await Client.WaitPost(() => CConSys.TryStartConstruction(ghost.GhostId));
+ await RunTicks(5);
+ }
+
+ if (awaitDoAfters)
+ await AwaitDoAfters(shouldSucceed);
+
+ await CheckTargetChange(shouldSucceed && awaitDoAfters);
+ }
+
+ /// <summary>
+ /// Wait for any currently active DoAfters to finish.
+ /// </summary>
+ protected async Task AwaitDoAfters(bool shouldSucceed = true, int maxExpected = 1)
+ {
+ if (!ActiveDoAfters.Any())
+ return;
+
+ // Generally expect interactions to only start one DoAfter.
+ Assert.That(ActiveDoAfters.Count(), Is.LessThanOrEqualTo(maxExpected));
+
+ // wait out the DoAfters.
+ var doAfters = ActiveDoAfters.ToList();
+ while (ActiveDoAfters.Any())
+ {
+ await RunTicks(10);
+ }
+
+ if (!shouldSucceed)
+ return;
+
+ foreach (var doAfter in doAfters)
+ {
+ Assert.That(!doAfter.Cancelled);
+ }
+ }
+
+ /// <summary>
+ /// Cancel any currently active DoAfters. Default arguments are such that it also checks that there is at least one
+ /// active DoAfter to cancel.
+ /// </summary>
+ protected async Task CancelDoAfters(int minExpected = 1, int maxExpected = 1)
+ {
+ Assert.That(ActiveDoAfters.Count(), Is.GreaterThanOrEqualTo(minExpected));
+ Assert.That(ActiveDoAfters.Count(), Is.LessThanOrEqualTo(maxExpected));
+
+ if (!ActiveDoAfters.Any())
+ return;
+
+ // Cancel all the do-afters
+ var doAfters = ActiveDoAfters.ToList();
+ await Server.WaitPost(() =>
+ {
+ foreach (var doAfter in doAfters)
+ {
+ DoAfterSys.Cancel(Player, doAfter.Index, DoAfters);
+ }
+ });
+
+ await RunTicks(1);
+
+ foreach (var doAfter in doAfters)
+ {
+ Assert.That(doAfter.Cancelled);
+ }
+
+ Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+ }
+
+ /// <summary>
+ /// Check if the test's target entity has changed. E.g., construction interactions will swap out entities while
+ /// a structure is being built.
+ /// </summary>
+ protected async Task CheckTargetChange(bool shouldSucceed)
+ {
+ EntityUid newTarget = default;
+ if (Target == null)
+ return;
+ var target = Target.Value;
+
+ await RunTicks(5);
+
+ if (target.IsClientSide())
+ {
+ Assert.That(CEntMan.Deleted(target), Is.EqualTo(shouldSucceed),
+ $"Construction ghost was {(shouldSucceed ? "not deleted" : "deleted")}.");
+
+ if (shouldSucceed)
+ {
+ Assert.That(CTestSystem.Ghosts.TryGetValue(ConstructionGhostId, out newTarget),
+ $"Failed to get construction entity from ghost Id");
+
+ await Client.WaitPost(() => Logger.Debug($"Construction ghost {ConstructionGhostId} became entity {newTarget}"));
+ Target = newTarget;
+ }
+ }
+
+ if (STestSystem.EntChanges.TryGetValue(Target.Value, out newTarget))
+ {
+ await Server.WaitPost(
+ () => Logger.Debug($"Construction entity {Target.Value} changed to {newTarget}"));
+
+ Target = newTarget;
+ }
+
+ if (Target != target)
+ await CheckTargetChange(shouldSucceed);
+ }
+
+ /// <summary>
+ /// Variant of <see cref="InteractUsing"/> that performs several interactions using different entities.
+ /// </summary>
+ protected async Task Interact(params EntitySpecifier?[] specifiers)
+ {
+ foreach (var spec in specifiers)
+ {
+ await Interact(spec);
+ }
+ }
+
+ #region Asserts
+
+ protected void AssertPrototype(string? prototype)
+ {
+ var meta = Comp<MetaDataComponent>();
+ Assert.That(meta.EntityPrototype?.ID, Is.EqualTo(prototype));
+ }
+
+ protected void AssertAnchored(bool anchored = true)
+ {
+ var sXform = SEntMan.GetComponent<TransformComponent>(Target!.Value);
+ var cXform = CEntMan.GetComponent<TransformComponent>(Target.Value);
+ Assert.That(sXform.Anchored, Is.EqualTo(anchored));
+ Assert.That(cXform.Anchored, Is.EqualTo(anchored));
+ }
+
+ protected void AssertDeleted(bool deleted = true)
+ {
+ Assert.That(SEntMan.Deleted(Target), Is.EqualTo(deleted));
+ Assert.That(CEntMan.Deleted(Target), Is.EqualTo(deleted));
+ }
+
+ /// <summary>
+ /// Assert whether or not the target has the given component.
+ /// </summary>
+ protected void AssertComp<T>(bool hasComp = true)
+ {
+ Assert.That(SEntMan.HasComponent<T>(Target), Is.EqualTo(hasComp));
+ }
+
+ /// <summary>
+ /// Check that the tile at the target position matches some prototype.
+ /// </summary>
+ protected async Task AssertTile(string? proto, EntityCoordinates? coords = null)
+ {
+ var targetTile = proto == null
+ ? Tile.Empty
+ : new Tile(TileMan[proto].TileId);
+
+ Tile tile = Tile.Empty;
+ var pos = (coords ?? TargetCoords).ToMap(SEntMan, Transform);
+ await Server.WaitPost(() =>
+ {
+ if (MapMan.TryFindGridAt(pos, out var grid))
+ tile = grid.GetTileRef(coords ?? TargetCoords).Tile;
+ });
+
+ Assert.That(tile.TypeId, Is.EqualTo(targetTile.TypeId));
+ }
+
+ #endregion
+
+ #region Entity lookups
+
+ /// <summary>
+ /// Returns entities in an area around the target. Ignores the map, grid, player, target, and contained entities.
+ /// </summary>
+ protected async Task<HashSet<EntityUid>> DoEntityLookup(LookupFlags flags = LookupFlags.Uncontained)
+ {
+ var lookup = SEntMan.System<EntityLookupSystem>();
+
+ HashSet<EntityUid> entities = default!;
+ await Server.WaitPost(() =>
+ {
+ // Get all entities left behind by deconstruction
+ entities = lookup.GetEntitiesIntersecting(MapId, Box2.CentredAroundZero((10, 10)), flags);
+
+ var xformQuery = SEntMan.GetEntityQuery<TransformComponent>();
+
+ HashSet<EntityUid> toRemove = new();
+ foreach (var ent in entities)
+ {
+ var transform = xformQuery.GetComponent(ent);
+
+ if (ent == transform.MapUid
+ || ent == transform.GridUid
+ || ent == Player
+ || ent == Target)
+ {
+ toRemove.Add(ent);
+ }
+ }
+
+ entities.ExceptWith(toRemove);
+ });
+
+ return entities;
+ }
+
+ /// <summary>
+ /// Performs an entity lookup and asserts that only the listed entities exist and that they are all present.
+ /// Ignores the grid, map, player, target and contained entities.
+ /// </summary>
+ protected async Task AssertEntityLookup(params EntitySpecifier[] entities)
+ {
+ var collection = new EntitySpecifierCollection(entities);
+ await AssertEntityLookup(collection);
+ }
+
+ /// <summary>
+ /// Performs an entity lookup and asserts that only the listed entities exist and that they are all present.
+ /// Ignores the grid, map, player, target and contained entities.
+ /// </summary>
+ protected async Task AssertEntityLookup(
+ EntitySpecifierCollection collection,
+ bool failOnMissing = true,
+ bool failOnExcess = true,
+ LookupFlags flags = LookupFlags.Uncontained)
+ {
+ var expected = collection.Clone();
+ var entities = await DoEntityLookup(flags);
+ var found = ToEntityCollection(entities);
+ expected.Remove(found);
+ expected.ConvertToStacks(ProtoMan, Factory);
+
+ if (expected.Entities.Count == 0)
+ return;
+
+ Assert.Multiple(() =>
+ {
+ foreach (var (proto, quantity) in expected.Entities)
+ {
+ if (quantity < 0 && failOnExcess)
+ Assert.Fail($"Unexpected entity/stack: {proto}, quantity: {-quantity}");
+
+ if (quantity > 0 && failOnMissing)
+ Assert.Fail($"Missing entity/stack: {proto}, quantity: {quantity}");
+
+ if (quantity == 0)
+ throw new Exception("Error in entity collection math.");
+ }
+ });
+ }
+
+ /// <summary>
+ /// Performs an entity lookup and attempts to find an entity matching the given entity specifier.
+ /// </summary>
+ /// <remarks>
+ /// This is used to check that an item-crafting attempt was successful. Ideally crafting items would just return the
+ /// entity or raise an event or something.
+ /// </remarks>
+ protected async Task<EntityUid> FindEntity(
+ EntitySpecifier spec,
+ LookupFlags flags = LookupFlags.Uncontained | LookupFlags.Contained,
+ bool shouldSucceed = true)
+ {
+ spec.ConvertToStack(ProtoMan, Factory);
+
+ var entities = await DoEntityLookup(flags);
+ foreach (var uid in entities)
+ {
+ var found = ToEntitySpecifier(uid);
+ if (spec.Prototype != found.Prototype)
+ continue;
+
+ if (found.Quantity >= spec.Quantity)
+ return uid;
+
+ // TODO combine stacks?
+ }
+
+ if (shouldSucceed)
+ Assert.Fail($"Could not find stack/entity with prototype {spec.Prototype}");
+
+ return default;
+ }
+
+ #endregion
+
+
+ /// <summary>
+ /// List of currently active DoAfters on the player.
+ /// </summary>
+ protected IEnumerable<Shared.DoAfter.DoAfter> ActiveDoAfters
+ => DoAfters.DoAfters.Values.Where(x => !x.Cancelled && !x.Completed);
+
+ /// <summary>
+ /// Convenience method to get components on the target. Returns SERVER-SIDE components.
+ /// </summary>
+ protected T Comp<T>() => SEntMan.GetComponent<T>(Target!.Value);
+
+ /// <summary>
+ /// Set the tile at the target position to some prototype.
+ /// </summary>
+ protected async Task SetTile(string? proto, EntityCoordinates? coords = null, MapGridComponent? grid = null)
+ {
+ var tile = proto == null
+ ? Tile.Empty
+ : new Tile(TileMan[proto].TileId);
+
+ var pos = (coords ?? TargetCoords).ToMap(SEntMan, Transform);
+
+ await Server.WaitPost(() =>
+ {
+ if (grid != null || MapMan.TryFindGridAt(pos, out grid))
+ {
+ grid.SetTile(coords ?? TargetCoords, tile);
+ return;
+ }
+
+ if (proto == null)
+ return;
+
+ grid = MapMan.CreateGrid(MapData.MapId);
+ var gridXform = SEntMan.GetComponent<TransformComponent>(grid.Owner);
+ Transform.SetWorldPosition(gridXform, pos.Position);
+ grid.SetTile(coords ?? TargetCoords, tile);
+
+ if (!MapMan.TryFindGridAt(pos, out grid))
+ Assert.Fail("Failed to create grid?");
+ });
+ await AssertTile(proto, coords);
+ }
+
+ protected async Task Delete(EntityUid uid)
+ {
+ await Server.WaitPost(() => SEntMan.DeleteEntity(uid));
+ await RunTicks(5);
+ }
+
+ protected async Task RunTicks(int ticks)
+ {
+ await PoolManager.RunTicksSync(PairTracker.Pair, ticks);
+ }
+
+ protected async Task RunSeconds(float seconds)
+ => await RunTicks((int) Math.Ceiling(seconds / TickPeriod));
+}
--- /dev/null
+#nullable enable
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Client.Construction;
+using Content.Client.Examine;
+using Content.Server.Body.Systems;
+using Content.Server.Mind.Components;
+using Content.Server.Stack;
+using Content.Server.Tools;
+using Content.Shared.Body.Part;
+using Content.Shared.DoAfter;
+using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Interaction;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+using Robust.UnitTesting;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+/// <summary>
+/// This is a base class designed to make it easier to test various interactions like construction & DoAfters.
+///
+/// For construction tests, the interactions are intentionally hard-coded and not pulled automatically from the
+/// construction graph, even though this may be a pain to maintain. This is because otherwise these tests could not
+/// detect errors in the graph pathfinding (e.g., infinite loops, missing steps, etc).
+/// </summary>
+[TestFixture]
+[FixtureLifeCycle(LifeCycle.InstancePerTestCase)]
+public abstract partial class InteractionTest
+{
+ protected PairTracker PairTracker = default!;
+ protected TestMapData MapData = default!;
+
+ protected RobustIntegrationTest.ServerIntegrationInstance Server => PairTracker.Pair.Server;
+ protected RobustIntegrationTest.ClientIntegrationInstance Client => PairTracker.Pair.Client;
+
+ protected MapId MapId => MapData.MapId;
+
+ /// <summary>
+ /// Target coordinates. Note that this does not necessarily correspond to the position of the <see cref="Target"/>
+ /// entity.
+ /// </summary>
+ protected EntityCoordinates TargetCoords;
+
+ /// <summary>
+ /// Initial player coordinates. Note that this does not necessarily correspond to the position of the
+ /// <see cref="Player"/> entity.
+ /// </summary>
+ protected EntityCoordinates PlayerCoords;
+
+ /// <summary>
+ /// The player entity that performs all these interactions. Defaults to an admin-observer with 1 hand.
+ /// </summary>
+ protected EntityUid Player;
+
+ /// <summary>
+ /// The current target entity. This is the default entity for various helper functions.
+ /// </summary>
+ /// <remarks>
+ /// Note that this target may be automatically modified by various interactions, in particular construction
+ /// interactions often swap out entities, and there are helper methods that attempt to automatically upddate
+ /// the target entity. See <see cref="CheckTargetChange"/>
+ /// </remarks>
+ protected EntityUid? Target;
+
+ /// <summary>
+ /// When attempting to start construction, this is the client-side ID of the construction ghost.
+ /// </summary>
+ protected int ConstructionGhostId;
+
+ // SERVER dependencies
+ protected IEntityManager SEntMan = default!;
+ protected ITileDefinitionManager TileMan = default!;
+ protected IMapManager MapMan = default!;
+ protected IPrototypeManager ProtoMan = default!;
+ protected IGameTiming Timing = default!;
+ protected IComponentFactory Factory = default!;
+ protected SharedHandsSystem HandSys = default!;
+ protected StackSystem Stack = default!;
+ protected SharedInteractionSystem InteractSys = default!;
+ protected Content.Server.Construction.ConstructionSystem SConstruction = default!;
+ protected SharedDoAfterSystem DoAfterSys = default!;
+ protected ToolSystem ToolSys = default!;
+ protected InteractionTestSystem STestSystem = default!;
+ protected SharedTransformSystem Transform = default!;
+
+ // CLIENT dependencies
+ protected IEntityManager CEntMan = default!;
+ protected ConstructionSystem CConSys = default!;
+ protected ExamineSystem ExamineSys = default!;
+ protected InteractionTestSystem CTestSystem = default!;
+
+ // player components
+ protected HandsComponent Hands = default!;
+ protected DoAfterComponent DoAfters = default!;
+
+ public float TickPeriod => (float)Timing.TickPeriod.TotalSeconds;
+
+ [SetUp]
+ public async Task Setup()
+ {
+ PairTracker = await PoolManager.GetServerClient(new PoolSettings());
+
+ // server dependencies
+ SEntMan = Server.ResolveDependency<IEntityManager>();
+ TileMan = Server.ResolveDependency<ITileDefinitionManager>();
+ MapMan = Server.ResolveDependency<IMapManager>();
+ ProtoMan = Server.ResolveDependency<IPrototypeManager>();
+ Factory = Server.ResolveDependency<IComponentFactory>();
+ Timing = Server.ResolveDependency<IGameTiming>();
+ HandSys = SEntMan.System<SharedHandsSystem>();
+ InteractSys = SEntMan.System<SharedInteractionSystem>();
+ ToolSys = SEntMan.System<ToolSystem>();
+ DoAfterSys = SEntMan.System<SharedDoAfterSystem>();
+ Transform = SEntMan.System<SharedTransformSystem>();
+ SConstruction = SEntMan.System<Content.Server.Construction.ConstructionSystem>();
+ STestSystem = SEntMan.System<InteractionTestSystem>();
+ Stack = SEntMan.System<StackSystem>();
+
+ // client dependencies
+ CEntMan = Client.ResolveDependency<IEntityManager>();
+ CTestSystem = CEntMan.System<InteractionTestSystem>();
+ CConSys = CEntMan.System<ConstructionSystem>();
+ ExamineSys = CEntMan.System<ExamineSystem>();
+
+ // Setup map.
+ MapData = await PoolManager.CreateTestMap(PairTracker);
+ PlayerCoords = MapData.GridCoords.Offset((0.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan);
+ TargetCoords = MapData.GridCoords.Offset((1.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan);
+ await SetTile(Plating, grid: MapData.MapGrid);
+
+ // Get player data
+ var sPlayerMan = Server.ResolveDependency<Robust.Server.Player.IPlayerManager>();
+ var cPlayerMan = Client.ResolveDependency<Robust.Client.Player.IPlayerManager>();
+ if (cPlayerMan.LocalPlayer?.Session == null)
+ Assert.Fail("No player");
+ var cSession = cPlayerMan.LocalPlayer!.Session!;
+ var sSession = sPlayerMan.GetSessionByUserId(cSession.UserId);
+
+ // Spawn player entity & attach
+ EntityUid? old = default;
+ await Server.WaitPost(() =>
+ {
+ old = cPlayerMan.LocalPlayer.ControlledEntity;
+ Player = SEntMan.SpawnEntity(PlayerEntity, PlayerCoords);
+ sSession.AttachToEntity(Player);
+ Hands = SEntMan.GetComponent<HandsComponent>(Player);
+ DoAfters = SEntMan.GetComponent<DoAfterComponent>(Player);
+ });
+
+ // Check player got attached.
+ await RunTicks(5);
+ Assert.That(cPlayerMan.LocalPlayer.ControlledEntity, Is.EqualTo(Player));
+
+ // Delete old player entity.
+ await Server.WaitPost(() =>
+ {
+ if (old == null)
+ return;
+
+ // Fuck you mind system I want an hour of my life back
+ if (SEntMan.TryGetComponent(old, out MindComponent? mind))
+ mind.GhostOnShutdown = false;
+
+ SEntMan.DeleteEntity(old.Value);
+ });
+
+ // Ensure that the player only has one hand, so that they do not accidentally pick up deconstruction protucts
+ await Server.WaitPost(() =>
+ {
+ var bodySystem = SEntMan.System<BodySystem>();
+ var hands = bodySystem.GetBodyChildrenOfType(Player, BodyPartType.Hand).ToArray();
+
+ for (var i = 1; i < hands.Length; i++)
+ {
+ bodySystem.DropPart(hands[i].Id);
+ SEntMan.DeleteEntity(hands[i].Id);
+ }
+ });
+
+ // Final player asserts/checks.
+ await PoolManager.ReallyBeIdle(PairTracker.Pair, 5);
+ Assert.That(cPlayerMan.LocalPlayer.ControlledEntity, Is.EqualTo(Player));
+ Assert.That(sPlayerMan.GetSessionByUserId(cSession.UserId).AttachedEntity, Is.EqualTo(Player));
+ }
+
+ [TearDown]
+ public async Task Cleanup()
+ {
+ await Server.WaitPost(() => MapMan.DeleteMap(MapId));
+ await PairTracker.CleanReturnAsync();
+ }
+}
+
--- /dev/null
+using System.Collections.Generic;
+using Content.Server.Construction;
+using Content.Shared.Construction;
+using Robust.Shared.GameObjects;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+/// <summary>
+/// System for listening to events that get raised when construction entities change.
+/// In particular, when construction ghosts become real entities, and when existing entities get replaced with
+/// new ones.
+/// </summary>
+public sealed class InteractionTestSystem : EntitySystem
+{
+ public Dictionary<int, EntityUid> Ghosts = new();
+ public Dictionary<EntityUid, EntityUid> EntChanges = new();
+
+ public override void Initialize()
+ {
+ SubscribeNetworkEvent<AckStructureConstructionMessage>(OnAck);
+ SubscribeLocalEvent<ConstructionChangeEntityEvent>(OnEntChange);
+ }
+
+ private void OnEntChange(ConstructionChangeEntityEvent ev)
+ {
+ EntChanges[ev.Old] = ev.New;
+ }
+
+ private void OnAck(AckStructureConstructionMessage ev)
+ {
+ if (ev.Uid != null)
+ Ghosts[ev.GhostId] = ev.Uid.Value;
+ }
+}
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Server.Explosion.Components;
+using NUnit.Framework;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+
+namespace Content.IntegrationTests.Tests.Payload;
+
+public sealed class ModularGrenadeTests : InteractionTest
+{
+ public const string Trigger = "TimerTrigger";
+ public const string Payload = "ExplosivePayload";
+
+ /// <summary>
+ /// Test that a modular grenade can be fully crafted and detonated.
+ /// </summary>
+ [Test]
+ public async Task AssembleAndDetonateGrenade()
+ {
+ await PlaceInHands(Steel, 5);
+ await CraftItem("ModularGrenadeRecipe");
+ Target = await FindEntity("ModularGrenade");
+
+ await Drop();
+ await Interact(Cable);
+
+ // Insert & remove trigger
+ AssertComp<OnUseTimerTriggerComponent>(false);
+ await Interact(Trigger);
+ AssertComp<OnUseTimerTriggerComponent>();
+ await FindEntity(Trigger, LookupFlags.Uncontained, shouldSucceed: false);
+ await Interact(Pry);
+ AssertComp<OnUseTimerTriggerComponent>(false);
+
+ // Trigger was dropped to floor, not deleted.
+ await FindEntity(Trigger, LookupFlags.Uncontained);
+
+ // Re-insert
+ await Interact(Trigger);
+ AssertComp<OnUseTimerTriggerComponent>();
+
+ // Insert & remove payload.
+ await Interact(Payload);
+ await FindEntity(Payload, LookupFlags.Uncontained, shouldSucceed: false);
+ await Interact(Pry);
+ var ent = await FindEntity(Payload, LookupFlags.Uncontained);
+ await Delete(ent);
+
+ // successfully insert a second time
+ await Interact(Payload);
+ ent = await FindEntity(Payload);
+ var sys = SEntMan.System<SharedContainerSystem>();
+ Assert.That(sys.IsEntityInContainer(ent));
+
+ // Activate trigger.
+ await Pickup();
+ AssertComp<ActiveTimerTriggerComponent>(false);
+ await UseInHand();
+
+ // So uhhh grenades in hands don't destroy themselves when exploding. Maybe that will be fixed eventually.
+ await Drop();
+
+ // Wait until grenade explodes
+ var timer = Comp<ActiveTimerTriggerComponent>();
+ while (timer.TimeRemaining >= 0)
+ {
+ await RunTicks(10);
+ }
+
+ // Grenade has exploded.
+ await RunTicks(5);
+ AssertDeleted();
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+
+namespace Content.IntegrationTests.Tests.Tiles;
+
+public sealed class TileConstructionTests : InteractionTest
+{
+ private void AssertGridCount(int value)
+ {
+ var count = 0;
+ var query = SEntMan.AllEntityQueryEnumerator<MapGridComponent, TransformComponent>();
+ while (query.MoveNext(out _, out var xform))
+ {
+ if (xform.MapUid == MapData.MapUid)
+ count++;
+ }
+
+ Assert.That(count, Is.EqualTo(value));
+ }
+
+ /// <summary>
+ /// Test placing and cutting a single lattice.
+ /// </summary>
+ [Test]
+ public async Task PlaceThenCutLattice()
+ {
+ await AssertTile(Plating);
+ await AssertTile(Plating, PlayerCoords);
+ AssertGridCount(1);
+ await SetTile(null);
+ await Interact(Rod);
+ await AssertTile(Lattice);
+ Assert.IsNull(Hands.ActiveHandEntity);
+ await Interact(Cut);
+ await AssertTile(null);
+ await AssertEntityLookup((Rod, 1));
+ AssertGridCount(1);
+ }
+
+ /// <summary>
+ /// Test placing and cutting a single lattice in space (not adjacent to any existing grid.
+ /// </summary>
+ [Test]
+ public async Task CutThenPlaceLatticeNewGrid()
+ {
+ await AssertTile(Plating);
+ await AssertTile(Plating, PlayerCoords);
+ AssertGridCount(1);
+
+ // Remove grid
+ await SetTile(null);
+ await SetTile(null, PlayerCoords);
+ Assert.That(MapData.MapGrid.Deleted);
+ AssertGridCount(0);
+
+ // Place Lattice
+ var oldPos = TargetCoords;
+ TargetCoords = new EntityCoordinates(MapData.MapUid, 1, 0);
+ await Interact(Rod);
+ TargetCoords = oldPos;
+ await AssertTile(Lattice);
+ AssertGridCount(1);
+
+ // Cut lattice
+ Assert.IsNull(Hands.ActiveHandEntity);
+ await Interact(Cut);
+ await AssertTile(null);
+ AssertGridCount(0);
+
+ await AssertEntityLookup((Rod, 1));
+ }
+
+ /// <summary>
+ /// Test space -> floor -> plating
+ /// </summary>
+ [Test]
+ public async Task FloorConstructDeconstruct()
+ {
+ await AssertTile(Plating);
+ await AssertTile(Plating, PlayerCoords);
+ AssertGridCount(1);
+
+ // Remove grid
+ await SetTile(null);
+ await SetTile(null, PlayerCoords);
+ Assert.That(MapData.MapGrid.Deleted);
+ AssertGridCount(0);
+
+ // Space -> Lattice
+ var oldPos = TargetCoords;
+ TargetCoords = new EntityCoordinates(MapData.MapUid, 1, 0);
+ await Interact(Rod);
+ TargetCoords = oldPos;
+ await AssertTile(Lattice);
+ AssertGridCount(1);
+
+ // Lattice -> Plating
+ await Interact(Steel);
+ Assert.IsNull(Hands.ActiveHandEntity);
+ await AssertTile(Plating);
+ AssertGridCount(1);
+
+ // Plating -> Tile
+ await Interact(FloorItem);
+ Assert.IsNull(Hands.ActiveHandEntity);
+ await AssertTile(Floor);
+ AssertGridCount(1);
+
+ // Tile -> Plating
+ await Interact(Pry);
+ await AssertTile(Plating);
+ AssertGridCount(1);
+
+ await AssertEntityLookup((FloorItem, 1));
+ }
+}
+
--- /dev/null
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Server.Tools.Components;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Weldable;
+
+/// <summary>
+/// Simple test to check that using a welder on a locker will weld it shut.
+/// </summary>
+public sealed class WeldableTests : InteractionTest
+{
+ public const string Locker = "LockerFreezer";
+
+ [Test]
+ public async Task WeldLocker()
+ {
+ await SpawnTarget(Locker);
+ var comp = Comp<WeldableComponent>();
+
+ Assert.That(comp.Weldable, Is.True);
+ Assert.That(comp.IsWelded, Is.False);
+
+ await Interact(Weld);
+ Assert.That(comp.IsWelded, Is.True);
+ AssertPrototype(Locker); // Prototype did not change.
+ }
+}
{
[DataField("container")] public string Container { get; private set; } = string.Empty;
+ // TODO use or generalize ConstructionSystem.ChangeEntity();
public void PerformAction(EntityUid uid, EntityUid? userUid, IEntityManager entityManager)
{
if (!entityManager.TryGetComponent(uid, out ContainerManagerComponent? containerManager))
// We only add this container. If some construction needs to take other containers into account, fix this.
entityManager.EntitySysManager.GetEntitySystem<ConstructionSystem>().AddContainer(computer, Container);
+ var entChangeEv = new ConstructionChangeEntityEvent(computer, uid);
+ entityManager.EventBus.RaiseLocalEvent(uid, entChangeEv);
+ entityManager.EventBus.RaiseLocalEvent(computer, entChangeEv, broadcast: true);
+
// Delete the original entity.
- entityManager.DeleteEntity(uid);
+ entityManager.QueueDeleteEntity(uid);
}
}
}
[DataDefinition]
public sealed class BuildMachine : IGraphAction
{
+ // TODO use or generalize ConstructionSystem.ChangeEntity();
public void PerformAction(EntityUid uid, EntityUid? userUid, IEntityManager entityManager)
{
if (!entityManager.TryGetComponent(uid, out ContainerManagerComponent? containerManager))
constructionSystem.RefreshParts(machineComp);
}
- entityManager.DeleteEntity(uid);
+ var entChangeEv = new ConstructionChangeEntityEvent(machine, uid);
+ entityManager.EventBus.RaiseLocalEvent(uid, entChangeEv);
+ entityManager.EventBus.RaiseLocalEvent(machine, entChangeEv, broadcast: true);
+ entityManager.QueueDeleteEntity(uid);
}
}
}
[DataField("container")]
public string Container = "battery-container";
+ // TODO use or generalize ConstructionSystem.ChangeEntity();
public void PerformAction(EntityUid uid, EntityUid? userUid, IEntityManager entityManager)
{
if (!entityManager.TryGetComponent(uid, out ContainerManagerComponent? containerManager))
mechComp.BatterySlot.Insert(cell);
}
- // Delete the original entity.
- entityManager.DeleteEntity(uid);
+ var entChangeEv = new ConstructionChangeEntityEvent(mech, uid);
+ entityManager.EventBus.RaiseLocalEvent(uid, entChangeEv);
+ entityManager.EventBus.RaiseLocalEvent(mech, entChangeEv, broadcast: true);
+ entityManager.QueueDeleteEntity(uid);
}
}
}
}
+ var entChangeEv = new ConstructionChangeEntityEvent(newUid, uid);
+ RaiseLocalEvent(uid, entChangeEv);
+ RaiseLocalEvent(newUid, entChangeEv, broadcast: true);
+
QueueDel(uid);
return newUid;
return ChangeNode(uid, userUid, nodeId, performActions, construction);
}
}
+
+ /// <summary>
+ /// This event gets raised when an entity changes prototype / uid during construction. The event is raised
+ /// directed both at the old and new entity.
+ /// </summary>
+ public sealed class ConstructionChangeEntityEvent : EntityEventArgs
+ {
+ public readonly EntityUid New;
+ public readonly EntityUid Old;
+
+ public ConstructionChangeEntityEvent(EntityUid newUid, EntityUid oldUid)
+ {
+ New = newUid;
+ Old = oldUid;
+ }
+ }
}
if (!materialStep.EntityValid(entity, out var stack))
continue;
+ // TODO allow taking from several stacks.
+ // Also update crafting steps to check if it works.
var splitStack = _stackSystem.Split(entity, materialStep.Amount, user.ToCoordinates(0, 0), stack);
if (splitStack == null)
return newEntity;
}
- // LEGACY CODE. See warning at the top of the file!
private async void HandleStartItemConstruction(TryStartItemConstructionMessage ev, EntitySessionEventArgs args)
{
- if (!_prototypeManager.TryIndex(ev.PrototypeName, out ConstructionPrototype? constructionPrototype))
+ if (args.SenderSession.AttachedEntity is {Valid: true} user)
+ await TryStartItemConstruction(ev.PrototypeName, user);
+ }
+
+ // LEGACY CODE. See warning at the top of the file!
+ public async Task<bool> TryStartItemConstruction(string prototype, EntityUid user)
+ {
+ if (!_prototypeManager.TryIndex(prototype, out ConstructionPrototype? constructionPrototype))
{
- _sawmill.Error($"Tried to start construction of invalid recipe '{ev.PrototypeName}'!");
- return;
+ _sawmill.Error($"Tried to start construction of invalid recipe '{prototype}'!");
+ return false;
}
if (!_prototypeManager.TryIndex(constructionPrototype.Graph,
out ConstructionGraphPrototype? constructionGraph))
{
_sawmill.Error(
- $"Invalid construction graph '{constructionPrototype.Graph}' in recipe '{ev.PrototypeName}'!");
- return;
+ $"Invalid construction graph '{constructionPrototype.Graph}' in recipe '{prototype}'!");
+ return false;
}
var startNode = constructionGraph.Nodes[constructionPrototype.StartNode];
var targetNode = constructionGraph.Nodes[constructionPrototype.TargetNode];
var pathFind = constructionGraph.Path(startNode.Name, targetNode.Name);
- if (args.SenderSession.AttachedEntity is not {Valid: true} user || !_actionBlocker.CanInteract(user, null))
- return;
+ if (!_actionBlocker.CanInteract(user, null))
+ return false;
if (!HasComp<HandsComponent>(user))
- return;
+ return false;
foreach (var condition in constructionPrototype.Conditions)
{
if (!condition.Condition(user, user.ToCoordinates(0, 0), Direction.South))
- return;
+ return false;
}
if (pathFind == null)
{
throw new InvalidDataException(
- $"Can't find path from starting node to target node in construction! Recipe: {ev.PrototypeName}");
+ $"Can't find path from starting node to target node in construction! Recipe: {prototype}");
}
var edge = startNode.GetEdge(pathFind[0].Name);
if (edge == null)
{
throw new InvalidDataException(
- $"Can't find edge from starting node to the next node in pathfinding! Recipe: {ev.PrototypeName}");
+ $"Can't find edge from starting node to the next node in pathfinding! Recipe: {prototype}");
}
// No support for conditions here!
}
if (await Construct(user, "item_construction", constructionGraph, edge, targetNode) is not { Valid: true } item)
- return;
+ return false;
// Just in case this is a stack, attempt to merge it. If it isn't a stack, this will just normally pick up
// or drop the item as normal.
_stackSystem.TryMergeToHands(item, user);
+ return true;
}
// LEGACY CODE. See warning at the top of the file!
xform.LocalRotation = constructionPrototype.CanRotate ? ev.Angle : Angle.Zero;
xform.Anchored = wasAnchored;
- RaiseNetworkEvent(new AckStructureConstructionMessage(ev.Ack));
+ RaiseNetworkEvent(new AckStructureConstructionMessage(ev.Ack, structure));
_adminLogger.Add(LogType.Construction, LogImpact.Low, $"{ToPrettyString(user):player} has turned a {ev.PrototypeName} construction ghost into {ToPrettyString(structure)} at {Transform(structure).Coordinates}");
Cleanup();
}
args.Verbs.Add(verb);
}
+ public List<MachinePartComponent> GetAllParts(EntityUid uid, MachineComponent? component = null)
+ {
+ if (!Resolve(uid, ref component))
+ return new List<MachinePartComponent>();
+
+ return GetAllParts(component);
+ }
+
public List<MachinePartComponent> GetAllParts(MachineComponent component)
{
var parts = new List<MachinePartComponent>();
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("ghostOnShutdown")]
+ [Access(typeof(MindSystem), Other = AccessPermissions.ReadWriteExecute)] // FIXME Friends
public bool GhostOnShutdown { get; set; } = true;
}
{
public readonly int GhostId;
- public AckStructureConstructionMessage(int ghostId)
+ /// <summary>
+ /// The entity that is now being constructed, if any.
+ /// </summary>
+ public readonly EntityUid? Uid;
+
+ public AckStructureConstructionMessage(int ghostId, EntityUid? uid = null)
{
GhostId = ghostId;
+ Uid = uid;
}
}
public DoAfterComponentState(DoAfterComponent component)
{
NextId = component.NextId;
+
+ // Cursed test bugs - See CraftingTests.CancelCraft
+ // The following is wrapped in an if DEBUG. This is tests don't (de)serialize net messages and just copy objects
+ // by reference. This means that the server will directly modify cached server states on the client's end.
+ // Crude fix at the moment is to used modified state handling while in debug mode Otherwise, this test cannot work.
+#if !DEBUG
DoAfters = component.DoAfters;
+#else
+ DoAfters = new();
+ foreach (var (id, doafter) in component.DoAfters)
+ {
+ DoAfters.Add(id, new DoAfter(doafter));
+ }
+#endif
}
}
EnsureComp<ActiveDoAfterComponent>(uid);
}
-
#region Creation
/// <summary>
/// Tasks that are delayed until the specified time has passed
// TODO add predicted pop-up overrides.
if (_net.IsServer)
_popup.PopupEntity(Loc.GetString("encryption-keys-all-extracted"), uid, args.User);
+
_audio.PlayPredicted(component.KeyExtractionSound, uid, args.User);
}
{
[ViewVariables(VVAccess.ReadWrite)]
[DataField("stackType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<StackPrototype>))]
- public string? StackTypeId { get; private set; }
+ public string StackTypeId { get; private set; } = default!;
/// <summary>
/// Current stack count.
projects / space-station-14.git / commitdiff