Proecto Programacion

FICHA DE IDENTIFICACIÓN DE TRABAJO DE INVESTIGACIÓN
Título
Nombres y Apellidos Código de estudiantes
Autor/es Alvaro Toco Toaca
Fecha dd/mm/aaaa
Carrera Ing. Gas y Petróleo

Asignatura Programación 1
Grupo A
Docente
Periodo Académico 4to Semestre
Subsede Oruro - Bolivia
Título: Buscaminas
Autor/es: Álvaro Toco Toaca
TABLA DE CONTENIDOS
Lista de Figuras…………………………………………………………………………………………
Introducción……………………………………………………………………………………………..
Capítulo 1. Planteamiento del Problema…………………………………………………………………
1.1 Formulación del Problema…………………………………………………………………
1.2 Objetivos………………………………………………………………………………….
1.3 Justificación……………………………………………………………………………..
1.4 Planteamiento de Hipótesis…………………………………………………………………
Capítulo 2. Marco Teórico……………………………………………………………………………
2.1 Área del Estudio/Campo de Estudio……………………………………………………….
2.2 Desarrollo del Marco Teórico……………………………………………………………….
Capítulo 3. Método…………………………………………………………………………………….
3.1 Tipo de Investigación…………………………………………………………………..
3.2 Operacionalización de variables……………………………………………………………
Asignatura: Programación 1
Carrera: Ing. Gas y Petróleo Página 22 de 22
Título: Buscaminas
LISTA DE FIGURAS
Título: Buscaminas
INTRODUCCION
Este problema fue presentado como tarea para los estudiantes de Programación 1, asignatura de
primer año donde se intenta enseñar a programar desde la nada a los estudiantes. Claro está que en
un curso formal esto tenía plazos de entrega y estaba sujeto a los rigurosos test del equipo de la
facultad UDABOL, de modo que si el programa no funcionaba perfectamente uno perdía el curso
directamente sin posibilidad de dar exámenes, por más bien que le haya ido en las pruebas escritas.
Aquí ustedes no manejarán plazos porque esto es voluntario y personal, cada uno ve si toma esta
oportunidad o la deja. Saludos.
Con el fin de poder probar en forma interactiva los procedimientos que se piden en este proyecto, se
les brinda el siguiente código: buscaminas. pas, al cual le faltan los procedimientos que se piden
implementar.
Ud. deberá implementar dichos procedimientos en el archivo motor. pas. Para que esto funcione,
dentro del archivo buscaminas. pas se encuentra la siguiente directiva:
Como parte de un proceso industrial, la fase de pruebas añade valor al producto generado. Todos los
programas tienen errores (somos humanos) y la fase de pruebas los descubre. Ese es uno de los
principales valores que añade. Recuerden que probar un programa es ejercitarlo con la peor intención
con el fin de encontrarle fallas.
Además de las sugerencias en la definición de la Interfaz para el buscaminas referente a las pruebas,
en este documento se les brindará una guía de cómo efectuar sus pruebas. ¡¡Así que a hincarle los
dientes a esto que será de gran ayuda para ustedes!!
Capítulo 1. Planteamiento del Problema
Título: Buscaminas
1.1 Formulación del Problema

¿Cómo hacer el juego buscaminas en el programa pascal?
¿Pasos a seguir el juego buscaminas en el programa pascal?
1.2 Objetivos
Bueno este programa es de poder hacer correr en el programa pascal el juego buscaminas
1.3 Justificación
2 En este
3 se escogió para poder ampliar conocimientos y determinar de manera científica cual es la
4 causa de la deformación de rocas, pliegues y fallas.
Capítulo 2. Marco Teórico

2.1 Área del Estudio/Campo de Estudio
El juego buscaminas, ahora lo vamos a jugar en el programa pascal para q sea más interesante.
2.2 Desarrollo del Marco Teórico

Información general
Aquí se redactaban las reglas para los estudiantes, tales como cuál compilador utilizar, qué pasa si se
copian el código fuente o parte del mismo, etc. Ustedes no tienen restricciones en esto, usen lo que
más cómodo les quede para trabajar, y por supuesto, si comparte código no hay problema, al
contrario.
Presentación
Título: Buscaminas
El buscaminas es un conocido juego de computadora que simula un campo de minas que debe ser
despejado por el jugador, marcando la posición de todas las minas sin pisar ninguna.
El juego consiste en despejar todas las casillas de una pantalla que no oculten una mina.
Algunas casillas tienen un número, este número indica las minas que suman todas las casillas
circundantes. Así si una casilla tiene el número 3 significa que de las ocho casillas que hay alrededor
(si no está en una esquina o borde) hay 3 con minas y 5 sin minas. Si se descubre una casilla sin
número indica que ninguna de las casillas vecinas tiene mina y estas se descubren automáticamente.
Si se descubre una casilla con una mina se pierde la partida.
Acciones Básicas
Existen muchas versiones del buscaminas que pueden diferir en algunos aspectos. La mayoría de ellas
incluye los siguientes movimientos por parte del jugador:
Descubrir una celda: Esta acción se realiza sobre una celda oculta. El resultado depende del contenido
de la celda:
 Si la celda contiene una mina el juego se pierde.
 Si la celda está libre pero hay minas en las celdas circundantes, aparece un número (entre 1 y
8) que indica la cantidad de celdas circundantes que contienen una mina.
 Si la celda está libre y no hay minas en ninguna de las celdas circundantes, la celda se
