cmdrunematti
/
Delta-v
mirror of https://github.com/DeltaV-Station/Delta-v.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Damage Visualizer ECS (#10654)

This commit is contained in:
Flipp Syder 2022-08-17 19:36:49 -07:00 committed by GitHub
parent 676f3a0c68
commit 15217baa1d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 905 additions and 933 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

857
Content.Client/Damage/DamageVisualizer.cs
View File

@ -1,857 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Content.Shared.FixedPoint;
using Robust.Client.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Maths;
using Robust.Shared.Prototypes;
using Robust.Shared.Reflection;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.Utility;
// apologies in advance for all the != null checks,
// my IDE wouldn't stop complaining about these
namespace Content.Client.Damage
{
/// <summary>
/// A simple visualizer for any entity with a DamageableComponent
/// to display the status of how damaged it is.
///
/// Can either be an overlay for an entity, or target multiple
/// layers on the same entity.
///
/// This can be disabled dynamically by passing into SetData,
/// key DamageVisualizerKeys.Disabled, value bool
/// (DamageVisualizerKeys lives in Content.Shared.Damage)
///
/// Damage layers, if targetting layers, can also be dynamically
/// disabled if needed by passing into SetData, the name/enum
/// of the sprite layer, and then passing in a bool value
/// (true to enable, false to disable).
/// </summary>
public sealed class DamageVisualizer : AppearanceVisualizer
{
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
private const string _name = "DamageVisualizer";
/// <summary>
/// Damage thresholds between damage state changes.
///
/// If there are any negative thresholds, or there is
/// less than one threshold, the visualizer is marked
/// as invalid.
/// </summary>
/// <remarks>
/// A 'zeroth' threshold is automatically added,
/// and this list is automatically sorted for
/// efficiency beforehand. As such, the zeroth
/// threshold is not required - and negative
/// thresholds are automatically caught as
/// invalid. The zeroth threshold automatically
/// sets all layers to invisible, so a sprite
/// isn't required for it.
/// </remarks>
[DataField("thresholds", required: true)]
private List<FixedPoint2> _thresholds = new();
/// <summary>
/// Layers to target, by layerMapKey.
/// If a target layer map key is invalid
/// (in essence, undefined), then the target
/// layer is removed from the list for efficiency.
///
/// If no layers are valid, then the visualizer
/// is marked as invalid.
///
/// If this is not defined, however, the visualizer
/// instead adds an overlay to the sprite.
/// </summary>
/// <remarks>
/// Layers can be disabled here by passing
/// the layer's name as a key to SetData,
/// and passing in a bool set to either 'false'
/// to disable it, or 'true' to enable it.
/// Setting the layer as disabled will make it
/// completely invisible.
/// </remarks>
[DataField("targetLayers")]
private List<Enum>? _targetLayers;
/// <summary>
/// The actual sprites for every damage group
/// that the entity should display visually.
///
/// This is keyed by a damage group identifier
/// (for example, Brute), and has a value
/// of a DamageVisualizerSprite (see below)
/// </summary>
[DataField("damageOverlayGroups")]
private readonly Dictionary<string, DamageVisualizerSprite>? _damageOverlayGroups;
/// <summary>
/// Sets if you want sprites to overlay the
/// entity when damaged, or if you would
/// rather have each target layer's state
/// replaced by a different state
/// within its RSI.
///
/// This cannot be set to false if:
/// - There are no target layers
/// - There is no damage group
/// </summary>
[DataField("overlay")]
private readonly bool _overlay = true;
/// <summary>
/// A single damage group to target.
/// This should only be defined if
/// overlay is set to false.
/// If this is defined with damageSprites,
/// this will be ignored.
/// </summary>
/// <remarks>
/// This is here because otherwise,
/// you would need several permutations
/// of group sprites depending on
/// what kind of damage combination
/// you would want, on which threshold.
/// </remarks>
[DataField("damageGroup")]
private readonly string? _damageGroup;
/// <summary>
/// Set this if you want incoming damage to be
/// divided.
/// </summary>
/// <remarks>
/// This is more useful if you have similar
/// damage sprites inbetween entities,
/// but with different damage thresholds
/// and you want to avoid duplicating
/// these sprites.
/// </remarks>
[DataField("damageDivisor")]
private float _divisor = 1;
/// <summary>
/// Set this to track all damage, instead of specific groups.
/// </summary>
/// <remarks>
/// This will only work if you have damageOverlay
/// defined - otherwise, it will not work.
/// </remarks>
[DataField("trackAllDamage")]
private readonly bool _trackAllDamage = false;
/// <summary>
/// This is the overlay sprite used, if _trackAllDamage is
/// enabled. Supports no complex per-group layering,
/// just an actually simple damage overlay. See
/// DamageVisualizerSprite for more information.
/// </summary>
[DataField("damageOverlay")]
private readonly DamageVisualizerSprite? _damageOverlay;
// deals with the edge case of human damage visuals not
// being in color without making a Dict<Dict<Dict<Dict<Dict<Dict...
[DataDefinition]
internal sealed class DamageVisualizerSprite
{
/// <summary>
/// The RSI path for the damage visualizer
/// group overlay.
/// </summary>
/// <remarks>
/// States in here will require one of four
/// forms:
///
/// If tracking damage groups:
/// - {base_state}_{group}_{threshold} if targetting
/// a static layer on a sprite (either as an
/// overlay or as a state change)
/// - DamageOverlay_{group}_{threshold} if not
/// targetting a layer on a sprite.
///
/// If not tracking damage groups:
/// - {base_state}_{threshold} if it is targetting
/// a layer
/// - DamageOverlay_{threshold} if not targetting
/// a layer.
/// </remarks>
[DataField("sprite", required: true)]
public readonly string Sprite = default!;
/// <summary>
/// The color of this sprite overlay.
/// Supports only hexadecimal format.
/// </summary>
[DataField("color")]
public readonly string? Color;
}
/// <summary>
/// Initializes an entity to be managed by this appearance controller.
/// DO NOT assume this is your only entity. Visualizers are shared.
/// </summary>
[Obsolete("Subscribe to your component being initialised instead.")]
public override void InitializeEntity(EntityUid entity)
{
base.InitializeEntity(entity);
IoCManager.InjectDependencies(this);
var damageData = _entityManager.EnsureComponent<DamageVisualizerDataComponent>(entity);
VerifyVisualizerSetup(entity, damageData);
if (damageData.Valid)
InitializeVisualizer(entity, damageData);
}
private void VerifyVisualizerSetup(EntityUid entity, DamageVisualizerDataComponent damageData)
{
if (_thresholds.Count < 1)
{
Logger.ErrorS(_name, $"Thresholds were invalid for entity {entity}. Thresholds: {_thresholds}");
damageData.Valid = false;
return;
}
if (_divisor == 0)
{
Logger.ErrorS(_name, $"Divisor for {entity} is set to zero.");
damageData.Valid = false;
return;
}
if (_overlay)
{
if (_damageOverlayGroups == null && _damageOverlay == null)
{
Logger.ErrorS(_name, $"Enabled overlay without defined damage overlay sprites on {entity}.");
damageData.Valid = false;
return;
}
if (_trackAllDamage && _damageOverlay == null)
{
Logger.ErrorS(_name, $"Enabled all damage tracking without a damage overlay sprite on {entity}.");
damageData.Valid = false;
return;
}
if (!_trackAllDamage && _damageOverlay != null)
{
Logger.WarningS(_name, $"Disabled all damage tracking with a damage overlay sprite on {entity}.");
damageData.Valid = false;
return;
}
if (_trackAllDamage && _damageOverlayGroups != null)
{
Logger.WarningS(_name, $"Enabled all damage tracking with damage overlay groups on {entity}.");
damageData.Valid = false;
return;
}
}
else if (!_overlay)
{
if (_targetLayers == null)
{
Logger.ErrorS(_name, $"Disabled overlay without target layers on {entity}.");
damageData.Valid = false;
return;
}
if (_damageOverlayGroups != null || _damageOverlay != null)
{
Logger.ErrorS(_name, $"Disabled overlay with defined damage overlay sprites on {entity}.");
damageData.Valid = false;
return;
}
if (_damageGroup == null)
{
Logger.ErrorS(_name, $"Disabled overlay without defined damage group on {entity}.");
damageData.Valid = false;
return;
}
}
if (_damageOverlayGroups != null && _damageGroup != null)
{
Logger.WarningS(_name, $"Damage overlay sprites and damage group are both defined on {entity}.");
}
if (_damageOverlay != null && _damageGroup != null)
{
Logger.WarningS(_name, $"Damage overlay sprites and damage group are both defined on {entity}.");
}
}
private void InitializeVisualizer(EntityUid entity, DamageVisualizerDataComponent damageData)
{
if (!_entityManager.TryGetComponent(entity, out SpriteComponent? spriteComponent)
|| !_entityManager.TryGetComponent<DamageableComponent?>(entity, out var damageComponent)
|| !_entityManager.HasComponent<AppearanceComponent>(entity))
return;
_thresholds.Add(FixedPoint2.Zero);
_thresholds.Sort();
if (_thresholds[0] != 0)
{
Logger.ErrorS(_name, $"Thresholds were invalid for entity {entity}. Thresholds: {_thresholds}");
damageData.Valid = false;
return;
}
// If the damage container on our entity's DamageableComponent
// is not null, we can try to check through its groups.
if (damageComponent.DamageContainerID != null
&& _prototypeManager.TryIndex<DamageContainerPrototype>(damageComponent.DamageContainerID, out var damageContainer))
{
// Are we using damage overlay sprites by group?
// Check if the container matches the supported groups,
// and start cacheing the last threshold.
if (_damageOverlayGroups != null)
{
foreach (string damageType in _damageOverlayGroups.Keys)
{
if (!damageContainer.SupportedGroups.Contains(damageType))
{
Logger.ErrorS(_name, $"Damage key {damageType} was invalid for entity {entity}.");
damageData.Valid = false;
return;
}
damageData.LastThresholdPerGroup.Add(damageType, FixedPoint2.Zero);
}
}
// Are we tracking a single damage group without overlay instead?
// See if that group is in our entity's damage container.
else if (!_overlay && _damageGroup != null)
{
if (!damageContainer.SupportedGroups.Contains(_damageGroup))
{
Logger.ErrorS(_name, $"Damage keys were invalid for entity {entity}.");
damageData.Valid = false;
return;
}
damageData.LastThresholdPerGroup.Add(_damageGroup, FixedPoint2.Zero);
}
}
// Ditto above, but instead we go through every group.
else // oh boy! time to enumerate through every single group!
{
var damagePrototypeIdList = _prototypeManager.EnumeratePrototypes<DamageGroupPrototype>()
.Select((p, _) => p.ID)
.ToList();
if (_damageOverlayGroups != null)
foreach (string damageType in _damageOverlayGroups.Keys)
{
if (!damagePrototypeIdList.Contains(damageType))
{
Logger.ErrorS(_name, $"Damage keys were invalid for entity {entity}.");
damageData.Valid = false;
return;
}
damageData.LastThresholdPerGroup.Add(damageType, FixedPoint2.Zero);
}
else if (_damageGroup != null)
{
if (!damagePrototypeIdList.Contains(_damageGroup))
{
Logger.ErrorS(_name, $"Damage keys were invalid for entity {entity}.");
damageData.Valid = false;
return;
}
damageData.LastThresholdPerGroup.Add(_damageGroup, FixedPoint2.Zero);
}
}
// If we're targetting any layers, and the amount of
// layers is greater than zero, we start reserving
// all the layers needed to track damage groups
// on the entity.
if (_targetLayers != null && _targetLayers.Count > 0)
{
// This should ensure that the layers we're targetting
// are valid for the visualizer's use.
//
// If the layer doesn't have a base state, or
// the layer key just doesn't exist, we skip it.
foreach (var key in _targetLayers)
{
if (!spriteComponent.LayerMapTryGet(key, out int index)
|| spriteComponent.LayerGetState(index).ToString() == null)
{
Logger.WarningS(_name, $"Layer at key {key} was invalid for entity {entity}.");
continue;
}
damageData.TargetLayerMapKeys.Add(key);
};
// Similar to damage overlay groups, if none of the targetted
// sprite layers could be used, we display an error and
// invalidate the visualizer without crashing.
if (damageData.TargetLayerMapKeys.Count == 0)
{
Logger.ErrorS(_name, $"Target layers were invalid for entity {entity}.");
damageData.Valid = false;
return;
}
// Otherwise, we start reserving layers. Since the filtering
// loop above ensures that all of these layers are not null,
// and have valid state IDs, there should be no issues.
foreach (object layer in damageData.TargetLayerMapKeys)
{
int layerCount = spriteComponent.AllLayers.Count();
int index = spriteComponent.LayerMapGet(layer);
string layerState = spriteComponent.LayerGetState(index)!.ToString()!;
if (index + 1 != layerCount)
{
index += 1;
}
damageData.LayerMapKeyStates.Add(layer, layerState);
// If we're an overlay, and we're targetting groups,
// we reserve layers per damage group.
if (_overlay && _damageOverlayGroups != null)
{
foreach (var (group, sprite) in _damageOverlayGroups)
{
AddDamageLayerToSprite(spriteComponent,
sprite,
$"{layerState}_{group}_{_thresholds[1]}",
$"{layer}{group}",
index);
}
damageData.DisabledLayers.Add(layer, false);
}
// If we're not targetting groups, and we're still
// using an overlay, we instead just add a general
// overlay that reflects on how much damage
// was taken.
else if (_damageOverlay != null)
{
AddDamageLayerToSprite(spriteComponent,
_damageOverlay,
$"{layerState}_{_thresholds[1]}",
$"{layer}trackDamage",
index);
damageData.DisabledLayers.Add(layer, false);
}
}
}
// If we're not targetting layers, however,
// we should ensure that we instead
// reserve it as an overlay.
else
{
if (_damageOverlayGroups != null)
{
foreach (var (group, sprite) in _damageOverlayGroups)
{
AddDamageLayerToSprite(spriteComponent,
sprite,
$"DamageOverlay_{group}_{_thresholds[1]}",
$"DamageOverlay{group}");
damageData.TopMostLayerKey = $"DamageOverlay{group}";
}
}
else if (_damageOverlay != null)
{
AddDamageLayerToSprite(spriteComponent,
_damageOverlay,
$"DamageOverlay_{_thresholds[1]}",
"DamageOverlay");
damageData.TopMostLayerKey = $"DamageOverlay";
}
}
}
/// <summary>
/// Adds a damage tracking layer to a given sprite component.
/// </summary>
private void AddDamageLayerToSprite(SpriteComponent spriteComponent, DamageVisualizerSprite sprite, string state, string mapKey, int? index = null)
{
int newLayer = spriteComponent.AddLayer(
new SpriteSpecifier.Rsi(
new ResourcePath(sprite.Sprite), state
), index);
spriteComponent.LayerMapSet(mapKey, newLayer);
if (sprite.Color != null)
spriteComponent.LayerSetColor(newLayer, Color.FromHex(sprite.Color));
spriteComponent.LayerSetVisible(newLayer, false);
}
[Obsolete("Subscribe to AppearanceChangeEvent instead.")]
public override void OnChangeData(AppearanceComponent component)
{
var entities = _entityManager;
if (!entities.TryGetComponent(component.Owner, out DamageVisualizerDataComponent? damageData))
return;
if (!damageData.Valid)
return;
// If this was passed into the component, we update
// the data to ensure that the current disabled
// bool matches.
if (component.TryGetData<bool>(DamageVisualizerKeys.Disabled, out var disabledStatus))
if (disabledStatus != damageData.Disabled)
damageData.Disabled = disabledStatus;
if (damageData.Disabled)
return;
HandleDamage(component, damageData);
}
private void HandleDamage(AppearanceComponent component, DamageVisualizerDataComponent damageData)
{
var entities = _entityManager;
if (!entities.TryGetComponent(component.Owner, out SpriteComponent? spriteComponent)
|| !entities.TryGetComponent(component.Owner, out DamageableComponent? damageComponent))
return;
if (_targetLayers != null && _damageOverlayGroups != null)
UpdateDisabledLayers(spriteComponent, component, damageData);
if (_overlay && _damageOverlayGroups != null && _targetLayers == null)
CheckOverlayOrdering(spriteComponent, damageData);
if (component.TryGetData<bool>(DamageVisualizerKeys.ForceUpdate, out bool update)
&& update)
{
ForceUpdateLayers(damageComponent, spriteComponent, damageData);
return;
}
if (_trackAllDamage)
{
UpdateDamageVisuals(damageComponent, spriteComponent, damageData);
}
else if (component.TryGetData(DamageVisualizerKeys.DamageUpdateGroups, out DamageVisualizerGroupData data))
{
UpdateDamageVisuals(data.GroupList, damageComponent, spriteComponent, damageData);
}
}
/// <summary>
/// Checks if any layers were disabled in the last
/// data update. Disabled layers mean that the
/// layer will no longer be visible, or obtain
/// any damage updates.
/// </summary>
private void UpdateDisabledLayers(SpriteComponent spriteComponent, AppearanceComponent component, DamageVisualizerDataComponent damageData)
{
foreach (var layer in damageData.TargetLayerMapKeys)
{
bool? layerStatus = null;
if (component.TryGetData<bool>(layer, out var layerStateEnum))
layerStatus = layerStateEnum;
if (layerStatus == null)
continue;
if (damageData.DisabledLayers[layer] != (bool) layerStatus)
{
damageData.DisabledLayers[layer] = (bool) layerStatus;
if (!_trackAllDamage && _damageOverlayGroups != null)
foreach (string damageGroup in _damageOverlayGroups!.Keys)
spriteComponent.LayerSetVisible($"{layer}{damageGroup}", damageData.DisabledLayers[layer]);
else if (_trackAllDamage)
spriteComponent.LayerSetVisible($"{layer}trackDamage", damageData.DisabledLayers[layer]);
}
}
}
/// <summary>
/// Checks the overlay ordering on the current
/// sprite component, compared to the
/// data for the visualizer. If the top
/// most layer doesn't match, the sprite
/// layers are recreated and placed on top.
/// </summary>
private void CheckOverlayOrdering(SpriteComponent spriteComponent, DamageVisualizerDataComponent damageData)
{
if (spriteComponent[damageData.TopMostLayerKey] != spriteComponent[spriteComponent.AllLayers.Count() - 1])
{
if (!_trackAllDamage && _damageOverlayGroups != null)
{
foreach (var (damageGroup, sprite) in _damageOverlayGroups)
{
FixedPoint2 threshold = damageData.LastThresholdPerGroup[damageGroup];
ReorderOverlaySprite(spriteComponent,
damageData,
sprite,
$"DamageOverlay{damageGroup}",
$"DamageOverlay_{damageGroup}",
threshold);
}
}
else if (_trackAllDamage && _damageOverlay != null)
{
ReorderOverlaySprite(spriteComponent,
damageData,
_damageOverlay,
$"DamageOverlay",
$"DamageOverlay",
damageData.LastDamageThreshold);
}
}
}
private void ReorderOverlaySprite(SpriteComponent spriteComponent, DamageVisualizerDataComponent damageData, DamageVisualizerSprite sprite, string key, string statePrefix, FixedPoint2 threshold)
{
spriteComponent.LayerMapTryGet(key, out int spriteLayer);
bool visibility = spriteComponent[spriteLayer].Visible;
spriteComponent.RemoveLayer(spriteLayer);
if (threshold == FixedPoint2.Zero) // these should automatically be invisible
threshold = _thresholds[1];
spriteLayer = spriteComponent.AddLayer(
new SpriteSpecifier.Rsi(
new ResourcePath(sprite.Sprite),
$"{statePrefix}_{threshold}"
),
spriteLayer);
spriteComponent.LayerMapSet(key, spriteLayer);
spriteComponent.LayerSetVisible(spriteLayer, visibility);
// this is somewhat iffy since it constantly reallocates
damageData.TopMostLayerKey = key;
}
/// <summary>
/// Updates damage visuals without tracking
/// any damage groups.
/// </summary>
private void UpdateDamageVisuals(DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualizerDataComponent damageData)
{
if (!CheckThresholdBoundary(damageComponent.TotalDamage, damageData.LastDamageThreshold, out FixedPoint2 threshold))
return;
damageData.LastDamageThreshold = threshold;
if (_targetLayers != null)
{
foreach (var layerMapKey in damageData.TargetLayerMapKeys)
UpdateTargetLayer(spriteComponent, damageData, layerMapKey, threshold);
}
else
{
UpdateOverlay(spriteComponent, threshold);
}
}
/// <summary>
/// Updates damage visuals by damage group,
/// according to the list of damage groups
/// passed into it.
/// </summary>
private void UpdateDamageVisuals(List<string> delta, DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualizerDataComponent damageData)
{
foreach (var damageGroup in delta)
{
if (!_overlay && damageGroup != _damageGroup)
continue;
if (!_prototypeManager.TryIndex<DamageGroupPrototype>(damageGroup, out var damageGroupPrototype)
|| !damageComponent.Damage.TryGetDamageInGroup(damageGroupPrototype, out FixedPoint2 damageTotal))
continue;
if (!damageData.LastThresholdPerGroup.TryGetValue(damageGroup, out FixedPoint2 lastThreshold)
|| !CheckThresholdBoundary(damageTotal, lastThreshold, out FixedPoint2 threshold))
continue;
damageData.LastThresholdPerGroup[damageGroup] = threshold;
if (_targetLayers != null)
{
foreach (var layerMapKey in damageData.TargetLayerMapKeys)
UpdateTargetLayer(spriteComponent, damageData, layerMapKey, damageGroup, threshold);
}
else
{
UpdateOverlay(spriteComponent, damageGroup, threshold);
}
}
}
/// <summary>
/// Checks if a threshold boundary was passed.
/// </summary>
private bool CheckThresholdBoundary(FixedPoint2 damageTotal, FixedPoint2 lastThreshold, out FixedPoint2 threshold)
{
threshold = FixedPoint2.Zero;
damageTotal = damageTotal / _divisor;
int thresholdIndex = _thresholds.BinarySearch(damageTotal);
if (thresholdIndex < 0)
{
thresholdIndex = ~thresholdIndex;
threshold = _thresholds[thresholdIndex - 1];
}
else
{
threshold = _thresholds[thresholdIndex];
}
if (threshold == lastThreshold)
return false;
return true;
}
/// <summary>
/// This is the entry point for
/// forcing an update on all damage layers.
/// Does different things depending on
/// the configuration of the visualizer.
/// </summary>
private void ForceUpdateLayers(DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualizerDataComponent damageData)
{
if (_damageOverlayGroups != null)
{
UpdateDamageVisuals(_damageOverlayGroups.Keys.ToList(), damageComponent, spriteComponent, damageData);
}
else if (_damageGroup != null)
{
UpdateDamageVisuals(new List<string>(){ _damageGroup }, damageComponent, spriteComponent, damageData);
}
else if (_damageOverlay != null)
{
UpdateDamageVisuals(damageComponent, spriteComponent, damageData);
}
}
/// <summary>
/// Updates a target layer. Without a damage group passed in,
/// it assumes you're updating a layer that is tracking all
/// damage.
/// </summary>
private void UpdateTargetLayer(SpriteComponent spriteComponent, DamageVisualizerDataComponent damageData, object layerMapKey, FixedPoint2 threshold)
{
if (_overlay && _damageOverlayGroups != null)
{
if (!damageData.DisabledLayers[layerMapKey])
{
string layerState = damageData.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet($"{layerMapKey}trackDamage", out int spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}",
threshold);
}
}
else if (!_overlay)
{
string layerState = damageData.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet(layerMapKey, out int spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}",
threshold);
}
}
/// <summary>
/// Updates a target layer by damage group.
/// </summary>
private void UpdateTargetLayer(SpriteComponent spriteComponent, DamageVisualizerDataComponent damageData, object layerMapKey, string damageGroup, FixedPoint2 threshold)
{
if (_overlay && _damageOverlayGroups != null)
{
if (_damageOverlayGroups.ContainsKey(damageGroup) && !damageData.DisabledLayers[layerMapKey])
{
string layerState = damageData.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet($"{layerMapKey}{damageGroup}", out int spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}_{damageGroup}",
threshold);
}
}
else if (!_overlay)
{
string layerState = damageData.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet(layerMapKey, out int spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}_{damageGroup}",
threshold);
}
}
/// <summary>
/// Updates an overlay that is tracking all damage.
/// </summary>
private void UpdateOverlay(SpriteComponent spriteComponent, FixedPoint2 threshold)
{
spriteComponent.LayerMapTryGet($"DamageOverlay", out int spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"DamageOverlay",
threshold);
}
/// <summary>
/// Updates an overlay based on damage group.
/// </summary>
private void UpdateOverlay(SpriteComponent spriteComponent, string damageGroup, FixedPoint2 threshold)
{
if (_damageOverlayGroups != null)
{
if (_damageOverlayGroups.ContainsKey(damageGroup))
{
spriteComponent.LayerMapTryGet($"DamageOverlay{damageGroup}", out int spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"DamageOverlay_{damageGroup}",
threshold);
}
}
}
/// <summary>
/// Updates a layer on the sprite by what
/// prefix it has (calculated by whatever
/// function calls it), and what threshold
/// was passed into it.
/// </summary>
private void UpdateDamageLayerState(SpriteComponent spriteComponent, int spriteLayer, string statePrefix, FixedPoint2 threshold)
{
if (threshold == 0)
{
spriteComponent.LayerSetVisible(spriteLayer, false);
}
else
{
if (!spriteComponent[spriteLayer].Visible)
{
spriteComponent.LayerSetVisible(spriteLayer, true);
}
spriteComponent.LayerSetState(spriteLayer, $"{statePrefix}_{threshold}");
}
}
}
}

