forked from: forked from: [ff]: ビリビリ（Lightning Effect）

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

// forked from h_sakurai's forked from: [ff]: ビリビリ（Lightning Effect）
// forked from bradsedito's [ff]: ビリビリ（Lightning Effect）




package 
{    
    import flash.display.BitmapData;
    import flash.display.Bitmap;
    import flash.events.Event;
    import flash.geom.Point;
    import flash.display.Sprite;
    import flash.geom.ColorTransform;
    import flash.geom.Matrix;
    import flash.filters.GlowFilter;
    import flash.events.MouseEvent;
    
    [SWF(width="465", height="465", backgroundColor="0", frameRate="30")]
    
    public class Main extends Sprite{
        private const W:Number = 465;
        private const H:Number = 465;
        private const RANGE:int = 31; // 1,3,5,15,31,93,155,465
        private var _pn:int = 0;
        private var _ps:Array = [];
        private var _sp:Sprite;
        private var _ctf:ColorTransform;
        private var _canvas:BitmapData;
        private var _glow:BitmapData;
        
        private var _rad:Number = 0.0;

        public function Main() {
            main = this;
            initialize();

            init();
            addEventListener(Event.ENTER_FRAME, update)    ;
            stage.addEventListener(MouseEvent.CLICK, onDown);
            
        
        }
        
        private function init():void
        {
            _ps[0] = new Point( W,H-H );
            _ps[1] = new Point(0, H);
            //_p = new Point( W/2,H/2 );
            _sp = new Sprite();
            //_sp.filters = [new GlowFilter(0xC9E6FC, 1, 10, 10, 4, 3, false, false)];
            _ctf = new ColorTransform(0.9, 0.96, 1, 0.9);
            _canvas = new BitmapData(W,H,true,0);
            
            var bm:Bitmap = new Bitmap(_canvas, "auto", true);
            //_glow = new BitmapData(W / RANGE, H / RANGE, true, 0);
            
            //var glowBm:Bitmap = new Bitmap(_glow, "never", true);
            //glowBm.blendMode = "add";
            //glowBm.scaleX = RANGE;
            //glowBm.scaleY = RANGE;
            
            addChild(bm);
            //addChild(glowBm);
        }
        
        private function onDown(e:MouseEvent):void{
            _ps[1] = new Point(mouseX, mouseY);
        }
                
        private function update(e:Event):void{
            var p:Point = new Point();
            var num:int = Math.random() * 5;
            p.x = _ps[0].x = mouseX;
            p.y = _ps[0].y = mouseY;
//            p.x = mouseX;
//            p.y = mouseY;
            _sp.graphics.clear();
            _sp.graphics.lineStyle(num, 0xFFFFFF, 1-(num / 10));
            _sp.graphics.moveTo(p.x, p.y);
            
            _rad += ( Math.random() * 90.0) * Math.PI / 180.0 * (Math.random() * 2.0 - 1.0);
            var rad:Number = _rad;
            var max:Number = 20.0;
            var speed:int;
            var noise:int;
            var l1:int = len2(_ps[0], _ps[1]);
            var ps:Array = [];
            
            while( l1 > len2(p, _ps[0])){
                speed = Math.random() * (Math.sqrt(l1)/40+10)/2;
                rad += Math.random() * max * Math.PI / 180.0 * (Math.random() * 2.0 - 1.0);
                noise = Math.random() * 8 - 4;
                p.x += Math.cos(rad) * speed + noise;
                p.y += Math.sin(rad) * speed + noise;
                ps.push(new Point(p.x, p.y));
            }
            var rad2:Number = Math.atan2(p.y-_ps[0].y, p.x-_ps[0].x);
            var rad1:Number = Math.atan2(_ps[1].y-_ps[0].y, _ps[1].x - _ps[0].x);
            rad2 = normalRad(rad2-rad1)
            
//rad2 = Math.PI / 2;
            for each (p in ps) {
                var x:Number = p.x - _ps[0].x;
                var y:Number = p.y - _ps[0].y;
                p.x = Math.cos(rad2)*x + Math.sin(rad2)*y + _ps[0].x;
                p.y = -Math.sin(rad2)*x + Math.cos(rad2)*y + _ps[0].y;
                _sp.graphics.lineTo(p.x, p.y);
                
            }

            
            _canvas.colorTransform(_canvas.rect, _ctf);
            _canvas.draw(_sp);
            _glow.draw(_canvas, new Matrix(1 / RANGE, 0, 0, 1 / RANGE));
        }
        private function len2(p:Point, p2:Point):int {
            var x2:int = (p.x - p2.x);
            var y2:int = (p.y - p2.y);
            return x2*x2+y2*y2;
        }
        private function normalRad(v:Number):Number {
            return v + 2 * Math.PI * (
                (v >  Math.PI) ? -1 :
                (v < -Math.PI) ? 1  : 0
            );
        }
    }
}
import flash.display.BitmapData;
import flash.display.Bitmap;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Rectangle;
import flash.text.TextField;
const W:int = 465;
const H:int = 465;
const BLUR_MAX:int = 8;
const SHOT_MAX:int = 5;
const SHOT2_MAX:int = 1;
const BGLIGHT_MAX:int = 160;
const GROUP_MAX:int = 7;

