Flash / Examples 9

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

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

/*
Устанавливаем точку для  кординаты у.
Когда объект будет далеко его координата у будет равна вот этой точке .
*/
var vanishingPointY:Number = stage.stageHeight / 2;

//Устанавливаем переменную, которая "отвечает" за перспективу. То есть "дальше-ближе".
var focalLength:Number = 300;

//Создаем массив, который будет содержать текст и кружок.
var itemsArray:Array = new Array();

//Добавляем текст в массив.
itemsArray.push(myText);

//добавляем кружок в массив
itemsArray.push(myCircle);

/*Угол. Даже не знаю как подробней обяснить зачем эта переменная.
Вообщем на сколько будет поворачиваться туннель. Вообще можно пооэксперементировать
с этой переменной. Будет еще красиво смотреться если устантовить значение 3. Мне так больше нравиться, но оставлю так, как
в оригинальном уроке*/
var angleSpeed:Number = 0.2;

//Скорость движения по горизонтали
var xSpeed:Number = 4;

//Что бы туннэль не "врезался" в текст, надо сделать радиус туннэля  равным высоте текста
var yRadius:Number = myText.height;

//Высчитываем глубину с помощью yRadius
var zRadius:Number = yRadius * 3;

//Устанавливаем 3D y и z координаты
myCircle.ypos3D = 0;
myCircle.zpos3D = 0;

//Устанавливаем 3D z позицию для текста
myText.zpos3D = 0;

//Initial angle for the circle
myCircle.currentAngle = 0;

//Добавляем ENTER_FRAME listener что бы анимировать кружок
myCircle.addEventListener(Event.ENTER_FRAME, moveCircle);

/*
Устанавливаем timer для начала движения.
С помощью этого создаем след.
*/
var timer:Timer = new Timer(20,0);
timer.addEventListener(TimerEvent.TIMER, createTrail);
timer.start();

//Следущая функция двигает наш кружок
function moveCircle(e:Event):void {

 //Обновляем укогл кружка
 myCircle.currentAngle += angleSpeed;

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

 //Высчитываем новую 3D z позицию
 myCircle.zpos3D=Math.cos(myCircle.currentAngle)*zRadius;

 //Высчитываем размеры
 var scaleRatio = focalLength/(focalLength + myCircle.zpos3D);

 //Высчитываем размеры кружка следующим соотношением
 myCircle.scaleX=myCircle.scaleY=scaleRatio;

 //Обновляем  координату х
 myCircle.x+=xSpeed;

 //Обновляем координату у
 myCircle.y=vanishingPointY+myCircle.ypos3D*scaleRatio;

 //Если кружок закончил движение, заставляем его повторить
 if (myCircle.x>stage.stageWidth+20) {
  myCircle.x=-20;
 }

 //Вызываем функцию, которая сортирует круги, что бы они правильно накладывались
 sortZ();
}

//Эта функция создает новый след
function createTrail(e:Event):void {

 //Create a new circle
 var newCircle:MyCircle = new MyCircle();

 //Устанавливаем z позицию, которая была у "myCircle"
 newCircle.zpos3D=myCircle.zpos3D;

 //Устанавливаем одинаковые координаты
 newCircle.x=myCircle.x;
 newCircle.y=myCircle.y;

 //Высчитываем размеры
 var scaleRatio = focalLength/(focalLength + newCircle.zpos3D);

 //Устанавливаем размеры следующим уравнением
 newCircle.scaleX=newCircle.scaleY=scaleRatio;

 //Добавляем в массив новый элемент
 itemsArray.push(newCircle);

 //Добавляем новый круг на сцену
 addChild(newCircle);

 //Сортируем так, что бы кружки правильно накладывались
 sortZ();

 /*
 Используем TweenMax
  */
 TweenMax.to(newCircle, 2, {alpha: 0, scaleX:0, scaleY:0, onComplete: removeCircle, onCompleteParams: [newCircle]});
}

//Вызываем йункцию removeCircle когда анимация закончена
function removeCircle(circle:MyCircle):void {

 //Удаляем круг из массива
 var i:uint=itemsArray.indexOf(circle);
 itemsArray.splice(i, 1);

 //Удаляем со сцены
 removeChild(circle);
}

