Discussion :

[cdm1024]

Bonjour,

Je m'essaie pendant mon temps à la programmation de jeux vidéos.
Je suis actuellement en train de développer un space invader en openGL c++ avec sdl et un avec java2D les deux sous linux ubuntu.

Cependant Dans les deux programmes j'ai le même problème. J'ai la boucle suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
boucle begin
  deplacer le vaisseau
  depalcer les bullets
  afficher le tout
boucle end

Quand il y a pas beaucoup de bullet le déplacement du vaisseau et du reste est fluide par contre dès qu'il y beaucoup de bullet sur l'écran alors la tout se ralenti. Ce qui est normale car il y a plus d'objet à mettre à jour.

Mais là c'est aux alentours de 20 bullets que ca se ralenti donc c'est très mauvais dès le départ.

Comment dois-je m'y prendre pour corriger ce problème ?

Merci.

[stardeath]

quand tu dis déplacer,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

position += vitesse * temps écoulé

ou tu fais autre chose?

postes ton code, parce que comme ça on peut pas deviner ce que tu fais réellement

[cdm1024]

oui c'est ca.

En fait j'ai fait du code objet. Donc a moins de poster tout le code source il va en falloir des extrait.

Et puis si j'ai pas posté mon c'est qu'a mon avis l'explication n'en a pas besoin. En faîte mas question est "est ce que la boucle est correcte dans le sens où l'on met tous les traitement de déplacements, de collisions, éventuellement d'iA, de communication dans un jeux réseaux ?" car cela en fait du traitement entre deux affichage ?

Note: c'est pas bien mais j'ai un peu menti
Le space invader en c++ je l'ai fait et eu ce problème . Je l'ai perdu dans un crash disque.
Pour la version en java en fait c'est un jeu de robot qui se battent dans une arène.
Voilà ma conscience est soulagée.

Merci

[Acropole]

L'algo que tu as posté ne dis rien de ce qui ralentis ton jeu. Il faut savoir que l'IA, le réseau, l'input etc ne sont rien comparé au temps de calcul de la carte vidéo. Ca m'étonnerais que des calculs de position soient plus long que le calcul des polygones, des textures, la rasterisation et l'affichage.
Mais sans ton code on ne peut rien dire.

[cdm1024]

Bonjour,

Mon calcul d'affichage sous java se limite a afficher une image avec Graphics2D

La boucle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
	player.run();
 
		Iterator<RobotBot> itb=bots.iterator();
		while(itb.hasNext())
			itb.next().run();
 
		Iterator<Bullet> it=bullets.iterator();
		while(it.hasNext())
		{
			Bullet b=it.next();
			if(!b.run())
				it.remove();
		}
		display.paint();

On ne voit pas le while mais le tout est dans une fonction qui est dans un while.

Le canvas2D avec la fonction paint qui est appeller pour afficher les objets:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
public void paint()
	{
		Graphics2D g=(Graphics2D) buffer.getDrawGraphics();
 
 
		boolean retry;
		do
		{
			try
			{
				retry=false;
				Iterator<Bullet> itb=bullets.iterator();
				while(itb.hasNext())
					itb.next().paint(g);			
			}
			catch(ConcurrentModificationException e)
			{
				retry=true;
			}
 
		}while(retry);
 
		Iterator<Displayer> it=displayers.iterator();
		while(it.hasNext())
			it.next().paint(g);
 
		buffer.show();
	}

Le code de la class parent pour affichier des objets mobile:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
	public void paint(Graphics2D g)
	{
		g.clearRect((int)lx-img_width,(int)ly-img_height,2*img_width,2*img_height);
		img.paint(g, x-img_width,y-img_height);
	}

l'affichage d'une image

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
	public void paint(Graphics g,double x, double y)
	{
		g.drawImage(img,(int)x,(int)y,null);
	}

exemple de code de run du robot humain (player dans la boucle ):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
public boolean run()
		super.run();
		if(x+speedX<screenX && x+speedX>0)
			x+=speedX;
		if(y+speedY<screenY && y+speedY>0)
			y+=speedY;		
		rotate();
		return true;

rotate est une méthod qui aurrait peut etre du est appeler dans la boucle . En faite se devrai etre un évènemnt car elle fait pivoter le robot pour regarder dans la direction de la souris.

Voila.

NB: t'as gagné t'as du code. Si il en faut plus ca va être compliqué car j'ai beacoupp DRY et donc il y a beaucoup de méthode et de classe.

[stardeath]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
public void paint()
	{
		Graphics2D g=(Graphics2D) buffer.getDrawGraphics();
 
 
		boolean retry;
		do
		{
			try
			{
				retry=false;
				Iterator<Bullet> itb=bullets.iterator();
				while(itb.hasNext())
					itb.next().paint(g);			
			}
			catch(ConcurrentModificationException e)
			{
				retry=true;
			}
 
		}while(retry);
 
		Iterator<Displayer> it=displayers.iterator();
		while(it.hasNext())
			it.next().paint(g);
 
		buffer.show();
	}

j'espère pour toi que ce code ne génère JAMAIS l'exception attrapée, car sinon c'est la catastrophe.

après visiblement le reste du code n'a pas l'air d'être potentiellement lent.

faut essayer de faire l'affichage en désactivant le maximum de la logique du jeu, et en réactivant au fur et à mesure, il y aura bien un moment où ça foira.

