Probleme Classe/héritage

[Shino]

Bonjour.

Alors voici mon problème ça fais juste un ans que je commence a programmer et pour le coup je fais un casse brique en C++ sous VC6
Donc j'ai une classe CRectangle (qui est composé de la classe CPoint) dans laquelle ce trouve la fonction detecterCollision, la classe CTerrain (agrégation de CRectangle) dans laquelle il y a juste un constructeur avec 3 rectangle qui constitue les bord du terrain et enfin la classe CRaquette qui herite de la classe CRectangle.

Quand j'ai fais le test entre 2 rectangle pour voir si mes collision marcher, çà allait parfaitement.
Apres quand je suis passer a la raquette eh bien elle ne detecte plus les collision avec bord du terrain (les rectangle de CTerrain) , avec un rectangle tout bete ca marche par contre.

voila mes .h

CRectangle.h

class CRectangle
{
public :
CPoint mHG ; // point en Haut à Gauche
CPoint mBD ; // point en Bas à Droite
int mClr ; // couleur du rectangle (cste BGI)


// constructeurs
CRectangle () {} ; //cstr par défaut pour héritage
CRectangle ( CPoint hg, CPoint bd, int clr ) ;
// méthodes
effacer () ;
dessiner() ;
deplacer( CPoint dep );
int detecterCollision(CRectangle rect) ;
int detecterAuDessous(CRectangle rect) ; // detecter Balle au-dessous Raquette
};

CTerrain.h

class CTerrain
{

public:
CRectangle mCoteD;
CRectangle mCoteG;
CRectangle mCoteH;

CTerrain();
};

CRaquette.h

class CRaquette : public CRectangle
{

public:

CRaquette(CPoint hg, CPoint bd, int clr);

int detecterCollision(CRectangle rect) ;
};


et voila les .cpp

CRectangle.cpp

.....
CRectangle::detecterCollision(CRectangle rect)
{
if(((mBD.mY==rect.mHG.mY) && (mBD.mX>=rect.mHG.mX) && (mBD.mX<=rect.mBD.mX)) || ((mBD.mY==rect.mHG.mY) && (mHG.mX<=rect.mBD.mX) && (mHG.mX>=rect.mHG.mX)))
{
return NORD;
}
if(((mHG.mY==rect.mBD.mY) && (mBD.mX>=rect.mHG.mX) && (mBD.mX<=rect.mBD.mX)) || ((mHG.mY==rect.mBD.mY) && (mHG.mX<=rect.mBD.mX) && (mHG.mX>=rect.mHG.mX)))
{
return SUD;
}
if(((mBD.mX==rect.mHG.mX) && (mBD.mY>=rect.mHG.mY) && (mBD.mY<=rect.mBD.mY)) || ((mBD.mX==rect.mHG.mX) && (mHG.mY<=rect.mBD.mY) && (mHG.mY>=rect.mHG.mY)))
{
return OUEST;
}
if(((mHG.mX==rect.mBD.mX) && (mBD.mY>=rect.mHG.mY) && (mBD.mY<=rect.mBD.mY)) || ((mHG.mX==rect.mBD.mX) && (mHG.mY<=rect.mBD.mY) && (mHG.mY>=rect.mHG.mY)))
{
return EST;
}
return 0;
}

CTerrain.cpp

CTerrain::CTerrain()
{
CRectangle mCoteH(CPoint(-5,-5), CPoint(645,10), 5);
CRectangle mCoteG(CPoint(-5,0), CPoint(10,490), 5);
CRectangle mCoteD(CPoint(630,0), CPoint(645,490), 5);
}

CRaquette.cpp

CRaquette::CRaquette(CPoint hg, CPoint bd, int clr):
CRectangle(hg, bd, clr)
{
}

CRaquette::detecterCollision(CRectangle rect)
{
if(((mBD.mY==rect.mHG.mY) && (mBD.mX>=rect.mHG.mX) && (mBD.mX<=rect.mBD.mX)) || ((mBD.mY==rect.mHG.mY) && (mHG.mX<=rect.mBD.mX) && (mHG.mX>=rect.mHG.mX)))
{
return NORD;
}
if(((mHG.mY==rect.mBD.mY) && (mBD.mX>=rect.mHG.mX) && (mBD.mX<=rect.mBD.mX)) || ((mHG.mY==rect.mBD.mY) && (mHG.mX<=rect.mBD.mX) && (mHG.mX>=rect.mHG.mX)))
{
return SUD;
}
if(((mBD.mX==rect.mHG.mX) && (mBD.mY>=rect.mHG.mY) && (mBD.mY<=rect.mBD.mY)) || ((mBD.mX==rect.mHG.mX) && (mHG.mY<=rect.mBD.mY) && (mHG.mY>=rect.mHG.mY)))
{
return OUEST;
}
if(((mHG.mX==rect.mBD.mX) && (mBD.mY>=rect.mHG.mY) && (mBD.mY<=rect.mBD.mY)) || ((mHG.mX==rect.mBD.mX) && (mHG.mY<=rect.mBD.mY) && (mHG.mY>=rect.mHG.mY)))
{
return EST;
}
return 0;
}

Et une petite partie du main

CTerrain terrain;
CRaquette raquette1(CPoint(285,460), CPoint(345,480), 4);
do
{
raquette1.deplacer(CPoint(-5,0));
if(raquette1.CRectangle::detecterCollision(terrain .mCoteD)==OUEST)
{
cout<<"collision OUEST"<<endl;
break;
}
if(raquette1.CRectangle::detecterCollision(terrain .mCoteG)==EST)
{
cout<<"collision EST"<<endl;
break;
}
}while(1);


