Varias cosas:

1. No escribas en negrita, no se te va a entender mejor ( más bien todo lo contrario ).

2. El código lo metes dentro de las etiquetas GeSHi correspondientes ( en tu caso C )

3. y1 es una función declarada en math.h... deberías plantearte cambiar los nombres o, mejor aún, agrupar esas variables en estructuras y, por supuesto, evitar el uso de variables globales.

4. Variables con nombres tan guays como x, xx, x1, ix no me dicen absolutamente nada... ¿tanto cuesta usar nombres que clarifiquen un poco el código? O al menos añade comentarios al código.

5. En la siguiente línea:

if( x== 2);
  condicion =false;

te sobra el primer punto y coma ';'... ese if así como está, simplemente, no hace nada.

6. Tu código es un puñetero lío. Un ejemplo:

if (x > 20)
{
  x = 2;
  y = (rand() % 80) + 6;
 
  if( x== 2);
    condicion =false;
}

Suponiendo corregido el tema del punto y coma... a ver si lo entiendo, hacemos x=2 y luego... si x=2 entonces condicion = false???? qué sentido tiene ese if ahí ??

7. Las coordenadas de generación de los asteroides están mal:

if (x > 20)
{
  x = 2;
  y = (rand() % 80) + 6;
}

La pantalla tiene 80 columnas ( X ) no 80 filas ( Y ).

Pondré más cosillas cuando tenga tiempo...

Ah, .... y debe ser "explosion", no "explocion". Se que es una nimiedad, pero nunca está demás 

Si no hacen falta capturas... cualquiera que pruebe tu código ve el resultado.

Lo que te estamos diciendo es que el diseño que has elegido es muy pobre y propenso a errores y prueba de ello es que no es fácil encontrar el error en un programa tan corto.

Te propongo que readaptes un poco el código... y como muestra de buena fe te pongo algunas propuestas:

1. Usa estructuras. Las variables estarán organizadas y será más sencillo evitar el uso de variables globales:

typedef struct
{
  int x;
  int y;
} Coordenada;
 
typedef struct
{
  // Coordenadas de la nave
  Coordenada coord_nave;
 
  // Coordenadas de cada asteroide
  Coordenada coord_asteroides[ MAX_ASTEROIDES ];
 
  // Numero de vidas restantes
  int vidas;
 
  // Nivel de salud
  int salud;
 
  // Nivel del juego
  int nivel;
 
  // Progreso del juego. Para saber cuando subir de nivel
  int progreso;
} DatosJuego;

2. Usa defines. Vienen muy bien para evitar tener valores fijos en el código:

// Numero total de asteroides
#define MAX_ASTEROIDES 4
 
// progreso necesario para pasar de nivel
#define MAX_PROGRESO 1000
 
// desplazamiento de la nave
#define MOV_NAVE    2
 
// Caracter para pintar los asteroides
#define CHAR_ASTEROIDE 3
 
// Caracter para pintar la salud
#define CHAR_SALUD     4
 
// Para limpiar la pantalla
#define CHAR_BLANCO    ' '

3. Crea funciones para las tareas repetitivas. Por ejemplo pintar la nave:

void pintar_nave( Coordenadas coord )
{
  int i;
  for ( i=0; i<3; i++ )
  {
    gotoxy( coord.x, coord.y + i );
    puts( nave[ i ] );
  }
}

Ten en cuenta que para que el código anterior funcione es necesario redefinir la forma de describir la nave... algo así estaría bien (copiado de amchacon):

char nave[][]=
                   {
                     { " ***   " },   
                     { " ** *  " },
                     { " ***   " }
                   };

Y lo mismo puedes hacer para borrar la nave....

void borrar_nave( Coordenadas coord )
{
  int i;
  for ( i=0; i<3; i++ )
  {
    gotoxy( coord.x, coord.y + i );
    puts( nave_vacia[ i ] );
  }
}

Puedes, de echo, juntar ambas funciones en una sola y pasarle como argumento la matriz para pintar la nave o borrarla... pero eso ya te lo dejo a ti.

