tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move Access to ECS (#4826)

Browse Source 
* Moved access to ecs

* Fixed tests

* Moved test to integration

* Better IoC

* Moved preset ID card

* Moved id card to ECS

* Moved access component to ECS

* Fixed pda access

* Final touches

Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>
This commit is contained in:
Alex Evgrashin
2021-10-22 05:31:07 +03:00
committed by GitHub
parent 430485de06
commit a3f16295ea
26 changed files with 409 additions and 466 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
Content.IntegrationTests/Tests/Access/AccessReaderTest.cs Normal file
View File

@@ -0,0 +1,76 @@
using System.Collections.Generic;
using System.Threading.Tasks;
using Content.IntegrationTests;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using NUnit.Framework;
using Robust.Shared.GameObjects;
namespace Content.Tests.Server.GameObjects.Components.Access
{
[TestFixture]
[TestOf(typeof(AccessReader))]
public class AccessReaderTest : ContentIntegrationTest
{
[Test]
public async Task TestTags()
{
var server = StartServerDummyTicker();
await server.WaitAssertion(() =>
{
var system = EntitySystem.Get<AccessReaderSystem>();
// test empty
var reader = new AccessReader();
Assert.That(system.IsAllowed(reader, new[] { "Foo" }), Is.True);
Assert.That(system.IsAllowed(reader, new[] { "Bar" }), Is.True);
Assert.That(system.IsAllowed(reader, new string[] { }), Is.True);
// test deny
reader = new AccessReader();
reader.DenyTags.Add("A");
Assert.That(system.IsAllowed(reader, new[] { "Foo" }), Is.True);
Assert.That(system.IsAllowed(reader, new[] { "A" }), Is.False);
Assert.That(system.IsAllowed(reader, new[] { "A", "Foo" }), Is.False);
Assert.That(system.IsAllowed(reader, new string[] { }), Is.True);
// test one list
reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> { "A" });
Assert.That(system.IsAllowed(reader, new[] { "A" }), Is.True);
Assert.That(system.IsAllowed(reader, new[] { "B" }), Is.False);
Assert.That(system.IsAllowed(reader, new[] { "A", "B" }), Is.True);
Assert.That(system.IsAllowed(reader, new string[] { }), Is.False);
// test one list - two items
reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> { "A", "B" });
Assert.That(system.IsAllowed(reader, new[] { "A" }), Is.False);
Assert.That(system.IsAllowed(reader, new[] { "B" }), Is.False);
Assert.That(system.IsAllowed(reader, new[] { "A", "B" }), Is.True);
Assert.That(system.IsAllowed(reader, new string[] { }), Is.False);
// test two list
reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> { "A" });
reader.AccessLists.Add(new HashSet<string> { "B", "C" });
Assert.That(system.IsAllowed(reader, new[] { "A" }), Is.True);
Assert.That(system.IsAllowed(reader, new[] { "B" }), Is.False);
Assert.That(system.IsAllowed(reader, new[] { "A", "B" }), Is.True);
Assert.That(system.IsAllowed(reader, new[] { "C", "B" }), Is.True);
Assert.That(system.IsAllowed(reader, new[] { "C", "B", "A" }), Is.True);
Assert.That(system.IsAllowed(reader, new string[] { }), Is.False);
// test deny list
reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> { "A" });
reader.DenyTags.Add("B");
Assert.That(system.IsAllowed(reader, new[] { "A" }), Is.True);
Assert.That(system.IsAllowed(reader, new[] { "B" }), Is.False);
Assert.That(system.IsAllowed(reader, new[] { "A", "B" }), Is.False);
Assert.That(system.IsAllowed(reader, new string[] { }), Is.False);
});
}
}
}

6
Content.Server/AI/Pathfinding/Accessible/AiReachableSystem.cs
View File

@@ -1,6 +1,7 @@
using System;
using System;
using System.Collections.Generic;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.AI.Pathfinding.Pathfinders;
using Content.Shared.AI;
using Content.Shared.GameTicking;
@@ -38,6 +39,7 @@ namespace Content.Server.AI.Pathfinding.Accessible
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly PathfindingSystem _pathfindingSystem = default!;
[Dependency] private readonly AccessReaderSystem _accessReader = default!;
/// <summary>
/// Queued region updates
@@ -184,7 +186,7 @@ namespace Content.Server.AI.Pathfinding.Accessible
collisionMask = physics.CollisionMask;
}
var access = AccessReader.FindAccessTags(entity);
var access = _accessReader.FindAccessTags(entity.Uid);
// We'll do a quick traversable check before going through regions
// If we can't access it we'll try to get a valid node in range (this is essentially an early-out)

6
Content.Server/AI/Pathfinding/Accessible/ReachableArgs.cs
View File