//Эта  функция сортирует круги что бы они накладывались правильно
function sortZ():void {

 /*
 Сортируем массив так, что бы круг с наибольшей координатой z был первым
 */
 itemsArray.sortOn("zpos3D", Array.NUMERIC | Array.DESCENDING);

 //Устанавливаем новые индексы child indexes для элементов
 for (var i:uint = 0; i < itemsArray.length; i++) {
  setChildIndex(itemsArray[i], i);
 }}

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

<?xml version="1.0" encoding="UTF-8"?>
<images>
 <image src="img/01.jpg"/>
 <image src="img/02.jpg"/>
 <image src="img/03.jpg"/>
 <image src="img/04.jpg"/>
 <image src="img/05.jpg"/>
 <image src="img/06.jpg"/>
 <image src="img/07.jpg"/>
 <image src="img/08.jpg"/>
 <image src="img/09.jpg"/>
 <image src="img/10.jpg"/>
</images>

//------------------------------------
package {
 //Импортируем нужные классы
 import flash.display.Loader;
 import flash.display.Sprite;
 import flash.events.Event;
 import flash.events.MouseEvent;
 import flash.net.URLLoader;
 import flash.net.URLRequest;
 import com.theflashblog.fp10.*;
 import gs.*;
 import gs.easing.*;

 //Создаём наш класс
//------------------------------------
 public class Carousel extends Sprite
 {
    private var container:Sprite; //Здесь будут храниться наши картинки
    private var loader:URLLoader; //Этот URLLoader загрузит наш XML
    private var anglePer:Number;

    //------------------------------------
    public function Carousel() //Это функция конструктор и она запуститься самой первой
    {
        createContainer(); //Вызываем функцию, которая создаст наш контейнер для картинок
        loadXml(); //Загружаем наш XML
    }
   //------------------------------------
    private function loadXml():void //Это функция загрузки XML
    {
        loader=new URLLoader(new URLRequest('images.xml')); //Загружаем наш XML
        loader.addEventListener(Event.COMPLETE, createCarousel); //Регистрируем событие когда закончиться загрузка, чтобы создать карусель
    }

      //------------------------------------
    private function createCarousel(e:Event):void //Это функция создания карусели
    {
        var xml:XML=new XML(e.target.data); //создаем xml
        var list:XMLList=xml.image; //создаём XMLList, чтобы было удобно брать настройки
        anglePer = (Math.PI*2)/list.length();
        for(var i:int=0;i<list.length();i++) //создаём цикл в котором разместим наши элементы по кругу
        {
            var imc:imCon=new imCon(); //берем наш контейнер из библиотеки
            imc.buttonMode=true; //делаем так, чтобы он был похож на кнопку
            imc.addEventListener(MouseEvent.CLICK, onclickiiiii); //регистрируем событие, чтобы знать когда мышкой кликнут по этой картинке
            var l:Loader=new Loader(); //создаём новый Loader, чтобы загрузить нашу картику
            l.x=-250; //центрируем нашу картинку
            l.y=-187.5;
            l.load(new URLRequest(list[i].@src)); //загружаем картинку, используя наш XMLList
            imc.addChild(l); //добавляем в наш контейнер Loader, чтобы иметь возможность увидеть его на сцене
            imc.scaleX=imc.scaleY=0.5; //немного уменьшаем наш контейнер, чтобы видеть все картинки
            imc.angle=(i*anglePer) - Math.PI/2; //узнаём угол, на который нужно повернуть главный контейнер, чтобы увидеть нашу картинку посередине
            imc.x=Math.cos(imc.angle)*450; //располагаем наш контейнер изображения на нужной координате x
            imc.z=Math.sin(imc.angle)*450; ////располагаем наш контейнер изображения на нужной координате z
            imc.rotationY=36*-i; //поворачиваем наш контейнер изображения в зависимости от расстояния по z
            container.addChild(imc); //добавляем контейнер изображения в главный контейнер
        }
        this.addEventListener(Event.ENTER_FRAME, loop); //регистрируем событие, которое быдет отправляться каждый кадр
    }

//------------------------------------
    private function onclickiiiii(e:MouseEvent):void //Эта функция будет поворачивать главный контейнер и увеличивать его, чтобы увидеть нашу картинку посередине
    {
        TweenLite.to(container, 0.8,{rotationY:(e.currentTarget.angle+Math.PI/2)/Math.PI*180,z:100}); //создаём анимацию поворота
    }
//------------------------------------
    private function createContainer():void //Эта функция создаст главный контейнер
    {
        container=new Sprite();
        container.x=350; //центрируем наш контейнер
        container.y=250;
        container.z=400;
        addChild(container); //добавляем наш контейнер на сцену
        cover.addEventListener(MouseEvent.CLICK, stageClick); //регистрируем событие, чтобы знать когда мышкой кликнут по сцене для уменьшения карусели
    }
//------------------------------------
    private function stageClick(e:MouseEvent):void //Эта функция уменьшит главный контейнер
    {
        TweenLite.to(container, 0.8,{z:400}); //создаём анимацию уменьшения
    }
//------------------------------------
    private function loop(e:Event):void //Эта функция отсортирует наши картинки по оси z
    {
        SimpleZSorter.sortClips(container); //сортируем наши картинки по оси z
    }
 }
}

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


