JobRequiremet refactor (#579)

* JobRequirement refactor (#30347)

* refactor JobRequirements

* add profile support

* fix

* Update quartermaster.yml

* sloth fixes

* inport 30208

* Update DepartmentPrototype.cs

* species restriction

* left tweak stick

* stringbuilder is cool!

* Add JobRequirementOverride prototypes (#28607)

* Add JobRequirementOverride prototypes

* a

* invert if

* Add override that takes in prototypes directly

* - fix: Errors.

* - add: Add stuff.

* - fix: Formatted message fix.

* - add: Another requirement.

---------

Co-authored-by: Ed <96445749+TheShuEd@users.noreply.github.com>
Co-authored-by: Leon Friedrich <60421075+ElectroJr@users.noreply.github.com>

Content.Shared/Roles/AntagPrototype.cs

@@ -41,6 +41,8 @@ public sealed partial class AntagPrototype : IPrototype
     /// <summary>
     ///     Requirements that must be met to opt in to this antag role.
     /// </summary>
-    [DataField("requirements")]
+    // TODO ROLE TIMERS
+    // Actually check if the requirements are met. Because apparently this is actually unused.
+    [DataField]
     public HashSet<JobRequirement>? Requirements;
 }

Content.Shared/Roles/DepartmentPrototype.cs

@@ -9,16 +9,16 @@ public sealed partial class DepartmentPrototype : IPrototype
     [IdDataField] public string ID { get; } = default!;
 
     /// <summary>
-    ///     A name string.
+    /// The name LocId of the department that will be displayed in the various menus.
     /// </summary>
     [DataField(required: true)]
-    public string Name = default!;
+    public LocId Name = string.Empty;
 
     /// <summary>
-    ///     A description string to display in the character menu as an explanation of the department's function.
+    /// A description LocId to display in the character menu as an explanation of the department's function.
     /// </summary>
-    [DataField (required: true)]
-    public string Description = default!;
+    [DataField(required: true)]
+    public LocId Description = string.Empty;
 
     /// <summary>
     ///     A color representing this department to use for text.
@@ -26,8 +26,8 @@ public sealed partial class DepartmentPrototype : IPrototype
     [DataField(required: true)]
     public Color Color = default!;
 
-    [ViewVariables(VVAccess.ReadWrite), DataField(customTypeSerializer: typeof(PrototypeIdListSerializer<JobPrototype>))]
-    public List<string> Roles = new();
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public List<ProtoId<JobPrototype>> Roles = new();
 
     /// <summary>
     /// Whether this is a primary department or not.

Content.Shared/Roles/JobRequirement/AgeRequirement.cs

@@ -0,0 +1,50 @@
+using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Preferences;
+using JetBrains.Annotations;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Roles;
+
+/// <summary>
+/// Requires the character to be older or younger than a certain age (inclusive)
+/// </summary>
+[UsedImplicitly]
+[Serializable, NetSerializable]
+public sealed partial class AgeRequirement : JobRequirement
+{
+    [DataField(required: true)]
+    public int RequiredAge;
+
+    public override bool Check(IEntityManager entManager,
+        IPrototypeManager protoManager,
+        HumanoidCharacterProfile? profile,
+        IReadOnlyDictionary<string, TimeSpan> playTimes,
+        [NotNullWhen(false)] out FormattedMessage? reason)
+    {
+        reason = new FormattedMessage();
+
+        if (profile is null) //the profile could be null if the player is a ghost. In this case we don't need to block the role selection for ghostrole
+            return true;
+
+        if (!Inverted)
+        {
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString("role-timer-age-to-young",
+                ("age", RequiredAge)));
+
+            if (profile.Age <= RequiredAge)
+                return false;
+        }
+        else
+        {
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString("role-timer-age-to-old",
+                ("age", RequiredAge)));
+
+            if (profile.Age >= RequiredAge)
+                return false;
+        }
+
+        return true;
+    }
+}

Content.Shared/Roles/JobRequirement/DepartmentTimeRequirement.cs

