Esempio n. 1
0
    // Use this for initialization
    void Start()
    {
        Graph g = new Graph();

        for (int i = 1; i < 6; i++)
        {
            g.AddNode(i);
        }

        g.AddEdge(1, 2);
        g.AddEdge(1, 3);
        g.AddEdge(2, 4, 7);
        g.AddEdge(4, 5);
        g.AddEdge(3, 5, 5f);


        List <GraphEdge> path;

        GraphSearch.Dijkstra(g, g.GetNode(1), g.GetNode(5), out path);
        float cost = 0;

        foreach (GraphEdge e in path)
        {
            Debug.Log(e.from.index + " - " + e.to.index);
            cost += e.cost;
        }
        Debug.Log("Total Cost: " + cost);
    }
Esempio n. 2
0
 public void trim()
 {
     GraphSearch.fromPosition(Size_x / 2, Size_y / 2)
     .DepthFirstFlood(Map_data_passable, GraphSearch.DefaultPassable, new ActionOnVisit(MarkOneAsTwo));
     for (int i = 0; i < Size_x; i++)
     {
         for (int j = 0; j < Size_y; j++)
         {
             if (Map_data_passable[i, j] == 1)
             {
                 Map_data_passable[i, j] = 0;
             }
         }
     }
     for (int i = 0; i < Size_x; i++)
     {
         for (int j = 0; j < Size_y; j++)
         {
             if (Map_data_passable[i, j] == 2)
             {
                 Map_data_passable[i, j] = 1;
             }
         }
     }
 }
        public GraphCycleEdgeVisitor(GraphSearch <V, E> search)
        {
            parent = new Dictionary <IVertex <V>, IVertex <V> >();
            Search = search;

            HasCycle = false;
        }
 public override int Compare(Unit x, Unit y)
 {
     return((int)((GraphSearch.fromPosition(x.Map_position_x, x.Map_position_y)
                   .manhattanDistanceFromTarget(GameTools.Player.Map_position_x, GameTools.Player.Map_position_y)
                   - GraphSearch.fromPosition(y.Map_position_x, y.Map_position_y)
                   .manhattanDistanceFromTarget(GameTools.Player.Map_position_x, GameTools.Player.Map_position_y)) * 100.0f));
 }
 private void MoveDroidToSecurityCheckpoint(Droid droid, ShipGraph shipGraph)
 {
     var(path, _) = GraphSearch.Dijkstra(shipGraph, droid.Room, "== Security Checkpoint ==");
     foreach (var nextRoom in path)
     {
         droid.TakeDoor((Direction)shipGraph.GetDoorDirection(droid.Room, nextRoom));
     }
 }
Esempio n. 6
0
        public List <VacancyPersonApplication> ConsultVacancyApplications(int vacancyId)
        {
            Vacancy vacancyInfo = _vacanciesRepository.VacancyConsult(vacancyId);

            List <VacancyPersonApplication> applications = _applicationsRepository.ConsultApplications(vacancyId);

            Graph graph  = new Graph();
            var   search = new GraphSearch();

            graph.AddPoint("A");
            graph.AddPoint("B");
            graph.AddPoint("C");
            graph.AddPoint("D");
            graph.AddPoint("E");
            graph.AddPoint("F");



            graph.AddConnection("A", "B", 5);
            graph.AddConnection("B", "C", 7);
            graph.AddConnection("B", "D", 3);
            graph.AddConnection("C", "E", 4);
            graph.AddConnection("D", "E", 10);
            graph.AddConnection("D", "F", 8);

            var Alldistances = search.FindAllRouteFromTheStart(graph, vacancyInfo.Location);

            foreach (VacancyPersonApplication vacancyPersonApplication in applications)
            {
                double distance = Alldistances[vacancyPersonApplication.Location];

                int N = 100 - 25 * (vacancyInfo.Level - vacancyPersonApplication.Level);

                int D = 0;

                if (distance <= 20 && distance > 15)
                {
                    D = 25;
                }
                else if (distance <= 15 && distance > 10)
                {
                    D = 50;
                }
                else if (distance <= 10 && distance > 5)
                {
                    D = 75;
                }
                else if (distance <= 5 && distance >= 0)
                {
                    D = 100;
                }

                vacancyPersonApplication.Score = (N + D) / 2;
            }

            return(applications.OrderByDescending(i => i.Score).ToList());
        }