descubre y también se descubren automáticamente todas las casillas circundantes, aplicando
el mismo procedimiento para cada una de ellas. Este procedimiento deja al descubierto toda
un área de casillas libres adyacentes.
Marcar una celda: Esta acción se realiza sobre una celda oculta que el jugador supone que contiene
una mina; suposición que puede ser correcta o no. Independientemente de ello, el sistema muestra la
celda como marcada e incrementa el contador de celdas marcadas.
Título: Buscaminas
Desmarcar una celda: Esta acción se realiza sobre una celda marcada. El resultado es desmarcar la
celda y dejarla como oculta. Y decrementar el número de celdas marcadas
Acciones complementarias
Varias versiones del buscaminas también incorporan las siguientes facilidades:
Despejar circundantes de una celda: Esta acción se realiza sobre una celda ya descubierta. El
resultado es descubrir todas las celdas circundantes que no estén marcadas. Por “descubrir”
entendemos ejecutar la acción descubrir una celda explicada más arriba. La acción se lleva a cabo,
solamente si el número que contiene la celda es igual a la cantidad de celdas circundantes marcadas.
Marcar circundantes de una celda: Esta acción se realiza sobre una celda ya descubierta. El resultado
es marcar todas las celdas circundantes no descubiertas. La acción se lleva a cabo, solamente si el
número que contiene la celda es igual a la suma de la cantidad de celdas circundantes ya marcadas
más las celdas circundantes no descubiertas sin marcar.
Descubrir una celda segura: Es una ayuda que solicita el jugador. El resultado es que una celda sin
bomba se descubre. En general la solicitud de esta ayuda es penalizada de alguna manera por
ejemplo sumando segundos (en este proyecto no tendremos en cuenta el tiempo empleado por el
jugador)
Terminación
El juego termina cuando se da alguna de las dos siguientes situaciones:
Se descubre una celda que contiene una mina. En este caso el jugador pierde el juego.
Se descubrieron todas las celdas que no contienen minas. No importa si se marcaron o no todas las
celdas con minas. En este caso el jugador gana el juego.
Arquitectura del sistema
El sistema que implementa el juego se construirá de acuerdo con la siguiente arquitectura:
Título: Buscaminas
Este es un modelo simple donde tenemos dos capas o módulos: la interfaz y el motor.
La interfaz se encarga de realizar el diálogo con el usuario (el jugador), capturar sus entradas e
invocar las operaciones asociadas. La interfaz también maneja la imagen del juego en pantalla
actualizándola cada vez que hay cambios. En resumen, se encarga de todo lo que tenga que ver con
entrada y salida. La interfaz no realiza ninguna modificación directa sobre la estructura de datos.
El motor es el módulo que trata con la estructura de datos que representa el juego en un estado
determinado. Este módulo estará compuesto por todos los subprogramas necesarios para ejecutar las
acciones del jugador y reflejar estas en la estructura de datos. El motor no realiza ninguna operación
de entrada y salida.
En este proyecto, el estudiante implementará solamente el motor. La interfaz será provista por los
docentes, en este caso, por mí, que les daré los mismos archivos que dieron los docentes en su
momento. En las siguientes secciones explicamos los detalles del módulo a ser implementado.
La estructura
La estructura de datos que representa el juego de buscaminas es la siguiente:
Código:
type
TipoEstadoJuego = (jugando,ganado,perdido);
TipoJuego = record
estado : TipoEstadoJuego;
tablero : TipoTablero;
bombas, (* cantidad de bombas en el tablero *)
marcadas, (* cantidad de celdas marcadas *)
descubiertas : integer; (* cantidad de celdas descubiertas *)
end;
El juego es un registro con los siguientes campos:
 estado: Contiene el estado del juego en un momento dado.

 tablero: el tablero con las celdas
 bombas: cantidad de bombas en total en el tablero
 marcadas: cantidad de bombas ya marcadas por el usuario
 descubiertas: cantidad de celdas que están descubiertas
