teleporter-WWDP

Content.Server/Backmen/Teleporter/ExperimentalTeleporterComponent.cs

@@ -0,0 +1,28 @@
+using Robust.Shared.Audio;
+
+namespace Content.Server._White.Teleporter;
+
+[RegisterComponent]
+public sealed partial class ExperimentalTeleporterComponent : Component
+{
+    [DataField]
+    public int MinTeleportRange = 3;
+
+    [DataField]
+    public int MaxTeleportRange = 8;
+
+    [DataField]
+    public int EmergencyLength = 4;
+
+    [DataField]
+    public List<int> RandomRotations = new() {90, -90};
+
+    [DataField]
+    public string? TeleportInEffect = "ExperimentalTeleporterInEffect";
+
+    [DataField]
+    public string? TeleportOutEffect = "ExperimentalTeleporterOutEffect";
+
+    [DataField]
+    public SoundSpecifier TeleportSound = new SoundPathSpecifier("/Audio/Backman/Object/Devices/experimentalsyndicateteleport.ogg");
+}

Content.Server/Backmen/Teleporter/ExperimentalTeleporterSystem.cs

@@ -0,0 +1,114 @@
+using System.Linq;
+using System.Numerics;
+using Content.Server.Body.Systems;
+using Content.Server.Standing;
+using Content.Shared.Charges.Systems;
+using Content.Shared.Coordinates.Helpers;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Maps;
+using Content.Shared.Tag;
+using Robust.Server.Audio;
+using Robust.Server.Containers;
+using Robust.Server.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Random;
+
+namespace Content.Server._White.Teleporter;
+
+public sealed class ExperimentalTeleporterSystem : EntitySystem
+{
+    [Dependency] private readonly TransformSystem _transform = default!;
+    [Dependency] private readonly BodySystem _bodySystem = default!;
+    [Dependency] private readonly MapSystem _mapSystem = default!;
+    [Dependency] private readonly IEntityManager _entManager = default!;
+    [Dependency] private readonly AudioSystem _audio = default!;
+    [Dependency] private readonly ContainerSystem _containerSystem = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly SharedLayingDownSystem _layingDown = default!;
+    [Dependency] private readonly SharedChargesSystem _charges = default!;
+    [Dependency] private readonly TagSystem _tag = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<ExperimentalTeleporterComponent, UseInHandEvent>(OnUse);
+    }
+
+    private void OnUse(EntityUid uid, ExperimentalTeleporterComponent component, UseInHandEvent args)
+    {
+        if (_charges.IsEmpty(uid)
+            || !TryComp<TransformComponent>(args.User, out var xform)
+            || (_containerSystem.IsEntityInContainer(args.User)
+                && !_containerSystem.TryRemoveFromContainer(args.User)))
+            return;
+
+        var oldCoords = xform.Coordinates;
+        var range = _random.Next(component.MinTeleportRange, component.MaxTeleportRange);
+        var offset = xform.LocalRotation.ToWorldVec().Normalized();
+        var direction = xform.LocalRotation.GetDir().ToVec();
+        var newOffset = offset + direction * range;
+
+        var coords = xform.Coordinates.Offset(newOffset).SnapToGrid(EntityManager);
+
+        Teleport(args.User, uid, component, coords, oldCoords);
+
+        if (!TryCheckWall(coords)
+            || EmergencyTeleportation(args.User, uid, component, xform, oldCoords, newOffset))
+            return;
+
+        _bodySystem.GibBody(args.User, true, splatModifier: 3F);
+    }
+
+    private bool EmergencyTeleportation(EntityUid uid, EntityUid teleporterUid, ExperimentalTeleporterComponent component, TransformComponent xform, EntityCoordinates oldCoords, Vector2 offset)
+    {
+        var newOffset = offset + VectorRandomDirection(component, offset, component.EmergencyLength);
+        var coords = xform.Coordinates.Offset(newOffset).SnapToGrid(EntityManager);
+
+        if (_charges.IsEmpty(teleporterUid))
+            return false;
+
+        Teleport(uid, teleporterUid, component, coords, oldCoords);
+
+        return !TryCheckWall(coords);
+    }
+
+    private void Teleport(EntityUid uid, EntityUid teleporterUid, ExperimentalTeleporterComponent component, EntityCoordinates coords, EntityCoordinates oldCoords)
+    {
+        PlaySoundAndEffects(component, coords, oldCoords);
+
+        _layingDown.LieDownInRange(uid, coords);
+        _transform.SetCoordinates(uid, coords);
+
+        _charges.UseCharge(teleporterUid);
+    }
+
+    private void PlaySoundAndEffects(ExperimentalTeleporterComponent component, EntityCoordinates coords, EntityCoordinates oldCoords)
+    {
+        _audio.PlayPvs(component.TeleportSound, coords);
+        _audio.PlayPvs(component.TeleportSound, oldCoords);
+
+        _entManager.SpawnEntity(component.TeleportInEffect, coords);
+        _entManager.SpawnEntity(component.TeleportOutEffect, oldCoords);
+    }
+
+    private bool TryCheckWall(EntityCoordinates coords)
+    {
+        if (!coords.TryGetTileRef(out var tile)
+            || !TryComp<MapGridComponent>(tile.Value.GridUid, out var mapGridComponent))
+            return false;
+
+        var anchoredEntities = _mapSystem.GetAnchoredEntities(tile.Value.GridUid, mapGridComponent, coords);
+
+        return anchoredEntities.Any(x => _tag.HasTag(x, "Wall"));
+    }
+
+    private Vector2 VectorRandomDirection(ExperimentalTeleporterComponent component, Vector2 offset, int length)
+    {
+        if (component.RandomRotations.Count == 0)
+            return Vector2.Zero;
+
+        var randomRotation = _random.Next(0, component.RandomRotations.Count);
+        return Angle.FromDegrees(component.RandomRotations[randomRotation]).RotateVec(offset.Normalized() * length);
+    }
+}

