Flash / Examples 6

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


const particleContainer_bolt:Sprite = new Sprite();
addChild(particleContainer_bolt);


function Bolt():void {
    stage.addEventListener(Event.ENTER_FRAME, Particles_bolt);
    var mcParticle_bolt:Boltmc=new Boltmc();
    particleContainer_bolt.addChild(mcParticle_bolt);

    function Particles_bolt(event:Event):void {
        if (Math.random()*10<0.5) {
            mcParticle_bolt.x=Math.random()*stage.stageWidth;
            mcParticle_bolt.y=200;
            mcParticle_bolt.scaleX=Math.random()*1;
            mcParticle_bolt.scaleY=mcParticle_bolt.scaleX;
        }
    }
}
Bolt();

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


//Запускаем таймер. Таймер вызывает функцию timerHandler каждые 0.2 секунды.
var timer:Timer = new Timer(200, 0);
timer.addEventListener (TimerEvent.TIMER, timerHandler);
timer.start ();

//Находим центр сцены
var centerX:Number = stage.stageWidth / 2;
var centerY:Number = stage.stageHeight / 2;

//Описываем функцию, вызываемую таймером
function timerHandler (e:Event):void {

    //Создаем новый квадрат
    var newRectangle:MyRectangle = new MyRectangle();

    //Устанавливаем для квадрата координаты равные координатам мыши
    newRectangle.x = mouseX;
    newRectangle.y = mouseY;

    //Высчитываем положение квадрата по х и у от центра сцены
    var dx:Number = newRectangle.x - centerX;
    var dy:Number = newRectangle.y - centerY;

    //Высчитываем расстояние от квадрата до центра сцены с помощью теоремы Пифагора
    newRectangle.radius = Math.sqrt(dx*dx + dy*dy);

    //Высчитываем угол квадрата относительно центра сцеы
    newRectangle.myAngle = Math.atan2(dy, dx);

    //Устанавливаем скорость поворота
    newRectangle.speed = 0.06;

    //Сначала квадрат должен быть прозрачный
    newRectangle.alpha = 0;

    //Устанавливаем случайные размеры квадрата
    newRectangle.scaleX = Math.random() + 1.5;
    newRectangle.scaleY = newRectangle.scaleX;

//Получаем доступ к смене цвета квадрата с помощью ColorTransform
var colorInfo:ColorTransform = newRectangle.transform.colorTransform;

    // Устанавливаем случайный цветобъекта ColorTransform
    colorInfo.color = 0xffffff * Math.random();

    //Даем получившийся цвет квадрату
    newRectangle.transform.colorTransform = colorInfo;

    //Добавляем квадрат на сцену
    addChild (newRectangle);

    //Добавляем функцию  ENTER_FRAME для анимации вращения
    newRectangle.addEventListener (Event.ENTER_FRAME, moveRectangle);
}

//Эта функция вращает квадраты
function moveRectangle (e:Event):void {

    //Берем квадрат как цель действий
    var rectangle:MovieClip = e.target as MovieClip;

    //Высчитываем новые х и у позиции для квадрата
    var newX:Number = centerX + Math.cos(rectangle.myAngle) * rectangle.radius;
    var newY:Number = centerY + Math.sin(rectangle.myAngle) * rectangle.radius;

    //Увеличиваем угол в следующем кадре
    rectangle.myAngle += rectangle.speed;

    //Задаем новую позицию
    rectangle.x = newX;
    rectangle.y = newY;

    //Уменьшаем радиус, то бы получить спиральную анимацию
    rectangle.radius -= 0.6;

    //Уменьшаем размер
    rectangle.scaleX -= rectangle.radius * 0.0001;
    rectangle.scaleY -= rectangle.radius * 0.0001;

    //Увеличиваем непрозрачность, если она меньше 1 и радиус больше 50
    if (rectangle.alpha < 1 && rectangle.radius > 50) {
        rectangle.alpha += 0.05;
    }
    //Увеличиваем прозрачность если радиус меньше 50
    if (rectangle.radius < 50) {
        rectangle.alpha -= 0.005;
    }

    //Если радиус меньше 0 удаляем квадрат
    if (rectangle.radius < 0) {
        rectangle.removeEventListener (Event.ENTER_FRAME, moveRectangle);
        removeChild (rectangle);
    }
}

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


