Blog · Flash · HTML 5 · Tecnologia · Web

Sim, o fim do Flash já tem data marcada. Meus dois centavos sobre o assunto: mitos, verdades e a Web de hoje

Soube recentemente que a Adobe já definiu uma data para o fim definitivo da tecnologia Flash. Ficou para 2020. Mas na prática ele já está morto há alguns anos – no meu ponto de vista, de quem trabalhou com Flash e AS3 por uns anos, ele começou a agonizar a partir de 2012, morrendo de vez lá por meados de 2013.

Quando digo “morrer de vez” quero dizer no sentido de surgimento de projetos novos – sites, games, animações interativas para Web. Em 2012 mesmo eu já me recordo de transpor um site simples em Flash para HTML (antigo e que rodasse no IE8, não HTML5).

Como alguém que trabalhou com a tecnologia e dedicou uns dois ou três anos à ela, a ponto de escrever alguns posts aqui no blog sobre, acho que deveria escrever algo a respeito. E cá estou. Vou dizer o que penso sobre tudo isso, a história do Flash, a imagem errada que se criou em torno dela e o que vem pela frente. Continue reading “Sim, o fim do Flash já tem data marcada. Meus dois centavos sobre o assunto: mitos, verdades e a Web de hoje”

ActionScript · Flash

CASA Lib, a biblioteca ActionScript que é uma verdadeira “mão na roda”

Neste post vou tratar sobre uma biblioteca que conheço há muito tempo mas que, curiosamente, nunca dei espaço para usar em um projeto: CASA Lib.

A biblioteca, olhando por cima, tem recursos interessantes e que cobre muitos vácuos encontrados na linguagem AS 3, como, por exemplo, um método para remover um item determinado numa Array. Para isso o CASA Lib oferece um objeto List que tem um método removeItem() que cobre esse vazio e facilita a remoção de um item, independentemente da sua posição:

[as3]
var arr:List = new List([‘francisco’, ‘joão’, ‘maria’, ‘daniel’]);
arr.removeItem(‘joão’);
trace(arr); // exibe francisco,maria,daniel
[/as3]

Outras classes úteis são Key e KeyCombo, que facilitam a manipulação de teclas pressionadas simultaneamente.

Mais um recurso bacana são os carregadores. Há para vários tipos, assim como o carregador em grupo (GroupLoad), que permite carregar vários objetos exibindo uma só porcentagem de progresso do conjunto. Carregar imagens, por exemplo, é mais simples do que escrever os objetos “na unha”:

[as3]
var imageLoader:ImageLoad = new ImageLoad(“imagem-de-exemplo.jpg”);
imageLoader.addEventListener(LoadEvent.COMPLETE, onComplete);
imageLoader.start();

function onComplete(evt:LoadEvent):void
{
addChild(imageLoader.contentAsBitmap);
}
[/as3]

Para ver outros recursos é recomendável ver a documentação. Apesar de ser documentação há os exemplo de como usá-las.

ActionScript · Flash

Usando Box2D no Flash / ActionScript 3.0 – tutorial básico

Garimpei muito na Web buscando um tutorial simples para o uso da biblioteca de física Box2D e que funcionasse no Flash. Encontrei códigos com formato antigo, que rodam em versões anteriores da biblioteca (ou em Flash Player anteriores), e principalmente pouco interessantes

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.

[as3]
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-
}
}
}
[/as3]

ActionScript · Dicas & Tutoriais · Flash

Detectando quais teclas estão pressionadas em ActionScript 3

É simples você saber qual tecla foi pressionada em ActionScript. Um pouco mais complicado é saber qual conjunto de teclas estão sendo pressionadas simultaneamente. Isto pode ser necessário em caso de games, como num de corrida, em que o usuário pressionará várias teclas ao mesmo tempo, como um botão para acelerar, outro para direcionar o carro, e assim vai.

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.

[as3]
// 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();
}
[/as3]

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

ActionScript · Dicas & Tutoriais

Criando um sistema de partículas simples com ActionScript 3.0

Há várias maneiras de como se criar partículas em Flash. Há desde bibliotecas que facilitam o trabalho e permitem criar efeitos excelentes (é o caso da Tweensy e a sua parte – ainda em beta – FX) até os tutoriais dificílimos disponíveis na Web, que geralmente envolvem muita matemática – e que são muito bons -, de sites como o Flash & Math.

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:

