el buscaminas en c

[chivis cristian]

tengo un problema con ese codigo fuente y no se porque alguien que me ayude por favor el error esta en la linea  189 esta hecho en c recopilen por favor y demen una ayudita

#include <stdio.h>
#include <stdlib.h>
#include "buscaminas.h"

struct casilla **tablero;   /* tabla dinámica de 2 dimensiones */

int x,   /* número de columnas del tablero */
   y,   /* número de filas del tablero */
   minas,   /* número de minas */
   destapadas = 0,   /* número de casillas destapadas */
   banderas = 0,   /* banderas (posibles minas) puestas */
   pos_x = 0,   /* componente x del cursor */
   pos_y = 0,   /* componente y del cursor */
   seg = 1,   /* tiempo acumulado en segundos */
   modo_juego;   /* 1.- principiante 2.- intermedio 3.- experto 0.- personalizado */

/* prototipos de funciones */
void GenerarMinas ();
void menu ();
void main ();

/* protoripos de funciones definidas en ficheros.c */
void GuardarResultado (int, int);
void GuardarPartida (int, int, int, int, int, int, int, int, int, struct casilla **);
void CargarPartida (int *, int *, int *, int *, int *, int *, int *, int *, int *, struct casilla ***);
void MostrarResultados (int);


/* devuelve los segundos del reloj */
int Segundos ()
{
   struct tm *tiempo;
   time_t t;
   time (&t);
   tiempo = localtime(&t);
   return tiempo->tm_sec;
}

/* muestra el tablero del juego por pantalla según el modo:
0: modo normal
1: todas las casillas visibles (cuando se pierde)
2: todas las casillas tapadas (cuando el juego está en pausa) */
void MostrarTablero (int modo)
{
   int ancho,
      alto;

   printf ("PR%c\n\n   ",1);

   /* imprime el eje de coordenadas x */
   for (ancho=0; ancho<x; ancho++)
      printf ("%3d",ancho);

   printf ("\n   ");

   /* imprime líneas debajo del eje de coordenadas x */
   for (ancho=0; ancho<x*3; ancho++)
      printf ("%c",95);

   /* imprime la primera línea vertical del eje de coordenadas y */
   printf ("\n  %c\n",179);

   /* imprime el tablero por líneas*/
   for (alto=0; alto<y; alto++)
   {
      /* imprime el número de fila y una raya vertical al primcipio de cada línea */
      printf ("%2d%c",alto,179);
      /* imprime todas las casillas de la línea */
      for (ancho=0; ancho<x; ancho++)
      {
         /* si la casilla está oculta y el modo es 0 o el modo es 2 se imprime el
         cursor (si tiene) y un cuadrado negro */
         if (((tablero[ancho][alto].estado == oculto)&&(!modo)) || (modo == 2))
         {
            printf (" %c%c",tablero[ancho][alto].sel,219);
            continue;
         }

         /* si la casilla está visible y el modo es 0 o el modo es 1 se imprime el
         cursor (si tiene) y un cuadrado negro y lo que corresponda */
         if (((tablero[ancho][alto].estado == visible)&&(!modo)) || (modo == 1))
         {
            /* una mina */
            if (tablero[ancho][alto].ady == 9)
            {
               printf (" %c%c",tablero[ancho][alto].sel,15);
               continue;
            }
            /* un cuadro gris (si la casilla tiene 0 minas adyacentes) */
            if (tablero[ancho][alto].ady == 0)
            {
               printf (" %c%c",tablero[ancho][alto].sel,177);
               continue;
            }
            /* el número de minas adyacentes */
            printf (" %c%d",tablero[ancho][alto].sel,tablero[ancho][alto].ady);
            continue;
         }

         /* si la casilla está marcada como mina se imprime una bandera */
         if (tablero[ancho][alto].estado == mina)
         {
            printf (" %c%c",tablero[ancho][alto].sel,4);
            continue;
         }

         /* si la casilla está marcada como dudosa se imprime una interrogación */
         if (tablero[ancho][alto].estado == dudoso)
         {
            printf (" %c?",tablero[ancho][alto].sel);
            continue;
         }
      }
      /* se imprimen barras verticales entre línea y línea */
      if (alto != y-1)
         printf ("\n  %c\n",179);
   }
   printf ("\n\n");
}