package {
    import flash.display.Sprite;
    import flash.utils.Timer;
    import flash.events.TimerEvent;

    public class Fireworks extends Sprite {
        //Таймер, который каждые пол секунды будет создавать фейерверк
        private var _timer:Timer = new Timer(500,2000);

        public function Fireworks() {
            _timer.addEventListener(TimerEvent.TIMER, createFirework);
            _timer.start();
        }

        private function createFirework(event:TimerEvent):void {
            //Создаем экземпляр фейерверка и задаем ему нужные координаты
            var firework:Firework = new Firework();
            firework.y = 220;
            firework.x = Math.random() * stage.stageWidth;
            addChild(firework);
        }
    }
}


package {
    import flash.utils.Timer;
    import flash.events.TimerEvent;
    import flash.display.Sprite;
    import flash.events.Event;

    public class Firework extends Sprite {
        //Скорость фейерверка по оси Y
        private var _speedY:Number = 0;
        private var _timer:Timer = null;

        public function Firework() {
            _speedY = (-1) * Math.random() * 1 - 1;
            //Рисуем - белый круг
            this.graphics.beginFill(0xFFFFFF);
            this.graphics.drawCircle(0, 0, 2);
            this.graphics.endFill();
            launch();
        }

        //Запускает анимацию
        private function launch():void {
            this.addEventListener(Event.ENTER_FRAME, update);
            //Создаем таймер на 2 секунды
            _timer = new Timer(2000,1);
            _timer.start();
            _timer.addEventListener(TimerEvent.TIMER_COMPLETE, explode);
        }

        //Движет белый круг вверх по оси Y
        private function update(event:Event):void {
            this.y +=  _speedY;
        }

        //Создает анимацию взрыва
        private function explode(event:TimerEvent):void {
            removeEventListener(Event.ENTER_FRAME, update);
            var explosion:Explosion = new Explosion();
            explosion.x = this.x;
            explosion.y = this.y;
            stage.addChild(explosion);
            this.visible = false;
        }
    }
}


package {

    import flash.utils.Timer;
    import flash.events.TimerEvent;
    import flash.display.Sprite;
    import flash.events.*;
    import fl.motion.Color;
    import flash.geom.ColorTransform;

    public class Explosion extends Sprite {
        //Массив, в котором будут хранится частицы данного взрыва
        private var _particles:Array = null;
        //Переменная, хранящая число частиц
        private var _number:uint = 0;

        public function Explosion() {
            //Создаем новый массив
            _particles = [];
            //Задаем число частиц
            _number = Math.floor(Math.random() * 30) + 10;
            //Задаем цвет
            var ct:Color = new Color();
            ct.setTint(0xFFFFFF * Math.random(),1);
            //Задаем масштаб
            var scale:Number = Math.random();
            //Вычисляем углы
            var angleDifference:Number = 360 / _number;
            var angle = 0;
            //Цикл, в котором создается каждая частица взрыва
            for (var i = 0; i < _number; i++) {
                var particle:Particle = new Particle();
                //Задаем скорость
                particle._speedY = Math.sin(angle * Math.PI / 180) * 3;
                particle._speedX = Math.cos(angle * Math.PI / 180) * 3;
                //Применяем масштаб к частице, изменяя ее размер
                particle.scaleX = scale;
                particle.scaleY = scale;
                _particles.push(particle);
                //Применяем цвет;
                particle.transform.colorTransform = ct;
                addChild(particle);
                //Обновляем угол для следующей частицы
                angle +=  angleDifference;
            }
            addEventListener(Event.ENTER_FRAME, update);
        }

        //Обновляет положение и вид частиц в каждом кадре
        private function update(event:Event):void {
            for (var i = 0; i < _particles.length; i++) {
                var particle:Particle = _particles[i];
                particle.y +=  particle._speedY;
                particle.x +=  particle._speedX;
                particle.alpha -=  0.02;
                //если прозрачность частицы меньше -0.1 - удаляем ее
                if (particle.alpha < -0.1) {
                    removeEventListener(Event.ENTER_FRAME, update);
                    removeChild(particle);
                    particle.clear();
                    particle = null;
                }
            }
        }
    }
}


package {
    import flash.display.Shape;

    public class Particle extends Shape {
        //Переменные, отвечающие за скорость частицы
        public var _speedY:Number = 0;
        public var _speedX:Number = 0;

        public function Particle() {
            //В конструкторе рисуем изображение частицы
            this.graphics.beginFill(0xFFFFFF);
            this.graphics.drawCircle(0,0,4);
            this.graphics.endFill();
        }

        //Очищает изображение частицы и "обнуляет" ее параметры
        public function clear():void {
            this.graphics.clear();
            _speedY = NaN;
            _speedX = NaN;
        }
    }
}

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


