[Golist] Fuse-like parser in a few minutes!

[Sebastian Weyrauch]

I really hope to finde some time for "tweego" the next days. Unfortunately
I'm busy in another project :(

 

 

Von: golist-bounces at goasap.org [mailto:golist-bounces at goasap.org] Im Auftrag
von Moses Gunesch
Gesendet: Donnerstag, 21. Februar 2008 08:47
An: Mailing list for the Go ActionScript Animation Platform
Betreff: [Golist] Fuse-like parser in a few minutes!

 

I will do a video tut on this topic soon.

 

My hope with Go was that the tween layer would typically stay OO in nature,
then people could build custom parsers to do Fuse syntax, XML syntax or
anything custom. Well, I gave it a shot and it worked just fine! Having
labored so long over Fuse myself, it was a little shocking how easy this
was.

 

First, I made a general multiple-property tween class that I called
BlockTweenMG. It has a method setProperty(name:String, value:Number) and the
constructor simply accepts two arrays like zigoengine used to:
(target:Object=null, props:Array=null, endVals:Array=null...).  It's
versatile enough to start with, although it doesn't support filters or other
fanciness.

 

Next I created a parser class that I called BlockParserMG with a static
method called go() and one called sequence(), pluse one private static
method parseAction() that parses a generic fuse object and returns a new
BlockTweenMG. 

 

public static function go(action:Object): BlockTweenMG {

    var tween:BlockTweenMG = parseAction(action);

    tween.start();

    return tween;

}

 

While go() just parses & starts one tween, sequence() will parse any number
of actions using an open input (...actions). It was easy to make it support
arrays of objects for parallel tweens like in Fuse. It builds & returns a
SequenceCA instance. 

 

parseAction() is amazingly lightweight. It makes the tween and loops through
the properties of the object. It goes, if (tween.hasOwnProperty(prop)) then
set the prop on the tween... this takes care of all the basic tween props:
delay, duration, easing, etc. Otherwise assume it's a tween prop and use the
addProperty() method on the tween instance. This was all simply too easy, so
I threw in one bit of fanciness. Go's SequenceCA class supports
Custom-Advance options for sequencing so I added a conditional to look for
the property 'advance' and set it to the current SequenceStepCA.

 

I ran this sequence and voila, it worked without a hitch!

 

var targ:Sprite = addSquareSprite();

BlockParserMG.sequence({ target: targ,

                                                x:200,

                                                scaleX:5,

                                                duration:2,

                                                // custom-advance before the
action completes:

                                                advance: new
OnDurationComplete(.5)

                                                },

 

                                              // a parallel-action array

                                              [{ target: targ,

                                                 y:200,

                                                 scaleY:5,

                                                 duration:1.5,

                                                 easing:Back.easeOut

                                                },

                                                { target: targ,

                                                  rotation:180,

                                                  easing:Back.easeInOut

                                                  }]);

 

I'll have a tutorial up soon on this, but don't wait... Try this at home! 

 

If you're not into Fuse syntax, try inventing your own XML syntax for
condensing animation code, or surprise us with something totally new.

 

:)

 

- m

 

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://goasap.org/pipermail/golist_goasap.org/attachments/20080229/d5d5263c/attachment.html