@@ -1,5 +1,6 @@
using System.Collections.Generic;
using System.Collections.Generic;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.AI.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Physics;
@@ -32,7 +33,8 @@ namespace Content.Server.AI.Pathfinding.Accessible
collisionMask = physics.CollisionMask;
}
var access = AccessReader.FindAccessTags(entity);
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
var access = accessSystem.FindAccessTags(entity.Uid);
var visionRadius = entity.GetComponent<AiControllerComponent>().VisionRadius;
return new ReachableArgs(visionRadius, access, collisionMask);

4
Content.Server/AI/Pathfinding/PathfindingHelpers.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using Content.Server.Access.Systems;
using Content.Server.AI.Pathfinding.Accessible;
using Content.Server.AI.Pathfinding.Pathfinders;
using Robust.Shared.GameObjects;
@@ -117,9 +118,10 @@ namespace Content.Server.AI.Pathfinding
return false;
}
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
foreach (var reader in node.AccessReaders)
{
if (!reader.IsAllowed(access))
if (!accessSystem.IsAllowed(reader, access))
{
return false;
}

9
Content.Server/AI/Pathfinding/PathfindingSystem.cs
View File

@@ -1,8 +1,9 @@
using System;
using System;
using System.Collections.Generic;
using System.Threading;
using Content.Server.Access;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.AI.Pathfinding.Pathfinders;
using Content.Server.CPUJob.JobQueues;
using Content.Server.CPUJob.JobQueues.Queues;
@@ -31,6 +32,7 @@ namespace Content.Server.AI.Pathfinding
{
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
[Dependency] private readonly AccessReaderSystem _accessReader = default!;
public IReadOnlyDictionary<GridId, Dictionary<Vector2i, PathfindingChunk>> Graph => _graph;
private readonly Dictionary<GridId, Dictionary<Vector2i, PathfindingChunk>> _graph = new();
@@ -375,11 +377,10 @@ namespace Content.Server.AI.Pathfinding
return false;
}
var access = AccessReader.FindAccessTags(entity);
var access = _accessReader.FindAccessTags(entity.Uid);
foreach (var reader in node.AccessReaders)
{
if (!reader.IsAllowed(access))
if (!_accessReader.IsAllowed(reader, access))
{
return false;
}

4
Content.Server/AI/Steering/AiSteeringSystem.cs
View File

@@ -4,6 +4,7 @@ using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.AI.Components;
using Content.Server.AI.Pathfinding;
using Content.Server.AI.Pathfinding.Pathfinders;
@@ -28,6 +29,7 @@ namespace Content.Server.AI.Steering
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IPauseManager _pauseManager = default!;
[Dependency] private readonly PathfindingSystem _pathfindingSystem = default!;
[Dependency] private readonly AccessReaderSystem _accessReader = default!;
/// <summary>
/// Whether we try to avoid non-blocking physics objects
@@ -423,7 +425,7 @@ namespace Content.Server.AI.Steering
collisionMask = physics.CollisionMask;
}
var access = AccessReader.FindAccessTags(entity);
var access = _accessReader.FindAccessTags(entity.Uid);
var job = _pathfindingSystem.RequestPath(new PathfindingArgs(
entity.Uid,

17
Content.Server/Access/Components/AccessComponent.cs
View File

@@ -1,4 +1,6 @@
using System.Collections.Generic;
using Content.Server.Access.Systems;
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
@@ -9,22 +11,13 @@ namespace Content.Server.Access.Components
/// Simple mutable access provider found on ID cards and such.
/// </summary>
[RegisterComponent]
[ComponentReference(typeof(IAccess))]
public class AccessComponent : Component, IAccess
[Friend(typeof(AccessSystem))]
public class AccessComponent : Component
{
public override string Name => "Access";
[DataField("tags")]
[ViewVariables]
private readonly HashSet<string> _tags = new();
public ISet<string> Tags => _tags;
public bool IsReadOnly => false;
public void SetTags(IEnumerable<string> newTags)
{
_tags.Clear();
_tags.UnionWith(newTags);
}
public HashSet<string> Tags = new();
}
}

92
Content.Server/Access/Components/AccessReaderComponent.cs
View File

@@ -20,13 +20,15 @@ namespace Content.Server.Access.Components
/// Stores access levels necessary to "use" an entity
/// and allows checking if something or somebody is authorized with these access levels.
/// </summary>
[PublicAPI]
[RegisterComponent]
public class AccessReader : Component
{
public override string Name => "AccessReader";
private readonly HashSet<string> _denyTags = new();
/// <summary>
/// The set of tags that will automatically deny an allowed check, if any of them are present.
/// </summary>
public HashSet<string> DenyTags = new();
/// <summary>
/// List of access lists to check allowed against. For an access check to pass
@@ -34,90 +36,6 @@ namespace Content.Server.Access.Components
/// </summary>
[DataField("access")]
[ViewVariables]
public List<HashSet<string>> AccessLists { get; } = new();
/// <summary>
/// The set of tags that will automatically deny an allowed check, if any of them are present.
/// </summary>
[ViewVariables] public ISet<string> DenyTags => _denyTags;
/// <summary>
/// Searches an <see cref="IAccess"/> in the entity itself, in its active hand or in its ID slot.
/// Then compares the found access with the configured access lists to see if it is allowed.
/// </summary>
/// <remarks>
/// If no access is found, an empty set is used instead.
/// </remarks>
/// <param name="entity">The entity to be searched for access.</param>
public bool IsAllowed(IEntity entity)
{
var tags = FindAccessTags(entity);
return IsAllowed(tags);
}
public bool IsAllowed(IAccess access)
{
return IsAllowed(access.Tags);
}
public bool IsAllowed(ICollection<string> accessTags)
{
if (_denyTags.Overlaps(accessTags))
{
// Sec owned by cargo.
return false;
}
return AccessLists.Count == 0 || AccessLists.Any(a => a.IsSubsetOf(accessTags));
}
public static ICollection<string> FindAccessTags(IEntity entity)
{
if (entity.TryGetComponent(out IAccess? accessComponent))
{
return accessComponent.Tags;
}
if (entity.TryGetComponent(out IHandsComponent? handsComponent))
{
var activeHandEntity = handsComponent.GetActiveHand?.Owner;
if (activeHandEntity != null &&
activeHandEntity.TryGetComponent(out IAccess? handAccessComponent))
{
return handAccessComponent.Tags;
}
}
else
{
return Array.Empty<string>();
}
if (entity.TryGetComponent(out InventoryComponent? inventoryComponent))
{
if (inventoryComponent.HasSlot(EquipmentSlotDefines.Slots.IDCARD) &&
inventoryComponent.TryGetSlotItem(EquipmentSlotDefines.Slots.IDCARD, out ItemComponent? item) &&
item.Owner.TryGetComponent(out IAccess? idAccessComponent)
)
{
return idAccessComponent.Tags;
}
}
return Array.Empty<string>();
}
protected override void Initialize()
{
base.Initialize();
var proto = IoCManager.Resolve<IPrototypeManager>();
foreach (var level in AccessLists.SelectMany(c => c).Union(DenyTags))
{
if (!proto.HasIndex<AccessLevelPrototype>(level))
{
Logger.ErrorS("access", $"Invalid access level: {level}");
}
}
}
public List<HashSet<string>> AccessLists = new();
}
}

31
Content.Server/Access/Components/IAccess.cs
View File

@@ -1,31 +0,0 @@
using System;
using System.Collections.Generic;
namespace Content.Server.Access.Components
{
/// <summary>
/// Contains access levels that can be checked to see if somebody has access with an <see cref="AccessReader"/>.
/// </summary>
public interface IAccess
{
/// <summary>
/// The set of access tags this thing has.
/// </summary>
/// <remarks>
/// This set may be read-only. Check <see cref="IsReadOnly"/> if you want to mutate it.
/// </remarks>
ISet<string> Tags { get; }
/// <summary>
/// Whether the <see cref="Tags"/> list is read-only.
/// </summary>
bool IsReadOnly { get; }
/// <summary>
/// Replaces the set of access tags we have with the provided set.
/// </summary>
/// <param name="newTags">The new access tags</param>
/// <exception cref="NotSupportedException">If this access tag list is read-only.</exception>
void SetTags(IEnumerable<string> newTags);
}
}

67
Content.Server/Access/Components/IdCardComponent.cs
View File

@@ -1,77 +1,24 @@
using Content.Server.Access.Systems;
using Content.Server.PDA;
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
using Robust.Shared.Localization;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
namespace Content.Server.Access.Components
{
[RegisterComponent]
[Friend(typeof(IdCardSystem), typeof(PDASystem))]
public class IdCardComponent : Component
{
public override string Name => "IdCard";
/// See <see cref="UpdateEntityName"/>.
[DataField("originalOwnerName")]
private string _originalOwnerName = default!;
public string OriginalOwnerName = default!;
[DataField("fullName")]
private string? _fullName;
[ViewVariables(VVAccess.ReadWrite)]
public string? FullName
{
get => _fullName;
set
{
_fullName = value;
UpdateEntityName();
}
}
public string? FullName;
[DataField("jobTitle")]
private string? _jobTitle;
[ViewVariables(VVAccess.ReadWrite)]
public string? JobTitle
{
get => _jobTitle;
set
{
_jobTitle = value;
UpdateEntityName();
}
}
/// <summary>
/// Changes the <see cref="Entity.Name"/> of <see cref="Component.Owner"/>.
/// </summary>
/// <remarks>
/// If either <see cref="FullName"/> or <see cref="JobTitle"/> is empty, it's replaced by placeholders.
/// If both are empty, the original entity's name is restored.
/// </remarks>
private void UpdateEntityName()
{
if (string.IsNullOrWhiteSpace(FullName) && string.IsNullOrWhiteSpace(JobTitle))
{
Owner.Name = _originalOwnerName;
return;
}
var jobSuffix = string.IsNullOrWhiteSpace(JobTitle) ? string.Empty : $" ({JobTitle})";
Owner.Name = string.IsNullOrWhiteSpace(FullName)
? Loc.GetString("access-id-card-component-owner-name-job-title-text",
("originalOwnerName", _originalOwnerName),
("jobSuffix", jobSuffix))
: Loc.GetString("access-id-card-component-owner-full-name-job-title-text",
("fullName", FullName),
("jobSuffix", jobSuffix));
}
protected override void Initialize()
{
base.Initialize();
// ReSharper disable once ConstantNullCoalescingCondition
_originalOwnerName ??= Owner.Name;
UpdateEntityName();
}
public string? JobTitle;
}
}

15
Content.Server/Access/Components/IdCardConsoleComponent.cs
View File

@@ -1,6 +1,7 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Access.Systems;
using Content.Server.Power.Components;
using Content.Server.UserInterface;
using Content.Shared.Access;
@@ -91,7 +92,8 @@ namespace Content.Server.Access.Components
}
var privilegedIdEntity = PrivilegedIdContainer.ContainedEntity;
return privilegedIdEntity != null && reader.IsAllowed(privilegedIdEntity);
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
return privilegedIdEntity != null && accessSystem.IsAllowed(reader, privilegedIdEntity.Uid);
}
/// <summary>
@@ -107,17 +109,18 @@ namespace Content.Server.Access.Components
var targetIdEntity = TargetIdContainer.ContainedEntity;
var targetIdComponent = targetIdEntity.GetComponent<IdCardComponent>();
targetIdComponent.FullName = newFullName;
targetIdComponent.JobTitle = newJobTitle;
var cardSystem = EntitySystem.Get<IdCardSystem>();
cardSystem.TryChangeFullName(targetIdEntity.Uid, newFullName);
cardSystem.TryChangeJobTitle(targetIdEntity.Uid, newJobTitle);
if (!newAccessList.TrueForAll(x => _prototypeManager.HasIndex<AccessLevelPrototype>(x)))
{
Logger.Warning("Tried to write unknown access tag.");
return;
}
var targetIdAccess = targetIdEntity.GetComponent<AccessComponent>();
targetIdAccess.SetTags(newAccessList);
var accessSystem = EntitySystem.Get<AccessSystem>();
accessSystem.TrySetTags(targetIdEntity.Uid, newAccessList);
}
/// <summary>