Mouse.hide();//прячем курсор
var a:Number;//катет
var b:Number;//катет
var c:Number;// гипотенуза
var lightPower:Number=5;//сила света
var lightArea:Number=30;//территория света
stage.addEventListener(MouseEvent.MOUSE_MOVE, shadowMove);

function shadowMove(e:MouseEvent):void {
                light.x=mouseX; //устанавливаем координату Х источника света равной Х координате мыщи
                light.y=mouseY;//тот же процесс, только с координатой Y
                // $$$ Находим координаты тени, противоположные коордиатам мыщи, относительно text_mc
                shadow_mc.y = text_mc.y-(mouseY-text_mc.y)/lightPower;
                shadow_mc.x = text_mc.x-(mouseX-text_mc.x)/lightPower;
                //$$$
//Геометричесие расчеты
                b=text_mc.x-mouseX;//Находим кактет b
                a=text_mc.y-mouseY;//Находим какте a
                c= Math.sqrt((A*A)+(B*B));//Находим гипотенузу c
                shadow_mc.alpha =(lightArea/C);//Устанавливаем прозрачность тени, в зависимости от положения мыши
//Обновляем после каждого движения мыши
                e.updateAfterEvent();
}

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

particle._visible = false;
for (z = 0; z < 200; z++) {
var dupe = particle.duplicateMovieClip("s" + z, z);
dupe._x = Math.random() * 550; dupe._y = Math.random() * 200;
dupe._xscale = dupe._yscale = Math.random() * 50 + 50;
dupe._rotation = Math.random() * 360;
dupe._alpha = Math.random() * 100;
dupe.gotoAndStop(int(Math.random() * dupe._totalframes + 1));
}

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


<site>
<links>
<link name="Home"/>
<link name="Works"/>
<link name="About"/>
<link name="Contact"/>
</links>
</site>


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

//Путь до XML файла.
//Вы можете прописать любой путь.
var xmlPath:String = "menu.xml";

//Данные из XML будут помещены в эту переменную после загрузки.
var settingsXML:XML;

//Массив для твин анимаций нужен для того,
//чтобы сборщик мусора не удалял анимации в самое неподходящее время.
var tweensArray:Array = new Array();
//Твин анимации кнопки.
var buttonTween:Tween;

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


//Эта функция вызывается, когда XML файл загружен.
function xmlLoaded(e:Event):void
{
 //Проверяем, не равен ли наш загружчик null.
 if ((e.target as URLLoader) != null )
 {
 //Помещаем данные XML файла в переменную.
 settingsXML = new XML(loader.data);
 settingsXML.ignoreWhitespace = true;
 //Вызываем функцию создания меню.
 createMenu();
 }
}


function createMenu():void
{
 //Локальная переменная для экземпляра класса MenuItem.
 var menuItem:MenuItem;
 //Счетчик.
 var i:uint = 0;

 //Цикл по пунктам links, найденых в XML файле.
 for each (var link:XML in settingsXML.links.link)
 {

 menuItem = new MenuItem();

 //Вставка названия кнопки меню. (link.@name читает атребут "name" в элементе link)
 menuItem.menuLabel.text = link. @ name;

 //Если текст больше, чем текстовое поле, то выравниваем размер.
 menuItem.menuLabel.autoSize = TextFieldAutoSize.LEFT;

 //Помещаем кнопку меню на сцену.
 menuItem.x = 20;
 menuItem.y = 30 + i * 40;

 //Активируем крсор над кнопкой. Отключаем у текстового поля кнопки реакцию на мышь.
 menuItem.buttonMode = true;
 menuItem.mouseChildren = false;

 //Назначаем слушатели событий.
 menuItem.addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
 menuItem.addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);

 addChild(menuItem);

 //Считаем количество кнопок.
 i++;
 }
}

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


