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

Mind ECS (#16826)

Browse Source
This commit is contained in:
ShadowCommander
2023-06-18 11:33:19 -07:00
committed by GitHub
parent 8a943fb374
commit dd7032a860
85 changed files with 1432 additions and 711 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Content.Server/Mind/Commands/MakeSentientCommand.cs
View File

@@ -44,7 +44,7 @@ namespace Content.Server.Mind.Commands
public static void MakeSentient(EntityUid uid, IEntityManager entityManager, bool allowMovement = true, bool allowSpeech = true)
{
entityManager.EnsureComponent<MindComponent>(uid);
entityManager.EnsureComponent<MindContainerComponent>(uid);
if (allowMovement)
{
entityManager.EnsureComponent<InputMoverComponent>(uid);

2
Content.Server/Mind/Commands/MindInfoCommand.cs
View File

@@ -40,7 +40,7 @@ namespace Content.Server.Mind.Commands
}
var builder = new StringBuilder();
builder.AppendFormat("player: {0}, mob: {1}\nroles: ", mind.UserId, mind.OwnedComponent?.Owner);
builder.AppendFormat("player: {0}, mob: {1}\nroles: ", mind.UserId, mind.OwnedEntity);
foreach (var role in mind.AllRoles)
{
builder.AppendFormat("{0} ", role.Name);

2
Content.Server/Mind/Commands/RenameCommand.cs
View File

@@ -48,7 +48,7 @@ public sealed class RenameCommand : IConsoleCommand
var entSysMan = IoCManager.Resolve<IEntitySystemManager>();
if (entMan.TryGetComponent(entityUid, out MindComponent? mind) && mind.Mind != null)
if (entMan.TryGetComponent(entityUid, out MindContainerComponent? mind) && mind.Mind != null)
{
// Mind
mind.Mind.CharacterName = name;

6
Content.Server/Mind/Components/MindComponent.cs → Content.Server/Mind/Components/MindContainerComponent.cs
View File

@@ -1,10 +1,13 @@
using System.Diagnostics.CodeAnalysis;
using YamlDotNet.Core.Tokens;
namespace Content.Server.Mind.Components
{
/// <summary>
/// Stores a <see cref="Server.Mind.Mind"/> on a mob.
/// </summary>
[RegisterComponent, Access(typeof(MindSystem))]
public sealed class MindComponent : Component
public sealed class MindContainerComponent : Component
{
/// <summary>
/// The mind controlling this mob. Can be null.
@@ -17,6 +20,7 @@ namespace Content.Server.Mind.Components
/// True if we have a mind, false otherwise.
/// </summary>
[ViewVariables]
[MemberNotNullWhen(true, nameof(Mind))]
public bool HasMind => Mind != null;
/// <summary>

10
Content.Server/Mind/Components/VisitingMindComponent.cs
View File

@@ -3,14 +3,8 @@ namespace Content.Server.Mind.Components
[RegisterComponent]
public sealed class VisitingMindComponent : Component
{
[ViewVariables] public Mind Mind { get; set; } = default!;
protected override void OnRemove()
{
base.OnRemove();
Mind?.UnVisit();
}
[ViewVariables]
public Mind? Mind;
}
public sealed class MindUnvisitedMessage : EntityEventArgs

381
Content.Server/Mind/Mind.cs
View File

@@ -1,19 +1,9 @@
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Content.Server.Administration.Logs;
using Content.Server.GameTicking;
using Content.Server.Ghost.Components;
using Content.Server.Mind.Components;
using Content.Server.Objectives;
using Content.Server.Players;
using Content.Server.Roles;
using Content.Shared.Database;
using Content.Shared.Mobs.Components;
using Content.Shared.Mobs.Systems;
using Robust.Server.GameObjects;
using Robust.Server.Player;
using Robust.Shared.Network;
using Robust.Shared.Utility;
namespace Content.Server.Mind
{
@@ -29,16 +19,9 @@ namespace Content.Server.Mind
/// </remarks>
public sealed class Mind
{
private readonly MobStateSystem _mobStateSystem = default!;
private readonly GameTicker _gameTickerSystem = default!;
private readonly MindSystem _mindSystem = default!;
[Dependency] private readonly IPlayerManager _playerManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
internal readonly ISet<Role> Roles = new HashSet<Role>();
private readonly ISet<Role> _roles = new HashSet<Role>();
private readonly List<Objective> _objectives = new();
internal readonly List<Objective> Objectives = new();
public string Briefing = String.Empty;
@@ -48,36 +31,32 @@ namespace Content.Server.Mind
/// The provided UserId is solely for tracking of intended owner.
/// </summary>
/// <param name="userId">The session ID of the original owner (may get credited).</param>
public Mind(NetUserId userId)
public Mind(NetUserId? userId)
{
OriginalOwnerUserId = userId;
IoCManager.InjectDependencies(this);
_entityManager.EntitySysManager.Resolve(ref _mobStateSystem);
_entityManager.EntitySysManager.Resolve(ref _gameTickerSystem);
_entityManager.EntitySysManager.Resolve(ref _mindSystem);
}
// TODO: This session should be able to be changed, probably.
/// <summary>
/// The session ID of the player owning this mind.
/// </summary>
[ViewVariables]
public NetUserId? UserId { get; private set; }
public NetUserId? UserId { get; internal set; }
/// <summary>
/// The session ID of the original owner, if any.
/// May end up used for round-end information (as the owner may have abandoned Mind since)
/// </summary>
[ViewVariables]
public NetUserId OriginalOwnerUserId { get; }
public NetUserId? OriginalOwnerUserId { get; }
[ViewVariables]
public bool IsVisitingEntity => VisitingEntity != null;
[ViewVariables]
public EntityUid? VisitingEntity { get; private set; }
public EntityUid? VisitingEntity { get; set; }
[ViewVariables] public EntityUid? CurrentEntity => VisitingEntity ?? OwnedEntity;
[ViewVariables]
public EntityUid? CurrentEntity => VisitingEntity ?? OwnedEntity;
[ViewVariables(VVAccess.ReadWrite)]
public string? CharacterName { get; set; }
@@ -87,33 +66,33 @@ namespace Content.Server.Mind
/// Can be null - will be null if the Mind is not considered "dead".
/// </summary>
[ViewVariables]
public TimeSpan? TimeOfDeath { get; set; } = null;
public TimeSpan? TimeOfDeath { get; set; }
/// <summary>
/// The component currently owned by this mind.
/// Can be null.
/// </summary>
[ViewVariables]
public MindComponent? OwnedComponent { get; private set; }
public MindContainerComponent? OwnedComponent { get; internal set; }
/// <summary>
/// The entity currently owned by this mind.
/// Can be null.
/// </summary>
[ViewVariables]
public EntityUid? OwnedEntity => OwnedComponent?.Owner;
public EntityUid? OwnedEntity { get; internal set; }
/// <summary>
/// An enumerable over all the roles this mind has.
/// </summary>
[ViewVariables]
public IEnumerable<Role> AllRoles => _roles;
public IEnumerable<Role> AllRoles => Roles;
/// <summary>
/// An enumerable over all the objectives this mind has.
/// </summary>
[ViewVariables]
public IEnumerable<Objective> AllObjectives => _objectives;
public IEnumerable<Objective> AllObjectives => Objectives;
/// <summary>
/// Prevents user from ghosting out
@@ -134,341 +113,11 @@ namespace Content.Server.Mind
/// Can be null, in which case the player is currently not logged in.
/// </summary>
[ViewVariables]
public IPlayerSession? Session
{
get
{
if (!UserId.HasValue)
{
return null;
}
_playerManager.TryGetSessionById(UserId.Value, out var ret);
return ret;
}
}
/// <summary>
/// True if this Mind is 'sufficiently dead' IC (objectives, endtext).
/// Note that this is *IC logic*, it's not necessarily tied to any specific truth.
/// "If administrators decide that zombies are dead, this returns true for zombies."
/// (Maybe you were looking for the action blocker system?)
/// </summary>
[ViewVariables]
public bool CharacterDeadIC => CharacterDeadPhysically;
/// <summary>
/// True if the OwnedEntity of this mind is physically dead.
/// This specific definition, as opposed to CharacterDeadIC, is used to determine if ghosting should allow return.
/// </summary>
[ViewVariables]
public bool CharacterDeadPhysically
{
get
{
// This is written explicitly so that the logic can be understood.
// But it's also weird and potentially situational.
// Specific considerations when updating this:
// + Does being turned into a borg (if/when implemented) count as dead?
// *If not, add specific conditions to users of this property where applicable.*
// + Is being transformed into a donut 'dead'?
// TODO: Consider changing the way ghost roles work.
// Mind is an *IC* mind, therefore ghost takeover is IC revival right now.
// + Is it necessary to have a reference to a specific 'mind iteration' to cycle when certain events happen?
// (If being a borg or AI counts as dead, then this is highly likely, as it's still the same Mind for practical purposes.)
// This can be null if they're deleted (spike / brain nom)
var targetMobState = _entityManager.GetComponentOrNull<MobStateComponent>(OwnedEntity);
// This can be null if it's a brain (this happens very often)
// Brains are the result of gibbing so should definitely count as dead
if (targetMobState == null)
return true;
// They might actually be alive.
return _mobStateSystem.IsDead(OwnedEntity!.Value, targetMobState);
}
}
/// <summary>
/// A string to represent the mind for logging
/// </summary>
private string MindOwnerLoggingString
{
get
{
if (OwnedEntity != null)
return _entityManager.ToPrettyString(OwnedEntity.Value);
if (UserId != null)
return UserId.Value.ToString();
return "(originally " + OriginalOwnerUserId + ")";
}
}
/// <summary>
/// Gives this mind a new role.
/// </summary>
/// <param name="role">The type of the role to give.</param>
/// <returns>The instance of the role.</returns>
/// <exception cref="ArgumentException">
/// Thrown if we already have a role with this type.
/// </exception>
public Role AddRole(Role role)
{
if (_roles.Contains(role))
{
throw new ArgumentException($"We already have this role: {role}");
}
_roles.Add(role);
role.Greet();
var message = new RoleAddedEvent(this, role);
if (OwnedEntity != null)
{
_entityManager.EventBus.RaiseLocalEvent(OwnedEntity.Value, message, true);
}
_adminLogger.Add(LogType.Mind, LogImpact.Low,
$"'{role.Name}' added to mind of {MindOwnerLoggingString}");
return role;
}
/// <summary>
/// Removes a role from this mind.
/// </summary>
/// <param name="role">The type of the role to remove.</param>
/// <exception cref="ArgumentException">
/// Thrown if we do not have this role.
/// </exception>
public void RemoveRole(Role role)
{
if (!_roles.Contains(role))
{
throw new ArgumentException($"We do not have this role: {role}");
}
_roles.Remove(role);
var message = new RoleRemovedEvent(this, role);
if (OwnedEntity != null)
{
_entityManager.EventBus.RaiseLocalEvent(OwnedEntity.Value, message, true);
}
_adminLogger.Add(LogType.Mind, LogImpact.Low,
$"'{role.Name}' removed from mind of {MindOwnerLoggingString}");
}
public bool HasRole<T>() where T : Role
{
return _roles.Any(role => role is T);
}
public IPlayerSession? Session { get; internal set; }
/// <summary>
/// Gets the current job
/// </summary>
public Job? CurrentJob => _roles.OfType<Job>().SingleOrDefault();
/// <summary>
/// Adds an objective to this mind.
/// </summary>
public bool TryAddObjective(ObjectivePrototype objectivePrototype)
{
if (!objectivePrototype.CanBeAssigned(this))
return false;
var objective = objectivePrototype.GetObjective(this);
if (_objectives.Contains(objective))
return false;
foreach (var condition in objective.Conditions)
_adminLogger.Add(LogType.Mind, LogImpact.Low, $"'{condition.Title}' added to mind of {MindOwnerLoggingString}");
_objectives.Add(objective);
return true;
}
/// <summary>
/// Removes an objective from this mind.
/// </summary>
/// <returns>Returns true if the removal succeeded.</returns>
public bool TryRemoveObjective(int index)
{
if (index < 0 || index >= _objectives.Count) return false;
var objective = _objectives[index];
foreach (var condition in objective.Conditions)
_adminLogger.Add(LogType.Mind, LogImpact.Low, $"'{condition.Title}' removed from the mind of {MindOwnerLoggingString}");
_objectives.Remove(objective);
return true;
}
/// <summary>
/// Transfer this mind's control over to a new entity.
/// </summary>
/// <param name="entity">
/// The entity to control.
/// Can be null, in which case it will simply detach the mind from any entity.
/// </param>
/// <param name="ghostCheckOverride">
/// If true, skips ghost check for Visiting Entity
/// </param>
/// <exception cref="ArgumentException">
/// Thrown if <paramref name="entity"/> is already owned by another mind.
/// </exception>
public void TransferTo(EntityUid? entity, bool ghostCheckOverride = false)
{
// Looks like caller just wants us to go back to normal.
if (entity == OwnedEntity)
{
UnVisit();
return;
}
MindComponent? component = null;
var alreadyAttached = false;
if (entity != null)
{
if (!_entityManager.TryGetComponent(entity.Value, out component))
{
component = _entityManager.AddComponent<MindComponent>(entity.Value);
}
else if (component.HasMind)
{
_gameTickerSystem.OnGhostAttempt(component.Mind!, false);
}
if (_entityManager.TryGetComponent<ActorComponent>(entity.Value, out var actor))
{
// Happens when transferring to your currently visited entity.
if (actor.PlayerSession != Session)
{
throw new ArgumentException("Visit target already has a session.", nameof(entity));
}
alreadyAttached = true;
}
}
if(OwnedComponent != null)
_mindSystem.InternalEjectMind(OwnedComponent.Owner, OwnedComponent);
OwnedComponent = component;
if(OwnedComponent != null)
_mindSystem.InternalAssignMind(OwnedComponent.Owner, this, OwnedComponent);
// Don't do the full deletion cleanup if we're transferring to our visitingentity
if (alreadyAttached)
{
// Set VisitingEntity null first so the removal of VisitingMind doesn't get through Unvisit() and delete what we're visiting.
// Yes this control flow sucks.
VisitingEntity = null;
_entityManager.RemoveComponent<VisitingMindComponent>(entity!.Value);
}
else if (VisitingEntity != null
&& (ghostCheckOverride // to force mind transfer, for example from ControlMobVerb
|| !_entityManager.TryGetComponent(VisitingEntity!, out GhostComponent? ghostComponent) // visiting entity is not a Ghost
|| !ghostComponent.CanReturnToBody)) // it is a ghost, but cannot return to body anyway, so it's okay
{
RemoveVisitingEntity();
}
// Player is CURRENTLY connected.
if (Session != null && !alreadyAttached && VisitingEntity == null)
{
Session.AttachToEntity(entity);
Logger.Info($"Session {Session.Name} transferred to entity {entity}.");
}
}
public void ChangeOwningPlayer(NetUserId? newOwner)
{
var playerMgr = IoCManager.Resolve<IPlayerManager>();
PlayerData? newOwnerData = null;
if (newOwner.HasValue)
{
if (!playerMgr.TryGetPlayerData(newOwner.Value, out var uncast))
{
// This restriction is because I'm too lazy to initialize the player data
// for a client that hasn't logged in yet.
// Go ahead and remove it if you need.
throw new ArgumentException("new owner must have previously logged into the server.");
}
newOwnerData = uncast.ContentData();
}
// Make sure to remove control from our old owner if they're logged in.
var oldSession = Session;
oldSession?.AttachToEntity(null);
if (UserId.HasValue)
{
var data = playerMgr.GetPlayerData(UserId.Value).ContentData();
DebugTools.AssertNotNull(data);
data!.UpdateMindFromMindChangeOwningPlayer(null);
}
UserId = newOwner;
if (!newOwner.HasValue)
{
return;
}
// Yank new owner out of their old mind too.
// Can I mention how much I love the word yank?
DebugTools.AssertNotNull(newOwnerData);
newOwnerData!.Mind?.ChangeOwningPlayer(null);
newOwnerData.UpdateMindFromMindChangeOwningPlayer(this);
}
public void Visit(EntityUid entity)
{
Session?.AttachToEntity(entity);
VisitingEntity = entity;
var comp = _entityManager.AddComponent<VisitingMindComponent>(entity);
comp.Mind = this;
Logger.Info($"Session {Session?.Name} visiting entity {entity}.");
}
/// <summary>
/// Returns the mind to its original entity.
/// </summary>
public void UnVisit()
{
var currentEntity = Session?.AttachedEntity;
Session?.AttachToEntity(OwnedEntity);
RemoveVisitingEntity();
if (Session != null && OwnedEntity != null && currentEntity != OwnedEntity)
_adminLogger.Add(LogType.Mind, LogImpact.Low,
$"{Session.Name} returned to {_entityManager.ToPrettyString(OwnedEntity.Value)}");
}
/// <summary>
/// Cleans up the VisitingEntity.
/// </summary>
private void RemoveVisitingEntity()
{
if (VisitingEntity == null)
return;
var oldVisitingEnt = VisitingEntity.Value;
// Null this before removing the component to avoid any infinite loops.
VisitingEntity = null;
DebugTools.AssertNotNull(oldVisitingEnt);
_entityManager.RemoveComponent<VisitingMindComponent>(oldVisitingEnt);
_entityManager.EventBus.RaiseLocalEvent(oldVisitingEnt, new MindUnvisitedMessage(), true);
}
public bool TryGetSession([NotNullWhen(true)] out IPlayerSession? session)
{
return (session = Session) != null;
}
public Job? CurrentJob => Roles.OfType<Job>().SingleOrDefault();
}
}

600
Content.Server/Mind/MindSystem.cs
View File

@@ -1,13 +1,24 @@
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Content.Server.Administration.Logs;
using Content.Server.GameTicking;
using Content.Server.Ghost;
using Content.Server.Ghost.Components;
using Content.Server.Mind.Components;
using Content.Server.Objectives;
using Content.Server.Players;
using Content.Server.Roles;
using Content.Shared.Database;
using Content.Shared.Examine;
using Content.Shared.Mobs.Components;
using Content.Shared.Mobs.Systems;
using Content.Shared.Interaction.Events;
using Content.Shared.Mobs.Components;
using Robust.Server.GameObjects;
using Robust.Server.Player;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
namespace Content.Server.Mind;
@@ -17,17 +28,34 @@ public sealed class MindSystem : EntitySystem
[Dependency] private readonly GameTicker _gameTicker = default!;
[Dependency] private readonly MobStateSystem _mobStateSystem = default!;
[Dependency] private readonly GhostSystem _ghostSystem = default!;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
[Dependency] private readonly IPlayerManager _playerManager = default!;
[Dependency] private readonly ActorSystem _actor = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<MindComponent, ComponentShutdown>(OnShutdown);
SubscribeLocalEvent<MindComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<MindComponent, SuicideEvent>(OnSuicide);
SubscribeLocalEvent<MindContainerComponent, ComponentShutdown>(OnShutdown);
SubscribeLocalEvent<MindContainerComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<MindContainerComponent, SuicideEvent>(OnSuicide);
SubscribeLocalEvent<VisitingMindComponent, EntityTerminatingEvent>(OnTerminating);
SubscribeLocalEvent<VisitingMindComponent, PlayerDetachedEvent>(OnDetached);
}
public void SetGhostOnShutdown(EntityUid uid, bool value, MindComponent? mind = null)
private void OnDetached(EntityUid uid, VisitingMindComponent component, PlayerDetachedEvent args)
{
component.Mind = null;
RemCompDeferred(uid, component);
}
private void OnTerminating(EntityUid uid, VisitingMindComponent component, ref EntityTerminatingEvent args)
{
if (component.Mind?.Session?.AttachedEntity == uid)
UnVisit(component.Mind);
}
public void SetGhostOnShutdown(EntityUid uid, bool value, MindContainerComponent? mind = null)
{
if (!Resolve(uid, ref mind))
return;
@@ -37,10 +65,10 @@ public sealed class MindSystem : EntitySystem
/// <summary>
/// Don't call this unless you know what the hell you're doing.
/// Use <see cref="Mind.TransferTo(System.Nullable{Robust.Shared.GameObjects.EntityUid},bool)"/> instead.
/// Use <see cref="MindSystem.TransferTo(Mind,System.Nullable{Robust.Shared.GameObjects.EntityUid},bool)"/> instead.
/// If that doesn't cover it, make something to cover it.
/// </summary>
public void InternalAssignMind(EntityUid uid, Mind value, MindComponent? mind = null)
private void InternalAssignMind(EntityUid uid, Mind value, MindContainerComponent? mind = null)
{
if (!Resolve(uid, ref mind))
return;
@@ -51,10 +79,10 @@ public sealed class MindSystem : EntitySystem
/// <summary>
/// Don't call this unless you know what the hell you're doing.
/// Use <see cref="Mind.TransferTo(System.Nullable{Robust.Shared.GameObjects.EntityUid},bool)"/> instead.
/// Use <see cref="MindSystem.TransferTo(Mind,System.Nullable{Robust.Shared.GameObjects.EntityUid},bool)"/> instead.
/// If that doesn't cover it, make something to cover it.
/// </summary>
public void InternalEjectMind(EntityUid uid, MindComponent? mind = null)
private void InternalEjectMind(EntityUid uid, MindContainerComponent? mind = null)
{
if (!Resolve(uid, ref mind, false))
return;
@@ -63,109 +91,519 @@ public sealed class MindSystem : EntitySystem
mind.Mind = null;
}
private void OnShutdown(EntityUid uid, MindComponent mind, ComponentShutdown args)
private void OnShutdown(EntityUid uid, MindContainerComponent mindContainerComp, ComponentShutdown args)
{
// Let's not create ghosts if not in the middle of the round.
if (_gameTicker.RunLevel != GameRunLevel.InRound)
return;
if (mind.HasMind)
if (!TryGetMind(uid, out var mind, mindContainerComp))
return;
if (mind.VisitingEntity is {Valid: true} visiting)
{
if (mind.Mind?.VisitingEntity is {Valid: true} visiting)
if (TryComp(visiting, out GhostComponent? ghost))
{
if (TryComp(visiting, out GhostComponent? ghost))
_ghostSystem.SetCanReturnToBody(ghost, false);
}
TransferTo(mind, visiting);
}
else if (mindContainerComp.GhostOnShutdown)
{
// Changing an entities parents while deleting is VERY sus. This WILL throw exceptions.
// TODO: just find the applicable spawn position directly without actually updating the transform's parent.
Transform(uid).AttachToGridOrMap();
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.InRound)
return;
// Async this so that we don't throw if the grid we're on is being deleted.
var gridId = spawnPosition.GetGridUid(EntityManager);
if (!spawnPosition.IsValid(EntityManager) || gridId == EntityUid.Invalid || !_mapManager.GridExists(gridId))
{
_ghostSystem.SetCanReturnToBody(ghost, false);
spawnPosition = _gameTicker.GetObserverSpawnPoint();
}
mind.Mind!.TransferTo(visiting);
}
else if (mind.GhostOnShutdown)
{
// Changing an entities parents while deleting is VERY sus. This WILL throw exceptions.
// TODO: just find the applicable spawn position dirctly without actually updating the transform's parent.
Transform(uid).AttachToGridOrMap();
var spawnPosition = Transform(uid).Coordinates;
// Use a regular timer here because the entity has probably been deleted.
Timer.Spawn(0, () =>
// TODO refactor observer spawning.
// please.
if (!spawnPosition.IsValid(EntityManager))
{
// Make extra sure the round didn't end between spawning the timer and it being executed.
if (_gameTicker.RunLevel != GameRunLevel.InRound)
return;
// 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(mind, null);
return;
}
// Async this so that we don't throw if the grid we're on is being deleted.
var gridId = spawnPosition.GetGridUid(EntityManager);
if (!spawnPosition.IsValid(EntityManager) || gridId == EntityUid.Invalid || !_mapManager.GridExists(gridId))
{
spawnPosition = _gameTicker.GetObserverSpawnPoint();
}
var ghost = Spawn("MobObserver", spawnPosition);
var ghostComponent = Comp<GhostComponent>(ghost);
_ghostSystem.SetCanReturnToBody(ghostComponent, false);
// 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.
Logger.WarningS("mind", $"Entity \"{ToPrettyString(uid)}\" for {mind.Mind?.CharacterName} was deleted, and no applicable spawn location is available.");
mind.Mind?.TransferTo(null);
return;
}
// 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)}\".");
var ghost = Spawn("MobObserver", spawnPosition);
var ghostComponent = Comp<GhostComponent>(ghost);
_ghostSystem.SetCanReturnToBody(ghostComponent, false);
// Log these to make sure they're not causing the GameTicker round restart bugs...
Logger.DebugS("mind", $"Entity \"{ToPrettyString(uid)}\" for {mind.Mind?.CharacterName} was deleted, spawned \"{ToPrettyString(ghost)}\".");
if (mind.Mind == null)
return;
var val = mind.Mind.CharacterName ?? string.Empty;
MetaData(ghost).EntityName = val;
mind.Mind.TransferTo(ghost);
});
}
var val = mind.CharacterName ?? string.Empty;
MetaData(ghost).EntityName = val;
TransferTo(mind, ghost);
});
}
}
private void OnExamined(EntityUid uid, MindComponent mind, ExaminedEvent args)
private void OnExamined(EntityUid uid, MindContainerComponent mindContainer, ExaminedEvent args)
{
if (!mind.ShowExamineInfo || !args.IsInDetailsRange)
{
if (!mindContainer.ShowExamineInfo || !args.IsInDetailsRange)
return;
}
var dead = TryComp<MobStateComponent?>(uid, out var state) && _mobStateSystem.IsDead(uid, state);
var dead = _mobStateSystem.IsDead(uid);
var hasSession = mindContainer.Mind?.Session;
if (dead)
{
if (mind.Mind?.Session == null) {
// Player has no session attached and dead
args.PushMarkup($"[color=yellow]{Loc.GetString("mind-component-no-mind-and-dead-text", ("ent", uid))}[/color]");
} else {
// Player is dead with session
args.PushMarkup($"[color=red]{Loc.GetString("comp-mind-examined-dead", ("ent", uid))}[/color]");
}
}
else if (!mind.HasMind)
{
if (dead && hasSession == null)
args.PushMarkup($"[color=yellow]{Loc.GetString("comp-mind-examined-dead-and-ssd", ("ent", uid))}[/color]");
else if (dead)
args.PushMarkup($"[color=red]{Loc.GetString("comp-mind-examined-dead", ("ent", uid))}[/color]");
else if (!mindContainer.HasMind)
args.PushMarkup($"[color=mediumpurple]{Loc.GetString("comp-mind-examined-catatonic", ("ent", uid))}[/color]");
}
else if (mind.Mind?.Session == null)
{
else if (hasSession == null)
args.PushMarkup($"[color=yellow]{Loc.GetString("comp-mind-examined-ssd", ("ent", uid))}[/color]");
}
}
private void OnSuicide(EntityUid uid, MindComponent component, SuicideEvent args)
private void OnSuicide(EntityUid uid, MindContainerComponent component, SuicideEvent args)
{
if (args.Handled)
return;
if (component.HasMind && component.Mind!.PreventSuicide)
if (component.HasMind && component.Mind.PreventSuicide)
{
args.BlockSuicideAttempt(true);
}
}
public Mind? GetMind(EntityUid uid, MindContainerComponent? mind = null)
{
if (!Resolve(uid, ref mind))
return null;
if (mind.HasMind)
return mind.Mind;
return null;
}
public Mind CreateMind(NetUserId? userId, string? name = null)
{
var mind = new Mind(userId);
mind.CharacterName = name;
ChangeOwningPlayer(mind, userId);
return mind;
}
/// <summary>
/// True if the OwnedEntity of this mind is physically dead.
/// This specific definition, as opposed to CharacterDeadIC, is used to determine if ghosting should allow return.
/// </summary>
public bool IsCharacterDeadPhysically(Mind mind)
{
// This is written explicitly so that the logic can be understood.
// But it's also weird and potentially situational.
// Specific considerations when updating this:
// + Does being turned into a borg (if/when implemented) count as dead?
// *If not, add specific conditions to users of this property where applicable.*
// + Is being transformed into a donut 'dead'?
// TODO: Consider changing the way ghost roles work.
// Mind is an *IC* mind, therefore ghost takeover is IC revival right now.
// + Is it necessary to have a reference to a specific 'mind iteration' to cycle when certain events happen?
// (If being a borg or AI counts as dead, then this is highly likely, as it's still the same Mind for practical purposes.)
if (mind.OwnedEntity == null)
return true;
// This can be null if they're deleted (spike / brain nom)
var targetMobState = EntityManager.GetComponentOrNull<MobStateComponent>(mind.OwnedEntity);
// This can be null if it's a brain (this happens very often)
// Brains are the result of gibbing so should definitely count as dead
if (targetMobState == null)
return true;
// They might actually be alive.
return _mobStateSystem.IsDead(mind.OwnedEntity.Value, targetMobState);
}
public void Visit(Mind mind, EntityUid entity)
{
if (mind.VisitingEntity != null)
{
Log.Error($"Attempted to visit an entity ({ToPrettyString(entity)}) while already visiting another ({ToPrettyString(mind.VisitingEntity.Value)}).");
return;
}
if (HasComp<VisitingMindComponent>(entity))
{
Log.Error($"Attempted to visit an entity that already has a visiting mind. Entity: {ToPrettyString(entity)}");
return;
}
mind.Session?.AttachToEntity(entity);
mind.VisitingEntity = entity;
// EnsureComp instead of AddComp to deal with deferred deletions.
var comp = EnsureComp<VisitingMindComponent>(entity);
comp.Mind = mind;
Log.Info($"Session {mind.Session?.Name} visiting entity {entity}.");
}
/// <summary>
/// Returns the mind to its original entity.
/// </summary>
public void UnVisit(Mind? mind)
{
if (mind == null || mind.VisitingEntity == null)
return;
DebugTools.Assert(mind.VisitingEntity != mind.OwnedEntity);
RemoveVisitingEntity(mind);
if (mind.Session == null || mind.Session.AttachedEntity == mind.VisitingEntity)
return;
var owned = mind.OwnedEntity;
mind.Session.AttachToEntity(owned);
if (owned.HasValue)
{
_adminLogger.Add(LogType.Mind, LogImpact.Low,
$"{mind.Session.Name} returned to {ToPrettyString(owned.Value)}");
}
}
/// <summary>
/// Cleans up the VisitingEntity.
/// </summary>
/// <param name="mind"></param>
private void RemoveVisitingEntity(Mind mind)
{
if (mind.VisitingEntity == null)
return;
var oldVisitingEnt = mind.VisitingEntity.Value;
// Null this before removing the component to avoid any infinite loops.
mind.VisitingEntity = null;
if (TryComp(oldVisitingEnt, out VisitingMindComponent? visitComp))
{
visitComp.Mind = null;
RemCompDeferred(oldVisitingEnt, visitComp);
}
RaiseLocalEvent(oldVisitingEnt, new MindUnvisitedMessage(), true);
}
/// <summary>
/// Transfer this mind's control over to a new entity.
/// </summary>
/// <param name="mind">The mind to transfer</param>
/// <param name="entity">
/// The entity to control.
/// Can be null, in which case it will simply detach the mind from any entity.
/// </param>
/// <param name="ghostCheckOverride">
/// If true, skips ghost check for Visiting Entity
/// </param>
/// <exception cref="ArgumentException">
/// Thrown if <paramref name="entity"/> is already owned by another mind.
/// </exception>
public void TransferTo(Mind mind, EntityUid? entity, bool ghostCheckOverride = false)
{
// Looks like caller just wants us to go back to normal.
if (entity == mind.OwnedEntity)
{
UnVisit(mind);
return;
}
MindContainerComponent? component = null;
var alreadyAttached = false;
if (entity != null)
{
if (!TryComp(entity.Value, out component))
{
component = AddComp<MindContainerComponent>(entity.Value);
}
else if (component.HasMind)
{
_gameTicker.OnGhostAttempt(component.Mind, false);
}
if (TryComp<ActorComponent>(entity.Value, out var actor))
{
// Happens when transferring to your currently visited entity.
if (actor.PlayerSession != mind.Session)
{
throw new ArgumentException("Visit target already has a session.", nameof(entity));
}
alreadyAttached = true;
}
}
var oldComp = mind.OwnedComponent;
var oldEntity = mind.OwnedEntity;
if(oldComp != null && oldEntity != null)
InternalEjectMind(oldEntity.Value, oldComp);
SetOwnedEntity(mind, entity, component);
if (mind.OwnedComponent != null)
InternalAssignMind(mind.OwnedEntity!.Value, mind, mind.OwnedComponent);
// Don't do the full deletion cleanup if we're transferring to our VisitingEntity
if (alreadyAttached)
{
// Set VisitingEntity null first so the removal of VisitingMind doesn't get through Unvisit() and delete what we're visiting.
// Yes this control flow sucks.
mind.VisitingEntity = null;
RemComp<VisitingMindComponent>(entity!.Value);
}
else if (mind.VisitingEntity != null
&& (ghostCheckOverride // to force mind transfer, for example from ControlMobVerb
|| !TryComp(mind.VisitingEntity!, out GhostComponent? ghostComponent) // visiting entity is not a Ghost
|| !ghostComponent.CanReturnToBody)) // it is a ghost, but cannot return to body anyway, so it's okay
{
RemoveVisitingEntity(mind);
}
// Player is CURRENTLY connected.
if (mind.Session != null && !alreadyAttached && mind.VisitingEntity == null)
{
mind.Session.AttachToEntity(entity);
Log.Info($"Session {mind.Session.Name} transferred to entity {entity}.");
}
}
public void ChangeOwningPlayer(Mind mind, NetUserId? newOwner)
{
// Make sure to remove control from our old owner if they're logged in.
var oldSession = mind.Session;
oldSession?.AttachToEntity(null);
if (mind.UserId.HasValue)
{
if (_playerManager.TryGetPlayerData(mind.UserId.Value, out var oldUncast))
{
var data = oldUncast.ContentData();
DebugTools.AssertNotNull(data);
data!.UpdateMindFromMindChangeOwningPlayer(null);
}
else
{
Log.Warning($"Mind UserId {newOwner} is does not exist in PlayerManager");
}
}
SetUserId(mind, newOwner);
if (!newOwner.HasValue)
{
return;
}
if (!_playerManager.TryGetPlayerData(newOwner.Value, out var uncast))
{
// This restriction is because I'm too lazy to initialize the player data
// for a client that hasn't logged in yet.
// Go ahead and remove it if you need.
throw new ArgumentException("New owner must have previously logged into the server.", nameof(newOwner));
}
// PlayerData? newOwnerData = null;
var newOwnerData = uncast.ContentData();
// Yank new owner out of their old mind too.
// Can I mention how much I love the word yank?
DebugTools.AssertNotNull(newOwnerData);
if (newOwnerData!.Mind != null)
ChangeOwningPlayer(newOwnerData.Mind, null);
newOwnerData.UpdateMindFromMindChangeOwningPlayer(mind);
}
/// <summary>
/// Adds an objective to this mind.
/// </summary>
public bool TryAddObjective(Mind mind, ObjectivePrototype objectivePrototype)
{
if (!objectivePrototype.CanBeAssigned(mind))
return false;
var objective = objectivePrototype.GetObjective(mind);
if (mind.Objectives.Contains(objective))
return false;
foreach (var condition in objective.Conditions)
{
_adminLogger.Add(LogType.Mind, LogImpact.Low, $"'{condition.Title}' added to mind of {MindOwnerLoggingString(mind)}");
}
mind.Objectives.Add(objective);
return true;
}
/// <summary>
/// Removes an objective to this mind.
/// </summary>
/// <returns>Returns true if the removal succeeded.</returns>
public bool TryRemoveObjective(Mind mind, int index)
{
if (mind.Objectives.Count >= index) return false;
var objective = mind.Objectives[index];
foreach (var condition in objective.Conditions)
{
_adminLogger.Add(LogType.Mind, LogImpact.Low, $"'{condition.Title}' removed from the mind of {MindOwnerLoggingString(mind)}");
}
mind.Objectives.Remove(objective);
return true;
}
/// <summary>
/// Gives this mind a new role.
/// </summary>
/// <param name="mind">The mind to add the role to.</param>
/// <param name="role">The type of the role to give.</param>
/// <returns>The instance of the role.</returns>
/// <exception cref="ArgumentException">
/// Thrown if we already have a role with this type.
/// </exception>
public void AddRole(Mind mind, Role role)
{
if (mind.Roles.Contains(role))
{
throw new ArgumentException($"We already have this role: {role}");
}
mind.Roles.Add(role);
role.Greet();
var message = new RoleAddedEvent(mind, role);
if (mind.OwnedEntity != null)
{
RaiseLocalEvent(mind.OwnedEntity.Value, message, true);
}
_adminLogger.Add(LogType.Mind, LogImpact.Low,
$"'{role.Name}' added to mind of {MindOwnerLoggingString(mind)}");
}
/// <summary>
/// Removes a role from this mind.
/// </summary>
/// <param name="mind">The mind to remove the role from.</param>
/// <param name="role">The type of the role to remove.</param>
/// <exception cref="ArgumentException">
/// Thrown if we do not have this role.
/// </exception>
public void RemoveRole(Mind mind, Role role)
{
if (!mind.Roles.Contains(role))
{
throw new ArgumentException($"We do not have this role: {role}");
}
mind.Roles.Remove(role);
var message = new RoleRemovedEvent(mind, role);
if (mind.OwnedEntity != null)
{
RaiseLocalEvent(mind.OwnedEntity.Value, message, true);
}
_adminLogger.Add(LogType.Mind, LogImpact.Low,
$"'{role.Name}' removed from mind of {MindOwnerLoggingString(mind)}");
}
public bool HasRole<T>(Mind mind) where T : Role
{
return mind.Roles.Any(role => role is T);
}
public bool TryGetSession(Mind mind, [NotNullWhen(true)] out IPlayerSession? session)
{
return (session = mind.Session) != null;
}
/// <summary>
/// Gets a mind from uid and/or MindContainerComponent. Used for null checks.
/// </summary>
/// <param name="uid">Entity UID that owns the mind.</param>
/// <param name="mind">The returned mind.</param>
/// <param name="mindContainerComponent">Mind component on <paramref name="uid"/> to get the mind from.</param>
/// <returns>True if mind found. False if not.</returns>
public bool TryGetMind(EntityUid uid, [NotNullWhen(true)] out Mind? mind, MindContainerComponent? mindContainerComponent = null)
{
mind = null;
if (!Resolve(uid, ref mindContainerComponent))
return false;
if (!mindContainerComponent.HasMind)
return false;
mind = mindContainerComponent.Mind;
return true;
}
/// <summary>
/// Sets the Mind's OwnedComponent and OwnedEntity
/// </summary>
/// <param name="mind">Mind to set OwnedComponent and OwnedEntity on</param>
/// <param name="uid">Entity owned by <paramref name="mind"/></param>
/// <param name="mindContainerComponent">MindContainerComponent owned by <paramref name="mind"/></param>
private void SetOwnedEntity(Mind mind, EntityUid? uid, MindContainerComponent? mindContainerComponent)
{
if (uid != null)
Resolve(uid.Value, ref mindContainerComponent);
mind.OwnedEntity = uid;
mind.OwnedComponent = mindContainerComponent;
}
/// <summary>
/// Sets the Mind's UserId and Session
/// </summary>
/// <param name="mind"></param>
/// <param name="userId"></param>
private void SetUserId(Mind mind, NetUserId? userId)
{
mind.UserId = userId;
if (!userId.HasValue)
return;
_playerManager.TryGetSessionById(userId.Value, out var ret);
mind.Session = ret;
}
/// <summary>
/// True if this Mind is 'sufficiently dead' IC (Objectives, EndText).
/// Note that this is *IC logic*, it's not necessarily tied to any specific truth.
/// "If administrators decide that zombies are dead, this returns true for zombies."
/// (Maybe you were looking for the action blocker system?)
/// </summary>
public bool IsCharacterDeadIc(Mind mind)
{
return IsCharacterDeadPhysically(mind);
}
/// <summary>
/// A string to represent the mind for logging
/// </summary>
private string MindOwnerLoggingString(Mind mind)
{
if (mind.OwnedEntity != null)
return ToPrettyString(mind.OwnedEntity.Value);
if (mind.UserId != null)
return mind.UserId.Value.ToString();
return "(originally " + mind.OriginalOwnerUserId + ")";
}
}

