public override bool IsDuplicate(DependencyAction item)
{
if (item is DependencyTimerAction)
return ((DependencyTimerAction)item).Name == Name;
else
return false;
}
public override bool IsDuplicate(DependencyAction item)
{
if (item is DependencyValueAction)
{
return(((DependencyValueAction)item).Name == Name);
}
else
{
return(false);
}
}
public override bool IsActionStatisfying(DependencyAction action, ref int seconds, ref double probability)
{
seconds = 0;
if (action is DependencyTimerAction)
{
return(((DependencyTimerAction)action).Name == Name && Helper.IntTryParse(((DependencyTimerAction)action).Value, out seconds));
}
else
{
return(false);
}
}
private void Actions_Add(MissionStatement item)
{
DependencyAction da = DependencyAction.NewFromStatement(item);
//Remove duplicate if present
for (int i = Actions.Count - 1; i >= 0; i--)
{
if (Actions[i].IsDuplicate(da))
{
Actions.RemoveAt(i);
}
}
Actions.Add(da);
}
public override bool IsDuplicate(DependencyAction item)
{
return false;
}
/// <summary> If action is a duplicate of existing action </summary> public abstract bool IsDuplicate(DependencyAction item);
/// <summary> If action is a duplicate of existing action </summary> public abstract bool IsDuplicate(DependencyAction item);
public override bool IsDuplicate(DependencyAction item)
{
return(false);
}
public override bool IsActionStatisfying(DependencyAction action, ref int seconds, ref double probability)
{
probability = 1.0;
if (action is DependencyValueAction)
{
DependencyValueAction va = (DependencyValueAction)action;
if (va.Name != Name)
{
return(false);
}
if (!Helper.DoubleTryParse(Value))
{
return(false);
}
if (va.ValueExact == null && va.ValueMinInt != null && va.ValueMaxInt != null) //random int
{
double value = Helper.StringToDouble(Value);
double minInt = Helper.StringToDouble(va.ValueMinInt);
double maxInt = Helper.StringToDouble(va.ValueMaxInt);
//Check if values are integer
if (value != Math.Round(value))
{
if (Comparator == "GREATER")
{
value = Math.Truncate(value);
}
if (Comparator == "GREATER_EQUAL")
{
value = Math.Truncate(value) + 1;
}
if (Comparator == "EQUALS")
{
return(false);
}
if (Comparator == "NOT")
{
return(true);
}
if (Comparator == "LESS_EQUAL")
{
value = Math.Truncate(value);
}
if (Comparator == "LESS")
{
value = Math.Truncate(value) + 1;
}
}
if (minInt != Math.Round(minInt))
{
return(false);
}
if (maxInt != Math.Round(maxInt))
{
return(false);
}
switch (Comparator)
{
case "GREATER":
if (value >= maxInt)
{
return(false);
}
if (value < minInt)
{
return(true);
}
probability = (maxInt - value) / (1 + maxInt - minInt);
return(true);
case "GREATER_EQUAL":
if (value > maxInt)
{
return(false);
}
if (value <= minInt)
{
return(true);
}
probability = (1 + maxInt - value) / (1 + maxInt - minInt);
return(true);
case "EQUALS":
if (value > maxInt)
{
return(false);
}
if (value < minInt)
{
return(false);
}
probability = 1 / (1 + maxInt - minInt);
return(true);
case "NOT":
if (value > maxInt)
{
return(true);
}
if (value < minInt)
{
return(true);
}
probability = (maxInt - minInt) / (1 + maxInt - minInt);
return(true);
case "LESS_EQUAL":
if (value >= maxInt)
{
return(true);
}
if (value < minInt)
{
return(false);
}
probability = (1 + value - minInt) / (1 + maxInt - minInt);
return(true);
case "LESS":
if (value > maxInt)
{
return(true);
}
if (value <= minInt)
{
return(false);
}
probability = (value - minInt) / (1 + maxInt - minInt);
return(true);
default:
return(false);
}
}
else if (va.ValueExact == null && va.ValueMinFloat != null && va.ValueMaxFloat != null) //random float
{
double value = Helper.StringToDouble(Value);
double minFloat = Helper.StringToDouble(va.ValueMinFloat);
double maxFloat = Helper.StringToDouble(va.ValueMaxFloat);
switch (Comparator)
{
case "GREATER":
if (value >= maxFloat)
{
return(false);
}
if (value < minFloat)
{
return(true);
}
probability = (maxFloat - value) / (maxFloat - minFloat);
return(true);
case "GREATER_EQUAL": //Should add minimal possible value
if (value > maxFloat)
{
return(false);
}
if (value <= minFloat)
{
return(true);
}
probability = (maxFloat - value) / (maxFloat - minFloat);
return(true);
case "EQUALS": //Should add minimal possible value
if (value > maxFloat)
{
return(false);
}
if (value < minFloat)
{
return(false);
}
probability = 0 / (1 + maxFloat - minFloat);
return(true);
case "NOT":
if (value > maxFloat)
{
return(true);
}
if (value < minFloat)
{
return(true);
}
probability = (1 + maxFloat - minFloat) / (maxFloat - minFloat);
return(true);
case "LESS_EQUAL": //Should add minimal possible value
if (value > maxFloat)
{
return(true);
}
if (value <= minFloat)
{
return(false);
}
probability = (value - minFloat) / (maxFloat - minFloat);
return(true);
case "LESS":
if (value > maxFloat)
{
return(true);
}
if (value <= minFloat)
{
return(false);
}
probability = (value - minFloat) / (maxFloat - minFloat);
return(true);
default:
return(false);
}
}
else if (va.ValueExact == null || !Helper.DoubleTryParse(va.ValueExact)) //exact value is invalid
{
return(false);
}
else //exact value is valid
{
switch (Comparator)
{
case "GREATER":
return(Helper.StringToDouble(va.ValueExact) > Helper.StringToDouble(Value));
case "GREATER_EQUAL":
return(Helper.StringToDouble(va.ValueExact) >= Helper.StringToDouble(Value));
case "EQUALS":
return(Helper.StringToDouble(va.ValueExact) == Helper.StringToDouble(Value));
case "NOT":
return(Helper.StringToDouble(va.ValueExact) != Helper.StringToDouble(Value));
case "LESS_EQUAL":
return(Helper.StringToDouble(va.ValueExact) <= Helper.StringToDouble(Value));
case "LESS":
return(Helper.StringToDouble(va.ValueExact) < Helper.StringToDouble(Value));
default:
return(false);
}
}
}
else
{
return(false);
}
}
/// <summary> Check if action statisfies a condition </summary> public abstract bool IsActionStatisfying(DependencyAction action, ref int seconds, ref double probability);
public override bool IsActionStatisfying(DependencyAction action, ref int seconds, ref double probability)
{
return(false);
}
