Programação de jogos com java

Boa dica!

Preciso construir um jogo Space Invader hhehe!
Quem sabe esse livro me auxilia!

Estou tendo experiencia agora em JME e SuperWaba…
Ja ate fiz um joguinho bobo de adivinhar número…

Então você vai gostar ainda mais desse site!
http://www.cokeandcode.com/spaceinvaderstutorial

E é em java!

Valeu cara vou dar uma olhada!

eu também ja fiz meus joguinhos em Java.

JPONG http://www.unidev.com.br/centroprojeto.asp?id=512

JSpaceInvaders http://www.unidev.com.br/centroprojeto.asp?id=500

o meu irmão fez no TCC dele um jogo em Xith3D http://xith.org/, em conjunto com o TCC de um amigo que fez um em jMe (ou jMonkey) http://jmonkeyengine.com/

jMe dá de 10000000 no Xith :roll: mas ambas são boas para aquela primeira experiência.

A propósito, jME possui melhores recursos de interface

[]'s

algum de vocês já usaram monkeyWorld3d? parece uma ferramenta mais intuitiva pra desenvolver gráficos usando a api jMonkeyEngine. o que podem me dizer sobre?

Estou desenvolvendo o jogo Tetris em java Alguem poderia me dar umas dicas de algum livro mas especifico que possa me auxiliar no desenvolviemnto da parte grafica do game? :?:

Pessoal,

o java é uma boa linguagem para desenvolvimento de jogos 3D/2D? Aliás, são feitos jogos 3D em java? falo isso porque também tive de desenvolver um jogo na faculdade, só que fiz em allegro… e sinceramente eu vi que depende-se tanto do design que até desanimei…

Com certeza me interesso . Gosto muito de jogos, mas ainda não parei efetivamente para pesquisar. Então vai minha pergunta: começo usando alguma engine, para desktop, mesmo sabendo que “não há” mercado, ou vou direto para jogos J2ME?

Até que ponto posso me dedicar a uma engine específica?
Alguém conhece alguma empresa no DF que desenvolve jogos em java?

Obrigado.

Depois de muito estudar jogos desktop em Java, cheguei a conclusão que é uma péssima idéia faze-los. Use outras linguagens melhores, como C++ ou C#. Jogos em Java, sejam 3D ou 2D são raras exceções. Você só vai usar java mesmo se for desenvolver para um nicho, como o Android.

A única empresa de jogos do DF que ouvi falar foi a Dynamic Light Studios, que faz o Legend Alive:

[youtube]http://www.youtube.com/watch?v=_E1VbdnYEck[/youtube]

[youtube]http://www.youtube.com/watch?v=gVkaVJkgKxU[/youtube]

http://www.legend-alive.com/

Mas duvido que tenham usado Java. O mais provável é o C# com a Unity, ou o próprio C++.

Mas devem ter empresas trabalhando com jogos em Android por aí. Eu não apostaria minhas fichas em J2ME hoje em dia.

Para o colega do tetris que ressuscitou o tópico de 2008. Leia os tutoriais do Ponto V (links na minha assinatura) ou o livro e o tutorial indicado no início do tópico!

putz! nem me toquei que sua dica era de 2006 affs! sem comentários…
JavaTeenager

Olá, pessoal, desculpem-me por ressuscitar esse tópico, mas é que também me envolvi nesse negócio de programar jogos em Java.
Poxa vida, Vini, eu que colocava minhas fichas em jogos desenvolvidos em Java, agora leio esse seu último post e fico perplexo !
Bem, depois de estudar os conceitos básicos e alguns avançados em Java, comecei a estudar desenvolvimento de jogos em Java.
Minha intenção é utilizar as técnicas de programação de jogos para programar simulações em física (sou profeesor de física!).
Deu uma pesquisada aqui no fórum e baixei o Killer Gaming Programing in java, mas confesso que fiquei bastante confuso com o livro, não me dou muito bem com o Inglês técnico, apesar de me comunicar bem em Inglês.
Resolvi então comprar um livro em Portugês de jogos em Java, comprei o Programação de Games com Java, editora Cengage Learning, autor Jonathan S. Harbour e confesso que gostei da didática do livro. a obra começa com o bem básico mesmo, o que eu quero! No capítulo 3 o autor já coloca o código de um joguinho bem simples baseado no jogo Asteroids, do Atari. Escrevi o código inteiro, ele deve rodar em uma applet, mas não obtive sucesso, há muitos erros, NullExceptionPointer e outros erros que não consigo resolver por causa de inexperiência com as técnicas de programação de jogos.
Se alguém pudesse me ajudar, ficaria muito grato.
Bem, o jogo é composto de 5 classes: BaseVectorShape (que é a classe mãe), Asteroid (que controla os asteroides), Bullet (que controla as balas), Ship (que controla a nave), e Asteroids (que é a applet que roda o jogo no navegador).

Os códigos das classes estão logo abaixo:

Classe BaseVectorShape:

package galactWarPackage;

import java.awt.Shape;

/*********************************************************************
 * Base vector shape class for polygonal shapes
 * @author valder
 *********************************************************************/

public class BaseVectorShape
{
	// Variáveis
	private Shape shape;
	private boolean alive;
	private double x,y;
	private double velX, velY;
	private double moveAngle, faceAngle;
	
	// Métodos
	
	public Shape getShape()
	{
		return shape;
	}
	
	public boolean isAlive()
	{
		return alive;
	}
	
	public double getX()
	{
		return x;
	}
	
	public double getY()
	{
		return y;
	}
	
	public double getVelX()
	{
		return velX;
	}
	
	public double getVelY()
	{
		return velY;
	}
	
