Convert DisposalUnitVisualizer to VisualizerSystem (#13637)

Content.Client/Disposal/Components/DisposalUnitComponent.cs

@@ -1,6 +1,6 @@
-using Content.Shared.Disposal.Components;
-using Content.Shared.DragDrop;
-using Robust.Shared.GameObjects;
+using Content.Shared.Disposal.Components;
+using Robust.Client.Animations;
+using Robust.Shared.Audio;
 
 namespace Content.Client.Disposal.Components
 {
@@ -8,6 +8,11 @@ namespace Content.Client.Disposal.Components
     [ComponentReference(typeof(SharedDisposalUnitComponent))]
     public sealed class DisposalUnitComponent : SharedDisposalUnitComponent
     {
+        [DataField("flushSound")]
+        public readonly SoundSpecifier? FlushSound;
+
+        public Animation FlushAnimation = default!;
+
         public DisposalUnitBoundUserInterfaceState? UiState;
 
         public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)

Content.Client/Disposal/Systems/DisposalUnitSystem.cs

@@ -1,27 +1,39 @@
-using System.Collections.Generic;
 using Content.Client.Disposal.Components;
 using Content.Client.Disposal.UI;
 using Content.Shared.Disposal;
 using Robust.Client.GameObjects;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
+using Robust.Client.Animations;
+using static Content.Shared.Disposal.Components.SharedDisposalUnitComponent;
+
+namespace Content.Client.Disposal.Systems;
 
-namespace Content.Client.Disposal.Systems
-{
 public sealed class DisposalUnitSystem : SharedDisposalUnitSystem
 {
-        public List<DisposalUnitComponent> PressuringDisposals = new();
+    [Dependency] private readonly AppearanceSystem AppearanceSystem = default!;
+    [Dependency] private readonly AnimationPlayerSystem AnimationSystem = default!;
+    [Dependency] private readonly SharedAudioSystem SoundSystem = default!;
+    private const string AnimationKey = "disposal_unit_animation";
 
-        public void UpdateActive(DisposalUnitComponent component, bool active)
+    private List<EntityUid> PressuringDisposals = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<DisposalUnitComponent, ComponentInit>(OnComponentInit);
+        SubscribeLocalEvent<DisposalUnitComponent, AppearanceChangeEvent>(OnAppearanceChange);
+    }
+
+    public void UpdateActive(EntityUid disposalEntity, bool active)
     {
         if (active)
         {
-                if (!PressuringDisposals.Contains(component))
-                    PressuringDisposals.Add(component);
+            if (!PressuringDisposals.Contains(disposalEntity))
+                PressuringDisposals.Add(disposalEntity);
         }
         else
         {
-                PressuringDisposals.Remove(component);
+            PressuringDisposals.Remove(disposalEntity);
         }
     }
 
@@ -30,20 +42,26 @@ namespace Content.Client.Disposal.Systems
         base.FrameUpdate(frameTime);
         for (var i = PressuringDisposals.Count - 1; i >= 0; i--)
         {
-                var comp = PressuringDisposals[i];
-                if (!UpdateInterface(comp)) continue;
+            var disposal = PressuringDisposals[i];
+            if (!UpdateInterface(disposal))
+                continue;
+
             PressuringDisposals.RemoveAt(i);
         }
     }
 
-        private bool UpdateInterface(DisposalUnitComponent component)
+    private bool UpdateInterface(EntityUid disposalUnit)
     {
-            if (component.Deleted) return true;
-
-            if (!EntityManager.TryGetComponent(component.Owner, out ClientUserInterfaceComponent? userInterface)) return true;
+        if (!TryComp(disposalUnit, out DisposalUnitComponent? component) || component.Deleted)
+            return true;
+        if (component.Deleted)
+            return true;
+        if (!TryComp(disposalUnit, out ClientUserInterfaceComponent? userInterface))
+            return true;
 
         var state = component.UiState;
-            if (state == null) return true;
+        if (state == null)
+            return true;
 
         foreach (var inter in userInterface.Interfaces)
         {
@@ -55,5 +73,114 @@ namespace Content.Client.Disposal.Systems
 
         return true;
     }
+
+    private void OnComponentInit(EntityUid uid, DisposalUnitComponent disposalUnit, ComponentInit args)
+    {
+        if (!TryComp<SpriteComponent>(uid, out var sprite))
+            return;
+
+        if(!sprite.LayerMapTryGet(DisposalUnitVisualLayers.Base, out var baseLayerIdx))
+            return; // Couldn't find the "normal" layer to return to after flush animation
+
+        if(!sprite.LayerMapTryGet(DisposalUnitVisualLayers.BaseFlush, out var flushLayerIdx))
+            return; // Couldn't find the flush animation layer
+
+        var originalBaseState = sprite.LayerGetState(baseLayerIdx);
+        var flushState = sprite.LayerGetState(flushLayerIdx);
+
+        // Setup the flush animation to play
+        disposalUnit.FlushAnimation = new Animation {
+            Length = TimeSpan.FromSeconds(disposalUnit.FlushTime),
+            AnimationTracks = {
+                new AnimationTrackSpriteFlick {
+                    LayerKey = DisposalUnitVisualLayers.BaseFlush,
+                    KeyFrames = {
+                        // Play the flush animation
+                        new AnimationTrackSpriteFlick.KeyFrame(flushState, 0),
+                        // Return to base state (though, depending on how the unit is
+                        // configured we might get an appearence change event telling
+                        // us to go to charging state)
+                        new AnimationTrackSpriteFlick.KeyFrame(originalBaseState, disposalUnit.FlushTime)
+                    }
+                },
+            }
+        };
+
+        if (disposalUnit.FlushSound != null)
+        {
+            disposalUnit.FlushAnimation.AnimationTracks.Add(
+                new AnimationTrackPlaySound {
+                    KeyFrames = {
+                        new AnimationTrackPlaySound.KeyFrame(SoundSystem.GetSound(disposalUnit.FlushSound), 0)
+                    }
+                });
+        }
+
+        EnsureComp<AnimationPlayerComponent>(uid);
+
+        UpdateState(uid, disposalUnit, sprite);
+    }
+
+    private void OnAppearanceChange(EntityUid uid, DisposalUnitComponent unit, ref AppearanceChangeEvent args)
+    {
+        if (args.Sprite == null)
+        {
+            return;
+        }
+
+        UpdateState(uid, unit, args.Sprite);
+    }
+
+    // Update visuals and tick animation
+    private void UpdateState(EntityUid uid, DisposalUnitComponent unit, SpriteComponent sprite)
+    {
+        if (!AppearanceSystem.TryGetData<VisualState>(uid, Visuals.VisualState, out var state))
+        {
+            return;
+        }
+
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.Unanchored, state == VisualState.UnAnchored);
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.Base, state == VisualState.Anchored);
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.BaseCharging, state == VisualState.Charging);
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.BaseFlush, state == VisualState.Flushing);
+
+        if (state == VisualState.Flushing)
+        {
+            if (!AnimationSystem.HasRunningAnimation(uid, AnimationKey))
+            {
+                AnimationSystem.Play(uid, unit.FlushAnimation, AnimationKey);
             }
         }
