public static SimpleNode GetCareerCupTreeSimple1()
{
SimpleNode l4 = new SimpleNode() { Value = 4 };
SimpleNode l8 = new SimpleNode() { Value = 8 };
SimpleNode left = new SimpleNode() { Value = 3, Left = l4, Right = l8 };
SimpleNode r6 = new SimpleNode() { Value = 6 }; ;
SimpleNode r2 = new SimpleNode() { Value = 2 }; ;
SimpleNode rn2 = new SimpleNode() { Value = -2, Right = r2 }; ;
SimpleNode right = new SimpleNode() { Value = 5, Left = r6, Right = rn2 };
return new SimpleNode() { Value = 2, Left = left, Right = right };
}
/// <summary>
/// Attempts to remove an item from the queue. The item does not need to be the head of the queue.
/// Useful for multi-threading, where the queue may become empty between calls to Contains() and Remove()
/// Returns true if the item was successfully removed, false if it wasn't in the queue.
/// If multiple copies of the item are enqueued, only the first one is removed.
/// O(log n)
/// </summary>
public bool TryRemove(TItem item)
{
lock (_queue)
{
SimpleNode removeMe = GetExistingNode(item);
if (removeMe == null)
{
return(false);
}
_queue.Remove(removeMe);
RemoveFromNodeCache(removeMe);
return(true);
}
}
/// <summary>
/// Removes the head of the queue (node with minimum priority; ties are broken by order of insertion), and returns it.
/// If queue is empty, throws an exception
/// O(log n)
/// </summary>
public TItem Dequeue()
{
lock (_queue)
{
if (_queue.Count <= 0)
{
throw new InvalidOperationException("Cannot call Dequeue() on an empty queue");
}
SimpleNode node = _queue.Dequeue();
RemoveFromNodeCache(node);
return(node.Data);
}
}
/// <summary>
/// Attempt to get the priority of the given item.
/// Useful for multi-threading, where the queue may become empty between calls to Contains() and GetPriority()
/// If the item is enqueued multiple times, only the priority of the first will be returned.
/// (If your requirements are complex enough that you need to enqueue the same item multiple times <i>and</i> be able
/// to query all their priorities, please wrap your items in a wrapper class so they can be distinguished).
/// Returns true if the item was found in the queue, false otherwise
/// O(1)
/// </summary>
public bool TryGetPriority(TItem item, out TPriority priority)
{
lock (_queue)
{
SimpleNode findMe = GetExistingNode(item);
if (findMe == null)
{
priority = default(TPriority);
return(false);
}
priority = findMe.Priority;
return(true);
}
}
/// <summary>
/// Adds an item to the Node-cache to allow for many methods to be O(1) or O(log n)
/// </summary>
private void AddToNodeCache(SimpleNode node)
{
if (node.Data == null)
{
_nullNodesCache.Add(node);
return;
}
if (!_itemToNodesCache.ContainsKey(node.Data))
{
_itemToNodesCache[node.Data] = new List <SimpleNode>();
}
_itemToNodesCache[node.Data].Add(node);
}
/// <summary>
/// Renders the input reader using the context into the output writer.
/// To be used when a template is dynamically constructed, or want to
/// use Velocity as a token replacer.
/// </summary>
/// <param name="context">context to use in rendering input string
/// </param>
/// <param name="out"> Writer in which to render the output
/// </param>
/// <param name="logTag"> string to be used as the template name for log messages
/// in case of error
/// </param>
/// <param name="reader">Reader containing the VTL to be rendered
/// </param>
/// <returns>true if successful, false otherwise. If false, see
/// Velocity runtime log
/// @since Velocity v1.1
/// </returns>
public bool Evaluate(IContext context, TextWriter writer, String logTag, TextReader reader)
{
SimpleNode nodeTree = null;
try
{
nodeTree = ri.parse(reader, logTag);
}
catch (ParseException pex)
{
throw new ParseErrorException(pex.Message);
}
/*
* now we want to init and render
*/
if (nodeTree != null)
{
InternalContextAdapterImpl ica = new InternalContextAdapterImpl(context);
ica.PushCurrentTemplateName(logTag);
try
{
try
{
nodeTree.init(ica, ri);
}
catch (Exception e)
{
ri.error("Velocity.evaluate() : init exception for tag = " + logTag + " : " + e);
}
/*
* now render, and let any exceptions fly
*/
nodeTree.render(ica, writer);
}
finally
{
ica.PopCurrentTemplateName();
}
return(true);
}
return(false);
}
protected override VisualGroup UpdateVisual(IRenderContext context, VisualGroup oldVisual, INode node)
{
var layout = node.Layout;
if (oldVisual.Children.Count != 2)
{
// something's wrong - re-create visual
return(CreateVisual(context, node));
}
// get the child visuals from the container
var wrappedVisual = oldVisual.Children[0];
var image = oldVisual.Children.Count > 1?oldVisual.Children[1]:null;
// update wrapped visual - delegate to renderer of wrapped style
wrappedVisual = wrapped.Renderer.GetVisualCreator(node, wrapped).UpdateVisual(context, wrappedVisual);
if (wrappedVisual != oldVisual.Children[0])
{
oldVisual.Children[0] = wrappedVisual;
}
var oldImageUrl = oldVisual.GetRenderDataCache <string>();
if (imageUrl != oldImageUrl)
{
// update image
imageStyle.Image = new BitmapImage(new Uri(imageUrl, UriKind.Relative));
}
SimpleNode dummyNode = new SimpleNode
{
Layout = new RectD(layout.X + layout.Width - (decoratorSize.Width * 0.5), layout.Y - decoratorSize.Height * 0.5, decoratorSize.Width, decoratorSize.Height)
};
image = imageStyle.Renderer.GetVisualCreator(dummyNode, imageStyle).UpdateVisual(context, image);
if (oldVisual.Children.Count > 1)
{
if (image == null)
{
oldVisual.Children.RemoveAt(1);
}
else if (oldVisual.Children[1] != image)
{
oldVisual.Children[1] = image;
}
}
else if (image != null)
{
oldVisual.Add(image);
}
return(oldVisual);
}
/// <summary>
/// Removes the head of the queue (node with minimum priority; ties are broken by order of insertion), and sets it to first.
/// Useful for multi-threading, where the queue may become empty between calls to Contains() and Dequeue()
/// Returns true if successful; false if queue was empty
/// O(log n)
/// </summary>
public bool TryDequeue(out TItem first)
{
lock (_queue) {
if (_queue.Count <= 0)
{
first = default(TItem);
return(false);
}
SimpleNode node = _queue.Dequeue();
first = node.Data;
RemoveFromNodeCache(node);
return(true);
}
}
private static SimpleNode CreateStartNode(System.Guid nodeGuid)
{
SimpleNode node = null;
node = new SimpleNode(nodeGuid, SimpleNodeType.StartNode);
Port outPort = node.InstantiatePort(Orientation.Horizontal, Direction.Output, Port.Capacity.Single, m_objectType);
node.m_outputPorts.Add(outPort);
node.outputContainer.Add(outPort);
node.RefreshPorts();
node.RefreshExpandedState();
return(node);
}
public SimpleNode <T> Peak()
{
if (_head == null)
{
return(null);
}
SimpleNode <T> temp = _head;
while (temp.HasNext())
{
temp = temp.GetNext();
}
return(temp);
}
internal void parseTree(InternalContextAdapter ica)
{
try
{
//UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"'
TextReader br = new StringReader(macrobody);
nodeTree = Enclosing_Instance.rsvc.parse(br, "VM:" + macroname, true);
nodeTree.init(ica, null);
}
catch (System.Exception e)
{
Enclosing_Instance.rsvc.error("VelocimacroManager.parseTree() : exception " + macroname + " : " + StringUtils.stackTrace(e));
}
}
/// <summary>
/// Call this method to change the priority of an item.
/// Useful for multi-threading, where the queue may become empty between calls to Contains() and UpdatePriority()
/// If the item is enqueued multiple times, only the first one will be updated.
/// (If your requirements are complex enough that you need to enqueue the same item multiple times <i>and</i> be able
/// to update all of them, please wrap your items in a wrapper class so they can be distinguished).
/// Returns true if the item priority was updated, false otherwise. O(log n)
/// </summary>
public bool TryUpdatePriority(TItem item, TPriority priority)
{
lock (_queue)
{
SimpleNode updateMe = GetExistingNode(item);
if (updateMe == null)
{
return(false);
}
_queue.UpdatePriority(updateMe, priority);
return(true);
}
}
public void testMultipleObjectIndexMethodPairs() // throws OgnlException
{
SimpleNode expression = (SimpleNode)Ognl.parseExpression("#ka.sunk[#root]");
context ["ka"] = (new Test5());
try
{
Ognl.getValue(expression, context, "aksdj");
Assert.Fail();
}
catch (OgnlException ex)
{
/* Should throw */
}
}
/// <summary>
/// Adds an item to the Node-cache to allow for many methods to be O(1) or O(log n)
/// </summary>
private void AddToNodeCache(SimpleNode node)
{
if (node.data == null)
{
this._nullNodesCache.Add(node);
return;
}
if (!this._itemToNodesCache.TryGetValue(node.data, out IList <SimpleNode> nodes))
{
nodes = new List <SimpleNode>();
this._itemToNodesCache[node.data] = nodes;
}
nodes.Add(node);
}
/* Override this method if you want to customize how the node dumps
* out its children. */
public void Dump(string prefix)
{
System.Console.Out.WriteLine(ToString(prefix));
if (children != null)
{
for (int i = 0; i < children.Length; ++i)
{
SimpleNode n = (SimpleNode)children[i];
if (n != null)
{
n.Dump(prefix + " ");
}
}
}
}
private static void AddSimpleChildren(SimpleNode sourceNode, List <SimpleNode> simpleTree, XmlTree source)
{
foreach (var id in sourceNode.Children)
{
var node = source.Nodes.FirstOrDefault(e => e.Id == id);
var simpleNode = new SimpleNode(id, sourceNode.Id);
foreach (var bond in node.Bonds)
{
simpleNode.Add(bond);
}
simpleTree.Add(simpleNode);
AddSimpleChildren(simpleNode, simpleTree, source);
}
}
public void Append(T value)
{
if (_head == null)
{
_head = new SimpleNode <T>(value);
return;
}
SimpleNode <T> temp = _head;
while (temp.HasNext())
{
temp = temp.GetNext();
}
temp.SetNext(new SimpleNode <T>(value));
}
/// <summary>
/// Call this method to change the priority of an item.
/// Calling this method on a item not in the queue will throw an exception.
/// If the item is enqueued multiple times, only the first one will be updated.
/// (If your requirements are complex enough that you need to enqueue the same item multiple times <i>and</i> be able
/// to update all of them, please wrap your items in a wrapper class so they can be distinguished).
/// O(n)
/// </summary>
public void UpdatePriority(TItem item, TPriority priority)
{
lock (_queue)
{
try
{
SimpleNode updateMe = GetExistingNode(item);
_queue.UpdatePriority(updateMe, priority);
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException("Cannot call UpdatePriority() on a node which is not enqueued: " + item, ex);
}
}
}
public bool Evaluate(IContext context, TextWriter writer, string logTag, TextReader reader)
{
SimpleNode simpleNode = null;
try
{
simpleNode = this.ri.Parse(reader, logTag);
}
catch (ParseException ex)
{
throw new ParseErrorException(ex.Message, ex);
}
bool result;
if (simpleNode != null)
{
InternalContextAdapterImpl internalContextAdapterImpl = new InternalContextAdapterImpl(context);
internalContextAdapterImpl.PushCurrentTemplateName(logTag);
try
{
try
{
simpleNode.Init(internalContextAdapterImpl, this.ri);
}
catch (System.Exception ex2)
{
this.ri.Error(string.Concat(new object[]
{
"Velocity.evaluate() : init exception for tag = ",
logTag,
" : ",
ex2
}));
}
simpleNode.Render(internalContextAdapterImpl, writer);
}
finally
{
internalContextAdapterImpl.PopCurrentTemplateName();
}
result = true;
}
else
{
result = false;
}
return(result);
}
protected override void WriteInner(System.Xml.XmlWriter writer)
{
var container = new ComplexNode();
container.Classes.Add("image-container");
var img = new SimpleNode("img", string.Empty);
img.Attributes.Add("src", _imagePath);
img.Styles.Add("width", "100%");
container.ChildNodes.Add(img);
ChildNodes.Add(container);
base.WriteInner(writer);
}
internal void parseTree(IInternalContextAdapter internalContextAdapter)
{
try
{
//UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"'
TextReader br = new StringReader(macroBody);
nodeTree = Enclosing_Instance.runtimeServices.Parse(br, string.Format("VM:{0}", macroName), true);
nodeTree.Init(internalContextAdapter, null);
}
catch (System.Exception e)
{
Enclosing_Instance.runtimeServices.Error(
string.Format("VelocimacroManager.parseTree() : exception {0} : {1}", macroName, e));
}
}
/// <summary>
/// Creates the dummy connector edge for the given label.
/// </summary>
private IEdge CreateConnectorEdge(ILabel label)
{
// create a dummy node at the location of the label
var labelNodeDummy = new SimpleNode {
Layout = label.GetLayout().GetBounds(), Style = new ShapeNodeStyle()
};
labelNodeDummy.Ports = new ListEnumerable <IPort>(new[] { new SimplePort(labelNodeDummy, LabelPortLocation) });
// create a connecting edge between the dummy node and the owner of the label
return(new SimpleEdge(new SimplePort(labelNodeDummy, OwnerPortLocation),
new SimplePort((IPortOwner)label.Owner, OwnerPortLocation))
{
Style = ConnectorEdgeStyle
});
}
public void ValidateSampleOneFromAToF()
{
var a = new SimpleNode("A");
var b = new SimpleNode("B");
var c = new SimpleNode("C");
var d = new SimpleNode("D");
var e = new SimpleNode("E");
var f = new SimpleNode("F");
a.ConnectTo(b, 4);
a.ConnectTo(c, 2);
b.ConnectTo(c, 1);
b.ConnectTo(d, 5);
c.ConnectTo(d, 8);
c.ConnectTo(e, 10);
d.ConnectTo(f, 6);
d.ConnectTo(e, 2);
e.ConnectTo(f, 2);
var dijkstra = new Dijkstra.Dijkstra();
var result = dijkstra.FindShortestPath(a, f);
Assert.NotNull(result);
Assert.Equal(6, result.Length);
Assert.Equal("A", result[0].Label);
Assert.Equal("C", result[1].Label);
Assert.Equal("B", result[2].Label);
Assert.Equal("D", result[3].Label);
Assert.Equal("E", result[4].Label);
Assert.Equal("F", result[5].Label);
var weight = 0;
for (var i = 0; i < result.Length; i++)
{
var currentWeight = 0;
if (i < result.Length - 1)
{
currentWeight = result[i].Neighbors
.Single(n => n.Node.Label.Equals(result[i + 1].Label))
.WeightToNode;
}
weight += currentWeight;
}
Assert.Equal(12, weight);
}
/// <summary>
/// Called to render the combo box items.
/// </summary>
private void DrawComboBoxItem(object sender, DrawItemEventArgs e)
{
e.DrawBackground();
e.DrawFocusRectangle();
var node = Nodes[e.Index];
var item = (INeo4jNode)node.Tag;
var style = new Neo4JNodeStyle();
var dummyNode = new SimpleNode {
Layout = new RectD(0, 0, 240, 75), Tag = item, Style = style
};
var context = new RenderContext(e.Graphics, canvasControl);
var visual = style.Renderer.GetVisualCreator(dummyNode, style).CreateVisual(context);
((VisualGroup)visual).Transform = new Matrix();
((VisualGroup)visual).Transform.Translate(e.Bounds.X, e.Bounds.Y);
visual.Paint(context, e.Graphics);
}
public void testPop()
{
Stack <int> tester = new Stack <int>();
tester.Push(0);
tester.Push(1);
tester.Push(2);
SimpleNode <int> popped = tester.Pop();
Assert.AreEqual(popped.GetValue(), 2);
popped = tester.Pop();
Assert.AreEqual(popped.GetValue(), 1);
Assert.AreEqual(tester.Size(), 1);
popped = tester.Pop();
Assert.AreEqual(popped.GetValue(), 0);
Assert.Null(tester.Pop());
}
private ComplexNode CreateAchor(string imagePath, string filePath, string text)
{
var anchor = new ComplexNode("a");
anchor.Attributes.Add("href", "FileDownload/DownloadFile?fileName=" + filePath);
var img = new SimpleNode("img", string.Empty);
img.Attributes.Add("src", @"Content/Images/help/" + imagePath);
anchor.ChildNodes.Add(img);
var span = new SimpleNode("span", text);
anchor.ChildNodes.Add(span);
return(anchor);
}
public void InitializeDrag(IInputModeContext context)
{
wrappedHandler.InitializeDrag(context);
this.shadowLocation = node.Layout.GetTopLeft();
this.emulatedOffset = PointD.Origin;
var dummyNode = new SimpleNode {
Layout = new DynamicRectangle(shadowLocation, node.Layout),
Style =
new ShapeNodeStyle {
Shape = ShapeNodeShape.RoundRectangle,
Brush = Brushes.Transparent,
Pen = new Pen(Brushes.Gray, 2)
}
};
shadowObject = context.CanvasControl.RootGroup.AddChild(dummyNode, GraphModelManager.DefaultNodeDescriptor).ToFront();
}
protected override void WriteInner(XmlWriter writer)
{
var aNode = new SimpleNode("div", string.Empty);
aNode.Attributes.Add("parentId", _parentId);
aNode.Attributes.Add("style", "display:none;float:left;");
ChildNodes.Add(aNode);
ChildNodes.Add(new UserInputNode(_data, _parentId));
ChildNodes.Add(new UserImageNode());
var userName = _data.Attribute("firstName").Value + " " + _data.Attribute("lastName").Value;
ChildNodes.Add(new UserNameNode(userName));
base.WriteInner(writer);
}
/// <summary>
/// Enqueue a node to the priority queue. Lower values are placed in front. Ties are broken by first-in-first-out.
/// This queue automatically resizes itself, so there's no concern of the queue becoming 'full'.
/// Duplicates and null-values are allowed.
/// O(log n)
/// </summary>
public void Enqueue(TItem item, TPriority priority)
{
lock (_queue) {
IList <SimpleNode> nodes;
if (item == null)
{
nodes = _nullNodesCache;
}
else if (!_itemToNodesCache.TryGetValue(item, out nodes))
{
nodes = new List <SimpleNode>();
_itemToNodesCache[item] = nodes;
}
SimpleNode node = EnqueueNoLockOrCache(item, priority);
nodes.Add(node);
}
}
/// <summary>
/// Adds an item to the Node-cache to allow for many methods to be O(1) or O(log n)
/// </summary>
private void AddToNodeCache(SimpleNode node)
{
if (node.Data == null)
{
_nullNodesCache.Add(node);
return;
}
IList <SimpleNode> nodes;
if (!_itemToNodesCache.TryGetValue(node.Data, out nodes))
{
nodes = new List <SimpleNode>();
_itemToNodesCache[node.Data] = nodes;
}
nodes.Add(node);
}
public int Length()
{
SimpleNode <T> temp = _head;
if (temp == null)
{
return(0);
}
int result = 0;
do
{
result++;
temp = temp.GetNext();
}while (temp != _head);
return(result);
}
public void Setup()
{
m_workflowBuilder = new WorkflowBuilder();
InitializeEventReceiver receiver = new InitializeEventReceiver();
m_simpleNode1 = new SimpleNode();
m_simpleNode2 = new SimpleNode();
m_simpleNode3 = new SimpleNode();
m_workflowBuilder.Add(receiver);
m_workflowBuilder.Add(m_simpleNode1);
m_workflowBuilder.Add(m_simpleNode2);
m_workflowBuilder.Add(m_simpleNode3);
m_workflowBuilder.Connect(receiver.Pin(x => x.Fired), m_simpleNode1);
m_workflowBuilder.Connect(m_simpleNode1.Pin(x => x.Next), m_simpleNode2);
m_workflowBuilder.Connect(m_simpleNode2.Pin(x => x.Next), m_simpleNode3);
m_debuggerMock = new Mock<IDebugger>();
}
public void CreateGridOLD(SimpleNode[] nodes)
{
Grid grid = new Grid();
grids = new Grid[1] { grid };
grid.width = nodes.Length;
grid.depth = 1;
staticNodes = new Node[1][,];
staticNodes[0] = new Node[grid.width, grid.depth];
totalNodeAmount = nodes.Length;
for (int x = 0; x < nodes.Length; x++)
{
Node node = new Node();
node.pos = new Int3(x, 0, 0);
nodes[x].pos = node.pos;
node.vectorPos = nodes[x].vectorPos;
staticNodes[0][x, 0] = node;
}
for (int x = 0; x < nodes.Length; x++)
{
Node node = staticNodes[0][x, 0];
node.neighbours = new Node[nodes[x].neighbours.Length];
node.costs = new int[nodes[x].neighbours.Length];
node.angles = new float[nodes[x].neighbours.Length];
node.neighboursKeys = new int[nodes[x].neighbours.Length];
for (int i = 0; i < node.neighbours.Length; i++)
{
node.neighbours[i] = GetNode(nodes[x].neighbours[i].pos);
node.costs[i] = nodes[x].costs == null ? (int)(Vector3.Distance(node.neighbours[i].vectorPos, node.vectorPos) * 100) : nodes[x].costs[i];
node.angles[i] = nodes[x].angles == null ? 0 : nodes[x].angles[i];
node.neighboursKeys[i] = i;
}
}
Bounds b = new Bounds(staticNodes[0][0, 0].vectorPos, Vector3.zero);
for (int x = 0; x < nodes.Length; x++)
{
b.Encapsulate(staticNodes[0][x, 0].vectorPos);
}
b.extents += Vector3.one * boundsMargin;
grid.globalWidth = b.size.x;
grid.globalDepth = b.size.z;
grid.globalHeight = b.size.y;
grid.globalOffset = (b.center - b.extents);
FloodFillAll();
binaryHeap = new BinaryHeap(Mathf.CeilToInt(totalNodeAmount * heapSize));
}
/// <summary> Default constructor: sets up the Velocity
/// Runtime, creates the visitor for traversing
/// the node structure and then produces the
/// visual representation by the visitation.
/// </summary>
public TemplateNodeView(System.String template)
{
try {
RuntimeSingleton.init("velocity.properties");
System.IO.StreamReader isr = new InputStreamReader(new System.IO.FileStream(template, System.IO.FileMode.Open, System.IO.FileAccess.Read), RuntimeSingleton.getString(RuntimeSingleton.INPUT_ENCODING))
;
//UPGRADE_ISSUE: The equivalent of constructor 'java.io.BufferedReader.BufferedReader' is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"'
System.IO.StreamReader br = new System.IO.StreamReader(isr.BaseStream);
document = RuntimeSingleton.parse(br, template)
;
visitor = new NodeViewMode();
visitor.Context = null;
//UPGRADE_ISSUE: The equivalent of parameter java.lang.System.out is incompatible with the expected type in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1109"'
visitor.Writer = new System.IO.StreamWriter(System.Console.Out);
document.jjtAccept(visitor, null);
} catch (System.Exception e) {
System.Console.Out.WriteLine(e);
SupportClass.WriteStackTrace(e, Console.Error);
}
}
public void the_remove_method_puts_a_node_removed_event_on_the_chain()
{
var chain = new BehaviorChain();
chain.AddToEnd(new SimpleNode());
var nodeToBeRemoved = new SimpleNode();
chain.AddToEnd(nodeToBeRemoved);
chain.AddToEnd(new SimpleNode());
chain.AddToEnd(new SimpleNode());
nodeToBeRemoved.Remove();
chain.As<ITracedModel>().StagedEvents.Last()
.ShouldEqual(new NodeRemoved(nodeToBeRemoved));
}
public void the_replace_method_puts_a_node_replaced_event_on_the_chain()
{
var original = new SimpleNode();
var newNode = new SimpleNode();
var chain = new BehaviorChain();
chain.AddToEnd(original);
original.ReplaceWith(newNode);
chain.As<ITracedModel>().StagedEvents.Last()
.ShouldEqual(new NodeReplaced(original, newNode));
}
public void CreateGrid (SimpleNode[][] nodes) {
if (nodes.Length < 1) {
Debug.LogError ("Make sure you use at least one grid");
}
Grid[] allGrids = new Grid[nodes.Length];
for (int i=0;i<allGrids.Length;i++) {
allGrids[i] = new Grid ();
allGrids[i].width = nodes[i].Length;
allGrids[i].depth = 1;
if (allGrids[i].width < 1) {
Debug.LogError ("Make sure you use at least one node for each grid");
return;
}
}
staticNodes = new Node[allGrids.Length][,];
totalNodeAmount = 0;
for (int i=0;i<allGrids.Length;i++) {
Grid grid = allGrids[i];
staticNodes[i] = new Node [grid.width,grid.depth];
totalNodeAmount+= grid.width*grid.depth;
}
for (int y=0;y<allGrids.Length;y++) {
SimpleNode[] gridNodes = nodes[y];
for (int x=0;x<gridNodes.Length;x++) {
Node node = new Node ();
node.pos = new Int3(x,y,0);
gridNodes[x].pos = node.pos;
node.vectorPos = gridNodes[x].vectorPos;
staticNodes[y][x,0] = node;
}
}
for (int y=0;y<allGrids.Length;y++) {
Grid grid = allGrids[y];
SimpleNode[] gridNodes = nodes[y];
for (int x=0;x<gridNodes.Length;x++) {
Node node = staticNodes[y][x,0];
node.connections = new Connection[gridNodes[x].neighbours.Length];
for (int i=0;i<node.connections.Length;i++) {
Node neighbour = GetNode (gridNodes[x].neighbours[i].pos);
int cost = gridNodes[x].costs == null ? (int)(Vector3.Distance (neighbour.vectorPos,node.vectorPos)*100) : gridNodes[x].costs[i];
float angle = gridNodes[x].angles == null ? 0 : gridNodes[x].angles[i];
node.connections[i] = new Connection (neighbour,cost,angle,true);
}
node.GenerateEnabledConnections ();
}
Bounds b = new Bounds (staticNodes[y][0,0].vectorPos,Vector3.zero);
for (int x=0;x<gridNodes.Length;x++) {
b.Encapsulate (staticNodes[y][x,0].vectorPos);
}
b.extents += Vector3.one * boundsMargin;
grid.globalWidth = b.size.x;
grid.globalDepth = b.size.z;
grid.globalHeight = b.size.y;
grid.globalOffset = (b.center-b.extents);
}
grids = allGrids;
FloodFillAll ();
binaryHeap = new BinaryHeap (Mathf.CeilToInt (totalNodeAmount*heapSize));
}
public void CreateGrid (SimpleNode[] nodes) {
SimpleNode[][] nds = new SimpleNode[1][];
nds[0] = nodes;
CreateGrid (nds);
}
