Лучевой алгоритм трассировки

#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>       // for time() only
#include <Windows.h>   // for Sleep() only
 
using namespace std;
 
typedef unsigned char Byte;
typedef char Color;
 
struct Cell {
    Color WireColor;
};
 
typedef vector<Cell> CellVec;
 
// Возвращает true, если найдена свободная соседняя ячейка
bool fndCll(int kP2, const CellVec &arrB, Color clrE, Color clr, int, int nT) {
    if (kP2 >= 0 && kP2 < nT) {
        Color wc = arrB[kP2].WireColor;
        return wc == clrE || wc == clr;
    }
    return false;
}
 
void i2c(int nx, int index, int &x, int &y) {
    x = index % nx;
    y = index / nx;
}
 
const Color RED('R');
const Color BLUE('B');
const Color BLACK('T');
 
void print(int nx, int ny, const CellVec &arrB) {
    system("cls");
    for (int i = 0; i < ny; ++i) {
        for (int j = 0; j < nx; ++j) 
            cout << ' ' << arrB[i * nx + j].WireColor;
        cout << endl;
    }
    //system("pause");
    Sleep(300);
}
 
int main()
{
    srand((unsigned int)time(NULL));
 
    Color clr('.');
    Color clr2('#');
    CellVec arrB;
    int nx = 40;
    int ny = 20;
    int nT = nx * ny;
    // Формируем дискретное рабочее поле из nx * ny ячеек
    arrB.resize(nT);
    for (int i = 0; i < nT; ++i) arrB[i].WireColor = clr;
    print(nx, ny, arrB);
 
    int nC = (int)(0.2 * nT);
    // Формируем nC ячеек - препятствий
    for (int k = 0; k < nC; ++k) {
        int k2 = rand() % nT;
        arrB[k2].WireColor = clr2;
    }
    print(nx, ny, arrB);
 
    int xS, yS, xE, yE;
    xS = yS = xE = yE = 0;
 
    // Выбираем ячейку - источник
    int kS;
    // kS = 0;   // фиксированная точка начала пути
    kS = rand() % nT;
    i2c(nx, kS, xS, yS);
    arrB[kS].WireColor = BLUE;
    print(nx, ny, arrB);
 
    // Выбираем ячейку - приемник
    int kE;
    // kE = nT - 1;   // фиксированная точка конца пути
    kE = rand() % nT;
    i2c(nx, kE, xE, yE);
    arrB[kE].WireColor = BLACK;
    print(nx, ny, arrB);
 
    // Формирование пути
    int kC = kS;
    int nMx = 100;
    int i = 0;
    int x = xS;
    int y = yS;
    int d = abs(xE - x) + abs(yE - y);
    while (i < nMx && kC != kE) {
        vector<int> arrD{ d, d, d, d };
        i += 1;
        // Находим свободного, ближайшего к приемнику соседа текущей ячейки kC
        if ((kC + 1) % nx != 0 && fndCll((kC + 1), arrB, BLACK, clr, i, nT))
            arrD[0] = abs(xE - x - 1) + abs(yE - y);
        if (fndCll((kC + nx), arrB, BLACK, clr, i, nT))
            arrD[1] = abs(xE - x) + abs(yE - y - 1);
        if (kC % nx != 0 && fndCll((kC - 1), arrB, BLACK, clr, i, nT))
            arrD[2] = abs(xE - x + 1) + abs(yE - y);
        if (fndCll((kC - nx), arrB, BLACK, clr, i, nT))
            arrD[3] = abs(xE - x) + abs(yE - y + 1);
        int dM = *min_element(arrD.begin(), arrD.end());
 
        if (dM == d) {
            cout << "The path is not found" << endl;
            return 1;
        }
        int kM = distance(arrD.begin(), find(arrD.begin(), arrD.end(), dM));
        switch (kM) {
            case 0: x += 1; kC += 1; break;
            case 1 : y += 1; kC += nx; break;
            case 2 : x -= 1; kC -= 1; break;
            case 3 : y -= 1; kC -= nx; break;
        }
        Cell &bx = arrB[kC];
        bx.WireColor = RED;
        if (kC == kE)
            bx.WireColor = BLACK;
        print(nx, ny, arrB);
    }
    cout << "Target is reached. Trace length " << i << " steps." << endl;
}