25
Content.Client/Damage/DamageVisualizerComponent.cs
View File

@ -1,25 +0,0 @@
using System.Collections.Generic;
using Content.Shared.FixedPoint;
using Robust.Shared.GameObjects;
namespace Content.Client.Damage
{
// Stores all the data for a DamageVisualizer.
//
// Storing it inside of the AppearanceComponent's data
// dictionary was too messy, but at least we can
// store it in the entity itself as a separate,
// dynamically added component.
[RegisterComponent]
public sealed class DamageVisualizerDataComponent : Component
{
public List<Enum> TargetLayerMapKeys = new();
public bool Disabled = false;
public bool Valid = true;
public FixedPoint2 LastDamageThreshold = FixedPoint2.Zero;
public Dictionary<object, bool> DisabledLayers = new();
public Dictionary<object, string> LayerMapKeyStates = new();
public Dictionary<string, FixedPoint2> LastThresholdPerGroup = new();
public string TopMostLayerKey = default!;
}
}

161
Content.Client/Damage/DamageVisualsComponent.cs Normal file
View File

@ -0,0 +1,161 @@
using Content.Shared.FixedPoint;
namespace Content.Client.Damage;
[RegisterComponent]
public sealed class DamageVisualsComponent : Component
{
/// <summary>
/// Damage thresholds between damage state changes.
///
/// If there are any negative thresholds, or there is
/// less than one threshold, the visualizer is marked
/// as invalid.
/// </summary>
/// <remarks>
/// A 'zeroth' threshold is automatically added,
/// and this list is automatically sorted for
/// efficiency beforehand. As such, the zeroth
/// threshold is not required - and negative
/// thresholds are automatically caught as
/// invalid. The zeroth threshold automatically
/// sets all layers to invisible, so a sprite
/// isn't required for it.
/// </remarks>
[DataField("thresholds", required: true)]
public List<FixedPoint2> Thresholds = new();
/// <summary>
/// Layers to target, by layerMapKey.
/// If a target layer map key is invalid
/// (in essence, undefined), then the target
/// layer is removed from the list for efficiency.
///
/// If no layers are valid, then the visualizer
/// is marked as invalid.
///
/// If this is not defined, however, the visualizer
/// instead adds an overlay to the sprite.
/// </summary>
/// <remarks>
/// Layers can be disabled here by passing
/// the layer's name as a key to SetData,
/// and passing in a bool set to either 'false'
/// to disable it, or 'true' to enable it.
/// Setting the layer as disabled will make it
/// completely invisible.
/// </remarks>
[DataField("targetLayers")] public List<Enum>? TargetLayers;
/// <summary>
/// The actual sprites for every damage group
/// that the entity should display visually.
///
/// This is keyed by a damage group identifier
/// (for example, Brute), and has a value
/// of a DamageVisualizerSprite (see below)
/// </summary>
[DataField("damageOverlayGroups")] public readonly Dictionary<string, DamageVisualizerSprite>? DamageOverlayGroups;
/// <summary>
/// Sets if you want sprites to overlay the
/// entity when damaged, or if you would
/// rather have each target layer's state
/// replaced by a different state
/// within its RSI.
///
/// This cannot be set to false if:
/// - There are no target layers
/// - There is no damage group
/// </summary>
[DataField("overlay")] public readonly bool Overlay = true;
/// <summary>
/// A single damage group to target.
/// This should only be defined if
/// overlay is set to false.
/// If this is defined with damageSprites,
/// this will be ignored.
/// </summary>
/// <remarks>
/// This is here because otherwise,
/// you would need several permutations
/// of group sprites depending on
/// what kind of damage combination
/// you would want, on which threshold.
/// </remarks>
[DataField("damageGroup")] public readonly string? DamageGroup;
/// <summary>
/// Set this if you want incoming damage to be
/// divided.
/// </summary>
/// <remarks>
/// This is more useful if you have similar
/// damage sprites in between entities,
/// but with different damage thresholds
/// and you want to avoid duplicating
/// these sprites.
/// </remarks>
[DataField("damageDivisor")] public float Divisor = 1;
/// <summary>
/// Set this to track all damage, instead of specific groups.
/// </summary>
/// <remarks>
/// This will only work if you have damageOverlay
/// defined - otherwise, it will not work.
/// </remarks>
[DataField("trackAllDamage")] public readonly bool TrackAllDamage;
/// <summary>
/// This is the overlay sprite used, if _trackAllDamage is
/// enabled. Supports no complex per-group layering,
/// just an actually simple damage overlay. See
/// DamageVisualizerSprite for more information.
/// </summary>
[DataField("damageOverlay")] public readonly DamageVisualizerSprite? DamageOverlay;
public readonly List<Enum> TargetLayerMapKeys = new();
public bool Disabled = false;
public bool Valid = true;
public FixedPoint2 LastDamageThreshold = FixedPoint2.Zero;
public readonly Dictionary<object, bool> DisabledLayers = new();
public readonly Dictionary<object, string> LayerMapKeyStates = new();
public readonly Dictionary<string, FixedPoint2> LastThresholdPerGroup = new();
public string TopMostLayerKey = default!;
}
// deals with the edge case of human damage visuals not
// being in color without making a Dict<Dict<Dict<Dict<Dict<Dict...
[DataDefinition]
public sealed class DamageVisualizerSprite
{
/// <summary>
/// The RSI path for the damage visualizer
/// group overlay.
/// </summary>
/// <remarks>
/// States in here will require one of four
/// forms:
///
/// If tracking damage groups:
/// - {base_state}_{group}_{threshold} if targeting
/// a static layer on a sprite (either as an
/// overlay or as a state change)
/// - DamageOverlay_{group}_{threshold} if not
/// targeting a layer on a sprite.
///
/// If not tracking damage groups:
/// - {base_state}_{threshold} if it is targeting
/// a layer
/// - DamageOverlay_{threshold} if not targeting
/// a layer.
/// </remarks>
[DataField("sprite", required: true)] public readonly string Sprite = default!;
/// <summary>
/// The color of this sprite overlay.
/// Supports only hexadecimal format.
/// </summary>
[DataField("color")] public readonly string? Color;
}

