Код AS3:

Call.nextFrame(func, ...args) //Вызываем функцию func передавая ей параметры args
Call.forget(func) //Отменить вызов функции

Код AS3:

Music.playSound("http://domain.com/sound.mp3").volume(56); //Фоновая музыка - только один поток
Music.playUI(ClickSound) //Проигрывание кнопочек

Код AS3:

Tween.bounce(this, time, onTweenComplete).x(100).easeFunctionArgument(from, to);

Код AS3:

this.filters = [ColorFilter.hue(180).alpha(0.5).tint(0.5, 0xffffff)];

Код AS3:

addChild(WebLoader.crossBitmap("http://vk.com/empty.png").center(100,200);

Код AS3:

Server.json(data:*, path, handler)

Код AS3:

MixFilter.add(this, "highlightarget", filter);
MixFilter.remove(this, "highlightarget");

Код AS3:

ObjectEvent.addEventListener(this, MouseEvent.CLICK, onClick);
ObjectEvent.removeAllListeners(this);
ObjectEvent.bubble(this,"complete") //Всплывающее событие (plain - обычное)

Код AS3:

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
        xmlns:s="library://ns.adobe.com/flex/spark"
        xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600">
    <fx:Declarations>
        <!-- Place non-visual elements (e.g., services, value objects) here -->
    </fx:Declarations>
</s:Application>

Код AS3:

<?xml version="1.0" encoding="utf-8"?>
<mx:Sprite xmlns:fx="http://ns.adobe.com/mxml/2009"
        xmlns:mx="library://ns.adobe.com/flex/mx"
        addedToStage="init();"
        >
    <fx:Declarations>
        <fx:Number id="property" />
    </fx:Declarations>
 
    <fx:Script><![CDATA[
        public function init():void {
            trace("init");
	    property = 10;
        }
    ]]>
    </fx:Script>
    <mx:Sprite id="child" addedToStage="trace('child added');" />
</mx:Sprite>

Код AS3:

<mx:Sprite id="child" addedToStage="trace('child added');" />

Код AS3:

<?xml version="1.0" encoding="utf-8"?>
<mx:Sprite xmlns:fx="http://ns.adobe.com/mxml/2009"
        xmlns:mx="library://ns.adobe.com/flex/mx"
        addedToStage="init();"
        >
    <fx:Declarations>
        <fx:Number id="property" />
        <mx:Sprite id="child" addedToStage="trace('child added');" />
    </fx:Declarations>
 
    <fx:Script><![CDATA[
        public function init():void {
            trace("init");
	    property = 10;
            addChild(child);
        }
    ]]>
    </fx:Script>    
</mx:Sprite>

Код AS3:

class BindableProperty
{
	/*
	 * generated bindable wrapper for property child (public)
	 * - generated setter
	 * - generated getter
	 * - original public var 'child' moved to '_94631196child'
	 */
 
    [Bindable(event="propertyChange")]
    public function get child():flash.display.Sprite
    {
        return this._94631196child;
    }
 
    public function set child(value:flash.display.Sprite):void
    {
    	var oldValue:Object = this._94631196child;
        if (oldValue !== value)
        {
            this._94631196child = value;
           if (this.hasEventListener("propertyChange"))
               this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "child", oldValue, value));
        }
    }
 
	/*
	 * generated bindable wrapper for property property (public)
	 * - generated setter
	 * - generated getter
	 * - original public var 'property' moved to '_993141291property'
	 */
 
    [Bindable(event="propertyChange")]
    public function get property():Number
    {
        return this._993141291property;
    }
 
    public function set property(value:Number):void
    {
    	var oldValue:Object = this._993141291property;
        if (oldValue !== value)
        {
            this._993141291property = value;
           if (this.hasEventListener("propertyChange"))
               this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "property", oldValue, value));
        }
    }
 
}

