Randomising level layout (AS3/Flashpunk) - actionscript-3

Question

I'm cutting my teeth on randomization in games and trying to figure out the trick that games like Binding Of Isacc & Sperlunky use of pre-fab level fragments arranged randomly to create a functional floor/level, something along the lines of this:
A floor will always contain the player, exit and a bonus room (yellow dot). Rooms that are connected are directly connected to each other.
I have a faint idea of how to go about it: Start by creating an multi-dimensional array that holds the tilemap & grid data:
public static var levelLayout:Array =
[[tile,grid],[tile,grid],[tile,grid],[tile,grid]
[tile, grid],[tile,grid],[tile,grid],[tile,grid] etc]
And from there, go through each grid space, roll to see if that spot is nothing, also making rooms nothing if they are isolated and then begin to assign rooms from an shuffled array that contains all the tilemaps/grids.
Am I on the right track? How should I handle the exits? Any help would be appreciated. Cheers

Answer 1

Start by making a perfect maze (a maze where you can get to any point in the maze from anywhere else in the maze). This helps create a network of rooms that are connected in a winnable/solvable way.
There are plenty of tutorials out there for doing this. This one is a little dirty and has a bunch of code you may not need, but it's good to look through some relevant examples of this to understand different approaches:
http://www.emanueleferonato.com/2008/11/28/perfect-maze-generation-with-as3/
I've had good luck with a recursive backtracking algorithm:
http://en.wikipedia.org/wiki/Maze_generation_algorithm#Recursive_backtracker
Consider each cell in the maze to be a room. Once the maze is built, you know which rooms are connected to other rooms, so make each room have a means for either having a door to connect to the next room, or a wall. You probably would want to make like a 4x4 perfect maze.
Ways to spice it up-
You can safely remove deadends from your maze and it will still be perfect. Once the maze is generated, loop through all cells in the maze. Any cell that has 3 walls is a dead end, and you can wall it off completely. Or make it a secret room or whatever.
Add loops to the maze. Randomly connect 2 rooms in the maze that weren't previously connected. This still keeps the maze perfect, it just makes it a little more open.
This is fun territory, enjoy it :)

Answer 2

I've actually been looking into information like this myself recently, having been inspired by Spelunky and Rogue Legacy. While reading around, I found there is a lot of information on how the level layout in Spelunky is generated at http://tinysubversions.com/spelunkyGen/
Inspired(stolen?) by this, I've rigged up a simple version of this to generate a multidimensional Array with a single solution path, using the numbers 0-5 to identify what type of room each cell represents (based off the site listed above). Note that you could easily have it return a different type of result based on your needs. Also I've used Math.random() throughout but you could substitute FP.rand() if you wanted. Supports level layouts of whatever size Room x Room, default is 4 x 4. Some random results I've had [EDITED TO MAKE MORE READABLE]:
4 x 4 6 x 5 7 x 12
[S][ ][ ][ ] [ ][ ][ ][ ][ ][S] [v][-][-][-][-][-][S]
[v][ ][ ][ ] [ ][ ][v][-][-][^] [^][-][-][-][-][-][v]
[^][-][-][v] [ ][v][^][ ][ ][ ] [ ][ ][v][-][-][-][^]
[E][-][-][^] [v][^][ ][ ][ ][ ] [v][-][^][ ][ ][ ][ ]
[^][-][-][-][-][E] [v][ ][ ][ ][ ][ ][ ]
[^][-][-][-][-][-][v]
[ ][ ][v][-][-][-][^]
[v][-][^][ ][ ][ ][ ]
[v][ ][ ][ ][ ][ ][ ]
[^][-][-][-][-][-][v]
[ ][ ][ ][ ][ ][ ][v]
[E][-][-][-][-][-][^]
In any case, I think it's better suited for the 4x4 layout of Spelunky (gee, I wonder why) and I'm pretty sure that I'm going about it slightly off, but here's my code:
/**Generates a pseudo-random single solution path layout to be used for tile painting
* #param dimenR Number of rows (Y-Axis) Should correspond with height of level, in rooms
* #param dimenC Number of columns (X-Axis) Should correspond with width of level, in rooms
* #return The resulting multi-dimensional array*/
private function generateNewRoomLayout(dimenC:int = 4, dimenR:int = 4):Array {
// NOTE: 0= non solution, 1= left/right, 2= left/right/down, 3= left/right/up, 4= start, 5= end
// Initialize array as all non-solution path rooms
var generatedLayout:Array = new Array(dimenR);
for (var i:int = 0; i < dimenR; i++) {
generatedLayout[i] = new Array(dimenC);
for (var j:int = 0; j < dimenC; j++) { generatedLayout[i][j] = 0; }
}
// Initialize our Start Room location
/**Position along X-Axis in the grid*/
var column:int = Math.random() * dimenC;
/**Position along Y-Axis in the grid*/
var row:int = 0;
generatedLayout[row][column] = 4;
/**Chooses the next direction. 0-1= left, 2-3= right, 5= down*/
var chooseDirection:int = Math.random() * 6;
/**Direction solution path is currently taking. -1= left, 1= right*/
var currentDirection:int = 0;
// Keep running until our position goes beyond the dimension of the grid
while (row < dimenR) {
// Chosen to go downards
if (chooseDirection == 5) {
// Reset which way we're going so we can make a random choice later
currentDirection = 0;
if (generatedLayout[row][column] != 4) { generatedLayout[row][column] = 2; }
// Bottom row
if (row == dimenR - 1) {
generatedLayout[row][column] = 5; // Found our ending point
break;
}
else {
row++;
generatedLayout[row][column] = 3;
}
}
else {
// If we don't have a direction to go left/right
if (currentDirection == 0) {
if (chooseDirection < 3) { currentDirection = -1; }
else { currentDirection = 1; }
}
// If we're at the edge of the grid and trying to move past it, we move down and flip our direction instead
if ((currentDirection < 0 && column == 0) || (currentDirection > 0 && column == dimenC - 1)) {
currentDirection = -currentDirection;
generatedLayout[row][column] = 2;
if (row == dimenR - 1) {
generatedLayout[row][column] = 5;
break;
}
else {
row++;
generatedLayout[row][column] = 3;
}
}
else {
column += currentDirection;
generatedLayout[row][column] = 1;
}
}
chooseDirection = Math.random() * 6;
}
return generatedLayout;
}