+
+        if (!AppearanceSystem.TryGetData<HandleState>(uid, Visuals.Handle, out var handleState))
+        {
+            handleState = HandleState.Normal;
+        }
+
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayEngaged, handleState != HandleState.Normal);
+
+        if (!AppearanceSystem.TryGetData<LightStates>(uid, Visuals.Light, out var lightState))
+        {
+            lightState = LightStates.Off;
+        }
+
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayCharging,
+                (lightState & LightStates.Charging) != 0);
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayReady,
+                (lightState & LightStates.Ready) != 0);
+        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayFull,
+                (lightState & LightStates.Full) != 0);
+    }
+}
+
+public enum DisposalUnitVisualLayers : byte
+{
+    Unanchored,
+    Base,
+    BaseCharging,
+    BaseFlush,
+    OverlayCharging,
+    OverlayReady,
+    OverlayFull,
+    OverlayEngaged
+}

Content.Client/Disposal/UI/DisposalUnitBoundUserInterface.cs

@@ -1,12 +1,9 @@
-using Content.Client.Disposal.Components;
+using Content.Client.Disposal.Components;
 using Content.Client.Disposal.Systems;
 using Content.Shared.Disposal;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 using Robust.Client.UserInterface.Controls;
-using Robust.Client.UserInterface.CustomControls;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using static Content.Shared.Disposal.Components.SharedDisposalUnitComponent;
 
 namespace Content.Client.Disposal.UI
@@ -17,11 +14,14 @@ namespace Content.Client.Disposal.UI
     [UsedImplicitly]
     public sealed class DisposalUnitBoundUserInterface : BoundUserInterface
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public MailingUnitWindow? MailingUnitWindow;
         public DisposalUnitWindow? DisposalUnitWindow;
 
         public DisposalUnitBoundUserInterface(ClientUserInterfaceComponent owner, Enum uiKey) : base(owner, uiKey)
         {
+            IoCManager.InjectDependencies(this);
         }
 
         private void ButtonPressed(UiButton button)
@@ -76,7 +76,9 @@ namespace Content.Client.Disposal.UI
                 return;
             }
 
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(Owner.Owner, out DisposalUnitComponent? component)) return;
+            var entityId = Owner.Owner;
+            if (!_entityManager.TryGetComponent(entityId, out DisposalUnitComponent? component))
+                return;
 
             switch (state)
             {
@@ -91,7 +93,7 @@ namespace Content.Client.Disposal.UI
                     break;
             }
 
-            EntitySystem.Get<DisposalUnitSystem>().UpdateActive(component, true);
+            _entityManager.System<DisposalUnitSystem>().UpdateActive(entityId, true);
         }
 
         protected override void Dispose(bool disposing)

Content.Client/Disposal/Visualizers/DisposalUnitVisualizer.cs

@@ -1,169 +0,0 @@
-using JetBrains.Annotations;
-using Robust.Client.Animations;
-using Robust.Client.GameObjects;
-using Robust.Shared.Audio;
-using Robust.Shared.Serialization;
-using static Content.Shared.Disposal.Components.SharedDisposalUnitComponent;
-
-namespace Content.Client.Disposal.Visualizers
-{
-    [UsedImplicitly]
-    public sealed class DisposalUnitVisualizer : AppearanceVisualizer, ISerializationHooks
-    {
-        private const string AnimationKey = "disposal_unit_animation";
-
-        [DataField("state_anchored", required: true)]
-        private string? _stateAnchored;
-
-        [DataField("state_unanchored", required: true)]
-        private string? _stateUnAnchored;
-
-        [DataField("state_charging", required: true)]
-        private string? _stateCharging;
-
-        [DataField("overlay_charging", required: true)]
-        private string? _overlayCharging;
-
-        [DataField("overlay_ready", required: true)]
-        private string? _overlayReady;
-
-        [DataField("overlay_full", required: true)]
-        private string? _overlayFull;
-
-        [DataField("overlay_engaged", required: true)]
-        private string? _overlayEngaged;
-
-        [DataField("state_flush", required: true)]
-        private string? _stateFlush;
-
-        [DataField("flush_sound", required: true)]
-        private SoundSpecifier _flushSound = default!;
-
-        [DataField("flush_time", required: true)]
-        private float _flushTime;
-
-        private Animation _flushAnimation = default!;
-
-        void ISerializationHooks.AfterDeserialization()
-        {
-            _flushAnimation = new Animation {Length = TimeSpan.FromSeconds(_flushTime)};
-
-            var flick = new AnimationTrackSpriteFlick();
-            _flushAnimation.AnimationTracks.Add(flick);
-            flick.LayerKey = DisposalUnitVisualLayers.Base;
-            flick.KeyFrames.Add(new AnimationTrackSpriteFlick.KeyFrame(_stateFlush, 0));
-
-            var sound = new AnimationTrackPlaySound();
-            _flushAnimation.AnimationTracks.Add(sound);
-
-            sound.KeyFrames.Add(new AnimationTrackPlaySound.KeyFrame(_flushSound.GetSound(), 0));
-        }
-
-        private void ChangeState(AppearanceComponent appearance)
-        {
-            if (!appearance.TryGetData(Visuals.VisualState, out VisualState state))
-            {
-                return;
-            }
-
-            var entities = IoCManager.Resolve<IEntityManager>();
-            if (!entities.TryGetComponent(appearance.Owner, out SpriteComponent? sprite))
-            {
-                return;
-            }
-
-            switch (state)
-            {
-                case VisualState.UnAnchored:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Base, _stateUnAnchored);
-                    break;
-                case VisualState.Anchored:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Base, _stateAnchored);
-                    break;
-                case VisualState.Charging:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Base, _stateCharging);
-                    break;
-                case VisualState.Flushing:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Base, _stateAnchored);
-
-                    var animPlayer = entities.GetComponent<AnimationPlayerComponent>(appearance.Owner);
-
-                    if (!animPlayer.HasRunningAnimation(AnimationKey))
-                    {
-                        animPlayer.Play(_flushAnimation, AnimationKey);
-                    }
-
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-
-            if (!appearance.TryGetData(Visuals.Handle, out HandleState handleState))
-            {
-                handleState = HandleState.Normal;
-            }
-
-            sprite.LayerSetVisible(DisposalUnitVisualLayers.Handle, handleState != HandleState.Normal);
-
-            switch (handleState)
-            {
-                case HandleState.Normal:
-                    break;
-                case HandleState.Engaged:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Handle, _overlayEngaged);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-
-            if (!appearance.TryGetData(Visuals.Light, out LightState lightState))
-            {
-                lightState = LightState.Off;
-            }
-
-            sprite.LayerSetVisible(DisposalUnitVisualLayers.Light, lightState != LightState.Off);
-
-            switch (lightState)
-            {
-                case LightState.Off:
-                    break;
-                case LightState.Charging:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Light, _overlayCharging);
-                    break;
-                case LightState.Full:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Light, _overlayFull);
-                    break;
-                case LightState.Ready:
-                    sprite.LayerSetState(DisposalUnitVisualLayers.Light, _overlayReady);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
-        [Obsolete("Subscribe to your component being initialised instead.")]
-        public override void InitializeEntity(EntityUid entity)
-        {
-            base.InitializeEntity(entity);
-            var entities = IoCManager.Resolve<IEntityManager>();
-            entities.EnsureComponent<AnimationPlayerComponent>(entity);
-            var appearance = entities.EnsureComponent<ClientAppearanceComponent>(entity);
-
-            ChangeState(appearance);
-        }
-
-        [Obsolete("Subscribe to AppearanceChangeEvent instead.")]
-        public override void OnChangeData(AppearanceComponent component)
-        {
-            base.OnChangeData(component);
-            ChangeState(component);
-        }
-    }
-
-    public enum DisposalUnitVisualLayers : byte
-    {
-        Base,
-        Handle,
-        Light
-    }
-}