Esempio n. 7
0
 bool transitionInAttackRange()
 {
     return(GraphSearch
            .fromPosition(unit.Map_position_x, unit.Map_position_y)
            .manhattanDistanceFromTarget(GameTools.Player.Map_position_x, GameTools.Player.Map_position_y) <= unit.MainSpell.CastRange ||
            GraphSearch
            .fromPosition(unit.Map_position_x, unit.Map_position_y)
            .manhattanDistanceFromTarget(GameTools.Base.Map_position_x, GameTools.Base.Map_position_y) <= unit.MainSpell.CastRange);
 }
 public static GraphSearch fromPosition(int x1, int y1)
 {
     if (instance == null)
     {
         instance = new GraphSearch();
     }
     x = x1;
     y = y1;
     return(instance);
 }
Esempio n. 9
0
        public void BreadthFirstSearchTest()
        {
            //Arrange
            var graph  = new Graph <int>(vertices, edges);
            var search = new GraphSearch();
            //Act
            string result = new StringBuilder(string.Join(", ", search.BreadthFirstSearch(graph, 1))).ToString();

            // Assert
            Assert.Equal("1, 2, 3, 4, 5, 6, 7, 8, 9, 10", result);
        }
Esempio n. 10
0
        private GraphSearch BuildSearch(IEnumerable <TrustModel> trusts)
        {
            var graphService = new GraphContext();
            var builder      = new GraphBuilder(graphService);

            builder.Build(trusts);


            var search = new GraphSearch(graphService);

            return(search);
        }
Esempio n. 11
0
        private void ButtonSolveClick(object sender, RoutedEventArgs e)
        {
            if (_currentPolyLine.Points.Count >= 2)
            {
                _currentPolyLine.Points.Add(_currentPolyLine.Points[0]);
            }

            var initialState = new PathFindingState(new Search.Types.Point(100, 100));
            var goalState    = new PathFindingState(new Search.Types.Point(800, 600));

            var environment = new PathFindingEnvironment();

            foreach (var polyLine in _polyLines)
            {
                var points = polyLine.Points.Select(p => p).Distinct().ToList();
                for (int i = 0; i < points.Count; i++)
                {
                    for (int j = i + 1; j < points.Count; j++)
                    {
                        if (i == j)
                        {
                            continue;
                        }

                        var pointLine = new PointLine(
                            new Point(points[i].X, points[i].Y),
                            new Point(points[j].X, points[j].Y));

                        environment.PointLines.Add(pointLine);
                    }
                }
            }

            var actionFunction  = new PathFindingActionFunction(environment, goalState);
            var resultFunction  = new PathFindingResultFunction();
            var goalTest        = new PathFindingGoalTest(goalState);
            var stepCost        = new PathFindingStepCost();
            var searchAlgorithm = new GraphSearch <PathFindingState, PathFindingAction>();

            var problem = new Problem <PathFindingState, PathFindingAction>(initialState, actionFunction, resultFunction, goalTest, stepCost);

            var solution = searchAlgorithm.Search(problem);

            for (int i = 1; i < solution.Count; i++)
            {
                AddLine(
                    solution[i - 1].State.Point.X,
                    solution[i - 1].State.Point.Y,
                    solution[i].State.Point.X,
                    solution[i].State.Point.Y);
            }
        }
Esempio n. 12
0
        public void ShortestPath()
        {
            //Arrange
            var graph  = new Graph <int>(vertices, edges);
            var search = new GraphSearch();
            //Act
            var    result       = search.ShortestPath(graph, 1);
            string shortestPath = string.Empty;

            // Assert
            shortestPath = (string.Join(", ", result(7)));
            Assert.Equal("1, 2, 4, 7", shortestPath);
        }
