EntityStorage ECS (#9291)

Content.Server/Morgue/CrematoriumSystem.cs

@@ -0,0 +1,162 @@
+using Content.Server.Morgue.Components;
+using Content.Shared.Morgue;
+using Robust.Server.GameObjects;
+using Robust.Shared.Player;
+using Robust.Shared.Audio;
+using Content.Server.Storage.Components;
+using System.Threading;
+using Content.Shared.Verbs;
+using Content.Shared.Database;
+using Content.Shared.Interaction.Events;
+using Content.Server.Players;
+using Content.Server.GameTicking;
+using Content.Shared.Popups;
+using Content.Server.Storage.EntitySystems;
+using Content.Shared.Examine;
+using Content.Shared.Standing;
+using Content.Shared.Storage;
+
+namespace Content.Server.Morgue;
+
+public sealed class CrematoriumSystem : EntitySystem
+{
+    [Dependency] private readonly GameTicker _ticker = default!;
+    [Dependency] private readonly EntityStorageSystem _entityStorage = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly StandingStateSystem _standing = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<CrematoriumComponent, ExaminedEvent>(OnExamine);
+        SubscribeLocalEvent<CrematoriumComponent, StorageOpenAttemptEvent>(OnAttemptOpen);
+        SubscribeLocalEvent<CrematoriumComponent, GetVerbsEvent<AlternativeVerb>>(AddCremateVerb);
+        SubscribeLocalEvent<CrematoriumComponent, SuicideEvent>(OnSuicide);
+    }
+
+    private void OnExamine(EntityUid uid, CrematoriumComponent component, ExaminedEvent args)
+    {
+        if (!TryComp<AppearanceComponent>(uid, out var appearance))
+            return;
+
+        if (appearance.TryGetData(CrematoriumVisuals.Burning, out bool isBurning) && isBurning)
+            args.PushMarkup(Loc.GetString("crematorium-entity-storage-component-on-examine-details-is-burning", ("owner", uid)));
+        if (appearance.TryGetData(StorageVisuals.HasContents, out bool hasContents) && hasContents)
+            args.PushMarkup(Loc.GetString("crematorium-entity-storage-component-on-examine-details-has-contents"));
+        else
+            args.PushMarkup(Loc.GetString("crematorium-entity-storage-component-on-examine-details-empty"));
+    }
+
+    private void OnAttemptOpen(EntityUid uid, CrematoriumComponent component, StorageOpenAttemptEvent args)
+    {
+        if (component.Cooking)
+            args.Cancel();
+    }
+
+    private void AddCremateVerb(EntityUid uid, CrematoriumComponent component, GetVerbsEvent<AlternativeVerb> args)
+    {
+        if (!TryComp<EntityStorageComponent>(uid, out var storage))
+            return;
+
+        if (!args.CanAccess || !args.CanInteract || args.Hands == null || component.Cooking || storage.Open)
+            return;
+
+        AlternativeVerb verb = new()
+        {
+            Text = Loc.GetString("cremate-verb-get-data-text"),
+            // TODO VERB ICON add flame/burn symbol?
+            Act = () => TryCremate(uid, component, storage),
+            Impact = LogImpact.Medium // could be a body? or evidence? I dunno.
+        };
+        args.Verbs.Add(verb);
+    }
+
+    public void Cremate(EntityUid uid, CrematoriumComponent? component = null, EntityStorageComponent? storage = null)
+    {
+        if (!Resolve(uid, ref component, ref storage))
+            return;
+
+        if (TryComp<AppearanceComponent>(uid, out var app))
+            app.SetData(CrematoriumVisuals.Burning, true);
+        component.Cooking = true;
+
+        SoundSystem.Play(component.CrematingSound.GetSound(), Filter.Pvs(uid), uid);
+
+        component.CremateCancelToken?.Cancel();
+        component.CremateCancelToken = new CancellationTokenSource();
+        uid.SpawnTimer(component.BurnMilis, () =>
+        {
+            if (Deleted(uid))
+                return;
+            if (TryComp<AppearanceComponent>(uid, out var app))
+                app.SetData(CrematoriumVisuals.Burning, false);
+            component.Cooking = false;
+
+            if (storage.Contents.ContainedEntities.Count > 0)
+            {
+                for (var i = storage.Contents.ContainedEntities.Count - 1; i >= 0; i--)
+                {
+                    var item = storage.Contents.ContainedEntities[i];
+                    storage.Contents.Remove(item);
+                    EntityManager.DeleteEntity(item);
+                }
+
+                var ash = Spawn("Ash", Transform(uid).Coordinates);
+                storage.Contents.Insert(ash);
+            }
+
+            _entityStorage.OpenStorage(uid, storage);
+
+            SoundSystem.Play(component.CremateFinishSound.GetSound(), Filter.Pvs(uid), uid);
+
+        }, component.CremateCancelToken.Token);
+    }
+
+    public void TryCremate(EntityUid uid, CrematoriumComponent component, EntityStorageComponent? storage = null)
+    {
+        if (!Resolve(uid, ref storage))
+            return;
+
+        if (component.Cooking || storage.Open || storage.Contents.ContainedEntities.Count < 1)
+            return;
+
+        SoundSystem.Play(component.CremateStartSound.GetSound(), Filter.Pvs(uid), uid);
+
+        Cremate(uid, component, storage);
+    }
+
+    private void OnSuicide(EntityUid uid, CrematoriumComponent component, SuicideEvent args)
+    {
+        if (args.Handled)
+            return;
+        args.SetHandled(SuicideKind.Heat);
+
+        var victim = args.Victim;
+        if (TryComp(victim, out ActorComponent? actor) && actor.PlayerSession.ContentData()?.Mind is { } mind)
+        {
+            _ticker.OnGhostAttempt(mind, false);
+
+            if (mind.OwnedEntity is { Valid: true } entity)
+            {
+                _popup.PopupEntity(Loc.GetString("crematorium-entity-storage-component-suicide-message"), entity, Filter.Pvs(entity));
+            }
+        }
+
+        _popup.PopupEntity(Loc.GetString("crematorium-entity-storage-component-suicide-message-others", ("victim", victim)),
+            victim, Filter.PvsExcept(victim), PopupType.LargeCaution);
+
+        if (_entityStorage.CanInsert(uid))
+        {
+            _entityStorage.CloseStorage(uid);
+            _standing.Down(victim, false);
+            _entityStorage.Insert(victim, uid);
+        }
+        else
+        {
+            EntityManager.DeleteEntity(victim);
+        }
+        _entityStorage.CloseStorage(uid);
+        Cremate(uid, component);
+    }
+}