Irei falar hoje sobre o iPhone, que é minha meta para esse ano, dominar o máximo possível essa nova ferramenta que veio para ficar no mercado, não como um Celular, e sim como um padrão mobile, com sua Apple Store, e sua facilidade de desenvolvimento, com sua tela interativa e intuitiva, entre muitos outros fatores que todos devem conhecer muito bem! Vou começar com alguem bem, bem simples! Porem ja da uma pequena ajuda na hora para toda linguagem de programação!

Primeiramente gostaria de falar que não sou um experiente no iPhone, estou aprendendo e justamente para fixar melhor meu aprendizado quero compartilhar com todos que quiserem também.
Corro o risco de falar algo errado em algum momento, ou não mostrar a melhor maneira de se fazer tal coisa ou outra coisa, porem estou aqui para ajudar o máximo possível! Em cima disso, vamos a alguns detalhes:

• Para desenvolver para o iPhone é necessario um MAC (duhhh), sei que parece meio obvio, porem acredito que algumas pessoas não saibam disso, existem algumas maneiras de desenvolver no Windows, porem são bem complexas.
• Para testar os aplicativos no iPhone é necessario ter uma conta de developer da Apple, que custa U$99 dolares, e junto com isso você ganha acesso a muitas e muias coisas (videos, foruns, exemplos), um preço bem justo a ser pago
• Quem nunca programou em linguagem nenhuma, não vai conseguir se sair muito bem, é necessário saber o mínimo de Cocoa, e Objective-C, recomendo o seguinte site: http://cocoadevcentral.com/d/learn_cocoa_two/ muito bom essa parte!
• Paciência e muita pesquisa ajudam muito, existem muitos e muitos sites hoje em dia falando sobre isso, vou reunir alguns e postar aqui assim que possivel!

Primeira coisa a ser feita:

Download do SDK da Apple, você pode realizar o download dele aqui (você precisa fazer um cadastro gratis no site da apple, para fazer o download), ele vem com todo o conjunto de ferramentas necessario para iniciar o desenvolvimento de um aplicativo para o iPhone!

Feito isso, vamos a nossa ferramenta de desenvolvimento, bem vindo ao Xcode!

XCode Main Screen!

É aqui que todo o desenvolvimento para o iPhone é feito, provavelmente não é a unica maneira, mais é aque tenho utilizado!

Vamos criar um novo projeto View-Based Application:
De o nome para ele de HelloWorld, e salve o mesmo.

Agora você vera a seguinte tela:

Isso é o core de todo aplicativo, todo projeto novo criado vira com os arquivos, não vou entrar uma definição muito correta de todos os termos, mais basicamente:

• Arquivos .xbi são arquivos que contem uma visualização, que pode ser alterada pelo interface builder, que mostrarei daqui a pouco
• Arquivos .h são os headers de todas as classes, aonde declaramos funções e variáveis
• Arquivos .m são as classes propriamente ditas, aonde construimos a mesma.

Primeiramente vamos editar o nosso arquivo .xib, essa parte é um pouco complicada de explicar mesmo, vou tentar postar um passo a passo de cada um deles, mais qualquer duvida, não exite em perguntar.
Dentro da pasta Resources existe um arquivo chamado: HelloWorldViewController.xib, vamos dar um duplo click nele, para ele abrir no interface builder:
Ele vai abrir da seguinte maneira para nós:
Temos a visualização dos seguintes itens: Inspector / View / Controlador / Library.
Para este exemplo vamos precisar de 2 itens, 1 Text Label, e 1 Round Rect Button, precisa simplesmente arrastar da library para o seu view, para achar os itens, no canto inferior da LIbrary existe um finder, basta começar a digitar que eles ja aparecem:

Vamos arrastar ambos para o nosso View, deixando da seguinte maneira:

Pronto, pode salvar e fechar o mesmo, agora dentro da pasta Classes, abra o arquivo: HelloWorldViewController.h:

Agora precisamos iniciar o nosso label e o nosso botão:

 
#import <UIKit/UIKit.h>
 
@interface HelloWorldViewController : UIViewController
{
	//Criando objeto da classe label
	IBOutlet UILabel *meuLabel;
}
//declarando função para o botão
-(IBAction)showLabel;
 
//Iniciando minha variavel Label
@property(nonatomic, retain) UILabel *meuLabel;
 

Agora vamos até o arquivo: HelloWorldViewController.m, aonde criaremos nossa função:

 
#import "HelloWorldViewController.h"
 
