Nunca gostei muito de jogos de tiro, porque para mim a experiência de mirar com as teclas de direção é horrível ! mas quando vi um call of duty para Wii resolvi comprar para experimentar … e tem sido uma experiência de jogo ótima.
a imagem que coloquei eh do agradecimento por jogar que aparece depois da fase bônus final
apesar do jogo de 2 pessoas ser meio estranho, porque o segundo jogador só atira, não move o personagem ficando como se fosse um papagaio armado no seu ombro hehehe, apesar desta “novidade” do jogo cooperativo, tudo é bem interessante a estória é legal, algumas fases são realmente desafiantes e o multiplayer pela internet é ótimo, sempre com pessoas jogando.

resumo da estória, gostei muito !

lembre-se jogar com este acessório faz toda a diferença !

parece besteira, mas colocar um ambiente de programação novo funcionando eh sempre uma novidade !!

seguindo os primeiros passso com o framework de jogos 2D para o Iphone ! primeiros passos começam sempre com um pouco de dor hehehe, estou seguindo esta orientacao inicial …
http://www.cocos2d-iphone.org/wiki/doku.php/prog_guide:lesson_1._install_test

mas jah comecei bem tomando uns erros de compilacao …

mas imagino o que seja, acho que tinha habilitado o profiler para o xcode e agora ao compilar o cocos2d ele esta reclamando que o mesmo nao esta ligado … deve ser isto

huahuahuahuhua muito boa !! os ataques periódicos dos monstrinhos, agora na versão vou te dar um presente de grego !!

iau que joguinho maneiro para facebook !!

gostei do conceito de vc proteger seu territorio, mas ter 14 dias para se preparar
veja mais em : http://apps.facebook.com/backyardmonsters/

edit :
ainda tem a opção de comprar proteção para ninguem encher o saco !!

clique na imagem para jogar e proteger a ilha dos monstros !!
Jogo criado para o Ludum Dare 17

Gerador de trilhas sonoras ! show de bola
http://tones.wolfram.com/

Apos alguns arranhoes e minha vista cansada, porque ainda nao troquei o oculos … fiz algo que funciona, um quadradinho que vai para um lado e para o outro batendo nas paredes

veja que legal, pongme

o codigo fonte eh razoalmente simples:
um arquivo Main.as que faz a inicializacoes do framework flashpunk, uma classe para cada intancia de World, que representa cada cena, por exemplo Menu, o jogo em si, tela de fim de jogo e assim por diante, e objetos filhos de Actor que sao elementos de tela.

seguem os arquivos que usei

main.as

package
{
	import punk.core.*;
	import punk.util.*;
	import punk.*;

	[SWF(width = "480", height = "320")]

	public class Main extends Engine
	{
		public function Main()
		{
			super(480, 320, 60, 1, Menu);
		}
	}
}

menu.as

package
{
	import punk.core.*;
	import punk.util.*;
	import punk.*;

	/**
	 * ...
	 * @author athanazio.com
	 */
	public class Menu extends World
	{

		public function Menu()
		{
			Text.color = 0x667CFF;
			var centerX:int = FP.screen.width / 2;
			var centerY:int = FP.screen.height / 2;

			var title:Text = new Text("PongMe!\nPress Space to play.", centerX, centerY);
			title.size = 15;
			title.center();
			add(title);
		}

		override public function update():void
		{
			if (Input.pressedKey(Key.SPACE))
				FP.goto = new GameWorld();
		}

	}

}

gameworld.as

package
{

	import punk.core.World;
	import punk.Text;

	/**
	 * ...
	 * @author athanazio.com
	 */
	public class GameWorld extends World
	{

		public function GameWorld()
		{
		}

		override public function init():void
		{
			FP.randomizeSeed();

			Text.color = 0x667CFF;
			add(new Text("Game Screen.", 10, 10));

			add(new Player());
			add(new Ball());
			add(new WallTop());
			add(new WallLeft());
			add(new WallRight());
		}
	}

}

player.as

