Naive pathfinding function in Swift. Throw into a playground to mess around with. (Need to figure out an algorithm for calculating adjacent nodes). See http://gabrielgambetta.com/path1.html for original algorithm.

naive pathfinding

import UIKit

class Node : Equatable {
    
    let name: String;
    var previous: Node? = nil
    var adjacents: [Node] = []

    init (name: String) {
        self.name = name
    }
}

func == (lhs: Node, rhs: Node) -> Bool {
    return lhs.name == rhs.name && lhs.previous === rhs.previous
}

func findPath(startNode: Node, endNode: Node) -> [Node] {
    
    func chooseNode(nodes: [Node]) -> (Node?) {
        return nodes[Int(rand()) % nodes.count]
    }
    
    func buildPath(var currentNode: Node?) -> [Node] {
        var path: [Node] = [];
        while let node = currentNode {
            path.append(node);
            currentNode = node.previous
        }
        return path.reverse();
    }
    
    func getAdjacentNodes(node: Node) -> [Node] {
        return node.adjacents;
    }
    
    var reachable: [Node] = [startNode];
    var explored: [Node] = [];
    
    while !reachable.isEmpty {
        if let node = chooseNode(reachable) {
            if node === endNode {
                return buildPath(endNode)
            }
            if let foundIndex = find(reachable, node) {
                reachable.removeAtIndex(foundIndex)
            }
            explored.append(node)
            
            let adjacents = getAdjacentNodes(node).filter({!contains(explored, $0)})
            
            for adjacent in adjacents {
                if !contains(reachable, adjacent) {
                    adjacent.previous = node
                    reachable.append(adjacent)
                }
            }
        }
    }
    
    return []
}

let a = Node(name: "a")
let b = Node(name: "b")
let c = Node(name: "c")
let d = Node(name: "d")
let e = Node(name: "e")
let f = Node(name: "f")
let g = Node(name: "g")
let h = Node(name: "h")
let i = Node(name: "i")
let j = Node(name: "j")
let k = Node(name: "k")
let l = Node(name: "l")
let m = Node(name: "m")
let n = Node(name: "n")
let o = Node(name: "o")
let p = Node(name: "p")
let q = Node(name: "q")
let r = Node(name: "r")
let s = Node(name: "s")
let t = Node(name: "t")
let u = Node(name: "u")
let v = Node(name: "v")
let w = Node(name: "w")
let x = Node(name: "x")
let y = Node(name: "y")

a.adjacents.append(b)
a.adjacents.append(f)
b.adjacents.append(a)
b.adjacents.append(c)
b.adjacents.append(g)
c.adjacents.append(b)
c.adjacents.append(d)
c.adjacents.append(h)
d.adjacents.append(c)
d.adjacents.append(e)
d.adjacents.append(i)
e.adjacents.append(d)
e.adjacents.append(j)
f.adjacents.append(a)
f.adjacents.append(g)
f.adjacents.append(k)
g.adjacents.append(b)
g.adjacents.append(f)
g.adjacents.append(h)
g.adjacents.append(l)
h.adjacents.append(c)
h.adjacents.append(g)
h.adjacents.append(i)
h.adjacents.append(m)
i.adjacents.append(d)
i.adjacents.append(h)
i.adjacents.append(j)
i.adjacents.append(n)
j.adjacents.append(e)
j.adjacents.append(i)
j.adjacents.append(o)
k.adjacents.append(f)
k.adjacents.append(l)
k.adjacents.append(p)
l.adjacents.append(g)
l.adjacents.append(k)
l.adjacents.append(m)
l.adjacents.append(q)
m.adjacents.append(h)
m.adjacents.append(l)
m.adjacents.append(n)
m.adjacents.append(r)
n.adjacents.append(i)
n.adjacents.append(m)
n.adjacents.append(o)
n.adjacents.append(s)
o.adjacents.append(j)
o.adjacents.append(n)
o.adjacents.append(t)
p.adjacents.append(k)
p.adjacents.append(q)
p.adjacents.append(u)
q.adjacents.append(l)
q.adjacents.append(p)
q.adjacents.append(r)
q.adjacents.append(v)
r.adjacents.append(m)
r.adjacents.append(q)
r.adjacents.append(s)
r.adjacents.append(w)
s.adjacents.append(n)
s.adjacents.append(r)
s.adjacents.append(t)
s.adjacents.append(x)
t.adjacents.append(o)
t.adjacents.append(s)
t.adjacents.append(y)
u.adjacents.append(p)
u.adjacents.append(v)
v.adjacents.append(q)
v.adjacents.append(u)
v.adjacents.append(w)
w.adjacents.append(r)
w.adjacents.append(v)
w.adjacents.append(x)
x.adjacents.append(s)
x.adjacents.append(w)
x.adjacents.append(y)
y.adjacents.append(t)
y.adjacents.append(x)

let nodePath = findPath(a, y)
nodePath