Чудо-Юдо. Новый монстр Недр. H/M

Content.Server/Imperial/SCP/NothingThere/Components/ImperialControlledNothingThereComponent.cs

@@ -0,0 +1,30 @@
+using Robust.Shared.Map;
+using Robust.Shared.Audio;
+using Content.Shared.Chat.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+using Content.Shared.Damage;
+using Robust.Shared.Prototypes;
+using Content.Shared.FixedPoint;
+using Content.Shared.Mobs.Systems;
+namespace Content.Server.Imperial.SCP.NothingThere.Components;
+
+[RegisterComponent]
+public sealed partial class ImperialControlledNothingThereComponent : Component
+{
+    [DataField("gibBodyAction")]
+    public EntProtoId GibBodyAction = "ImperialNothingThereGibBodyAction";
+    [ViewVariables]
+    public EntityUid? GibBodyEntity;
+    [ViewVariables]
+    public EntityUid OriginalBody = EntityUid.Invalid;
+    [ViewVariables]
+    public SoundSpecifier ExitSound = new SoundPathSpecifier("/Audio/Imperial/SCP/nothingthere_gibbody.ogg");
+    [ViewVariables]
+    public int KillCount = 0;
+    [ViewVariables]
+    public SoundSpecifier GibSound = new SoundCollectionSpecifier("gib", AudioParams.Default.WithVariation(0.025f));
+    [ViewVariables]
+    public float GibletLaunchImpulse = 150;
+    [ViewVariables]
+    public float GibletLaunchImpulseVariance = 3;
+}

Content.Server/Imperial/SCP/NothingThere/Components/ImperialNothingThereComponent.cs

@@ -0,0 +1,93 @@
+using Robust.Shared.Map;
+using Robust.Shared.Audio;
+using Content.Shared.Chat.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+using Content.Shared.Damage;
+using Robust.Shared.Prototypes;
+using Content.Shared.FixedPoint;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.Mobs;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.Polymorph;
+namespace Content.Server.Imperial.SCP.NothingThere.Components;
+
+[RegisterComponent]
+public sealed partial class ImperialNothingThereComponent : Component
+{
+    public SoundSpecifier ChaseSound = new SoundPathSpecifier("/Audio/Imperial/SCP/nothingthere_idle.ogg");
+
+    [ViewVariables]
+    public EntityUid? PlayingStream;
+
+    [ViewVariables]
+    public bool IsPlaying = false;
+    [DataField("enterBodyAction")]
+    public EntProtoId EnterBodyAction = "ImperialNothingThereEnterBodyAction";
+    public EntityUid? EnterBodyEntity;
+
+    [DataField]
+    public TimeSpan EnterBodyWindUp = TimeSpan.FromSeconds(2);
+    [DataField("threshold", required: true)]
+    public FixedPoint2 Threshold = new();
+    [DataField("killsRequired")]
+    public int KillsRequired = 5;
+
+    [DataField("killCount")]
+    public int KillCount = 0;
+
+    [DataField("phase")]
+    public NothingTherePhase Phase = NothingTherePhase.Original;
+    public EntProtoId? EggEntityProto = "ImperialSCPNothingThereEgg";
+    [DataField("transformEggAction")]
+    public EntProtoId TransformEggAction = "ImperialNothingThereEggAction";
+    [DataField("transformEggEntity")]
+    public EntityUid? TransformEggEntity;
+    [DataField("enterSound")]
+    public SoundSpecifier EnterSound = new SoundPathSpecifier("/Audio/Imperial/SCP/nothingthere_enter.ogg");
+
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    public TimeSpan EggTransformDuration = TimeSpan.FromSeconds(30);
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    public TimeSpan EggTransformEnd = TimeSpan.Zero;
+    [ViewVariables]
+    public EntProtoId? TrueEntityProto = "ImperialSCPNothingThereTrue";
+    [DataField("hatchSound")]
+    public SoundSpecifier HatchSound = new SoundPathSpecifier("/Audio/Imperial/SCP/nothingthere_hatch.ogg");
+    [ViewVariables]
+    public bool Empowered = false;
+    [DataField("empowerAction")]
+    public EntProtoId EmpowerAction = "ImperialNothingThereHelloAction";
+    [DataField("empowerEntity")]
+    public EntityUid? EmpowerEntity;
+    [DataField("empowerSound")]
+    public SoundSpecifier EmpowerSound = new SoundPathSpecifier("/Audio/Imperial/SCP/nothingthere_empower.ogg");
+    [DataField(required: true), ViewVariables]
+    public DamageSpecifier EmpowerDamage = new();
+    [ViewVariables]
+    public ProtoId<PolymorphPrototype> EggMorph = "NothingThereEggMorph";
+    [ViewVariables]
+    public ProtoId<PolymorphPrototype> TrueMorph = "NothingThereTrueMorph";
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    [ViewVariables]
+    public TimeSpan GoodbyeDelay = TimeSpan.FromSeconds(0.5f);
+    [ViewVariables]
+    public EntProtoId GoodbyeProto = "ImperialNothingThereEmpowerHit";
+    [ViewVariables]
+    public EntProtoId HitProto = "ImperialNothingThereHit";
+    [DataField]
+    public bool NeedItems = false;
+    [ViewVariables]
+    public bool NeedGoodbye = false;
+    [DataField("projectileAction")]
+    public EntProtoId ProjectileAction = "ImperialNothingThereProjectileAction";
+    [DataField("projectileEntity")]
+    public EntityUid? ProjectileEntity;
+}
+
+public enum NothingTherePhase : byte
+{
+    Original = 0,
+    Egg = 1,
+    True = 2
+}