package
{
	import punk.Actor;
	import punk.util.Input;
	import punk.util.Key;

	/**
	 * ...
	 * @author athanazio.com
	 */
	public class Player extends Actor
	{
		private var speed:Number = 3;

		[Embed(source='data/player.png')] private var ImgPlayer:Class;
		public function Player()
		{
			sprite = FP.getSprite(ImgPlayer, 0, 0);
			speed = 6 * (sprite.width / FP.fps);
			setHitbox( sprite.width, sprite.height, 0, 0);

			x = 100;
			y = 200;
			type = "player";

			Input.define("right", Key.RIGHT);
			Input.define("left", Key.LEFT);
			Input.define("up", Key.UP);
			Input.define("down", Key.DOWN);
		}

		override public function update():void
		{
			var newX:Number = x;
			var newY:Number = y;

			if (Input.check("right")) newX += speed;
			if (Input.check("left")) newX -= speed;
			if (Input.check("up")) newY -= speed;
			if (Input.check("down")) newY += speed;

			if ( ! collide("wall", newX, newY) )
			{
				x = newX;
				y = newY;
			}

			var ball:Ball= collide("ball", x, y) as Ball;
			if ( ball )
			{
				ball.speedY = ball.speedY * -1;
			}

		}

	}

}

ball.as

package
{
	import punk.Actor;

	/**
	 * ...
	 * @author athanazio.com
	 */
	public class Ball extends Actor
	{
		public var speedX:Number = 0;
		public var speedY:Number = 0;

		[Embed(source='data/ball.png')]	private var ImgPlayer:Class;
		public function Ball()
		{
			super();
			sprite = FP.getSprite(ImgPlayer, 0, 0);
			speedX = 7 * (sprite.width / FP.fps);
			speedY = 7 * (sprite.width / FP.fps);

			x = 100;
			y = 100;
			type = "ball";
		}

		override public function update():void
		{
			x += speedX;
			y += speedY;
		}

	}

}

wallleft.as

package
{
	import punk.Actor;
	import punk.core.Entity;

	/**
	 * ...
	 * @author athanazio.com
	 */
	public class WallLeft extends Actor
	{
		[Embed(source='data/wall-vert.png')] private var ImgPlayer:Class;
		public function WallLeft()
		{
			sprite = FP.getSprite(ImgPlayer, 0, 0);
			setHitbox( sprite.width, sprite.height, 0, 0);
			x = 0;
			y = 0;
			type = "wall";
		}

		override public function update():void
		{
			var ball:Ball= collide("ball", x, y) as Ball;

			if ( ball )
			{
				ball.speedX = ball.speedX * -1;
			}
		}
	}

}

wallright.as

package
{
	import punk.Actor;
	import punk.core.Entity;

	/**
	 * ...
	 * @author athanazio.com
	 */
	public class WallRight extends Actor
	{
		[Embed(source='data/wall-vert.png')] private var ImgPlayer:Class;
		public function WallRight()
		{
			sprite = FP.getSprite(ImgPlayer, 0, 0);
			setHitbox( sprite.width, sprite.height, 0, 0);
			x = FP.screen.width - sprite.width;
			y = 0;
			type = "wall";
		}

		override public function update():void
		{
			var ball:Ball= collide("ball", x, y) as Ball;

			if ( ball )
			{
				ball.speedX = ball.speedX * -1;
			}
		}

	}

}

walltop.as

package
{
	import punk.Actor;
	import punk.core.Entity;

	/**
	 * ...
	 * @author athanazio.com
	 */
	public class WallTop extends Actor
	{
		[Embed(source='data/wall-top.png')] private var ImgPlayer:Class;
		public function WallTop()
		{
			sprite = FP.getSprite(ImgPlayer, 0, 0);
			setHitbox( sprite.width, sprite.height, 0, 0);
			x = 0;
			y = 0;
			type = "wall";
		}

		override public function update():void
		{
			var ball:Ball= collide("ball", x, y) as Ball;

			if ( ball )
			{
				ball.speedY = ball.speedY * -1;
			}
		}

	}

}

