public void GetDepth()
{
// Get a valid tree.
var tree = TestTreeFactory.GetSimpleTree();
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
// For each node in the tree assert that 'GetDepth' returns the correct elements.
Assert.Equal(
0,
walker.GetDepth(tree));
Assert.Equal(
1,
walker.GetDepth(tree[0]));
Assert.Equal(
2,
walker.GetDepth(tree[0][0]));
Assert.Equal(
2,
walker.GetDepth(tree[0][1]));
Assert.Equal(
1,
walker.GetDepth(tree[1]));
Assert.Equal(
2,
walker.GetDepth(tree[1][0]));
Assert.Equal(
3,
walker.GetDepth(tree[1][0][0]));
}
/// <summary>
/// Finds the parameter that either contains this node or _is_ this node.
/// </summary>
/// <param name="callExpression">The containing call expression for this node</param>
/// <param name="nodeAtPosition">The current node in the editor</param>
/// <returns>The index of the argument (or 0 if this didn't correspond to any argument)</returns>
public static int GetActiveParameterIndex(ICallExpression callExpression, INode nodeAtPosition)
{
var arguments = callExpression?.Arguments?.Elements.ToArray();
if (arguments == null)
{
return(DefaultArgIndex);
}
// first check the top level arguments (much cheaper and also very likely)
for (int i = 0; i < arguments.Length; ++i)
{
if (ReferenceEquals(arguments[i], nodeAtPosition))
{
return(i);
}
}
// let's try the slightly more expensive check within subfields
for (int i = 0; i < arguments.Length; ++i)
{
var result = NodeWalker.ForEachChildRecursively(arguments[i], node => ReferenceEquals(node, nodeAtPosition) ? node : null);
if (result != null)
{
return(i);
}
}
return(DefaultArgIndex);
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
Array.Walk(walker, depth + 1, Priority < Array.Priority);
walker("[", Value, depth);
Index.Walk(walker, depth + 1, false);
walker("]");
}
/// <summary>
/// Finds all the nodes at a given <paramref name="positions"/>.
/// </summary>
public static INode[] TryGetNodesAtPositions(ISourceFile sourceFile, IReadOnlyList <int> positions, Func <INode, bool> isNodeAcceptable, System.Threading.CancellationToken token)
{
Contract.Requires(sourceFile != null);
INode[] nodeByPosition = new INode[positions.Count];
foreach (var node in NodeWalker.TraverseBreadthFirstAndSelf(sourceFile))
{
if (token.IsCancellationRequested)
{
break;
}
int startPosition = node.GetNodeStartPositionWithoutTrivia(sourceFile);
int endPosition = node.End;
for (int i = 0; i < positions.Count; i++)
{
int position = positions[i];
if (startPosition <= position && position <= endPosition)
{
if (nodeByPosition[i] == null || node.GetNodeWidth(sourceFile) <= nodeByPosition[i].GetNodeWidth(sourceFile))
{
if (isNodeAcceptable(node))
{
nodeByPosition[i] = node;
}
}
}
}
}
return(nodeByPosition);
}
internal override void Walk(NodeWalker walker, int depth)
{
bool isCompiledExpression = base.MemberName.Equals("compile", System.StringComparison.InvariantCultureIgnoreCase);
if (isCompiledExpression)
{
base.Container.Walk(walker, depth);
walker("."+base.MemberName);
}
else
{
base.Walk(walker, depth);
}
walker("(");
foreach (var parameter in Parameters.Take(1))
{
parameter.Walk(walker, depth);
}
foreach (var parameter in Parameters.Skip(1))
{
walker(", ");
parameter.Walk(walker, depth);
}
walker(")");
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
Array.Walk(walker, depth + 1, Priority < Array.Priority);
walker("[", Value, depth);
Index.Walk(walker, depth + 1, false);
walker("]");
}
public void GetParentOrDefault_NullNode_ThrowsArgumentNullException()
{
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
Assert.Throws <ArgumentNullException>("node", () => walker.GetParentOrDefault(null));
}
private void VisitFile(ISourceFile node, DiagnosticContext context)
{
// Parallel node visitation may only make sense when specs are huge. The only case we know is Office, where
// some specs have >600K statements. For specs of regular size parallel node visitation adds a significant sync overhead
// (e.g. for analog it adds ~20% overhead to ast conversion)
// Since UseLegacyOfficeLogic is an Office-specific flag, we are using that to special-case Office specs until they
// are onboarded to DScript V2.
// TODO: This needs to go!!!!!
if (m_useLegacyOfficeLogic)
{
// Parallel visitation can only work if the handlers registered during the creation of rules
// in <see cref="InitializeDiagnosticRules"/> are thread-safe. They are currently thread-safe.
ParallelVisitNode(node, context);
}
else
{
// Synchronous node visitation
foreach (var nestedNode in NodeWalker.TraverseBreadthFirstAndSelf(node))
{
// Only non-injected nodes are checked by the linter.
if (nestedNode.IsInjectedForDScript())
{
continue;
}
Handle(nestedNode, context);
}
}
}
/// <summary>
/// Performs the analysis.
/// </summary>
public virtual bool AnalyzeSourceFile(Workspace workspace, AbsolutePath path, ISourceFile sourceFile)
{
if (m_specHandlers != null)
{
var context = new DiagnosticsContext(sourceFile, Logger, LoggingContext, PathTable, workspace);
bool success = true;
foreach (var node in NodeWalker.TraverseBreadthFirstAndSelf(sourceFile))
{
// Only non-injected nodes are checked by the linter.
if (node.IsInjectedForDScript())
{
continue;
}
var handlers = m_specHandlers[(int)node.Kind];
if (handlers != null)
{
foreach (var handler in handlers)
{
success &= handler(node, context);
}
}
}
return(success);
}
return(true);
}
internal override void Walk(NodeWalker walker, int depth)
{
Array.Walk(walker, depth + 1);
walker("[", Value, depth);
Index.Walk(walker, depth + 1);
walker("]");
}
internal override void Walk(NodeWalker walker, int depth)
{
Array.Walk(walker, depth + 1);
walker("[", Value, depth);
Index.Walk(walker, depth + 1);
walker("]");
}
private TestFunction TestHelper(string code, string expectedShortName, string expectedFullIdentifier, int expectedErrorCount, Dictionary <string, string> lkgFiles, params string[] expectedMessages)
{
TestFunction testFunction = null;
var parser = new Parser();
ISourceFile sourceFile = parser.ParseSourceFileContent("testFile.dsc", code, ParsingOptions.DefaultParsingOptions);
Assert.Equal(0, sourceFile.ParseDiagnostics.Count);
var binder = new Binder();
binder.BindSourceFile(sourceFile, CompilerOptions.Empty);
Assert.Equal(0, sourceFile.BindDiagnostics.Count);
foreach (var node in NodeWalker.TraverseBreadthFirstAndSelf(sourceFile))
{
if (node.Kind == SyntaxKind.FunctionDeclaration)
{
var functionDecl = (IFunctionDeclaration)node;
var success = TestFunction.TryExtractFunction(Logger, sourceFile, functionDecl, lkgFiles, out testFunction);
Assert.Equal(expectedErrorCount == 0, success);
if (success)
{
Assert.NotNull(testFunction);
Assert.Equal(expectedShortName, testFunction.ShortName);
Assert.Equal(expectedFullIdentifier, testFunction.FullIdentifier);
}
}
}
Logger.ValidateErrors(expectedErrorCount, expectedMessages);
return(testFunction);
}
public void GetChildAt_NullNode_ThrowsArgumentNullException()
{
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
Assert.Throws <ArgumentNullException>("node", () => walker.GetChildAt((Node <int>)null, 0));
Assert.Throws <ArgumentNullException>("nodes", () => walker.GetChildAt((Node <int>[])null, 0).ToArray());
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
if (!string.IsNullOrEmpty(Prefix))
{
walker(Prefix, PrefixValue, depth + 1);
}
Operand.Walk(walker, depth, Priority < Operand.Priority);
}
public void GetPrecedingSiblingsAndSelf_NullNode_ArgumentNullExceptionThrown()
{
// Create a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
// Assert that 'GetPrecedingSiblingsAndSelf' throws an 'ArgumentNullException' when the node is null.
Assert.Throws <ArgumentNullException>("node", () => walker.GetPrecedingSiblingsAndSelf(null).ToArray());
}
public void HasChildren_NullNode_ArgumentNullExceptionThrown()
{
// Create a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
// Assert that 'HasChildren' throws an 'ArgumentNullException' when the node is null.
Assert.Throws <ArgumentNullException>("node", () => walker.HasChildren(null));
}
public void GetDepth_NullNode_ArgumentNullExceptionThrown()
{
// Create a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
// Assert that 'GetDepth' throws an 'ArgumentNullException' when the node is null.
Assert.Throws <ArgumentNullException>("node", () => walker.GetDepth(null));
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
if (!string.IsNullOrEmpty(Prefix))
{
walker(Prefix, PrefixValue, depth + 1);
}
Operand.Walk(walker, depth, Priority < Operand.Priority);
}
internal override void Walk(NodeWalker walker, int depth)
{
Left.Walk(walker, depth+1);
walker(" ");
walker(Operator, Value, depth);
walker(" ");
Right.Walk(walker, depth + 1);
}
internal override void Walk(NodeWalker walker, int depth)
{
Left.Walk(walker, depth + 1);
walker(" ");
walker(Operator, Value, depth);
walker(" ");
Right.Walk(walker, depth + 1);
}
public void TryGetParent_NullNode_ThrowsArgumentNullException()
{
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
Node <int> parent = null;
Assert.Throws <ArgumentNullException>("node", () => walker.TryGetParent(null, out parent));
}
public void GetBranches_NullNode_ThrowsArgumentNullException()
{
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
Assert.Throws <ArgumentNullException>(
"node",
() => walker.GetBranches(null).ToArray());
}
public static void Main(string[] args)
{
System.Console.WriteLine("Hello World!");
var characterInfo = new CharacterInfo();
characterInfo.Input = new Brawler.Input.Packets.ControllerState();
characterInfo.Input.AttackStick = new Brawler.Input.Packets.AnalogStick();
characterInfo.Input.MoveStick = new Brawler.Input.Packets.AnalogStick();
characterInfo.Current = new Brawler.Simulation.PlayerInfo();
characterInfo.Previous = new Brawler.Simulation.PlayerInfo();
var dictionary = new TreeDictionary();
var builder = new BlackboardTreeBuilder <CharacterInfo>(
new TreeBuilder(),
dictionary);
var plan = builder
.Selector()
.Begin()
//.Success()
.Failed()
.Success()
.Success()
.End();
var compiled = builder.Build();
//var compiled = BuildSM (builder);
var walker = new NodeWalker(compiled);
walker.Restart();
walker.ComputeStep();
System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine("walker.Outcome : " + walker.Outcome);
//Test1 (characterInfo, walker);
//Test2 (characterInfo, walker, timer, MAX_TIMES);
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
walker("(", TestValue ? TrueValue : FalseValue, depth);
Condition.Walk(walker, depth + 1, false);
walker(" ? ");
TrueNode.Walk(walker, depth + 1, false);
walker(" : ");
FalseNode.Walk(walker, depth + 1, false);
walker(")");
}
internal override void Walk(NodeWalker walker, int depth)
{
walker("(");
Condition.Walk(walker, depth + 1);
walker(" ? ");
TrueValue.Walk(walker, depth + 1);
walker(" : ");
FalseValue.Walk(walker, depth + 1);
walker(")");
}
public void LevelOrderTraversal_NullNode_ArgumentNullExceptionThrown()
{
// Create a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
// Assert that 'LevelOrderTraversal' throws an 'ArgumentNullException' when the node is null.
Assert.Throws <ArgumentNullException>(
"node",
() => walker.LevelOrderTraversal(null).ToArray());
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
walker("(", TestValue ? TrueValue : FalseValue, depth);
Condition.Walk(walker, depth + 1, false);
walker(" ? ");
TrueNode.Walk(walker, depth + 1, false);
walker(" : ");
FalseNode.Walk(walker, depth + 1, false);
walker(")");
}
internal override void Walk(NodeWalker walker, int depth)
{
walker("(");
Condition.Walk(walker, depth + 1);
walker(" ? ");
TrueValue.Walk(walker, depth + 1);
walker(" : ");
FalseValue.Walk(walker, depth + 1);
walker(")");
}
public void LevelOrderTraversal()
{
// Get a valid tree.
var tree = TestTreeFactory.GetSimpleTree();
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
// Create arrays of the results expected from each node.
int[] node0ExpectedResult = new int[] { 0, 1, 4, 2, 3, 5, 6 };
int[] node1ExpectedResult = new int[] { 1, 2, 3 };
int[] node2ExpectedResult = new int[] { 2 };
int[] node3ExpectedResult = new int[] { 3 };
int[] node4ExpectedResult = new int[] { 4, 5, 6 };
int[] node5ExpectedResult = new int[] { 5, 6 };
int[] node6ExpectedResult = new int[] { 6 };
// For each node in the tree assert that 'LevelOrderTraversal' returns the correct
// elements.
// Node 0:
Assert.Equal(
node0ExpectedResult,
walker.LevelOrderTraversal(tree).Select(x => x.Value));
// Node 1:
Assert.Equal(
node1ExpectedResult,
walker.LevelOrderTraversal(tree[0]).Select(x => x.Value));
// Node 2:
Assert.Equal(
node2ExpectedResult,
walker.LevelOrderTraversal(tree[0][0]).Select(x => x.Value));
// Node 3:
Assert.Equal(
node3ExpectedResult,
walker.LevelOrderTraversal(tree[0][1]).Select(x => x.Value));
// Node 4:
Assert.Equal(
node4ExpectedResult,
walker.LevelOrderTraversal(tree[1]).Select(x => x.Value));
// Node 5:
Assert.Equal(
node5ExpectedResult,
walker.LevelOrderTraversal(tree[1][0]).Select(x => x.Value));
// Node 6:
Assert.Equal(
node6ExpectedResult,
walker.LevelOrderTraversal(tree[1][0][0]).Select(x => x.Value));
}
private static void CheckFullyQualifiedName(string code, string expectedQualifiedName, bool preserveTrivia)
{
var sourceFile = ParseAndBind(code, preserveTrivia);
var checker = CreateTypeChecker(sourceFile);
checker.GetDiagnostics();
var node = NodeWalker.TraverseBreadthFirstAndSelf(sourceFile).First(n => n is VariableDeclaration || n is FunctionDeclaration || n is InterfaceDeclaration || n is TypeAliasDeclaration) as Node;
Assert.Equal(expectedQualifiedName, checker.GetFullyQualifiedName(node.Symbol));
}
public void GetLevel_NegativeDepth_ArgumentExceptionThrown()
{
// Get a valid tree.
var tree = TestTreeFactory.GetSimpleTree();
// Create a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
// Assert that 'GetLevel' throws an 'ArgumentNullException' when the node is null.
Assert.Throws <ArgumentException>("depth", () => walker.GetLevel(tree, -1).ToArray());
}
public void GetPrecedingSiblingsAndSelf_NullWalker_ArgumentNullExceptionThrown()
{
// Get a valid tree.
var tree = TestTreeFactory.GetSimpleTree();
// Create a null ITreeWalker.
NodeWalker <int> walker = null;
// Assert that 'GetPrecedingSiblingsAndSelf' throws an 'ArgumentNullException' when the tree walker
// is null.
Assert.Throws <ArgumentNullException>("walker", () => walker.GetPrecedingSiblingsAndSelf(tree).ToArray());
}
internal override void Walk(NodeWalker walker, int depth)
{
if (!string.IsNullOrEmpty(Prefix))
{
walker(Prefix, PrefixValue, depth + 1);
}
Operand.Walk(walker, depth);
if (!string.IsNullOrEmpty(Suffix))
{
walker(Suffix, SuffixValue, depth + 1);
}
}
/// <summary>
/// Gets all child nodes of <paramref name="node"/>.
/// </summary>
/// <param name="node">The node.</param>
/// <returns>All child nodes.</returns>
public static IEnumerable <INode> GetChildNodes(this INode node)
{
var l = new List <INode>();
NodeWalker.ForEachChild <object>(node, child =>
{
l.Add(child.ResolveUnionType());
return(null);
});
return(l);
}
internal override void Walk(NodeWalker walker, int depth)
{
if (!string.IsNullOrEmpty(Prefix))
{
walker(Prefix, PrefixValue, depth + 1);
}
Operand.Walk(walker, depth);
if (!string.IsNullOrEmpty(Suffix))
{
walker(Suffix, SuffixValue, depth + 1);
}
}
private void WalkParameter(NodeWalker walker, int depth, MemberAssignmentNode node)
{
var constant = node.Value as ConstantNode;
if (constant != null && constant.Text == node.MemberName)
{
constant.Walk(walker, depth, false);
}
else
{
node.Walk(walker, depth, false);
}
}
public void GetParentOrDefault_NodeDoesNotHaveParent_ReturnsNull()
{
// Get a valid tree.
var tree =
Node.Create(0).AddChildren(
Node.Create(1));
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
Assert.Null(walker.GetParentOrDefault(tree));
}
public void GetParentOrDefault_NullTreeWalker_ThrowsArgumentNullException()
{
// Get a valid tree.
var tree =
Node.Create(0).AddChildren(
Node.Create(1));
// Get a null ITreeWalker.
NodeWalker <int> walker = null;
Assert.Throws <ArgumentNullException>("walker", () => walker.GetParentOrDefault(tree));
}
public void GetParent_NodeDoesNotHaveParent_ReturnsNull()
{
// Get a valid tree.
var tree =
Node.Create(0).AddChildren(
Node.Create(1));
// Get a valid ITreeWalker.
NodeWalker <int> walker = new NodeWalker <int>();
Assert.Throws <InvalidOperationException>(() => walker.GetParent(tree));
}
internal override void Walk(NodeWalker walker, int depth)
{
foreach (var node in Items.Take(1))
{
node.Walk(walker, depth);
}
foreach (var node in Items.Skip(1))
{
walker(", ");
node.Walk(walker, depth);
}
}
internal override void Walk(NodeWalker walker, int depth)
{
Container.Walk(walker, depth + 1);
if (MemberName == "get_Item")
{
walker("[", MemberValue, depth);
}
else
{
walker(".");
walker(MemberName, MemberValue, depth);
}
}
internal override void Walk(NodeWalker walker, int depth)
{
walker("new " + Type + "[]{");
foreach (var node in Items.Take(1))
{
node.Walk(walker, depth);
}
foreach (var node in Items.Skip(1))
{
walker(", ");
node.Walk(walker, depth);
}
walker("}");
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
walker("new {", Value, depth);
foreach (var node in Parameters.Take(1))
{
WalkParameter(walker, depth + 1, node);
}
foreach (var node in Parameters.Skip(1))
{
walker(", ");
WalkParameter(walker, depth + 1, node);
}
walker("}");
}
internal override void Walk(NodeWalker walker, int depth)
{
walker("new " + Type + "(", Value, depth);
foreach (var node in Parameters.Take(1))
{
node.Walk(walker, depth);
}
foreach (var node in Parameters.Skip(1))
{
walker(", ");
node.Walk(walker, depth);
}
walker(")");
}
internal override void Walk(NodeWalker walker, int depth)
{
Expression.Walk(walker, depth);
walker("(");
foreach (var arg in Arguments.Take(1))
{
arg.Walk(walker, depth + 1);
}
foreach (var arg in Arguments.Skip(1))
{
walker(", ");
arg.Walk(walker, depth + 1);
}
walker(")");
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
Expression.Walk(walker, depth, Priority < Expression.Priority);
walker("(");
foreach (var arg in Arguments.Take(1))
{
arg.Walk(walker, depth + 1, false);
}
foreach (var arg in Arguments.Skip(1))
{
walker(", ");
arg.Walk(walker, depth + 1, false);
}
walker(")");
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
if (wrap)
{
walker("(", Value, depth);
depth += 1;
}
Left.Walk(walker, depth + 1, Priority < Left.Priority);
walker(" ");
walker(Operator, Value, depth);
walker(" ");
Right.Walk(walker, depth + 1, Priority <= Right.Priority);
if (wrap)
walker(")");
}
internal override void Walk(NodeWalker walker, int depth)
{
Constructor.Walk(walker, depth);
walker("{");
foreach (var node in Items.Take(1))
{
node.Walk(walker, depth + 1);
}
foreach (var node in Items.Skip(1))
{
walker(", ");
node.Walk(walker, depth + 1);
}
walker("}");
}
internal override void Walk(NodeWalker walker, int depth, bool wrap)
{
Constructor.Walk(walker, depth, false);
walker("{");
foreach (var node in Bindings.Take(1))
{
node.Walk(walker, depth + 1, false);
}
foreach (var node in Bindings.Skip(1))
{
walker(", ");
node.Walk(walker, depth + 1, false);
}
walker("}");
}
internal override void Walk(NodeWalker walker, int depth)
{
InvokedNode.Walk(walker, depth);
walker("(");
foreach (var node in ArgumentNodes.Take(1))
{
node.Walk(walker, depth);
}
foreach (var node in ArgumentNodes.Skip(1))
{
walker(", ");
node.Walk(walker, depth);
}
walker(")");
}
internal override void Walk(NodeWalker walker, int depth)
{
base.Walk(walker, depth);
walker("(");
foreach (var parameter in Parameters.Take(1))
{
parameter.Walk(walker, depth);
}
foreach (var parameter in Parameters.Skip(1))
{
walker(", ");
parameter.Walk(walker, depth);
}
walker(")");
}
internal override void Walk(NodeWalker walker, int depth)
{
base.Walk(walker, depth);
if (MemberName != "get_Item")
{
walker("(");
}
foreach (var parameter in Parameters.Take(1))
{
parameter.Walk(walker, depth + 1);
}
foreach (var parameter in Parameters.Skip(1))
{
walker(", ");
parameter.Walk(walker, depth + 1);
}
walker(MemberName == "get_Item" ? "]" : ")");
}
internal override void Walk(NodeWalker walker, int depth)
{
walker(MemberName);
walker(" = ");
Value.Walk(walker, depth);
}
// If `wrap` specified, output from this node should be unified.
// For BinaryNode, it means output should be wrapped by "(" and ")".
// For others, nothing to do (outputs from others are unified by default)
internal abstract void Walk(NodeWalker walker, int depth, bool wrap);
internal override void Walk(NodeWalker walker, int depth)
{
walker(Text, Value, depth);
}
internal abstract void Walk(NodeWalker walker, int depth);
public static void Main (string[] args)
{
System.Console.WriteLine ("Hello World!");
var characterInfo = new CharacterInfo();
characterInfo.Input = new Brawler.Input.Packets.ControllerState();
characterInfo.Input.AttackStick = new Brawler.Input.Packets.AnalogStick();
characterInfo.Input.MoveStick = new Brawler.Input.Packets.AnalogStick();
characterInfo.Current = new Brawler.Simulation.PlayerInfo();
characterInfo.Previous = new Brawler.Simulation.PlayerInfo();
var dictionary = new TreeDictionary();
var builder = new BlackboardTreeBuilder<CharacterInfo>(
new TreeBuilder(),
dictionary);
var plan = builder
.Selector()
.Begin ()
//.Success()
.Failed ()
.Success()
.Success()
.End ();
var compiled = builder.Build();
//var compiled = BuildSM (builder);
var walker = new NodeWalker(compiled);
walker.Restart ();
walker.ComputeStep();
System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine ("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine ("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine ("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine ("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine ("walker.Outcome : " + walker.Outcome);
walker.ComputeStep();
System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine ("walker.Outcome : " + walker.Outcome);
//Test1 (characterInfo, walker);
//Test2 (characterInfo, walker, timer, MAX_TIMES);
}
static void Test2 (CharacterInfo characterInfo, NodeWalker walker, Stopwatch timer)
{
characterInfo.Input.MoveStick.X = -0.5f;
characterInfo.Input.MoveStick.Y = -0.5f;
characterInfo.Input.AttackStick.X = 0.0f;
characterInfo.Input.AttackStick.Y = 0.0f;
timer.Reset ();
for (int i = 0; i < MAX_TIMES; ++i)
{
timer.Start ();
walker.Restart ();
walker.ComputeAllSteps ();
timer.Stop ();
}
System.Console.WriteLine ("Time elapsed : " + timer.Elapsed.TotalMilliseconds / MAX_TIMES);
System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete);
System.Console.WriteLine ("walker.Outcome : " + walker.Outcome);
System.Console.WriteLine ("IsMoving : " + characterInfo.Current.IsMoving);
System.Console.WriteLine ("IsGuardUp : " + characterInfo.Current.IsGuardUp);
}
internal override void Walk(NodeWalker walker, int depth)
{
Container.Walk(walker, depth + 1);
walker(" ");
walker(MemberName.CleanupName(), MemberValue, depth);
}
internal override void Walk(NodeWalker walker, int depth)
{
walker(Text.CleanupCamelCasing(), Value, depth);
}
