public void TestTrueFalse()
{
var tree = new TriggerTree();
tree.AddTrigger("exists(blah) && true", 1);
tree.AddTrigger("exists(blah) && false", 2);
tree.AddTrigger("exists(blah)", 3);
tree.AddTrigger("true", 4);
tree.AddTrigger("false", 5);
var memory = new Dictionary <string, object>();
var matches = tree.Matches(memory).ToList();
Assert.AreEqual(1, matches.Count);
var triggers = matches[0].Triggers;
Assert.AreEqual(1, triggers.Count);
Assert.AreEqual(4, triggers[0].Action);
memory.Add("blah", 1);
matches = tree.Matches(memory).ToList();
Assert.AreEqual(1, matches.Count());
triggers = matches[0].Triggers;
Assert.AreEqual(2, triggers.Count);
Assert.AreEqual(1, triggers[0].Action);
Assert.AreEqual(3, triggers[1].Action);
}
private Trigger VerifyAddTrigger(TriggerTree tree, Expression expression, object action)
{
var trigger = tree.AddTrigger(expression, action);
VerifyTree(tree);
return(trigger);
}
private void SyncTrees(TriggerTree oldTree, TriggerTree newTree)
{
Dictionary <MonoBehaviour, TriggerEditorNode> currentState = new Dictionary <MonoBehaviour, TriggerEditorNode>();
GetStateByNode(oldTree.EventNode, currentState);
SyncNodeState(newTree.EventNode, currentState);
}
public void SelectTrigger(Trigger trigger)
{
if (_selectedTriggerTree == null && trigger == null)
{
// do nothing
}
else if (_selectedTriggerTree == null && trigger != null)
{
_selectedTriggerTree = BuildTree(trigger);
}
else if (_selectedTriggerTree != null && trigger == null)
{
_selectedTriggerTree.Delete();
_selectedTriggerTree = null;
}
else if (_selectedTriggerTree.Trigger != trigger)
{
_selectedTriggerTree.Delete();
_selectedTriggerTree = BuildTree(trigger);
}
else if (_selectedTriggerTree.Trigger == trigger)
{
TriggerTree newTree = BuildTree(trigger);
TriggerTree oldTree = _selectedTriggerTree;
SyncTrees(oldTree, newTree);
_selectedTriggerTree = newTree;
oldTree.Delete();
}
}
// Use this for initialization
void Start()
{
tree = GetComponent <TriggerTree> ();
audio = GetComponent <AudioSource> ();
audio.clip = sing;
audio.volume = 0.0f;
playing = false;
}
public void TestRoot()
{
var tree = new TriggerTree();
tree.AddTrigger("true", "root");
var matches = tree.Matches(new Dictionary <string, object>());
Assert.AreEqual(1, matches.Count());
Assert.AreEqual("root", matches.First().Action);
}
public void UpdateTree(ref Twinsanity.Triggers TRIGs, int Index)
{
TriggerTree.BeginUpdate();
for (int i = 0; i <= TRIGs._Item.Length - 1; i++)
{
TriggerTree.Nodes.Add("ID: " + TRIGs._Item[i].ID.ToString());
}
TriggerTree.EndUpdate();
IISIndex = Index;
}
/// <summary>
/// Get the expression for this rule by calling GatherConstraints().
/// </summary>
/// <param name="parser">Expression parser.</param>
/// <returns>Expression which will be cached and used to evaluate this rule.</returns>
public virtual Expression GetExpression(IExpressionParser parser)
{
lock (this.extraConstraints)
{
if (this.fullConstraint == null)
{
var allExpressions = new List <Expression>();
if (this.Condition != null)
{
allExpressions.Add(this.Condition.ToExpression());
}
if (this.extraConstraints.Any())
{
allExpressions.AddRange(this.extraConstraints);
}
if (allExpressions.Any())
{
this.fullConstraint = Expression.AndExpression(allExpressions.ToArray());
}
else
{
this.fullConstraint = Expression.ConstantExpression(true);
}
if (RunOnce)
{
this.fullConstraint = Expression.AndExpression(
this.fullConstraint,
new Expression(
TriggerTree.LookupFunction("ignore"),
new Expression(new ExpressionEvaluator(
$"runOnce{Id}",
(expression, os) =>
{
var state = os as DialogStateManager;
var basePath = $"{AdaptiveDialog.ConditionTracker}.{Id}.";
var lastRun = state.GetValue <uint>(basePath + "lastRun");
var paths = state.GetValue <string[]>(basePath + "paths");
var changed = state.AnyPathChanged(lastRun, paths);
return(changed, null);
},
ReturnType.Boolean,
BuiltInFunctions.ValidateUnary))));
}
}
}
return(this.fullConstraint);
}
private TriggerTree BuildTree(Trigger trigger)
{
TriggerTree tree = new TriggerTree();
tree.Trigger = trigger;
tree.EventNode = new EventEditorNode(trigger.gameObject, _context);
List <TriggerEditorNode> children = GetChildrenNodes(trigger.gameObject);
foreach (TriggerEditorNode child in children)
{
tree.EventNode.Add(child);
}
return(tree);
}
public void TestOr()
{
var tree = new TriggerTree();
tree.AddTrigger("exists(woof) || exists(blah)", 1);
tree.AddTrigger("exists(blah)", 2);
tree.AddTrigger("exists(blah) && exists(foo)", 3);
var frame = new Dictionary <string, object> {
{ "blah", 1 }, { "woof", 3 }
};
var matches = tree.Matches(frame).ToList();
Assert.AreEqual(2, matches.Count);
Assert.AreEqual(1, matches[0].Action);
Assert.AreEqual(2, matches[1].Action);
}
public void TestIgnore()
{
var tree = new TriggerTree();
tree.AddTrigger("ignore(!exists(foo)) && exists(blah)", 1);
tree.AddTrigger("exists(blah) && ignore(!exists(foo2)) && woof == 3", 2);
tree.AddTrigger("exists(blah) && woof == 3", 3);
tree.AddTrigger("exists(blah) && woof == 3 && ignore(!exists(foo2))", 2);
var frame = new Dictionary <string, object> {
{ "blah", 1 }, { "woof", 3 }
};
var matches = tree.Matches(frame).ToList();
Assert.Equal(2, matches.Count);
Assert.Equal(2, matches[0].Action);
Assert.Equal(3, matches[1].Action);
}
public List <ExpressionInfo> GenerateOptionals(List <ExpressionInfo> predicates, int numOptionals, int minClause, int maxClause)
{
var optionals = new List <ExpressionInfo>();
for (var i = 0; i < numOptionals; ++i)
{
var clauses = minClause + Rand.Next(maxClause - minClause);
var expressions = new List <ExpressionInfo>();
var used = new List <int>();
for (var j = 0; j < clauses; ++j)
{
int choice;
do
{
choice = Rand.Next(predicates.Count);
}while (used.Contains(choice));
var predicate = predicates[choice];
if (j == 0)
{
var optional = Expression.MakeExpression(TriggerTree.LookupFunction(TriggerTree.Optional), predicate.Expression);
if (Rand.NextDouble() < 0.25)
{
optional = Expression.NotExpression(optional);
}
expressions.Add(new ExpressionInfo(optional, predicate.Bindings));
}
else
{
expressions.Add(predicate);
}
used.Add(choice);
}
var conjunction = Binary(ExpressionType.And, expressions, out var bindings);
optionals.Add(new ExpressionInfo(conjunction, bindings));
}
return(optionals);
}
public void TestTree()
{
var numPredicates = 100;
var numSingletons = 50;
var numConjunctions = 100;
var numDisjunctions = 100;
var numOptionals = 100;
var numQuantifiers = 100;
var numNots = 100;
var minClause = 2;
var maxClause = 4;
var maxExpansion = 3;
var maxQuantifiers = 3;
var singletons = _generator.GeneratePredicates(numPredicates, "mem");
var tree = new TriggerTree();
var predicates = new List <ExpressionInfo>(singletons);
var triggers = new List <Trigger>();
// Add singletons
foreach (var predicate in singletons.Take(numSingletons))
{
triggers.Add(tree.AddTrigger(predicate.Expression, predicate.Bindings));
}
Assert.AreEqual(numSingletons, tree.TotalTriggers);
// Add conjunctions and test matches
var conjunctions = _generator.GenerateConjunctions(predicates, numConjunctions, minClause, maxClause);
foreach (var conjunction in conjunctions)
{
var memory = new Dictionary <string, object>();
foreach (var binding in conjunction.Bindings)
{
memory.Add(binding.Key, binding.Value.Value);
}
var trigger = tree.AddTrigger(conjunction.Expression, conjunction.Bindings);
var matches = tree.Matches(memory);
triggers.Add(trigger);
Assert.IsTrue(matches.Count() >= 1);
var first = matches.First().Clauses.First();
foreach (var match in matches)
{
Assert.AreEqual(RelationshipType.Equal, first.Relationship(match.Clauses.First(), tree.Comparers));
}
}
Assert.AreEqual(numSingletons + numConjunctions, tree.TotalTriggers);
// Add disjunctions
predicates.AddRange(conjunctions);
var disjunctions = _generator.GenerateDisjunctions(predicates, numDisjunctions, minClause, maxClause);
foreach (var disjunction in disjunctions)
{
triggers.Add(tree.AddTrigger(disjunction.Expression, disjunction.Bindings));
}
Assert.AreEqual(numSingletons + numConjunctions + numDisjunctions, tree.TotalTriggers);
var all = new List <ExpressionInfo>(predicates);
all.AddRange(disjunctions);
// Add optionals
var optionals = _generator.GenerateOptionals(all, numOptionals, minClause, maxClause);
foreach (var optional in optionals)
{
triggers.Add(tree.AddTrigger(optional.Expression, optional.Bindings));
}
Assert.AreEqual(numSingletons + numConjunctions + numDisjunctions + numOptionals, tree.TotalTriggers);
all.AddRange(optionals);
// Add quantifiers
var quantified = _generator.GenerateQuantfiers(all, numQuantifiers, maxClause, maxExpansion, maxQuantifiers);
foreach (var expr in quantified)
{
triggers.Add(tree.AddTrigger(expr.Expression, expr.Bindings, expr.Quantifiers.ToArray()));
}
Assert.AreEqual(numSingletons + numConjunctions + numDisjunctions + numOptionals + numQuantifiers, tree.TotalTriggers);
all.AddRange(quantified);
var nots = _generator.GenerateNots(all, numNots);
foreach (var expr in nots)
{
triggers.Add(tree.AddTrigger(expr.Expression, expr.Bindings, expr.Quantifiers.ToArray()));
}
Assert.AreEqual(numSingletons + numConjunctions + numDisjunctions + numOptionals + numQuantifiers + numNots, tree.TotalTriggers);
all.AddRange(nots);
VerifyTree(tree);
// Test matches
foreach (var predicate in predicates)
{
var memory = new Dictionary <string, object>();
foreach (var binding in predicate.Bindings)
{
memory.Add(binding.Key, binding.Value.Value);
}
var matches = tree.Matches(memory).ToList();
// Clauses in every match must not generalize or specialize other matches
for (var i = 0; i < matches.Count; ++i)
{
var first = matches[i];
for (var j = i + 1; j < matches.Count; ++j)
{
var second = matches[j];
var found = false;
foreach (var firstClause in first.Clauses)
{
var(match, error) = firstClause.TryEvaluate <bool>(memory);
if (error == null && match)
{
foreach (var secondClause in second.Clauses)
{
bool match2;
(match2, error) = firstClause.TryEvaluate <bool>(memory);
if (error == null && match2)
{
var reln = firstClause.Relationship(secondClause, tree.Comparers);
if (reln == RelationshipType.Equal || reln == RelationshipType.Incomparable)
{
found = true;
break;
}
}
}
if (found)
{
break;
}
}
}
Assert.IsTrue(found);
}
}
}
// NOTE: This is useful to test tree visualization, but not really a test.
// tree.GenerateGraph("tree.dot");
// Delete triggers
Assert.AreEqual(triggers.Count, tree.TotalTriggers);
foreach (var trigger in triggers)
{
tree.RemoveTrigger(trigger);
}
Assert.AreEqual(0, tree.TotalTriggers);
VerifyTree(tree);
}
private void VerifyTree(TriggerTree tree)
{
var badNode = tree.VerifyTree();
Assert.AreEqual(null, badNode);
}
private void VerifyTree(TriggerTree tree)
{
var badNode = tree.VerifyTree();
Assert.Null(badNode);
}
void Start()
{
basicFreq = 0.0f;
tree = GetComponent <TriggerTree> ();
}