/* destapa todas las casillas anexas de una que no tiene minas adyacentes */
void DestaparAnexas (int pos_x,int pos_y)
{
   int   i,
      j;

   /* destapa la casilla */
   tablero[pos_x][pos_y].estado = visible;

   for (i=-1; i<2; i++)
      for (j=-1; j<2; j++)
         if (((pos_x+i>=0)&&(pos_x+i<x))&&((pos_y+j>=0)&&(pos_y+j<y)))
            if (tablero[pos_x+i][pos_y+j].estado != visible)
            {
               /* si la casilla estaba marcada como mina, se quita la bandera */
               if (tablero[pos_x+i][pos_y+j].estado == mina)
                  banderas--;

               /* si la casilla tampoco tiene adyacentes se hace una llamada
               recursiva */
               if (tablero[pos_x+i][pos_y+j].ady == 0)
                  DestaparAnexas (pos_x+i,pos_y+j);

               tablero[pos_x+i][pos_y+j].estado = visible;
               destapadas++;
            }
}

/* gestiona la partida segun el modo:
0: modo normal
1: cuando se pierde
2: cuando el juego está en pausa */
void Partida (int modo)
{
   int tiempo = Segundos (); /* decide cuando hay que cambiar los segundos */

   system ("cls");

   MostrarTablero (modo);

   /* si se han destapado todas las casillas sin minas (cuando se gana) */
   if (destapadas == (x*y)-minas)
   {
      printf ("\nHas ganado!!!\n");
      printf ("\n1.. Volver a jugar");
      printf ("\n2.. Volver al menu");
      /* no se guardan los mejores de modos personalizados */
      if (modo_juego)
         printf ("\n3.. Guardar resultado");

      /* se restauran los datos de la partida */
      pos_x = pos_y = 0;
      tiempo = seg;
      seg = 1;
      banderas = 0;
      destapadas = 0;

      switch (getch ())
      {
      case '1':   /* volver a jugar en el mismo modo */
         GenerarMinas ();

      case '2':   /* volver al menú principal */
         menu ();

      case '3':   /* guardar el resultado */
         /* no se guardan los mejores de modos personalizados */
         if (modo_juego)
            GuardarResultado (tiempo, modo_juego);

      default:
         Partida (0);
      }
   }

   /* si se ha destapado alguna casilla con mina (se ha perdido) */
   if (modo == 1)
   {
      printf ("\nHas perdido\n");
      printf ("\n1.. Menu principal");
      printf ("\n2.. Volver a intentarlo");

      /* se restauran los datos de la partida */
      pos_x = pos_y = 0;
      seg = 1;
      banderas = 0;
      destapadas = 0;

      switch (getch ())
      {
      case '1':   /* volver al menú principal */
         menu ();

      case '2':   /* volver a jugar en el mismo modo */
         GenerarMinas ();

      default:
         Partida (1);
      }
   }

   /* si el juego está en pausa */
   if (modo == 2)
   {
      printf ("\nPulsa una tecla para continuar la partida");
      getch ();
      Partida (0);
   }

   printf ("\nEnter:destapar  m:mina  d:dudosa  o:desmarcar  p:pausa  g:guardar r:retirarse\n");

   /* imprime el número de banderas restantes y el tiempo acumulado */
   printf ("banderas restantes: %d\n", minas-banderas);
   printf ("segundos:%4d",seg);

   /* mientras no se pulse una tecla, seg se incrementa cada segundo */
   while (!kbhit ())
   {
      if (tiempo != Segundos ())
      {
         printf ("\rsegundos:%4d",seg++);
         tiempo = Segundos ();
      }
   }

   switch (tolower (getch ()))
   {
   case 224:   /* si se ha pulsado una tecla del cursor */

      switch (getch ())
      {
      case 72:   /* flecha arriba */
         if (pos_y-1 >= 0)
         {
            tablero[pos_x][pos_y].sel = ' ';
            pos_y = pos_y-1;
            tablero[pos_x][pos_y].sel = '>';
         }
         Partida (0);

      case 80:   /* flecha abajo */
         if (pos_y+1 < y)
         {
            tablero[pos_x][pos_y].sel = ' ';
            pos_y = pos_y+1;
            tablero[pos_x][pos_y].sel = '>';
         }
         Partida (0);

      case 75:   /* flecha izquierda */
         if (pos_x-1 >= 0)
         {
            tablero[pos_x][pos_y].sel = ' ';
            pos_x = pos_x-1;
            tablero[pos_x][pos_y].sel = '>';
         }
         Partida (0);

      case 77:   /* flecha derecha */
         if (pos_x+1 < x)
         {
            tablero[pos_x][pos_y].sel = ' ';
            pos_x = pos_x+1;
            tablero[pos_x][pos_y].sel = '>';
         }
         Partida (0);
      }

   case 13:   /* si se pulsa enter (destapar) */
      /* si la casilla destapada es una mina, se pierde */
      if (tablero[pos_x][pos_y].ady == 9)
         Partida (1);

      /* si no es una mina */
      else
         /* si no tiene minas adyacentes */
         if (tablero[pos_x][pos_y].ady == 0)
         {
            /* si había una bandera, se quita */
            if (tablero[pos_x][pos_y].estado == mina)
               banderas--;

            /* se destapan las casillas anexas */
            DestaparAnexas (pos_x, pos_y);
         }

         /* si tiene minas adyacentes */
         else
         {
            /* si había una bandera, se quita */
            if (tablero[pos_x][pos_y].estado == mina)
               banderas--;

            /* se marca como casilla visible */
            tablero[pos_x][pos_y].estado = visible;
         }

         destapadas++;
         Partida (0);

   case 'm':   /* si se pulsa 'm' (marcar como mina) */
      if ((tablero[pos_x][pos_y].estado != visible)&&(tablero[pos_x][pos_y].estado != mina))
      {
         tablero[pos_x][pos_y].estado = mina;
         banderas++;
      }

      Partida (0);

   case 'd':   /* si se pulsa 'd' (marcar como dudosa) */
      if (tablero[pos_x][pos_y].estado != visible)
      {
         /* si había una bandera, se quita */
         if (tablero[pos_x][pos_y].estado == mina)
            banderas--;

         tablero[pos_x][pos_y].estado = dudoso;
      }

      Partida (0);

   case 'o':   /* si se pulsa 'o' (desmarcar casilla) */
      if (tablero[pos_x][pos_y].estado != visible)
      {
         /* si había una bandera, se quita */
         if (tablero[pos_x][pos_y].estado == mina)
            banderas--;

         tablero[pos_x][pos_y].estado = oculto;
      }

      Partida (0);

   case 'p':   /* si se pulsa 'p' (parar el juego) */
      Partida (2);

   case 'g':   /* si se pulsa 'g' (guardar el juego) */
      GuardarPartida (x, y, minas, destapadas, banderas, pos_x, pos_y, seg, modo_juego, tablero);

   case 'r':   /* si se pulsa 'r' (retirarse y volver al menú principal) */
      pos_x = pos_y = 0;
      seg = 1;
      banderas = 0;
      destapadas = 0;
      menu ();

   default:
      printf ("\nOpcion incorrecta, pulse enter para elegir una opcion");
      getch ();
      Partida (0);
   }
}

