Flash / Test Game

//---------------------------------------------------------------
//                    ZMain.as
//---------------------------------------------------------------
package  {

    import flash.display.MovieClip;
    import flash.events.*;

    import flash.utils.setTimeout;
    import flash.utils.Timer;
    import flash.ui.Mouse;


    //----------------------------------------
    public class ZMain extends MovieClip {

        //-------------------------------
        public const SPLIT_LINE:Number=440;
        public const NUM_FLOWERS:Number = 15;

        public var _hlp : Helper;
        public var _dbg : ZDebug;
        public var _fact : elFactory;

        public var _Timer, _Timer4 : Timer;

        public var started = false;
        public var flowersDisperse = false;
        public var flowersFar=false;
        public var score:int =0;

        //-------------------------------
        public function ZMain() {

            _hlp = new Helper();
            _fact = new elFactory(this);


            addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
            stage.addEventListener("evStop", zstop);
            stage.addEventListener("evRestart",restart);
            stage.addEventListener("startClick", restart);

        }
        //-------------------------------
        private function mk_bg() {

            _hlp._layer_picture_bg = _fact.mkEl('bg');
            _hlp._layer_treemask = _fact.mkEl('treemask');

            addChild(_hlp._layer_picture_bg);
            addChild(_hlp._layer_treemask);

            var zpnl = new ZControlPanel(this);
            _hlp._layer_control_panel = zpnl.add_panel();
            addChild(_hlp._layer_control_panel);

            var zscore = new ZScoreBoard(this);
            _hlp._layer_score_board = zscore.add_panel();
            addChild(_hlp._layer_score_board);
        }
        //-------------------------------
        private function onAddedToStage(e:Event):void {

            mk_bg();
            var zspl = new ZSplashScreen(stage);

            _hlp._layer_splash_screen = zspl.add_splashScreen();

            //addChild(_hlp._layer_splash_screen);

            _dbg = new ZDebug(this);
            //_hlp._layer_debugbox = _dbg.add_debugbox();
            //addChild(_hlp._layer_debugbox);

            restart(null);

        }

        //-------------------------------
        private function restart(e:Event) {
            if (started)
               zstop(null);

             zstart(null);
        }
        //-------------------------------
        private function zstop(e:Event) {

            _Timer.stop();
            _Timer4.stop();
            _Timer=null;
            _Timer4=null;

            stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouse_Move);
            stage.removeEventListener(MouseEvent.MOUSE_DOWN, onMouse_Down);
            stage.removeEventListener(MouseEvent.MOUSE_UP, onMouse_Up);
            stage.removeEventListener("evPanelOver", onPanelOver);
            stage.removeEventListener("evPanelOut", onPanelOut);

            _hlp._deleteAllFlowers();
            _hlp._deleteAllClouds();
            _hlp._deleteAllBirds();
            _hlp._deleteAllDynEls();

            started =false;
        }
        //-------------------------------
        private function zstart(e:Event) {

            //removeChild(_layer_splash_screen);
            started = true;
            _setScore(0);

            Mouse.hide();

            stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouse_Move);
            stage.addEventListener(MouseEvent.MOUSE_DOWN, onMouse_Down);
            stage.addEventListener(MouseEvent.MOUSE_UP, onMouse_Up);
            stage.addEventListener("evPanelOver", onPanelOver);
            stage.addEventListener("evPanelOut", onPanelOut);

            add_flowers();

            add_Cloud(null);
            _Timer = new Timer(7000);
            _Timer.addEventListener(TimerEvent.TIMER, add_Cloud);
            _Timer.start();

            _Timer4 = new Timer(4000);
            _Timer4.addEventListener(TimerEvent.TIMER, add_Bird);
            _Timer4.start();

        }

        //-------------------------------
        private function add_Cloud(e:Event) {

            var _cloud = _fact.mkEl('cloud',_hlp._clouds);
            if (_cloud.scaleX<0.7)
               addChildAt(_cloud, _hlp._getFlowerIndex());
            else
               addChild(_cloud);
        }

        //-------------------------------
        private function add_Bird(e:Event) {

            var _bird = _fact.mkEl('bird',_hlp._birds);

            if (_bird.scaleX<0.7)
               addChildAt(_bird, _hlp._getFlowerIndex());
            else
               addChild(_bird);

        }

        //-------------------------------
        private function onPanelOver(e:Event) {

            flowersDisperse = true;

            _hlp._parts[0]._targ.x=stage.stageWidth/3;
            _hlp._parts[0]._targ.y=stage.stageHeight/2;
        }
        //-------------------------------
        private function onPanelOut(e:Event) {

            flowersDisperse = false;
        }

        //-------------------------------
        private function onMouse_Down(e:MouseEvent):void {

            if (flowersFar)
               return;

            _hlp.mouse_pressed=true;
        }
        //-------------------------------
        private function onMouse_Up(e:MouseEvent):void {
            _hlp.mouse_pressed = false;
        }
        //-------------------------------
        private function onMouse_Move(e:MouseEvent):void {

            if (!flowersDisperse) {
                _hlp._parts[0]._targ.x=mouseX;
                _hlp._parts[0]._targ.y=mouseY;
            }
            flowersFar = false;

            if (mouseY<SPLIT_LINE-200) {
                flowersFar = true;
                _hlp._parts[0].scaleX = _hlp._parts[0].scaleY = mouseY/(SPLIT_LINE-200)/4;

            } else {
                _hlp._parts[0].scaleX = _hlp._parts[0].scaleY =1;

            }
        }

        //-------------------------------
        private function add_flowers() {

            for (var i:Number = 0; i< NUM_FLOWERS; i++) {

                var flower = _fact.mkEl('flower',_hlp._parts);

                if (i>0) {
                    flower._targEl = _hlp._parts[_hlp._parts.length-2];
                }

                flower.alpha=(NUM_FLOWERS-i/2)/NUM_FLOWERS;
                flower._velMod = 200;//(NUM_FLOWERS-i/6)*10;

                if (i==NUM_FLOWERS-1)
                   flower._fireMode = true;

                addChild(flower);

            }

        }
    //-------------------------------
       public function _setScore(num) {

           score = num;
           stage.dispatchEvent(new Event("evUpdateScore",true,false));
       }
       //-------------------------------
       public function _addScore(num) {

           score +=num;
           stage.dispatchEvent(new Event("evUpdateScore",true,false));
       }

    }

}

