Fecha y hora actual: Lunes 22 Jul 2019 08:41
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Proyecto Final: Juego Buscaminas

Responder al Tema Ir a página Anterior1234

Índice del Foro > Programación en general > Proyecto Final: Juego Buscaminas

Autor Mensaje
daalpri
Usuario Inquieto


Registrado: 28 Dic 2014
Mensajes: 105

Mensaje Publicado: Miércoles 08 Feb 2017 17:39

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Ok. pense que la instruccion Randomize estaba declarada en el codigo de Buscaminas y por eso no lo declare.
Pasare el depurador a ver si encuentro algo y ya te cuento.
Gracias por el interes

Volver arriba
Ver perfil del usuario Enviar mensaje privado
daalpri
Usuario Inquieto


Registrado: 28 Dic 2014
Mensajes: 105

Mensaje Publicado: Viernes 10 Feb 2017 12:31

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Bueno, pues despues de declarar "randomize" ya me creaba todos los tipos de tableros... a veces, otras veces se caia.
Pues pasando el depurador (varias veces, ya que a veces si funcionaba sin caerse) por fin encontre el error, error de principiante, que son de los que mas cometo
Código:

   i:=random(juego.tablero.topeFila+1);
   j:=random(juego.tablero.topeColumna+1);

Como ves puse el "+1" dentro del parentesis, con lo que random tenia la posibilidad de dar como resultado 0, y ahi caia el programa.
Simplemente sacando eso fuera del parentesis ya funciona como tiene que hacerlo.
Te reitero mis agradecimientos por tu ayuda desinteresada Kyshuo, eres un grande

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Viernes 10 Feb 2017 14:35

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Ese tipo de problemas los cometerás a menudo, aún cuando seas el mejor de los expertos. ¡¡¡Y QUÉ DIFÍCILES DE ENCONTRAR!!!

Es un placer ayudarte. Espero que este proyecto haya representado un aprendizaje para ti y te ayude a seguir en el camino que elijas luego.

Cualquier comentario o sugerencia que tengas será bienvenida.
Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
daalpri
Usuario Inquieto


Registrado: 28 Dic 2014
Mensajes: 105

Mensaje Publicado: Sábado 11 Feb 2017 16:33

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Terminado y funcionando Aplauso Aplauso
Código:


Type

   RangoRecorrido=RECORD
      filaSuperior,
      filaInferior:RangoFila;
      columnaAnterior,
      columnaPosterior:RangoColumna;
   end;

{************************************************************************************************}

FUNCTION circundantes(juego:TipoJuego;posicion:TipoPosicion):RangoRecorrido;

{Encontramos 9 casos posibles para saber cuantas y cuales son las celdas circundantes de una celda determinada:
   1/ en el centro del tablero tendra 8 celdas que la circundan
   2/ 4 bordes tendra 5 celdas que la circundan
   3/ 4 esquinas tendra 3 celdas que la circundan
esta funcion nos devuelve los limite de fila y columna que circundan una celda en la "posicion" dada para evitar
tener que buscarlos cada vez que lo necesite, como en "descubrir", "marcar circundantes"...}

begin
   if ((posicion.fila<>1) and (posicion.fila<>juego.tablero.topeFila)) and ((posicion.columna<>1) and (posicion.columna<>juego.tablero.topeColumna)) then
      begin //para una celda situada en el centro del tablero.
      circundantes.filaSuperior:=posicion.fila-1;
      circundantes.filaInferior:=posicion.fila+1;
      circundantes.columnaAnterior:=posicion.columna-1;
      circundantes.columnaPosterior:=posicion.columna+1;
      end

   else
      begin

{Primero definimos las 4 esquinas del tablero}

      if (posicion.fila=1) and (posicion.columna=1) then
         begin //esquina superior izquierda.
         circundantes.filaSuperior:=posicion.fila;
         circundantes.filaInferior:=posicion.fila+1;
         circundantes.columnaAnterior:=posicion.columna;
         circundantes.columnaPosterior:=posicion.columna+1;
         end;

      if (posicion.fila=1) and (posicion.columna=juego.tablero.topeColumna) then
         begin //esquina superior derecha.
         circundantes.filaSuperior:=posicion.fila;
         circundantes.filaInferior:=posicion.fila+1;
         circundantes.columnaAnterior:=posicion.columna-1;
         circundantes.columnaPosterior:=posicion.columna;
         end;

      if (posicion.fila=juego.tablero.topeFila) and (posicion.columna=1) then
         begin //esquina inferior izquierda.
         circundantes.filaSuperior:=posicion.fila-1;
         circundantes.filaInferior:=posicion.fila;
         circundantes.columnaAnterior:=posicion.columna;
         circundantes.columnaPosterior:=posicion.columna+1;
         end;

      if (posicion.fila=juego.tablero.topeFila) and (posicion.columna=juego.tablero.topeColumna) then
         begin //esquina inferior derecha.
         circundantes.filaSuperior:=posicion.fila-1;
         circundantes.filaInferior:=posicion.fila;
         circundantes.columnaAnterior:=posicion.columna-1;
         circundantes.columnaPosterior:=posicion.columna;
         end;

