bool RTSMap::GenerateTDMaze()

in rts/engine/map.cc [48:113]

• 62 lines of code
• 21 McCabe index (conditional complexity)

bool RTSMap::GenerateTDMaze(const std::function<uint16_t(int)>& f) {
    const int blank = 3;
    int m = _m / 2;
    int n = _n / 2;
    _map.assign(_m * _n * _level, MapSlot());
    for (int x = 0; x < _m; x++) {
        for (int y = 0; y < _n; y++) {
        if ((x < _m - blank * 2) || (y < _n - blank * 2))
            _map[GetLoc(Coord(x, y))].type = IMPASSABLE;
        }
    }
    int maze[m * n];
    for (int i = 0; i < m * n; i++) {
        maze[i] = 0;
    }
    vector<int> current;
    // base
    // wave starting area
    for (int x = m - blank; x < m ; x++) {
        for (int y = n - blank; y < n; y++) {
            maze[x * m + y] = 1;
            if ((x == m - blank) || (y == n - blank)) current.push_back(x * m + y);
        }
    }
    int dx[] = { 1, 0, -1, 0 };
    int dy[] = { 0, 1, 0, -1 };
    vector<int> next;
    vector<int> previous;
    for (int c : current) {
        for (size_t i = 0; i < sizeof(dx) / sizeof(int); ++i) {
            int xn = c / m + dx[i];
            int yn = c % m + dy[i];
            if ((xn < 0) || (xn >= m) || (yn < 0) || (yn >= n) || (maze[xn * m + yn] == 1)) continue;
            next.push_back(xn * m + yn);
            previous.push_back(i);
        }
    }

    //91 slots to be filled
    int iter = 0;
    while (iter < m * n - blank * blank) {
        int next_size = next.size();
        int rd = f(next_size);
        int curr = next[rd];
        int coming_from = previous[rd];
        next.erase(next.begin() + rd);
        previous.erase(previous.begin() + rd);
        if (maze[curr] == 1) {
            continue;
        }
        iter ++;
        maze[curr] = 1;
        int xc = curr / m;
        int yc = curr % m;
        _map[GetLoc(Coord(xc * 2, yc * 2))].type = NORMAL;
        _map[GetLoc(Coord(xc * 2 - dx[coming_from], yc * 2 - dy[coming_from]))].type = NORMAL;
        for (size_t i = 0; i < sizeof(dx) / sizeof(int); ++i) {
            int xn = xc + dx[i];
            int yn = yc + dy[i];
            if ((xn < 0) || (xn >= m) || (yn < 0) || (yn >= n) || (maze[xn * m + yn] == 1)) continue;
            next.push_back(xn * m + yn);
            previous.push_back(i);
        }
    }
    return true;
}