コード例 #1
0
ファイル: Robber.cs プロジェクト: gipsiarek/cop-robber
 /// <summary>
 /// robber for test uses
 /// </summary>
 public Robber(int startNode, Board board)
 {
     myPath = new List<int>();
     ocpupiedNode = startNode;
     movesSoFar = 0;
     myNeighbors = new List<int>();
     myNeighbors = board.findNeighbors(ocpupiedNode);
 }
コード例 #2
0
ファイル: Cop.cs プロジェクト: gipsiarek/cop-robber
 /// <summary>
 /// creates ellipse on a board in Point and gives it number i
 /// </summary>
 public Cop(Board board, Point node, int i)
 {
     myNode = new Node(node);
     myNeighbors = new List<int>();
     myNode.number = i;
     board.pointCop(node, myNode);
     myNeighbors = board.findNeighbors(myNode.number);
 }
コード例 #3
0
ファイル: Robber.cs プロジェクト: gipsiarek/cop-robber
 /// <summary>
 /// creates ellipse on a board in Point and gives it number i
 /// </summary>
 public Robber(Board board, Point node, int i)
 {
     myNode = new Node(node);
     myNeighbors = new List<int>();
     myNode.number = i;
     movesSoFar = 0;
     myPath = new List<int>();
     board.pointRobber(node, myNode);
     myNeighbors = board.findNeighbors(myNode.number);
 }
コード例 #4
0
ファイル: Board.cs プロジェクト: gipsiarek/cop-robber
        public static List<List<int>> removePitfalls(Board board)
        {
            int numberOfNodes = board.neighborForClass.Count();
            bool isEqual=true;
            for (int i = 0; i < numberOfNodes; i++)
            {
                List<int> nodeList = board.neighborForClass[i];
                if (nodeList.Count != 0)
                    for (int j = 0; j < nodeList.Count; j++)
                    {
                        isEqual = true;
                        int node = nodeList[j];
                        List<int> robPos = new List<int>(nodeList);
                        List<int> copPos = new List<int>(board.findNeighbors(node, true));
                        copPos.Add(node);
                        robPos.Add(i);
                        copPos.Sort();
                        robPos.Sort();

                        for (int k = 0; k < robPos.Count; k++)
                        {
                            if (!copPos.Contains(robPos[k]))
                            {
                                isEqual = false;
                                break;
                            }
                        }
                        if (isEqual)
                        {
                            // nodeList.Remove(i);
                            foreach (List<int> tmp in board.neighborForClass)
                            {
                                if (tmp.Contains(i))
                                    tmp.Remove(i);
                            }
                            nodeList.Clear();
                            board.neighborForClass = removePitfalls(board);
                            nodeList = board.neighborForClass[0];
                            i = 0; j = 0;
                            break;
                        }

                    }
            }
            return board.neighborForClass;
        }
コード例 #5
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
 internal static int robber_moves_MCTS(Tree<Node<Data>> MCTSTree, int robberNode, int copNode, int graphWidth, int graphDepth, Board board, out Tree<Node<Data>> MCTSTreeOut)
 {
     if (MCTSTree == null || MCTSTree.node.GetData().Counter == 0)
     {
         Data data = new Data();
         data.CopPos[0] = copNode;
         data.RobberPos = robberNode;
         data.Counter = graphDepth;
         MCTSTree = new Tree<Node<Data>>(simulateGame(graphWidth, graphDepth, 1, new Node<Data>(null, data), board));
         MCTSTree.node = PropagateChildrenProbability(MCTSTree.node);
         return getBestTreeNode(MCTSTree, out MCTSTreeOut, board);
     }
     else
     {
         return getBestTreeNode(MCTSTree, out MCTSTreeOut, board);
     }
 }
コード例 #6
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
 internal static int getBestTreeNode(Tree<Node<Data>> Tree, out Tree<Node<Data>> newTree, Board board)
 {
     LinkedList<Node<Data>> linkedList = new LinkedList<Node<Data>>(Tree.node.GetChildren());
     int node = 0, iter = 0, nodeToMove = 0;
     double maxProbability = 0;
     foreach (Node<Data> treeNode in linkedList)
     {
         Data data = treeNode.GetData();
         if (data.Probability > maxProbability)
         {
             nodeToMove = data.RobberPos;
             node = iter;
             maxProbability = data.Probability;
         }
         iter++;
     }
     newTree = new Tree<Node<Data>>(Tree.node.GetChild(node));
     return nodeToMove;
 }