/*
Главный класс Main.as.

Создает таймер и по таймеру создает пузырьки в координатах, зависимых от положения мыши.
*/

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

 public class Main extends Sprite
 {
 //Переменная для таймера.
 private var timer:Timer;

 //Конструктор главного класса.
 public function Main()
 {
 //Создаем экземпляр класса Таймер.
 timer = new Timer(50, 0);
 //Назначаем слушатель события тика таймера.
 timer.addEventListener(TimerEvent.TIMER, InTimer);
 //Запускаем таймер.
 timer.start();
 }

 //Функция, которая срабатывает по тику таймера.
 private function InTimer(e:TimerEvent):void
 {
 //Создаем пузырек.
 var c:Circle = new Circle(stage);
 }
 }
}


/*
Класс пузырька.

Класс рисует пузырек, добавляет его в список отображения и удаляет по событию.
*/

package
{
 //Необходимые импорты.
 import flash.display.Sprite;
 import flash.display.Stage;
 import flash.display.GradientType;
 import flash.geom.Matrix;
 import flash.filters.BlurFilter;
 import fl.transitions.Tween;
 import fl.transitions.easing.Strong;
 import fl.transitions.TweenEvent;

 public class Circle extends Sprite
 {
 //Контейнер Stage, к которому в список отображения будут добавляться пузырек.
 private var container:Stage;
 //Переменные для будущих твин анимаций.
 private var scaleXTween:Tween;
 private var scaleYTween:Tween;
 private var gravityTween:Tween;
 //Константа разброса пузырьков.
 private const delay:uint = 50;

 //Конструктор.
 public function Circle(c:Stage)
 {
 //Кладем в переменную контейнера переданый stage.
 container = c;
 //Добавляем пузырек в список отображения.
 container.addChild(this);
 //Создаем пузырек.
 CreateCircle();
 }

 private function CreateCircle():void
 {
 //Задаем фильтр размытия для красоты. :)
 var blur:BlurFilter = new BlurFilter(1.5,1.5,3);
 //Задаем рандомный цвет пузырька в диапазоне от синего до зеленого.
 var color:uint = Math.random() * 0x0000ff + 0x00ff00;
 //Задаем радиус пузырька.
 var radius:Number = Math.random() * 10 + 10;
 //Задаем матрицу для последующей заливки градиентом.
 var matrix:Matrix = new Matrix();
 //Преобразуем матрицу в соответстующий необходимый вид.
 matrix.createGradientBox(2 * radius, 2 * radius, 0, (- radius - radius/2), (- radius - radius/2));

 /*
 Рисуем пузырек
 */
 //Задаем градиентный фон заливки.
 this.graphics.beginGradientFill(GradientType.RADIAL,[0xffffff, color],[0.8, 0.3],[0, 200], matrix);
 //Задаем стиль линий.
 this.graphics.lineStyle(1, (color - 0x222222));
 //Рисуем круг.
 this.graphics.drawCircle(0,0,radius);
 //Конец рисования.
 this.graphics.endFill();
 //Назначаем фильтр размытия.
 this.filters = [blur];

 //Задаем координаты пузырька.
 this.x = mouseX + Math.random() * delay - delay / 2;
 this.y = mouseY + Math.random() * delay - delay / 2;
 //Анимируем появление пузырька.
 scaleXTween = new Tween(this,"scaleX",Strong.easeOut,0.5,1,1,true);
 scaleYTween = new Tween(this,"scaleY",Strong.easeOut,0.5,1,1,true);
 //Анимируем падение пузырька.
 gravityTween = new Tween(this,"y",Strong.easeIn,this.y,this.y+480,7,true);
 //Назначаем слушатель на событие завершения анимации падения.
 gravityTween.addEventListener(TweenEvent.MOTION_FINISH, Delete);
 }

 //Функция вызывается после завершения анимации падения пузырька и удаляет пузырек из списка отображения stage.
 private function Delete(e:TweenEvent):void
 {
 container.removeChild(this);
 /*
 После удаления из списка отображения больше не остается ссылок на экземпляр класса. Поэтому сборщик мусора прекрасно удаляет этот экземпляр из памяти.
 */
 }
 }
}

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


/*
Это главный класс. Его имя должно быть прописано в свойствах *.fla файла.
Класс добавляет на сцену некоторе количество бочек.
По клику по одной из бочек можно запустить цепную реакцию.
Для перезарядки бочек можно нажать пробел.
*/