Esempio n. 13
0
    public void FindAttackRange()
    {
        GraphSearch mSearch = new GraphSearch(mTileMap.MapInfo.mGraph);

        mSearch.AttackRange(mPositionX, mPositionY, mRange);
        mAttackRangeList = mSearch.GetCloseList();
        //int positionIndex = mTileMap.MapInfo.XYToIndex (mPositionX, mPositionY);
        mAttackRangeList.RemoveAt(0);
        foreach (Node i in mAttackRangeList)
        {
            int index = i.mIndex;
            DTileMap.TileType temp = mTileMap.MapInfo.GetTileTypeIndex(index);
            if (temp == DTileMap.TileType.Player1)
            {
                mAttackList.Add(DTileMap.TileType.Player1);
                mAttackPosition.Add(mTileMap.MapInfo.GetTileLocationIndex(index));
            }
            else if (temp == DTileMap.TileType.Player2)
            {
                mAttackList.Add(DTileMap.TileType.Player2);
                mAttackPosition.Add(mTileMap.MapInfo.GetTileLocationIndex(index));
            }
            else if (temp == DTileMap.TileType.Player3)
            {
                mAttackList.Add(DTileMap.TileType.Player3);
                mAttackPosition.Add(mTileMap.MapInfo.GetTileLocationIndex(index));
            }
            else if (temp == DTileMap.TileType.Player4)
            {
                mAttackList.Add(DTileMap.TileType.Player4);
                mAttackPosition.Add(mTileMap.MapInfo.GetTileLocationIndex(index));
            }
            else if (temp == DTileMap.TileType.Target1)
            {
                mAttackList.Add(DTileMap.TileType.Target1);
                mAttackPosition.Add(mTileMap.MapInfo.GetTileLocationIndex(index));
            }
            else if (temp == DTileMap.TileType.Target2)
            {
                mAttackList.Add(DTileMap.TileType.Target2);
                mAttackPosition.Add(mTileMap.MapInfo.GetTileLocationIndex(index));
            }
            else if (temp == DTileMap.TileType.Target3)
            {
                mAttackList.Add(DTileMap.TileType.Target3);
                mAttackPosition.Add(mTileMap.MapInfo.GetTileLocationIndex(index));
            }
        }
    }
Esempio n. 14
0
        public void GraphSearchPerformanceTest()
        {
            int   graphSize = 1024;
            int   iteration = 100;
            float density   = 0.5f;

            PathGrid graph = new PathGrid(0, 0, graphSize, graphSize, graphSize, graphSize);

            var picks = new int[graphSize * graphSize];

            for (int i = 0; i < picks.Length; ++i)
            {
                picks[i] = i;
            }

            Random random        = new Random(0);
            int    obstacleCount = (int)(density * graphSize * graphSize);

            while (obstacleCount > 0)
            {
                var i = random.Next(obstacleCount);
                graph.Mark(picks[i] % graphSize, picks[i] / graphSize);
                obstacleCount--;
                picks[i] = picks[obstacleCount];
            }
            int walkables = picks.Length - obstacleCount;


            GraphSearch search = new GraphSearch();
            List <int>  result = new List <int>();

            int[] array = new int[graphSize * graphSize];

            GC.Collect();
            Stopwatch watch = new Stopwatch();

            watch.Start();

            for (int i = 0; i < iteration; ++i)
            {
                result.Clear();
                search.Search(graph, picks[random.Next(walkables)], picks[random.Next(walkables)], result);
            }

            watch.Stop();

            Trace.WriteLine("Max searches per frame (60 FPS): " + iteration / watch.Elapsed.TotalSeconds / 60.0);
        }
    public void solveLab(string algorithm)
    {
        FrameWork myProblem = new FrameWork(colorsMatrixNormalized, Int32.Parse(nSize.text));

        foreach (var element in myProblem.initialStates)
        {
            Debug.Log(element[0] + ", " + element[1] + " 2");
        }
        GraphSearch  graph = new GraphSearch(myProblem, 1);
        List <int[]> path  = graph.JustDoIt();

        foreach (var element in path)
        {
            Debug.Log(element[0] + ", " + element[1]);
        }
    }
Esempio n. 16
0
        private static void TestBfsDirectedSmallGraph(string path)
        {
            IDirectedGraph <int> graph = null;

            using (var reader = new StreamReader(path))
            {
                graph = GraphHelper.ParseFromTextDirectedGraph(reader, saveReversedVersion: false);
                Console.WriteLine("Graph initiated!");
                Console.WriteLine(graph);
            }

            foreach (int exploredNode in GraphSearch.BreadthFirst(graph, 1))
            {
                Console.WriteLine(exploredNode);
            }
        }
    protected override void InitMapPosition()
    {
        if (Map_position_x == 0 && Map_position_y == 0)
        {
            Map_position_x = Random.Range(0, GameTools.Map.size_x);
            Map_position_y = Random.Range(0, GameTools.Map.size_z);

            while (GameTools.Map.map_unit_occupy[Map_position_x, Map_position_y] != null ||
                   (!TileTools.IsLand(GameTools.Map.TileMapData[Map_position_x, Map_position_y])) ||
                   GraphSearch.fromPosition(Map_position_x, Map_position_y).manhattanDistanceFromTarget(GameTools.Player.Map_position_x, GameTools.Player.Map_position_y) < 10)
            {
                Map_position_x = Random.Range(0, GameTools.Map.size_x);
                Map_position_y = Random.Range(0, GameTools.Map.size_z);
            }
        }
    }