コード例 #7
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
 internal static Data FindChildOnBoard(List<int> neighborList, Data nodeInfo, int copnumber, out int robberNodePosition, Board board)
 {
     List<int> path = new List<int>();
     Data newNode = new Data();
     if (neighborList.Count != 0)
     {
         newNode.RobberPos = neighborList[board.random.Next(neighborList.Count)];    //neighbors of robber
     }
     for (int j = 0; j < copnumber; j++)
     {
         path = Dijkstra(nodeInfo.CopPos[j], nodeInfo.CopPos[j], newNode.RobberPos, board);     //path from cop to robber in the same variable
         if (neighborList.Count > 0)
         {
             newNode.CopPos[j] = path[1];
             if (newNode.RobberCopDistance > path.Count - 1 || newNode.RobberCopDistance == -1) newNode.RobberCopDistance = path.Count - 1;
         }
     }
     robberNodePosition = newNode.RobberPos;
     return newNode;
 }
コード例 #8
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
 public static int robber_moves_randomBeacon(Board board, int r, int goOnTime, Robber robber, Cop cop)
 {
     int node = 0;
     if ((robber.movesSoFar == goOnTime || robber.movesSoFar == 1 || robber.myPath.Count <= robber.movesSoFar))
     {
         robber.movesSoFar = 1;
         robber.myPath = getBeaconNodes(r, 1, board, cop, robber);
         //robber.move(robber.myPath[robber.movesSoFar], board);
         node = robber.myPath[robber.movesSoFar];
         robber.movesSoFar++;
     }
     else
     {
         //robber.move(robber.myPath[robber.movesSoFar], board);
         node = robber.myPath[robber.movesSoFar];
         robber.movesSoFar++;
     }
     return node;
 }
コード例 #9
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
        public static int robber_moves_greedy_dijkstra(int copnumber, Board board, Cop cop, Robber robber)
        {
            List<int> currentPath = new List<int>();
            List<int> bestPath = new List<int>();
            List<List<int>> currentPathToCops = new List<List<int>>();
            bool defeat = false;
            int pathLength = 0;
            if (robber.myNeighbors.Contains(cop.ocupiedNode))
                defeat = true;

            foreach (int item in robber.myNeighbors)
            {
                if (item != cop.myNode.number)
                {
                    currentPath = Dijkstra(robber.ocpupiedNode, item, cop.ocupiedNode, board);
                    currentPathToCops.Add(currentPath);

                    foreach (List<int> tmp in currentPathToCops)
                    {
                        if (pathLength == 0 || pathLength < tmp.Count)
                        {
                            pathLength = tmp.Count;
                            currentPath = tmp;
                        }
                    }
                    defeat = false;
                    if (bestPath.Count < currentPath.Count)
                        bestPath = currentPath;
                    currentPathToCops.Clear();
                }
            }
            if (!defeat)
            {
                try
                {
                    return bestPath[0];
                }
                catch (Exception ex)
                {
                    MessageBox.Show("ruch złodzieja" + ex);
                }
            }
            return -1;
        }
コード例 #10
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
        public static List<int> getBeaconNodes(int r, int copnumber, Board board, Cop cop, Robber robber)
        {
            List<int> path = new List<int>();
            List<int> bestPath = new List<int>();
            List<List<int>> currentPathToCops = new List<List<int>>();
            int bestNode = 0, pathLength = 0;
            int node;
            for (int randNumber = 0; randNumber < r; randNumber++)
            {
                node = board.random.Next(board.neighbor.Count);
                if (cop.ocupiedNode != node)
                {
                    path = Dijkstra(node, node, cop.ocupiedNode, board);
                    currentPathToCops.Add(path);

                }
                foreach (List<int> tmp in currentPathToCops)
                {
                    if (pathLength == 0 || pathLength > tmp.Count)
                    {
                        pathLength = tmp.Count;
                        path = tmp;
                    }
                }
                if (path.Count > bestPath.Count || bestPath.Count == 0)
                {
                    bestPath = path;
                    bestNode = node;
                }
                currentPathToCops.Clear();
            }
            return Dijkstra(robber.ocpupiedNode, robber.ocpupiedNode, bestNode, board);
        }
