MazeGenerator Class

package {

    /**
     * ...
     * @author netgrind (Cale Bradbury)
     *
     * If you find this useful let me know, I'd love to see what you do with it. Use it for whatever! (Some credit would be nice though :3)
     *
     * The only function you need to call for a maze is gatMaze.
     * Gat is a spelling mistake for get that I deceide to leave in as I created this for a gun game thing droqen and I were messing around with
     *
     * The function returns an array of 0's and 1's, 0 being solid space (player never touches) and 1's being where the player can be
     *
     * roomSize is number of tiles in a room, it gets around that number as a rectangle (25 could be 5x5 room or 3x8)
     * rooms is the number of rooms it plops down
     * hall length is a buffer of solid around the room so halls can form
     * pillars is how many pillars it just randomly tries to place down all over the map
     * boarder is a boarder of solid around the full map
     * link attempts is how many times it tries to link rooms together, after all the tries it removes any unlinked bits of room
     *
     * The loadout I'm rocking in the demo is MazeGenerator.gatMaze(100, 10, 2, 100, 1);
     *
     * demo - http://www.netgrindgames.com/cale/LD25.swf
     * controls - arrows, restart for a new map.
     */
    public class MazeGenerator {

        public static function gatMaze(roomSize:int, rooms:int, hallLength:int,  pillars:int, boarder:int=0, linkAttempts:int = 50):Array {

            //var worldSize:int = Math.sqrt(roomSize) + Math.sqrt(rooms) + Math.sqrt(hallLength);
            //var worldSize:int = (roomSize*.5) + (rooms*.5) + (hallLength*.5);
            var worldSize:int = (roomSize + rooms + (hallLength*rooms*.5))*.25;
            var level:Array = getBlankWorld(worldSize, worldSize);

            for (var i:int = 0; i < rooms; i++) {
                var room:Array = createRoom(roomSize, hallLength);
                level = mergeArrays(level, room, Math.random()*(level.length-room.length), Math.random()*(level[0].length - room[0].length));
            }//end for

            level = changeValue(level, 2, 0);
            level = addPaths(level, hallLength, linkAttempts);
            level = addPillars(level, pillars);
            return mergeArrays(getBlankWorld(worldSize+boarder*2, worldSize+boarder*2),level,boarder,boarder);
        }//ed gatMaze

        static public function addPillars(level:Array, pillars:int):Array {
            do {

                pillars--;
                var i:int = Math.ceil(Math.random() * (level.length - 3)) + 2;
                var j:int = Math.ceil(Math.random() * (level[0].length - 3)) + 2;
                if (
                level[i][j] == 1 &&
                level[i+1][j] == 1 &&
                level[i-1][j] == 1 &&
                level[i-1][j+1] == 1 &&
                level[i-1][j-1] == 1 &&
                level[i+1][j-1] == 1 &&
                level[i+1][j+1] == 1 &&
                level[i][j+1] == 1 &&
                level[i][j - 1] == 1) {
                    level[i][j] = 0;
                }
            }while (pillars > 0 );
            return level;
        }

        public static function addPaths(level:Array,path:int, attempts:int):Array {

            do {
                var i:int = Math.floor(Math.random() * level.length);
                var j:int = Math.floor(Math.random() * level[0].length);
            }while (level[i][j] != 1);
            var hasHitEmpty:Boolean = false;
            for (var k:int = j; k < level[i].length; k++) {
                if (level[i][k] == 0 ) {//&& level[i][k - path] == 1 && level[i][k+path]==1 ) {
                    hasHitEmpty = true;
                }else if (hasHitEmpty&&level[i][k] == 1) {
                    for (var n:int = j; n <= k; n++){
                        level[i][n] = 1;
                    }
                    break;
                }
            }//end for
            if (levelValid(level)) {
                return level;
            }else {
                attempts --;
                if(attempts>0){
                    level = rotateArray(level);
                    level = addPaths(level, path, attempts);
                }else {
                    var biggest:int = 0;
                    for (i = 0; i < level.length; i++) {
                        for (j = 0; j < level[i].length; j++) {
                            if (level[i][j] == 1) {
                                floodFill(level, i, j, 1, 2);
                                var size:int = numberOfValue(level, 2);
                                if (size > biggest) {
                                    biggest = size;
                                    changeValue(level, 3, 0);
                                    changeValue(level, 2, 3);
                                }else {
                                    changeValue(level,2, 0);
                                }

                            }
                        }
                    }
                    changeValue(level, 3, 1);
                }
            }
            return level;

        }

        public static function levelValid(level:Array):Boolean{
            for (var i:int = 0; i < level.length; i++) {
                var j:int = level[i].lastIndexOf(1);
                if(j!=-1){
                    level = floodFill(level, i, j, level[i][j], 9);
                    if (hasNoValue(level, 1)) {
                        changeValue(level, 9, 1);
                        return true;
                    }else {
                        changeValue(level, 9, 1);
                        return false;
                    }
                }
            }
            return false;
        }

        public static function hasNoValue(a:Array, val:*):Boolean {
            for (var i:int = 0; i < a.length; i++) {
                if (a[i].indexOf(val) != -1) {
                    return false
                }
            }//end for
            return true;
        }

        public static function floodFill(a:Array, i:int, j:int, oldVal:*, newVal:*):Array {
            if(i>-1&& i<a.length && j>-1 && j < a[i].length){
                if (a[i][j] == oldVal) {
                    a[i][j] = newVal;
                    floodFill(a, i + 1, j, oldVal, newVal);
                    floodFill(a, i - 1, j, oldVal, newVal);
                    floodFill(a, i, j+1, oldVal, newVal);
                    floodFill(a, i, j-1, oldVal, newVal);
                }
            }
            return a
        }

        public static function changeValue(a:Array, oldVal:*, newVal:*):Array{
            for (var i:int = 0; i < a.length; i++) {
                for (var j:int = 0; j < a[i].length; j++) {
                    if (a[i][j] == oldVal) {
                        a[i][j] = newVal;
                    }
                }
            }
            return a;
        }

        public static function addRoom(parent:Array, room:Array):Array {
            for (var i:int = 0; i < parent.length-room.length-1; i++) {
                for (var j:int = 0; j < parent[i].length - room[0].length-1; j++) {
                    if (parent[i][j] == 0 &&
                        parent[i + room.length][j] == 0 &&
                        parent[i + room.length][j + room[0].length] == 0 &&
                        parent[i][j + room[0].length] == 0
                        ) {

                            trace(parent);
                            return mergeArrays(parent, room, i, j);
                        }//end if
                }//end for
            }//end for
            return(parent);
        }//end add Room

        public static function mergeArrays(parent:Array, child:Array, x:int, y:int):Array {
            for (var i:int = 0; i < child.length; i ++) {
                for (var j:int = 0; j < child[i].length; j++) {
                    parent[i + x][j + y] = child[i][j];
                }//end for
            }
            return parent;
        }

        public static function createRoom(size:int, hallLength:int):Array {
            var used:int = 0;
            var side:int = Math.sqrt(size);
            var dif:int = side * Math.random() * .5 + .25;
            var room:Array = getBlankWorld( side - dif, side + dif, 1);
            if (Math.random() < 0.5) {
                rotateArray(room);
            }
            return mergeArrays(getBlankWorld(room.length+hallLength*2, room[0].length + hallLength*2, 2), room,hallLength, hallLength);
        }//end createRoom;

        public static function rotateArray(room:Array):Array {
            var a:Array = new Array();
            for (var i:int = 0; i < room.length; i++) {

                for (var j:int = 0; j < room[0].length; j++) {
                    if (!a[j]) {
                        a[j] = new Array();
                    }
                    a[j][i] = room[i][j];
                }//end for
            }//end for
            return a;
        }//end rotateArray

        public static function getBlankWorld(width:int, height:int, fill:int = 0):Array {
            var a:Array = new Array();
            for (var i:int = 0; i < width; i++) {
                a.push(new Array());
                for (var j:int = 0; j < height; j++) {
                    a[i][j] = fill;
                }//end for
            }//end for
            return a;
        }//end getBlankWorld

        public static function numberOfValue(a:Array, value:*):int {
            var c:int = 0;
            for (var i:int = 0; i < a.length; i++) {
                for (var j:int = 0; j < a[i].length; j++) {
                    if (a[i][j] == value) {
                        c++;
                    }
                }
            }
            return c;
        }

    }

}