Quando escrevi sobre javaFX uma das constatações foi de que o player com maior abrangencia no mercado eh o flash, e porque nao fazer jogos em flash ? umas das minhas maiores restrições pessoais eh não conhecer uma opção gratuita que tenha foco no desenvolvedor e menos foco no design, porque para mim usar o flash professional para criar os jogos seria um desafio de aprendizado muito grande, alem do produto ser pago.

Acabei pesquisando e perguntando a um amigo que anda desenvolvendo em flash, e descobri a alternativa do FlashDevelop + Flex SDK, que combina uma IDE para desenvolvimento para flash, usando ActionScript, e um compilador de ActionScript que gera o SWF final para ser apresentado nas paginas. Assim estou em casa, codigo codigo codigo + artefatos graficos e audio = jogo.

Bem o processo de instalacao eh bem simples, esta bem documentado aqui
http://www.flashdevelop.org/community/viewtopic.php?f=11&t=5669

alem disto identifiquei um framework que eh muito bem comentado pela comunidade do ludumdare, que eh o flashpunk que tem um monte de exemplos disponiveis em
http://www.brighthub.com/hubfolio/matthew-casperson/blog/archive/2010/03/19/flashpunk-tutorials.aspx

Bem agora eh colocar a mao na massa e ver no que vai dar !

Opa parem tudo !! inscrições abertas para o Global Game Jam no Rio de Janeiro !!!
http://www.riogdug.org/2010/01/05/global-game-jam-2010/

Este evento é muito maneiro participei ano passado, ficamos internados 48horas num lugar, com programadores de jogos, designers, engenheiros de som, artistas de um modo geral, roteiristas, gente de todo tipo, e agrupados criamos videogames em 48horas, excelente experiência !!

te vejo lá !

bem o fim de semana foi bizzarro cheio novidades e aventuras, a mais legal eh um novo morador da casa esta chegando, o Neskau, um simpatico cachorrinho que vai morar conosco, por enquanto como esta desmamando, vem durante o dia e depois volta na mãe … otimo presente de natal para todos nós.

outro ocorrido foi a participação no ludum dare 16, meio desastrosa porque não entreguei um jogo no fim do prazo, mas muito produtiva porque conclui a migracao inicial do framework que estou fazedo para o desktop. A versão inicial soh rodava no android agora tem a versão desktop também, as duas estão assim como direi em estágio alpha mas breve breve terei ao menos uma versão beta com documentação decente, vai esta lah em jaga.athanazio.com

ao menos os desenhos para o jogo ficaram bonitinhos hhhahahhah

Ahhhh 2009 terminando, quanta coisa aconteceu !! minha investida no mercado de jogos esta crescendo, consegui fazer vários jogos este ano, vários mesmo !! dá uma olhada na lista : http://www.athanazio.com/jogos/ e nesta jornada usei diversas tecnologias diferentes: XNA, SDL, Lõve, Java, Unity3D delícia !! agora com a experiência que acumulei estou iniciando o desenvolvimento de um framework para jogos, onde o desenvolvimento será em Lua e o backend em Java.

A implementação da primeira versão de testes foi feita para o sistema operacional Android, e pretendo ter a versão para web pronta para o próximo Ludum Dare ! espera otimas novidades ! assim que tiver um release para download vai estar em jaga.athanazio.com

abs

Opa ! apos algumas idas e vindas no codigo, as coisas começam a se arrumar hehehehe, nesta versão já esta resolvida a exibição de imagem a partir do nome da imagem, e execução de som no formato ogg, tanto no loop como um som a partir de um evento do usuário.

Apesar da recomendação do SDK seja de acessar os arquivos de midia através do resource ID criado na classe R, eu estou construindo as classes usando o nome do resource para poder expandir a programação do jogo para uma lingaguem de script, e usar o java como uma camada de abstração do jogo.

Vamos ao codigo e alguns comentarios sobre cada um :

GameActivity - ganhou uma nova chamada para determinar que volume o jogo vai usar, setVolumeControlStream(AudioManager.STREAM_MUSIC) assim o jogo fica com o mesmo volume que estiver acertado para a musica, alem disto o metodo onDestroy() chama o novo metodo release() da view que vai se encarregar de liberar recursos e em especial mandar os audios se calarem

