Regalis11
1159 lines
55 KiB
C#
1159 lines
55 KiB
C#
using Barotrauma.Abilities;
|
||
using Microsoft.Xna.Framework;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Reflection;
|
||
using System.Xml.Linq;
|
||
using Barotrauma.Extensions;
|
||
using System.Collections.Immutable;
|
||
using Barotrauma.Items.Components;
|
||
using System.Linq;
|
||
|
||
namespace Barotrauma
|
||
{
|
||
class CPRSettings : Prefab
|
||
{
|
||
public readonly static PrefabSelector<CPRSettings> Prefabs = new PrefabSelector<CPRSettings>();
|
||
public static CPRSettings Active => Prefabs.ActivePrefab;
|
||
|
||
public readonly float ReviveChancePerSkill;
|
||
public readonly float ReviveChanceExponent;
|
||
public readonly float ReviveChanceMin;
|
||
public readonly float ReviveChanceMax;
|
||
public readonly float StabilizationPerSkill;
|
||
public readonly float StabilizationMin;
|
||
public readonly float StabilizationMax;
|
||
public readonly float DamageSkillThreshold;
|
||
public readonly float DamageSkillMultiplier;
|
||
|
||
private readonly string insufficientSkillAfflictionIdentifier;
|
||
public AfflictionPrefab InsufficientSkillAffliction
|
||
{
|
||
get
|
||
{
|
||
return
|
||
AfflictionPrefab.Prefabs.ContainsKey(insufficientSkillAfflictionIdentifier) ?
|
||
AfflictionPrefab.Prefabs[insufficientSkillAfflictionIdentifier] :
|
||
AfflictionPrefab.InternalDamage;
|
||
}
|
||
}
|
||
|
||
public CPRSettings(XElement element, AfflictionsFile file) : base(file, file.Path.Value.ToIdentifier())
|
||
{
|
||
ReviveChancePerSkill = Math.Max(element.GetAttributeFloat("revivechanceperskill", 0.01f), 0.0f);
|
||
ReviveChanceExponent = Math.Max(element.GetAttributeFloat("revivechanceexponent", 2.0f), 0.0f);
|
||
ReviveChanceMin = MathHelper.Clamp(element.GetAttributeFloat("revivechancemin", 0.05f), 0.0f, 1.0f);
|
||
ReviveChanceMax = MathHelper.Clamp(element.GetAttributeFloat("revivechancemax", 0.9f), ReviveChanceMin, 1.0f);
|
||
|
||
StabilizationPerSkill = Math.Max(element.GetAttributeFloat("stabilizationperskill", 0.01f), 0.0f);
|
||
StabilizationMin = MathHelper.Max(element.GetAttributeFloat("stabilizationmin", 0.05f), 0.0f);
|
||
StabilizationMax = MathHelper.Max(element.GetAttributeFloat("stabilizationmax", 2.0f), StabilizationMin);
|
||
|
||
DamageSkillThreshold = MathHelper.Clamp(element.GetAttributeFloat("damageskillthreshold", 40.0f), 0.0f, 100.0f);
|
||
DamageSkillMultiplier = MathHelper.Clamp(element.GetAttributeFloat("damageskillmultiplier", 0.1f), 0.0f, 100.0f);
|
||
|
||
insufficientSkillAfflictionIdentifier = element.GetAttributeString("insufficientskillaffliction", "");
|
||
}
|
||
|
||
public override void Dispose() { }
|
||
}
|
||
|
||
/// <summary>
|
||
/// AfflictionPrefabHusk is a special type of affliction that has added functionality for husk infection.
|
||
/// </summary>
|
||
class AfflictionPrefabHusk : AfflictionPrefab
|
||
{
|
||
// Use any of these to define which limb the appendage is attached to.
|
||
// If multiple are defined, the order of preference is: id, name, type.
|
||
public readonly int AttachLimbId;
|
||
public readonly string AttachLimbName;
|
||
public readonly LimbType AttachLimbType;
|
||
|
||
/// <summary>
|
||
/// The minimum strength at which husk infection will be in the dormant stage.
|
||
/// It must be less than or equal to ActiveThreshold.
|
||
/// </summary>
|
||
public readonly float DormantThreshold;
|
||
|
||
/// <summary>
|
||
/// The minimum strength at which husk infection will be in the active stage.
|
||
/// It must be greater than or equal to DormantThreshold and less than or equal to TransitionThreshold.
|
||
/// </summary>
|
||
public readonly float ActiveThreshold;
|
||
|
||
/// <summary>
|
||
/// The minimum strength at which husk infection will be in its final stage.
|
||
/// It must be greater than or equal to ActiveThreshold.
|
||
/// </summary>
|
||
public readonly float TransitionThreshold;
|
||
|
||
/// <summary>
|
||
/// The minimum strength the affliction must have for the affected character
|
||
/// to transform into a husk upon death.
|
||
/// </summary>
|
||
public readonly float TransformThresholdOnDeath;
|
||
|
||
/// <summary>
|
||
/// The species of husk to convert the affected character to
|
||
/// once husk infection reaches its final stage.
|
||
/// </summary>
|
||
public readonly Identifier HuskedSpeciesName;
|
||
|
||
/// <summary>
|
||
/// If set to true, all buffs are transferred to the converted
|
||
/// character after husk transformation is complete.
|
||
/// </summary>
|
||
public readonly bool TransferBuffs;
|
||
|
||
/// <summary>
|
||
/// If set to true, the affected player will see on-screen messages describing husk infection symptoms
|
||
/// and affected bots will speak about their current husk infection stage.
|
||
/// </summary>
|
||
public readonly bool SendMessages;
|
||
|
||
/// <summary>
|
||
/// If set to true, affected characters will have their speech impeded once the affliction
|
||
/// reaches the dormant stage.
|
||
/// </summary>
|
||
public readonly bool CauseSpeechImpediment;
|
||
|
||
/// <summary>
|
||
/// If set to false, affected characters will no longer require air
|
||
/// once the affliction reaches the active stage.
|
||
/// </summary>
|
||
public readonly bool NeedsAir;
|
||
|
||
/// <summary>
|
||
/// If set to true, affected players will retain control of their character
|
||
/// after transforming into a husk.
|
||
/// </summary>
|
||
public readonly bool ControlHusk;
|
||
|
||
public AfflictionPrefabHusk(ContentXElement element, AfflictionsFile file, Type type = null) : base(element, file, type)
|
||
{
|
||
HuskedSpeciesName = element.GetAttributeIdentifier("huskedspeciesname", Identifier.Empty);
|
||
if (HuskedSpeciesName.IsEmpty)
|
||
{
|
||
DebugConsole.NewMessage($"No 'huskedspeciesname' defined for the husk affliction ({Identifier}) in {element}", Color.Orange);
|
||
HuskedSpeciesName = "husk".ToIdentifier();
|
||
}
|
||
// Remove "[speciesname]" for backward support (we don't use it anymore)
|
||
HuskedSpeciesName = HuskedSpeciesName.Remove("[speciesname]").ToIdentifier();
|
||
if (TargetSpecies.Length == 0)
|
||
{
|
||
DebugConsole.NewMessage($"No 'targets' defined for the husk affliction ({Identifier}) in {element}", Color.Orange);
|
||
TargetSpecies = new Identifier[] { CharacterPrefab.HumanSpeciesName };
|
||
}
|
||
var attachElement = element.GetChildElement("attachlimb");
|
||
if (attachElement != null)
|
||
{
|
||
AttachLimbId = attachElement.GetAttributeInt("id", -1);
|
||
AttachLimbName = attachElement.GetAttributeString("name", null);
|
||
AttachLimbType = attachElement.GetAttributeEnum("type", LimbType.None);
|
||
}
|
||
else
|
||
{
|
||
AttachLimbId = -1;
|
||
AttachLimbName = null;
|
||
AttachLimbType = LimbType.None;
|
||
}
|
||
|
||
TransferBuffs = element.GetAttributeBool("transferbuffs", true);
|
||
SendMessages = element.GetAttributeBool("sendmessages", true);
|
||
CauseSpeechImpediment = element.GetAttributeBool("causespeechimpediment", true);
|
||
NeedsAir = element.GetAttributeBool("needsair", false);
|
||
ControlHusk = element.GetAttributeBool("controlhusk", false);
|
||
|
||
DormantThreshold = element.GetAttributeFloat("dormantthreshold", MaxStrength * 0.5f);
|
||
ActiveThreshold = element.GetAttributeFloat("activethreshold", MaxStrength * 0.75f);
|
||
TransitionThreshold = element.GetAttributeFloat("transitionthreshold", MaxStrength);
|
||
|
||
if (DormantThreshold > ActiveThreshold)
|
||
{
|
||
DebugConsole.ThrowError($"Error in \"{Identifier}\": {nameof(DormantThreshold)} is greater than {nameof(ActiveThreshold)} ({DormantThreshold} > {ActiveThreshold})",
|
||
contentPackage: element.ContentPackage);
|
||
}
|
||
if (ActiveThreshold > TransitionThreshold)
|
||
{
|
||
DebugConsole.ThrowError($"Error in \"{Identifier}\": {nameof(ActiveThreshold)} is greater than {nameof(TransitionThreshold)} ({ActiveThreshold} > {TransitionThreshold})",
|
||
contentPackage: element.ContentPackage);
|
||
}
|
||
|
||
TransformThresholdOnDeath = element.GetAttributeFloat("transformthresholdondeath", ActiveThreshold);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// AfflictionPrefab is a prefab that defines a type of affliction that can be applied to a character.
|
||
/// There are multiple sub-types of afflictions such as AfflictionPrefabHusk, AfflictionPsychosis and AfflictionBleeding that can be used for additional functionality.
|
||
///
|
||
/// When defining a new affliction, the type will be determined by the element name.
|
||
/// </summary>
|
||
/// <example>
|
||
/// <code language="xml">
|
||
/// <Afflictions>
|
||
/// <!-- Defines a regular affliction. -->
|
||
/// <Affliction identifier="mycoolaffliction1" />
|
||
///
|
||
/// <!-- Defines an AfflictionPrefabHusk affliction. -->
|
||
/// <AfflictionPrefabHusk identifier="mycoolaffliction2"/>
|
||
///
|
||
/// <!-- Defines an AfflictionBleeding affliction. -->
|
||
/// <AfflictionBleeding identifier="mycoolaffliction3"/>
|
||
/// </Afflictions>
|
||
/// </code>
|
||
/// </example>
|
||
class AfflictionPrefab : PrefabWithUintIdentifier
|
||
{
|
||
/// <summary>
|
||
/// Effects are the primary way to add functionality to afflictions.
|
||
/// </summary>
|
||
/// <doc>
|
||
/// <Ignore type="SubElement" identifier="AbilityFlag" />
|
||
/// <SubElement identifier="abilityflag" type="AppliedAbilityFlag">
|
||
/// Enables the specified flag on the character as long as the effect is active.
|
||
/// </SubElement>
|
||
/// <Type identifier="AppliedAbilityFlag">
|
||
/// <Summary>
|
||
/// Flag that will be enabled for the character as long as the effect is active.
|
||
/// <example>
|
||
/// <code language="xml">
|
||
/// <Effect minstrength="0" maxstrength="100">
|
||
/// <!-- Grants pressure immunity to the character while the effect is active. -->
|
||
/// <AbilityFlag flagtype="ImmuneToPressure" />
|
||
/// </Effect>
|
||
/// </code>
|
||
/// </example>
|
||
/// </Summary>
|
||
/// <Field identifier="FlagType" type="AbilityFlags" defaultValue="None">
|
||
/// Which ability flag to enable.
|
||
/// </Field>
|
||
/// </Type>
|
||
/// </doc>
|
||
public sealed class Effect
|
||
{
|
||
//this effect is applied when the strength is within this range
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Minimum affliction strength required for this effect to be active.")]
|
||
public float MinStrength { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Maximum affliction strength for which this effect will be active.")]
|
||
public float MaxStrength { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "The amount of vitality that is lost at this effect's lowest strength.")]
|
||
public float MinVitalityDecrease { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "The amount of vitality that is lost at this effect's highest strength.")]
|
||
public float MaxVitalityDecrease { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "How much the affliction's strength changes every second while this effect is active.")]
|
||
public float StrengthChange { get; private set; }
|
||
|
||
[Serialize(false, IsPropertySaveable.No, description:
|
||
"If set to true, MinVitalityDecrease and MaxVitalityDecrease represent a fraction of the affected character's maximum " +
|
||
"vitality, with 1 meaning 100%, instead of the same amount for all species.")]
|
||
public bool MultiplyByMaxVitality { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Blur effect strength at this effect's lowest strength.")]
|
||
public float MinScreenBlur { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Blur effect strength at this effect's highest strength.")]
|
||
public float MaxScreenBlur { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Generic distortion effect strength at this effect's lowest strength.")]
|
||
public float MinScreenDistort { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Generic distortion effect strength at this effect's highest strength.")]
|
||
public float MaxScreenDistort { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Radial distortion effect strength at this effect's lowest strength.")]
|
||
public float MinRadialDistort { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Radial distortion effect strength at this effect's highest strength.")]
|
||
public float MaxRadialDistort { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Chromatic aberration effect strength at this effect's lowest strength.")]
|
||
public float MinChromaticAberration { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Chromatic aberration effect strength at this effect's highest strength.")]
|
||
public float MaxChromaticAberration { get; private set; }
|
||
|
||
[Serialize("255,255,255,255", IsPropertySaveable.No, description: "Radiation grain effect color.")]
|
||
public Color GrainColor { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Radiation grain effect strength at this effect's lowest strength.")]
|
||
public float MinGrainStrength { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description: "Radiation grain effect strength at this effect's highest strength.")]
|
||
public float MaxGrainStrength { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No, description:
|
||
"The maximum rate of fluctuation to apply to visual effects caused by this affliction effect. " +
|
||
"Effective fluctuation is proportional to the affliction's current strength.")]
|
||
public float ScreenEffectFluctuationFrequency { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description:
|
||
"Multiplier for the affliction overlay's opacity at this effect's lowest strength. " +
|
||
"See the list of elements for more details.")]
|
||
public float MinAfflictionOverlayAlphaMultiplier { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description:
|
||
"Multiplier for the affliction overlay's opacity at this effect's highest strength. " +
|
||
"See the list of elements for more details.")]
|
||
public float MaxAfflictionOverlayAlphaMultiplier { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description:
|
||
"Multiplier for every buff's decay rate at this effect's lowest strength. " +
|
||
"Only applies to afflictions of class BuffDurationIncrease.")]
|
||
public float MinBuffMultiplier { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description:
|
||
"Multiplier for every buff's decay rate at this effect's highest strength. " +
|
||
"Only applies to afflictions of class BuffDurationIncrease.")]
|
||
public float MaxBuffMultiplier { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to the affected character's speed at this effect's lowest strength.")]
|
||
public float MinSpeedMultiplier { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to the affected character's speed at this effect's highest strength.")]
|
||
public float MaxSpeedMultiplier { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to all of the affected character's skill levels at this effect's lowest strength.")]
|
||
public float MinSkillMultiplier { get; private set; }
|
||
|
||
[Serialize(1.0f, IsPropertySaveable.No, description: "Multiplier to apply to all of the affected character's skill levels at this effect's highest strength.")]
|
||
public float MaxSkillMultiplier { get; private set; }
|
||
|
||
/// <summary>
|
||
/// A list of identifiers of afflictions that the affected character will be
|
||
/// resistant to when this effect is active.
|
||
/// </summary>
|
||
public readonly ImmutableArray<Identifier> ResistanceFor;
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No,
|
||
description: "The amount of resistance to the afflictions specified by ResistanceFor to apply at this effect's lowest strength.")]
|
||
public float MinResistance { get; private set; }
|
||
|
||
[Serialize(0.0f, IsPropertySaveable.No,
|
||
description: "The amount of resistance to the afflictions specified by ResistanceFor to apply at this effect's highest strength.")]
|
||
public float MaxResistance { get; private set; }
|
||
|
||
[Serialize("", IsPropertySaveable.No, description: "Identifier used by AI to determine conversation lines to say when this effect is active.")]
|
||
public Identifier DialogFlag { get; private set; }
|
||
|
||
[Serialize("", IsPropertySaveable.No, description: "Tag that enemy AI may use to target the affected character when this effect is active.")]
|
||
public Identifier Tag { get; private set; }
|
||
|
||
[Serialize("0,0,0,0", IsPropertySaveable.No,
|
||
description: "Color to tint the affected character's face with at this effect's lowest strength. The alpha channel is used to determine how much to tint the character's face.")]
|
||
public Color MinFaceTint { get; private set; }
|
||
|
||
[Serialize("0,0,0,0", IsPropertySaveable.No,
|
||
description: "Color to tint the affected character's face with at this effect's highest strength. The alpha channel is used to determine how much to tint the character's face.")]
|
||
public Color MaxFaceTint { get; private set; }
|
||
|
||
[Serialize("0,0,0,0", IsPropertySaveable.No,
|
||
description: "Color to tint the affected character's entire body with at this effect's lowest strength. The alpha channel is used to determine how much to tint the character.")]
|
||
public Color MinBodyTint { get; private set; }
|
||
|
||
[Serialize("0,0,0,0", IsPropertySaveable.No,
|
||
description: "Color to tint the affected character's entire body with at this effect's highest strength. The alpha channel is used to determine how much to tint the character.")]
|
||
public Color MaxBodyTint { get; private set; }
|
||
|
||
/// <summary>
|
||
/// StatType that will be applied to the affected character when the effect is active that is proportional to the effect's strength.
|
||
/// </summary>
|
||
/// <example>
|
||
/// <code language="xml">
|
||
/// <Effect minstrength="0" maxstrength="100">
|
||
/// <!-- Walking speed will be increased by 10% at strength 0, 20% at 50 and 30% at 100 -->
|
||
/// <StatValue stattype="WalkingSpeed" minvalue="0.1" maxvalue="0.3" />
|
||
/// <!-- Maximum health will be increased by 20% regardless of the effect strength -->
|
||
/// <StatValue stattype="MaximumHealthMultiplier" value="0.2" />
|
||
/// </Effect>
|
||
/// </code>
|
||
/// </example>
|
||
public readonly struct AppliedStatValue
|
||
{
|
||
/// <summary>
|
||
/// Which StatType to apply
|
||
/// </summary>
|
||
public readonly StatTypes StatType;
|
||
|
||
/// <summary>
|
||
/// Minimum value to apply
|
||
/// </summary>
|
||
public readonly float MinValue;
|
||
|
||
/// <summary>
|
||
/// Minimum value to apply
|
||
/// </summary>
|
||
public readonly float MaxValue;
|
||
|
||
/// <summary>
|
||
/// Constant value to apply, will be ignored if MinValue or MaxValue are set
|
||
/// </summary>
|
||
private readonly float Value;
|
||
|
||
public AppliedStatValue(ContentXElement element)
|
||
{
|
||
Value = element.GetAttributeFloat("value", 0.0f);
|
||
StatType = element.GetAttributeEnum("stattype", StatTypes.None);
|
||
MinValue = element.GetAttributeFloat("minvalue", Value);
|
||
MaxValue = element.GetAttributeFloat("maxvalue", Value);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Prevents AfflictionHusks with the specified identifier(s) from transforming the character into an AI-controlled character.
|
||
/// </summary>
|
||
public readonly ImmutableArray<Identifier> BlockTransformation;
|
||
|
||
/// <summary>
|
||
/// StatType that will be applied to the affected character when the effect is active that is proportional to the effect's strength.
|
||
/// </summary>
|
||
public readonly ImmutableDictionary<StatTypes, AppliedStatValue> AfflictionStatValues;
|
||
|
||
public readonly AbilityFlags AfflictionAbilityFlags;
|
||
|
||
//statuseffects applied on the character when the affliction is active
|
||
public readonly ImmutableArray<StatusEffect> StatusEffects;
|
||
|
||
public Effect(ContentXElement element, string parentDebugName)
|
||
{
|
||
SerializableProperty.DeserializeProperties(this, element);
|
||
|
||
ResistanceFor = element.GetAttributeIdentifierArray("resistancefor", Array.Empty<Identifier>())!.ToImmutableArray();
|
||
BlockTransformation = element.GetAttributeIdentifierArray("blocktransformation", Array.Empty<Identifier>())!.ToImmutableArray();
|
||
|
||
var afflictionStatValues = new Dictionary<StatTypes, AppliedStatValue>();
|
||
var statusEffects = new List<StatusEffect>();
|
||
foreach (var subElement in element.Elements())
|
||
{
|
||
switch (subElement.Name.ToString().ToLowerInvariant())
|
||
{
|
||
case "statuseffect":
|
||
statusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
|
||
break;
|
||
case "statvalue":
|
||
var newStatValue = new AppliedStatValue(subElement);
|
||
if (newStatValue.StatType == StatTypes.None || !afflictionStatValues.TryAdd(newStatValue.StatType, newStatValue))
|
||
{
|
||
DebugConsole.ThrowError($"Invalid stat value in the affliction \"{parentDebugName}\".", contentPackage: element.ContentPackage);
|
||
}
|
||
break;
|
||
case "abilityflag":
|
||
AbilityFlags flagType = subElement.GetAttributeEnum("flagtype", AbilityFlags.None);
|
||
if (flagType is AbilityFlags.None)
|
||
{
|
||
DebugConsole.ThrowError($"Error in affliction \"{parentDebugName}\" - invalid ability flag type \"{subElement.GetAttributeString("flagtype", "")}\".",
|
||
contentPackage: element.ContentPackage);
|
||
continue;
|
||
}
|
||
AfflictionAbilityFlags |= flagType;
|
||
break;
|
||
case "affliction":
|
||
DebugConsole.AddWarning($"Error in affliction \"{parentDebugName}\" - additional afflictions caused by the affliction should be configured inside status effects.",
|
||
contentPackage: element.ContentPackage);
|
||
break;
|
||
}
|
||
}
|
||
AfflictionStatValues = afflictionStatValues.ToImmutableDictionary();
|
||
StatusEffects = statusEffects.ToImmutableArray();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns 0 if affliction.Strength is MinStrength,
|
||
/// 1 if affliction.Strength is MaxStrength
|
||
/// </summary>
|
||
public float GetStrengthFactor(Affliction affliction) => GetStrengthFactor(affliction.Strength);
|
||
|
||
/// <summary>
|
||
/// Returns 0 if affliction.Strength is MinStrength,
|
||
/// 1 if affliction.Strength is MaxStrength
|
||
/// </summary>
|
||
public float GetStrengthFactor(float strength)
|
||
=> MathUtils.InverseLerp(
|
||
MinStrength,
|
||
MaxStrength,
|
||
strength);
|
||
}
|
||
|
||
/// <summary>
|
||
/// The description element can be used to define descriptions for the affliction which are shown under specific conditions;
|
||
/// for example a description that only shows to other players or only at certain strength levels.
|
||
/// </summary>
|
||
/// <doc>
|
||
/// <Field identifier="Text" type="string" defaultValue="""">
|
||
/// Raw text for the description.
|
||
/// </Field>
|
||
/// </doc>
|
||
public sealed class Description
|
||
{
|
||
public enum TargetType
|
||
{
|
||
/// <summary>
|
||
/// Everyone can see the description.
|
||
/// </summary>
|
||
Any,
|
||
/// <summary>
|
||
/// Only the affected character can see the description.
|
||
/// </summary>
|
||
Self,
|
||
/// <summary>
|
||
/// The affected character cannot see the description but others can.
|
||
/// </summary>
|
||
OtherCharacter
|
||
}
|
||
|
||
/// <summary>
|
||
/// Raw text for the description.
|
||
/// </summary>
|
||
public readonly LocalizedString Text;
|
||
|
||
/// <summary>
|
||
/// Text tag used to set the text from the localization files.
|
||
/// </summary>
|
||
public readonly Identifier TextTag;
|
||
|
||
/// <summary>
|
||
/// Minimum strength required for the description to be shown.
|
||
/// </summary>
|
||
public readonly float MinStrength;
|
||
|
||
/// <summary>
|
||
/// Maximum strength required for the description to be shown.
|
||
/// </summary>
|
||
public readonly float MaxStrength;
|
||
|
||
/// <summary>
|
||
/// Who can see the description.
|
||
/// </summary>
|
||
public readonly TargetType Target;
|
||
|
||
public Description(ContentXElement element, AfflictionPrefab affliction)
|
||
{
|
||
TextTag = element.GetAttributeIdentifier("textidentifier", Identifier.Empty);
|
||
if (!TextTag.IsEmpty)
|
||
{
|
||
Text = TextManager.Get(TextTag);
|
||
}
|
||
string text = element.GetAttributeString("text", string.Empty);
|
||
if (!text.IsNullOrEmpty())
|
||
{
|
||
Text = Text?.Fallback(text) ?? text;
|
||
}
|
||
else if (TextTag.IsEmpty)
|
||
{
|
||
DebugConsole.ThrowError($"Error in affliction \"{affliction.Identifier}\" - no text defined for one of the descriptions.",
|
||
contentPackage: element.ContentPackage);
|
||
}
|
||
|
||
MinStrength = element.GetAttributeFloat(nameof(MinStrength), 0.0f);
|
||
MaxStrength = element.GetAttributeFloat(nameof(MaxStrength), 100.0f);
|
||
if (MinStrength >= MaxStrength)
|
||
{
|
||
DebugConsole.ThrowError($"Error in affliction \"{affliction.Identifier}\" - max strength is not larger than min.",
|
||
contentPackage: element.ContentPackage);
|
||
}
|
||
Target = element.GetAttributeEnum(nameof(Target), TargetType.Any);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// PeriodicEffect applies StatusEffects to the character periodically.
|
||
/// </summary>
|
||
/// <doc>
|
||
/// <SubElement identifier="StatusEffect" type="StatusEffect" />
|
||
/// <Field identifier="Interval" type="float" defaultValue="1.0">
|
||
/// How often the status effect is applied in seconds.
|
||
/// Setting this attribute will set both the min and max interval to the specified value.
|
||
/// </Field>
|
||
/// <Field identifier="MinInterval" type="float" defaultValue="1.0">
|
||
/// Minimum interval between applying the status effect in seconds.
|
||
/// </Field>
|
||
/// <Field identifier="MaxInterval" type="float" defaultValue="1.0">
|
||
/// Maximum interval between applying the status effect in seconds.
|
||
/// </Field>
|
||
/// </doc>
|
||
public sealed class PeriodicEffect
|
||
{
|
||
public readonly List<StatusEffect> StatusEffects = new List<StatusEffect>();
|
||
public readonly float MinInterval, MaxInterval;
|
||
public readonly float MinStrength, MaxStrength;
|
||
|
||
public PeriodicEffect(ContentXElement element, string parentDebugName)
|
||
{
|
||
foreach (var subElement in element.Elements())
|
||
{
|
||
StatusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
|
||
}
|
||
|
||
if (element.GetAttribute("interval") != null)
|
||
{
|
||
MinInterval = MaxInterval = Math.Max(element.GetAttributeFloat("interval", 1.0f), 1.0f);
|
||
}
|
||
else
|
||
{
|
||
MinInterval = Math.Max(element.GetAttributeFloat(nameof(MinInterval), 1.0f), 1.0f);
|
||
MaxInterval = Math.Max(element.GetAttributeFloat(nameof(MaxInterval), 1.0f), MinInterval);
|
||
MinStrength = Math.Max(element.GetAttributeFloat(nameof(MinStrength), 0f), 0f);
|
||
MaxStrength = Math.Max(element.GetAttributeFloat(nameof(MaxStrength), MinStrength), MinStrength);
|
||
}
|
||
}
|
||
}
|
||
|
||
public static readonly Identifier DamageType = "damage".ToIdentifier();
|
||
public static readonly Identifier BurnType = "burn".ToIdentifier();
|
||
public static readonly Identifier BleedingType = "bleeding".ToIdentifier();
|
||
public static readonly Identifier ParalysisType = "paralysis".ToIdentifier();
|
||
public static readonly Identifier PoisonType = "poison".ToIdentifier();
|
||
public static readonly Identifier StunType = "stun".ToIdentifier();
|
||
public static readonly Identifier EMPType = "emp".ToIdentifier();
|
||
public static readonly Identifier SpaceHerpesType = "spaceherpes".ToIdentifier();
|
||
public static readonly Identifier AlienInfectedType = "alieninfected".ToIdentifier();
|
||
public static readonly Identifier InvertControlsType = "invertcontrols".ToIdentifier();
|
||
|
||
public static AfflictionPrefab InternalDamage => Prefabs["internaldamage"];
|
||
public static AfflictionPrefab BiteWounds => Prefabs["bitewounds"];
|
||
public static AfflictionPrefab ImpactDamage => Prefabs["blunttrauma"];
|
||
public static AfflictionPrefab Bleeding => Prefabs[BleedingType];
|
||
public static AfflictionPrefab Burn => Prefabs[BurnType];
|
||
public static AfflictionPrefab OxygenLow => Prefabs["oxygenlow"];
|
||
public static AfflictionPrefab Bloodloss => Prefabs["bloodloss"];
|
||
public static AfflictionPrefab Pressure => Prefabs["pressure"];
|
||
public static AfflictionPrefab OrganDamage => Prefabs["organdamage"];
|
||
public static AfflictionPrefab Stun => Prefabs[StunType];
|
||
public static AfflictionPrefab RadiationSickness => Prefabs["radiationsickness"];
|
||
|
||
|
||
public static readonly PrefabCollection<AfflictionPrefab> Prefabs = new PrefabCollection<AfflictionPrefab>();
|
||
|
||
public static IEnumerable<AfflictionPrefab> List => Prefabs;
|
||
|
||
public override void Dispose() { }
|
||
|
||
private readonly ContentXElement configElement;
|
||
|
||
public readonly LocalizedString Name;
|
||
|
||
public readonly LocalizedString CauseOfDeathDescription, SelfCauseOfDeathDescription;
|
||
|
||
private readonly LocalizedString defaultDescription;
|
||
public readonly ImmutableList<Description> Descriptions;
|
||
|
||
/// <summary>
|
||
/// Arbitrary string that is used to identify the type of the affliction.
|
||
/// </summary>
|
||
public readonly Identifier AfflictionType;
|
||
|
||
/// <summary>
|
||
/// If set to true, the affliction affects individual limbs. Otherwise, it affects the whole character.
|
||
/// </summary>
|
||
public readonly bool LimbSpecific;
|
||
|
||
/// <summary>
|
||
/// If the affliction doesn't affect individual limbs, this attribute determines
|
||
/// where the game will render the affliction's indicator when viewed in the
|
||
/// in-game health UI.
|
||
///
|
||
/// For example, the psychosis indicator is rendered on the head, and low oxygen
|
||
/// is rendered on the torso.
|
||
/// </summary>
|
||
public readonly LimbType IndicatorLimb;
|
||
|
||
/// <summary>
|
||
/// Can be set to the identifier of another affliction to make this affliction
|
||
/// reuse the same name and description.
|
||
/// </summary>
|
||
public readonly Identifier TranslationIdentifier;
|
||
|
||
/// <summary>
|
||
/// If set to true, the game will recognize this affliction as a buff.
|
||
/// This means, among other things, that bots won't attempt to treat it,
|
||
/// and the health UI will render the affected limb in green rather than red.
|
||
/// </summary>
|
||
public readonly bool IsBuff;
|
||
|
||
/// <summary>
|
||
/// If set to true, this affliction can affect characters that are marked as
|
||
/// machines, such as the Fractal Guardian.
|
||
/// </summary>
|
||
public readonly bool AffectMachines;
|
||
|
||
/// <summary>
|
||
/// If set to true, this affliction can be healed at the medical clinic.
|
||
/// </summary>
|
||
/// <doc>
|
||
/// <override type="DefaultValue">
|
||
/// false if the affliction is a buff or has the type "geneticmaterialbuff" or "geneticmaterialdebuff", true otherwise.
|
||
/// </override>
|
||
/// </doc>
|
||
public readonly bool HealableInMedicalClinic;
|
||
|
||
/// <summary>
|
||
/// How much each unit of this affliction's strength will add
|
||
/// to the cost of healing at the medical clinic.
|
||
/// </summary>
|
||
public readonly float HealCostMultiplier;
|
||
|
||
/// <summary>
|
||
/// The minimum cost of healing this affliction at the medical clinic.
|
||
/// </summary>
|
||
public readonly int BaseHealCost;
|
||
|
||
/// <summary>
|
||
/// If set to false, the health UI will not show the strength of the affliction
|
||
/// as a bar under its indicator.
|
||
/// </summary>
|
||
public readonly bool ShowBarInHealthMenu;
|
||
|
||
/// <summary>
|
||
/// If set to true, this affliction's icon will be hidden from the HUD after 5 seconds.
|
||
/// </summary>
|
||
public readonly bool HideIconAfterDelay;
|
||
|
||
/// <summary>
|
||
/// How high the strength has to be for the affliction to take effect
|
||
/// </summary>
|
||
public readonly float ActivationThreshold = 0.0f;
|
||
|
||
/// <summary>
|
||
/// How high the strength has to be for the affliction icon to be shown in the UI
|
||
/// </summary>
|
||
public readonly float ShowIconThreshold = 0.05f;
|
||
|
||
/// <summary>
|
||
/// How high the strength has to be for the affliction icon to be shown to others with a health scanner or via the health interface
|
||
/// </summary>
|
||
public readonly float ShowIconToOthersThreshold = 0.05f;
|
||
|
||
/// <summary>
|
||
/// The maximum strength this affliction can have.
|
||
/// </summary>
|
||
public readonly float MaxStrength = 100.0f;
|
||
|
||
/// <summary>
|
||
/// The strength of the radiation grain effect to apply when the strength of this affliction increases.
|
||
/// </summary>
|
||
public readonly float GrainBurst;
|
||
|
||
/// <summary>
|
||
/// How high the strength has to be for the affliction icon to be shown with a health scanner
|
||
/// </summary>
|
||
public readonly float ShowInHealthScannerThreshold;
|
||
|
||
/// <summary>
|
||
/// How strong the affliction needs to be before bots attempt to treat it.
|
||
/// Also effects when the affliction is shown in the suitable treatments list.
|
||
/// </summary>
|
||
public readonly float TreatmentThreshold;
|
||
|
||
/// <summary>
|
||
/// Bots will not try to treat the affliction if the character has any of these afflictions
|
||
/// </summary>
|
||
public ImmutableHashSet<Identifier> IgnoreTreatmentIfAfflictedBy;
|
||
|
||
/// <summary>
|
||
/// The duration of the affliction, in seconds. If set to 0, the affliction does not expire.
|
||
/// </summary>
|
||
public readonly float Duration;
|
||
|
||
/// <summary>
|
||
/// How much karma changes when a player applies this affliction to someone (per strength of the affliction)
|
||
/// </summary>
|
||
public float KarmaChangeOnApplied;
|
||
|
||
/// <summary>
|
||
/// Opacity of the burn effect (darker tint) on limbs affected by this affliction. 1 = full strength.
|
||
/// </summary>
|
||
public readonly float BurnOverlayAlpha;
|
||
|
||
/// <summary>
|
||
/// Opacity of the bloody damage overlay on limbs affected by this affliction. 1 = full strength.
|
||
/// </summary>
|
||
public readonly float DamageOverlayAlpha;
|
||
|
||
/// Steam achievement given when the controlled character receives the affliction.
|
||
/// </summary>
|
||
public readonly Identifier AchievementOnReceived;
|
||
|
||
/// <summary>
|
||
/// Steam achievement given when the affliction is removed from the controlled character.
|
||
/// </summary>
|
||
public readonly Identifier AchievementOnRemoved;
|
||
|
||
/// <summary>
|
||
/// A gradient that defines which color to render this affliction's icon
|
||
/// with, based on the affliction's current strength.
|
||
/// </summary>
|
||
public readonly Color[] IconColors;
|
||
|
||
/// <summary>
|
||
/// If set to true and the affliction has an AfflictionOverlay element, the overlay's opacity will be strictly proportional to its strength.
|
||
/// Otherwise, the overlay's opacity will be determined based on its activation threshold and effects.
|
||
/// </summary>
|
||
public readonly bool AfflictionOverlayAlphaIsLinear;
|
||
|
||
/// <summary>
|
||
/// If set to true, this affliction will not persist between rounds.
|
||
/// </summary>
|
||
public readonly bool ResetBetweenRounds;
|
||
|
||
/// <summary>
|
||
/// Should damage particles be emitted when a character receives this affliction?
|
||
/// Only relevant if the affliction is of the type "bleeding" or "damage".
|
||
/// </summary>
|
||
public readonly bool DamageParticles;
|
||
|
||
/// <summary>
|
||
/// An arbitrary modifier that affects how much medical skill is increased when you apply the affliction on a target.
|
||
/// If the affliction causes damage or is of the 'poison' or 'paralysis' type, the skill is increased only when the target is hostile.
|
||
/// If the affliction is of the 'buff' type, the skill is increased only when the target is friendly.
|
||
/// </summary>
|
||
public readonly float MedicalSkillGain;
|
||
|
||
/// <summary>
|
||
/// An arbitrary modifier that affects how much weapons skill is increased when you apply the affliction on a target.
|
||
/// The skill is increased only when the target is hostile.
|
||
/// </summary>
|
||
public readonly float WeaponsSkillGain;
|
||
|
||
/// <summary>
|
||
/// A list of species this affliction is allowed to affect.
|
||
/// </summary>
|
||
public Identifier[] TargetSpecies { get; protected set; }
|
||
|
||
/// <summary>
|
||
/// Effects to apply at various strength levels.
|
||
/// Only one effect can be applied at any given moment, so their ranges should be defined with no overlap.
|
||
/// </summary>
|
||
private readonly List<Effect> effects = new List<Effect>();
|
||
|
||
/// <summary>
|
||
/// PeriodicEffect applies StatusEffects to the character periodically.
|
||
/// </summary>
|
||
private readonly List<PeriodicEffect> periodicEffects = new List<PeriodicEffect>();
|
||
|
||
public IEnumerable<Effect> Effects => effects;
|
||
|
||
public IList<PeriodicEffect> PeriodicEffects => periodicEffects;
|
||
|
||
private readonly ConstructorInfo constructor;
|
||
|
||
/// <summary>
|
||
/// An icon that’s used in the UI to represent this affliction.
|
||
/// </summary>
|
||
public readonly Sprite Icon;
|
||
|
||
/// <summary>
|
||
/// A sprite that covers the affected player's entire screen when this affliction is active.
|
||
/// Its opacity is controlled by the active effect's MinAfflictionOverlayAlphaMultiplier and MaxAfflictionOverlayAlphaMultiplier
|
||
/// </summary>
|
||
public readonly Sprite AfflictionOverlay;
|
||
|
||
public ImmutableDictionary<Identifier, float> TreatmentSuitabilities
|
||
{
|
||
get;
|
||
private set;
|
||
} = new Dictionary<Identifier, float>().ToImmutableDictionary();
|
||
|
||
/// <summary>
|
||
/// Can this affliction be treated with some item?
|
||
/// </summary>
|
||
public bool HasTreatments { get; private set; }
|
||
|
||
public AfflictionPrefab(ContentXElement element, AfflictionsFile file, Type type) : base(file, element.GetAttributeIdentifier("identifier", ""))
|
||
{
|
||
configElement = element;
|
||
|
||
AfflictionType = element.GetAttributeIdentifier("type", "");
|
||
TranslationIdentifier = element.GetAttributeIdentifier("translationoverride", Identifier);
|
||
Name = TextManager.Get($"AfflictionName.{TranslationIdentifier}");
|
||
string fallbackName = element.GetAttributeString("name", "");
|
||
if (!string.IsNullOrEmpty(fallbackName))
|
||
{
|
||
Name = Name.Fallback(fallbackName);
|
||
}
|
||
defaultDescription = TextManager.Get($"AfflictionDescription.{TranslationIdentifier}");
|
||
string fallbackDescription = element.GetAttributeString("description", "");
|
||
if (!string.IsNullOrEmpty(fallbackDescription))
|
||
{
|
||
defaultDescription = defaultDescription.Fallback(fallbackDescription);
|
||
}
|
||
IsBuff = element.GetAttributeBool(nameof(IsBuff), false);
|
||
AffectMachines = element.GetAttributeBool(nameof(AffectMachines), true);
|
||
|
||
ShowBarInHealthMenu = element.GetAttributeBool("showbarinhealthmenu", true);
|
||
|
||
HealableInMedicalClinic = element.GetAttributeBool("healableinmedicalclinic",
|
||
!IsBuff &&
|
||
AfflictionType != "geneticmaterialbuff" &&
|
||
AfflictionType != "geneticmaterialdebuff");
|
||
HealCostMultiplier = element.GetAttributeFloat(nameof(HealCostMultiplier), 1f);
|
||
BaseHealCost = element.GetAttributeInt(nameof(BaseHealCost), 0);
|
||
|
||
IgnoreTreatmentIfAfflictedBy = element.GetAttributeIdentifierArray(nameof(IgnoreTreatmentIfAfflictedBy), Array.Empty<Identifier>()).ToImmutableHashSet();
|
||
|
||
Duration = element.GetAttributeFloat(nameof(Duration), 0.0f);
|
||
|
||
if (element.GetAttribute("nameidentifier") != null)
|
||
{
|
||
Name = TextManager.Get(element.GetAttributeString("nameidentifier", string.Empty)).Fallback(Name);
|
||
}
|
||
|
||
LimbSpecific = element.GetAttributeBool("limbspecific", false);
|
||
if (!LimbSpecific)
|
||
{
|
||
string indicatorLimbName = element.GetAttributeString("indicatorlimb", "Torso");
|
||
if (!Enum.TryParse(indicatorLimbName, out IndicatorLimb))
|
||
{
|
||
DebugConsole.ThrowErrorLocalized("Error in affliction prefab " + Name + " - limb type \"" + indicatorLimbName + "\" not found.");
|
||
}
|
||
}
|
||
|
||
HideIconAfterDelay = element.GetAttributeBool(nameof(HideIconAfterDelay), false);
|
||
|
||
ActivationThreshold = element.GetAttributeFloat(nameof(ActivationThreshold), 0.0f);
|
||
ShowIconThreshold = element.GetAttributeFloat(nameof(ShowIconThreshold), Math.Max(ActivationThreshold, 0.05f));
|
||
ShowIconToOthersThreshold = element.GetAttributeFloat(nameof(ShowIconToOthersThreshold), ShowIconThreshold);
|
||
MaxStrength = element.GetAttributeFloat(nameof(MaxStrength), 100.0f);
|
||
GrainBurst = element.GetAttributeFloat(nameof(GrainBurst), 0.0f);
|
||
|
||
ShowInHealthScannerThreshold = element.GetAttributeFloat(nameof(ShowInHealthScannerThreshold),
|
||
Math.Max(ActivationThreshold, AfflictionType == "talentbuff" ? float.MaxValue : ShowIconToOthersThreshold));
|
||
TreatmentThreshold = element.GetAttributeFloat(nameof(TreatmentThreshold), Math.Max(ActivationThreshold, 10.0f));
|
||
|
||
DamageOverlayAlpha = element.GetAttributeFloat(nameof(DamageOverlayAlpha), 0.0f);
|
||
BurnOverlayAlpha = element.GetAttributeFloat(nameof(BurnOverlayAlpha), 0.0f);
|
||
|
||
KarmaChangeOnApplied = element.GetAttributeFloat(nameof(KarmaChangeOnApplied), 0.0f);
|
||
|
||
CauseOfDeathDescription =
|
||
TextManager.Get($"AfflictionCauseOfDeath.{TranslationIdentifier}")
|
||
.Fallback(TextManager.Get(element.GetAttributeString("causeofdeathdescription", "")))
|
||
.Fallback(element.GetAttributeString("causeofdeathdescription", ""));
|
||
SelfCauseOfDeathDescription =
|
||
TextManager.Get($"AfflictionCauseOfDeathSelf.{TranslationIdentifier}")
|
||
.Fallback(TextManager.Get(element.GetAttributeString("selfcauseofdeathdescription", "")))
|
||
.Fallback(element.GetAttributeString("selfcauseofdeathdescription", ""));
|
||
|
||
IconColors = element.GetAttributeColorArray(nameof(IconColors), null);
|
||
AfflictionOverlayAlphaIsLinear = element.GetAttributeBool(nameof(AfflictionOverlayAlphaIsLinear), false);
|
||
AchievementOnReceived = element.GetAttributeIdentifier(nameof(AchievementOnReceived), "");
|
||
AchievementOnRemoved = element.GetAttributeIdentifier(nameof(AchievementOnRemoved), "");
|
||
|
||
TargetSpecies = element.GetAttributeIdentifierArray("targets", Array.Empty<Identifier>(), trim: true);
|
||
|
||
ResetBetweenRounds = element.GetAttributeBool("resetbetweenrounds", false);
|
||
|
||
DamageParticles = element.GetAttributeBool(nameof(DamageParticles), true);
|
||
WeaponsSkillGain = element.GetAttributeFloat(nameof(WeaponsSkillGain), 0.0f);
|
||
MedicalSkillGain = element.GetAttributeFloat(nameof(MedicalSkillGain), 0.0f);
|
||
|
||
List<Description> descriptions = new List<Description>();
|
||
foreach (var subElement in element.Elements())
|
||
{
|
||
switch (subElement.Name.ToString().ToLowerInvariant())
|
||
{
|
||
case "icon":
|
||
Icon = new Sprite(subElement);
|
||
break;
|
||
case "afflictionoverlay":
|
||
AfflictionOverlay = new Sprite(subElement);
|
||
break;
|
||
case "statvalue":
|
||
DebugConsole.ThrowError($"Error in affliction \"{Identifier}\" - stat values should be configured inside the affliction's effects.",
|
||
contentPackage: element.ContentPackage);
|
||
break;
|
||
case "effect":
|
||
case "periodiceffect":
|
||
break;
|
||
case "description":
|
||
descriptions.Add(new Description(subElement, this));
|
||
break;
|
||
default:
|
||
DebugConsole.AddWarning($"Unrecognized element in affliction \"{Identifier}\" ({subElement.Name})",
|
||
contentPackage: element.ContentPackage);
|
||
break;
|
||
}
|
||
}
|
||
Descriptions = descriptions.ToImmutableList();
|
||
|
||
constructor = type.GetConstructor(new[] { typeof(AfflictionPrefab), typeof(float) });
|
||
}
|
||
|
||
private void RefreshTreatmentSuitabilities()
|
||
{
|
||
var newTreatmentSuitabilities = new Dictionary<Identifier, float>();
|
||
|
||
foreach (var itemPrefab in ItemPrefab.Prefabs)
|
||
{
|
||
float suitability = itemPrefab.GetTreatmentSuitability(Identifier) + itemPrefab.GetTreatmentSuitability(AfflictionType);
|
||
if (!MathUtils.NearlyEqual(suitability, 0.0f))
|
||
{
|
||
newTreatmentSuitabilities.TryAdd(itemPrefab.Identifier, suitability);
|
||
}
|
||
}
|
||
HasTreatments = newTreatmentSuitabilities.Any(kvp => kvp.Value > 0);
|
||
TreatmentSuitabilities = newTreatmentSuitabilities.ToImmutableDictionary();
|
||
}
|
||
|
||
public LocalizedString GetDescription(float strength, Description.TargetType targetType)
|
||
{
|
||
foreach (var description in Descriptions)
|
||
{
|
||
if (strength < description.MinStrength || strength > description.MaxStrength) { continue; }
|
||
switch (targetType)
|
||
{
|
||
case Description.TargetType.Self:
|
||
if (description.Target == Description.TargetType.OtherCharacter) { continue; }
|
||
break;
|
||
case Description.TargetType.OtherCharacter:
|
||
if (description.Target == Description.TargetType.Self) { continue; }
|
||
break;
|
||
}
|
||
return description.Text;
|
||
}
|
||
return defaultDescription;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Should be called before each round: loads all StatusEffects and refreshes treatment suitabilities.
|
||
/// </summary>
|
||
public static void LoadAllEffectsAndTreatmentSuitabilities()
|
||
{
|
||
foreach (var prefab in Prefabs)
|
||
{
|
||
prefab.RefreshTreatmentSuitabilities();
|
||
prefab.LoadEffects();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Removes all the effects of the prefab (including the sounds and other assets defined in them).
|
||
/// Note that you need to call LoadAllEffectsAndTreatmentSuitabilities before trying to use the affliction again!
|
||
/// </summary>
|
||
public static void ClearAllEffects()
|
||
{
|
||
Prefabs.ForEach(p => p.ClearEffects());
|
||
}
|
||
|
||
private void LoadEffects()
|
||
{
|
||
ClearEffects();
|
||
foreach (var subElement in configElement.Elements())
|
||
{
|
||
switch (subElement.Name.ToString().ToLowerInvariant())
|
||
{
|
||
case "effect":
|
||
effects.Add(new Effect(subElement, Name.Value));
|
||
break;
|
||
case "periodiceffect":
|
||
periodicEffects.Add(new PeriodicEffect(subElement, Name.Value));
|
||
break;
|
||
}
|
||
}
|
||
for (int i = 0; i < effects.Count; i++)
|
||
{
|
||
for (int j = i + 1; j < effects.Count; j++)
|
||
{
|
||
var a = effects[i];
|
||
var b = effects[j];
|
||
if (a.MinStrength < b.MaxStrength && b.MinStrength < a.MaxStrength)
|
||
{
|
||
DebugConsole.AddWarning($"Affliction \"{Identifier}\" contains effects with overlapping strength ranges. Only one effect can be active at a time, meaning one of the effects won't work.",
|
||
ContentPackage);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void ClearEffects()
|
||
{
|
||
effects.Clear();
|
||
periodicEffects.Clear();
|
||
}
|
||
|
||
#if CLIENT
|
||
public void ReloadSoundsIfNeeded()
|
||
{
|
||
foreach (var effect in effects)
|
||
{
|
||
foreach (var statusEffect in effect.StatusEffects)
|
||
{
|
||
foreach (var sound in statusEffect.Sounds)
|
||
{
|
||
if (sound.Sound == null) { RoundSound.Reload(sound); }
|
||
}
|
||
}
|
||
}
|
||
foreach (var periodicEffect in periodicEffects)
|
||
{
|
||
foreach (var statusEffect in periodicEffect.StatusEffects)
|
||
{
|
||
foreach (var sound in statusEffect.Sounds)
|
||
{
|
||
if (sound.Sound == null) { RoundSound.Reload(sound); }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
public override string ToString()
|
||
{
|
||
return $"AfflictionPrefab ({Name})";
|
||
}
|
||
|
||
public Affliction Instantiate(float strength, Character source = null)
|
||
{
|
||
object instance = null;
|
||
try
|
||
{
|
||
instance = constructor.Invoke(new object[] { this, strength });
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
DebugConsole.ThrowError(ex.InnerException != null ? ex.InnerException.ToString() : ex.ToString());
|
||
}
|
||
Affliction affliction = instance as Affliction;
|
||
affliction.Source = source;
|
||
return affliction;
|
||
}
|
||
|
||
public Effect GetActiveEffect(float currentStrength)
|
||
{
|
||
foreach (Effect effect in effects)
|
||
{
|
||
if (currentStrength > effect.MinStrength && currentStrength <= effect.MaxStrength)
|
||
{
|
||
return effect;
|
||
}
|
||
}
|
||
|
||
//if above the strength range of all effects, use the highest strength effect
|
||
Effect strongestEffect = null;
|
||
float largestStrength = currentStrength;
|
||
foreach (Effect effect in effects)
|
||
{
|
||
if (currentStrength > effect.MaxStrength &&
|
||
(strongestEffect == null || effect.MaxStrength > largestStrength))
|
||
{
|
||
strongestEffect = effect;
|
||
largestStrength = effect.MaxStrength;
|
||
}
|
||
}
|
||
return strongestEffect;
|
||
}
|
||
|
||
public float GetTreatmentSuitability(Item item)
|
||
{
|
||
if (item == null)
|
||
{
|
||
return 0.0f;
|
||
}
|
||
return Math.Max(item.Prefab.GetTreatmentSuitability(Identifier), item.Prefab.GetTreatmentSuitability(AfflictionType));
|
||
}
|
||
}
|
||
}
|