Discussion :

[Novocaine]

Bonjour, je suis confronté a un probleme dans mon programme pour mon projet d'informatique.

En grandes lignes, je dois faire un jeu calqué sur Space Invader...bref.
Notre professeur nous a demandé d'appliquer un type opaque sur nos structures ; chose que j'ai faite.
Cependant, voila mon soucis:

J'ai un module projectile.c avec la definition de la structure PROJECTILE a l'interieur. Ce module gere la creation de projectile sous forme d'une liste chainée. Elle gere egalement les collisions entre elles, la suppressions de projectiles selon certaines conditions,...
J'ai aussi un module enemy.c avec la definition de la structure ENEMY. Sur le meme principe, elle gere la creation d'enemies, leur suppresions, leur dessins,...

Ce que je souhaite faire, c'est pouvoir controler la collision entre un projectile et un enemie. Je souhaite le faire a l'interieur de mon module projectile car il y a deja une fonction projectile_collision(PROJETILE** tete_robot_projectile) qui s'occupe de cela.
Mais bien entendu si j'ajoute un argument "ENEMY** tete_enemy" dans la definition de ma fonction (dans projectile.h), le compilateur me dit que ENEMY n'est pas declaré. Ce qui est normal.

Donc existe-t-il un moyen pour que je puisse faire comprendre a ma fonction que ENEMY existe bien sans devoir faire une redeclaration dans projectile.h de la structure ENEMY avec un typedef. ce qui entraine une erreur de compilation ?

Merci d'avance pour vos aides.

[Bayard]

Je ne suis pas sur d'avoir tout saisi...

Peut-être le mot clé

Code :

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

extern

peut-il aider.