import flash.display.MovieClip;

//----------------------------------------------
//           Elements Factory
//----------------------------------------------
class elFactory extends MovieClip{

    import flash.net.URLRequest;
    import flash.display.Loader;

    public var _parent:MovieClip;
    //-----------------------
    public function elFactory(_inparent) {

        _parent = _inparent;
    }

    //-----------------------
    public function mkEl(elname:String, arr:Array=null) {

        var el;
        switch (elname) {
            case 'flower':   el = getFlower();break;
            case 'cloud':    el = getCloud();break;
            case 'bird':     el = getBird();break;
            case 'bg':       el = getBg();break;
            case 'treemask': el = getTreeMask();break;
        }
        if (arr!=null)
           arr.push(el);

         return el;
    }
    //-----------------------
    function getFlower() {

        var flower:zFlower = new zFlower(ZMain(_parent));

                flower.x = Math.random()*_parent.stage.stageWidth;
                flower.y = Math.random()*_parent.stage.stageHeight;

                return flower;
    }
    //-----------------------
    function getCloud() {

        var _cloud = new mvCloud(_parent);
            _cloud.x=  _parent.stage.stageWidth+50;
            _cloud.y= Math.ceil(Math.random()* 300);
            _cloud.scaleX = _cloud.scaleY = Math.random()*0.4+0.5;
            _cloud.alpha = _cloud.scaleX;

            return _cloud;
    }
    //-----------------------
    function getBird() {

            var _bird = new mvBird(_parent);
            _bird.x=  _parent.stage.stageWidth+50;
            _bird.y= Math.ceil(Math.random()* 250);
            _bird.scaleX = _bird.scaleY = Math.random()*0.8+0.4;
            _bird.alpha =_bird.scaleX<1 ?  _bird.scaleX : 1;

            return _bird;
    }
    //-----------------------
    function getBg() {

            var picClip:Loader = new Loader();
            var picUrl:URLRequest = new URLRequest('field.jpg');
            picClip.load(picUrl);
            return picClip;
    }
    //-----------------------
    function getTreeMask() {

            var treeMask:MovieClip = new MovieClip();
            treeMask.graphics.drawRect(0,0,170,80);
            treeMask.width=170;
            treeMask.height=80;
            treeMask.x=620;
            treeMask.y=310;

            return treeMask;
    }

}

//----------------------------------------------
//        Helper
//----------------------------------------------
class Helper {

        import flash.display.Loader;


        public var _parts:Array=[];
        public var _clouds:Array=[];
        public var _birds:Array=[];

        public var _alldynels:Array=[];

        public var _layer_splash_screen: MovieClip;
        public var _layer_picture_bg : Loader;
        public var _layer_treemask : MovieClip;
        public var _layer_debugbox : MovieClip;
        public var _layer_control_panel : MovieClip;
        public var _layer_score_board : MovieClip;

        //---------------------
        public var mouse_pressed:Boolean =false;

       //--------------------------
       public function Helper () {

       }

       //-------------------------------
       public function _hitTestTree(obj):Boolean {

           return obj.hitTestObject(_layer_treemask);
       }

       //-------------------------------
       public function _hitTestFlower(obj) {

            if (obj.hitTestObject(_parts[0]))
               return true;

            return false;
       }

       //-------------------------------
       public function _hitTestCloud(obj) {

            var cloud: mvCloud;

            for (var i:Number=0; i<_clouds.length; i++) {

                   if ((_clouds[i] is MovieClip)===false)
                      continue;

                   cloud = _clouds[i];
                   if (obj.hitTestObject(cloud)) {
                      return cloud;
                   }
            }
            return false;
       }