{Ahora definimos los 4 bordes del tablero}

      if (posicion.fila=1) and ((posicion.columna<>1) and (posicion.columna<>juego.tablero.topeColumna)) then
         begin //borde superior.
         circundantes.filaSuperior:=posicion.fila;
         circundantes.filaInferior:=posicion.fila+1;
         circundantes.columnaAnterior:=posicion.columna-1;
         circundantes.columnaPosterior:=posicion.columna+1;
         end;

      if (posicion.fila=juego.tablero.topeFila) and ((posicion.columna<>1) and (posicion.columna<>juego.tablero.topeColumna)) then
         begin //borde inferior.
         circundantes.filaSuperior:=posicion.fila-1;
         circundantes.filaInferior:=posicion.fila;
         circundantes.columnaAnterior:=posicion.columna-1;
         circundantes.columnaPosterior:=posicion.columna+1;
         end;

      if ((posicion.fila<>1) and (posicion.fila<>juego.tablero.topeFila)) and (posicion.columna=1) then
         begin //borde izquierdo.
         circundantes.filaSuperior:=posicion.fila-1;
         circundantes.filaInferior:=posicion.fila+1;
         circundantes.columnaAnterior:=posicion.columna;
         circundantes.columnaPosterior:=posicion.columna+1;
         end;

      if ((posicion.fila<>1) and (posicion.fila<>juego.tablero.topeFila)) and (posicion.columna=juego.tablero.topeColumna) then
         begin //borde derecho.
         circundantes.filaSuperior:=posicion.fila-1;
         circundantes.filaInferior:=posicion.fila+1;
         circundantes.columnaAnterior:=posicion.columna-1;
         circundantes.columnaPosterior:=posicion.columna;
         end;
      end; //final del "else".
end; //de la funcion.

{************************************************************************************************}

procedure IniciarJuego(var juego: TipoJuego; cuantas_filas: RangoFila; cuantas_columnas: RangoColumna; cuantas_bombas: integer);

var
   i,j,x,y:integer; //para realizar iteraciones.
   numBombas:integer; //para contar las bombas que llevamos colocadas.
   miCelda:TipoPosicion; //para llamar a la funcion "circundantes".
   limitrofes:RangoRecorrido; //para almacenar las circundantes de una celda.

begin

randomize;

juego.estado:=jugando; //el juego acaba de empezar.
juego.marcadas:=0; //aun  no hemos marcado ninguna celda.
juego.descubiertas:=0; //aun no hemos descubierto ninguna celda.
juego.bombas:=cuantas_bombas; //marcamos el numero de bombas que tendra el tablero.
juego.tablero.topeFila:=cuantas_filas; //definimos los limites del tablero.
juego.tablero.topeColumna:=cuantas_columnas; //definimos los limites del tablero.

{Recorremos el tablero maracando la celdas como ocultas, y de momento no tienen bombas}
for i:=1 to juego.tablero.topefila do
   for j:=1 to juego.tablero.topeColumna do
      begin
      juego.tablero.celdas[i,j].estado:=oculta;
      juego.tablero.celdas[i,j].tieneBomba:=false;
      end; //hasta aqui hemos creado un tablero vacio.

numBombas:=0; //aun no hay ninguna bomba colocada.
{Vamos buscando posiciones aleatorias dentro de los limites del tablero}
repeat
   i:=random(juego.tablero.topeFila)+1;
   j:=random(juego.tablero.topeColumna)+1;

   if juego.tablero.celdas[i,j].tieneBomba=false then //comprovamos que la posicion aleatoria no contenga ya una bomba.
      begin //en el caso de que no tenga bomba.
      juego.tablero.celdas[i,j].tieneBomba:=true; //colocamos una bomba.
      numBombas:=numBombas+1; //sumamos 1 a la cantidad de bombas.
      end;
   {Si ya tenia bomba no hacemos nada y buscamos otra posicion}
until numBombas=juego.bombas; //repetimos hasta que esten colocadas todas las bombas

