Наконец, настало время рассмотреть еще один очень распространенный прием, используемый при создании роликов. Речь идет о программном дублировании флэш-символов. Оказывается, размещать экземпляр флэш-символа в рабочей области основного ролика или одного из мувиков совершенно необязательно вручную. Можно воспользоваться оператором duplicateMovieClip, который помещает в ролик новый экземпляр указанного мувика. Правда, здесь есть два момента. Во-первых, чтобы разместить новый экземпляр мувика, в сцене уже должен быть хотя бы один его экземпляр (образца в библиотеке недостаточно). Во-вторых, каждый созданный таким образом экземпляр должен быть размещен на уровне с уникальным номером. Если попытаться разместить с помощью оператора duplicateMovieClip два "дубля" объекта на одном и том же уровне, то в момент размещения второго первый удаляется.

И еще одно важное замечание, которое нужно сделать, прежде чем переходить к рассмотрению примеров. Любой экземпляр мувика, созданный оператором duplicateMovieClip, может быть удален оператором removeMovieCtip. На экземпляры, размещенные вручную, оператор removeMovieClip не влияет.

Начнем с совсем простого примера. Откройте новый ролик и создайте в нем мувик с анимацией. Разместите в основном ролике экземпляр этого мувика, назовите его clip1. Просмотрите ролик и убедитесь, что анимация происходит. Теперь откройте окно сценария в первом (пока единственном) кадре основного ролика. Напишите там следующий код:

duplicateMovieClip ("clip1","clip2",1);

Этот оператор создает дубликат мувика под названием clip1 и присваивает ему имя clip2. Дубликат размещается на уровне 1.

Если сейчас просмотреть ролик, может показаться, что ничего не изменилось. На самом деле дубликат мувика появился, но он расположен на том же месте, что и мувик clip1 Чтобы воочию увидеть действие оператора duplicateMovieClip, добавим после него дополнительные операторы:

setProperty ("clip2",_x,300);
setProperty ("clip2",_y,300);

С помощью этих строк дубликат сдвигается на другое место. Если теперь снова просмотреть ролик, то мы действительно увидим не один, а два мувика.

Теперь давайте с помощью клавиши F6 создадим еще два ключевых кадра на второй и третьей позициях. Во второй кадр поместим следующий код:

if (getTimer()>10000) {
   removeMovieClip ("clip2");
}

а в третий кадр -

gotoAndPlay (2);

Таким образом, по истечении 10 секунд от начала ролика "дубликат" прекратит свое существование. Если же написать

removeMovieClip ("clip1");

то но произойдет вообще ничего, поскольку мувик clip1 не был создан командой duplicateMovieClip.

Это пример использования оператора duplicateMovieClip, что называется, "в лоб". Так его почти никогда не используют. Действительно, городить огород ради размещения одного дубликата существующего мувика вряд ли стоит - его легче скопировать мышью, удерживая нажатой клавишу CTRL. Давайте же рассмотрим способы более осмысленного использования оператора duplicateMovieClip.

Следующий пример - упорядоченное расположение многих объектов.

Предположим, нам надо создать правильный квадрат-сетку из 64 шариков (рис. 7.8). Размещать столько экземпляров вручную довольно трудоемко, особенно если нужно соблюсти расстояния между ними. И мы воспользуемся оператором duplicateMovieClip.

Рис. 7.8. Все видимые объекты этого ролика созданы программно

Откройте новый ролик, создайте в нем пустой мувик (CTRL+F8) и нарисуйте в нем небольшой круг. Вернитесь в основной ролик и поместите экземпляр только что созданного мувика где-нибудь за пределами рабочей области. Не видимый при просмотре, он используется только в качестве образца. Назовем этот экземпляр sh0.

Теперь откройте окно сценария первого кадра основного ролика и введите туда такой код:

for (i=1;i<9;i++) {
   for (j=1;j<9;j++) {
      duplicateMovieClip ("sh0","sh"+String(i*10+j),i*10+j);
      setProperty ("sh"+String(i*10+j),_x,j*30);
      setProperty ("sh"+String(i*10+j),_y,i*30);
   }
}

Давайте разберемся, что здесь к чему. Поскольку нужно создать 64 мувика, это логично сделать в цикле for. Однако здесь целесообразнее использовать не один цикл for (i=1,i<65,i++), а два вложенных, чтобы иметь возможность использовать счетчики циклов для вычисления значений координат мувиков. В данном случае счетчик внутреннего цикла j используется для определения горизонтальной координаты каждого мувика, а счетчик внешнего цикла i - для определения вертикальной координаты.