@implementation HelloWorldViewController
//Declarando minha variavel como publica
@synthesize meuLabel;
 
//Criando a função para clique no botão
-(IBAction)showLabel
{
	//Setando meu texto para Hello World
	[meuLabel setText:@"Hello World"];
}
 

Se tudo correu bem até agora, você deve poder clicar no Build and Go sem erro algum, porem não vai funcionar ainda, porque precisamos linkar nossas variaveis, novamente vamos para o Interface Builder, duplo clique no HelloWorldViewController.xib, você vai precisar arrastar com o botão direito do mouse o objeto File's Owner até em cima do label, como na imagem abaixo:

E a mesma coisa deve ser feita, só que agora para o botão chamando o evento ShowLabel:

Salve novamente, e agora va novamente em Build and Go!

Se tudo correr bem, agora você deve conseguir testar a aplicação funcionando!

e é isso, é bem simples, e bem por cima não expliquei nada muito a fundo, na verdade não expliquei nem a raso, mais ja é alguma coisa para sair do zero!
Valeu!

 
var arr:Array = ["a","b","b","c","b","d","c"];
 
var z:Array = arr.filter(function (a:*,b:int,c:Array):Boolean
{
return ((z ? z : z = new Array()).indexOf(a) >= 0 ? false : (z.push(a) >= 0));
 }, this);
 
trace(z);
 

Quando um botão é criado dinamicamente em cima de um movieclip, com um textfield sobre ele, o flash não reconhece a area do movieclip como status de over, ou seja, ele não aparece a maozinha, como visto no exemplo abaixo:

 
hit.buttonMode = true;
hit.useHandCursor = true;
 

para resolver isso basta ajustar com o seguinte código:

 
hit.mouseChildren = false;
 

e prontinho:

isso ai!

Vou postar um pequeno jogo que desenvolvi pela Midia Digital, é um joguinho bem antigo! Quem é dos anos 90 lembra dele, consistia basicamente em apertar 2 botões tentando fazer com que as bolinhas ficassem em 2 spots!

hahah explicação bem estranha, porem ao ver o jogo vocês vão intender!

O bacana desse cógigo é que ele usa algumas técnicas em APE, que pode auxiliar você em varios outros projetos na mesma engine, por exemplo:
- Como adicionar uma força especifica em um unico lugar.
- Interação com força em botões.

Com isso a questão fica muito simples, o projeto se consiste em 2 unicos pontos:
- Criar o Puzzle na APE.
- Fazer as interações.

Ao criar o projeto na APE você tera toda a parte em que a física em si, vai interagir com as bolinhas:

acquaplayGroup = new Group();
acquaplayGroup.collideInternal = true;
APEngine.addGroup(acquaplayGroup);
 
//Creating Balls;
var ball1Display:DisplayObject = new bola1();
var ball2Display:DisplayObject = new bola2();
var ball3Display:DisplayObject = new bola3();
var ball4Display:DisplayObject = new bola4();
 
var ball1:CircleParticle = new CircleParticle(70, 125, 6, false, 1, 0);
var ball2:CircleParticle = new CircleParticle(87, 125, 6, false, 1, 0);
var ball3:CircleParticle = new CircleParticle(105, 125, 6, false, 1, 0);
var ball4:CircleParticle = new CircleParticle(121, 125, 6, false, 1, 0);
 
ball1.sprite.name = "ball1";
ball2.sprite.name = "ball2";
ball3.sprite.name = "ball3";
ball4.sprite.name = "ball4";
 
acquaplayGroup.addParticle(ball1);
acquaplayGroup.addParticle(ball2);
acquaplayGroup.addParticle(ball3);
acquaplayGroup.addParticle(ball4);
 
//Creating Wall and obstacles
var lWall:RectangleParticle = new RectangleParticle(8, 85, 1, 134, -.05, true);
var rWall:RectangleParticle = new RectangleParticle(188, 85, 1, 134, .05, true);
var tWall:RectangleParticle = new RectangleParticle(100, 18, 200, 1, 0, true);
var bWall:RectangleParticle = new RectangleParticle(100, 153, 185, 1, 0, true);
var blColision:RectangleParticle = new RectangleParticle(60, 142, 75, 0.5, -.13, true, 1, 0.0);
var brColision:RectangleParticle = new RectangleParticle(133, 142, 75, 0.5, .13, true, 1, 0.0);
 
