private static List <NodePointer> GetNeighbours(IReadOnlyArray2D <DefinitionNode> nodeArray, int gridX, int gridY, GenerateNodeGridConnections generateNodeGridConnections)
{
var neighbours = new List <NodePointer>();
for (var y = -1; y <= 1; y++)
{
for (var x = -1; x <= 1; x++)
{
if (x == 0 && y == 0)
{
continue; //Skip the center since this is the node we are adding neighbours to.
}
var checkX = gridX + x;
var checkY = gridY + y;
if (checkX >= 0 && checkX < nodeArray.Width && checkY >= 0 && checkY < nodeArray.Height)
{
if (generateNodeGridConnections == GenerateNodeGridConnections.NoDiagonal)
{
if (x == 1 && y == 1 || x == -1 && y == 1 || x == -1 && y == -1 || x == 1 && y == -1)
{
continue;
}
}
var p = new NodePointer(nodeArray.Width * checkY + checkX);
neighbours.Add(p);
}
}
}
return(neighbours);
}
public NodePath FindPath(IPathfindNodeNetwork <AstarNode> nodeNetwork, IPathRequest pathRequest, out bool succes)
{
var pathfindingNetwork = nodeNetwork.GetCollisionLayerNetwork(pathRequest.CollisionCategory);
var startNode = NodePointer.Dereference(pathRequest.PathStart.Index, pathfindingNetwork);
var endNode = NodePointer.Dereference(pathRequest.PathEnd.Index, pathfindingNetwork);
var path = FindPath(pathfindingNetwork, startNode, endNode, pathRequest.AgentSize, pathRequest.CollisionCategory);
if (path == null)
{
succes = false;
return(new NodePath(new[] { startNode.DefinitionNode }, nodeNetwork.DefinitionNodeNetwork.Transformer));
}
succes = true;
switch (nodeNetwork.DefinitionNodeNetwork)
{
case IDefinitionNodeGrid definitionNodeGrid:
var offset = GridClearanceHelper.GridNodeOffset(pathRequest.AgentSize, definitionNodeGrid.Transformer.Scale);
return(new NodePath(path.ToArray(), definitionNodeGrid.Transformer));
case IDefinitionNodeNetwork definitionNodeNetwork:
return(new NodePath(path.ToArray(), definitionNodeNetwork.Transformer));
default:
throw new NotSupportedException($"{nodeNetwork.DefinitionNodeNetwork.GetType()} is not supported");
}
}
private void Draw(IDrawDevice device, IReadOnlyList <ICollisionLayerNode> network, IDefinitionNodeNetwork definitionNodeNetwork)
{
var canvas = new Canvas(device, new CanvasBuffer());
canvas.State.ZOffset = -8;
for (var i = 0; i < network.Count; i++)
{
var node = network[i];
canvas.State.ColorTint = ColorRgba.LightGrey;
var nodeWorldPosition = definitionNodeNetwork.Transformer.ToWorld(node.DefinitionNode.Position);
canvas.FillCircle(nodeWorldPosition.X, nodeWorldPosition.Y, NodeSize);
canvas.State.ColorTint = ColorRgba.VeryLightGrey;
if (node.DefinitionNode.Connections != null)
{
canvas.State.ColorTint = new ColorRgba(199, 21, 133);
foreach (var connection in node.DefinitionNode.Connections)
{
var toNode = NodePointer.Dereference(connection.To, definitionNodeNetwork);
var vector = (definitionNodeNetwork.Transformer.ToWorld(toNode.Position) - nodeWorldPosition) * 0.5f; //Times 0.5f so we can see the connections in both directions.
canvas.DrawDashLine(nodeWorldPosition.X, nodeWorldPosition.Y, nodeWorldPosition.X + vector.X, nodeWorldPosition.Y + vector.Y);
}
if (!float.IsNaN(node.Clearance))
{
canvas.State.ColorTint = ColorRgba.Black;
canvas.DrawText(node.Clearance.ToString(), nodeWorldPosition.X, nodeWorldPosition.Y, -1f, Alignment.Center);
}
}
}
}
/// <summary>
/// Constructs a <see cref="ParentOfSpecification"/> specification matching the given <paramref name="childPointer"/> and <paramref name="depth"/>.
/// </summary>
/// <param name="childPointer">The pointer of the parent.</param>
/// <param name="depth">The depth from which to select.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="childPointer"/> is null.</exception>
public static ParentOfSpecification Child(NodePointer childPointer, int? depth = 1)
{
// validate arguments
if (childPointer == null)
throw new ArgumentNullException("childPointer");
return new ParentOfSpecification(childPointer, depth);
}
/// <summary>
/// Constructs a <see cref="ChildOfSpecification"/> specification matching the given <paramref name="parentPointer"/> and <paramref name="depth"/>.
/// </summary>
/// <param name="parentPointer">The pointer of the parent.</param>
/// <param name="depth">The depth from which to select.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="parentPointer"/> is null.</exception>
public static ChildOfSpecification Parent(NodePointer parentPointer, int? depth = 1)
{
// validate arguments
if (parentPointer == null)
throw new ArgumentNullException("parentPointer");
return new ChildOfSpecification(parentPointer, depth);
}
/// <summary>
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The <see cref="NodePointer"/>.</param>
/// <param name="depth">The depth from which to get the path.</param>
/// <param name="separator">The separator to use.</param>
/// <returns>Returns the path.</returns>
public string Evaluate(IMansionContext context, NodePointer pointer, int depth, string separator)
{
// validate arguments
if (context == null)
throw new ArgumentNullException("context");
if (pointer == null)
throw new ArgumentNullException("pointer");
return string.Join(separator, pointer.Path.Skip(depth).TakeWhile((x, y) => y != (pointer.Depth - depth - 1)));
}
/// <summary>
/// Constructs this specification.
/// </summary>
/// <param name="childPointer">The pointer of the parent.</param>
/// <param name="depth">The depth from which to select.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="childPointer"/> is null.</exception>
private ParentOfSpecification(NodePointer childPointer, int? depth = 1)
{
// validate argument
if (childPointer == null)
throw new ArgumentNullException("childPointer");
// set values
ChildPointer = childPointer;
Depth = depth;
}
/// <summary>
/// Constructs this specification.
/// </summary>
/// <param name="parentPointer">The pointer of the parent.</param>
/// <param name="depth">The depth from which to select.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="parentPointer"/> is null.</exception>
private ChildOfSpecification(NodePointer parentPointer, int? depth = 1)
{
// validate argument
if (parentPointer == null)
throw new ArgumentNullException("parentPointer");
// set values
ParentPointer = parentPointer;
Depth = depth;
}
/// <summary>
/// Prepares an insert query.
/// </summary>
/// <param name="context"></param>
/// <param name="connection">The connection.</param>
/// <param name="transaction">The transaction.</param>
/// <param name="pointer"></param>
/// <param name="newParentPointer"></param>
/// <returns></returns>
public void Prepare(IMansionContext context, SqlConnection connection, SqlTransaction transaction, NodePointer pointer, NodePointer newParentPointer)
{
// validate arguments
if (connection == null)
throw new ArgumentNullException("connection");
if (transaction == null)
throw new ArgumentNullException("transaction");
if (pointer == null)
throw new ArgumentNullException("pointer");
if (newParentPointer == null)
throw new ArgumentNullException("newParentPointer");
// retrieve the schema
var type = typeService.Load(context, pointer.Type);
var schema = Resolver.Resolve(context, type);
// create the commands
command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.Transaction = transaction;
var query = new StringBuilder();
// calculate the new parent pointer
var newPointer = NodePointer.ChangeParent(newParentPointer, pointer);
// update the path
query.AppendFormat(@"UPDATE [{0}] SET
[parentPointer] = @newPointer + RIGHT( [parentPointer], LEN( [parentPointer] ) - @oldPointerLength ),
[parentPath] = @newPath + RIGHT( [parentPath], LEN( [parentPath] ) - @oldPathLength ),
[parentStructure] = @newStructure + RIGHT( [parentStructure], LEN( [parentStructure] ) - @oldStructureLength ),
[depth] = (LEN(@newPointer + RIGHT( [parentPointer], LEN( [parentPointer] ) - @oldPointerLength )) - LEN(REPLACE(@newPointer + RIGHT( [parentPointer], LEN( [parentPointer] ) - @oldPointerLength ), '-', ''))) + 1
WHERE ( [parentId] = @id OR [parentPointer] LIKE @oldPointer ); ", schema.RootTable.Name);
query.AppendFormat(@"UPDATE [{0}] SET
[parentId] = @newParentId,
[parentPointer] = @newParentPointer,
[parentPath] = @newParentPath,
[parentStructure] = @newParentStructure,
[depth] = (LEN(@newParentPointer) - LEN(REPLACE(@newParentPointer, '-', ''))) + 1
WHERE [id] = @id ", schema.RootTable.Name);
command.AddParameter(pointer.PointerString.Length + 1, "oldPointerLength");
command.AddParameter(newPointer.PointerString + NodePointer.PointerSeparator, "newPointer");
command.AddParameter(pointer.PathString.Length + 1, "oldPathLength");
command.AddParameter(newPointer.PathString + NodePointer.PathSeparator, "newPath");
command.AddParameter(pointer.StructureString.Length + 1, "oldStructureLength");
command.AddParameter(newPointer.StructureString + NodePointer.StructureSeparator, "newStructure");
command.AddParameter(pointer.PointerString + NodePointer.PointerSeparator, "oldPointer");
command.AddParameter(newPointer.Id, "id");
command.AddParameter(newParentPointer.Id, "newParentId");
command.AddParameter(newParentPointer.PointerString + NodePointer.PointerSeparator, "newParentPointer");
command.AddParameter(newParentPointer.PathString + NodePointer.PathSeparator, "newParentPath");
command.AddParameter(newParentPointer.StructureString + NodePointer.StructureSeparator, "newParentStructure");
// execute
command.CommandText = query.ToString();
}
/// <summary>
/// </summary>
/// <param name="context"></param>
/// <param name="candidateParent"></param>
/// <param name="childPointer"></param>
/// <returns></returns>
public bool Evaluate(IMansionContext context, NodePointer candidateParent, NodePointer childPointer)
{
// validate arguments
if (context == null)
throw new ArgumentNullException("context");
if (candidateParent == null)
throw new ArgumentNullException("candidateParent");
if (childPointer == null)
throw new ArgumentNullException("childPointer");
return candidateParent.Id.Equals(childPointer.Parent.Id);
}
/// <summary>
/// Prepares an insert query.
/// </summary>
/// <param name="context"></param>
/// <param name="connection">The connection.</param>
/// <param name="transaction">The transaction.</param>
/// <param name="parent"></param>
/// <param name="properties"></param>
/// <returns></returns>
public void Prepare(IMansionContext context, SqlConnection connection, SqlTransaction transaction, NodePointer parent, IPropertyBag properties)
{
// validate arguments
if (connection == null)
throw new ArgumentNullException("connection");
if (transaction == null)
throw new ArgumentNullException("transaction");
if (parent == null)
throw new ArgumentNullException("parent");
if (properties == null)
throw new ArgumentNullException("properties");
// get the values
var name = properties.Get<string>(context, "name", null);
if (string.IsNullOrWhiteSpace(name))
throw new InvalidOperationException("The node must have a name");
var typeName = properties.Get<string>(context, "type", null);
if (string.IsNullOrWhiteSpace(typeName))
throw new InvalidOperationException("The node must have a type");
// retrieve the type
var type = typeService.Load(context, typeName);
// get the schema of the root type
var schema = Resolver.Resolve(context, type);
// set the full text property
SqlServerUtilities.PopulateFullTextColumn(context, type, properties, properties);
// create the new pointer
name = NodePointer.MakeSafeName(name);
var newPointer = NodePointer.Parse(string.Join(NodePointer.PointerSeparator, new[] {parent.PointerString, 0.ToString(CultureInfo.InvariantCulture)}), string.Join(NodePointer.StructureSeparator, new[] {parent.StructureString, type.Name}), string.Join(NodePointer.PathSeparator, new[] {parent.PathString, name}));
properties.Set("_newPointer", newPointer);
// create the commands
command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.Transaction = transaction;
// prepare the query
var queryBuilder = new ModificationQueryBuilder(command);
// loop through all the tables in the schema and let them prepare for insert
foreach (var table in schema.Tables)
table.ToInsertStatement(context, queryBuilder, properties);
// finish the complete insert statement
queryBuilder.AppendQuery("SELECT @ScopeIdentity");
// set the command text
command.CommandText = queryBuilder.ToStatement();
}
/// <summary>
/// This method is called just before a node is copied in the repository.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="originalParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> from which <paramref name="node"/> was copied.</param>
/// <param name="targetParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> to which <paramref name="node"/> was copied.</param>
/// <param name="node">The copied node.</param>
public void AfterCopy(IMansionContext context, NodePointer originalParentPointer, NodePointer targetParentPointer, Node node)
{
// validate arguments
if (context == null)
throw new ArgumentNullException("context");
if (originalParentPointer == null)
throw new ArgumentNullException("originalParentPointer");
if (targetParentPointer == null)
throw new ArgumentNullException("targetParentPointer");
if (node == null)
throw new ArgumentNullException("node");
// invoke template method
DoAfterCopy(context, originalParentPointer, targetParentPointer, node);
}
/// <summary>
/// This method is called just before a node is copied in the repository.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="originalParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> from which <paramref name="pointer"/> is being copied.</param>
/// <param name="targetParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> to which <paramref name="pointer"/> is being copied.</param>
/// <param name="pointer">The pointer to the node being copied.</param>
public void BeforeCopy(IMansionContext context, NodePointer originalParentPointer, NodePointer targetParentPointer, NodePointer pointer)
{
// validate arguments
if (context == null)
throw new ArgumentNullException("context");
if (originalParentPointer == null)
throw new ArgumentNullException("originalParentPointer");
if (targetParentPointer == null)
throw new ArgumentNullException("targetParentPointer");
if (pointer == null)
throw new ArgumentNullException("pointer");
// invoke template method
DoBeforeCopy(context, originalParentPointer, targetParentPointer, pointer);
}
private static List <DefinitionNode> RetracePath(AstarNode[] pathfindingNetwork, AstarNode startGridNode, AstarNode endGridNode)
{
var path = new List <DefinitionNode>();
var currentNode = endGridNode;
while (true)
{
path.Add(currentNode.DefinitionNode);
if (currentNode == startGridNode)
{
break;
}
currentNode = NodePointer.Dereference(currentNode.Parent, pathfindingNetwork);
}
path.Reverse();
return(path);
}
public bool FindPath(DijkstraNode[] pathfindingNetwork, DijkstraNode targetNode, DijkstraNode startNode, IPathRequest pathRequest)
{
if (targetNode.Clearance < pathRequest.AgentSize)
{
return(false);
}
ResetNetwork(pathfindingNetwork);
var openSet = new MaxHeap <DijkstraNode>(pathfindingNetwork.Length);
var closedSet = new HashSet <DijkstraNode>();
openSet.Add(targetNode);
targetNode.GCost = 0f;
while (openSet.Count > 0)
{
var currentNode = openSet.RemoveFirst();
closedSet.Add(currentNode);
foreach (var connection in currentNode.DefinitionNode.Connections)
{
var toNode = NodePointer.Dereference(connection.To, pathfindingNetwork);
if ((connection.CollisionCategory & pathRequest.CollisionCategory) != 0 || closedSet.Contains(toNode))
{
continue;
}
if (toNode.Clearance < pathRequest.AgentSize)
{
toNode.GCost = float.NaN;
}
else
{
var newMovementCostToNeighbour = currentNode.GCost + GetDistance(currentNode.DefinitionNode, toNode.DefinitionNode) * currentNode.DefinitionNode.MovementCostModifier;
if (newMovementCostToNeighbour < toNode.GCost || !openSet.Contains(toNode))
{
toNode.GCost = newMovementCostToNeighbour;
if (!openSet.Contains(toNode))
{
openSet.Add(toNode);
}
}
}
}
}
return(true);
}
public PotentialField FindPath(DijkstraNodeGrid dijkstraNodeNetwork, IPathRequest pathRequest, out bool succes)
{
try
{
if (pathRequest.AgentSize % 2 == 0)
{
throw new InvalidAgentSizeException("Potential fields only support uneven agent sizes such as 1,3,5 etc.");
}
if (_potentialFieldCache == null || !_potentialFieldCache.TryGetValue(pathRequest, out var potentialField))
{
var sw = Stopwatch.StartNew();
var pathfindingNetwork = dijkstraNodeNetwork.GetCollisionLayerNetwork(pathRequest.CollisionCategory);
var startNode = NodePointer.Dereference(pathRequest.PathStart.Index, pathfindingNetwork);
var targetNode = NodePointer.Dereference(pathRequest.PathEnd.Index, pathfindingNetwork);
if (_dijkstraAlgorithm.FindPath(pathfindingNetwork, targetNode, startNode, pathRequest))
{
potentialField = FindPath(dijkstraNodeNetwork, pathfindingNetwork, targetNode, pathRequest);
}
else
{
potentialField = new PotentialField(dijkstraNodeNetwork.DefinitionNodeGrid.Transformer, (Point2)targetNode.DefinitionNode.Position);
}
_potentialFieldCache?.Add(pathRequest, potentialField);
Debug.WriteLine($"Potentialfield created in {sw.ElapsedMilliseconds} ms.");
}
var nodeWorldPosition = potentialField.GridTransformer.ToWorld(pathRequest.PathStart.Position);
var offset = GridClearanceHelper.GridNodeOffset(pathRequest.AgentSize, dijkstraNodeNetwork.DefinitionNodeGrid.Transformer.Scale);
succes = potentialField.GetHeading(nodeWorldPosition + offset).Length > 0;
return(potentialField);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
Debugger.Break();
succes = false;
return(null);
}
}
/// <summary>
/// Prepares an insert query.
/// </summary>
/// <param name="context"></param>
/// <param name="connection">The connection.</param>
/// <param name="transaction">The transaction.</param>
/// <param name="pointer"></param>
/// <returns></returns>
public void Prepare(IMansionContext context, SqlConnection connection, SqlTransaction transaction, NodePointer pointer)
{
// validate arguments
if (connection == null)
throw new ArgumentNullException("connection");
if (transaction == null)
throw new ArgumentNullException("transaction");
if (pointer == null)
throw new ArgumentNullException("pointer");
// retrieve the schema
var type = typeService.Load(context, pointer.Type);
var schema = Resolver.Resolve(context, type);
// create the commands
command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.Transaction = transaction;
command.CommandText = string.Format(@"DELETE FROM [{0}] WHERE [{0}].[parentPointer] LIKE @pointer; DELETE FROM [{0}] WHERE [{0}].[id] = @id", schema.RootTable.Name);
command.Parameters.AddWithValue("pointer", pointer.PointerString + NodePointer.PointerSeparator + "%");
command.Parameters.AddWithValue("id", pointer.Id);
}
/// <summary>
/// This method is called just before a node is copied in the repository.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="originalParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> from which <paramref name="pointer"/> is being copied.</param>
/// <param name="targetParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> to which <paramref name="pointer"/> is being copied.</param>
/// <param name="pointer">The pointer to the node being copied.</param>
protected virtual void DoBeforeCopy(IMansionContext context, NodePointer originalParentPointer, NodePointer targetParentPointer, NodePointer pointer)
{
}
/// <summary>
/// This method is called just before a node is copied in the repository.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="originalParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> from which <paramref name="node"/> was copied.</param>
/// <param name="targetParentPointer">The <see cref="NodePointer"/> of the parent <see cref="Node"/> to which <paramref name="node"/> was copied.</param>
/// <param name="node">The copied node.</param>
protected virtual void DoAfterCopy(IMansionContext context, NodePointer originalParentPointer, NodePointer targetParentPointer, Node node)
{
}
/// <summary>
/// Creates the tree structure from the <paramref name="navigationItemNodeset"/>.
/// </summary>
/// <param name="context"></param>
/// <param name="navigationNode"></param>
/// <param name="navigationItemNodeset"></param>
/// <param name="currentPagePointer"></param>
/// <returns></returns>
private Leaf BuildTreeStructure(IMansionContext context, Node navigationNode, Nodeset navigationItemNodeset, NodePointer currentPagePointer)
{
// first sort the set by depth ASC, than order ASC
var sortedSet = navigationItemNodeset.Nodes.OrderBy(x => x, new ComparisonComparer<Node>((x, y) =>
{
// first compare on depth
var depthComparison = x.Pointer.Depth.CompareTo(y.Pointer.Depth);
if (depthComparison != 0)
return depthComparison;
// next compare on order
return x.Order.CompareTo(y.Order);
}));
// create the parent leaf
var rootLeaf = Leaf.Create(context, navigationNode);
var leafSet = new List<Leaf> {rootLeaf};
// loop over the sorted set
foreach (var leafNode in sortedSet)
{
// find the parent leaf
var parentLeaf = leafSet.Single(candidate => candidate.Node.Pointer == leafNode.Pointer.Parent);
// create the leaf
var leaf = Leaf.Create(context, leafNode, parentLeaf);
if (leaf == null)
continue;
// add the leaf to the parent leaf
parentLeaf.Add(leaf);
// add the leaf to the set
leafSet.Add(leaf);
}
// find the deepest node who has an internal link and is parent of or equal to the current page pointer
var activeLeaf = ((IEnumerable<Leaf>) leafSet).Reverse().Where(x => x.HasTarget && (currentPagePointer.IsChildOf(x.TargetNode.Pointer) || currentPagePointer == x.TargetNode.Pointer)).FirstOrDefault();
if (activeLeaf != null)
activeLeaf.SetActive();
// return the parent leaf
return rootLeaf;
}
/// <summary>
/// Creates a new <see cref="NodeConnection"/>.
/// </summary>
/// <param name="to">Where this connection is going to</param>
/// <param name="collisionCategory">The <see cref="PathfindaxCollisionCategory"/> of this <see cref="NodeConnection"/></param>
public NodeConnection(NodePointer to, PathfindaxCollisionCategory collisionCategory = PathfindaxCollisionCategory.None)
{
To = to;
CollisionCategory = collisionCategory;
}
/// <summary>
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The <see cref="NodePointer"/>.</param>
/// <param name="depth">The depth from which to get the path.</param>
/// <returns>Returns the path.</returns>
public string Evaluate(IMansionContext context, NodePointer pointer, int depth)
{
return Evaluate(context, pointer, depth, " / ");
}
/// <summary>
/// Copies an existing node in this repository to a new node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be copied.</param>
/// <param name="targetParentPointer">The pointer to the parent to which the copied node is added.</param>
/// <returns>Returns the copied node.</returns>
protected override Node DoCopyNode(IMansionContext context, NodePointer pointer, NodePointer targetParentPointer)
{
// get the type of this node
var listeners = GetListeners(context, pointer.Type);
// fire the on before copy
var originalParentPointer = pointer.Parent;
foreach (var listener in listeners.OfType<NodeListener>())
listener.BeforeCopy(context, originalParentPointer, targetParentPointer, pointer);
// execute the derived class
var node = DecoratedRepository.CopyNode(context, pointer, targetParentPointer);
// fire the on after copy
foreach (var listener in listeners.OfType<NodeListener>())
listener.AfterCopy(context, originalParentPointer, targetParentPointer, node);
return node;
}
/// <summary>
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The <see cref="NodePointer"/>.</param>
/// <returns>Returns the path.</returns>
public string Evaluate(IMansionContext context, NodePointer pointer)
{
return Evaluate(context, pointer, 0);
}
/// <summary> /// Copies an existing node in this repository to a new node. /// </summary> /// <param name="context">The <see cref="IMansionContext"/>.</param> /// <param name="pointer">The pointer to the node which will be copied.</param> /// <param name="newParentPointer">The pointer to the parent to which the copied node is added.</param> /// <returns>Returns the copied node.</returns> protected abstract Node DoCopyNode(IMansionContext context, NodePointer pointer, NodePointer newParentPointer);
/// <summary>
/// Copies an existing node in this repository to a new node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be copied.</param>
/// <param name="newParentPointer">The pointer to the parent to which the copied node is added.</param>
/// <returns>Returns the copied node.</returns>
protected override Node DoCopyNode(IMansionContext context, NodePointer pointer, NodePointer newParentPointer)
{
// copy the node
var record = storageEngine.CopyNode(context, pointer, newParentPointer);
// index the record
foreach (var indexer in indexEngines)
indexer.Index(context, record);
// return the record
return record;
}
/// <summary>
/// Copies an existing node in this repository to a new node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be copied.</param>
/// <param name="targetParentPointer">The pointer to the parent to which the copied node is added.</param>
/// <returns>Returns the copied node.</returns>
protected override Node DoCopyNode(IMansionContext context, NodePointer pointer, NodePointer targetParentPointer)
{
// excute derived class
var node = DecoratedRepository.CopyNode(context, pointer, targetParentPointer);
// clear the cache for the given node
node.ClearFromCache(cachingService);
return node;
}
/// <summary>
/// Copies an existing node in this repository to a new node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be copied.</param>
/// <param name="targetParentPointer">The pointer to the parent to which the copied node is added.</param>
/// <returns>Returns the copied node.</returns>
protected override Node DoCopyNode(IMansionContext context, NodePointer pointer, NodePointer targetParentPointer)
{
// create a query to retrieve the new node
var selectQuery = new Query();
// build the query
using (var connection = CreateConnection())
using (var transaction = connection.BeginTransaction())
{
// retrieve the nodes
// TODO: retrieve the nodes within the same transaction
var nodeToCopy = RetrieveSingleNode(context, new Query().Add(new IsPropertyEqualSpecification("id", pointer.Id)));
if (nodeToCopy == null)
throw new ArgumentNullException(string.Format("Could not find node with pointer '{0}'", pointer));
var targetParentNode = RetrieveSingleNode(context, new Query().Add(new IsPropertyEqualSpecification("id", targetParentPointer.Id)));
if (targetParentNode == null)
throw new ArgumentNullException(string.Format("Could not find node with pointer '{0}'", targetParentPointer));
// create the copy query
using (var command = context.Nucleus.CreateInstance<CopyNodeCommand>())
{
// init the command
command.Prepare(context, connection, transaction, nodeToCopy, targetParentNode);
// execute the command
try
{
// execute the query
var copiedNodeId = command.Execute();
selectQuery.Add(new IsPropertyEqualSpecification("id", copiedNodeId));
// woohoo it worked!
transaction.Commit();
}
catch (Exception)
{
// something terrible happened, revert everything
transaction.Rollback();
throw;
}
}
}
// return the created node
return RetrieveSingleNode(context, selectQuery);
}
void Start()
{
// instances
nodePointer = GetComponent <NodePointer>();
lineRenderer = GetComponent <LineRenderer>();
}
/// <summary>
/// Copies an existing node in this repository to a new node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be copied.</param>
/// <param name="targetParentPointer">The pointer to the parent to which the copied node is added.</param>
/// <returns>Returns the copied node.</returns>
public Node CopyNode(IMansionContext context, NodePointer pointer, NodePointer targetParentPointer)
{
// validate arguments
if (context == null)
throw new ArgumentNullException("context");
if (pointer == null)
throw new ArgumentNullException("pointer");
if (targetParentPointer == null)
throw new ArgumentNullException("targetParentPointer");
CheckDisposed();
// invoke template method
return DoCopyNode(context, pointer, targetParentPointer);
}
private static List <DefinitionNode> FindPath(AstarNode[] pathfindingNetwork, AstarNode startNode, AstarNode targetNode, float neededClearance, PathfindaxCollisionCategory collisionCategory)
{
try
{
var sw = new Stopwatch();
sw.Start();
var pathSucces = false;
if (startNode == targetNode)
{
return(new List <DefinitionNode> {
targetNode.DefinitionNode
});
}
if (startNode.Clearance >= neededClearance && targetNode.Clearance >= neededClearance)
{
var openSet = new MaxHeap <AstarNode>(pathfindingNetwork.Length);
var closedSet = new HashSet <AstarNode>();
var itterations = 0;
var neighbourUpdates = 0;
openSet.Add(startNode);
while (openSet.Count > 0)
{
itterations++;
var currentNode = openSet.RemoveFirst();
closedSet.Add(currentNode);
if (currentNode == targetNode)
{
sw.Stop();
Debug.WriteLine($"NodePath found in {sw.ElapsedMilliseconds} ms. Itterations: {itterations} Neighbourupdates: {neighbourUpdates}");
pathSucces = true;
break;
}
foreach (var connection in currentNode.DefinitionNode.Connections)
{
var toNode = NodePointer.Dereference(connection.To, pathfindingNetwork);
if ((connection.CollisionCategory & collisionCategory) != 0 || closedSet.Contains(toNode))
{
continue;
}
if (toNode.Clearance >= neededClearance)
{
var newMovementCostToNeighbour = currentNode.GCost + GetDistance(currentNode.DefinitionNode, toNode.DefinitionNode) * currentNode.DefinitionNode.MovementCostModifier;
if (newMovementCostToNeighbour < toNode.GCost || !openSet.Contains(toNode))
{
toNode.GCost = newMovementCostToNeighbour;
toNode.HCost = GetDistance(toNode.DefinitionNode, targetNode.DefinitionNode);
toNode.Parent = currentNode.DefinitionNode.Index;
neighbourUpdates++;
if (!openSet.Contains(toNode))
{
openSet.Add(toNode);
}
}
}
}
}
}
if (pathSucces)
{
return(RetracePath(pathfindingNetwork, startNode, targetNode));
}
Debug.WriteLine("Did not find a path :(");
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
Debugger.Break();
return(null);
}
}
/// <summary>
/// Moves an existing node in this repository to a new parent node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be moved.</param>
/// <param name="newParentPointer">The pointer to the parent to which the node is moved.</param>
/// <returns>Returns the moved node.</returns>m
protected override Node DoMoveNode(IMansionContext context, NodePointer pointer, NodePointer newParentPointer)
{
return repository.MoveNode(context, pointer, newParentPointer);
}
/// <summary>
/// Moves an existing node in this repository to a new parent node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be moved.</param>
/// <param name="newParentPointer">The pointer to the parent to which the node is moved.</param>
/// <returns>Returns the moved node.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="context"/>, <paramref name="pointer"/> or <paramref name="newParentPointer"/> is null.</exception>
public Node MoveNode(IMansionContext context, NodePointer pointer, NodePointer newParentPointer)
{
// validate arguments
if (context == null)
throw new ArgumentNullException("context");
if (pointer == null)
throw new ArgumentNullException("pointer");
if (newParentPointer == null)
throw new ArgumentNullException("newParentPointer");
// invoke template method
return DoMoveNode(context, pointer, newParentPointer);
}
/// <summary>
/// Copies an existing node in this repository to a new node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be copied.</param>
/// <param name="targetParentPointer">The pointer to the parent to which the copied node is added.</param>
/// <returns>Returns the copied node.</returns>
protected override Node DoCopyNode(IMansionContext context, NodePointer pointer, NodePointer targetParentPointer)
{
return repository.CopyNode(context, pointer, targetParentPointer);
}
/// <summary>
/// Moves an existing node in this repository to a new parent node.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="pointer">The pointer to the node which will be moved.</param>
/// <param name="newParentPointer">The pointer to the parent to which the node is moved.</param>
/// <returns>Returns the moved node.</returns>m
protected override Node DoMoveNode(IMansionContext context, NodePointer pointer, NodePointer newParentPointer)
{
// build the query
using (var connection = CreateConnection())
using (var transaction = connection.BeginTransaction())
using (var command = context.Nucleus.CreateInstance<MoveNodeCommand>())
{
// init the command
command.Prepare(context, connection, transaction, pointer, newParentPointer);
// execute the command
try
{
// execute the query
command.Execute();
// woohoo it worked!
transaction.Commit();
}
catch (Exception)
{
// something terrible happened, revert everything
transaction.Rollback();
throw;
}
}
// return the moved node
var selectQuery = new Query().Add(new IsPropertyEqualSpecification("id", pointer.Id));
return RetrieveSingleNode(context, selectQuery);
}