Далее, как мы уже говорили, каждому дубликату исходного мувика необходимо дать имя. В данном случае мы составляем имя каждого из дубликатов из префикса sh и значений переменных i и j. Из значений этих переменных мы составляем и номер уровня, на который загружается данный дубликат. Неважно, что номера уровней у нас идут не подряд (например, после 18 сразу 21). Главное, чтобы номера всех уровней были различны. (Заметим, что, в принципе, не составляет особого труда и заставить эти номера идти подряд, используя вместо выражения i*10+j выражение i*8+j.)

После этого каждый вновь созданный дубликат надо разместить в нужной точке рабочей области. Здесь нам опять помогут счетчики вложенных циклов. Поскольку на каждом шаге цикла счетчик увеличивается на 1, нужно только умножить значения обоих счетчиков i и j на количество точек, которое надо оставить между мувиками (точнее, между их центрами), и присвоить полученные результаты свойствам _x и _y. Как видите, сценарий получился вполне компактный и размер файла ролика получается меньше, чем если бы мы размешали каждый экземпляр мувика вручную. Так что в результате мы еще и экономим время загрузки ролика через Интернет.

Заметьте, что если в мувике, дублируемом оператором duplicateMovieClip, тоже размещен какой-нибудь сценарий, то он выполняется отдельно внутри каждого из дубликатов. Например, если в нашем случае внутрь мувика sh0 (в первый его кадр) поместить сценарий:

a = new Color(this);
a.setRGB (Math.random()*0xFFFFFF);

то он выполнится отдельно в каждом из "дубликатов", и в результате мы получим "сетку" из разноцветных, а не одинаковых шариков.

Теперь можно немного усложнить пример. Предположим, что нам необходимо создать не статическую сетку шариков, а некий фон, на котором в некоторых местах то и дело бы плавно появлялись и исчезали разноцветные шарики. Это вполне подойдет для какого-нибудь новогоднего или карнавального сайта, а если изменить частоту и характер появляющихся объектов - то почти для любого.

Постараемся справиться с этой задачей, немного модифицировав предыдущий пример. Вначале вместо упорядоченного расположения "дубликатов" основного объекта расположим их беспорядочно, заменив код первого кадра основного ролика следующим:

for (i=1;i<65;i++) {
   duplicateMovieClip ("sh0","sh"+String(i),i);
   setProperty ("sh"+String(i),_x,Math.random()*550);
   setProperty ("sh"+String(i),_y,Math.random()*400);
}

Поскольку объекты мы теперь располагаем случайным образом, то вместо двух вложенных циклов мы использовали один. Заодно более простыми стали имена дубликатов, а номера уровней, на которых они располагаются, идут подряд. При операторе setProperty мы использовали метод Math.random для случайной установки координат объекта.

Теперь давайте отредактируем сам мувик. Преобразуем изображение круга в нем в графический объект. Затем с помощью клавиши F6 создадим ключевые кадры в позициях 20 и 40. Вернемся в первый кадр и установим для нашего графического объекта значение прозрачности Alpha (Альфа-канал) равное 0. То же самое осуществим в кадре 40, а затем создадим анимацию движения в кадрах 1 и 20.

Вопросы синхронизации

Если сейчас просмотреть ролик, то мы увидим, что все наши случайным образом расположенные шарики синхронно появляются и исчезают. Это и понятно, ведь все дубликаты созданы одновременно и начали воспроизводиться синхронно. Как же заставить объекты появляться только время от времени? Очевидно, нужно остановить мувики при загрузке (в первом кадре объект невидим) и затем написать сценарий, запускающий их в случайный момент времени.

Откроем окно сценария первого кадра мувика и вставим туда такой код:

a = new Color(this);
a.setRGB (Math.random()*0xFFFFFF);
stop ();

Первые две строки, как и раньше, задают случайный цвет, а третья останавливает мувик. В последний кадр мувика вставим оператор

gotoAndStop (1);

Теперь создадим новый мувик с помощью клавиш CTRL+F8. Назовем его Actions. Он будет делать самое главное - запускать в случайные моменты времени тот мувик, в котором он расположен (родительский мувик). Вставим в его первый кадр код:

if (Math.random()*100<5) _parent.play ();

Этот код запустит воспроизведение родительского мувика с вероятностью 5% (если случайное число от 0 до 100 окажется меньше 5). Осталось добавить в этот мувик обычный кадр клавишей F5, чтобы зациклить исполнение кода первого кадра. Теперь создадим в мувике с изображением круга новый слой actions и разместим там экземпляр невидимого мувика Actions. Если теперь просмотреть ролик, можно увидеть, что разноцветные шарики время от времени возникают в различных точках.