	public double getMoveAngle()
	{
		return moveAngle;
	}
	
	public double getFaceAngle()
	{
		return faceAngle;
	}
	
	// Mutador and helper methods
	
	public void setShape(Shape shape)
	{
		this.shape = shape;
	}
	
	public void setAlive(boolean alive)
	{
		this.alive = alive;
	}
	
	public void setX(double x)
	{
		this.x = x;
	}
	
	public void incX(double i)
	{
		this.x += i;
	}
	
	public void setY(double y)
	{
		this.y = y;
	}
	
	public void incY(double i)
	{
		this.y += i;
	}
	
	public void setVelX(double velX)
	{
		this.velX = velX;
	}
	
	public void incVelX(double i)
	{
		this.velX += i;
	}
	
	public void setVelY(double velY)
	{
		this.velY = velY;
	}
	
	public void incVelY(double i)
	{
		this.velY += i;
	}
	
	public void setFaceAngle(double angle)
	{
		this.faceAngle = angle;
	}
	
	public void incFaceAngle(double i)
	{
		this.faceAngle += i;
	}
	
	public void setMoveAngle(double angle)
	{
		this.moveAngle = angle;
	}
	
	public void incMoveAngle(double i)
	{
		this.moveAngle += i;
	}
	
	// Default constructor
	
	BaseVectorShape()
	{
		setShape(null);
		setAlive(false);
		setX(0.0);
		setY(0.0);
		setVelX(0.0);
		setVelY(0.0);
		setMoveAngle(0.0);
		setFaceAngle(0.0);
	}
}

Classe Ship:

package galactWarPackage;

import java.awt.Polygon;
import java.awt.Rectangle;

/**************************************************************
 * Ship class - Polygonal shape of the player's ship
 * @author valder
 **************************************************************/

public class Ship extends BaseVectorShape
{
	// Define the ship polygon
	private int[] shipx = {-6,-3,0,3,6,0};
	private int[] shipy = {6,7,7,7,6,-7};
	
	// Bounding Rectangle
	
	public Rectangle getBounds()
	{
		Rectangle r;
		r = new Rectangle((int)getX()-6, (int)getY()-6,12,12);
		return r;
	}
	
	// Default Constructor
	
	Ship()
	{
		setShape(new Polygon(shipx, shipy, shipx.length));
		setAlive(true);
	}
}

Classe Asteroid:

package galactWarPackage;

import java.awt.Polygon;
import java.awt.Rectangle;

/***********************************************************************
 * Asteroid class - for polygonal asteroid shapes 
 * @author valder
 ***********************************************************************/

public class Asteroid extends BaseVectorShape
{
	// Define the asteroid polygon shape
	private int[] astx = {-20,-13,0,20,22,20,12,2,-10,-22,-16};
	private int[] asty = {20,23,17,20,16,-20,-22,-14,-17,-20,-5};
	
	// Rotation Speed
	
	protected double rotVel;
	public double getRotationVelocity()
	{
		return rotVel;
	}
	
	public void setRotationVelocity(double v)
	{
		rotVel = v;
	}
	
	//Bounding Rectangle
	
	public Rectangle getBounds()
	{
		Rectangle r;
		r = new Rectangle((int)getX()-20,(int)getY()-20, 40, 40);
		return r;
	}
	
	// Default Constructor
	
	Asteroid()
	{
		setShape(new Polygon(astx,asty,astx.length));
		setAlive(true);
		setRotationVelocity(0.0);
	}
}

Classe Bullet:

package galactWarPackage;

import java.awt.*;
import java.awt.Rectangle;

/************************************************************
 * Bullet class - Polygonal shape of a bullet
 * @author valder
 ************************************************************/

public class Bullet extends BaseVectorShape
{
	public Rectangle getBounds()
	{
		Rectangle r;
		r = new Rectangle((int)getX(), (int)getY(),1,1);
		return r;
	}
	
	// Default Constructor
	Bullet()
	{
		// Create the bullet shape
		setShape(new Rectangle(0,0,1,1));
		setAlive(false);
	}
}

E a classe Asteroids

package galactWarPackage;

/********************************************************************
 * Chapter 3 - Asteroids Game 
 ********************************************************************/

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.util.*;

/********************************************************************
 * Primary class for the game
 ********************************************************************/

public class Asteroids extends Applet implements Runnable, KeyListener
{
	// The main thread becomes the game loop
	Thread gameloop;
	
	// Use this as a double buffer
	BufferedImage backbuffer;
	
	// The main drawing object for the back buffer
	Graphics2D g2d;
	
	// Toggle for drawing bounding boxes
	boolean showbounds = false;
	
	// Create the asteroid array
	int ASTEROIDS = 20;
	Asteroid[] ast = new Asteroid[ASTEROIDS];
	
	// Create the bullet array
	int BULLETS = 10;
	Bullet[] bullet = new Bullet[BULLETS];
	int currentBullet = 0;
	
	// The player's ship
	Ship ship = new Ship();
	
	// Create a indentity transform (0,0)
	AffineTransform identity = new AffineTransform();
	
	// Create a random number generator
	Random rand = new Random();
	
	/********************************************************************
	 * Applet init event
	 ********************************************************************/
	public void init()
	{
		// Create the back buffer for smooth graphics
		backbuffer = new BufferedImage(640,480,BufferedImage.TYPE_INT_RGB);
		g2d = backbuffer.createGraphics();
		
		//Set up the ship
		ship.setX(320);
		ship.setY(240);
		
		// Set up the bullets
		for(int n = 0; n < ASTEROIDS; n++)
		{
			ast[n] = new Asteroid();
			ast[n].setRotationVelocity(rand.nextInt(3)+1);
			ast[n].setX((double)rand.nextInt(600)+20);
			ast[n].setY((double)rand.nextInt(440)+20);
			ast[n].setMoveAngle(rand.nextInt(360));
			double ang = ast[n].getMoveAngle()-90;
			ast[n].setVelX(calcAngleMoveX(ang));
			ast[n].setVelY(calcAngleMoveY(ang));
		}
		
		// Start the user input listener
		addKeyListener(this);
	}
	
	
	/********************************************************************
	 * Applet update event to redraw the screen 
	 ********************************************************************/
	