El tablero
El tablero se representa con la siguiente estructura:
Código:
RangoFila = 1..MAX_FILAS;
RangoColumna = 1..MAX_COLUMNAS;
Título: Buscaminas
TipoTablero = record
celdas : array[RangoFila,RangoColumna] of TipoCelda;
topeFila : RangoFila;
topeColumna : RangoColumna;
end;
Esta estructura es una matriz (ver Arreglos Bidimensionales) con dos topes (ver array con tope). De
esta manera se pueden representar tableros de diferentes tamaños. Las celdas válidas de la matriz
son aquellas cuyas coordenadas (i,j) son tales:
• 1<= i <= topeFila

• 1<= j <= topeColumna
Las constantes MAX_FILAS y MAX_COLUMNAS se suponen definidas con valores apropiados. Estos
valores están definidos en la interfaz, de manera que el estudiante no necesita conocerlos.
La celda
La celda se representa con la siguiente estructura:
Código:
TipoEstadoCelda = (oculta,marcada,descubierta);
TipoCelda = record
estado : TipoEstadoCelda;
case tieneBomba :Boolean of
True : ();
False : (bombasCircundantes :integer)
end;
La información que tiene una celda es la siguiente:
 estado : indica si la celda fue marcada, descubierta o continúa

 oculta (cuando decimos oculta nos referimos a oculta y sin marca).
 tiene Bomba: es un booleano que vale true si y sólo si la celda contiene una mina.
 bombas Circundantes: indica la cantidad de bombas que hay en las celdas circundantes. Este
valor puede ser 0.
Los subprogramas
El motor del juego está constituido por un conjunto de subprogramas que trabajan sobre la estructura
definida. En varios de los subprogramas se utiliza un parámetro que representa la posición de una
celda dentro del tablero. Para ello necesitamos definir el siguiente tipo:
Código:
Título: Buscaminas
TipoPosicion = record
fila : RangoFila;
columna: RangoColumna;
end;
Cualquiera de los subprogramas pedidos más abajo retorna sin ejecutar nada cuando recibe una
posición no válida.
A continuación se describen los subprogramas que constituyen el motor del buscaminas:
Inicialización
Este subprograma es invocado al comienzo del juego para generar el tablero inicial.
Código:
procedure IniciarJuego(var juego: TipoJuego; cuantas_filas: RangoFila; cuantas_columnas: RangoCo

cuantas_bombas: integer);
Los parámetros que recibe son:
 cuantas filas: cantidad de filas que va a tener el tablero

 cuantas columnas : cantidad de columnas que va a tener el tablero
 cuantas bombas: cantidad de bombas que va a tener el tablero
Este procedimiento debe retornar el parámetro juego configurado para iniciar el juego:
 Todas las celdas quedan ocultas.

 Las bombas se colocan al azar en tantas celdas como lo indique el parámetro cuantas bombas.
La colocación al azar se realiza utilizando la función rondón ya explicada en este curso.
 Las celdas sin bombas deben tener el campo bombas Circundantes con el valor apropiado.
 Los demás campos del juego (estados, contadores, topes, etcétera) se deben inicializar
apropiadamente
En caso que el parámetro cuantas bombas tenga un valor negativo o sea mayor que el número de
celdas, el estudiante puede decidir el comportamiento del procedimiento.
Descubrir una celda
Título: Buscaminas
Código:
procedure Descubrir(var juego: TipoJuego; posicion: TipoPosicion);
Esta operación realiza sobre el parámetro juego la acción de descubrir una celda tal como se describe
más arriba. La celda a descubrir es la indicada por el parámetro posicion. En caso de que la celda ya
esté descubierta, o la posición no sea válida, el procedimiento no hace nada.
Tener en cuenta que cuando se descubre una celda con 0 bombas circundantes, se produce
automáticamente el descubrimiento de las celdas adyacentes para las cuales a su vez se aplica el
mismo criterio. Esto puede provocar el descubrimiento de toda un área de celdas adyacentes,
situación seguramente muy apreciada por el jugador.
En las versiones clásicas del buscaminas, esta operación se realiza con un clic con el botón principal
sobre una celda no descubierta.
Marcar y Desmarcar
Código:
procedure Marcar(var juego: TipoJuego; posicion: TipoPosicion);