Content.IntegrationTests/Tests/Disposal/DisposalUnitTest.cs

@@ -62,12 +62,12 @@ namespace Content.IntegrationTests.Tests.Disposal
             UnitContains(unit, result, entities);
         }
 
-        private void Flush(DisposalUnitComponent unit, bool result, params EntityUid[] entities)
+        private void Flush(EntityUid unitEntity, DisposalUnitComponent unit, bool result, params EntityUid[] entities)
         {
             Assert.That(unit.Container.ContainedEntities, Is.SupersetOf(entities));
             Assert.That(entities.Length, Is.EqualTo(unit.Container.ContainedEntities.Count));
 
-            Assert.That(result, Is.EqualTo(EntitySystem.Get<DisposalUnitSystem>().TryFlush(unit)));
+            Assert.That(result, Is.EqualTo(EntitySystem.Get<DisposalUnitSystem>().TryFlush(unitEntity, unit)));
             Assert.That(result || entities.Length == 0, Is.EqualTo(unit.Container.ContainedEntities.Count == 0));
         }
 
@@ -119,6 +119,7 @@ namespace Content.IntegrationTests.Tests.Disposal
   - type: DisposalUnit
     entryDelay: 0
     draggedEntryDelay: 0
+    flushTime: 0
   - type: Anchorable
   - type: ApcPowerReceiver
   - type: Physics
@@ -151,7 +152,7 @@ namespace Content.IntegrationTests.Tests.Disposal
             EntityUid wrench = default!;
             EntityUid disposalUnit = default!;
             EntityUid disposalTrunk = default!;
-            DisposalUnitComponent unit = default!;
+            DisposalUnitComponent unitComponent = default!;
 
             var entityManager = server.ResolveDependency<IEntityManager>();
 
@@ -166,28 +167,28 @@ namespace Content.IntegrationTests.Tests.Disposal
                     IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(disposalUnit).MapPosition);
 
                 // Test for components existing
-                ref DisposalUnitComponent? comp = ref unit!;
+                ref DisposalUnitComponent? comp = ref unitComponent!;
                 Assert.True(entityManager.TryGetComponent(disposalUnit, out comp));
                 Assert.True(entityManager.HasComponent<DisposalEntryComponent>(disposalTrunk));
 
                 // Can't insert, unanchored and unpowered
-                entityManager.GetComponent<TransformComponent>(unit!.Owner).Anchored = false;
-                UnitInsertContains(unit, false, human, wrench, disposalUnit, disposalTrunk);
+                entityManager.GetComponent<TransformComponent>(unitComponent!.Owner).Anchored = false;
+                UnitInsertContains(unitComponent, false, human, wrench, disposalUnit, disposalTrunk);
             });
 
             await server.WaitAssertion(() =>
             {
                 // Anchor the disposal unit
-                entityManager.GetComponent<TransformComponent>(unit.Owner).Anchored = true;
+                entityManager.GetComponent<TransformComponent>(unitComponent.Owner).Anchored = true;
 
                 // No power
-                Assert.False(unit.Powered);
+                Assert.False(unitComponent.Powered);
 
                 // Can't insert the trunk or the unit into itself
-                UnitInsertContains(unit, false, disposalUnit, disposalTrunk);
+                UnitInsertContains(unitComponent, false, disposalUnit, disposalTrunk);
 
                 // Can insert mobs and items
-                UnitInsertContains(unit, true, human, wrench);
+                UnitInsertContains(unitComponent, true, human, wrench);
             });
 
             await server.WaitAssertion(() =>
@@ -196,7 +197,7 @@ namespace Content.IntegrationTests.Tests.Disposal
                 entityManager.GetComponent<TransformComponent>(disposalTrunk).WorldPosition += (1, 0);
 
                 // Fail to flush with a mob and an item
-                Flush(unit, false, human, wrench);
+                Flush(disposalUnit, unitComponent, false, human, wrench);
             });
 
             await server.WaitAssertion(() =>
@@ -205,7 +206,7 @@ namespace Content.IntegrationTests.Tests.Disposal
                 entityManager.GetComponent<TransformComponent>(disposalTrunk).WorldPosition -= (1, 0);
 
                 // Fail to flush with a mob and an item, no power
-                Flush(unit, false, human, wrench);
+                Flush(disposalUnit, unitComponent, false, human, wrench);
             });
 
             await server.WaitAssertion(() =>
@@ -213,16 +214,16 @@ namespace Content.IntegrationTests.Tests.Disposal
                 // Remove power need
                 Assert.True(entityManager.TryGetComponent(disposalUnit, out ApcPowerReceiverComponent power));
                 power!.NeedsPower = false;
-                unit.Powered = true; //Power state changed event doesn't get fired smh
+                unitComponent.Powered = true; //Power state changed event doesn't get fired smh
 
                 // Flush with a mob and an item
-                Flush(unit, true, human, wrench);
+                Flush(disposalUnit, unitComponent, true, human, wrench);
             });
 
             await server.WaitAssertion(() =>
             {
                 // Re-pressurizing
-                Flush(unit, false);
+                Flush(disposalUnit, unitComponent, false);
             });
             await pairTracker.CleanReturnAsync();
         }