Код AS3:

 public class no_flex_mxml extends flash.display.Sprite {
        [Bindable]
        public var child:flash.display.Sprite;
 
        [Inspectable]
        [Bindable]
        public var property:Number;
 
        //  constructor (non-Flex display object)
        public function no_flex_mxml() {
            super();
 
            _no_flex_mxml_Sprite2_i();
 
            // events
            this.addEventListener("addedToStage", ___no_flex_mxml_Sprite1_addedToStage);
        }
 
 
        //  scripts
        //  <Script>, line 11 - 17 - 
		// Это скрипт который я написал в блоке fx:Script
        public function init():void {
            trace("init");
            property = 10;
            addChild(child);
        }
 
        //	supporting function definitions for properties, events, styles, effects
        private function _no_flex_mxml_Sprite2_i():flash.display.Sprite {
            var temp:flash.display.Sprite = new flash.display.Sprite();
            temp.addEventListener("addedToStage", __child_addedToStage);
            child = temp;
            mx.binding.BindingManager.executeBindings(this, "child", child);
            return temp;
        }
 
 
        public function __child_addedToStage(event:flash.events.Event):void {
            trace('child added');
        }
 
        public function ___no_flex_mxml_Sprite1_addedToStage(event:flash.events.Event):void {
            init();
        }
    }
 
}

Код AS3:

public class no_flex_mxml extends flash.display.Sprite
    {
        public function no_flex_mxml() {}
 
        [Bindable]
        public var property : Number;
        [Bindable]
        public var child : flash.display.Sprite;
 
        mx_internal var _bindings : Array;
        mx_internal var _watchers : Array;
        mx_internal var _bindingsByDestination : Object;
        mx_internal var _bindingsBeginWithWord : Object;
 
        include "C:/dev/workspace/no_flex_mxml/src/no_flex_mxml.mxml:11,17";
 
    }}

Код AS3:

public class Car{ 
    private var engine:IEngine = new Engine(); 
}

Код AS3:

======= IEngine.as ========
public interface IEngine {}
 
======= Engine.as ========
public class Engine implements IEngine {
	public function Engine(){
		trace('engine constructed');
	}
}
 
======= Car.as ========
public class Car {
 
	[Inject]
	public var engine:IEngine;
 
	public function start():void{
		if(engine) trace('it works');
	}
}
 
======= Main.as ========
import flash.display.Sprite;
import org.swiftsuspenders.Injector;
 
public class Main extends Sprite{
	public function Main(){
		var car:Car = new Car();
		var injector:Injector = new Injector();
		injector.map(IEngine).toType(Engine);
		injector.injectInto(car);  // engine constructed
		car.start();  //it works
	}
}

Код AS3:

var animationCache:AnimationCache = AnimationCache.getInstance();
animationCache.addToBulkCache(XML(new animationList()));
 
//*****************************************
var anim:Animation = animationCache.getAnimation("animName");
anim.addEventListener(Event.COMPLETE, onDied);
this.addChild(anim);
anim.gotoAndPlayRandomFrame();

Код AS3:

package com.earwig.animationcache
{
	import flash.events.EventDispatcher;
	import flash.utils.setTimeout;
 
	/**
	 * Класс кеширует векторные анимации в растр.
	 */
	public class AnimationCache extends EventDispatcher
	{
		public var replaceExisting:Boolean = false;
 
		private var animations:Object = {};
 
		private static var instance:AnimationCache;
 
		//=====================================================================
		// CONSTRUCTOR
		//=====================================================================
		public function AnimationCache() 
		{
			if(instance) throw(new Error("AnimationCache is a Singleton. Dont Instantiate!"));
			instance = this;
		}	
 
		//=====================================================================
		// PUBLIC
		//=====================================================================
		/**
		 * Выдает инстанс библиотеки
		 * @return
		 */
		public static function getInstance():AnimationCache
		{
			return instance ? instance : new AnimationCache();
		}
 
		/**
		 * Кеширует анимацию с заданным именем класса мувика и скейлом
		 * (растровые тайлы будут уже указанного размера)
		 * @param	id
		 * @param	scaleX
		 * @param	scaleY
		 * @return
		 */
		public function cacheAnimation(id:String, scaleX:Number, scaleY:Number):Animation
		{
			// TODO придумать что-то чтобы можно было кешировать одну и ту же анимацию с разными скейлами
			var animation:Animation
			if (!animations[id] || replaceExisting)
			{
				animation = new Animation();
				animation.buildCacheFromLibrary(id, scaleX, scaleY);
				animations[id] = animation;
			} 
			else 
			{
				animation = animations[id]
			}
 
			return animation;
		}
 
		/**
		 * Выдает копию анимации из библиотеки с указанным именем
		 * @param	id
		 * @return
		 */
		public function getAnimation(id:String):Animation
		{
			if (!animations[id]) 
			{
				trace("MISSING ANIMATION :"+ id);
				return null;
			}
 
			var animation:Animation = new Animation();
			animation.frames = animations[id].frames;
			animation.clip = animations[id].clip;
			animation.gotoAndPlay(1);
 
			return animation;
		}
 
		/**
		 * Кеширует список анимаций пакетом
		 * @param	list список анимаций в формате XML. 
		 * 	<data>
		 * 		<anim name="className" scaleX="0.5" scaleY="0.5" />
		 * 	</data>
		 */
		public function addToBulkCache(list:XML):void
		{
			for each(var anim:XML in list.anim)
			{
				cacheAnimation(anim.@name, parseFloat(anim.@scaleX) || 1, parseFloat(anim.@scaleY) || 1);
				//TODO добавить диспатчи событий о прогрессе при групповой загрузке
			}
		}
	}
}