       //-------------------------------
       public function _hitTestBird(obj) {

            var bird: mvBird;

            for (var i:Number=0; i<_birds.length; i++) {

                   if ((_birds[i] is MovieClip)===false)
                      continue;

                   bird = _birds[i];
                   if (obj.hitTestObject(bird)) {
                      return bird;
                   }
            }
            return false;
       }
       //-------------------------------
        public function _deleteAllFlowers() {

            while (_parts.length>0)
               _destroyFlower(0);
        }
       //-------------------------------
        public function _deleteAllClouds() {

            while (_clouds.length>0)
               _destroyCloud(0);
        }
       //-------------------------------
        public function _deleteAllBirds() {

            while (_birds.length>0)
               _destroyBird(0);
        }
       //-------------------------------
        public function _deleteAllDynEls() {

            while (_alldynels.length>0)
               _alldynels[0]._final();
        }
       //-------------------------------
        public function _destroyFlower(ind:int) {

            var flower =_parts[ind];
            _removeFlower(flower);
            flower._final();
        }
        //-------------------------------
        public function _destroyCloud(ind:int) {

            var cloud = _clouds[ind];
            _removeCloud(cloud)
            cloud._final();
        }
        //-------------------------------
        public function _destroyBird(ind:int) {

            var bird = _birds[ind];
            _removeBird(bird);
            bird._final();
        }

        //-------------------------------
        public function _removeFlower(flower) {

           for (var i:Number=_parts.length-1; i>=0; i--) {
                if (_parts[i]==flower) {
                    _parts.splice(i,1);
                    break;
                }
            }
        }
       //-------------------------------
        public function _removeCloud(cloud) {

           for (var i:Number=_clouds.length-1; i>=0; i--) {
                if (_clouds[i]==cloud) {
                    _clouds.splice(i,1);
                    break;
                }
            }
        }
        //-------------------------------
        public function _removeBird(bird) {

           for (var i:Number=_birds.length-1; i>=0; i--) {
                if (_birds[i]==bird) {
                    _birds.splice(i,1);
                    break;
                }
            }
        }
        //-------------------------------
        public function _removeDynEl(el) {

           for (var i:Number=_alldynels.length-1; i>=0; i--) {
                if (_alldynels[i]==el) {
                    _alldynels.splice(i,1);
                    break;
                }
            }
        }


       //-------------------------------
        public function _getFlowerIndex(upper=false) {

            var flo:zFlower;
            if (upper)
               flo = _parts[_parts.length-1];
            else
               flo = _parts[0];

            var ind:Number = flo.parent.getChildIndex(flo);
            return ind;
        }

   }

//----------------------------------------------
//----------------------------------------------
class ZScoreBoard extends MovieClip {

    import flash.events.*;
    import fl.transitions.Tween;
    import fl.transitions.easing.Strong;

    public const VIS_ALPHA:Number = 0.6;
    public const ACTIVE_ALPHA:Number = 0.9;

    private var _parent : ZMain;
    private var active:Boolean = false;
    private var panel:mvScore;

    //------------------------------------
    public function ZScoreBoard(_inparent) {

        _parent = _inparent;
        _parent.stage.addEventListener("evUpdateScore", updScore);
    }

    //------------------------------------
    public function add_panel() {

        panel = new mvScore();

        panel.x = _parent.stage.stageWidth-400;
        panel.y = 30;
        panel.alpha = VIS_ALPHA;


        return panel;
    }
    //------------------------------------
    public function updScore(e:Event) {

        panel.txScore.text ='your current score: '+_parent.score.toString();
    }

}

//----------------------------------------------
//         Control Panel
//----------------------------------------------
class ZControlPanel extends MovieClip {

    import flash.events.*;
    import fl.transitions.Tween;
    import fl.transitions.easing.Strong;
    import flash.ui.Mouse;
    import fl.controls.Label;
    import flash.text.TextField;
    import flash.text.TextFormat;

    public const VIS_ALPHA:Number = 0.2;
    public const ACTIVE_ALPHA:Number = 0.8;

    public var _parent:ZMain;
    public var active=false;
    public var _objOn:MovieClip=null;

    public function ZControlPanel(_inparent) {
        _parent = _inparent;
    }

    //------------------------------------
    public function add_panel() {

        var panel: mvCntPanel = new mvCntPanel();


        panel.alpha = VIS_ALPHA;

        panel.addEventListener(Event.ADDED_TO_STAGE, onAdded);
        panel.addEventListener(MouseEvent.MOUSE_OVER, onMouse_Over);
        panel.addEventListener(MouseEvent.MOUSE_OUT, onMouse_Out);
        panel.btStop.addEventListener(MouseEvent.CLICK, onStop);
        panel.btRestart.addEventListener(MouseEvent.CLICK, onRestart);

        var format = new TextFormat();
        format.bold=true;

        for (var i:int=0; i<panel.numChildren; i++) {
            var zel = panel.getChildAt(i);
            if (zel is Label) {
                //Label(zel).textField.setTextFormat(format);
                Label(zel).htmlText ='<b>'+Label(zel).text+'</b>';

            }
        }

        return panel;
    }
    //------------------------------------
    public function onAdded(e:Event) {

        e.currentTarget.x = _parent.stage.stageWidth-e.currentTarget.width/2;
        e.currentTarget.y = _parent.stage.stageHeight-e.currentTarget.height/2;

    }
    //------------------------------------
    private function onStop(e:Event) {
        _parent.stage.dispatchEvent(new Event("evStop",true,false));
    }

    //------------------------------------
    private function onRestart(e:Event) {
        _parent.stage.dispatchEvent(new Event("evRestart",true,false));
    }

