JUEGO BUSCAMINAS - pseudocódigo

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

*             CLASE: TABLERO

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

CLASE_TABLERO

    cadena tablero[][];

    entero minas[][];

    boolean elegidos[][];

    int filas;

    int columnas;

    constructor_Tablero

      filas= 6;

      columnas= 6;

      tablero=new cadena[filas][columnas];//reservamos espacio en memoria de tipo cadena

      minas=new entero[filas][columnas];// reservamos espacio en memoria de tipo enteros

      elegidos = new boolean[filas][columnas];

       para(i desde 0 hasta filas-1)

            para(j desde 0 hasta columnas-1)

                elegidos[i][j]= false;//inicialmente ningún casillero es elegido

            fin_para

       fin_para

       

    fin_constructor_Tablero

 //este método lanzarDado retorna un valor de tipo entero

 metodo_lanzarDado:entero

        entero numero = 0;

        hacer

            numero = (entero)(random()*10);// el valor de random oscila entre 0 y 1

        mientras(numero < 1 || numero > 6);

        retornar numero;

 fin_metodo_lanzarDado

    

 //el método generarMinas no retorna nada

 metodo_generarMinas:void

  para(i desde 0 hasta filas-1) {

            para(j desde 0 hasta columnas-1) 

//si al lanzar el dado sale par entonces asignaremos una mina en esa posición

                si(lanzarDado()mod 2= 0) //mod significa el resto de una division

//para diferenciarlo marcamos la posición con el valor 1 

                                        minas[i][j] = 1; // 0:no hay mina & 1:hay mina

                fin_si

           fin_para

  fin_para

 fin_metodo_generarMinas

 metodo_cantidadCasillerosSinMinas():entero

        entero contador=0;

  para(i desde 0 hasta filas-1) {

            para(j desde 0 hasta columnas-1) 

               si(tablero[i][j]<>"M"){ //<>:diferente

                    contador=contador+1;

                fin_si

            fin_para

  fin_para

        retornar contador;

 fin_metodo_cantidadCasilleroSinMinas

 metodo_limpiarMinas:void

  para(i desde 0 hasta filas-1) {

            para(j desde 0 hasta columnas-1) 

                minas[i][j] = 0;

            fin_para

  fin_para

 fin_metodo_limpiarMinas

 //método llenarTablero solo asigna las casillas donde hay minas y donde no hay minas

  //indica la cantidad de minas que hay a su alrededor

 método_llenarTablero:vacio

 generarMinas();//hace un llamado al método generarMinas

 entero numMinasAlrededor = 0;

 para(i desde 0 hasta filas-1) 

  para(j desde 0 hasta columnas-1) 

   si (minas[i][j] == 1)

    tablero[i][j] = "M";

   sino

    si (i=0||i=5)

     si (i=0)

      si (j=0 || j = 5) 

        si(j=0) 

//aquí lo que hacemos es sumar el valor de todos los casilleros que están a nuestro //alrededor, recordar que si en el casillero hay una mina entonces tiene valor uno (1) //caso contrario el valor es cero(0)

          tablero[i][j]=""+(minas[i][j]+minas[i][j+1]+minas[i+1][j]+minas[i+1][j+1]);

        fin_si

        si(j=5)

          tablero[i][j]=""+(minas[i][j-1]+minas[i][j]+minas[i+1][j-1]+minas[i+1][j]);

        fin_si

      sino

          tablero[i][j]=""+(minas[i][j-1]+minas[i][j]+minas[i][j+1]+minas[i+1][j-1]                            +minas[i+1][j]+minas[i+1][j+1]);

      fin_si

     fin_si

     si(i=5)

      si(j=0||j=5)

        si(j=0)

        tablero[i][j]=""+(minas[i-1][j]+minas[i-1][j+1]+minas[i][j]+minas[i][j+1]);

        fin_si

        si(j=5)

        tablero[i][j]=""+(minas[i-1][j-1]+minas[i-1][j]+minas[i][j-1]+minas[i][j]);

        fin_si

      sino

        tablero[i][j]=""+(minas[i-1][j-1]+minas[i-1][j]+minas[i-1][j+1]+minas[i][j-1]+    minas[i][j] + minas[i][j+1]);

     fin_si

    fin_si

   sino

     si(j=0||j=5)

      si(j=0)

       tablero[i][j]=""+(minas[i-1][j]+minas[i-1][j+1]+minas[i][j]+minas[i][j+1]+minas[i +1][j]+minas[i+1][j+1]);

      fin_si

      si(j=5)

       tablero[i][j]=""+(minas[i-1][j-1]+minas[i-1][j]+minas[i][j-1]+minas[i][j]+minas[i +1][j-1]+minas[i+1][j]);

      fin_si

    sino

      tablero[i][j]=""+(minas[i-1][j-1]+minas[i-1][j]+minas[i-1][j+1]+minas[i][j-1]+minas[i][j]+minas[i][j+1]+minas[i+1][j-1]+minas[i+1][j]+minas[i+1][j+1]);

    fin_si

  fin_si

 fin_si

fin_para

fin_para

fin_metodo_llenarTablero

//método mostrarTablero solo muestra por eso su retorno es vacio

metodo_mostrarTablero:vacio

para(i desde 0 hasta filas-1) 

  para(j desde 0 hasta columnas-1) 

               si(elegidos[i][j] es verdad)

//solo muestra los casilleros que el jugador ha elegido.

//el jugador elige un casillero y el tablero muestra el valor de ese casillero

                    si(j=5)

                        escribir(" [" + tablero[i][j] + "]");

                    sino

                        escribir(" [" + tablero[i][j] + "]");

                    fin_si

               sino

//si aun no ha elegido dicho casillero el programa muestra el casillero vacio

                   si(j=5)

                       escribir(" [ ]");

                   sino

                       escribir(" [ ]");

                   Fin_si

               Fin_si

          Fin_para

        Fin_para

Fin_metodo_mostrarTablero

   

/*este método voltearCasillero dice: si el valor del casillero es una M:mina entonces ya no continuo con el juego por ello continuar lo asigna falso. Si el valor del casillero no es una M(mina) sino otro cualquier numero entonces continuo con el juego por ello continuar lo asigna verdadero*/

metodo_voltearCasillero(fila:entero, columna:entero):booleano

        booleano continuar=falso;

        para(i desde 0 hasta filas-1) 

  para(j desde 0 hasta columnas-1) 

  si(i= fila && j= columna)

                    si(tablero[i][j]="M")

                            continuar=falso;

                    sino

                        elegidos[i][j]=verdad;

                        continuar=verdad;

                    fin_si

                fin_si

            fin_para

        fin_para

        retornar continuar;

fin_metodo_voltearCasillero

FIN_CLASE_TABLERO

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

*             CLASE: JUEGO

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

CLASE_JUEGO

Tablero T;

Constructor_Juego()

  T = nuevo Tablero(); //crea un objeto de la clase Tablero

      fin_constructor_Juego

   método_menu():vacio

        para (;;) {

            escribir("=================================");

            escribir("     JUEGO BUSCA MINAS           ");

            escribir("=================================");

            escribir("JUGAR.........................[1]");

            escribir("SALIR.........................[2]");

            escribir ("=================================");

            escribir ("Elige la opcion:");

            escribir ("=================================");

            entero opcion = leer();

            segun_sea(opcion)

                caso 1:

                    jugar();

                    break;

                caso 2:

                    Sale_del_programa;

            Fin_segun_sea

        Fin_para

Fin_metodo_menu

 metodo_jugar:vacio

/*Cómo el objeto T ha sido creado en el constructor, ahora T es una instancia de la clase Tablero.

  Entonces T puede acceder a los métodos de la clase Tablero*/

        T.llenarTablero(); 

        T.mostrarTablero();

        entero fila, columna;

        entero aciertos = 0;

//el objetivo sería voltear todos los casilleros que no contengan minas

        entero objetivo=T.cantidadCasillerosSinMinas();

        booleano salir = falso;

        escribir("cantidad de casilleros sin minas: "+T.cantidadCasillerosSinMinas());

        hacer

            escribir("Elige un casillero : ");

            escribir ("Ingresando sus coordenadas");

            escribir ("Fila: ");   fila = leer();

            escribir("Columna: "); columna = leer ();

            escribir("El casillero elegido es: casillero[" + fila + "][" + columna + "]");

            si (T.voltearCasillero(fila, columna))

                //si el casillero no es una mina entonces continua con el juego

                T.mostrarTablero();

                aciertos=aciertos+1;

                escribir("aciertos: "+aciertos);

//cada acierto es cuando volteamos el casillero y el valor que contiene no es una mina

//entonces si el total de aciertos es igual que el objetivo se dice que se ha ganado

                si(aciertos=objetivo ) {

                    escribir("Has Ganado el Juego");

//indicamos que debemos salir del juego.

                    salir = verdad;

                fin_si

            sino

                escribir("Ha perdido");

                salir=true;

            fin_si

//todo esto se va repetir mientras salir sea falso

        mientras(!salir);

    fin_metodo_jugar

FIN_CLASE_JUEGO

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

*             CLASE: MAIN
/****************************************************************/

//esta clase es la encargada de ejecutar el programa

CLASE_MAIN

        Juego juego=new Juego(); //Creamos un objeto de la clase Juego

        //ahora juego es una instancia de la clase Juego

        juego.menu(); //Invocamos al menú de opciones para dar inicio al juego

FIN_CLASE_MAIN

Nos vemos en el siguiente Blog :)
Saludos.
MAGALEX