package com.athanazio.android.showimage;

import android.app.Activity;
import android.media.AudioManager;
import android.os.Bundle;
import android.view.Window;

public class GameActivity extends Activity {
	private GameView view;

	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setVolumeControlStream(AudioManager.STREAM_MUSIC);

		view = new GameView(this, getResources());
		setContentView(view);
	}

	protected void onDestroy() {
		super.onDestroy();
		view.release();
	}

}

GameView – usa as classes Sprite e Audio para exibir imagens e tocar audio, poucas mudanças comparando com a versão anterior.

package com.athanazio.android.showimage;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;

public class GameView extends View implements Runnable {

	private static final String TAG = "GAME VIEW";

	private static final int INTERVAL = 10;
	private Paint cPaint;

	private boolean running = true;

	FPSCounter fps;

	private Sprite background;
	private Sprite cloud;

	private Audio soundtrack;
	private Audio touch;

	public GameView(Context context, Resources resources) {
		super(context);

		String packageName = getClass().getPackage().getName();

		background = new Sprite(resources, packageName, "background");
		cloud = new Sprite(resources, packageName, "cloud");
		cloud.setCenterAtMiddle();

		soundtrack = new Audio(resources, packageName, "soundtrack");
		touch = new Audio(resources, packageName, "cowbell");

		soundtrack.setLooping(true);
		soundtrack.play();

		cPaint = new Paint();
		setFocusable(true);
		setClickable(true);
		setLongClickable(true);

		fps = new FPSCounter();

		// Set the background
		this.setBackgroundColor(Color.WHITE);
		Log.i(TAG, "game view created");

		Thread monitorThread = new Thread(this);
		monitorThread.setPriority(Thread.MIN_PRIORITY);
		monitorThread.start();
	}

	public void draw(Canvas canvas) {
		super.draw(canvas);

		background.draw(canvas);
		cloud.draw(canvas);

		cPaint.setColor(Color.WHITE);
		canvas.drawText(fps.getFPS(), 20, 20, cPaint);
	}

	public boolean onKeyUp(int keyCode, KeyEvent event) {
		return super.onKeyUp(keyCode, event);
	}

	public boolean onKeyDown(int keyCode, KeyEvent event) {
		boolean handled = false;
		Log.i(TAG, "key down");
		float x = cloud.getX();
		float y = cloud.getY();

		if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
			y = y - 5;
			handled = true;
		} else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
			y = y + 5;
			handled = true;
		} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
			x = x - 5;
			handled = true;
		} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
			x = x + 5;
			handled = true;
		}

		cloud.move(x, y);
		return handled;
	}

	public boolean onTouchEvent(MotionEvent event) {
		cloud.setX(event.getRawX());
		cloud.setY(event.getRawY());
		Log.i(TAG, "on touch");

		touch.play();
		return super.onTouchEvent(event);
	}

	public void run() {
		while (running) {
			try {
				Thread.sleep(INTERVAL);
			} catch (InterruptedException e) {
				Log.e(TAG, "main loop finished");
			}
			update();
			postInvalidate();
		}
	}

	private void update() {
		fps.update();

	}

	public void release() {
		running = false;
		soundtrack.release();
		touch.release();
	}

}

Sprite – esta eh responsavel por exibir imagens na tela, uma atenção especial deve ser dada ao recurso de determinar o centro da imagem, isto eh muito util para responder eventos de mouse, e por exemplo posicionar a imagem centralizada onde o usuário clicou, o método setCenterAtMiddle() calcula a posição para desenhar baseado na largura e altura da imagem. e por default o centro da imagem eh no 0,0.

package com.athanazio.android.showimage;

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.util.Log;

public class Sprite {

	private static final String TAG = "GAME SPRITE";
	private Bitmap bitmap;
	private float x;
	private float y;
	private float centerX;
	private float centerY;
	private float drawX;
	private float drawY;
	private Paint paint;