コード例 #11
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
        public static int alphabeta(int node, int depth, int alpha, int beta, bool player, int oponentNode, int startDepth, Board board)
        {
            int goNode = node;
            if (depth == 0 || node == oponentNode) //lub koniec gry
            {
                return getNodeValue(node, oponentNode, player, board);
            }

            if (player == true)
            {
                foreach (int neighbor in board.findNeighbors(node))
                {
                    int alpha2 = Math.Max(alpha, alphabeta(oponentNode, depth - 1, alpha, beta, !player, neighbor, startDepth, board));
                    if (alpha2 > alpha)
                    {
                        goNode = neighbor;
                        alpha = alpha2;
                    }

                    if (alpha>=beta)
                    {
                        return beta;

                    }
                }
                return alpha;
            }
            else
            {
                foreach (int neighbor in board.findNeighbors(oponentNode))
                {
                    beta = Math.Min(beta, alphabeta(oponentNode, depth - 1, alpha, beta, !player, neighbor, startDepth, board));
                    if (alpha>=beta)
                    {
                        return alpha;
                    }
                }
                return beta;
            }
        }
コード例 #12
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
 /// <summary>
 /// creating new board robber and cops for new series of runaways
 /// </summary>        
 private void newDataForTest(int copnumber)
 {
     List<int> notSafe = new List<int>();
     cops = new List<Cop>();
     ocupied = new List<int>();
     board = new Board(nodenumberMin, nodenumberMax, maxNodeSt);
     int nodenumber = board.neighbor.Count;
     int i;
     for (i = 0; i < copnumber; i++)
     {
         cops.Add(new Cop(board.random.Next(nodenumber), board));
         cops[i].copId = i;
         if (!ocupied.Contains(cops[i].ocupiedNode))
         {
             ocupied.Add(cops[i].ocupiedNode);
             cops[i].startNode = cops[i].ocupiedNode;
         }
         else
         {
             do
             {
                 cops[i] = new Cop(board.random.Next(nodenumber), board);
                 cops[i].startNode = cops[i].ocupiedNode;
             } while (ocupied.Contains(cops[i].startNode));
             ocupied.Add(cops[i].startNode);
         }
     }
     foreach (Cop cop in cops)
     {
         foreach (int a in cop.myNeighbors)
         {
             notSafe.Add(a);
         }
     }
     i = 0;
     do
     {
         i++;
         robber = new Robber(board.random.Next(nodenumber), board);
         robber.startNode = robber.ocpupiedNode;
         if (i > 100) newDataForTest(copnumber);
     } while (ocupied.Contains(robber.ocpupiedNode) || notSafe.Contains(robber.ocpupiedNode));
 }
コード例 #13
0
ファイル: UserGame.xaml.cs プロジェクト: gipsiarek/cop-robber
        private void UserGame_OnLoad()
        {
            checkboard.Children.Clear();
            gType = Convert.ToString(Application.Current.Properties["gType"]);

            gWidth = (gType == "koperta" || gType == "4-regularny c3" || gType == "dwunastoscian" || gType=="petersen") ? 0 : Convert.ToInt32(Application.Current.Properties["gWidth"]);

            gHeight = (gType == "koperta" || gType == "4-regularny c3" || gType == "dwunastoscian" || gType == "petersen") ? 0 : Convert.ToInt32(Application.Current.Properties["gHeight"]);

            gAlgorithm = Convert.ToString(Application.Current.Properties["gAlgorithm"]);
            nodenumber = gHeight * gWidth;
            board = new Board(gWidth, gHeight, gType, (int)checkboard.Width, (int)checkboard.Height);
            Board.removePitfalls(board);
            foreach (List<int> tmp in board.neighborForClass)
            {
                if (tmp.Count != 0)
                {
                    board.isCopWinGraph = false;
                }
            }
            if (board.isCopWinGraph)
                lblKlasa.Text = "Cop-Win";
            else lblKlasa.Text = "Robber-Win";

            foreach (Node node in board.vertex)
            {
                foreach (int tmp in board.neighbor[node.number])
                {
                    Line linia = board.drawLine(node.number, tmp);
                    checkboard.Children.Add(linia);
                }
            }
            foreach (Node node in board.vertex)
                checkboard.Children.Add(node.elly);
        }
