Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Add slipping prediction (#1440)

Browse Source
This commit is contained in:
DrSmugleaf
2020-07-23 01:40:31 +02:00
committed by GitHub
parent c9057d01ae
commit b88afec350
12 changed files with 461 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Content.Server/GameObjects/Components/Mobs/ServerStatusEffectsComponent.cs
View File

@@ -2,7 +2,6 @@ using System;
using System.Collections.Generic;
using Content.Server.GameObjects.Components.Buckle;
using Content.Shared.GameObjects.Components.Mobs;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.Network;
using Robust.Shared.Players;
@@ -47,10 +46,11 @@ namespace Content.Server.GameObjects.Components.Mobs
Dirty();
}
public void ChangeStatusEffect(StatusEffect effect, string icon, ValueTuple<TimeSpan, TimeSpan>? cooldown)
public override void ChangeStatusEffect(StatusEffect effect, string icon, ValueTuple<TimeSpan, TimeSpan>? cooldown)
{
_statusEffects[effect] = new StatusEffectStatus()
{Icon = icon, Cooldown = cooldown};
Dirty();
}

265
Content.Server/GameObjects/Components/Mobs/StunnableComponent.cs
View File

@@ -1,248 +1,95 @@
using System;
using System.Threading;
using Content.Server.Mobs;
using Content.Shared.Audio;
using Content.Server.Mobs;
using Content.Shared.GameObjects.Components.Mobs;
using Robust.Server.GameObjects.EntitySystems;
using Robust.Shared.GameObjects;
using Robust.Shared.GameObjects.Systems;
using Robust.Shared.Interfaces.Timing;
using Robust.Shared.IoC;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using Timer = Robust.Shared.Timers.Timer;
using Content.Shared.GameObjects.Components.Movement;
using Content.Shared.Interfaces.GameObjects.Components;
using Math = CannyFastMath.Math;
using MathF = CannyFastMath.MathF;
namespace Content.Server.GameObjects.Components.Mobs
{
[RegisterComponent]
[ComponentReference(typeof(SharedStunnableComponent))]
public class StunnableComponent : SharedStunnableComponent, IInteractHand
public class StunnableComponent : SharedStunnableComponent
{
#pragma warning disable 649
[Dependency] private IGameTiming _gameTiming;
#pragma warning restore 649
private TimeSpan? _lastStun;
[ViewVariables] public TimeSpan? StunStart => _lastStun;
[ViewVariables]
public TimeSpan? StunEnd => _lastStun == null
? (TimeSpan?) null
: _gameTiming.CurTime +
(TimeSpan.FromSeconds(Math.Max(_stunnedTimer, Math.Max(_knockdownTimer, _slowdownTimer))));
private const int StunLevels = 8;
private bool _canHelp = true;
private float _stunCap = 20f;
private float _knockdownCap = 20f;
private float _slowdownCap = 20f;
private float _helpKnockdownRemove = 1f;
private float _helpInterval = 1f;
private float _stunnedTimer = 0f;
private float _knockdownTimer = 0f;
private float _slowdownTimer = 0f;
private string _stunTexture;
private CancellationTokenSource _statusRemoveCancellation = new CancellationTokenSource();
[ViewVariables] public override bool Stunned => _stunnedTimer > 0f;
[ViewVariables] public override bool KnockedDown => _knockdownTimer > 0f;
[ViewVariables] public override bool SlowedDown => _slowdownTimer > 0f;
[ViewVariables] public float StunCap => _stunCap;
[ViewVariables] public float KnockdownCap => _knockdownCap;
[ViewVariables] public float SlowdownCap => _slowdownCap;
public override void ExposeData(ObjectSerializer serializer)
protected override void OnKnockdown()
{
base.ExposeData(serializer);
serializer.DataField(ref _stunCap, "stunCap", 20f);
serializer.DataField(ref _knockdownCap, "knockdownCap", 20f);
serializer.DataField(ref _slowdownCap, "slowdownCap", 20f);
serializer.DataField(ref _helpInterval, "helpInterval", 1f);
serializer.DataField(ref _helpKnockdownRemove, "helpKnockdownRemove", 1f);
serializer.DataField(ref _stunTexture, "stunTexture",
"/Textures/Objects/Weapons/Melee/stunbaton.rsi/stunbaton_off.png");
}
/// <summary>
/// Stuns the entity, disallowing it from doing many interactions temporarily.
/// </summary>
/// <param name="seconds">How many seconds the mob will stay stunned</param>
public void Stun(float seconds)
{
seconds = MathF.Min(_stunnedTimer + (seconds * StunTimeModifier), _stunCap);
if (seconds <= 0f)
return;
StandingStateHelper.DropAllItemsInHands(Owner, false);
_stunnedTimer = seconds;
_lastStun = _gameTiming.CurTime;
SetStatusEffect();
Dirty();
}
/// <summary>
/// Knocks down the mob, making it fall to the ground.
/// </summary>
/// <param name="seconds">How many seconds the mob will stay on the ground</param>
public void Knockdown(float seconds)
{
seconds = MathF.Min(_knockdownTimer + (seconds * KnockdownTimeModifier), _knockdownCap);
if (seconds <= 0f)
{
return;
}
StandingStateHelper.Down(Owner);
_knockdownTimer = seconds;
_lastStun = _gameTiming.CurTime;
SetStatusEffect();
Dirty();
}
/// <summary>
/// Applies knockdown and stun to the mob temporarily
/// </summary>
/// <param name="seconds">How many seconds the mob will be paralyzed</param>
public void Paralyze(float seconds)
{
Stun(seconds);
Knockdown(seconds);
}
/// <summary>
/// Slows down the mob's walking/running speed temporarily
/// </summary>
/// <param name="seconds">How many seconds the mob will be slowed down</param>
/// <param name="walkModifierOverride">Walk speed modifier. Set to 0 or negative for default value. (0.5f)</param>
/// <param name="runModifierOverride">Run speed modifier. Set to 0 or negative for default value. (0.5f)</param>
public void Slowdown(float seconds, float walkModifierOverride = 0f, float runModifierOverride = 0f)
{
seconds = MathF.Min(_slowdownTimer + (seconds * SlowdownTimeModifier), _slowdownCap);
if (seconds <= 0f)
return;
WalkModifierOverride = walkModifierOverride;
RunModifierOverride = runModifierOverride;
_slowdownTimer = seconds;
_lastStun = _gameTiming.CurTime;
if (Owner.TryGetComponent(out MovementSpeedModifierComponent movement))
movement.RefreshMovementSpeedModifiers();
SetStatusEffect();
Dirty();
}
/// <summary>
/// Used when
/// </summary>
public void CancelAll()
{
_knockdownTimer = 0f;
_stunnedTimer = 0f;
KnockdownTimer = 0f;
StunnedTimer = 0f;
Dirty();
}
public bool InteractHand(InteractHandEventArgs eventArgs)
{
if (!_canHelp || !KnockedDown)
return false;
_canHelp = false;
Timer.Spawn(((int) _helpInterval * 1000), () => _canHelp = true);
EntitySystem.Get<AudioSystem>()
.PlayFromEntity("/Audio/Effects/thudswoosh.ogg", Owner, AudioHelpers.WithVariation(0.25f));
_knockdownTimer -= _helpKnockdownRemove;
SetStatusEffect();
Dirty();
return true;
}
private void SetStatusEffect()
{
if (!Owner.TryGetComponent(out ServerStatusEffectsComponent status))
return;
status.ChangeStatusEffect(StatusEffect.Stun, _stunTexture,
(StunStart == null || StunEnd == null) ? default : (StunStart.Value, StunEnd.Value));
_statusRemoveCancellation.Cancel();
_statusRemoveCancellation = new CancellationTokenSource();
}
public void ResetStuns()
{
_stunnedTimer = 0f;
_slowdownTimer = 0f;
StunnedTimer = 0f;
SlowdownTimer = 0f;
if (KnockedDown)
{
StandingStateHelper.Standing(Owner);
}
_knockdownTimer = 0f;
KnockdownTimer = 0f;
}
public void Update(float delta)
{
if (Stunned)
{
_stunnedTimer -= delta;
StunnedTimer -= delta;
if (_stunnedTimer <= 0)
if (StunnedTimer <= 0)
{
_stunnedTimer = 0f;
StunnedTimer = 0f;
Dirty();
}
}
if (KnockedDown)
{
_knockdownTimer -= delta;
KnockdownTimer -= delta;
if (_knockdownTimer <= 0f)
if (KnockdownTimer <= 0f)
{
StandingStateHelper.Standing(Owner);
_knockdownTimer = 0f;
KnockdownTimer = 0f;
Dirty();
}
}
if (SlowedDown)
{
_slowdownTimer -= delta;
SlowdownTimer -= delta;
if (_slowdownTimer <= 0f)
if (SlowdownTimer <= 0f)
{
_slowdownTimer = 0f;
SlowdownTimer = 0f;
if (Owner.TryGetComponent(out MovementSpeedModifierComponent movement))
{
movement.RefreshMovementSpeedModifiers();
}
Dirty();
}
}
if (!StunStart.HasValue || !StunEnd.HasValue ||
!Owner.TryGetComponent(out ServerStatusEffectsComponent status))
{
return;
}
var start = StunStart.Value;
var end = StunEnd.Value;
@@ -252,73 +99,15 @@ namespace Content.Server.GameObjects.Components.Mobs
if (progress >= length)
{
Timer.Spawn(250, () => status.RemoveStatusEffect(StatusEffect.Stun), _statusRemoveCancellation.Token);
_lastStun = null;
}
}
public float StunTimeModifier
{
get
{
var modifier = 1.0f;
var components = Owner.GetAllComponents<IStunModifier>();
foreach (var component in components)
{
modifier *= component.StunTimeModifier;
}
return modifier;
}
}
public float KnockdownTimeModifier
{
get
{
var modifier = 1.0f;
var components = Owner.GetAllComponents<IStunModifier>();
foreach (var component in components)
{
modifier *= component.KnockdownTimeModifier;
}
return modifier;
}
}
public float SlowdownTimeModifier
{
get
{
var modifier = 1.0f;
var components = Owner.GetAllComponents<IStunModifier>();
foreach (var component in components)
{
modifier *= component.SlowdownTimeModifier;
}
return modifier;
Timer.Spawn(250, () => status.RemoveStatusEffect(StatusEffect.Stun), StatusRemoveCancellation.Token);
LastStun = null;
}
}
public override ComponentState GetComponentState()
{
return new StunnableComponentState(Stunned, KnockedDown, SlowedDown, WalkModifierOverride,
return new StunnableComponentState(StunnedTimer, KnockdownTimer, SlowdownTimer, WalkModifierOverride,
RunModifierOverride);
}
}
/// <summary>
/// This interface allows components to multiply the time in seconds of various stuns by a number.
/// </summary>
public interface IStunModifier
{
float StunTimeModifier => 1.0f;
float KnockdownTimeModifier => 1.0f;
float SlowdownTimeModifier => 1.0f;
}
}

102
Content.Server/GameObjects/Components/Movement/SlipperyComponent.cs
View File

@@ -1,118 +1,36 @@
using System.Collections.Generic;
using System.Timers;
using Content.Server.GameObjects.Components.Mobs;
using Content.Server.Throw;
using Content.Shared.Audio;
using Content.Shared.GameObjects.EntitySystems;
using Content.Shared.Physics;
using Content.Shared.Audio;
using Content.Shared.GameObjects.Components.Movement;
using Robust.Server.GameObjects.EntitySystems;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.GameObjects.Components;
using Robust.Shared.GameObjects.Systems;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using Timer = Robust.Shared.Timers.Timer;
namespace Content.Server.GameObjects.Components.Movement
{
[RegisterComponent]
public class SlipperyComponent : Component, ICollideBehavior
[ComponentReference(typeof(SharedSlipperyComponent))]
public class SlipperyComponent : SharedSlipperyComponent
{
[Dependency] private IEntityManager _entityManager = default!;
public override string Name => "Slippery";
private List<EntityUid> _slipped = new List<EntityUid>();
/// <summary>
/// How many seconds the mob will be paralyzed for.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public float ParalyzeTime { get; set; } = 3f;
/// <summary>
/// Percentage of shape intersection for a slip to occur.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public float IntersectPercentage { get; set; } = 0.3f;
/// <summary>
/// Entities will only be slipped if their speed exceeds this limit.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public float RequiredSlipSpeed { get; set; } = 0f;
/// <summary>
/// Path to the sound to be played when a mob slips.
/// </summary>
[ViewVariables]
public string SlipSound { get; set; } = "/Audio/Effects/slip.ogg";
public override void Initialize()
{
base.Initialize();
var collidable = Owner.GetComponent<ICollidableComponent>();
collidable.Hard = false;
var shape = collidable.PhysicsShapes[0];
shape.CollisionLayer |= (int) CollisionGroup.SmallImpassable;
shape.CollisionMask = (int)CollisionGroup.None;
}
private string SlipSound { get; set; } = "/Audio/Effects/slip.ogg";
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(this, x => ParalyzeTime, "paralyzeTime", 3f);
serializer.DataField(this, x => IntersectPercentage, "intersectPercentage", 0.3f);
serializer.DataField(this, x => RequiredSlipSpeed, "requiredSlipSpeed", 0f);
serializer.DataField(this, x => SlipSound, "slipSound", "/Audio/Effects/slip.ogg");
}
public void CollideWith(IEntity collidedWith)
protected override void OnSlip()
{
if (ContainerHelpers.IsInContainer(Owner)
|| _slipped.Contains(collidedWith.Uid)
|| !collidedWith.TryGetComponent(out StunnableComponent stun)
|| !collidedWith.TryGetComponent(out ICollidableComponent otherBody)
|| !collidedWith.TryGetComponent(out IPhysicsComponent otherPhysics)
|| !Owner.TryGetComponent(out ICollidableComponent body))
return;
if (otherPhysics.LinearVelocity.Length < RequiredSlipSpeed || stun.KnockedDown)
return;
var percentage = otherBody.WorldAABB.IntersectPercentage(body.WorldAABB);
if (percentage < IntersectPercentage)
return;
if(!EffectBlockerSystem.CanSlip(collidedWith))
return;
stun.Paralyze(5f);
_slipped.Add(collidedWith.Uid);
if(!string.IsNullOrEmpty(SlipSound))
EntitySystem.Get<AudioSystem>().PlayFromEntity(SlipSound, Owner, AudioHelpers.WithVariation(0.2f));
}
public void Update(float frameTime)
{
foreach (var uid in _slipped.ToArray())
if (!string.IsNullOrEmpty(SlipSound))
{
if(!uid.IsValid() || !_entityManager.EntityExists(uid)) continue;
var entity = _entityManager.GetEntity(uid);
var collidable = Owner.GetComponent<ICollidableComponent>();
var otherCollidable = entity.GetComponent<ICollidableComponent>();
if (!collidable.WorldAABB.Intersects(otherCollidable.WorldAABB))
_slipped.Remove(uid);
EntitySystem.Get<AudioSystem>()
.PlayFromEntity(SlipSound, Owner, AudioHelpers.WithVariation(0.2f));
}
}
}