/**
  $Id: FuncMovie.as 78 2007-08-07 19:07:27Z gijsbert $
*/

import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Transform;

class FuncMovie extends MovieClip
{
    // Register this class so we can use attachMovie to create them.
    public static var symbolName : String = "__Packages.FuncMovie";
    public static var symbolLinked : Boolean =
        Object.registerClass( symbolName, FuncMovie );

    private static var s_initialized : Boolean = init();
    
    private static function init() : Boolean 
    {
        trace( "FuncMovie.init" );
        trace( "symbolName = " + symbolName );
        trace( "symbolLinked = " + symbolLinked );
        return true;
    }
    
    private var ls : Number;
    private var t  : Number;
    private var ts : Number;
    private var ms : Number;
    private var maxpts : Number;
    private var nbEvals : Number;
    private var maxeval : Number;
    private var pts : Array;
    private var m_w : Number;
    private var m_h : Number;
    
    // Movie clip tracer.
    static function tr(t : String, mc : MovieClip) {
        trace(t + " " +
              mc + " @ " + mc._x + "," + mc._y + " size " + mc._width + "," + mc._height);
        trace("  scale " + mc._xscale + "," + mc._yscale + " depth " + mc.getDepth());
    }
    static function trp(mc : MovieClip) {
        if ( mc._parent ) {
            tr( "parent:", mc._parent );
            trp( mc._parent );
        }
    }

    // FuncMovie: constructor.
    function FuncMovie() 
    {
        trace("FuncMovie.FuncMovie");
        tr( "this", this );
        trace("Stage " + Stage.width + "x" + Stage.height);
        trp( this );

        // Setup transform.
        transform = new Transform( this );

        // FIXME: should get those initial values from somewhere? you can pass init object
        // into attachMovie, how to not override those?
        ts = 1;
        ls = 4;
        ms = 1;
        maxpts = 256;
        maxeval = 1024;
        trace("_parent._totalframes=" + _parent._totalframes);
        _parent._totalframes = maxeval;
        trace("_parent._totalframes=" + _parent._totalframes);
        
        setupCircle();
        
        // Do some stuff on key release.
        Key.addListener( this );

        // Adjust to size changes.
        Stage.addListener( this );
    }
    
    // reset: reset vars to restart animation.
    function reset() {
        t = 0;
        pts = new Array;
        nbEvals = 0;
    }
    
    // Start animating onLoad.
    function onLoad() {
        trace("FuncMovie.onLoad");
        tr( "this", this );
        trp( this );
        setupMatrix( Stage.width, Stage.height );
        onEnterFrame = doStep;
        _parent._totalframes = maxeval;
    }

    // onResize: Stage listener.
    function onResize() {
        trace("FuncMovie.onResize");
        tr( "this", this );
        trp( this );
        setupMatrix( Stage.width, Stage.height );
    }

    // setupMatrix: sets up matrix and other viewport related values.
    function setupMatrix( w : Number, h : Number ) 
    {
        trace( "setupMatrix " + w + "," + h );
        m_w = w;
        m_h = h;

        var m : Matrix = new Matrix();
        m.identity();
        m.translate( w / 2, h / 2 );
        transform.matrix = m;

        ms = 0.95 * Math.min( w, h ) / 2;
    }

    // redraw function.
    function redraw()
    {
        clear();

        // To get some size.
        beginFill(0x000000, 1);
        var w:Number = m_w / 2;
        var h:Number = m_h / 2;
        moveTo(-w, -h);
        lineTo( w, -h);
        lineTo( w,  h);
        lineTo(-w,  h);
        endFill();
        
        lineStyle( ls, 0xffff00 );
        if ( pts.length > 0 ) {
            moveTo( pts[0].x, pts[0].y );
            for ( var i : Number = 1; i < pts.length; ++i ) {
                lineTo( pts[i].x, pts[i].y );
            }
        }
    }
    
    // play: not sure when this is called or why.
    function play()
    {
        trace( "FuncMovie.play" );
        tr( "this", this );
        trp( this );
        reset();
        super.play();
    }
    
    // stop: remove onEnterFrame
    function stop() {
        trace( "FuncMovie.stop" );
        onEnterFrame = undefined;
        super.stop();
    }
    
    function gotoAndStop(frame:Object):Void
    {
        stop();
        var frameNb:Number = parseInt(String(frame));
        if (!isNaN(frameNb)) {
            reset();
            var i:Number;
            for (i = 1; i < frame; ++i) {
                t += ts;
                pts.push( eval( t, ms ) );
            }
            redraw();
            _currentframe = frameNb;
        }
    }
            
    function gotoAndPlay(frame:Object):Void
    {
        gotoAndStop(frame);
        onEnterFrame = doStep;
    }
            
    // doStep: increments 't' and evaluates the function, adds the new point to the pts
    // array and if array to big removes one point as well.
    function doStep() 
    {
        t += ts;
        pts.push( eval( t, ms ) );
        if ( pts.length > maxpts ) {
            pts.shift();
        }
        redraw();

        ++nbEvals;
        _currentframe = nbEvals;
        if ( nbEvals > maxeval ) {
            stop();
        }
    }

    function setupCircle()
    {
        trace( "setupCircle" );
        maxpts = 256;
        eval = evalCircle;
        reset();
    }
    
    function setupEpicycloide(a:Number, b:Number)
    {
        maxpts = 256 + 128;
        eval = evalEpicycloide;
        this["a"] = a;
        this["b"] = b;
        reset();
    }

    // eval: evaluate parametric function
    function eval(t:Number, s:Number):Point
    {
        return new Point( 0, 0 );
    }
    
    // evalCircle: evaluate parametric circle, getting smaller of t.
    function evalCircle(t:Number, s:Number):Point
    {
        t *= Math.PI / 45.0;
        s *= Math.max(0.1, 1 - t / 50);
        return new Point( Math.cos( t ) * s, Math.sin( t ) * s );
    }

    // evalEpicycloide: evaluate epicycloide.
    function evalEpicycloide(t:Number, s:Number):Point
    {
        t *= Math.PI / 30.0;
        s *= 0.4;
        var a : Number = this["a"];
        var b : Number = this["b"];
        return new Point(
            s * ( ( a + b ) * Math.cos( t ) - b * Math.cos((a+b)/b*t) ),
            s * ( ( a + b ) * Math.sin( t ) - b * Math.sin((a+b)/b*t) ) );
    }

    // onKeyDown: Key listener, ' ' forces a new random image to be loaded.
    function onKeyDown()
    {
        trace( "onKeyDown" );
        switch(Key.getCode()) {
            case Key.SPACE: {
            } break;
        }
        switch(Key.getAscii()) {
            case 'c'.charCodeAt(0): {
                setupCircle();
            } break;
            case 'e'.charCodeAt(0): {
                setupEpicycloide( 1, 1.211 );
            } break;
            case 'E'.charCodeAt(0): {
                setupEpicycloide( 1, 1.2 );
            } break;
        }
    }
}