• Sábado 14 de Diciembre de 2024, 12:40

Autor Tema:  Función De Recursividad En El Juego Del Buscaminas  (Leído 5367 veces)

Pandii

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Función De Recursividad En El Juego Del Buscaminas
« en: Sábado 14 de Junio de 2008, 06:42 »
0
Hooola!

He buscado en internet códigos donde salga alguna aplicación de recursividad para el juego del buscaminas, a la hora de destapar las celdas, pero no he encontrado nada bueno en verdad.

Yo hice una función de recursividad, pero en un principio creí que habia errores en la impresión en Consola del arreglo, pero ahora el visual me tira error de recursividad infinita,  ya he intentado solucionarlo, y no me resulta.
 
:(


Por favor, si alguien me puede mostrar un código correcto de recursividad en el buscaminas, cuando las bombas alrededor de la coordenada sean cero, estaría muy agradecida.

O sea, yo entiendo la idea de,

caso inicial de fin de recursividad que las bombas alrededor sean distintas de sero, sino.. recursividad... y sus variados casos, pero no me resulta =(


Bueno, lo que yo tenía era esto.. :



   static char cuenta_bombas(int x, int y)
        {
            char c = '0';


            if (x+1 < bombas.GetLength(0))
            {
                if (bombas[x + 1, y])
               
                    c++;
               
           
           
            }
            if ((x-1)>= 0)
            {
                if (bombas[x-1, y])
                    c++;



            }

            if (y-1 >= 0)
            {
                if (bombas[x, y-1])
                    c++;



            }
            if (y+1< bombas.GetLength(1))
            {
                if (bombas[x, y+1])
                    c++;



            }

            if (x-1>= 0 && y-1>=0)
            {
                if (bombas[x-1, y-1])
                    c++;



            }
            if (x-1 >= 0 && y+1 < bombas.GetLength(1))
            {
                if (bombas[x-1, y+1])
                    c++;



            }
            if (y-1 >= 0 && x+1 < bombas.GetLength(0))
            {
                if (bombas[x+1, y-1])
                    c++;



            }
            if (x+1<bombas.GetLength(0) && y+1 < bombas.GetLength(1))
            {
                if (bombas[x+1, y+1])
                    c++;



            }


            return c;
       
       
       
        }

        static void abrir(int x, int y)
      {
          if (Validacion(x, y))
          {
              tablero[x, y] = ' ';

              if (cuenta_bombas(x, y) != '0')
              {
                  tablero[x, y] = cuenta_bombas(x, y);


              }

              else
              {


                  if (Validacion(x + 1, y))
                      abrir(x + 1, y);
                  if (Validacion(x - 1, y))
                      abrir(x - 1, y);
                  if (Validacion(x + 1, y + 1))
                      abrir(x + 1, y + 1);
                  if (Validacion(x - 1, y - 1))
                      abrir(x - 1, y - 1);
                  if (Validacion(x + 1, y - 1))
                      abrir(x + 1, y - 1);
                  if (Validacion(x - 1, y + 1))
                      abrir(x - 1, y + 1);
                  if (Validacion(x, y + 1))
                      abrir(x, y + 1);
                  if (Validacion(x, y - 1))
                      abrir(x, y - 1);

              }

          }  
         

       
           
         
        }
        static bool Validacion(int x, int y)
        {
            if (x <= 0 || y <=0 || x >= l-1 || y >= e-1)
                return false;
            else
                return true;




        }
  static void bbass()
        {

       
         

            for (int ii = 0; ii < l; ii++)
            {
                for (int jj = 0; jj < e; jj++)
                {


                    tablero[ii, jj] = '?';


                }
               
            }

         

            for (int i = 0; i < bombas.GetLength(0); i++)
            {
               
                for (int j = 0; j < bombas.GetLength(1); j++)
                {


                    Console.Write("{0}", tablero[i, j]);





                }
                Console.WriteLine();



            }
            int x, y;
            do
            {

               
                do
                {

                    Console.Write("Ingrese coordenada vertical: ");
                    x = int.Parse(Console.ReadLine());


                } while (x < 0 || x >= l);
               
                do
                {

                    Console.Write("Ingrese coordenada horizontal: ");
                    y = int.Parse(Console.ReadLine());


                } while (y < 0 || y >= e);




                abrir(x, y);

                Imprimir();

            } while (!bombas[x, y]);
     
}
   
Omiti copiar mi función de imprimir y el main, porque no aportan mucho en que no me salga el código..

Mi codigo está diseñado para Consola, en Visual Studio 2008




         
        Se agradecen ideas, correcciones a mi codigo, o codigo bueno y nuevo
=)


Saludos


Andrea  :)
[size=109]
Los cuatro puntos cardinales son en realidad tres, norte y sur.

        [/i]
        [/b]


[/size]

ivancp

  • Miembro activo
  • **
  • Mensajes: 70
    • Ver Perfil
Re: Función De Recursividad En El Juego Del Buscaminas
« Respuesta #1 en: Lunes 22 de Septiembre de 2008, 17:21 »
0
Creo que lo que te falta controlar en la recursividad es que necesitas una "condición de parada".

Concretamente debes controlar si una celda del buscaminas ha sido visitada por la función, por que no hay necesidad de visitar una celda mas de una vez (lo que generaría una recursividad infita)
ivancp