/* calcula de cada casilla las minas que tiene alrededor y guarda el valor en
tablero[ancho][alto].ady; guarda un 9 si la casilla contiene una mina y un 0
si no tiene minas adyacentes */
void CalcularMinas ()
{
   int alto,
      ancho,
      i,
      j;

   /* recorre las columnas del tablero */
   for (ancho=0; ancho<x; ancho++)
      /* recorre las filas del tablero para cada columna */
      for (alto=0; alto<y; alto++)
         /* calcula las casillas adyacentes con mina */
         for (i=-1; i<2; i++)
            for (j=-1; j<2; j++)
               if (tablero[ancho][alto].ady != 9)
                  if (((ancho+i>=0)&&(ancho+i<x))&&((alto+j>=0)&&(alto+j<y)))
                     if (tablero[ancho+i][alto+j].ady == 9)
                        tablero[ancho][alto].ady++;

   Partida (0);
}

/* genera las minas de forma aleatoria */
void GenerarMinas ()
{
   int ancho,
      alto,
      minas_aux;   /* se decrementa cuando se inserta una mina */

   minas_aux = minas;

   /* reserva memoria para el tablero */
   tablero = (struct casilla **)malloc(x*sizeof (struct casilla *));
   for (ancho=0; ancho<x; ancho++)
      tablero[ancho] = (struct casilla *)malloc(y*sizeof (struct casilla));

   /* se inicializa el generador de números aleatorios */
   srand(time(NULL));

   /* se recorre el tablero */
   for (ancho=0; ancho<x; ancho++)
   {
      for (alto=0; alto<y; alto++)
         /* si hay o se va a poner una mina en la casilla */
         if (((minas_aux)&&(rand()%20 == 0))||(tablero[ancho][alto].ady == 9))
         {
            if (tablero[ancho][alto].ady != 9)
               minas_aux--;

            tablero[ancho][alto].ady = 9;
         }
         /* si la casilla no tiene mina */
         else
            tablero[ancho][alto].ady = 0;

      /* si se ha recorrido toda la tabla y todavía no se han colocado todas las
      minas, se vuelve a recorrer el tablero */
      if ((ancho == x-1)&&(minas_aux))
         ancho = -1;
   }

   /* se quita el cursor de todas las casillas */
   for (ancho=0; ancho<x; ancho++)
      for (alto=0; alto<y; alto++)
      {
         tablero[ancho][alto].estado = oculto;
         tablero[ancho][alto].sel = ' ';
      }

   /* y se pone en la primera */
   tablero[0][0].sel = '>';

   CalcularMinas ();
}

