Flash / Examples 7

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
<menu>
 <buttons>
 <button>
 <label>Home</label>
 <linkTo>http://easyflash.org/</linkTo>
 </button>
 <button>
 <label>Tutorials</label>
 <linkTo>http://easyflash.org/flatexttutorials</linkTo>
 </button>
 <button>
 <label>Forum</label>
 <linkTo>http://forum.easyflash.org/</linkTo>
 </button>
 <button>
 <label>About</label>
 <linkTo>http://easyflash.org/aboutus.html</linkTo>
 </button>
 <button>
 <label>Home</label>
 <linkTo>http://easyflash.org/</linkTo>
 </button>
 <button>
 <label>Tutorials</label>
 <linkTo>http://easyflash.org/flatexttutorials</linkTo>
 </button>
 </buttons>
</menu>
//-----------------------------------------

//Импортируем TweenMax
import com.greensock.*;

//Задаем путь XML файла.
var xmlPath:String = "colorful_menu.xml";

//Переменная, в которую поместим дайнные из загруженного XML файла.
var xml:XML;

//Создаем загрузчик.
var loader = new URLLoader();
loader.load(new URLRequest(xmlPath));
loader.addEventListener(Event.COMPLETE, xmlLoaded);

//Эта функция вызывается, когда файл полностью загружен.
function xmlLoaded(e:Event):void {

 //Убедимся, что файл загружен.
 if ((e.target as URLLoader) != null ) {

 //Создадим XML объект.
 xml = new XML(loader.data);

 //Вызовем функцию создания меню.
 createMenu();
 }
}
//-----------------------------------------

//Создаем контейнер, который будет содержать в себе элементы меню.
var menuHolder:MovieClip = new MovieClip();

//Добавляем контейнер в список отображения.
addChild(menuHolder);

//Сюда будем помещать количество созданных элементов меню.
var count:Number = 0;

//-----------------------------------------
function createMenu():void {

 //Цикл проходит через все элементы <button></button> в XML файле.
 for each (var button:XML in xml.buttons.button) {

 //Зодаем новый элемент меню.
 var menuItem:MenuItem = new MenuItem();

 //Позиционируем элемент меню.
 menuItem.x = 0;
 menuItem.y = count * menuItem.height;

 //Добавляем текст элемента меню.
 menuItem.itemText.text = button.label.toString();

 //Задаем ссылку элементу меню.
 menuItem.linkTo = button.linkTo.toString();

 //Отключаем реакцию на события мыши у подобъектов мувиклипа элемента меню.
 menuItem.mouseChildren = false;

 //Добавляем слушатели событий для элемента меню.
 menuItem.addEventListener(MouseEvent.MOUSE_OVER, mouseOverItem);
 menuItem.addEventListener(MouseEvent.MOUSE_OUT, mouseOutItem);
 menuItem.addEventListener(MouseEvent.CLICK, itemClicked);

 //Добавляем элемент меню в контейнер.
 menuHolder.addChild(menuItem);


 //Обновляем счетчик элементов меню.
 count++;
 }

 //Вызываем функцию, которая назначает слушатели всему меню.
 addMenuListeners();
}
//-----------------------------------------

//Функция наведения мышью на элемент меню.
function mouseOverItem(e:Event):void {

 //Получим элемент меню, который получил это событие мыши.
 var item:MenuItem = e.target as MenuItem;

 //Изменим цвет этого элемента меню.
 TweenMax.to(item.itemBackground, 0.5, {tint: Math.random()*0xffffff});
}

//-----------------------------------------
//Функция отведения мыши от элемента меню.
function mouseOutItem(e:Event):void {

 //Получим элемент меню, который получил это событие мыши.
 var item:MenuItem = e.target as MenuItem;

 //Изменим цвет этого элемента меню.
 TweenMax.to(item.itemBackground, 1.5, {tint: 0xffffff});
}

//-----------------------------------------
//Функция клика по элементу меню.
function itemClicked(e:Event):void {

 //Получим элемент меню, который получил это событие мыши.
 var item:MenuItem = e.target as MenuItem;

 //Перейдем по заданной ссылке.
 var urlRequest:URLRequest = new URLRequest(item.linkTo);
 navigateToURL(urlRequest);
}

