Airlock / firelock code refactor, pseudo-prediction implementation (#3037)

* splits off airlocks, firelocks

* adds airlock prediction. anims broken though

* fixes animation weirdness

* removes opacity prediction because it looked odd

* Now firelocks don't visually start open. Argh.

* Fixes firelock weirdness, saneifies _state var.

* Documentation changes, code shuffle.

* Lets firelocks crush people.

* Stops open-hand opening/closing firelocks.

* updates serializable, netserializable attributes

* Addresses reviews... hopefully.

* updates submodule?

* nullability

* fuck fuck fuck fuck

* fucking finally

Content.Client/GameObjects/Components/Doors/ClientDoorComponent.cs

@@ -0,0 +1,102 @@
+#nullable enable
+using Content.Shared.GameObjects.Components.Doors;
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+using Robust.Shared.ViewVariables;
+using System;
+
+namespace Content.Client.GameObjects.Components.Doors
+{
+    /// <summary>
+    /// Bare-bones client-side door component; used to stop door-based mispredicts.
+    /// </summary>
+    [UsedImplicitly]
+    [RegisterComponent]
+    [ComponentReference(typeof(SharedDoorComponent))]
+    public class ClientDoorComponent : SharedDoorComponent
+    {
+        private bool _stateChangeHasProgressed = false;
+        private TimeSpan _timeOffset;
+
+        public override DoorState State
+        {
+            protected set
+            {
+                if (State == value)
+                {
+                    return;
+                }
+
+                base.State = value;
+
+                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new DoorStateMessage(this, State));
+            }
+        }
+
+        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
+        {
+            base.HandleComponentState(curState, nextState);
+
+            if (curState is not DoorComponentState doorCompState)
+            {
+                return;
+            }
+
+            CurrentlyCrushing = doorCompState.CurrentlyCrushing;
+            StateChangeStartTime = doorCompState.StartTime;
+            State = doorCompState.DoorState;
+
+            if (StateChangeStartTime == null)
+            {
+                return;
+            }
+
+            _timeOffset = State switch
+            {
+                DoorState.Opening => OpenTimeOne,
+                DoorState.Closing => CloseTimeOne,
+                _ => throw new ArgumentOutOfRangeException(),
+            };
+
+            if (doorCompState.CurTime >= StateChangeStartTime + _timeOffset)
+            {
+                _stateChangeHasProgressed = true;
+                return;
+            }
+
+            _stateChangeHasProgressed = false;
+        }
+
+        public void OnUpdate()
+        {
+            if (!_stateChangeHasProgressed)
+            {
+                if (GameTiming.CurTime < StateChangeStartTime + _timeOffset) return;
+
+                if (State == DoorState.Opening)
+                {
+                    OnPartialOpen();
+                }
+                else
+                {
+                    OnPartialClose();
+                }
+
+                _stateChangeHasProgressed = true;
+                Dirty();
+            }
+        }
+    }
+
+    public sealed class DoorStateMessage : EntitySystemMessage
+    {
+        public ClientDoorComponent Component { get; }
+        public SharedDoorComponent.DoorState State { get; }
+
+        public DoorStateMessage(ClientDoorComponent component, SharedDoorComponent.DoorState state)
+        {
+            Component = component;
+            State = state;
+        }
+    }
+}