Foi então que resolvi experimentar usar por conta própria o manual do Box2D, que tem um tutorial que, apesar de estar em C/C++, é muito didático. Adaptei o código para o Actionscript 3.0 e funcionou.

Para ver o programa funcionando usei a as3isolib, para geração de gráficos isométricos – a intenção é tornar visível o funcionamento. Porém, você pode usar o próprio trace() do Flash para exibir a posição da caixa que cai sobre um piso e dá uma leve quicada. Mais detalhes sobre o código veja no tutorial do manual.

package{
import flash.display.*;
import flash.events.*;
import Box2D.Dynamics.*;
import Box2D.Collision.*;
import Box2D.Collision.Shapes.*;
import Box2D.Common.Math.*;
import as3isolib.display.primitive.IsoBox;
import as3isolib.display.scene.IsoScene;

public class Main extends Sprite{

public var world:b2World;
public var groundBodyDef, bodyDef:b2BodyDef;
public var body, groundBody:b2Body;
public var groundBox:b2PolygonShape = new b2PolygonShape();
public var dynamicBox:b2PolygonShape = new b2PolygonShape();
public var fixtureDef:b2FixtureDef = new b2FixtureDef();
public var timeStep:Number = Number(1 / 60);
public var velocityIterations:Number = 6;
public var positionIterations:Number = 2;

/*objetos as3isolib - se não quiser baixar a biblioteca você pode usar o trace() para exibir a posição da caixa*/
public var scene:IsoScene = new IsoScene();
public var groundIso:IsoBox = new IsoBox();
public var bodyIso:IsoBox = new IsoBox();

public function Main() {
stage.scaleMode = StageScaleMode.NO_SCALE;

// função que fará tudo se mover
stage.addEventListener(Event.ENTER_FRAME, update);

/* CÓDIGO BOX2D */
// criação do ambiente
world = new b2World(new b2Vec2(0, -10), true);

// criação do chão, onde a caixa irá cair
groundBodyDef = new b2BodyDef();
groundBodyDef.position.Set(250, -50);

// adicionando o corpo ao ambiente
groundBody = world.CreateBody(groundBodyDef);

groundBox.SetAsBox(50, 10);

groundBody.CreateFixture2(groundBox);

// a caixa que cairá
bodyDef = new b2BodyDef();
bodyDef.type = b2Body.b2_dynamicBody;
bodyDef.position.Set(250, 50);

body = world.CreateBody(bodyDef);

dynamicBox.SetAsBox(1, 1);

fixtureDef.shape = dynamicBox;
fixtureDef.density = 1;
fixtureDef.friction = 0.3;
fixtureDef.restitution = 0.1;

body.CreateFixture(fixtureDef);
// -X-

/* CÓDIGO AS3ISOLIB - NÃO ESSENCIAL */
// gráficos do chão
groundIso.setSize(50, 50, 10);

bodyIso.width = 10;
bodyIso.length = 10;
bodyIso.height = 10;

scene.hostContainer = this;
scene.addChild(bodyIso);
scene.addChild(groundIso);
// -X-
}

public function update(evt:Event):void {
// executando a ação física
world.Step(timeStep, velocityIterations, positionIterations);
world.ClearForces();

groundIso.x = groundBody.GetPosition().x;
groundIso.z = groundBody.GetPosition().y;

/* CÓDIGO AS3ISOLIB - NÃO ESSENCIAL */
bodyIso.x = body.GetPosition().x;
bodyIso.z = body.GetPosition().y;

scene.render();
// -x-
}
}
}

Algumas bibliotecas oferecem esse recurso, como o CASALib. No entanto basta um código simples para isso. A seguir, segue um exemplo em que são mostradas num campo de texto as teclas que estão sendo pressionadas num momento. No campo de texto será exibido os valores keyCode (a representação da tecla em número da tabela ASCII) das teclas.

// campo de texto informativo
var output:TextField = new TextField();

// as teclas pressionadas
var arr_teclas:Array = new Array();

// listeners que detectarão o pressionamento de teclas
stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDown);
stage.addEventListener(KeyboardEvent.KEY_UP, keyUp);

// tamanho do texto e adicionando ao stage
output.text = "Teclas pressionadas: ";
output.scaleY = output.scaleX = 2;
output.width = 300;
addChild(output);

function keyDown(evt:KeyboardEvent):void {
	/* se não houver nenhuma tecla na array que
	 * corresponda à tecla pressionada,
	 * adiciona a atual à array */

	if (arr_teclas.indexOf(evt.keyCode) < 0) {
		arr_teclas.push(evt.keyCode);
	}

	// exibe as teclas pressionadas atualmente
	output.text = "Teclas pressionadas: " + arr_teclas.join();
}