@@ -0,0 +1,83 @@
+using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Preferences;
+using JetBrains.Annotations;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Roles;
+
+[UsedImplicitly]
+[Serializable, NetSerializable]
+public sealed partial class DepartmentTimeRequirement : JobRequirement
+{
+    /// <summary>
+    /// Which department needs the required amount of time.
+    /// </summary>
+    [DataField(required: true)]
+    public ProtoId<DepartmentPrototype> Department = default!;
+
+    /// <summary>
+    /// How long (in seconds) this requirement is.
+    /// </summary>
+    [DataField(required: true)]
+    public TimeSpan Time;
+
+    public override bool Check(IEntityManager entManager,
+        IPrototypeManager protoManager,
+        HumanoidCharacterProfile? profile,
+        IReadOnlyDictionary<string, TimeSpan> playTimes,
+        [NotNullWhen(false)] out FormattedMessage? reason)
+    {
+        reason = new FormattedMessage();
+        var playtime = TimeSpan.Zero;
+
+        // Check all jobs' departments
+        var department = protoManager.Index(Department);
+        var jobs = department.Roles;
+        string proto;
+
+        // Check all jobs' playtime
+        foreach (var other in jobs)
+        {
+            // The schema is stored on the Job role but we want to explode if the timer isn't found anyway.
+            proto = protoManager.Index(other).PlayTimeTracker;
+
+            playTimes.TryGetValue(proto, out var otherTime);
+            playtime += otherTime;
+        }
+
+        var deptDiff = Time.TotalMinutes - playtime.TotalMinutes;
+        var nameDepartment = "role-timer-department-unknown";
+
+        if (protoManager.TryIndex(Department, out var departmentIndexed))
+        {
+            nameDepartment = departmentIndexed.Name;
+        }
+
+        if (!Inverted)
+        {
+            if (deptDiff <= 0)
+                return true;
+
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString(
+                "role-timer-department-insufficient",
+                ("time", Math.Ceiling(deptDiff)),
+                ("department", Loc.GetString(nameDepartment)),
+                ("departmentColor", department.Color.ToHex())));
+            return false;
+        }
+
+        if (deptDiff <= 0)
+        {
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString(
+                "role-timer-department-too-high",
+                ("time", -deptDiff),
+                ("department", Loc.GetString(nameDepartment)),
+                ("departmentColor", department.Color.ToHex())));
+            return false;
+        }
+
+        return true;
+    }
+}

Content.Shared/Roles/JobRequirement/OverallPlaytimeRequirement.cs

@@ -0,0 +1,50 @@
+using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Players.PlayTimeTracking;
+using Content.Shared.Preferences;
+using JetBrains.Annotations;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Roles;
+
+[UsedImplicitly]
+[Serializable, NetSerializable]
+public sealed partial class OverallPlaytimeRequirement : JobRequirement
+{
+    /// <inheritdoc cref="DepartmentTimeRequirement.Time"/>
+    [DataField(required: true)]
+    public TimeSpan Time;
+
+    public override bool Check(IEntityManager entManager,
+        IPrototypeManager protoManager,
+        HumanoidCharacterProfile? profile,
+        IReadOnlyDictionary<string, TimeSpan> playTimes,
+        [NotNullWhen(false)] out FormattedMessage? reason)
+    {
+        reason = new FormattedMessage();
+
+        var overallTime = playTimes.GetValueOrDefault(PlayTimeTrackingShared.TrackerOverall);
+        var overallDiff = Time.TotalMinutes - overallTime.TotalMinutes;
+
+        if (!Inverted)
+        {
+            if (overallDiff <= 0 || overallTime >= Time)
+                return true;
+
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString(
+                "role-timer-overall-insufficient",
+                ("time", Math.Ceiling(overallDiff))));
+            return false;
+        }
+
+        if (overallDiff <= 0 || overallTime >= Time)
+        {
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString("role-timer-overall-too-high",
+                ("time", -overallDiff)));
+            return false;
+        }
+
+        return true;
+    }
+}

Content.Shared/Roles/JobRequirement/RoleTimeRequirement.cs