const BULLETS:int = 6;
const SHOTS:int = 5;
const ENEMIES:int = 4;
const SHIPS:int = 3;
const PARTICLES:int = 2;
const BLURS:int = 1;
const BGS:int = 0;

var screen:BitmapData = new BitmapData(W, H);
var main:Main;
var tf:TextField = new TextField();
function initialize():void {
    main.addChild(new Bitmap(screen));
    main.addChild(tf);
    tf.width = tf.height = 100;
    tf.text = "111";
    main.addEventListener(Event.ENTER_FRAME, update);
    main.stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDown);
    main.stage.addEventListener(MouseEvent.MOUSE_UP, mouseUp);
    for (var i:int = 0; i < BLUR_MAX; i++) {
        blurs[i]=new Vector.<Blur>(50);
        for(var j:int = 0; j < 50; j++) {
            blurs[i][j] = new Blur();
        }
    }
    for (i = 0; i < SHOT_MAX; i++) {
        shots[i] = new Shot();
    }
    for (i = 0; i < SHOT2_MAX; i++) {
        shot2s[i] = new Shot2();
    }
    for (i = 0; i < BGLIGHT_MAX; i++) {
        bglights[i] = new BGLight();
    }
    
    for (i = 0; i < GROUP_MAX; i++) {
        actors[i] = new Vector.<Actor>();
        nextActors[i] = new Vector.<Actor>();
    }
    ship.exists = true;
    actors[SHIPS].push(ship);
}
var mouse:Boolean;
function mouseDown(e:Event):void {
    mouse = true;
}
function mouseUp(e:Event):void {
    mouse = false;    
}
var rect:Rectangle = new Rectangle(0, 0, W, H);
function fillRect(x:int, y:int, w:int, h:int, col:int):void {
    rect.x = x;
    rect.y = y;
    rect.width = w;
    rect.height = h;
    screen.fillRect(rect, col);    
}
function update(e:Event):void {
    screen.lock();
    screen.fillRect(screen.rect, 0x00)
    var i:int;
    var j:int;
    for(var g:int = 0; g < GROUP_MAX; g++) {
        if(g==BLURS){
    for(i = 0; i < BLUR_MAX; i++){
        var bs:Vector.<Blur> = blurs[(i+blurIdx)%BLUR_MAX];
        for(j = 0; j < 50; j++) {
            var b:Blur = bs[j];
            if(!b.exists)continue;
            b.update();
        }    
    }
    blurIdx = (blurIdx + 1) % BLUR_MAX;
    for(j = 0; j < 50; j++) {
        blurs[blurIdx][j].exists = false;    
    }
            continue;            
        }
        var acs:Vector.<Actor> = actors[g];
        var len:int = acs.length;
        for(i = 0; i < len; i++) {
            acs[i].update();
            if(acs[i].exists)nextActors[g].push(acs[i]);
        }
        acs.length = 0;
    }
//    for(j=0;j<4;j++)
        newBGLight();
    var tmpActors:Vector.<Vector.<Actor>> = actors;
    actors = nextActors;
    nextActors = tmpActors;
    screen.unlock();
}

var actors:Vector.<Vector.<Actor>>=new Vector.<Vector.<Actor>>();
var nextActors:Vector.<Vector.<Actor>>=new Vector.<Vector.<Actor>>();
class Actor {
    public var x:Number;
    public var y:Number;
    public var exists:Boolean = false;
    public function update():void{}
}
var ship:Ship = new Ship();
class Ship extends Actor {
    public override function update():void {
        x = main.stage.mouseX;
        y = main.stage.mouseY;
        fillRect(x-10, y-10, 20, 20, 0xffff8888);
        if(mouse){
            newShot(x, y);
            newShot2(x, y);
        }
        newBlur(x, y, 0xffff8888, 10, 10);
    }
}