Il faut poser du code (avec les balises code (c'est un #). Cela sera sans doute plus clair.

[Novocaine]

Oui, en effet, je n'ai pas été tres clair Donc voila le code:

cinematique.cpp

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
30
31
32
33
34
35
36
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <math.h>
#include "glui.h"
#include "constante.h"
 
extern "C"
{
#include "robot.h"
#include "graphic.h"
#include "projectile.h"
#include "enemy.h"
#include "rand.h"
}
[...]
static PROJECTILE* tete_robot_projectile = NULL;
static ENEMY* tete_enemy = NULL;
 
[...]
 
void idle_cb()
{
  [...]
 
  //gestion collision
  projectile_collision(&tete_robot_projectile, &tete_enemy);
 
  //gestion enemy positon
  enemy_set_position(&tete_enemy, width, height);
 
  refresh();
}

projectile.h:

Code :

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

1
2
3
4
5
 
typedef struct projectile PROJECTILE;
[...]
void projectile_collision(PROJECTILE** tete_projectile_robot,
			  ENEMY** tete_enemy);

projectile.c:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
#include "enemy.h"
#include "projectile.h"
#include "graphic.h"
#include "robot.h"
#include "constante.h"
 
//modele de la structule PROJECTILE
struct projectile
{
  float x_projectile;
  float y_projectile;
  float vitesse;
  float delta_phi;
  PROJECTILE* projectile_suivant;
};
 
void projectile_collision(PROJECTILE** tete_projectile_robot, ENEMY** tete_enemy)
{
  PROJECTILE* pjte_compareur = *tete_projectile_robot;
 
  while(pjte_compareur != NULL)
    {
      ENEMY* enemy_courant = *tete_enemy;
      PROJECTILE* pjte_courant = pjte_compareur->projectile_suivant;
 
      //le pjte_compareur compare sa position avec celle des autres projectiles
      while(pjte_courant != NULL)
	{	
	  if(abs(pjte_compareur->x_projectile - pjte_courant->x_projectile) < DELTA_X 
	     &&
	     abs(pjte_compareur->y_projectile - pjte_courant->y_projectile) < DELTA_Y)
	    {
	      projectile_supprimer(tete_projectile_robot, pjte_compareur );
	      projectile_supprimer(tete_projectile_robot, pjte_courant);
	    } 
 
	  pjte_courant = pjte_courant->projectile_suivant;	     
	}
 
      //le pjte_compareur compare sa position avec celle des enemies
      while(enemy_courant != NULL)
	{	  
	  if(pow(pjte_compareur->x_projectile - enemy_courant->x_enemy, 2)
	     +
	     pow(pjte_compareur->y_projectile - enemy_courant->y_enemy, 2)
	     <
	     pow(R_ENEMY, 2))
	    { 
	      projectile_supprimer(tete_projectile_robot, pjte_compareur);
	       enemy_supprimer(tete_enemy, enemy_courant);
	    }
 
	  enemy_courant = enemy_courant->enemy_suivant; 
	  }
 
      pjte_compareur = pjte_compareur->projectile_suivant;
 
    }
 
}

enemy.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
typedef struct enemy ENEMY;
 
void enemy_creation(ENEMY** tete);
[...]
void enemy_set_position(ENEMY** tete,
			int width,
			int height);
 
void enemy_supprimer(ENEMY** tete,
		     ENEMY* enemy);

enemy.c

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
 
#include <stdio.h>
#include <stdlib.h>
#include <GL/glu.h>
#include <math.h>
 
#include "graphic.h"
#include "constante.h"
#include "rand.h"
#include "enemy.h"
 
//modele de la structure ENEMY
struct enemy
{
  float x_enemy;
  float y_enemy;
  float vitesse_enemy;
  ENEMY* enemy_suivant;
};

Voila, j'espere que mon probleme est un peu plus transparent.

Donc j'ai un message d'erreur lors de la compilation m'indiquant que la definition de la fonction projectile_collision(PROJECTILE**, ENEMY**) ne convient pas car il ne peut convertir ENEMY** en int**. Si j'ai bien comprit, le message survient a cause du faite que ENEMY n'est pas connu dans projectile.h

[zooro]

Pourquoi n'as-tu pas inclus

Code :

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

1
2
3
4
5
6
7
8
struct projectile
{
  float x_projectile;
  float y_projectile;
  float vitesse;
  float delta_phi;
  PROJECTILE* projectile_suivant;
};

dans le fichier .h correspondant ?
Et idem pour struct ENEMY.

C'est plus logique, et ça devrait résoudre ton problème.

[Novocaine]

Si je fais cela, je n'aurai plus de type opaque

[Emmanuel Delahaye]

Pourquoi n'as-tu pas inclus

Code :

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

1
2
3
4
5
6
7
8
struct projectile
{
  float x_projectile;
  float y_projectile;
  float vitesse;
  float delta_phi;
  PROJECTILE* projectile_suivant;
};

dans le fichier .h correspondant ?
Et idem pour struct ENEMY.

C'est plus logique, et ça devrait résoudre ton problème.

Hum. Il s'agit de types opaques...

http://emmanuel-delahaye.developpez.com/tad.htm

C'est justement ce qu'on ne veut pas faire.

[Emmanuel Delahaye]

Oui, en effet, je n'ai pas été tres clair Donc voila le code:
<...>
Donc j'ai un message d'erreur lors de la compilation m'indiquant que la definition de la fonction projectile_collision(PROJECTILE**, ENEMY**) ne convient pas car il ne peut convertir ENEMY** en int**. Si j'ai bien comprit, le message survient a cause du faite que ENEMY n'est pas connu dans projectile.h

Je ne suis pas rentré dans le détail, mais en principe, il suffit de prévoir les deux fonctions qui vont bien ('accesseurs') pour retourner la ou les données (on a le droit de faire une structure 'publique' pour ça si il y a plus d'une valeur) et appliquer sur ces données les tests qui vont bien pour déterminer si il y a collision.

[Novocaine]

J'ai fait un tour sur le lien que tu m'as envoyé....cependant il ne repond pas trop a mon probleme.

Lorsque tu dis qu'il faudrait prevoir une fonction adequat, je bute toujours sur la meme chose:
Si j'ecris la definition de la fonction dans mon .h et que je fais apparaitre dans les arguments une struct non-declaré, il va se planter a la compilation.
De meme si je cree un nouveau module,...

Et si je place une fonction qui retourne les valeurs de ma structure ENEMY, il me faut l'addresse du debut de la chaine, ce qui signifie un argumenent de type pointeur sur structure et donc je me retrouve dans la meme impasse.

[Emmanuel Delahaye]

J'ai fait un tour sur le lien que tu m'as envoyé....cependant il ne repond pas trop a mon probleme.

Il était en réponse à zooro qui semblait ignorer la notion de données opaques... Il faut lire correctement les citations...

Lorsque tu dis qu'il faudrait prevoir une fonction adequat, je bute toujours sur la meme chose:
Si j'ecris la definition de la fonction dans mon .h et que je fais apparaitre dans les arguments une struct non-declaré, il va se planter a la compilation.
De meme si je cree un nouveau module,...

Et si je place une fonction qui retourne les valeurs de ma structure ENEMY, il me faut l'addresse du debut de la chaine, ce qui signifie un argumenent de type pointeur sur structure et donc je me retrouve dans la meme impasse.

Bien sûr. Les types opaques ne fonctionnent qu'avec des pointeurs simples (pas de **) et ne peuvent être déréférencés hors de leur implémentation.

Il est cependant possible de créer une fonction 'à-part' nommé

Code :

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

1
2
3
4
 
collision (PROJECTILE *p_proj, ENEMY *p_enem)
{
}

précédée de #include "projectile.h" et de #include "ennemy.h"

qui fasse en gros ceci :

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
 
   struct xy
   {
      int x;
      int y;
   };
 
   struct xy xy_proj;
   struct xy xy_enem;
 
   projectile_get_xy (p_proj, &xy_proj.x, &xy_proj.y);
   enemy_get_xy (p_enem, &xy_enem.x, &xy_enem.y);
 
   if (xy_proj.x == xy_enem.x && xy_proj.y == xy_enem.y)
   {
      /* boum */
   }

Ne reste plus qu'à ajouter

Code :

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

projectile_get_xy (PROJECTILE *self, int *px, int *py);

et

Code :

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

enemy_get_xy (ENEMY *self, int *px, int *py);

aux objets opaques respectifs. Je ne vois pas trop où est le problème.

NOTA : l'objet struct xy (disons XY pour rester dans ta terminologie) pourrait être un objet commun (non opaque) aux 2 objets ENNEMY et PROJECTILE, ce qui permettrait de faire ceci :

Code :

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

projectile_get_xy (PROJECTILE *self, XY *p_xy);

et

Code :

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

enemy_get_xy (ENEMY *self, XY *p_xy);