	public void update(Graphics g)
	{
		// Start off transforms at identity
		g2d.setTransform(identity);
		
		// Erase the background
		g2d.setPaint(Color.BLACK);
		g2d.fillRect(0, 0, getSize().width, getSize().height);
		
		// Print some status information
		g2d.setColor(Color.WHITE);
		g2d.drawString("Ship:" + "," + Math.round(ship.getX())+ "," + Math.round(ship.getY()),5, 10);
		g2d.drawString("Move angle: " + Math.round(ship.getMoveAngle())+90,5,25);
		g2d.drawString("Face angle: " + Math.round(ship.getFaceAngle()),5,40);
		
		// Draw the game graphics
		drawShip();
		drawBullets();
		drawAsteroids();
		
		// Repaint the applet window
		paint(g);
	}
	
	/********************************************************************
	 * drawShip called by applet update event 
	 ********************************************************************/
	
	public void drawShip()
	{
		g2d.setTransform(identity);
		g2d.translate(ship.getX(),ship.getY());
		g2d.rotate(Math.toRadians(ship.getFaceAngle()));
		g2d.setColor(Color.ORANGE);
		g2d.fill(ship.getShape());
	}
	
	/********************************************************************
	 * drawBullets called by applet update event 
	 ********************************************************************/
	
	public void drawBullets()
	{
		// Iterate through the array of bullets
		for(int n = 0; n < BULLETS; n++)
		{
			// is the bullet currently in use?
			if(bullet[n].isAlive())
			{
				// Draw the bullet
				g2d.setTransform(identity);
				g2d.translate(bullet[n].getX(), bullet[n].getY());
				g2d.setColor(Color.MAGENTA);
				g2d.draw(bullet[n].getShape());
			}
		}
	}
	
	/********************************************************************
	 * drawAsteroids called by applet update event 
	 ********************************************************************/
	
	public void drawAsteroids()
	{
		// Iterate through asteroids array
		for(int n = 0; n < ASTEROIDS; n++)
		{
			// Is this asteroid being used?
			if(ast[n].isAlive())
			{
				// Draw the asteroid
				g2d.setTransform(identity);
				g2d.translate(ast[n].getX(), ast[n].getY());
				g2d.rotate(Math.toRadians(ast[n].getMoveAngle()));
				g2d.setColor(Color.DARK_GRAY);
				g2d.fill(ast[n].getShape());
			}	
		}
	}
	
	/********************************************************************
	 * Applet window repaint event -- draw the back buffer
	 ********************************************************************/
	
	public void paint(Graphics g)
	{
		// Draw the back buffer onto the applet window
		g.drawImage(backbuffer,0,0,this);
	}
	/********************************************************************
	 * Thread start event - start the game loop running
	 ********************************************************************/
	
	public void start()
	{
		// Create the gameloop thread for real - time update
		gameloop = new Thread(this);
		gameloop.start();
	}
	
	/********************************************************************
	 * Thread run event (game loop)
	 ********************************************************************/
	
