Адресация

Так же, как телефонные номера, электронные и почтовые адреса направляют послание адресату, пути в Macromedia Flash направляют "послания" одного монтажного стола другому, давая им возможность "общаться" друг с другом. В этом уроке мы рассмотрим различные способы адресации, используемые в типичных Flash-проектах; покажем, как использовать возможность "общения" между монтажными столами – возможность, которая позволит придать вашим проектам большую глубину и изощренность.

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

Что будет изучаться

В этом уроке:

Время выполнения

На выполнение этого урока требуется примерно полтора часа.

Файлы урока

Файлы-носители:

Нет

Стартовые файлы:

Lesson03/Assets/currentTarget1.fla
Lesson03/Assets/rootTarget1.fla
Lesson03/Assets/parentTarget1.fla
Lesson03/Assets/movieclipTarget1.fla
Lesson03/Assets/backgroundControl1.fla
Lesson03/Assets/textBox1.fla
Lesson03/Assets/levelTarget1.fla
Lesson03/Assets/levelTarget2.fla
Lesson03/Assets/backgroundControl2.fla
Lesson03/Assets/levelTarget.swf

Законченные проекты:

currentTarget2.fla
rootTarget2.fla
parentTarget2.fla
movieclipTarget2.fla
textBox2.fla
levelTarget3.fla
backgroundControl3.fla

О монтажных столах проекта

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

Однако все эти монтажные столы могут работать совместно; могут управлять друг другом. Любой монтажный стол, присутствующий в сцене, может передать другому присутствующему монтажному столу указание что-либо сделать. Монтажный стол считается присутствующим, пока он отображен в окне проигрывателя. Так, если фильм-символ отображается в фильме на протяжении 40 кадров, то он присутствует (и на него можно указать) только в течение этих 40 кадров.

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

Данный путь состоит из четырех уровней (разделенных точками); с каждым последующим уровнем "границы поиска" все сужаются, пока мы не достигаем цели: Дерека Франклина. Такую адресацию называют абсолютной – она полностью описывает местонахождение Дерека Франклина на планете Земля. Адресация может также быть относительной – таким путем могли бы воспользоваться те, кто тоже живет в городе Блумингтон. Им, чтобы найти Дерека, не нужна вся информация, составляющая абсолютный путь; достаточно относительного пути:

DerekFranklin

Как видите, относительный путь указывает адрес объекта относительно того, кто ищет этот объект. Так, если бы весь город Блумингтон (вместе с Дереком Франклином) переместился бы в Париж, те же жители попрежнему могли бы найти Дерека Франклина по адресу DerekFranklin. Несмотря на то, что абсолютный путь теперь другой – France.Paris.DerekFranklin, относительная позиция Дерека Франклина (для бывших жителей Блумингтона) не изменилась.

Относительные пути очень удобны. Вы можете запрограммировать монтажные столы для совместной работы, ссылаясь на их положение относительно друг друга. Пока их относительное положение не меняется, они будут работать совместно – даже если вы переместите их (но только вместе) в другое место проекта или даже в другой проект.

Flash-проект можно представить как иерархию фильмов, где каждый монтажный стол находится внутри другого монтажного стола, а отправной точкой служит главный, или корневой (root) монтажный стол. В такой иерархической структуре важно четко представлять себе, как адресовать действие нужному монтажному столу.

Посредством адресации можно не только обратиться к тому или иному монтажному столу, но и получить доступ к его переменным, функциям, объектам и так далее.

Обращение к текущему фильму

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

встать();

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

Другой способ адресовать действие текущему фильму – предварить действие ключевым словом this, например, так:

this.встать();

Можно перевести это на нормальный язык так: "С этим ( this ) монтажным столом выполнить следующее действие". Мы это еще обсудим во всех подробностях, пока же запомните следующее: во всех случаях при обращении к текущему фильму используются следующие взаимозаменяемые конструкции:

действие();
this.действие();

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

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

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

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

startingColor = random (4) + 1;
this.gotoAndStop (this.startingColor);

Первым делом позаботьтесь, чтобы был выделен кадр 1 основного монтажного стола – таким образом текущим фильмом для нашего скрипта станет главный монтажный стол. Значит, все действия, которые мы введем в панели Действия без адресации (или с адресацией this ), будут воздействовать на этот монтажный стол.

Первое действие генерирует случайное число в диапазоне от 1 до 4 и присваивает его значение переменной startingColor. Функция random(4) генерирует случайное целое число из четырех возможных, причем это множество всегда начинается с нуля – в нашем случае это 0, 1, 2 и 3. Прибавляя к результату функции единицу, мы получим число из множества 1, 2, 3 и 4 – это будет именно то, что нам нужно, ведь в следующем действии мы приказываем фильму перейти к кадру, номер которого содержит переменная startingColor, а кадра с номером 0 на монтажных столах быть не может. Итак, в результате этих действий при начале проигрывания фон на экране отображается одним из четырех цветов, выбранным случайно.

