Can I exit the maze with this many bombs? Inspired by this Puzzling challenge, and easier version of my previous challenge.
Challenge
A 2D rectangular grid is given, where each cell is either an empty space or a wall. You start at the top left cell, and you need to exit through the bottom right cell. You can move to one of four adjacent cells in one step.
You have some bombs, so that using one bomb will let you break exactly one cell-sized wall and go through it. Can you exit the maze using just what you have?
Input and output
The input is the maze and the initial number of bombs. The maze can be taken as a matrix (or any equivalent) containing two distinct values to represent empty spaces and walls. The top left and bottom right cells are guaranteed to be empty. The number of bombs n is always a non-negative integer.
The output should be truthy if you can exit the maze using n or fewer bombs, falsy otherwise. You can output truthy/falsy using your language's convention (swapping is allowed), or use two distinct values to represent true or false respectively.
Standard code-golf rules apply. The shortest code in bytes wins.
Test cases
Uses .# for spaces and walls.
Input maze
..#..#..
Output: false (for 0 or 1 bomb), true (≥2 bombs)

Input maze
.....
####.
.....
.####
.....
Output: true (for any bombs)

Input maze
.
Output: true (for any bombs)

Input maze
.#.#.
##.##
.###.
Output: false (for ≤2 bombs), true (≥3 bombs)

Input maze
.####
#####
##.##
#####
####.
Output: false (for ≤5 bombs), true (≥6 bombs)
JavaScript (ES7),  126 125  119 bytes
Expects (matrix)(bombs), where the matrix is filled with -1 for an empty cell and -2 for a wall.
Returns false if we can exit the maze, or true if we can't.

m=&gt;g=(b,X=0,Y=0)=&gt;m.every((r,y)=&gt;m[Y+1]||r[X+1]?r.every((v,x)=&gt;r[x]*=v&gt;0|(X-x)**2+(Y-y)**2!=1||g(b-~v,x,y,r[x]=1)):b&lt;0)

Try it online!
Commented
m =&gt;                        // m[] = matrix
g = (                       // g is a recursive function taking:
  b,                        //   b = number of bombs
  X = 0, Y = 0              //   (X, Y) = current position, starting at (0, 0)
) =&gt;                        //
  m.every((r, y) =&gt;         // for each row r[] at position y in m[]:
    m[Y + 1] ||             //   if there's a row below the current cell
    r[X + 1] ?              //   or there's a column on the right:
      r.every((v, x) =&gt;     //     for each value v at position x in r[]:
        r[x] *=             //       restore r[x] if any of these tests is true:
          v &gt; 0 |           //         - v is greater than 0 (this cell was visited)
          (X - x) ** 2 +    //         - the squared distance between
          (Y - y) ** 2 != 1 //           (x, y) and (X, Y) is not equal to 1
          ||                //
          g(                //         - this recursive call is truthy:
            b - ~v,         //             decrement b if v = -2
            x, y,           //             use the new position (x, y)
            r[x] = 1        //             mark r[x] as visited by setting it to 1
          )                 //           end of recursive call
      )                     //     end of inner every()
    :                       //   else (bottom-right cell):
      b &lt; 0                 //     return true if we've used too many bombs
  )                         // end of outer every()