//Практическое применение. Пример:
//var ваша_переменная:Flame = new Flame(значение_п1, значение_п2, значение_п3, значение_п4, значение_п5);

    var flame:Flame = new Flame(100, 100, 30, 0.5, 2) //Описание ниже.
    flame.x = 150; //Координата источника пламени по X в родительском контейнере.
    flame.y = 200; //Координата источника пламени по Y в родительском контейнере.
    flame.rotation = 0; /*Угол поворота огня (по часовой стрелке - в градусах).
    При нуле (0) - это свойство можно вообще не изменять. Идет по умолчанию.*/
    addChild(flame);

/*
п1. Размер огня в процентах по ширине от 100% (50 - сократит огонь в половину);
п2. Размер огня в процентах по высоте от 100% (200 - увеличит огонь вдвое);
п3. Минимальная граница непрозрачности искр(они же Spark) в процентах от 100%.
Больше 100 ставить значение НЕ имеет смысла. Ничего не изменится. Поскольку 100 -
это 100% непрозрачности. Значение прозрачности выщитывается случайно.
Затем к нему плюсуется минимальная граница;
п4. Коэффициент скалирования. Задает амплитуду возникающих искр.
При больших значениях можно получить одну искру размером с танк,
а вторую - с муравья. Поэтому для равномерности рекомендуется значение держать
на уhовне 0.5 + (само собой) ваши эксперименты.
п5. Плотность частиц. Значения - строго целые положительные(прим.:
1. для любителей пустых экранов - нуль тоже можно передать;
2. для программистов - изменив свойство density(например, flame.density = 0),
можно получить эффект потухания огня. Динамически добавив, большую плотность &ndash;
можно получить эффект усиления огня. Эффективность такого подхода - не определена.)
*/

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

