notice: Flash editor updated! Join the development! Thanks to MiniBuilder


embed

noswf download fullscreen
flash swf thumbnail play
download fullscreen
FORKED
>sort

4. Tween grouping with BetweenAS3 forked from: 4. Tween grouping with BetweenAS3 [diff(25)]

  1. // forked from beinteractive's 4. Tween grouping with BetweenAS3
  2. package
  3. {
  4.     import flash.display.Sprite;
  5.     import flash.text.TextField;
  6.     import flash.events.MouseEvent;
  7.     import org.libspark.betweenas3.BetweenAS3;
  8.     import org.libspark.betweenas3.tweens.ITween;
  9.     import org.libspark.betweenas3.events.TweenEvent;
  10.     import org.libspark.betweenas3.easing.*;
  11.     
  12.     public class Sample extends Sprite
  13.     {
  14.         public function Sample()
  15.         {
  16.             (addChild(_field = new TextField()) as TextField).text = 'Click to start';
  17.             stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
  18.         }
  20.         private var _field:TextField;
  21.         
  22.         private function mouseUpHandler(e:MouseEvent):void
  23.         {
  24.             stage.removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
  26.             var box1:Box = addNewBox(50);
  27.             var box2:Box = addNewBox(150);
  28.             
  29.             // Serial (Start in specified order) Tween
  30.             var t:ITween = BetweenAS3.serial(
  31.                 BetweenAS3.tween(box1, {x: 220}, null, 1.2, Cubic.easeOut),
  32.                 BetweenAS3.tween(box2, {x: 220}, null, 1.2, Cubic.easeOut)
  33.             );
  34.             t.addEventListener(TweenEvent.COMPLETE, completeHandler);
  35.             t.play();
  36.         }
  38.         private function completeHandler(e:TweenEvent):void
  39.         {
  40.              _field.text = 'Complete!';
  41.          }
  42.         
  43.         private function addNewBox(y:Number):Box
  44.         {
  45.             var box:Box = new Box();
  46.             box.x = 20;
  47.             box.y = y;
  48.             addChild(box);
  49.             return box;
  50.         }
  51.     }
  52. }
  54. import flash.display.Sprite;
  56. internal class Box extends Sprite
  57. {
  58.     public function Box()
  59.     {
  60.         graphics.beginFill(0);
  61.         graphics.drawRect(-10, -10, 20, 20);
  62.         graphics.endFill();
  63.     }
  64. }
noswf