Несмотря на то что только что рассмотренный пример может произвести впечатление случайно разбросанных объектов, более внимательный взгляд заметит, что объекты возникают в одних и тех же местах. Это происходит потому, что мы лишь время от времени включаем воспроизведение мувиков, а размещение их задано заранее.

Можно, конечно, перед воспроизведением всякий раз задавать координаты, на сейчас мы поступим еще радикальнее. Будем создавать и уничтожать дубликаты нашего мувика по мере необходимости!

Откроем предыдущий пример и удалим из него мувик Actions. Из мувика с изображением круга удалим из первого кадра оператор stop, а в последнем кадре удалим предыдущее содержимое и разместим оператор

removeMovieClip (this);

Эта строка на первый взгляд может показаться странной: выходит, что мувик уничтожает сам себя. Однако вспомним, что оператор removeMovieClip уничтожает только программно созданные "дубликаты", а это нам как раз и нужно: если все копии мувика оставлять в памяти (хоть они и становятся невидимыми в конце анимации), то через некоторое время они начнут "тормозить" работу компьютера. А экземпляр мувика, играющий роль "оригинала" (с которого делаются все копии), хотя и имеет эту строку кода в последнем кадре, однако для него она остается безвредной.

Теперь перейдем в первый кадр основного ролика и, удалив все, что там есть, напишем такой код:

if (Math.random()*100<10) {
   i++;
   if (i>100) i = 1;
   duplicateMovieClip ("sh0","sh"+String(i),i);
   setProperty ("sh"+String(i),_x,Math.random()*550);
   setProperty ("sh"+String(i),_y,Math.random()*400);
}

Как видите, этот сценарий с десятипроцентной вероятностью создает дубликат исходного мувика, размещает его на следующем по номеру уровне и воспроизводит. В конце воспроизведения дубликат самоуничтожается, так что об этом сценарию основного ролика заботиться уже не надо. Осталось добавить в основной ролик обычный кадр клавишей F5, чтобы зациклить исполнение сценария первого кадра.

Чтобы при длительном просмотре ролика не возникало слишком больших номеров уровней, в сценарий введена строка

if (i>100) i = 1;

Правда, ее введение автоматически означает, что на экране не отобразится более 100 дубликатов одновременно. Однако при данной длине анимации и вероятности дублирования на экране и так никогда не появится сразу 100 объектов. В любой момент их будет не больше трех-четырех.

Рассмотрим еще один пример, демонстрирующий довольно-таки эффектный прием, - создание шлейфа мыши. Предположим, требуется, чтобы при движении мыши пользователь видел небольшой след вдоль ее траектории. Такая возможность имеется в специальных настройках Windows и других операционных систем (рис. 7.9).

Рис. 7.9. Программно созданный шлейф, возникающий при движении мыши

Давайте подумаем, как реализовать подобный эффект. Ясно, что удобнее всего достичь его с помощью дублирования флэш-символов. Надо сделать так, чтобы там, где "прошла" мышь, возникал мувик в форме указателя мыши и через какое-то время исчезал. Хорошо, если он исчезнет постепенно, - это смотрится естественнее.

Итак, откройте новый ролик. Вначале нужно нарисовать объект, похожий на указатель мыши. Можно, конечно, нарисовать и объект любой другой формы, например, просто небольшой полупрозрачный шарик. Тогда в результате возникнет эффект, будто от указателя мыши при его движении идут пузыри.

Создание рисунка указателя

Вернемся к указателю мыши. Лучше всего просто "сфотографировать" его изображение прямо с экрана, воспользовавшись любой программой снятия экранных изображений, например SnagIt (www.techsmith.com). Получившееся растровое изображение следует импортировать в ролик.

Для ускорения работы ролика и уменьшения размера файла изображение указателя мыши необходимо вначале преобразовать в векторную форму. В данном случае лучше не пользоваться командой Trace Bitmap (Трассировка изображения), а выполнить операцию вручную.

Для этого увеличьте его до достаточных размеров, создайте новый слой, а на слой с растровым изображением повесьте "замочек". Возьмите инструмент Линия и просто обведите линиями контур изображения. Для хорошего четкого изображения указателя мыши достаточно семи линий. Преобразуйте его в графический объект, назвав его Pointer, а затем удалите все содержимое обоих слоев основного ролика.