Esempio n. 18
0
        private static void TestShortestPath(string path)
        {
            IDirectedGraph <int> graph = null;

            using (var reader = new StreamReader(path))
            {
                graph = GraphHelper.ParseFromTextDirectedGraph(reader, saveReversedVersion: false);
                Console.WriteLine("Graph initiated!");
                Console.WriteLine(graph);
            }

            int startVertex = 1, endVertex = 9;
            var shortestPath = GraphSearch.ComputeShortestPath(graph, startVertex, endVertex);

            Console.WriteLine($"Shortest path in graph from vertex {startVertex} to {endVertex} is {shortestPath}");
        }
Esempio n. 19
0
        private static List <int> TestDijkstraSearch(string path)
        {
            IDirectedWeightedGraph <int> graph;

            using (var reader = new StreamReader(path))
            {
                graph = GraphHelper.ParseFromTextDirectedWeightedGraph(reader);
            }

            int[] result = GraphSearch.DijkstraMinHeap(graph, 1);

            int[] requiredPaths = { 7, 37, 59, 82, 99, 115, 133, 165, 188, 197 };

            return(requiredPaths.Select(i => result[i])
                   .ToList());
        }
Esempio n. 20
0
        public void GreedyGraphSearch()
        {
            // Arrange
            var problem = new TriForkTestProblem();
            var search = new GraphSearch<TestState>(new GreedySearchFringe<TestState>(new TestStateHuristic()), new TestStateEqualityComparer());

            // Act
            var result = search.Execute(problem);

            // Assert
            var expanded = problem.Expanded.Select(s => s.Node.Name);
            var resultPath = result.Path.Select(n => n.Name);

            Assert.Equal(new[] { "Start", "B" }, expanded);
            Assert.Equal(new[] { "Start", "B", "Goal" }, resultPath);
        }
 public int GetDistance(string from, string to)
 {
     if (!distanceMatrix.TryGetValue(from, out var nextDict))
     {
         distanceMatrix[from] = new Dictionary <string, int>();
     }
     if (!distanceMatrix[from].TryGetValue(to, out var distance))
     {
         var(_, dist)             = GraphSearch.Dijkstra(this, from, to);
         distanceMatrix[from][to] = dist;
         return(dist);
     }
     else
     {
         return(distance);
     }
 }
Esempio n. 22
0
        public string Solve()
        {
            var graph           = GetDirectedGraphFromSccInput();
            var componentsSizes = new List <int>();

            var searcher            = new GraphSearch(InputMaxNodeNumber);
            var connectedComponents = searcher.KasarajuFindSccs(graph);

            foreach (var component in connectedComponents)
            {
                componentsSizes.Add(component.Count);
            }

            componentsSizes.Sort();
            componentsSizes.Reverse();

            var topFiveComponents = componentsSizes.Take(5).ToArray();

            return(string.Join(", ", topFiveComponents));
        }
Esempio n. 23
0
    public void FindWalkRange(int movement)
    {
        GraphSearch mSearch = new GraphSearch(mTileMap.MapInfo.mGraph);

        mSearch.RangeSearch(mPositionX, mPositionY, movement);
        mWalkRangeList = mSearch.GetCloseList();
        foreach (Node i in mWalkRangeList)
        {
            int index = i.mIndex;
            DTileMap.TileType temp = mTileMap.MapInfo.GetTileTypeIndex(index);
            if (temp == DTileMap.TileType.Floor)
            {
                mTileMap.MapInfo.SetTileTypeIndex(index, DTileMap.TileType.Walkable, true);
            }
            if (temp == DTileMap.TileType.Sewer)
            {
                mTileMap.MapInfo.SetTileTypeIndex(index, DTileMap.TileType.TrueSewer, true);
            }
        }
    }