/* permite elegir uno de los modos de juego: la anchura de el tablero se guarda en la
variable global x, la altura en y, el número de minas en minas y el modo de juego
en modo_juego */
void ElegirTamano ()
{
   system ("cls");

   printf ("\t\t**** ESCOGER NIVEL ****\n");
   printf ("\n1.. Principiante (9x9, 10 minas)");
   printf ("\n2.. Intermedio (16x16, 40 minas)");
   printf ("\n3.. Experto (25x16, 99 minas)");
   printf ("\n4.. Personalizado");
   printf ("\n5.. Volver al menu principal");

   switch (getch ())
   {
   case '1':   /* modo principiante */
      x = 9;
      y = 9;
      minas = 10;
      modo_juego = 1;
      GenerarMinas ();

   case '2':   /* modo intermedio */
      x = 16;
      y = 16;
      minas = 40;
      modo_juego = 2;
      GenerarMinas ();

   case '3':   /* modo experto */
      x = 25;
      y = 16;
      minas = 99;
      modo_juego = 3;
      GenerarMinas ();

   case '4':   /* modo personalizado */
      system ("cls");

      modo_juego = 0;

      printf ("Introduzca la anchura del tablero (2-25): ");
      scanf (" %d",&x);
      /* comprueba la anchura del tablero */
      if ((x > 25)||(x < 2))
      {
         printf ("\n\nla anchura del tablero no puede ser mayor de 30 ni menor de 2"
         ", pulse enter para continuar");
         getch ();
         ElegirTamano ();
      }

      printf ("\nIntroduzca la altura del tablero (2-22): ");
      scanf (" %d",&y);
      /* comprueba la altura del tablero */
      if ((y > 22)||(y < 2))
      {
         printf ("\n\nla altura del tablero no puede ser mayor de 22 ni menor de 2"
         ", pulse enter para continuar");
         getch ();
         ElegirTamano ();
      }

      printf ("\nIntroduzca el numero de minas (1-(alto*ancho-1)): ");
      scanf (" %d",&minas);
      /* comprueba el número de minas */
      if ((minas >= x*y)||(minas < 1))
      {
         /* comprueba si se quieren introducir mas minas que casillas */
         if (minas >= x*y)
            printf ("\n\nVamos a meter todas esas minas ahi???");
         else
            printf ("\n\nNo seria un poco facil??? Anda, mete mas minas");

         printf (", pulse enter para continuar");
         getch ();
         ElegirTamano ();
      }

      GenerarMinas ();

   case '5':   /* volver al menú */
      menu ();

   default:
      printf ("\nOpcion incorrecta, pulse enter para elegir una opcion");
      getch ();
      ElegirTamano ();
   }
}