Код AS3:

package com.earwig.animationcache 
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.geom.Matrix;
	import flash.geom.Rectangle;
	import flash.utils.getDefinitionByName;
 
	public class Animation extends Sprite
	{
		private var _bitmap:Bitmap;
		private var _clip:MovieClip;
		private var _frames:Vector.<AnimationFrame>;
		private var _currentFrame:Number = 1;
		private var _playing:Boolean = false;
 
		private var _id:String;
		private var _scaleX:Number;
		private var _scaleY:Number;
 
		//=====================================================================
		// CONSTRUCTOR
		//=====================================================================
		public function Animation() 
		{
			_bitmap = new Bitmap(null, "auto", true);
			_bitmap.smoothing = true;
			addChild(_bitmap);
			_frames = new Vector.<AnimationFrame>();
		}
 
		//=====================================================================
		// CONSTRUCTOR
		//=====================================================================
		/**
		 * Делает анимаци из класса загруженной флешки
		 * @param	params
		 */
		public function buildCacheFromLibrary(name:String = "", scaleX:Number = 1, scaleY:Number = 1):void
		{
			_id = name;
			_scaleX = scaleX;
			_scaleY = scaleY;
 
			_clip = new (getDefinitionByName(_id))();
			_clip.gotoAndStop(1)
 
			var r:Rectangle;
 
			for (var i:int = 0; i < _clip.totalFrames; i++)
			{
				r = _clip.getBounds(_clip);
 
				var bitmapData:BitmapData = new BitmapData(r.width, r.height, true, 0x000000);
				var m:Matrix = new Matrix();
				m.scale(_scaleX, _scaleY);
				m.translate(-r.x, -r.y);
				bitmapData.draw(_clip, m, null, null, null, true);
 
				_frames.push(new AnimationFrame(bitmapData, r.x, r.y));
 
				_clip.nextFrame();
				makeAllChildrenNextFrame(_clip);
			}
		}
 
		/**
		 * Проигрывает анимацию циклически
		 */
		public function play():void
		{
			_playing = true;
			addEventListener(Event.ENTER_FRAME, enterFrame, false, 0, true);
		}
 
		/**
		 * Стоп анимации 
		 */
		public function stop():void
		{
			_playing = false;
			removeEventListener(Event.ENTER_FRAME, enterFrame)
		}
 
		/**
		 * Переход к кадру и остановка
		 * @param	frame
		 */
		public function gotoAndStop(frame:int):void
		{
			goto(frame);
			stop();
		}
 
		/**
		 * Переход к кадру и проигрывание
		 * @param	frame
		 */
		public function gotoAndPlay(frame:int):void
		{
			goto(frame);
			play();
		}
 
		/**
		 * Переход к случайному кадру и проигрывание
		 */
		public function gotoAndPlayRandomFrame():void
		{
			gotoAndPlay(int(Math.random() * totalFrames));
		}
 
		/**
		 * Переход на след кадр
		 * @param	useSpeed
		 */
		public function nextFrame():void
		{
			goto(_currentFrame + 1);
		}
 
		/**
		 * Переход на предыдущий кадр
		 */
		public function prevFrame():void
		{
			goto(_currentFrame - 1);
		}
 
		/**
		 * Перезаполняет содержимое кеша заново.
		 */
		public function update():void
		{
			stop();
			_frames = new Vector.<AnimationFrame>();
			buildCacheFromLibrary();
		}
 
		//=====================================================================
		// PRIVATE
		//=====================================================================
		/**
		 * Переход к кадру
		 * @param	frame
		 */
		private function goto(num:int):void
		{
			if (num > totalFrames) num = num % totalFrames; //num - (totalFrames * int(num / totalFrames));
			if (!num) num = totalFrames;
 
			_currentFrame = num;
 
			var frame:AnimationFrame = _frames[_currentFrame - 1];
			_bitmap.bitmapData = frame.bitmapData;
			_bitmap.smoothing = true;
 
			_bitmap.x = frame.x;
			_bitmap.y = frame.y;
		}
 
		/**
		 * Проходит по всем детям и прокручивает на кадр с указанным номером, 
		 * нужно в процессе кеширования. Утилитная функция.
		 * @param	m
		 * @param	f
		 */
		private function makeAllChildrenNextFrame(m:MovieClip):void
		{
			for (var i:int = 0; i < m.numChildren; i++) 
			{
				var c:* = m.getChildAt(i);
				if (c is MovieClip) 
				{
					makeAllChildrenNextFrame(c);
					c.nextFrame();
				}
			}
		}
 
		//=====================================================================
		// HANDLERS
		//=====================================================================
		/**
		 * Без комментариев (;
		 * @param	e
		 */
		private function enterFrame(e:Event = null):void
		{
			nextFrame();
 
			if (_currentFrame >= totalFrames) 
				dispatchEvent(new Event(Event.COMPLETE))
		}
		//=====================================================================
		// ACCESSORS
		//=====================================================================
		/** Проигрывается ли флешка в данный момент */
		public function get playing():Boolean { return _playing; }
 
		/** Полное кол-во кадров */
		public function get totalFrames():int { return _frames.length; }
 
		/** Текущий кадр */
		public function get currentFrame():int {	return _currentFrame; }
 
		/** Масив(вектор) фреймов, нужен для клонирования */
		internal function get frames():Vector.<AnimationFrame> { return _frames; }
		internal function set frames(value:Vector.<AnimationFrame>):void { _frames = value; }
 
		/** исходный мувиклип, нужен для клонирования */
		internal function get clip():MovieClip { return _clip; }
		internal function set clip(value:MovieClip):void { _clip = value; }
 
 
	}
}