package
 {
     // импортируем необходимые для работы классы
     import flash.display.MovieClip;
     import flash.utils.Timer;
     import flash.events.TimerEvent;

     public class Flame extends MovieClip
     {
         /* устанавливаем таймер, который будет генерировать искры(Spark),
         что сделает огонь независимым от частоты кадров, но несколько осложнит
         работу вашему процессору*/
         public var timer:Timer = new Timer(42, 0)

         private var alphaSpark:Number; // минимальная граница непрозрачности.
         private var scaleSpark:Number; // коэффициент скалирования частиц (Spark)
         public var density:uint; // плотность частиц

         // функция-конструктор получает параметры:
         function Flame(sF_X:Number, sF_Y:Number, aS:Number, sS:Number, den_y:uint)
         {
             this.scaleX = sF_X/100; //изменяем размер по X для контейнера(Flame) искр(Spark)
             this.scaleY = sF_Y/100; //изменяем размер по Y для контейнера(Flame) искр(Spark)
             alphaSpark = aS/100;
             scaleSpark = sS;
             density = den_y;

             //добавляем слушатель к таймеру, который запустит обработчик sparkAdder:
             timer.addEventListener ("timer", sparkAdder, false, 0, true);
             timer.start(); // запускаем таймер
         }

         // пишем функцию-обработчик sparkAdder:
         function sparkAdder(e:TimerEvent):void
         {
             // создаем локальные переменные свойств объекта.
             var a = alphaSpark;
             var s = scaleSpark;
             var d = density;

             // создаем цикл который "выплевывает" на экран искры(Spark):
             for (var i:uint = 0; i < d; i+=1)
             {
                 var spark:Spark = new Spark(); //создаем экземпляр класса Spark

                 spark.x = (Math.random()-0.5)*15; // задаем рандом по X для искр
                 spark.y = Math.random()*20; // задаем рандом по Y для искр
                 spark.alpha = Math.random() + alphaSpark; // прозрачность новой искры
                 spark.scaleY = Math.random()*scaleSpark + 1; // размер новой искры
                 spark.scaleX = spark.scaleY; // сохраняем пропорции
                 addChild(spark); // добавляем искру в список отображения.
             }
         }
     }
 }

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

package
 {
     // импортируем необходимые для работы классы
     import flash.display.MovieClip;
     import flash.events.*;

     class SparkMover extends MovieClip
     {
         // создаем пустой контейнер искр класса Object
         private static var sparks:Object = {};
         private static var allSparks:uint = 0; // счетчик последней по порядку искры

         private var thisSpark:uint;

         function SparkMover()
         {
             /* избавляем особо усидчивых игроков от ошибки,
             возникающей из-за числового ограничения класса uint.
             Не помешает ;)*/
             if (allSparks > 10000)
             {
                 allSparks = 0;
             }

             thisSpark = allSparks+=1; // задаем индекс текущей искре
             sparks[thisSpark] = this; /* делаем ссылку экземпляра класса
             SparkMover на самого себя. Нужно для дальнейшей работы */

             // добавляем слушатель нового кадра. Ведь класс Spark содержит кадры
             addEventListener(Event.ENTER_FRAME, sparkMover, false, 0, true);
         }

         private function sparkMover (e:Event):void
         {
             if (currentFrame == totalFrames) /* проверяем проиграла ли
             искра себя полностью. Т.е. достиг ли текущий кадр конечно.
             Хотя формально totalFrames - общее количество кадров*/
             {
                 // удаляем слушатель
                 removeEventListener(Event.ENTER_FRAME, sparkMover);
                 this.stop (); // останавливаем проигрывание кадров
                 // добавляем слушатель, который удалит искру со сцены
                 addEventListener (Event.ENTER_FRAME, killSpark, false, 0, true);
             }
         }

         private function killSpark (e:Event):void
         {
             removeEventListener(Event.ENTER_FRAME, killSpark);
             parent.removeChild(this); //удаляем искру со сцены
             delete sparks[thisSpark]; //удаляем ссылку на искру из нашего контейнера
         }
     }
 }

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


// Создаем массив для точек (точнее координат)
var pointArray:Array = new Array();

// Определяем центр "вселенной" как центр сцены
var centerX:Number = Stage.width / 2;
var centerY:Number = Stage.height / 2;

// Определям элементы массива точек как обекты со свойствами pointX и pointY
// и заполняем их значениями нашего центра "вселенной"
for (var i:Number = 0; i < 100; i++) {
pointArray[i] = new Object();
pointArray[i].pointX = centerX;
pointArray[i].pointY = centerY;
}