function keyUp(evt:KeyboardEvent):void {
	/* Se a tecla deixou de ser pressionada,
	 * busca ela na array e a remove */

	if (arr_teclas.indexOf(evt.keyCode) >= 0) {
		arr_teclas = arr_teclas.splice(0, arr_teclas.indexOf(evt.keyCode));
	}

	// exibe as teclas pressionadas atualmente
	output.text = "Teclas pressionadas: " + arr_teclas.join();
}

Veja o resultado a seguir, pressionando teclas (dê foco ao SWF clicando no quadro abaixo):

No entanto, até que não é muito complicado criar efeitos simples usando bibliotecas como a TweenMax. Com uma quantidade enxuta de linhas é possível fazer efeitos interessantes.

A seguir, posto um exemplo bem simples, mas que serve para ilustrar que usar métodos e métodos para controle de tempo e criação de efeitos são desnecessários usando TweenMax:

package
{
	import flash.display.*;
	import flash.events.*;
	import com.greensock.*; 

	/**
	 * ...
	 * @author Francisco Prado
	 */
	public class Main extends MovieClip
	{
		private var volume:int = 0;
		private var particulas:Array = new Array();

		public function Main():void
		{
			// inicia (ou desenha mais) "partículas"
			desenharParticula();
		}

		private function desenharParticula():void {
			var mc:MovieClip = new MovieClip();
			mc.graphics.beginFill(Math.round(Math.random()*0x6666ff));
			mc.graphics.drawCircle(0, 0, 5);
			mc.graphics.endFill();

			mc.x = 200;
			mc.y = 300;

			addChild(mc);

			// fazendo as "partículas" subirem e desaparecerem
			TweenMax.to(mc, Math.random() + 1,
			{ bezier: [
			{ x: mc.x, y: mc.y },
			{ x: (Math.random() * 50) + mc.x, y: 250 },
			{ x: (Math.random() * -50) + mc.x, y: 180 },
			{ x: mc.x, y: 80 }],
			orientToBezier:true, blurFilter: { blurX: 10, blurY: 10 }, alpha: 0, motionBlur:true,
			onComplete: function removendo():void {
					removeChild(mc);
					mc = null;
				}
			});

			// chama o método para adicionar novas partículas à cena
			TweenMax.to(this, 0, { delay: 0.05, onComplete: desenharParticula } );
		}
	}
}

O código fará o efeito seguinte:

A ideia aqui não é mostrar necessariamente como fazer um sistema bonitinho de particulas, mas sim demonstrar que com uma linha do TweenMax é possível fazer um método para tempo e efeitos de cores e luz.

Usando ActionScript “puro” seria necessário apelar para uma variável Timer, uma outra linha para iniciar a contagem e uma função para manipular eventos no AS (TimerEvent).

Já com uma linha (no caso, a 48 do exemplo anterior) do TweenMax é possível fazer uma contagem (usando a propriedade de atraso delay) é possível fazer todas as coisas: o tempo e a chamada da função (no atributo onComplete é chamado o método que adicionará mais partículas).

A mesma situação na linha que fazem as partículas subirem e sumirem. Com o parâmetro bezier da TweenMax é possível fazer animações em curvas. Você pode conhecer mais efeitos testando nesta página, na seção Plugins.

Enfim, com um punhado de linhas é possível fazer efeitos bem interessantes, dispensando assim volumosos códigos chatos para caramba.

Acredito que, em se trantando de Flash – largamente utilizado na publicidade -, quanto menos linhas de código melhor, pois os prazos nem sempre são generosos (geralmente tudo é “pra ontem” ) e eficiência é sempre fundamental.

Ainda não tive condições de experimentar, mas pelos exemplos ela é uma mão na roda para gerar efeitos sofisticados de uma maneira bem simples. No site dela você encontra exemplos e tutoriais.

Utilizar este plugin, em detrimento de uma biblioteca mais específica, pode ser útil quando se está habituado a usar jQuery. No site oficial do projeto jQuery SVG você encontra diversos exemplos úteis.

Existe a documentação da biblioteca, no site, onde você encontra, bem organizadamente, métodos e atributos para utilizar a biblioteca.

Experimentei um pouco a biblioteca. Para testes, você deve baixar os arquivos Javascript específicos e direcionar corretamente a localização nas pastas de acordo com o seu computador. A seguir, um exemplo, em que baixei do site e modifiquei, adicionando um retângulo que responde aos cliques do mouse (repare nos parâmetros – entre chaves – a chamada do método alert).

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
 "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8">
