Programmation de l'ancien jeu arcade , ping-pong avec C ++

//installez les ncurses avant! ! sudo apt-get install libncurses-dev
//compilation >  g++ -std=c++11 -o tennis tennis.cpp -lncurses
//Etude de l'ancien jeu de ping pong en  c ++ objet
//Antonio Villanueva Segura
#include <ncurses.h>
#include <stdlib.h>
#include <string>

using namespace std ;
#define RETARDO 10000 //délai pour un  ARM9 à 400 Mhz ==100
//Touches de contrôle raquettes de ping-pongg
#define SUBE_IZQ '7'
#define BAJA_IZQ '1'

#define SUBE_DER '9'
#define BAJA_DER '3'

#define MARGENX 3 //offset marge x fenêtre du terminal
#define MARGENY 3 //offset marge y fenêtre du terminal
#define MAX_X 80 //Maximum X dans fenetre ncurses , constructeur par défaut
#define MAX_Y 24 //Maximum Y dans fenetre ncurses , constructeur par défaut
/***********************************************************************/
/***********************************************************************/
class pelota{
    public:
    pelota(int max_x,int max_y,string obj,int x,int y);
    void mueve(int x1,int y1,int x2,int y2) ;// mouvement de la balle
    int getX() const;//Coordonne l'objet X, peut être une balle ou une raquette
    int getY() const;//Coordonne l'objet Y, peut être une balle ou une raquette
    int PtosIzq()const;//Retour, points de joueur à Gauche
    int PtosDer() const;//Retour, points de joueur à Droite
    string getObj()const;// retourne le dessin de l'objet O ou |

    protected:
    string objeto;//dessin d'objet balle O raquette |
    int max_x,max_y,x,y;//écran maximum, coordonnées de la balle O
    bool dir_x,dir_y;//direction , où va la balle
    int puntosIzq,puntosDerch;//points de chaque joueur
};
/***********************************************************************/
pelota::pelota(int max_x=80,int max_y=24,string obj="O",int x=40,int y=12):
max_x(max_x),max_y(max_y),x(x),y(y),dir_x(true),dir_y(true),
puntosIzq(0),puntosDerch(0){objeto=obj;}
/***********************************************************************/
void pelota::mueve(int x1,int y1,int x2,int y2){// mouvement de la balle

    //se déplace selon la direction vrai ou faux
    dir_x ? x++: x--;
    dir_y ? y++: y--;

    //détection de raquettes si collision; trajectoire inverse

    if ( ((x1+1)==x && y1==y) || ((x2-1)==x && y2==y) ){dir_x^=1;}

    //collision avec les extrémités du champ; trajectoire inverse
    if (x>max_x-MARGENX){dir_x^=1;puntosDerch++;flash();}
    if (y>max_y-MARGENY){dir_y^=1;}

    if (x<=1){dir_x^=1;puntosIzq++;flash();}
    if (y<=1) {dir_y^=1;}
}

/***********************************************************************/
int pelota::getX()const {return x;}//Coordonne X la balle ou la raquette
/***********************************************************************/
int pelota::getY()const{return y;}//Coordonne Y la balle ou la raquette
/***********************************************************************/
int pelota::PtosIzq()const {return puntosIzq;}//Retour, points de joueur à Gauche
/***********************************************************************/
int pelota::PtosDer()const {return puntosDerch;}//Retour, points de joueur à Droite
/***********************************************************************/
string pelota::getObj()const {return objeto;}//Graphique d'objet
/***********************************************************************/
class raqueta : public pelota {//Classe de raquette héritée de la balle ...
    public:
    raqueta(int max_x,int max_y,string obj,int x,int y);
    void mueve(int tecla) ;//déplace la raquette , en fonction de la touche pressée
};
/***********************************************************************/
raqueta::raqueta(int max_x=MAX_X,int max_y=MAX_Y,string obj="O",int x=1,int y=1):
pelota ( max_x , max_y, "|",x,y){} //initialise la classe de base de balle
/***********************************************************************/
void raqueta::mueve(int tecla){//déplace la raquette , en fonction de la touche pressée

    if (x<max_x/2){//raquette Gauche

        switch (tecla){ //raquette Gauche.
            case SUBE_IZQ:--y;erase();break;
            case BAJA_IZQ :++y;erase();break;
        }
    }else{//raquette Drotie
            switch (tecla){ //raqueta Droite.
                case SUBE_DER:--y;erase();tecla=0;break;
                case BAJA_DER:++y;erase();tecla=0;break;
            }
        }
    tecla=0;//Reset . évite la répétition de la touche

    if (y<2){y=2;}//limite inférieure y
    if (y>max_y-3){y=max_y-3;} //limite supérieure
}

