///////////////////// GESTION DEPLACEMENT /////////////////////

il te faut quatres variables (bool) de classe pour Affichage qui représente les quatres touches de déplacement. ces quatres variables t'indiques si une touche est pressé ou non. glutKeyboardFunc(Affichage::keyboardDown); et glutKeyboardUpFunc(Affichage::keyboardUp); vont se charger de mettre ces variables à true ou false.

Il n'y a plus de déplacement de caméra dans la fonction 'keyboard'. Le mouvement de la caméra va se faire périodiquement en fonction des touches enfoncées. Pour appeller periodiquement une fonction tu as besoin de 
"void glutTimerFunc(unsigned int msecs, void (*func)(int value), value);"  
c'est une facon d'éviter l'utilisation de threads.

Donc, ce qu'il y a maintenant dans 'keyboard' sera dans la fonction appellée periodiquement, bien sur il faut faire des modifications. discute avec ton pote et réfléchissez bien à ce que vous allez faire ! 



///////

glutSpecialFunc(Affichage::keyboardDown);
glutSpecialUpFunc(Affichage::keyboardUp);

///////

void Affichage::keyboardDown(int touche, int x, int y) 
{ 
	Affichage::avancer == (touche == GLUT_KEY_UP);
	Affichage::reculer == (touche == GLUT_KEY_DOWN);
	Affichage::droite == (touche == GLUT_KEY_RIGHT);
	Affichage::gauche == (touche == GLUT_KEY_UP);
} 
void Affichage::keyboardUp(int touche, int x, int y) 
{ 
	Affichage::avancer == (!(touche == GLUT_KEY_UP) && Affichage::avancer);
	Affichage::reculer == (!(touche == GLUT_KEY_DOWN) && Affichage::reculer);
	Affichage::droite == (!(touche == GLUT_KEY_RIGHT) && Affichage::droite);
	Affichage::gauche == (!(touche == GLUT_KEY_UP) && Affichage::gauche);
}


(il faut bien sur créer les variables de classe : Affichage::avancer etc..)





///////////////////// GESTION SOURIS /////////////////////

je te conseil un truc :
utilise la touche 'espace' pour commuter entre "souris croché au jeu" et "souris libre" et tu fais un truc comme ca :

glutPassiveMotionFunc(Affichage::mouse_move);

glutMotionFunc(Affichage::mouse_move);

ca fait que quand tu click tu peux toujours tourner la tête ce qui n'est pas le cas actuellement 

///////////////////// IMPACT /////////////////////

à ajouter juste après #include <iostream> :
#include <cmath>

/////////

à ajouter dans le constructeur d'une cible : 

this->touche = false;

/////////

Pour le click de la souris (dans Affichage.cpp) : 
à ajouter après glutSpecialFunc(Affichage::keyboard);

glutMouseFunc(Affichage::mouseClick);


et la fonction mouseClick à ajouter quelque pars :

void Affichage::mouseClick(int bouton, int etat, int x, int y)
{
    if(etat == GLUT_DOWN)
    {
        for(int i = 0; i < Affichage::objets->getNbObjet(); i++)
        {        
             Affichage::objets->getObjet(i)->calculerImpact(
             Point3D(Affichage::position_camera_x, Affichage::position_camera_y, Affichage::position_camera_z),
             Vecteur3D(Affichage::vecteur_direction[0], Affichage::vecteur_direction[1], Affichage::vecteur_direction[2]));
        }    
    }
}

/////////

Pour savoir si une cible à été touché tu par exemple la peindre en noir (dans Cible::afficher()) :

    glColor4f(this->touche ? 0 : this->couleur.r,
              this->touche ? 0 : this->couleur.v,
              this->touche ? 0 : this->couleur.b, this->couleur.a);


/////////


la fonction de calcul d'impact :

void Cible::calculerImpact(Point3D depuis, Vecteur3D direction)
{
    /*
    calcul la position de l'impact, les coordonnées
    (lambda, mu, gamma) sont relatives au rectangle formé par la cible
    */
  
    //tolerance du zero
    const double TOLERANCE_ZERO = 0.0001;
                
    //les vecteurs e et f dans le plan
    //ATTENTION : il sont calculés que pour une certaine orientation de la cible
    Vecteur3D e(0, 0, 1);
    Vecteur3D f(0, 1, 0);
    
    //le vecteur sur la droite (normalisé) 
    double longD = sqrt(pow(direction.x, 2) + pow(direction.y, 2) + pow(direction.z, 2));
    Vecteur3D d(direction.x/longD, direction.y/longD, direction.z/longD);
    
    //un point sur la droite
    Point3D A = depuis;
    
    //un point dans le plan
    Point3D B(
        0+this->position.x,
        this->potHauteur+this->position.y,
        -this->ciLargeur/2+this->position.z);
    
    double lambdaMuDenominateur =
        d.z*(-e.y*f.x + e.x*f.y) +
        d.y*( e.z*f.x - e.x*f.z) +
        d.x*(-e.z*f.y + e.y*f.z);
        
    if(lambdaMuDenominateur > -TOLERANCE_ZERO & lambdaMuDenominateur < TOLERANCE_ZERO) return;
    
    double lambda =
       (-A.y*e.z*f.x + B.y*e.z*f.x + A.x*e.z*f.y - B.x*e.z*f.y +
         A.z*( e.y*f.x - e.x*f.y) +
         B.z*(-e.y*f.x + e.x*f.y) +
         A.y*e.x*f.z - B.y*e.x*f.z - A.x*e.y*f.z + B.x*e.y*f.z) / lambdaMuDenominateur;
         
         
    double mu = 
       (A.y*d.z*e.x + B.y*d.z*e.x - A.x*d.z*e.y + B.x*d.z*e.y +
        B.z*( d.y*e.x - d.x*e.y) +
        A.z*(-d.y*e.x + d.x*e.y) -
        A.y*d.x*e.z + B.y*d.x*e.z + A.x*d.y*e.z - B.x*d.y*e.z) / lambdaMuDenominateur;
        
    double gammaDenominateur = d.x*(lambdaMuDenominateur);
    
    if(gammaDenominateur > -TOLERANCE_ZERO & gammaDenominateur < TOLERANCE_ZERO) return;
    
    double gamma =
       ((( A.z - B.z)*d.x + (-A.x + B.x)*d.z)* (d.y*f.x - d.x*f.y) +
         (A.y*d.x - B.y*d.x + (-A.x + B.x)*d.y)*(-d.z*f.x + d.x*f.z)) / gammaDenominateur;

    //test si l'impact est sur la cible
    if(lambda > 0 && mu > 0 && mu < this->ciLargeur && gamma > 0 && gamma < this->ciHauteur)
        this->touche = true;

    //cout << "lambda : " << lambda << "  mu : " << mu << "  gamma : " << gamma << endl;        
}