count down flash

I've uploaded the example to here; so no need for a e-mail anymore:

www.itbdesign.no/loadvars_example.zip

:)

step 1:
create a textfile with name "time.txt" and content of the text should be following:
--------------
YEAR=2007&MONTH=5&DATE=3&
--------------------
you can change date setting using this text file.

step 2:
replace complete code on frame 1 with following:
----------------
// stop the timeline
stop();
// first get this current year so this example
// remains valid for some time to come
currentDate = new Date();
thisYear = currentDate.getFullYear();
var myloadVar = new LoadVars();
myloadVar.load("time.txt");
myloadVar.onLoad = function()
{
      // define the event date counting down to
      // this is constant so it won't need to be
      // calculated in the onEnterFrame function below
      // currently counting down 'til christmas of 2003
      // Date( year, month-1, date [, hour [, minute [, second [, millisecond]]]])
      _root.eventDate = new Date(Number(myloadVar.YEAR), Number(myloadVar.MONTH) - 1, Number(myloadVar.DATE));
      _root.eventMillisecs = eventDate.getTime();
      startCountDown();
};
function startCountDown()
{
      counter.onEnterFrame = function()
      {
            // get the current date and time as it exists at
            // this instance in time when the frame is entered
            currentDate = new Date();
            currentMillisecs = currentDate.getTime();
            // the milliseconds between the current time and the
            // time of the event can then be calculated by simply
            // subtracting the current time's milliseconds from the
            // milliseconds of the time of the event
            this.msecs = eventMillisecs - currentMillisecs;
            // if the msecs variable is less than 0, that means the
            // current time is greater that the time of the event
            if (this.msecs <= 0)
            {
                  // and the event time has been reached!
                  // play the next frame for the result of the countdown.            
                  play();
                  // a return can be used to exit the function since
                  // in going to the next frame, there's no need to
                  // continue with the remaining operations.
                  return;
            }
            // if the date hasn't been reached, continue to      
            // devise seconds, minutes, hours and days from
            // the calculated milliseconds
            this.secs = Math.floor(this.msecs / 1000);
            // 1000 milliseconds make a second
            this.mins = Math.floor(this.secs / 60);
            // 60 seconds make a minute
            this.hours = Math.floor(this.mins / 60);
            // 60 minutes make a hour
            this.days = Math.floor(this.hours / 24);
            // 24 hours make a second
            // make sure each value doesn't exceed the range in
            // which they exist.  Milliseconds, for example, will
            // be shown in a range of 0 - 999.  The modulous
            // operator, or %, well help in that.  Here the values
            // are also turned into strings preparing for the next step
            this.msecs = String(this.msecs % 1000);
            this.secs = String(this.secs % 60);
            this.mins = String(this.mins % 60);
            this.hours = String(this.hours % 24);
            this.days = String(this.days);
            // add on leading zeros for all the number values (which are
            // now strings) that aren't 3 or 2 characters long based on the
            // range being used to represent them.  Because mseconds and
            // days have up to 3 characters, a while loop is used to
            // continuously add 0s until they have 3.  Other values which
            // only need 2 leading 0s can get by on a single if check
            while (this.msecs.length < 3)
            {
                  this.msecs = "0" + this.msecs;
            }
            if (this.secs.length < 2)
            {
                  this.secs = "0" + this.secs;
            }
            if (this.mins.length < 2)
            {
                  this.mins = "0" + this.mins;
            }
            if (this.hours.length < 2)
            {
                  this.hours = "0" + this.hours;
            }
            while (this.days.length < 3)
            {
                  this.days = "0" + this.days;
            }
            // finally, display your values.  If you want to put your values
            // in a textField, you can pretty much just stop here and throw them
            // into your textField as desired.  This example, however will go a step
            // further and use images for numbers for each numerical value in the
            // countdown to the desired date.
            // So, for that, loop through all the movies in this counter clip using the
            // evaluateFrameFrom prototype method on each. A single check for a
            // _parent variable is used to make sure the property found in a for
            // loop is a movieclip and is within the timeline of this counter clip.
            // TextFields and buttons would also be true here, but since the contents
            // within counter are strictly those numbers movieclips, we won't have to
            // be concerned with such complications.  The only movieclips in this counter
            // clip are the numbers movieclips with the frames of the imagery making up
            // the numbers of 0-9.
            for (movie in this)
            {
                  if (this[movie]._parent == this)
                  {
                        this[movie].evaluateFrameFrom(this);
                  }
            }
      };
      // this function is a MovieClip.prototype meaning its available to be used by
      // all movieclips.  It's a sneaky function that saves a lot of work by using
      // name each numbers movieclip in the counter movieclip to determine which value
      // it needs to display based on the times derived from the previous
      // calculations of the onEnterFrame. What it does is seperates a movieclip's
      // _name into a variable word and a number.  The variable word will represent
      // the variable to look up a value for in the passed variableClip and the
      // number will be used to get a character from that value (a string) which
      // represents which number this movieclip should display.
      MovieClip.prototype.evaluateFrameFrom = function(variableClip)
      {
            // split this _name into an array of 2 values seperated by an underscore
            var nameArray = this._name.split("_");
            // the first value represents what variable in variableClip (counter clip)
            // this movieclip is used to represent whether it be mins or hours etc.
            var numberSet = variableClip[nameArray[0]];
            // next a number representing which character in that first value this
            // movieclip should display.  this will be between 0 and 2 (any one of
            // three values).  number() is used to force it to be a number value.
            var character = Number(nameArray[1]);
            // a frame number can then be derived from the value of the numberset
            // variable based on the character defined by character.  number() is
            // used to force it to a number value and 1 is added to offset the
            // frame value by one since 0 is at frame 1 and 1 at frame 2 etc.
            var frame = 1 + Number(numberSet.charAt(character));
            // if the movieclip is not already at the frame, move it there!
            if (this._currentframe != frame)
            {
                  this.gotoAndStop(frame);
            }
      };
      // an example of the above function in action would be for a movieclip
      // with the name "days_1".  days_1 is seperated into an array by dividing
      // the name by its "_" character giving "days" (nameArray[0]) and "1" (nameArray[1]).
      // The value of days is then retrieved from the passed variableClip using
      // associative array ssntax and is set to numberset.  The value of days in variableClip
      // would be a string something along the lines of "045".  character is then used
      // to get which of those 3 values this movieclip is to represent. It is just
      // nameArray[1] turned into a number or "1" to 1.  So, charAt(1) of "045" would
      // be 4.  Turn that into a number and add one and you get frame 5 where the image of
      // the 4 is located.  The movieclip, days_1, is then played to that frame to show it.
}

---------------

enjoy

- Aneesh Chopra