4. Evita las variables globales. No son necesarias como norma general.

 
int main( )
{
  DatosJuego datos_juego;
 
  // inicializamos la estructura
  memset( &datos_juego, 0, sizeof( DatosJuego ) );
  datos_juego.coord_nave.x = 1;
  datos_juego.coord_nave.y = 19;
  datos_juego.vidas = 3;
  datos_juego.salud = 3;
  datos_juego.nivel = 1;
 
  vidas( datos_juego.vidas );
  Barra_salud( datos_juego.salud );
  gotoxy(35,1); printf("NIVEL %d", datos_juego.nivel );   
 
  pintar_nave( datos_juego.coord_nave );  
 
  while( datos_juego.vidas > 0 )
    jugar( &datos_juego);
 
  gotoxy(22,16); printf("Game Over");
  Sleep(120);  
  getch();
  return 0;
}

5. Evita instrucciones duplicadas:

Por ejemplo el código que controla la pulsación del teclado tiene código repetitivo hasta la saciedad.

switch (tecla)
{         
  case ARR:
    if ( datos_juego->coord_nave.y > 4 )
    {
      borrar_nave( datos_juego->coord_nave );
      datos_juego->coord_nave.y -= MOV_NAVE;
    }                              
    break;
 
  case ABA: 
    // Nota que ya no es 70 sino 20, la consola tiene unicamente 25 filas
    if( datos_juego->coord_nave.y < 20 )
    {
      borrar_nave( datos_juego->coord_nave );
      datos_juego->coord_nave.y += MOV_NAVE;
    }                              
    break;
 
  case IZQ:
    if ( datos_juego->coord_nave.x > 4 )
    {
      borrar_nave( datos_juego->coord_nave );
      datos_juego->coord_nave.x -= MOV_NAVE;
    }                              
    break;
 
  case DER:
     if ( datos_juego->coord_nave.x < 70 )
    {
      borrar_nave( datos_juego->coord_nave );
      datos_juego->coord_nave.x += MOV_NAVE;
    }                              
    break;
} //fin del switch
 
pintar_nave( datos_juego->coord_nave );

Con estos dos pasos el código ya lucirá un aspecto bastante más saludable. Será más complicado confundirse al usar las variables y será más sencillo seguir el código que has escrito.

Dale un repaso al código siguiendo estas pautas... u otras similares a tu elección y si no consigues resolver tu problema pon tu nuevo código.

Ah sí, por segunda vez Usa las etiquetas GeSHi para que el codigo sea legible si no, voy a empezar a plantearme el no responderte.

PD.: por si te preguntabas sobre la variable "progreso"... la idea que pensé es que con cada refresco, progreso se incrementase en una unidad. Al llegar a MAX_PROGRESO, se pone el contador a 0 y se sube el nivel.

Cuando corrijas tu código te comento si quieres cómo puedes hacer que aumente la dificultad con cada nivel.

      if(!condicion)
      {
        repeticion --;
        //condicionc = true;
      }
      if(repeticion == 4)
      {
          nivel++;
          gotoxy(35,1); printf("NIVEL %i",nivel);                
 
          gotoxy(ix,iy); puts(borrar_nave);      
          gotoxy(ix,iy); puts(borrar_nave);   
          gotoxy(ix,iy); puts(borrar_nave);   
 
          iy -= 2; //iy = iy - 2;
 
          gotoxy(ix,iy); puts(nave_l1);      
          gotoxy(ix,iy); puts(nave_l2);   
          gotoxy(ix,iy); puts(nave_l3);
 
          repeticion = 0;
 
 
      }

Partiendo de ese código... si lo resumimos para quedarnos con lo importante tenemos:

      if(!condicion)
      {
        repeticion --;
      }
      if(repeticion == 4)
      {
          nivel++;
          repeticion = 0;
      }

Dicho de otra forma... coges un int ( 2^32 combinaciones = 4.294.967.296 combinaciones ) y lo vas decrementando empezando por cero... es decir, de 0 a 4 pasando primero por negativos... tendrías que jugar unos 4.300 millones de turnos para que te cambie de nivel.

