Semana passada pedi ajuda ao meus amigos “flasheiros” para escrever esse post pedi indicações de livros sobre Flash, imediatamente tive a resposta da galera, só eu que demorei para postar mais aqui vai a dica dos TOP 5 :

André Fontenelle
Twitter : @alfont

ActionScript 3.0 CookBook - É um livro muito didático, especialmente indicado para quem está no nível intermediário de ActionScript. Ele aborda muitos assuntos, servindo até como uma bíblia de ActionScript.

André Ponce
Site Pessoal: andreponce.com
Twitter: @andreponce

Foundation Actionscript 3.0 Animation: Making Things Move -  Livro muito bom pra quem quer desenvolver tecnicas de animacão dinâmica combinando simples recursos do actionscript a eficientes fórmulas matemáticas. Certamente vai lhe ajudar a economizar tempo quando você se deparar com a necessidade em desenvolver logicas e algoritimos mais elaborados.

Breno Claizoni
Site Pessoal: brenoclaizoni.com/blog
Twitter: @brenoocs

Essential ActionScript 3, O’Reilly – Fundamental pra quem quer migrar ou quer começar a programar em ActionScript, mostra desde o básico até os mais avançados exemplos em AS3, como a linguagem funciona, etc. Como o próprio nome do Livro diz, é Essencial!

Neto Leal
Site Pessoal: netoleal.com.br
Twitter: @netoleal

Advanced ActionScript 3 with Design Patterns – by Joey Lott and Danny Patterson – Aplica em ActionScript 3 conceitos avançados e conhecidos dos principais design patterns. Uma grande lição de organização de grandes projetos, reutilização e otimização de código além de ser uma grande fonte de absorção de experiência já que seus autores são pessoas absolutamente competentes nos conceitos demonstrados. Leitura obrigatória para qualquer profissional que deseja se desenvolver em programação orientada a objetos.

Ricardo Teixeira
Twitter : @ricardoteix
ActionScript 3.0 Cookbook, O’Reilly (DE NOVO) - Principalmente para quem quer iniciar em AS3 ou amplicar os conceitos. Apresenta de forma bem clara e com linguagem simples como funciona a estrutura da linguagem, a DisplayList etc. Seria um pré-requisito para a dica do Neto Leal (Advanced ActionScript 3 with Design Patterns).

Fellyph Cintra(Eu)
Twitter:  @fellyph

ActionScript 3.0 Game Programming University – Um livro número um para quem quer entrar no mundo dos games, noções de trigonometria e física ele tem uma evolução no assunto muito legal.

Então galera esse é o meu top 5, claro que existem outros livros muito bons, mas notem que todos os livros indicados são em inglês, na minha a opinião a ideia está crua de acordo com escritor e na maioria das vezes os gringos trantam dos lançamentos primeiro, o livro quando passa por tradução tem que ter um cuidado muito grande para não distorcer a idéia inicial, isso onde alguns livros traduzidos pecam.

Agradeço a galera que participou no post. valeu mesmo galera !!!

E ae galera qual é o seu TOP 5?

Deixe seu comentário…

No Post anterior começamos a falar sobre materiais em papervision, paramos em materiais que trabalham com bitmap, neste post iremos continuar a abordagem sobre o assunto começando por materiais que utilizam MovieClip. Grande vantagem de se trabalhar com a textura em movieclip, é que podemos aproveitar toda a interatividade do do movieClip, animação e transparência podem ser aplicados na textura. Existem dois tipos de materiais que trabalham com movieclip o MovieAssetMaterial e o MovieMaterial.

MovieAssetMaterial
Carrega o movieClip através do linkageID do movieClip na biblioteca esse recurso é utilizado com o Flash CS3 ou superior, por já ter mostrado no post anterior sobre materiais como incluir o linkageID então não vou repetir o passo-a-passo, link para o post anterior. As principais propriedades que o MovieAssetMaterial trabalha são :

• linkageID:String, o nome no linkage do movieclip
• transparent:Boolean, define se o material vai ter transparência ou não (true ou false)
• animated:Boolean, define se o material vai ser animado (true ou false)

Então vamos ao código :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