Voila j'espere que vous pourez m'aider a mon avis ca viens du main ou de CRaquette mais j'arrive pas a trouver :(
merci

[Kikof]

Salut,

Sans analyser en profondeur les détails de ton code (car bien trop difficile à lire...), il est assez surprenant.

Tu as une fonction detecterCollision dans la classe mère CRectangle. Tu en réécrit une pour CRaquette (ce qui n'est déjà pas bon d'un point de vue objet).
Mais en plus dans ton main, tu appelles finalement la fonction CRectangle::detecterCollision, autrement dit celle de la classe CRectangle.
Pourquoi en réécrire une pour CRaquette si tu ne l'utilises pas ?

Le problème je pense se situe au niveau de ce que tu attends comme retour de ta fonction detecterCollision. Par exemple :

         if(raquette1.CRectangle::detecterCollision(terrain.mCoteD)==OUEST)
        {
            cout<<"collision OUEST"<<endl;
            break;
        }

Et si ta fonction répondait par erreur NORD, par exemple ? Pour débugger, tu devrais plutôt écrire quelque chose comme :

int iCollision = raquette1.CRectangle::detecterCollision(terrain.mCoteD);
if (iCollision != 0) {
   cout<<"collision " << iCollision <<endl;
   break;
}

[Shino]

Merci d'avoir répondu déjà.

Je viens d'essayer ce que tu ma proposé mais ca ne marche toujours pas :(,
et en effet au tout début je n'avais pas fais la fonction detecterCollision dans la classe CRaquette car il me semblais bien que cela ne servirai a rien mais comme je suis rester bloquer sur ça 2 jour j'ai essayer une tonne de chose mais rien n'y fais :(.

[Kikof]

Ok. Supprime ta fonction doublon dans CRaquette et appelle simplement detectCollision de la classe de base.

Ensuite essaie de modifier ta classe terrain ainsi (.h) :

 class CTerrain
{
    
public:
    CRectangle mCoteH(CPoint(-5,-5), CPoint(645,10), 5);
    CRectangle mCoteG(CPoint(-5,0), CPoint(10,490), 5);
    CRectangle mCoteD(CPoint(630,0), CPoint(645,490), 5);
    CTerrain() {}; // Constructeur par défaut
};

Enlève le .cpp correspondant au constructeur de CTerrain, car tu initialises ce qui pour toi semble être les mCoteH, mCoteG et mCoteD accessibles depuis l'extérieur mais qui ne sont en fait que des variables locales dans le constructeur et détruites à la fin de celui-ci. En fait, tu travaillais avec un terrain composé de CRectangle non initialisés.

[Shino]

J'ai fais comme tu ma conseiller de faire mais le compilateur me met plusieurs erreurs:

...\cterrain.h(6) :error C2629: unexpected 'class CPoint (' (3fois celle ci)

main.cpp(54) : error C2664: 'detecterCollision' : cannot convert parameter 1 from 'class CRectangle (void)' to 'class CRectangle'

Il y a à la base une classe CPoint pour facilité le construction d'un rectangle (CRectangle est composé de CPoint), j'avais oublier de précisé ça

[Kikof]

Apparemment le compilateur ne permet pas l'instanciation d'objet temporaires dans le .h.

Alors, il te faut passer par des pointeurs :

.h

class CTerrain
{
    
public:
    CRectangle* pmCoteH;
    CRectangle* pmCoteG;
    CRectangle* pmCoteD;
    CTerrain();
    ~CTerrain();
};

Et le .cpp :

CTerrain::CTerrain()
{
   pmCoteH = new CRectangle(CPoint(-5,-5), CPoint(645,10), 5);
   pmCoteG = new CRectangle(CPoint(-5,0), CPoint(10,490), 5);
   pmCoteD = new CRectangle(CPoint(630,0), CPoint(645,490), 5);
}

CTerrain::~CTerrain()
{
   delete pmCoteH, pmCoteG, pmCoteD;
}

A l'appel de CTerrain, il te faudra lever l'indirection, ainsi :

 int iCollision = raquette1.detecterCollision(*terrain.pmCoteD);
if (iCollision != 0) {
   cout<<"collision " << iCollision <<endl;
   break;
}

[Shino]

Ca marche !!

Un grand merci a toi de m'avoir accordé un peu de ton temps je vais pouvoir avancé sur mon projet encore merci

[Kikof]

Content pour toi.

Si tu veux que le compilateur lève l'indirection à ta place, tu peux modifier ta classe CRectangle ainsi :

 class CRectangle
{    
public :
        CPoint mHG ;    // point en Haut à Gauche
        CPoint mBD ;    // point en Bas  à Droite
        int mClr ;        // couleur du rectangle (cste BGI)

    
        // constructeurs
        CRectangle () {} ;    //cstr par défaut pour héritage
        CRectangle ( CPoint hg, CPoint bd, int clr ) ;
        // méthodes
        effacer () ;
        dessiner() ;
        deplacer( CPoint dep );
        int detecterCollision(CRectangle rect) ;
        inline int detecterCollision(CRectangle* prect)  
           { return detecterCollision(*prect); };
        int detecterAuDessous(CRectangle rect) ; // detecter Balle au-dessous Raquette
};

Enfin si ton compilateur le veux bien. Ainsi, tu peux appeler indifféremment detecterCollision avec un CRectangle ou un CRectangle*.