Заметьте: присваивая значение переменной startingColor, мы не указываем путь; однако в следующем действии присоединяем к имени переменной слово this. В данном случае делать это было необязательно, это ничего не меняет.

В этом уроке нам предстоит выполнить еще несколько упражнений с монтажным столом этого фильма-символа, а потому давайте познакомимся с ним поближе.

На этом монтажном столе имеется две метки: Quiet и Speak. В кадре метке Speak появляется округлый контур для "произносимых" персонажем слов; внутри этого контура имеется текстовое поле с именем balloon. Вскоре мы создадим скрипт, отображающий, как только монтажный стол переместится к метке Speak, текст в этом поле.

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

Наконец, в кадре 1 слоя Actions на этом монтажном столе содержится действие stop(), предотвращающее воспроизведение последующих кадров до получения особого указания.

on (press) {
  startDrag (this);
  gotoAndStop ("Speak");
  balloon.text = words;
}
on (release) {
  stopDrag ();
  this.gotoAndStop ("Quiet");
}

Первый набор инструкций выполняется при нажатии на кнопку. Экземпляр фильма-символа становится перетаскиваемым. Далее, этот же монтажный стол отсылается к кадру с меткой Speak. И наконец, в текстовом поле balloon отображается значение переменной с именем words, мы создадим эту переменную вскоре – она будет содержать текстовую строку.

При отпускании кнопки перетаскивание прекращается и монтажный стол отправляется к метке Quiet.

Первое, что вы заметите при проверке фильма – изменение цвета фона, ведь основной монтажный стол перешел к одному из кадров с 1 по 4, выбранному случайным образом.

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

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

onClipEvent (load) {
  words = "My name is Derek";
  this._xscale = 75;
  _yscale = 75;
}

Как вы узнали из предыдущего урока, обработчики событий клипа ( load, enterFrame, mouseMove и прочих) присоединяются к экземплярам фильмов-символов. Они позволяют запрограммировать действия, воздействующие только на один экземпляр фильма-символа. Таким образом, для программирования характеристик, уникальных для конкретного экземпляра фильма-символа, следует применять события клипа – вне монтажного стола фильма-символа; для программирования характеристик, общих для всех экземпляров фильма-символа, следует помещать скрипты внутрь монтажного стола фильма-символа (в кадр или кнопку в составе этого символа). И те, и другие действия указывают на текущий монтажный стол – но с разных точек зрения.

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

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

onClipEvent (load) {
  words = "My name is Ashlie";
  _x = 400;
  _y = 300;
}

Скрипт очень похож на предыдущий, за исключением того, что переменной words присвоено другое значение – "My name is Ashlie", и вместо масштабирования при загрузке фильма-символа меняются его координаты: 400 пикселей по горизонтали и 300 по вертикали (отсчет от верхнего левого угла сцены).

onClipEvent (load) {
  words = "My name is Kathy";
}
onClipEvent (mouseMove) {
  this._rotation = this._rotation + .5;
}

При загрузке этого экземпляра выполняется первое действие, присваивающее переменной words значение "My name is Kathy". Второй обработчик события при каждом перемещении мыши поворачивает экземпляр на полградуса.

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

Мы будем работать с этим же проектом (слегка модифицированным) в следующем упражнении.

Обращение к основному монтажному столу

Основной (или корневой – root) фильм представляет собой главный монтажный стол SWF-файла. Все прочие монтажные столы, присутствующие в проекте, находятся, так или иначе, внутри него.

Обратиться к основному монтажному столу очень просто. Синтаксис следующий:

_root.play();

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

Примечание Фильм, загружаемый в уровень, также рассматривается как основной монтажный стол. Такие фильмы будут рассмотрены в разделе "Обращение к фильмам в уровнях".

Этот файл очень похож на тот, с которым мы только что работали – за исключением двух кнопок, расположенных в правом нижнем углу сцены. Мы запрограммируем их так, чтобы при нажатии на них изменялся размер сцены – основного монтажного стола. Затем мы скопируем эти кнопки, поместим их внутрь наших экземпляров фильма-символа, и – не меняя адресации в скрипте – продемонстрируем, что _root указывает на основной монтажный стол из любого другого монтажного стола проекта.

on (release) {
  _root._xscale = _root._xscale - 10;
  _root._yscale = _root._yscale - 10;
}

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

on (release) {
  _root._xscale = _root._xscale + 10;
  _root._yscale = _root._yscale + 10;
}

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