20
Content.Server/Access/Components/PresetIdCardComponent.cs
View File

@@ -7,27 +7,11 @@ using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Access.Components
{
[RegisterComponent]
public class PresetIdCardComponent : Component, IMapInit
public class PresetIdCardComponent : Component
{
public override string Name => "PresetIdCard";
[DataField("job")]
private string? _jobName;
void IMapInit.MapInit()
{
if (_jobName == null)
{
return;
}
var prototypes = IoCManager.Resolve<IPrototypeManager>();
var job = prototypes.Index<JobPrototype>(_jobName);
var access = Owner.GetComponent<AccessComponent>();
var idCard = Owner.GetComponent<IdCardComponent>();
access.SetTags(job.Access);
idCard.JobTitle = job.Name;
}
public readonly string? JobName;
}
}

119
Content.Server/Access/Systems/AccessReaderSystem.cs Normal file
View File

@@ -0,0 +1,119 @@
using Content.Server.Access.Components;
using Content.Server.Inventory.Components;
using Content.Server.Items;
using Content.Server.PDA;
using Content.Shared.Access;
using Content.Shared.Hands.Components;
using Content.Shared.Inventory;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Prototypes;
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
namespace Content.Server.Access.Systems
{
public class AccessReaderSystem : EntitySystem
{
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<AccessReader, ComponentInit>(OnInit);
}
private void OnInit(EntityUid uid, AccessReader reader, ComponentInit args)
{
var allTags = reader.AccessLists.SelectMany(c => c).Union(reader.DenyTags);
foreach (var level in allTags)
{
if (!_prototypeManager.HasIndex<AccessLevelPrototype>(level))
{
Logger.ErrorS("access", $"Invalid access level: {level}");
}
}
}
/// <summary>
/// Searches an <see cref="AccessComponent"/> in the entity itself, in its active hand or in its ID slot.
/// Then compares the found access with the configured access lists to see if it is allowed.
/// </summary>
/// <remarks>
/// If no access is found, an empty set is used instead.
/// </remarks>
/// <param name="entity">The entity to be searched for access.</param>
public bool IsAllowed(AccessReader reader, EntityUid entity)
{
var tags = FindAccessTags(entity);
return IsAllowed(reader, tags);
}
public bool IsAllowed(AccessReader reader, ICollection<string> accessTags)
{
if (reader.DenyTags.Overlaps(accessTags))
{
// Sec owned by cargo.
return false;
}
return reader.AccessLists.Count == 0 || reader.AccessLists.Any(a => a.IsSubsetOf(accessTags));
}
public ICollection<string> FindAccessTags(EntityUid uid)
{
// check entity itself
if (FindAccessTagsItem(uid, out var tags))
return tags;
// maybe access component inside its hands?
if (EntityManager.TryGetComponent(uid, out SharedHandsComponent? hands))
{
if (hands.TryGetActiveHeldEntity(out var heldItem) &&
FindAccessTagsItem(heldItem.Uid, out tags))
{
return tags;
}
}
// maybe its inside an inventory slot?
if (EntityManager.TryGetComponent(uid, out InventoryComponent? inventoryComponent))
{
if (inventoryComponent.HasSlot(EquipmentSlotDefines.Slots.IDCARD) &&
inventoryComponent.TryGetSlotItem(EquipmentSlotDefines.Slots.IDCARD, out ItemComponent? item) &&
FindAccessTagsItem(item.Owner.Uid, out tags)
)
{
return tags;
}
}
return Array.Empty<string>();
}
/// <summary>
/// Try to find <see cref="AccessComponent"/> on this item
/// or inside this item (if it's pda)
/// </summary>
private bool FindAccessTagsItem(EntityUid uid, [NotNullWhen(true)] out HashSet<string>? tags)
{
if (EntityManager.TryGetComponent(uid, out AccessComponent? access))
{
tags = access.Tags;
return true;
}
if (EntityManager.TryGetComponent(uid, out PDAComponent? pda))
{
tags = pda?.ContainedID?.Owner?.GetComponent<AccessComponent>()?.Tags;
return tags != null;
}
tags = null;
return false;
}
}
}

