Random Map Generator - Creating areas on a grid - php

Question

I'm developing a game which requires a randomly generated map. The map is going to be, effectively, a giant grid containing mostly emptiness with objects scattered about, grouped in regions. The idea is that I first generate these regions, then individual classes for each region type handle the generation of the map within the regions.
What I'm currently trying to do is generate these regions randomly on a grid. The regions will always be rectangles or squares and of any size, and the grid itself could also be of any size (again, either rectangular or square).
So to simplify all this down, I'm trying to generate randomly proportioned rectangles on a grid of arbitrary size. For the record, when I say arbitrary, I mean seriously large - we could be looking at sizes as high as 100,000 x 100,000, potentially. Regions are probably going to be a maximum of 100x100, but again, the script should be able to cope with any size.
Just to throw some more constraints out there, these regions cannot overlap. Ultimately, both the regions, and the objects generated within each region will be put into a MySQL database.
I initially thought that using a 2 dimensional array to represent the entire grid and simply marking spaces as taken within that would be fine, and it was in initial tests for small sized grids. I found for very large grids, Php complained about exceeding the memory limit and would not execute the script.
Another approach I thought about taking but haven't tried is inserting regions into the database as they are created and then running a query on the database to see if an area is empty or not every time it is required. I'm confident I could make this work, but the amount of database queries would be huge. I can reduce the number of tests required by eliminating certain squares that I can know for sure to be unusable via purely mathematical means, but for large grids we're still talking a massive amount of queries. This would make the script really, really time intensive and I can't help but feel that it's unnecessary. I'd prefer to do things another way, if possible.
The last method I thought of is purely mathematical, and would be perfect if I could make it work. I used only two variables - maximum x and maximum y to store the highest value on each axis. When testing to create a region I simply checked if the new region's top left coordinate was lower than both the maximum x and y - if it was, the space could not be used. If either one was higher, there was no issue and the region was created. Some of you might spot the problem here I imagine, but to cut a long story short there's certain situations where this system would judge an empty space to be unusable, so masses of random empty blocks appeared when I ran the script.
So, I'm stuck. I can't help but feel that there's a good mathematical solution to this that uses a fixed number of variables, but I can't see it. Failing that, does anyone know of another way to achieve what I'm looking for?

Answer 1

Have a read through this, maybe it will help. I haven't tested it, but I have commented my intentions so you should be able to come up with something based on it.
//create some globals we will need
$region_id = 1;
$current_x = 0;
$current_y = 0;
$squares = array();
//Create the base grid
$grid = array(GRID_WIDTH);
foreach($grid as $a)
{
$a = array(GRID_HEIGHT);
$a = array_fill(0, count($a), 0);
}
//$grid[0][0] will be the top left square
//Iterates over the grid until it is full
while($current_x != (-1) && $current_y != (-1))
{
//We just need to set these counters back to their minimums
$max_x = $current_x;
$max_y = $current_y;
//Lets see how many spaces we have between current x and end of the row
//$max_x will be the maxiumum newX2
for($x = $current_x; $x<GRID_WIDTH; $x++)
{
if($grid[$x][$current_y]==0)
{
$max_x = $x;
}
}
//Lets create a width between 1 and the max left in the row
$newX1 = $current_x;
$newX2 = rand($current_x, $max_x)
//Now lets see how tall we can make it by going down the y until we hit a square or the end.. do for each x
for($x = $newX1; $x<newX2;$x++)
{
for($y = $current_y; $y<GRID_HEIGHT; $y++)
{
if($grid[$x][$y]==0)
{
//We just need the maxiumum y we can have based on our already determined width
//Since this distance has to be smallest possible distance
//We only let max_y get larger on the first iteration of x
if($y>$max_y && $x==$newX1)
{
$max_y = $y;
}
}
}
}
//lets create a height bettwen 1 and the max
$newY1 = $current_y;
$newY2 = rand($current_y, $max_y);
//create a spacewith these values
occupySpace($newX1, $newX2, $newY1, $newY2, $grid, $region_id);
$squares[] = array($newX1, $newX2, $newY1, $newY2);
//Iterate over the grid looking for an empty space
//First lets set current_x and current_y to -1. We will use this to evalute done
$current_x = -1;
$current_y = -1;
for($x = 0; $x<GRID_WIDTH; $x++)
{
for($y = 0; $y<GRID_HEIGHT; $y++)
{
//Looking for any space that hasn't been occupied, if one is found break both for loops
if($grid[$x][$y]==0)
{
$current_x = $x;
$current_y = $y;
break 2;
}
}
}
}
//fills all spaces in the region with the current region id and increments region id
function occupySpace($x1, $x2, $y1, $y2, &$grid, &$region_id)
{
for($x=$x1; $x<$x2; $x++)
{
for($y=$y1; $y<$y2; $y++)
{
$grid[$x][$y] = $region_id;
}
}
$region_id += 1;
}
?>
Update: This solution didn't originally keep track the 'regions' that were created. Now they exist in array $squares.
PS - If this is going to be a big part of your script/business I would consider writing some classes for Grid and region,

Answer 2

there is no need to save every bit of information into the db. For every rectangle you only need top/left-coordinates + width/height.
then you should be able get the maximum available space for a given coordinate with with one query (e.g. getting minimum-x which is bigger than your-x and also lies within the needed y-space)
Update:
For max-width you can use:
SELECT `x` - :x AS `maxWidth`
FROM `test`
WHERE `x` > :x
AND (`y` > :y OR `y` + `h` > :y)
ORDER BY `y`, `y` + `h`
LIMIT 1
and max-height:
SELECT `y` - :y AS `maxHeight`
FROM `test`
WHERE `y` > :y
AND (`x` > :x OR `x` + `w` > :x)
ORDER BY `x`, `x` + `w`
LIMIT 1