Хотя копии кнопок находятся на монтажном столе фильма-символа, присоединенные к ним действия попрежнему направлены на основной монтажный стол (SWF) благодаря адресации _root.

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

Мы будем работать с этим же проектом (слегка модифицированным) в следующем упражнении.

Обращение к родительскому фильму

Flash позволяет вставлять монтажные столы один в другой – на самом-то деле вы делаете это, не задумываясь: каждый раз, когда помещаете на основной монтажный стол экземпляр фильма-символа. Мало того – любой фильм-символ может содержать другие фильмы-символы, и так далее, на много уровней в глубину. Помещая один монтажный стол внутрь другого, мы тем самым создаем между монтажными столами отношения "родитель-потомок". Родительским является тот монтажный стол, который содержит другой фильм; потомок – это фильм, который содержится внутри другого монтажного стола.

Фильм-потомок может передать родителю указание сделать что-либо (не то, что в реальной жизни!), используя следующий синтаксис:

_parent.play();

Чтобы лучше понять, как это работает, вообразите, что вы поместили экземпляр фильма-символа с именем myMovieClip на основной монтажный стол, а затем поместили другой экземпляр фильма-символа, с именем myOtherMovieClip, внутрь myMovieClip. Абсолютный путь при такой структуре выглядел бы так:

_root.myMovieClip.myOtherMovieClip

Если вам понадобилось поместить на монтажный стол myOtherMovieClip действие, вызывающее переход монтажного стола myMovieClip к кадру 50, следует использовать такой синтаксис:

_parent.gotoAndPlay(50);

Если точно такое же действие поместить на монтажный стол myMovieClip, то оно приведет к тому, что к кадру 50 перейдет основной монтажный стол, ведь в данном случае родителем является он.

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

Единственное отличие этого файла от того, с которым мы работали в предыдущем упражнении – то, что убраны кнопки, выполнявшие масштабирование основного монтажного стола; здесь они нам не нужны.

Вы только что поместили один фильм-символ внутрь другого, создав между ними отношения родитель-потомок: экземпляр, который вы перетащили на сцену, становится потомком того монтажного стола, на который он помещен. Монтажный стол потомка точно такой же, как у родителя. Он содержит невидимую кнопку, при нажатии которой экземпляр становится перетаскиваемым и у него появляется контур для текста. Текстовое поле в этом контуре тоже имеет имя balloon – как у фильма-родителя.

onClipEvent (load) {
	this.words = _parent.words + "'s kid";
}

При загрузке этого экземпляра фильма-символа – а это произойдет в тот же момент, когда загрузится его родитель, поскольку он находится в кадре 1 основного монтажного стола – родитель передаст имеющиеся у него данные потомку. Приведенное выше действие можно расшифровать так: "Присвоить переменной этого монтажного стола words значение, равное значению переменной words родительского монтажного стола плюс "’s kid". Так, если у родителя значение words было "I’m Derek", тогда у потомка words будет иметь значение "I’m Derek’s kid". Давайте это проверим.

Вы сразу же заметите, что каждый из наших экземпляров теперь получил дочерний фильм-символ. Если вы нажмете кнопку мыши на одном из фильмов-потомков, он станет перетаскиваемым и у него появится контур, содержащий сообщение о том, чьим "ребенком" он является. Это как раз то, что мы запрограммировали на предыдущем шаге.

Нажмите и потащите один из фильмов-родителей, и вы увидите, что его потомок перемещается вместе с ним. То же самое наблюдается при вращении: потомок вращается вместе с родительским фильмом. Данные, которыми располагает потомок, не зависят от родителя: данные одного монтажного стола не влияют на данные другого, если только мы специально не запрограммируем такое влияние. Что же касается графики – тут история другая. Динамическое изменение размера, позиции, прозрачности и прочих графических параметров родительского фильма-символа автоматически отражаются на его потомке; если же вы захотите, чтобы клип-потомок повлиял на родителя, это также придется специально запрограммировать. Подведем итог: вы можете запрограммировать группу монтажных столов для совместных, координированных действий, при этом они останутся независимыми от других групп в проекте.

Давайте посмотрим, как еще можно применить отношения родитель-потомок между монтажными столами.

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

В кадр 1 поместите:

_parent._x = _parent._x - 1;
_parent._xscale = _parent._xscale - 1;

В кадр 2 поместите:

_parent._y = _parent._y - 1;
_parent._yscale = _parent._yscale - 1;

В кадр 3 поместите:

_parent._x = _parent._x + 2;
_parent._xscale = _parent._xscale -1;

В кадр 4 поместите:

_parent._y = _parent._y + 2;
_parent._yscale = _parent._yscale -1;

