Play a Game of Minigolf Background
I feel that for a site named code-golf we have a shockingly little amount of golf being played. Let's fix that.
Challenge
Determine whether the hole of a minigolf course can be reached after exactly a certain number of movements and whether it can be reached at all.
How to play
Inputs are an integer &quot;power level&quot; and an ASCII art minigolf course. The ball starts on the X (capital) and the hole is an O (capital). The walls of the course are made of the characters + | - \ and /. The characters + | and - rotate the direction of the ball 180 degrees and the characters \ and / rotate the direction 90 degrees as you would expect. When a ball hits the wall it enters the wall for that turn and then leaves the next turn.
Launch the ball in each of the four cardinal directions from the starting X.

If the ball enters the hole after exactly the power level moves, then output truthy.
If the ball could make it to the hole given a different power level, then output mediumy.
If the ball cannot enter the hole regardless of the power level, output falsy.

Rules

This is code-golf so shortest answer in bytes wins.
Assume only valid input will be given.
All input strings will be rectangular. (All rows will be the same length)
Assume that there is no way to escape the course and leave the edge of the string.
No solution will require the ball to be in the same place facing the same direction twice.
Standard loopholes disallowed.
Only a string or a list of strings is acceptable for the course input.
Output can be any three distinct values.
The ball will never hit the characters | or - &quot;end-on.&quot;

Example
11
   -----+ 
  /   X | 
 | +----+ 
 | |      
 |O|      
 +-+      

This is true. If the ball starts heading east it will be on the wall after two movements.
   -----+ 
  /   X o&lt;- ball right here. movements:2
 | +----+ 
 | |      
 |O|      
 +-+      

It will then change directions until it hits the corner
   -----+ 
  o   X | movements:8
 | +----+ 
 | |      
 |O|      
 +-+      

Now it is heading south and will end in the hole after 11 moves. Note that 13 would also be true as the ball could bounce off of the bottom wall and into the hole. Other valid power levels for this course are 7 and 9.
Test Cases
All answers validated using this java code: https://github.com/Dragon-Hatcher/CodeGolfMiniGolf/tree/master/MinigolfCodeGolf/src
power
course
output

11
   -----+ 
  /   X | 
 | +----+ 
 | |      
 |O|      
 +-+      
          
truthy

10
    +---+ 
    | X | 
    +---+ 
 +-+      
 |O|      
 +-+        
          
falsy

25
                   
      ---------    
     /     X   \   
    +++-------+ |  
    | |       | |  
    |O|       | |  
    | \-------/ |  
     \         /   
      ---------    
                   
truthy

2
     
 +-+ 
 |X| 
 | | 
 | | 
 |O| 
 +-+      
                
mediumy

34
                
      +------+  
      |/    \|  
      | +--+ |  
      |X|  | |  
  +---+ +--+ |  
  |    O    /|  
  +---+ +----+  
      +-+       
                
true
APL (Dyalog Unicode), 146 115 bytes
{(∨/+⍺⊃⊢)∨⌿↑{'O'=1↓⊃¨⊢∘(((⊢,⍉∘⊖∘⌽¨)1⌽¨⊂,⊂∘⍉)⊃⍨1⌈¯2+'X O\/'⍳⊃)\(4×≢,⍵)⍴⊂⍵}¨({¯1+⊃⊃⍸'X'=⍵}⌽⍉)⍣2¨(⊢,⌽∘⊖¨)(⊂,⊂∘⍉)⍵,⍳≢⍵}

-31 bytes (!) thanks to @Bubbler (combining transformations; simplifying iteration end condition; smaller details)
Try it online!
Outputs 2 for truthy, 1 for mediumy, and 0 for falsy.
Similarly to my solution to Solve the Halting Problem for Modilar SNISP, this moves the grid around the ball location, so the ball is always in the top-left, moving right. This might not be the best strategy (as opposed to storing a pointer position and direction) in this case because the ball doesn't always start from the top-left moving right, so I spend many bytes rotating and aligning the grid.
Details
Append 1,2,3,4,...,n to the input grid.
This prevents symmetric grids from comparing equal after some sequence of moves
⍵,⍳≢⍵

We must be careful here and elsewhere in the code that we do not affect
the angle of / and \. Using a simple reflection ⌽ to reverse direction
should change / to \, but the reflection of the character '/' is '/'.
Conveniently, APL matrix reflection operators are visually sensible:

⌽ reflects across a vertical line: swaps / and \
⊖ reflects across a horizontal line: swaps / and \
⍉ (transpose) reflects across the main diagonal: no change

Thus we must use an even total number of ⌽ and ⊖ in all transforms.
Obtain all 4 starting directions/rotations:
(⊢,⌽∘⊖¨)(⊂,⊂∘⍉)

Shift each grid so that 'X' is in the top left
(Shifts 'X' to the left edge twice, transposing the matrix in between)
{(¯1+⊃⊃⍸'X'=⍵)⌽⍉⍵}⍣2¨

For each starting grid, beginning with the starting grid, repeat 4×#coordinates (= max # of states) times...
\(4×≢,⍵)⍴⊂⍵

...move by one step:
(((⊢,⍉∘⊖∘⌽¨)1⌽¨⊂,⊂∘⍉)⊃⍨1⌈¯2+'X O\/'⍳⊃)
  ⍝ Get the ID of the entry: `X`, ` `, or `O`:1, `\`:2, `/`:3, `|`,`+`, or `-`:4
  ⍝ We can consider |, +, and - as the same because we are always travelling
  ⍝ horizontally (albeit on a rotated grid), and these all do the same action 
  1⌈¯2+'X O\/'⍳⊃
  ⍝ Get the corresponding grid position after the move
  ((⊢,⍉∘⊖∘⌽¨)1⌽¨⊂,⊂∘⍉)⊃⍨

1 if there exists a move history whose final move's top-left element is O, and add another 1 if there exists a move history where the ⍺-th move has top-left element equal to O.
(∨/+⍺⊃⊢)∨⌿↑{'O'=1↓⊃¨