// Ну что ж, приступим. В каждом кадре....
this.onEnterFrame = function() {

       // очищаем сцену
       this.clear();

       // перемещаемся в точку, которая в массиве стоит первой
       this.moveTo(pointArray[0].pointX, pointArray[0].pointY)

       // А теперь перебираем все точки
       for (var i:Number = 1; i < 100; i++) {

               // пусть линия у нас начинается от абсолютно черной и "уходит" в небытие,
               // то есть становится белой в конце
               // для этого и следующие две строки.
               // чтоб не вдаваться в подробности, лиш скажу что в переменной RGB мы должны
               // получить цвет оттенка серого в строковом формате "0000"
               var colort = int((100 - i) * 255 / 100);
               var RGB = "0x" + Number(colort + colort * 256 + colort * 256 * 256).toString(16);

               // определяем стиль для линии, при этом пусть у начала линия будет тонкой,
               // а в конце - 20
               this.lineStyle(20 - 19 * i / 100, RGB, 100, true, "none", "round", "round", 1);

               // непосредственно рисуем линию до текущей точки
               this.lineTo(pointArray[i].pointX, pointArray[i].pointY);

               // а теперь немного сместим координаты уже отрисованной точки от центра
               // коэффициент 1.03 регулирует скорость "полета"
               // (предупреждая упреки неиспользования переменной скажу - мне было впадло :)
               pointArray[i].pointX = 1.03 * (pointArray[i].pointX - centerX) + centerX;
               pointArray[i].pointY = 1.03 * (pointArray[i].pointY - centerY) + centerY;
       }

       // теперь удаляем координаты первой точки
       pointArray.shift();
       // и добавляем в конец массива координаты курсора
       pointArray.push({pointX:_xmouse, pointY:_ymouse}); }

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

var Molnia:MovieClip = new MovieClip;
var timer1:Timer = new Timer(Math.random()*3000 + 2000, 1);
timer1.addEventListener("timer", onTimer1);
timer1.start();


function onTimer1(event:TimerEvent):void {
    molnia();
    var timer2:Timer = new Timer(500, 1);
    timer2.addEventListener("timer", onTimer2);
    timer2.start();
    var timer1:Timer = new Timer(Math.random()*6000 + 2000, 1);
    timer1.addEventListener("timer", onTimer1);
    timer1.start();
}


function molnia():void {
    var startX:Array = new Array;                         //координаты старта
    var startY:Array = new Array;                         //
    var conX:Array = new Array;                            //координаты финиша
    var conY:Array = new Array;                            //
    var col:Number = 10;                                       //кол-во возможных ветвей молнии
    var pix:Number = 1;                                         //ширина пера
    var width_:Number = 10;                                 //длина единичного отрезка
    var curveQuant:Number = 20;                         //количество изгибов
    var dlt:Number = 15;                                       //максимальное отклонение при изгибе
    var remX:Array = new Array;;                        //промежуточные начальные значения участка ломаной
    var remY:Array = new Array;;                        //
    var remX0:Number;
    var i:int;                                                          //счетчики
    var j:int;
///////////  начальные значения для переменных  ////////////
//задаем х из которого будет расти молния
startX[0] = Math.random()*800;       //800 - это ширина мувиклипа Molnia_mc
startY[0] = 0;
for (j = 1; j <= col-1; j++) {            //обнуляем массивы
startX[j] = startX[0];
startY[j] = startY[0];
}
remX = startX;
remY = startY;

///////////   рисуем молнию      ////////////////
    Molnia.graphics.lineStyle(pix, 0xFFFFFF); // настройка параметров линии которой будем рисовать
    for(i = 1; i <= curveQuant; i++){        //по коленам
        for (j = 1; j <= col; j++) {        //по веткам
            if (j == 1) {                    //основная ветвь
                conX[0] = remX[0] + (Math.random()*dlt - dlt/2);
                conY[0] = remY[0] + (width_- Math.random()*dlt/4);
                Molnia.graphics.moveTo(remX[0], remY[0]);   // ставим перо
                Molnia.graphics.lineTo(conX[0], conY[0]);     //рисуем черту
                addChild(Molnia);                 // добавляем на экран
                remX0 = remX[0];
                remX[0] = conX[0];
                remY[0] = conY[0];
            } else {
                var q:Number = Math.random()*i;
                if ((q < (i / curveQuant)) || (remX0 !== remX[j-1])) {        //для ответвившейся части
                    conX[j-1] = remX[j-1] + (Math.random()*dlt - dlt/2);      //задаем конечную точку рисования черты
                    conY[j-1] = remY[j-1] + (width_- Math.random()*dlt/4);
                } else {                                                    //для не ответвившейся
                    conX[j-1] = conX[0];
                    conY[j-1] = conY[0];
                }
                Molnia.graphics.moveTo(remX[j-1], remY[j-1]);   //ставим перо
                Molnia.graphics.lineTo(conX[j-1], conY[j-1]);    //рисуем
                addChild(Molnia);            //отображаем
                remX[j-1] = conX[j-1];
                remY[j-1] = conY[j-1];
            }
        }
    Molnia.filters = [new GlowFilter(0xAAAAFF, 1.0, 6.0, 6.0, 3, 1, false, false)];    //применяем к молнии фильтр
    Nebo_mc.alpha = 100;   //отображаем небо
    }
}


