Juego antiguo Ping-Pong en C++ objeto y con grafismo curses

//https://www.youtube.com/watch?v=xFS6tbjdv3Q
//instalar las ncurses antes ! sudo apt-get install libncurses-dev
//compilacion  g++ -std=c++11 -o juego juego.cpp -lncurses
//Estudio del antiguo juego de ping pong en c++ objeto empleando la libreria  grafica curses
//Antonio Villanueva Segura
#include <ncurses.h>
#include <stdlib.h>
#include <string>

using namespace std ;
#define RETARDO 10000 //retardo para un ARM9 a 400 Mhz ==100
//Teclas de control raquetas de ping-pong
#define SUBE_IZQ '7'
#define BAJA_IZQ '1'

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

#define MARGENX 3 //offset margen x ventana terminal
#define MARGENY 3 //offset margen y ventana terminal
#define MAX_X 80 //Maxima X en ventana curses , constructor por defecto
#define MAX_Y 24 //Maxima Y en ventana curses , constructor por defecto
/***********************************************************************/
/***********************************************************************/
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);//algoritmo movimiento pelota
    int getX() const;//Coordenadas X objeto ,puede ser pelota o raqueta
    int getY() const;//Coordenadas Y objeto ,puede ser pelota o raqueta
    int PtosIzq()const;//Retorna puntos jugador Izquierda
    int PtosDer() const;//Retorna puntos jugador Derecha
    string getObj()const;// retorna dibujo del objeto

    protected:
    string objeto;//dibujo del objeto pelota O raqueta |
    int max_x,max_y,x,y;//maximos pantalla,coordenadas pelota
    bool dir_x,dir_y;//direccion hacia donde va la pelota
    int puntosIzq,puntosDerch;//puntos de cada jugador
};
/***********************************************************************/
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){// movimiento pelota

    //se desplaza segun la direccion true o false
    dir_x ? x++: x--;
    dir_y ? y++: y--;

    //deteccion raquetas , colision ; inversa trayectoria

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

    //choque con los extremos del campo ; inversa trayectoria
    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;}//Coordenada X pêlota o raqueta
/***********************************************************************/
int pelota::getY()const{return y;}//Coordenada Y pêlota o raqueta
/***********************************************************************/
int pelota::PtosIzq()const {return puntosIzq;}//Retorna puntos jugador Izq.
/***********************************************************************/
int pelota::PtosDer()const {return puntosDerch;}//Retorna puntos jugador Der.
/***********************************************************************/
string pelota::getObj()const {return objeto;}//Grafico del objeto
/***********************************************************************/
class raqueta : public pelota {//Clase raqueta hereda de pelota ...
    public:
    raqueta(int max_x,int max_y,string obj,int x,int y);
    void mueve(int tecla);//mueve raqueta en funcion tecla
};
/***********************************************************************/
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){} //inicializa clase base pelota{}
/***********************************************************************/
void raqueta::mueve(int tecla){//mueve raqueta en funcion tecla

    if (x<max_x/2){//raqueta izquierda

        switch (tecla){ //raqueta Izq.
            case SUBE_IZQ:--y;erase();break;
            case BAJA_IZQ :++y;erase();break;
        }
    }else{//raqueta Derecha
            switch (tecla){ //raqueta Derch.
                case SUBE_DER:--y;erase();tecla=0;break;
                case BAJA_DER:++y;erase();tecla=0;break;
            }
        }
    tecla=0;//Reset evita repeticion de tecla

    if (y<2){y=2;}//limite inferior y
    if (y>max_y-3){y=max_y-3;} //limite superior
}

/***********************************************************************/
/***********************************************************************/
class juego{//Contexto y gestion del  juego
    public:
    juego ();//Constructor por defecto de juego
    ~juego();//Destructor ... Fin juego
    void run ();

    private:
    void pantalla();//Muestra lo que se debe de pintar
    void campo ();//dibuja un campo de tenis
    WINDOW *win;//ventana curses , graficos
    int max_x,max_y;//limites ventana curses
    pelota ball;//instancia de una pelota
    raqueta izq,der;//instancias  de dos raquetas Izquierda y Derecha
};

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

juego::juego():win (initscr()){//Constructor de la clase juego
    getmaxyx(win,max_y,max_x);//maximos de la ventana juego ncurses
    curs_set(0);
    noecho();

    ball =pelota( max_x , max_y, "O");//Crea una pelota
    izq=raqueta (max_x , max_y, "|",2,1);//Crea raqueta izquierda
    der=raqueta (max_x , max_y, "X",max_x-3,1);//Crea raqueta derecha
    }
/***********************************************************************/
juego::~juego(){ //Fin juego
    delwin(win);//fin de ncurses
    endwin();
    refresh();}
/***********************************************************************/
void juego::run(){
    int tempo(0);//para retardo , en bucle , no bloquea
    int tecla;//para lectura del teclado
    timeout (0);//no bloquea lectura

    while (true){//bucle principal juego
        tecla=getch();//lee teclado

        while (tempo  >=RETARDO){
            ball.mueve(izq.getX(),izq.getY(),der.getX(),der.getY());//mueve pelota
            tempo=0;
        }

        tempo++;//retardo

        izq.mueve(tecla);// mueve segun tecla pulsada raqueta izquierda
        der.mueve(tecla);//mueve  segun tecla pulsada raqueta derecha

        pantalla();//Imprime ,pinta , muestra  objetos en pantalla
    }
}
/***********************************************************************/
void juego::pantalla(){//Muestra lo que se debe de pintar

    erase ();//borra pantalla
    mvprintw(ball.getY(),ball.getX(),ball.getObj().c_str());//imprime pelota

    mvprintw(izq.getY(),izq.getX(),izq.getObj().c_str());//imprime raqueta izq.
    mvprintw(der.getY(),der.getX(),der.getObj().c_str());//imprime raqueta derer.


    mvprintw(max_y-3,((max_x/2)-5),to_string(ball.PtosDer()).c_str() );//puntos Derecha
    mvprintw(max_y-3,((max_x/2) + 4),to_string(ball.PtosIzq()).c_str() );//puntos Izquierda

    campo();//imprime un campo de tenis ,lineas central ,superior
    refresh();
}
/***********************************************************************/
void juego::campo (){//dibuja un campo de tenis
    for (int y=0;y<max_y;y++){
        mvprintw (y,(max_x-1)/2,"|"); //centro del campo de tenis
    }

    for (int y=0;y<max_y;y+=max_y-1){//dibuja rayas sup. e inferior
        for (int x=0; x<max_x ;x++){ mvprintw (y,x,"-");}
    }
}
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
int main(){

    juego tenis;
    tenis.run();
}