В данном случае для нас не особенно важна структура этих скриптов; что действительно важно, так это то, что все действия адресуются родителю, поэтому, когда этот фильм будет помещен на какой-либо монтажный стол, тот начнет двигаться по спирали, постепенно уменьшаясь. Давайте посмотрим, как это будет.

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

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

В синтаксисе обращения к родителю можно создавать многоуровневые конструкции, например:

_parent._parent._alpha = 50

Это позволяет программировать еще более сложные модели поведения.

Это упражнение завершено.

Обращение к экземпляру фильма-символа

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

_root.alien

Этот абсолютный путь вы можете использовать в скрипте на любом монтажном столе проекта для обращения к данному конкретному экземпляру.

Однако для того, чтобы обратиться к этому экземпляру с основного монтажного стола (который является родителем по отношению к этому экземпляру), достаточно указать относительный путь:

alien

Если же мы помещаем тот же экземпляр в другой экземпляр фильма-символа, с именем spaceship, который сам находится на основном монтажном столе, абсолютный путь будет таким:

_root.spaceship.alien

Теперь отношения между корневым монтажным столом и экземпляром alien иные, и для обращения к этому экземпляру с основного монтажного стола нужно указать такой относительный путь:

spaceship.alien

Поскольку экземпляр spaceship теперь является родителем экземпляра alien, то для него относительный путь к фильму-символу alien будет:

alien

В следующем упражнении мы потренируемся в адресации к определенным экземплярам фильмов-символов с помощью их имен и отношения к монтажному столу, содержащему скрипт.

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

Например, если вы выделили экземпляр, который при загрузке присваивает переменной words значение "I’m Derek", то этому экземпляру следует дать имя Derek. То же самое и для других экземпляров, присутствующих на сцене.

Теперь у нас шесть именованных экземпляров фильмов-символов, на которые мы можем указать с любого монтажного стола. Абсолютные пути к ним таковы:

_root.Derek
_root.derek.myKid
_root.Kathy
_root.Kathy.myKid
_root.Ashlie
_root.Ashlie.myKid

myKid._rotation = myKid._rotation + 20;
  _root.Derek.myKid._xscale = _root.Derek.myKid._xscale + .5;
  _root.Derek.myKid._yscale = _root.Derek.myKid._yscale + .5;
  _root.Ashlie.myKid._y = _root.Ashlie.myKid._y - .5;

Эти строки мы вставили в обработчик события mouseMove, значит, они будут выполняться при каждом перемещении мыши. Поскольку скрипт присоединен к экземпляру с именем Kathy, в первом действии использован относительный путь для указания на экземпляр myKid, находящийся внутри экземпляра Kathy. При каждом перемещении мыши свойство "поворот" этого экземпляра myKid увеличивается на 20. В двух следующих действиях используется абсолютный путь, указывающий на экземпляр myKid внутри экземпляра Derek. Действия масштабируют экземпляр – он будет увеличиваться на 0,5 процента при каждом перемещении мыши. В последнем действии также используется абсолютный путь, на сей раз указывающий на экземпляр myKid в экземпляре Ashlie. При каждом перемещении мыши этот экземпляр должен перемещаться вверх на 0,5 пикселя.

Попробуйте перемещать мышь – экземпляры фильма-символа myKid, к которым мы обратились, будут выполнять запрограммированные нами действия.

Упражнение закончено, как и наша работа с этим файлом.

Обращение к фильмам в уровнях

При помощи действия loadMovie() во Flash имеется возможность загрузить во Flash Player для одновременного воспроизведения сразу несколько .swf файлов. Кое-что об этом вы узнаете в данном упражнении, а подробно мы обсудим эту тему в Уроке 17 – "Загрузка внешних материалов". Файлы SWF, загружаемые в проигрыватель, помещаются в так называемые уровни. Функционально эти уровни (содержащие SWF) схожи со слоями (содержащими графический и прочий материал) на монтажном столе. Уровни, как и слои, можно представить себе в виде пачки параллельных плоскостей; они определяют "глубину" загрузки SWF-файла (и всего его содержимого) – окажется ли он "выше" или "ниже" других фильмов, загруженных в проигрыватель. Вы можете загрузить в проигрыватель, в различные уровни, несколько сот внешних .swf-файлов.

Загружая действием loadMovie() фильм в уровень, вы должны указать номер уровня для загрузки. При этом вы не обязаны загружать фильмы в уровни последовательно; номера можно выбирать произвольно, например, 731, а потом 46 – как вам угодно. Как только фильм загружен в уровень, путем для указания на него с других монтажных столов становится номер уровня. Предположим, вы загрузили фильм в Уровень 37, фильмы из других уровней могут обратиться к нему так:

_level37

Например, чтобы остановить воспроизведение монтажного стола в этом уровне, следует использовать такой синтаксис:

_level37.stop ();

