AS3 Rain Particle Generator SeniorCreative | Independent Freelance Multimedia Developer

Contact | ABN 76 112 803 072

Folio currently contains 131 items

Recent Work Top Ten Views This Month Contact us

Viewed 43 times this month

Actionscript 3.0 - LEVEL ADVANCED
AS3 Rain Particle Generator	Last edited 30TH NOV, 2009
This is one of a few particle generators I have. I used this on the thatworks site and also made an earlier posting of it for forking on wonderfl. There are a fair few parameters you can tweak to get your rain looking how you want it. Make sure you have the latest versions of TweenLite available from greensock. You can make the rain start and stop periodically or just have it constantly going... see the attach method for these options.

package classes.particles
{

//Rain Generator v1.0 SeniorCreative.com.au

//FLASH CLASSES IMPORT
    import flash.events.*;
    import flash.display.*;
    import flash.utils.*;

// TWEENLITE IMPORT
    import com.greensock.*;
    import com.greensock.easing.*;
    
    
    public class Rain extends MovieClip
    {

private var nXDif:Number;// x offset based on angle and length
        private var nYDif:Number;// y offset based on angle and length

private var iRotDegrees:int;// angle to rotate rain clip
        private var nRotRadians:Number;// same angle in radians (calculated based on iRotDegrees);
        private var iRotVariance:int;// number of randomness offset angle (degrees) to apply to general angle or raindrops. 10 will go +5 or -5 either way
        private var iLen:int;// length the rain is going to travel

private var iTime:int;// call rainTimerHandler every iTime milliseconds...
        private var iDrops:int;// new drops to add each time Rain timer is called

private var iDropLengthMin:int;// min size of rain
        private var iDropLengthRnd:int;// random length of new rain drops to add on to min size
        private var iDropStroke:int;// stroke width of rain drop
        private var iDropColor:uint;// color of rain stroke
        private var iDropAlpha:int;// alpha of drop stroke - 0 to 1
        private var iYOffSetStart:int;// start new rain drops this y offset so they come on
        private var iYOffSetRnd:int;// start new rain drops this y offset so they come on

private var nSpeed:Number;// speed in seconds rain takes to fall distance
        private var nSpeedVariance:Number;// speed variance - will go +1 or -1 either way....
        
        private var nDelayDuration:Number     = 3 * 1000; // Randomized amount of time to wait til next rain (in seconds)
        private var nMinDuration:Number     = 5 * 1000; // The minimum amount of delay at least required 
        private var nDurationSpan:Number     = 10 * 1000; // Randomized additional time to rain on top of minimum duration

private var __displayList:Array;

// timer
        private var tRainTimer:Timer;

//    Construct
        function Rain ()
        {

init ();
            addEventListener (Event.ADDED_TO_STAGE, attach);

}

private function init ():void
        {

__displayList = new Array();// in case we want to make a list of all rain objects and loop through and remove when kill function is called;
            
            setRandomVars();

nRotRadians         = iRotDegrees * Math.PI/180;
            iRotVariance         = 10;
            iLen                 = 1400;
            
            iDropColor             = 0xcccccc;
            iDropAlpha             = 1;
            iYOffSetStart         = -50;
            iYOffSetRnd         = 100;
            nSpeed               = 1.5;
            nSpeedVariance         = 1.5;

}

private function setRandomVars() : void
        {
            
            iRotDegrees         = 100 + getVariance(20, true);
            
            iTime                 = 15  + getVariance(8);
            iDrops                 = 12 + getVariance(4);
            
            iDropLengthMin      = 5;
            iDropLengthRnd         = 50 + getVariance(20);
            
            iDropStroke            = 1.5 + getVariance(1);
            
        }
        
        private function getVariance(nLength:Number, bRound:Boolean = true) : Number
        {
            
            var nVariance:Number = ((Math.random() * nLength) - nLength/2);
            if (bRound) nVariance = Math.round(nVariance);
            
            return nVariance;
            
        }

private function attach (e:Event):void
        {

//trace("Rain Added");

removeEventListener (Event.ADDED_TO_STAGE, attach);

// timer
            tRainTimer = new Timer(iTime,0);// this means the a new drop is added every (iTime) milliseconds approximately
            tRainTimer.addEventListener (TimerEvent.TIMER, rainTimerHandler);

// Either delay the rain - making it start and stop periodically - or just have constant rain
            // Option A - Periodic rain
            rainDelayStart ();

// Option B = Constant rain
            // tRainTimer.start ();

}

// ========================================================================

//    PUBLIC & PRIVATE METHODS

private function rainDelayStart ():void
        {

var nStartDelay:Number = Math.random() * nDelayDuration;
            var nDuration:Number   = nMinDuration + (Math.random() * nDurationSpan);

// Delay the rain starting
            setTimeout (function():void{
                                  
                        tRainTimer.start();
                        
                        }, nStartDelay);

// Set the rain to go for a certain amount of time then stop and call this again...
            setTimeout (function():void{
            
                         tRainTimer.stop();
                        
                        // Lets randomize the direction a little to show change in atmospherics
                        setRandomVars();
                        
                         rainDelayStart();
                     
                         }, nStartDelay + nDuration);

}

private function addRain ():void
        {

var tRotDegrees:Number = iRotDegrees + (Math.random() * iRotVariance) - iRotVariance/2;// angle to rotate rain clip
            var tRotRadians:Number = tRotDegrees * Math.PI/180;// same angle in radians (calculated based on iRotDegrees);

// create new blank sprite to draw into
            var sRain:Sprite = new Sprite();

// lineStyle(width, color, alpha, hinting);
            sRain.graphics.lineStyle (iDropStroke, iDropColor, iDropAlpha, false);
            sRain.graphics.moveTo (0,0);

// draw rain line - random x from 0 to 100 pixels long, y at zero - based on this being rotation of zero which is horizontal facing right
            sRain.graphics.lineTo (iDropLengthMin + (Math.random() * iDropLengthRnd), 0);

// add rain anywhere between - stage width (stage left minus the width again) and + stage width (stage right)
            sRain.x = stage.stageWidth/2 + ((Math.random() * (stage.stageWidth * 2)) - stage.stageWidth);
            sRain.y = iYOffSetStart + (Math.random() * iYOffSetRnd);
            sRain.rotation = tRotDegrees;

// add to root (or container if you have one)
            addChild (sRain);

// calc the offset based on the angle and distance to travel
            nXDif = iLen * Math.cos(tRotRadians);
            nYDif = iLen * Math.sin(tRotRadians);

TweenLite.to (sRain, nSpeed + ((Math.random() * nSpeedVariance) - nSpeedVariance/2), {alpha:0, x:sRain.x + nXDif, y:sRain.y + nYDif, ease:Linear, onComplete:onFinishTween, onCompleteParams:[sRain]});

}

private function onFinishTween (parameter2:Sprite):void
        {

//trace("The tween has finished! parameters:", parameter2);
            removeChild (parameter2);

}

//    ========================================================================

//    EVENTS

private function rainTimerHandler (e:TimerEvent):void
        {

// each time the timer is called - you can add as many drops as you want. this example adds 3 new drops;

for (var iDrop:int = 0; iDrop < iDrops; iDrop++)
            {

addRain ();

}

public function kill ():void
        {

tRainTimer.stop ();
            tRainTimer.removeEventListener (TimerEvent.TIMER, rainTimerHandler);

}