public void BreadthFirst_Smoke_Test()
{
var graph = new Graph <char>();
graph.AddVertex('A');
graph.AddVertex('B');
graph.AddVertex('C');
graph.AddVertex('D');
graph.AddVertex('E');
graph.AddVertex('F');
graph.AddVertex('G');
graph.AddVertex('H');
graph.AddVertex('I');
graph.AddEdge('A', 'B');
graph.AddEdge('B', 'C');
graph.AddEdge('C', 'D');
graph.AddEdge('D', 'E');
graph.AddEdge('E', 'F');
graph.AddEdge('F', 'G');
graph.AddEdge('G', 'H');
graph.AddEdge('H', 'I');
var algorithm = new BreadthFirst <char>();
Assert.IsTrue(algorithm.Find(graph, 'D'));
Assert.IsFalse(algorithm.Find(graph, 'M'));
}
public void BreadthFirst_AdjacencyListGraph_Smoke_Test()
{
var graph = new Advanced.Algorithms.DataStructures.Graph.AdjacencyList.Graph <char>();
graph.AddVertex('A');
graph.AddVertex('B');
graph.AddVertex('C');
graph.AddVertex('D');
graph.AddVertex('E');
graph.AddVertex('F');
graph.AddVertex('G');
graph.AddVertex('H');
graph.AddVertex('I');
graph.AddEdge('A', 'B');
graph.AddEdge('B', 'C');
graph.AddEdge('C', 'D');
graph.AddEdge('D', 'E');
graph.AddEdge('E', 'F');
graph.AddEdge('F', 'G');
graph.AddEdge('G', 'H');
graph.AddEdge('H', 'I');
var algorithm = new BreadthFirst <char>();
Assert.IsTrue(algorithm.Find(graph, 'D'));
Assert.IsFalse(algorithm.Find(graph, 'M'));
}
public void BreadthFirstPath()
{
var solver = new BreadthFirst <TestNode>(_start, _end);
solver.Run();
Assert.Multiple(() =>
{
CollectionAssert.AreEqual(
new List <TestNode> {
_testGraph.GetNode(0, 1), _testGraph.GetNode(0, 2), _testGraph.GetNode(0, 3), _testGraph.GetNode(0, 4), _testGraph.GetNode(0, 5), _testGraph.GetNode(0, 6), _testGraph.GetNode(0, 7), _testGraph.GetNode(1, 8), _testGraph.GetNode(2, 9), _testGraph.GetNode(3, 8), _testGraph.GetNode(4, 7), _testGraph.GetNode(5, 6), _testGraph.GetNode(6, 6), _testGraph.GetNode(7, 7), _testGraph.GetNode(8, 8), _testGraph.GetNode(9, 9)
},
solver.Path
);
CollectionAssert.AreEqual(
new List <TestNode> {
_testGraph.GetNode(7, 6)
},
solver.Open
);
CollectionAssert.AreEqual(
new List <TestNode> {
_testGraph.GetNode(0, 1), _testGraph.GetNode(1, 0), _testGraph.GetNode(1, 1), _testGraph.GetNode(0, 0), _testGraph.GetNode(0, 2), _testGraph.GetNode(1, 2), _testGraph.GetNode(2, 0), _testGraph.GetNode(2, 1), _testGraph.GetNode(2, 2), _testGraph.GetNode(0, 3), _testGraph.GetNode(1, 3), _testGraph.GetNode(2, 3), _testGraph.GetNode(3, 0), _testGraph.GetNode(3, 1), _testGraph.GetNode(3, 2), _testGraph.GetNode(3, 3), _testGraph.GetNode(0, 4), _testGraph.GetNode(4, 0), _testGraph.GetNode(4, 1), _testGraph.GetNode(4, 2), _testGraph.GetNode(4, 3), _testGraph.GetNode(0, 5), _testGraph.GetNode(1, 5), _testGraph.GetNode(5, 0), _testGraph.GetNode(5, 1), _testGraph.GetNode(5, 2), _testGraph.GetNode(5, 3), _testGraph.GetNode(0, 6), _testGraph.GetNode(1, 6), _testGraph.GetNode(2, 5), _testGraph.GetNode(2, 6), _testGraph.GetNode(6, 0), _testGraph.GetNode(6, 1), _testGraph.GetNode(6, 2), _testGraph.GetNode(6, 3), _testGraph.GetNode(6, 4), _testGraph.GetNode(0, 7), _testGraph.GetNode(1, 7), _testGraph.GetNode(7, 0), _testGraph.GetNode(7, 1), _testGraph.GetNode(7, 2), _testGraph.GetNode(7, 3), _testGraph.GetNode(7, 4), _testGraph.GetNode(2, 7), _testGraph.GetNode(0, 8), _testGraph.GetNode(1, 8), _testGraph.GetNode(8, 2), _testGraph.GetNode(8, 3), _testGraph.GetNode(8, 4), _testGraph.GetNode(6, 5), _testGraph.GetNode(2, 8), _testGraph.GetNode(3, 5), _testGraph.GetNode(3, 6), _testGraph.GetNode(3, 7), _testGraph.GetNode(0, 9), _testGraph.GetNode(1, 9), _testGraph.GetNode(2, 9), _testGraph.GetNode(9, 2), _testGraph.GetNode(9, 3), _testGraph.GetNode(9, 4), _testGraph.GetNode(3, 8), _testGraph.GetNode(3, 9), _testGraph.GetNode(4, 7), _testGraph.GetNode(4, 8), _testGraph.GetNode(4, 9), _testGraph.GetNode(4, 6), _testGraph.GetNode(5, 6), _testGraph.GetNode(5, 7), _testGraph.GetNode(5, 8), _testGraph.GetNode(5, 9), _testGraph.GetNode(6, 6), _testGraph.GetNode(6, 7), _testGraph.GetNode(6, 8), _testGraph.GetNode(6, 9), _testGraph.GetNode(7, 7), _testGraph.GetNode(7, 8), _testGraph.GetNode(7, 9), _testGraph.GetNode(8, 6), _testGraph.GetNode(8, 7), _testGraph.GetNode(8, 8), _testGraph.GetNode(8, 9), _testGraph.GetNode(9, 6), _testGraph.GetNode(9, 7), _testGraph.GetNode(9, 8), _testGraph.GetNode(9, 9)
},
solver.Closed
);
Assert.AreEqual(16.0d, Math.Round(solver.PathCost));
});
}
public void GraphCannotBeNull()
{
typeof(BreadthFirst).Invoking(_ =>
BreadthFirst.VisitAll(null, NodeIdentity.Of("A")).ToList())
.Should().Throw <ArgumentNullException>()
.Which.ParamName.Should().Be("graph");
}
public void CanCountNodesDepth()
{
// Arrange
Tree <string> tree = new Tree <string>();
Node <string> root = new Node <string>("a");
Node <string> b = new Node <string>("b");
Node <string> c = new Node <string>("c");
Node <string> d = new Node <string>("d");
Node <string> e = new Node <string>("e");
Node <string> f = new Node <string>("f");
Node <string> g = new Node <string>("g");
Node <string> h = new Node <string>("h");
Node <string> i = new Node <string>("i");
tree.Root = root;
root.LeftChild = b;
root.RightChild = c;
b.LeftChild = d;
b.RightChild = e;
c.LeftChild = f;
c.RightChild = g;
d.LeftChild = h;
d.RightChild = i;
// Act
int result = BreadthFirst.NodeDepths(root);
// Assert
Assert.Equal(16, result);
}
public void Dijkstra_Solves_Raw_Data(int mapId, int xStart, int yStart, int xGoal, int yGoal, int expectedLength)
{
byte[,] map = mapId == 0 ? m_Map_0 : m_Map_1;
List <Vector2Int> accessibles = new List <Vector2Int>();
//We flip the array values to match horizontal values with X coords and vertical values with Y coords
//So (0 , 0) coords starts from the bottom left and not from the top left and Y coords from bottom to top and not
//from top to bottom as the default indexing 2D array system.
for (int iRun = map.GetLength(0) - 1, i = 0; iRun >= 0; iRun--, i++)
{
for (int j = 0; j < map.GetLength(1); j++)
{
if (map[iRun, j] == 0)
{
accessibles.Add(new Vector2Int(j, i));
}
}
}
IPathFinder pathFinder = new BreadthFirst(accessibles); //<-- TODO: Create Dijsktra pathfinder class here, TIP-->> Use accessible tiles
IEnumerable <Vector2Int> path = pathFinder.FindPath(new Vector2Int(xStart, yStart), new Vector2Int(xGoal, yGoal));
Assert.AreEqual(expectedLength, path.Count());
}
public void whenDoBreadthFirstSearchInTheGraphShouldEqualToResult()
{
var bfs = new BreadthFirst <int>();
var bfsresult = bfs.search(graph);
Assert.Equal("0 1 2 4 3 ", bfsresult);
}
public override void EndState()
{
if (Agent.WalkPath.Count > 1)
{
bool endAutoWalk = false;
BreadthFirst enemyScan = new BreadthFirst();
enemyScan.Search(Agent.CurrentNode, Agent.HighlighterRadius + 1);
if (enemyScan.Done && enemyScan.Nodes != null)
{
foreach (var node in enemyScan.Nodes)
{
if (node.HasEnemy)
{
endAutoWalk = true;
break;
}
}
}
if (endAutoWalk == false)
{
Agent.WalkPath.RemoveAt(0);
}
else
{
Agent.WalkPath = null;
}
}
else
{
Agent.WalkPath = null;
}
}
public void CanCountTreeNodesBreadth()
{
// Arrange
Tree <string> tree = new Tree <string>();
Node <string> root = new Node <string>("a");
Node <string> b = new Node <string>("b");
Node <string> c = new Node <string>("c");
Node <string> d = new Node <string>("d");
Node <string> e = new Node <string>("e");
Node <string> f = new Node <string>("f");
Node <string> g = new Node <string>("g");
tree.Root = root;
root.LeftChild = b;
root.RightChild = c;
b.LeftChild = d;
b.RightChild = e;
c.LeftChild = f;
c.RightChild = g;
// Act
int result = BreadthFirst.CountTreeNodesBreath(tree);
// Assert
Assert.Equal(7, result);
}
public BattleManager()
{
tilesManager = new BattleTilesManager();
calculateManager = new BattleCalculateManager();
aiManager = new AIManager();
breadthFirst = new BreadthFirst();
}
private void RunBuntton_ItemClick(object sender, ItemClickEventArgs e)
{
if (_dGraph == null) //|| _dGraph.Vertices.Any(v => v.Visited))
{
MessageBox.Show("Загрузите новый лабиринт!", "Warning", MessageBoxButtons.OK,
MessageBoxIcon.Warning);
return;
}
//запускаем параллельно все наши алгоритмы
if (dijkstraButton.Down)
{
Task.Run(() => DijkstraAlgorithm.Execute(_dGraph, dijkstraPanel, dijkstraFirst, dijkstraBest));
return;
}
if (bfsButton.Down)
{
Task.Run(() => BreadthFirst.Execute(_bGraph, bFirstPanel, bfFirst, bfBest));
return;
}
if (astarButton.Down)
{
Task.Run(() => AStar.Execute(_aGraph, aStarPanel, asFirst, asBest));
return;
}
Task.Run(() => DijkstraAlgorithm.Execute(_dGraph, dijkstraPanel, dijkstraFirst, dijkstraBest));
Task.Run(() => BreadthFirst.Execute(_bGraph, bFirstPanel, bfFirst, bfBest));
Task.Run(() => AStar.Execute(_aGraph, aStarPanel, asFirst, asBest));
}
public void StartCannotBeNull()
{
typeof(BreadthFirst).Invoking(_ =>
BreadthFirst.VisitAll(CreateSimpleGraph(), null).ToList())
.Should().Throw <ArgumentNullException>()
.Which.ParamName.Should().Be("start");
}
private bool Solve(string selectedAlgorithm)
{
TraversalType TraversalType = null;
switch (selectedAlgorithm)
{
case "BreadthFirst":
TraversalType = new BreadthFirst(_Map);
break;
case "DepthFirst":
TraversalType = new DepthFirst(_Map);
break;
case "DeadEndFill":
TraversalType = new DeadEndFill(_Map);
break;
case "FibonacciHeap":
break;
case "LeftTurn":
break;
default:
break;
}
return(TraversalType.Solve());
}
public void ReturnsEmptyPathIfNoPathIsFound()
{
var path = (object)BreadthFirst.FindPath(CreateSimpleGraph(),
NodeIdentity.Of("A"),
node => node == NodeIdentity.Of("notfound"));
path.Should().Be(Path.Empty);
}
public void BreadthFirstTraversal()
{
const string result = "ABCDEFG";
// TODO replace me with your implementation of a breadth-first traverser
ITraverser traverser = new BreadthFirst();
Assert.AreEqual(result, traverser.Traverse(BT));
}
private void Start()
{
grid = GetComponent <Grid>();
astar = new AStar();
breadthFirst = new BreadthFirst();
depthFirst = new DepthFirst();
dijkstra = new Dijkstra();
greedyBfs = new GreedyBestFirst();
}
public void CanFindStraightPath()
{
BreadthFirst.FindPath(GraphFactory.BuildGraph("A-B", "B-C", "C-D"), NodeIdentity.Of("A"), node => node == NodeIdentity.Of("D"))
.Should().ContainInOrder(
NodeIdentity.Of("A"),
NodeIdentity.Of("B"),
NodeIdentity.Of("C"),
NodeIdentity.Of("D")
).And.HaveCount(4);
}
public void DoesNotVisitDisconnectedNodes()
{
BreadthFirst.VisitAll(
GraphFactory.BuildGraph("A-B", "C-D"), NodeIdentity.Of("A"))
.Should()
.ContainInOrder(
NodeIdentity.Of("A"),
NodeIdentity.Of("B")
).And.HaveCount(2);
}
public void VisitsNodesInOrder()
{
BreadthFirst.VisitAll(CreateSimpleGraph(), NodeIdentity.Of("A"))
.Should().ContainInOrder(
NodeIdentity.Of("A"),
NodeIdentity.Of("B1"),
NodeIdentity.Of("B2"),
NodeIdentity.Of("C1"),
NodeIdentity.Of("C2")
).And.HaveCount(5);
}
public void FindsShortestPath()
{
BreadthFirst.FindPath(
GraphFactory.BuildGraph("A-B", "B-C", "C-D", "A-D"),
NodeIdentity.Of("A"),
node => node == NodeIdentity.Of("D"))
.Should().ContainInOrder(
NodeIdentity.Of("A"),
NodeIdentity.Of("D")
).And.HaveCount(2);
}
// throws jjtraveler.VisitFailure
public virtual void testBreadthFirst()
{
Identity id = new Identity();
Logger expected = new Logger(id, new IVisitable[]{n4, n3, n2, n0, n1} );
BreadthFirst bf = new BreadthFirst( logVisitor(id) );
IVisitable resultNode = bf.visit(n4);
Assertion.AssertEquals(expected, logger);
Assertion.AssertEquals(resultNode, n4);
}
static void StartBreadthFirst(int initstate)
{
try
{
BreadthFirst o = new BreadthFirst(initstate);
Console.Write("\rBreadth First Search starts . . . Please wait");
o.Solve();
}
catch (Exception e)
{
HandleException(e);
}
}
public void VertexDoesNotExist()
{
// Arrange
var graph = new Graph <char>();
graph.AddVertex('A');
graph.AddVertex('B');
graph.AddEdge('A', 'B');
var breadthFirst = new BreadthFirst <char>();
// Act & Assert
Assert.False(breadthFirst.Find(graph, 'X'));
}
public void Test()
{
// Arrange
var graph = new Graph <char>();
graph.AddVertex('A');
graph.AddVertex('B');
graph.AddVertex('C');
graph.AddVertex('D');
graph.AddEdge('A', 'B');
graph.AddEdge('B', 'C');
graph.AddEdge('C', 'D');
var breadthFirst = new BreadthFirst <char>();
// Act & Assert
Assert.True(breadthFirst.Find(graph, 'A'));
}
public static Path Extend(this Path firstPath, Path secondPath, DirectedGraph graph)
{
ArgumentHelpers.ThrowIfNull(() => firstPath);
ArgumentHelpers.ThrowIfNull(() => secondPath);
ArgumentHelpers.ThrowIfNull(() => graph);
var overlap = OverlapFinder.FindOverlap(firstPath, secondPath);
if (!Path.IsEmpty(overlap))
{
return(overlap);
}
var shortestPath = BreadthFirst.FindPath(graph, firstPath.End, node => node == secondPath.Start);
if (Path.IsEmpty(shortestPath))
{
return(Path.Empty);
}
return(Path.Join(firstPath, Path.Of(shortestPath.GetRange(1, shortestPath.Length - 2)), secondPath));
}
private void RunAlgorithm(string _algoName, Graph _graph)
{
// Variables
DateTime beginning;
DateTime end;
TimeSpan duration;
Algorithm algo = null;
// Création de l'algorithme
switch (_algoName)
{
case "Depth-First":
algo = new DepthFirst(_graph, this); // Algorithm(Graph _graph, IHM _ihm).
break;
case "Breadth-First":
algo = new BreadthFirst(_graph, this);
break;
case "Bellman-Ford":
algo = new BellmanFord(_graph, this);
break;
case "Dijkstra":
algo = new Dijkstra(_graph, this);
break;
case "A*":
algo = new AStar(_graph, this);
break;
}
// Résolution
Console.Out.WriteLine("Algorithme : " + _algoName);
beginning = DateTime.Now;
algo.Solve();
end = DateTime.Now;
duration = end - beginning;
Console.Out.WriteLine("Durée (ms) : " + duration.TotalMilliseconds.ToString() + "\n");
}
public override void Start()
{
_exitingIdle = false;
Manager.RemoveDeadEnemies();
BreadthFirst enemyScan = new BreadthFirst();
enemyScan.Search(Manager.GetPlayerAgent().CurrentNode, Manager.GetPlayerAgent().HighlighterRadius + 1); //Scan for enemies in given range
if (enemyScan.Done && enemyScan.Nodes != null)
{
HashSet <EnemyAgent> currentEnemies = Manager.GetEnemyHashSet();
foreach (var node in enemyScan.Nodes)
{
if (node.HasEnemy)
{
EnemyAgent enemy = (node.Occupant as EnemyAgent);
if (enemy != null)
{
if (!currentEnemies.Contains(enemy))
{
Debug.Log("Enemy " + enemy.AgentName + " has been successfully added!");
Manager.AddEnemy(enemy);
}
else
{
Debug.Log("Enemy " + enemy.AgentName + " already was an enemy!");
}
}
else
{
Debug.Log("Something went wrong while adding the enemy to the gamephase");
}
}
}
}
}
private void MoveEnemy(List <GameEntity> enemies, GameEntity player, Dictionary <Vector2Int, TileType> map)
{
enemies.ForEach(enemy => {
PathNode result = BreadthFirst.GetRoute(enemy.gridCoordinate.value, player.gridCoordinate.value, map, 4);
if (result != null)
{
enemy.ReplacePosition(result.GetFirstStep());
enemy.ReplaceGridCoordinate(result.GetFirstStep());
}
else
{
Vector2Int randomPos = new List <Vector2Int> {
enemy.gridCoordinate.value + Vector2Int.up,
enemy.gridCoordinate.value + Vector2Int.down,
enemy.gridCoordinate.value + Vector2Int.left,
enemy.gridCoordinate.value + Vector2Int.right
}.FindAll(pos => IsFloorTile(pos, map)).RandomItem();
enemy.ReplacePosition(randomPos);
enemy.ReplaceGridCoordinate(randomPos);
}
enemy.isMoveCompleted = true;
});
}
private void RebuildMaze(VertexLinker builder)
{
Debug.Log("rebuilding " + builder.ToString());
PolarGrid maze = (PolarGrid)target;
maze.Graph.ClearLinks();
builder.Build(new VertexLinkerHelper(maze.Graph, maze.AdjacentGraph));
EditorUtility.SetDirty(maze);
BreadthFirst bf = new BreadthFirst(maze.Graph, 0);
bf.Run();
int[] distances = bf.Distances;
float maxDistance = (float)bf.MaxDistance;
Color nearColor = Color.red;
Color farColor = Color.black;
Color[] distanceColors = System.Array.ConvertAll <int, Color>(
distances, distance => Color.Lerp(nearColor, farColor, (distance / maxDistance))
);
image.Draw(maze, distanceColors);
}
private void Start()
{
_breadthFirst = new BreadthFirst();
_highlights = new List <GameObject>();
}
private void Run()
{
// 1st map
String mapStr = ".. XX .\n"
+ "*. *X *.\n"
+ " . XX ...\n"
+ " .* X *.* \n"
+ " ...=... \n"
+ " .* X \n"
+ " . XXX* \n"
+ " . * = \n"
+ " .... XX \n"
+ " *. X* ";
Map map = new Map(mapStr, 0, 0, 9, 9);
Algorithm algo = new DepthFirst(map, this);
algo.Solve();
Console.WriteLine();
algo = new BreadthFirst(map, this);
algo.Solve();
Console.WriteLine();
algo = new BellmanFord(map, this);
algo.Solve();
Console.WriteLine();
algo = new Dijkstra(map, this);
algo.Solve();
Console.WriteLine();
algo = new AStar(map, this);
algo.Solve();
Console.WriteLine();
// 2nd map
mapStr = "...* X .* * \n"
+ " *..* *X .........\n"
+ " . = *.* *.\n"
+ " *. * XXXX . .\n"
+ "XXX=XX X *XX=XXX*.\n"
+ " *.*X = X*. X \n"
+ " . X * X X . *X* \n"
+ "* .*XX=XX *X . XXXX\n"
+ " .... .... X . X \n"
+ " . *....* . X*. = * ";
map = new Map(mapStr, 0, 0, 9, 19);
algo = new DepthFirst(map, this);
algo.Solve();
Console.WriteLine();
algo = new BreadthFirst(map, this);
algo.Solve();
Console.WriteLine();
algo = new BellmanFord(map, this);
algo.Solve();
Console.WriteLine();
algo = new Dijkstra(map, this);
algo.Solve();
Console.WriteLine();
algo = new AStar(map, this);
algo.Solve();
Console.WriteLine();
Console.ReadKey();
}
private (List <Position>, List <Position>) BFS(Position a, Position b)
{
BreadthFirst bfsSearch = new BreadthFirst();
return(bfsSearch.Search(a, b, grid));
}