{Ya tenemos las bombas colocadas, por ultimo recorremos las celdas sin bomba calculando para cada una}
{el numero de bombas que la circundan}
for i:=1 to juego.tablero.topeFila do
   for j:=1 to juego.tablero.topeColumna do
      begin
      juego.tablero.celdas[i,j].bombasCircundantes:=0; //de momento no sabemos cuantas celdas con bomba la circundan.
      if not juego.tablero.celdas[i,j].tieneBomba then //solo marcamos las bombas circundantes si la celda no tiene bomba.
         begin
         {damos la posicion de la celda a la variable "miCelda" para calcular los limites de las celdas circundantes}
         miCelda.fila:=i;
         miCelda.columna:=j;
         limitrofes:=circundantes(juego,miCelda); //hallamos los limites entre los que buscamos bombas para dar valor a "bombasCircundantes".
         {Recorremos las celdas circundantes y sumamos las bombas que encontremos}
         for x:=limitrofes.filaSuperior to limitrofes.filaInferior do
            for y:=limitrofes.columnaAnterior to limitrofes.columnaPosterior do
               if juego.tablero.celdas[x,y].tieneBomba then
                  juego.tablero.celdas[i,j].bombasCircundantes:=juego.tablero.celdas[i,j].bombasCircundantes+1;
         end;
      end;

end; //del procedimiento.

{*************************************************************************************************}

procedure Descubrir(var juego: TipoJuego; posicion: TipoPosicion);

Type

listaPendientes=^Lista;

lista=record

   celda:TipoPosicion;

   siguiente:ListaPendientes;
end;

Var

   maxCeldas:integer;
   miLista:listaPendientes;

{-------------------------------------------------------------------------------------------------}

PROCEDURE PonerEnLista(var lista:listaPendientes; posicion:TipoPosicion);

var
   auxlista:listaPendientes;

begin

if lista=NIL then //si es el primero que metemos en la lista.
   begin
   new(lista); //solicitamos espacio en la memoria.
   lista^.celda:=posicion; //
   lista^.siguiente:=NIL; //lo marcamos como el ultimo de la lista.
   end //del "if...".
else //si ya tenemos algun elemento en la lista.
   begin
   auxlista:=lista; //damos valor a nuestro auxiliar para recorrer la lista;
   while auxlista^.siguiente<>NIL do
      auxlista:=auxlista^.siguiente;
   new(auxlista^.siguiente); //creamos un elemento al final de la lista.
   auxlista:=auxlista^.siguiente; //apuntamos hacia el nuevo elemento.
   auxlista^.celda:=posicion; //le damos valor.
   auxlista^.siguiente:=NIL; //lo marcamos como el ultimo de la lista.
   end; //del "else".

end; //del subprocedimiento.

{-------------------------------------------------------------------------------------------------}

PROCEDURE QuitarDeLista(var lista:ListaPendientes; posicion:TipoPosicion);

var
   auxlista:listaPendientes;

begin
auxlista:=lista^.siguiente; //apuntamos con nuestro auxiliar al segundo dela lista.
dispose(lista); //eliminamos el que era el primer elemento de la lista.
lista:=auxlista; //y apuntamos el inicio de nuestra lista al auxiliar.
end;

{-------------------------------------------------------------------------------------------------}

PROCEDURE DescubrirLasCircundantes(var juego:TipoJuego; var lista:listaPendientes);

var
   i,j:integer;
   limitrofes:RangoRecorrido;
   miCelda:TipoPosicion;

begin

limitrofes:=circundantes(juego,lista^.celda); //hallamos los limites de las celdas circundantes a la que nos ocupa.

{recorremos las celdas circundantes}
for i:=limitrofes.filaSuperior to limitrofes.filaInferior do
   for j:=limitrofes.columnaAnterior to limitrofes.columnaPosterior do

      begin
      if juego.tablero.celdas[i,j].estado=oculta then //si esta oculta.
         begin
         juego.tablero.celdas[i,j].estado:=descubierta; //la marcamos como descubierta.
         juego.descubiertas:=juego.descubiertas+1; //sumamos 1 al numero de celdas que hay descubiertas en total.

         if juego.tablero.celdas[i,j].bombasCircundantes=0 then //si las bombas circundantes de la celda son 0.
            begin //damos valor a la posicion para añadirla a la lista de posiciones pendientes.
            miCelda.fila:=i;
            miCelda.columna:=j;
            PonerEnlista(lista,miCelda); //la añadimos a la lista.
            end; //de las acciones que realizaos si las bombas circundantes son 0.
         end; //de las acciones que realizamos cuando la celda esta oculta
      end; //del recorrido "for...".
if Juego.descubiertas=maxCeldas-juego.bombas then //si hemos descubierto todas las celdas.
   juego.estado:=ganado;

end; //del subprocedimiento.

{-------------------------------------------------------------------------------------------------}
{-------------------------BLOQUE PRINCIPAL DEL PROCEDIMIENTO--------------------------------------}

begin