Content.Server/Imperial/SCP/NothingThere/Components/ImperialNothingThereGoodbyeComponent.cs

@@ -0,0 +1,19 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Audio;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+[RegisterComponent]
+public sealed partial class ImperialNothingThereGoodbyeComponent : Component
+{
+    [ViewVariables]
+    public bool Used = false;
+    [ViewVariables]
+    public EntProtoId HitProto = "ImperialNothingThereHit";
+    [DataField("empowerSound")]
+    public SoundSpecifier EmpowerSound = new SoundPathSpecifier("/Audio/Imperial/SCP/nothingthere_empower.ogg");
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    public TimeSpan AttackDuration = TimeSpan.FromSeconds(1.5);
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    public TimeSpan AttackEnd = TimeSpan.Zero;
+    [ViewVariables]
+    public EntityUid WeaponUser = EntityUid.Invalid;
+}

Content.Server/Imperial/SCP/NothingThere/Systems/ImperialNothingThere.ChaseMusic.cs

@@ -0,0 +1,60 @@
+using Content.Server.Imperial.SCP.NothingThere.Components;
+using Robust.Shared.Audio;
+using Content.Shared.Mobs;
+
+namespace Content.Server.Imperial.SCP.NothingThere.Systems;
+
+public sealed partial class ImperialNothingThereSystem
+{
+
+    private void InitializeChaseMusic()
+    {
+        SubscribeLocalEvent<ImperialNothingThereComponent, MapInitEvent>(OnInit);
+        SubscribeLocalEvent<ImperialNothingThereComponent, ComponentRemove>(OnRemove);
+        SubscribeLocalEvent<ImperialNothingThereComponent, MobStateChangedEvent>(OnMobStateChanged);
+    }
+    private void OnRemove(EntityUid uid, ImperialNothingThereComponent comp, ComponentRemove args)
+    {
+        StopChaseMusic(uid, comp);
+    }
+
+    public void StartChaseMusic(EntityUid uid, ImperialNothingThereComponent comp)
+    {
+        if (comp.IsPlaying)
+            return;
+        if (comp.Phase == NothingTherePhase.True)
+            return;
+        comp.PlayingStream = _audio.PlayPvs(
+            comp.ChaseSound,
+            uid,
+            AudioParams.Default.WithLoop(true)
+        )?.Entity;
+
+        comp.IsPlaying = true;
+    }
+
+    public void StopChaseMusic(EntityUid uid, ImperialNothingThereComponent comp)
+    {
+        if (!comp.IsPlaying)
+            return;
+        if (comp.Phase == NothingTherePhase.True)
+            return;
+        if (comp.PlayingStream != null)
+        {
+            _audio.Stop(comp.PlayingStream.Value);
+            comp.PlayingStream = null;
+        }
+        comp.IsPlaying = false;
+    }
+    private void OnMobStateChanged(EntityUid uid, ImperialNothingThereComponent comp, MobStateChangedEvent args)
+    {
+        if (_mobStateSystem.IsDead(uid) || _mobStateSystem.IsCritical(uid))
+        {
+            StopChaseMusic(uid, comp);
+        }
+        else if (_mobStateSystem.IsAlive(uid))
+        {
+            StartChaseMusic(uid, comp);
+        }
+    }
+}

Content.Server/Imperial/SCP/NothingThere/Systems/ImperialNothingThereSystem.Arsenal.cs

