This is an expansion on the particle system I posted a few hours ago. I wanted to add movement to the particles within the circle and have them reflect off of the boundary as you would expect them to (see the bad-*** while loop in the move method.)
Check it out
If you resize your browser and refresh, the circular boundary will redraw to a slightly different size - makes for a different effect.
As before the FLA contains no source-code - simply the document class definition. The other 2 files are the ParticleSystem.as and Particle.as files.
ParticleSystem.as
package {
import Particle;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.display.Sprite;
import flash.display.MovieClip;
import flash.display.Stage;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
public class ParticleSpace extends MovieClip {
// Configuration Variables
var num_particles:Number = 20; // The number of particles to create on each draw
var distance:Number = 100; // The maximum distance for connected particles
var vx_max:Number = 3; // The maximum horizontal velocity
var vx_min:Number = -3; // The minimum horizontal velocity
var vy_max:Number = 3; // The maximum veritcal velocity
var vy_min:Number = -3; // The minimum vertical velocity
// Variables
var particles:Array = [];
var radius:Number;
var connections:Sprite;
var circle:Sprite;
/**
* Constructor
* Initialises the drawing and sets a listener to redraw on every mouse click
*/
public function ParticleSpace() {
// Prepare
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
// Begin
this.draw();
}
/**
* Event handler
* @param event <Event> The event
*/
function enter_frame(event:Event):void {
this.move();
this.drawConnections(distance);
}
/**
* Move the balls around with their constraints
*/
function move():void {
var i:Number = 0;
var radius_sq:Number = radius * radius;
for (i = 0; i < particles.length; i++) {
var particle:Particle = particles*;
// Target destination
var tx:Number = particle.x + particle.vx;
var ty:Number = particle.y + particle.vy;
// Watch for those borders ...
while (tx * tx + ty * ty >= radius_sq) {
// Reference: http://mathworld.wolfram.com/Circle-LineIntersection.html
// Point 1: (ox, oy)
// Point 2: (tx, ty)
var ox:Number = particle.x;
var oy:Number = particle.y;
var dx:Number = tx - ox;
var dy:Number = ty - oy;
var d:Number = dx * dx + dy * dy;
var D:Number = ox * ty - tx * oy;
var disc:Number = radius_sq * d - D * D;
if (disc >= 0) {
disc = Math.sqrt(disc);
// Work out which intersection point to use (still works when there's only 1)
var ix:Number = (D * dy + sign(dy) * dx * disc) / d;
var iy:Number;
if (sign(ix - ox) != sign(tx - ox)) {
ix = (D * dy - sign(dy) * dx * disc) / d;
iy = ( -D * dx - Math.abs(dy) * disc) / d;
} else {
iy = ( -D * dx + Math.abs(dy) * disc) / d;
}
// Calculate the angle to bounce away from the intersection at
var a:Number = 2 * Math.atan2( -iy, -ix) - Math.atan2( -dy, -dx);
var ca:Number = Math.cos(a);
var sa:Number = Math.sin(a);
dx = tx - ix;
dy = ty - iy;
d = Math.sqrt(dx * dx + dy * dy);
tx = ix + d * ca;
ty = iy + d * sa;
var v:Number = particle.v;
particle.vx = v * ca;
particle.vy = v * sa;
}
}
// Reposition the particle to the newly calculated position
particle.x = tx;
particle.y = ty;
}
}
/**
* Returns the sign of n
* @param n
*/
function sign(n:Number) {
if (n < 0) return -1;
return 1;
}
/**
* Calculates the dimensions for drawing and calls the worker functions
* Begins the cycles
*/
function draw():void {
// Calculate the dimensions
radius = Math.min(stage.stageHeight, stage.stageWidth) / 2;
this.x = stage.stageWidth / 2;
this.y = stage.stageHeight / 2;
// Representation of limitations
this.addChild(this.circle = new Sprite());
this.circle.graphics.lineStyle(5, 0x333333, 1);
this.circle.graphics.drawCircle(0, 0, radius);
// Prepare
this.addChild(this.connections = new Sprite());
this.drawParticles(num_particles, radius);
// Continue
this.addEventListener(Event.ENTER_FRAME, this.enter_frame);
}
/**
* Creates the particles on the stage
* @param n <Number> The number of particles to create
* @param radius <Number> The radius of the circle within which to distribute the particles
* @param center_x <Number> The centre of the circle on the horizontal axis
* @param center_y <Number> The centre of the circle of the vertical axis
*/
function drawParticles(n:Number, radius:Number):void {
var i:Number;
// Create n particles
for (i = 0; i < n; i++) {
var particle:Particle = new Particle(this);
particles.push(particle);
// Disribute uniformly throughout the circle
var r:Number = Math.sqrt(Math.random()) * radius;
var a:Number = (Math.random() * 2 - 1) * Math.PI;
particle.x = Math.sin(a) * r;
particle.y = Math.cos(a) * r;
// Define a random velocity
particle.vx = Math.random() * (vx_max - vx_min) + vx_min;
particle.vy = Math.random() * (vy_max - vy_min) + vy_min;
}
}
/**
* Draws connecting lines between close-enough particles
* @param dist <Number> The maximum distance between particles for them to be connected
*/
function drawConnections(dist:Number):void {
var i:Number;
var j:Number;
// This method requires less recursion through less use of the Math.sqrt function
this.connections.graphics.clear();
var distance_sq:Number = distance * distance;
// Loop through each PAIR of particles
for (i = 0; i < particles.length - 1; i++) {
var particle_a:Particle = particles*;
for (j = i + 1; j < particles.length; j++) {
var particle_b:Particle = particles[j];
// Calculate the square of their distance apart
var dx:Number = particle_a.x - particle_b.x;
var dy:Number = particle_a.y - particle_b.y;
var d:Number = dx * dx + dy * dy;
if (d < distance_sq) {
// Draw a line if they're close enough
var alpha:Number = (distance - Math.sqrt(d)) / distance;
this.connections.graphics.lineStyle(1, 0xFFFFFF, alpha);
this.connections.graphics.moveTo(particle_a.x, particle_a.y);
this.connections.graphics.lineTo(particle_b.x, particle_b.y);
}
}
}
}
/**
* Empties the stage of all particles and graphics
* Pretty much redundant
*/
function clear():void {
for (var i:Number = 0; i < particles.length; i++) {
particles*.parent.removeChild(particles*);
}
this.particles = [];
this.connections.graphics.clear();
}
}
}
Particle.as
package {
import flash.display.Sprite;
class Particle extends Sprite {
// Variables
var v:Number;
var _vx:Number;
var _vy:Number;
public function Particle(parent:Sprite) {
// Draw the particle
this.graphics.beginFill(0xFFFFFF);
this.graphics.drawCircle(0, 0, 3);
this.graphics.endFill();
// Add the particle to the particle space
parent.addChild(this);
}
public function get vx():Number {
return this._vx;
}
public function set vx(n:Number):void {
this._vx = n;
this.v = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
}
public function get vy():Number {
return this._vy;
}
public function set vy(n:Number):void {
this._vy = n;
this.v = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
}
}
}
Critiques of course welcome.
Thanks 