miLista:=NIL; //la lista de pendientes la marcamos como vacia.
maxceldas:=juego.tablero.topeFila*juego.tablero.topeColumna; //obtenemos el numero maximo de celdas del tablero para controlar si estan todas descubiertas.

juego.tablero.celdas[posicion.fila,posicion.columna].estado:=descubierta; //marcamos la celda como descubierta.
juego.descubiertas:=juego.descubiertas+1; //sumamos 1 a las celdas que estan descubiertas.

if juego.tablero.celdas[posicion.fila,posicion.columna].tieneBomba then //si la celda tiene bomba.
   juego.estado:=perdido //perdemos el juego
else //si no tiene bomba
   begin
   if juego.descubiertas=maxceldas-juego.bombas then //si es la ultima celda sin marcar
      juego.estado:=ganado //hemos ganado el juego
   else //si no es la ultima celda
      begin
      if juego.tablero.celdas[posicion.fila,posicion.columna].bombasCircundantes=0 then //si no tiene bombas alrededor.
         begin
         PonerEnLista(miLista,posicion); //la añadimos a la lista de pendientes.
         repeat //repetimos
            DescubrirLasCircundantes(juego,miLista); //descubrimos las circundantes de la primera celda de la lista, y añadimos al final de la lista las circundantes que tengan 0.
            QuitarDeLista(miLista,posicion); //y eliminamos de la lista el primer elemento de la lista.
         until miLista=NIL; //hasat que la lista de pendientes este vacia.
         end;
      end; //del else
   end; //del else principal.

end; //del procedimiento.

{*************************************************************************************************}

procedure Marcar(var juego: TipoJuego; posicion: TipoPosicion);

begin

   //accedemos a la celda que esta en la "posicion" y si esta oculta la marcamos.
   //si esta descubierta o ya esta marcada no hacemos nada.
   if juego.tablero.celdas[posicion.fila,posicion.columna].estado=oculta then
      begin
      juego.tablero.celdas[posicion.fila,posicion.columna].estado:=marcada;
      juego.marcadas:=juego.marcadas+1;
      end;

end;

{*************************************************************************************************}

procedure DesMarcar(var juego: TipoJuego; posicion: TipoPosicion);

begin

   //accedemos a la celda que esta en la "posicion" y si y solo si esta marcada la marcamos como oculta.
   if juego.tablero.celdas[posicion.fila,posicion.columna].estado=marcada then
      begin
      juego.tablero.celdas[posicion.fila,posicion.columna].estado:=oculta;
      juego.marcadas:=juego.marcadas-1;
      end;

end;

{**************************************************************************************************}

procedure DespejarCircundantes(var juego: TipoJuego; posicion: TipoPosicion);

var
   celdaMarcada:TipoPosicion; //para llamar a "Descubrir".
   limitrofes:RangoRecorrido; //para almacenar los limites de las celdas en los que vamos a buscar.
   x,y:integer; //dos contadores para iterar.
   posibles:integer; //para contar las celdas posibles (marcadas).

begin

   posibles:=0; //iniciamos el contador.

   if juego.tablero.celdas[posicion.fila,posicion.columna].estado=descubierta then //el procedimiento solo se realizara sobre una celda descubierta.
      begin
      limitrofes:=circundantes(juego,posicion); //hallamos el rango de celdas en las que vamos a buscar.
      
      {recorremos todo el rango comprobando que esten marcadas tantas circundantes como bombas marca la celda}
      for x:=limitrofes.filaSuperior to limitrofes.filaInferior do
         for y:=limitrofes.columnaAnterior to limitrofes.columnaPosterior do
            if juego.tablero.celdas[x,y].estado=marcada then
               posibles:=posibles+1;

      {si el numero de marcadas alrededor de la celda es igual a lo que marca, despejamos el resto de celdas circundantes}
      if juego.tablero.celdas[posicion.fila,posicion.columna].BombasCircundantes=posibles then
         begin //vamos recorriendo todas las celdas circundantes.
         for x:=limitrofes.filaSuperior to limitrofes.filaInferior do
            for y:=limitrofes.columnaAnterior to limitrofes.columnaPosterior do
            
               {solamente despejamos las que aun estan ocultas}
               if juego.tablero.celdas[x,y].estado=oculta then
                  begin
                  celdaMarcada.fila:=x;
                  celdaMarcada.columna:=y;
                  Descubrir(juego,celdaMarcada);
                  end;
         end; //del recorrido.
      end; //de lo que realiza el procedimiento si se cumple la primera condicion.
         

end; //del procedimiento.

{**************************************************************************************************}

procedure MarcarCircundantes(var juego: TipoJuego; posicion: TipoPosicion);

