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

criminal records revival (#22510)

Browse Source
This commit is contained in:
deltanedas
2024-02-04 23:29:35 +00:00
committed by GitHub
parent c856dd7506
commit 683591ab04
34 changed files with 1564 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
Content.Server/StationRecords/Systems/GeneralStationRecordConsoleSystem.cs
View File

@@ -1,5 +1,6 @@
using System.Linq;
using Content.Server.Station.Systems;
using Content.Server.StationRecords.Components;
using Content.Shared.StationRecords;
using Robust.Server.GameObjects;
@@ -7,126 +8,78 @@ namespace Content.Server.StationRecords.Systems;
public sealed class GeneralStationRecordConsoleSystem : EntitySystem
{
[Dependency] private readonly UserInterfaceSystem _userInterface = default!;
[Dependency] private readonly StationSystem _stationSystem = default!;
[Dependency] private readonly StationRecordsSystem _stationRecordsSystem = default!;
[Dependency] private readonly UserInterfaceSystem _ui = default!;
[Dependency] private readonly StationSystem _station = default!;
[Dependency] private readonly StationRecordsSystem _stationRecords = default!;
public override void Initialize()
{
SubscribeLocalEvent<GeneralStationRecordConsoleComponent, BoundUIOpenedEvent>(UpdateUserInterface);
SubscribeLocalEvent<GeneralStationRecordConsoleComponent, SelectGeneralStationRecord>(OnKeySelected);
SubscribeLocalEvent<GeneralStationRecordConsoleComponent, GeneralStationRecordsFilterMsg>(OnFiltersChanged);
SubscribeLocalEvent<GeneralStationRecordConsoleComponent, RecordModifiedEvent>(UpdateUserInterface);
SubscribeLocalEvent<GeneralStationRecordConsoleComponent, AfterGeneralRecordCreatedEvent>(UpdateUserInterface);
SubscribeLocalEvent<GeneralStationRecordConsoleComponent, RecordRemovedEvent>(UpdateUserInterface);
}
private void UpdateUserInterface<T>(EntityUid uid, GeneralStationRecordConsoleComponent component, T ev)
{
UpdateUserInterface(uid, component);
}
private void OnKeySelected(EntityUid uid, GeneralStationRecordConsoleComponent component,
SelectGeneralStationRecord msg)
{
component.ActiveKey = msg.SelectedKey;
UpdateUserInterface(uid, component);
}
private void OnFiltersChanged(EntityUid uid,
GeneralStationRecordConsoleComponent component, GeneralStationRecordsFilterMsg msg)
{
if (component.Filter == null ||
component.Filter.Type != msg.Type || component.Filter.Value != msg.Value)
Subs.BuiEvents<GeneralStationRecordConsoleComponent>(GeneralStationRecordConsoleKey.Key, subs =>
{
component.Filter = new GeneralStationRecordsFilter(msg.Type, msg.Value);
UpdateUserInterface(uid, component);
subs.Event<BoundUIOpenedEvent>(UpdateUserInterface);
subs.Event<SelectStationRecord>(OnKeySelected);
subs.Event<SetStationRecordFilter>(OnFiltersChanged);
});
}
private void UpdateUserInterface<T>(Entity<GeneralStationRecordConsoleComponent> ent, ref T args)
{
UpdateUserInterface(ent);
}
// TODO: instead of copy paste shitcode for each record console, have a shared records console comp they all use
// then have this somehow play nicely with creating ui state
// if that gets done put it in StationRecordsSystem console helpers section :)
private void OnKeySelected(Entity<GeneralStationRecordConsoleComponent> ent, ref SelectStationRecord msg)
{
ent.Comp.ActiveKey = msg.SelectedKey;
UpdateUserInterface(ent);
}
private void OnFiltersChanged(Entity<GeneralStationRecordConsoleComponent> ent, ref SetStationRecordFilter msg)
{
if (ent.Comp.Filter == null ||
ent.Comp.Filter.Type != msg.Type || ent.Comp.Filter.Value != msg.Value)
{
ent.Comp.Filter = new StationRecordsFilter(msg.Type, msg.Value);
UpdateUserInterface(ent);
}
}
private void UpdateUserInterface(EntityUid uid,
GeneralStationRecordConsoleComponent? console = null)
private void UpdateUserInterface(Entity<GeneralStationRecordConsoleComponent> ent)
{
if (!Resolve(uid, ref console))
var (uid, console) = ent;
var owningStation = _station.GetOwningStation(uid);
if (!TryComp<StationRecordsComponent>(owningStation, out var stationRecords))
{
_ui.TrySetUiState(uid, GeneralStationRecordConsoleKey.Key, new GeneralStationRecordConsoleState());
return;
}
var owningStation = _stationSystem.GetOwningStation(uid);
var listing = _stationRecords.BuildListing((owningStation.Value, stationRecords), console.Filter);
if (!TryComp<StationRecordsComponent>(owningStation, out var stationRecordsComponent))
switch (listing.Count)
{
GeneralStationRecordConsoleState state = new(null, null, null, null);
SetStateForInterface(uid, state);
case 0:
_ui.TrySetUiState(uid, GeneralStationRecordConsoleKey.Key, new GeneralStationRecordConsoleState());
return;
case 1:
console.ActiveKey = listing.Keys.First();
break;
}
if (console.ActiveKey is not { } id)
return;
}
var consoleRecords =
_stationRecordsSystem.GetRecordsOfType<GeneralStationRecord>(owningStation.Value, stationRecordsComponent);
var key = new StationRecordKey(id, owningStation.Value);
_stationRecords.TryGetRecord<GeneralStationRecord>(key, out var record, stationRecords);
var listing = new Dictionary<(NetEntity, uint), string>();
foreach (var pair in consoleRecords)
{
if (console.Filter != null && IsSkippedRecord(console.Filter, pair.Item2))
{
continue;
}
listing.Add(_stationRecordsSystem.Convert(pair.Item1), pair.Item2.Name);
}
if (listing.Count == 0)
{
GeneralStationRecordConsoleState state = new(null, null, null, console.Filter);
SetStateForInterface(uid, state);
return;
}
else if (listing.Count == 1)
{
console.ActiveKey = listing.Keys.First();
}
GeneralStationRecord? record = null;
if (console.ActiveKey != null)
{
_stationRecordsSystem.TryGetRecord(owningStation.Value, _stationRecordsSystem.Convert(console.ActiveKey.Value), out record,
stationRecordsComponent);
}
GeneralStationRecordConsoleState newState = new(console.ActiveKey, record, listing, console.Filter);
SetStateForInterface(uid, newState);
}
private void SetStateForInterface(EntityUid uid, GeneralStationRecordConsoleState newState)
{
_userInterface.TrySetUiState(uid, GeneralStationRecordConsoleKey.Key, newState);
}
private bool IsSkippedRecord(GeneralStationRecordsFilter filter,
GeneralStationRecord someRecord)
{
bool isFilter = filter.Value.Length > 0;
string filterLowerCaseValue = "";
if (!isFilter)
return false;
filterLowerCaseValue = filter.Value.ToLower();
return filter.Type switch
{
GeneralStationRecordFilterType.Name =>
!someRecord.Name.ToLower().Contains(filterLowerCaseValue),
GeneralStationRecordFilterType.Prints => someRecord.Fingerprint != null
&& IsFilterWithSomeCodeValue(someRecord.Fingerprint, filterLowerCaseValue),
GeneralStationRecordFilterType.DNA => someRecord.DNA != null
&& IsFilterWithSomeCodeValue(someRecord.DNA, filterLowerCaseValue),
};
}
private bool IsFilterWithSomeCodeValue(string value, string filter)
{
return !value.ToLower().StartsWith(filter);
GeneralStationRecordConsoleState newState = new(id, record, listing, console.Filter);
_ui.TrySetUiState(uid, GeneralStationRecordConsoleKey.Key, newState);
}
}