function onTimer2(event:TimerEvent):void {
    Molnia.graphics.clear();
    Nebo_mc.alpha = 0
}

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

<?xml version="1.0" encoding="utf-8"?>
<playlist>
        <url>0.mp3</url>
        <url>1.mp3</url>
</playlist>



var playlist:XML = new XML();                     //создаем объект для работы с нашим плэйлистом XML ...
var loader:URLLoader = new URLLoader();         //этим будем загружать наш XML

var setPosition:int = 0;                         //здесь будем хранить позицию воспроизведения при нажатии паузы и т.п.
var soundObj:Sound = new Sound();                 //наш основной объект для работы
var soundCha:SoundChannel = new SoundChannel(); //позволит управлять каналом воспроизведения
var soundTrans:SoundTransform = new SoundTransform(); //для звука и получания данных для аналийзера
var reqUrl:URLRequest = new URLRequest();         //для загрузки mp3 в объект Sound
this.progress_mc.status_mc.width = 0;             //устанавливаем показатель уровня загрузки в 0
this.progress_mc.progressfill_mc.x = -200;         //и показатель воспроизведения в позицию -200 что будет видется тоже как 0
var loaded:Number = 0;                             //для правильного просчитывания отображения места воспроизведения
var soundBytes:ByteArray = new ByteArray();     //для хранения данных о звуке
var arrayUrl:Array = new Array();                  //массив для адресов mp3
var array:Array = new Array();                  //для хранения преобразованных данных о звуке
var volumeP:Number = 1;                         //для хранения уровня громкости звука
var volumeS:Number = 1;                         //тоже
var track:int = 0;                                 //номер текущего трэка для воспроизведения
var offmark:Boolean = false;                     //для кнопки MUTE


//события и слушатели. основа
function initPlayMp3():void {
    Play_btn.addEventListener(MouseEvent.CLICK, startPlay);             //присвоим реакцию на клик мышки нашим элементам интерфейса
    Pause_btn.addEventListener(MouseEvent.CLICK, stopPlay);
    volume_mc.addEventListener(MouseEvent.CLICK, volumePlay);
    progress_mc.addEventListener(MouseEvent.CLICK, progressPlay);
    offVolume_btn.addEventListener(MouseEvent.CLICK, offvolumePlay);
    onVolume_btn.addEventListener(MouseEvent.CLICK, onvolumePlay);
    Next_btn.addEventListener(MouseEvent.CLICK, nextTrack);
    Prev_btn.addEventListener(MouseEvent.CLICK, prevTrack);
    Stop_btn.addEventListener(MouseEvent.CLICK, fullStop);

    loader.addEventListener(Event.COMPLETE, whenLoaded);         //событие вызовется когда XML фал будет загружен
    loader.load(new URLRequest("playlist.xml"));                 //а это адрес того что будем загружать

    volume_mc.buttonMode = true;                                //определим свойсто для нужных нам клипов что бы при наведении на них курсор менялся на руку
    progress_mc.buttonMode = true;

    offVolume_btn.visible = false;                                //скроем кнопки которые не нужны
    Pause_btn.visible = false;
}

//загрузка xml
function whenLoaded(event:Event):void {            //если загрузка XML прошла успешно то в наш массив с адресами запишем все ее содержимое
    playlist = XML(event.target.data);
    for(var i:int = 0; i< playlist.url.length(); i++) {
         arrayUrl[i] = playlist.url[i].text();
    }
    name_txt.text = "0" + "/" +arrayUrl.length + " Исполнитель - Название Песни";    //и обновим тектовое поле добавив туда информацию о колличестве трэков
}