package
{
//Импорт необходимых классов.
import flash.display.MovieClip;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.media.Sound;

public class Main extends MovieClip
{
//Массив, в котором будут храниться бочки.
private var bochkaArray:Array = [];
//Массив, в котором будут храниться осколки.
private var splintersArray:Array = [];
//Количество выставляемых бочек.
private var numberOfBochka:uint = 15;
//Звук взрыва из библиотеки.
private var explosionSound:Sound = new ExplosionSound();

//Конструктор.
public function Main()


{
//Расставляем несколько бочек на сцене.
CreateFildOfBochka(numberOfBochka);
//Назначаем слушатель события смены кадра.
stage.addEventListener(Event.ENTER_FRAME, Update);
//Назначаем слушатель события на нажатие клавиш.
stage.addEventListener(KeyboardEvent.KEY_DOWN, Reload);
}

//Функция проигрывания звука взрыва.
public function PlayExplosionSound():void
{
//Запускаем звук взрыва.
explosionSound.play();
}

//Функция создания нескольких бочек на сцене.
private function CreateFildOfBochka(numberOfBochka:uint):void
{
//Цикл.
for (var i:uint = 0; i < numberOfBochka; i++)
{
//Создаем экземпляр бочки.
var bochka:Bochka = new Bochka(stage,this);
//Добавляем в массив бочек.
bochkaArray.push(bochka);
}
}

//Функция добавления новых бочек. Функция срабатывает, когда нажимается какая-либо клавиша.
private function Reload(e:KeyboardEvent):void
{
//Узнаем, какая клавиша была нажата.
switch (e.keyCode)
{
//Если нажата клавиша "ПРОБЕЛ".
case 32 :
//Цикл по массиву бочек.
for (var j:uint = 0; j < bochkaArray.length; j++)
{
//Удаляем старые бочки.
stage.removeChild(bochkaArray[j]);
}

//Очищаем массив бочек.
bochkaArray = [];
//Создаем новые бочки.
CreateFildOfBochka(numberOfBochka);
//Завершение условия.
break;
}
}

//Функция добавления в массив осколков нового осколка.
public function PushNewSplinter(s:Splinter):void
{
//Добавляем в массив новый осколок.
splintersArray.push(s);
}

//Проверка попадания осколка в бочку.
private function CheckColisions(s:Splinter):void
{
//Цикл по массиву бочек.
for(var i:uint = 0; i < bochkaArray.length; i++)
{
//Помещаем бочку из массива в локальную переменную для удобства.
var b:Bochka = bochkaArray[i];
//Определяем расстояние от осколка до бочки.
var distance:Number = Math.sqrt(Math.pow((s.x - b.x),2) + Math.pow((s.y - b.y),2));

//Если осколок от бочки на расстоянии меньше, чем половина высоты бочки, то рапускаем реакцию нагрева бочки.
if(distance < b.height/2)
{
//Имитируем клик по бочке, так как функция клика у бочки как раз и запускает нагрев.
b.Click();
}
//Если клип бочки доиграл анимацию взрыва, то удаляем бочку.
if(b.currentLabel == "deleting")
{
//Удаляем из списка отображения.
b.Delete();
//Удаляем из массива.
bochkaArray.splice(i,1);
//По идее, ссылок на этот экземпляр класса бочки больше нет, поэтому сборщик мусора очистит память.
}
}
}

//Эта функция запускается каждый кадр и обновляет необходимые данные.
private function Update(e:Event):void
{
//Цикл по массиву осколков.
for (var i:uint = 0; i < splintersArray.length; i++)
{
//Помещаем осколок из массива в локальную переменную для удобства.
var s:Splinter = splintersArray[i];
//Обновляем данные осколка (Анимируем его перемещение).
s.Update();
//Проверяем столкновение с бочками.
CheckColisions(s);
//Проверяем вылет за экран. Если осколок улетел за экран, то удаляем его.
if (s.x < 0 || s.x > 640 || s.y < 0 || s.y > 480)
{
//Удаляем осколок из списка отображения.
s.Delete();
//Удаляем осколок из массива осколков.
splintersArray.splice(i, 1);
//По идее, ссылок на этот осколок больше нет. Поэтому сборщик мусора должен очистить память.
}
}
//Выводим на экран количество бочек и осколков в данный момент.
 //trace_txt.text = String(bochkaArray.length +" || "+ splintersArray.length);
}
}
}



/*
Класс бочки.

Бочка взрывается и создает осколки.
*/