Код AS3:

package com.earwig.animationcache 
{
	import flash.display.BitmapData;
	/**
	 * ...
	 * @author Dukobpa3
	 */
	public class AnimationFrame 
	{
 
		private var _bitmapData:BitmapData;
		private var _x:int;
		private var _y:int;
 
		public function AnimationFrame(bmpd:BitmapData, x:int,y:int) 
		{
			_bitmapData = bmpd;
			_x = x;
			_y = y;
		}
 
		internal function get bitmapData():BitmapData 
		{
			return _bitmapData;
		}
 
		internal function get x():int 
		{
			return _x;
		}
 
		internal function get y():int 
		{
			return _y;
		}
 
	}
 
}

Код AS3:

//задаем координаты и цвет вершин
var vertices:Vector.<Number> = Vector.<Number>([
				//x    y	z	r	g	b
				0, 	0, 	1, 	1,	0, 	0,
				1, 	0, 	1, 	0,	1, 	0,
				0, 	1, 	1, 	0,	0, 	1
			]);
//пишем шейдеры
var vertexShader:String = 
			'mov op va0\n' +
			'mov v0 vt0';
var fragmentShader:String = 
			'mov oc, v0';

Код AS3:

m44 op va0 vc0

Код AS3:

//координаты
var vertices:Vector.<Number> = Vector.<Number>([
				//x	y	z	w
				0, 	0, 	600, 	1,
				200, 	0, 	600, 	1,
				200, 	200, 	600, 	1,
				0, 	200,	600, 	1
			]);
 