Content.Server/Disposal/Unit/EntitySystems/DisposableSystem.cs

@@ -39,15 +39,19 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             // *This ejection also makes the target not collide with the unit.*
             // *This is on purpose.*
 
+            EntityUid? disposalId = null;
             DisposalUnitComponent? duc = null;
             if (_mapManager.TryGetGrid(holderTransform.GridUid, out var grid))
             {
                 foreach (var contentUid in grid.GetLocal(holderTransform.Coordinates))
                 {
                     if (EntityManager.TryGetComponent(contentUid, out duc))
+                    {
+                        disposalId = contentUid;
                         break;
                     }
                 }
+            }
 
             foreach (var entity in holder.Container.ContainedEntities.ToArray())
             {
@@ -71,9 +75,9 @@ namespace Content.Server.Disposal.Unit.EntitySystems
                 }
             }
 
-            if (duc != null)
+            if (disposalId != null && duc != null)
             {
-                _disposalUnitSystem.TryEjectContents(duc);
+                _disposalUnitSystem.TryEjectContents(disposalId.Value, duc);
             }
 
             if (_atmosphereSystem.GetContainingMixture(uid, false, true) is {} environment)

Content.Server/Disposal/Unit/EntitySystems/DisposalUnitSystem.cs

@@ -41,7 +41,6 @@ namespace Content.Server.Disposal.Unit.EntitySystems
         [Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
         [Dependency] private readonly AppearanceSystem _appearance = default!;
         [Dependency] private readonly AtmosphereSystem _atmosSystem = default!;
-        [Dependency] private readonly AudioSystem _audio = default!;
         [Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
         [Dependency] private readonly EntityLookupSystem _lookup = default!;
         [Dependency] private readonly PopupSystem _popupSystem = default!;
@@ -95,7 +94,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             {
                 // Verbs to flush the unit
                 AlternativeVerb flushVerb = new();
-                flushVerb.Act = () => Engage(component);
+                flushVerb.Act = () => Engage(uid, component);
                 flushVerb.Text = Loc.GetString("disposal-flush-verb-get-data-text");
                 flushVerb.IconTexture = "/Textures/Interface/VerbIcons/delete_transparent.svg.192dpi.png";
                 flushVerb.Priority = 1;
@@ -104,7 +103,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
                 // Verb to eject the contents
                 AlternativeVerb ejectVerb = new()
                 {
-                    Act = () => TryEjectContents(component),
+                    Act = () => TryEjectContents(uid, component),
                     Category = VerbCategory.Eject,
                     Text = Loc.GetString("disposal-eject-verb-get-data-text")
                 };
@@ -126,11 +125,11 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             // Add verb to climb inside of the unit,
             Verb verb = new()
             {
-                Act = () => TryInsert(component.Owner, args.User, args.User),
+                Act = () => TryInsert(uid, args.User, args.User),
                 DoContactInteraction = true,
                 Text = Loc.GetString("disposal-self-insert-verb-get-data-text")
             };
-            // TODO VERN ICON
+            // TODO VERB ICON
             // TODO VERB CATEGORY
             // create a verb category for "enter"?
             // See also, medical scanner. Also maybe add verbs for entering lockers/body bags?
@@ -156,7 +155,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
                 {
                     _handsSystem.TryDropIntoContainer(args.User, args.Using.Value, component.Container, checkActionBlocker: false, args.Hands);
                     _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(args.User):player} inserted {ToPrettyString(args.Using.Value)} into {ToPrettyString(uid)}");
-                    AfterInsert(component, args.Using.Value);
+                    AfterInsert(uid, component, args.Using.Value);
                 }
             };
 
@@ -167,7 +166,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
         {
             var toInsert = ev.ToInsert;
 
-            if (!EntityManager.TryGetComponent(ev.Unit, out DisposalUnitComponent? unit))
+            if (!TryComp(ev.Unit, out DisposalUnitComponent? unit))
             {
                 return;
             }
@@ -176,20 +175,20 @@ namespace Content.Server.Disposal.Unit.EntitySystems
                 return;
             if (ev.User != null)
                 _adminLogger.Add(LogType.Action, LogImpact.Medium,
-                    $"{ToPrettyString(ev.User.Value):player} inserted {ToPrettyString(toInsert)} into {ToPrettyString(unit.Owner)}");
-            AfterInsert(unit, toInsert);
+                    $"{ToPrettyString(ev.User.Value):player} inserted {ToPrettyString(toInsert)} into {ToPrettyString(ev.Unit)}");
+            AfterInsert(ev.Unit, unit, toInsert);
         }
 
-        public void DoInsertDisposalUnit(EntityUid unit, EntityUid toInsert, EntityUid user, DisposalUnitComponent? disposal = null)
+        public void DoInsertDisposalUnit(EntityUid uid, EntityUid toInsert, EntityUid user, DisposalUnitComponent? disposal = null)
         {
-            if (!Resolve(unit, ref disposal))
+            if (!Resolve(uid, ref disposal))
                 return;
 
             if (!disposal.Container.Insert(toInsert))
                 return;
 
-            _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(user):player} inserted {ToPrettyString(toInsert)} into {ToPrettyString(unit)}");
-            AfterInsert(disposal, toInsert);
+            _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(user):player} inserted {ToPrettyString(toInsert)} into {ToPrettyString(uid)}");
+            AfterInsert(uid, disposal, toInsert);
         }
 
         public override void Update(float frameTime)
@@ -197,10 +196,11 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             base.Update(frameTime);
             foreach (var (_, comp) in EntityQuery<ActiveDisposalUnitComponent, DisposalUnitComponent>())
             {
-                if (!Update(comp, frameTime))
+                var uid = comp.Owner;
+                if (!Update(uid, comp, frameTime))
                     continue;
 
-                RemComp<ActiveDisposalUnitComponent>(comp.Owner);
+                RemComp<ActiveDisposalUnitComponent>(uid);
             }
         }
 
@@ -215,11 +215,11 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             switch (args.Button)
             {
                 case SharedDisposalUnitComponent.UiButton.Eject:
-                    TryEjectContents(component);
+                    TryEjectContents(uid, component);
                     _adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(player):player} hit eject button on {ToPrettyString(uid)}");
                     break;
                 case SharedDisposalUnitComponent.UiButton.Engage:
-                    ToggleEngage(component);
+                    ToggleEngage(uid, component);
                     _adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(player):player} hit flush button on {ToPrettyString(uid)}, it's now {(component.Engaged ? "on" : "off")}");
                     break;
                 case SharedDisposalUnitComponent.UiButton.Power:
