Programação de jogos com java.

Alguém se interessa pelo tema?

Eu me interesso. Nesse site você pode baixar o livro Killer Gaming Programming em java de graça e o melhor: não é pirataria.

O site é do próprio autor e tem até capítulos lá que não estão presentes no livro! Eu comprei o livro e com ele já consegui fazer um jogo estilo Arkanoid, com direito a tela cheia, música de fundo, efeitos sonoros, etc.

http://fivedots.coe.psu.ac.th/~ad/jg/

A performance do Java me surpreendeu. Ele possui escrita direta na tela, double buffering, acesso a recursos de aceleração gráfica, API para manipulação de diversos formatos de audio, etc.

Mais alguém aí tem alguma experiência nessa área?

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

JavaBaby Membro desde: 21/11/2006 18:57:10 Mensagens: 76 Offline

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

mas ambas são boas para aquela primeira experiência.

A propósito, jME possui melhores recursos de interface

[]'s

Entusiasta Java Membro desde: 12/11/2007 17:40:38 Mensagens: 16 Offline

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?

Thread.start() Membro desde: 12/04/2011 09:35:21 Mensagens: 30 Offline

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?

Java Ninja Membro desde: 15/09/2010 10:27:22 Mensagens: 254 Offline

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.

This message was edited 4 times. Last update was at 30/05/2011 20:09:00

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:

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!

Java Ninja Membro desde: 15/09/2010 10:27:22 Mensagens: 254 Offline

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:

Classe Asteroid:

Classe Bullet:

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:

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:

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

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

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:

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.

Notícias, artigos e o maior fórum brasileiro sobre Java