なんとなくProgressionのカスタムコマンド練習。

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

package {
    import jp.progression.commands.lists.ParallelList;
    import jp.progression.commands.lists.SerialList;
    import flash.display.Sprite;
    import flash.geom.Point;

    /**
     * @author KSKe
     * LineCommand Test Class
     */
    public class LineCommandTest extends Sprite {

        private var serialList : SerialList = new SerialList();
        private var parallelList :ParallelList = new ParallelList();
        private var sprites : Vector.<Sprite> = new Vector.<Sprite>();
        private var points : Vector.<Point> = new Vector.<Point>();
        private var initObject : Object;

        public function LineCommandTest() {
            
            initObject = {
                thick: 5, color: 0xcccccc * Math.random()
            };
            points.push(new Point(180, 20));
            points.push(new Point(80, 240));
            points.push(new Point(330, 100));
            points.push(new Point(30, 100));
            points.push(new Point(280, 240));
            points.push(new Point(180, 20));
            
            
            
            var i : int;
            for (i = 0;i < 5;i++) {
                var s : Sprite = new Sprite;
                addChild(s);
                sprites.push(s);
                var c : LineCommand = new LineCommand(s.graphics, 1.5, points[i], points[i + 1], initObject);
                serialList.addCommand(c);
            }
            
            serialList.onComplete = doParallel;
            
            serialList.execute();
        }

        private function doParallel() : void {
            serialList.onComplete = null;
            var i : int;
            for (i = 0;i < 5;i++) {
                sprites[i].graphics.clear();
                var c : LineCommand = new LineCommand(sprites[i].graphics, 1.5, points[i], points[i + 1], initObject);
                parallelList.addCommand(c);
            }
            
            parallelList.execute();
        }
    }
}

import flash.display.JointStyle;
import flash.display.CapsStyle;

import jp.progression.commands.Command;

import flash.display.Graphics;
import flash.display.LineScaleMode;
import flash.events.TimerEvent;
import flash.geom.Point;
import flash.utils.Timer;
import flash.utils.getTimer;

class LineCommand extends Command {
    private var g : Graphics;
    private var time : uint = 0;
    private var start : Point;
    private var diff : Point;
    private var ticker : Timer;
    private var startTime : uint;
    private var thick : Number;
    private var color : uint;
    private var alpha : Number;
    private var pixelHinting : Boolean;
    private var scaleMode : String;
    private var caps : String;
    private var joints : String;
    private var miterLimits : Number;

    public function LineCommand(g : Graphics, time : Number, start : Point, end : Point, initObject : Object = null) : void {
        super(_execute, _interrupt, initObject);
        this.g = g;
        this.time = time * 1000;
        this.start = start;
        
        diff = new Point(end.x - start.x, end.y - start.y);
        
        thick = Number(initObject && initObject.thick) || 1;
        color = uint(initObject && initObject.color) || 0x0;
        alpha = Number(initObject && initObject.alpha) || 1.0;
        pixelHinting = Boolean(initObject && initObject.pixelHinting) || false;
        scaleMode = String(initObject && initObject.scaleMode) || LineScaleMode.NORMAL;
        caps = String(initObject && initObject.caps) || CapsStyle.NONE;
        joints = String(initObject && initObject.joints) || JointStyle.MITER;
        miterLimits = Number(initObject && initObject.miterLimits) || 3;
    }

    private function setLineStyle() : void {
        g.lineStyle(thick, color, alpha, pixelHinting, scaleMode, caps, joints, miterLimits);
    }

    private function _interrupt() : void {
        stopTicker();
    }

    private function _execute() : void {
        startTime = getTimer();
        ticker = new Timer(1, 0);
        ticker.addEventListener(TimerEvent.TIMER, update);
        ticker.start();
    }

    private function update(e : TimerEvent) : void {
        var current : uint = getTimer();
        var elapse : uint = current - startTime;
        var fract : Number = elapse / time;
        
        fract = fract >= 1 ? 1 : fract;
        
        g.clear();
        setLineStyle();
        g.moveTo(start.x, start.y);
        g.lineTo(start.x + diff.x * fract, start.y + diff.y * fract);
        if(fract === 1) {
            stopTicker();
            executeComplete();
        }
    }

    private function stopTicker() : void {
        ticker.removeEventListener(TimerEvent.TIMER, update);
        ticker.stop();
    }
}