Evil Factory
798 lines
34 KiB
C#
798 lines
34 KiB
C#
using Barotrauma.Abilities;
|
|
using Microsoft.Xna.Framework;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Xml.Linq;
|
|
|
|
namespace Barotrauma
|
|
{
|
|
static class CPRSettings
|
|
{
|
|
public static string FilePath { get; private set; }
|
|
public static bool IsLoaded { get; private set; }
|
|
public static float ReviveChancePerSkill { get; private set; }
|
|
public static float ReviveChanceExponent { get; private set; }
|
|
public static float ReviveChanceMin { get; private set; }
|
|
public static float ReviveChanceMax { get; private set; }
|
|
public static float StabilizationPerSkill { get; private set; }
|
|
public static float StabilizationMin { get; private set; }
|
|
public static float StabilizationMax { get; private set; }
|
|
public static float DamageSkillThreshold { get; private set; }
|
|
public static float DamageSkillMultiplier { get; private set; }
|
|
|
|
private static string insufficientSkillAfflictionIdentifier { get; set; }
|
|
public static AfflictionPrefab InsufficientSkillAffliction
|
|
{
|
|
get
|
|
{
|
|
return
|
|
AfflictionPrefab.Prefabs.ContainsKey(insufficientSkillAfflictionIdentifier) ?
|
|
AfflictionPrefab.Prefabs[insufficientSkillAfflictionIdentifier] :
|
|
AfflictionPrefab.InternalDamage;
|
|
}
|
|
}
|
|
|
|
public static void Load(XElement element, string filePath)
|
|
{
|
|
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", "");
|
|
|
|
IsLoaded = true;
|
|
FilePath = filePath;
|
|
}
|
|
|
|
public static void Unload()
|
|
{
|
|
IsLoaded = false;
|
|
FilePath = null;
|
|
}
|
|
}
|
|
|
|
class AfflictionPrefabHusk : AfflictionPrefab
|
|
{
|
|
public AfflictionPrefabHusk(XElement element, string filePath, Type type = null) : base(element, filePath, type)
|
|
{
|
|
HuskedSpeciesName = element.GetAttributeString("huskedspeciesname", null).ToLowerInvariant();
|
|
if (HuskedSpeciesName == null)
|
|
{
|
|
DebugConsole.NewMessage($"No 'huskedspeciesname' defined for the husk affliction ({Identifier}) in {element}", Color.Orange);
|
|
HuskedSpeciesName = "[speciesname]husk";
|
|
}
|
|
TargetSpecies = element.GetAttributeStringArray("targets", new string[0] { }, trim: true, convertToLowerInvariant: true);
|
|
if (TargetSpecies.Length == 0)
|
|
{
|
|
DebugConsole.NewMessage($"No 'targets' defined for the husk affliction ({Identifier}) in {element}", Color.Orange);
|
|
TargetSpecies = new string[] { "human" };
|
|
}
|
|
var attachElement = element.GetChildElement("attachlimb");
|
|
if (attachElement != null)
|
|
{
|
|
AttachLimbId = attachElement.GetAttributeInt("id", -1);
|
|
AttachLimbName = attachElement.GetAttributeString("name", null);
|
|
AttachLimbType = Enum.TryParse(attachElement.GetAttributeString("type", "none"), true, out LimbType limbType) ? limbType : 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);
|
|
TransformThresholdOnDeath = element.GetAttributeFloat("transformthresholdondeath", ActiveThreshold);
|
|
}
|
|
|
|
// 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;
|
|
|
|
public float ActiveThreshold, DormantThreshold, TransitionThreshold;
|
|
public float TransformThresholdOnDeath;
|
|
|
|
public readonly string HuskedSpeciesName;
|
|
public readonly string[] TargetSpecies;
|
|
public const string Tag = "[speciesname]";
|
|
|
|
public readonly bool TransferBuffs;
|
|
public readonly bool SendMessages;
|
|
public readonly bool CauseSpeechImpediment;
|
|
public readonly bool NeedsAir;
|
|
public readonly bool ControlHusk;
|
|
}
|
|
|
|
partial class AfflictionPrefab : IPrefab, IDisposable, IHasUintIdentifier
|
|
{
|
|
public class Effect
|
|
{
|
|
//this effect is applied when the strength is within this range
|
|
[Serialize(0.0f, false)]
|
|
public float MinStrength { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxStrength { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MinVitalityDecrease { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxVitalityDecrease { get; private set; }
|
|
|
|
//how much the strength of the affliction changes per second
|
|
[Serialize(0.0f, false)]
|
|
public float StrengthChange { get; private set; }
|
|
|
|
[Serialize(false, false)]
|
|
public bool MultiplyByMaxVitality { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MinScreenBlur { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxScreenBlur { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MinScreenDistort { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxScreenDistort { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MinRadialDistort { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxRadialDistort { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MinChromaticAberration { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxChromaticAberration { get; private set; }
|
|
|
|
[Serialize("255,255,255,255", false)]
|
|
public Color GrainColor { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MinGrainStrength { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxGrainStrength { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float ScreenEffectFluctuationFrequency { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MinAfflictionOverlayAlphaMultiplier { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MaxAfflictionOverlayAlphaMultiplier { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MinBuffMultiplier { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MaxBuffMultiplier { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MinSpeedMultiplier { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MaxSpeedMultiplier { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MinSkillMultiplier { get; private set; }
|
|
|
|
[Serialize(1.0f, false)]
|
|
public float MaxSkillMultiplier { get; private set; }
|
|
|
|
private readonly string[] resistanceFor;
|
|
public IEnumerable<string> ResistanceFor
|
|
{
|
|
get { return resistanceFor; }
|
|
}
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MinResistance { get; private set; }
|
|
|
|
[Serialize(0.0f, false)]
|
|
public float MaxResistance { get; private set; }
|
|
|
|
[Serialize("", false)]
|
|
public string DialogFlag { get; private set; }
|
|
|
|
[Serialize("0,0,0,0", false)]
|
|
public Color MinFaceTint { get; private set; }
|
|
|
|
[Serialize("0,0,0,0", false)]
|
|
public Color MaxFaceTint { get; private set; }
|
|
|
|
[Serialize("0,0,0,0", false)]
|
|
public Color MinBodyTint { get; private set; }
|
|
|
|
[Serialize("0,0,0,0", false)]
|
|
public Color MaxBodyTint { get; private set; }
|
|
|
|
public readonly Dictionary<StatTypes, (float minValue, float maxValue)> AfflictionStatValues = new Dictionary<StatTypes, (float minValue, float maxValue)>();
|
|
public readonly HashSet<AbilityFlags> AfflictionAbilityFlags = new HashSet<AbilityFlags>();
|
|
|
|
//statuseffects applied on the character when the affliction is active
|
|
public readonly List<StatusEffect> StatusEffects = new List<StatusEffect>();
|
|
|
|
public Effect(XElement element, string parentDebugName)
|
|
{
|
|
SerializableProperty.DeserializeProperties(this, element);
|
|
|
|
resistanceFor = element.GetAttributeStringArray("resistancefor", new string[0], convertToLowerInvariant: true);
|
|
|
|
foreach (XElement subElement in element.Elements())
|
|
{
|
|
switch (subElement.Name.ToString().ToLowerInvariant())
|
|
{
|
|
case "statuseffect":
|
|
StatusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
|
|
break;
|
|
case "statvalue":
|
|
var statType = CharacterAbilityGroup.ParseStatType(subElement.GetAttributeString("stattype", ""), parentDebugName);
|
|
|
|
float defaultValue = subElement.GetAttributeFloat("value", 0f);
|
|
float minValue = subElement.GetAttributeFloat("minvalue", defaultValue);
|
|
float maxValue = subElement.GetAttributeFloat("maxvalue", defaultValue);
|
|
|
|
AfflictionStatValues.TryAdd(statType, (minValue, maxValue));
|
|
break;
|
|
case "abilityflag":
|
|
var flagType = CharacterAbilityGroup.ParseFlagType(subElement.GetAttributeString("flagtype", ""), parentDebugName);
|
|
AfflictionAbilityFlags.Add(flagType);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class PeriodicEffect
|
|
{
|
|
public readonly List<StatusEffect> StatusEffects = new List<StatusEffect>();
|
|
public readonly float MinInterval, MaxInterval;
|
|
|
|
public PeriodicEffect(XElement element, string parentDebugName)
|
|
{
|
|
foreach (XElement subElement in element.Elements())
|
|
{
|
|
StatusEffects.Add(StatusEffect.Load(subElement, parentDebugName));
|
|
}
|
|
|
|
if (element.Attribute("interval") != null)
|
|
{
|
|
MinInterval = MaxInterval = Math.Max(element.GetAttributeFloat("interval", 1.0f), 1.0f);
|
|
}
|
|
else
|
|
{
|
|
MinInterval = Math.Max(element.GetAttributeFloat("mininterval", 1.0f), 1.0f);
|
|
MaxInterval = Math.Max(element.GetAttributeFloat("maxinterval", 1.0f), MinInterval);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static AfflictionPrefab InternalDamage;
|
|
public static AfflictionPrefab ImpactDamage;
|
|
public static AfflictionPrefab Bleeding;
|
|
public static AfflictionPrefab Burn;
|
|
public static AfflictionPrefab OxygenLow;
|
|
public static AfflictionPrefab Bloodloss;
|
|
public static AfflictionPrefab Pressure;
|
|
public static AfflictionPrefab Stun;
|
|
public static AfflictionPrefab RadiationSickness;
|
|
|
|
public static readonly PrefabCollection<AfflictionPrefab> Prefabs = new PrefabCollection<AfflictionPrefab>();
|
|
|
|
private bool disposed = false;
|
|
public void Dispose()
|
|
{
|
|
if (disposed) { return; }
|
|
disposed = true;
|
|
Prefabs.Remove(this);
|
|
}
|
|
|
|
public static IEnumerable<AfflictionPrefab> List
|
|
{
|
|
get
|
|
{
|
|
foreach (var prefab in Prefabs)
|
|
{
|
|
yield return prefab;
|
|
}
|
|
}
|
|
}
|
|
|
|
public string FilePath { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Unique identifier that's generated by hashing the prefab's string identifier.
|
|
/// Used to reduce the amount of bytes needed to write affliction data into network messages in multiplayer.
|
|
/// </summary>
|
|
public uint UIntIdentifier { get; set; }
|
|
|
|
// Arbitrary string that is used to identify the type of the affliction.
|
|
public readonly string AfflictionType;
|
|
|
|
//Does the affliction affect a specific limb or the whole character
|
|
public readonly bool LimbSpecific;
|
|
|
|
//If not a limb-specific affliction, which limb is the indicator shown on in the health menu
|
|
//(e.g. mental health problems on head, lack of oxygen on torso...)
|
|
public readonly LimbType IndicatorLimb;
|
|
|
|
public string Identifier { get; private set; }
|
|
public string OriginalName { get { return Identifier; } }
|
|
public ContentPackage ContentPackage { get; private set; }
|
|
|
|
public readonly string Name, Description;
|
|
public readonly string TranslationOverride;
|
|
public readonly bool IsBuff;
|
|
|
|
public readonly string CauseOfDeathDescription, SelfCauseOfDeathDescription;
|
|
|
|
//how high the strength has to be for the affliction to take affect
|
|
public readonly float ActivationThreshold = 0.0f;
|
|
//how high the strength has to be for the affliction icon to be shown in the UI
|
|
public readonly float ShowIconThreshold = 0.05f;
|
|
//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
|
|
public readonly float ShowIconToOthersThreshold = 0.05f;
|
|
public readonly float MaxStrength = 100.0f;
|
|
|
|
public readonly float GrainBurst;
|
|
|
|
//how high the strength has to be for the affliction icon to be shown with a health scanner
|
|
public readonly float ShowInHealthScannerThreshold = 0.05f;
|
|
|
|
//how strong the affliction needs to be before bots attempt to treat it
|
|
public readonly float TreatmentThreshold = 5.0f;
|
|
|
|
//how much karma changes when a player applies this affliction to someone (per strength of the affliction)
|
|
public float KarmaChangeOnApplied;
|
|
|
|
public float BurnOverlayAlpha;
|
|
public float DamageOverlayAlpha;
|
|
|
|
//steam achievement given when the affliction is removed from the controlled character
|
|
public readonly string AchievementOnRemoved;
|
|
|
|
public readonly Sprite Icon;
|
|
public readonly Color[] IconColors;
|
|
|
|
public readonly Sprite AfflictionOverlay;
|
|
public readonly bool AfflictionOverlayAlphaIsLinear;
|
|
|
|
private readonly List<Effect> effects = new List<Effect>();
|
|
private readonly List<PeriodicEffect> periodicEffects = new List<PeriodicEffect>();
|
|
|
|
public IEnumerable<Effect> Effects => effects;
|
|
|
|
public IList<PeriodicEffect> PeriodicEffects => periodicEffects;
|
|
|
|
private readonly string typeName;
|
|
|
|
private readonly ConstructorInfo constructor;
|
|
|
|
public IEnumerable<KeyValuePair<string, float>> TreatmentSuitability
|
|
{
|
|
get
|
|
{
|
|
foreach (var itemPrefab in ItemPrefab.Prefabs)
|
|
{
|
|
float suitability = Math.Max(itemPrefab.GetTreatmentSuitability(Identifier), itemPrefab.GetTreatmentSuitability(AfflictionType));
|
|
if (suitability > 0.0f)
|
|
{
|
|
yield return new KeyValuePair<string, float>(itemPrefab.Identifier, suitability);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void LoadAll(IEnumerable<ContentFile> files)
|
|
{
|
|
CPRSettings.Unload();
|
|
InternalDamage = null;
|
|
ImpactDamage = null;
|
|
Bleeding = null;
|
|
Burn = null;
|
|
OxygenLow = null;
|
|
Bloodloss = null;
|
|
Pressure = null;
|
|
Stun = null;
|
|
RadiationSickness = null;
|
|
#if CLIENT
|
|
CharacterHealth.DamageOverlay?.Remove();
|
|
CharacterHealth.DamageOverlay = null;
|
|
CharacterHealth.DamageOverlayFile = string.Empty;
|
|
#endif
|
|
var prevPrefabs = Prefabs.AllPrefabs.SelectMany(kvp => kvp.Value).ToList();
|
|
foreach (var prefab in prevPrefabs)
|
|
{
|
|
prefab?.Dispose();
|
|
}
|
|
System.Diagnostics.Debug.Assert(Prefabs.Count() == 0, "All previous AfflictionPrefabs were not removed in AfflictionPrefab.LoadAll");
|
|
|
|
foreach (ContentFile file in files)
|
|
{
|
|
LoadFromFile(file);
|
|
}
|
|
|
|
if (InternalDamage == null) { DebugConsole.ThrowError("Affliction \"Internal Damage\" not defined in the affliction prefabs."); }
|
|
if (Bleeding == null) { DebugConsole.ThrowError("Affliction \"Bleeding\" not defined in the affliction prefabs."); }
|
|
if (Burn == null) { DebugConsole.ThrowError("Affliction \"Burn\" not defined in the affliction prefabs."); }
|
|
if (OxygenLow == null) { DebugConsole.ThrowError("Affliction \"OxygenLow\" not defined in the affliction prefabs."); }
|
|
if (Bloodloss == null) { DebugConsole.ThrowError("Affliction \"Bloodloss\" not defined in the affliction prefabs."); }
|
|
if (Pressure == null) { DebugConsole.ThrowError("Affliction \"Pressure\" not defined in the affliction prefabs."); }
|
|
if (Stun == null) { DebugConsole.ThrowError("Affliction \"Stun\" not defined in the affliction prefabs."); }
|
|
if (RadiationSickness == null) { DebugConsole.ThrowError("Affliction \"RadiationSickness\" not defined in the affliction prefabs."); }
|
|
}
|
|
|
|
public static void LoadFromFile(ContentFile file)
|
|
{
|
|
XDocument doc = XMLExtensions.TryLoadXml(file.Path);
|
|
if (doc == null) { return; }
|
|
var mainElement = doc.Root.IsOverride() ? doc.Root.FirstElement() : doc.Root;
|
|
if (doc.Root.IsOverride())
|
|
{
|
|
DebugConsole.ThrowError("Cannot override all afflictions, because many of them are required by the main game! Please try overriding them one by one.");
|
|
}
|
|
|
|
List<(AfflictionPrefab prefab, XElement element)> loadedAfflictions = new List<(AfflictionPrefab prefab, XElement element)>();
|
|
|
|
foreach (XElement element in mainElement.Elements())
|
|
{
|
|
bool isOverride = element.IsOverride();
|
|
XElement sourceElement = isOverride ? element.FirstElement() : element;
|
|
string elementName = sourceElement.Name.ToString().ToLowerInvariant();
|
|
string identifier = sourceElement.GetAttributeString("identifier", null);
|
|
if (!elementName.Equals("cprsettings", StringComparison.OrdinalIgnoreCase) &&
|
|
!elementName.Equals("damageoverlay", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (string.IsNullOrWhiteSpace(identifier))
|
|
{
|
|
DebugConsole.ThrowError($"No identifier defined for the affliction '{elementName}' in file '{file.Path}'");
|
|
continue;
|
|
}
|
|
if (Prefabs.ContainsKey(identifier))
|
|
{
|
|
if (isOverride)
|
|
{
|
|
DebugConsole.NewMessage($"Overriding an affliction or a buff with the identifier '{identifier}' using the file '{file.Path}'", Color.Yellow);
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError($"Duplicate affliction: '{identifier}' defined in {elementName} of '{file.Path}'");
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
string type = sourceElement.GetAttributeString("type", "");
|
|
switch (sourceElement.Name.ToString().ToLowerInvariant())
|
|
{
|
|
case "cprsettings":
|
|
type = "cprsettings";
|
|
break;
|
|
case "damageoverlay":
|
|
type = "damageoverlay";
|
|
break;
|
|
}
|
|
|
|
AfflictionPrefab prefab = null;
|
|
switch (type)
|
|
{
|
|
case "damageoverlay":
|
|
#if CLIENT
|
|
if (CharacterHealth.DamageOverlay != null)
|
|
{
|
|
if (isOverride)
|
|
{
|
|
DebugConsole.NewMessage($"Overriding damage overlay with '{file.Path}'", Color.Yellow);
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError($"Error in '{file.Path}': damage overlay already loaded. Add <override></override> tags as the parent of the custom damage overlay sprite to allow overriding the vanilla one.");
|
|
break;
|
|
}
|
|
}
|
|
CharacterHealth.DamageOverlay?.Remove();
|
|
CharacterHealth.DamageOverlay = new Sprite(element);
|
|
CharacterHealth.DamageOverlayFile = file.Path;
|
|
#endif
|
|
break;
|
|
case "bleeding":
|
|
prefab = new AfflictionPrefab(sourceElement, file.Path, typeof(AfflictionBleeding));
|
|
break;
|
|
case "huskinfection":
|
|
case "alieninfection":
|
|
prefab = new AfflictionPrefabHusk(sourceElement, file.Path, typeof(AfflictionHusk));
|
|
break;
|
|
case "cprsettings":
|
|
if (CPRSettings.IsLoaded)
|
|
{
|
|
if (isOverride)
|
|
{
|
|
DebugConsole.NewMessage($"Overriding the CPR settings with '{file.Path}'", Color.Yellow);
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError($"Error in '{file.Path}': CPR settings already loaded. Add <override></override> tags as the parent of the custom CPRSettings to allow overriding the vanilla values.");
|
|
break;
|
|
}
|
|
}
|
|
CPRSettings.Load(sourceElement, file.Path);
|
|
break;
|
|
case "damage":
|
|
case "burn":
|
|
case "oxygenlow":
|
|
case "bloodloss":
|
|
case "stun":
|
|
case "pressure":
|
|
case "internaldamage":
|
|
prefab = new AfflictionPrefab(sourceElement, file.Path, typeof(Affliction))
|
|
{
|
|
ContentPackage = file.ContentPackage
|
|
};
|
|
break;
|
|
default:
|
|
prefab = new AfflictionPrefab(sourceElement, file.Path)
|
|
{
|
|
ContentPackage = file.ContentPackage
|
|
};
|
|
break;
|
|
}
|
|
switch (identifier)
|
|
{
|
|
case "internaldamage":
|
|
InternalDamage = prefab;
|
|
break;
|
|
case "blunttrauma":
|
|
ImpactDamage = prefab;
|
|
break;
|
|
case "bleeding":
|
|
Bleeding = prefab;
|
|
break;
|
|
case "burn":
|
|
Burn = prefab;
|
|
break;
|
|
case "oxygenlow":
|
|
OxygenLow = prefab;
|
|
break;
|
|
case "bloodloss":
|
|
Bloodloss = prefab;
|
|
break;
|
|
case "pressure":
|
|
Pressure = prefab;
|
|
break;
|
|
case "stun":
|
|
Stun = prefab;
|
|
break;
|
|
case "radiationsickness":
|
|
RadiationSickness = prefab;
|
|
break;
|
|
}
|
|
if (ImpactDamage == null) { ImpactDamage = InternalDamage; }
|
|
|
|
if (prefab != null)
|
|
{
|
|
loadedAfflictions.Add((prefab, sourceElement));
|
|
Prefabs.Add(prefab, isOverride);
|
|
prefab.CalculatePrefabUIntIdentifier(Prefabs);
|
|
}
|
|
}
|
|
|
|
//load the effects after all the afflictions in the file have been instantiated
|
|
//otherwise afflictions can't inflict other afflictions that are defined at a later point in the file
|
|
foreach ((AfflictionPrefab prefab, XElement element) in loadedAfflictions)
|
|
{
|
|
prefab.LoadEffects(element);
|
|
}
|
|
}
|
|
|
|
public static void RemoveByFile(string filePath)
|
|
{
|
|
if (CPRSettings.FilePath == filePath) { CPRSettings.Unload(); }
|
|
#if CLIENT
|
|
if (CharacterHealth.DamageOverlayFile == filePath)
|
|
{
|
|
CharacterHealth.DamageOverlay?.Remove();
|
|
CharacterHealth.DamageOverlay = null;
|
|
}
|
|
#endif
|
|
|
|
Prefabs.RemoveByFile(filePath);
|
|
}
|
|
|
|
public AfflictionPrefab(XElement element, string filePath, Type type = null)
|
|
{
|
|
FilePath = filePath;
|
|
|
|
typeName = type == null ? element.Name.ToString() : type.Name;
|
|
if (typeName == "InternalDamage" && type == null)
|
|
{
|
|
type = typeof(Affliction);
|
|
}
|
|
|
|
Identifier = element.GetAttributeString("identifier", "");
|
|
|
|
AfflictionType = element.GetAttributeString("type", "");
|
|
TranslationOverride = element.GetAttributeString("translationoverride", null);
|
|
string translationId = TranslationOverride ?? Identifier;
|
|
Name = TextManager.Get("AfflictionName." + translationId, true) ?? element.GetAttributeString("name", "");
|
|
Description = TextManager.Get("AfflictionDescription." + translationId, true) ?? element.GetAttributeString("description", "");
|
|
IsBuff = element.GetAttributeBool("isbuff", false);
|
|
|
|
if (element.Attribute("nameidentifier") != null)
|
|
{
|
|
Name = TextManager.Get(element.GetAttributeString("nameidentifier", string.Empty), returnNull: true) ?? Name;
|
|
}
|
|
|
|
LimbSpecific = element.GetAttributeBool("limbspecific", false);
|
|
if (!LimbSpecific)
|
|
{
|
|
string indicatorLimbName = element.GetAttributeString("indicatorlimb", "Torso");
|
|
if (!Enum.TryParse(indicatorLimbName, out IndicatorLimb))
|
|
{
|
|
DebugConsole.ThrowError("Error in affliction prefab " + Name + " - limb type \"" + indicatorLimbName + "\" not found.");
|
|
}
|
|
}
|
|
|
|
ActivationThreshold = element.GetAttributeFloat("activationthreshold", 0.0f);
|
|
ShowIconThreshold = element.GetAttributeFloat("showiconthreshold", Math.Max(ActivationThreshold, 0.05f));
|
|
ShowIconToOthersThreshold = element.GetAttributeFloat("showicontoothersthreshold", ShowIconThreshold);
|
|
MaxStrength = element.GetAttributeFloat("maxstrength", 100.0f);
|
|
GrainBurst = element.GetAttributeFloat(nameof(GrainBurst).ToLowerInvariant(), 0.0f);
|
|
|
|
ShowInHealthScannerThreshold = element.GetAttributeFloat("showinhealthscannerthreshold", Math.Max(ActivationThreshold, 0.05f));
|
|
TreatmentThreshold = element.GetAttributeFloat("treatmentthreshold", Math.Max(ActivationThreshold, 5.0f));
|
|
|
|
DamageOverlayAlpha = element.GetAttributeFloat("damageoverlayalpha", 0.0f);
|
|
BurnOverlayAlpha = element.GetAttributeFloat("burnoverlayalpha", 0.0f);
|
|
|
|
KarmaChangeOnApplied = element.GetAttributeFloat("karmachangeonapplied", 0.0f);
|
|
|
|
CauseOfDeathDescription = TextManager.Get("AfflictionCauseOfDeath." + translationId, true) ?? element.GetAttributeString("causeofdeathdescription", "");
|
|
SelfCauseOfDeathDescription = TextManager.Get("AfflictionCauseOfDeathSelf." + translationId, true) ?? element.GetAttributeString("selfcauseofdeathdescription", "");
|
|
|
|
IconColors = element.GetAttributeColorArray("iconcolors", null);
|
|
AfflictionOverlayAlphaIsLinear = element.GetAttributeBool("afflictionoverlayalphaislinear", false);
|
|
AchievementOnRemoved = element.GetAttributeString("achievementonremoved", "");
|
|
|
|
foreach (XElement 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.");
|
|
break;
|
|
case "effect":
|
|
case "periodiceffect":
|
|
break;
|
|
default:
|
|
DebugConsole.AddWarning($"Unrecognized element in affliction \"{Identifier}\" ({subElement.Name})");
|
|
break;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
if (type == null)
|
|
{
|
|
type = Type.GetType("Barotrauma." + typeName, true, true);
|
|
if (type == null)
|
|
{
|
|
DebugConsole.ThrowError("Could not find an affliction class of the type \"" + typeName + "\".");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DebugConsole.ThrowError("Could not find an affliction class of the type \"" + typeName + "\".");
|
|
type = typeof(Affliction);
|
|
}
|
|
|
|
constructor = type.GetConstructor(new[] { typeof(AfflictionPrefab), typeof(float) });
|
|
}
|
|
|
|
private void LoadEffects(XElement element)
|
|
{
|
|
foreach (XElement subElement in element.Elements())
|
|
{
|
|
switch (subElement.Name.ToString().ToLowerInvariant())
|
|
{
|
|
case "effect":
|
|
effects.Add(new Effect(subElement, Name));
|
|
break;
|
|
case "periodiceffect":
|
|
periodicEffects.Add(new PeriodicEffect(subElement, Name));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
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));
|
|
}
|
|
}
|
|
}
|