-----------------------------------------snow2.ks-------------------------------------------------

;整理by karryngai(darkcross007部分改，谢谢karryngai前辈的整理)
@if exp="typeof(global.snow2_object) == 'undefined'"
@iscript

/*
        下雪的插件
*/

class snow2Grain
{
        // 雪粒的类

        var fore; // 表层的雪粒对象
        var back; // 里层的雪粒速度
        var xvelo; // 横向速度
        var yvelo; // 纵向速度
        var xaccel; // 横向加速度
        var l, t; // 横向坐标位置和纵向坐标位置
        var owner; // 这个类的所属，也就是指snow2Plugin
        var spawned = false; // 雪粒是否出现了
        var window; // Window的对象

        function snow2Grain(window, n, owner)
        {
                // snow2Grain的构造方法
                this.owner = owner;
                this.window = window;

                fore = new Layer(window, window.fore.base);
                back = new Layer(window, window.back.base);

                fore.absolute = 100010-1; // 把表层和里层的次序设置在最前面
                back.absolute = fore.absolute;

                fore.hitType = htMask;
                fore.hitThreshold = 256; // 鼠标移过去时不会在当层触发事件，并且相当于穿透了该层
                back.hitType = htMask;
                back.hitThreshold = 256;

                fore.loadImages("snow2_" + n); // 读取画像
                back.assignImages(fore);
                fore.setSizeToImageSize(); // 设定里表层的大小和图像一样
                back.setSizeToImageSize();
                xvelo = 0; // 横向速度为0
                yvelo = -(n*0.6 + 1.9 + Math.random() * 0.2);// 纵向的速度，雪粒越大，其纵向速度就越大
                xaccel = Math.random(); // 开始时的横向加速度
        }

        function finalize()
        {
                invalidate fore;        //销毁表里层
                invalidate back;
        }

        function spawn()
        {
                // 雪粒出现了
                l = Math.random() * window.primaryLayer.width; // 横向坐标的初始位置
                t = window.primaryLayer.height;fore.height; // 纵向坐标的初始位置
                spawned = true;
                fore.setPos(l, t);
                back.setPos(l, t); // 里层的坐标也设置的一样
                fore.visible = owner.foreVisible;
                back.visible = owner.backVisible;
        }

        function resetVisibleState()
        {
                // 如果雪粒出现了就根据所属类设定表里层的可视性
                if(spawned)
                {
                        fore.visible = owner.foreVisible;
                        back.visible = owner.backVisible;
                }
                else
                {
                        fore.visible = false;
                        back.visible = false;
                }
        }

        function move()
        {
                // 雪粒移动
                if(!spawned)
                {
                        // 如果雪粒不出现，就以极低的机率让它出现，雪粒多了，出现的机率就大了
                        if(Math.random() < 0.002) spawn();
                }
                else
                {
                        l += xvelo;
                        t += yvelo;
                        xvelo += xaccel;                        //让零的横向速度加上一个0至1间的加速度值
                        xaccel += (Math.random() - 0.5) * 0.3;        //改变加速度值，改变大小为-0.15到+0.15之间
                        if(xvelo>=1.5) xvelo=1.5;                //把横向速度限死在-1.5至1.5间
                        if(xvelo<=-1.5) xvelo=-1.5;
                        if(xaccel>=0.2) xaccel=0.2;                //把横向加速度限死在-0.2至0.2间
                        if(xaccel<=-0.2) xaccel=-0.2;
                        if(t <= 0)        //如果雪粒飘出了画面，把它们送回画面的上方
                        {
                                t = window.primaryLayer.height;
                                l = Math.random() * window.primaryLayer.width;
                        }
                        fore.setPos(l, t);
                        back.setPos(l, t); // 里层和表层的位置相同
                }
        }

        function exchangeForeBack()
        {
                // 交换表里层
                var tmp = fore;
                fore = back;
                back = tmp;
        }
}

class snow2Plugin extends KAGPlugin
{
        // 下雪的插件

        var snow2s = []; // 雪粒
        var timer; // 计时器
        var window; // Window类的对象
        var foreVisible = true; // 表层是否可视
        var backVisible = true; // 里层是否可视