package
{
 //Импорты необходимых классов.
 import flash.display.MovieClip;
 import flash.display.Stage;
 import flash.events.MouseEvent;
 import fl.transitions.Tween;
 import fl.transitions.easing.Strong;
 import fl.transitions.TweenEvent;

 public class Bochka extends MovieClip
 {
 /*
 labels:
 1 - "stay"
 2 - "explosion"
 14 - "deleting"

 movieclips:
 bochkaHot_mc
 */

 //Контейнер для stage.
 private var container:Stage;
 //Контейнер для главного класса.
 private var main:Main;
 //Количество осколков у бочки.
 private var numberOfSplinters:uint = Math.floor(Math.random() * 6) + 10;
 //Переменная для твинанимации нагревания бочки.
 private var heatingTween:Tween;
 //Время нагревания бочки в секундах.
 private var timer:Number = 1;
 //Флаг взрыва бочки.
 private var inBoom:Boolean = false;

 //Конструктор.
 public function Bochka(c:Stage, m:Main)
 {
 //Скрываем картинку нагретой бочки, которая будет позже плавно появляться и имитировать нагрев бочки.
 bochkaHot_mc.alpha = 0;
 //Добавляем главный класс в контейнер.
 main = m;
 //Добавляем stage в контейнер.
 container = c;
 //Добавляем бочку в список отображения.
 container.addChild(this);
 //Задаем рандомные бочки координаты на сцене.
 this.x = (Math.random() * 590)+ 25;
 this.y = (Math.random() * 410) + 60;
 //Назначаем слушатель на событие клика по бочке.
 this.addEventListener(MouseEvent.CLICK, Click);
 }

 //Функция клика по бочке.
 public function Click(e:MouseEvent = null):void
 {
 //Если бочка еще не взорвалась, то...
 if (! inBoom)
 {
 //Помечаем, что бочка уже взорвана.
 inBoom = true;
 //Анимируем нагрев бочки.
 heatingTween = new Tween(this.bochkaHot_mc,"alpha",Strong.easeOut,0,1,timer,true);
 //Назначаем слушатель на событие завершения анимации нагрева бочки.
 heatingTween.addEventListener(TweenEvent.MOTION_FINISH, Explosion);
 //Удаляем слушатель на клик по бочке - он больше не нужен.
 this.removeEventListener(MouseEvent.CLICK, Click);
 }
 }

 //Функция взрыва бочки после полного нагрева.
 private function Explosion(e:TweenEvent):void
 {
 //Запускам звук взрыва.
 main.PlayExplosionSound();
 //Запускаем анимацию взрыва.
 this.gotoAndPlay("explosion");
 //Цикл по количеству осколков.
 for (var i:uint = 0; i < numberOfSplinters; i++)
 {
 //Создаем новый осколок.
 var splinter:Splinter = new Splinter(container,[this.x,this.y + 20]);
 //Помешаем осколок в массив осколков в главном классе.
 main.PushNewSplinter(splinter);
 }
 //Удаляем слушатель завершения анимации нагрева.
 heatingTween.removeEventListener(TweenEvent.MOTION_FINISH, Explosion);
 }

 //Функция удаления бочки из списка отображения контейнера stage.
 public function Delete():void
 {
 container.removeChild(this);
 }
 }
}


/*
Класс осколков.
*/

package
{
 //Импорт необходимых классов.
 import flash.display.MovieClip;
 import flash.display.Stage;

 public class Splinter extends MovieClip
 {
 //Контейнер для stage.
 private var container:Stage;
 //Скорость осколка по х и у.
 private var speedXY:Array = [Math.random()*5 + 0.1,Math.random()*5 + 0.1];

 //Конструктор.
 public function Splinter(c:Stage, coords:Array)
 {
 //Помешаем осколок в нужные координаты, которые берутся относительно конкретной бочки.
 this.x = coords[0];
 this.y = coords[1];
 //Добавляем stage в контейнер.
 container = c;
 //Добавляем осколок в список отображения.
 container.addChild(this);

 //Рандомно изменяем знак скорости по осям, чтобы осколки летели не только вправо и вниз, но и влево и вверх.
 if(Math.random()*1 < 0.5)
 {
 speedXY[0] = -speedXY[0];
 }
 if(Math.random()*1 < 0.5)
 {
 speedXY[1] = -speedXY[1];
 }
 }

 //Функция удаления из списка отображения контейнера.
 public function Delete():void
 {
 container.removeChild(this);
 }

 //Функция одновления данных.
 public function Update():void
 {
 //Анимируем перемещение осколка в зависимости от скоростей.
 this.x += speedXY[0];
 this.y += speedXY[1];
 }
 }
}