Волновой алгоритм пускает волну только в одну сторону - C (СИ)

Формулировка задачи:

День добрый , проблема в том что волновой алгоритм пускает волну только в одну сторону, вроде все перебрал, толи глаз замулился , толи я ослеп, но не вижу проблему, чтож ему не нравится то?

#include <stdio.h>
#define SIZE1 30
#define SIZE2 30
char m[SIZE1][SIZE2];
int R[SIZE1][SIZE2];
void pos();
int main(){
 
    int ni, nk;
    for (int i = 0; i < SIZE1; i++){
        for (int b = 0; b < SIZE2; b++){
            m[i][b] = ' ';
            m[0][b] = m[i][0] = m[SIZE1 - 1][b] = m[i][SIZE2 - 1] = '#';//рисуем стеночки
        }
    }
    m[5][6] = '%';//точка начальная 
    m[5][10] = '#';//стена
    m[5][12] = '@';//точка конечная
    ni = 0;
    nk = 32;
    for (int i = 0; i < SIZE1; i++){
        for (int b = 0; b < SIZE2; b++){
            if (m[i][b] == ' ')
                R[i][b] = 50;
            if (m[i][b] == '#')
                R[i][b] = 51;
            if (m[i][b] == '@')
                R[i][b] = 0;
            if (m[i][b] == '%')
                R[i][b] = 49;
        }
    }
    int x, y;
    while (ni < nk){
        for (int i = 0; i < SIZE1; i++){
            for (int b = 0; b < SIZE2; b++){
                if (R[i][b] == ni){
                    if (R[i + 1][b] == 49){ pos(); break; }
                    if (R[i - 1][b] == 49){ pos(); break; }
                    if (R[i][b + 1] == 49){ pos(); break; }
                    if (R[i][b - 1] == 49){ pos(); break; }
 
                    if (R[i + 1][b] == 50){ R[i + 1][b] = ni + 1; }
                    if (R[i - 1][b] == 50){ R[i - 1][b] = ni + 1; }
                    if (R[i][b + 1] == 50){ R[i][b + 1] = ni + 1; }
                    if (R[i][b - 1] == 50){ R[i][b - 1] = ni + 1; }
                    ni += 1;
                }
            }
        }
    }
    //exit(1);
 
    m[5][12] = '@';
 
    for (int i = 0; i < SIZE1; i++){
        for (int b = 0; b < SIZE2; b++){
            printf("%c ", m[i][b]);
        }
        printf("\n");
    }
 
}
 
void pos(){
    int x, y, x1, y1;
    x = 5;
    y = 6;
    int min;
    min = 51;
    while (1){
        if (R[x + 1][y] < min){ min = R[x + 1][y]; x1 = x + 1; y1 = y; m[x1][y1] = '1'; }
        if (R[x - 1][y] < min){ min = R[x - 1][y]; x1 = x - 1; y1 = y; m[x1][y1] = '1'; }
        if (R[x][y + 1] < min){ min = R[x][y + 1]; x1 = x; y1 = y + 1; m[x1][y1] = '1'; }
        if (R[x][y - 1] < min){ min = R[x][y - 1]; x1 = x; y1 = y - 1; m[x1][y1] = '1'; }

        if (R[x][y] == 0) 
            break;
        else{
            x = x1;
            y = y1;
        }
        
    }
}

Решение задачи: «Волновой алгоритм пускает волну только в одну сторону»

Листинг программы

    while (ni < nk){
        for (int i = 0; i < SIZE1; i++){
            for (int b = 0; b < SIZE2; b++){
                if (R[i][b] == ni){
                    if (R[i + 1][b] == 49){ pos(); break; }
                    if (R[i - 1][b] == 49){ pos(); break; }
                    if (R[i][b + 1] == 49){ pos(); break; }
                    if (R[i][b - 1] == 49){ pos(); break; }
 
                    if (R[i + 1][b] == 50){ R[i + 1][b] = ni + 1; }
                    if (R[i - 1][b] == 50){ R[i - 1][b] = ni + 1; }
                    if (R[i][b + 1] == 50){ R[i][b + 1] = ni + 1; }
                    if (R[i][b - 1] == 50){ R[i][b - 1] = ni + 1; }
                    
                }
            }
        }
ni++;
    }

Объяснение кода листинга программы

Код представляет собой реализацию волнового алгоритма. Вот список действий, которые он выполняет:

Проверяет, достиг ли он границы массива размером SIZE1 на SIZE2.
Проверяет каждую ячейку массива R[i][b] на предмет значения равного текущей волне ni.
Если значение найдено, алгоритм проверяет каждую соседнюю ячейку на предмет значения 49 (смещение на одну ячейку в каждом направлении).
Если значение 49 найдено в любой из соседних ячеек, алгоритм делает шаг в этом направлении и помечает эту ячейку как часть текущей волны (ni + 1).
Если значение 49 не найдено ни в одной из соседних ячеек, алгоритм помечает текущую ячейку как часть текущей волны (ni + 1).
Увеличивает значение переменной ni на 1 после каждой итерации цикла.
Цикл продолжается до тех пор, пока значение ni не достигнет границы массива.