rWall.setLine(0.1, 0x000, 1);
tWall.setLine(0.1, 0x000, 1);
lWall.setLine(0.1, 0x000, 1);
bWall.setLine(0.1, 0x000, 1);
blColision.setLine(1, 0x000, 1);
brColision.setLine(1, 0x000, 1);
 
acquaplayGroup.addParticle(lWall);
acquaplayGroup.addParticle(rWall);
acquaplayGroup.addParticle(tWall);
acquaplayGroup.addParticle(bWall);
 
acquaplayGroup.addParticle(blColision);
acquaplayGroup.addParticle(brColision);
 
var ob1left:RectangleParticle = new RectangleParticle(63, 82, 1, 20, 0, true);
var ob1right:RectangleParticle = new RectangleParticle(80, 82, 1, 20, 0, true);
var ob1Ldown:RectangleParticle = new RectangleParticle(68, 95, 10, 1, .6, true);
var ob1Rdown:RectangleParticle = new RectangleParticle(75, 95, 10, 1, -.6, true);
 
var ob2left:RectangleParticle = new RectangleParticle(120, 62, 1, 20, 0, true);
var ob2right:RectangleParticle = new RectangleParticle(137, 62, 1, 20, 0, true);
var ob2Ldown:RectangleParticle = new RectangleParticle(125, 75, 10, 1, .6, true);
var ob2Rdown:RectangleParticle = new RectangleParticle(132, 75, 10, 1, -.6, true);
 
ob2left.setLine(0.1, 0x000, 1);
ob2right.setLine(0.1, 0x000, 1);
ob2Ldown.setLine(0.1, 0x000, 1);
ob2Rdown.setLine(0.1, 0x000, 1);
 
ob1left.setLine(0.1, 0x000, 1);
ob1right.setLine(0.1, 0x000, 1);
ob1Ldown.setLine(0.1, 0x000, 1);
ob1Rdown.setLine(0.1, 0x000, 1);
 
acquaplayGroup.addParticle(ob2left);
acquaplayGroup.addParticle(ob2right);
acquaplayGroup.addParticle(ob2Ldown);
acquaplayGroup.addParticle(ob2Rdown);
 
acquaplayGroup.addParticle(ob1left);
acquaplayGroup.addParticle(ob1right);
acquaplayGroup.addParticle(ob1Ldown);
acquaplayGroup.addParticle(ob1Rdown);

Com isso nosso puzzle ja esta ok! Agora é Customizar os objetos!

o proximo passo for criar os objetos para serem usados como skin dos meus objetos.

Criei 4 objetos diferentes e exportei como ball1, ball2, ball3 e ball4.

Agora crio os objetos como display object:

var ball1Display:DisplayObject = new bola1();
var ball2Display:DisplayObject = new bola2();
var ball3Display:DisplayObject = new bola3();
var ball4Display:DisplayObject = new bola4();
 
//e adiciono eles com a função setDisplay
 
ball1.setDisplay(ball1Display, 0, 0, 0);
ball2.setDisplay(ball2Display, 0, 0, 0);
ball3.setDisplay(ball3Display, 0, 0, 0);
ball4.setDisplay(ball4Display, 0, 0, 0);

a principal sacada, que acho que é bem interessante aqui, e pode ser utilizado em inumeros outros jogos, é justamente a seguinte parte:

no meu enterframe, eu utilizo a seguinte função:

for each(var p:AbstractParticle in acquaplayGroup.particles)
{
}

Ou seja, eu consigo pegar todas as minhas particulas que estão rodadndo na minha APE, e com isso, consigo tratar cada 1 de maneira diferente, então, eu quero pegar apenas as particulas que estão em movimento, verifico se ela é fixa ou não:

if (p.fixed == false)
{
}

E agora faço as verificações, se a bola, estiver em uma posisão x, com o botão estando apertado, aplique uma força no objeto:

if (p.px > 145 && p.px < 185 && p.py < 50 && p.py > 20)
{
	p.addForce(new VectorForce(false, -.5, 0.5));
}
else if (p.px > 4 && p.px < 62 && p.py < 50 && p.py > 20)
{
	p.addForce(new VectorForce(false, .5, 0.5));
}
if (bLeftForce)
{
	if (p.px > 15 && p.px < 30 && p.py > 50)
	{
		p.addForce(new VectorForce(false, 0, -4));
	}
	if (p.px > 4 && p.px < 62 && p.py < 50 && p.py > 20)
	{
		p.addForce(new VectorForce(false, 2, 0));
	}
}
if (bRightForce)
{
	if (p.px > 168 && p.px < 180 && p.py > 50)
	{
		p.addForce(new VectorForce(false, 0, -4));
	}
	if (p.px > 145 && p.px < 185 && p.py < 50 && p.py > 20)
	{
		p.addForce(new VectorForce(false, -2, 0));
	}
}