var
   celdaMarcada:TipoPosicion; //para dar la posicion al procedimiento "marcar".
   limitrofes:RangoRecorrido; //almacena los limites de las celdas que circundan la celda dada.
   x,y:integer; //dos contadores para iterar.
   posibles:integer;//para ir sumando las celdas posibles (marcadas+ocultas).

begin

   posibles:=0; //iniciamos el contador.

   if juego.tablero.celdas[posicion.fila,posicion.columna].estado=descubierta then //el procedimiento solo se realizara si se llama sobre una celda que ya este descubierta.
      begin
      limitrofes:=circundantes(juego,posicion); //hallamos el rango de filas y columnas en los que hay que buscar.

      {recorremos todo el rango comprobando que esten todas las circundantes marcadas u ocultas}
      for x:=limitrofes.FilaSuperior to limitrofes.FilaInferior do
         for y:=limitrofes.ColumnaAnterior to limitrofes.ColumnaPosterior do
            if (juego.tablero.celdas[x,y].estado=marcada) or (juego.tablero.celdas[x,y].estado=oculta) then
               posibles:=posibles+1;

      {si el numero de ocultas mas marcadas coincide con el numero de bombas que marca la celda, procedemios a marcar todas las celdas de alrededor}
      if juego.tablero.celdas[posicion.fila,posicion.columna].bombasCircundantes=posibles then
         begin //vamos recorriendo todas las celdas circundantes.
         for x:=limitrofes.filaSuperior to limitrofes.FilaInferior do
            for y:=limitrofes.columnaAnterior to limitrofes.columnaPosterior do

               {solamente marcamos las que esten ocultas todavia}
               if juego.Tablero.celdas[x,y].estado=oculta then
                  begin
                  celdaMarcada.fila:=x;
                  celdaMarcada.columna:=y;
                  Marcar(juego,celdaMarcada);
                  end;
         end; //del recorrido.
      end; //de lo que realiza el procedimiento si se cumple la condicion inicial.

end; //del procedimiento.

{**************************************************************************************************}

procedure DescubrirSegura(var juego: TipoJuego);

var
   x:integer; //fila de la casilla que descubriremos.
   y:integer; //columna de la casilla que descubriremos.
   coordenada:TipoPosicion; //para llamar al procedimiento "descubrir".
begin

{Vamos buscando una celda que tiene que cumplir dos condiciones:
   1/ tiene que estar todavia oculta.
   2/ no tiene que tener bomba.}

   repeat
      //buscamos unas coordenadas de una casilla al azar.
      x:=random(juego.tablero.topeFila)+1;
      y:=random(juego.tablero.topeColumna)+1;
   until (juego.tablero.celdas[x,y].estado=oculta) and (juego.tablero.celdas[x,y].tieneBomba=false);

   //asignamos los valores que son validos a la variable "coordenada" para llamar a "descubrir".
   coordenada.fila:=x;
   coordenada.columna:=y;

   //llamamos al procedimiento "descubrir".
   descubrir(juego,coordenada);
end;

Ahora a pasar a Modula.
Nuevo reto. Mil gracias Kyshuo

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Lunes 13 Feb 2017 17:27

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Excelente!!!! Muy buen trabajo.

En estos momentos estoy preparando una nueva versión del curso donde Modula es reemplazado por Object Pascal en entorno Lazarus. De momento no lo tengo listo como para publicar, pero creo que trabajar con Modula igualmente te ayudará a entender algunas cosas y pasarte a orientación a objetos.

Saludos. Seguiré a las órdenes.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
daalpri
Usuario Inquieto


Registrado: 28 Dic 2014
Mensajes: 105

Mensaje Publicado: Martes 14 Feb 2017 13:49

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Mi intencion es poder llegar a hacer aplicaciones para moviles, por lo que he leido, para eso lo mejor es java, asi que continuare el curso tal cual lo tienes planteado, que me parece claro y asequible. Asi que de momeento te seguire dando la tabarra de vez en cuando.
Gracias por tu esfuerzo en transmitir tus conocimientos y tu paciencia.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Martes 14 Feb 2017 16:28

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Si, Java es lo que tienes que aprender para programar para dispositivos móviles, sobre todo para Android. De hecho en Android el entorno de desarrollo se basa en NetBeans, que es el entorno que muestro en el curso. Hoy día ya hay versiones más avanzadas, pero en esencia todo se maneja igual.

Saludos y mucho éxito.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Wul



Registrado: 30 Jul 2018
Mensajes: 6

Mensaje Publicado: Lunes 25 Mar 2019 00:29

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Buenas Kyshuo, antes de nada quería agradecerte otra vez por este curso el cual poco a poco voy continuándolo, y que por fin e llegado hasta el final de esta parte.