@@ -230,17 +230,17 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             }
         }
 
-        public void ToggleEngage(DisposalUnitComponent component)
+        public void ToggleEngage(EntityUid uid, DisposalUnitComponent component)
         {
             component.Engaged ^= true;
 
             if (component.Engaged)
             {
-                Engage(component);
+                Engage(uid, component);
             }
             else
             {
-                Disengage(component);
+                Disengage(uid, component);
             }
         }
         #endregion
@@ -248,13 +248,13 @@ namespace Content.Server.Disposal.Unit.EntitySystems
         #region Eventbus Handlers
         private void HandleActivate(EntityUid uid, DisposalUnitComponent component, ActivateInWorldEvent args)
         {
-            if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
+            if (!TryComp(args.User, out ActorComponent? actor))
             {
                 return;
             }
 
             args.Handled = true;
-            _ui.TryOpen(component.Owner, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, actor.PlayerSession);
+            _ui.TryOpen(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, actor.PlayerSession);
         }
 
         private void HandleAfterInteractUsing(EntityUid uid, DisposalUnitComponent component, AfterInteractUsingEvent args)
@@ -262,7 +262,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             if (args.Handled || !args.CanReach)
                 return;
 
-            if (!EntityManager.HasComponent<HandsComponent>(args.User))
+            if (!HasComp<HandsComponent>(args.User))
             {
                 return;
             }
@@ -273,7 +273,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             }
 
             _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(args.User):player} inserted {ToPrettyString(args.Used)} into {ToPrettyString(uid)}");
-            AfterInsert(component, args.Used);
+            AfterInsert(uid, component, args.Used);
             args.Handled = true;
         }
 
@@ -292,16 +292,16 @@ namespace Content.Server.Disposal.Unit.EntitySystems
 
             if (args.User != null)
                 _adminLogger.Add(LogType.Landed, LogImpact.Low, $"{ToPrettyString(args.Thrown)} thrown by {ToPrettyString(args.User.Value):player} landed in {ToPrettyString(uid)}");
-            AfterInsert(component, args.Thrown);
+            AfterInsert(uid, component, args.Thrown);
         }
 
         private void HandleDisposalInit(EntityUid uid, DisposalUnitComponent component, ComponentInit args)
         {
             component.Container = _containerSystem.EnsureContainer<Container>(uid, SharedDisposalUnitComponent.ContainerId);
 
-            UpdateInterface(component, component.Powered);
+            UpdateInterface(uid, component, component.Powered);
 
-            if (!EntityManager.HasComponent<AnchorableComponent>(component.Owner))
+            if (!HasComp<AnchorableComponent>(uid))
             {
                 Logger.WarningS("VitalComponentMissing", $"Disposal unit {uid} is missing an {nameof(AnchorableComponent)}");
             }
@@ -311,10 +311,10 @@ namespace Content.Server.Disposal.Unit.EntitySystems
         {
             foreach (var entity in component.Container.ContainedEntities.ToArray())
             {
-                component.Container.ForceRemove(entity);
+                component.Container.Remove(entity, force: true);
             }
 
-            _ui.TryCloseAll(component.Owner, SharedDisposalUnitComponent.DisposalUnitUiKey.Key);
+            _ui.TryCloseAll(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key);
             component.AutomaticEngageToken?.Cancel();
             component.AutomaticEngageToken = null;
 
@@ -336,28 +336,28 @@ namespace Content.Server.Disposal.Unit.EntitySystems
                 component.AutomaticEngageToken = null;
             }
 
-            HandleStateChange(component, args.Powered && component.State == SharedDisposalUnitComponent.PressureState.Pressurizing);
-            UpdateVisualState(component);
-            UpdateInterface(component, args.Powered);
+            HandleStateChange(uid, component, args.Powered && component.State == SharedDisposalUnitComponent.PressureState.Pressurizing);
+            UpdateVisualState(uid, component);
+            UpdateInterface(uid, component, args.Powered);
 
-            if (component.Engaged && !TryFlush(component))
+            if (component.Engaged && !TryFlush(uid, component))
             {
-                TryQueueEngage(component);
+                TryQueueEngage(uid, component);
             }
         }
 
         /// <summary>
         /// Add or remove this disposal from the active ones for updating.
         /// </summary>
-        public void HandleStateChange(DisposalUnitComponent component, bool active)
+        public void HandleStateChange(EntityUid uid, DisposalUnitComponent component, bool active)
         {
             if (active)
             {
-                EnsureComp<ActiveDisposalUnitComponent>(component.Owner);
+                EnsureComp<ActiveDisposalUnitComponent>(uid);
             }
             else
             {
-                RemComp<ActiveDisposalUnitComponent>(component.Owner);
+                RemComp<ActiveDisposalUnitComponent>(uid);
             }
         }
 
@@ -365,7 +365,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
         {
             var currentTime = GameTiming.CurTime;
 
-            if (!EntityManager.TryGetComponent(args.Entity, out HandsComponent? hands) ||
+            if (!TryComp(args.Entity, out HandsComponent? hands) ||
                 hands.Count == 0 ||
                 currentTime < component.LastExitAttempt + ExitAttemptDelay)
             {
@@ -373,7 +373,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             }
 
             component.LastExitAttempt = currentTime;
-            Remove(component, args.Entity);
+            Remove(uid, component, args.Entity);
         }
 
         private void OnAnchorChanged(EntityUid uid, DisposalUnitComponent component, ref AnchorStateChangedEvent args)
@@ -381,26 +381,26 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             if (Terminating(uid))
                 return;
 
-            UpdateVisualState(component);
+            UpdateVisualState(uid, component);
             if (!args.Anchored)
-                TryEjectContents(component);
+                TryEjectContents(uid, component);
         }
 
         private void HandleDestruction(EntityUid uid, DisposalUnitComponent component, DestructionEventArgs args)
         {
-            TryEjectContents(component);
+            TryEjectContents(uid, component);
         }
 
         private void HandleDragDropOn(EntityUid uid, DisposalUnitComponent component, DragDropEvent args)
         {
-            args.Handled = TryInsert(component.Owner, args.Dragged, args.User);
+            args.Handled = TryInsert(uid, args.Dragged, args.User);
         }
         #endregion
 
         /// <summary>
         /// Work out if we can stop updating this disposals component i.e. full pressure and nothing colliding.
         /// </summary>