Basicamente é isso, aqui em baixo você pode ver como ficou o projeto final:

Download do código fonte do jogo!

Away 3D site do Hellboy

Não porque é em 3D muito bem feito, mais é utilizado de forma sensata, leve, e realmente muito facil de ser reproduzido! Ela ainda tem suporte a WOW Engine (engine de fisica para 3D)!

Existem vários exemplos ótimos de Away 3D, segue alguns exemplos, retirados do próprio site do Away 3D

Então! Chega de papo furado, e vamos a um exemplo BEM SIMPLES! Ridiculamente Simples, de ser feito!

Ok! Sem tirar sarro! é que realmente queria algo bem simples, para mostrar a facilidade do mesmo!

Basicamente para um projeto em Away 3D, você vai precisar fazer o download da ultima versão, e jogar no seu Classpath, ou simplesmente deixar a mesma na pasta da sua aplicação, estou utilizando Flash Develop aqui, aconselho a todos que não gostem muito do editor de Actionscript do Flash, utilizarem o mesmo, é muito bom!

Crie seu Arquivo Flash Actionscript 3, defina o Document Class como Main, no flash Develop crie uma nova Classe como Main.as, jogue no mesmo diretório que o seu .fla.

O seu arquivo Main.as devera ser como o arquivo abaixo:

package
{
public class Main
{
public function Main()
{
}
}
}

Precisamos apenas extender a nossa classe para a mesma ser um Document Class, então alteramos para:

 public class Main extends Sprite

Feito isso nossa Document Class esta pronta para ser usada!

Basicamente para trabalher com o Away 3D vc precisa de um unico objeto, o View3D, então vamos criar um novo view 3D, centralizado no Stage:

private var view:View3D = new View3D( { x:(stage.stageWidth/2), y:(stage.stageHeight/2)} );

Agora precisamos de um Objeto 3D neste caso utilizei uma porem inicio a mesma como Object3D, pois sphere é uma extensão da classe Objeto 3D:

private var sphere:Object3D;

E no Construtor da nossa classe vamos iniciar e definir alguns padrões:

public function Main()
{
//Adicionando nosso view ao stage
addChild(view);
//criando um listener para o enterFrame para o mesmo rodar a engine
addEventListener(Event.ENTER_FRAME, run);
//Criando uma nova Sphere, passo para ela as cores do meu Wireframe, o raio, quantos poligonos verticais e horizontais, posições x,y e z
sphere = new Sphere( { material:"white#black", radius:100, segmentsW:12, segmentsH:9, y:0, x:0, z:10 } );
//Adiciono a minha esfera ao stage da minha visualização
view.scene.addChild(sphere);
//Mudo a posição da minha camera
view.camera.position = new Number3D(1000, 1000, 1000);
//Travo a minha camera para a mesma apontar para a sphere
view.camera.lookAt(sphere.position);
}

E no enterFrame rodamos nossa engine, e rodamos a esfera!

private function run(e:Event):void
{
sphere.rotationY += 1;
view.render();
}

E pronto, uma simples aplicação em 3D escrita com pouquíssimas linhas de código, para ser exato, de código real temos apenas 10 linhas de código!

Código Completo:

package
{
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.primitives.*;
	import away3d.core.math.*;
	import flash.display.Sprite;
	import flash.display.Stage;
	import flash.events.Event;
 
	public class Main extends Sprite
	{
		private var view:View3D = new View3D( { x:(stage.stageWidth/2), y:(stage.stageHeight/2)} );
		private var sphere:Object3D;
		public function Main()
		{
			//Adicionando nosso view ao stage
			addChild(view);
			//criando um listener para o enterFrame para o mesmo rodar a engine
			addEventListener(Event.ENTER_FRAME, run);
			//Criando uma nova Sphere, passo para ela as cores do meu Wireframe, o raio, quantos poligonos verticais e horizontais, posições x,y e z
			sphere = new Sphere( { material:"white#black", radius:100, segmentsW:12, segmentsH:9, y:0, x:0, z:10 } );
			//Adiciono a minha esfera ao stage da minha visualização
			view.scene.addChild(sphere);
			//Mudo a posição da minha camera
			view.camera.position = new Number3D(1000, 1000, 1000);
			//Travo a minha camera para a mesma apontar para a sphere
			view.camera.lookAt(sphere.position);
		}
		private function run(e:Event):void
		{
			sphere.rotationY += 1;
			view.render();
		}
	}
}