Esempio n. 24
0
        private static void TestFindStronglyConnectedComponents(string path)
        {
            IDirectedGraphWithReversed <int> graph;

            using (var reader = new StreamReader(path))
            {
                graph = GraphHelper.ParseFromTextDirectedGraph(reader, saveReversedVersion: true);
            }

            var results     = GraphSearch.FindStronglyConnectedComponents(graph);
            var biggestSccs = results.OrderByDescending(r => r.Count)
                              .Take(6)
                              .ToList();

            Console.WriteLine($"Strongly connected components number - {biggestSccs.Count}!");
            for (var i = 0; i < biggestSccs.Count; i++)
            {
                var sccVertices = biggestSccs[i];
                Console.WriteLine($"SCC #{i+1}: {sccVertices.Count}");
            }
        }
Esempio n. 25
0
        private static void TestDfs(string path)
        {
            IDirectedGraph <int> graph = null;

            using (var reader = new StreamReader(path))
            {
                graph = GraphHelper.ParseFromTextDirectedGraph(reader, saveReversedVersion: false);
                Console.WriteLine("Graph initiated!");
                Console.WriteLine(graph);
            }

            int startVertex = 1;

            Console.WriteLine($"Dfs result. Start vertex - {startVertex}");
            var result = GraphSearch.DepthFirst(graph, 1);

            foreach (int node in result)
            {
                Console.WriteLine(node);
            }
        }
Esempio n. 26
0
    //Path Find Parts
    List <Node> PathFind(int startX, int startY, int endX, int endY)
    {
        List <Node> Path    = null;
        GraphSearch mSearch = new GraphSearch(mTileMap.MapInfo.mGraph);

        mSearch.PathFind(startX, startY, endX, endY);
        if (mSearch.IsFound())
        {
            //mCloseList = mSearch.GetCloseList();
            Path = mSearch.GetPathList();
            //foreach(Node i in Path)
            //{
            //	mTileMap.MapInfo.SetTileTypeIndex(i.mIndex,DTileMap.TileType.Path);
            //}
        }
        else
        {
            Debug.Log("No Path is found");
        }
        return(Path);
    }
Esempio n. 27
0
        static void Main(string[] args)
        {
            var people = new PeopleCollection();

            new GedcomImport().Import(people, @"C:\Users\davit\source\repos\RelationshipSearch\hayden.ged");
            Person from     = people[0];
            Person to       = people[163];
            var    solution = new GraphSearch(new BreadthFirstFrontier()).FindSolution(new PersonChildState(from), new GoalTest(to));

            if (solution == null)
            {
                solution = new GraphSearch(new BreadthFirstFrontier()).FindSolution(new PersonParentState(from), new GoalTest(to));
            }
            if (solution == null)
            {
                solution = new GraphSearch(new BreadthFirstFrontier()).FindSolution(new PersonCousinState(from, true), new GoalTest(to));
            }
            var html = HtmlHelper.ConvertToHtml(solution);

            File.WriteAllText("D:/temp/test.html", html);
        }
    public override int Compare(DirectionWeight x, DirectionWeight y)
    {
        int   val = 0;
        float d1  = (GraphSearch.fromPosition(x.x, x.y).euclidianDistanceFromTarget(x.goalX, x.goalY));
        float d2  = (GraphSearch.fromPosition(y.x, y.y).euclidianDistanceFromTarget(y.goalX, y.goalY));

        if (d1 < d2)
        {
            val = -1;
        }
        else if (d1 > d2)
        {
            val = 1;
        }
        else
        {
            val = 0;
        }

        return((x.weight - y.weight) * 10 + val);
    }
