I'm actually splitting assets up into several small files and then loading them up into an invisible container clip.

When I started writing the loading code, I forgot that AS1 doesn't have the MovieClipLoader class. That's a Flash 7 invention. So, I got to do things the really old fashioned way, by listening to bytes loaded and all that. I figured since it is potentially a common problem (for those who wind up having to go back into the stone ages, that is), I may as well share the code with folks.

Please note that this code is a skeleton. It does not do a whole lot as it is. It just gives you a starting framework to edit to your individual application.

[as3]
FakeMCL = function( parent, depth ) {
if( !parent )
parent = _root;
this.parent = parent; // parent clip of container
this.loadQueue = []; // queue of clips to be loaded
this.container = null; // clip into which all children are loaded
this.init( depth );
};// end: "constructor"

FakeMCL.prototype.init = function( depth ) {
if( !depth )
depth = this.parent.getNextHighestDepth();
// create an invisible container clip at parent._fakemcl
this.container = this.parent.createEmptyMovieClip( "_fakemcl", depth );
this.container._visible = false;
trace("<fakemcl> container "+this.container+" is at depth "+depth);
}// end: init()

FakeMCL.prototype.loadMovie = function( url ) {
this.loadQueue.push( url );
if( !this.loadInterval ) {
trace("<fakemcl> starting interval");
// try to tick once every 25ms (that's once per frame at 40fps), we're
// probably not running that fast, so it will just execute once per frame
// NOTE: you can (and might want to) throttle this back
this.loadInterval = setInterval( this.onInterval, 25, this );
}// end: start interval
}// end: loadMovie()

FakeMCL.prototype.onInterval = function( mcl ) {
// stop iterating if we're completely out of clips to load
if( !mcl.loadQueue.length && !mcl.loadingClip ) {
trace("<fakemcl> queue is empty");
clearInterval( mcl.loadInterval );
// NOTE: you might want to do something here now that the whole queue is loaded
return;
}// end: queue is empty
// start loading a clip if we aren't already
if( !mcl.loadingClip ) {
var clipURL = mcl.loadQueue.shift();
var instanceName = "_"+clipURL.substr( 0, clipURL.indexOf(".") );
trace("<fakemcl> loading "+clipURL+" ("+instanceName+")");
mcl.loadingClip = mcl.container.createEmptyMovieClip( instanceName, mcl.container.getNextHighestDepth() );
mcl.loadingClip.loadMovie( clipURL );
// NOTE: clip init goes here
}// end: not loading anything
else {
// check status of currently loading movie
var percentLoaded = mcl.loadingClip.getBytesLoaded() / mcl.loadingClip.getBytesTotal();
trace("<fakemcl> loaded "+mcl.loadingClip.getBytesLoaded()+"/"+mcl.loadingClip.getBytesTotal());
if( percentLoaded>= 1.0 && mcl.loadingClip.getBytesTotal() ) {
// we're done loading
trace("<fakemcl> done, "+mcl.loadingClip);
mcl.loadingClip = null;
// NOTE: callback for individual clip loading goes here
}
}// end: currently loading
}// end: onInterval()
[/as3]

Again, this is skeleton code and isn't terribly useful as is. I've put some notes in the code where you might want to do more interesting things to adapt the durned thing to your application. Also, feel free to yoink the trace statements, they can get awful spammy

This skeleton supports queuing up a whole list of swf's for loading, but in actual use, it is probably going to be more useful for you to just load one swf at a time. Shrug.

example

Put the following code on a frame of your timeline:
[as3]
#include "FakeMCL.as"

var mcl = new FakeMCL( this, 10 );
mcl.loadMovie("fish.swf");
mcl.loadMovie("bird.swf");
[/as3]
And hopefully, you'll get some output like this:

When all is done running, you've got those clips at _fakemcl._bird and _fakemcl._fish that you can toy with however you need. Chances are, you probably want to know when the loading is actually done, however. That'll take some editing of this code. Put a stop() on the frame you call FakeMCL.loadMovie() from and then put "mcl.parent.play()" in the load complete block, etc...