En serio, renombra esas variables... no es tan complicado y queda un código más sencillo de seguir:

#include <windows.h>
#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
 
#define ARR 72
#define ABA 80
#define IZQ 75
#define DER 77
 
#define CHAR_SALUD    3
#define CHAR_DIAMANTE 4
#define CHAR_BLANCO   ' '
 
#define MAX_CORAZONES 3
#define MAX_DIAMANTES 25
#define MAX_PROGRESO  1000
#define MAX_VIDAS     3
 
#define AVANCE        2
 
typedef struct
{
  int x;
  int y;
} Coordenadas;
 
typedef struct
{
  Coordenadas coord_nave;
  Coordenadas coord_diamantes[ MAX_DIAMANTES ];
 
  int num_vidas;
  int corazones;
  int nivel;
  int progreso;
} DatosJuego;
 
// Dibujo de la nave
char *nave[]        = { " ***  ", " ** * ", " ***  " };
char *nave_vacia[]  = { "      ", "      ", "      " };
char *explosion1[]  = { "  **  ", " **** ", "  **  " };
char *explosion2[]  = { "* ** *", " **** ", "* ** *" };
 
void inicializar( DatosJuego* datos_juego )
{
  memset( datos_juego, 0, sizeof( DatosJuego ) );
 
  datos_juego->coord_nave.x = 1;
  datos_juego->coord_nave.y = 19;
 
  datos_juego->num_vidas = MAX_VIDAS;
  datos_juego->corazones = MAX_CORAZONES;
  datos_juego->nivel = 1;
}
 
void gotoxy(int x, int y)
{
  HANDLE hCon;
  COORD dwPos;
 
  dwPos.X = x;
  dwPos.Y = y;
 
  hCon = GetStdHandle( STD_OUTPUT_HANDLE );
  SetConsoleCursorPosition( hCon, dwPos );
}
 
void pintar_nave( Coordenadas coord, char* patron[] )
{
  int i;
  for ( i=0; i<3; i++ )
  {
    gotoxy( coord.x, coord.y + i );
    puts( patron[ i ] );
  }
}
 
void pintar_nivel( int nivel )
{
  gotoxy( 35, 1 );
  printf( "NIVEL: %d", nivel );
}
 
void pintar_vidas( int vidas )
{
   gotoxy( 2, 1 );
   printf( "VIDAS %d", vidas );
}
 
void pintar_salud( int salud )
{
  int i;
 
  gotoxy( 72, 1 );
 
  for( i = 0; i < salud; i++ )
    putchar( CHAR_SALUD );
 
  for ( ; i < 3; i++ )
    putchar( CHAR_BLANCO );
}
 
void pintar_explosion( Coordenadas coord )
{
  int i;
 
  for ( i = 0; i < 3; i++ )
  {
    gotoxy( coord.x, coord.y + i );
    puts( explosion1[ i ] );
  }
 
  Sleep( 380 );
 
  for ( i = 0; i < 3; i++ )
  {
    gotoxy( coord.x, coord.y + i );
    puts( explosion2[ i ] );
  }
 
  Sleep(380);
 
  pintar_nave( coord, nave );
}
 
void reiniciar_diamante( Coordenadas* coord )
{
  gotoxy( coord->x, coord->y );
  putchar( CHAR_BLANCO );
 
  if ( coord->x == 0 )
  {
    // Este codigo permite que los asteroides salgan repartidos
    // por el escenario al inicio de la partida
    coord->x = ( rand( ) % 50 ) + 29;
  }
  else
    coord->x = 79;
 
  coord->y = (rand( ) % 20 ) + 5;
}
 
void mover_diamante( Coordenadas* coord )
{
  gotoxy( coord->x, coord->y );
  putchar( CHAR_BLANCO );
 
  if ( coord->x < 2 )
    reiniciar_diamante( coord );
  else
    coord->x--;
 
  gotoxy( coord->x, coord->y );
  putchar( CHAR_DIAMANTE );
}
 
int colision( Coordenadas coord_nave, Coordenadas coord_diamante )
{
  int to_return = 0;
 
  // Comprobamos que el asteroide esta en la misma vertical que
  // la nave
  if ( ( coord_diamante.y >= coord_nave.y )
    && ( coord_diamante.y <= coord_nave.y + 2 ) )
  {
    // Ahora se comprueba si esta en la misma horizontal
    if ( ( coord_diamante.x <= coord_nave.x + 5 )
      && ( coord_diamante.x > coord_nave.x ) )
    {
      to_return = 1;
    }
  }
 
  return to_return;
}
 
void jugar( DatosJuego* datos_juego )
{
  //rutina de los diamantes
 
  int i;
  for ( i = 0; i < MAX_DIAMANTES; i++ )
    mover_diamante( &datos_juego->coord_diamantes[ i ] );
 
  //rutina de mover la ave
  if( _kbhit( ) )
  {
    unsigned char tecla = _getch( );
 
    switch (tecla)
    {
      case ARR:
        if ( datos_juego->coord_nave.y > 4 )
        {
          pintar_nave( datos_juego->coord_nave, nave_vacia );
          datos_juego->coord_nave.y -= AVANCE;
        }
        break;
 
      case ABA:
 
        if (datos_juego->coord_nave.y < 20 )
        {
          pintar_nave( datos_juego->coord_nave, nave_vacia );
          datos_juego->coord_nave.y += AVANCE;
        }
        break;
 
      case IZQ:
        if( datos_juego->coord_nave.x > 4 )
        {
          pintar_nave( datos_juego->coord_nave, nave_vacia );
          datos_juego->coord_nave.x -= AVANCE;
        }
        break;
 
      case DER:
        if( datos_juego->coord_nave.x < 70 )
        {
          pintar_nave( datos_juego->coord_nave, nave_vacia );
          datos_juego->coord_nave.x += AVANCE;
        }
        break;
    } //fin del switch
  }// Fin if
 
  pintar_nave( datos_juego->coord_nave, nave );
 
  //rutina para golpes de metoritos
  for ( i = 0; i < MAX_DIAMANTES; i++ )
  {
    if ( colision( datos_juego->coord_nave, datos_juego->coord_diamantes[ i ] ) )
    {
      reiniciar_diamante( &datos_juego->coord_diamantes[ i ] );
      pintar_nave( datos_juego->coord_nave, nave );
 
      datos_juego->corazones--;
 
      if( datos_juego->corazones == 0 )
      {
        datos_juego->num_vidas--;
        datos_juego->corazones = MAX_CORAZONES;
        pintar_vidas( datos_juego->num_vidas );
        pintar_explosion( datos_juego->coord_nave );
      }
 
      pintar_salud( datos_juego->corazones );
      break;
    }
  }
 
  /*rutina para cambio de nivel*/
  if ( datos_juego->progreso == MAX_PROGRESO )
  {
    datos_juego->nivel++;
    pintar_nivel( datos_juego->nivel );
    datos_juego->progreso = 0;
  }
  else
    datos_juego->progreso++;
}
 
int main ()
{
  DatosJuego datos_juego;
 
  inicializar( &datos_juego );
 
  pintar_vidas( datos_juego.num_vidas );
  pintar_salud( datos_juego.corazones );
 
  pintar_nivel(datos_juego.nivel );
  pintar_nave( datos_juego.coord_nave, nave );
 
  while( datos_juego.num_vidas > 0 )
  {
    jugar( &datos_juego );
 
    int sleep = 80 - datos_juego.nivel * 10;
    if ( sleep < 10 )
      sleep = 10;
    Sleep( sleep );
  }
 
 
  gotoxy( 30, 11 );
  puts( "*******************" );
  gotoxy( 30, 12 );
  puts( "*    Game Over    *" );
  gotoxy( 30, 13 );
  puts( "*******************" );
 
  gotoxy( 0, 24 );
  _getch( );
  return EXIT_SUCCESS;
}

  Muchas gracias!! has salvado mi alma de satanás >_<'
muchas gracias y perdona las molestias.... >-<'