    //------------------------------------
    public function onMouse_Over(e:MouseEvent) {

        if (active)
           return;

        active = true;
        if (_objOn==null)
           _objOn = MovieClip(_parent.getChildAt(_parent.getChildIndex(
                                                MovieClip(e.currentTarget))-1));

        _parent.stage.dispatchEvent(new Event("evPanelOver",true,false));
        Mouse.show();

        var zTween:Tween = new Tween(e.currentTarget, 'alpha', Strong.easeOut,
                                           VIS_ALPHA,ACTIVE_ALPHA, 0.5, true);

    }
    //------------------------------------
    public function onMouse_Out(e:MouseEvent) {


        if (!active)
           return;

        if (e.currentTarget.contains(e.relatedObject))
           return;

         active =false;

         _parent.stage.dispatchEvent(new Event("evPanelOut",true,false));
         Mouse.hide();

         var zTween:Tween = new Tween(e.currentTarget, 'alpha', Strong.easeOut,
                                           ACTIVE_ALPHA, VIS_ALPHA, 0.5, true);
    }
}

//----------------------------------------------
//           Splash Screen
//----------------------------------------------
class ZSplashScreen extends MovieClip {

    import flash.events.*;

    import flash.geom.Matrix;
    import flash.display.GradientType;
    import flash.display.InterpolationMethod;
    import flash.display.SpreadMethod;
    import flash.display.BlendMode;

    public var _stage;

    public function ZSplashScreen(_instage) {
        _stage = _instage;

    }
    //----------------------------
    public function add_splashScreen()
    {
            var w = _stage.stageWidth;
            var h = _stage.stageHeight;

            var gshape:MovieClip = new MovieClip();
            var gmatrix = new Matrix();

            var gtype = GradientType.LINEAR;
            var gspread = SpreadMethod.PAD;
            var ginterpolation = InterpolationMethod.LINEAR_RGB;
            var gcolours = [0xf0eeff, 0xaaff99];
            var galphas = [1,1];
            var gratios = [0,255];

            gmatrix.createGradientBox(w,h, Math.PI/2);

            gshape.graphics.clear();


            gshape.graphics.beginGradientFill(gtype, gcolours, galphas,
                                              gratios, gmatrix, gspread, ginterpolation);

            gshape.graphics.drawRect(0,0, w,h);
            gshape.graphics.endFill();

            gshape.x=0;
            gshape.y=0;

            gshape.blendMode=BlendMode.HARDLIGHT;

            var zPanel = new cntPanel();
            zPanel.bt_start.addEventListener(MouseEvent.CLICK, send_start);
            zPanel.x = Math.floor(w/2);
            zPanel.y = Math.floor(h/2);
            gshape.addChild(zPanel);


            return gshape;
    }
    //--------------------------------
    private function send_start(e:MouseEvent) {
        _stage.dispatchEvent(new Event("startClick",true,false));
    }
}


//----------------------------------------------
//           Debug window
//----------------------------------------------
class ZDebug extends MovieClip {

    import flash.events.*;

    import fl.transitions.Tween;
    import fl.transitions.easing.Strong;

    import fl.controls.TextInput;
    import fl.controls.ScrollPolicy;
    import fl.controls.TextArea;

    import flash.text.TextFormat;
    import flash.text.TextField;
    import flash.text.StyleSheet;

    import fl.controls.Button;

    public const VIS_TRANS:Number=0.4;

    public var _parent:MovieClip;
    public var _dbg_box:MovieClip;
    public var _sysdate:Date;


    public var _ElementOn: MovieClip=null;

    public function ZDebug(_inparent) {

        _parent = _inparent;
    }