Примечание Первый (основной) фильм автоматически загружается в Уровень 0.

Адресация к уровням – ключ к управлению SWF-фильмами, загруженными в них: как их основными монтажными столами, так и фильмами-символами, которые они могут содержать.

Необходимо сделать одно важное замечание. Когда вы загружаете действием loadMovie() дополнительные SWF-фильмы, то основной монтажный стол каждого SWF-фильма является корневым ( _root ) по отношению к другим фильмам (символам), содержащимся в данном SWF. Так, если фильмы из других уровней должны обращаться к SWF-фильму по адресу _level37, фильмы-символы, содержащиеся в самом этом SWF-фильме, обращаются к нему по адресу _root. Таким образом, можно сказать, что когда какой-либо монтажный стол обращается к другому монтажному столу в этом же уровне, он использует относительный путь.

В следующем упражнении мы загрузим фильмы в уровни 1 и 2, а затем будем управлять ими из Уровня 0.

Это будет фильм, который мы загрузим в Уровень 1. Внешне он похож на диалоговое окно некой операционной системы. Фильм состоит из шести слоев, которые названы соответственно их содержимому.

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

_visible = false;

Это действие адресуется текущему фильму, а поскольку данный фильм будет загружаться в Уровень 1, значит, фильм Уровня 1 сразу после загрузки будет невидимым – как будто это диалоговое окно поначалу закрыто. При помощи скрипта, помещенного в фильм Уровня 0 мы будем "открывать" это окно, вернее, делать его видимым.

on (release) {
  _visible = false;
}

Этой кнопкой можно будет "закрыть" окно – после того, как оно станет видимым.

on (press) {
  _alpha = 50;
  startDrag (this);
}
on (release) {
  _alpha = 100;
  stopDrag ();
}

Пока эта кнопка нажата, фильм будет на 50% прозрачным, при этом его можно будет перетаскивать. Как только кнопка будет отпущена, перетаскивание прекратится, и фильм вновь станет непрозрачным на 100% – так мы сымитировали перетаскиваемое диалоговое окно.

Тут стоит сделать отступление. Мы с вами знаем, что этот фильм будет загружаться в Уровень 1, значит, можно было бы использовать такой синтаксис:

on (press) {
  _level1._alpha = 50;
  startDrag ();
}
on (release) {
  _level1._alpha = 100;
  stopDrag ();
}

Как видите, здесь к действиям, изменяющим прозрачность, добавлен абсолютный путь, указывающий на Уровень 1. Конечно, работать это будет, но у такого подхода – явного указания абсолютного пути для действий, направленных на основной монтажный стол – имеется большой недостаток. В приведенном примере мы заранее знаем, что этот фильм будет загружаться именно в Уровень 1. А если бы проект был более сложным и динамичным, если бы этот фильм можно было бы загружать в произвольный свободный уровень? Предположим, этот фильм оказался бы загружен в Уровень 82, и к чему бы тогда привели эти строки в скрипте, изменяющие прозрачность? Ведь они обращаются к фильму в Уровне 1, а на самом деле текущий фильм находится в Уровне 82! В таких случаях лучше использовать относительные пути, тогда фильм можно будет загрузить в какой угодно уровень, и все его скрипты будут работать правильно.

Тем самым мы создаем из нашего проекта SWF-файл, который будет загружаться в Уровень 1.

Теперь возьмемся за фильм, предназначенный для загрузки в Уровень 2.

В следующем упражнении мы вернемся к работе над этим файлом.

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

Скрипты, которые мы добавим в этот проект, будут точно такими же, как для предыдущего фильма, и выполнять они будут те же самые функции; только воздействовать будут, естественно, на этот фильм, загруженный в Уровень 2.

_visible = false;

Это действие указывает на текущий фильм, стало быть, фильм, загруженный в Уровень 2, сразу же станет невидимым – то же самое мы делали на шаге 2 для предыдущего фильма.

on (release) {
  _visible = false;
}

Эта кнопка будет "закрывать" окно – после того, как оно станет видимым.

on (press) {
  _alpha = 50;
  startDrag (this);
}
on (release) {
  _alpha = 100;
  stopDrag ();
}

Пока эта кнопка нажата, фильм в Уровне 2 станет на 50% прозрачным, его можно будет перетаскивать. Как только кнопка будет отпущена, перетаскивание прекратится, и фильм вновь станет непрозрачным на 100% – то же, что было на шаге 4: имитация перетаскиваемого диалогового окна.

На этом (пока что) закончим написание скриптов для этого фильма.

Тем самым мы создаем из нашего проекта SWF-файл, который будет загружаться в Уровень 2.

В следующем упражнении мы вернемся к работе над этим файлом.