-        private bool Update(DisposalUnitComponent component, float frameTime)
+        private bool Update(EntityUid uid, DisposalUnitComponent component, float frameTime)
         {
             var oldPressure = component.Pressure;
 
@@ -411,40 +411,55 @@ namespace Content.Server.Disposal.Unit.EntitySystems
 
             if (oldPressure < 1 && state == SharedDisposalUnitComponent.PressureState.Ready)
             {
-                UpdateVisualState(component);
-                UpdateInterface(component, component.Powered);
+                UpdateVisualState(uid, component);
+                UpdateInterface(uid, component, component.Powered);
 
                 if (component.Engaged)
                 {
-                    TryFlush(component);
+                    TryFlush(uid, component);
                     state = component.State;
                 }
             }
 
+            if (component.State == SharedDisposalUnitComponent.PressureState.Pressurizing)
+            {
+                var oldTimeElapsed = oldPressure / PressurePerSecond;
+                if (oldTimeElapsed < component.FlushTime && (oldTimeElapsed + frameTime) >= component.FlushTime)
+                {
+                    // We've crossed over the amount of time it takes to flush. This will switch the
+                    // visuals over to a 'Charging' state.
+                    UpdateVisualState(uid, component);
+                }
+            }
+
             Box2? disposalsBounds = null;
             var count = component.RecentlyEjected.Count;
 
             if (count > 0)
             {
-                if (!EntityManager.TryGetComponent(component.Owner, out PhysicsComponent? disposalsBody))
+                if (!TryComp(uid, out PhysicsComponent? disposalsBody))
                 {
                     component.RecentlyEjected.Clear();
                 }
                 else
                 {
-                    disposalsBounds = _lookup.GetWorldAABB(disposalsBody.Owner);
+                    disposalsBounds = _lookup.GetWorldAABB(uid);
                 }
             }
 
             for (var i = component.RecentlyEjected.Count - 1; i >= 0; i--)
             {
-                var uid = component.RecentlyEjected[i];
-                if (EntityManager.EntityExists(uid) &&
-                    EntityManager.TryGetComponent(uid, out PhysicsComponent? body))
+                var ejectedId = component.RecentlyEjected[i];
+                if (Exists(ejectedId) &&
+                    TryComp(ejectedId, out PhysicsComponent? body))
                 {
                     // TODO: We need to use a specific collision method (which sloth hasn't coded yet) for actual bounds overlaps.
                     // Check for itemcomp as we won't just block the disposal unit "sleeping" for something it can't collide with anyway.
-                    if (!EntityManager.HasComponent<ItemComponent>(uid) && _lookup.GetWorldAABB(body.Owner).Intersects(disposalsBounds!.Value)) continue;
+                    if (!HasComp<ItemComponent>(ejectedId)
+                        && _lookup.GetWorldAABB(ejectedId).Intersects(disposalsBounds!.Value))
+                    {
+                        continue;
+                    }
                     component.RecentlyEjected.RemoveAt(i);
                 }
             }
@@ -495,30 +510,30 @@ namespace Content.Server.Disposal.Unit.EntitySystems
         }
 
 
-        public bool TryFlush(DisposalUnitComponent component)
+        public bool TryFlush(EntityUid uid, DisposalUnitComponent component)
         {
-            if (component.Deleted || !CanFlush(component))
+            if (component.Deleted || !CanFlush(uid, component))
             {
                 return false;
             }
 
             //Allows the MailingUnitSystem to add tags or prevent flushing
             var beforeFlushArgs = new BeforeDisposalFlushEvent();
-            RaiseLocalEvent(component.Owner, beforeFlushArgs);
+            RaiseLocalEvent(uid, beforeFlushArgs);
 
             if (beforeFlushArgs.Cancelled)
             {
-                Disengage(component);
+                Disengage(uid, component);
                 return false;
             }
 
-            var xform = Transform(component.Owner);
+            var xform = Transform(uid);
             if (!TryComp(xform.GridUid, out MapGridComponent? grid))
                 return false;
 
             var coords = xform.Coordinates;
             var entry = grid.GetLocal(coords)
-                .FirstOrDefault(entity => EntityManager.HasComponent<DisposalEntryComponent>(entity));
+                .FirstOrDefault(entity => HasComp<DisposalEntryComponent>(entity));
 
             if (entry == default)
             {
@@ -526,8 +541,8 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             }
 
             var air = component.Air;
-            var entryComponent = EntityManager.GetComponent<DisposalEntryComponent>(entry);
-            var indices = _transformSystem.GetGridOrMapTilePosition(component.Owner, xform);
+            var entryComponent = Comp<DisposalEntryComponent>(entry);
+            var indices = _transformSystem.GetGridOrMapTilePosition(uid, xform);
 
             if (_atmosSystem.GetTileMixture(xform.GridUid, xform.MapUid, indices, true) is {Temperature: > 0} environment)
             {
@@ -542,25 +557,25 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             component.AutomaticEngageToken = null;
 
             component.Pressure = 0;
-            component.State = component.Pressure >= 1 ? SharedDisposalUnitComponent.PressureState.Ready : SharedDisposalUnitComponent.PressureState.Pressurizing;
+            component.State = SharedDisposalUnitComponent.PressureState.Pressurizing;
 
             component.Engaged = false;
 
-            HandleStateChange(component, true);
-            UpdateVisualState(component, true);
-            UpdateInterface(component, component.Powered);
+            HandleStateChange(uid, component, true);
+            UpdateVisualState(uid, component, true);
+            UpdateInterface(uid, component, component.Powered);
 
             return true;
         }
 
-        public void UpdateInterface(DisposalUnitComponent component, bool powered)
+        public void UpdateInterface(EntityUid uid, DisposalUnitComponent component, bool powered)
         {
             var stateString = Loc.GetString($"disposal-unit-state-{component.State}");
-            var state = new SharedDisposalUnitComponent.DisposalUnitBoundUserInterfaceState(Name(component.Owner), stateString, EstimatedFullPressure(component), powered, component.Engaged);
-            _ui.TrySetUiState(component.Owner, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, state);
+            var state = new SharedDisposalUnitComponent.DisposalUnitBoundUserInterfaceState(Name(uid), stateString, EstimatedFullPressure(component), powered, component.Engaged);
+            _ui.TrySetUiState(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, state);
 
             var stateUpdatedEvent = new DisposalUnitUIStateUpdatedEvent(state);
-            RaiseLocalEvent(component.Owner, stateUpdatedEvent);
+            RaiseLocalEvent(uid, stateUpdatedEvent);
         }
 
         private TimeSpan EstimatedFullPressure(DisposalUnitComponent component)
@@ -573,59 +588,64 @@ namespace Content.Server.Disposal.Unit.EntitySystems
             return TimeSpan.FromSeconds(currentTime.TotalSeconds + (1.0f - pressure) / PressurePerSecond);
         }
 