@@ -0,0 +1,128 @@
+
+using Content.Server.Imperial.SCP.NothingThere.Components;
+using Content.Shared.Imperial.SCP.NothingThere.Events;
+using Content.Shared.Weapons.Melee.Events;
+using Content.Shared.Hands.Components;
+using Content.Shared.Popups;
+using Content.Shared.DoAfter;
+using Content.Shared.Mobs.Components;
+using Robust.Shared.Timing;
+namespace Content.Server.Imperial.SCP.NothingThere.Systems;
+
+public sealed partial class ImperialNothingThereSystem
+{
+    #region Initialize
+    private void InitializeArsenal()
+    {
+        SubscribeLocalEvent<ImperialNothingThereComponent, ImperialNothingThereGoodbyeEvent>(OnGoodbyeAction);
+        SubscribeLocalEvent<ImperialNothingThereComponent, ImperialNothingThereGoodbyeDoAfterEvent>(OnGoodbyeDoAfter);
+        SubscribeLocalEvent<ImperialNothingThereGoodbyeComponent, MeleeHitEvent>(OnGoodbyeAttack);
+    }
+    #endregion
+    #region Item provision
+    private void UpdateItemProvide()
+    {
+        var query = EntityQueryEnumerator<ImperialNothingThereComponent>();
+        while (query.MoveNext(out var uid, out var comp))
+        {
+            if (!comp.NeedItems)
+                continue;
+            var hands = EnsureComp<HandsComponent>(uid);
+            if (_hands.TryGetEmptyHand((uid, hands), out var emptyHand))
+            {
+                EntityUid? hit;
+                if (comp.NeedGoodbye)
+                {
+                    hit = Spawn(comp.GoodbyeProto, Transform(uid).Coordinates);
+                    comp.NeedGoodbye = false;
+                }
+                else
+                {
+                    hit = Spawn(comp.HitProto, Transform(uid).Coordinates);
+                }
+                if (!_hands.TryForcePickup(uid, hit ?? EntityUid.Invalid, emptyHand, checkActionBlocker: false, handsComp: hands))
+                {
+                    QueueDel(hit);
+                    return;
+                }
+                else
+                    comp.NeedItems = false;
+            }
+        }
+        var weaponquery = EntityQueryEnumerator<ImperialNothingThereGoodbyeComponent>();
+        while (weaponquery.MoveNext(out var wpnuid, out var wpncomp))
+        {
+            var curTime = _gameTiming.CurTime;
+            if (wpncomp.WeaponUser == EntityUid.Invalid || wpncomp.AttackEnd < curTime)
+                continue;
+            var user = wpncomp.WeaponUser;
+            if (!TryComp<HandsComponent>(user, out var hands))
+                continue;
+            wpncomp.AttackEnd = TimeSpan.Zero;
+            wpncomp.WeaponUser = EntityUid.Invalid;
+            var handd = _hands.GetActiveHand((user, hands));
+            _hands.DoDrop((user, hands), handd!, false, false);
+            if (Exists(wpnuid))
+                QueueDel(wpnuid);
+            if (TryComp<ImperialNothingThereComponent>(user, out var scp))
+            {
+                scp.NeedItems = true;
+            }
+        }
+    }
+    #endregion
+    #region Goodbye Handle
+    private void OnGoodbyeAction(Entity<ImperialNothingThereComponent> ent, ref ImperialNothingThereGoodbyeEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        var doAfterArgs = new DoAfterArgs(EntityManager, ent, ent.Comp.GoodbyeDelay, new ImperialNothingThereGoodbyeDoAfterEvent(), ent)
+        {
+            BreakOnMove = true,
+            BreakOnDamage = false,
+            NeedHand = false
+        };
+        if (!TryComp<MobStateComponent>(args.Performer, out var mob))
+            return;
+        if (!TryComp<ImperialNothingThereComponent>(args.Performer, out var comp))
+            return;
+        if (_doAfterSystem.TryStartDoAfter(doAfterArgs))
+        {
+            args.Handled = true;
+            _popupSystem.PopupEntity(Loc.GetString("nothing-there-goodbye-windup"), ent, PopupType.MediumCaution);
+        }
+        args.Handled = true;
+    }
+    private void OnGoodbyeDoAfter(Entity<ImperialNothingThereComponent> ent, ref ImperialNothingThereGoodbyeDoAfterEvent args)
+    {
+        if (args.Cancelled || args.Handled)
+            return;
+
+        var hands = EnsureComp<HandsComponent>(args.User);
+        var handd = _hands.GetActiveHand((args.User, hands));
+        var wpn = _hands.GetActiveItem((args.User, hands));
+        var user = args.User;
+        _hands.DoDrop((args.User, hands), handd!, false, false);
+        QueueDel(wpn);
+        ent.Comp.NeedGoodbye = true;
+        ent.Comp.NeedItems = true;
+    }
+
+    private void OnGoodbyeAttack(EntityUid uid, ImperialNothingThereGoodbyeComponent comp, ref MeleeHitEvent args)
+    {
+        if (comp.Used || args.Handled)
+            return;
+        if (!TryComp<HandsComponent>(args.User, out var hands))
+            return;
+        args.Handled = true;
+        _audio.PlayPvs(comp.EmpowerSound, args.User);
+        comp.Used = true;
+        var user = args.User;
+        var handd = _hands.GetActiveHand((user, hands));
+        comp.WeaponUser = user;
+        var curTime = _gameTiming.CurTime;
+        comp.AttackEnd = curTime + comp.AttackDuration;
+    }
+    #endregion
+}