698
Content.Client/Damage/DamageVisualsSystem.cs Normal file
View File

@ -0,0 +1,698 @@
using System.Linq;
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Content.Shared.FixedPoint;
using Robust.Client.GameObjects;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
namespace Content.Client.Damage;
/// <summary>
/// A simple visualizer for any entity with a DamageableComponent
/// to display the status of how damaged it is.
///
/// Can either be an overlay for an entity, or target multiple
/// layers on the same entity.
///
/// This can be disabled dynamically by passing into SetData,
/// key DamageVisualizerKeys.Disabled, value bool
/// (DamageVisualizerKeys lives in Content.Shared.Damage)
///
/// Damage layers, if targeting layers, can also be dynamically
/// disabled if needed by passing into SetData, the name/enum
/// of the sprite layer, and then passing in a bool value
/// (true to enable, false to disable).
/// </summary>
public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponent>
{
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
private const string SawmillName = "DamageVisuals";
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<DamageVisualsComponent, ComponentInit>(InitializeEntity);
}
private void InitializeEntity(EntityUid entity, DamageVisualsComponent comp, ComponentInit args)
{
VerifyVisualizerSetup(entity, comp);
if (!comp.Valid)
{
RemCompDeferred<DamageVisualsComponent>(entity);
return;
}
InitializeVisualizer(entity, comp);
}
private void VerifyVisualizerSetup(EntityUid entity, DamageVisualsComponent damageVisComp)
{
if (damageVisComp.Thresholds.Count < 1)
{
Logger.ErrorS(SawmillName, $"Thresholds were invalid for entity {entity}. Thresholds: {damageVisComp.Thresholds}");
damageVisComp.Valid = false;
return;
}
if (damageVisComp.Divisor == 0)
{
Logger.ErrorS(SawmillName, $"Divisor for {entity} is set to zero.");
damageVisComp.Valid = false;
return;
}
if (damageVisComp.Overlay)
{
if (damageVisComp.DamageOverlayGroups == null && damageVisComp.DamageOverlay == null)
{
Logger.ErrorS(SawmillName, $"Enabled overlay without defined damage overlay sprites on {entity}.");
damageVisComp.Valid = false;
return;
}
if (damageVisComp.TrackAllDamage && damageVisComp.DamageOverlay == null)
{
Logger.ErrorS(SawmillName, $"Enabled all damage tracking without a damage overlay sprite on {entity}.");
damageVisComp.Valid = false;
return;
}
if (!damageVisComp.TrackAllDamage && damageVisComp.DamageOverlay != null)
{
Logger.WarningS(SawmillName, $"Disabled all damage tracking with a damage overlay sprite on {entity}.");
damageVisComp.Valid = false;
return;
}
if (damageVisComp.TrackAllDamage && damageVisComp.DamageOverlayGroups != null)
{
Logger.WarningS(SawmillName, $"Enabled all damage tracking with damage overlay groups on {entity}.");
damageVisComp.Valid = false;
return;
}
}
else if (!damageVisComp.Overlay)
{
if (damageVisComp.TargetLayers == null)
{
Logger.ErrorS(SawmillName, $"Disabled overlay without target layers on {entity}.");
damageVisComp.Valid = false;
return;
}
if (damageVisComp.DamageOverlayGroups != null || damageVisComp.DamageOverlay != null)
{
Logger.ErrorS(SawmillName, $"Disabled overlay with defined damage overlay sprites on {entity}.");
damageVisComp.Valid = false;
return;
}
if (damageVisComp.DamageGroup == null)
{
Logger.ErrorS(SawmillName, $"Disabled overlay without defined damage group on {entity}.");
damageVisComp.Valid = false;
return;
}
}
if (damageVisComp.DamageOverlayGroups != null && damageVisComp.DamageGroup != null)
{
Logger.WarningS(SawmillName, $"Damage overlay sprites and damage group are both defined on {entity}.");
}
if (damageVisComp.DamageOverlay != null && damageVisComp.DamageGroup != null)
{
Logger.WarningS(SawmillName, $"Damage overlay sprites and damage group are both defined on {entity}.");
}
}
private void InitializeVisualizer(EntityUid entity, DamageVisualsComponent damageVisComp)
{
if (!TryComp(entity, out SpriteComponent? spriteComponent)
|| !TryComp<DamageableComponent?>(entity, out var damageComponent)
|| !HasComp<AppearanceComponent>(entity))
return;
damageVisComp.Thresholds.Add(FixedPoint2.Zero);
damageVisComp.Thresholds.Sort();
if (damageVisComp.Thresholds[0] != 0)
{
Logger.ErrorS(SawmillName, $"Thresholds were invalid for entity {entity}. Thresholds: {damageVisComp.Thresholds}");
damageVisComp.Valid = false;
return;
}
// If the damage container on our entity's DamageableComponent
// is not null, we can try to check through its groups.
if (damageComponent.DamageContainerID != null
&& _prototypeManager.TryIndex<DamageContainerPrototype>(damageComponent.DamageContainerID, out var damageContainer))
{
// Are we using damage overlay sprites by group?
// Check if the container matches the supported groups,
// and start caching the last threshold.
if (damageVisComp.DamageOverlayGroups != null)
{
foreach (var damageType in damageVisComp.DamageOverlayGroups.Keys)
{
if (!damageContainer.SupportedGroups.Contains(damageType))
{
Logger.ErrorS(SawmillName, $"Damage key {damageType} was invalid for entity {entity}.");
damageVisComp.Valid = false;
return;
}
damageVisComp.LastThresholdPerGroup.Add(damageType, FixedPoint2.Zero);
}
}
// Are we tracking a single damage group without overlay instead?
// See if that group is in our entity's damage container.
else if (!damageVisComp.Overlay && damageVisComp.DamageGroup != null)
{
if (!damageContainer.SupportedGroups.Contains(damageVisComp.DamageGroup))
{
Logger.ErrorS(SawmillName, $"Damage keys were invalid for entity {entity}.");
damageVisComp.Valid = false;
return;
}
damageVisComp.LastThresholdPerGroup.Add(damageVisComp.DamageGroup, FixedPoint2.Zero);
}
}
// Ditto above, but instead we go through every group.
else // oh boy! time to enumerate through every single group!
{
var damagePrototypeIdList = _prototypeManager.EnumeratePrototypes<DamageGroupPrototype>()
.Select((p, _) => p.ID)
.ToList();
if (damageVisComp.DamageOverlayGroups != null)
{
foreach (var damageType in damageVisComp.DamageOverlayGroups.Keys)
{
if (!damagePrototypeIdList.Contains(damageType))
{
Logger.ErrorS(SawmillName, $"Damage keys were invalid for entity {entity}.");
damageVisComp.Valid = false;
return;
}
damageVisComp.LastThresholdPerGroup.Add(damageType, FixedPoint2.Zero);
}
}
else if (damageVisComp.DamageGroup != null)
{
if (!damagePrototypeIdList.Contains(damageVisComp.DamageGroup))
{
Logger.ErrorS(SawmillName, $"Damage keys were invalid for entity {entity}.");
damageVisComp.Valid = false;
return;
}
damageVisComp.LastThresholdPerGroup.Add(damageVisComp.DamageGroup, FixedPoint2.Zero);
}
}
// If we're targeting any layers, and the amount of
// layers is greater than zero, we start reserving
// all the layers needed to track damage groups
// on the entity.
if (damageVisComp.TargetLayers is { Count: > 0 })
{
// This should ensure that the layers we're targeting
// are valid for the visualizer's use.
//
// If the layer doesn't have a base state, or
// the layer key just doesn't exist, we skip it.
foreach (var key in damageVisComp.TargetLayers)
{
if (!spriteComponent.LayerMapTryGet(key, out var index)
|| spriteComponent.LayerGetState(index).ToString() == null)
{
Logger.WarningS(SawmillName, $"Layer at key {key} was invalid for entity {entity}.");
continue;
}
damageVisComp.TargetLayerMapKeys.Add(key);
}
// Similar to damage overlay groups, if none of the targeted
// sprite layers could be used, we display an error and
// invalidate the visualizer without crashing.
if (damageVisComp.TargetLayerMapKeys.Count == 0)
{
Logger.ErrorS(SawmillName, $"Target layers were invalid for entity {entity}.");
damageVisComp.Valid = false;
return;
}
// Otherwise, we start reserving layers. Since the filtering
// loop above ensures that all of these layers are not null,
// and have valid state IDs, there should be no issues.
foreach (object layer in damageVisComp.TargetLayerMapKeys)
{
var layerCount = spriteComponent.AllLayers.Count();
var index = spriteComponent.LayerMapGet(layer);
var layerState = spriteComponent.LayerGetState(index).ToString()!;
if (index + 1 != layerCount)
{
index += 1;
}
damageVisComp.LayerMapKeyStates.Add(layer, layerState);
// If we're an overlay, and we're targeting groups,
// we reserve layers per damage group.
if (damageVisComp.Overlay && damageVisComp.DamageOverlayGroups != null)
{
foreach (var (group, sprite) in damageVisComp.DamageOverlayGroups)
{
AddDamageLayerToSprite(spriteComponent,
sprite,
$"{layerState}_{group}_{damageVisComp.Thresholds[1]}",
$"{layer}{group}",
index);
}
damageVisComp.DisabledLayers.Add(layer, false);
}
// If we're not targeting groups, and we're still
// using an overlay, we instead just add a general
// overlay that reflects on how much damage
// was taken.
else if (damageVisComp.DamageOverlay != null)
{
AddDamageLayerToSprite(spriteComponent,
damageVisComp.DamageOverlay,
$"{layerState}_{damageVisComp.Thresholds[1]}",
$"{layer}trackDamage",
index);
damageVisComp.DisabledLayers.Add(layer, false);
}
}
}
// If we're not targeting layers, however,
// we should ensure that we instead
// reserve it as an overlay.
else
{
if (damageVisComp.DamageOverlayGroups != null)
{
foreach (var (group, sprite) in damageVisComp.DamageOverlayGroups)
{
AddDamageLayerToSprite(spriteComponent,
sprite,
$"DamageOverlay_{group}_{damageVisComp.Thresholds[1]}",
$"DamageOverlay{group}");
damageVisComp.TopMostLayerKey = $"DamageOverlay{group}";
}
}
else if (damageVisComp.DamageOverlay != null)
{
AddDamageLayerToSprite(spriteComponent,
damageVisComp.DamageOverlay,
$"DamageOverlay_{damageVisComp.Thresholds[1]}",
"DamageOverlay");
damageVisComp.TopMostLayerKey = $"DamageOverlay";
}
}
}
/// <summary>
/// Adds a damage tracking layer to a given sprite component.
/// </summary>
private void AddDamageLayerToSprite(SpriteComponent spriteComponent, DamageVisualizerSprite sprite, string state, string mapKey, int? index = null)
{
var newLayer = spriteComponent.AddLayer(
new SpriteSpecifier.Rsi(
new ResourcePath(sprite.Sprite), state
), index);
spriteComponent.LayerMapSet(mapKey, newLayer);
if (sprite.Color != null)
spriteComponent.LayerSetColor(newLayer, Color.FromHex(sprite.Color));
spriteComponent.LayerSetVisible(newLayer, false);
}
protected override void OnAppearanceChange(EntityUid uid, DamageVisualsComponent damageVisComp, ref AppearanceChangeEvent args)
{
// how is this still here?
if (!damageVisComp.Valid)
return;
// If this was passed into the component, we update
// the data to ensure that the current disabled
// bool matches.
if (args.Component.TryGetData<bool>(DamageVisualizerKeys.Disabled, out var disabledStatus))
damageVisComp.Disabled = disabledStatus;
if (damageVisComp.Disabled)
return;
HandleDamage(args.Component, damageVisComp);
}
private void HandleDamage(AppearanceComponent component, DamageVisualsComponent damageVisComp)
{
if (!TryComp(component.Owner, out SpriteComponent? spriteComponent)
|| !TryComp(component.Owner, out DamageableComponent? damageComponent))
return;
if (damageVisComp.TargetLayers != null && damageVisComp.DamageOverlayGroups != null)
UpdateDisabledLayers(spriteComponent, component, damageVisComp);
if (damageVisComp.Overlay && damageVisComp.DamageOverlayGroups != null && damageVisComp.TargetLayers == null)
CheckOverlayOrdering(spriteComponent, damageVisComp);
if (component.TryGetData<bool>(DamageVisualizerKeys.ForceUpdate, out var update)
&& update)
{
ForceUpdateLayers(damageComponent, spriteComponent, damageVisComp);
return;
}
if (damageVisComp.TrackAllDamage)
{
UpdateDamageVisuals(damageComponent, spriteComponent, damageVisComp);
}
else if (component.TryGetData(DamageVisualizerKeys.DamageUpdateGroups, out DamageVisualizerGroupData data))
{
UpdateDamageVisuals(data.GroupList, damageComponent, spriteComponent, damageVisComp);
}
}
/// <summary>
/// Checks if any layers were disabled in the last
/// data update. Disabled layers mean that the
/// layer will no longer be visible, or obtain
/// any damage updates.
/// </summary>
private void UpdateDisabledLayers(SpriteComponent spriteComponent, AppearanceComponent component, DamageVisualsComponent damageVisComp)
{
foreach (var layer in damageVisComp.TargetLayerMapKeys)
{
bool? layerStatus = null;
if (component.TryGetData<bool>(layer, out var layerStateEnum))
layerStatus = layerStateEnum;
if (layerStatus == null)
continue;
if (damageVisComp.DisabledLayers[layer] != (bool) layerStatus)
{
damageVisComp.DisabledLayers[layer] = (bool) layerStatus;
if (!damageVisComp.TrackAllDamage && damageVisComp.DamageOverlayGroups != null)
{
foreach (var damageGroup in damageVisComp.DamageOverlayGroups!.Keys)
{
spriteComponent.LayerSetVisible($"{layer}{damageGroup}", damageVisComp.DisabledLayers[layer]);
}
}
else if (damageVisComp.TrackAllDamage)
spriteComponent.LayerSetVisible($"{layer}trackDamage", damageVisComp.DisabledLayers[layer]);
}
}
}
/// <summary>
/// Checks the overlay ordering on the current
/// sprite component, compared to the
/// data for the visualizer. If the top
/// most layer doesn't match, the sprite
/// layers are recreated and placed on top.
/// </summary>
private void CheckOverlayOrdering(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
{
if (spriteComponent[damageVisComp.TopMostLayerKey] != spriteComponent[spriteComponent.AllLayers.Count() - 1])
{
if (!damageVisComp.TrackAllDamage && damageVisComp.DamageOverlayGroups != null)
{
foreach (var (damageGroup, sprite) in damageVisComp.DamageOverlayGroups)
{
var threshold = damageVisComp.LastThresholdPerGroup[damageGroup];
ReorderOverlaySprite(spriteComponent,
damageVisComp,
sprite,
$"DamageOverlay{damageGroup}",
$"DamageOverlay_{damageGroup}",
threshold);
}
}
else if (damageVisComp.TrackAllDamage && damageVisComp.DamageOverlay != null)
{
ReorderOverlaySprite(spriteComponent,
damageVisComp,
damageVisComp.DamageOverlay,
$"DamageOverlay",
$"DamageOverlay",
damageVisComp.LastDamageThreshold);
}
}
}
private void ReorderOverlaySprite(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, DamageVisualizerSprite sprite, string key, string statePrefix, FixedPoint2 threshold)
{
spriteComponent.LayerMapTryGet(key, out var spriteLayer);
var visibility = spriteComponent[spriteLayer].Visible;
spriteComponent.RemoveLayer(spriteLayer);
if (threshold == FixedPoint2.Zero) // these should automatically be invisible
threshold = damageVisComp.Thresholds[1];
spriteLayer = spriteComponent.AddLayer(
new SpriteSpecifier.Rsi(
new ResourcePath(sprite.Sprite),
$"{statePrefix}_{threshold}"
),
spriteLayer);
spriteComponent.LayerMapSet(key, spriteLayer);
spriteComponent.LayerSetVisible(spriteLayer, visibility);
// this is somewhat iffy since it constantly reallocates
damageVisComp.TopMostLayerKey = key;
}
/// <summary>
/// Updates damage visuals without tracking
/// any damage groups.
/// </summary>
private void UpdateDamageVisuals(DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
{
if (!CheckThresholdBoundary(damageComponent.TotalDamage, damageVisComp.LastDamageThreshold, damageVisComp, out var threshold))
return;
damageVisComp.LastDamageThreshold = threshold;
if (damageVisComp.TargetLayers != null)
{
foreach (var layerMapKey in damageVisComp.TargetLayerMapKeys)
{
UpdateTargetLayer(spriteComponent, damageVisComp, layerMapKey, threshold);
}
}
else
{
UpdateOverlay(spriteComponent, threshold);
}
}
/// <summary>
/// Updates damage visuals by damage group,
/// according to the list of damage groups
/// passed into it.
/// </summary>
private void UpdateDamageVisuals(List<string> delta, DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
{
foreach (var damageGroup in delta)
{
if (!damageVisComp.Overlay && damageGroup != damageVisComp.DamageGroup)
continue;
if (!_prototypeManager.TryIndex<DamageGroupPrototype>(damageGroup, out var damageGroupPrototype)
|| !damageComponent.Damage.TryGetDamageInGroup(damageGroupPrototype, out var damageTotal))
continue;
if (!damageVisComp.LastThresholdPerGroup.TryGetValue(damageGroup, out var lastThreshold)
|| !CheckThresholdBoundary(damageTotal, lastThreshold, damageVisComp, out var threshold))
continue;
damageVisComp.LastThresholdPerGroup[damageGroup] = threshold;
if (damageVisComp.TargetLayers != null)
{
foreach (var layerMapKey in damageVisComp.TargetLayerMapKeys)
{
UpdateTargetLayer(spriteComponent, damageVisComp, layerMapKey, damageGroup, threshold);
}
}
else
{
UpdateOverlay(spriteComponent, damageVisComp, damageGroup, threshold);
}
}
}
/// <summary>
/// Checks if a threshold boundary was passed.
/// </summary>
private bool CheckThresholdBoundary(FixedPoint2 damageTotal, FixedPoint2 lastThreshold, DamageVisualsComponent damageVisComp, out FixedPoint2 threshold)
{
threshold = FixedPoint2.Zero;
damageTotal = damageTotal / damageVisComp.Divisor;
var thresholdIndex = damageVisComp.Thresholds.BinarySearch(damageTotal);
if (thresholdIndex < 0)
{
thresholdIndex = ~thresholdIndex;
threshold = damageVisComp.Thresholds[thresholdIndex - 1];
}
else
{
threshold = damageVisComp.Thresholds[thresholdIndex];
}
if (threshold == lastThreshold)
return false;
return true;
}
/// <summary>
/// This is the entry point for
/// forcing an update on all damage layers.
/// Does different things depending on
/// the configuration of the visualizer.
/// </summary>
private void ForceUpdateLayers(DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
{
if (damageVisComp.DamageOverlayGroups != null)
{
UpdateDamageVisuals(damageVisComp.DamageOverlayGroups.Keys.ToList(), damageComponent, spriteComponent, damageVisComp);
}
else if (damageVisComp.DamageGroup != null)
{
UpdateDamageVisuals(new List<string>(){ damageVisComp.DamageGroup }, damageComponent, spriteComponent, damageVisComp);
}
else if (damageVisComp.DamageOverlay != null)
{
UpdateDamageVisuals(damageComponent, spriteComponent, damageVisComp);
}
}
/// <summary>
/// Updates a target layer. Without a damage group passed in,
/// it assumes you're updating a layer that is tracking all
/// damage.
/// </summary>
private void UpdateTargetLayer(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, object layerMapKey, FixedPoint2 threshold)
{
if (damageVisComp.Overlay && damageVisComp.DamageOverlayGroups != null)
{
if (!damageVisComp.DisabledLayers[layerMapKey])
{
var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet($"{layerMapKey}trackDamage", out var spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}",
threshold);
}
}
else if (!damageVisComp.Overlay)
{
var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet(layerMapKey, out var spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}",
threshold);
}
}
/// <summary>
/// Updates a target layer by damage group.
/// </summary>
private void UpdateTargetLayer(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, object layerMapKey, string damageGroup, FixedPoint2 threshold)
{
if (damageVisComp.Overlay && damageVisComp.DamageOverlayGroups != null)
{
if (damageVisComp.DamageOverlayGroups.ContainsKey(damageGroup) && !damageVisComp.DisabledLayers[layerMapKey])
{
var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet($"{layerMapKey}{damageGroup}", out var spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}_{damageGroup}",
threshold);
}
}
else if (!damageVisComp.Overlay)
{
var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
spriteComponent.LayerMapTryGet(layerMapKey, out var spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"{layerState}_{damageGroup}",
threshold);
}
}
/// <summary>
/// Updates an overlay that is tracking all damage.
/// </summary>
private void UpdateOverlay(SpriteComponent spriteComponent, FixedPoint2 threshold)
{
spriteComponent.LayerMapTryGet($"DamageOverlay", out var spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"DamageOverlay",
threshold);
}
/// <summary>
/// Updates an overlay based on damage group.
/// </summary>
private void UpdateOverlay(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, string damageGroup, FixedPoint2 threshold)
{
if (damageVisComp.DamageOverlayGroups != null)
{
if (damageVisComp.DamageOverlayGroups.ContainsKey(damageGroup))
{
spriteComponent.LayerMapTryGet($"DamageOverlay{damageGroup}", out var spriteLayer);
UpdateDamageLayerState(spriteComponent,
spriteLayer,
$"DamageOverlay_{damageGroup}",
threshold);
}
}
}
/// <summary>
/// Updates a layer on the sprite by what
/// prefix it has (calculated by whatever
/// function calls it), and what threshold
/// was passed into it.
/// </summary>
private void UpdateDamageLayerState(SpriteComponent spriteComponent, int spriteLayer, string statePrefix, FixedPoint2 threshold)
{
if (threshold == 0)
{
spriteComponent.LayerSetVisible(spriteLayer, false);
}
else
{
if (!spriteComponent[spriteLayer].Visible)
{
spriteComponent.LayerSetVisible(spriteLayer, true);
}
spriteComponent.LayerSetState(spriteLayer, $"{statePrefix}_{threshold}");
}
}
}

