package {
	import flash.display.Sprite;
	import flash.text.TextField;
	import flash.display.MovieClip;
	
	import flash.utils.Timer;
	import flash.events.TimerEvent; 

	public class Main extends MovieClip	{
		public static var stageWidth:int = 800;
		public static var stageHeight:int = 600;
		
		private var flakes:Array;
		private var heaps:Array;
		private var cnt:int = 100;
		var windTimer:Timer;
		
		public function Main() {			
			graphics.beginFill(0);
			graphics.drawRect(0,0,800,600);
			graphics.endFill();
			
			flakes = new Array(cnt);
			for(var iFlake:uint; iFlake<cnt; iFlake++){
			   var snowflake:Snowflake = new Snowflake();
			   flakes[iFlake] = snowflake;
			   flakes[iFlake].reachBottomFunction = flakeReachedBottom;  //************** Here we set that functions
			   flakes[iFlake].collisionTestFunction = testHeapCollision;
			   addChild(snowflake)
			}
			
			//Init timer
			windTimer = new Timer(500,0);
			windTimer.addEventListener(TimerEvent.TIMER, updateWind);
			windTimer.start();
			
			//Heaps
			heaps = new Array(stageWidth/50+1);
			for (var iHeap:uint;iHeap<heaps.length;iHeap++) {
				heaps[iHeap] = new SnowHeap(100);
				heaps[iHeap].y = stageHeight;
				heaps[iHeap].x = iHeap*50;
				addChild(heaps[iHeap]);
			}
			
			//addChild(new StartButton());
			
			graphics.moveTo(0,stageHeight-SnowHeap.maxHeight*SnowHeap.maxScale);
			graphics.lineTo(stageWidth,stageHeight-SnowHeap.maxHeight*SnowHeap.maxScale);
		}			
		
		public function testHeapCollision(X:int,Y:int):int {
			var num:int = X/50;
			if ((num >= heaps.length || num < 0) == false)
			{
				var top:int = stageHeight - heaps[num].height / 2;
				if (Y > top) {
					return 1;
				}
			}
			if (Y>stageHeight) {
				return 1;
			}
			
			return 0;
		}
		
		public function flakeReachedBottom(X:int) {
			var num:int = X/50;
			if ((num >= heaps.length || num < 0) == false)
				heaps[num].doGrow(0.03);
		}
		
		function updateWind(event:TimerEvent):void {
			if (Math.round(Math.random()*3)==1){
				var mod:int = Math.round(Math.random()*4)-2;
				for (var i:uint;i<cnt;i++){
					flakes[i].modWind(mod);
				}
			}
		}

	}
}










package {
	import flash.display.Shape;
	import flash.filters.BlurFilter;
	import flash.filters.GlowFilter;
	import flash.events.Event;

	class Snowflake extends Shape {
		private var lowestDropSpeed:uint = 2;
		private var highestDropSpeed:uint = 4;
		private var dropSpeed:int = Math.round(Math.random() * Math.random() * (highestDropSpeed-lowestDropSpeed))+lowestDropSpeed;
		private var incrementer:int = Math.round(Math.random() * 100);
		private var shades:Array = [ 0xFFFFFF, 0xFFFFFF ];
		private var angles:Array = [ 30, 45, 52, 60, 72 ];
		
		private var windSpeed:int = 0;
		private var minWindSpeed:int = -10;
		private var maxWindSpeed:int = 10;
		private var subAngleMin:int = 20;
		private var subAngleMax:int = 43;
		private var subLenMod:Number = 0.3;
		private var subGrowMod:Number = 1.4;
		public var reachBottomFunction:Function;  //******************** Here are they declared
		public var collisionTestFunction:Function;
		
		public function modWind(mod:int){
			windSpeed += mod;
			if (windSpeed > maxWindSpeed) {
				windSpeed = maxWindSpeed;
			}
			if (windSpeed < minWindSpeed) {
				windSpeed = minWindSpeed;
			}
		}		

		public function Snowflake() {
			var shade:int = 0xFFFFFF; //shades[ Math.ceil(Math.random() * shades.length) ];
			graphics.beginFill(shade);
			graphics.drawCircle(0,0,5);
			graphics.endFill();
			
			var lines:int = Math.round(Math.random()*1)+2;
			var depth:int = Math.round(Math.random()*1)+1;
			var subAngleMod:int = Math.round(Math.random()*(subAngleMax-subAngleMin))+subAngleMin;
			graphics.lineStyle(1,shade);			
			var anglemod:int = angles[Math.round(Math.random()*(angles.length-1))];
			for (var angle:int=0;angle<360;angle+=anglemod)
			{
				graphics.moveTo(0,0);
				addSubLines(0,0,50,angle,lines,depth,subAngleMod);
			}
			
			//filters = [ new BlurFilter(1,dropSpeed/2,1) ];
			filters = [ new GlowFilter(0xCCCCFF,0.8) ];
			addEventListener(Event.ENTER_FRAME,update);
			reset();
		}
		private function reset():void {
			y = Math.random() * Main.stageHeight * -1  -  dropSpeed;
			x = Math.random() * Main.stageWidth - (windSpeed*200);
			scaleX = scaleY = 0.4 + (Math.random() * Math.random() * 0.6);
			rotation = Math.round(Math.random()*180);
		}
		private function update(e:Event):void {
			y += dropSpeed;
			x += windSpeed + Math.sin(incrementer/10) * (1/(dropSpeed/3));
			if ((collisionTestFunction != null && collisionTestFunction(x,y) == 1) || y > Main.stageHeight) {
				if (reachBottomFunction != null) {
					reachBottomFunction(x); //***************************** Used here
				}
				reset();
			} else if (x > Main.stageWidth+width) {
				x = -width;
			} else if (x < -width) {
				x = Main.stageWidth+width;
			}
			incrementer++;
		}
		
		public function getLineEndX(startX:int,len:int,angle:int):int {
			return startX + Math.cos((angle/180)*Math.PI)*len;
		}
		
		public function getLineEndY(startY:int,len:int,angle:int):int {
			return startY + Math.sin((angle/180)*Math.PI)*len;
		}
		
		public function addSubLines(subX:int,subY:int,subLength:int,subAngle:int,subLines:int,leftSubs:int,angleMod:int=30){
			graphics.moveTo(subX,subY);
			var endX:int = getLineEndX(subX,subLength,subAngle);
			var endY:int = getLineEndY(subY,subLength,subAngle);
			graphics.lineTo(endX,endY);
			
			if (leftSubs>0 && subLines > 1) {
				for (var i:int=0;i<subLines;i++){
					var newX:int = subX + ((endX-subX)/(subLines+1))*(i+1);
					var newY:int = subY + ((endY-subY)/(subLines+1))*(i+1);
					
					addSubLines(newX,newY,subLength*subLenMod*(Math.pow(subGrowMod,i)),subAngle+angleMod,subLines/2,leftSubs-1);
					addSubLines(newX,newY,subLength*subLenMod*(Math.pow(subGrowMod,i)),subAngle-angleMod,subLines/2,leftSubs-1);
				}
			}
		}
	}
}