anchor.diff:          }
         }
   
  -      switch (this.diagonalMovement) {
  +      switch (diagonal) {
           case DiagonalMovement.Always:
             allowedCorners.add(corner);
             break;
  
positive.code:     return new Grid(boolGrid);
    }
  
    /// Return a list of nodes that are the neighbors of [node].
    ///
    /// By default, will only return only the neighbor nodes that are walkable.
  
negative.code:     return this._grid[point.y][point.x];
    }
  
    /// Return a list of all the "exterior corners" of this [Grid].
    ///
    /// An "exterior corner" is defined as any walkable [Node]
    /// diagonally adjacent to a non-walkable [Node] that has
    /// 0 obstructions. An obstruction in defined in the doc
    /// string for the DiagonalMovement enum.
    List<PointNode> getExteriorCorners() {
      Set<PointNode> exteriorCorners = new Set<PointNode>();
  
      for (int x = 0; x < this.cols; x++) {
        for (int y = 0; y < this.rows; y++) {
          PointNode center = this.nodeFromPoint(new Point(x, y));
          if (!center.walkable) {
            exteriorCorners.addAll(
                this._getCorners(center, true, DiagonalMovement.WithNoObstructions));
          }
        }
      }
  
      return exteriorCorners.toList();
    }
  
    /// Construct an [UndirectedPointGraph] from this [Grid]s exterior corners.
    ///
    /// The Graph is optimized to only hold adjacencies between
    /// exterior corners who are "line of sight" with each other,
    /// meaning there are no non-walkable nodes on the straight
    /// line between them.
    UndirectedPointGraph getExteriorCornersGraph() {
      List<PointNode> exteriorCorners = this.getExteriorCorners();
  
      UndirectedPointGraph exteriorCornersGraph = new UndirectedPointGraph();
  
      for (PointNode outerNode in exteriorCorners) {
        for (PointNode innerNode in exteriorCorners) {
          if (_isWalkableLine(outerNode, innerNode)) {
            exteriorCornersGraph.addAdjacency(outerNode, innerNode);
          }
        }
      }
  
      return exteriorCornersGraph;
    }
  
    List<PointNode> _getCorners(PointNode node, bool onlyWalkable,
        DiagonalMovement diagonal) {
      if (diagonal == DiagonalMovement.Never) return [];
  
      List<Point> offsets = const [
        const Point(-1, -1), const Point(1, -1),
        const Point(-1, 1), const Point(1, 1)];
  