Создайте новый мувик, назовите его Mousepointer. Поместите туда экземпляр графического объекта Pointer. В позиции 10 создайте ключевой кадр клавишей F6 и, перейдя на него, установите для нашего объекта значение прозрачности Alpha (Альфа-канал) равным 0. Кроме того, откройте окно сценария этого кадра и введите туда следующий код:

removeMovieClip (this);

для самоуничтожения мувика в конце воспроизведения.

Формирование шлейфа

Вернитесь в основной ролик. Поместите в первый кадр экземпляр мувика Mousepointer, но расположите его за границами рабочей области, чтобы его не было видно при просмотре. Назовите этот экземпляр mouse. Это образец для создания многочисленных дубликатов.

Добавьте в третью позицию обычный кадр, переименуйте второй слой в Actions и вставьте в него пустые ключевые кадры (F7) в позициях 1, 2 и 3. Откройте окно сценария первого кадра и введите туда следующие команды:

stop ();
i = 0;

Впрочем, вторая из них необязательна. Теперь откройте окно сценария второго кадра (исполняемого при перемещении мыши). Вставьте туда такой код:

i++;
if (i>100) i = 1;
dupicateMovieClip ("mouse","a"+i,i);
setProperty ("a"+i,_x,_xmouse);
setProperty ("a"+i,_y,_ymouse);

Давайте разберемся, что здесь к чему. Как мы уже говорили, этот код выполняется при перемещении мыши. При этом мы сначала увеличиваем счетчик уровней расположения дубликатов i (он же используется для генерации имен дубликатов). Если значение счетчика превышает 100, мы сбрасываем его значение (больше ста дубликатов изображения одновременно точно не понадобится). Следующая строка создает дубликат изображения указателя мыши. Обратите внимание, что при конкатенации числовое значение переменной i автоматически преобразуется в строковое, хотя преобразующая функция String() в явном виде и не вызывается.

Затем мы располагаем дубликат мувика с изображением указателя мыши точно в том месте, где находится настоящий указатель. Теперь при движении указателя мыши наш "дубликат" останется на месте. Из нескольких таких дубликатов и складывается мышиный шлейф. Каждый из дубликатов самостоятельно воспроизводит анимацию - возникает впечатление, что он постепенно исчезает. В конце воспроизведения каждый дубликатов выполняет команду

removeMovieClip (this);

и перестает существовать.

Теперь откройте сценарий третьего кадра и введите туда команду

gotoAndStop (1);

Она снова направляет основой ролик в первый кадр, где происходит ожидание. Напомним, что переход на второй кадр должен происходить только во время движения мыши, что мы сейчас и реализуем.

Щелкните правой кнопкой мыши по экземпляру мувика mouse и выберите пункт Actions (Действия), чтобы открыть окно сценария объекта. Введите туда такой код:

onClipEvent (mouseMove) {
   _root.gotoAndPlay (2);
}

Этот код ожидает события "движение мыши" и в случае его возникновения передает управление во второй кадр основного ролика. Заметьте, что при этом к основному ролику пришлось обратиться по абсолютному пути.

Просмотрите ролик. Он должен казаться пустым, однако при движении мыши в пределах окна ролика за ней остается след, что и требовалось. Теперь можно добавить в этот ролик любые другие объекты.

Можно, кстати, поработать над улучшением эффекта следа от мыши. Попробуйте самостоятельно поэкспериментировать с этим. Например, уменьшите объект в заключительном кадре мувика Mousepointer. Тогда при просмотре ролика за мышью потянутся более естественно исчезающие, уменьшающиеся следы (рис. 7.10). Сохранив принцип, здесь можно дать большую волю своей фантазии.

Рис. 7.10. "Улучшенный" шлейф мыши

Представьте себе, что вы создали отличный ролик с массой анимационных и интерактивных эффектов, который должен просто потрясти пользователя, и поместили его на веб-страничку (о том, как это делается, рассказывается в следующем разделе). Пользователь щелкнул мышкой на гиперссылке, ведущей на эту страничку, и увидел на экране прямоугольник, куда должен загрузиться ролик. Подождал пользователь минуту, другую, видит - ничего в прямоугольнике не появляется (или появилось несколько дергающихся фрагментов), ему эта дело надоело, он обиделся и ушел со странички, так ничего и не дождавшись. А ведь, может быть, еще бы секунд пять - и он был бы настолько впечатлен, что долго рассказывал бы знакомым о том, какая замечательная есть страничка. А теперь он, наоборот, всем расскажет, что-де ничего интересного на страничке этой нет...