Этот фильм будет загружаться в проигрыватель изначально (в Уровень 0, это произойдет автоматически, специально указывать номер уровня не нужно). В этот фильм мы поместим действия, загружающие backgroundControl.swf в Уровень 1 и textBox.swf в Уровень 2. Затем мы добавим действия, позволяющие управлять этими фильмами из Уровня 0.

Этот файл выглядит как диалоговое окно операционной системы. Он состоит из одной сцены, включающей четыре слоя, названия которых соответствуют их содержимому.

loadMovieNum ("backgroundControl.swf", 1);
loadMovieNum ("textBox.swf", 2);

Первое действие загружает фильм backgroundControl.swf в Уровень 1, второе – textBox.swf в Уровень 2.

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

on (release) {
  _level1._visible = true;
}

Это действие делает видимым фильм, загруженный в Уровень 1, имитируя открытие диалогового окна. Как видите, здесь присутствует прямое обращение к фильму, загруженному в уровень.

on (release) {
  _level2._visible = true;
}

То же самое, что для предыдущей кнопки, только в данном случае целью действия является фильм, загруженный в Уровень 2.

Теперь давайте запрограммируем кнопки, позволяющие масштабировать фильмы в уровнях 1 и 2.

on (release) {
  _level1._xscale = _level1._xscale - 5;
  _level1._yscale = _level1._yscale - 5;
}

Если эту кнопку нажать и отпустить, размеры фильма в Уровне 1 по горизонтали и вертикали уменьшатся на 5%.

on (release) {
  _level1._xscale = _level1._xscale + 5;
  _level1._yscale = _level1._yscale + 5;
}

То же самое, что для предыдущей кнопки, только здесь размеры фильма в Уровне 1 увеличиваются.

Для стрелки влево:

on (release) {
  _level2._xscale = _level2._xscale - 5;
  _level2._yscale = _level2._yscale - 5;
}

Для стрелки вправо:

on (release) {
  _level2._xscale = _level2._xscale + 5;
  _level2._yscale = _level2._yscale + 5;
}

Действия имеют тот же эффект, что для предыдущих двух кнопок, только направлены они на фильм, загруженный в Уровень 2.

Как только начнется воспроизведение этого проекта, backgroundControl.swf загрузится в Уровень 1, а textBox.swf – в Уровень 2. Однако на экране они не появятся – как вы помните, мы запрограммировали эти фильмы так, чтобы сразу после загрузки они становились невидимыми. Щелкните на одной из запрограммированных нами кнопок-значков на "рабочем столе", и соответствующий фильм отобразится на экране. Мы можем управлять размерами этих фильмов при помощи кнопок-стрелок в нижней части экрана пара. Эти фильмы можно перетаскивать мышью, можно закрыть любое из этих "диалоговых окон" предназначенной для этого кнопкой.

В следующем упражнении мы используем тот же файл (немного измененный).

Обращение к экземплярам фильмов-символов в уровнях

Обратиться к экземпляру фильма-символа, находящемуся в SWF-фильме, загруженном в уровень, проще простого: нужно просто указать номер уровня, в котором находится SWF, а затем имя нужного экземпляра. Например, путь (для фильмов из других уровней) к экземпляру под названием cuteDog внутри SWF, загруженного в Уровень 42, будет выглядеть так:

_level42.cuteDog

Если cuteDog сам содержит экземпляр фильма-символа с именем tail, путь к этому последнему будет таким:

_level42.cuteDog.tail

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

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

Файл такой же, как тот, к которому мы добавили скрипты в предыдущем упражнении – с единственным исключением: здесь на монтажном столе имеется еще один слой, под названием Colors Clip.

Теперь вы видите лиловый прямоугольник, покрывающий всю сцену. Этот прямоугольник есть экземпляр фильма-символа с именем colors. Он будет работать как цветной фильтр, наложенный поверх разноцветного текстурного фона нашего "рабочего стола". При изменении цвета и прозрачности этого экземпляра будет казаться, что меняется этот фон. Мы напишем скрипт для фильма, загруженного в Уровень 1 (backgroundColor.swf) для управления цветом и прозрачностью этого экземпляра.

Вы видите монтажный стол фильма-символа colors. Он состоит из единственного слоя, в котором имеется несколько кадров с метками. На каждой из этих меток прямоугольник на сцене окрашен цветом, соответствующим названию метки. Мы будем управлять цветом этого клипа, переходя к той или иной метке на его монтажном столе. Изначально клип лиловый – это цвет кадра 1, и в этом кадре содержится действие stop(), предотвращающее воспроизведение монтажного стола до получения особых инструкций.

Взгляните на инспектор Параметры. Как видите, это текстовое поле относится к типу Input text (поле для ввода), имя экземпляра – inputText. Сюда пользователь может ввести любой текст, и этот текст будет использован в фильме, загружаемом в Уровень 2 (textBox.swf). Сейчас мы создадим скрипт, обеспечивающий эту возможность.