-        public void UpdateVisualState(DisposalUnitComponent component)
+        public void UpdateVisualState(EntityUid uid, DisposalUnitComponent component)
         {
-            UpdateVisualState(component, false);
+            UpdateVisualState(uid, component, false);
         }
 
-        public void UpdateVisualState(DisposalUnitComponent component, bool flush)
+        public void UpdateVisualState(EntityUid uid, DisposalUnitComponent component, bool flush)
         {
-            if (!EntityManager.TryGetComponent(component.Owner, out AppearanceComponent? appearance))
+            if (!TryComp(uid, out AppearanceComponent? appearance))
             {
                 return;
             }
 
-            if (!EntityManager.GetComponent<TransformComponent>(component.Owner).Anchored)
+            if (!Comp<TransformComponent>(uid).Anchored)
             {
-                _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.VisualState, SharedDisposalUnitComponent.VisualState.UnAnchored, appearance);
-                _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.Handle, SharedDisposalUnitComponent.HandleState.Normal, appearance);
-                _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.Light, SharedDisposalUnitComponent.LightState.Off, appearance);
+                _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.VisualState, SharedDisposalUnitComponent.VisualState.UnAnchored, appearance);
+                _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.Handle, SharedDisposalUnitComponent.HandleState.Normal, appearance);
+                _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.Light, SharedDisposalUnitComponent.LightStates.Off, appearance);
                 return;
             }
 
-            _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.VisualState, component.Pressure < 1 ? SharedDisposalUnitComponent.VisualState.Charging : SharedDisposalUnitComponent.VisualState.Anchored, appearance);
+            _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.VisualState, component.Pressure < 1 ? SharedDisposalUnitComponent.VisualState.Charging : SharedDisposalUnitComponent.VisualState.Anchored, appearance);
 
-            _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.Handle, component.Engaged
+            _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.Handle, component.Engaged
                 ? SharedDisposalUnitComponent.HandleState.Engaged
                 : SharedDisposalUnitComponent.HandleState.Normal, appearance);
 
             if (!component.Powered)
             {
-                _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.Light, SharedDisposalUnitComponent.LightState.Off, appearance);
+                _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.Light, SharedDisposalUnitComponent.LightStates.Off, appearance);
                 return;
             }
 
+            var lightState = SharedDisposalUnitComponent.LightStates.Off;
             if (flush)
             {
-                _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.VisualState, SharedDisposalUnitComponent.VisualState.Flushing, appearance);
-                _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.Light, SharedDisposalUnitComponent.LightState.Off, appearance);
-                return;
+                _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.VisualState, SharedDisposalUnitComponent.VisualState.Flushing, appearance);
             }
 
             if (component.Container.ContainedEntities.Count > 0)
             {
-                _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.Light, SharedDisposalUnitComponent.LightState.Full, appearance);
-                return;
+                lightState |= SharedDisposalUnitComponent.LightStates.Full;
             }
 
-            _appearance.SetData(component.Owner, SharedDisposalUnitComponent.Visuals.Light, component.Pressure < 1
-                ? SharedDisposalUnitComponent.LightState.Charging
-                : SharedDisposalUnitComponent.LightState.Ready, appearance);
-        }
-
-        public void Remove(DisposalUnitComponent component, EntityUid entity)
+            if (component.Pressure < 1)
             {
-            component.Container.Remove(entity);
+                lightState |= SharedDisposalUnitComponent.LightStates.Charging;
+            }
+            else if (!component.Engaged)
+            {
+                lightState |= SharedDisposalUnitComponent.LightStates.Ready;
+            }
+
+            _appearance.SetData(uid, SharedDisposalUnitComponent.Visuals.Light, lightState, appearance);
+        }
+
+        public void Remove(EntityUid uid, DisposalUnitComponent component, EntityUid toRemove)
+        {
+            component.Container.Remove(toRemove);
 
             if (component.Container.ContainedEntities.Count == 0)
             {
@@ -633,46 +653,48 @@ namespace Content.Server.Disposal.Unit.EntitySystems
                 component.AutomaticEngageToken = null;
             }
 
-            if (!component.RecentlyEjected.Contains(entity))
-                component.RecentlyEjected.Add(entity);
+            if (!component.RecentlyEjected.Contains(toRemove))
+                component.RecentlyEjected.Add(toRemove);
 
             Dirty(component);
-            HandleStateChange(component, true);
-            UpdateVisualState(component);
+            HandleStateChange(uid, component, active: true);
+            UpdateVisualState(uid, component);
         }
 
-        public bool CanFlush(DisposalUnitComponent component)
+        public bool CanFlush(EntityUid unit, DisposalUnitComponent component)
         {
-            return component.State == SharedDisposalUnitComponent.PressureState.Ready && component.Powered && EntityManager.GetComponent<TransformComponent>(component.Owner).Anchored;
+            return component.State == SharedDisposalUnitComponent.PressureState.Ready
+                && component.Powered
+                && Comp<TransformComponent>(unit).Anchored;
         }
 
-        public void Engage(DisposalUnitComponent component)
+        public void Engage(EntityUid uid, DisposalUnitComponent component)
         {
             component.Engaged = true;
-            UpdateVisualState(component);
-            UpdateInterface(component, component.Powered);
+            UpdateVisualState(uid, component);
+            UpdateInterface(uid, component, component.Powered);
 
-            if (CanFlush(component))
+            if (CanFlush(uid, component))
             {
-                component.Owner.SpawnTimer(component.FlushDelay, () => TryFlush(component));
+                uid.SpawnTimer(component.FlushDelay, () => TryFlush(uid, component));
             }
         }
 
-        public void Disengage(DisposalUnitComponent component)
+        public void Disengage(EntityUid uid, DisposalUnitComponent component)
         {
             component.Engaged = false;
-            UpdateVisualState(component);
-            UpdateInterface(component, component.Powered);
+            UpdateVisualState(uid, component);
+            UpdateInterface(uid, component, component.Powered);
         }
 
         /// <summary>
         /// Remove all entities currently in the disposal unit.
         /// </summary>
-        public void TryEjectContents(DisposalUnitComponent component)
+        public void TryEjectContents(EntityUid uid, DisposalUnitComponent component)
         {
             foreach (var entity in component.Container.ContainedEntities.ToArray())
             {
-                Remove(component, entity);
+                Remove(uid, component, entity);
             }
         }
 
@@ -687,7 +709,7 @@ namespace Content.Server.Disposal.Unit.EntitySystems
         /// <summary>
         /// If something is inserted (or the likes) then we'll queue up a flush in the future.
         /// </summary>
