Порт лестниц из Маринов

Content.Client/_RMC14/Ladder/LadderSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared._RMC14.Ladder;
+
+namespace Content.Client._RMC14.Ladder;
+
+public sealed class LadderSystem : SharedLadderSystem;

Content.Client/_RMC14/Teleporter/RMCTeleporterSystem.cs

@@ -0,0 +1,20 @@
+using Content.Shared._RMC14.Teleporter;
+using Robust.Client.Graphics;
+
+namespace Content.Client._RMC14.Teleporter;
+
+public sealed class RMCTeleporterSystem : SharedRMCTeleporterSystem
+{
+    [Dependency] private readonly IOverlayManager _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _overlay.AddOverlay(new RMCTeleporterViewerOverlay());
+    }
+
+    public override void Shutdown()
+    {
+        _overlay.RemoveOverlay<RMCTeleporterViewerOverlay>();
+    }
+}

Content.Client/_RMC14/Teleporter/RMCTeleporterViewerOverlay.cs

@@ -0,0 +1,100 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+using Content.Shared._RMC14.Teleporter;
+using Content.Shared.Physics;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Containers;
+
+namespace Content.Client._RMC14.Teleporter;
+
+public sealed class RMCTeleporterViewerOverlay : Overlay
+{
+    [Dependency] private readonly IEntityManager _entity = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly IOverlayManager _overlay = default!;
+
+    private readonly SharedContainerSystem _container;
+    private readonly EntityLookupSystem _entityLookup;
+    private readonly Robust.Client.Physics.PhysicsSystem _physics;
+    private readonly SharedRMCTeleporterSystem _teleporter;
+    private readonly SharedTransformSystem _transform;
+
+    private readonly EntityQuery<SpriteComponent> _spriteQuery;
+    private readonly EntityQuery<RMCTeleporterViewerComponent> _teleporterViewerQuery;
+    private readonly EntityQuery<TransformComponent> _transformQuery;
+
+    private readonly List<(Entity<SpriteComponent> Ent, Vector2 Position, Angle Rotation)> _toDraw = new();
+
+    public RMCTeleporterViewerOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+
+        _container = _entity.System<SharedContainerSystem>();
+        _entityLookup = _entity.System<EntityLookupSystem>();
+        _physics = _entity.System<Robust.Client.Physics.PhysicsSystem>();
+        _teleporter = _entity.System<SharedRMCTeleporterSystem>();
+        _transform = _entity.System<SharedTransformSystem>();
+
+        _spriteQuery = _entity.GetEntityQuery<SpriteComponent>();
+        _teleporterViewerQuery = _entity.GetEntityQuery<RMCTeleporterViewerComponent>();
+        _transformQuery = _entity.GetEntityQuery<TransformComponent>();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (_player.LocalEntity is not { } player)
+            return;
+
+        var handle = args.WorldHandle;
+        var eye = args.Viewport.Eye;
+        var eyeRot = eye?.Rotation ?? default;
+        foreach (var selfContact in _physics.GetEntitiesIntersectingBody(player, (int) CollisionGroup.MobLayer))
+        {
+            if (!_teleporterViewerQuery.TryComp(selfContact, out var viewer))
+                continue;
+
+            var viewerPosition = _transform.GetWorldPosition(selfContact);
+            foreach (var otherViewer in _teleporter.GetMatchingTeleporterViewers((selfContact, viewer)))
+            {
+                var otherViewerPosition = _transform.GetMapCoordinates(otherViewer);
+                var viewerPositionDiff = otherViewerPosition.Position - viewerPosition;
+                var otherViewerAABB = _physics.GetWorldAABB(otherViewer);
+
+                _toDraw.Clear();
+                foreach (var viewerContact in _entityLookup.GetEntitiesIntersecting(otherViewerPosition.MapId, otherViewerAABB, LookupFlags.Uncontained))
+                {
+                    if (!_spriteQuery.TryComp(viewerContact, out var viewerContactSprite) ||
+                        !viewerContactSprite.Visible ||
+                        !_transformQuery.TryComp(viewerContact, out var viewerContactTransform))
+                    {
+                        continue;
+                    }
+
+                    if (_container.IsEntityInContainer(viewerContact))
+                        continue;
+
+                    if (viewerContactTransform.Anchored)
+                        continue;
+
+                    // technically you could use try delta here for the vast majority of cases
+                    // since they share a parent entity uid but i don't got time to do that
+                    // good luck future coder
+                    var (position, rotation) = _transform.GetWorldPositionRotation(viewerContactTransform);
+                    _toDraw.Add(((viewerContact, viewerContactSprite), position, rotation));
+                }
+
+                _toDraw.Sort((a, b) => a.Ent.Comp.DrawDepth.CompareTo(b.Ent.Comp.DrawDepth));
+
+                foreach (ref var draw in CollectionsMarshal.AsSpan(_toDraw))
+                {
+                    draw.Position -= viewerPositionDiff;
+                    draw.Ent.Comp.Render(handle, eyeRot, draw.Rotation, position: draw.Position);
+                }
+            }
+        }
+
+        handle.SetTransform(Matrix3x2.Identity);
+    }
+}

Content.Server/_RMC14/Ladder/LadderSystem.cs

