 //
 
 import Foundation
-private struct NoWeight : Comparable, Summable {
-    private init() {}
-    static let value:NoWeight = NoWeight()
-}
-
-private func +(lhs: NoWeight, rhs: NoWeight) -> NoWeight {
-    return lhs
-}
-private func <(lhs:NoWeight, rhs:NoWeight) -> Bool {
+private enum OpenOrBlocked {
+    case Open
+    case Blocked
+}
+
+
+extension OpenOrBlocked : Comparable {
+
+}
+
+extension OpenOrBlocked : Summable {
+
+}
+
+
+private func +(lhs:OpenOrBlocked, rhs:OpenOrBlocked) -> OpenOrBlocked {
+    if lhs == .Blocked || rhs == .Blocked {
+        return .Blocked
+    }
+    return .Open
+}
+private func <(lhs:OpenOrBlocked, rhs:OpenOrBlocked) -> Bool {
+    if lhs == .Open {
+        return rhs == .Blocked
+    }
+
     return false
 }
 
-private func ==(lhs:NoWeight, rhs:NoWeight) -> Bool {
-    return true
-}
+
 
 public class GameBoard {
 
 
     private var positions:[Pandemic.Character:Int]
 
-    private let graph:WeightedGraph<City,NoWeight>
+    private let graph:WeightedGraph<City,OpenOrBlocked>
 
 
     init(withCharacters characters:[Pandemic.Character], inCity city:City) {

        let route = routesOut.filter { edge in
            let edgeDestinationCity = board.graph.vertexAtIndex(edge.v)
            return edgeDestinationCity.name == self.cityName
        }.first

        guard route != nil else {
            throw ExecutionError.DriveOrFerryCityUnreachable(to: cityName, from: currentCity.name)

        let washingtonIndex = graph.addVertex(City.washington)

        func addEdges(from: Int, to:[Int]) {
            to.forEach { graph.addEdge(from, to: $0, weight: .Open) }
        }

        addEdges(algiersIndex, to:[cairoIndex, istanbulIndex, madridIndex, parisIndex])