[as3]
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 } );
}
}
}
[/as3]

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.

ActionScript · Flash

Componente Scrollbar para Flash – grátis

Neste post deixo para download um componente simples, mas que é usado em 10 de cada 10 sites em Flash que contém texto: um scroller com movimento animado.

Ele foi criado originalmente pelo pessoal do Free Flash Resources, mas a versão deles é separada em várias classes. A versão que posto aqui foi modificada por mim, e contém os códigos ActionScript direto nas timelines dos clipes de filme. Em outras palavras, basta copiar e colar os clipes; nada de mover as classes AS dele para lá e para cá. Isso evita bagunça e que você tenha que reeditar códigos cada vez que for usar o componente.

O componente tem a parte gráfica e códigos customizáveis.

Download.

Veja o exemplo abaixo do funcionamento.

ActionScript

Flupie – usando ActionScript para animação de texto

A postagem é curta, mas é de coração e é isso que importa. Recebi a dica de um colega sobre uma biblioteca chamada Flupie, destinada a facilitar a criação de efeitos para textos em Flash.

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.

ActionScript

Usando APE para simulação de física no ActionScript 3.0

Depois de um longo hiato, volto aqui para falar de uma biblioteca de física para ActionScript, a APE. Gostei muito desta biblioteca e a adotei. Existem similares, como a Box2D e a JigLib (esta última, para 3D), caso interesse, mas aqui postarei um pequeno exemplo básico de como funciona.

No exemplo, mostro como é o funcionamento básico, e para demonstrar a flexibilidade da biblioteca, é mostrado como é possível realizar a detecção de colisão, misturando métodos comuns do AS 3.0 à objetos da biblioteca. O código foi criado usando FlashDevelop.

[as3]
package {
import flash.text.TextField;
import org.cove.ape.*;
import flash.events.Event;
import flash.display.Sprite;

public class Main extends Sprite {

// CRIANDO UMA “ESFERA”
public var esfera:CircleParticle = new CircleParticle(250, 10, 25);

// CRIANDO RETANGULO (SERÁ O “PISO”)
public var piso:RectangleParticle = new RectangleParticle(150, 300, 300, 50, 0, true);

// O GRUPO QUE SERÁ O NOSSO “MUNDO” ONDE OS OBJETOS IRÃO INTERAGIR
public var grupo:Group = new Group();

public function Main() {

stage.frameRate = 60;
addEventListener(Event.ENTER_FRAME, run);

APEngine.init(1/4);
APEngine.container = this;

// CRIANDO A FORÇA DA GRAVIDADE
APEngine.addMasslessForce(new Vector(0, 2));

// ATIVANDO COLISÕES
grupo.collideInternal = true;

// ADICIONANDO AO CÍRCULO A FORÇA QUE O MOVIMENTARÁ
esfera.addForce(new Vector(5, 0));

// JUNTANDO AO GRUPO
grupo.addParticle(esfera);
grupo.addParticle(piso);

APEngine.addGroup(grupo);
}

private function run(evt:Event):void {
// PROCESSAMENTO DA AÇÃO
APEngine.step();
APEngine.paint();

// DETECÇÃO DE COLISÃO – AO COLIDIREM SERÁ EXIBIDO UM TEXTO
if (esfera.sprite.hitTestObject(piso.sprite)) {
var txt:TextField = new TextField();
txt.text = “COLIDIU!”;
addChild(txt);
}
}
}
}
[/as3]

Numa próxima postagem darei a dica de como associar essa biblioteca com a as3isolib (para criação de gráficos isométricos).

ActionScript · Dicas & Tutoriais

Usando SVG através do ActionScript – AS3 SVG Renderer

É possível carregar arquivos gráficos SVG (formato de arquivos de desenho em vetor, organizados em modo XML) através do ActionScript como se fossem Sprites.

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. Continue reading “Usando SVG através do ActionScript – AS3 SVG Renderer”

ActionScript · Dicas & Tutoriais

Mais sobre ActionScript 3.0 – programas, bibliotecas e dicas

Para reanimar um pouco este blog vou postar aqui algumas dicas de programas e de bibliotecas para quem programa/quer programar com ActionScript 3.0.

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. 😛 ).

JigLibFlashengine 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.