30
Resources/Prototypes/Entities/Mobs/Species/base.yml
View File

@ -254,27 +254,27 @@
60: 0.7
80: 0.5
- type: HeatResistance
- type: DamageVisuals
thresholds: [ 20, 40, 100 ]
targetLayers:
- "enum.HumanoidVisualLayers.Chest"
- "enum.HumanoidVisualLayers.Head"
- "enum.HumanoidVisualLayers.LArm"
- "enum.HumanoidVisualLayers.LLeg"
- "enum.HumanoidVisualLayers.RArm"
- "enum.HumanoidVisualLayers.RLeg"
damageOverlayGroups:
Brute:
sprite: Mobs/Effects/brute_damage.rsi
color: "#FF0000"
Burn:
sprite: Mobs/Effects/burn_damage.rsi
- type: Appearance
visuals:
- type: RotationVisualizer
- type: BuckleVisualizer
- type: CreamPiedVisualizer
state: creampie_human
- type: DamageVisualizer
thresholds: [ 20, 40, 100 ]
targetLayers:
- "enum.HumanoidVisualLayers.Chest"
- "enum.HumanoidVisualLayers.Head"
- "enum.HumanoidVisualLayers.LArm"
- "enum.HumanoidVisualLayers.LLeg"
- "enum.HumanoidVisualLayers.RArm"
- "enum.HumanoidVisualLayers.RLeg"
damageOverlayGroups:
Brute:
sprite: Mobs/Effects/brute_damage.rsi
color: "#FF0000"
Burn:
sprite: Mobs/Effects/burn_damage.rsi
- type: FireVisuals
sprite: Mobs/Effects/onfire.rsi
normalState: Generic_mob_burning

