226 lines
11 KiB
C#
226 lines
11 KiB
C#
using System.Collections.Generic;
|
|
using Content.Shared.Acts;
|
|
using Content.Shared.Damage.Resistances;
|
|
using Robust.Shared.GameObjects;
|
|
|
|
namespace Content.Shared.Damage.Components
|
|
{
|
|
public interface IDamageableComponent : IComponent, IExAct
|
|
{
|
|
/// <summary>
|
|
/// The sum of all damages types in the DamageableComponent.
|
|
/// </summary>
|
|
int TotalDamage { get; }
|
|
|
|
/// <summary>
|
|
/// Returns a dictionary of the damage in the container, indexed by applicable <see cref="DamageGroupPrototype"/>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The values represent the sum of all damage in each group. If a supported damage type is a member of more than one group, it will contribute to each one.
|
|
/// Therefore, the sum of the values may be greater than the sum of the values in the dictionary returned by <see cref="GetDamagePerType"/>
|
|
/// </remarks>
|
|
IReadOnlyDictionary<DamageGroupPrototype, int> GetDamagePerApplicableGroup { get; }
|
|
|
|
/// <summary>
|
|
/// Returns a dictionary of the damage in the container, indexed by fully supported instances of <see
|
|
/// cref="DamageGroupPrototype"/>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The values represent the sum of all damage in each group. As the damage container may have some damage
|
|
/// types that are not part of a fully supported damage group, the sum of the values may be less of the values
|
|
/// in the dictionary returned by <see cref="GetDamagePerType"/>. On the other hand, if a supported damage type
|
|
/// is a member of more than one group, it will contribute to each one. Therefore, the sum may also be greater
|
|
/// instead.
|
|
/// </remarks>
|
|
IReadOnlyDictionary<DamageGroupPrototype, int> GetDamagePerFullySupportedGroup { get; }
|
|
|
|
/// <summary>
|
|
/// Returns a dictionary of the damage in the container, indexed by <see cref="DamageTypePrototype"/>.
|
|
/// </summary>
|
|
IReadOnlyDictionary<DamageTypePrototype, int> GetDamagePerType { get; }
|
|
|
|
/// <summary>
|
|
/// Like <see cref="GetDamagePerApplicableGroup"/>, but indexed by <see cref="DamageGroupPrototype.ID"/>
|
|
/// </summary>
|
|
IReadOnlyDictionary<string, int> GetDamagePerApplicableGroupIDs { get; }
|
|
|
|
/// <summary>
|
|
/// Like <see cref="GetDamagePerFullySupportedGroup"/>, but indexed by <see cref="DamageGroupPrototype.ID"/>
|
|
/// </summary>
|
|
IReadOnlyDictionary<string, int> GetDamagePerFullySupportedGroupIDs { get; }
|
|
|
|
/// <summary>
|
|
/// Like <see cref="GetDamagePerType"/>, but indexed by <see cref="DamageTypePrototype.ID"/>
|
|
/// </summary>
|
|
IReadOnlyDictionary<string, int> GetDamagePerTypeIDs { get; }
|
|
|
|
/// <summary>
|
|
/// Collection of damage types supported by this DamageableComponent.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Each of these damage types is fully supported. If any of these damage types is a
|
|
/// member of a damage group, these groups are represented in <see cref="ApplicableDamageGroups"></see>
|
|
/// </remarks>
|
|
HashSet<DamageTypePrototype> SupportedDamageTypes { get; }
|
|
|
|
/// <summary>
|
|
/// Collection of damage groups that are fully supported by DamageableComponent.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This describes what damage groups this damage container explicitly supports. It supports every damage type
|
|
/// contained in these damage groups. It may also support other damage types not in these groups. To see all
|
|
/// damage types <see cref="SupportedDamageTypes"/>, and to see all applicable damage groups <see
|
|
/// cref="ApplicableDamageGroups"/>.
|
|
/// </remarks>
|
|
HashSet<DamageGroupPrototype> FullySupportedDamageGroups { get; }
|
|
|
|
/// <summary>
|
|
/// Collection of damage groups that could apply damage to this DamageableComponent.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This describes what damage groups could have an effect on this damage container. However not every damage
|
|
/// group has to be fully supported. For example, the container may support ONLY the piercing damage type. It should
|
|
/// therefore be affected by instances of brute damage, but does not necessarily support blunt or slash damage.
|
|
/// For a list of supported damage types, see <see cref="SupportedDamageTypes"/>.
|
|
/// </remarks>
|
|
HashSet<DamageGroupPrototype> ApplicableDamageGroups { get; }
|
|
|
|
/// <summary>
|
|
/// The resistances of this component.
|
|
/// </summary>
|
|
ResistanceSet Resistances { get; }
|
|
|
|
/// <summary>
|
|
/// Tries to get the amount of damage of a type.
|
|
/// </summary>
|
|
/// <param name="type">The type to get the damage of.</param>
|
|
/// <param name="damage">The amount of damage of that type.</param>
|
|
/// <returns>
|
|
/// True if the given <see cref="type"/> is supported, false otherwise.
|
|
/// </returns>
|
|
bool TryGetDamage(DamageTypePrototype type, out int damage);
|
|
|
|
/// <summary>
|
|
/// Returns the amount of damage of a given type, or zero if it is not supported.
|
|
/// </summary>
|
|
int GetDamage(DamageTypePrototype type);
|
|
|
|
/// <summary>
|
|
/// Tries to get the total amount of damage in a damage group.
|
|
/// </summary>
|
|
/// <param name="group">The group to get the damage of.</param>
|
|
/// <param name="damage">The amount of damage in that group.</param>
|
|
/// <returns>
|
|
/// True if the given group is applicable to this container, false otherwise.
|
|
/// </returns>
|
|
bool TryGetDamage(DamageGroupPrototype group, out int damage);
|
|
|
|
/// <summary>
|
|
/// Returns the amount of damage present in an applicable group, or zero if no members are supported.
|
|
/// </summary>
|
|
int GetDamage(DamageGroupPrototype group);
|
|
|
|
/// <summary>
|
|
/// Tries to change the specified <see cref="DamageTypePrototype"/>, applying
|
|
/// resistance values only if it is dealing damage.
|
|
/// </summary>
|
|
/// <param name="type">Type of damage being changed.</param>
|
|
/// <param name="amount">
|
|
/// Amount of damage being received (positive for damage, negative for heals).
|
|
/// </param>
|
|
/// <param name="ignoreDamageResistances">
|
|
/// Whether or not to ignore resistances when taking damage.
|
|
/// Healing always ignores resistances, regardless of this input.
|
|
/// </param>
|
|
/// <returns>
|
|
/// False if the given type is not supported or no damage change occurred; true otherwise.
|
|
/// </returns>
|
|
bool TryChangeDamage(DamageTypePrototype type, int amount, bool ignoreDamageResistances = false);
|
|
|
|
/// <summary>
|
|
/// Tries to change damage of the specified <see cref="DamageGroupPrototype"/>, applying resistance values
|
|
/// only if it is damage.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// If dealing damage, this spreads the damage change amount evenly between the <see
|
|
/// cref="DamageTypePrototype"></see>s in this group (subject to integer rounding). If only a subset of the
|
|
/// damage types in the group are actually supported, then the total damage dealt may be less than expected
|
|
/// (unsupported damage is ignored).
|
|
/// </para>
|
|
/// <para>
|
|
/// If healing damage, this spreads the damage change proportional to the current damage value of each <see
|
|
/// cref="DamageTypePrototype"></see> (subject to integer rounding). If there is less damage than is being
|
|
/// healed, some healing is wasted. Unsupported damage types do not waste healing.
|
|
/// </para>
|
|
/// </remarks>
|
|
/// <param name="group">group of damage being changed.</param>
|
|
/// <param name="amount">
|
|
/// Amount of damage being received (positive for damage, negative for heals).
|
|
/// </param>
|
|
/// <param name="ignoreDamageResistances">
|
|
/// Whether to ignore resistances when taking damage. Healing always ignores resistances, regardless of this
|
|
/// input.
|
|
/// </param>
|
|
/// <returns>
|
|
/// Returns false if the given group is not applicable or no damage change occurred; true otherwise.
|
|
/// </returns>
|
|
bool TryChangeDamage(DamageGroupPrototype group, int amount, bool ignoreDamageResistances = false);
|
|
|
|
/// <summary>
|
|
/// Forcefully sets the specified <see cref="DamageTypePrototype"/> to the given value, ignoring resistance
|
|
/// values.
|
|
/// </summary>
|
|
/// <param name="type">Type of damage being set.</param>
|
|
/// <param name="newValue">New damage value to be set.</param>
|
|
/// <returns>
|
|
/// Returns false if a given type is not supported or a negative value is provided; true otherwise.
|
|
/// </returns>
|
|
bool TrySetDamage(DamageTypePrototype type, int newValue);
|
|
|
|
/// <summary>
|
|
/// Forcefully sets all damage types in a specified damage group using <see cref="TrySetDamage"></see>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Note that the actual damage of this group will be equal to the given value times the number damage group
|
|
/// members that this container supports.
|
|
/// </remarks>
|
|
/// <param name="group">Group of damage being set.</param>
|
|
/// <param name="newValue">New damage value to be set.</param>
|
|
/// <returns>
|
|
/// Returns false if the given group is not applicable or a negative value is provided; true otherwise.
|
|
/// </returns>
|
|
bool TrySetDamage(DamageGroupPrototype group, int newValue);
|
|
|
|
/// <summary>
|
|
/// Sets all supported damage types to specified value using <see cref="TrySetDamage"></see>.
|
|
/// </summary>
|
|
/// <param name="newValue">New damage value to be set.</param>
|
|
/// <returns>
|
|
/// Returns false if a negative value is provided; true otherwise.
|
|
/// </returns>
|
|
bool TrySetAllDamage(int newValue);
|
|
|
|
/// <summary>
|
|
/// Returns true if the given damage group is applicable to this damage container.
|
|
/// </summary>
|
|
public bool IsApplicableDamageGroup(DamageGroupPrototype group);
|
|
|
|
/// <summary>
|
|
/// Returns true if the given damage group is fully supported by this damage container.
|
|
/// </summary>
|
|
public bool IsFullySupportedDamageGroup(DamageGroupPrototype group);
|
|
|
|
/// <summary>
|
|
/// Returns true if the given damage type is supported by this damage container.
|
|
/// </summary>
|
|
public bool IsSupportedDamageType(DamageTypePrototype type);
|
|
|
|
|
|
/// <summary>
|
|
/// Invokes the HealthChangedEvent with the current values of health.
|
|
/// </summary>
|
|
void ForceHealthChangedEvent();
|
|
}
|
|
}
|