@@ -0,0 +1,87 @@
+using Content.Shared._RMC14.Ladder;
+using Robust.Server.GameObjects;
+using Robust.Shared.Player;
+
+namespace Content.Server._RMC14.Ladder;
+
+public sealed class LadderSystem : SharedLadderSystem
+{
+    [Dependency] private readonly SharedEyeSystem _eye = default!;
+    [Dependency] private readonly ViewSubscriberSystem _viewSubscriber = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<LadderWatchingComponent, ComponentRemove>(OnWatchingRemove);
+        SubscribeLocalEvent<LadderWatchingComponent, EntityTerminatingEvent>(OnWatchingRemove);
+    }
+
+    private void OnWatchingRemove<T>(Entity<LadderWatchingComponent> ent, ref T args)
+    {
+        RemoveWatcher(ent);
+    }
+
+    protected override void Watch(Entity<ActorComponent?, EyeComponent?> watcher, Entity<LadderComponent?> toWatch)
+    {
+        base.Watch(watcher, toWatch);
+
+        if (!Resolve(toWatch, ref toWatch.Comp, false))
+            return;
+
+        if (watcher.Owner == toWatch.Owner)
+            return;
+
+        if (!Resolve(watcher, ref watcher.Comp1, ref watcher.Comp2) ||
+            !Resolve(toWatch, ref toWatch.Comp))
+        {
+            return;
+        }
+
+        _eye.SetTarget(watcher, toWatch, watcher);
+        _viewSubscriber.AddViewSubscriber(toWatch, watcher.Comp1.PlayerSession);
+
+        RemoveWatcher(watcher);
+        EnsureComp<LadderWatchingComponent>(watcher).Watching = toWatch;
+        toWatch.Comp.Watching.Add(watcher);
+    }
+
+    protected override void Unwatch(Entity<EyeComponent?> watcher, ICommonSession player)
+    {
+        if (!Resolve(watcher, ref watcher.Comp))
+            return;
+
+        var oldTarget = watcher.Comp.Target;
+
+        base.Unwatch(watcher, player);
+
+        if (oldTarget != null && oldTarget != watcher.Owner)
+            _viewSubscriber.RemoveViewSubscriber(oldTarget.Value, player);
+
+        RemoveWatcher(watcher);
+    }
+
+    private void RemoveWatcher(EntityUid toRemove)
+    {
+        if (!TryComp(toRemove, out LadderWatchingComponent? watching))
+            return;
+
+        if (TryComp(watching.Watching, out LadderComponent? watched))
+            watched.Watching.Remove(toRemove);
+
+        watching.Watching = null;
+        RemCompDeferred<LadderWatchingComponent>(toRemove);
+    }
+
+    protected override void AddViewer(Entity<LadderComponent> ent, ICommonSession player)
+    {
+        base.AddViewer(ent, player);
+        _viewSubscriber.AddViewSubscriber(ent, player);
+    }
+
+    protected override void RemoveViewer(Entity<LadderComponent> ent, ICommonSession player)
+    {
+        base.RemoveViewer(ent, player);
+        _viewSubscriber.RemoveViewSubscriber(ent, player);
+    }
+}

Content.Server/_RMC14/Teleporter/RMCTeleporterSystem.cs

@@ -0,0 +1,22 @@
+using Content.Shared._RMC14.Teleporter;
+using Robust.Server.GameObjects;
+using Robust.Shared.Player;
+
+namespace Content.Server._RMC14.Teleporter;
+
+public sealed class RMCTeleporterSystem : SharedRMCTeleporterSystem
+{
+    [Dependency] private readonly ViewSubscriberSystem _viewSubscriber = default!;
+
+    protected override void AddViewer(Entity<RMCTeleporterViewerComponent> viewer, ICommonSession player)
+    {
+        base.AddViewer(viewer, player);
+        _viewSubscriber.AddViewSubscriber(viewer, player);
+    }
+
+    protected override void RemoveViewer(Entity<RMCTeleporterViewerComponent> viewer, ICommonSession player)
+    {
+        base.RemoveViewer(viewer, player);
+        _viewSubscriber.RemoveViewSubscriber(viewer, player);
+    }
+}

Content.Shared/_RMC14/Ladder/LadderComponent.cs

@@ -0,0 +1,33 @@
+using Content.Shared.Interaction;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._RMC14.Ladder;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
+[Access(typeof(SharedLadderSystem))]
+public sealed partial class LadderComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public string? Id;
+
+    [DataField, AutoNetworkedField]
+    public EntityUid? Other;
+
+    [DataField, AutoNetworkedField]
+    public TimeSpan Delay = TimeSpan.FromSeconds(2);
+
+    [DataField, AutoNetworkedField]
+    public float Range = SharedInteractionSystem.InteractionRange + 0.1f;
+
+    [DataField, AutoNetworkedField]
+    public EntityUid? LastDoAfterEnt;
+
+    [DataField, AutoNetworkedField]
+    public ushort? LastDoAfterId;
+
+    [DataField, AutoNetworkedField, AutoPausedField]
+    public TimeSpan LastDoAfterTime;
+
+    [DataField, AutoNetworkedField]
+    public HashSet<EntityUid> Watching = new();
+}

Content.Shared/_RMC14/Ladder/LadderDoAfterEvent.cs

@@ -0,0 +1,7 @@
+using Content.Shared.DoAfter;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared._RMC14.Ladder;
+
+[Serializable, NetSerializable]
+public sealed partial class LadderDoAfterEvent : SimpleDoAfterEvent;

Content.Shared/_RMC14/Ladder/LadderWatchingComponent.cs

@@ -0,0 +1,11 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._RMC14.Ladder;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[Access(typeof(SharedLadderSystem))]
+public sealed partial class LadderWatchingComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public EntityUid? Watching;
+}