procedure DesMarcar(var juego: TipoJuego; posicion: TipoPosicion);
Estos dos procedimientos corresponden a las acciones de marcado y desmarcado de una celda tal
como se describió en la sección Acciones Básicas.
En las versiones clásicas del buscaminas, esta operación se realiza con un clic con el botón secundario
del ratón sobre una celda no descubierta.
Despejar Celdas Circundantes
Código:
procedure DespejarCircundantes(var juego: TipoJuego; posicion: TipoPosicion);
Este procedimiento corresponde a la acción Despejar Circundantes de una celda tal como se explicó en
la sección Acciones Complementarias.
En las versiones clásicas del buscaminas, esta operación se realiza con un clic con el botón principal
del ratón sobre una celda descubierta.
Marcar Celdas Circundantes
Código:
Título: Buscaminas
procedure MarcarCircundantes(var juego: TipoJuego; posicion: TipoPosicion);
Este procedimiento corresponde a la acción Marcar Circundantes de una Celda tal como se explicó más
arriba.
Esta operación no está implementada en las versiones clásicas del buscaminas.
Descubrir Celda Segura
Código:
procedure DescubrirSegura(var juego: TipoJuego);
Este procedimiento corresponde a la acción Descubrir Celda Segura tal como se explicó más arriba.
Esta operación no está implementada en las versiones clásicas del buscaminas.
Se pide
Escribir un archivo con todos los subprogramas que forman el motor del juego.
Los cabezales de los subprogramas deben coincidir exactamente con los que aparecen en esta letra. Si
el estudiante realiza algún cambio se considerará que el subprograma no fue implementado.
Se puede utilizar todo en este curso y nada más.
La compilación y la ejecución se realizarán en línea de comandos. El comando de compilación se

invocará de la siguiente manera:
Código:
fpc -Co -Cr programa.pas
Si trabaja con el IDE, asegúrese de configurarlo para que compile de la misma manera que el
comando anterior (habilitación de range checking e Integer Overflow Checking).
No está permitido utilizar facilidades de Free Pascal que no forman parte del estándar y no se dan en
el curso. Así por ejemplo, no se pueden utilizar ninguna de las palabras
siguientes: uses, crlscr, gotoxy, crt, readkey, longint, string, break, etcétera.
Uses y ClrScr fueron mostradas por mí en este curso, sin embargo la interfaz gráfica se encarga del
trabajo con la pantalla, por lo cual ustedes no necesitan usarlas.
Título: Buscaminas
En esta tarea como en todos los problemas de este curso, se valorará además de la lógica correcta, la
utilización de un buen estilo de programación de acuerdo a los criterios impartidos en el curso. De esta
manera, se hará énfasis en buenas prácticas de programación que lleven a un código legible, bien
documentado y mantenible, tales como:
 indentación adecuada
 utilización correcta y apropiada de las estructuras de control
 código claro y legible
 algoritmos razonablemente eficientes
 utilización de comentarios que documenten y complementen el código
 utilización de constantes simbólicas
 nombres mnemotécnicos para variables, constantes, etcétera.
Apéndices
Números randómicos
En free pascal se pueden generar números al azar utilizando la función random la cual ya fue
explicada en este curso.
Guía para descubrir celda
El procedimiento Descubrir tiene algunas complejidades algorítmicas que requieren pensarlo con
cuidado. En este apéndice damos algunas sugerencias para su implementación.
Si la celda a descubrir contiene una bomba el juego termina. Si la celda a descubrir no contiene
bomba y la cantidad de circundantes con bomba es mayor que cero, se descubre sólo esta celda y
continúa el juego.
La situación más compleja surge cuando la celda no contiene bomba y la cantidad de circundantes con
bomba es igual a 0. Para este caso sugerimos un algoritmo que permite explorar exhaustivamente el
área circundante a descubrir.
Se utiliza una lista de posiciones de celdas que llamaremos la lista de pendientes. En esta estructura
guardamos un conjunto de posiciones de celdas que aún nos resta procesar en el proceso de descubrir
toda el área circundante. La implementación de esta estructura la dejamos a consideración del
estudiante.
El algoritmo es el siguiente:
 Poner el estado de la celda inicial como descubierta

 Guardar posición de esta celda en lista de pendientes.
 Repetir mientras la lista de pendientes no sea vacía.
Título: Buscaminas
 Elegir una celda cualquiera de la lista de pendientes. Quitarla de la lista

 Para cada una de sus celdas circundantes aún no descubiertas (pueden ser hasta 8) hacer lo
siguiente:
 Poner el estado en descubierta
 Si el número de circundantes con bomba es 0, agregar la posición de esta celda a la lista de
