avoid

#include<graphics.h>
#include<conio.h>
#include<time.h>
#include<string.h>
#include<stdio.h>

#define K_UP 80       /* Tecla: Fecha Arriba */
#define K_DOWN 72     /* Tecla: Flecha Abajo */
#define K_LEFT 75     /* Tecla: Flecha Izquierda */
#define K_RIGHT 77    /* Tecla: Flecha Derecha */
#define K_QUIT 27     /* Tecla: ESC */
#define N_ENEMIES 7   /* Numero de Cuadros "enemigos" */
#define MAX_Y 480     /* Maximo de las Y (en pantalla: 480) */
#define MAX_X 640     /* Maximo de las X (en pantalla: 640) */

/* Ya existen dentro de las librerias incluidas, pero el compilador
   pide prototipo, sino lanza un warning y no queremos eso.
*/
void delay(int);
void srand(int);
int rand(void);

/* Determinara si las figuras (jugador y enemigo) colisionan */
int colision(int [][], int, int);

void main(void)
{
    int regen=1, i, j, act, per=1, cn=3, pts=0, dif=0;
    int en[N_ENEMIES][4], player[3]={320, 440, 20};
    int gd=DETECT, gm;
    char x[20]="Puntaje: 0";

    /* Colores de los niveles */
    int colniv[] = {7, 10, 2, 9, 1, 14, 12};

    /* Velocidad de bajada de los niveles */
    int velniv[] = {20, 25, 28, 35, 38, 42, 50};

    /* Semilla para generar numero aleatorio */
    srand((int) time(NULL));

    /*Inicializando las posiciones de los enemigos */
    for(i=0; i<N_ENEMIES; i++){
        for(j=0; j<4; j++)
        {
            if(j<2)
                en[i][j]=10;
            else
                en[i][j]=35;

            if(i>0 && j==0)
                en[i][j] = en[i-1][j]+95;
            if(i>0 && j==2)
                en[i][j] = en[i-1][j]+95;
        }
    }

    /* Abriendo modo grafico */
    initgraph(&gd, &gm, "c:\\tc20\\bin");
    setcolor(7);

    do{
        /* Agregando puntaje a la cadena a mostrar */
        sprintf(x, "Puntaje: %d", pts);

        if(dif>0)
            setcolor(colniv[dif]);

        outtextxy(5, 5, x);

        for(i=0; i<N_ENEMIES; i++)
        {
            if(regen==0)
            {
                /* si se ha llegado al limite inferior, o ha perdido
                   Se generan nuevamente las posiciones en Y */
                en[i][1] = 10;
                en[i][3] = 35;

                /* Generacion aleatoria de las posiciones en X */
                /* El sobreponer imagenes es una caracteristica
                   no un error, pero pude cambiarse, si en este punto
                   se valida que en[i][2] sea diferente a cualquier otro
                   en en[][2].
                */

                en[i][2]=rand() % MAX_X + 1;
                en[i][0]=en[i][2]-25;
            }

            /* Dibujando los cuadros "enemigos" */
            setcolor(i+1);
            rectangle(en[i][0], en[i][1], en[i][2], en[i][3]);
        }

        /* Plantando una nueva semilla de generacion de n aleatorios
           cada vez que se regeneran por limite o se pierde */
        if(cn%3==0)
            srand((int) time(NULL));

        /* Validando si los cuadros aun no han llegado al limite inferior
           para seguir avanzando hacia abajo */
        if(en[0][3] < MAX_Y )
        {
            for(i=0; i<N_ENEMIES; i++)
            {
                en[i][3]+=velniv[dif];
                en[i][1]+=velniv[dif];
            }
            /* Evitando regeneracion, ya que SI se puede bajar aun mas */
            regen=1;
            cn++; /* Para la semilla aleatoria */
        }else
        {
            /* EL JUGADOR HA GANADO UN PUNTO */
            regen=0;  /* Marca para regeneracion de cuadros */
            cn=3;     /* Marca para generar nueva semilla */
            pts++;    /* Aumento del puntaje */

            /* Cada 4 puntos, aumentar nivel */
            if(dif<6 && (pts%4==0) ){
                dif++;
                setcolor(colniv[dif]);
            }
        }

        /* IMPORTANTE */
        /* kbhit() devuelve 0 si se ha presionado un boton, 1 sino...
           Con esta condicion se dice entonces, que si se ha presionado
           un boton, capturarlo en la variable "act", asi capturamos los
           eventos del teclado.
        */
        if(kbhit())
        {
            act =(int)getch();
        }else{
            act=0;
        }

        /* si se ha capturado una tecla, mover jugador */
       if(act == K_RIGHT)
       {    if(player[0] + 20 < MAX_X)
                player[0]+=20;
       }else if(act == K_LEFT)
       {
            if(player[0] - 20 > 0)
                player[0]-=20;
       }

       /* Dibujando al jugador */
       circle(player[0], player[1], player[2]);

       /* Si los cuadros van por mas de la mitad de la pantalla
          Se valida que no choque el jugador con los cuadros.
       */

       if(en[0][3] > 400)
       {
            i=20;
            j=0;
            do{
                per=colision(en, player[0]-i, player[1]-j);
                i--;
                if(i>0)
                    j++;
                else
                    j--;

                if(per==0)
                    i=-21;
            }while(i>=-20);

            /* ya que la funcion "colision" devuelve 1 si no hay colision,
              puede existir la confusion de que: se halla ganado y se puede
              continuar, pero la funcion nos dice que no hay que regenerar
              porque aun no se ha perdido. Con esto permitimos que se
              regenere si ha ganado y se ha llegado al limite.
            */
            if(regen!=0)
                regen=per;

            /* EL JUGADOR HA PERDIDO */
            if(per==0)
            {
                setcolor(12);
                sprintf(x, "Puntaje: %d. Nivel: %d", pts, dif);
                outtextxy(220, 170, "Has Perdido!");
                outtextxy(220, 180, x);
                outtextxy(220, 200, "Presione cualquier tecla!");
                delay(1000);
                while( !kbhit() );

                dif=0;
                pts=0;
            }
       }

       /* Se esperan 90 milisegundos y se actualiza la pantalla */
       delay(90);
       cleardevice(); /* Actualiza borrando todo en pantalla */
       fflush(stdin); /* Borrar ordenes guardadas en buffer */
    }while(act!=K_QUIT);

    closegraph();
}

int colision(int en[N_ENEMIES][4],int x,int y)
{
    int i=0, j=0, c=0, col=1;

    /* La colision consiste en que: se toman coordenadas o
       como he llamado "puntos criticos" de cada figura, y
       se determinan si no hay contacto entre los puntos
       criticos de la figura jugador, con ninguna figura enemiga.
    */

    do{
    j = en[i][3]-25;
        do{
            if(y==j)
            {
            c = en[i][2]-25;
                do{
                    if(x==c)
                    {
                        col = 0;
                    }

                    if(col == 0)
                        c=en[i][2]+1;

                    c++;
                }while(c<en[i][2]);
            }

            if(col == 0)
                j=en[i][3]+1;

            j++;
        }while(j<en[i][3]);

        if(col==0)
            i=N_ENEMIES+1;
        i++;
    }while(i<N_ENEMIES);

return col;
}