499 lines
20 KiB
C#
499 lines
20 KiB
C#
using System.Diagnostics.CodeAnalysis;
|
|
using System.Linq;
|
|
using Content.Shared.Alert;
|
|
using Content.Shared.Damage;
|
|
using Content.Shared.FixedPoint;
|
|
using Content.Shared.Mobs.Components;
|
|
using Content.Shared.Mobs.Events;
|
|
using Robust.Shared.GameStates;
|
|
|
|
namespace Content.Shared.Mobs.Systems;
|
|
|
|
public sealed class MobThresholdSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly MobStateSystem _mobStateSystem = default!;
|
|
[Dependency] private readonly AlertsSystem _alerts = default!;
|
|
|
|
public override void Initialize()
|
|
{
|
|
SubscribeLocalEvent<MobThresholdsComponent, ComponentGetState>(OnGetState);
|
|
SubscribeLocalEvent<MobThresholdsComponent, ComponentHandleState>(OnHandleState);
|
|
SubscribeLocalEvent<MobThresholdsComponent, MapInitEvent>(MobThresholdMapInit); // Offbrand
|
|
|
|
SubscribeLocalEvent<MobThresholdsComponent, ComponentShutdown>(MobThresholdShutdown);
|
|
SubscribeLocalEvent<MobThresholdsComponent, ComponentStartup>(MobThresholdStartup);
|
|
SubscribeLocalEvent<MobThresholdsComponent, DamageChangedEvent>(OnDamaged);
|
|
SubscribeLocalEvent<MobThresholdsComponent, UpdateMobStateEvent>(OnUpdateMobState);
|
|
SubscribeLocalEvent<MobThresholdsComponent, MobStateChangedEvent>(OnThresholdsMobState);
|
|
}
|
|
|
|
private void OnGetState(EntityUid uid, MobThresholdsComponent component, ref ComponentGetState args)
|
|
{
|
|
var thresholds = new Dictionary<FixedPoint2, MobState>();
|
|
foreach (var (key, value) in component.Thresholds)
|
|
{
|
|
thresholds.Add(key, value);
|
|
}
|
|
args.State = new MobThresholdsComponentState(thresholds,
|
|
component.TriggersAlerts,
|
|
component.CurrentThresholdState,
|
|
component.StateAlertDict,
|
|
component.ShowOverlays,
|
|
component.AllowRevives);
|
|
}
|
|
|
|
private void OnHandleState(EntityUid uid, MobThresholdsComponent component, ref ComponentHandleState args)
|
|
{
|
|
if (args.Current is not MobThresholdsComponentState state)
|
|
return;
|
|
component.Thresholds = new SortedDictionary<FixedPoint2, MobState>(state.UnsortedThresholds);
|
|
component.TriggersAlerts = state.TriggersAlerts;
|
|
component.CurrentThresholdState = state.CurrentThresholdState;
|
|
component.AllowRevives = state.AllowRevives;
|
|
}
|
|
|
|
#region Public API
|
|
|
|
/// <summary>
|
|
/// Gets the next available state for a mob.
|
|
/// </summary>
|
|
/// <param name="target">Target entity</param>
|
|
/// <param name="mobState">Supplied MobState</param>
|
|
/// <param name="nextState">The following MobState. Can be null if there isn't one.</param>
|
|
/// <param name="thresholdsComponent">Threshold Component Owned by the target</param>
|
|
/// <returns>True if the next mob state exists</returns>
|
|
public bool TryGetNextState(
|
|
EntityUid target,
|
|
MobState mobState,
|
|
[NotNullWhen(true)] out MobState? nextState,
|
|
MobThresholdsComponent? thresholdsComponent = null)
|
|
{
|
|
nextState = null;
|
|
if (!Resolve(target, ref thresholdsComponent))
|
|
return false;
|
|
|
|
MobState? min = null;
|
|
foreach (var state in thresholdsComponent.Thresholds.Values)
|
|
{
|
|
if (state <= mobState)
|
|
continue;
|
|
|
|
if (min == null || state < min)
|
|
min = state;
|
|
}
|
|
|
|
nextState = min;
|
|
return nextState != null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the Damage Threshold for the appropriate state if it exists
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="mobState">MobState we want the Damage Threshold of</param>
|
|
/// <param name="thresholdComponent">Threshold Component Owned by the target</param>
|
|
/// <returns>the threshold or 0 if it doesn't exist</returns>
|
|
public FixedPoint2 GetThresholdForState(EntityUid target, MobState mobState,
|
|
MobThresholdsComponent? thresholdComponent = null)
|
|
{
|
|
if (!Resolve(target, ref thresholdComponent))
|
|
return FixedPoint2.Zero;
|
|
|
|
foreach (var pair in thresholdComponent.Thresholds)
|
|
{
|
|
if (pair.Value == mobState)
|
|
{
|
|
return pair.Key;
|
|
}
|
|
}
|
|
|
|
return FixedPoint2.Zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to get the Damage Threshold for the appropriate state if it exists
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="mobState">MobState we want the Damage Threshold of</param>
|
|
/// <param name="threshold">The damage Threshold for the given state</param>
|
|
/// <param name="thresholdComponent">Threshold Component Owned by the target</param>
|
|
/// <returns>true if successfully retrieved a threshold</returns>
|
|
public bool TryGetThresholdForState(EntityUid target, MobState mobState,
|
|
[NotNullWhen(true)] out FixedPoint2? threshold,
|
|
MobThresholdsComponent? thresholdComponent = null)
|
|
{
|
|
threshold = null;
|
|
if (!Resolve(target, ref thresholdComponent))
|
|
return false;
|
|
|
|
foreach (var pair in thresholdComponent.Thresholds)
|
|
{
|
|
if (pair.Value == mobState)
|
|
{
|
|
threshold = pair.Key;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to get the a percentage of the Damage Threshold for the appropriate state if it exists
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="mobState">MobState we want the Damage Threshold of</param>
|
|
/// <param name="damage">The Damage being applied</param>
|
|
/// <param name="percentage">Percentage of Damage compared to the Threshold</param>
|
|
/// <param name="thresholdComponent">Threshold Component Owned by the target</param>
|
|
/// <returns>true if successfully retrieved a percentage</returns>
|
|
public bool TryGetPercentageForState(EntityUid target, MobState mobState, FixedPoint2 damage,
|
|
[NotNullWhen(true)] out FixedPoint2? percentage,
|
|
MobThresholdsComponent? thresholdComponent = null)
|
|
{
|
|
percentage = null;
|
|
if (!TryGetThresholdForState(target, mobState, out var threshold, thresholdComponent))
|
|
return false;
|
|
|
|
percentage = damage / threshold;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to get the Damage Threshold for crit or death. Outputs the first found threshold.
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="threshold">The Damage Threshold for incapacitation</param>
|
|
/// <param name="thresholdComponent">Threshold Component owned by the target</param>
|
|
/// <returns>true if successfully retrieved incapacitation threshold</returns>
|
|
public bool TryGetIncapThreshold(EntityUid target, [NotNullWhen(true)] out FixedPoint2? threshold,
|
|
MobThresholdsComponent? thresholdComponent = null)
|
|
{
|
|
threshold = null;
|
|
if (!Resolve(target, ref thresholdComponent))
|
|
return false;
|
|
|
|
return TryGetThresholdForState(target, MobState.Critical, out threshold, thresholdComponent)
|
|
|| TryGetThresholdForState(target, MobState.Dead, out threshold, thresholdComponent);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to get a percentage of the Damage Threshold for crit or death. Outputs the first found percentage.
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="damage">The damage being applied</param>
|
|
/// <param name="percentage">Percentage of Damage compared to the Incapacitation Threshold</param>
|
|
/// <param name="thresholdComponent">Threshold Component Owned by the target</param>
|
|
/// <returns>true if successfully retrieved incapacitation percentage</returns>
|
|
public bool TryGetIncapPercentage(EntityUid target, FixedPoint2 damage,
|
|
[NotNullWhen(true)] out FixedPoint2? percentage,
|
|
MobThresholdsComponent? thresholdComponent = null)
|
|
{
|
|
percentage = null;
|
|
if (!TryGetIncapThreshold(target, out var threshold, thresholdComponent))
|
|
return false;
|
|
|
|
if (damage == 0)
|
|
{
|
|
percentage = 0;
|
|
return true;
|
|
}
|
|
|
|
percentage = FixedPoint2.Min(1.0f, damage / threshold.Value);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to get the Damage Threshold for death
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="threshold">The Damage Threshold for death</param>
|
|
/// <param name="thresholdComponent">Threshold Component owned by the target</param>
|
|
/// <returns>true if successfully retrieved incapacitation threshold</returns>
|
|
public bool TryGetDeadThreshold(EntityUid target, [NotNullWhen(true)] out FixedPoint2? threshold,
|
|
MobThresholdsComponent? thresholdComponent = null)
|
|
{
|
|
threshold = null;
|
|
if (!Resolve(target, ref thresholdComponent, false))
|
|
return false;
|
|
|
|
return TryGetThresholdForState(target, MobState.Dead, out threshold, thresholdComponent);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to get a percentage of the Damage Threshold for death
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="damage">The damage being applied</param>
|
|
/// <param name="percentage">Percentage of Damage compared to the Death Threshold</param>
|
|
/// <param name="thresholdComponent">Threshold Component Owned by the target</param>
|
|
/// <returns>true if successfully retrieved death percentage</returns>
|
|
public bool TryGetDeadPercentage(EntityUid target, FixedPoint2 damage,
|
|
[NotNullWhen(true)] out FixedPoint2? percentage,
|
|
MobThresholdsComponent? thresholdComponent = null)
|
|
{
|
|
percentage = null;
|
|
if (!TryGetDeadThreshold(target, out var threshold, thresholdComponent))
|
|
return false;
|
|
|
|
if (damage == 0)
|
|
{
|
|
percentage = 0;
|
|
return true;
|
|
}
|
|
|
|
percentage = FixedPoint2.Min(1.0f, damage / threshold.Value);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Takes the damage from one entity and scales it relative to the health of another
|
|
/// </summary>
|
|
/// <param name="target1">The entity whose damage will be scaled</param>
|
|
/// <param name="target2">The entity whose health the damage will scale to</param>
|
|
/// <param name="damage">The newly scaled damage. Can be null</param>
|
|
public bool GetScaledDamage(EntityUid target1, EntityUid target2, out DamageSpecifier? damage)
|
|
{
|
|
damage = null;
|
|
|
|
if (!TryComp<DamageableComponent>(target1, out var oldDamage))
|
|
return false;
|
|
|
|
if (!TryComp<MobThresholdsComponent>(target1, out var threshold1) ||
|
|
!TryComp<MobThresholdsComponent>(target2, out var threshold2))
|
|
return false;
|
|
|
|
if (!TryGetThresholdForState(target1, MobState.Dead, out var ent1DeadThreshold, threshold1))
|
|
ent1DeadThreshold = 0;
|
|
|
|
if (!TryGetThresholdForState(target2, MobState.Dead, out var ent2DeadThreshold, threshold2))
|
|
ent2DeadThreshold = 0;
|
|
|
|
damage = (oldDamage.Damage / ent1DeadThreshold.Value) * ent2DeadThreshold.Value;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set a MobState Threshold or create a new one if it doesn't exist
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="damage">Damageable Component owned by the target</param>
|
|
/// <param name="mobState">MobState Component owned by the target</param>
|
|
/// <param name="threshold">MobThreshold Component owned by the target</param>
|
|
public void SetMobStateThreshold(EntityUid target, FixedPoint2 damage, MobState mobState,
|
|
MobThresholdsComponent? threshold = null)
|
|
{
|
|
if (!Resolve(target, ref threshold))
|
|
return;
|
|
|
|
// create a duplicate dictionary so we don't modify while enumerating.
|
|
var thresholds = new Dictionary<FixedPoint2, MobState>(threshold.Thresholds);
|
|
foreach (var (damageThreshold, state) in thresholds)
|
|
{
|
|
if (state != mobState)
|
|
continue;
|
|
threshold.Thresholds.Remove(damageThreshold);
|
|
}
|
|
threshold.Thresholds[damage] = mobState;
|
|
Dirty(target, threshold);
|
|
VerifyThresholds(target, threshold);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks to see if we should change states based on thresholds.
|
|
/// Call this if you change the amount of damagable without triggering a damageChangedEvent or if you change
|
|
/// </summary>
|
|
/// <param name="target">Target Entity</param>
|
|
/// <param name="threshold">Threshold Component owned by the Target</param>
|
|
/// <param name="mobState">MobState Component owned by the Target</param>
|
|
/// <param name="damageable">Damageable Component owned by the Target</param>
|
|
public void VerifyThresholds(EntityUid target, MobThresholdsComponent? threshold = null,
|
|
MobStateComponent? mobState = null, DamageableComponent? damageable = null)
|
|
{
|
|
if (!Resolve(target, ref mobState, ref threshold, ref damageable))
|
|
return;
|
|
|
|
CheckThresholds(target, mobState, threshold, damageable);
|
|
|
|
var ev = new MobThresholdChecked(target, mobState, threshold, damageable);
|
|
RaiseLocalEvent(target, ref ev, true);
|
|
UpdateAlerts(target, mobState.CurrentState, threshold, damageable);
|
|
}
|
|
|
|
public void SetAllowRevives(EntityUid uid, bool val, MobThresholdsComponent? component = null)
|
|
{
|
|
if (!Resolve(uid, ref component, false))
|
|
return;
|
|
component.AllowRevives = val;
|
|
Dirty(uid, component);
|
|
VerifyThresholds(uid, component);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Implementation
|
|
|
|
private void CheckThresholds(EntityUid target, MobStateComponent mobStateComponent,
|
|
MobThresholdsComponent thresholdsComponent, DamageableComponent damageableComponent, EntityUid? origin = null)
|
|
{
|
|
foreach (var (threshold, mobState) in thresholdsComponent.Thresholds.Reverse())
|
|
{
|
|
if (damageableComponent.TotalDamage < threshold)
|
|
continue;
|
|
|
|
TriggerThreshold(target, mobState, mobStateComponent, thresholdsComponent, origin);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void TriggerThreshold(
|
|
EntityUid target,
|
|
MobState newState,
|
|
MobStateComponent? mobState = null,
|
|
MobThresholdsComponent? thresholds = null,
|
|
EntityUid? origin = null)
|
|
{
|
|
if (!Resolve(target, ref mobState, ref thresholds) ||
|
|
mobState.CurrentState == newState)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (mobState.CurrentState != MobState.Dead || thresholds.AllowRevives)
|
|
{
|
|
thresholds.CurrentThresholdState = newState;
|
|
Dirty(target, thresholds);
|
|
}
|
|
|
|
_mobStateSystem.UpdateMobState(target, mobState, origin);
|
|
}
|
|
|
|
private void UpdateAlerts(EntityUid target, MobState currentMobState, MobThresholdsComponent? threshold = null,
|
|
DamageableComponent? damageable = null)
|
|
{
|
|
if (!Resolve(target, ref threshold, ref damageable))
|
|
return;
|
|
|
|
// don't handle alerts if they are managed by another system... BobbySim (soon TM)
|
|
if (!threshold.TriggersAlerts)
|
|
return;
|
|
|
|
if (!threshold.StateAlertDict.TryGetValue(currentMobState, out var currentAlert))
|
|
{
|
|
Log.Error($"No alert alert for mob state {currentMobState} for entity {ToPrettyString(target)}");
|
|
return;
|
|
}
|
|
|
|
if (!_alerts.TryGet(currentAlert, out var alertPrototype))
|
|
{
|
|
Log.Error($"Invalid alert type {currentAlert}");
|
|
return;
|
|
}
|
|
|
|
if (alertPrototype.SupportsSeverity)
|
|
{
|
|
var severity = _alerts.GetMinSeverity(currentAlert);
|
|
|
|
var ev = new BeforeAlertSeverityCheckEvent(currentAlert, severity);
|
|
RaiseLocalEvent(target, ev);
|
|
|
|
if (ev.CancelUpdate)
|
|
{
|
|
_alerts.ShowAlert(target, ev.CurrentAlert, ev.Severity);
|
|
return;
|
|
}
|
|
|
|
if (TryGetNextState(target, currentMobState, out var nextState, threshold) &&
|
|
TryGetPercentageForState(target, nextState.Value, damageable.TotalDamage, out var percentage))
|
|
{
|
|
percentage = FixedPoint2.Clamp(percentage.Value, 0, 1);
|
|
|
|
severity = (short) MathF.Round(
|
|
MathHelper.Lerp(
|
|
_alerts.GetMinSeverity(currentAlert),
|
|
_alerts.GetMaxSeverity(currentAlert),
|
|
percentage.Value.Float()));
|
|
}
|
|
_alerts.ShowAlert(target, currentAlert, severity);
|
|
}
|
|
else
|
|
{
|
|
_alerts.ShowAlert(target, currentAlert);
|
|
}
|
|
}
|
|
|
|
private void OnDamaged(EntityUid target, MobThresholdsComponent thresholds, DamageChangedEvent args)
|
|
{
|
|
if (!TryComp<MobStateComponent>(target, out var mobState))
|
|
return;
|
|
CheckThresholds(target, mobState, thresholds, args.Damageable, args.Origin);
|
|
var ev = new MobThresholdChecked(target, mobState, thresholds, args.Damageable);
|
|
RaiseLocalEvent(target, ref ev, true);
|
|
UpdateAlerts(target, mobState.CurrentState, thresholds, args.Damageable);
|
|
}
|
|
|
|
private void MobThresholdStartup(EntityUid target, MobThresholdsComponent thresholds, ComponentStartup args)
|
|
{
|
|
if (!TryComp<MobStateComponent>(target, out var mobState) || !TryComp<DamageableComponent>(target, out var damageable))
|
|
return;
|
|
CheckThresholds(target, mobState, thresholds, damageable);
|
|
UpdateAllEffects((target, thresholds, mobState, damageable), mobState.CurrentState);
|
|
}
|
|
|
|
// Begin Offbrand
|
|
private void MobThresholdMapInit(Entity<MobThresholdsComponent> ent, ref MapInitEvent args)
|
|
{
|
|
var overlayUpdate = new Content.Shared._Offbrand.Wounds.bPotentiallyUpdateDamageOverlayEventb(ent);
|
|
RaiseLocalEvent(ent, ref overlayUpdate);
|
|
}
|
|
// End Offbrand
|
|
|
|
private void MobThresholdShutdown(EntityUid target, MobThresholdsComponent component, ComponentShutdown args)
|
|
{
|
|
if (component.TriggersAlerts)
|
|
_alerts.ClearAlertCategory(target, component.HealthAlertCategory);
|
|
}
|
|
|
|
private void OnUpdateMobState(EntityUid target, MobThresholdsComponent component, ref UpdateMobStateEvent args)
|
|
{
|
|
if (!component.AllowRevives && component.CurrentThresholdState == MobState.Dead)
|
|
{
|
|
args.State = MobState.Dead;
|
|
}
|
|
else if (component.CurrentThresholdState != MobState.Invalid)
|
|
{
|
|
args.State = component.CurrentThresholdState;
|
|
}
|
|
}
|
|
|
|
private void UpdateAllEffects(Entity<MobThresholdsComponent, MobStateComponent?, DamageableComponent?> ent, MobState currentState)
|
|
{
|
|
var (_, thresholds, mobState, damageable) = ent;
|
|
if (Resolve(ent, ref thresholds, ref mobState, ref damageable))
|
|
{
|
|
var ev = new MobThresholdChecked(ent, mobState, thresholds, damageable);
|
|
RaiseLocalEvent(ent, ref ev, true);
|
|
}
|
|
|
|
UpdateAlerts(ent, currentState, thresholds, damageable);
|
|
}
|
|
|
|
private void OnThresholdsMobState(Entity<MobThresholdsComponent> ent, ref MobStateChangedEvent args)
|
|
{
|
|
UpdateAllEffects((ent, ent, null, null), args.NewMobState);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event that triggers when an entity with a mob threshold is checked
|
|
/// </summary>
|
|
/// <param name="Target">Target entity</param>
|
|
/// <param name="Threshold">Threshold Component owned by the Target</param>
|
|
/// <param name="MobState">MobState Component owned by the Target</param>
|
|
/// <param name="Damageable">Damageable Component owned by the Target</param>
|
|
[ByRefEvent]
|
|
public readonly record struct MobThresholdChecked(EntityUid Target, MobStateComponent MobState,
|
|
MobThresholdsComponent Threshold, DamageableComponent Damageable);
|