[nouknouk]

faut essayer de faire l'affichage en désactivant le maximum de la logique du jeu, et en réactivant au fur et à mesure, il y aura bien un moment où ça foira.

Il me semblerait surtout beaucoup plus pertinent de faire du profiling pour voir ce qui est réellement lent dans le programme.

Les IDEs répandus permettent de lancer des sessions de profliling en quelques secondes et donnent des résultats très utiles. Ca me paraît mieux que "taper dans le code" pour désactiver à la main ceci ou cela.

PS: J'aurais tendance à penser que ce sont les fonctions de dessin de JAVA (qui sont très lentes par défaut) qui posent souci. Mais sans profiling, impossible de conclure quoi que ce soit.

[stardeath]

je n'ai pas proposé ça parce que je ne connais pas d'ide qui permette le profiling (ou alors je ne sais pas me servir des ide que je possède)

[nouknouk]

je ne connais pas d'ide qui permette le profiling

- Eclipse le propose via ce qui semble être un plugin supplémentaire.

- NetBeans le propose 'out of the box', et pour l'utiliser très régulièrement, ça marche vraiment bien

Ceus deux IDE doivent couvrir à eux seuls dans les 90% des environnements utilisés pour le développement Java.

[Mat.M]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
boolean retry;
		do
		{
			try
			{
				retry=false;
				Iterator<Bullet> itb=bullets.iterator();
				while(itb.hasNext())
					itb.next().paint(g);			
			}
			catch(ConcurrentModificationException e)
			{
				retry=true;
			}
 
		}while(retry);
 
		Iterator<Displayer> it=displayers.iterator();
		while(it.hasNext())
			it.next().paint(g);
 
		buffer.show();
	}

Comme c'est bien compliqué !!
Pourquoi faire une boucle avec un do-while ?
Construit de cette manière ,c'est strictement inutile et cela va ralentir l'exécution.
Et construit de cette manière tu boucles indéfiniment dans la méthode Paint si tu n'as jamais d'exception !
Et puis fait quelque chose de simple,pour les exceptions tu les mets en dernier quand le programme est bien optimisé..
c'est un petit jeu pour le fun que tu fais pas un une application critique à tolérance de panne zéro.
Donc mettre des gestions d'exceptions partout cela risque de nuire aux performances..

[Mat.M]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
catch(ConcurrentModificationException e)

http://java.sun.com/j2se/1.4.2/docs/...Exception.html

cette classe d'exception est valable surtout si tu crées plusieurs threads dans ton programme, est-ce le cas ?
Pour un Space Invader je n'en vois pas trop l'intérêt sauf si tu vas gérer le réseau.
Encore une fois essaie de partir sur quelque chose de simple..

[cdm1024]

Bonjour,

Merci de vous intéresser à mon cas.

Donc la boucle est très réllement de la mauvaise programmation dû à de la paresse de ma part.

Il y a une JFrame dans l'application qui contient le Canvas. Cette JFrame est dans un thread pour l'affichage. Tout le code précédement poster est dans le thread métier.

Donc en faîte je suis dans le flou. Est-ce que j'ai bien un thread d'affichage sachant que j'appelle paint dans on thread métier.

Pour la boucle : Il y a une exception qui peut être lever car quand je clique pendant qu'il affichage la taille de la liste de bullet augmente. Il suffisait en faîte de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
synchronized(bullets)
{
Iterator<Bullet> itb=bullets.iterator();
				while(itb.hasNext())
					itb.next().paint(g);	
}

pour verroulliez l'accès à bullets le temps de l'affichage.

J'ai fait du profiling avec tptp de eclipse. Donc ce qui prend le plus de temps dans le code métier c'est le run des bullets qui est appellé beaucoup de fois quand il y a beaucoup de bullet.

Sinon en effet la majeur parti du temps est consommé par l'affichage des images.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
public void paint(Graphics g,double x, double y)
	{
		g.drawImage(img,(int)x,(int)y,null);
	}

Cette fonction qui est appellé le plus de fois car tout ce qui est affiché à l'écran passe par elle consomme plus de la moitié du temps du programme.

Voila.

Je vais allez chercher dans les fils de java du forum si il y a pas plus efficace pour afficher une image. Si vous avez des suggestions n'hésitez pas.



Il y a deux threads dans l'application.

[nouknouk]

pour accélérer l'affichage, tu as deux possibilités majeures:

- optimiser ton code existant, l'objectif étant d'implémenter différentes techniques pour minimiser ce qui est redessiné à chaque image. Par exemple en utilisant la technique des 'dirty rectangles'.

- utiliser une librairie qui utilise l'accélération hardware de ta carte graphique. Typiquement une librairie 3D au dessus d'openGL que tu n'utiliseras que pour afficher des éléments en 2D, genre slick.

ceci étant dit, avoir 50% du CPU occupé juste pour la gestion de la 'logique de jeu' me semble à priori élevé. Tout dépend de ce que tu fais, mais si ton moteur se borne à calculer les déplacements et collisions de quelques centaines d'objets par frame, on devrait plutôt avoir une occupation de l'ordre de 10% à 20% amha.
Sans vouloir optimiser à bloc, il y a certainement des choses qui pourraient être réorganisées dans ta logique de jeu ; le pofiling devrait là encore te pointer les parties du code qui sont trop 'lourdes'.