Random Caverns

/**
 * Copyright itsDcTurner ( http://wonderfl.net/user/itsDcTurner )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/EJT1
 */

// forked from itsDcTurner's Pattern Experiment 1
package 
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.geom.Point;
    import gs.OverwriteManager;
    
    [SWF(backgroundColor="#000000", frameRate=60)]
    public class Main extends Sprite 
    {
        private const     grid:Point = new Point(13, 13); // x:columns, y:rows
        private const     patternBank:Array = [new<int>[1,1,1,0,0,0,1,1,1], new<int>[0,0,0,1,1,1,0,0,0], new<int>[1,0,0,0,1,0,0,0,1], new<int>[0,0,1,0,1,0,1,0,0], new<int>[1,1,1,1,0,1,1,1,1], new<int>[0,0,0,0,1,0,0,0,0], new<int>[1,1,1,0,0,0,0,0,0], new<int>[0,0,0,0,0,0,1,1,1], new<int>[1,1,1,1,0,1,0,0,0], new<int>[0,0,0,1,0,1,1,1,1]];
        private const   colorBank:Array = [0x77817E, 0xB1BEBB, 0xF0FFFA, 0x3C4140, 0xD7E6E0];
        private var     cellWidth:Number;
        public function Main():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
        
        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            OverwriteManager.init(OverwriteManager.NONE);
            
            draw();
        }
        
        private function draw():void
        {
            cellWidth = stage.stageWidth / grid.x;
            var loc:Point = new Point(0, 0);
            var count:int = 0;
            for (var  i:int =  0;  i  < grid.x;  i ++) 
            {
                for (var j:int =  0; j  < grid.y; j ++) 
                {
                    loc.x = (i * cellWidth) + cellWidth *.5;
                    loc.y = (j * cellWidth) + cellWidth *.5;
                    addPattern(loc, count);
                    count++;
                }
            }
        }
        private function addPattern($loc:Point, $index:int):Pattern {
            var p:Pattern = new Pattern(cellWidth, patternBank[int(Math.random() * patternBank.length)], 0xeeeeee, $index);
            p.x = $loc.x;
            p.y = $loc.y;
            addChild(p);
            return p;
        }
    }
}
    import flash.display.Sprite;
    import flash.geom.Point;
    import gs.TweenMax;
    import gs.easing.*;
    
    class Pattern extends Sprite {
        
        private const minTime:Number = .35;
        private const maxTime:Number = 2;
        
        public var v        :Vector.<int>;
        public var size        :Number;
        public var gridSize    :int;
        public var col        :uint;
        private var cellSize:Number;
        private var halfSize:Number;
        
        function Pattern($size:Number, $pat:Vector.<int>, $col:uint, index:int):void {
            v = $pat;
            trace(v);
            col = $col;
            size = $size;
            gridSize = Math.sqrt(v.length);
            drawPattern();
            TweenMax.delayedCall(Math.random()*30, rotate);
     
            alpha=0;
            TweenMax.to(this, Math.random()*15, {alpha:100, ease:Bounce.easeOut, delay:index*.04});
        }
        
        private function rotate():void
        {
            var rotAmount:int = int((Math.random() * 6)-3) * 90;
            var time:Number = randomBetween(minTime, maxTime);
            
            TweenMax.to(this, time, { rotation:rotAmount, ease:Bounce.easeOut } );
            //TweenMax.to(this, time * .5, { alpha:Math.random() } );
            TweenMax.delayedCall(Math.random()*25, rotate);
            
        }
        
        private function randomBetween($min:Number, $max:Number):Number {
            return minTime + Math.random() * ($max - $min);
        }
        
        private function drawPattern():void
        {
            var count:int = 0;
            var loc:Point = new Point(0, 0);
            graphics.beginFill(col);
            cellSize = size / gridSize;
            halfSize = size * .5;
            
            trace("cellsize: " + cellSize);
            
            for (var i:int = 0; i < gridSize; i++) 
            {
                for (var j:int = 0; j < gridSize; j++) 
                {
                    trace("i: " + i +", j: " + j +", = :" + v[count]);
                    if (v[count]) {
                        loc.x = (i * cellSize); 
                        loc.y = (j*cellSize);
                        addSquare(loc);
                    }
                    count++;
                }
            }
        }
        private function addSquare($loc:Point):void {
            graphics.beginFill(col);
            graphics.drawRect($loc.x-halfSize, $loc.y-halfSize, cellSize, cellSize);
            graphics.endFill();
            trace("square at " + $loc.x + ", " + $loc.y);
        }
    }