    //-------------------------------
        public function wr(tx, targ) {


            if (targ<3) {
                TextField(_dbg_box.getChildAt(targ)).htmlText = tx;
            } else if (targ<6) {
                TextInput(_dbg_box.getChildAt(targ)).text=tx;
            } else {
                _dbg_box.ztext.text = tx+String.fromCharCode(13)+_dbg_box.ztext.text;
            }
        }
        //-------------------------------
        private function z_mouseInfo() {

                _sysdate = new Date();
                var tm:String = _sysdate.getDate()+'.'+ _sysdate.getMonth()+'.'+
                _sysdate.getFullYear()+' '+_sysdate.getHours()+':'+
                _sysdate.getMinutes()+':'+_sysdate.getSeconds();

                wr('mouseTriggered '+tm,0);
                wr('mouseX='+mouseX,1);
                wr('mouseY='+mouseY,2);
        }
        //-------------------------------
        public function add_debugbox() {

            _dbg_box = new MovieClip();

            _dbg_box.inactive=true;
            _dbg_box.name='zdebugbox_inst';

            _dbg_box.graphics.beginFill(0xeeeeee);
            _dbg_box.graphics.lineStyle(1,0x888888);
            _dbg_box.graphics.drawRect(0,0, 300, 500);
            _dbg_box.graphics.endFill();
            _dbg_box.alpha=VIS_TRANS;


            _dbg_box.addEventListener(MouseEvent.MOUSE_OVER, dbgMouse_Over);
            _dbg_box.addEventListener(MouseEvent.MOUSE_OUT, dbgMouse_Out);

            var zfld:TextField;
            var zinp:TextInput;
            //--------------------
            var format:TextFormat = new TextFormat();
            format.align = 'right';
            format.bold = true;

            var sheet:StyleSheet = new StyleSheet();
            var st:Object = new Object();
            st.color='#880000';
            sheet.setStyle('body', st)

            //--------------------
            for (var i:Number=0; i<3; i++) {
                zfld = new TextField();
                zfld.width=290;
                zfld.height=20;
                zfld.styleSheet = sheet;
                zfld.x=5;
                zfld.y=5+i*25;

                _dbg_box.addChild(zfld);

            }
            //--------------------
            for (i=3; i<6; i++) {
                zinp = new TextInput();
                zinp.setSize(290, 20);
                zinp.setStyle("textFormat", format);

                zinp.graphics.beginFill(0xeeeeee);
                zinp.graphics.lineStyle(1,0x888888);
                zinp.graphics.drawRect(0,0, zinp.width, zinp.height);
                zinp.graphics.endFill();
                zinp.move(5,5+i*25);

                _dbg_box.addChild(zinp);

            }

            var ztext:TextArea = new TextArea();
            ztext.verticalScrollPolicy = ScrollPolicy.ON;
            ztext.setSize(290, 280);
            ztext.move(5,5+7*25);
            _dbg_box.ztext = ztext;
            _dbg_box.addChild(ztext);

            /*var btIn:Button = new Button();
            //btIn.emphasized = true;
            btIn.width = 30;
            btIn.height = 30;
            btIn.label = 'ftg';
            _dbg_box.addChild(btIn);
            //btIn.move(_dbg_box.width-35, _dbg_box.height-35);
            //_parent.addChild(btIn);
            //btIn.name = 'fadeOutButton';
            */

            var btIn = new mvFadeIn();
            btIn.name='fadeInButton';

            _dbg_box.addChild(btIn);
            btIn.x = _dbg_box.width-btIn.width-5;
            btIn.y = _dbg_box.height-btIn.height-5;


            _dbg_box.addEventListener(Event.ADDED_TO_STAGE, onAdd);
            return _dbg_box;


        }
        //-------------------------------
        private function onAdd(e:Event) {
            e.target.addEventListener(Event.ENTER_FRAME, onEnter_Frame);
        }
        //-------------------------------
        private function onEnter_Frame(e:Event) {

            wr('ch: '+_parent.numChildren,0);
            wr('chst: '+_parent.stage.numChildren,1);
        }
        //-------------------------------
        private function dbgMouse_Over(e:MouseEvent):void {

            if (_dbg_box.inactive==false)
               return;

            if (e.relatedObject==null)
               return;

            if (e.relatedObject.name!='fadeInButton')
               return;

            if (_ElementOn==null) {
                _ElementOn = MovieClip( _parent.getChildAt(_parent.getChildIndex(_dbg_box)-1));
            }

            _parent.setChildIndex(_dbg_box, _parent.numChildren - 1);
            var dbgTween:Tween = new Tween(_dbg_box, 'alpha', Strong.easeOut,
                                           VIS_TRANS,1, 0.5, true);
            _dbg_box.inactive=false;
        }
        //-------------------------------
        private function dbgMouse_Out(e:MouseEvent):void {


            /*if (e.relatedObject!==null) {
               wr(e.relatedObject.name, 5);
               if (e.relatedObject.name=='zdebugbox_inst')
                  return;

               if (e.relatedObject.parent.name=='zdebugbox_inst')
                  return;
            }*/
            if (_dbg_box.inactive==true)
               return;

            if (_dbg_box.hitTestPoint(mouseX,mouseY)==true)
               return;

            var dbgTween:Tween = new Tween(_dbg_box, 'alpha', Strong.easeOut,
                                           1, VIS_TRANS, 0.5, true);
            _parent.setChildIndex(_dbg_box,_parent.getChildIndex(_ElementOn)+1);
            _dbg_box.inactive=true;
        }
}

//---------------------------------------------------------------
//                    zBase.as
//---------------------------------------------------------------
package  {
    import flash.display.MovieClip;
    import flash.events.*;

    public class zBase extends MovieClip{

        public var _parent:ZMain;

        public var speedX:Number=0;
        public var speedY:Number=0;
        public var speedSX: Number=1;
        public var speedSY: Number=1;
        public var speedSPX: Number=0;
        public var speedSPY: Number=0;
        public var rotSpeed:Number=0;
        public var alphaSpeed:Number=0;

        public var removing:Boolean = false;

        public function zBase(_inparent:ZMain) {

            _parent = _inparent;
            _parent._hlp._alldynels.push(this);

            addEventListener(Event.ADDED_TO_STAGE, onAdded);
            addEventListener(Event.ENTER_FRAME, onEnter_frame);
        }
        //---------------------------------
        public function onAdded(e:Event) {

        }
        //---------------------------------
        public function onEnter_frame(e:Event) {

            updSpeed();


            x+=speedX;
            y+=speedY;
            rotation+=rotSpeed;
            alpha+=alphaSpeed;

            scaleX *= speedSX;
            scaleY *= speedSY;
            scaleX += speedSPX;
            scaleY += speedSPY;

            checkEnv();
        }
        //---------------------------------
        public function _final() {

            if (removing)
               return;

            removing = true;
            removeEventListener(Event.ENTER_FRAME, onEnter_frame);
            _parent._hlp._removeDynEl(this);

            user_final();

            _parent.removeChild(this);
        }
        //---------------------------------
        public function user_final() {
        }
        //---------------------------------
        public function updSpeed() {
        }
        //---------------------------------
        public function checkEnv() {
        }

    }

}