-        public void TryQueueEngage(DisposalUnitComponent component)
+        public void TryQueueEngage(EntityUid uid, DisposalUnitComponent component)
         {
             if (component.Deleted || !component.AutomaticEngage || !component.Powered && component.Container.ContainedEntities.Count == 0)
             {
@@ -696,25 +718,25 @@ namespace Content.Server.Disposal.Unit.EntitySystems
 
             component.AutomaticEngageToken = new CancellationTokenSource();
 
-            component.Owner.SpawnTimer(component.AutomaticEngageTime, () =>
+            uid.SpawnTimer(component.AutomaticEngageTime, () =>
             {
-                if (!TryFlush(component))
+                if (!TryFlush(uid, component))
                 {
-                    TryQueueEngage(component);
+                    TryQueueEngage(uid, component);
                 }
             }, component.AutomaticEngageToken.Token);
         }
 
-        public void AfterInsert(DisposalUnitComponent component, EntityUid entity)
+        public void AfterInsert(EntityUid uid, DisposalUnitComponent component, EntityUid inserted)
         {
-            TryQueueEngage(component);
+            TryQueueEngage(uid, component);
 
-            if (EntityManager.TryGetComponent(entity, out ActorComponent? actor))
+            if (TryComp(inserted, out ActorComponent? actor))
             {
-                _ui.TryClose(component.Owner, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, actor.PlayerSession);
+                _ui.TryClose(uid, SharedDisposalUnitComponent.DisposalUnitUiKey.Key, actor.PlayerSession);
             }
 
-            UpdateVisualState(component);
+            UpdateVisualState(uid, component);
         }
     }
 

Content.Shared/Disposal/Components/SharedDisposalUnitComponent.cs

@@ -15,6 +15,8 @@ namespace Content.Shared.Disposal.Components
         /// </summary>
         public List<EntityUid> RecentlyEjected = new();
 
+        [DataField("flushTime", required: true)]
+        public readonly float FlushTime;
 
         [DataField("mobsCanEnter")]
         public bool MobsCanEnter = true;
@@ -44,12 +46,12 @@ namespace Content.Shared.Disposal.Components
         }
 
         [Serializable, NetSerializable]
-        public enum LightState : byte
+        public enum LightStates : byte
         {
-            Off,
-            Charging,
-            Full,
-            Ready
+            Off = 0,
+            Charging = 1 << 0,
+            Full = 1 << 1,
+            Ready = 1 << 2
         }
 
         [Serializable, NetSerializable]

Resources/Prototypes/Entities/Structures/Piping/Disposal/units.yml

@@ -14,11 +14,21 @@
     snapCardinals: true
     layers:
     - state: condisposal
+      map: [ "enum.DisposalUnitVisualLayers.Unanchored" ]
+    - state: disposal
       map: [ "enum.DisposalUnitVisualLayers.Base" ]
-    - state: dispover-handle
-      map: ["enum.DisposalUnitVisualLayers.Handle"]
+    - state: disposal-charging
+      map: [ "enum.DisposalUnitVisualLayers.BaseCharging" ]
+    - state: disposal-flush
+      map: [ "enum.DisposalUnitVisualLayers.BaseFlush" ]
+    - state: dispover-charge
+      map: [ "enum.DisposalUnitVisualLayers.OverlayCharging" ]
     - state: dispover-ready
-      map: ["enum.DisposalUnitVisualLayers.Light"]
+      map: [ "enum.DisposalUnitVisualLayers.OverlayReady" ]
+    - state: dispover-full
+      map: [ "enum.DisposalUnitVisualLayers.OverlayFull" ]
+    - state: dispover-handle
+      map: [ "enum.DisposalUnitVisualLayers.OverlayEngaged" ]
   - type: Physics
     bodyType: Static
   - type: Fixtures
@@ -54,19 +64,6 @@
             min: 1
             max: 1
   - type: Appearance
-    visuals:
-    - type: DisposalUnitVisualizer
-      state_unanchored: condisposal
-      state_anchored: disposal
-      state_charging: disposal-charging
-      overlay_charging: dispover-charge
-      overlay_ready: dispover-ready
-      overlay_full: dispover-full
-      overlay_engaged: dispover-handle
-      state_flush: disposal-flush
-      flush_sound:
-        path: /Audio/Machines/disposalflush.ogg
-      flush_time: 2
   - type: UserInterface
     interfaces:
     - key: enum.DisposalUnitUiKey.Key
@@ -87,6 +84,8 @@
     graph: DisposalMachine
     node: disposal_unit
   - type: DisposalUnit
+    flushSound:
+      path: /Audio/Machines/disposalflush.ogg
     flushTime: 2
   - type: UserInterface
     interfaces:
@@ -104,18 +103,30 @@
     sprite: Structures/Piping/disposal.rsi
     layers:
       - state: conmailing
+        map: [ "enum.DisposalUnitVisualLayers.Unanchored" ]
+      - state: mailing
         map: [ "enum.DisposalUnitVisualLayers.Base" ]
-      - state: mailover-handle
-        map: [ "enum.DisposalUnitVisualLayers.Handle" ]
+      - state: mailing-charging
+        map: [ "enum.DisposalUnitVisualLayers.BaseCharging" ]
+      - state: mailing-flush
+        map: [ "enum.DisposalUnitVisualLayers.BaseFlush" ]
+      - state: dispover-charge
+        map: [ "enum.DisposalUnitVisualLayers.OverlayCharging" ]
       - state: dispover-ready
-        map: [ "enum.DisposalUnitVisualLayers.Light" ]
+        map: [ "enum.DisposalUnitVisualLayers.OverlayReady" ]
+      - state: dispover-full
+        map: [ "enum.DisposalUnitVisualLayers.OverlayFull" ]
+      - state: mailover-handle
+        map: [ "enum.DisposalUnitVisualLayers.OverlayEngaged" ]
   - type: Construction
     graph: DisposalMachine
     node: mailing_unit
   - type: DisposalUnit
-    flushTime: 2
     autoEngageEnabled: false
     mobsCanEnter: false
+    flushSound:
+      path: /Audio/Machines/disposalflush.ogg
+    flushTime: 2
   - type: MailingUnit
   - type: DeviceNetwork
     deviceNetId: Wired
@@ -124,19 +135,6 @@
   - type: WiredNetworkConnection
   - type: Configuration
   - type: Appearance
-    visuals:
-      - type: DisposalUnitVisualizer
-        state_unanchored: conmailing
-        state_anchored: mailing
-        state_charging: mailing-charging
-        overlay_charging: dispover-charge
-        overlay_ready: dispover-ready
-        overlay_full: dispover-full
-        overlay_engaged: mailover-handle
-        state_flush: mailing-flush
-        flush_sound:
-          path: /Audio/Machines/disposalflush.ogg
-        flush_time: 2
   - type: UserInterface
     interfaces:
     - key: enum.MailingUnitUiKey.Key