package  {
 
	/**
	* ...
	* @author Fellyph Cintra
	*/
 
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import org.papervision3d.materials.MovieAssetMaterial;
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	import org.papervision3d.objects.primitives.Plane;
	import flash.events.Event;
 
	import flash.events.Event;
 
	public class MainMateriaisMovieAsset extends Sprite{
 
		private var _viewport 		:Viewport3D;
		private var _cena 			:Scene3D;
		private var _camera 		:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
		private var plano			:Plane;
		private var plano2			:Plane;
		private var material  		:MovieAssetMaterial;
 
		public function MainMateriaisMovieAsset() {
 
			//criamos nosso Viewport3D
			_viewport = new Viewport3D(450 , 300 , false, true);
			addChild(_viewport);
 
			_cena = new Scene3D();
			_camera = new Camera3D();
			_renderizador = new BasicRenderEngine();
 
			// com o movie material trabalhamos com as seguintes propriedades
			//(linkageId, transparência um valor Booleano , se a textura vai ser animada um valor também Booleano)
			material = new MovieAssetMaterial("face",true,true);
 
			//nesse exemplo eu vou trabalhar com dois planos
			// para dar a impressão de um plano com dupla face
			plano = new Plane(material, 300,300, 8, 8);
			plano2 = new Plane(material, 300, 300, 8, 8);
 
			//no segundo plano um rotação de 180 para fica no sentido oposta ao primeiro plano
			plano2.rotationY -= 180;
 
			//adicionamos nossos 2 planos na Scene3D _cena
			_cena.addChild(plano);
			_cena.addChild(plano2);
 
			//aplicamos um onEnterFrame para rotacionar os objetos
			addEventListener(Event.ENTER_FRAME, onRender);
 
		}
 
		public function onRender(e:Event):void {
			plano.rotationY += 3;
			plano2.rotationY += 3;
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
	}
 
}

Como podemos ver para burlar a falta de planos de dupla face nessa versão do papervision criamos dois planos em sentidos contrários. então temos o seguinte resultado :

MovieMaterial

Este tipo de material trabalha com Objetos do tipo DisplayObject criados em tempo de execução, ou seja podemos trabalhar com MovieClips e Sprites, é bem parecido com o material anterior , mas o objeto primitivo que vamos trabalhar dessa vez é o cubo(Cube), vamos ao código :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

package  {
 
	/**
	* ...
	* @author Fellyph Cintra
	*/
 
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.materials.MovieMaterial;
	import org.papervision3d.materials.utils.MaterialsList;
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	import org.papervision3d.objects.primitives.Cube;
	import flash.events.Event;
	import Formas;
	import flash.events.Event;
 
	public class MainMateriaisMovie extends Sprite{
 
		private var _viewport 		:Viewport3D;
		private var _cena 			:Scene3D;
		private var _camera 		:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
 
		//Nesse Exemplo vou trabalhar com um objeto cubo
		private var cubo			:Cube;
		private var material  		:MovieMaterial;
 
		// Para trabalhar com o MovieMaterial eu vou criar
		//uma classe que extends de Sprite que eu criei em um tutorial anterior
		private var movieForma		:Formas;
		private var materialList 	:MaterialsList;
 
		// Criamos mais dois materiais para diversificar mais os materiais
		//na montagem do cubo
		private var corAmarela		:ColorMaterial;
		private var corAzul			:ColorMaterial;
 
		public function MainMateriaisMovie() {
 
			//Criamos nosso Viewport3D
			_viewport = new Viewport3D(450 , 300 , false, true);
			addChild(_viewport);
 
			_cena = new Scene3D();
			_camera = new Camera3D();
			_renderizador = new BasicRenderEngine();
 
			// Estou inicializando meu objeto movieForma
			movieForma = new Formas();
 
			// Com o movie material trabalhamos com as seguintes propriedades
			//(o nosso movie que é um displayObject ou seja pode ser um movieclip, Sprite ou shape,
			//transparência um valor Booleano , se a textura vai ser animada um valor também Booleano)
			material = new MovieMaterial(movieForma,false,false);
			corAzul = new ColorMaterial(0x00027F);
			corAmarela = new ColorMaterial(0xFCFF00);
 
			// criamos um materialList para montar nosso cubo
			materialList = new MaterialsList( { front:material,back:material,left:corAmarela,right:corAmarela,top:corAzul,bottom:corAzul } )
 
			cubo = new Cube(materialList,330,50,240, 6,6,6);
 
			//adicionamos nosso cubo na Scene3D _cena
			_cena.addChild(cubo);
 
			addEventListener(Event.ENTER_FRAME, onRender);
 
		}
 
		public function onRender(e:Event):void {
			cubo.rotationY += 1;
			cubo.rotationZ += 1;
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
	}
 
}

Nesse exemplo trabalhamos com a classe Formas que extends de Sprite, essa classe foi criada em um tutorial anterior link para o tutorial, ela possui o seguinte código :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package {
 
	import flash.display.Shape;
	import flash.display.Sprite;
 
	/**
	* ...
	* @author Fellyph Cintra
	*/
	public class Formas extends Sprite {
		public var bola		:Shape;
		public var rect 	:Shape;
		public var rect2 	:Shape;
 
		public function Formas() {
 
			criaRect();
			criaLosango();
			criaBola();
 
		}
 
		public function criaRect():void {
			rect = new Shape();
			rect.graphics.beginFill(0x008300);
			rect.graphics.lineStyle(1, 0x008300);
			rect.graphics.drawRect(0,0,330,240);
			addChild(rect);
		}
 
		public function criaLosango():void {
 
			rect2 = new Shape();
			rect2.graphics.beginFill(0xFCFF00);
			rect2.graphics.lineStyle(1, 0xFCFF00);
			rect2.graphics.moveTo( 165, 10);
			rect2.graphics.lineTo( 310, 120);
			rect2.graphics.lineTo( 165, 230);
			rect2.graphics.lineTo( 20, 120);
			rect2.graphics.lineTo( 165, 10);
			rect2.graphics.endFill();
			addChild(rect2);
 
		}
 
		public function criaBola():void {
 
			bola = new Shape();
			bola.graphics.beginFill(0x00027F);
			bola.graphics.lineStyle(1, 0x00027F);
			bola.graphics.drawCircle(165, 120, 70);
			bola.graphics.endFill();
			addChild(bola);
		}
 
	}
 
}

O resultado que temos é o seguinte :

Anteriormente tinha previsto o post sobre materiais dividido em dois, mas será necessário um terceiro post sobre o assunto, então pessoal até o próximo post sobre materiais.

Olá pessoal nesse post vamos falar sobre materiais em papervision ( texturas ), parece simples mas o papervision têm uma gama de materiais muito boa, basicamente são divididos em materiais simples , bitmap, movieclip e vídeos. A classe mais básicas onde todos estendem é a classe MaterialObject3D ela contém os métodos mais básicos da família dos materiais. Nos posts anteriores sobre papervision começamos com wireframeMaterial, é o tipo mais simples formados por linhas entre os segmentos. Para trabalhar com  wireframeMaterial utilizamos as seguintes propriedades:

• lineColor : cor da linha RGB
• lineAlpha : alpha da linha de 0..1
• lineThickness : espessura da linha

package  {
 
	/**
	* ...
	* @author Fellyph Cintra
        * www.fellyph.com/blog/
	*/
 
	import flash.display.Sprite;
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	import org.papervision3d.objects.primitives.Sphere;
 
	import org.papervision3d.materials.WireframeMaterial;
 
	public class MainMateriaisWire extends Sprite{
 
		private var _viewport 		:Viewport3D;
		private var _cena 		:Scene3D;
		private var _camera 		:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
 
		private var esfera			:Sphere;
 
		private var material  		:WireframeMaterial;
 
 		public function MainMateriaisWire() {
 
			//criamos nosso Viewport3D
			_viewport = new Viewport3D(450 , 300 , false, true);
			addChild(_viewport);
 
			_cena = new Scene3D();
			_camera = new Camera3D();
			_renderizador = new BasicRenderEngine();
 
			// criamos um novo material e passamos como parâmetro(cor , alpha , espessura da linha)
			material = new WireframeMaterial(0x004400, 0.8, 3);
 
			esfera = new Sphere(material, 80, 8, 8);
 
			//adicionamos nossa esfera na Scene3D _cena
			_cena.addChild(esfera);
 
			// por fim renderizamos a _cena junto com a _camera e o _viewport
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
 
	}
 
}

Não comentei as primeiras linhas por que esse assunto já foi tratado em posts anteriores, se ainda não viu aqui está o link :

Tutorial PaperVision 3D 2.0

Papervison 3D – Objects Primitive

Com código acima temos o seguinte resultado:

ColorMaterial

Diferente do wireFrame material ele cobre toda a área do objeto.

Suas propriedades são :

• fillColor : cor do preenchimento em RGB
• fillAlpha : alpha do preenchimento 0..1

package  {
 
	import flash.display.Sprite;
	import org.papervision3d.core.math.Sphere3D;
 
	/**
	* ...
	* @author Fellyph Cintra
	*/
 
	import flash.display.Sprite;
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	import org.papervision3d.objects.primitives.Sphere;
 
	import org.papervision3d.materials.ColorMaterial;
 
	public class MainMateriaisColor extends Sprite{
 
		private var _viewport 		:Viewport3D;
		private var _cena 		:Scene3D;
		private var _camera 		:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
		private var esfera			:Sphere;
		private var material  		:ColorMaterial;
 
 		public function MainMateriaisColor() {
 
			//criamos nosso Viewport3D
			_viewport = new Viewport3D(450 , 300 , false, true);
			addChild(_viewport);
 
			_cena = new Scene3D();
			_camera = new Camera3D();
			_renderizador = new BasicRenderEngine();
 
			// criamos um novo material e passamos como parâmetro(cor , alpha )
			material = new ColorMaterial(0x004400, 0.8);
 
			esfera = new Sphere(material, 80, 8, 8);
 
			//adicionamos nossa esfera na Scene3D _cena
			_cena.addChild(esfera);
 
			// por fim renderizamos a _cena junto com a _camera e o _viewport
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
 
	}
 
}

Bitmaps

Os materiais que trabalham com bitmaps têm suas variações, podemos utilizar as seguintes opções, uma imagem da biblioteca, criar um bitmap em tempo de execução, carregar um arquivo externo ou simplesmente wireframes ou Colors(preenchimentos).

BitmapColorMaterial

Tem praticamente a mesma função que ColorMaterial a diferença é que não estamos trabalhando com vetores e sim bitmaps, para não repetir o mesmo código vou comentar apenas as linhas que sofrem modificações, em relação aos exemplos anteriores …

//no momento de importar a classe devemos importar a classe BitmapColorMaterial
import org.papervision3d.materials.BitmapColorMaterial;
 
//definimos uma variável do tipo BitmapColorMaterial
private var materialcolor 	:BitmapColorMaterial;
 
//inicializamos nossa variável a atribuindo um ColorMaterial na cor 0x004400 e alpha 0.8
materialcolor   = new ColorMaterial(0x004400, 0.8, );
 
//adicionamos nosso materialcolor a esfera
esfera           = new Sphere(materialcolor, 80, 8, 8);

BitmapWireframeMaterial

Mesmo esquema do WireframeMaterial com a diferença de temos acesso a o bitmapData desse matérial:

//no momento de importar a classe devemos importar a classe BitmapColorMaterial
import org.papervision3d.materials.BitmapWireframeMaterial;
 
//definimos uma variável do tipo BitmapColorMaterial
private var materialwire 	:BitmapWireframeMaterial;
 
//inicializamos nossa variável a atribuindo um ColorMaterial na cor 0x004400,
//alpha 0.8, espessura da linha 5px
 
materialwire   = new BitmapWireframeMaterial(0x004400, 0.8, 5);
 
//adicionamos nosso materialwire a esfera
esfera           = new Sphere(materialwire, 150, 8, 8);

BitmapAssetMaterial

Nesse material podemos carrega-lo da nossa biblioteca, mas para isso é preciso linkageID em nossa imagem. Esse tipo de material é trabalhado apenas no Flash CS3 ou versão superior. Para obter o linkageID devemos importar uma imagem no flash e atribuir um id nas propriedades da imagem, da seguinte forma :

Para esse exemplo eu vou utilizar essa imagem:

primeiro importamos para biblioteca a imagem, em seguida vamos editar as propriedades da imagem, na biblioteca selecione a imagem e vá em “Properties…” um “i” que fica localizado no canto inferior da aba da library. como podemos ver na image a baixo:

habilite a opção advanced, adicione em Linkage um no para a Classe que vai representar a imagem da biblioteca, esse será o nome utilizado no código para fazer referência a imagem no código.

Agora tudo pronto para programação. Na mesma pasta que se encontra o nosso arquivo “.fla” vamos criar o arquivo “.as” MainMateriaisBitmap.as, ele segue a mesma lógica dos códigos anteriores :

package  {
 
	/**
	* ...
	* @author Fellyph Cintra
	*/
 
	import flash.display.Sprite;
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	import org.papervision3d.objects.primitives.Sphere;
 
	import org.papervision3d.materials.BitmapAssetMaterial;
 
	import flash.events.Event;
 
	public class MainMateriaisBitmap extends Sprite{
 
		private var _viewport 		:Viewport3D;
		private var _cena 			:Scene3D;
		private var _camera 		:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
		private var esfera			:Sphere;
		private var material  		:BitmapAssetMaterial;
 
 		public function MainMateriaisBitmap() {
 
			//criamos nosso Viewport3D
			_viewport = new Viewport3D(450 , 300 , false, true);
			addChild(_viewport);
 
			_cena = new Scene3D();
			_camera = new Camera3D();
			_renderizador = new BasicRenderEngine();
 
			// criamos um novo material do tipo BitmapAssetMaterial
			//passamos como parâmetro(o id da imagem como String)
			material = new BitmapAssetMaterial("Img");
 
			esfera = new Sphere(material, 150, 8, 8);
 
			//adicionamos nossa esfera na Scene3D _cena
			_cena.addChild(esfera);
 
			// adicionamos um evento ENTER_FRAME para fazer a rotação da nossa esfera
			addEventListener(Event.ENTER_FRAME, onRender);
 
		}
 
		public function onRender(e:Event):void {
			// fazemos o incremento da propriedade rotationY
                        esfera.rotationY += 3;
                        // por fim renderizamos a _cena junto com a _camera e o _viewport
			_renderizador.renderScene(_cena, _camera, _viewport);
		}
	}
 
}

O resultado que temos é o seguinte :

Bitmap File

Material que recebe um bitmap, apontado pelo endereço da imagem através de uma string, por exemplo “http://www.meusite.com/minhaimagem.jpg”. Esse material também podemos adicionar um evento a essa imagem. Nesse Exemplo eu volto a trabalhar somente com o Flash Develop, vamos ao código :

package  {
 
	/**
	* ...
	* @author Fellyph Cintra
	*/
 
	import flash.display.Sprite;
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	//nesse exemplo vamos mudar um, pouco vamos trabalhar com um plano
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.materials.BitmapFileMaterial;
	import flash.events.Event;
 
	import flash.events.Event;
 
	public class MainMateriaisBitmapFile extends Sprite{
 
		private var _viewport 		:Viewport3D;
		private var _cena 		:Scene3D;
		private var _camera 		:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
		private var plano			:Plane;
		private var material  		:BitmapFileMaterial;
 
		public function MainMateriaisBitmapFile() {
 
			//criamos nosso Viewport3D
			_viewport = new Viewport3D(450 , 300 , false, true);
			addChild(_viewport);
 
			_cena = new Scene3D();
			_camera = new Camera3D();
			_renderizador = new BasicRenderEngine();
			//nesse exemplo no mesmo local do meu arquivo .swf eu tenho um arquivo agua.jpg
                        //então passo como parâmetro o endereço da minha imagem
			material = new BitmapFileMaterial("agua.jpg");
			//criamos um plano com 300px de altura e 300px de largura
                        //e 8 segmentos verticais e horizontais
			plano = new Plane(material, 300,300, 8, 8);
 
			//adicionamos nosso plano na Scene3D _cena
			_cena.addChild(plano);
 
			addEventListener(Event.ENTER_FRAME, onRender);
 
		}
 
		public function onRender(e:Event):void {
			plano.rotationY -= 3;
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
	}
 
}

Para não ficar muito extenso esse post vou dividi-lo em dois.
Então até o próximo post, pessoal.

Olá pessoal mais um post sobre actionScript 3.0, agora vamos trabalhar com o teclado. Em AS3 houve mudanças no tratamento dos eventos com o teclado,mas ficou no padrão no tratamento de eventos. Para disparar funções quando o teclado for pressionado fazemos da seguinte forma:

stage.addEventListener(KeyboardEvent.KEY_DOWN, fazAlgoa);

function fazAlgo(e:KeyBoardEvent):void{

 //faz qualquer coisa

 }

Na linha 01 adicionamos o evento KeyboardEvent no stage, e passamos como parâmetro que função será chamada no nosso caso ‘fazAlgo’, Na linha 02 temos a assinatura da função ‘fazAlgo’ que recebe a variável ‘e’ do tipo KeyboardEvent. Até agora simples, vamos trabalhar melhor essas funções com o exemplo a seguir:

• Crie um novo arquivo flash

• Determine a sua taxa de framerate para 30 fps

• Crie um movieclip com o nome de instância bola_mc

• Crie uma layer com nome ações

• Seleciona a layer ações pressione f9 para inserir o código.

var vx        :Number = 0;
var vy        :Number = 0;
var ax        :Number = 0;
var ay        :Number = 0;

stage.addEventListener(Event.ENTER_FRAME, onEnter);
stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeydown);
stage.addEventListener(KeyboardEvent.KEY_UP, onKeyup);

function onEnter(e:Event):void{
      vx += ax;
      vy += ay;
      bola_mc.x += vx;
      bola_mc.y += vy;
}

  function onKeydown(e:KeyboardEvent):void{

      if(e.keyCode == Keyboard.LEFT){
          ax = - 0.1;
      }else if(e.keyCode == Keyboard.RIGHT)
      {
          ax = 0.1;
      }else if(e.keyCode == Keyboard.UP){
          ay = -0.1
      }else if(e.keyCode == Keyboard.DOWN){
          ay = 0.1;
      }
}

function onKeyup(e:KeyboardEvent):void{
      ax = 0;
      ay = 0;
}

Nas linhas 1, 2, 3 e 4 foram criadas variavéis to tipo Number para a velocidade e aceleração do eixo x e y. Na linha 5 foi adicionado o evento ENTER_FRAME e na 6 e 7 os eventos KEY_DOWN e KEY_UP. A função onEnter incrementa a velocidade dos eixos com a aceleração. A função onKeyDown na linha 14 é disparado quando o usuário pressiona qualquer tecla e através da variável ‘e’ do tipo KeyboardEvent podemos saber qual tecla foi pressionada com o código e.KeyCode que na realidade é o número equivalente a tabela ASCI mas como nem todo mundo tem tempo de sobra para ficar decorando toda a tabela ASCI, a classe keyboard possui variáveis estáticas para facilitar a vida do programador, onde podemos ver nas linhas 15, 17, 20 e 22.

Assim a lógica fica da seguinte forma quando a tecla esquerda for pressionada a aceleração x é decrementada, quando pressionado a direita incrementada, quando a tecla cima(up) for pressionada a aceleração y é decrementada e baixo(down) o oposto. A função onKeyup é disparada no Evento KeyboarEvent.KEY_UP ou seja quando o usuário solta a tecla será chamada a função que zera a aceleração tanto x e y. Vamos ver o resultado :

(use as teclas direcionais)

Notem que a bola foge do palco então vamos dar uma melhorada no código substituindo a função onEnter do código anterior por essa :

function onEnter(e:Event):void{
    vx += ax;
    vy += ay;

    if((bola_mc.x < bola_mc.width/2) || (bola_mc.x > stage.stageWidth - bola_mc.width/2)){
      vx *= -1;
    }
    bola_mc.x += vx;

    if((bola_mc.y < bola_mc.height/2) || (bola_mc.y > stage.stage.stageHeight -   bola_mc.height/2)){
      vy *= -1;
   }
bola_mc.y += vy;

}

O incremento da velocidade permanece da mesma foram a diferença é que quando a bola chegar nas extremidades do palco receber sua velocidade inversa. Notem que não utilizamos a posição zero como limite porque o registration do movieclipe está no centro por isso usamos a metade de suas medidas e para usarmos a largura e altura total do stage utilizamos stage.stageWidth e stage.stageHeight. O resultado que temos é esse :

Até a próxima…