353 lines
15 KiB
C#
353 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Xml.Linq;
|
|
using System.Linq;
|
|
|
|
namespace Barotrauma
|
|
{
|
|
// TODO: This class should be refactored:
|
|
// - Use XElement instead of XAttribute in the constructor
|
|
// - Simplify, remove unnecessary conversions
|
|
// - Improve the flow so that the logic is undestandable.
|
|
// - Maybe ass some test cases for the operators?
|
|
class PropertyConditional
|
|
{
|
|
public enum ConditionType
|
|
{
|
|
PropertyValue,
|
|
Name,
|
|
SpeciesName,
|
|
HasTag,
|
|
HasStatusTag,
|
|
Affliction
|
|
}
|
|
|
|
public enum Comparison
|
|
{
|
|
And,
|
|
Or
|
|
}
|
|
|
|
public enum OperatorType
|
|
{
|
|
Equals,
|
|
NotEquals,
|
|
LessThan,
|
|
LessThanEquals,
|
|
GreaterThan,
|
|
GreaterThanEquals
|
|
}
|
|
|
|
public readonly ConditionType Type;
|
|
public readonly OperatorType Operator;
|
|
public readonly string AttributeName;
|
|
public readonly string AttributeValue;
|
|
public readonly float? FloatValue;
|
|
|
|
public readonly string TargetItemComponentName;
|
|
|
|
private readonly string[] afflictionNames = new string[] { "internaldamage", "bleeding", "burn", "oxygenlow", "bloodloss", "pressure", "stun", "husk", "afflictionhusk", "huskinfection" };
|
|
|
|
private readonly int cancelStatusEffect;
|
|
|
|
// TODO: use XElement instead of XAttribute
|
|
public PropertyConditional(XAttribute attribute)
|
|
{
|
|
AttributeName = attribute.Name.ToString().ToLowerInvariant();
|
|
string attributeValueString = attribute.Value.ToString();
|
|
if (string.IsNullOrWhiteSpace(attributeValueString))
|
|
{
|
|
DebugConsole.ThrowError($"Conditional attribute value is empty: {attribute.Parent.ToString()}");
|
|
return;
|
|
}
|
|
string valueString = attributeValueString;
|
|
string[] splitString = valueString.Split(' ');
|
|
if (splitString.Length > 0)
|
|
{
|
|
for (int i = 1; i < splitString.Length; i++)
|
|
{
|
|
valueString = splitString[i] + (i > 1 && i < splitString.Length ? " " : "");
|
|
}
|
|
}
|
|
//thanks xml for not letting me use < or > in attributes :(
|
|
string op = splitString[0];
|
|
switch (op)
|
|
{
|
|
case "e":
|
|
case "eq":
|
|
case "equals":
|
|
Operator = OperatorType.Equals;
|
|
break;
|
|
case "ne":
|
|
case "neq":
|
|
case "notequals":
|
|
case "!":
|
|
case "!e":
|
|
case "!eq":
|
|
case "!equals":
|
|
Operator = OperatorType.NotEquals;
|
|
break;
|
|
case "gt":
|
|
case "greaterthan":
|
|
Operator = OperatorType.GreaterThan;
|
|
break;
|
|
case "lt":
|
|
case "lessthan":
|
|
Operator = OperatorType.LessThan;
|
|
break;
|
|
case "gte":
|
|
case "gteq":
|
|
case "greaterthanequals":
|
|
Operator = OperatorType.GreaterThanEquals;
|
|
break;
|
|
case "lte":
|
|
case "lteq":
|
|
case "lessthanequals":
|
|
Operator = OperatorType.LessThanEquals;
|
|
break;
|
|
default:
|
|
if (op != "==" && op != "!=" && op != ">" && op != "<" && op != ">=" && op != "<=") //Didn't use escape strings or anything
|
|
{
|
|
valueString = attributeValueString; //We probably don't even have an operator
|
|
}
|
|
break;
|
|
}
|
|
|
|
TargetItemComponentName = attribute.Parent.GetAttributeString("targetitemcomponent", "");
|
|
|
|
foreach (XElement subElement in attribute.Parent.Elements())
|
|
{
|
|
switch (subElement.Name.ToString().ToLowerInvariant())
|
|
{
|
|
case "cancel":
|
|
case "canceleffect":
|
|
case "cancelstatuseffect":
|
|
//This only works if there's a conditional checking for status effect tags. There is no way to cancel *all* status effects atm.
|
|
cancelStatusEffect = 1;
|
|
if (subElement.GetAttributeBool("all", false)) cancelStatusEffect = 2;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!Enum.TryParse(AttributeName, true, out Type))
|
|
{
|
|
if (afflictionNames.Any(n => n == AttributeName))
|
|
{
|
|
Type = ConditionType.Affliction;
|
|
if (AttributeName == "husk" || AttributeName == "huskaffliction")
|
|
{
|
|
AttributeName = "huskinfection";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Type = ConditionType.PropertyValue;
|
|
}
|
|
}
|
|
|
|
AttributeValue = valueString;
|
|
if (float.TryParse(AttributeValue, NumberStyles.Float, CultureInfo.InvariantCulture, out float value))
|
|
{
|
|
FloatValue = value;
|
|
}
|
|
}
|
|
|
|
public bool Matches(ISerializableEntity target)
|
|
{
|
|
string valStr = AttributeValue.ToString();
|
|
|
|
switch (Type)
|
|
{
|
|
case ConditionType.PropertyValue:
|
|
SerializableProperty property;
|
|
if (target.SerializableProperties.TryGetValue(AttributeName, out property))
|
|
{
|
|
return Matches(target, property);
|
|
}
|
|
return false;
|
|
case ConditionType.Name:
|
|
return (Operator == OperatorType.Equals) == (target.Name == valStr);
|
|
case ConditionType.HasTag:
|
|
{
|
|
string[] readTags = valStr.Split(',');
|
|
int matches = 0;
|
|
foreach (string tag in readTags)
|
|
if (((Item)target).HasTag(tag)) matches++;
|
|
|
|
//If operator is == then it needs to match everything, otherwise if its != there must be zero matches.
|
|
return Operator == OperatorType.Equals ? matches >= readTags.Length : matches <= 0;
|
|
}
|
|
case ConditionType.HasStatusTag:
|
|
List<DurationListElement> durations = StatusEffect.DurationList.FindAll(d => d.Targets.Contains(target));
|
|
List<DelayedListElement> delays = DelayedEffect.DelayList.FindAll(d => d.Targets.Contains(target));
|
|
|
|
bool success = false;
|
|
if (durations.Count > 0 || delays.Count > 0)
|
|
{
|
|
string[] readTags = valStr.Split(',');
|
|
foreach (DurationListElement duration in durations)
|
|
{
|
|
int matches = 0;
|
|
foreach (string tag in readTags)
|
|
if (duration.Parent.HasTag(tag)) matches++;
|
|
|
|
success = Operator == OperatorType.Equals ? matches >= readTags.Length : matches <= 0;
|
|
if (cancelStatusEffect > 0 && success)
|
|
StatusEffect.DurationList.Remove(duration);
|
|
if (cancelStatusEffect != 2) //cancelStatusEffect 1 = only cancel once, cancelStatusEffect 2 = cancel all of matching tags
|
|
return success;
|
|
}
|
|
foreach (DelayedListElement delay in delays)
|
|
{
|
|
int matches = 0;
|
|
foreach (string tag in readTags)
|
|
if (delay.Parent.HasTag(tag)) matches++;
|
|
|
|
success = Operator == OperatorType.Equals ? matches >= readTags.Length : matches <= 0;
|
|
if (cancelStatusEffect > 0 && success)
|
|
DelayedEffect.DelayList.Remove(delay);
|
|
if (cancelStatusEffect != 2) //ditto
|
|
return success;
|
|
}
|
|
}
|
|
else if (Operator == OperatorType.NotEquals)
|
|
{
|
|
//no status effects, so the tags cannot be equal -> condition met
|
|
return true;
|
|
}
|
|
return success;
|
|
case ConditionType.SpeciesName:
|
|
Character targetCharacter = target as Character;
|
|
if (targetCharacter == null) return false;
|
|
return (Operator == OperatorType.Equals) == (targetCharacter.SpeciesName == valStr);
|
|
case ConditionType.Affliction:
|
|
if (target is Character targetChar)
|
|
{
|
|
var health = targetChar.CharacterHealth;
|
|
if (health == null) { return false; }
|
|
var affliction = health.GetAffliction(AttributeName);
|
|
if (affliction == null) { return false; }
|
|
if (FloatValue.HasValue)
|
|
{
|
|
float value = FloatValue.Value;
|
|
switch (Operator)
|
|
{
|
|
case OperatorType.Equals:
|
|
return affliction.Strength == value;
|
|
case OperatorType.GreaterThan:
|
|
return affliction.Strength > value;
|
|
case OperatorType.GreaterThanEquals:
|
|
return affliction.Strength >= value;
|
|
case OperatorType.LessThan:
|
|
return affliction.Strength < value;
|
|
case OperatorType.LessThanEquals:
|
|
return affliction.Strength <= value;
|
|
case OperatorType.NotEquals:
|
|
return affliction.Strength != value;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// TODO: refactor and add tests
|
|
private bool Matches(ISerializableEntity target, SerializableProperty property)
|
|
{
|
|
object propertyValue = property.GetValue(target);
|
|
|
|
if (propertyValue == null)
|
|
{
|
|
DebugConsole.ThrowError("Couldn't compare " + AttributeValue.ToString() + " (" + AttributeValue.GetType() + ") to property \"" + property.Name + "\" - property.GetValue() returns null!");
|
|
return false;
|
|
}
|
|
|
|
Type type = propertyValue.GetType();
|
|
float? floatProperty = null;
|
|
if (type == typeof(float) || type == typeof(int))
|
|
{
|
|
floatProperty = (float)propertyValue;
|
|
}
|
|
|
|
switch (Operator)
|
|
{
|
|
case OperatorType.Equals:
|
|
if (type == typeof(bool))
|
|
{
|
|
return ((bool)propertyValue) == (AttributeValue == "true");
|
|
}
|
|
else if (FloatValue == null)
|
|
{
|
|
return propertyValue.ToString().Equals(AttributeValue);
|
|
}
|
|
else
|
|
{
|
|
return propertyValue.Equals(FloatValue);
|
|
}
|
|
case OperatorType.NotEquals:
|
|
if (type == typeof(bool))
|
|
{
|
|
return ((bool)propertyValue) != (AttributeValue == "true");
|
|
}
|
|
else if (FloatValue == null)
|
|
{
|
|
return !propertyValue.ToString().Equals(AttributeValue);
|
|
}
|
|
else
|
|
{
|
|
return !propertyValue.Equals(FloatValue);
|
|
}
|
|
case OperatorType.GreaterThan:
|
|
if (FloatValue == null)
|
|
{
|
|
DebugConsole.ThrowError("Couldn't compare " + AttributeValue.ToString() + " (" + AttributeValue.GetType() + ") to property \"" + property.Name + "\" (" + type + ")! "
|
|
+ "Make sure the type of the value set in the config files matches the type of the property.");
|
|
}
|
|
else if (floatProperty > FloatValue)
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
case OperatorType.LessThan:
|
|
if (FloatValue == null)
|
|
{
|
|
DebugConsole.ThrowError("Couldn't compare " + AttributeValue.ToString() + " (" + AttributeValue.GetType() + ") to property \"" + property.Name + "\" (" + type + ")! "
|
|
+ "Make sure the type of the value set in the config files matches the type of the property.");
|
|
}
|
|
else if (floatProperty < FloatValue)
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
case OperatorType.GreaterThanEquals:
|
|
if (FloatValue == null)
|
|
{
|
|
DebugConsole.ThrowError("Couldn't compare " + AttributeValue.ToString() + " (" + AttributeValue.GetType() + ") to property \"" + property.Name + "\" (" + type + ")! "
|
|
+ "Make sure the type of the value set in the config files matches the type of the property.");
|
|
}
|
|
else if (floatProperty >= FloatValue)
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
case OperatorType.LessThanEquals:
|
|
if (FloatValue == null)
|
|
{
|
|
DebugConsole.ThrowError("Couldn't compare " + AttributeValue.ToString() + " (" + AttributeValue.GetType() + ") to property \"" + property.Name + "\" (" + type + ")! "
|
|
+ "Make sure the type of the value set in the config files matches the type of the property.");
|
|
}
|
|
else if (floatProperty <= FloatValue)
|
|
{
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|