@@ -0,0 +1,73 @@
+using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Players.PlayTimeTracking;
+using Content.Shared.Preferences;
+using Content.Shared.Roles.Jobs;
+using JetBrains.Annotations;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Roles;
+
+[UsedImplicitly]
+[Serializable, NetSerializable]
+public sealed partial class RoleTimeRequirement : JobRequirement
+{
+    /// <summary>
+    /// What particular role they need the time requirement with.
+    /// </summary>
+    [DataField(required: true)]
+    public ProtoId<PlayTimeTrackerPrototype> Role = default!;
+
+    /// <inheritdoc cref="DepartmentTimeRequirement.Time"/>
+    [DataField(required: true)]
+    public TimeSpan Time;
+
+    public override bool Check(IEntityManager entManager,
+        IPrototypeManager protoManager,
+        HumanoidCharacterProfile? profile,
+        IReadOnlyDictionary<string, TimeSpan> playTimes,
+        [NotNullWhen(false)] out FormattedMessage? reason)
+    {
+        reason = new FormattedMessage();
+
+        string proto = Role;
+
+        playTimes.TryGetValue(proto, out var roleTime);
+        var roleDiff = Time.TotalMinutes - roleTime.TotalMinutes;
+        var departmentColor = Color.Yellow;
+
+        if (entManager.EntitySysManager.TryGetEntitySystem(out SharedJobSystem? jobSystem))
+        {
+            var jobProto = jobSystem.GetJobPrototype(proto);
+
+            if (jobSystem.TryGetDepartment(jobProto, out var departmentProto))
+                departmentColor = departmentProto.Color;
+        }
+
+        if (!Inverted)
+        {
+            if (roleDiff <= 0)
+                return true;
+
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString(
+                "role-timer-role-insufficient",
+                ("time", Math.Ceiling(roleDiff)),
+                ("job", Loc.GetString(proto)),
+                ("departmentColor", departmentColor.ToHex())));
+            return false;
+        }
+
+        if (roleDiff <= 0)
+        {
+            reason = FormattedMessage.FromMarkupPermissive(Loc.GetString(
+                "role-timer-role-too-high",
+                ("time", -roleDiff),
+                ("job", Loc.GetString(proto)),
+                ("departmentColor", departmentColor.ToHex())));
+            return false;
+        }
+
+        return true;
+    }
+}

Content.Shared/Roles/JobRequirement/SpeciesRequirement.cs

@@ -0,0 +1,59 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using Content.Shared.Humanoid.Prototypes;
+using Content.Shared.Preferences;
+using JetBrains.Annotations;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Roles;
+
+/// <summary>
+/// Requires the character to be or not be on the list of specified species
+/// </summary>
+[UsedImplicitly]
+[Serializable, NetSerializable]
+public sealed partial class SpeciesRequirement : JobRequirement
+{
+    [DataField(required: true)]
+    public HashSet<ProtoId<SpeciesPrototype>> Species = new();
+
+    public override bool Check(IEntityManager entManager,
+        IPrototypeManager protoManager,
+        HumanoidCharacterProfile? profile,
+        IReadOnlyDictionary<string, TimeSpan> playTimes,
+        [NotNullWhen(false)] out FormattedMessage? reason)
+    {
+        reason = new FormattedMessage();
+
+        if (profile is null) //the profile could be null if the player is a ghost. In this case we don't need to block the role selection for ghostrole
+            return true;
+
+        var sb = new StringBuilder();
+        sb.Append("[color=yellow]");
+        foreach (var s in Species)
+        {
+            sb.Append(Loc.GetString(protoManager.Index(s).Name) + " ");
+        }
+
+        sb.Append("[/color]");
+
+        if (!Inverted)
+        {
+            reason = FormattedMessage.FromMarkupPermissive($"{Loc.GetString("role-timer-whitelisted-species")}\n{sb}");
+
+            if (!Species.Contains(profile.Species))
+                return false;
+        }
+        else
+        {
+            reason = FormattedMessage.FromMarkupPermissive($"{Loc.GetString("role-timer-blacklisted-species")}\n{sb}");
+
+            if (Species.Contains(profile.Species))
+                return false;
+        }
+
+        return true;
+    }
+}

Content.Shared/Roles/JobRequirementOverridePrototype.cs

