I was still intrigued by the idea this morning, so I expanded the Class to do a continual fading operation where at a random time interval it randomly selects combs to fade out (which can then fade back in if so desired).
It works fairly well if the parameters are right, but if not, with 48 little movies getting adjusted, the Flash Player can get overloaded pretty easily. When the parameters are not right, it's remarkably ineffecient, so if anybody wants to jump in and make it better, redesign the class, tell me I'm doing it the most difficult way possible, that'd be great. There's got to be an easier way to do this.
Anyways, here's the new Class (again just actionscript, paste it in an empty .fla and test the movie):
PHP Code:
// ******************************************************************* //
// Define HoneyComb Class //
function HoneyComb(name,parent) {
this.name = name; // set the name of the instance as this.name
this.parent = parent; // set the parent of the instance as this.parent
this.count = 0; // set a counter to 0;
} // end HoneyComb class
// build the honey comb with buildComb() method
// -------------------------------------------------------------------
HoneyComb.prototype.buildComb = function() {
// set up counter variables
var count_x = 0;
var count_x2 = 0;
var count_y = 0;
var depth = 0;
// execute two loops to construct the honey comb
for (var i=0; i < 12; i++) { // create each of the 12 columns
for (var j=0; j < 4; j++) { // create each column of four combs each
var clip_nm = "comb" + depth + "_mc"; // set the new clip name
this.parent.createEmptyMovieClip(clip_nm,depth); // create movie
with (this.parent[clip_nm]) {
// draw comb
lineStyle(1,0x272728,100);
beginfill(0x272728,100);
moveTo(0,36);
lineTo(21,0);
lineTo(62,0);
lineTo(83,36);
lineTo(62,72);
lineTo(21,72);
lineTo(0,36);
endFill();
// move comb to proper place
_x = count_x;
_y = count_y;
} // end with grouping
count_y += 77; // increment _y by 77 since one comb has been created
depth += 1; // increment the depth since 1 clip has been created
} // end j loop
if ((i % 2) > 0) { // i is even
count_y = 0; // start even rows at 0
} else { // i is odd
count_y = 38; // start odd rows at 38
} // end "if i mod 2"
count_x += 67; // move _x over 67 px to start next column
} // end i loop
} // end HoneyComb.buildComb() method
// randomFade() method
// -------------------------------------------------------------------
HoneyComb.prototype.randomFade = function(x,y) {
// x: the name of the current instance
// y: the name of the secondaryInterval
/* if (x == undefined) { // if x has not been defined, set it to "this"
x = "this";
} // end "if x == undefined" */
var thisInterval = x + "." + y;
clearInterval(eval(thisInterval)); // clear the random interval which called this method
trace("2: " + thisInterval + " cleared");
var ranNum = eval(x).getRandom(1,48); // get a random number between 1 and 48
var clip_nm = "comb" + ranNum + "_mc";
// run this.fadeOut() every 20 milliseconds
var interval_nm = "fadeInterval" + ranNum;
eval(x)[interval_nm] = setInterval(eval(x).fadeOut,20,clip_nm,x,interval_nm,ranNum);
} // end HoneyComb.randomFade() method
// fadeOut() method
// -------------------------------------------------------------------
HoneyComb.prototype.fadeOut = function(x,y,z,num) {
// x: the name of the clip to fade
// y: the name of the current instance
// z: the name of the fadeInterval
// num: the number of the clip being faded
var thisPath = "this." + x;
var thisInterval = y + "." + z;
if (eval(thisPath)._alpha > 0) { // do this if alpha is greater than 0
eval(thisPath)._alpha -= 1; // reduce alpha by 1
} else { // do this if alpha has reached zero
clearInterval(eval(thisInterval)); // stop fadeInterval from executing
trace("A: " + thisInterval + " cleared");
if (eval(y).stayFaded == "no") { // if this.stayFaded is "no", start fadeBack
// start the fadeBack interval, every ranNum milliseconds
var fadeBackInterval = eval(y).fadeBackInterval;
var ranNum = eval(y).getRandom(0,fadeBackInterval);
var interval_nm = "waitInterval" + num;
eval(y)[interval_nm] = setInterval(eval(y).waitFadeBack,ranNum,x,y,interval_nm,num);
} // end "if this.stayFaded = "no"
} // end "if _alpha > 0"
} // end HoneyComb.fadeOut() method
HoneyComb.prototype.waitFadeBack = function(x,y,z,num) {
// x: the name of the clip to fade back, passed from this.fadeOut()
// y: the name of the current instance
// z: the name of the waitInterval
// num: the number of the clip being faded
var thisInterval = y + "." + z;
clearInterval(eval(thisInterval));
trace("B: " + thisInterval + " cleared");
var interval_nm = "fadeBackInterval" + num;
eval(y)[interval_nm] = setInterval(eval(y).fadeBack,20,x,y,interval_nm,num);
} // end HoneyComb.waitFadeBack() method
HoneyComb.prototype.fadeBack = function(x,y,z,num) {
// x: the name of the clip to fade back, passed from this.waitFadeBack()
// y: the name of the instance
// z: the name of the fadeBackInterval
// num: the number of the clip being faded
var thisPath = "this." + x;
var thisInterval = y + "." + z;
if (eval(thisPath)._alpha < 100) { // do this if alpha is less than 100
eval(thisPath)._alpha += 1; // increase alpha by 1
} else { // do this if alpha has reached 100
clearInterval(eval(thisInterval)); // stop fadeBackInterval from executing
trace("C: " + thisInterval + " cleared");
} // end "if _alpha < 100"
} // end HoneyComb.fadeBack() method
// fadingOn() method
// -------------------------------------------------------------------
HoneyComb.prototype.fadingOn = function(x,maxInterval,fadeBackInterval) {
// x: yes|no; whether the combs should fade back or stay faded out
// maxInterval: the max time (in milliseconds) between each new fade
// fadeBackInterval: the max time (in milliseconds) between fadeOut and fadeIn
this.stayFaded = x;
this.maxInterval = maxInterval;
this.fadeBackInterval = fadeBackInterval;
mainInterval = setInterval(this.setRandomFade,maxInterval,this.name);
} // end HoneyComb.fadingOn() method
// fadingOff() method
// -------------------------------------------------------------------
HoneyComb.prototype.fadingOff = function() {
clearInterval(mainInterval);
} // end HoneyComb.fadingOff() method
// setRandomFade() method
// -------------------------------------------------------------------
HoneyComb.prototype.setRandomFade = function(x) {
// x: the name of the current instance
var maxInterval = eval(x).maxInterval;
var ranNum = eval(x).getRandom(0,maxInterval); // get a random number between 0 and maxInterval
var interval_nm = "secondaryInterval" + eval(x).count;
trace("1: count = " + eval(x).count + "; " + interval_nm);
eval(x).count += 1;
// run this.randomFade() at ranNum milliseconds
eval(x)[interval_nm] = setInterval(eval(x).randomFade,ranNum,x,interval_nm);
} // end HoneyComb.setRandomFade() method
// HoneyComb.getRandom() method (*credit to Colin Moock)
// returns a random number between two specified values
// -------------------------------------------------------------------
HoneyComb.prototype.getRandom = function(minVal,maxVal) {
return minVal + Math.floor(Math.random() * (maxVal + 1 - minVal));
} // end HoneyComb.getRandom() method
// end HoneyComb Class definition //
// ******************************************************************* //
// now that the HoneyComb Class is defined, let's create an instance of it and run it
var myComb = new HoneyComb("myComb",this); // create a new instance of the HoneyComb Class
myComb.buildComb(); // run the "buildComb()" method
myComb.fadingOn("no",2000,500); // run the "fadingOn()" method
The "randomOn()" function starts the random fading, but if you want to stop it then "randomOff()" does the trick.
So the last three lines of code: after instantiating a new object and building the honey comb, the last line is the one which turns the random fading "on". It takes three parameters:
1. "yes" or "no", this sets a property called "stayFaded". If "yes", then a comb will stay faded out after it has faded; if "no", each comb will fade back in (works best as "no").
2. The maximum time (in milliseconds) between each fading event. For each fade event, the class will randomly select a number between 0 and this number and fade one comb out at that time.
3. The maximum time (in milliseconds) between a comb's fading-out and fading-back-in.
The class works best if the second parameter is a larger number and the third is smaller. The closer these two numbers get, the more work the flash player has to do at once (i.e. fading many little movies at once).
Bugs: it seems to not work right when the third number is equal or greater than the second (though it still works). I don't have the time to really work more on this, but that would be something to look at. Also, since it selects combs to fade at random, it is possible that a comb will get selected again while it is in the process of fading in or out. I reckon that would keep the comb faded out until it randomly gets select again (which might never happen for a long while since it's random).
Improvement: if you want it to fade out and stay faded out, then you set the first parameter of the ".fadingOn()" method to "yes". However, when the combs are mostly faded out and there's only a few left, it takes some time before the random selection actually selects the few visible combs, so it could take a while for the combs to all disappear. I would certainly want to adjust the way it works to fix that, maybe put the movieclips in an array, then pop each one when it is completely faded out. Then the random selection could choose from the remaining elements of the array. Something like that. That would work more effeciently since there would be fewer elements to control as more movies were removed.
Well, I must stop fooling around and get to work. Again, hope something here helps or gives you some ideas.
retrotron
Random fades
Linear Mode