24
Content.Server/Access/Systems/AccessSystem.cs Normal file
View File

@@ -0,0 +1,24 @@
using Content.Server.Access.Components;
using Robust.Shared.GameObjects;
using System.Collections.Generic;
namespace Content.Server.Access.Systems
{
public class AccessSystem : EntitySystem
{
/// <summary>
/// Replaces the set of access tags we have with the provided set.
/// </summary>
/// <param name="newTags">The new access tags</param>
public bool TrySetTags(EntityUid uid, IEnumerable<string> newTags, AccessComponent? access = null)
{
if (!Resolve(uid, ref access))
return false;
access.Tags.Clear();
access.Tags.UnionWith(newTags);
return true;
}
}
}

70
Content.Server/Access/Systems/IdCardSystem.cs Normal file
View File

@@ -0,0 +1,70 @@
using Content.Server.Access.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Localization;
namespace Content.Server.Access.Systems
{
public class IdCardSystem : EntitySystem
{
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<IdCardComponent, ComponentInit>(OnInit);
}
private void OnInit(EntityUid uid, IdCardComponent id, ComponentInit args)
{
id.OriginalOwnerName ??= id.Owner.Name;
UpdateEntityName(uid, id);
}
public bool TryChangeJobTitle(EntityUid uid, string jobTitle, IdCardComponent? id = null)
{
if (!Resolve(uid, ref id))
return false;
id.JobTitle = jobTitle;
UpdateEntityName(uid, id);
return true;
}
public bool TryChangeFullName(EntityUid uid, string fullName, IdCardComponent? id = null)
{
if (!Resolve(uid, ref id))
return false;
id.FullName = fullName;
UpdateEntityName(uid, id);
return true;
}
/// <summary>
/// Changes the <see cref="Entity.Name"/> of <see cref="Component.Owner"/>.
/// </summary>
/// <remarks>
/// If either <see cref="FullName"/> or <see cref="JobTitle"/> is empty, it's replaced by placeholders.
/// If both are empty, the original entity's name is restored.
/// </remarks>
private void UpdateEntityName(EntityUid uid, IdCardComponent? id = null)
{
if (!Resolve(uid, ref id))
return;
if (string.IsNullOrWhiteSpace(id.FullName) && string.IsNullOrWhiteSpace(id.JobTitle))
{
id.Owner.Name = id.OriginalOwnerName;
return;
}
var jobSuffix = string.IsNullOrWhiteSpace(id.JobTitle) ? string.Empty : $" ({id.JobTitle})";
id.Owner.Name = string.IsNullOrWhiteSpace(id.FullName)
? Loc.GetString("access-id-card-component-owner-name-job-title-text",
("originalOwnerName", id.OriginalOwnerName),
("jobSuffix", jobSuffix))
: Loc.GetString("access-id-card-component-owner-full-name-job-title-text",
("fullName", id.FullName),
("jobSuffix", jobSuffix));
}
}
}