@@ -0,0 +1,20 @@
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Roles;
+
+/// <summary>
+/// Collection of job, antag, and ghost-role job requirements for per-server requirement overrides.
+/// </summary>
+[Prototype]
+public sealed partial class JobRequirementOverridePrototype : IPrototype
+{
+    [ViewVariables]
+    [IdDataField]
+    public string ID { get; private set; } = default!;
+
+    [DataField]
+    public Dictionary<ProtoId<JobPrototype>, HashSet<JobRequirement>> Jobs = new ();
+
+    [DataField]
+    public Dictionary<ProtoId<AntagPrototype>, HashSet<JobRequirement>> Antags = new ();
+}

Content.Shared/Roles/JobRequirements.cs

@@ -1,226 +1,51 @@
 using System.Diagnostics.CodeAnalysis;
-using Content.Shared.Players.PlayTimeTracking;
-using Content.Shared.Roles.Jobs;
-using JetBrains.Annotations;
+using Content.Shared.Preferences;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 using Robust.Shared.Utility;
 
-namespace Content.Shared.Roles
+namespace Content.Shared.Roles;
+
+public static class JobRequirements
 {
-    /// <summary>
-    /// Abstract class for playtime and other requirements for role gates.
-    /// </summary>
-    [ImplicitDataDefinitionForInheritors]
-    [Serializable, NetSerializable]
-    public abstract partial class JobRequirement{}
-
-    [UsedImplicitly]
-    [Serializable, NetSerializable]
-    public sealed partial class DepartmentTimeRequirement : JobRequirement
+    public static bool TryRequirementsMet(
+        JobPrototype job,
+        IReadOnlyDictionary<string, TimeSpan> playTimes,
+        [NotNullWhen(false)] out FormattedMessage? reason,
+        IEntityManager entManager,
+        IPrototypeManager protoManager,
+        HumanoidCharacterProfile? profile)
     {
-        /// <summary>
-        /// Which department needs the required amount of time.
-        /// </summary>
-        [DataField("department", customTypeSerializer: typeof(PrototypeIdSerializer<DepartmentPrototype>))]
-        public string Department = default!;
-
-        /// <summary>
-        /// How long (in seconds) this requirement is.
-        /// </summary>
-        [DataField("time")] public TimeSpan Time;
-
-        /// <summary>
-        /// If true, requirement will return false if playtime above the specified time.
-        /// </summary>
-        /// <value>
-        /// <c>False</c> by default.<br />
-        /// <c>True</c> for invert general requirement
-        /// </value>
-        [DataField("inverted")] public bool Inverted;
-    }
-
-    [UsedImplicitly]
-    [Serializable, NetSerializable]
-    public sealed partial class RoleTimeRequirement : JobRequirement
-    {
-        /// <summary>
-        /// What particular role they need the time requirement with.
-        /// </summary>
-        [DataField("role", customTypeSerializer: typeof(PrototypeIdSerializer<PlayTimeTrackerPrototype>))]
-        public string Role = default!;
-
-        /// <inheritdoc cref="DepartmentTimeRequirement.Time"/>
-        [DataField("time")] public TimeSpan Time;
-
-        /// <inheritdoc cref="DepartmentTimeRequirement.Inverted"/>
-        [DataField("inverted")] public bool Inverted;
-    }
-
-    [UsedImplicitly]
-    [Serializable, NetSerializable]
-    public sealed partial class OverallPlaytimeRequirement : JobRequirement
-    {
-        /// <inheritdoc cref="DepartmentTimeRequirement.Time"/>
-        [DataField("time")] public TimeSpan Time;
-
-        /// <inheritdoc cref="DepartmentTimeRequirement.Inverted"/>
-        [DataField("inverted")] public bool Inverted;
-    }
-
-    public static class JobRequirements
-    {
-        public static bool TryRequirementsMet(
-            JobPrototype job,
-            Dictionary<string, TimeSpan> playTimes,
-            [NotNullWhen(false)] out FormattedMessage? reason,
-            IEntityManager entManager,
-            IPrototypeManager prototypes)
-        {
-            reason = null;
-            if (job.Requirements == null)
-                return true;
-
-            foreach (var requirement in job.Requirements)
-            {
-                if (!TryRequirementMet(requirement, playTimes, out reason, entManager, prototypes))
-                    return false;
-            }
-
+        var sys = entManager.System<SharedRoleSystem>();
+        var requirements = sys.GetJobRequirement(job);
+        reason = null;
+        if (requirements == null)
             return true;
-        }
 
-        /// <summary>
-        /// Returns a string with the reason why a particular requirement may not be met.
-        /// </summary>
-        public static bool TryRequirementMet(
-            JobRequirement requirement,
-            IReadOnlyDictionary<string, TimeSpan> playTimes,
-            [NotNullWhen(false)] out FormattedMessage? reason,
-            IEntityManager entManager,
-            IPrototypeManager prototypes)
+        foreach (var requirement in requirements)
         {
-            reason = null;
-
-            switch (requirement)
-            {
-                case DepartmentTimeRequirement deptRequirement:
-                    var playtime = TimeSpan.Zero;
-
-                    // Check all jobs' departments
-                    var department = prototypes.Index<DepartmentPrototype>(deptRequirement.Department);
-                    var jobs = department.Roles;
-                    string proto;
-
-                    // Check all jobs' playtime
-                    foreach (var other in jobs)
-                    {
-                        // The schema is stored on the Job role but we want to explode if the timer isn't found anyway.
-                        proto = prototypes.Index<JobPrototype>(other).PlayTimeTracker;
-
-                        playTimes.TryGetValue(proto, out var otherTime);
-                        playtime += otherTime;
-                    }
-
-                    var deptDiff = deptRequirement.Time.TotalMinutes - playtime.TotalMinutes;
-
-                    if (!deptRequirement.Inverted)
-                    {
-                        if (deptDiff <= 0)
-                            return true;
-
-                        reason = FormattedMessage.FromMarkup(Loc.GetString(
-                            "role-timer-department-insufficient",
-                            ("time", Math.Ceiling(deptDiff)),
-                            ("department", Loc.GetString(deptRequirement.Department)),
-                            ("departmentColor", department.Color.ToHex())));
-                        return false;
-                    }
-                    else
-                    {
-                        if (deptDiff <= 0)
-                        {
-                            reason = FormattedMessage.FromMarkup(Loc.GetString(
-                                "role-timer-department-too-high",
-                                ("time", -deptDiff),
-                                ("department", Loc.GetString(deptRequirement.Department)),
-                                ("departmentColor", department.Color.ToHex())));
-                            return false;
-                        }
-
-                        return true;
-                    }
-
-                case OverallPlaytimeRequirement overallRequirement:
-                    var overallTime = playTimes.GetValueOrDefault(PlayTimeTrackingShared.TrackerOverall);
-                    var overallDiff = overallRequirement.Time.TotalMinutes - overallTime.TotalMinutes;
-
-                    if (!overallRequirement.Inverted)
-                    {
-                        if (overallDiff <= 0 || overallTime >= overallRequirement.Time)
-                            return true;
-
-                        reason = FormattedMessage.FromMarkup(Loc.GetString(
-                              "role-timer-overall-insufficient",
-                              ("time", Math.Ceiling(overallDiff))));
-                        return false;
-                    }
-                    else
-                    {
-                        if (overallDiff <= 0 || overallTime >= overallRequirement.Time)
-                        {
-                            reason = FormattedMessage.FromMarkup(Loc.GetString("role-timer-overall-too-high", ("time", -overallDiff)));
-                            return false;
-                        }
-
-                        return true;
-                    }
-
-                case RoleTimeRequirement roleRequirement:
-                    proto = roleRequirement.Role;
-
-                    playTimes.TryGetValue(proto, out var roleTime);
-                    var roleDiff = roleRequirement.Time.TotalMinutes - roleTime.TotalMinutes;
-                    var departmentColor = Color.Yellow;
-
-                    if (entManager.EntitySysManager.TryGetEntitySystem(out SharedJobSystem? jobSystem))
-                    {
-                        var jobProto = jobSystem.GetJobPrototype(proto);
-
-                        if (jobSystem.TryGetDepartment(jobProto, out var departmentProto))
-                            departmentColor = departmentProto.Color;
-                    }
-
-                    if (!roleRequirement.Inverted)
-                    {
-                        if (roleDiff <= 0)
-                            return true;
-
-                        reason = FormattedMessage.FromMarkup(Loc.GetString(
-                            "role-timer-role-insufficient",
-                            ("time", Math.Ceiling(roleDiff)),
-                            ("job", Loc.GetString(proto)),
-                            ("departmentColor", departmentColor.ToHex())));
-                        return false;
-                    }
-                    else
-                    {
-                        if (roleDiff <= 0)
-                        {
-                            reason = FormattedMessage.FromMarkup(Loc.GetString(
-                                "role-timer-role-too-high",
-                                ("time", -roleDiff),
-                                ("job", Loc.GetString(proto)),
-                                ("departmentColor", departmentColor.ToHex())));
-                            return false;
-                        }
-
-                        return true;
-                    }
-                default:
-                    throw new NotImplementedException();
-            }
+            if (!requirement.Check(entManager, protoManager, profile, playTimes, out reason))
+                return false;
         }
+
+        return true;
     }
 }
