private static List<Edge> getPathUnweighted(Ship ship, Node start, Node end, Set<EdgeState> acceptableEdges) {

                // Make sure the two nodes are in in the ship
                if (!(ship.nodeMap.containsValue(start) && ship.nodeMap.containsValue(end))) {
                        throw new IllegalArgumentException("Both nodes not contained in the graph");
                }

                // Get the first node
                Node firstNode = ship.nodeMap.get(start.getCoordinates());

                // Create the map to store info for each node
                Map<Node, DijkstraInfo> nodeInfo = new HashMap<Node, DijkstraInfo>();

                // Put the first node in the node info
                nodeInfo.put(firstNode, new DijkstraInfo(0));
                // Create Queue and add the first node to the queue
                Queue<Node> toDo = new LinkedList<Node>();
                toDo.add(firstNode);

                // While there are still nodes left in the queue
                while (toDo.size() > 0) {

                        // Remove a node
                        Node currentNode = toDo.remove();

                        // Get each of the adjacent nodes
                        Set<NodeEdgePair> adjacentNodes = currentNode.getAdjacentNodeEdgePair();

                        // For every adjacent node
                        for (NodeEdgePair nep : adjacentNodes) {
                                // If the edge is an acceptable edge to count
                                if (acceptableEdges.contains(nep.edge.getEdgeState())) {
                                        // If the node is not already in the map
                                        if (!nodeInfo.containsKey(nep.node)) {
                                                // Add the node to the map and
                                                // store its distance,
                                                // previous
                                                // node, and previous edge
                                                nodeInfo.put(nep.node, new DijkstraInfo(nodeInfo.get(currentNode).distance + 1, currentNode, nep.edge));

                                                // Put the node in the Queue
                                                toDo.add(nep.node);

                                        }
                                        // If it already in the map
                                        else {

                                                // Current best distance
                                                DijkstraInfo currentBest = nodeInfo.get(nep.node);
                                                int newDistance = (nodeInfo.get(currentNode).distance + 1);

                                                // If the current node allows a
                                                // faster path to the node
                                                if (currentBest.distance > newDistance) {
                                                        // Then update the best
                                                        // path
                                                        currentBest.distance = newDistance;
                                                        currentBest.bestPrevNode = currentNode;
                                                        currentBest.bestPrevEdge = nep.edge;
                                                }

                                        }
                                }

                        }

                }

                // If the Dijkstra search did not find the end point. Return
                // null to
                // indicate no path has been found
                if (!nodeInfo.containsKey(ship.nodeMap.get(end.getCoordinates()))) {
                        return null;

                }

                else {

                        // Best Path list
                        List<Edge> bestPath = new LinkedList<Edge>();

                        // Current node (starts with the last node
                        Node currentNode = ship.nodeMap.get(end.getCoordinates());

                        // While it has not made it to the first node
                        while (!currentNode.equals(firstNode)) {

                                // Add the edge to the best path at the
                                // beginning
                                bestPath.add(0, nodeInfo.get(currentNode).bestPrevEdge);
                                // Change current node
                                currentNode = nodeInfo.get(currentNode).bestPrevNode;
                        }

                        return bestPath;
                }

        }