	public Sprite(Resources resources, String packageName, String name) {
		String logFileName = packageName + " " + name;
		Log.i(TAG, "loading image : " + logFileName);

		int id = resources.getIdentifier(name, "drawable", packageName);
		bitmap = BitmapFactory.decodeResource(resources, id);
		centerX = 0;
		centerY = 0;

		setX(0);
		setY(0);

		this.paint = new Paint();
	}

	public void draw(Canvas canvas) {
		canvas.drawBitmap(bitmap, drawX, drawY, paint);
	}

	public void move(float x, float y) {
		setX(this.x + x);
		setY(this.y + y);
	}

	public void setCenterAtMiddle(){
		centerX = bitmap.getWidth() / 2F;
		centerY = bitmap.getHeight() / 2F;
	}

	public float getX() {
		return x;
	}

	public void setX(float x) {
		this.x = x;
		drawX = this.x - centerX;
	}

	public float getY() {
		return y;
	}

	public void setY(float y) {
		this.y = y;
		drawY = this.y - centerY;
	}

}

Audio – esta classe esconde a criação de um MediaPlayer para cada som que se deseja tocar, imagino que o melhor cenário seria ter uma classe para som em loop que usaria um MediaPlayer, e outra classe para efeitos sonoros que tocaria no maximo N efeitos ao mesmo tempo, mantendo menos objetos MediaPlayer na memória.

Mas a implementação atual mantém um MediaPlayer para cada som, observar que o resource ID é recuperado pelo nome do arquivo usando o metodo resources.getIdentifier(name, “raw”, packageName) e a partir do resource ID podemos recuperar o AssetFileDescriptor com a chamada resources.openRawResourceFd(id), of file descriptor é usado para inicializar o MediaPlayer com os detalhes necessários a execução do som.

package com.athanazio.android.showimage;

import android.content.res.AssetFileDescriptor;
import android.content.res.Resources;
import android.media.MediaPlayer;
import android.util.Log;

/**
 * Audio resources abstraction
 *
 * @author athanazio
 * @see "http://developer.android.com/intl/fr/guide/topics/media/index.html"
 * @see "http://developer.android.com/intl/fr/reference/android/media/MediaPlayer.html#Valid_and_Invalid_States"
 */
public class Audio {

	private static final String TAG = "GAME AUDIO";
	private MediaPlayer player;
	private boolean ready;
	private int id;
	private AssetFileDescriptor afd;

	/**
	 *
	 * @param resources
	 * @param context
	 * @param packageName
	 * @param name
	 *
	 */
	public Audio(Resources resources, String packageName, String name) {
		String logFileName = packageName + " " + name;
		Log.i(TAG, "loading audio : " + logFileName);

		ready = false;
		player = new MediaPlayer();

		try {
			this.id = resources.getIdentifier(name, "raw", packageName);
			this.afd = resources.openRawResourceFd(id);

			Log.i(TAG, "loading audio : " + logFileName + " id:" + id);

			player.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
			player.setLooping(false);
			player.prepare();

			// reset the player after completion
			player.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
				public void onCompletion(MediaPlayer mp) {
					try {
						player.reset();
						player.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
						player.prepare();
					} catch (Exception e) {
						Log.e(TAG, "error resetting the media player");
						e.printStackTrace();
					}
				}
			});

			ready = true;

		} catch (Exception e) {
			Log.e(TAG, "ERROR loading audio : " + logFileName);
			e.printStackTrace();
		}
	}

	public void play() {
		if (ready) {
			player.start();
		} else {
			Log.i(TAG, "the player is not ready.");
		}
	}

	public void setLooping(boolean b) {
		player.setLooping(b);
	}

	public void release() {
		player.stop();
		player.release();
	}

}

Na minha opinão o hello world para desenvolver jogos eh mover um desenho primitivo na tela junto com a informação de FPS (frames por segundo) até porque logo logo perguntamos : tah rodando a quantos FPS ? assim sendo já posso dizer que fiz o meu hello world para o android.

Alguns links que ajudaram bastante foram estes :

Uma apresentação da google sobre o desenvolvimento para de jogos para o Android
Writing-Real-Time-Games-for-Android

