anchor.diff:  
     /// If [room] is big enough, adds a floating room inside of it with a single
     /// entrance.
  -  bool decorateInnerRoom(Rect room) {
  +  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);
  +    var width = rng.range(3, room.width  - 2);
  +    var height = rng.range(3, room.height - 2);
  +    var x = rng.range(room.x + 1, room.right - width);
  +    var 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()) {
  +    var type = rng.oneIn(2) ? Tiles.wall : Tiles.lowWall;
  +    for (var pos in new Rect(x, y, width, height).trace()) {
         setTile(pos, type);
       }
   
  
positive.code:     }
  
      // If the rooms overlap horizontally, carve a horizontal path.
      final top = math.max(fromRoom.bounds.top, toRoom.bounds.top);
      final bottom = math.min(fromRoom.bounds.bottom, toRoom.bounds.bottom);
      if (top < bottom) {
        final left = math.min(fromRoom.bounds.left, toRoom.bounds.left);
        final right = math.max(fromRoom.bounds.right, toRoom.bounds.right);
  
        final y = rng.range(top, bottom);
        for (var x = left; x < right; x++) {
          setTile(new Vec(x, y), Tiles.floor);
        }
  
negative.code:     return true;
    }
  
    bool _isFloor(int x, int y) => stage.get(x, y).type == Tiles.floor;
    bool _isWall(int x, int y) => stage.get(x, y).type == Tiles.wall;
  
    void _addDoors() {
      // For each room, attempt to place doors along its edges.
      for (var room in _rooms) {
        // Top and bottom.
        for (var x = room.bounds.left; x < room.bounds.right; x++) {
          _tryHorizontalDoor(x, room.bounds.top - 1);
          _tryHorizontalDoor(x, room.bounds.bottom);
        }
  
        // Left and right.
        for (var y = room.bounds.top; y < room.bounds.bottom; y++) {
          _tryVerticalDoor(room.bounds.left - 1, y);
          _tryVerticalDoor(room.bounds.right, y);
        }
      }
    }
  
    void _tryHorizontalDoor(int x, int y) {
      // Must be an opening where the door will be.
      if (!_isFloor(x, y)) return;
  
      // Must be wall on either end of the door.
      if (!_isWall(x - 1, y)) return;
      if (!_isWall(x + 1, y)) return;
  
      // And open in front and behind it.
      if (!_isFloor(x, y - 1)) return;
      if (!_isFloor(x, y + 1)) return;
  
      _addDoor(x, y);
    }
  
    void _tryVerticalDoor(int x, int y) {
      // Must be an opening where the door will be.
      if (!_isFloor(x, y)) return;
  
      // Must be wall on either end of the door.
      if (!_isWall(x, y - 1)) return;
      if (!_isWall(x, y + 1)) return;
  
      // And open in front and behind it.
      if (!_isFloor(x - 1, y)) return;
      if (!_isFloor(x + 1, y)) return;
  
      _addDoor(x, y);
    }
  
    void _addDoor(int x, int y) {
      var type = Tiles.floor;
  
      var roll = rng.range(100);
  