_level2.inputText.text = _level0.inputText.text;

В фильме, загружаемом в уровень 2, тоже имеется текстовое поле, и тоже с именем inputText. При нажатии на эту кнопку добавленное нами действие поместит в текстовое поле фильма Уровня 2 тот же текст, который введен в текстовое поле этого фильма. Это – простейший пример обмена данными между монтажными столами.

_level0.colors._alpha = 50;

Данное действие устанавливает для экземпляра фильма-символа colors (который находится в слое Colors Clip ) 50-процентную прозрачность сразу после начала воспроизведения фильма. Мы указали здесь путь _level0, хотя это и не требовалось – просто чтобы освежить вашу память, лишний раз напомнив, что этот первый фильм будет автоматически загружаться в Уровень 0.

В конце упражнения мы воспроизведем этот фильм.

Написание скриптов для этого файла завершено.

Это тот же файл, который мы использовали в предыдущем упражнении – тот, что предназначен для загрузки в Уровень 1. В предыдущем упражнении мы запрограммировали его: сразу после загрузки он становится невидимым, "закрывается" при щелчке на кнопке "выход" (круглая, с крестом), его можно перетаскивать при нажатой невидимой кнопке, расположенной поверх "полосы заголовка". Теперь мы расширим функциональность этого "диалогового окна", дав ему возможность управлять экземпляром фильма-символа colors, находящегося в Уровне 0. Мы присоединим скрипты к этим многочисленным цветным квадратикам-кнопкам, которые вы видите.

Прежде чем начать программирование, давайте познакомимся поближе с элементами сцены. Слева, под надписью Transparency, вы видите динамическое текстовое поле, имеющее имя alphaAmount. Оно найдет у нас два применения: будет отображать текущее значение прозрачности экземпляра фильма-символа colors из Уровня 0, а также показывать, какому значению прозрачности соответствует каждая из кнопок, управляющих прозрачностью (при наведении указателя на эти кнопки). Эти пять кнопок – небольших, квадратных – расположены левее; мы запрограммируем их для изменения прозрачности экземпляра фильма-символа colors. Под этими кнопками имеется еще девять цветных квадратных кнопочек. Они будут изменять цвет экземпляра colors (перемещая его монтажный стол к той или иной метке). Ниже этих кнопок вы видите экземпляр фильма-символа currentColor, представляющий собой, по сути, уменьшенную версию фильма-символа colors. Этот экземпляр будет отображать текущий цвет, примененный к фону "рабочего стола". В самом низу имеется еще одно текстовое поле, оно называется colorName и будет отображать название цвета при наведении указателя на ту или иную цветовую кнопку.

on (rollOver) {
  alphaAmount.text = 0;
}
on (release) {
  _level0.colors._alpha = 0;
}
on (release, rollOut) {
  alphaAmount.text = _level0.colors._alpha;
}

Эта кнопка будет устанавливать на 0 значение прозрачности экземпляра фильма-символа colors в Уровне 0.

Первое действие отображает 0 в текстовом поле alphaAmount при наведении указателя на кнопку – это подсказка пользователю. Следующее действие выполняется, если кнопка нажата и отпущена: свойству _alpha экземпляра фильма-символа colors присваивается нулевое значение, в результате он становится полностью прозрачным. Обратите внимание на адресацию: все просто – уровень, а за ним имя экземпляра. Следующее действие отображает в текстовом поле alphaAmount текущее значение прозрачности экземпляра фильма-символа colors; действие выполняется, если кнопка отпущена или с нее убран указатель.

Самостоятельно присоедините такой же скрипт к остальным кнопкам, управляющим прозрачностью, только вместо значения 0 подставьте, соответственно, 25, 50, 75 и 100.

on (rollOver) {
  colorName.text = "Purple";
}
on (release) {
  currentColor.gotoAndStop ("Purple");
  _level0.colors.gotoAndStop ("Purple");
}
on (release, rollOut) {
  colorName.text = "Выберите цвет";
}

Эта кнопка устанавливает цвет экземпляра фильма-символа colors в Уровне 0, перемещая его монтажный стол к кадру с нужной меткой.

Первое действие при наведении указателя на кнопку отображает в текстовом поле colorName слово "Purple" – это подсказка пользователю, какому цвету соответствует данная кнопка. По нажатию и отпусканию кнопки выполняются два действия. Первое из них отсылает экземпляр фильма-символа currentColor к кадру с меткой Purple. Тем самым изменится цвет прямоугольника, расположенного ниже кнопок смены цветов – он станет лиловым. Следующее действие отсылает к кадру с меткой Purple экземпляр фильма-символа colors в Уровне 0, приводя к тому, что фон Уровня 0 приобретает лиловый оттенок (его насыщенность будет зависеть от текущего значения прозрачности). Последнее действие выводит в текстовое поле colorName надпись "Выберите цвет".

