/**********************************\

This File creates a wave simulation using scaling 'bar' movie clips.
Each bar references the 2 (sometimes 1) bars next to it so that it
can transfer its waving influence to those bars and thereby create
the effect. 

\**********************************/

Stage.scaleMode = "noScale";

/****************\
 * CreateBars
 * creates 'count' bar clips in the 'where' movie clip
\****************/
function CreateBars(count, where){
	
	var i; // increment value for looping count bars
	var bar; // bar being attached in loop
	var last_bar = false; // last bar created
	
	// create an array in the where clip to manage bars
	where.bars = new Array();
	
	// loop through count times to create count bars in where clip
	for (i=0; i<count; i++){
		
		// attach and position bar
		bar = where.attachMovie("bar", "bar"+i, i);
		bar._x = i * bar._width; // bars next to each other based on width
		
		// define bar variables
		bar.magnitude = 0; // marks power of wave which causes it to scale
		bar.clickMagnitude = where.clickMagnitude; // the magnitude added when a bar is clicked
		bar.influences = new Array(); // contains magnitudes coming from neighbor waves
		bar.transfers = new Array(); // used to transfer influences between a delay (controls wave speed)
		
		bar.left = null; // defines the bar next to the left of this one, assume non-existant
		bar.right = null; // defines the bar next to the right of this one, assume non-existant
		// if last_bar exists, then the bar to the left of the current bar is valid
		if (last_bar){
			bar.left = last_bar; // assign this bar's left to be the last bar
			last_bar.right = bar; // since this bar is to the right of the last_bar, set it's right to this bar
		}
		
		// define bar events
		bar.onPress = barPressForWave; // action when a bar is pressed, creates a wave based on where.clickMagnitude
		
		// include bar in where clip's bars array
		where.bars.push(bar);
		
		// note the last bar created
		last_bar = bar;
	}// end create bars loop
	
}


/****************\
 * barPressForWave
 * assigned as onPress event for each bar created in CreateBars
 * creates a wave starting with the bar clicked.  Wave magnitude
 * is determined by the bar's clickMagnitude property
\****************/
function barPressForWave(){
	
	var wave_object; // object used to define wave created
	
	this.magnitude += this.clickMagnitude; // apply clickMagnitude to this bar's magnitude
	
	// if there exists a bar to the left of this bar
	if (this.left){
		wave_object = new Object(); // create a new wave object
		wave_object.magnitude = this.clickMagnitude; // mark the wave as having a magnitude of clickMagnitude
		wave_object.direction = "left"; // define the direction of the wave to be 'left' so it will know where to go next
		this.left.influences.push(wave_object); // add this wave to the collection of influences for the left bar
	}
	// if there exists a bar to the left of this bar
	if (this.right){
		wave_object = new Object(); // create a new wave object
		wave_object.magnitude = this.clickMagnitude; // mark the wave as having a magnitude of clickMagnitude
		wave_object.direction = "right"; // define the direction of the wave to be 'right' so it will know where to go next
		this.right.influences.push(wave_object); // add this wave to the collection of influences for the right bar
	}
	
}


/****************\
 * handleWaves
 * controls the waving of a collection of bars added to the clip calling it
 * meant for the onEnterFrame event of a clip used with CreateBars
\****************/
function handleWaves(){
	
	var apply_influences = false; // used with the delay to know when influences should be applied and change hands
	// increment variables for looping through bars:
	var bar_count = this.bars.length; // bar count
	var i; // increment value for looping bar_count bars
	var bar; // current bar in loop
	// increment variables for looping through influences:
	var influence_count; // influence count
	var j; // increment value for looping influence_count influences
	var influence; // current influence in loop
	
	var difference; // used to determine how far a bar is from normal scale
	var receiver; // marks the neighboring bar which is to receive influences from the current bar
	
	
	// a delay is used to manage how fast bars affect themselves and neighboring bars
	// it counts down from this clip's delay variable until 0
	// when 0, apply_influences is set to true marking the point in
	// time when influences for bars are applied to their magnitudes and
	// gets passed to their left and right neighbors
	if (this.delayCounter == 0){
		this.delayCounter = this.delay; // reset delay counter to delay
		apply_influences = true; // when true, influences are applied and change hands
	}
	this.delayCounter--; // reduce delayCounter
	
	// the reactions of all bars are handled through this loop _yscale
	// is based on a basic spring calculation which bases its movement
	// off of the magnitude set for the current bar. Any influences
	// on magnitude are only applied when apply_influences is true
	// and this occurs after the current bar has already been scaled so
	// that they take effect on the next frame. After being applied they
	// are passed to the respective left or right neighbor
	for (i=0; i<bar_count; i++){
		bar = this.bars[i]; // current bar
		
		// move bar in wave motion by applying a springing
		// ease using the current bar's difference in
		// _yscale from the base of 100 (100% full scale)
		var difference = 100 - bar._yscale;
		bar.magnitude += difference * this.acceleration; // accelerate towards target
		bar.magnitude *= this.friction; // apply friction
		bar._yscale += bar.magnitude; // alter scale based on this bar's magnitude
		
		// if enough time has passed, apply influences to the bar's magnitude
		// and then pass the influences to the correct left or right neighbors
		if (apply_influences == true){
			
			influence_count = bar.influences.length; // count of this bar's influences
			// loop through each influence within this bar's influences array (containing wave objects)
			for (j=0; j<influence_count; j++){
				influence = bar.influences[j]; // current influence for this bar
				
				// update current bar's magnitude for each influence in the loop
				// any influence added here is a result of those given to this bar
				// from the last time apply_influences was true or from a bar being pressed
				bar.magnitude += influence.magnitude;
				
				// once the magnitude for this influence has been applied, find where
				// it needs to go next using the influence' direction which as either
				// 'left' or 'right' corresponds to the similarly named reference to 
				// a neighboring bar in the current bar
				receiver = bar[influence.direction]; // bar.left or bar.right
				// if a valid receiver and not null (which will be the case for end bars)
				if (receiver){
					// add the influence to the receiving neighbor bar. Note that it is
					// important that these are added to transfers and not influences. If
					// added to influences, the next bar in the current loop would be using
					// old and recently added influences from this bar.  The transfers array
					// lets us make sure all the bars being looped through here only use
					// their original influences and nothing added as a result of this loop
					// transfers is updated to be each bars influences array in another loop
					// following this one
					receiver.transfers.push(influence);
				}
			}// end influences loop
		}
	} // end bars loop
	
	// if applying influences, loop through each bar and convert the
	// transfers array to be influences arrays so that durring the next
	// update, the transfered influences will be used to alter magnitued
	if (apply_influences == true){
		for (i=0; i<bar_count; i++){
			bar = this.bars[i]; // current bar
			// set current influences to transfers
			bar.influences = bar.transfers;
			// clear transfers for the next time influences change hands
			bar.transfers = new Array();
		}
	} // end bars loop

}



/************ Initialize ***********/



// option variables to control behavior
// (since wave is controlling the bars, variables assigned in wave)
wave.delay = 3; // time in frames between one bar transfering its wave influence to its neighboring bars
wave.acceleration = 0.05; // determines acceleration of a bar to reach its 100% scale
wave.friction = 0.95; // determines friction applied to a bars attempt to reach its 100% scale
wave.clickMagnitude = 3; // how much wave magnitude is applied to each bar when clicked
// internal variables for handleWaves
wave.delayCounter = 0; // used to count frames for delay

// function calls/event assignments
// create bars in the wave movie
CreateBars(20, wave); // 20 bars in movie clip wave
// handleWaves controls bars in the movie based on the above variables
wave.onEnterFrame = handleWaves;