Download do arquivo Fonte!

É isso ai, até a proxima, prometo trazer algo mais aplicável e interessante!

Em primeiro lugar, vamos preparar o necessário:

Desenhe uma pétala simples, e exporte a mesma como "petala".

Agora vamos a parte que importa o código!

 
import flash.events.Event;
//Criando um Timer
var myTimer:Timer = new Timer(100);
myTimer.addEventListener(TimerEvent.TIMER, addPetala);
myTimer.start();
 
//Função para retornar um numero randomico passando 2 valores como parametro
function getRandomByRange(min:Number, max:Number, floor:Boolean = false):Number
{
    var randomNum:Number;
    switch(floor)
    {
        case false:
            randomNum = Math.random() * (max - min + 1) + min;
        break
        case true:
            randomNum = Math.floor(Math.random() * (max - min + 1)) + min;
        break;
    }
 
    return randomNum;
}
//Função que adiciona nova petala.
function addPetala(te:TimerEvent):void
{
    var myPetala:petala = new petala();
 
    var scale:Number = getRandomByRange(0.3, 1);
 
    myPetala.scaleX                = myPetala.scaleY = scale;
    myPetala.x                    = Math.random()*stage.stageWidth;
    myPetala.fallingCurve        = getRandomByRange(-2,2,true);
    myPetala.dropSpeed            = (scale/20)*100;
    myPetala.rotateSpeed        = getRandomByRange(-3,3,true);
    myPetala.turn                = 0.1;
 
    var petalaBlur:BlurFilter    = new BlurFilter();
    petalaBlur.blurX            = petalaBlur.blurY = (scale/50)*100;
    petalaBlur.quality            = 3;
 
    var filterArray:Array        = new Array(petalaBlur);
    myPetala.filters            = filterArray;
 
    myPetala.addEventListener(Event.ENTER_FRAME, dropMe);
 
    stage.addChild(myPetala);
}
//Função da animação da petala
function dropMe(e:Event):void
{
    var petala:MovieClip     = e.target as MovieClip;
    petala.x                += petala.fallingCurve;
    petala.y                += petala.dropSpeed;
    petala.rotation            += petala.rotateSpeed;
    petala.scaleX             += petala.turn;
 
    if(petala.scaleX > 1)
    {
        petala.turn = -0.1;
    }
    else if(petala.scaleX < 0)
    {
        petala.turn = 0.1;
    }
 
    if(petala.y > stage.stageHeight+petala.height)
    {
        e.target.removeEventListener(Event.ENTER_FRAME, dropMe);
        e.target.parent.removeChild(e.target);
    }
}

Basicamente a grande sacada aqui é que as petalas que caem na frente, caem mais rapido, e tem mais blur aplicado, dando um efeito bacana de desfoque!

É bem simples mais o efeito final e bacana e bem leve!

Download dos arquivos

Overview

Pelo que anda rolando de rumores, ele será lançado em Outubro de 2008, não vamos mais ter Keyframes, agora ele vai utilizar coordenada baseada em tempo, basicamente como temos em todos os programas de animação (After Effects, Primier, 3DS) Acredito que isso fará muito mais sentido para quem esta começando no flash. Nas vias praticas, isso quer dizer que vc vai poder clicar com o botão direito sobre um objeto, e simplesmente adicionar um Shape Tween ou Motion Tween diretamente a este objeto. Isso significa que não vai ter mais Tweens Quebrados, porque eles não estão mais ligados a um Keyframe. Quando você mexer o objeto de lugar no Stage, ele é automaticamente atualizado, sem mudar frames algum. Outra boa coisa, é que você vai poder desenhar uma linha com a Pen Tool, e fazer um Tween seguir o caminho, Antigamente você precisaria criar um Path Layer para ai adicionar uma animação a mesma, isso vai economizar muito tempo :). Outra adição é a Transform Tool que permite modificar ou transformar o Tween path

Novidades

Typed Arrays (Vetores)

