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> (); }