4. Tween grouping with BetweenAS3 forked from: 4. Tween grouping with BetweenAS3 [diff(294)]

  1. // Click to apply attraction force.
  3. // Please view all steps, to see how i got to this point.
  4. // I did not / do not, know when I'll stop these iterations but they are fun.
  6. // Sort of forked 5. Tween controlling BetweenAS3
  7. // forked from onedayitwillmake's Proximity step 6
  8. // forked from onedayitwillmake's Proximity step 5
  9. // forked from onedayitwillmake's Proximity step 4
  10. // forked from onedayitwillmake's forked from: Proximity step 3
  11. // forked from onedayitwillmake's forked from: Proximity step 2
  12. // forked from onedayitwillmake's forked from: Proximity step 1
  13. /**
  14.  * Proximity field - Step 7
  15.  * @Revision 
  16.  *         -First time using BetweenAS3!
  17.                 -the parameter, "stopOnComplete" = false, brings this spiderweb to life
  18.  * @author Mario Gonzalez
  19.  * @see http://onedayitwillmake.com/ 
  20.  */
  21. package
  22. {
  23.     
  24.     import flash.display.GradientType;
  25.     import flash.display.Graphics;
  26.     import flash.display.Shape;
  27.     import flash.display.SpreadMethod;
  28.     import flash.display.Sprite;
  29.     import flash.display.StageQuality;
  30.     import flash.events.Event;
  31.     import flash.events.MouseEvent;
  32.     import flash.geom.Matrix;
  33.     import flash.geom.Point;
  34.     
  35.     import org.libspark.betweenas3.BetweenAS3;
  36.     import org.libspark.betweenas3.easing.Back;
  37.     import org.libspark.betweenas3.easing.Sine;
  38.     import org.libspark.betweenas3.tweens.ITween;
  40.     [SWF(width="465", height="465", background="#000000")]
  41.     
  42.     public class Proximity extends Sprite
  43.     {
  44.         //Parameters 
  45.                 private var _cCount            :int = 0;
  46.                 private var _cMax            :int = 80;
  47.         //Rendering
  48.         private var _canvas            :Sprite;
  49.         public    var _canvasGraphics    :Graphics
  50.         //Reference 
  51.         public    var _lastCircle        :Circle; 
  52.         //Movement
  53.                 public static var FORCE_DEFAULT     :int = 500;
  54.                 public static var FORCE             :int = FORCE_DEFAULT;
  55.         public var _mousePressed    :Boolean = false;
  56.                 public var _mousePoint          :Point = new Point(0, 0);
  58.         
  59.         public function Proximity()
  60.         {
  61.             stage.quality = StageQuality.LOW
  63.             addChildAt(createBG(), 0);
  64.             addChild(_canvas = new Sprite());
  65.             _canvasGraphics = _canvas.graphics;
  66.                         
  67.                         create();
  68.                                              
  69.             addEventListener(Event.ENTER_FRAME, loop);
  70.             stage.addEventListener(MouseEvent.MOUSE_DOWN, toggleMouseDown);
  71.             stage.addEventListener(MouseEvent.MOUSE_UP, toggleMouseDown);
  72.                            
  73.         }
  74.         
  75.         private function createBG():Sprite
  76.         {
  77.             var matr:Matrix = new Matrix();
  78.             matr.createGradientBox(465, 465, Math.PI / 2, 0, 0);
  79.             
  80.             var bg:Sprite = new Sprite();
  81.             bg.graphics.beginGradientFill
  82.             (
  83.                 GradientType.LINEAR, 
  84.                 [0x000021, 0x000000], //colors
  85.                 [1, 1], //alphas
  86.                 [0, 255], //ratios
  87.                 matr, //matrix
  88.                 SpreadMethod.PAD
  89.             );    
  90.             
  91.             bg.graphics.drawRect(0, 0, 465, 465);
  92.             bg.graphics.endFill();
  93.             
  94.             return bg;
  95.         }
  96.         
  97.         /**
  98.          * Main program loop
  99.          */ 
  100.         private function loop(e:Event):void
  101.         {
  102.              if(stage.mouseX == _mousePoint.x && stage.mouseY == _mousePoint.y)
  103.                 Proximity.FORCE = 0;
  104.              else
  105.                  Proximity.FORCE = Proximity.FORCE_DEFAULT
  106.                         
  107.             _mousePoint.x = stage.mouseX;
  108.             _mousePoint.y = stage.mouseY;
  109.             
  110.             draw();
  111.         }
  112.         
  113.         /**
  114.          * Creates more circles if we have not reached the maximum count
  115. #  // Time setting: 2.5sec
  116. #             BetweenAS3.tween(box1, {x: 220}, null, 2.5).play();
  117. #             
  118. #             // Easing setting: EaseOutBounce
  119. #             BetweenAS3.tween(box2, {x: 220}, null, 0.5, Bounce.easeOut).play();
  120. #             
  121. #             // Easing with parameter
  122. #             BetweenAS3.tween(box3, {x: 220}, null, 0.5, Back.easeOutWith(1.9)).play();
  123. #             
  124. #             // Delay setting: 1.0sec
  125. #             BetweenAS3.tween(box4, {x: 220}, null, 1.5, null, 1.0).play();
  126.          */ 
  127.         public function create():void
  128.         {
  129.             //if(_cCount >= _cMax) return;
  130.              
  131.             var c:Circle;
  132.                         var columns :int = 8;
  133.                         var rows    :int = 10;
  135.                         for(var ax:int = 0; ax < columns; ax++)
  136.                         {
  137.                             for (var ay:int = 0; ay < rows; ay++)
  138.                             {
  139.                                  c = new Circle(this);
  140.                                  
  141.                                  var startX:int = Math.random() * 465;
  142.                                  var startY:int = Math.random() * 10 - 5 + 15;
  143.                                  var homeX:int = ax * (475 / columns);
  144.                                  var homeY:int = 470
  145.                                  
  146.                                  addChild(c);
  147.                                 
  148.                                  var t:ITween = 
  149.                                  BetweenAS3.tween(c,
  150.                                      {_ix: homeX, x: homeX, y: homeY, _iy: homeY}, /* End values */
  151.                                      {x: startX, _ix: startX, y: startY, _iy: startY}, /* Start at */
  152.                                      Math.random() * 6 + 1, /* Tween duration in seconds */
  153.                                      Sine.easeOutIn, /* Easing equation */ 
  154.                                      Math.random() * 3
  155.                                  );
  157.                                       t.stopOnComplete = false;
  158.                                       t.onPlay = c.reset;
  159.                                       t.play();
  160.                                      
  161.                                       
  162.                                  if(_lastCircle) 
  163.                                      c._prev = _lastCircle;    
  164.                                   
  165.                                   _lastCircle = c;
  166.                             }    
  167.                         }
  168.         }
  169.         
  170.         /**
  171.          * Draws the proximity field between the circles
  172.          */ 
  173.         public function draw():void
  174.         {
  175.             _canvas.graphics.clear();
  176.             _canvas.graphics.lineStyle(1, 0xffffff, 0.3);
  177.             
  178.             if(_lastCircle == null) return;
  179.             
  180.             _lastCircle.checkForProximity(_lastCircle._prev);
  181.             _lastCircle.move();
  182.         }
  183.         
  184.         public function toggleMouseDown(e:MouseEvent):void
  185.         {
  186.             if(_mousePressed)
  187.                 _mousePressed = false;
  188.             else
  189.                 _mousePressed = true;
  190.         }
  191.     }
  192. }
  195. import flash.display.Shape;
  196. import flash.display.Sprite;
  198. /**
  199.  * Circles that live in the feild
  200.  */
  201. class Circle extends Sprite
  202. {
  203.     private var _radius            :Number = Math.random() * 15 + 5;
  204.     private var _curveModifier    :Number    = Math.random() * 50 - 25;
  205.      public    var _isEnabled        :Boolean = false;
  206.      
  207.      public var _p            :Proximity; //reference
  208.      public var _prev        :Circle;    //Linked list style behavior
  209.     
  210.     //MOVEMENT
  211.     public static var ACC_PARAM:Number = 0.05;
  212.     public static var VELOCITY_PARAM:Number = 0.85
  213.     
  214.     public var _ix:Number;
  215.     public var _iy:Number;
  216.     public var _vx:Number = 0;
  217.     public var _vy:Number = 0;
  218.     public var _ax:Number = 0;
  219.     public var _ay:Number = 0;
  220.     /**
  221.      * Individual Circles know only the Circle created previously to their own
  222.      */
  223.     public function Circle(p:Proximity):void
  224.     {
  225.     
  226.         _p = p;
  227.         //blendMode = "add";
  228. //        graphics.beginFill(Math.random() * 255 * 255 * 255, 0.5)
  229. //        graphics.drawCircle(0, 0, _radius);
  230. //        graphics.endFill();
  232.         graphics.beginFill(0xffffff, 1)
  233.         graphics.drawCircle(0, 0, 1);
  234.         graphics.endFill();
  237.     }
  238.     
  239.         public function reset():void
  240.         {
  241.             _vx = 0;
  242.             _vy = 0;
  243.             _ax = 0;
  244.             _ay = 0;   
  245.         }
  246.     /**
  247.      * Check all previous circles for proximity, and do [something]
  248.      * There is no need for each circle to check the ones ahead, 
  249.      * because they've already checked against this one.
  250.      * 
  251.      * Called recursively for this circle, until the linked list reaches the first circle.
  252.      * Once it does, it calls checkForProximity on its '_prev'
  253.      * The sequence repeats until there are no more previous ones
  254.      * 
  255.      * @param tc:Circle The 'test circle' we will check against.
  256.      */ 
  257.     public function checkForProximity(tc:Circle):void
  258.     {
  259.         if(tc == null) return; // This is the first circle created (unless error of course!)
  260.         //if(tc._isEnabled == false) { checkForProximity(tc._prev); return;};
  261.         
  262.         var d:Number = Math.sqrt((x - tc.x) * (x - tc.x) + (y - tc.y) * (y - tc.y));
  263.         
  264.         if(d <  90)
  265.         {
  266.             _p._canvasGraphics.moveTo(x, y);
  267.             //_p._canvasGraphics.lineTo(tc.x, tc.y);
  268.             //_p._canvasGraphics.curveTo(tc.x, tc.y);
  269.             _p._canvasGraphics.curveTo((x + tc.x) * 0.5, (y + tc.y) * 0.5 + _curveModifier, tc.x, tc.y);
  270.         }
  271.         
  272.                 //Keep checking backwards for proximity, until you reach the first circle
  273.         if(tc._prev)
  274.             checkForProximity(tc._prev);
  275.         else if(_prev) //Reached first circle. We are the last created circle, so continue the loop until we reach the first
  276.             _prev.checkForProximity(_prev._prev);
  277.     }
  278.     
  279.         /** 
  280.         * Moves the circle, initial position relative to mouse attraction/repelling force
  281.         */
  282.     public function move():void
  283.     {
  284.         //Don't let the force become too strong, by saying the distance will always be X at min
  285.         var dist:Number = Math.max(Math.sqrt((x - stage.mouseX) * (x - stage.mouseX) + (y - stage.mouseY) * (y - stage.mouseY)), 40);
  287.         var dy:Number = stage.mouseY - y;
  288.         var dx:Number = stage.mouseX - x
  289.         var angle:Number = Math.atan2(dy, dx);
  290.         var f:Number = 1 / dist * Proximity.FORCE * ((_p._mousePressed == true) ? 1 : -1);
  291.         
  292.         _ax += Math.cos(angle) * f;
  293.         _ay += Math.sin(angle) * f;
  294.         _ax += (_ix - x) * ACC_PARAM;
  295.         _ay += (_iy - y) * ACC_PARAM;
  296.         _vx = (_vx + _ax) * VELOCITY_PARAM;
  297.         _vy = (_vy + _ay) * VELOCITY_PARAM;
  298.         x += _vx;
  299.         y += _vy;
  300.         _ax = _ay = 0;
  301.         
  302.         if(_prev) //Call move on all circles
  303.             _prev.move();
  304.     }
  305.     
  306.     public function destroy():void
  307.     {
  308. //         _p._firstCircle = this;
  309.     }    
  310.     
  311.     public function enable():void
  312.     {
  313.         x = _ix = Math.random() * 10 - 5 + 15;
  314.     }
  315. }
noswf
Get Adobe Flash Player