Isso deveria ter sido implementado no Actionscript 3 em primeiro lugar, finalmente agora foram adicionadas ao CS4.
Typed Arrays, fazem com que debuggar e manutenção das aplicações sejam uma coisa mais simples, dando a você compilação em tempo real, fazendo com que a escrita do código seja mais segura. Com isso tbm, temos a chance de escrever arrays com elementos como Vetores.

Suporte a 64-bit

Rolou alguns boatos que o Flash CS3 teria suporte a 64-Bit, porem não tem.
Adobe oficialmente anunciou que o Flash CS4 tera suporte a processadores 64- bits. Desta forma podemos utilizar tudo que um processador 64-bit tem a oferecer, especialmente com coisas em 3D!

PixelBender utilizando GPU

Isso sera uma otima adição, Isso vai permitir que você crie filtros e efeitos utilizando a mais nova linguagem de processamento de imagens chamada "PixelBender". É isso é ainda melhor pelo fato que a PixelBender faz uso direto da GPU (Sua VGA).
Isso permite a criação de filtros e efeitos Real Time, que vão deixar os desenvolvedores malucos, existem varios exemplos "open-source" disponiveis no Adobe Lab.
Pixel Bender é uma linguagem de programação usada para processar algoritimos de imagens, via hardware, algumas das coisas que ele oferece são:

• Sintaxe parecida com o GLSL, que é baseado em C
• Permite que um mesmo filtro rode efetivamente em diferentes GPU e CPU, incluindo sistemas multi-core e multi-processadores não necessariamente sendo da mesma arquitetura.
• Facilita a criação de um aplicativo para varios sistemas
• Suporte para aplicações de terceiros, criação e compartilhamento de filtros e efeitos
• Traz uma qualidade exelente de performace quando trabalhado junto com produtos ADOBE

Tweens Inverse Kinematic (BONES!!)

Adobe finalmente anuciou que o Flash CS4 vai ter suporte nativo a IK tweens.
O Basico do IK é que vc consegue controlar objetos diferentes com um simples bone. E quando você move o objeto, os objetos presos ao mesmo bone, são forçados a se mexer e se adaptar junto com ele. Como você pode imaginar isso facilitara muito o trabalho para animar, personagens. Quem trabalha com 3D ja deve estar acostumados com isso, porem agora temos isso em Flash sem terque escrever uma unica linha de código:

(Please open the article to see the flash file or player.)

Novo modelo de tween (baseado no objeto)

Basicamente esse novo metodo é para você utilizar tween em objetos sem a necessidade de isto estar a presto em alguma timeline.
Isto é feito basicamente clicando com o botão direto sobre um objeto e clicando em "Add Tween". Isso facilita muito, até para quem esta começando no flash.
E garante uma nova experiencia ao se tratar de tween, facilitando e agilizando o processo. Esse é o improvement que eu mais expero.
Abaixo um video demonstrando a nova engine de Tween:

(Please open the article to see the flash file or player.)

Conversor para Flash Lite

Quem desenvolve para flash lite, pode ficar feliz, basicamente as coisas serão melhores com o Flash CS4.
Você não tera mais que ajustar um conteudo para Flash Lite. Porque de alguma maneira agora tudo sera a mesma coisa.

Fim do Limite de Bitmap de 2880 x 2880 px

Os Flash anteriores tinham este limite para prever problemas de memoria. Esse limite foi pras trevas! Ou vai ser bem melhorado!

Novo modelo de renderização para o Stage

Essa é mais uma ótima novidade! Com a nova engine poderemos ver animações, videos e varias outras coisas sem precisar compilar o mesmo!

3D

Agora o Flash CS4 permitira a manipulação de objetos 2D em 3D.

(Please open the article to see the flash file or player.)

Por hoje é só, qualquer novidade a mais posto aqui!

ops! Havia esquecido da fonte! é plagio traduzido

fonte: http://www.brianwiltshire.net/lab/?p=56

O APE é um engine feita em C++ e portada para actionscript 3.0 que facilita aplicativos envolvendo fisica no Flash

Existem muitas outras engines tais para o mesmo propósito tais como:

• Box2DFlashAS3
• WOW-Engine
• foam-as3
• Motor Physics
• Revive
• Flade (Flash Dynamics Engine)
• Fisix Engine
• glaze

Entre algumas outras que eu devo ter esquecido! haha Porem por esta engine ser conhecida no C, e realmente ser EXTREMAMENTE simples de usar!