<title>jQuery SVG - o Básico</title>
<style type="text/css">
@import "css/jquery.svg.css";

#svgbasics { width: 400px; height: 300px; border: 1px solid #484; }
</style>
<script type="text/javascript" src="js/jquery-1.3.2.js"></script>
<script type="text/javascript" src="js/jquery.svg.js"></script>
<script type="text/javascript">
 $(function() {
 // Ao ser carregado, chamará a função draw...
 $('#svgbasics').svg({onLoad: draw});
 });

 function draw (svg) {
 // Desenhando um círculo...
 svg.circle(75, 75, 50, {fill: 'none', stroke: 'red', 'stroke-width': 3});

 // Criando um grupo com duas linhas...
 var g = svg.group({stroke: 'black', 'stroke-width': 2});
 svg.line(g, 15, 75, 135, 75);
 svg.line(g, 75, 15, 75, 135);

 // Desenhando um retângulo que, quando clicado, chama o método alert
 svg.rect(g, 150, 100, 200, 100, 10, 10,
 {fill: 'yellow', stroke: 'navy', strokeWidth: 5, onclick:"alert('Você clicou!')"});
 }

</script>
</head>
<body>
 <h1>jQuery SVG - O Básico</h1>
 <p>Página de exemplo</p>
 <div id="svgbasics"></div>
</body>
</html>

A biblioteca AS3 SVG Renderer suporta boa parte dos recursos oferecidos pela linguagem SVG. Criada por um brasileiro (veja o blog), ela ainda não suporta o carregamento de arquivos de imagem (como JPEG, PNG, etc., um recurso disponível no SVG), o que não chega a atrapalhar em nada (haja vista que é possível carregar Bitmaps usando classes nativas do ActionScript). Muitos outros recursos estão disponíveis (desenhos de formas, linhas, transformações como rotação e inclinação, entre outros).

O uso da biblioteca é muito simples: basta carregar o arquivo como se fosse um XML, usando o package do ActionScript. O programa Adobe Flash torna-se dispensável.

O exemplo a seguir carrega e exibe um SVG carregado a partir de uma URL qualquer.

[actionscript3]
package
{
import flash.display.MovieClip;
import flash.display.Sprite;

// A biblioteca AS3 SVG RENDERER
import com.lorentz.SVG.*;

import flash.events.Event;

import flash.net.URLLoader;
import flash.net.URLRequest;

/**
* …
* @author FRANCISCO PRADO
*/
public class Main extends Sprite
{
public var mc:MovieClip = new MovieClip();

public function Main() {
// Carregador da figura
var loader:URLLoader = new URLLoader();
loader.addEventListener(Event.COMPLETE, onComplete);

// Iniciando o carregamento
loader.load(new URLRequest("URL do arquivo.svg"));

addChild(mc);
}

public function onComplete(evt:Event):void {
var shp:Sprite;
var svg:XML = new XML(evt.target.data);

// Renderizará o arquivo SVG
shp = new SVGRenderer(svg);

// Adiciona ao movieclip
mc.addChild(shp);
}
}
}
[/actionscript3]

Programas

FlashDevelop – não conheço todas as IDEs para ActionScript, mas acredito que esta seja uma das melhores – senão a melhor. Ela automaticamente importa os packages de classes que você instancia, seu auto-complete é poderosíssimo, além de ser leve e permitir a compilação usando o Flex SDK (para configurar isso veja este tutorial).

Funciona em Windows (não sei se há versão para Mac, e não acredito que rode/possa rodar em Linux, uma vez que ele foi criado sobre o Microsoft .NET Framework – tentei emular e não deu certo).

Ambientes de Desenvolvimento para ActionScript – aqui segue uma lista com outros programas (e seus links) para programar em ActionScript.

Flex SDK – necessário ter caso queira compilar seus programas via FlashDevelop, entre outros. É opensource.

Tutoriais

Wikilivro em português – wikilivro sobre AS 3.0 hospedado no Wikilivros (da Wikipédia).

Tutorial do Mário Santos (em PDF) – parte 1 e parte 2 – talvez os mais populares tutoriais sobre AS 3.0 em português (de Portugal) da Web.

Bibliotecas

Você pode ver uma postagem minha antiga sobre algumas bibliotecas. Há sobre bibliotecas 3D apenas. Aqui vou indicar mais algumas bibliotecas que talvez não sejam tão conhecidas.