Os exemplos de cógigo citados na apresentação
C2B 2 GameView

Com certeza este exemplo que escrevi eh extremamente simples, mas exemplifica alguns elementos básicos :

• main loop
• chamada de update
• atualização da area de vizualização
• input do usuário

O ambiente que tenho eh o Eclipse com o plugin para desenvolvimento do android instalado, para os testes eu prefiro usar o telefone porque o emulador demora muito para inicializar e este exemplo tem basicamento 3 classes :

GameActivity – que eh a entrada da aplicação, nela eu solicito o uso fullscreen para o jogo, e determino que a visualização será realizada por uma instancia da classe GameView.

package com.athanazio.android.moveball2;

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;

public class GameActivity extends Activity {
	private GameView view;

	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);

		view = new GameView(this);
		setContentView(view);
	}

	protected void onPause() {
		super.onPause();
		view.pause();
	}
}

GameView – nesta classe reside o loop principal do jogo que é iniciado no final do construtor, note que na verdade eh criado um Thread com baixa prioridade, que passará a realizar as atividades de atualização e principalmente executar o método postupdate() notficando a interface que pode ser exibida.

além do loop principal o input direcional é tratado pelo método onKeyDown() e o tocar na tela pelo método onTouchEvent()

package com.athanazio.android.moveball2;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;

public class GameView extends View implements Runnable {

	private static final String TAG = "GAMEVIEW";

	private static final int INTERVAL = 10;
	private Paint cPaint;

	private float x = 50;

	private float y = 50;

	private boolean running = true;

	FPSCounter fps;

	public GameView(Context context) {
		super(context);
		cPaint = new Paint();
		setFocusable(true);
		setClickable(true);
		setLongClickable(true);

		fps = new FPSCounter();

		// Set the background
		this.setBackgroundColor(Color.WHITE);
		Log.i(TAG, "game view created");

		Thread monitorThread = new Thread(this);
		monitorThread.setPriority(Thread.MIN_PRIORITY);
		monitorThread.start();
	}

	public boolean onKeyUp(int keyCode, KeyEvent event) {
		return super.onKeyUp(keyCode, event);
	}

	public boolean onKeyDown(int keyCode, KeyEvent event) {
		boolean handled = false;
		Log.i(TAG, "key down");

		if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
			y = y - 5;
			handled = true;
		} else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
			y = y + 5;
			handled = true;
		} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
			x = x - 5;
			handled = true;
		} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
			x = x + 5;
			handled = true;
		}
		return handled;
	}

	public boolean onTouchEvent(MotionEvent event) {
		x = event.getRawX();
		y = event.getRawY();
		Log.i(TAG, "on touch");

		return super.onTouchEvent(event);
	}

	public void draw(Canvas canvas) {
		super.draw(canvas);

		cPaint.setColor(Color.BLUE);
		canvas.drawCircle(x, y, 15, cPaint);

		cPaint.setColor(Color.BLACK);
		canvas.drawText(fps.getFPS(), 20, 20, cPaint);

	}

	public void run() {
		while (running) {
			try {
				Thread.sleep(INTERVAL);
			} catch (InterruptedException e) {
				Log.e(TAG, "main loop finished");
			}
			update();
			postInvalidate();
		}
	}

	private void update() {
		fps.update();

	}

	public void pause() {
		running = false;
	}

}

FPSCounter – nesta classe é feita uma contagem de frames que o jogo consegue exibir por segundo, vi algumas implementações interessantes disto, mas acabei fazendo o mais simples e mais econômico, contar frames e ver se jah passou o tempo note que algumas variáveis eu criei fora dos métodos para evitar que o Garbage collector tivesse que trabalhar, querendo ou não isto economiza alguns milisegundos

package com.athanazio.android.moveball2;

import java.text.DecimalFormat;

import android.os.SystemClock;

public class FPSCounter {

	public static final DecimalFormat format = new DecimalFormat("###0.00");

	private float frames;
	private String fps;
	private long start;
	private long current;

	public FPSCounter() {
		start = SystemClock.uptimeMillis();
		frames = 0;
		fps = "???";
	}