var blurs:Vector.<Vector.<Blur>> = new Vector.<Vector.<Blur>>(BLUR_MAX);
var blurIdx:int = 0;
function newBlur(x:Number, y:Number, col:int, w:int, h:int):void {
    var bs:Vector.<Blur> = blurs[blurIdx];
    for(var i:int = 0; i < 50; i++) {
        if(!bs[i].exists) {
            var b:Blur = bs[i];
            b.x = x;
            b.y = y;
            b.col = col;
            b.w = w;
            b.h = h;
            b.tick = 0;
            b.exists = true;
            break;
        }
    }
}
class Blur extends Actor {
    public var col:int;
    public var tick:int;
    public var w:int;
    public var h:int;
    public var l:int;
    public var vl:int = 2;
    public override function update():void {
        var r:int = (col>>16)&0xff;
        var g:int = (col>>8)&0xff;
        var b:int = (col)&0xff;
        var t:Number = 0.5 - tick / BLUR_MAX/2;
        var t2:Number = (1 - t) * (0xcc+l);
        r = r * t + t2;
        g = g * t + t2;
        b = b * t + t2;
        
        var c:int = (col & 0xff000000)|(r << 16)|(g << 8)|b;
        tick++;
        w+=2; h+=2;
        l+=vl;
        if(l > 20||l <= 0)vl=- vl;
        
        fillRect(x - w, y - h, w * 2, h * 2, c);
    }
}
var shots:Vector.<Shot> = new Vector.<Shot>(SHOT_MAX);
function newShot(x:Number, y:Number):void {
    for(var i:int = 0; i < SHOT_MAX; i++) {
        if(!shots[i].exists) {
            var b:Shot = shots[i];
            b.x = x;
            b.y = y;
            b.exists = true;
            nextActors[SHOTS].push(b);
            break;
        }
    }
}
class Shot extends Actor {
    public override function update():void {
        x+= 20;
        if(x > W) exists = false;
        fillRect(x-10, y-5, 20, 10, 0xff8888ff);
        newBlur(x, y, 0xffffffff, 10, 5);
    }
}


var shot2s:Vector.<Shot2> = new Vector.<Shot2>(SHOT2_MAX);
function newShot2(x:Number, y:Number):void {
    for(var i:int = 0; i < SHOT2_MAX; i++) {
        if(!shot2s[i].exists) {
            var b:Shot2 = shot2s[i];
            b.x = x;
            b.y = y;
            b.exists = true;
            b.vy = 0;
            nextActors[SHOTS].push(b);
            break;
        }
    }
}
class Shot2 extends Actor {
    public var vy:Number;
    public override function update():void {
        x+= 20;
        vy+=1;
        y+=vy;
        if(x > W || y > H) exists = false;
        fillRect(x-5, y-5, 10, 10, 0xff8888ff);
        newBlur(x, y, 0xffffffff, 10, 10);
    }
}

var bglights:Vector.<BGLight> = new Vector.<BGLight>(BGLIGHT_MAX);
            const XSPEED:int = 8;
function newBGLight():void {
    for(var i:int = 0; i < BGLIGHT_MAX; i++) {
        if(!bglights[i].exists) {
            var b:BGLight = bglights[i];
            b.exists = true;
            switch(i % 2){
            case 0:
                b.vx = (Math.random() < 0.5 ? 1 : -1)*b.speed-XSPEED; b.vy = 0;
                b.x = W;
                b.y = int(H * Math.random()/8)*8;
                break;
            case 1:
                switch(int(Math.random()*4)){
//                case 0:
//                    b.x = int(W * Math.random()/8)*8;
//                    b.y = H;
//                    b.vy = -b.speed; b.vx = -20;break;
//                case 1:
//                    b.x = int(W * Math.random()/8)*8;
//                    b.y = -100;
//                    b.vy = b.speed; b.vx = -XSPEED;break;
                default:
                    b.x = W;
                    b.y = int(H * Math.random()/8)*8;
                    b.vy = (Math.random() < 0.5 ? 1 : -1)*b.speed;
                    b.vx = -XSPEED;break;
                }
                
            }
            if(b.vx >= 0) {
                b.x = -100;
            }
            nextActors[BGS].push(b);
            break;
        }
    }
}
class BGLight extends Actor {
    public var speed:int = Math.random()*10+5;
    public var vx:int;
    public var vy:int;
    public override function update():void {
        //x += vx; y += vy;
        x -= XSPEED;
        if(vy != 0)
            fillRect(x,y,4,100, 0xffeeeeee);
        else
            fillRect(x,y,100,4, 0xffeeeeee);
        if(x < -100 || x > W || y < -100 || y > H) exists = false;
    }    
}