Vamos a um pequeno exemplo, bem simples, que ja mostra boa parte do que é necessário:

Veja o código abaixo

stage.quality = "BEST";
import flash.events.Event;
import org.cove.ape.*;
//Iniciando Engine
APEngine.init(1/4);
APEngine.container = this;
APEngine.addForce(new VectorForce(false, 0, 4));
//Criando Grupo
var apeGroup:Group = new Group();
apeGroup.collideInternal = true;
//Adicionando Grupo para Engine
APEngine.addGroup(apeGroup);
//Criando step no enterFrame do Stage, para rodar a API
function run(e:Event):void
{
	APEngine.step();
	APEngine.paint();
 
}
function init(e:Event)
{
	startMc.visible = false;
	addEventListener(Event.ENTER_FRAME, run);
	var cParticle:CircleParticle = new CircleParticle(175, 0, 5);
	cParticle.setFill(0x444444 * Math.random() + 0xbbbbbb);
	cParticle.setLine(0, 0xff0000, 0);
	apeGroup.addParticle(cParticle);
}
startMc.addEventListener(MouseEvent.MOUSE_DOWN,init);

Basicamente ela funciona assim:

1. Iniciando APE
2. Criando Objetos
3. Criando Grupos
4. Adicionando Objetos ao Grupo
5. Adicionando Grupo a APE
6. Rodando a Engine em um ENTER_FRAME;

Iniciando ENGINE:

• APEngine.init é o metodo que deve ser chamado para iniciar a ENGINE, passando o valor do delta para ela, este valor é basicamente a força das equações de sua aplicação, quanto menor o numero/mais cálculos serão feitos, e mais preciso será sua física, porem mais lenta, por default é utilizado 1/3 ou 1/4.

• APEngine.addForce Isso aqui você define um valor padrão para a massa dos objetos que vai ter no seu aplicativo, você seta um valor default, ou seja, não precisa declarar em todos os objetos.

• APEngine.container é aonde fica o o stage da mesma, você pode controlar fisicas separadas para varios objetos com isso.

Criando Objetos

• var cParticle:CircleParticle = new CircleParticle(Math.random()*350, 0, 5); Criando um objeto da classe Circulo, em uma posição randomica entre 350~0, na posição y:0, e com raio 5.
  cParticle.setFill(0x444444 * Math.random() + 0xbbbbbb);
  Setando um preenchimento randomico.
  cParticle.setLine(1, 0xff0000, 0);
  Setando uma linha de 1 pixel.

Criando Grupos

• var apeGroup:Group = new Group(); Criando um grupo
  apeGroup.collideInternal = true; passando a Colisão entre objetos interna do grupo como verdadeira.

Adicionando Objetos aos Grupos

• apeGroup.addParticle(cParticle); Simplesmente dizendo que a bola criada a pouco, pertence ao grupo apeGroup

Adicionando o grupo a APE

• APEngine.addGroup(apeGroup); Adicionando o grupo para a APE

Rodando a Engine em um ENTER_FRAME;

• APEngine.step(); Realiza os cálculos necessários para a fisica
  APEngine.paint(); Pinta os obejtos na tela!

É uma Engine muito simples e pratica de trabalhar, no exemplo abaixo, vou adicionar um retângulo para colisão do objeto:

stage.quality = "BEST";
import flash.events.Event;
import org.cove.ape.*;
//Iniciando Engine
APEngine.init(1/4);
APEngine.container = this;
APEngine.addForce(new VectorForce(false, 0, 4));
//Criando Grupo
var apeGroup:Group = new Group();
apeGroup.collideInternal = true;
//Criando Chão
var rParticle:RectangleParticle = new RectangleParticle(150, 295, 300, 10, 0, true);
apeGroup.addParticle(rParticle);
//Adicionando Grupo para Engine
APEngine.addGroup(apeGroup);
//Criando TIMER para adicionar bolas
var timer:Timer = new Timer(100);
timer.addEventListener(TimerEvent.TIMER,addBall)
 