//-----------------------------------------
//Функция назначает слушатели всему меню.

function addMenuListeners():void {

//Слушатели наведения.
menuHolder.addEventListener(MouseEvent.MOUSE_OVER, mouseOverMenuF);
menuHolder.addEventListener(MouseEvent.MOUSE_OUT, mouseOutMenuF);

//Слушатель ENTER_FRAME для анимации.
addEventListener(Event.ENTER_FRAME, enterFrameHandler);

}

//Мы должны знать, когда мышь была наведена.
var mouseOverMenu:Boolean = false;

//-----------------------------------------
//Эта функция вызывается, когда мышь наводится на меню.
function mouseOverMenuF(e:Event):void {

//Задаем переменной значение true.
mouseOverMenu = true;
}
//-----------------------------------------
//Эта функция вызывается, когда мышь отведена.
function mouseOutMenuF(e:Event):void {

//Задаем переменной значение false.
mouseOverMenu = false;
}

//-----------------------------------------
//Эта функция вызывается каждый кадр.
function enterFrameHandler(e:Event):void {

 //Проверяем, наведена ли мышь на меню.
 if (mouseOverMenu) {

 //Узнаем расстояние от верха сцены до мыши.
 var distance:Number = mouseY;

 //Высчитываем процент.
 var percentage:Number = distance / stage.stageHeight;

 //Высчитываем новую координату y (Помните, y изменяется, когда мы перемещаемся по меню.)
 var targetY:Number = -((menuHolder.height - stage.stageHeight) * percentage);

 //Анимируем переход меню в новую координату.
 TweenMax.to(menuHolder, 0.2, {y: Math.round(targetY)});
 }
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------


import flash.display.Sprite;
import flash.display.BitmapData;
import flash.display.Bitmap;

var speed:Number = 0.3;
var radius:Number = 0;
var angle:Number = 0;
var xpos:Number;
var ypos:Number;


var centerX:Number = stage.stageWidth / 2;
var centerY:Number = stage.stageHeight / 2;

//Задаем черный задний фон.

var back:Sprite = new Sprite();
back.graphics.beginFill(0x000000);
back.graphics.drawRect(0, 0, 2*centerX, 2*centerY);
back.graphics.endFill();
addChild (back);

//Наша спираль будет содержаться в контейнере.
var container:Sprite = new Sprite();

//Помещаем наш контейнер в центр сцены.
container.x = centerX;
container.y = centerY;
addChild (container);

//Задаем в контейнере стиль линии в 4 пикселя и белого цвета.
container.graphics.lineStyle (4, 0xffffff);

//Начальная точка будет в центре сцены. (это левый верхний угол контейнера)
container.graphics.moveTo (0, 0);

addEventListener (Event.ENTER_FRAME, onEnterFrame);

function onEnterFrame (event:Event):void {

/*
Мы останавливаем рисование спирали после того, как ее радиус достигает 100 пикселей.
Но вращение спирали продолжаем.
*/
if (radius > 100) {
speed = 0;
container.rotation += 10;
}
else {
//Увеличиваем радиус каждый кадр.
radius += 0.5;

//Новые х и у координаты.
xpos = Math.cos(angle) * radius;
ypos = Math.sin(angle) * radius;

//Рисуем линию по новым координатам.
container.graphics.lineTo (xpos,ypos);

//Вращаем контейнер.
container.rotation += 10;

//Чем больше скорость, тем быстрее рисуем спираль.
angle += speed;
}
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

<?xml version="1.0" encoding="utf-8"?>

<menus>

 <menu id="1">
 <item>1.1</item>
 <item>1.2</item>
 </menu>

 <menu id="2">
 <item>2.1</item>
 <item>2.2</item>
 <item>2.3</item>
 <item>2.4</item>
 </menu>

 <menu id="3">
 <item>3.1</item>
 <item>3.2</item>
 <item>3.3</item>
 <item>3.4</item>
 </menu>

 <menu id="4">
 <item>4.1</item>
 <item>4.2</item>
 <item>4.3</item>
 </menu>

</menus>



//Импортируем ТвинМакс для анимации.
import com.greensock.*;
import com.greensock.easing.*;
import com.greensock.plugins.*;
TweenPlugin.activate([GlowFilterPlugin]);

//Сохраняем высоту элемента меню в константе.
const ITEM_HEIGHT:Number = 40;

//Сохраняем путь до XML файла.
var xmlPath:String = "flash_menu.xml";

//The XML data will be inserted into this variable
var xml:XML;

//Задаем расположение меню по Y.
var floor:Number = 280;

//Здесь будет храниться массив текущего выбранного меню.
var selectedMenu:Array;

//Здесб будет храниться чисто созданных меню.
var menuCounter:uint = 0;

// Загружаем XML файл.
var loader = new URLLoader();
loader.load(new URLRequest(xmlPath));
loader.addEventListener(Event.COMPLETE, xmlLoaded);

//Эта функция вызывается, когда XML файл полностью загружен.
function xmlLoaded(e:Event):void {

 //Убедимся, что мы не работаем с нулевым загрузчиком.
 if ((e.target as URLLoader) != null ) {

 //Поместим загруженные данные в XML переменную.
 xml = new XML(loader.data);

 //Вызываем функцию, которая создает все меню.
 createMenus();
 }
}

//Эта функция создаем все меню.
function createMenus():void {

 //Цикл ищет список меню в XML файле
 for each (var menu:XML in xml.menu) {

 //Мы создаем пункт меню каждый раз, как цикл находит пункт меню в XML файле.
 //Мы отправляем "menu" данные xml как параметр функции создания меню..
 var menuItems:Array = createMenu(menu);

 //Расставляем элементы меню, которые находятся у нас в массиве.
 for (var i= 0; i< menuItems.length; i++) {

 //Задаем координаты.
 menuItems[i].y = floor;
 menuItems[i].x = -30 + menuCounter * 80;

 //Добавляем в список отображения.
 addChild(menuItems[i]);
 }
 }
}

//Эта функция создает один подпункт меню.
function createMenu(menu:XML):Array {

 //Создаем массив, который содержит все подпункты одного меню.
 var menuItems:Array = new Array();

 //Цикл ищет все подпункты одного меню.
 for each (var item:XML in menu.item) {

 //Создает новый подпункт меню.
 var menuItem:MenuItem = new MenuItem();

 //Задает текст подпункта меню.
 menuItem.menuText.text = item.toString();

 //Отключаем реакцию потомков мувиклипа на мышь.
 menuItem.mouseChildren = false;

 //Добавляем подпункт меню в массив.
 menuItems.push(menuItem);
 }

 //Теперь создаем главный пункт меню.
 var mainItem:MenuItem = new MenuItem();

 //Отключаем реакцию потомков мувиклипа на мышь.
 mainItem.mouseChildren = false;

 //Добавляем главный пункт меню в массив.
 menuItems.push(mainItem);

 //Сохраняем массив, к которому принадлежит этот главный пункт меню.
 //Это нам понадобиться для анимации.
 mainItem.belongsToMenu = menuItems;

 //Задаем id  атрибут в качестве текста в пункте меню.
 mainItem.menuText.text = menu. @ id;

 //Назначаем слушатель события на главные пункты меню.
 mainItem.addEventListener(MouseEvent.CLICK, mainItemClicked);

 //Обновляем счетчик.
 menuCounter++;

 //Возвращаем массив, который содержит все элементы одного меню.
 return menuItems;
}

//Эта функция вызывается, когда кликаем по пункту меню.
function mainItemClicked(e:Event):void {

 //Анимируем предыдущее меню вниз (сворачиваем).
 if (selectedMenu) {
 for (var i =0; i<  selectedMenu.length-1; i++) {
 TweenMax.to(selectedMenu[i], 0.5 , {y:floor, glowFilter:{color:0x324df, alpha:0, blurX:0, blurY:0}});
 }
 }

 //Узнаем, к какому меню принадлежит выбранный элемент.
 var clickedMenu:Array = e.target.belongsToMenu;

 //Делаем текущим выбранным меню тот, по которому мы кликнули.
 selectedMenu = clickedMenu;

 //Цикл проходит по элементам меню, кроме главного. Главный элемент не анимируется.
 for (var j =0; j<  selectedMenu.length-1; j++) {

 //Сохраняем элемент в локальной переменной.
 var item = selectedMenu[j];

 //Расчитываем координаты анимации элемента.
 var targetY:Number = floor - ITEM_HEIGHT*1.2*(1 + j);

 //Анимируем элемент.
 TweenMax.to(item, 0.5 , {y:targetY, glowFilter:{color:0xffffff, alpha:1, blurX:20, blurY:20}});
 }
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

package
{
 import flash.display.MovieClip;

 public class Particle extends MovieClip
 {
 /*
 Добавляем два свойства класса - скорость передвижения шарика по оси х и по оси у.
 Эти свойства будут доступны из главной сцены, так как имеют атрибут public (публичный).
 */
 public var speedX:Number = undefined;
 public var speedY:Number = undefined;

 //Пустой конструктор шарика.
 public function Particle()
 {

 }
 }
}

//----------------------------------------
//Задаем количество шариков и массив, в котором шарики будут храниться.
var numberOfParticles:Number = 30;
var particlesArray:Array = new Array();

//Этот цикл создает 30 шариков и рандомно размещает их на сцене.
//Так же мы добавили несколько эффектов.
for (var i=0; i < numberOfParticles; i++)
{

 var particle:Particle = new Particle();

 //Задаем шарикам рандомные скорости по х и у.
 //Math.random возвращает рандомное число n, где 0 <= n < 1.
 particle.speedX = 2 + Math.random();
 particle.speedY = 2 + Math.random();

 //Задаем начальные координаты.
 particle.y = Math.random() * stage.stageHeight;
 particle.x = Math.random() * stage.stageWidth;

 //Зададим рандомный оттенок для шариков, в результате они будут разного цвета.
 var ct:Color = new Color();
 ct.setTint(0xFFFFFF * Math.random(), 0.5);
 particle.transform.colorTransform = ct;

 //Зададим рандомный размер шариков.
 particle.scaleX = 0.5 + Math.random();
 particle.scaleY = particle.scaleX;

 //Этот массив будет содержать все используемые фильтры.
 var particleFilters:Array = new Array();

 //Создадим различный blur-эффект (размытие) для шариков.
 var tempBlurAmount = Math.random() * 4;
 var blur:BlurFilter = new BlurFilter(tempBlurAmount,tempBlurAmount,1);
 particleFilters.push(blur);

 //Создадим различный glow-эффект (свечение).;
 var color:Number = 0x000000;
 var alphaValue:Number = 0.5;
 var blurX:Number = 20;
 var blurY:Number = 20;
 var strength:Number = 5;
 var glow:GlowFilter = new GlowFilter(color,
 alphaValue,
 blurX,
 blurY,
 strength);

 particleFilters.push(glow);

 //Назначим созданные фильтры шарикам (blur и glow);
 particle.filters = particleFilters;

 //Добавим шарики в список отображения сцены и в массив.
 addChild(particle);
 particlesArray.push(particle);
}

//----------------------------------------


//Добавляем слушатель на событие смены кадров ролика.
addEventListener(Event.ENTER_FRAME, enterFrameHandler);


//Эта функция вызывается каждый кадр и анимирует шарики.
function enterFrameHandler(e:Event):void
{
 //Очищаем предыдущие линии.
 graphics.clear();

 //Цикл проходит по всем созданным шарикам.
 for (i=0; i < particlesArray.length; i++)
 {
 //Помещаем текущий шарик в локальную переменную.
 var particleOne:Particle = particlesArray[i];
 //Перемещаем шарик в новые координаты.
 particleOne.x +=  particleOne.speedX;
 particleOne.y +=  particleOne.speedY;

 //Проверяем столкновение с границами.
 //Если шарик сталкивается с границей, то его скорость должна быть умножена на -1 для смены направления движения.

 //Правая граница.
 if (particleOne.x > stage.stageWidth)
 {
 particleOne.x = stage.stageWidth - particleOne.width / 2;
 particleOne.speedX *=  -1;
 }
 //Левая граница.
 else if (particleOne.x < 0)
 {
 particleOne.x = particleOne.width / 2;
 particleOne.speedX *=  -1;
 }
 //Нижняя граница.
 if (particleOne.y > stage.stageHeight)
 {
 particleOne.y = stage.stageHeight - particleOne.width / 2;
 particleOne.speedY *=  -1;
 }
 //Верхняя граница.
 else if (particleOne.y < 0)
 {
 particleOne.y = particleOne.width / 2;
 particleOne.speedY *=  -1;
 }

 //Пройдем циклом по оставшимся шарикам, чтобы вычислить дистанцию между ними.
 for (var j:uint = i + 1; j < particlesArray.length; j++) {

 var particleTwo:Particle = particlesArray[j];

 var distanceX:Number = particleOne.x - particleTwo.x;
 var distanceY:Number = particleOne.y - particleTwo.y;
 //Используем теорему Пифагора (a^2 + b^2 = c^2),
 //чтобы вычислить дистанцию между двумя шариками.
 var distance:Number = Math.sqrt(distanceX * distanceX + distanceY * distanceY);

 //Если дистанция меньше 80 пикселей, то рисуем линию между шариками.
 if (distance < 80) {
 drawLine (particleOne, particleTwo);
 }
 }
 }
}

//----------------------------------------

//Эта функция рисует черные линии между шариками.
function drawLine (particleOne:Particle, particleTwo:Particle):void
{
 graphics.lineStyle (1, 0x000000);
 graphics.moveTo (particleOne.x, particleOne.y);
 graphics.lineTo (particleTwo.x, particleTwo.y);
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

//Импортируем библиотеку с эффектами переходов.
import fl.transitions.*;
import fl.transitions.easing.*;

//Этот массив будет содержать все эффекты переходов.
var transitions:Array = new Array();

//Назначаем слушатель на событие мыши MOUSE_OVER для каждого квадрата.
box1.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box2.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box3.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box4.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box5.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box6.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box7.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box8.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box9.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
box10.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);

//Задаем каждому квадрату свой эффект перехода.
box1.transition = Blinds;
box2.transition = Fade;
box3.transition = Fly;
box4.transition = Iris;
box5.transition = Photo;
box6.transition = PixelDissolve;
box7.transition = Rotate;
box8.transition = Squeeze;
box9.transition = Wipe;
box10.transition = Zoom;

//Эта функция вызывается каждый раз при наведение мышью на какой-либо квадрат.
function mouseOverBox(e:Event):void
{
 //Квадрат, на который была наведена мышь, сохраняем в локальной переменной.
 var selectedBox:MovieClip = MovieClip(e.target);

 /*
 Удаляем слушатель события, чтобы пользователь не смог остановить
 анимацию до того, как она закончится.
 */
 selectedBox.removeEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);

 /*
 Начинаем новый переход со следующими параметрами:
 type: Мы используем тот тип эффекта перехода, который был назначен выбранному квадрату.
 direction: Направление анимации (Transition.OUT это второй параметр)
 duration: Продолжительность анимации в секундах.
 easing: Тип ослабления (сглаживания) анимации.
 shape: Форма маски. Назначается только когда используется "Iris" переход.
 */
 var myTransitionManager:TransitionManager = new TransitionManager(selectedBox);
 myTransitionManager.startTransition({type:selectedBox.transition,
 direction:Transition.IN, duration:1, easing:Regular.easeOut, shape:Iris.CIRCLE});

 //Добавляем переход в массив, теперь он не попадет в процесс сборки мусора;
 transitions.push(myTransitionManager);

 //Добавляем слушатель на окончание анимации перехода.
 myTransitionManager.addEventListener("allTransitionsInDone", animationComplete);
}

//Эта функция вызывается, когда анимация перехода завершена.
function animationComplete(e:Event):void
{
 //Вновь назначаем слушатель на событие наведения мышью.
 e.target.content.addEventListener(MouseEvent.MOUSE_OVER, mouseOverBox);
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------


//Скорость анимации по оси х.
var speedX:Number = 1;
//Скорость анимации по оси у.
var speedAngle:Number = 0.1;
//Амплитуда волны.
var range:Number = 100;
//Математический угол.
var angle:Number = 0;
//Координаты покадрового рисования.
var xpos:Number = 0;
var ypos:Number = 0;
//Координата начальной точки волны по оси у.
var centerY:Number = stage.stageHeight / 2;
//Задаем стиль линии: толщина 2 пикселя, цвет "красный".
graphics.lineStyle(2, 0xff0000);
//Задаем начальную позицию рисования.;
graphics.moveTo(0, centerY);
//Назначаем слушатель на событие смены кадра.;
addEventListener(Event.ENTER_FRAME, onEnterFrame);

//Эта функция выполняется каждый кадр и рисует окружность.
function onEnterFrame(event:Event):void
{
 //Задаем координаты следующей точки.
 xpos +=  speedX;
 ypos = centerY + Math.sin(angle) * range;
 //Задаем угол в следующем кадре.
 angle +=  speedAngle;
 //Рисуем окружность до следующей точки.
 graphics.lineTo(xpos,ypos);
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------


//Максимальная глубина шариков.
const MAXIMUM_Z:Number = 1500;

//Этот массив будет содержать шарики.
var circles:Array = new Array();

//Задаем фокусное расстояние.
var focalLength:Number = 500;

//Задаем точку схода перспективы в центре сцены.
var vanishingPointX:Number = stage.stageWidth / 2;
var vanishingPointY:Number = stage.stageHeight / 2;

//Радиус туннеля.
var radius:Number = 40;

//Начальная глубина для первого шарика.
var startingDepth:Number = MAXIMUM_Z;

//Начальный угол для шариков.
var startingAngle = 0;

//Скорость врашения шариков.
var angleSpeed:Number = 0.07;

//Создадим таймер, который срабатывает каждые 0.15 секунд.
var timer:Timer = new Timer(150,0);
timer.addEventListener(TimerEvent.TIMER, createCircle);
timer.start();

//Функция создания шарика.
function Ball():MovieClip
{
 var ball:MovieClip = new MovieClip();
 ball.graphics.beginFill( 0xcc0000 );
 ball.graphics.lineStyle( 2, 0x000000 );
 ball.graphics.drawCircle( 0, 0, 20 );
 addChild( ball );
 return ball;
}

function createCircle(e:Event):void
{

 //Создаем новый шарик.
 var circle:MovieClip = Ball();

 //Задаем z-позицию шарика.
 circle.zpos3D = MAXIMUM_Z;

 //Сохраняем угол шарика.
 circle.currentAngle = startingAngle;

 //Задаем начальную альфа, равную нулю.
 circle.alpha = 0;

 //Помешаем шарик на нижнуюю позицию в списке отображения сцены.
 addChildAt(circle, 0);

 //Назначаем слушатель ENTER_FRAME для анимации.
 circle.addEventListener(Event.ENTER_FRAME, moveCircle);
}

//Эта функция вызывается каждый кадр.
function moveCircle(e:Event):void
{

 //Помещаем шарик в локальную переменную.
 var circle:MovieClip = (MovieClip)(e.target);

 //Уменьшаем глубину шарика. Приближаем шарик.
 circle.zpos3D -=  5;

 //Если zpos3D <=-focalLength, то удаляем шарик.
 if (circle.zpos3D <=  -  focalLength)
 {

 //Удаляем слушатель.
 circle.removeEventListener(Event.ENTER_FRAME, moveCircle);

 //Удаляем шарик из сцены.
 removeChild(circle);
 }

 //Обновляем текущий угол.
 circle.currentAngle +=  angleSpeed;

 //Расчитываем новыю 3D x позицию.
 circle.xpos3D = Math.cos(circle.currentAngle) * radius;

 //Расчитываем новую 3D y позицию.
 circle.ypos3D = Math.sin(circle.currentAngle) * radius;

 //Расчитываем размер шарика.
 var scaleRatio = focalLength/(focalLength + circle.zpos3D);

 //Задаем размер шарика.
 circle.scaleX = circle.scaleY = scaleRatio;

 //Увеличиваем прозрачность.
 if (circle.alpha < 1)
 {
 circle.alpha +=  0.01;
 }
 //Размещаем шарик в сцене. (Переводим 3Д координаты в 2Д)
 circle.x = vanishingPointX + circle.xpos3D * scaleRatio;
 circle.y = vanishingPointY + circle.ypos3D * scaleRatio;
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

//Задаем ширину и высоту наших кнопок(эти значения равны размерам ваших картинок для кнопок)
const IMAGE_WIDTH:uint = 50;
const IMAGE_HEIGHT:uint = 50;

//Задаем фокусное расстояние.
var focalLength:Number = 500;

//Задаем точку схода перспективы в центре сцены.
var vanishingPointX:Number = stage.stageWidth / 2;
var vanishingPointY:Number = stage.stageHeight / 2;

//Задаем 3Д пол для картинок.
var floor:Number = 40;

//Мы будем расчитывать angleSpeed в ENTER_FRAME слушателе.
var angleSpeed:Number = 0;

//Задаем радиус 3Д карусели.
var radius:Number = 200;

//Задаем путь к XML файлу. Вы здесь можете прописать свой путь.
var xmlFilePath:String = "3D-carousel-settings.xml";

//Мы сохраняем загруженный XML файл в переменной.
var xml:XML;

//Этот массив будет содержать наши картинки.
var imageHolders:Array = new Array();

//Мы хотим знать, сколько изображений было загружено.
var numberOfLoadedImages:uint = 0;

//Полное количество загруженых картинок. Значение будет задаваться через XML файл.
var numberOfImages:uint = 0;

//Загружаем XML файл.
var loader = new URLLoader();
loader.load(new URLRequest(xmlFilePath));

//Назначаем слушатель на завершение загрузки XML файла.
loader.addEventListener(Event.COMPLETE, xmlLoaded);

//Эта функция вызывается, когда XML полностью загружен.
function xmlLoaded(e:Event):void {

 //Создаем новый XML объект.
 xml = new XML(loader.data);
 xml.ignoreWhitespace = true;

 //Вызываем функцию загрузки картинок.
 loadImages();
}

//Эта функция загружает картинки и создает кнопки карусели.
function loadImages():void {

 //Количестко загружаемых картинок. Значение берется из XML.
 numberOfImages = xml.number_of_images;

 //Цикл находит картинки в XML файле.
 for each (var image:XML in xml.images.image) {

 //Создает кнопку, в которую будет помещена картинка.
 var imageHolder:MovieClip = new MovieClip();

 //Создается загружчик картинок.
 var imageLoader = new Loader();

 //Добавляем загрузчик в кнопку.
 imageHolder.addChild(imageLoader);

 //Отключаем события мыши от загрузчика.
 imageHolder.mouseChildren = false;

 //Размещаем картинку в центре кнопки.
 imageLoader.x = - (IMAGE_WIDTH / 2);
 imageLoader.y = - (IMAGE_HEIGHT / 2);

 //Назначаем ссылки для кнопок.
 imageHolder.linkTo = image.link_to;

 //Помещаем кнопки в массив.
 imageHolders.push(imageHolder);

 //загружаем картинки.
 imageLoader.load(new URLRequest(image.url));

 //Слушатель на завершение загрузки.
 imageLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, imageLoaded);
 }
}

//Эта функция вызывается, когда картинка полностью загружена.
function imageLoaded(e:Event):void {

 //Обновляем число загруженных картинок.
 numberOfLoadedImages++;

 //Сглаживаем загруженные картинки (Мы знаем, что загрузчик содержит картинку).
 e.target.content.smoothing = true;

 //Проверяем, все ли картинки загруженны.
 if (numberOfLoadedImages == numberOfImages) {

 //Инициализируем 3Д карусель.
 initializeCarousel();
 }
}

//----------------------------------------------
function initializeCarousel():void {

 //Расчитываем угол отступа между кнопками карусели
 var angleDifference:Number = Math.PI * (360 / numberOfImages) / 180;

 //Цикл по массиву кнопок.
 for (var i:uint = 0; i < imageHolders.length; i++) {

 //Передаем кнопку в локальную переменную.
 var imageHolder:MovieClip = (MovieClip)(imageHolders[i]);

 //Получаем угол размещения для картинки.
 var startingAngle:Number = angleDifference * i;

 //Размещаем картинку.
 imageHolder.xpos3D = radius * Math.cos(startingAngle);
 imageHolder.zpos3D = radius * Math.sin(startingAngle);
 imageHolder.ypos3D = floor;

 //сохраняем угол размещения во внутренней переменной кнопки.
 imageHolder.currentAngle = startingAngle;

 //Расчитываем размер кнопки относительно ее удаленности от зрителя.
 var scaleRatio = focalLength/(focalLength + imageHolder.zpos3D);

 //Изменяем размер кнопки.
 imageHolder.scaleX = imageHolder.scaleY = scaleRatio;

 //Задаем прозрачность кнопки.
 imageHolder.alpha = 0.3;

 //Назначаем слушатели на события наведения мыши.
 imageHolder.addEventListener(MouseEvent.MOUSE_OVER, mouseOverImage);
 imageHolder.addEventListener(MouseEvent.MOUSE_OUT, mouseOutImage);

 //Назначаем слушатели на клик мыши.
 imageHolder.addEventListener(MouseEvent.CLICK, imageClicked);

 //Размещаем кнопки в сцене (Переводим 3Д координаты в 2Д)
 imageHolder.x = vanishingPointX + imageHolder.xpos3D * scaleRatio;
 imageHolder.y = vanishingPointY + imageHolder.ypos3D * scaleRatio;

 //Добавляем кнопки в список отображения сцены.
 addChild(imageHolder);
 }

 //Назначаем слушатель ENTER_FRAME для поворота карусели.
 addEventListener(Event.ENTER_FRAME, rotateCarousel);
}


//Функция вращения карусели.
function rotateCarousel(e:Event):void {

 //Расчитываем скорость вращения карусели относительно положения мыши.
 angleSpeed = (mouseX - vanishingPointX) / 4096;

 //Цикл по массиву кнопок.
 for (var i:uint = 0; i < imageHolders.length; i++) {

 //Передаем кнопку в локальную переменную.
 var imageHolder:MovieClip = (MovieClip)(imageHolders[i]);

 //Обновляем угол размещения кнопки.
 imageHolder.currentAngle += angleSpeed;

 //Задаем новые 3Д координы кнопки.
 imageHolder.xpos3D=radius*Math.cos(imageHolder.currentAngle);
 imageHolder.zpos3D=radius*Math.sin(imageHolder.currentAngle);

 //Расчитываем размеры кнопок.
 var scaleRatio = focalLength/(focalLength + imageHolder.zpos3D);

 //Задаем размер кнопок.
 imageHolder.scaleX=imageHolder.scaleY=scaleRatio;

 //Обновляем 2Д координаты кнопок.
 imageHolder.x=vanishingPointX+imageHolder.xpos3D*scaleRatio;
 imageHolder.y=vanishingPointY+imageHolder.ypos3D*scaleRatio;
 }

 //Сортируем кнопки по оси Z.
 sortZ();
}

//Эта функия сортирует кнопки по Z для правильного наложения друг на друга.
function sortZ():void {

 //Кнопка с бОльшим значением Z всегда первая в массиве.
 imageHolders.sortOn("zpos3D", Array.NUMERIC | Array.DESCENDING);

 //Задаем новые индексы кнопок в массиве.
 for (var i:uint = 0; i < imageHolders.length; i++) {
 setChildIndex(imageHolders[i], i);
 }
}

//Функция наведения мышью.
function mouseOverImage(e:Event):void {

 //Задаем альфа.
 e.target.alpha=1;
}

//Функция отведения мыши.
function mouseOutImage(e:Event):void {

 //Задаем альфа.
 e.target.alpha=0.3;
}

//Функция клика по кнопке.
function imageClicked(e:Event):void {

 //Переход по нужной ссылке.
 navigateToURL(new URLRequest(e.target.linkTo));
}