//Прогресс загрузки
function LoadProgress(event:ProgressEvent):void{
    var loadedsound:Number;
    loadedsound = Math.round(100 * (event.bytesLoaded / event.bytesTotal));     // просчитываем уровень загрузки
    set_txt.text = "Загруженo: " + loadedsound + "%";                             // обновляем значение в тектовом поле
    progress_mc.status_mc.width = loadedsound*2;                                 // и  увеличиваем полоску загрузки в прогресс баре
}

//Следующий трек
function nextTrack(event:MouseEvent):void{             //Запускается когда нажата кнопка СЛЕДУЮЩИЙ ТРЕК
    Play_btn.visible = false;                         // определяем какие кнопки управления должны быть видимыми а какие нет
    Pause_btn.visible = true;
    if((track+1)<arrayUrl.length){                     // определяем на какой трек нам переключаться
         track++;
    } else {
         track = 0;
    }
    try {                                             // пытаемся выполнить стоп и закрытие канала, если канал уже закрыт (загрузка закончилась) то оное вызовет ошибку и выполнение перейдет к catch
         soundCha.stop();
         soundObj.close();
    } catch(e:Error){
         soundCha.stop();                             // просто остановим
    }
    PlaySound();                                    // и запустим воспроизведение нового трека
}

//Предыдущий трек
function prevTrack(event:MouseEvent):void{             //Запускается когда нажата кнопка Предыдущий ТРЕК
    Play_btn.visible = false;                         // определяем какие кнопки управления должны быть видимыми а какие нет
    Pause_btn.visible = true;
    if((track-1)>=0){                     // определяем на какой трек нам переключаться
         track--;
    } else {
         track = arrayUrl.length-1;
    }
    try {                                             // пытаемся выполнить стоп и закрытие канала, если канал уже закрыт (загрузка закончилась) то оное вызовет ошибку и выполнение перейдет к catch
         soundCha.stop();
         soundObj.close();
    } catch(e:Error){
         soundCha.stop();                             // просто остановим
    }
    PlaySound();                                    // и запустим воспроизведение нового трека
}

function fullTrack(event:Event):void{ // определяет новый трэк и переходит к нему
    Play_btn.visible = false;                         // определяем какие кнопки управления должны быть видимыми а какие нет
    Pause_btn.visible = true;
    if((track+1)<arrayUrl.length){
        track++;
    } else {
        track = 0;
    }
    soundCha.stop();
    PlaySound();
}

// полный стоп
function fullStop(event:MouseEvent):void{// останавливает воспроизведение и если звук открыт закрывает загрузку
    setPosition = 0;//позицию воспроизведения в ноль
    try {
        soundCha.stop();
        soundCha = soundObj.play(0);
        soundCha.stop();
        soundObj.close();
    } catch(e:Error){
        soundCha.stop();
        soundCha = soundObj.play(0);
        soundCha.stop();
    }
    Play_btn.visible = true;
    Pause_btn.visible = false;
}

//чтение тэгов
function id3Handler(event:Event):void {
    name_txt.text=(track+1)+"/"+arrayUrl.length+"  "+soundObj.id3.artist + " - " + soundObj.id3.songName;
}

//кнопка ПУСК
function startPlay(event:MouseEvent):void{
    Play_btn.visible = false;
    Pause_btn.visible = true;
    PlaySound(); // запускаем основную функцию воспроизведения звука
}

//Кнопка ПАУЗА
function stopPlay(event:MouseEvent):void{
    setPosition = soundCha.position; // запоминаем позицию воспроизведения
    volumeS = soundTrans.volume; // и уровень звука
    Play_btn.visible = true;
    Pause_btn.visible = false;
    soundCha.stop(); // останавливаем воспроизведение
}