Esempio n. 29
0
            public void ResetMove(T id, GraphSearch search, Func <T, T, int> comparison = null)
            {
                Start   = Vertexes[id];
                Current = null;
                Search  = search;
                Visited.Clear();
                Comparison = comparison ?? new Func <T, T, int>((x, y) => x.CompareTo(y));

                switch (search)
                {
                case GraphSearch.BFS:
                    WaitingNodes = new WaitingQueue <Node>();
                    break;

                case GraphSearch.DFS:
                    WaitingNodes = new WaitingStack <Node>();
                    break;

                default:
                    break;
                }
            }
    /* Maybe make the unit search for a valid target before shooting, as opposed to always shooting at the player */
    public override void CastMainSpell()
    {
        base.CastMainSpell();
        /* new animation */

        if (GraphSearch
            .fromPosition(Map_position_x, Map_position_y)
            .manhattanDistanceFromTarget(GameTools.Player.Map_position_x, GameTools.Player.Map_position_y) <= MainSpell.CastRange)
        {
            MainSpell.loadInfo(new int[2] {
                Map_position_x, Map_position_y
            },
                               new int[2] {
                GameTools.Player.Map_position_x, GameTools.Player.Map_position_y
            });
            ProjectileManager.getInstance().queueProjectile(MainSpell, game_object.transform.position, GameTools.Player.game_object.transform.position);
        }
        else if (GraphSearch
                 .fromPosition(Map_position_x, Map_position_y)
                 .manhattanDistanceFromTarget(GameTools.Base.Map_position_x, GameTools.Base.Map_position_y) <= MainSpell.CastRange)
        {
            MainSpell.loadInfo(new int[2] {
                Map_position_x, Map_position_y
            },
                               new int[2] {
                GameTools.Base.Map_position_x, GameTools.Base.Map_position_y
            });
            ProjectileManager.getInstance().queueProjectile(MainSpell, game_object.transform.position, GameTools.Base.game_object.transform.position);
        }
        else
        {
            Debug.LogError("Not in either range");
        }

        enemyAnimation.SetBool("Cast", true);
    }
Esempio n. 31
0
    public void InitSpawners(int playerlevel, int difficultyChange)
    {
        Debug.Log("Difficulty change " + difficultyChange);
        int SpawnerCount = 10 + difficultyChange;

        if (SpawnerCount < 5)
        {
            SpawnerCount = 5;
        }
        if (SpawnerCount > 20)
        {
            SpawnerCount = 20;
        }
        Debug.Log("SpawnerCount " + SpawnerCount);
        while (SpawnerCount > 0)
        {
            int randX = Random.Range(0, size_x);
            int randY = Random.Range(0, size_z);
            if (GraphSearch.fromPosition(randX, randY)
                .manhattanDistanceFromTarget(GameTools.Player.Map_position_x, GameTools.Player.Map_position_y) <= 25)
            {
                continue;
            }
            if (TileTools.IsLand(TileMapData[randX, randY]))
            {
                if (BonusTileData[randX, randY] == null &&
                    SpawnerMap[randX, randY] == null)
                {
                    SpawnerCount--;
                    EnemySpawner e = new EnemySpawner(randX, randY, playerlevel, difficultyChange);
                    SpawnerMap[randX, randY] = e;
                    Spawners.Add(e);
                }
            }
        }
    }
Esempio n. 32
0
        public void Execute_WhenTheSameStateOccursMultipleTimesAccordingToTheStateEqualityComparer_OnlyExpandsItOnce()
        {
            // Arrange
            var someState = fixture.Create<TestState>();
            var someOtherState = fixture.Create<TestState>();
            var equalToSomeState = fixture.Create<TestState>();

            var equalityComparer = fixture.Create<Mock<IEqualityComparer<TestState>>>();
            equalityComparer.Setup(comparer => comparer.Equals(It.IsAny<TestState>(), It.IsAny<TestState>())).Returns(false);
            equalityComparer.Setup(comparer => comparer.Equals(someState, equalToSomeState)).Returns(true);

            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(startState)
                .Returns(someState)
                .Returns(someOtherState)
                .Returns(equalToSomeState)
                .Returns(goalState);

            var subject = new GraphSearch<TestState>(strategy.Object, equalityComparer.Object);

            // Act
            subject.Execute(problem.Object);

            // Assert
            problem.Verify(prob => prob.IsGoalState(equalToSomeState), Times.Never);
            problem.Verify(prob => prob.GetSuccessors(equalToSomeState), Times.Never);
        }
Esempio n. 33
0
        public void Execute_AddsTheStartStateToTheFringe()
        {
            // Arrange
            problem.Setup(prob => prob.IsGoalState(It.IsAny<TestState>())).Returns(true); // avoid infinite loop

            var subject = new GraphSearch<TestState>(strategy.Object);

            // Act
            subject.Execute(problem.Object);

            // Assert
            strategy.Verify(strat => strat.Add(startState), Times.Once());
        }