/* imprime un menú por pantalla con las opciones del juego */
void menu ()
{
   system ("cls");

   printf ("\t\t**** BUSCAMINAS PRO ****");
   printf ("\n\nSeleccione una opcion:\n");
   printf ("\n1.. Nueva partida");
   printf ("\n2.. Cargar Partida");
   printf ("\n3.. Los mejores modo principiante");
   printf ("\n4.. Los mejores modo intermedio");
   printf ("\n5.. Los mejores entre los mejores (modo experto)");
   printf ("\n6.. Mostrar creditos");
   printf ("\n0.. Salir");

   switch (getch ())
   {
   case '1':   /* nueva partida */
      system ("cls");
      ElegirTamano ();
      break;

   case '2':   /* cargar partida */
      CargarPartida (&x, &y, &minas, &destapadas, &banderas, &pos_x, &pos_y, &seg, &modo_juego, &tablero);

   case '3':   /* top principiantes */
      MostrarResultados (1);

   case '4':   /* top intermedio */
      MostrarResultados (2);

   case '5':   /* top expertos */
      MostrarResultados (3);

   case '6':   /* mostrar créditos */
      system ("cls");
      main ();

   case '0':   /* salir del juego */
      free (tablero);
      exit (0);

   default:
      printf ("\nOpcion incorrecta, pulse enter para elegir una opcion");
      getch ();
      menu ();
   }
}

/* muestra los créditos del programa */
void intro_1 ()
{
   printf("          !\n");
   printf("         !__.     ;     '_\n");
   printf("        !____.   ._,  `!__\n");
   printf("     ^;  ,____\"  ;__` ;___             ** UNIVERSIDAD SAN PABLO - CEU **\n");
   printf("    ,__   _____ .___,`___,\n");
   printf("   \"__\"   `;___\" ;__`,_;^\n");
   printf("   ___.     ____.._, \"\n");
   printf("   __^       ___! ;   `\"^           Practica 3 MPI. Buscaminas\n");
   printf("  ^,         ^___   ,___\n");
   printf("  `          `___.  ;__^\n");
   printf("              ;__. ,__!\n");
   printf("              ___. ;!`  '           Alumno: Bartolome Molina Menchen\n");
   printf("              ___.   _;___!.\n");
   printf("              ___.  .;____;,        Profesor: Dr. D. David Losada Carril\n");
   printf("              ___.     .,\n");
   printf("              ___.                  Curso: 2001/2002\n");
   printf("              ___.\n");
   printf("              ___.\n");
   printf("              ___.\n");
   printf("              ___.\n");
   printf("              ___.\n");
   printf("              ___.\n");
   printf("              ___.\n");
   printf("              ___.\n");

   getch();
}

/* muestra los créditos del programa */
void intro_2 ()
{
   printf("\n");
   printf("                               Bartolome Molina\n");
   printf("\n");
   printf("       MMM\n");
   printf("      M                                           M\n");
   printf("      M\n");
   printf("     M  MM  MM   M  MMM   MMM   MMMM  MM MM  MM   M  MM  MM   MMMM  MMM\n");
   printf("     M M M M M   M M     M  M  M   M M MM M M M  MM M M M M  M   M M\n");
   printf("     MM  M   M  M  M    M     M   M    M  MM  M  M    MM  M M   M  M\n");
   printf("     M  M   M  MM   MM  M     M   M    M  M  M   M    M  M  M   M   MM\n");
   printf("    M   M   M M M M  M  M   M M MMM M M  M   M M M M M   M MM MMM M  M\n");
   printf("    MMMM    MM  MMMMM   MMMM  MM  MM  M  M   MM  MM  M   MM MM  MMMMM\n");
   printf("\n");
   printf("\n");
   printf("                                                      M  MM MM  MM MMM\n");
   printf("                                                     MMMM MM M M  M  M\n");
   printf("                                                      M   M  MM  M   M\n");
   printf("                                                      M  M   M   M   M\n");
   printf("                                                     M   M  M    M  M\n");
   printf("                                                     MMMM   M    MMM\n");
   printf("                                                     M\n");
   printf("                                                     M\n");
   printf("                                                    M\n");

   getch();
}

void main ()
{
   intro_1 ();
   system ("cls");
   intro_2 ();
   menu ();
}

[Ferno]

Primero que nada, usa las etiquetas GeSHi para postear código!
Segundo, ¿Podrías especificar el error? ¿Que te dice el compilador?

[<<<-Basura->>>]

trata de postear el problema no todo el código