13
Resources/Prototypes/Entities/Structures/Windows/plasma.yml
View File

@ -33,13 +33,12 @@
graph: Window
node: plasmaWindow
- type: Appearance
visuals:
- type: DamageVisualizer
thresholds: [4, 8, 12]
damageDivisor: 12
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: DamageVisuals
thresholds: [4, 8, 12]
damageDivisor: 12
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: StaticPrice
price: 20.5

13
Resources/Prototypes/Entities/Structures/Windows/reinforced.yml
View File

@ -42,13 +42,12 @@
graph: Window
node: reinforcedWindow
- type: Appearance
visuals:
- type: DamageVisualizer
thresholds: [4, 8, 12]
damageDivisor: 10
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: DamageVisuals
thresholds: [4, 8, 12]
damageDivisor: 10
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: StaticPrice
price: 0.75

13
Resources/Prototypes/Entities/Structures/Windows/rplasma.yml
View File

@ -42,13 +42,12 @@
graph: Window
node: reinforcedPlasmaWindow
- type: Appearance
visuals:
- type: DamageVisualizer
thresholds: [4, 8, 12]
damageDivisor: 36
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: DamageVisuals
thresholds: [4, 8, 12]
damageDivisor: 36
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: StaticPrice
price: 20.75

15
Resources/Prototypes/Entities/Structures/Windows/shuttle.yml
View File

@ -16,7 +16,7 @@
- trigger:
!type:DamageTrigger
damage: 1000
behaviors:
behaviors:
- !type:DoActsBehavior
acts: [ "Destruction" ]
- trigger:
@ -39,12 +39,11 @@
- type: IconSmooth
base: swindow
- type: Appearance
visuals:
- type: DamageVisualizer
thresholds: [4, 8, 12]
damageDivisor: 36
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: DamageVisuals
thresholds: [4, 8, 12]
damageDivisor: 36
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: StaticPrice
price: 75

13
Resources/Prototypes/Entities/Structures/Windows/window.yml
View File

@ -78,13 +78,12 @@
graph: Window
node: window
- type: Appearance
visuals:
- type: DamageVisualizer
thresholds: [4, 8, 12]
damageDivisor: 2
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: DamageVisuals
thresholds: [4, 8, 12]
damageDivisor: 2
trackAllDamage: true
damageOverlay:
sprite: Structures/Windows/cracks.rsi
- type: StaticPrice
price: 0.5