Esempio n. 34
0
        private void ButtonSolveClick(object sender, RoutedEventArgs e)
        {
            if (_currentPolyLine.Points.Count >= 2)
            {
                _currentPolyLine.Points.Add(_currentPolyLine.Points[0]);
            }

            var initialState = new PathFindingState(new Search.Types.Point(100, 100));
            var goalState = new PathFindingState(new Search.Types.Point(800, 600));

            var environment = new PathFindingEnvironment();

            foreach (var polyLine in _polyLines)
            {
                var points = polyLine.Points.Select(p => p).Distinct().ToList();
                for (int i = 0; i < points.Count; i++)
                {
                    for (int j = i + 1; j < points.Count; j++)
                    {
                        if (i == j) continue;

                        var pointLine = new PointLine(
                            new Point(points[i].X, points[i].Y),
                            new Point(points[j].X, points[j].Y));

                        environment.PointLines.Add(pointLine);
                    }
                }
            }

            var actionFunction = new PathFindingActionFunction(environment, goalState);
            var resultFunction = new PathFindingResultFunction();
            var goalTest = new PathFindingGoalTest(goalState);
            var stepCost = new PathFindingStepCost();
            var searchAlgorithm = new GraphSearch<PathFindingState, PathFindingAction>();

            var problem = new Problem<PathFindingState, PathFindingAction>(initialState, actionFunction, resultFunction, goalTest, stepCost);

            var solution = searchAlgorithm.Search(problem);

            for (int i = 1; i < solution.Count; i++)
            {
                AddLine(
                    solution[i - 1].State.Point.X,
                    solution[i - 1].State.Point.Y,
                    solution[i].State.Point.X,
                    solution[i].State.Point.Y);
            }
        }
Esempio n. 35
0
        public void Execute_ExpandsStatesInOrderOfTheirAppearanceOffTheFringe()
        {
            // Arrange
            var stateBuilder = fixture.Build<TestState>();
            var s1 = stateBuilder.Create();
            var s2 = stateBuilder.Create();
            var s3 = stateBuilder.Create();

            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(startState)
                .Returns(s1)
                .Returns(s2)
                .Returns(s3)
                .Returns(goalState);

            using (Sequence.Create())
            {
                problem.Setup(prob => prob.GetSuccessors(startState)).InSequence().Returns(fixture.CreateMany<TestState>());
                problem.Setup(prob => prob.GetSuccessors(s1)).InSequence().Returns(fixture.CreateMany<TestState>());
                problem.Setup(prob => prob.GetSuccessors(s2)).InSequence().Returns(fixture.CreateMany<TestState>());
                problem.Setup(prob => prob.GetSuccessors(s3)).InSequence().Returns(fixture.CreateMany<TestState>());

                var subject = new GraphSearch<TestState>(strategy.Object);

                // Act
                subject.Execute(problem.Object);

                // Assert
                problem.Verify();
            }
        }
Esempio n. 36
0
        public void Execute_WhenTheStartStateIsNotAGoalState_ExpandsTheStartState()
        {
            // Arrange
            var subject = new GraphSearch<TestState>(strategy.Object);

            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(startState)
                .Returns(goalState);

            // Act
            subject.Execute(problem.Object);

            // Assert
            problem.Verify(prob => prob.GetSuccessors(startState), Times.Once());
        }
Esempio n. 37
0
        public void Execute_AddsExpandedStatesToTheFringe()
        {
            // Arrange
            var stateBuilder = fixture.Build<TestState>();
            var s1 = stateBuilder.Create();
            var s2 = stateBuilder.Create();
            var s3 = stateBuilder.Create();

            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(startState)
                .Returns(s1)
                .Returns(s2)
                .Returns(s3)
                .Returns(goalState);

            problem.Setup(prob => prob.GetSuccessors(startState)).Returns(new[] { s1 });
            problem.Setup(prob => prob.GetSuccessors(s1)).Returns(new[] { s2, s3 });
            problem.Setup(prob => prob.GetSuccessors(s2)).Returns(fixture.CreateMany<TestState>());
            problem.Setup(prob => prob.GetSuccessors(s3)).Returns(new[] { goalState });

            using (Sequence.Create())
            {
                strategy.Setup(strat => strat.Add(s1)).InSequence();
                strategy.Setup(strat => strat.Add(s2)).InSequence();
                strategy.Setup(strat => strat.Add(s3)).InSequence();
                strategy.Setup(strat => strat.Add(goalState)).InSequence();

                var subject = new GraphSearch<TestState>(strategy.Object);

                // Act
                subject.Execute(problem.Object);

                // Assert
                strategy.VerifyAll();
            }
        }