+
+/// <summary>
+/// Abstract class for playtime and other requirements for role gates.
+/// </summary>
+[ImplicitDataDefinitionForInheritors]
+[Serializable, NetSerializable]
+public abstract partial class JobRequirement
+{
+    [DataField]
+    public bool Inverted;
+
+    public abstract bool Check(
+        IEntityManager entManager,
+        IPrototypeManager protoManager,
+        HumanoidCharacterProfile? profile,
+        IReadOnlyDictionary<string, TimeSpan> playTimes,
+        [NotNullWhen(false)] out FormattedMessage? reason);
+}

Content.Shared/Roles/SharedRoleSystem.cs

@@ -1,9 +1,12 @@
 using Content.Shared.Administration.Logs;
+using Content.Shared.CCVar;
 using Content.Shared.Database;
+using Content.Shared.Ghost.Roles;
 using Content.Shared.Mind;
 using Content.Shared.Roles.Jobs;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Systems;
+using Robust.Shared.Configuration;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
 
@@ -15,14 +18,30 @@ public abstract class SharedRoleSystem : EntitySystem
     [Dependency] private readonly IPrototypeManager _prototypes = default!;
     [Dependency] private readonly SharedAudioSystem _audio = default!;
     [Dependency] private readonly SharedMindSystem _minds = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
 
     // TODO please lord make role entities
     private readonly HashSet<Type> _antagTypes = new();
 