278
Content.Server/StationRecords/Systems/StationRecordsSystem.cs
View File

@@ -32,8 +32,8 @@ namespace Content.Server.StationRecords.Systems;
/// </summary>
public sealed class StationRecordsSystem : SharedStationRecordsSystem
{
[Dependency] private readonly InventorySystem _inventorySystem = default!;
[Dependency] private readonly StationRecordKeyStorageSystem _keyStorageSystem = default!;
[Dependency] private readonly InventorySystem _inventory = default!;
[Dependency] private readonly StationRecordKeyStorageSystem _keyStorage = default!;
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
public override void Initialize()
@@ -45,26 +45,22 @@ public sealed class StationRecordsSystem : SharedStationRecordsSystem
private void OnPlayerSpawn(PlayerSpawnCompleteEvent args)
{
if (!HasComp<StationRecordsComponent>(args.Station))
if (!TryComp<StationRecordsComponent>(args.Station, out var stationRecords))
return;
CreateGeneralRecord(args.Station, args.Mob, args.Profile, args.JobId);
CreateGeneralRecord(args.Station, args.Mob, args.Profile, args.JobId, stationRecords);
}
private void CreateGeneralRecord(EntityUid station, EntityUid player, HumanoidCharacterProfile profile,
string? jobId, StationRecordsComponent? records = null)
string? jobId, StationRecordsComponent records)
{
if (!Resolve(station, ref records)
|| string.IsNullOrEmpty(jobId)
// TODO make PlayerSpawnCompleteEvent.JobId a ProtoId
if (string.IsNullOrEmpty(jobId)
|| !_prototypeManager.HasIndex<JobPrototype>(jobId))
{
return;
}
if (!_inventorySystem.TryGetSlotEntity(player, "id", out var idUid))
{
if (!_inventory.TryGetSlotEntity(player, "id", out var idUid))
return;
}
TryComp<FingerprintComponent>(player, out var fingerprintComponent);
TryComp<DnaComponent>(player, out var dnaComponent);
@@ -100,17 +96,28 @@ public sealed class StationRecordsSystem : SharedStationRecordsSystem
/// Optional - other systems should anticipate this.
/// </param>
/// <param name="records">Station records component.</param>
public void CreateGeneralRecord(EntityUid station, EntityUid? idUid, string name, int age, string species, Gender gender, string jobId, string? mobFingerprint, string? dna, HumanoidCharacterProfile? profile = null,
StationRecordsComponent? records = null)
public void CreateGeneralRecord(
EntityUid station,
EntityUid? idUid,
string name,
int age,
string species,
Gender gender,
string jobId,
string? mobFingerprint,
string? dna,
HumanoidCharacterProfile profile,
StationRecordsComponent records)
{
if (!Resolve(station, ref records))
{
return;
}
if (!_prototypeManager.TryIndex(jobId, out JobPrototype? jobPrototype))
{
if (!_prototypeManager.TryIndex<JobPrototype>(jobId, out var jobPrototype))
throw new ArgumentException($"Invalid job prototype ID: {jobId}");
// when adding a record that already exists use the old one
// this happens when respawning as the same character
if (GetRecordByName(station, name, records) is {} id)
{
SetIdKey(idUid, new StationRecordKey(id, station));
return;
}
var record = new GeneralStationRecord()
@@ -129,40 +136,47 @@ public sealed class StationRecordsSystem : SharedStationRecordsSystem
var key = AddRecordEntry(station, record);
if (!key.IsValid())
return;
if (idUid != null)
{
var keyStorageEntity = idUid;
if (TryComp(idUid, out PdaComponent? pdaComponent) && pdaComponent.ContainedId != null)
{
keyStorageEntity = pdaComponent.IdSlot.Item;
}
if (keyStorageEntity != null)
{
_keyStorageSystem.AssignKey(keyStorageEntity.Value, key);
}
Log.Warning($"Failed to add general record entry for {name}");
return;
}
RaiseLocalEvent(new AfterGeneralRecordCreatedEvent(station, key, record, profile));
SetIdKey(idUid, key);
RaiseLocalEvent(new AfterGeneralRecordCreatedEvent(key, record, profile));
}
/// <summary>
/// Set the station records key for an id/pda.
/// </summary>
public void SetIdKey(EntityUid? uid, StationRecordKey key)
{
if (uid is not {} idUid)
return;
var keyStorageEntity = idUid;
if (TryComp<PdaComponent>(idUid, out var pda) && pda.ContainedId is {} id)
{
keyStorageEntity = id;
}
_keyStorage.AssignKey(keyStorageEntity, key);
}
/// <summary>
/// Removes a record from this station.
/// </summary>
/// <param name="station">Station to remove the record from.</param>
/// <param name="key">The key to remove.</param>
/// <param name="key">The station and key to remove.</param>
/// <param name="records">Station records component.</param>
/// <returns>True if the record was removed, false otherwise.</returns>
public bool RemoveRecord(EntityUid station, StationRecordKey key, StationRecordsComponent? records = null)
public bool RemoveRecord(StationRecordKey key, StationRecordsComponent? records = null)
{
if (!Resolve(station, ref records))
if (!Resolve(key.OriginStation, ref records))
return false;
if (records.Records.RemoveAllRecords(key))
if (records.Records.RemoveAllRecords(key.Id))
{
RaiseLocalEvent(new RecordRemovedEvent(station, key));
RaiseLocalEvent(new RecordRemovedEvent(key));
return true;
}
@@ -174,20 +188,39 @@ public sealed class StationRecordsSystem : SharedStationRecordsSystem
/// from the provided station record key. Will always return
/// null if the key does not match the station.
/// </summary>
/// <param name="station">Station to get the record from.</param>
/// <param name="key">Key to try and index from the record set.</param>
/// <param name="key">Station and key to try and index from the record set.</param>
/// <param name="entry">The resulting entry.</param>
/// <param name="records">Station record component.</param>
/// <typeparam name="T">Type to get from the record set.</typeparam>
/// <returns>True if the record was obtained, false otherwise.</returns>
public bool TryGetRecord<T>(EntityUid station, StationRecordKey key, [NotNullWhen(true)] out T? entry, StationRecordsComponent? records = null)
public bool TryGetRecord<T>(StationRecordKey key, [NotNullWhen(true)] out T? entry, StationRecordsComponent? records = null)
{
entry = default;
if (!Resolve(station, ref records))
if (!Resolve(key.OriginStation, ref records))
return false;
return records.Records.TryGetRecordEntry(key, out entry);
return records.Records.TryGetRecordEntry(key.Id, out entry);
}
/// <summary>
/// Returns an id if a record with the same name exists.
/// </summary>
/// <remarks>
/// Linear search so O(n) time complexity.
/// </remarks>
public uint? GetRecordByName(EntityUid station, string name, StationRecordsComponent? records = null)
{
if (!Resolve(station, ref records))
return null;
foreach (var (id, record) in GetRecordsOfType<GeneralStationRecord>(station, records))
{
if (record.Name == name)
return id;
}
return null;
}
/// <summary>
@@ -197,30 +230,47 @@ public sealed class StationRecordsSystem : SharedStationRecordsSystem
/// <param name="records">Station records component.</param>
/// <typeparam name="T">Type of record to fetch</typeparam>
/// <returns>Enumerable of pairs with a station record key, and the entry in question of type T.</returns>
public IEnumerable<(StationRecordKey, T)> GetRecordsOfType<T>(EntityUid station, StationRecordsComponent? records = null)
public IEnumerable<(uint, T)> GetRecordsOfType<T>(EntityUid station, StationRecordsComponent? records = null)
{
if (!Resolve(station, ref records))
{
return Array.Empty<(StationRecordKey, T)>();
}
return Array.Empty<(uint, T)>();
return records.Records.GetRecordsOfType<T>();
}
/// <summary>
/// Adds a record entry to a station's record set.
/// Adds a new record entry to a station's record set.
/// </summary>
/// <param name="station">The station to add the record to.</param>
/// <param name="record">The record to add.</param>
/// <param name="records">Station records component.</param>
/// <typeparam name="T">The type of record to add.</typeparam>
public StationRecordKey AddRecordEntry<T>(EntityUid station, T record,
StationRecordsComponent? records = null)
public StationRecordKey AddRecordEntry<T>(EntityUid station, T record, StationRecordsComponent? records = null)
{
if (!Resolve(station, ref records))
return StationRecordKey.Invalid;
return records.Records.AddRecordEntry(station, record);
var id = records.Records.AddRecordEntry(record);
if (id == null)
return StationRecordKey.Invalid;
return new StationRecordKey(id.Value, station);
}
/// <summary>
/// Adds a record to an existing entry.
/// </summary>
/// <param name="key">The station and id of the existing entry.</param>
/// <param name="record">The record to add.</param>
/// <param name="records">Station records component.</param>
/// <typeparam name="T">The type of record to add.</typeparam>
public void AddRecordEntry<T>(StationRecordKey key, T record,
StationRecordsComponent? records = null)
{
if (!Resolve(key.OriginStation, ref records))
return;
records.Records.AddRecordEntry(key.Id, record);
}
/// <summary>
@@ -231,17 +281,99 @@ public sealed class StationRecordsSystem : SharedStationRecordsSystem
public void Synchronize(EntityUid station, StationRecordsComponent? records = null)
{
if (!Resolve(station, ref records))
{
return;
}
foreach (var key in records.Records.GetRecentlyAccessed())
{
RaiseLocalEvent(new RecordModifiedEvent(station, key));
RaiseLocalEvent(new RecordModifiedEvent(new StationRecordKey(key, station)));
}
records.Records.ClearRecentlyAccessed();
}
/// <summary>
/// Synchronizes a single record's entries for a station.
/// </summary>
/// <param name="key">The station and id of the record</param>
/// <param name="records">Station records component.</param>
public void Synchronize(StationRecordKey key, StationRecordsComponent? records = null)
{
if (!Resolve(key.OriginStation, ref records))
return;
RaiseLocalEvent(new RecordModifiedEvent(key));
records.Records.RemoveFromRecentlyAccessed(key.Id);
}
#region Console system helpers
/// <summary>
/// Checks if a record should be skipped given a filter.
/// Takes general record since even if you are using this for e.g. criminal records,
/// you don't want to duplicate basic info like name and dna.
/// Station records lets you do this nicely with multiple types having their own data.
/// </summary>
public bool IsSkipped(StationRecordsFilter? filter, GeneralStationRecord someRecord)
{
// if nothing is being filtered, show everything
if (filter == null)
return false;
if (filter.Value.Length == 0)
return false;
var filterLowerCaseValue = filter.Value.ToLower();
return filter.Type switch
{
StationRecordFilterType.Name =>
!someRecord.Name.ToLower().Contains(filterLowerCaseValue),
StationRecordFilterType.Prints => someRecord.Fingerprint != null
&& IsFilterWithSomeCodeValue(someRecord.Fingerprint, filterLowerCaseValue),
StationRecordFilterType.DNA => someRecord.DNA != null
&& IsFilterWithSomeCodeValue(someRecord.DNA, filterLowerCaseValue),
};
}
private bool IsFilterWithSomeCodeValue(string value, string filter)
{
return !value.ToLower().StartsWith(filter);
}
/// <summary>
/// Build a record listing of id to name for a station and filter.
/// </summary>
public Dictionary<uint, string> BuildListing(Entity<StationRecordsComponent> station, StationRecordsFilter? filter)
{
var listing = new Dictionary<uint, string>();
var records = GetRecordsOfType<GeneralStationRecord>(station, station.Comp);
foreach (var pair in records)
{
if (IsSkipped(filter, pair.Item2))
continue;
listing.Add(pair.Item1, pair.Item2.Name);
}
return listing;
}
#endregion
}
/// <summary>
/// Base event for station record events
/// </summary>
public abstract class StationRecordEvent : EntityEventArgs
{
public readonly StationRecordKey Key;
public EntityUid Station => Key.OriginStation;
protected StationRecordEvent(StationRecordKey key)
{
Key = key;
}
}
/// <summary>
@@ -250,23 +382,19 @@ public sealed class StationRecordsSystem : SharedStationRecordsSystem
/// listening to this event, as it contains the character's record key.
/// Also stores the general record reference, to save some time.
/// </summary>
public sealed class AfterGeneralRecordCreatedEvent : EntityEventArgs
public sealed class AfterGeneralRecordCreatedEvent : StationRecordEvent
{
public readonly EntityUid Station;
public StationRecordKey Key { get; }
public GeneralStationRecord Record { get; }
public readonly GeneralStationRecord Record;
/// <summary>
/// Profile for the related player. This is so that other systems can get further information
/// about the player character.
/// Optional - other systems should anticipate this.
/// </summary>
public HumanoidCharacterProfile? Profile { get; }
public readonly HumanoidCharacterProfile Profile;
public AfterGeneralRecordCreatedEvent(EntityUid station, StationRecordKey key, GeneralStationRecord record,
HumanoidCharacterProfile? profile)
public AfterGeneralRecordCreatedEvent(StationRecordKey key, GeneralStationRecord record,
HumanoidCharacterProfile profile) : base(key)
{
Station = station;
Key = key;
Record = record;
Profile = profile;
}
@@ -278,15 +406,10 @@ public sealed class AfterGeneralRecordCreatedEvent : EntityEventArgs
/// that store record keys can then remove the key from their internal
/// fields.
/// </summary>
public sealed class RecordRemovedEvent : EntityEventArgs
public sealed class RecordRemovedEvent : StationRecordEvent
{
public readonly EntityUid Station;
public StationRecordKey Key { get; }
public RecordRemovedEvent(EntityUid station, StationRecordKey key)
public RecordRemovedEvent(StationRecordKey key) : base(key)
{
Station = station;
Key = key;
}
}
@@ -295,14 +418,9 @@ public sealed class RecordRemovedEvent : EntityEventArgs
/// inform other systems that records stored in this key
/// may have changed.
/// </summary>
public sealed class RecordModifiedEvent : EntityEventArgs
public sealed class RecordModifiedEvent : StationRecordEvent
{
public readonly EntityUid Station;
public StationRecordKey Key { get; }
public RecordModifiedEvent(EntityUid station, StationRecordKey key)
public RecordModifiedEvent(StationRecordKey key) : base(key)
{
Station = station;
Key = key;
}
}