//Criando step no enterFrame do Stage, para rodar a API
function run(e:Event):void
{
	APEngine.step();
	APEngine.paint();
 
	for each(var p:AbstractParticle in apeGroup.particles)
	{
		if(p.py > 300)
		{
			apeGroup.removeParticle(p);
		}
	}
 
}
function init(e:Event)
{
	startMc.visible = false;
	stage.addEventListener(Event.ENTER_FRAME, run);
	timer.start();
}
function addBall(e:TimerEvent):void
{
	var cParticle:CircleParticle = new CircleParticle(Math.random()*350, -20, Math.random()*10+5);
	cParticle.setFill(0x444444 * Math.random() + 0xbbbbbb);
	cParticle.setLine(0, 0xff0000, 0);
	apeGroup.addParticle(cParticle);
}
startMc.addEventListener(MouseEvent.MOUSE_DOWN,init);
startMc.buttonMode = true;

No exemplo acima, eu simplesmente adicionei um objeto da classe RectangleParticle, na posição x:150 (tudo na APE é centralizado) y:295, largura: 300, altura: 10

var rParticle:RectangleParticle = new RectangleParticle(150, 295, 300, 10, 0, true);

E adicionei ela ao meu grupo:

apeGroup.addParticle(rParticle);

Outra coisa interessante nisso, é que eu removo as mesmas, quando elas passam de y>300, ou seja, saem do stage.
No função run, eu tenho a seguinte verificação:

for each(var p:AbstractParticle in apeGroup.particles)
{
	if(p.py > 300)
	{
		apeGroup.removeParticle(p);
	}
}

Ou seja, toda particula que eu tiver dentro do meu grupo, que exceder a posição y ou seja: py em 300 eu removo ela!

Matéria Primitivas

Na APE, temos basicamente 3 tipos de matérias primitivas, são elas:

• Rectangle
• Circle
• Whell

E temos uma matéria somente para ligação das mesmas:

• Spring Constrain

Aqui em baixo tem um exemplo bem tosco :S dos tipos de objetos:

Baixe aqui todos os experimentos

Por enquanto é isso! Assim que possivel, postarei um aplicativo que estou trabalhando, melhor feito com essa engine!!!

É um agregador de Feeds Visual! Não quero comentar a questão usabilidade ou coisas do genero, mais que realmente merece atenção merece!

Vale o Click!

Sei que meu primeiro post deveria ser uma breve apresentação do blog e conteúdo, porem ja tentei fazer um blog varias vezes, e dessa vez vou pular a introdução e vou direto a mão na massa!!!
Ultimamente tenho feito algumas experiências com o APE - Actionscript Physics Engine, e gostaria de começar meu blog com um post sobre ele, porem.... acho que seria bacana começar um pouco atras com isso! Hoje em dias vemos e utilizamos tantas Engines Open Source, tais como: Papervision 3D, APE entre muitas outras existes hoje em dia, que nos facilitam muito a vida!

Aonde eu quero chegar com isso tudo é em: Como acompanhar um projeto opensource que passa por varias atualizações, correções, improvements  mensais sem perder nada?

SVN é a resposta, svn que segundo o google é isso:

Subversion (também conhecido por svn ou SVN, o nome da sua ferramenta de linha de comando) é um sistema de controle de versão desenhado especificamente para ser um substituto moderno do CVS, que se considera ter alguns defeitos.

Ou seja:
É um sistema para controle de arquivos "versionados", você mantem um projeto em um servidor, aonde varias pessoas contribuem com o mesmo e mantem backup, versões e revisões de tudo, e ainda um controle geral de tudo que foi alterado! Isso é ótimo até mesmo para gerenciar projetos mesmo!

Software:
Com o servidor svn você pode ter um software para controlar isso, eu particularmente gosto muito do TortoiseSVN, pelas facilidades que ele traz.

Para fazer o download do Tortoise, acesse o link a baixo:
http://tortoisesvn.net/downloads

Baixe o installer correto (32Bit ou 64Bit), e instale.

Apos a instalação você, podera repara que apareceu algumas opções a mais no seu clique direito:

Agora que você ja tem SVN vamos acessar ao repositório do Papervision 3D no Google Code!

http://code.google.com/p/papervision3d/

Ao clicar em source vc devera ver a seguinte tela:

Tudo que precisamos é do endereço do repositório agora:
http://papervision3d.googlecode.com/svn/trunk/

E realizar o CheckOut do mesmo:

Agora ao final do processo, você devera ver a pasta que você selecionou assim:

Isso significa que a mesma esta com a versão mais recente do Projeto!!!

Isto significa que ela não esta com a versão mais recente, e/ou teve alguma alteração, que deve ser Comitada ou Updateada

Bom galera! Para inciar é isso! Assim que possivel, postarei meus primeiros experimentos com a maravilhosa APE!!!