Esempio n. 38
0
        public void Execute_WhenTheStartStateIsNotAGoalState_AddsItsSucessorsToTheFringe()
        {
            // Arrange
            var succesors = fixture.CreateMany<TestState>(3).ToArray();
            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(startState)
                .Returns(succesors[0])
                .Returns(succesors[1])
                .Returns(succesors[2])
                .Returns(goalState);

            problem.Setup(prob => prob.GetSuccessors(startState)).Returns(succesors);

            var subject = new GraphSearch<TestState>(strategy.Object);

            // Act
            subject.Execute(problem.Object);

            // Assert
            strategy.Verify(strat => strat.Add(succesors[0]), Times.Once());
            strategy.Verify(strat => strat.Add(succesors[1]), Times.Once());
            strategy.Verify(strat => strat.Add(succesors[2]), Times.Once());
        }
Esempio n. 39
0
        public void Execute_WhenTheStartStateIsAGoalState_DoesNotExpandAnyStates()
        {
            // Arrange
            var subject = new GraphSearch<TestState>(strategy.Object);

            strategy.Setup(strat => strat.GetNext()).Returns(startState);
            problem.Setup(prob => prob.IsGoalState(startState)).Returns(true);

            // Act
            subject.Execute(problem.Object);

            // Assert
            problem.Verify(prob => prob.GetSuccessors(It.IsAny<TestState>()), Times.Never());
        }
Esempio n. 40
0
        public void Execute_ReturnsTheFirstGoalStateOffTheFringe()
        {
            // Arrange
            var stateBuilder = fixture.Build<TestState>();
            var secondGoal = stateBuilder.Create();

            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(stateBuilder.Create())
                .Returns(stateBuilder.Create())
                .Returns(goalState)
                .Returns(stateBuilder.Create())
                .Returns(secondGoal);

            problem.Setup(prob => prob.IsGoalState(secondGoal)).Returns(true);

            var subject = new GraphSearch<TestState>(strategy.Object);

            // Act
            var result = subject.Execute(problem.Object);

            // Assert
            Assert.Equal(goalState, result);
        }
Esempio n. 41
0
        public void Execute_WhenProblemIsNull_ThrowsAnArgumentNullException()
        {
            // Arrange
            var subject = new GraphSearch<TestState>(strategy.Object);

            // Act
            Action act = () => subject.Execute(null);

            // Assert
            var ex = Assert.Throws<ArgumentNullException>(act);
            Assert.Equal(nameof(problem), ex.ParamName);
        }
Esempio n. 42
0
        public void Execute_WhenTheFringeBecomesEmptyWithNoGoalStateFound_ThrowsANoSolutionPossibleException()
        {
            // Arrange
            strategy.SetupSequence(strat => strat.IsEmpty())
                .Returns(false)
                .Returns(false)
                .Returns(true);

            var subject = new GraphSearch<TestState>(strategy.Object);

            // Act
            Action act = () => subject.Execute(problem.Object);

            // Assert
            var ex = Assert.Throws<NoSolutionPossibleException>(act);
            Assert.NotNull(ex.Message);
        }
Esempio n. 43
0
        public void Execute_DoesNotExpandStatesAfterTheGoalStateIsFound()
        {
            // Arrange
            var afterGoal = fixture.Create<TestState>();

            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(startState)
                .Returns(goalState)
                .Returns(afterGoal);

            var subject = new GraphSearch<TestState>(strategy.Object);

            // Act
            subject.Execute(problem.Object);

            // Assert
            problem.Verify(prob => prob.IsGoalState(afterGoal), Times.Never);
            problem.Verify(prob => prob.GetSuccessors(afterGoal), Times.Never);
        }
Esempio n. 44
0
        public void Execute_WhenTheSameStateOccursMultipleTimes_OnlyExpandsItOnce()
        {
            // Arrange
            var someState = fixture.Create<TestState>();

            strategy.SetupSequence(strat => strat.GetNext())
                .Returns(startState)
                .Returns(someState)
                .Returns(someState)
                .Returns(goalState);

            var subject = new GraphSearch<TestState>(strategy.Object);

            // Act
            subject.Execute(problem.Object);

            // Assert
            problem.Verify(prob => prob.IsGoalState(someState), Times.Once);
            problem.Verify(prob => prob.GetSuccessors(someState), Times.Once);
        }