#nullable enable
using System.Linq;
+using Content.IntegrationTests.Pair;
using Content.Server.Ghost.Roles;
using Content.Server.Ghost.Roles.Components;
using Content.Server.Players;
";
/// <summary>
- /// This is a simple test that just checks if a player can take a ghost roll and then regain control of their
+ /// This is a simple test that just checks if a player can take a ghost role and then regain control of their
/// original entity without encountering errors.
/// </summary>
[Test]
{
await using var pair = await PoolManager.GetServerClient(new PoolSettings
{
+ Dirty = true,
DummyTicker = false,
Connected = true
});
var server = pair.Server;
var client = pair.Client;
+ var mapData = await pair.CreateTestMap();
+
var entMan = server.ResolveDependency<IEntityManager>();
var sPlayerMan = server.ResolveDependency<Robust.Server.Player.IPlayerManager>();
var conHost = client.ResolveDependency<IConsoleHost>();
EntityUid originalMob = default;
await server.WaitPost(() =>
{
- originalMob = entMan.SpawnEntity(null, MapCoordinates.Nullspace);
+ originalMob = entMan.SpawnEntity(null, mapData.GridCoords);
mindSystem.TransferTo(originalMindId, originalMob, true);
});
Assert.That(entMan.HasComponent<GhostComponent>(ghost));
Assert.That(ghost, Is.Not.EqualTo(originalMob));
Assert.That(session.ContentData()?.Mind, Is.EqualTo(originalMindId));
- Assert.That(originalMind.OwnedEntity, Is.EqualTo(originalMob));
+ Assert.That(originalMind.OwnedEntity, Is.EqualTo(originalMob), $"Original mob: {originalMob}, Ghost: {ghost}");
Assert.That(originalMind.VisitingEntity, Is.EqualTo(ghost));
// Spawn ghost takeover entity.
EntityUid ghostRole = default;
- await server.WaitPost(() => ghostRole = entMan.SpawnEntity("GhostRoleTestEntity", MapCoordinates.Nullspace));
+ await server.WaitPost(() => ghostRole = entMan.SpawnEntity("GhostRoleTestEntity", mapData.GridCoords));
// Take the ghost role
await server.WaitPost(() =>
--- /dev/null
+using System.Numerics;
+using Content.IntegrationTests.Pair;
+using Content.Shared.Ghost;
+using Content.Shared.Mind;
+using Content.Shared.Players;
+using Robust.Server.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Player;
+using Robust.UnitTesting;
+
+namespace Content.IntegrationTests.Tests.Minds;
+
+[TestFixture]
+public sealed class GhostTests
+{
+ struct GhostTestData
+ {
+ public IEntityManager SEntMan;
+ public Robust.Server.Player.IPlayerManager SPlayerMan;
+ public Server.Mind.MindSystem SMindSys;
+ public SharedTransformSystem STransformSys = default!;
+
+ public TestPair Pair = default!;
+
+ public TestMapData MapData => Pair.TestMap!;
+
+ public RobustIntegrationTest.ServerIntegrationInstance Server => Pair.Server;
+ public RobustIntegrationTest.ClientIntegrationInstance Client => Pair.Client;
+
+ /// <summary>
+ /// Initial player coordinates. Note that this does not necessarily correspond to the position of the
+ /// <see cref="Player"/> entity.
+ /// </summary>
+ public NetCoordinates PlayerCoords = default!;
+
+ public NetEntity Player = default!;
+ public EntityUid SPlayerEnt = default!;
+
+ public ICommonSession ClientSession = default!;
+ public ICommonSession ServerSession = default!;
+
+ public GhostTestData()
+ {
+ }
+ }
+
+ 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
+ {
+ DummyTicker = false,
+ Connected = true,
+ Dirty = true
+ });
+
+ data.SEntMan = data.Pair.Server.ResolveDependency<IServerEntityManager>();
+ data.SPlayerMan = data.Pair.Server.ResolveDependency<Robust.Server.Player.IPlayerManager>();
+ data.SMindSys = data.SEntMan.System<Server.Mind.MindSystem>();
+ data.STransformSys = data.SEntMan.System<SharedTransformSystem>();
+
+ // 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));
+
+ if (data.Client.Session == null)
+ Assert.Fail("No player");
+ data.ClientSession = data.Client.Session!;
+ data.ServerSession = data.SPlayerMan.GetSessionById(data.ClientSession.UserId);
+
+ Entity<MindComponent> mind = default!;
+ await data.Pair.Server.WaitPost(() =>
+ {
+ data.Player = data.SEntMan.GetNetEntity(data.SEntMan.SpawnEntity(null, data.SEntMan.GetCoordinates(data.PlayerCoords)));
+ mind = data.SMindSys.CreateMind(data.ServerSession.UserId, "DummyPlayerEntity");
+ data.SPlayerEnt = data.SEntMan.GetEntity(data.Player);
+ data.SMindSys.TransferTo(mind, data.SPlayerEnt, mind: mind.Comp);
+ data.Server.PlayerMan.SetAttachedEntity(data.ServerSession, data.SPlayerEnt);
+ });
+
+ await data.Pair.RunTicksSync(5);
+
+ Assert.Multiple(() =>
+ {
+ Assert.That(data.ServerSession.ContentData()?.Mind, Is.EqualTo(mind.Owner));
+ Assert.That(data.ServerSession.AttachedEntity, Is.EqualTo(data.SPlayerEnt));
+ Assert.That(data.ServerSession.AttachedEntity, Is.EqualTo(mind.Comp.CurrentEntity),
+ "Player is not attached to the mind's current entity.");
+ Assert.That(data.SEntMan.EntityExists(mind.Comp.OwnedEntity),
+ "The mind's current entity does not exist");
+ Assert.That(mind.Comp.VisitingEntity == null || data.SEntMan.EntityExists(mind.Comp.VisitingEntity),
+ "The minds visited entity does not exist.");
+ });
+
+ Assert.That(data.SPlayerEnt, Is.Not.EqualTo(null));
+
+ return data;
+ }
+
+ /// <summary>
+ /// Test that a ghost gets created when the player entity is deleted.
+ /// 1. Delete mob
+ /// 2. Assert is ghost
+ /// </summary>
+ [Test]
+ public async Task TestGridGhostOnDelete()
+ {
+ var data = await SetupData();
+
+ var oldPosition = data.SEntMan.GetComponent<TransformComponent>(data.SPlayerEnt).Coordinates;
+
+ Assert.That(!data.SEntMan.HasComponent<GhostComponent>(data.SPlayerEnt), "Player was initially a ghost?");
+
+ // Delete entity
+ await data.Server.WaitPost(() => data.SEntMan.DeleteEntity(data.SPlayerEnt));
+ await data.Pair.RunTicksSync(5);
+
+ var ghost = data.ServerSession.AttachedEntity!.Value;
+ Assert.That(data.SEntMan.HasComponent<GhostComponent>(ghost), "Player did not become a ghost");
+
+ // Ensure the position is the same
+ var ghostPosition = data.SEntMan.GetComponent<TransformComponent>(ghost).Coordinates;
+ Assert.That(ghostPosition, Is.EqualTo(oldPosition));
+
+ await data.Pair.CleanReturnAsync();
+ }
+
+ /// <summary>
+ /// Test that a ghost gets created when the player entity is queue deleted.
+ /// 1. Delete mob
+ /// 2. Assert is ghost
+ /// </summary>
+ [Test]
+ public async Task TestGridGhostOnQueueDelete()
+ {
+ var data = await SetupData();
+
+ var oldPosition = data.SEntMan.GetComponent<TransformComponent>(data.SPlayerEnt).Coordinates;
+
+ Assert.That(!data.SEntMan.HasComponent<GhostComponent>(data.SPlayerEnt), "Player was initially a ghost?");
+
+ // Delete entity
+ await data.Server.WaitPost(() => data.SEntMan.QueueDeleteEntity(data.SPlayerEnt));
+ await data.Pair.RunTicksSync(5);
+
+ var ghost = data.ServerSession.AttachedEntity!.Value;
+ Assert.That(data.SEntMan.HasComponent<GhostComponent>(ghost), "Player did not become a ghost");
+
+ // Ensure the position is the same
+ var ghostPosition = data.SEntMan.GetComponent<TransformComponent>(ghost).Coordinates;
+ Assert.That(ghostPosition, Is.EqualTo(oldPosition));
+
+ await data.Pair.CleanReturnAsync();
+ }
+
+}
+#nullable enable
using System.Linq;
using Content.Server.GameTicking;
using Content.Shared.Ghost;
await using var pair = await SetupPair(dirty: true);
var server = pair.Server;
var testMap = await pair.CreateTestMap();
- var coordinates = testMap.GridCoords;
+ var testMap2 = await pair.CreateTestMap();
var entMan = server.ResolveDependency<IServerEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>();
MindComponent mind = default!;
await server.WaitAssertion(() =>
{
- playerEnt = entMan.SpawnEntity(null, coordinates);
+ playerEnt = entMan.SpawnEntity(null, testMap.GridCoords);
mindId = player.ContentData()!.Mind!.Value;
mind = entMan.GetComponent<MindComponent>(mindId);
mindSystem.TransferTo(mindId, playerEnt);
});
await pair.RunTicksSync(5);
- await server.WaitPost(() => mapManager.DeleteMap(testMap.MapId));
+ await server.WaitAssertion(() => mapManager.DeleteMap(testMap.MapId));
await pair.RunTicksSync(5);
await server.WaitAssertion(() =>
{
#pragma warning disable NUnit2045 // Interdependent assertions.
- Assert.That(entMan.EntityExists(mind.CurrentEntity), Is.True);
- Assert.That(mind.CurrentEntity, Is.Not.EqualTo(playerEnt));
+ // Spawn ghost on the second map
+ var attachedEntity = player.AttachedEntity;
+ Assert.That(entMan.EntityExists(attachedEntity), Is.True);
+ Assert.That(attachedEntity, Is.Not.EqualTo(playerEnt));
+ Assert.That(entMan.HasComponent<GhostComponent>(attachedEntity));
+ var transform = entMan.GetComponent<TransformComponent>(attachedEntity.Value);
+ Assert.That(transform.MapID, Is.Not.EqualTo(MapId.Nullspace));
+ Assert.That(transform.MapID, Is.Not.EqualTo(testMap.MapId));
#pragma warning restore NUnit2045
});
}
}
- var xformQuery = GetEntityQuery<TransformComponent>();
- var coords = _transform.GetMoverCoordinates(position, xformQuery);
-
- var ghost = Spawn(ObserverPrototypeName, coords);
-
- // Try setting the ghost entity name to either the character name or the player name.
- // If all else fails, it'll default to the default entity prototype name, "observer".
- // However, that should rarely happen.
- if (!string.IsNullOrWhiteSpace(mind.CharacterName))
- _metaData.SetEntityName(ghost, mind.CharacterName);
- else if (!string.IsNullOrWhiteSpace(mind.Session?.Name))
- _metaData.SetEntityName(ghost, mind.Session.Name);
-
- var ghostComponent = Comp<GhostComponent>(ghost);
-
- if (mind.TimeOfDeath.HasValue)
- {
- _ghost.SetTimeOfDeath(ghost, mind.TimeOfDeath!.Value, ghostComponent);
- }
+ var ghost = _ghost.SpawnGhost((mindId, mind), position, canReturn);
+ if (ghost == null)
+ return false;
if (playerEntity != null)
_adminLogger.Add(LogType.Mind, $"{EntityManager.ToPrettyString(playerEntity.Value):player} ghosted{(!canReturn ? " (non-returnable)" : "")}");
- _ghost.SetCanReturnToBody(ghostComponent, canReturn);
-
- if (canReturn)
- _mind.Visit(mindId, ghost, mind);
- else
- _mind.TransferTo(mindId, ghost, mind: mind);
return true;
}
using Content.Server.Station.Components;
using Content.Shared.CCVar;
using Content.Shared.Database;
+using Content.Shared.Mind;
using Content.Shared.Players;
using Content.Shared.Preferences;
using Content.Shared.Roles;
if (job == null)
{
var playerSession = _playerManager.GetSessionById(netUser);
- _chatManager.DispatchServerMessage(playerSession,
- Loc.GetString("job-not-available-wait-in-lobby"));
+ _chatManager.DispatchServerMessage(playerSession, Loc.GetString("job-not-available-wait-in-lobby"));
}
else
{
/// <param name="station">The station they're spawning on</param>
/// <param name="jobId">An optional job for them to spawn as</param>
/// <param name="silent">Whether or not the player should be greeted upon joining</param>
- public void MakeJoinGame(ICommonSession player,
- EntityUid station,
- string? jobId = null,
- bool silent = false)
+ public void MakeJoinGame(ICommonSession player, EntityUid station, string? jobId = null, bool silent = false)
{
if (!_playerGameStatuses.ContainsKey(player.UserId))
return;
if (DummyTicker)
return;
- var mind = player.GetMind();
+ Entity<MindComponent?>? mind = player.GetMind();
if (mind == null)
{
- mind = _mind.CreateMind(player.UserId);
+ var name = GetPlayerProfile(player).Name;
+ var (mindId, mindComp) = _mind.CreateMind(player.UserId, name);
+ mind = (mindId, mindComp);
_mind.SetUserId(mind.Value, player.UserId);
_roles.MindAddRole(mind.Value, new ObserverRoleComponent());
}
- var name = GetPlayerProfile(player).Name;
- var ghost = SpawnObserverMob();
- _metaData.SetEntityName(ghost, name);
- _ghost.SetCanReturnToBody(ghost, false);
- _mind.TransferTo(mind.Value, ghost);
+ var ghost = _ghost.SpawnGhost(mind.Value);
_adminLogger.Add(LogType.LateJoin,
LogImpact.Low,
$"{player.Name} late joined the round as an Observer with {ToPrettyString(ghost):entity}.");
}
- #region Mob Spawning Helpers
-
- private EntityUid SpawnObserverMob()
- {
- var coordinates = GetObserverSpawnPoint();
- return EntityManager.SpawnEntity(ObserverPrototypeName, coordinates);
- }
-
- #endregion
-
#region Spawn Points
public EntityCoordinates GetObserverSpawnPoint()
{
_possiblePositions.Clear();
- foreach (var (point, transform) in EntityManager
- .EntityQuery<SpawnPointComponent, TransformComponent>(true))
+ foreach (var (point, transform) in EntityManager.EntityQuery<SpawnPointComponent, TransformComponent>(true))
{
if (point.SpawnType != SpawnPointType.Observer)
continue;
var query = AllEntityQuery<MapGridComponent>();
while (query.MoveNext(out var uid, out var grid))
{
- if (!metaQuery.TryGetComponent(uid, out var meta) || meta.EntityPaused)
+ if (!metaQuery.TryGetComponent(uid, out var meta) || meta.EntityPaused || TerminatingOrDeleted(uid))
{
continue;
}
{
var mapUid = _mapManager.GetMapEntityId(map);
- if (!metaQuery.TryGetComponent(mapUid, out var meta) || meta.EntityPaused)
+ if (!metaQuery.TryGetComponent(mapUid, out var meta)
+ || meta.EntityPaused
+ || TerminatingOrDeleted(mapUid))
{
continue;
}
using Content.Shared.Storage.Components;
using Robust.Server.GameObjects;
using Robust.Server.Player;
+using Robust.Shared.Map;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Player;
[Dependency] private readonly GameTicker _ticker = default!;
[Dependency] private readonly TransformSystem _transformSystem = default!;
[Dependency] private readonly VisibilitySystem _visibilitySystem = default!;
+ [Dependency] private readonly MetaDataSystem _metaData = default!;
+ [Dependency] private readonly IMapManager _mapManager = default!;
private EntityQuery<GhostComponent> _ghostQuery;
private EntityQuery<PhysicsComponent> _physicsQuery;
return ghostBoo.Handled;
}
+
+ public EntityUid? SpawnGhost(Entity<MindComponent?> mind, EntityUid targetEntity,
+ bool canReturn = false)
+ {
+ _transformSystem.TryGetMapOrGridCoordinates(targetEntity, out var spawnPosition);
+ return SpawnGhost(mind, spawnPosition, canReturn);
+ }
+
+ public EntityUid? SpawnGhost(Entity<MindComponent?> mind, EntityCoordinates? spawnPosition = null,
+ bool canReturn = false)
+ {
+ if (!Resolve(mind, ref mind.Comp))
+ return null;
+
+ // Test if the map is being deleted
+ var mapUid = spawnPosition?.GetMapUid(EntityManager);
+ if (mapUid == null || TerminatingOrDeleted(mapUid.Value))
+ spawnPosition = null;
+
+ spawnPosition ??= _ticker.GetObserverSpawnPoint();
+
+ if (!spawnPosition.Value.IsValid(EntityManager))
+ {
+ Log.Warning($"No spawn valid ghost spawn position found for {mind.Comp.CharacterName}"
+ + " \"{ToPrettyString(mind)}\"");
+ _minds.TransferTo(mind.Owner, null, createGhost: false, mind: mind.Comp);
+ return null;
+ }
+
+ var ghost = SpawnAtPosition(GameTicker.ObserverPrototypeName, spawnPosition.Value);
+ var ghostComponent = Comp<GhostComponent>(ghost);
+
+ // Try setting the ghost entity name to either the character name or the player name.
+ // If all else fails, it'll default to the default entity prototype name, "observer".
+ // However, that should rarely happen.
+ if (!string.IsNullOrWhiteSpace(mind.Comp.CharacterName))
+ _metaData.SetEntityName(ghost, mind.Comp.CharacterName);
+ else if (!string.IsNullOrWhiteSpace(mind.Comp.Session?.Name))
+ _metaData.SetEntityName(ghost, mind.Comp.Session.Name);
+
+ if (mind.Comp.TimeOfDeath.HasValue)
+ {
+ SetTimeOfDeath(ghost, mind.Comp.TimeOfDeath!.Value, ghostComponent);
+ }
+
+ SetCanReturnToBody(ghostComponent, canReturn);
+
+ if (canReturn)
+ _minds.Visit(mind.Owner, ghost, mind.Comp);
+ else
+ _minds.TransferTo(mind.Owner, ghost, mind: mind.Comp);
+ Log.Debug($"Spawned ghost \"{ToPrettyString(ghost)}\" for {mind.Comp.CharacterName}.");
+ return ghost;
+ }
}
}
using System.Diagnostics.CodeAnalysis;
using Content.Server.Administration.Logs;
using Content.Server.GameTicking;
+using Content.Server.Ghost;
using Content.Server.Mind.Commands;
using Content.Shared.Database;
using Content.Shared.Ghost;
using Content.Shared.Players;
using Robust.Server.GameStates;
using Robust.Server.Player;
-using Robust.Shared.Map.Components;
using Robust.Shared.Network;
using Robust.Shared.Player;
-using Robust.Shared.Timing;
using Robust.Shared.Utility;
namespace Content.Server.Mind;
[Dependency] private readonly GameTicker _gameTicker = default!;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
[Dependency] private readonly IPlayerManager _players = default!;
- [Dependency] private readonly MetaDataSystem _metaData = default!;
- [Dependency] private readonly SharedGhostSystem _ghosts = default!;
+ [Dependency] private readonly GhostSystem _ghosts = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly PvsOverrideSystem _pvsOverride = default!;
&& !Terminating(visiting))
{
TransferTo(mindId, visiting, mind: mind);
- if (TryComp(visiting, out GhostComponent? ghost))
- _ghosts.SetCanReturnToBody(ghost, false);
+ if (TryComp(visiting, out GhostComponent? ghostComp))
+ _ghosts.SetCanReturnToBody(ghostComp, false);
return;
}
if (!component.GhostOnShutdown || mind.Session == null || _gameTicker.RunLevel == GameRunLevel.PreRoundLobby)
return;
- var xform = Transform(uid);
- var gridId = xform.GridUid;
- var spawnPosition = Transform(uid).Coordinates;
-
- // Use a regular timer here because the entity has probably been deleted.
- Timer.Spawn(0, () =>
- {
- // Make extra sure the round didn't end between spawning the timer and it being executed.
- if (_gameTicker.RunLevel == GameRunLevel.PreRoundLobby)
- return;
-
- // Async this so that we don't throw if the grid we're on is being deleted.
- if (!HasComp<MapGridComponent>(gridId))
- spawnPosition = _gameTicker.GetObserverSpawnPoint();
-
- // TODO refactor observer spawning.
- // please.
- if (!spawnPosition.IsValid(EntityManager))
- {
- // This should be an error, if it didn't cause tests to start erroring when they delete a player.
- Log.Warning($"Entity \"{ToPrettyString(uid)}\" for {mind.CharacterName} was deleted, and no applicable spawn location is available.");
- TransferTo(mindId, null, createGhost: false, mind: mind);
- return;
- }
-
- var ghost = Spawn(GameTicker.ObserverPrototypeName, spawnPosition);
- var ghostComponent = Comp<GhostComponent>(ghost);
- _ghosts.SetCanReturnToBody(ghostComponent, false);
-
+ var ghost = _ghosts.SpawnGhost((mindId, mind), uid);
+ if (ghost != null)
// Log these to make sure they're not causing the GameTicker round restart bugs...
Log.Debug($"Entity \"{ToPrettyString(uid)}\" for {mind.CharacterName} was deleted, spawned \"{ToPrettyString(ghost)}\".");
- _metaData.SetEntityName(ghost, mind.CharacterName ?? string.Empty);
- TransferTo(mindId, ghost, mind: mind);
- });
+ else
+ // This should be an error, if it didn't cause tests to start erroring when they delete a player.
+ Log.Warning($"Entity \"{ToPrettyString(uid)}\" for {mind.CharacterName} was deleted, and no applicable spawn location is available.");
}
public override bool TryGetMind(NetUserId user, [NotNullWhen(true)] out EntityUid? mindId, [NotNullWhen(true)] out MindComponent? mind)
projects / space-station-14.git / commitdiff