40
Content.Server/Access/Systems/PresetIdCardSystem.cs Normal file
View File

@@ -0,0 +1,40 @@
using Content.Server.Access.Components;
using Content.Shared.Roles;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Prototypes;
using System;
namespace Content.Server.Access.Systems
{
public class PresetIdCardSystem : EntitySystem
{
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly IdCardSystem _cardSystem = default!;
[Dependency] private readonly AccessSystem _accessSystem = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<PresetIdCardComponent, MapInitEvent>(OnMapInit);
}
private void OnMapInit(EntityUid uid, PresetIdCardComponent id, MapInitEvent args)
{
if (id.JobName == null) return;
if (!_prototypeManager.TryIndex(id.JobName, out JobPrototype? job))
{
Logger.ErrorS("access", $"Invalid job id ({id.JobName}) for preset card");
return;
}
// set access for access component
_accessSystem.TrySetTags(uid, job.Access);
// and also change job title on a card id
_cardSystem.TryChangeJobTitle(uid, job.Name);
}
}
}

9
Content.Server/Doors/Components/ServerDoorComponent.cs
View File

@@ -4,6 +4,7 @@ using System.Threading;
using System.Threading.Tasks;
using Content.Server.Access;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.Atmos.Components;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Construction.Components;
@@ -311,12 +312,13 @@ namespace Content.Server.Doors.Components
var doorSystem = EntitySystem.Get<DoorSystem>();
var isAirlockExternal = HasAccessType("External");
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
return doorSystem.AccessType switch
{
DoorSystem.AccessTypes.AllowAll => true,
DoorSystem.AccessTypes.AllowAllIdExternal => isAirlockExternal || access.IsAllowed(user),
DoorSystem.AccessTypes.AllowAllIdExternal => isAirlockExternal || accessSystem.IsAllowed(access, user.Uid),
DoorSystem.AccessTypes.AllowAllNoExternal => !isAirlockExternal,
_ => access.IsAllowed(user)
_ => accessSystem.IsAllowed(access, user.Uid)
};
}
@@ -430,7 +432,8 @@ namespace Content.Server.Doors.Components
return true;
}
return access.IsAllowed(user);
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
return accessSystem.IsAllowed(access, user.Uid);
}
/// <summary>