//---------------------------------------------------------------
//                    zFlower.as
//---------------------------------------------------------------
package  {

    import flash.display.MovieClip;

    import flash.geom.ColorTransform;
    import flash.geom.Point;
    import flash.events.*;
    import flash.utils.*;


    public class zFlower extends zBase {

        const VELDIV =400;


        public var _targEl: zFlower=null;
        public var _targ: Point;
        public var _velMod:Number;
        public var _fireMode:Boolean = false;
        public var _Trace: mvTrace;

        //----------------------------------
        public function zFlower(_inparent:ZMain) {

            super(_inparent);

            _targ = new Point(x,y);
            rotSpeed=10;
            //setTimeout(addTimer, Math.floor(Math.random()*4000));

        }
        //----------------------------------
        private function addTimer() {

            var _timer = new Timer(50);
            _timer.addEventListener(TimerEvent.TIMER, appTrace);
            _timer.start();
        }
        //----------------------------------
        override public function onAdded(e:Event) {

            var st:Number = Math.ceil(Math.random()*totalFrames);
            gotoAndPlay(st);

            if (_fireMode)
                addTimer();

        }
        //----------------------------------
        private function appTrace(e:TimerEvent) {

            if (!_parent._hlp.mouse_pressed)
               return;

            _Trace = new mvTrace(_parent);
            _Trace.x = x;
            _Trace.y = y;
            var koef = Math.random()*2+1;
            _Trace.speedX = speedX*koef;
            _Trace.speedY = speedY*koef;
            _parent.addChildAt(_Trace, _parent._hlp._getFlowerIndex(true));

            var snd = new sndFire();
            snd.play();
        }
        //----------------------------------
        override public function updSpeed() {

            if (_targEl!==null) {

               speedX = (_targEl.x - x )*_velMod/VELDIV;
               speedY = (_targEl.y - y )*_velMod/VELDIV;

               speedSPX = speedSPY = (_targEl.scaleX-scaleX)/3;

            }
            else {

               speedX = (_targ.x - x )*_velMod/VELDIV;
               speedY = (_targ.y - y )*_velMod/VELDIV;
            }

        }
        //----------------------------------
        override public function checkEnv() {

            if  (_parent._hlp._hitTestTree(this))
                visible=false;
            else
                visible=true;


        }
    }

}

//---------------------------------------------------------------
//                    mvTrace.as
//---------------------------------------------------------------
package  {

    import flash.display.MovieClip;
    import flash.events.*;


    public class mvTrace extends zBase {


        public function mvTrace(_inparent) {
            super(_inparent);

            speedSX = speedSY = 1.03;
            alphaSpeed = -0.01;
            rotSpeed = -20;
        }

        override public function user_final() {

            var mvf:mvFlash = new mvFlash(_parent);
            mvf.x = x;
            mvf.y = y;
            _parent.addChildAt(mvf, _parent.getChildIndex(this));

        }

        override public function checkEnv() {
            //alpha-=.01;

            var snd;

            if (currentFrame==totalFrames) {

                 snd = new sndExpl();
                 snd.play();
                _final();
            }

            if  (_parent._hlp._hitTestTree(this))
                visible=false;
            else
                visible=true;

            if (_parent._hlp._hitTestCloud(this)!=false) {

                snd = new sndHitCloud();
                snd.play();

                _final();
             }


            var bird=_parent._hlp._hitTestBird(this)
            if (bird!=false)
               bird.birdHit();

        }
    }

}

//---------------------------------------------------------------
//                    mvCloud.as
//---------------------------------------------------------------
package  {

    import flash.display.MovieClip;
    import flash.events.*;
    import flash.filters.BlurFilter;
    import flash.filters.BitmapFilterQuality;
    import flash.display.Bitmap;
    import flash.display.BitmapData;

    import flash.geom.Rectangle;
    import flash.geom.Matrix;
    import flash.geom.ColorTransform;

    public class mvCloud extends zBase {


        public var _shade:MovieClip;

        //----------------------------------
        private function add_shade() {

            _shade = new MovieClip();

            var _bm:BitmapData = new BitmapData(width, height, true, 0x000000);

            var _rect:Rectangle = getRect(this);
            var _matrix = new Matrix();
            _matrix.translate(width/2, height/2);

            //_bm.fillRect(_rect,0xffff00);

            _bm.draw(this,_matrix,null,null,null);

            var _bmp:Bitmap = new Bitmap(_bm);
            _bmp.x=0;
            _bmp.y=0;
            _shade.addChild(_bmp);

            var cTrans:ColorTransform = _shade.transform.colorTransform;
            cTrans.color=0x000000;
            _shade.transform.colorTransform = cTrans;
            var _blurS:BlurFilter = new BlurFilter(9,9, BitmapFilterQuality.LOW);
            _shade.filters = [_blurS];
        }
        //----------------------------------
        private function pos_shade() {

            _shade.x = x-width/2;
            _shade.y=int(_parent.SPLIT_LINE+(_parent.SPLIT_LINE-y)/2*Math.pow(scaleX,4));
            _shade.scaleX = scaleX*1.2 ;
            _shade.scaleY = Math.pow(scaleY,2);
            _shade.alpha=0.3*scaleX;

            _parent.addChild(_shade);
        }
        //----------------------------------
        private function add_filters() {

            var _blur:BlurFilter = new BlurFilter(4,4, BitmapFilterQuality.LOW);
            var arr:Array = new Array();
            arr.push(_blur);
            filters = arr;
        }
        //----------------------------------
        public function mvCloud(_inparent) {

            super(_inparent);

            speedX = -1;
            speedY = 0;
            add_shade();
            add_filters();
        }

        //----------------------------------
        override public function onAdded(e:Event) {

            pos_shade();
            var st:Number = Math.ceil(Math.random()*totalFrames);
            gotoAndPlay(st);
        }

        //----------------------------------
        override public function user_final() {
            _parent.removeChild(_shade);
            _parent._hlp._removeCloud(this);
        }
        //----------------------------------
        override public function checkEnv()  {

            _shade.x = x-width/2;

            if (x<-200) {
                _final();
            }
        }

    }

}