//вершинный шейдер
var vertexShader:String = 
			'm44 op va0 vc0';
 
//проекционная матрица
perspectiveMatrix.perspectiveOffCenterLH(-400, 400, 300, -300, 400, 1000);

Код AS3:

var v:Vector3D = new Vector3D(200, 200, 600, 1);
v = _perspectiveMatrix.transformVector(v); //вот тут кстати мы матрицу умножаем на вектор, а не наоборот - как в шейдере, поэтому трансопзить матрицу не нужно
trace(v); //Vector3D(200, -266.66668701171875, 333.3332824707031)
trace(v.w); //600

Код AS3:

v.scaleBy(1 / v.w);
v.w /= v.w
trace(v); //Vector3D(0.33333333333333337, -0.4444444783528646, 0.5555554707845053)
trace(v.w); //1

Код AS3:

var _vertexShader:String = 
			'm44 vt0 va0 vc0\n' +
			'mov op vt0\n' +
			'mov v0 vt0';

Код AS3:

//вершины
var vertices:Vector.<Number> = Vector.<Number>([
				//x	y	z	w
				0, 	0, 	600, 	1,
				200, 	0, 	600, 	1,
				200, 	200, 	600, 	1,
				0, 	200,	600, 	1
			]);
//индексы
var indices:Vector.<uint> = Vector.<uint>([
				0, 1, 3,
				1, 2, 3
 
//проекционная матрица
perspectiveMatrix.perspectiveOffCenterLH(-400, 400, 300, -300, 400, 1000);
			]);
 
//пускай обратная сторона тоже отрисовывается
context3D.setCulling(Context3DTriangleFace.NONE);
 
//шейдеры
private var _vertexShader:String = 
			'm44 vt0 va0 vc0\n' +
			'div vt0 vt0 vt0.wwww\n' +
			'mov op vt0\n' +
			'mov v0 vt0';
 
private var _fragmentShader:String = 
			'sub oc, fc0 v0.zzzz';
 
//отрисовка
function draw(event:Event):void {
 
			matrix.identity();
			_matrix.appendTranslation(0, 0, -600);
			_matrix.appendRotation(getTimer() * 0.05, Vector3D.Y_AXIS);
			_matrix.appendTranslation(stage.mouseX - 400, stage.mouseY - 300, 600);
			_matrix.append(_perspectiveMatrix);
 
			_context3D.setProgramConstantsFromMatrix(Context3DProgramType.VERTEX, 0, _matrix, true);
			_context3D.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT, 0, Vector.<Number>([1, 1, 1, 1]));
 
			_context3D.clear(0, 0, 0, 1);
			_context3D.drawTriangles(_indexBuffer, 0, 2);
			_context3D.present();
}

Код AS3:

package {
	import flash.display.Sprite;
 
	public class Main extends Sprite {
		public function Main():void {
			var test:ConstTest = new ConstTest(15); 
			trace(test.constValue);
			test.setConstValue(10); // some magic :)
			trace(test.constValue);
			test.setConstValue(20);
			trace(test.constValue);
		}
	}
}

Код AS3:

package {
	public class ConstTest extends ConstTestBase {
		private var _construcorMethod:Function;
		private var _inited:Boolean = false;
		private var _tempValue:int = 0;
		public const constValue:int = 0;
 
		public function ConstTest(someParam:int = 0) { // Можем юзать любые параметры. Но обязательно задать значение по умолчанию
			if (!this._inited) {
				super(); //NOTE: ОБЯЗАТЕЛЬНО. иначе компилятор сам добавить вызов конструктора предка выше и он будет вызываться много раз.
				this._construcorMethod = arguments.callee;
				this._inited = true;
				// обычный код коструктора который нам нужен
				trace("ConstTest constructed, param:",someParam);
			}
			else {
				this["constValue"] = this._tempValue; //NOTE: в строгом режиме компиляци явно менять константы нельзя вообще, поэтому перенесём резолвинг в рантайм.
			}
		}
 
		public function setConstValue(value:int):void {
			this._tempValue = value;
			this._construcorMethod();
		}
	}
}