К сожалению, подобная ситуация вполне реалистична. Как ни крути, хотя графика и векторная, обилие анимации заставляет ролик разрастаться. А если, к тому же, есть еще и тексты, и звук, и растровые изображения (иногда и они все же требуются)? Конечно, при создании ролика важно найти баланс между разумным размером файла и количеством художественных задач. Но если все же размер файла таков, что окончания его загрузки необходимо ждать несколько минут, следует приложить дополнительные усилия и постараться удержать пользователя, заставив его дождаться завершения загрузки ролика.

Вообще-то ролик по умолчанию начинает воспроизводиться сразу же после загрузки первого кадра, а если очередной кадр еще не загружен, проигрыватель Flash приостанавливается и ждет его загрузки. Обычно содержимое ролика распределено по кадрам неравномерно (кстати, это можно увидеть графически, нажав в режиме просмотра ролика клавиши CTRL+B), из-за чего желательно подождать с началом воспроизведения, пока не загрузится последний кадр.

Задержка анимации

Как это сделать, мы уже обсуждали, поэтому здесь лишь кратко напомним об этом, прежде чем рассмотреть несколько более сложные случаи. Начните основную анимацию с третьего (или с еще более отдаленного) кадра и дайте ему метку, например begin. Последнему кадру анимации дайте метку end и, если анимация должна быть зациклена, введите в сценарий последнего кадра команду

gotoAndPlay("begin");

Теперь в первый кадр поместите такой код:

ifFrameLoaded ("end") {
   gotoAndPlay ("begin");
}

а во второй кадр - код:

gotoAndPlay (l);

Таким образом, основная анимация не начнется, пока не загружен последний кадр. Но как побудить пользователя дождаться конца загрузки? Приведенный пример в этом смысле весьма плох, поскольку вплоть до конца загрузки (и начала анимации) пользователь не увидит в окне ролика вообще ничего. Добавить в первый кадр надпись "Идет загрузка..." - это уже лучше, потому что пользователь получит информацию о том, что загрузка действительно идет. На некоторое время этого достаточно.

Простейшие предзагрузчики

Однако если одна и та же надпись держится на экране слишком долго, у пользователя опять складывается впечатление, что "ничего не происходит". Поэтому и во время загрузки на экране нужно что-то менять.

Самый простой способ в данном случае - преобразовать надпись в мувик, дать ему имя (например, nadp) и добавить в конец сценария первого кадра что-нибудь такое:

if (!a) a = new Color(nadp);
a.setRGB (Math.random()*0xFFFFFF);

Далее надо отодвинуть кадр begin (а также идущий перед ним кадр с кодом gotoAndPlay(1);) на несколько кадров вперед (например, на 12 при скорости ролика 12 fps). В этом случае пользователь, ожидающий загрузки увидит надпись "Загрузка...", цвет которой каждую секунду меняется случайным образом. В принципе, это еще лучше - внимание пользователя занимается дольше, по вскоре ему станет понятно, что смена цвета никак не зависит от количества загруженных кадров, и это его разочарует. Поэтому хорошо бы придумать что-нибудь, отражающее реальный ход загрузки. Для этого вместо оператора ifFrameLoaded можно воспользоваться свойством framesloaded, которое возвращает количество загруженных кадров. А поскольку само по себе количество загруженных кадров для пользователя мало что значит, лучше использовать его совместно со свойством _totalframes, которое возвращает общее количество кадров ролика.

Например, можно заменить саму надпись чем-нибудь вроде текста "Загрузка началась...", а текстовое поле сделать динамическим. Если сопоставить с ним переменную z, то можно заменить код первого кадра следующим:

if (_framesloaded/_totalframes == 1) {
   gotoAndPlay ("begin");
} else if ((_frmesloaded/_totalframes>0.33)&&
   (_framesloaded/_totalframes<0.67)) {
   z = "Загрузка в самом разгаре...";
} else if (_framesloaded/_totalframes>0.67) {
   z = "Загрузка подходит к концу...";
}

Пользователь увидит в начале загрузки надпись "Загрузка началась...", после загрузки третьей части всех кадров - текст "Загрузка в самом разгаре..." и, наконец, в начале загрузки последней трети кадров - сообщение "Загрузка подходит к концу..." Пользователь уже должен почувствовать некоторое уважение к своей особе - ему сообщают, что происходит, и это должно понравиться больше, чем безликая надпись "Загрузка".