        function snow2Plugin(window)
        {
                super.KAGPlugin();
                this.window = window;
        }

        function finalize()
        {
                // finalize方法
                // 销毁类里的所有对象
                for(var i = 0; i < snow2s.count; i++)
                        invalidate snow2s;
                invalidate snow2s;

                invalidate timer if timer !== void;

                super.finalize(...);
        }

        function init(num, options)
        {
                // num 是雪粒出现的个数
                if(timer !== void) return; // 如果计时器运作了，跳出方法

                // 制作雪粒
                for(var i = 0; i < num; i++)
                {
                        var n = intrandom(0, 4); // 随机选择雪粒的种类，数字越大，雪粒越大，可参看雪粒的图像
                        snow2s = new snow2Grain(window, n, this);
                }
                snow2s[0].spawn(); // 让最初的雪粒呈现

                // 制作计时器
                timer = new Timer(onTimer, '');
                timer.interval = 80;
                timer.enabled = true;

                foreVisible = true;
                backVisible = true;
                setOptions(options); // 设定类里的变量，这和读入的东西有关
        }

        function uninit()
        {
                // 消除雪粒
                if(timer === void) return; // 雪粒如没出现，跳出方法

                for(var i = 0; i < snow2s.count; i++)
                        invalidate snow2s;
                snow2s.count = 0;

                invalidate timer;
                timer = void;
        }

        function setOptions(elm)
        {
                // 设定表里层可视性
                foreVisible = +elm.forevisible if elm.forevisible !== void;
                backVisible = +elm.backvisible if elm.backvisible !== void;
                resetVisibleState();
        }

        function onTimer()
        {
                // 计时器每周期呼叫的事件
                var snow2count = snow2s.count;
                for(var i = 0; i < snow2count; i++)
                        snow2s.move(); // 叫出move方法
        }

        function resetVisibleState()
        {
                // 重新设定雪粒的可视性
                var snow2count = snow2s.count;
                for(var i = 0; i < snow2count; i++)
                        snow2s.resetVisibleState(); // 叫出resetVisibleState方法
        }

        function onStore(f, elm)
        {
                // 保存雪粒的资料，主要用于tempsave时
                var dic = f.snow2s = %[];
                dic.init = timer !== void;
                dic.foreVisible = foreVisible;
                dic.backVisible = backVisible;
                dic.snow2Count = snow2s.count;
        }

        function onRestore(f, clear, elm)
        {
                // 读取保存的资料，主要用于tempload
                var dic = f.snow2s;
                if(dic === void || !+dic.init)
                {
                        // 雪没有飘出来
                        uninit();
                }
                else if(dic !== void && +dic.init)
                {
                        //雪飘出来了
                        init(dic.snow2Count, %[ forevisible : dic.foreVisible, backvisible : dic.backVisible ] );
                }
        }

        function onStableStateChanged(stable)
        {
        }

        function onMessageHiddenStateChanged(hidden)
        {
        }

        function onCopyLayer(toback)
        {
                // 表里层可视信息互相传递
                if(toback)
                {
                        // 表→里
                        backVisible = foreVisible;
                }
                else
                {
                        // 里→表
                        foreVisible = backVisible;
                }
                resetVisibleState();
        }

        function onExchangeForeBack()
        {
                // 表里层互相交换地址
                var snow2count = snow2s.count;
                for(var i = 0; i < snow2count; i++)
                        snow2s.exchangeForeBack(); // 叫出exchangeForeBack方法
        }
}

kag.addPlugin(global.snow2_object = new snow2Plugin(kag));
        // 注册snow2插件的对象

@endscript
@endif
;封装起来
@macro name="snow2init"
@eval exp="snow2_object.init(500, mp)"
@endmacro
@macro name="snow2uninit"
@eval exp="snow2_object.uninit()"
@endmacro
@macro name="snow2opt"
@eval exp="snow2_object.setOptions(mp)"
@endmacro
@return

----------------------------------------------------------------------------------------------------------

调用同snow

需要将snow的png  改为  snow2_(n).png

---------------------------------------------------------------------------------------------------------

补充，这个插件可以用来展现“气球纷飞”等等效果

主要是做到素材的摆动逆上升。