Код AS3:

package {
	public class ConstTestBase {
		public function ConstTestBase() {
			trace("ConstTestBase constructed"); // Это чтоб показать что конструктор предка вызывается корректно
		}
	}
}

Код:

ConstTestBase constructed
ConstTest constructed, param: 15
0
10
20

Код AS3:

stage.scaleMode = StageScaleMode.EXACT_FIT;

Код AS3:

public class SomeTweener {
	private var _obj:Object;
	private var _paramName:String;
	private var _endValue:Number;
	private var _frames:Number;
 
	public function SomeTweener(obj:Object, paramName:String, endValue:Number, frames:Number) {
		_obj = obj;
		_paramName = paramName;
		_endValue = endValue;
		_frames = frames;
	}
}

Код AS3:

import flash.display.Shape;
import flash.events.Event;
import flash.events.IEventDispatcher;
 
public class SomeTweener {
	private var _obj:Object;
	private var _paramName:String;
	private var _endValue:Number;
	private var _frames:Number;
	private var eventDispatcher:IEventDispatcher;
 
	public function SomeTweener(obj:Object, paramName:String, endValue:Number, frames:Number) {
		_obj = obj;
		_paramName = paramName;
		_endValue = endValue;
		_frames = frames;
		eventDispatcher = new Shape();
		eventDispatcher.addEventListener(Event.ENTER_FRAME, tween);
	}
 
	private function tween(e:Event):void {
	}
}

Код AS3:

import flash.display.Shape;
import flash.events.Event;
import flash.events.IEventDispatcher;
 
public class SomeTweener {
	private var _obj:Object;
	private var _paramName:String;
	private var _endValue:Number;
	private var _frames:Number;
	private var eventDispatcher:IEventDispatcher;
	private var increment:Number;
 
	public function SomeTweener(obj:Object, paramName:String, endValue:Number, frames:Number) {
		_obj = obj;
		_paramName = paramName;
		_endValue = endValue;
		_frames = frames;
		increment = (endValue - Number(obj[paramName])/frames;
		eventDispatcher = new Shape();
		eventDispatcher.addEventListener(Event.ENTER_FRAME, tween);
	}
 
	private function tween(e:Event):void {
		if (_frames == 0) {
			e.currentTarget.removeEventListener(e.type, tween);
			return;
		}
		obj[paramName] += increment;
		_frames--;
	}
 
}

Код AS3:

import flash.display.Sprite;
import flash.events.Event;
 
public class SomeClass extends Sprite {
	private var sprite:Sprite;
	public function SomeClass() {
		sprite = new Sprite();
		sprite.x = 1;
		sprite.addEventListener(Event.ENTER_FRAME, traceSome);
		var tween:SomeTweener = new SomeTweener(sprite, 'x', -1, 40);
	}
	private function traceSome(e:Event):void {
		trace(sprite.x);
	}
}

Код AS3:

trace(String(-.35 - .05)) // 0.39(9)97

Код AS3:

import flash.display.Shape;
import flash.events.Event;
import flash.events.IEventDispatcher;
 
public class SomeTweener {
	private var _obj:Object;
	private var _paramName:String;
	private var _endValue:Number;
	private var _frames:Number;
	private var eventDispatcher:IEventDispatcher;
	private var increment:Number;
	private var currentValue:Number;
 
	public function SomeTweener(obj:Object, paramName:String, endValue:Number, frames:Number) {
		_obj = obj;
		_paramName = paramName;
		_endValue = endValue;
		_frames = frames;
		currentValue = Number(obj[paramName]);
		increment = (endValue - Number(obj[paramName])/frames;
		eventDispatcher = new Shape();
		eventDispatcher.addEventListener(Event.ENTER_FRAME, tween);
	}
 
	private function tween(e:Event):void {
		if (_frames == 0) {
			e.currentTarget.removeEventListener(e.type, tween);
			return;
		}
		currentValue += increment;
		obj[paramName] = currentValue;
		_frames--;
	}
 
}