То, что мы сейчас создаем, обычно называют предварительным загрузчиком, или предзагрузчиком. В простых случаях это может быть код ожидания и одна или несколько надписей, но ограничиваться этим вовсе не обязательно.

Например, можно сделать предзагрузчик еще более совершенным. Удалите все содержимое первого кадра. Создайте новый мувик, назовите его indicator.

Нарисуйте в нем прямоугольник небольшой высоты и значительной ширины. Удалите его контур, а для заливки выберите какой-нибудь приятный цвет или градиент. Поместите в первый кадр экземпляр этого мувика, назвав его ind. Над ним поместите статическое поле с надписью "Идет загрузка:", а рядом - динамическое поле с надписью "0%". С динамическим полем сопоставьте переменную z.

Скопируйте экземпляр ind (CTRL+C), создайте новый слой выше предыдущего, назовите его up и нажмите клавиши SHIFT+CTRL+V, чтобы поместить копию экземпляра мувика indicator на том же месте в новом слое. Назовите новый экземпляр up. С помощью панели Effects (Эффекты) сделайте этот экземпляр белым (точнее, совпадающим с цветом фона). Вернитесь в первый слой и сдвиньте его первый кадр на вторую позицию, не двигая остальных, а в первый кадр этого слоя вставьте строку

xup = up._x;

Одновременно код последнего кадра загрузчика (того, что идет непосредственно перед основной анимацией) надо заменить на:

gotoAndPlay (2);

Таким образом, сейчас у нас есть мувик ind, запланированный на роль индикатора загрузки, и мувик up, который его полностью закрывает. По мере загрузки оставшейся части ролика мувик up должен отодвигаться вправо, открывая все большую часть полоски-индикатора. Чтобы управлять положением мувика up, мы и запомнили его первоначальную горизонтальную координату в переменной xup.

Чтобы управлять индикатором загрузки было удобнее, желательно сделать ширину мувиков ind и up кратной ста (поскольку долю загруженных кадров удобно выражать в процентах). В нашем примере примем ширину этих мувиков равной 300. Напомним, что ширину можно установить на панели Info (Сведения).

Вставим во второй кадр основной сценарий загрузчика, выполняемый циклически:

if (_framesloaded/_totalframes == 1) {
   gotoAndPlay ("begin");
}
z = Math.floor(_framesloaded*100/_totalframes)+" %";
up._x = xup+(_framesloaded*300/_totalframes);

Этот код проверяет, сколько кадров уже загружено, выводит информацию об этом в динамическом поле z и одновременно приоткрывает столько же процентов полоски индикатора. Возникает впечатление, что полоска индикатора растет по мере загрузки ролика (рис. 7.11).

Рис. 7.11. Ролик, отображающий ход собственной загрузки

Правда, как мы уже говорили, загрузка кадров обычно осуществляется неравномерно. Ключевые кадры с дополнительной графикой требуют на загрузку некоторого времени, а серии обычных кадров загружаются практически мгновенно. Поэтому наш индикатор все равно двигается не равномерно, а рывками, но это уже детали. Главное, что пользователь получает реальную информацию о ходе загрузки, оформленную достаточно привлекательно.

Однако, если загрузка длится долго, опытные флэшеры вставляют в загрузчик дополнительные элементы для привлечения внимания пользователя. Это может быть все что угодно, главное - небольшого размера, чтобы не отнимать лишнее время при загрузке самого ролика. Например, в нашем примере в верхней части экрана можно поместить еще одно динамическое поле, в котором отображать какие-нибудь цитаты, новости (которые могут быть загружены из внешнего файла, как описано в разделе 7.6), шутки (анекдоты) и так далее. Иногда встречаются и загрузчики посложнее. Например, в таком режиме, как описано выше, можно сначала загрузить дополнительный ролик, который невелик по размеру, но развлечет пользователя, ожидающего загрузки основного ролика. Этот ролик обычно представляет собой что-то вроде несложной, но привлекательной игры или занимательной анимации. Кстати, если занять пользователя игрой, можно выиграть чуть больше времени для загрузки основного ролика. Поэтому в некоторых случаях создают даже многоступенчатые предзагрузчики, последовательно проигрывающие несколько несложных занимательных роликов.

И последнее: не пренебрегайте такой важной деталью ролика, как предзагрузчик. Лучше всего, не оставлять его создание на самый конец работы, а сделать тогда, когда уже известна структура ролика и создано большинство графических объектов (то есть можно оценить размер ролика и, соответственно, время загрузки), но работа по отладке сценариев и доводке деталей еще впереди.