	public void run()
	{
		// Acquire the current thread
		Thread t = Thread.currentThread();
		
		// Keep going as long as the thread is alive
		while(t == gameloop)
		{
			try
			{
				// update the game loop
				gameUpdate();
				
				// Target framerate is 50 fps
				Thread.sleep(20);
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
			repaint();
		}
	}
	
	/********************************************************************
	 * Thread stop event
	 ********************************************************************/
	
	public void stop()
	{
		// Kill the gameloop thread
		gameloop = null;
	}
	
	
	/********************************************************************
	 * Move and animate the objects in the game
	 ********************************************************************/
	
	public void gameUpdate()
	{
		updateShip();
		updateBullets();
		updateAsteroids();
		checkCollisions();
	}
	
	/********************************************************************
	 * Update the ship position based on velocity
	 ********************************************************************/
	
	public void updateShip()
	{
		// Update ship's X positions
		ship.incX(ship.getVelX());
		
		// Wrap around left/right
		if(ship.getX()<-10)
			ship.setX(getSize().width+10);
		else if(ship.getX()>getSize().width+10)
			ship.setX(-10);
		
		//Update ship's Y position
		ship.incY(ship.getVelY());
		
		// Wrap around top/bottom
		if(ship.getY()<-10)
			ship.setY(getSize().height+10);
		else if(ship.getY()>getSize().height+10)
			ship.setY(-10);
	}
	
	/********************************************************************
	 * Update the bullets based on velocity
	 ********************************************************************/
	
	public void updateBullets()
	{
		// Move each of the bullets
		for(int n = 0;n<BULLETS;n++)
		{
			// Is the bullet  being used?
			if(bullet[n].isAlive())
			{
				// Update bullet's x position
				bullet[n].incX(bullet[n].getVelX());
				
				// Bullet disappears at left/right edge
				if(bullet[n].getX()<0||bullet[n].getX()>getSize().width)
					bullet[n].setAlive(false);
				
				// Update bullet's y position
				bullet[n].incY(bullet[n].getVelY());
				
				// Bullet disappears at top/bottom edge
				if(bullet[n].getY()<0||bullet[n].getY()>getSize().height)
					bullet[n].setAlive(false);
			}
		}
	}
	
	/********************************************************************
	 * Update the asteroids based on velocity
	 ********************************************************************/
	
	public void updateAsteroids()
	{
		// Move and rotate the asteroids
		for(int n = 0; n<ASTEROIDS; n++)
		{
			// Is the asteroid being used?
			if(ast[n].isAlive())
			{
				// Update the asteroid's X value
				ast[n].incX(ast[n].getVelX());
				
				// Warp the asteroid at screen edge
				if(ast[n].getX()<20)
					ast[n].setX(getSize().width+20);
				else if(ast[n].getX()>getSize().width+20)
					ast[n].setX(-20);
				
				// Update the asteroid's Y value
				ast[n].incY(ast[n].getVelY());
				
				// Warp the asteroid at the screen edge
				if(ast[n].getY()<-20)
					ast[n].setY(getSize().height+20);
				else if(ast[n].getY()>getSize().height+20)
					ast[n].setY(-20);
				
				// Update the asteroid's rotation
				ast[n].incMoveAngle(ast[n].getRotationVelocity());
				
				// Keep the angle within 0-359 degrees
				if(ast[n].getMoveAngle()<0)
					ast[n].setMoveAngle(360-ast[n].getRotationVelocity());
				else if(ast[n].getMoveAngle()>360)
					ast[n].setMoveAngle(ast[n].getRotationVelocity());
			}
		}
	}
	
	/********************************************************************
	 * Test asteroids for collisions with ship or bullets
	 ********************************************************************/
	
	public void checkCollisions()
	{
		// Iterate through the asteroids array
		for(int m=0; m<ASTEROIDS; m++)
		{
			// Is this asteroid being used?
			if(ast[m].isAlive())
			{
				/*
				 * Check for collision with bullet
				 */
				
				for(int n=0;n<BULLETS; n++)
				{
					// Is this bullet being used?
					if(bullet[n].isAlive())
					{
						// Perform the collision test
						if(ast[m].getBounds().contains(bullet[n].getX(), bullet[n].getY()))
						{
							bullet[n].setAlive(false);
							ast[m].setAlive(false);
							continue;
						}
					}
				}
				
				/*
				 * Check for collision with ship
				 */
				
				if(ast[m].getBounds().intersects(ship.getBounds()))
				{
					ast[m].setAlive(false);
					ship.setX(320);
					ship.setY(240);
					ship.setFaceAngle(0);
					ship.setVelX(0);
					ship.setVelY(0);
					continue;
				}			
			}
		}
	}
	
	/********************************************************************
	 * Key listener events
	 ********************************************************************/
	
	public void keyReleased(KeyEvent k){}
	public void keyTyped(KeyEvent k){}
	public void keyPressed(KeyEvent k)
	{
		int keyCode = k.getKeyCode();
		
		switch(keyCode)
		{
			case KeyEvent.VK_LEFT:
			    // left arrow rotates ship left 5 degrees
				ship.incFaceAngle(-5);
				if(ship.getFaceAngle()<0)
					ship.setFaceAngle(360-5);
				break;
			
			case KeyEvent.VK_RIGHT:
				// Right arrow rotates ship 5 degrees
				ship.incFaceAngle(5);
				if(ship.getFaceAngle()>360)
					ship.setFaceAngle(5);
				break;
			
			case KeyEvent.VK_UP:
				// Up arrow add thrust to ship (1/10 normal speed)
				ship.setMoveAngle(ship.getFaceAngle()-90);
				ship.incVelX(calcAngleMoveX(ship.getMoveAngle())*0.1);
				ship.incVelY(calcAngleMoveY(ship.getMoveAngle())*0.1);
				break;
				
			// Ctrl, Enter, or Space can be used to fire weapon
			case KeyEvent.VK_CONTROL:
			case KeyEvent.VK_ENTER:
			case KeyEvent.VK_SPACE:
				// Fire a bullet
				currentBullet++;
				if(currentBullet>BULLETS-1)
					currentBullet = 0;
				bullet[currentBullet].setAlive(true);
				
				// Point bullet in same direction ship is facing
				bullet[currentBullet].setX(ship.getX());
				bullet[currentBullet].setY(ship.getY());
				bullet[currentBullet].setMoveAngle(ship.getFaceAngle()-90);
				
				// Fire bullet at angle of the ship
				double angle = bullet[currentBullet].getMoveAngle();
				double svx = ship.getVelX();
				double svy = ship.getVelY();
				bullet[currentBullet].setVelX(svx + calcAngleMoveX(angle)*2);
				bullet[currentBullet].setVelY(svy + calcAngleMoveY(angle)*2);
				break;
		}
	}
	
	/********************************************************************
	 * Calculate X movement value based on direction angle
	 ********************************************************************/
	
	public double calcAngleMoveX(double angle)
	{
		return (double)(Math.cos(angle*Math.PI/180));
	}
	
	/********************************************************************
	 * Calculate Y movement value based on direction angle
	 ********************************************************************/
	
	public double calcAngleMoveY(double angle)
	{
		return (double)(Math.sin(angle*Math.PI/180));
	}
}

Quando executo a applet, após criar o devido arquivo HTML, aparece um problema, quendo clico para ver a mensagem aparece a seguinte mensagem:

Detected from bootclasspath: C:\\PROGRA~1\\Java\\jre7\\lib\\deploy.jar
Plug-in Java 10.0.0.147
Usando versão JRE 1.7.0-b147 Java HotSpot(TM) Client VM
Diretório home do usuário = C:\Users\valder
----------------------------------------------------
c:   limpar janela da console
f:   concluir objetos da fila de finalização
g:   coleta de lixo
h:   exibir esta mensagem de ajuda
l:   descartar lista de carregadores de classes
m:   imprimir uso de memória
o:   log do trigger
q:   ocultar console
r:   recarregar configuração da política
s:   descartar propriedades do sistema e de implantação
t:   descartar lista de threads
v:   descartar pilha de threads
x:   limpar cache do carregador de classes
0-5: definir nível de rastreamento como <n>
----------------------------------------------------

Daí resolvi rodar a aplicação dentro do Eclipse para ver o que dava, pois o Eclipse aponta melhor os erros. Rodei como um aplicativo Applet. A Applet é inicializada, é aberta uma tela preta pequena dizendo que a applet foi iniciada, mas aparece os erros abaixo:

Exception in thread "Thread-3" java.lang.NullPointerException
	at galactWarPackage.Asteroids.updateBullets(Asteroids.java:271)
	at galactWarPackage.Asteroids.gameUpdate(Asteroids.java:231)
	at galactWarPackage.Asteroids.run(Asteroids.java:200)
	at java.lang.Thread.run(Unknown Source)

Quando posiciono o ponteiro do mouse na tela da Applet e simpesmente teclo enter, aparecem os erros a seguir:

Exception in thread "Thread-3" java.lang.NullPointerException
	at galactWarPackage.Asteroids.updateBullets(Asteroids.java:271)
	at galactWarPackage.Asteroids.gameUpdate(Asteroids.java:231)
	at galactWarPackage.Asteroids.run(Asteroids.java:200)
	at java.lang.Thread.run(Unknown Source)
Exception in thread "AWT-EventQueue-1" java.lang.NullPointerException
	at galactWarPackage.Asteroids.keyPressed(Asteroids.java:422)
	at java.awt.Component.processKeyEvent(Unknown Source)
	at java.awt.Component.processEvent(Unknown Source)
	at java.awt.Container.processEvent(Unknown Source)
	at java.awt.Component.dispatchEventImpl(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(Unknown Source)
	at java.awt.KeyboardFocusManager.redispatchEvent(Unknown Source)
	at java.awt.DefaultKeyboardFocusManager.dispatchKeyEvent(Unknown Source)
	at java.awt.DefaultKeyboardFocusManager.preDispatchKeyEvent(Unknown Source)
	at java.awt.DefaultKeyboardFocusManager.typeAheadAssertions(Unknown Source)
	at java.awt.DefaultKeyboardFocusManager.dispatchEvent(Unknown Source)
	at java.awt.Component.dispatchEventImpl(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(Unknown Source)
	at java.awt.EventQueue.dispatchEventImpl(Unknown Source)
	at java.awt.EventQueue.access$000(Unknown Source)
	at java.awt.EventQueue$3.run(Unknown Source)
	at java.awt.EventQueue$3.run(Unknown Source)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.security.ProtectionDomain$1.doIntersectionPrivilege(Unknown Source)
	at java.security.ProtectionDomain$1.doIntersectionPrivilege(Unknown Source)
	at java.awt.EventQueue$4.run(Unknown Source)
	at java.awt.EventQueue$4.run(Unknown Source)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.security.ProtectionDomain$1.doIntersectionPrivilege(Unknown Source)
	at java.awt.EventQueue.dispatchEvent(Unknown Source)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.run(Unknown Source)

Notem que não são muitos os erros, apenas em 4 ou 5 linhas, parece. E após eu teclar enter na tela da Applet aparece um erro a mais, o da linha 422.
Alguém aí, por favor, poderia me ajudar ?
Grato !
Se precisarem de uma ajudinha com Física, estarei à disposição :lol:

Você está dando new em todas as bullets? Caso contrário, o if da linha 271 deveria ser:

if (bullet[n] != null && bullet[n].isAlive()) {

Seria uma ótima idéia criar uma classe para representar os Vetores matemáticos (ou copiar a que já tem no Ponto V!). Assim vc evita ficar mexendo diretamente no x e no y. A classe encapsula o conceito da “flecha”, o que facilita muito o pensamento e estimula os alunos a pensarem vetorialmente (eles tem uma tendência de xunxar movimentação no x e no y).

Eu sou professor de física para jogos. Uma das desvantagens do Java é que não tem sobrecarga de operadores. Aí vc não vai ter sintaxe natural como:

Vector v1 = new Vector(10,10); Vector v2 = new Vector(10,10); //Isso não dá pra fazer em Java Vector v3 = (v1 + v2).normalize();

O C#, além de ter o XNA (que é bem mais completo que o Java para várias coisas, e ainda permite rodar o jogo no X-Box), tem sobrecarga.

Opa, Vini, muito obrigado pela dica, rapaz !
Mas o problema não foi resolvido. Deixa eu explicar. Seguinte:
Quando mudei a linha 271 como você sugeriu, apareceram inúmeros outros erros, erros dizendo que o método isAlive não pode ser resolvido para o tipo Shape sendo que Shape extende (herda) o tipo BaseVectorShape, mas esse erro não ocorria com a classe Bullet. Na classe Ship havia um erro que confirmava a falta de erança, sendo que havia declarado a classe com o extends BaseVectorShape, entre outros inúmeros erros desse tipo que para mim não faziam sentido, pois todas as classes herdam de BaseVectorShape com excessão do Asteroids.
Bem, conferi todas as classes e não tive alternativa, baixei os códigos do site da editora. Rapaz, no meu ver estava tudo conforme o código que eu digitei, mas estava funcionando !!! :?
Bem, copiei os códigos para o Eclipse e para minha surpresa funcionou ! :oops:
Talvez eu tenha cometido algum erro de digitação feia, ou na sintaxe de algum método dessas classes da API 2D que não ainda não estou familiarizado. O importante é que entendi digamos uns 80% do funcionamento da aplicação !!! o resto espero que venha com os estudos futuros, pois nos próximos capítulos do livro o autor explicará o funcionamento do aplcativo com detalhes, esse pequeno game creio eu que tenha sido apenas para estimular o leitor, pois o próprio autor diz para não nos preocuparmos em entender todo o código.

Com relação a você ser professor de Física para games, poxa, rapaz, que legal !!! Se precisar de ajuda, grite aí ! ficarei muito feliz se puder ajudar com algum conceito que esteja precisando. Aliás, com relação a Física para games, você possui algum material ou apostila ? Seria de muita valia para mim.

E com relação a estudar C#, meu Deus ! agora que estou empolgado com Java e arrumei tempo, você vem com C# ? (hahahahaha!!!) :lol: Bem, ouvi dizaer que C# é muito parecido com Java, uma cópia discarada da Micro$soft. Então, acho que não será difícil não, valeu a dica, onde trabalho posso ter qualquer software da micro$soft gratuitamente sem precisar pagar, então, vou começar aprender C# sim.
Mas minha ointenção não é ganhar dinheiro com games não, mas sim as simulações em Física.

Bem, de qualquer forma, valeu aí pela dica !
Precisando, é só postar aqui ou enviar uma mp

Valder

Oi Valder,

Eu realmente não tive tempo de baixar e testar todo o seu código, só vi o erro que o Java evidenciou na exception. Mas se você entendeu o conceito, ok. O erro deve ser mesmo alguma bobeira e agora seria só um trabalho de ler exceptions e corrigir os pontos em questão.

O foco da física para games, é menor em simulação, e maior em apresentar comportamentos físicos e comportamentais convincentes. Acho que pode ser interessante para você conhecer meu material, até porque os resultados visuais são impressionantes, como é o caso desse gerador de partículas em Java. Se quiser meu material de aula, me passe seu e-mail via mp e te envio tudo.

A princípio, você conseguirá programar em C# exatamente igual você faz com Java (tirando um ou outro detalhe sintático). Aos poucos você se acostuma com os recursos diferentes. Eu recomendaria que você visse de início a sobrecarga de operadores e a sintaxe das properties, pois será especialmente útil para sua aula.

No caso, o XNA é uma plataforma de games da Microsoft, que roda sobre o C#. Ela já possui diversas classes adequadas para jogos, como classes para carga de texturas, sons, classes matemáticas (Vector2, Matrix, Quaternion, etc.). Ela já possui o controle de game loop e é integrada ao Direct X (embora forneça um modo fácil de desenhar em 2D). Quase nada disso está disponível no Java. É uma tarefa ardua e chata reproduzir um som ou música em Java, por exemplo. Com o XNA, em 40 linhas de código, você terá um joguinho simples rodando (ou uma simulação física), poupando os alunos de um bocado de trabalho mecânico. O fato de rodar no X-Box, no seu caso, é apenas um chamariz. Certamente muitos de seus alunos irão se interessar pela matéria exclusivamente pelos jogos.

se for desenvolver jogos para desktop esqueça java…
parta para o UDK3 ela é o que a de melhor na atualidade para desenvolvimento de jogos. Pra ter uma ideia o novo MK, Alice, Strom Bullet e toda a serie Gears of Wars foi feita com UDK…

Isso, claro, se você quiser fazer jogos 3D que exijam placa de vídeo e máquinas poderosas para serem executados.

Olá Valder,

Muito legal a ideia de trabalhar com simuladores e jogos para a fisica.
Eu também faço alguns trabalhos para escolas e professores.
Tomara que vc tenha mais demanda que eu pois é muito massa trabalhar com isso.
Aqui alguns exemplos do meus trabalhos com joguinhos educativos:

http://www.codigorapido.com.br/portfolio.html
http://www.codigorapido.com.br/jogos/orbitas.php

Para o meu caso, e creio que talvez possa ser o seu também, vc goste de utilizar o flash.

O flash tem 2 ideias muito interessantes que diferem de qualuqer outro compilador que eu coneci (trabalho com ele desde o flash 4):

1- o conceito de TimeLine. Que é cada frame do video. Como uma foto da camera.
é permitido a sobreposição das timelines e cada frame de cada time lide pode ter seu proprio codigo trabalhando só dentro daquele frame.
2- vc pode desenhar e trabalhar um simbolo diretamente dentro do compilador com quma qualidade gráfica muito boa.
Dentro de cada simbolo é permitido crirar outras time lines. Até hoje eu não conheci nada semelhante.
Estou estudando o Blender nas horas vagas, mas se o que quer é algo mais simples do que jogos 3D o que eu recomendo é o Flash mesmo.

Vini, obrigado pelas dicas !
Seguinte, quero seu material sim, será de grande valia para mim. Mas não o usarei para as aulas não, será para mim mesmo, quero saber o que de física é relevante para jogos. Minha intensão não é ensinar isso para os alunos, mas sim usar para fazer simulações e colocar em meu site pessoal. Para os cursos de engenharia eu ministro aulas apenas de linguagem C (aaaarrrrrghhhhhhh !!!).
Quando tiver tempo começarei a estudar C#, mas antes quero aprender direito Java para jogos, pois já comecei e não quero parar agora. Depois de aprender os conceitos gostaria de aprender a usar a JMonkeyEngine, que em um dos tópicos aqui você colocou o link e achei aquilo sensacional !
Enviei uma mo para você com meu email para que me enviasse o material.
Agora, gostaria de saber de vocês como vocês se arranjam com os cenários, palcos e sprites, pois arte não é comigo, não sei desenhar nem uma casinha ! Vocês contratam artistas ?

Luiz Augusto, dei uma olhada no site, muito legal o trabalho mesmo. Tentei trabalhar com flash, mas tive alguns problemas, gostaria de usar a engine Away3D, mas não obtive sucesso, não consegui instalar e fazer funcionar adequadamente no FlashDevelop. Se souber como fazer isso, gostaria de uma ajudinha sua.

Obrigrado aí, pessoal, estão prestando uma boa ajuda.

Abraços !

Valder Olmo Corrêa:

Vini, obrigado pelas dicas !
Seguinte, quero seu material sim, será de grande valia para mim. Mas não o usarei para as aulas não, será para mim mesmo, quero saber o que de física é relevante para jogos. Minha intensão não é ensinar isso para os alunos, mas sim usar para fazer simulações e colocar em meu site pessoal. Para os cursos de engenharia eu ministro aulas apenas de linguagem C (aaaarrrrrghhhhhhh !!!).
Quando tiver tempo começarei a estudar C#, mas antes quero aprender direito Java para jogos, pois já comecei e não quero parar agora. Depois de aprender os conceitos gostaria de aprender a usar a JMonkeyEngine, que em um dos tópicos aqui você colocou o link e achei aquilo sensacional !
Enviei uma mo para você com meu email para que me enviasse o material.
Agora, gostaria de saber de vocês como vocês se arranjam com os cenários, palcos e sprites, pois arte não é comigo, não sei desenhar nem uma casinha ! Vocês contratam artistas ?

Luiz Augusto, dei uma olhada no site, muito legal o trabalho mesmo. Tentei trabalhar com flash, mas tive alguns problemas, gostaria de usar a engine Away3D, mas não obtive sucesso, não consegui instalar e fazer funcionar adequadamente no FlashDevelop. Se souber como fazer isso, gostaria de uma ajudinha sua.

Obrigrado aí, pessoal, estão prestando uma boa ajuda.

Abraços !

Eu entrei para Física este ano na Universidade, e também gostava mesmo de desenvolver simulações de fenómenos reais. Apesar de já estar familiarizado com Java, o pessoal recomendo-me aprender C/C++

Olá Valder,

Infelizmente o flash que eu sei trabalhar é o Professional.
Quando quero afazer sumulações mais pesadas eu utilizo o blender.
olha o que é possivel fazer com fluidos no blender:

Eu tentei fazer algo realistico assim, levou 5 min para renderizar um único frame.
Inviavel para eu fazer filmes.

Sobre performance e java para física, veja minha opinião aqui:

Eu tentei fazer algo realistico assim, levou 5 min para renderizar um único frame.
Inviavel para eu fazer filmes.

Seria inviável para fazer filmes em tempo real, mas vc pode deixar “algumas” semanas o programa rodando em sua casa (só duas horas por segundo de filme, levaria apenas 14.400 horas, ou 183 dias, para fazer seu filme)… heheheheh.

Falando em física para esses builders, baba-se mesmo com os exemplos da Lagoa MultiPhysics:

Que, embora muito bonitos, saem do escopo do que queremos ensinar na aula de física (afinal ela faz tudo praticamente sozinha).
Só é legal para deixar os alunos babando e mostrar a eles até onde podem chegar se estudarem um bocado.

Vale lembrar também que a concepção e o desenvolvimento da engine foi liderado por um brasileiro.

ViniGodoy , blz?

Mais para questao de conhecimento(pq minha praia é jsf, hibernate). Normalmente, quais frameworks voce usa para programacao de games?

abs

Depende muito de que tipo de programação vc vá fazer, e do game.

Em iPhone tem a Cocos2D, para games 3D tem a UDK e a Unity…
Para ensinar games, eu uso uma API nacional chamada Chien2D, e o XNA.

Mas quando faço minhas pesquisas em game (principalmente em CG) gosto de fazer no braço com DirectX e C++.
Não tem jeito, pra estudar o melhor jeito é abusar de “programação orientada a cabelos no peito.”

Ah ta,
Pensei que voce usava “java puro” para games(se é que tem jeito)

Esse exemplo da lagoa magica foi desenvolvido em que ?

julianosts:

Ah ta,
Pensei que voce usava “java puro” para games(se é que tem jeito)

Eu usei Java2D puro em alguns games, no início. Mas logo vi que a linguagem era muito deficitária para esse mercado, e parti para alternativas melhores.
Se fosse usar Java, como já falei no post, seria apenas no Android, pois há alternatívas muitíssimo melhores na indústria (não estou dizendo que seja impossível fazer um game em Java, mas é muito mais difícil e arriscado, uma péssima estratégia do ponto de vista técnico ou de negócio).

ViniGodoy:

julianosts:

Ah ta,
Pensei que voce usava “java puro” para games(se é que tem jeito)

Eu usei Java2D puro em alguns games, no início. Mas logo vi que a linguagem era muito deficitária para esse mercado, e parti para alternativas melhores.
Se fosse usar Java, como já falei no post, seria apenas no Android, pois há alternatívas muitíssimo melhores na indústria (não estou dizendo que seja impossível fazer um game em Java, mas é muito mais difícil e arriscado, uma péssima estratégia do ponto de vista técnico ou de negócio).

As duas ultimas duvidas(senao fica parecendo entrevista.rs)

1.A lagoa magina foi feita em que?
2. Voce acha meio arriascado se aprofundar em j2me só por causa do android(tudo bem…conhecimento é bom), mas voce acha que existem outras solucoes melhores para estudar do que ele ?(linguagens)

julianosts:

1.A lagoa magina foi feita em que?
2. Voce acha meio arriascado se aprofundar em j2me só por causa do android(tudo bem…conhecimento é bom), mas voce acha que existem outras solucoes melhores para estudar do que ele ?(linguagens)

Segundo o autor, a Lagoa (que é o nome da engine de física que fez todos aqueles demos) foi feita em C++, e inicialmente como um plugin:

O J2ME está em declínio, sendo substituído pelo Android (são coisas diferentes). Não acho que valha a pena se concentrar em J2ME hoje em dia, a menos que vc tenha interesse em entrar em algum nicho específico de mercado já consolidado.

ViniGodoy:

julianosts:

1.A lagoa magina foi feita em que?
2. Voce acha meio arriascado se aprofundar em j2me só por causa do android(tudo bem…conhecimento é bom), mas voce acha que existem outras solucoes melhores para estudar do que ele ?(linguagens)

Segundo o autor, a Lagoa (que é o nome da engine de física que fez todos aqueles demos) foi feita em C++, e inicialmente como um plugin:

O J2ME está em declínio, sendo substituído pelo Android (são coisas diferentes). Não acho que valha a pena se concentrar em J2ME hoje em dia, a menos que vc tenha interesse em entrar em algum nicho específico de mercado já consolidado.

Valeu pela dica Vinny, perguntei do J2ME e do android, porque vi uns cursos especifico de java para android

Abraço

Só um comentário, a Lagoa Multiphysics (não sei de onde vc tirou o “mágica”), é uma engine para animadores, com foco em qualidade ao invés de tempo real (inadequada para jogos). Esses exemplos foram todos pré-renderizados.

Engines de física com foco em tempo real modernas incluem a Havok e, entre as gratuitas, a Bullet Physics.

Para vocês que estudaram por esse livro ‘Killer Game Programming in Java’, hoje ele ainda pode ser considerado uma referência para quem pretende começar a programar jogos?
Se não for, vocês têm sugestão de algum outro livro?
Obrigado.

Está um tanto desatualizado, por ser da época do Java 4. Desde lá, muita coisa piorou na plataforma JSE em relação à jogos.
Mesmo o livro do Dave Brackeen, está um tanto obsoleto, pois é da mesma época.

Foram descontinuados ou paralizados projetos como a JOGL, JMF e javax.sound.
Ok, muitos recursos legais foram adicionados ao JSE, como generics, for each e thread pools, mas poucos deles realmente fazem a diferença para games.

Sobra só o livro do Jonathan Harbour, que não é tão bom assim.
Esse autor sai escrevendo livro de desenvolvimento de game em tudo o que é linguagem, mas não se aprofunda bastante em nenhuma delas.

Enquanto não sai um livro específico de LibGdx, não é uma boa insistir em JSE.
Outra possibilidade é tentar partir para o JavaFX - mas esse é um campo que ainda não arrisquei.

Tem uma série interessante e bastante abrangente chamada Introdução ao Desenvolvimento de Games, publicada pela Carnage Learning. É bem interessante. Te dá uma visão geral da área.
A parte 2 é específica sobre desenvolvimento.

No caso de Java, eu recomendaria pegar livros para Android, como esse aqui:

Ou, se quiser aprender a fazer games 2D do jeito “hardcore”, esse aqui:

Mas há ótimos tutoriais de games 2D na internet, como esses:
http://www.sdltutorials.com/tutorials
http://lazyfoo.net/SDL_tutorials/

O importante é você ter um foco na área. Saber se quer estudar games 2D, 3D, mobile. Pelo menos, traçar seu objetivo com estudo de games.
Assim podemos te ajudar melhor, e não dar sugestões tão abrangentes.

O fato é que a área de jogos ainda é dominada pelo C++, e essa tendência não parece estar mudando. Você ainda acha alguma coisa em Objective-C, no caso do Android. Em flash, para games do facebook.
No Brasil, a Unity tem tido uma boa penetração no mercado de 3D. Mas é difícil competir com o C++ pois ele compila para praticamente qualquer coisa. Desde o último video-game tiplo A, até aquela cafeteira com um microprocessador que já prepara o café automaticamente de manhã.

Obrigado pelas dicas ViniGodoy. Eu pretendo fazer alguns jogos para Android.
Mas antes disso, queria começar tendo uma experiência com algo 2D.
No início do ano passado, comecei a estudar um pouco com o material desse site
‘Lazy Foo Productions’. Estava aprendendo bastante, mas interrompi para priorizar minha pesquisa de mestrado.
Nos próximos meses estou para retomar esse estudo, mas queria planejar bem para aproveitar melhor esse tempo.
Daí pesquisei um pouco no Google e achei este tópico, me veio o interesse em saber do livro porque
Java é a linguagem com a qual eu sou mais familiarizado.

É importante aprender os conceitos. Por exemplo, você não vai muito longe em jogos sem saber o básico sobre vetores e matrizes de transformação:
http://www.pontov.com.br/site/arquitetura/54-matematica-e-fisica/132-o-uso-de-vetores-nos-jogos
http://www.pontov.com.br/site/arquitetura/54-matematica-e-fisica/238-matrizes-e-transformacoes-parte-1

Isso permitirá que você faça objetos que girem, ou implemente frameworks de partículas.
Ou mesmo que modele comportamentos bem interessantes, como os desse site:
http://www.red3d.com/cwr/steer/

Se for implementar games de plataforma, é legal conhecer os assuntos listados nesse guia:
http://higherorderfun.com/blog/2012/05/20/the-guide-to-implementing-2d-platformers

E se for fazer games com mais física, estudar também a Box2D:
http://www.box2d.org/manual.html

Vários outros tópicos já estão listados no LazyFoo, tais como paralaxe, scrolling background, etc.
Vai nos conceitos, que depois adaptar para qualquer linguagem é só uma questão de tempo.