//---------------------------------------------------------------
//                    mvBird.as
//---------------------------------------------------------------
package  {

    import flash.display.MovieClip;
    import flash.events.*;
    import flash.filters.BitmapFilterQuality;
    import flash.filters.GlowFilter;
    import flash.filters.BlurFilter;
    import flash.filters.DropShadowFilter;
    import flash.utils.setTimeout;
    import flash.utils.Timer;

    public class mvBird extends zBase {


        public var _shade:mvBird_shade;
        public var z_coin:Boolean = false;
        public var n_coins:int=0;

        //----------------------------------------
        private function add_filters() {

            var red:int = 150;
            var green:int = 150;
            var blue:int = 150;

            var type:int = int(Math.random()*4);
            switch (type) {
                case 1:
                   red += int(Math.random()*105);
                   break;

                case 2:
                   green += int(Math.random()*105);
                   break;

                case 3:
                   blue += int(Math.random()*105);
                   break;

                default:
                 red += int(Math.random()*105);
            }

            var color:Number = Number("0x" + red.toString(16) +
                                    green.toString(16) + blue.toString(16));



            var glowFilter:GlowFilter = new GlowFilter(color, 0.8, 30, 30, 4,
            BitmapFilterQuality.LOW, true, false);


            var _shadow = new DropShadowFilter(3,45, 0x000000,0.7, 4,4, 1,
                                        BitmapFilterQuality.LOW, true, false);

            var _blur:BlurFilter = new BlurFilter(1,1, BitmapFilterQuality.LOW);

            filters = [ /*glowFilter, _blur,*/ _shadow ];
        }

        //----------------------------------------
        public function add_shade() {

            _shade = new mvBird_shade();

            var _blurS:BlurFilter = new BlurFilter(9,9, BitmapFilterQuality.LOW);
            _shade.filters = [_blurS];
        }

        //----------------------------------------
        public function pos_shade() {

            _shade.x = x-width/2;
            _shade.y=int(_parent.SPLIT_LINE+(_parent.SPLIT_LINE-y)/2*Math.pow(scaleX,4));
            _shade.scaleX = scaleX*1.2 ;
            _shade.scaleY = Math.pow(scaleY,2);
            _shade.alpha=0.5*scaleX;

            _parent.addChild(_shade);
        }

        //----------------------------------------
        public function mvBird(_inparent) {

            super(_inparent);

            speedX = -1*Math.random()*6-1;
            speedY = 0;
            rotSpeed = 0;

            add_filters();
            add_shade();
        }

        //----------------------------------
        override public function onAdded(e:Event) {

            pos_shade();

            var st:Number = Math.ceil(Math.random()*29);
            gotoAndPlay(st);
        }

        //----------------------------------
        public function killed() {
            speedY =4;
            rotSpeed=-5;

            var snd = new sndScream();
            snd.play();
        }
        //----------------------------------
        public function birdHit() {

            if (speedY>=4)
               return;

            rotSpeed+=3;
            if (currentFrame>30)
               return;

            gotoAndPlay(31);

            var snd = new sndShot();
            snd.play();
        }
        //----------------------------------
        override public function user_final() {
            _parent.removeChild(_shade);
            _parent._hlp._removeBird(this);
        }
        //----------------------------------
        private function appTrace() {

            var _coin = new mvCoin(_parent);
            _coin.x = x;
            _coin.y = y;
            _coin.scaleX=_coin.scaleY = scaleX;
            _coin.speedX = Math.random()*4;
            _coin.speedY = 4;
            _parent.addChildAt(_coin, _parent._hlp._getFlowerIndex(true));

            var snd = new sndCoin();
            snd.play();

            z_coin=false;

            n_coins++;
            if (n_coins>16)
               killed();
        }
        //----------------------------------
        private function setSmoke() {
            var _smoke = new mvSmoke(_parent);
            _smoke.x = x;
            _smoke.y = y;
            _smoke.scaleX=_smoke.scaleY = scaleX;

            _parent.addChildAt(_smoke, _parent._hlp._getFlowerIndex(true));

        }
        //----------------------------------
        private function setExplosion() {
            var _ztime:Timer = new Timer(1, 4);
            _ztime.addEventListener(TimerEvent.TIMER, zExpl);
            _ztime.start();

            var snd = new sndBirdFall();
            snd.play();
        }
        //----------------------------------
        private function zExpl(e:TimerEvent) {
            var _expl = new mvExplosion(_parent);
            _expl.x = x;
            _expl.y = y;
            _expl.scaleX=_expl.scaleY = scaleX;

            _parent.addChildAt(_expl, _parent._hlp._getFlowerIndex(true));
        }
        //----------------------------
        private function add_bubble() {

            var _bubble = new mvBubble(_parent);
            _bubble.x = x;
            _bubble.y = y-70;


            _bubble.txBubble.text="500";

            _parent.addChildAt(_bubble, _parent._hlp._getFlowerIndex(true));
        }
        //----------------------------------
        override public function checkEnv() {

            rotation +=int(Math.random()*6-3);
            if ((rotSpeed>15) && (speedY<4)) {

                setSmoke();


                var snd;
                if (!z_coin) {

                    switch (n_coins) {
                        case 0:
                        case 1: snd =  new sndBird();break;
                        case 2: snd =  new sndBird5();break;
                        case 3: snd =  new sndBird6();break;
                        case 4: snd =  new sndBird7();break;
                        default: snd =  new sndBird();
                    }
                    snd.play();

                    z_coin=true;
                    setTimeout(appTrace,500);

                }
            }
            if ((rotSpeed>40) && (speedY<4)) {
                killed();
            }

            if (speedY>=4) {
                setSmoke();
            }

            rotSpeed*=0.9;
            _shade.x = x-width/2;
            _shade.rotation = rotation;

            if (x<-200) {
                _final();
            }

            if (y>450) {
                setExplosion();
                _parent._addScore(500);
                add_bubble();
                _final();
            }
        }
    }

}