Dicho eso me gustaría preguntarte por que no se puede colocar esta expresión ya que me daba un error en tiempo de compilación:

i es un registro con dos variables para la fila y otra para la columna ambas integer

For i.fila:=(posicion.fila-1) to posicion.fila+1 do



Y aquí dejo ya el código de mi programa, si quieres que añada algún comentario mas para que sea mas sencillo me lo dices, aunque creo que tampoco necesita mucho mas:


Código:
FUNCTION posicionvalida(juego: TipoJuego; fila: integer; columna: integer):boolean;
begin
 posicionvalida:=false;
 if (fila>0) and (fila<=juego.tablero.topefila) and (columna>0) and (columna<=juego.tablero.topecolumna) then
   posicionvalida:=true;
end;

PROCEDURE IniciarJuego(var juego:TipoJuego; cuantas_filas: RangoFila; cuantas_columnas: RangoColumna; cuantas_bombas: integer);

Var
  i,j: integer;

//Subprogramas y funciones de IniciarJuego.

PROCEDURE RandomBombas(var juego:TipoJuego; CuantasBombas:Integer);// Colocara bombas aleatoriamnte.
  var i,j: integer;
      contBombas: integer;
begin
 randomize;
   contBombas:=0;
   repeat
   i:=random(juego.Tablero.topeFila)+1;
   j:=random(juego.Tablero.TopeColumna)+1;
   if juego.Tablero.celdas[i,j].TieneBomba=false then //Para no repetir.
    begin
   juego.Tablero.celdas[i,j].TieneBomba:=true;
   contBombas:=contBombas+1;
    end;
  until ContBombas=CuantasBombas;
End;

FUNCTION contadorbombas (var juego: TipoJuego; fila: integer; columna:integer):integer;
var
  c: integer;
  i,j: integer;
BEGIN
 c:=0;
 for i:=(fila-1) to fila+1 do
        for j:=(columna-1) to columna+1 do
            if posicionvalida(juego,i,j) and (juego.tablero.celdas[i,j].tienebomba) then
            c:=c+1;

 contadorbombas:=c;
 end;

//Fin subprogramas y funciones de IniciarJuego.

BEGIN

  if (cuantas_bombas>0) and (cuantas_bombas<=(cuantas_filas*cuantas_columnas)) then// Para detectar un error en el numero de bombas
  begin

   i:=1;
   j:=1;

   With juego do     // Entramos en el registro del TipoJuego.
   begin
   estado:= jugando;
   bombas:= cuantas_bombas;
   marcadas:= 0;
   descubiertas:= 0;
   tablero.topeFila:= cuantas_filas;
   tablero.topeColumna:= cuantas_columnas;
   end;


   For i:=1 to cuantas_filas do // Le doy a las celdas el estado de oculto y sin bomba.
     For j:=1 to cuantas_columnas do
      begin
       juego.tablero.celdas[i,j].estado:= oculta;
       juego.tablero.celdas[i,j].tienebomba:=false;
      end;

   randombombas(juego,cuantas_bombas);//Coloco las bombas.

   For i:=1 to cuantas_filas do // Doy el numero de bombas circundantes a cada celda.
    For j:=1 to cuantas_columnas do
      if juego.tablero.celdas[i,j].tienebomba= false then
         juego.tablero.celdas[i,j].bombasCircundantes:= contadorbombas(juego,i,j);
  end;
end;

PROCEDURE Descubrir(var juego: TipoJuego; posicion: TipoPosicion);
var
  i,j: integer;

//

Procedure DescCadena(var juego: TipoJuego; fila: integer; columna:integer);

const
  nCeldas=(max_filas*max_columnas);

var
  Cadena:array[1..nCeldas] of TipoPosicion;
  i,j,repetir: integer;

begin
repetir:=1;

repeat
  repetir:=repetir-1;

  for i:=fila-1 to fila+1 do
           for j:=columna-1 to columna+1 do
             if posicionvalida(juego,i,j) and (juego.tablero.celdas[i,j].estado=oculta) then
              begin
              juego.tablero.celdas[i,j].estado:= descubierta;
              juego.descubiertas:=juego.descubiertas+1;
              if juego.tablero.celdas[i,j].bombascircundantes=0 then //Si las bombas circundantes son 0 se añade a la cadena.
                begin
                repetir:=repetir+1;
                cadena[repetir].fila:=i;
                cadena[repetir].columna:=j;
                end;
              end;
  if repetir>0 then
    begin
    fila:=cadena[repetir].fila;
    columna:=cadena[repetir].columna;
    end;
until repetir=0;
end;

//