pendientes.
Interfaz para el buscaminas
Introducción
Con el fin de poder probar en forma interactiva los procedimientos que se piden en este proyecto, se
les brinda el siguiente código: buscaminas. Pas, al cual le faltan los procedimientos que se piden
implementar.
Ud. deberá implementar dichos procedimientos en el archivo motor. Pas. Para que esto funcione,
dentro del archivo buscaminas. Pas se encuentra la siguiente directiva:
Código:
{$INCLUDE motor.pas}
Esto tiene el mismo efecto que copiar y pegar el contenido del archivo motor.pas dentro de
buscaminas. Pas en el lugar de dicha directiva.
Restricciones
El programa final que implemente el juego debería funcionar sin que Ud. tenga que modificar el
archivo buscaminas. Pas. Todos los procedimientos que se piden implementar en la letra del proyecto,
como cualquier función, procedimiento, tipo, etc. extra que Ud. necesite definir deberán ser
implementados en el archivo motor. Pas.
Las directivas, procedimientos y funciones no estándar usadas en el archivo buscaminas. Pas, fueron
utilizadas con el fin de que Ud. tenga una interfaz más amigable. Sin embargo como es regla en este
curso Ud. no puede utilizar facilidades de Free Pascal que no forman parte del estándar y que no se
dan en el curso para implementar los procedimientos se piden, o cualquier otro subprograma extra
que necesite.
Ud. no debe usar variable global, toda la comunicación con la interfaz debe ser a través de los
parámetros de los procedimientos.
Descripción de la interfaz
Título: Buscaminas
La interfaz básicamente tiene un cabezal, un tablero y una barra de estado. En el cabezal está el
nombre del juego y se despliegan mensajes cuando el jugador ha ganado o perdido. En el tablero se
pueden ver las celdas, que pueden estar ocultas (‘ # ‘), marcadas (‘ B ‘), o descubiertas vacías (‘ ‘), o
indicando el número de bombas en las celdas circundantes (‘ 1′, ‘ 2 ‘, …, ‘ 8 ‘).
En la barra de estado se puede ver el nro. de fila y columna donde está posicionado el jugador, la
cantidad de celdas con bombas, cuantas están marcadas, cuantas están descubiertas, y la totalidad de
las bombas que tiene el tablero.
Usando las flechas del teclado y algunas teclas se consigue probar y jugar al buscaminas. Por más
información ver la ayuda que trae la interfaz, presionando la tecla “h” (de helo en inglés).
Comunicación interfaz-motor
Invocación a Iniciar Juego(…)
Cuando se inicia un juego nuevo seleccionando el nivel (fácil, intermedio, difícil), la interfaz invoca al
procedimiento Iniciar Juego(…) pasando como parámetros cierta cantidad de filas, columnas y bombas
dependiendo de cada nivel.
Invocación a los procedimientos del motor
Cuando el usuario se posiciona sobre una celda determinada y presiona algunas de las teclas
correspondientes a marcar, desmarcar, descubrir, etc. la interfaz invoca al procedimiento
correspondiente pasando como parámetro el juego y la posición, salvo para “descubrir segura” en que
se pasa sólo el juego.
Por lo tanto la comunicación entre la interfaz y el motor es usando sólo los parámetros de los
procedimientos.
Funcionalidades
Aparte de poder jugar al buscaminas en forma interactiva, esta interfaz ofrece otras funcionalidades
que le permitirán encontrar y corregir errores más fácilmente, por ejemplo:
 Ver el tablero en “modo debug”. Presionando la tecla correspondiente muestra información

oculta (bombas, cantidad de bombas en celdas circundantes) que un usuario jugando
normalmente no puede ver. Luego cuando quiera puede volver al “modo normal”.
 Volver atrás (o deshacer) una acción.
 Guardar la configuración actual del juego en un archivo de texto.
 Cargar la configuración de un juego desde un archivo de texto.
 Guardar en un archivo texto el historial de las sucesivas configuraciones del juego y las
acciones que se realizaron.
Título: Buscaminas
Recomendaciones
Para compilar
Cree una carpeta (o directorio) donde va a trabajar, descargue los archivos buscaminas. Pas (que
contiene la interfaz) y el motor. Pas(que solo contiene los encabezados de los procedimientos) y
cópielos a dicha carpeta.
Compile el archivo buscaminas. Pas desde la línea de comandos con:
Código:
fpc -Co -Cr buscaminas.pas
O desde el IDE teniendo abierta la ventana con el archivo buscaminas. Pas. El compilador se da cuenta
automáticamente que tiene que incluir el código del archivo motor. Pas donde está la directiva
mencionada antes.
Esto ya va a generar una interfaz sencilla que no permite crear juegos nuevos, ni realizar acciones,
pero sí cargar archivos con juegos de pruebas, como se explica a continuación. A medida que
implemente los procedimientos, podrá realizar más acciones del juego.
Para probar usando la interfaz
Hasta que usted no implemente el procedimiento Iniciar Juego (…), no va a poder generar sus propios
tableros. Pero sí puede ir probando los otros procedimientos, por ejemplo cargando el juego desde
uno de los archivo de ejemplo que le proporcionamos, e ir mirando en “modo debug” que todo
funcione bien, o generando un historial y revisando el archivo del historial.
Al final habrá un enlace para descargar un archivo RAR que contiene todos los archivos que se
mencionan a continuación incluyendo también el archivo buscaminas. Pas y motor. Pas.
A continuación se proporcionan algunos archivos generados desde la interfaz, los cuales se pueden
cargar sin necesidad de implementar los procedimientos del motor.
 juego1.txt
 juego2.txt
 juego3.txt
 juego3-empezado.txt
Título: Buscaminas
A continuación se proporcionan algunos archivos con historiales de ejemplo. Los historiales contienen
la secuencia de juegos que se generan a partir de un juego inicial y la aplicación sucesiva de acciones
(como marcar, desmarcar, descubrir, etc.)
 historial1.txt
 historial2.txt
 historial3.txt
Además Ud. puede probar los procedimientos implementando su propia interfaz, y/o pequeños
programas para probar cada procedimiento por separado. Recuerde que lo que Ud. debe realizar son
los procedimientos, la interfaz es simplemente una ayuda para probar y jugar con su motor.
Descarga de archivos
Para bajar los archivos necesarios para realizar este proyecto deben hacer click en el siguiente
enlace:
DESCARGAR ARCHIVOS DEL PROYECTO.
Serán dirigidos a un servidor externo llamado NetLoad. Seleccionen la opción de descarga gratuita y
podrán bajar el archivo RAR que contienen todo lo ya mencionado.
__________________________________________________________
1. Introducción
Como parte de un proceso industrial, la fase de pruebas añade valor al producto generado. Todos los
programas tienen errores (somos humanos) y la fase de pruebas los descubre. Ese es uno de los
principales valores que añade. Recuerden que probar un programa es ejercitarlo con la peor intención
con el fin de encontrarle fallas.
Además de las sugerencias en la definición de la Interfaz para el buscaminas referente a las pruebas,
en este documento se les brindará una guía de cómo efectuar sus pruebas. ¡¡Así que a hincarle los
dientes a esto que será de gran ayuda para ustedes!!
2. ¿Cómo arman un puzzle?
En general, uno empieza por el borde, luego arma las partes más fáciles, las difíciles, y siempre, para
cada parte, uno se va cerciorando que se está uniendo las piezas correctamente. Luego juntamos las
partes prearmadas hasta llegar a la figura final.
2.1 ¿Por qué estamos viendo cómo armar un puzzle?
Título: Buscaminas
La idea de cómo armar un puzzle e implementar y probar el buscaminas tiene muchas similitudes. El
borde y algunas partes ya están prearmados y testeados (buscamina.pas) y le pedimos que armen y
testeen las partes faltantes (motor.pas) para completar el juego o “puzzle”. Parece una tarea fácil,
¿no?
Por lo tanto para probar su tarea deben tener en cuenta 3 puntos de prueba y en este orden:
 Probar cada una de las partes armadas por ustedes por separado. O sea, cada subprograma o
procedimiento por separado.
 Probar que las partes encajan correctamente en lo que ya está armado. O sea, que al unir los
subprogramas implementados por ustedes con los implementados por nosotros no generen
errores.
 Probar finalmente que todas las partes junto con el borde funcionan correctamente. O sea,
nuestro puzzle es el que está en la imagen de la caja. Esto se hace probando desde la interfaz.
Acá es dónde se pone más divertido, es hora de jugar.
Como bien dice la letra de la tarea “Ud. puede probar los procedimientos implementando su propia
interfaz, y/o pequeños programas para probar cada procedimiento por separado. Recuerde que lo que
Ud. debe realizar son los procedimientos, la interfaz es simplemente una ayuda para probar y jugar
con su motor.”
3. Indicaciones y pautas a seguir para las pruebas
3.1 En los procedimientos:
Prueben todos los procedimientos por separado. Esta técnica les será de gran ayuda al momento de
hacer la prueba desde la interfaz. Es decir, disminuirá significativamente la cantidad de errores que
encontrarán y su gravedad. Pueden armarse un programa principal auxiliar que simplemente haga la
llamada al procedimiento bajo prueba y luego imprima el resultado en pantalla para que puedan
verificar la correctitud de su resultado. Recomendamos que piensen los casos de pruebas antes de
empezar a probar y que los anoten en una planilla.
Recuerden que un caso de prueba se puede decir que está formado por entradas (en este caso,
parámetros del procedimiento), un resultado esperado y un resultado obtenido. Además se puede
agregar una descripción para entender rápidamente qué se está atacando.
La idea es que prueben lo que se les sugiere abajo. Si tienen algunas ideas más, no las descarten,
úsenlas para probar, incluso en combinación con estas.
Pautas para los casos de prueba:
IniciarJuego
Título: Buscaminas
 Diferentes dimensiones de tableros, chicos, medianos, grandes.

 Casos límites en las dimensiones: máximo tablero (max_filas * max_columnas), mínimo
tablero (1 x 1)
 Diferentes densidades de bombas: muchas, pocas, etc.
 Casos límites en bombas: tablero lleno, tablero vacío.
 Verificar que todas las celdas quedan ocultas
 Verificar que los contadores están bien calculados.
Descubrir
 Diferentes estados de celda: oculta, descubierta, marcada.

 Diferentes situaciones de celda oculta: con bomba, sin bomba, con 0 o más bombas
circundantes.
 Para el caso 0 circundantes probar diferentes áreas a despejar, con diferentes tamaños y
formas.
 Diferentes posiciones: bordes, esquinas, centrales. No olvidar posiciones inválidas.
DespejarCircundantes
 Diferentes estados, situaciones, posiciones (como en el caso anterior)

 Celdas que cumplen la condición para que se aplique el despeje y celdas que no la cumplen.
 Situación que provoca pérdida del juego.
 Situación que provoca despejar un área más grande por efecto de descubrir celdas con 0
circundantes.
Los otros procedimientos se deben verificar en situaciones similares.
3.2 Al integrar el motor.pas con el buscamina.pas:
Además de manejar bien las estructuras ya definidas, deben estar seguros que los datos que les
llegan son los esperados por ustedes y los datos que devuelven son los esperados por
el buscamina.pas. En otras palabras deben verificar que están tomando correctamente los datos que
les pasan por parámetro y devolviéndolos correctamente también.
3.3 En el juego, desde la interfaz:
Esta es la última. Si hicieron bien las pruebas anteriores no deberían tener muchos errores en esta
Título: Buscaminas
etapa. Les sugerimos que para esta parte lo que más deben hacer es jugar. Recuerden que la
intención debe ser encontrar fallas y no salteárselas. Lo mejor es enfocarse en buscar cierto tipo de
errores durante varias partidas seguidas. Piensen que tienen una misión, encontrar errores, entonces
por varias partidas ponen el foco en buscar ciertos errores, por ejemplo, descubrir casillas sin bombas
y ver que se descubren toda la zona que se debe descubrir. Es importante que se guarden los
historiales de cada partida, así cuando ocurre un error, pueden reproducirlo. Esto les servirá al
momento de verificar que hayan arreglado el error. Les podrá ser útil anotar en una planilla la
correspondencia entre los errores y los archivos de historial. En las misiones, pueden intercalar los
distintos niveles de tablero de la interfaz, o alguno armado por ustedes.
4. Indicaciones útiles
Cuando utilicen casos de prueba:
 Ejecuten todos los casos de prueba y anoten sus resultados antes de comenzar la revisión de
los que fallaron. Esto les facilitará el trabajo.
 A la hora de empezar la revisión de los casos que fallaron. Se puede seguir estos pasos:
o Revisar la formulación del caso de prueba. Puede que esté mal el caso y no sea el
programa.
o Si el caso de prueba es correcto, se pasa a detectar qué parte del código está
generando la falla. Esto lo pueden hacer Debugueando por ejemplo.
 Cuando hayan arreglado todos los errores, ejecuten los casos de prueba que en un principio
no dieron error. Esto es para asegurarse que los cambios hechos no introdujeron errores en lo
que andaba bien.
Algunas indicaciones más para cuando prueben desde la interfaz:
 Al igual que con los casos de prueba, ejecuten varias misiones, las que ustedes crean
convenientes, antes de empezar a corregir las fallas.
_________________________________________________________
5. Un poco más de testing
5.1 Conceptos de testing manejados en esta guía:
 Testing Unitario (probar cada parte por separado)

 Testing de Integración (probar cómo encajan las partes entre sí)
Título: Buscaminas
 Testing de Sistema o Caja Negra (probar que el puzzle armado es igual al de la imagen en la
caja).
__________________________________________________________
6. Cómo probar los subprogramas por separado
Puede hacerse directamente desde la interfaz utilizando las facilidades de cargar un juego desde un
archivo, se puede lograr la configuración que se desea. También se recomienda utilizar el modo
*depuración* (tecla X) para poder ver el contenido de las celdas ocultas.
Otra posibilidad es hacer programas auxiliares que se encarguen de cargar un juego en particular y
verificar cada subprograma del motor de manera aislada. Para ello se recomienda utilizar un esquema
como el que sigue:
Código:
cargar juego
llamar subprograma
mostrar juego
Este programa se puede ejecutar varias veces cargando diferentes juegos y llamar el subprograma
con diferentes parámetros cubriendo todas las situaciones que parezcan interesantes.
Para poder aplicar lo anterior necesitamos un procedimiento que cargue un juego de un archivo y otro
que lo muestre.
Código:
procedure cargarJuego(nombre : string ; var juego :TipoJuego);

procedure mostrarJuego(juego :TipoJuego);
Por ejemplo para probar el procedimiento Descubrir sobre todas las posibles celdas de un tablero, se
podría hacer algo así:
Código:
for i:= 1 to juego.tablero.topeFila do

for j:= 1 to juego.tablero.topeColumna do
begin
cargarJuego('juego.txt',juego);
posicion.fila:= i;
posicion.columna:= j;
descubrir(juego,posicion);
Título: Buscaminas
mostrarJuego(juego);
readln; (* pausa *)
end;
De manera similar se pueden probar todos los subprogramas del motor.
El código de los subprogramas auxiliares cargarJuego y mostrarJuego lo pueden descargar aquí:
Testing Buscaminas Auxiliares.
---------------------------------------------------------------------------------
Mucha suerte con este proyecto. Estaré a su disposición para ayudarles en todo lo que necesiten. Soy
consciente de su dificultad y espero que lo emprendan. Es muy interesante lo que se proponen aquí.
Saludos a tod@s l@s que han seguido este curso, y sobretodo, muchas gracias.

Proecto Programacion

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Proecto Programacion

Hochgeladen von

Copyright:

Verfügbare Formate

FICHA DE IDENTIFICACIÓN DE TRABAJO DE INVESTIGACIÓN

Autor/es Alvaro Toco Toaca

Carrera Ing. Gas y Petróleo

Capítulo 1. Planteamiento del Problema

1.1 Formulación del Problema

Capítulo 2. Marco Teórico

2.2 Desarrollo del Marco Teórico

Varias versiones del buscaminas también incorporan las siguientes facilidades:

El juego termina cuando se da alguna de las dos siguientes situaciones:

Arquitectura del sistema

El sistema que implementa el juego se construirá de acuerdo con la siguiente arquitectura:

La estructura de datos que representa el juego de buscaminas es la siguiente:

El juego es un registro con los siguientes campos:

 estado: Contiene el estado del juego en un momento dado.

El tablero se representa con la siguiente estructura:

• 1<= i <= topeFila

La celda se representa con la siguiente estructura:

La información que tiene una celda es la siguiente:

 estado : indica si la celda fue marcada, descubierta o continúa

A continuación se describen los subprogramas que constituyen el motor del buscaminas:

procedure IniciarJuego(var juego: TipoJuego; cuantas_filas: RangoFila; cuantas_columnas: RangoCo

Los parámetros que recibe son:

 cuantas filas: cantidad de filas que va a tener el tablero

 Todas las celdas quedan ocultas.

Descubrir una celda

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

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

Despejar Celdas Circundantes

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

Marcar Celdas Circundantes

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

Esta operación no está implementada en las versiones clásicas del buscaminas.

Descubrir Celda Segura

procedure DescubrirSegura(var juego: TipoJuego);

Esta operación no está implementada en las versiones clásicas del buscaminas.

Se puede utilizar todo en este curso y nada más.

La compilación y la ejecución se realizarán en línea de comandos. El comando de compilación se

fpc -Co -Cr programa.pas

Guía para descubrir celda

 Poner el estado de la celda inicial como descubierta

 Elegir una celda cualquiera de la lista de pendientes. Quitarla de la lista

Interfaz para el buscaminas

Invocación a Iniciar Juego(…)

Invocación a los procedimientos del motor

 Ver el tablero en “modo debug”. Presionando la tecla correspondiente muestra información

Compile el archivo buscaminas. Pas desde la línea de comandos con:

fpc -Co -Cr buscaminas.pas

Para probar usando la interfaz

DESCARGAR ARCHIVOS DEL PROYECTO.

2. ¿Cómo arman un puzzle?

2.1 ¿Por qué estamos viendo cómo armar un puzzle?

3. Indicaciones y pautas a seguir para las pruebas

3.1 En los procedimientos:

Pautas para los casos de prueba:

 Diferentes dimensiones de tableros, chicos, medianos, grandes.

 Diferentes estados de celda: oculta, descubierta, marcada.

 Diferentes estados, situaciones, posiciones (como en el caso anterior)

Los otros procedimientos se deben verificar en situaciones similares.

3.2 Al integrar el motor.pas con el buscamina.pas:

3.3 En el juego, desde la interfaz:

4. Indicaciones útiles

Cuando utilicen casos de prueba:

Algunas indicaciones más para cuando prueben desde la interfaz: