Resomi

Content.Server/Chat/ChatComponent.cs

@@ -0,0 +1,11 @@
+namespace Content.Server.Chat;
+
+/// <summary>
+/// Modifaer for entity to expand whisper radius 
+/// </summary>
+[RegisterComponent]
+public sealed partial class ChatComponent : Component
+{
+    [DataField("whisperPersonalRange")]
+    public int WhisperPersonalRange = 2;
+}

Content.Server/Chat/Systems/ChatSystem.cs

@@ -537,10 +537,13 @@ private void SendEntityWhisper(
                 continue;
             listener = session.AttachedEntity.Value;
 
+            var listenerComp = CompOrNull<ChatComponent>(listener); //Corvax-Next-Resomi modifaer for whisper range 
+
             if (MessageRangeCheck(session, data, range) != MessageRangeCheckResult.Full)
                 continue; // Won't get logged to chat, and ghosts are too far away to see the pop-up, so we just won't send it to them.
 
-            if (data.Range <= WhisperClearRange)
+            if ((listenerComp != null && data.Range <= listenerComp.WhisperPersonalRange)
+                || (listenerComp == null && data.Range <= WhisperClearRange)) //Corvax-Next-Resomi modifaer for whisper range 
                 _chatManager.ChatMessageToOne(ChatChannel.Whisper, message, wrappedMessage, source, false, session.Channel);
             //If listener is too far, they only hear fragments of the message
             else if (_examineSystem.InRangeUnOccluded(source, listener, WhisperMuffledRange))

Content.Server/Flash/FlashSystem.cs

@@ -116,6 +116,12 @@ public void Flash(EntityUid target,
             bool melee = false,
             TimeSpan? stunDuration = null)
         {
+            //CorvaxNext duration modifier for resomi
+            if (TryComp<FlashModifierComponent>(target, out var flashModifier))
+            {
+                flashDuration *= flashModifier.Modifier;
+            }
+
             var attempt = new FlashAttemptEvent(target, user, used);
             RaiseLocalEvent(target, attempt, true);
 

Content.Server/_CorvaxNext/Resomi/Abilities/AgillitySkillSystem.cs

@@ -0,0 +1,108 @@
+using Content.Shared.Actions;
+using Content.Shared.Alert;
+using Content.Shared.Maps;
+using Robust.Shared.Containers;
+using Robust.Shared.Map;
+using Robust.Shared.Timing;
+using Content.Shared._CorvaxNext.Resomi;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Systems;
+using Content.Shared._CorvaxNext.Resomi.Abilities;
+using Content.Shared.Damage.Components;
+using Robust.Shared.Physics;
+
+namespace Content.Server._CorvaxNext.Resomi.Abilities;
+
+public sealed class AgillitySkillSystem : SharedAgillitySkillSystem
+{
+    [Dependency] private readonly SharedActionsSystem _actionsSystem = default!;
+    [Dependency] private readonly MovementSpeedModifierSystem _movementSpeedModifier = default!;
+
+    private Entity<BaseActionComponent> action;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<AgillitySkillComponent, ComponentInit>(OnComponentInit);
+        SubscribeLocalEvent<AgillitySkillComponent, SwitchAgillityActionEvent>(SwitchAgility);
+        SubscribeLocalEvent<AgillitySkillComponent, RefreshMovementSpeedModifiersEvent>(OnRefreshMovespeed);
+    }
+
+    private void OnComponentInit(Entity<AgillitySkillComponent> ent, ref ComponentInit args)
+    {
+        _actionsSystem.AddAction(ent.Owner, ref ent.Comp.SwitchAgilityActionEntity, ent.Comp.SwitchAgilityAction, ent.Owner);
+    }
+
+    private void SwitchAgility(Entity<AgillitySkillComponent> ent, ref SwitchAgillityActionEvent args)
+    {
+        action = args.Action;
+
+        if (!ent.Comp.Active)
+        {
+            ActivateAgility(ent, action);
+        }
+        else
+        {
+            DeactivateAgility(ent.Owner, ent.Comp, action);
+        }
+    }
+
+    private void ActivateAgility(Entity<AgillitySkillComponent> ent, Entity<BaseActionComponent> action)
+    {
+        if (!TryComp<MovementSpeedModifierComponent>(ent.Owner, out var comp))
+            return;
+
+        _popup.PopupEntity(Loc.GetString("agility-activated-massage"), ent.Owner);
+
+        ent.Comp.SprintSpeedCurrent += ent.Comp.SprintSpeedModifier; // adding a modifier to the base running speed
+        _movementSpeedModifier.RefreshMovementSpeedModifiers(ent.Owner);
+
+        ent.Comp.Active = !ent.Comp.Active;
+
+        var ev = new SwitchAgillity(action, ent.Comp.Active);
+        RaiseLocalEvent(ent.Owner, ref ev);
+    }
+
+    private void DeactivateAgility(EntityUid uid, AgillitySkillComponent component, Entity<BaseActionComponent> action)
+    {
+        if (!TryComp<MovementSpeedModifierComponent>(uid, out var comp))
+            return;
+
+        _popup.PopupEntity(Loc.GetString("agility-deactivated-massage"), uid);
+
+        component.SprintSpeedCurrent = 1f; // return the base running speed to normal
+        _movementSpeedModifier.RefreshMovementSpeedModifiers(uid);
+
+        _actions.SetCooldown(action.Owner, component.CooldownDelay);
+
+        component.Active = !component.Active;
+
+        var ev = new SwitchAgillity(action, component.Active);
+        RaiseLocalEvent(uid, ref ev);
+    }
+
+    private void OnRefreshMovespeed(Entity<AgillitySkillComponent> ent, ref RefreshMovementSpeedModifiersEvent args)
+    {
+        args.ModifySpeed(1f, ent.Comp.SprintSpeedCurrent);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var query = EntityQueryEnumerator<AgillitySkillComponent>();
+        while (query.MoveNext(out var uid, out var resomiComp))
+        {
+            if (!TryComp<StaminaComponent>(uid, out var stamina)
+                || !resomiComp.Active
+                || Timing.CurTime < resomiComp.NextUpdateTime)
+                continue;
+
+            resomiComp.NextUpdateTime = Timing.CurTime + resomiComp.UpdateRate;
+
+            _stamina.TryTakeStamina(uid, resomiComp.StaminaDamagePassive);
+            if (stamina.StaminaDamage > stamina.CritThreshold * 0.50f)
+                DeactivateAgility(uid, resomiComp, action);
+        }
+    }
+}

Content.Server/_CorvaxNext/Speech/Components/ResomiAccentComponent.cs

@@ -0,0 +1,4 @@
+namespace Content.Server._CorvaxNext.Speech.Components;
+
+[RegisterComponent]
+public sealed partial class ResomiAccentComponent : Component;

Content.Server/_CorvaxNext/Speech/EntitySystems/ResomiAccentSystem.cs

@@ -0,0 +1,61 @@
+using System.Text.RegularExpressions;
+using Content.Server._CorvaxNext.Speech.Components;
+using Content.Server.Speech;
+using Robust.Shared.Random;
+
+namespace Content.Server._CorvaxNext.Speech.EntitySystems;
+
+public sealed class ResomiAccentSystem : EntitySystem
+{
+
+    [Dependency] private readonly IRobustRandom _random = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<ResomiAccentComponent, AccentGetEvent>(OnAccent);
+    }
+
+    private void OnAccent(EntityUid uid, ResomiAccentComponent component, AccentGetEvent args)
+    {
+        var message = args.Message;
+
+        // ш => шшш
+        message = Regex.Replace(
+            message,
+            "ш+",
+            _random.Pick(new List<string>() { "шш", "шшш" })
+        );
+        // Ш => ШШШ
+        message = Regex.Replace(
+            message,
+            "Ш+",
+            _random.Pick(new List<string>() { "ШШ", "ШШШ" })
+        );
+        // ч => щщщ
+        message = Regex.Replace(
+            message,
+            "ч+",
+            _random.Pick(new List<string>() { "щщ", "щщщ" })
+        );
+        // Ч => ЩЩЩ
+        message = Regex.Replace(
+            message,
+            "Ч+",
+            _random.Pick(new List<string>() { "ЩЩ", "ЩЩЩ" })
+        );
+        // р => ррр
+        message = Regex.Replace(
+            message,
+            "р+",
+            _random.Pick(new List<string>() { "рр", "ррр" })
+        );
+        // Р => РРР
+        message = Regex.Replace(
+            message,
+            "Р+",
+            _random.Pick(new List<string>() { "РР", "РРР" })
+        );
+        args.Message = message;
+    }
+}