9
Content.Server/GameTicking/GameTicker.Spawning.cs
View File

@@ -2,6 +2,8 @@ using System;
using System.Collections.Generic;
using System.Globalization;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.CharacterAppearance.Components;
using Content.Server.Ghost.Components;
using Content.Server.Hands.Components;
using Content.Server.Inventory.Components;
@@ -19,6 +21,7 @@ using Content.Shared.Preferences;
using Content.Shared.Roles;
using Robust.Server.Player;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Map;
using Robust.Shared.Random;
@@ -32,6 +35,8 @@ namespace Content.Server.GameTicking
private const string PlayerPrototypeName = "MobHuman";
private const string ObserverPrototypeName = "MobObserver";
[Dependency] private readonly IdCardSystem _cardSystem = default!;
[ViewVariables(VVAccess.ReadWrite)]
private EntityCoordinates _spawnPoint;
@@ -228,8 +233,8 @@ namespace Content.Server.GameTicking
return;
var card = pdaComponent.ContainedID;
card.FullName = characterName;
card.JobTitle = jobPrototype.Name;
_cardSystem.TryChangeFullName(card.Owner.Uid, characterName, card);
_cardSystem.TryChangeJobTitle(card.Owner.Uid, jobPrototype.Name, card);
var access = card.Owner.GetComponent<AccessComponent>();
var accessTags = access.Tags;

6
Content.Server/Lock/LockSystem.cs
View File