4
Content.Server/Mind/MindTrackerSystem.cs
View File

@@ -20,7 +20,7 @@ namespace Content.Server.Mind
base.Initialize();
SubscribeLocalEvent<RoundRestartCleanupEvent>(Reset);
SubscribeLocalEvent<MindComponent, MindAddedMessage>(OnMindAdded);
SubscribeLocalEvent<MindContainerComponent, MindAddedMessage>(OnMindAdded);
}
void Reset(RoundRestartCleanupEvent ev)
@@ -28,7 +28,7 @@ namespace Content.Server.Mind
AllMinds.Clear();
}
void OnMindAdded(EntityUid uid, MindComponent mc, MindAddedMessage args)
void OnMindAdded(EntityUid uid, MindContainerComponent mc, MindAddedMessage args)
{
var mind = mc.Mind;
if (mind != null)

5
Content.Server/Mind/TransferMindOnGibSystem.cs
View File

@@ -15,6 +15,7 @@ public sealed class TransferMindOnGibSystem : EntitySystem
{
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly TagSystem _tag = default!;
[Dependency] private readonly MindSystem _mindSystem = default!;
/// <inheritdoc/>
public override void Initialize()
@@ -24,7 +25,7 @@ public sealed class TransferMindOnGibSystem : EntitySystem
private void OnGib(EntityUid uid, TransferMindOnGibComponent component, BeingGibbedEvent args)
{
if (!TryComp<MindComponent>(uid, out var mindcomp) || mindcomp.Mind == null)
if (!TryComp<MindContainerComponent>(uid, out var mindcomp) || mindcomp.Mind == null)
return;
var validParts = args.GibbedParts.Where(p => _tag.HasTag(p, component.TargetTag)).ToHashSet();
@@ -32,6 +33,6 @@ public sealed class TransferMindOnGibSystem : EntitySystem
return;
var ent = _random.Pick(validParts);
mindcomp.Mind.TransferTo(ent);
_mindSystem.TransferTo(mindcomp.Mind, ent);
}
}