Content.Shared/Flash/Components/FlashModifierComponent.cs

@@ -0,0 +1,13 @@
+ namespace Content.Shared.Flash.Components;
+
+
+/// <summary>
+/// Corvax-Next-Resomi
+/// </summary>
+
+[RegisterComponent]
+public sealed partial class FlashModifierComponent : Component
+{
+    [DataField]
+    public float Modifier = 1f;
+}

Content.Shared/Weapons/Ranged/Events/GunRefreshModifiersEvent.cs

@@ -1,4 +1,4 @@
-using Content.Shared.Weapons.Ranged.Components;
+using Content.Shared.Weapons.Ranged.Components;
 using Content.Shared.Weapons.Ranged.Systems;
 using Robust.Shared.Audio;
 

Content.Shared/Wieldable/Components/WieldableComponent.cs

@@ -37,6 +37,8 @@ public sealed partial class WieldableComponent : Component
     public string? WieldedInhandPrefix = "wielded";
 
     public string? OldInhandPrefix = null;
+
+    public EntityUid? User = null; // Corvax-Next-Resomi
 }
 
 [Serializable, NetSerializable]

Content.Shared/Wieldable/WieldableSystem.cs

@@ -20,6 +20,7 @@
 using Robust.Shared.Audio.Systems;
 using Robust.Shared.Network;
 using Robust.Shared.Timing;