//определение нового места проигрывания
function progressPlay(event:MouseEvent):void{// вызывается когда кликнули на полосе отображающей загрузку и воспроизведение
    volumeS = soundTrans.volume;
    soundCha.stop();
    soundCha = soundObj.play((soundObj.length*loaded) * event.currentTarget.mouseX/200); // определяем координату куда ткнули // и взависимости от этого помещаем точку воспроизведения в нужное нам место
    soundTrans.volume = volumeS;
    soundCha.soundTransform = soundTrans;
    soundCha.addEventListener(Event.SOUND_COMPLETE, fullTrack); // востанавливаем событие реагирующее на конец трэка
    Play_btn.visible = false;
    Pause_btn.visible = true;
}

//установка уровня звука
function volumePlay(event:MouseEvent):void{
    offmark = false;
    volume_mc.volumefill_mc.width = event.currentTarget.mouseX; // определяем куда ткнули и изменяем размер маски
    soundTrans.volume = (event.currentTarget.mouseX*5)/100; // устанавливаем громкость звука
    volumeP = volumeS = soundTrans.volume;
    soundCha.soundTransform = soundTrans;
    offVolume_btn.visible = false;
    onVolume_btn.visible = true;
}

//включение звука
function offvolumePlay(event:MouseEvent):void{
    offmark = false;
    offVolume_btn.visible = false;
    onVolume_btn.visible = true;
    volume_mc.volumefill_mc.width = (volumeP*100)/5;
    soundTrans.volume = volumeP;
    soundCha.soundTransform = soundTrans;
}

//Выключение звука
function onvolumePlay(event:MouseEvent):void{
    offmark = true;
    volumeP = soundTrans.volume;
    offVolume_btn.visible = true;
    onVolume_btn.visible = false;
    volume_mc.volumefill_mc.width = 0;
    soundTrans.volume = 0;
    soundCha.soundTransform = soundTrans;
}

//основная ПУСК функция
function PlaySound():void{ // основная функция которая воспроизводит звук
    reqUrl.url = arrayUrl[track]; // получаем адрес трека
    var nextTitle:Sound = new Sound(reqUrl);// т.к. в один объект два звука не загрузить то мы создаем промежуточный объект загружаем в него а потом просто приравниваем основной к нему загружаем его
    soundObj = nextTitle;

    name_txt.text = (track+1)+"/"+arrayUrl.length+" Не удалось прочитать ID3 тэги"; // делаем стандартную строку (она станется если функция чтения тэгов ее не обновит)
    soundObj.addEventListener(ProgressEvent.PROGRESS, LoadProgress); // создаем слушатель прогреса загрузки
    soundObj.addEventListener(Event.ID3, id3Handler); // и получения тэгов
    addEventListener(Event.ENTER_FRAME, Progress); // и ENTER_FRAME для програсса воспроизведения

    soundCha = soundObj.play(setPosition); // запускаем звук в нужном нам канале с определенной позиции

    soundTrans.volume = volumeS; // устанавливаем кромкость
    soundCha.soundTransform = soundTrans; // и присваиваем ее каналу нужному
    soundCha.addEventListener(Event.SOUND_COMPLETE, fullTrack); // запустит функцию меняющую трэк при достижении конца трэка текущего

    if(offmark){// обработка уровня громкости если включено MUTE
        soundTrans.volume = 0;
        soundCha.soundTransform = soundTrans;
    } else {
     soundTrans.volume = volumeS;
     soundCha.soundTransform = soundTrans;
    }
}

//отображение прогреса воспроизведения
function Progress(event:Event):void {
    loaded = soundObj.bytesTotal/soundObj.bytesLoaded;// просчитываем какую часть мы загрузили это нужно для поправики в отображения прогресса
    progress_mc.progressfill_mc.x = Math.round(200*(soundCha.position/(soundObj.length*loaded)))-200;// двигаем полосу прокресса
    var allsec:int = Math.floor(soundCha.position/1000);// и считаем секунды воспроизведения
    var min:int = Math.floor(allsec/60);//
    var sec:int = allsec-(Math.floor(allsec/60)*60);//
    if(sec<10){
         time_txt.text = String(min)+".0"+String(sec);//формируем текстовую строку с итогами посдчетов
    } else {
         time_txt.text = String(min)+"."+String(sec);//формируем текстовую строку с итогами посдчетов
    }
}

initPlayMp3();