//--------------------------------------------------------------
//                    mvCoin.as
//--------------------------------------------------------------
package  {

    import flash.display.MovieClip;


    public class mvCoin extends zBase {

        //----------------------------
        public function mvCoin(_inparent) {
            super(_inparent);
        }

        //----------------------------
        override public function user_final() {

            var mvf:mvFlash = new mvFlash(_parent);
            mvf.x = x;
            mvf.y = y;
            mvf.scaleX = mvf.scaleY = 1.5;
            _parent.addChildAt(mvf, _parent.getChildIndex(this));

        }
        //----------------------------
        private function add_bubble() {

            var _bubble = new mvBubble(_parent);
            _bubble.x = x;
            _bubble.y = y;

            _bubble.txBubble.text="100";

            _parent.addChildAt(_bubble, _parent._hlp._getFlowerIndex(true));
        }
        //----------------------------
        override public function checkEnv() {

            if (y>_parent.SPLIT_LINE) {
                _final();
            }

            if (_parent._hlp._hitTestFlower(this)) {
                _parent._addScore(100);

                var snd = new sndCoinGet();
                snd.play();

                add_bubble();
                _final();
            }
        }
    }

}

//--------------------------------------------------------------
//                    mvExplosion.as
//--------------------------------------------------------------
package  {

    import flash.display.MovieClip;
    import flash.filters.BitmapFilterQuality;
    import flash.filters.BlurFilter;

    public class mvExplosion extends zBase {


        public function mvExplosion(_inparent) {

            super(_inparent);

            speedSX=speedSY=1.7;
            speedY=Math.random()*10-5;
            speedX = Math.random()*10-5;
            alphaSpeed = -0.15;

            var _blurS:BlurFilter = new BlurFilter(9,9, BitmapFilterQuality.LOW);
            filters = [_blurS];
        }

        override public function checkEnv() {
            if (alpha<0.1) {
                _final();
            }
        }
    }

}

//--------------------------------------------------------------
//                    mvBubble.as
//--------------------------------------------------------------
package  {

    import flash.display.MovieClip;


    public class mvBubble extends zBase {


        public function mvBubble(_inparent) {

            super(_inparent);

            speedY = -10;
            speedSX = speedSY = 1.05;
            alphaSpeed = -0.04;

        }

        override public function checkEnv() {
            if (scaleX>1.5) {
                _final();
            }
        }

    }

}

//--------------------------------------------------------------
//                    mvSmoke.as
//--------------------------------------------------------------
package  {

    import flash.display.MovieClip;


    public class mvSmoke extends zBase {


        public function mvSmoke(_inparent) {
            super(_inparent)

            speedSX=speedSY=1.05;
            speedY=-3;
            speedX = Math.random()*4-2;
            alphaSpeed = -0.05;
        }

        override public function checkEnv() {
            if (alpha<0.1) {
                _final();
            }
        }
    }

}

//--------------------------------------------------------------
//                    mvFlash.as
//--------------------------------------------------------------
package  {

    import flash.display.MovieClip;
    import flash.events.*;


    public class mvFlash extends zBase {


        //--------------------------------
        public function mvFlash(_inparent) {

            super(_inparent);
        }
        //--------------------------------
        override public function checkEnv() {

            if (currentFrame==totalFrames) {
               _final();
            }
        }
    }

}