コード例 #1
0
        public Queue <string> search(int[,] initstate, int[,] desiredstate)
        {
            Modelisation.Node rootn = new Modelisation.Node(
                initstate,
                new[] { 0, 0 },
                0,
                0,
                false,
                "root"
                );
            Modelisation.Node goaln = new Modelisation.Node(
                desiredstate,
                new[] { 0, 0 },
                0,
                0,
                false,
                "goal"
                );
            tree_fs.Clear();
            tree_fg.Clear();


            tree_fs.Add(rootn);
            tree_fg.Add(goaln);


            int borderindex = 0;

            while (true)
            {
                Dictionary <string, Modelisation.Node> s_successors = problem.succession(tree_fs[borderindex]);

                Dictionary <string, Modelisation.Node> g_successors = problem.retrosuccession(tree_fg[borderindex]);



                foreach (KeyValuePair <string, Modelisation.Node> entry in s_successors)
                {
                    Modelisation.Node[] x = problem.isPresent(entry.Value, tree_fg.GetRange(0, borderindex));
                    if (x != null)
                    {
                        return(generateTasklist(x[0], x[1]));
                    }
                    tree_fs.Add(entry.Value);
                }


                foreach (KeyValuePair <string, Modelisation.Node> entry in g_successors)
                {
                    Modelisation.Node[] x = problem.isPresent(entry.Value, tree_fs.GetRange(0, borderindex));
                    if (x != null)
                    {
                        return(generateTasklist(x[1], x[0]));
                    }
                    tree_fg.Add(entry.Value);
                }

                borderindex++;
            }
        }
コード例 #2
0
 public Modelisation.Node[] isPresent(Modelisation.Node node, List <Modelisation.Node> visited)
 {
     foreach (Modelisation.Node n in visited)
     {
         if (node.getSignature() == n.getSignature())
         {
             return(new[] { node, n });
         }
     }
     return(null);
 }
コード例 #3
0
        public Dictionary <string, Modelisation.Node> retrosuccession(Modelisation.Node currentNode)
        {
            Dictionary <string, Modelisation.Node> newStates = new Dictionary <string, Modelisation.Node>();

            Floor testingFloor = new Floor(currentNode.getState(), currentNode.getPathcost());


            if (currentNode.getLastAction() == "nothing")
            {
                Modelisation.Node newnode = new Modelisation.Node(
                    testingFloor.getState(),
                    testingFloor.getAspXY(),
                    currentNode.getDepth() + 1,
                    //currentNode.getPathcost() + entry.Value.getCost(),
                    testingFloor.account(),
                    false,
                    "nothing",
                    currentNode
                    );
                newStates.Add("nothing", newnode);
                return(newStates);
            }



            foreach (KeyValuePair <string, Action> entry in actions)
            {
                entry.Value.reverse(testingFloor, testingFloor.getAspXY());
                if (isArrayEqual(testingFloor.getState(), currentNode.getState()) && entry.Key != "nothing")
                {
                    testingFloor.reset();
                    continue;
                }
                Modelisation.Node newnode = new Modelisation.Node(
                    testingFloor.getState(),
                    testingFloor.getAspXY(),
                    currentNode.getDepth() + 1,
                    //currentNode.getPathcost() + entry.Value.getCost(),
                    testingFloor.account(),
                    false,
                    entry.Key,
                    currentNode
                    );

                newStates.Add(entry.Key, newnode);
                testingFloor.reset();
            }


            return(newStates);
        }
コード例 #4
0
ファイル: Brain.cs プロジェクト: LeoSchirvanian/AI_Vacuum
        // Generate tasklist from a node list
        public Queue <string> generatetasklist(List <Modelisation.Node> l)
        {
            Queue <string> tasklist = new Queue <string>();

            if (l.Count != 0)
            {
                Modelisation.Node node = l[l.Count - 1];

                // While the node is not the root node, we add its lastaction to the tasklist
                while (node.getLastAction() != "nothing")
                {
                    tasklist.Enqueue(node.getLastAction());
                    node = node.getParent();
                }

                //tasklist.Enqueue(node.getLastAction());
            }

            return(tasklist);
        }
コード例 #5
0
        private Queue <string> generateTasklist(Modelisation.Node ns, Modelisation.Node ng)
        {
            List <string> actions = new List <string>();

            while (ns.getLastAction() != "root")
            {
                actions.Insert(0, ns.getLastAction());
                ns = ns.getParent();
            }

            while (ng.getLastAction() != "goal")
            {
                actions.Add(ng.getLastAction());
                ng = ng.getParent();
            }


            Queue <string> queue = new Queue <string>(actions);

            return(queue);
        }
コード例 #6
0
ファイル: Brain.cs プロジェクト: LeoSchirvanian/AI_Vacuum
        // Method search
        public Queue <string> searchInforme(int[,] initstate, List <int[, ]> desireStates, int[] vacXY)
        {
            // First check if initstate is one of our desireStates
            //*
            foreach (int[,] d in desireStates)
            {
                // If one of them is equal, then no need to search a tasklist
                if (isArrayEqual(initstate, d))
                {
                    // Stop method
                    Queue <string> q = new Queue <string>();
                    return(q);
                }
            }
            //*/

            // Clear tree
            tree.Clear();
            tasklist.Clear();

            // Create a root node with initial state
            Modelisation.Node root = new Modelisation.Node(
                initstate,          // initial state
                vacXY,              // vacXY
                0,                  // depth
                100,                // heuristic
                false,              // visited
                "nothing"           // lastaction
                );

            tree.Add(root);

            // Represent index of exploration : here it's Breadth first search
            //int borderindex = 0;

            List <Modelisation.Node> succ = new List <Modelisation.Node>();

            bool b = true;

            while (b)
            {
                // We check if the last node state of tree is on dirt or jewel
                //Floor f = new Floor(tree[borderindex].getState());
                int d = isJewelDirt(tree[tree.Count - 1].getState(), tree[tree.Count - 1].getVacXY());

                // If the vaccum is on jewel or dirt
                if (d != 0)
                {
                    switch (d)
                    {
                    case 3:
                        tasklist.Enqueue("pickup");
                        return(tasklist);

                    case 5:
                        tasklist.Enqueue("clean");
                        return(tasklist);

                    case 7:
                        tasklist.Enqueue("pickup");
                        tasklist.Enqueue("clean");
                        return(tasklist);

                    default:
                        b = false;
                        break;
                    }
                }

                // If not
                else
                {
                    tree = problem.successionInforme(tree[tree.Count - 1], tree);   // Get successor
                }

                tasklist = generatetasklist(tree);
            }

            return(tasklist);
        }