Cheers

Roger Clark

1. Local variables of particle() referenced by…
2. The eFrame function in particle()…
3. The ball sprite created in particle()…
4. The instance of your Main class…
5. The stage

But the reference of the eFrame function by the ball is weak, so it requires another reference in order to not get removed by the garbage collector on its next pass. You see this as 1 second, but it could be whenever the GC wants to do the collection. Since you have no other references to the eFrame function, it is weakly reachable and is therefore eligible for collection. When this happens, the eFrame function stops getting called. This causes the position to never get updated.

To avoid this problem in the future, do not add dynamic event listener functions as a weak reference unless you are sure you have another reference to them. Since you usually don’t, just make them a strong reference and call removeEventListener later.

Hope this helps clear things up.

The interesting thing about the code is that the closures do not fully work.

If you change the number of “particles” that are created e.g.

        private function mClick (event:MouseEvent):void
        {
            for (var i:uint=0; i<1000; i++)
            {
                particle ();
            }
        }

and also slow their possible movement

xVel = (Math.random() * 2)-1;
yVel = (Math.random() * 2)-1;

it doesn’t work at all.

If you create 200 (and have slow movement) the particles start comming out from the mouse click position, but usually stop after about 1 second.

I suspect that although the vars ball, xVel and yVel are initially maintained because of closure, that the Flash garbage collector is eventually deleting them.

<pre lang="actionscript3">
// code
</pre>

You’ve stumbled upon the wonderful world of closures. The eFrame function has the local variables in the particle() function “closed”, meaning they are bound to it like members of a class are bound to the object by this. You may even notice that if you use this explicitly within the eFrame function that you’ll be referring to the eFrame function itself, not the instance of the Main class that you would be referring to if you used this from the particle() function.

Closures can be tough to wrap your head around, but they’re really powerful once you manage it. See these articles for some of that power:
Curry Functions
Fun With Dynamic Functions

package 
{
    import flash.display.Sprite;
    import flash.events.*;
 
    /**
     * ...
     * @author Roger Clark
     */
    public class Main extends Sprite 
    {
 
        public function Main():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
 
        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);
 
            stage.addEventListener (MouseEvent.CLICK,mClick,false,0,true);
            // entry point
        }
 
 
 
        private function mClick (event:MouseEvent):void
        {
            for (var i:uint=0; i<20; i++)
            {
                particle ();
            }
        }
 
        private function particle ():void
        {
            var xPos:Number;
            var yPos:Number;
 
            var xVel:Number;
            var yVel:Number;
 
            xPos = mouseX;
            yPos = mouseY;
 
            xVel = (Math.random() * 20)-10;
            yVel = (Math.random() * 20)-10;
 
            var ball:Sprite=new Sprite();
            ball.graphics.beginFill (0xff0000);
            ball.graphics.drawCircle (0,0,10);
            addChild(ball);
 
            ball.x = xPos;
            ball.y = yPos;
 
            ball.scaleX=ball.scaleY=(Math.random()*.5)+.5;
 
            ball.addEventListener (Event.ENTER_FRAME, eFrame, false, 0, true);
 
            function eFrame (event:Event):void
            {
                ball.x += xVel;
                ball.y += yVel;
 
                if (xPos<0||yPos<0||xPos>stage.stageWidth||yPos>stage.stageHeight)
                {
                    ball.removeEventListener (Event.ENTER_FRAME,eFrame);
                    removeChild (ball);
                    ball=null;
                }
            }
        }
    }
}

placing the enterframe handler inside the particle() func seems to almost achieve the particle() func being a class with xPos,yPos,xVel etc as properties.
Keep clicking on the stage, after a while it packs up. But I’m kinda surprised it worked in the first place ;-)

But comming from a C,C++ background I’ve always been very wary about the ActionScript compiler and its scoping vagueries, in AS2 and AS3.

In AS2 on the timeline, I’ve seen numerous projects where bugs occuered due to vars or functions going out of scope depening on which frame the taget function was on and which frame the current execution was on.
There did’nt seem to be a pattern to this, as sometimes code would work and in another project, similar code would fail.

I generally don’t use functions inside other functions. I know that putting functions inside other functions etc, does give some scoping protection of the function i.e. it should not be visible outside the current scope.

But you’ve demonstrated a big downside to this..