AS3ISOlib – biblioteca para geração de gráficos isométricos. A biblioteca é bem fácil de se usar e bem interessante. Ela foi feita para ser usada com o Adobe Flash apenas. Porém, mudando algumas propriedades de umas classes consegui fazer ela ser usada com o FlashDevelop (em outras palavras, mudei os objetos Vector, disponíveis apenas nos Adobe Flash CSx para Array, fácil. ).

JigLibFlash – engine para simulação de física em 3D. Ela é ligada para fazer simulação usando em conjunto a biblioteca Papervision 3D, estritamente – mas há “plugins” para se utilizá-la em conjunto com Away3D, Sandy3D e outras.

O problema dela é esse: você não pode usá-la livremente (sem estar em conjunto com uma biblioteca 3D – você tem que estar atrelado a uma…). Os autores escreveram no blog deles que ainda pretendem mudar a arquitetura da biblioteca a fim de torná-la utilizável por qualquer outro modo – o que é uma boa notícia.

WOW 3D – outra engine de física em 3D. É baseada na APE, uma outra engine porém 2D. Esta aqui usa em conjunto a biblioteca Sandy3D para geração de gráficos 3D, apenas.

Estou sem postagem séria no momento e não rascunhei nada. Mas esses artigos, ainda a serem completados, já contêm bastante coteúdo.

O artigo sobre campos de texto já tem quase tudo a respeito sobre o assunto, com exceção ao uso de formatação com HTML e CSS (a ser inserido).

O sobre XML, mais completo, ainda não tem conteúdo a respeito da remoção e inserção de elementos e envio de dados. De todo resto, está completo.

O endereço do wikilivro é este aqui: http://pt.wikibooks.org/wiki/ActionScript

Mas há um artigo destinado ao uso de campos de texto (campos de senhas, input etc.) inserido (e incompleto ainda) lá.

Há outros artigos que tiveram pequenos acréscimos, dêem uma olhada lá. Até a próxima.

• ActionScript CheatSheet: parece ser muito bom: reúne várias cheatsheets (listas/dicionários com dicas de comandos e propriedades) sobre ActionScript, Papervision 3D (biblioteca para geração de 3D), AIR e outros. A seção de downloads das folhas está aqui. Dica: baixem o segundo PDF, tem várias funções relativas à datas, arrays, tipos de erros, etc.
• 30 grandes bibliotecas para AS 3: postagem reunindo links para várias bibliotecas de código aberto, de gêneros variados: física, desenvolvimento de games, 3D… Recomendo uma visita.
• Bibliotecas de física para AS 3: postagem que cita diferenças entre as bibliotecas disponíveis para simulação de física.
• Flash 3D – Edutech (em inglês): artigo numa wiki em que reúne comentários e links a respeito de vários tipos de bibliotecas para uso de física e 3D em Flash/ActionScript.
• Sandy 3D: eu sei, existe a Papervision3D para geração de gráficos 3D com AS e é muito mais popular. No entanto, esta biblioteca parece ser muito interessante, pois eles disponibilizam tutoriais muito bons (em inglês) e passo-a-passo (procuro material organizado sobre Papervision3D na web e não encontro). Ainda não experimentei, mas fica a dica.
• Away3D: outra biblioteca 3D. Tem tutoriais e uma wiki a respeito. Conheço nada do projeto mas como deve haver entusiastas deixo o link aqui.
• Tutorial do Mário Santos (em PDF) – parte 1 e parte 2: uma apostila bem rica e interessante. Em português de Portugal. Aliás, nosso amigo lusitano mantém um blog a respeito da linha Adobe (Flex, Flash etc). Ele também posta tutoriais sobre AS, porém mais dirigido à plataforma Flex. Li a parte 1 e recomendo.
• Blog do Erick Souza: blog do ituano Erick Souza, com ênfase em Flash. Tutoriais, dicas e notícias.

E claro, o Wikilivro de AS 3. É o wikilivro sobre AS hospedado no Wikibooks em português. Como estou revisando a linguagem (estudei ela há um bom tempo) vou inserindo as informações nele. Já há bastantes tópicos. A galera tem gostado e tudo, mas seria interessante que, se possível, colaborasse, mesmo com simples revisões/testes ou acréscimos.

A ideia por trás do livro em formato wiki é que qualquer um pode colaborar e acrescentar, o que pode gerar um livro em constante expansão e atualização, além de gratuito, para temas como este (linguagens de programação).

O wikilivro é promissor? Talvez. Pelo jeito vai ter um único colaborador: eu ! Mas é esperar para ver. Afinal só existe há cerca de 20 dias…

Caso tenha links para sugerir, insira nos comentários, que atualizarei a postagem.