Content.Shared/Standing/SharedLayingDownSystem.cs

@@ -0,0 +1,216 @@
+using System.Linq;
+using Content.Shared.ActionBlocker;
+using Content.Shared.CCVar;
+using Content.Shared.DoAfter;
+using Content.Shared.Gravity;
+using Content.Shared.Input;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.Movement.Systems;
+using Content.Shared.Body.Components;
+using Content.Shared.Standing;
+using Content.Shared.Popups;
+using Content.Shared.Stunnable;
+using Robust.Shared.Configuration;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.Map;
+using Robust.Shared.Player;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Standing;
+
+public abstract class SharedLayingDownSystem : EntitySystem
+{
+    [Dependency] private readonly IConfigurationManager _config = default!;
+
+    [Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!; // WWDP
+    [Dependency] private readonly MobStateSystem _mobState = default!;
+    [Dependency] private readonly MovementSpeedModifierSystem _speed = default!;
+    [Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
+    [Dependency] private readonly SharedGravitySystem _gravity = default!;
+    [Dependency] private readonly SharedPopupSystem _popups = default!;
+    [Dependency] private readonly StandingStateSystem _standing = default!;
+
+    public override void Initialize()
+    {
+        CommandBinds.Builder
+            .Bind(ContentKeyFunctions.ToggleStanding, InputCmdHandler.FromDelegate(ToggleStanding))
+            .Bind(ContentKeyFunctions.ToggleCrawlingUnder,
+                InputCmdHandler.FromDelegate(HandleCrawlUnderRequest, handle: false))
+            .Register<SharedLayingDownSystem>();
+
+        SubscribeNetworkEvent<ChangeLayingDownEvent>(OnChangeState);
+
+        SubscribeLocalEvent<StandingStateComponent, StandingUpDoAfterEvent>(OnStandingUpDoAfter);
+        SubscribeLocalEvent<LayingDownComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshMovementSpeed);
+        SubscribeLocalEvent<LayingDownComponent, EntParentChangedMessage>(OnParentChanged);
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+
+        CommandBinds.Unregister<SharedLayingDownSystem>();
+    }
+
+    private void ToggleStanding(ICommonSession? session)
+    {
+        if (session is not { AttachedEntity: { Valid: true } uid } _
+            || !Exists(uid)
+            || !HasComp<LayingDownComponent>(session.AttachedEntity)
+            || _gravity.IsWeightless(session.AttachedEntity.Value))
+            return;
+
+        RaiseNetworkEvent(new ChangeLayingDownEvent());
+    }
+
+    private void HandleCrawlUnderRequest(ICommonSession? session)
+    {
+        if (session == null
+            || session.AttachedEntity is not { } uid
+            || !TryComp<StandingStateComponent>(uid, out var standingState)
+            || !TryComp<LayingDownComponent>(uid, out var layingDown)
+            || !_actionBlocker.CanInteract(uid, null))
+            return;
+
+        var newState = !layingDown.IsCrawlingUnder;
+        if (standingState.CurrentState is StandingState.Standing)
+            newState = false; // If the entity is already standing, this function only serves a fallback method to fix its draw depth
+
+        // Do not allow to begin crawling under if it's disabled in config. We still, however, allow to stop it, as a failsafe.
+        if (newState && !_config.GetCVar(CCVars.CrawlUnderTables))
+        {
+            _popups.PopupEntity(Loc.GetString("crawling-under-tables-disabled-popup"), uid, session);
+            return;
+        }
+
+        layingDown.IsCrawlingUnder = newState;
+        _speed.RefreshMovementSpeedModifiers(uid);
+        Dirty(uid, layingDown);
+    }
+
+    private void OnChangeState(ChangeLayingDownEvent ev, EntitySessionEventArgs args)
+    {
+        if (!args.SenderSession.AttachedEntity.HasValue)
+            return;
+
+        var uid = args.SenderSession.AttachedEntity.Value;
+        if (!TryComp(uid, out StandingStateComponent? standing)
+            || !TryComp(uid, out LayingDownComponent? layingDown))
+            return;
+
+        RaiseNetworkEvent(new CheckAutoGetUpEvent(GetNetEntity(uid)));
+
+        if (HasComp<KnockedDownComponent>(uid)
+            || !_mobState.IsAlive(uid))
+            return;
+
+        if (_standing.IsDown(uid, standing))
+            TryStandUp(uid, layingDown, standing);
+        else
+            TryLieDown(uid, layingDown, standing);
+    }
+
+    private void OnStandingUpDoAfter(EntityUid uid, StandingStateComponent component, StandingUpDoAfterEvent args)
+    {
+        if (args.Handled || args.Cancelled
+                         || HasComp<KnockedDownComponent>(uid)
+                         || _mobState.IsIncapacitated(uid)
+                         || !_standing.Stand(uid))
+            component.CurrentState = StandingState.Lying;
+
+        component.CurrentState = StandingState.Standing;
+    }
+
+    private void OnRefreshMovementSpeed(EntityUid uid,
+        LayingDownComponent component,
+        RefreshMovementSpeedModifiersEvent args)
+    {
+        if (!_standing.IsDown(uid))
+            return;
+
+        var modifier = component.LyingSpeedModifier *
+                       (component.IsCrawlingUnder ? component.CrawlingUnderSpeedModifier : 1);
+        args.ModifySpeed(modifier, modifier);
+    }
+
+    private void OnParentChanged(EntityUid uid, LayingDownComponent component, EntParentChangedMessage args)
+    {
+        // If the entity is not on a grid, try to make it stand up to avoid issues
+        if (!TryComp<StandingStateComponent>(uid, out var standingState)
+            || standingState.CurrentState is StandingState.Standing
+            || Transform(uid).GridUid != null)
+            return;
+
+        _standing.Stand(uid, standingState);
+    }
+
+    public bool TryStandUp(EntityUid uid,
+        LayingDownComponent? layingDown = null,
+        StandingStateComponent? standingState = null)
+    {
+        if (!Resolve(uid, ref standingState, false)
+            || !Resolve(uid, ref layingDown, false)
+            || standingState.CurrentState is not StandingState.Lying
+            || !_mobState.IsAlive(uid)
+            || TerminatingOrDeleted(uid)
+            || !TryComp<BodyComponent>(uid, out var body)
+            || body.LegEntities.Count == 0)
+            return false;
+
+        var args = new DoAfterArgs(EntityManager, uid, layingDown.StandingUpTime, new StandingUpDoAfterEvent(), uid)
+        {
+            BreakOnHandChange = false,
+            RequireCanInteract = false
+        };
+
+        if (!_doAfter.TryStartDoAfter(args))
+            return false;
+
+        standingState.CurrentState = StandingState.GettingUp;
+        layingDown.IsCrawlingUnder = false;
+        return true;
+    }
+
+    public bool TryLieDown(EntityUid uid,
+        LayingDownComponent? layingDown = null,
+        StandingStateComponent? standingState = null,
+        DropHeldItemsBehavior behavior = DropHeldItemsBehavior.NoDrop)
+    {
+        if (!Resolve(uid, ref standingState, false)
+            || !Resolve(uid, ref layingDown, false)
+            || standingState.CurrentState is not StandingState.Standing)
+        {
+            if (behavior == DropHeldItemsBehavior.AlwaysDrop)
+                RaiseLocalEvent(uid, new DropHandItemsEvent());
+
+            return false;
+        }
+
+        _standing.Down(uid, true, behavior != DropHeldItemsBehavior.NoDrop, standingState);
+        return true;
+    }
+
+    // WWDP
+    public void LieDownInRange(EntityUid uid, EntityCoordinates coords, float range = 0.4f)
+    {
+        var ents = new HashSet<Entity<LayingDownComponent>>();
+        _lookup.GetEntitiesInRange(coords, range, ents);
+
+        foreach (var ent in ents.Where(ent => ent.Owner != uid))
+        {
+            TryLieDown(ent, behavior: DropHeldItemsBehavior.DropIfStanding);
+        }
+    }
+}
+
+[Serializable, NetSerializable]
+public sealed partial class StandingUpDoAfterEvent : SimpleDoAfterEvent;
+
+[Serializable, NetSerializable]
+public enum DropHeldItemsBehavior : byte
+{
+    NoDrop,
+    DropIfStanding,
+    AlwaysDrop
+}

Resources/Audio/Backmen/Object/Devices/attributions.yml

@@ -0,0 +1,4 @@
+- files: ["experimentalsyndicateteleport.ogg"]
+  license: "CC-BY-NC-SA-4.0"
+  copyright: "Taken from White Dream"
+  source: "https://github.com/frosty-dev/ss14-core/blob/master/Resources/Audio/White/Devices/expsyndicateteleport.ogg"

Resources/Locale/en-US/_backmen/store/uplink-catalog.ftl

@@ -0,0 +1,11 @@
+uplink-emp-flashlight-name = Emp Flashlight
+uplink-emp-flashlight-desc = A rechargeable device disguised as a flashlight designed to disrupt electronic systems. Useful for disrupting communications, security's energy weapons, and APCs when you're in a tight spot.
+
+uplink-betrayal-knife-name = Betrayal dagger
+uplink-betrayal-knife-desc = The betrayal dagger allows the user to teleport a short distance, and also causes significant damage when stabbed in the back.
+
+uplink-betrayal-knife-name = Experimental syndicate teleporter
+uplink-betrayal-knife-desc = Syndicate teleporter, when used, moves 3-8 meters forward. In case of teleportation into a wall, uses emergency teleportation. Has 4 charge.
+
+uplink-ebow-name = Small energy crossbow
+uplink-ebow-desc = A fairly quiet weapon that automatically reloads and stuns. It goes well with other types of weapons.

Resources/Locale/ru-RU/_backmen/Entities/Objects/device/syndicate_gadgets/experimental-teleporter.ftl

@@ -0,0 +1,2 @@
+ent-ExperimentalSyndicateTeleporter = экспериментальный телепортер синдиката
+  .desc = Телепортер синдиката, при использовании перемещает на 3-8 метров вперед. В случае телепортации в стену, использует экстренную телепортацию. Имеет 4 заряда и автоматически заряжается.

Resources/Locale/ru-RU/_backmen/store/uplink-catalog.ftl

@@ -0,0 +1,5 @@
+uplink-experimental-syndicate-teleporter-name = Экспериментальный телепортер синдиката
+uplink-experimental-syndicate-teleporter-desc = Телепортер синдиката, при использовании перемещает на 3-8 метров вперед. В случае телепортации в стену, использует экстренную телепортацию. Имеет 4 заряда и автоматически заряжается.
+
+uplink-ebow-name = Маленький энергетический арбалет
+uplink-ebow-desc = Довольно тихое оружие, которое автоматически перезаряжается и оглушает. Хорошо сочетается с другими видами оружия.