anchor.diff:      // Layout the rooms.
       addRooms(_numRooms);
   
  -    carveRooms();
  -    carveCorridors();
  -
  -    decorateRooms((room) {
  -      if (rng.oneIn(5)) decorateTable(room);
  +    _carveRooms();
  +    _carveCorridors();
  +
  +    _decorateRooms((room) {
  +      if (rng.oneIn(5)) _decorateTable(room);
       });
   
  -    addDoors();
  -  }
  -
  -  bool allowRoomOverlap(Rect a, Rect b) => rng.oneIn(20);
  +    _addDoors();
  +  }
  +
  +  bool _allowRoomOverlap(Rect a, Rect b) => rng.oneIn(20);
   }
   
   abstract class Dungeon extends StageBuilder {
  -  final List<Room> _rooms;
  -  final Set<int> _usedColors;
  +  final _rooms = <_Room>[];
  +  final _usedColors = new Set<int>();
   
     int get roomWidthMin => 3;
     int get roomWidthMax => 12;
  
positive.code: 
    /// If [room] is big enough, adds a floating room inside of it with a single
    /// entrance.
    bool decorateInnerRoom(Rect room) {
      if (room.width < 5) return false;
      if (room.height < 5) return false;
  
      final width = rng.range(3, room.width  - 2);
      final height = rng.range(3, room.height - 2);
      final x = rng.range(room.x + 1, room.right - width);
      final y = rng.range(room.y + 1, room.bottom - height);
  
      // Trace the room.
      final type = rng.oneIn(2) ? Tiles.wall : Tiles.lowWall;
      for (final pos in new Rect(x, y, width, height).trace()) {
        setTile(pos, type);
      }
  
  
negative.code:       var nearestTo = null;
        var nearestDistance = 9999;
  
        for (var fromRoom in _rooms) {
          if (fromRoom.color != fromColor) continue;
  
          for (var toRoom in _rooms) {
            if (toRoom.color == fromColor) continue;
  
            var distance = fromRoom.bounds.distanceTo(toRoom.bounds);
            if (distance >= nearestDistance) continue;
            nearestFrom = fromRoom;
            nearestTo = toRoom;
            nearestDistance = distance;
          }
        }
  
        _carveCorridor(nearestFrom, nearestTo);
      }
  
      // Add some extra corridors so the dungeon isn't a minimum spanning tree.
      _forEachRoomPair((fromRoom, toRoom) {
        var distance = fromRoom.bounds.distanceTo(toRoom.bounds);
        if (distance >= extraCorridorDistanceMax) return;
        if (!rng.oneIn(extraCorridorOneIn + distance *
                extraCorridorDistanceMultiplier)) return;
        _carveCorridor(fromRoom, toRoom);
      });
    }
  
    void _carveCorridor(_Room fromRoom, _Room toRoom) {
      _mergeColors(fromRoom, toRoom);
  
      // If the rooms overlap horizontally, carve a vertical path.
      var left = math.max(fromRoom.bounds.left, toRoom.bounds.left);
      var right = math.min(fromRoom.bounds.right, toRoom.bounds.right);
      if (left < right) {
        var top = math.min(fromRoom.bounds.top, toRoom.bounds.top);
        var bottom = math.max(fromRoom.bounds.bottom, toRoom.bounds.bottom);
  
        var x = rng.range(left, right);
        for (var y = top; y < bottom; y++) {
          setTile(new Vec(x, y), Tiles.floor);
        }
  