コード例 #14
0
ファイル: Cop.cs プロジェクト: gipsiarek/cop-robber
 /// <summary>
 /// move and find neighbor list
 /// </summary>
 /// <param name="node">node number to move to</param>
 /// <param name="board">board for witch we find neighborhood</param>
 public void move(int node, Board board)
 {
     ocupiedNode = node;
     myNeighbors = board.findNeighbors(ocupiedNode);
 }
コード例 #15
0
ファイル: Cop.cs プロジェクト: gipsiarek/cop-robber
 /// <summary>
 /// cop for test uses
 /// </summary>
 public Cop(int startNode, Board board)
 {
     ocupiedNode = startNode;
     myNeighbors = new List<int>();
     myNeighbors = board.findNeighbors(ocupiedNode);
 }
コード例 #16
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
        internal static Node<Data> simulateGame(int searchWidth, int searchDepth, int copnumber, Node<Data> node, Board board)
        {
            if (searchDepth != 0)
            {
                Data nodeInfo = node.GetData();
                List<int> neighborList = new List<int>(board.findNeighbors(nodeInfo.RobberPos));
                List<int> path = new List<int>();
                int robberNodePosition;
                for (int i = 0; i < searchWidth; i++)
                {
                    node.AddChild(FindChildOnBoard(neighborList, nodeInfo, copnumber, out robberNodePosition, board));
                    if (neighborList.Contains(robberNodePosition))
                        neighborList.Remove(robberNodePosition);
                }
                //obliczanie prawdopodobieństw do ruchu na zaraz
                int sum = 0, iter = 0, maxNode = 0;
                double maxProbNode = 0;
                foreach (Node<Data> child in node.GetChildren())
                {
                    sum += child.GetData().RobberCopDistance;
                }
                foreach (Node<Data> child in node.GetChildren())
                {
                    child.GetData().Probability = (double)child.GetData().RobberCopDistance / sum;
                    if (child.GetData().Probability > maxProbNode)
                    {
                        maxProbNode = child.GetData().Probability;
                        maxNode = iter;
                    }
                    iter++;
                }
                simulateGame(searchWidth, searchDepth - 1, copnumber, node.GetChild(maxNode), board);
            }

            return node;
        }
コード例 #17
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
        private static int getNodeValue(int node, int oponentNode, bool player, Board board)
        {
            List<int> length = new List<int>();
            if (player)
            {
                if (node == oponentNode) return -999;
                length = Dijkstra(node, node, oponentNode, board);
                return -length.Count;
            }
            else
            {
                if (node == oponentNode) return 999;
                length = Dijkstra(node, node, oponentNode, board);
                return (length.Count);

            }
        }
コード例 #18
0
ファイル: Tests.xaml.cs プロジェクト: gipsiarek/cop-robber
        public static List<int> Dijkstra(int from, int startNode, int finalNode, Board board)
        {
            nodeNumber = board.neighbor.Count;
            List<int> path = new List<int>();
            List<List<int>> visited = new List<List<int>>(nodeNumber);
            for (int i = 0; i < nodeNumber; i++)
            {
                visited.Add(new List<int>());
            }
            List<int> neighbors = board.findNeighbors(startNode);
            Queue<int> q = new Queue<int>(nodeNumber);
            int tmpNode;
            visited[startNode].Add(from);
            foreach (int i in neighbors)
            {
                if (i == finalNode)
                {
                    path.Add(startNode);
                    path.Add(finalNode);
                    return path;
                }
                else
                {
                    q.Enqueue(i);
                    visited[i].Add(startNode);
                }
            }
            while (q.Count != 0)
            {
                tmpNode = q.Dequeue();
                neighbors = board.findNeighbors(tmpNode);
                foreach (int node in neighbors)
                {
                    if (node == finalNode)
                    {
                        q.Enqueue(node);
                        visited[node].Add(tmpNode);
                        createPathFromQueue(visited, out path, node, startNode);
                        return path;
                    }
                    else
                    {

                        if (visited[node].Count == 0)
                        {
                            q.Enqueue(node);
                            visited[node].Add(tmpNode);
                        }
                    }
                }
            }
            return path;
        }