A very handy way to generate unsigned integers is with the fsu random object generator. Include these files:
#include <xran.h> #include <xran.cpp>
and declare an object and use it like this:
static fsu::Random_unsigned_int ran; ... x = ran(a,b); // x is a random unsigned int in the range a <= x < b y = ran(0,4); // y is a random choice of 0,1,2,3 (N,E,S,W) z = ran(0,2); // z is a random choice of 0 or 1 (coin flip)
This generator uses the Marsaglia KISS generator as its underlying engine.
The keyword static in this context has the meaning inherited from C: The object will be initialized the first time it comes into scope and remain alive during the remaining execution, going in and out of scope as needed.
An effective way to organize ranmaze.cpp is to write a function
void Connect(
size_t beg , size_t end , // start and goal cells
size_t numrows, size_t numcols, // maze dimensions
fsu::Vector<uint8_t>& maze , // walls codes for cells - passed by reference
fsu::Partition<size_t>& p // tracks component structure - passed by reference
);
that can be called from main() once for the "first pass" maze and subsequently as often as needed for the "one component" maze. Note that the maze data and partition data are passed by reference so that modifications made in a call to Connect will affect the data in the calling process. The organization is then left to function main:
int main (int argc, char* argv[])
{
...
size_t numcells = numrows * numcols;
start = ??;
goal = ??;
fsu::Vector<uint8_t> maze (numcells, 15); // all closed boxes
fsu::Partition<size_t> p (numcells); // all singletons
// ensure goal is reachable from start:
std::cout << " components after 0 passes: " << p.Components() << '\n';
Connect (start, goal, numrows, numcols, maze, p);
size_t components = p.Components();
std::cout << " components after 1 pass: " << components << '\n';
if (components > 1) // output intermediate result the first time goal is reachable
{
// build filename filec
...
// output first pass maze
out1.open(filec);
WriteMaze(out1, start, goal, numrows, numcols, maze);
out1.close();
out1.clear();
std::cout << "1-pass maze written to file " << filec << '\n';
}
// continue until all cells are reachable
if (components > 1)
{
for (size_t cell = 1; cell < numcells; ++cell)
{
Connect (0, cell, numrows, numcols, maze, p);
}
}
std::cout << " components after all passes: " << p.Components() << '\n';
out1.open(file1);
WriteMaze(out1, start, goal, numrows, numcols, maze);
out1.close();
out1.clear();
std::cout << "n-pass maze written to file " << file1 << '\n';
...
}
Building the filename is just the metedious [meticulous + tedious] work of creating the correct size null-terminated character array and putting all the characters in the right place. You need two such file names "filec" and "file1" each of which is the user input filename "file" with an extension appended. To get the extension for filec, unfortunately there is no "itoa" in the library, so you need the number of digits = 1 + (size_t)log10(components) and a loop that finds the digits:
for (size_t i = 0; i < digits; ++i)
{
char digit = '0' + (char)(components % 10);
// put this digit in the correct place in filec
components /= 10;
}
This loop calculates the digits. You have to put them in the correct place in
the file name array. Don't forget the null terminator. (You can also
use std::stringstream if you prefer.)
Here is a way to get started on the main program, including the handy constants for four atomic walls:
const uint8_t NORTH = 0x01;
const uint8_t EAST = 0x02;
const uint8_t SOUTH = 0x04;
const uint8_t WEST = 0x08;
...
int main (int argc, char* argv[])
{
if (argc < 4)
{
std::cout << "** command line arguments required:\n"
<< " 1: number of rows\n"
<< " 2: number of cols\n"
<< " 3: file name for maze\n"
return 0;
}
size_t numrows = atoi(argv[1]);
size_t numcols = atoi(argv[2]);
...
}
The wall constants are global, hence accessible from Connect()
The following image is of a maze generated by ranmaze. Start and goal cells marked red/green, respectively.