+using Content.Shared._CorvaxNext.Resomi.Abilities;
 
 namespace Content.Shared.Wieldable;
 
@@ -109,7 +110,7 @@ private void OnDeselectWieldable(EntityUid uid, WieldableComponent component, Ha
     private void OnGunRefreshModifiers(Entity<GunWieldBonusComponent> bonus, ref GunRefreshModifiersEvent args)
     {
         if (TryComp(bonus, out WieldableComponent? wield) &&
-            wield.Wielded)
+            wield.Wielded && !HasComp<WeaponsUseInabilityComponent>(wield.User)) //Corvax-Next-Resomi
         {
             args.MinAngle += bonus.Comp.MinAngle;
             args.MaxAngle += bonus.Comp.MaxAngle;
@@ -257,6 +258,8 @@ public bool TryWield(EntityUid used, WieldableComponent component, EntityUid use
         var othersMessage = Loc.GetString("wieldable-component-successful-wield-other", ("user", Identity.Entity(user, EntityManager)), ("item", used));
         _popupSystem.PopupPredicted(selfMessage, othersMessage, user, user);
 
+        component.User = user; //Corvax-Next-Resomi
+
         var targEv = new ItemWieldedEvent();
         RaiseLocalEvent(used, ref targEv);
 

Content.Shared/_CorvaxNext/Resomi/Abilities/SharedAgillitySkillComponent.cs

@@ -0,0 +1,60 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Shared._CorvaxNext.Resomi.Abilities;
+
+[RegisterComponent, NetworkedComponent]
+[AutoGenerateComponentState]
+public sealed partial class AgillitySkillComponent : Component
+{
+    [AutoNetworkedField, DataField]
+    public Dictionary<string, int> DisabledJumpUpFixtureMasks = new();
+    [AutoNetworkedField, DataField]
+    public Dictionary<string, int> DisabledJumpDownFixtureMasks = new();
+
+    [DataField("active")]
+    public bool Active = false;
+
+    /// <summary>
+    /// if we want the ability to not give the opportunity to jump on the tables and only accelerate
+    /// </summary>
+    [DataField("jumpEnabled")]
+    public bool JumpEnabled = true;
+
+    [DataField("switchAgilityAction", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>))]
+    public string? SwitchAgilityAction = "SwitchAgilityAction";
+
+    [DataField("switchAgilityActionEntity")] public EntityUid? SwitchAgilityActionEntity;
+
+    /// <summary>
+    /// how much stamina will be spent for each jump
+    /// </summary>
+    [DataField("staminaDamageOnJump")]
+    public float StaminaDamageOnJump = 10f;
+
+    /// <summary>
+    /// how much stamina will be passive spent while abilitty is activated
+    /// </summary>
+    [DataField("staminaDamagePassive")]
+    public float StaminaDamagePassive = 3f;
+
+    [DataField("sprintSpeedModifier")]
+    public float SprintSpeedModifier = 0.1f; //+10%
+    public float SprintSpeedCurrent = 1f;
+
+    /// <summary>
+    /// once in how many seconds is our stamina taken away while the ability is on
+    /// </summary>
+    [DataField("delay")]
+    public double Delay = 1.0;
+    public TimeSpan UpdateRate => TimeSpan.FromSeconds(Delay);
+    public TimeSpan NextUpdateTime;
+
+    /// <summary>
+    /// cooldown of ability. Called when the ability is disabled
+    /// </summary>
+    [DataField("cooldown")]
+    public double Cooldown = 20.0;
+    public TimeSpan CooldownDelay => TimeSpan.FromSeconds(Cooldown);
+}

Content.Shared/_CorvaxNext/Resomi/Abilities/SharedAgillitySkillSystem.cs

@@ -0,0 +1,45 @@
+using Robust.Shared.Timing;
+using Robust.Shared.Physics.Systems;
+using Robust.Shared.Physics;
+using Content.Shared.Physics;
+using Content.Shared.Popups;
+using Robust.Shared.Physics.Events;
+using Robust.Shared.Log;
+using Content.Shared.Climbing.Systems;
+using Content.Shared.Damage.Systems;
+using Content.Shared.Actions;
+
+namespace Content.Shared._CorvaxNext.Resomi.Abilities;
+
+public abstract class SharedAgillitySkillSystem : EntitySystem
+{
+    [Dependency] protected readonly IGameTiming Timing = default!;
+    [Dependency] protected readonly SharedPopupSystem _popup = default!;
+    [Dependency] protected readonly ClimbSystem _climb = default!;
+    [Dependency] protected readonly StaminaSystem _stamina = default!;
+    [Dependency] protected readonly SharedActionsSystem _actions = default!;
+
+    protected const int BaseCollisionGroup = (int)(CollisionGroup.MobMask);
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<AgillitySkillComponent, StartCollideEvent>(DoJump);
+        SubscribeLocalEvent<AgillitySkillComponent, SwitchAgillity>(OnHandleStateChange);
+    }
+
+    private void DoJump(Entity<AgillitySkillComponent> ent, ref StartCollideEvent args)
+    {
+        if (!ent.Comp.Active || !ent.Comp.JumpEnabled
+            || args.OurFixture.CollisionMask != BaseCollisionGroup
+            || args.OtherFixture.CollisionMask != (int)CollisionGroup.TableMask) //fix it.... maybe.... -_-.... or idk
+            return;
+
+        _stamina.TryTakeStamina(ent.Owner, ent.Comp.StaminaDamageOnJump);
+        _climb.ForciblySetClimbing(ent.Owner, args.OtherEntity);
+    }
+
+    private void OnHandleStateChange(Entity<AgillitySkillComponent> ent, ref SwitchAgillity args)
+    {
+        _actions.SetToggled(args.action.Owner, args.toggled);
+    }
+}

Content.Shared/_CorvaxNext/Resomi/Abilities/WeaponsUseInabilityComponent.cs

@@ -0,0 +1,11 @@
+namespace Content.Shared._CorvaxNext.Resomi.Abilities;
+
+
+/// <summary>
+/// It does not allow you to fire a weapon that requires two hands.
+/// increases the spread, as if shooting was conducted from one hand
+/// </summary>
+[RegisterComponent]
+public sealed partial class WeaponsUseInabilityComponent : Component
+{
+}