Точно такой же скрипт присоедините к остальным кнопкам смены цвета, только замените "Purple" на одно из следующих значений (для кнопок слева направо): "Maroon", "Lavender", "SkyBlue", "DeepBlue", "Orange", "GrassGreen", "SeaGreen" и "Pink".

Мы создали из нашего проекта SWF-фильм, предназначенный для загрузки в Уровень 1, перезаписав предыдущую версию файла, созданную в предыдущем упражнении.

Работу с этим файлом мы закончили.

Как только начнется воспроизведение файла, backgroundControl.swf будет загружен в Уровень 1, а textBox.swf – в Уровень 2; оба сразу же станут невидимыми. Экземпляр фильма-символа colors, который накладывается на текстурный фон, имеет лиловый оттенок при прозрачности 50 процентов.

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

Теперь нажмите кнопку-значок в виде компьютерного монитора – станет видимым фильм в Уровне 1. Этот фильм управляет цветом и прозрачностью экземпляра фильма-символа colors в Уровне 0. Понажимайте кнопки изменения прозрачности и цвета, посмотрите, как изменяется этот экземпляр.

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

Предположим, имеется переменная с именем myVariable. Пусть эта переменная находится в экземпляре фильма-символа myMovieClip, который находится в фильме, загруженном в уровень 74. Тогда, чтобы воспользоваться этой переменной в скрипте на любом монтажном столе, достаточно указать правильный путь к ней:

_level27.displayText = _level74.myMovieClip.myVariable;

То же самое и для вызовов функций:

_root.anotherMovieClip.myFunction();

И для объектов любого типа:

_parent.myObject;

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

Взаимозаменяемость способов адресации

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

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

Создание глобальных элементов и ссылка на них

Нет сомнения, что, даже имея ясное представление о способах адресации, порой бывает трудно уследить за всеми элементами – особенно когда монтажные столы многократно вложены друг в друга, вроде матрешек. Проявите немного воображения, и вы поймете, что пути при этом могут оказаться слишком длинными и неудобными. Чтобы упростить дело, в ActionScript предусмотрены глобальные объекты. Эти особые элементы Flash не принадлежат конкретному монтажному столу, но они полностью доступны для вашего проекта: на них можно сослаться с любого монтажного стола без указания пути, тем самым получив доступ ко всем возможностям, которыми они располагают (переменным, функциям, другим динамическим элементам).

Сначала мы расскажем, как создать глобальный элемент, а затем – как обычный элемент (то есть находящийся на монтажном столе) преобразовать в глобальный.

Процесс создания глобального элемента, например, переменной, очень прост и выглядит так:

_global.myVariable = "hello";

Поскольку эта переменная является глобальным объектом, к ней можно обратиться с любого монтажного стола просто по имени, не указывая путь:

_root.myMovieClip.favoriteGreeting = myVariable;

или

_root.favoriteGreeting = myVariable;

Также можно объявить глобальную функцию (см. Урок 5 – Применение функций), используя глобальный идентификатор:

_global.myFunction = function(){
     // действия...
}

Теперь эту функцию можно вызвать с любого монтажного стола, просто указав ее имя:

myFunction();

То же справедливо и при создании экземпляров объектов (см. Урок 4 – Объекты и их использование):

_global.myDateObject = new Date();

Выше мы упомянули, что обычный элемент, который находится на монтажном столе (например, экземпляр фильма-символа), можно преобразовать в глобальный (к которому не надо указывать путь). Предположим, например, что в нашем проекте имеется экземпляр фильма-символа, расположенный "по адресу" _root.car.engine.piston. Если мы захотим упростить доступ к этому экземпляру, то можем дать ему глобальный адрес:

_global.myPiston = _root.car.engine.piston;

Теперь этим элементом можно управлять с любого монтажного стола, просто указав его глобальное имя:

myPiston.play();

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

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

_root.myMovieClip.myVariable

Однако проблема появится, когда myMovieClip обратится к глобальной переменной с именем myVariable:

myVariable

Дело в том, что этот монтажный стол (фильм-символ) имеет собственную, локальную переменную с именем myVariable. Если использовать такой синтаксис (без указания пути), Flash не сможет понять, к какой переменной происходит обращение, к локальной или глобальной. Конфликт будет разрешен автоматически – Flash обратится к той переменной, которая ближе к данному монтажному столу, то есть к локальной.

Простейший способ избежать таких конфликтов – начинать имена всех глобальных элементов с буквы g:

gMyVariable
gFavoriteColor

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