/***********************************************************************/
/***********************************************************************/
class juego{//Contexte et gestion du jeu
    public:
    juego ();//Constructeur de jeu par défaut
    ~juego();//Destructeur, fin jeu
    void run ();

    private:
    void pantalla();//Montrer ce qui devrait être peint
    void campo ();//dessiner un champ de tennis
    WINDOW *win;//fenetre ncurses , graphique
    int max_x,max_y;//limites, fenêtre ncurses
    pelota ball;//instance d'une balle
    raqueta izq,der;//Instances de deux raquettes gauche et droite
};

/***********************************************************************/

juego::juego():win (initscr()){//Constructeur de jeu par défaut
    getmaxyx(win,max_y,max_x);//maximum du jeu , fenêtre ncurses
    curs_set(0);
    noecho();

    ball =pelota( max_x , max_y, "O");//Créer une balle
    izq=raqueta (max_x , max_y, "|",2,1);//Créer une raquette gauche
    der=raqueta (max_x , max_y, "X",max_x-3,1);//Créer une raquette droite
    }
/***********************************************************************/
juego::~juego(){ //Fin du jeu
    delwin(win);//fin  ncurses
    endwin();
    refresh();}
/***********************************************************************/
void juego::run(){
    int tempo(0);//pour le retard, en boucle, ne bloque pas
    int tecla;//pour la lecture du clavier
    timeout (0);//ça ne bloque pas la lecture

    while (true){// boucle principale jeu
        tecla=getch();//lire le clavier

        while (tempo  >=RETARDO){
            ball.mueve(izq.getX(),izq.getY(),der.getX(),der.getY());//déplacer la balle
            tempo=0;
        }

        tempo++;//retardo

        izq.mueve(tecla);//raquette gauche move
        der.mueve(tecla);//raquette droite move

        pantalla();//Montrer ce qui devrait être peint
    }
}
/***********************************************************************/
void juego::pantalla(){//Montrer ce qui devrait être peint

    erase ();//effacer l'écran
    mvprintw(ball.getY(),ball.getX(),ball.getObj().c_str());//impression, balle

    mvprintw(izq.getY(),izq.getX(),izq.getObj().c_str());//impression, raquette Gauche.
    mvprintw(der.getY(),der.getX(),der.getObj().c_str());//impression, raquette Droite.


    mvprintw(max_y-3,((max_x/2)-5),to_string(ball.PtosDer()).c_str() );//points Droite
    mvprintw(max_y-3,((max_x/2) + 4),to_string(ball.PtosIzq()).c_str() );//points Gauche

    campo();//imprimer un court de tennis, lignes centrales et haut
    refresh();
}
/***********************************************************************/
void juego::campo (){//imprimer un court de tennis, lignes centrales, haut
    for (int y=0;y<max_y;y++){
        mvprintw (y,(max_x-1)/2,"|"); //centre , moitie de tennis
    }

    for (int y=0;y<max_y;y+=max_y-1){//dessiner des lignes sup et  bas
        for (int x=0; x<max_x ;x++){ mvprintw (y,x,"-");}
    }
}
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
int main(){

    juego tenis;
    tenis.run();
}