@@ -1,4 +1,5 @@
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.Storage.Components;
using Content.Shared.Examine;
using Content.Shared.Interaction;
@@ -9,6 +10,7 @@ using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Player;
@@ -20,6 +22,8 @@ namespace Content.Server.Lock
[UsedImplicitly]
public class LockSystem : EntitySystem
{
[Dependency] private readonly AccessReaderSystem _accessReader = default!;
/// <inheritdoc />
public override void Initialize()
{
@@ -144,7 +148,7 @@ namespace Content.Server.Lock
if (!Resolve(uid, ref reader))
return true;
if (!reader.IsAllowed(user))
if (!_accessReader.IsAllowed(reader, user.Uid))
{
if (!quiet)
reader.Owner.PopupMessage(user, Loc.GetString("lock-comp-has-user-access-fail"));

27
Content.Server/PDA/PDAComponent.cs
View File

@@ -8,8 +8,7 @@ using Robust.Shared.ViewVariables;
namespace Content.Server.PDA
{
[RegisterComponent]
[ComponentReference(typeof(IAccess))]
public class PDAComponent : Component, IAccess
public class PDAComponent : Component
{
public override string Name => "PDA";
@@ -26,29 +25,5 @@ namespace Content.Server.PDA
[ViewVariables] public bool FlashlightOn;
[ViewVariables] public string? OwnerName;
// TODO: Move me to ECS after Access refactoring
#region Acces Logic
[ViewVariables] private readonly PDAAccessSet _accessSet;
public PDAComponent()
{
_accessSet = new PDAAccessSet(this);
}
public ISet<string>? GetContainedAccess()
{
return ContainedID?.Owner?.GetComponent<AccessComponent>()?.Tags;
}
ISet<string> IAccess.Tags => _accessSet;
bool IAccess.IsReadOnly => true;
void IAccess.SetTags(IEnumerable<string> newTags)
{
throw new NotSupportedException("PDA access list is read-only.");
}
#endregion
}
}

118
Content.Server/PDA/PdaAccessSet.cs
View File

@@ -1,118 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
namespace Content.Server.PDA
{
public sealed class PDAAccessSet : ISet<string>
{
private readonly PDAComponent _pdaComponent;
private static readonly HashSet<string> EmptySet = new();
public PDAAccessSet(PDAComponent pdaComponent)
{
_pdaComponent = pdaComponent;
}
public IEnumerator<string> GetEnumerator()
{
var contained = _pdaComponent.GetContainedAccess() ?? EmptySet;
return contained.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
void ICollection<string>.Add(string item)
{
throw new NotSupportedException("PDA access list is read-only.");
}
public void ExceptWith(IEnumerable<string> other)
{
throw new NotSupportedException("PDA access list is read-only.");
}
public void IntersectWith(IEnumerable<string> other)
{
throw new NotSupportedException("PDA access list is read-only.");
}
public bool IsProperSubsetOf(IEnumerable<string> other)
{
var set = _pdaComponent.GetContainedAccess() ?? EmptySet;
return set.IsProperSubsetOf(other);
}
public bool IsProperSupersetOf(IEnumerable<string> other)
{
var set = _pdaComponent.GetContainedAccess() ?? EmptySet;
return set.IsProperSupersetOf(other);
}
public bool IsSubsetOf(IEnumerable<string> other)
{
var set = _pdaComponent.GetContainedAccess() ?? EmptySet;
return set.IsSubsetOf(other);
}
public bool IsSupersetOf(IEnumerable<string> other)
{
var set = _pdaComponent.GetContainedAccess() ?? EmptySet;
return set.IsSupersetOf(other);
}
public bool Overlaps(IEnumerable<string> other)
{
var set = _pdaComponent.GetContainedAccess() ?? EmptySet;
return set.Overlaps(other);
}
public bool SetEquals(IEnumerable<string> other)
{
var set = _pdaComponent.GetContainedAccess() ?? EmptySet;
return set.SetEquals(other);
}
public void SymmetricExceptWith(IEnumerable<string> other)
{
throw new NotSupportedException("PDA access list is read-only.");
}
public void UnionWith(IEnumerable<string> other)
{
throw new NotSupportedException("PDA access list is read-only.");
}
bool ISet<string>.Add(string item)
{
throw new NotSupportedException("PDA access list is read-only.");
}
public void Clear()
{
throw new NotSupportedException("PDA access list is read-only.");
}
public bool Contains(string item)
{
return _pdaComponent.GetContainedAccess()?.Contains(item) ?? false;
}
public void CopyTo(string[] array, int arrayIndex)
{
var set = _pdaComponent.GetContainedAccess() ?? EmptySet;
set.CopyTo(array, arrayIndex);
}
public bool Remove(string item)
{
throw new NotSupportedException("PDA access list is read-only.");
}
public int Count => _pdaComponent.GetContainedAccess()?.Count ?? 0;
public bool IsReadOnly => true;
}
}

4
Content.Server/Power/Components/ApcComponent.cs
View File

@@ -1,5 +1,6 @@
using System;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.Power.NodeGroups;
using Content.Server.UserInterface;
using Content.Shared.APC;
@@ -91,7 +92,8 @@ namespace Content.Server.Power.Components
var user = serverMsg.Session.AttachedEntity;
if (user == null) return;
if (_accessReader == null || _accessReader.IsAllowed(user))
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
if (_accessReader == null || accessSystem.IsAllowed(_accessReader, user.Uid))
{
MainBreakerEnabled = !MainBreakerEnabled;
Owner.GetComponent<PowerNetworkBatteryComponent>().CanDischarge = MainBreakerEnabled;

5
Content.Server/Sandbox/SandboxManager.cs
View File

@@ -19,6 +19,7 @@ using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Robust.Shared.ViewVariables;
using static Content.Shared.Inventory.EquipmentSlotDefines;
using Content.Server.Access.Systems;
namespace Content.Server.Sandbox
{
@@ -158,8 +159,8 @@ namespace Content.Server.Sandbox
void UpgradeId(IEntity id)
{
var access = id.GetComponent<AccessComponent>();
access.SetTags(allAccess);
var accessSystem = EntitySystem.Get<AccessSystem>();
accessSystem.TrySetTags(id.Uid, allAccess);
if (id.TryGetComponent(out SpriteComponent? sprite))
{

8
Content.Server/Singularity/EntitySystems/EmitterSystem.cs
View File

@@ -1,6 +1,7 @@
using System;
using System;
using System.Threading;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.Power.EntitySystems;
using Content.Server.Projectiles.Components;
using Content.Server.Singularity.Components;
@@ -26,6 +27,7 @@ namespace Content.Server.Singularity.EntitySystems
public class EmitterSystem : EntitySystem
{
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly AccessReaderSystem _accessReader = default!;
public override void Initialize()
{
@@ -40,12 +42,12 @@ namespace Content.Server.Singularity.EntitySystems
{
if(args.Handled) return;
if (component.AccessReader == null || !args.Used.TryGetComponent(out IAccess? access))
if (component.AccessReader == null)
{
return;
}
if (component.AccessReader.IsAllowed(access))
if (_accessReader.IsAllowed(component.AccessReader, args.Used.Uid))
{
component.IsLocked ^= true;

4
Content.Server/VendingMachines/VendingMachineComponent.cs
View File

@@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.Linq;
using Content.Server.Access.Components;
using Content.Server.Access.Systems;
using Content.Server.Advertise;
using Content.Server.Popups;
using Content.Server.Power.Components;
@@ -191,7 +192,8 @@ namespace Content.Server.VendingMachines
{
if (Owner.TryGetComponent<AccessReader>(out var accessReader))
{
if (sender == null || !accessReader.IsAllowed(sender))
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
if (sender == null || !accessSystem.IsAllowed(accessReader, sender.Uid))
{
Owner.PopupMessageEveryone(Loc.GetString("vending-machine-component-try-eject-access-denied"));
Deny();

85
Content.Tests/Server/GameObjects/Components/Access/AccessReaderTest.cs
View File

@@ -1,85 +0,0 @@
using System.Collections.Generic;
using Content.Server.Access.Components;
using NUnit.Framework;
namespace Content.Tests.Server.GameObjects.Components.Access
{
[TestFixture]
[TestOf(typeof(AccessReader))]
public class AccessReaderTest : ContentUnitTest
{
[Test]
public void TestEmpty()
{
var reader = new AccessReader();
Assert.That(reader.IsAllowed(new[] {"Foo"}), Is.True);
Assert.That(reader.IsAllowed(new[] {"Bar"}), Is.True);
Assert.That(reader.IsAllowed(new string[] {}), Is.True);
}
[Test]
public void TestDeny()
{
var reader = new AccessReader();
reader.DenyTags.Add("A");
Assert.That(reader.IsAllowed(new[] {"Foo"}), Is.True);
Assert.That(reader.IsAllowed(new[] {"A"}), Is.False);
Assert.That(reader.IsAllowed(new[] {"A", "Foo"}), Is.False);
Assert.That(reader.IsAllowed(new string[] {}), Is.True);
}
[Test]
public void TestOneList()
{
var reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> {"A"});
Assert.That(reader.IsAllowed(new[] {"A"}), Is.True);
Assert.That(reader.IsAllowed(new[] {"B"}), Is.False);
Assert.That(reader.IsAllowed(new[] {"A", "B"}), Is.True);
Assert.That(reader.IsAllowed(new string[] {}), Is.False);
}
[Test]
public void TestOneListTwoItems()
{
var reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> {"A", "B"});
Assert.That(reader.IsAllowed(new[] {"A"}), Is.False);
Assert.That(reader.IsAllowed(new[] {"B"}), Is.False);
Assert.That(reader.IsAllowed(new[] {"A", "B"}), Is.True);
Assert.That(reader.IsAllowed(new string[] {}), Is.False);
}
[Test]
public void TestTwoList()
{
var reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> {"A"});
reader.AccessLists.Add(new HashSet<string> {"B", "C"});
Assert.That(reader.IsAllowed(new[] {"A"}), Is.True);
Assert.That(reader.IsAllowed(new[] {"B"}), Is.False);
Assert.That(reader.IsAllowed(new[] {"A", "B"}), Is.True);
Assert.That(reader.IsAllowed(new[] {"C", "B"}), Is.True);
Assert.That(reader.IsAllowed(new[] {"C", "B", "A"}), Is.True);
Assert.That(reader.IsAllowed(new string[] {}), Is.False);
}
[Test]
public void TestDenyList()
{
var reader = new AccessReader();
reader.AccessLists.Add(new HashSet<string> {"A"});
reader.DenyTags.Add("B");
Assert.That(reader.IsAllowed(new[] {"A"}), Is.True);
Assert.That(reader.IsAllowed(new[] {"B"}), Is.False);
Assert.That(reader.IsAllowed(new[] {"A", "B"}), Is.False);
Assert.That(reader.IsAllowed(new string[] {}), Is.False);
}
}
}