begin
  if posicionvalida(juego, posicion.fila, posicion.columna) then

   if juego.tablero.celdas[posicion.fila,posicion.columna].estado= oculta then

      if juego.tablero.celdas[posicion.fila,posicion.columna].tieneBomba then//si contiene bomba...
        begin
        juego.tablero.celdas[posicion.fila,posicion.columna].estado:=descubierta;
        juego.estado:= perdido;
        end

      else // Si no contiene bomba...
        if juego.tablero.celdas[posicion.fila,posicion.columna].bombasCircundantes=0 then // ni bombas circundantes se descubren las de alrededor.
         DescCadena(juego,posicion.fila,posicion.columna)
        else // si tiene bombas circundantes solo se descubre una.
         begin
         juego.tablero.celdas[posicion.fila,posicion.columna].estado:=descubierta;
         juego.descubiertas:=juego.descubiertas+1;
         end;
 if juego.descubiertas=(juego.tablero.topefila*juego.tablero.topecolumna-juego.bombas) then  // Para cambiar a 'ganado'.
  juego.estado:=ganado;
end;

PROCEDURE Marcar(var juego:TipoJuego; posicion:TipoPosicion);

begin
  if posicionvalida(juego, posicion.fila, posicion.columna) then
     if juego.tablero.celdas[posicion.fila,posicion.columna].estado= oculta then
      begin
      juego.tablero.celdas[posicion.fila,posicion.columna].estado:= marcada;
      juego.marcadas:=juego.marcadas+1;
      end;
end;

PROCEDURE DesMarcar(var juego:TipoJuego; posicion:TipoPosicion);

begin
  if posicionvalida(juego, posicion.fila, posicion.columna) then
    if juego.tablero.celdas[posicion.fila,posicion.columna].estado= marcada then
     begin
     juego.tablero.celdas[posicion.fila,posicion.columna].estado:= oculta;
     juego.marcadas:=juego.marcadas-1;
     end;
end;

PROCEDURE DespejarCircundantes(var juego:TipoJuego; posicion:TipoPosicion);

var
   i,j: integer;
   k:tipoposicion;
   contador: integer;
begin
 contador:=0;

if posicionvalida(juego,posicion.fila,posicion.columna) then
 if juego.tablero.celdas[posicion.fila,posicion.columna].estado=descubierta then
  begin
     for i:=(posicion.fila-1) to  posicion.fila+1 do
       for j:=posicion.columna-1 to posicion.columna+1 do
         if posicionvalida(juego,i,j) then
          if juego.tablero.celdas[i,j].estado=marcada then
            contador:=contador+1;//Suma las marcadas a su alrededor.

 if contador= juego.tablero.celdas[posicion.fila,posicion.columna].bombasCircundantes then
   for i:=posicion.fila-1 to posicion.fila+1 do
     for j:=posicion.columna-1 to posicion.columna+1 do
       if posicionvalida(juego,i,j) then
        begin
        k.fila:=i;
        k.columna:=j;
        Descubrir(juego,k);
        end;
  end;
end;

PROCEDURE  MarcarCircundantes(var juego: TipoJuego; posicion: TipoPosicion);
var
   i,j: integer;
   k: tipoPosicion;
   contador: integer;
begin
contador:=0;

if posicionvalida(juego,posicion.fila,posicion.columna) then
  if juego.tablero.celdas[posicion.fila,posicion.columna].estado=descubierta then
 begin
      for i:=posicion.fila-1 to posicion.fila+1 do
       for j:=posicion.columna-1 to posicion.columna+1 do
         if posicionvalida(juego,i,j) then
          if (juego.tablero.celdas[i,j].estado=marcada) or (juego.tablero.celdas[i,j].estado= oculta) then
           contador:=contador+1;//Suma las celdas ocultas y marcadas a su alrededor.

  if contador= juego.tablero.celdas[posicion.fila,posicion.columna].bombasCircundantes then
   for i:=posicion.fila-1 to posicion.fila+1 do
     for j:=posicion.columna-1 to posicion.columna+1 do
       if posicionvalida(juego,i,j) then
        begin
        k.fila:=i;
        k.columna:=j;
        Marcar(juego,k);
        end;
 end;
end;

PROCEDURE DescubrirSegura(var juego:tipojuego);// Esta accion se puede realizar siempre excepto si solo queda una casilla.
var
   i,j,q,r: integer;
begin
randomize;
q:= juego.tablero.topefila;
r:= juego.tablero.topecolumna;
if (juego.marcadas+juego.descubiertas)<(juego.tablero.topeFila*juego.tablero.topecolumna-juego.bombas-1) then
 begin
 repeat
   i:=random(q)+1;
   j:=random(r)+1;
 until (juego.tablero.celdas[i,j].estado=oculta) and (juego.tablero.celdas[i,j].tienebomba=false);

  juego.tablero.celdas[i,j].estado:=descubierta;
  juego.descubiertas:=juego.descubiertas+1;
 end;