	public void update() {
		frames ++;
		current = SystemClock.uptimeMillis();
		if( current - start > 1000 ){
			fps = format.format(frames);
			frames = 0;
			start = current;
		}
	}

	public String getFPS() {
		return fps;
	}
}

a propósito o fps esta em torno de 90 e poucos, vamos ver o que acontece quando tiver de desenhar uma imagem no fundo e varias outras na tela hehehehe.

apos uma pequena pesquisa, esbarrei com alguns frameworks para jogos para o android

• http://code.google.com/p/juicygames/
• http://code.google.com/p/cloak/
• http://code.google.com/p/rokon/
• http://code.google.com/p/mages/

estou explorando para servir de ideias para o framework de jogos que vou criar para o android !!! se preparem

sbgames 2009 – fast track – JavaFX evaluation from Hamilton Lima on Vimeo.

nova versao do jogo drop then all
algumas novidades :
- mais um nivel
- mudanca da camera com o mouse
- melhorias visuais
- mudanca no som das caixinhas
- adicionado help na primeira pagina

clique aqui para jogar !

Esta eh uma versao mais arrumada destas minhas investigacoes do Unity3D.

Alguns comentarios sobre o codigo abaixo que eh novinho em folha.

static var dead:int = 0;

function Awake () {
	dead = 0;
}

function OnCollisionEnter(collision : Collision) {

	if( collision.collider.name == "bottom" || collision.collider.tag == "enemy"){
		dead = 1;
		var message = GameObject.Find("end of level");
		var message2 = GameObject.Find("end of level2");
		message.guiText.text = "You failed.";
		message2.guiText.text = "Click to restart";
		audio.Play();
	}
}

function Update () {

	if( dead == 1 ){
		if (Input.GetButtonDown("Fire1")) {
			Application.LoadLevel (Application.loadedLevel);
		}
	}

}

Este codigo esta associado ao personagem que esta em movimento, ou seja se o danado colidir com o plano chamado “bottom” que esta abaixo das plataformas, ou com algum dos inimigos a variavel dead eh setada para 1, algumas mensagens sao exibidas e o som correspondente toca.

Quando estiver neste estado de “morto” (dead==1) o update deste mesmo script vai verificar se o click foi pressionado para ai entao recarregar a cena atual, detalhe que a funcao Awake garante que nao reiniciamos a cena com o personagem morto porque a variavel eh static e portanto o reload da cena nao apaga seu valor.

usei esta variavel em outros pontos do de outros scripts, como por exemplo para impedir que o tiro fosse disparado ou o personagem movimentado se estivesse no estado de morto, veja como foi usado

var speed:int = 10.0;

function FireRocket () {
	// dont fire if the char is dead
	if (restart_if_char_die.dead == 1) return;
	if( count_enemies.end_level == 1) return;

	var bullet = GameObject.CreatePrimitive(PrimitiveType.Sphere);
	bullet.tag = "bullet";
	bullet.AddComponent(Rigidbody);

	bullet.transform.position = transform.position;
	bullet.transform.rotation= transform.rotation;
	bullet.transform.localScale= transform.localScale;

    bullet.rigidbody.velocity = transform.forward * speed * -1;
	bullet.rigidbody.mass = 5;
	audio.Play();
}

function Update () {
    if (Input.GetButtonDown("Fire1")) {
        FireRocket();
    }
}

bom eh isto ae divirta-se jogando as caixinhas do alto, pena que elas nao gritam

Alem das coisas em 3D que giram explodem e coisa e tal precisamos de textos 2D pendurados em alguns lugares da tela, para isto adicionamos um GUIText, e o legal do GUIText eh o seu posicionamento na tela, que eh bem simples usando somente as coordenadas X e Y (2D pelamordeDEus) no intervalo de 0 a 1.

canto superior esquerdo : X=0 e Y=1
canto superior direito : X=0.9 e Y=1
canto inferior esquerdo : X=0 e Y=0.1
canto inferior direito : X=0.9 e Y=0.1

bons texto pra vc