+    private JobRequirementOverridePrototype? _requirementOverride;
+
     public override void Initialize()
     {
         // TODO make roles entities
         SubscribeLocalEvent<JobComponent, MindGetAllRolesEvent>(OnJobGetAllRoles);
+        Subs.CVar(_cfg, CCVars.GameRoleTimerOverride, SetRequirementOverride, true);
+    }
+
+    private void SetRequirementOverride(string value)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            _requirementOverride = null;
+            return;
+        }
+
+        if (!_prototypes.TryIndex(value, out _requirementOverride ))
+            Log.Error($"Unknown JobRequirementOverridePrototype: {value}");
     }
 
     private void OnJobGetAllRoles(EntityUid uid, JobComponent component, ref MindGetAllRolesEvent args)
@@ -186,4 +205,36 @@ public abstract class SharedRoleSystem : EntitySystem
         if (Resolve(mindId, ref mind) && mind.Session != null)
             _audio.PlayGlobal(sound, mind.Session);
     }
+
+    public HashSet<JobRequirement>? GetJobRequirement(JobPrototype job)
+    {
+        if (_requirementOverride != null && _requirementOverride.Jobs.TryGetValue(job.ID, out var req))
+            return req;
+
+        return job.Requirements;
+    }
+
+    public HashSet<JobRequirement>? GetJobRequirement(ProtoId<JobPrototype> job)
+    {
+        if (_requirementOverride != null && _requirementOverride.Jobs.TryGetValue(job, out var req))
+            return req;
+
+        return _prototypes.Index(job).Requirements;
+    }
+
+    public HashSet<JobRequirement>? GetAntagRequirement(ProtoId<AntagPrototype> antag)
+    {
+        if (_requirementOverride != null && _requirementOverride.Antags.TryGetValue(antag, out var req))
+            return req;
+
+        return _prototypes.Index(antag).Requirements;
+    }
+
+    public HashSet<JobRequirement>? GetAntagRequirement(AntagPrototype antag)
+    {
+        if (_requirementOverride != null && _requirementOverride.Antags.TryGetValue(antag.ID, out var req))
+            return req;
+
+        return antag.Requirements;
+    }
 }