end;
             
[/b]

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Wul



Registrado: 30 Jul 2018
Mensajes: 6

Mensaje Publicado: Lunes 25 Mar 2019 00:57

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Otra cosa, me dijiste que usara Lazarus y asi a sido pero ¿aun sirve para la segunda parte de este curso?

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Lunes 08 Abr 2019 16:59

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Hola Wul, antes que nada, discúlpame por la demora en responderte.

Tu primera duda es esta:

Wul escribió:
For i.fila:=(posicion.fila-1) to posicion.fila+1 do


Me gustaría saber cuál era el mensaje de error. Teóricamente está todo bien y no debería fallar, pero hay algo que se me escapa.

Luego me consultas esto:

Wul escribió:
Otra cosa, me dijiste que usara Lazarus y asi a sido pero ¿aun sirve para la segunda parte de este curso?


En realidad Lazarus es 1000 veces mejor para seguir el curso, el problema es que cuando lo escribí, la segunda parte la hice utilizando el lenguaje Modula-2 con el IDE llamado XDS. No te voy a pedir que instales esa basofia, porque ni yo mismo entiendo por qué utilicé esa herramietna en su momento. Seguramente porque desconocía todo el potencial de Pascal.

Así que te propongo lo siguiente:

NO INSTALES EL XDS, sigue usando Lazarus.

Lee la lección 28 para ver las leves diferencias entre Pascal y Modula. Esto es solo para que entiendas los ejemplos, porque no dejarás de usar Pascal.

Lee la lección sobre métodos de búsqueda y ordenación (31).


Sigue leyendo en orden las lecciones, aplicando los ejercicios en Pascal. Cuando llegues a la lección 40 te vas a encontrar con el concepto de TAD. En Módula eso se hace de la forma que se explicará en la lección. Bien, lee esa lección y luego me avisas así te explico cómo aplicar eso en Pascal con Lazarus, que es mucho más fácil y responde a los lenguajes de programación modernos como Java, C++, etc.

Estoy a tus órdenes.

Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Wul



Registrado: 30 Jul 2018
Mensajes: 6

Mensaje Publicado: Martes 09 Abr 2019 16:14

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Buenas Kyshuo, paciencia tengo no te preocupes Ok , incluso me sorprende que después de tanto tiempo que tiene el curso aun sigas aquí respondiendo a las dudas.

Respecto a mi duda dejo aquí un pequeño programa con el que me pasa:

Código:

program errorregistro;
type
  TipoPosicion=record
   fila: 1..90;
   columna: 1..80;
   end;

var
   i,posicion: tipoPosicion;
   contador: integer;
begin
 contador:=0;

posicion.fila:=5;
posicion.columna:=8;

     for i.fila:=(posicion.fila-1) to posicion.fila+1 do
       for i.columna:=posicion.columna-1 to posicion.columna+1 do
            contador:=contador+1;

end.   


Y aqui los errores que me dice, señala que esta mal el punto de i.fila:

errorregistro.pas(17,11) Error: Illegal counter variable
errorregistro.pas(18,13) Error: Illegal counter variable



Y sobre las lecciones quería preguntarte que si la lección 29 y 30 no hacen falta, ya que mencionas que lea la 28 y luego la 31.

Gracias.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Domingo 28 Abr 2019 21:11

Título del mensaje: Proyecto Final: Juego Buscaminas

Responder citando

Hacía tiempo no intentaba usar Registros y FOR. Pues no se puede hacer, tienes que usar una variable de algún tipo ordinal. Sé bien que i.fila es de tipo byte, pero Pascal no admite ese uso. Deberías reimplementarlo usando variables auxiliares.

Sobre las lecciones, efectivamente, 29 y 30 no son necesarias porque son específicas de Modula 2.

Un saludo.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema Ir a página Anterior1234
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Juego Liguita de futbol

Octavio Programación de juegos o videojuegos 1 Sábado 01 Jun 2019 05:03 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Agregar un volante al juego F1 2018

Miguelinho53 Programación de juegos o videojuegos 0 Domingo 11 Nov 2018 17:34 Ver último mensaje
El tema está bloqueado: no pueden editarse ni agregar mensajes.

Solicito programadores para mi proyecto

alexpin Bolsa de trabajo 0 Miércoles 23 May 2018 22:53 Ver último mensaje
El foro no contiene ningún mensaje nuevo

resultado separado por comas y al final un punto

pegomezca Python 0 Lunes 23 Oct 2017 11:19 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Duda codigo en Python - Red Neuronal con numpy ...

Daniel_wUNTG Python 1 Sábado 21 Oct 2017 22:27 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,