Fecha y hora actual: Sábado 24 Ago 2019 04:52
Í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 Iguales

Responder al Tema

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

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Miércoles 31 Ago 2011 17:26

Título del mensaje: Proyecto Final: Juego Iguales

Responder citando

Proyecto Final - Juego Iguales

Les propondré aquí el trabajo con lo que fue la segunda tarea de Programación 1 en la Facultad de Ingeniería donde estudio, corresponde al año 2010. Estos proyectos están diseñados para que apliquen todo lo dado aquí y para que piensen de forma estructurada, la misma forma que he enseñado a lo largo de este curso. Es de alto nivel pero podrán hacerla con mi ayuda, yo estaré abierto a que pregunten todas y cada una de las dudas que tengan al respecto ya que por lo general estos trabajos se acompañan con alguna clase de consulta.

Deben leer todo antes de continuar, ya que luego de la letra del problema existen las instrucciones para implementarlo ya que se les brindará un archivo con el código ya escrito para la interfaz gráfica y un archivo con el cual deberán trabajar ustedes creando el motor del juego. Aquí ven un ejemplo de un programa donde un archivo se encarga de realizar la interfaz gráfica y otro de hacer las tareas del programa, luego ambos trabajan juntos.

Reitero, lean toda la letra antes de intentar hacer algo.


1. Introducción

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 del Instituto de Computación de la facultad, 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.
____________________________________________________________

2. 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.


3. Presentación

3.1 Juego Iguales
Iguales es un juego tipo puzle. El objetivo es eliminar fichas obteniendo la mayor cantidad de puntos posible. Las fichas que están adyacentes las unas de las otras se eliminan como un bloque. Las demás fichas se colapsan para rellenar los huecos vacíos y se forman nuevos bloques. No se puede eliminar fichas que no estén en un bloque.



El tablero se inicia como una rejilla llena de fichas. Habrá cuatro tipos de fichas. Si las fichas adyacentes de un bloque son todas del mismo tipo, entonces pueden ser eliminadas simplemente seleccionando una de ellas. El número de fichas en el bloque y los puntos que se obtendrán al eliminar ese bloque se muestran en la parte inferior. Cuanto más fichas tenga un bloque más puntos se obtendrán. Una vez que el bloque ha sido eliminado, las fichas encima de él comenzarán a caer para rellenar el espacio. Si se elimina una columna entera, entonces las fichas se desplazarán hacia la izquierda para rellenar el espacio.

Dos fichas se consideran adyacentes:
• si están en la misma columna y en filas consecutivas, o
• si están en la misma fila y en columnas consecutivas.

En la siguiente figura se muestra paso a paso el resultado de la eliminación de un bloque para el juego SameGame del entorno Gnome de GNU/Linux.



Se decide eliminar el bloque de fichas verdes.
1. Las fichas se desplazan hacia abajo.
2. Como quedan columnas libres a la izquierda, se desplazan todos las fichas hacia la izquierda.
3. Resultado de eliminar el bloque de fichas verdes.

El juego termina cuando no hay bloques a eliminar.

3.2 Fichas
Cada celda del tablero contendrá una ficha del conjunto {A, B, C, D} o estará vacía. Al comenzar el juego, el tablero se llena de fichas de forma aleatoria.

3.3 Puntajes
La puntuación está basada en el número de fichas que se eliminen:
Código:

Número de fichas eliminadas   Puntos obtenidos
                2                                   0
                3                                   1
                4                                   4
               . . .                              . . .
                n                                (n-2)^2

Si se eliminan todas las fichas hay una bonificación de 1.000 puntos.

____________________________________________________________

4. Arquitectura del sistema

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



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, 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 usuario y reflejar estas en la estructura de datos. El motor no realiza ninguna operación de entrada y salida.
En esta tarea, el estudiante implementará solamente el motor. La interfaz será provista por los docentes, es este caso, por mí, que les daré el mismo archivo que dieron los docentes en su momento. En las siguientes secciones explicamos los detalles del módulo a ser implementado.

____________________________________________________________


5. Estructura

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

5.1 Estado del Juego

El TipoEstadoJuego es un registro con los siguientes campos:

• tablero: contiene el tablero del juego
• puntaje: contiene el puntaje actual del usuario
• finalizado: indica si el juego ha finalizado.

Código:
TipoEstadoJuego = record
   tablero : TipoTablero;
   puntaje : Integer;
   finalizado : Boolean;
end;

5.2 Tablero, Celdas y Fichas

El tablero se representa con la siguiente estructura:

Código:
TipoFicha = (A, B, C, D);

TipoEstadoCelda = record
   case vacia : boolean of
      true : ();
      false : (ficha : TipoFicha);
   end;

RangoFila = 1..MAX_FILAS;

RangoColumna = 1..MAX_COLUMNAS;

TipoTablero = record
   celdas : array [RangoFila, RangoColumna] of TipoEstadoCelda;
   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 que:

• 1<= i <= topeFila
• 1<= j <= topeColumna

Donde i corresponde a las filas y j a las columnas.

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.
Cada celda del tablero puede estar vacía, o contener una ficha como indica el registro con variantes TipoEstadoCelda. Para esta implementación las fichas son 4, y las distinguimos con las etiquetas: A, B, C o D.

5.3 Posición y Lista de Posiciones

Una posición en el tablero se representa con la siguiente estructura:

Código:
TipoPosicion = record
   fila : RangoFila;
   columna : RangoColumna
end;

Para representar una bloque (o conjunto de fichas) utilizaremos el tipo TipoListaPosicion, que es un arreglo con tope, como se muestra a continuación:

Código:
TipoListaPosicion = record
   lista : array [1..MAX_CELDAS] of TipoPosicion;
   tope : 0..MAX_CELDAS;
end;

____________________________________________________________

6. Los subprogramas

El motor del juego está constituido por un conjunto de subprogramas que trabajan sobre la estructura definida.

6.1 Procedimiento inicializarJuego
Este subprograma es invocado al comienzo del juego para generar el tablero inicial.

Código:
procedure inicializarJuego( cuantas_filas :RangoFila; cuantas_columnas :RangoColumna; var estado :TipoEstadoJuego);


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

Este procedimiento debe retornar el parámetro estado configurado para iniciar el juego, esto es:

• para cada celda selecciona al azar una ficha: A, B, C ó D
• el juego no está finalizado
• el puntaje es cero

6.2 Procedimiento obtenerBloque

Dado un tablero y la posición de una celda, devuelve la lista de posiciones de celdas que están en el mismo bloque según las reglas del juego.

Código:
procedure obtenerBloque( tablero :TipoTablero; posicion :TipoPosicion; var bloque :TipoListaPosicion)


6.3 Procedimiento obtenerBloqueMasGrande

Dado un tablero, devuelve en bloque el bloque más grande. Si hay más de un bloque que cumpla con esta condición, devuelve cualquiera de estos.

Código:
procedure obtenerBloqueMasGrande( tablero :TipoTablero; var bloque :TipoListaPosicion);


6.4 Función puntosAGenerar

Dado un bloque de posiciones a eliminar y un tablero, devuelve la cantidad de puntos que se generarían si se eliminara el bloque. No solo debe tomar en cuenta la cantidad de posiciones en el bloque, sino también debe tener en cuenta si el tablero queda vacío o no, pues puede corresponder sumar el puntaje extra.

Código:
function puntosAGenerar( bloque :TipoListaPosicion; tablero: TipoTablero) : Integer;


6.5 Procedimiento ordenarBloque

Este procedimiento ordena una lista de posiciones bloque de forma creciente. Esto es, una celda [i1, j1] es menor que [i2, j2] si (i1 < i2) o si (i1 = i2) y (j1 < j2). Por ejemplo, la lista ([1,1], [2,1], [3,4], [3,5], [3,6]) está ordenada.

Código:
procedure ordenarBloque(var bloque : TipoListaPosicion);


6.6 Procedimiento eliminarBloque

Dado un bloque (o lista de posiciones de celdas a eliminar) y un estado del juego, elimina las celdas y hace los corrimientos necesarios para que el tablero del juego sea válido nuevamente.
Una vez que el bloque ha sido eliminado, las fichas ubicadas encima de él caen para rellenar el espacio. Si se elimina una columna entera, entonces las fichas se desplazan hacia la izquierda para rellenar el espacio. Se debe sumar el puntaje ganado al puntaje total del usuario.

Código:
procedure eliminarBloque ( bloque :TipoListaPosicion; var estado :TipoEstadoJuego);


_____________________________________________________________

7. 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 lo visto en este curso, 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 -Mtp 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, Integer Overflow Checking y “Turbo Pascal Compatible”).

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 en el curso, pero para este proyecto no deben usarse ya que la interfaz gráfica se encarga del manejo de la pantalla.

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.

8. Apéndices

8.1 Números aleatorios

En free pascal se pueden generar números al azar utilizando la función random, la cual fue explicada en este curso.

8.2 Guía para resolver algunos de los problemas presentados en este proyecto

Algunos algoritmos tienen complejidades algorítmicas que requieren pensarlos con cuidado. En este apéndice damos algunas sugerencias para su implementación.

Obtener Bloque

Un algoritmo posible consiste en manejar dos listas de posiciones: lista de pendientes y lista de visitadas, aparte del bloque (o lista) que queremos obtener como resultado.

El algoritmo es el siguiente:

1. Agregar la posición inicial a la lista de posiciones pendientes.
2. Mientras haya posiciones en la lista de pendientes, procesar cada posición de la siguiente manera:
----1. Quitarla de la lista de pendientes
----2. Agregarla a la lista de visitadas
----3. Agregarla a la lista de posiciones que forma el bloque que estamos buscando
----4. Agregar todas las posiciones adyacentes, que sean del mismo tipo del bloque que estamos armando, y que no hayan sido visitadas, a la lista de pendientes para procesarla más tarde.

Eliminar Bloque

Hay varios algoritmos que resuelven este problema. Algunos más eficientes que otros. Una opción es:

1. Marcar todas las celdas del bloque a eliminar como vacías,
2. Mover todas las fichas hacia abajo para cubrir los huecos que hayan quedado en las columnas.
3. Si se generaron columnas vacías, mover las columnas que contienen fichas hacia la izquierda (respetando el orden que tenían), y que las columnas vacías queden a la derecha.

9. Referencias

1. http://library.gnome.org/users/swell-foop/2.31/swell-foop.html
2. http://en.wikipedia.org/wiki/Same_Game


Instrucciones para la interfaz gráfica:

1. Introducción

Con el fin de poder probar en forma interactiva los subprogramas que se piden en este proyecto, se les brinda el código iguales.pas, al cual le faltan los subprogramas que se pide implementar.

Ud. deberá implementar dichos subprogramas en el archivo motor.pas. Para que esto funcione, dentro del archivo iguales.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 iguales.pas en el lugar de dicha directiva. Tenga en cuenta que los subprogramas del motor.pas publicado pueden tener instrucciones a los efectos que compile iguales.pas que no necesariamente deben estar en la solución implementada.

2. Restricciones

• El programa final que implemente el juego debe funcionar sin que Ud. tenga que modificar el archivo iguales.pas. Todos los subprogramas que se pide implementar en la letra del proyecto, así 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 iguales.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 subprogramas que se piden o cualquier otro subprograma extra que necesite.

• Ud. no debe usar variable globales, toda la comunicación con la interfaz debe ser a través de los parámetros de los subprogramas.

3. Descripción de la interfaz
3.1 Pantalla principal

La interfaz se muestra en la siguiente figura:



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 ven:
---• las celdas vacías (que se representan con el caracter ‘.’) o con fichas (que se representan con los caracteres ‘A’, ‘B’, ‘C’ o ‘D’ con un color distinto cada uno).
---• la posición en donde está parado el usuario (que se indica con el cursor que está parpadeando).
---• el bloque de fichas adyacentes del mismo tipo que la ficha de la posición en donde está parado el cursor (que se resaltan con un color más brillante)

• En la barra de estado se puede ver:

---• la fila y la columna donde está posicionado el usuario,
---• la cantidad de fichas del bloque de fichas adyacentes del mismo tipo que la ficha de la posición en donde está parado el usuario.
---• los puntos a generar por el usuario, si borra el bloque de fichas adyacentes del mismo tipo que la ficha de la posición en donde está parado
---• los puntos ya generados en jugadas (o acciones) previas.
Usando las flechas del teclado y algunas teclas se consigue probar y jugar.


3.2 Pantalla inicial
Cuando se inicia el juego aparece la siguiente pantalla, que nos permite elegir el tamaño del tablero o cargar el estado del juego (nuevo o ya empezado) desde un archivo.




3.3 Ayuda

Por más información Ud. puede ver la ayuda que trae la interfaz. Presionando la tecla “h” (de help en inglés) se obtiene la siguiente pantalla:




4. Comunicación interfaz-motor

4.1 Invocación a inicializar Juego(...):

Cuando se inicia un juego nuevo seleccionando el nivel (fácil, intermedio, difícil), la interfaz invoca al procedimiento inicializarJuego(…) pasando como parámetros cierta cantidad de filas y columnas dependiendo de cada nivel.

4.2 Invocación a los otros subprogramas del motor

Cuando el usuario se posiciona sobre una celda determinada y presiona algunas de las teclas correspondientes a eliminar bloque, eliminar bloque más grande, etc., la interfaz invoca los procedimientos y funciones que correspondan pasando los parámetros que se necesiten, el estado del juego y/o la posición, dependiendo del procedimiento o función del motor que esté invocando.

Por lo tanto, la comunicación entre la interfaz y el motor se realiza usando solo los parámetros de los procedimientos y las funciones definidos en el motor.pas.


5. Funcionalidades

Aparte de poder jugar en forma interactiva, esta interfaz ofrece otras funcionalidades que le permitirán encontrar y corregir errores más fácilmente, por ejemplo:

• Listar las posiciones del bloque de fichas seleccionado que devuelve el procedimiento obtenerBloque(…)
• Listar las posiciones del bloque de fichas seleccionado que devuelve el procedimiento obtenerBloque(…), ordenadas tal cual las ordena el procedimiento ordenarBloque(…)
• Volver atrás (o deshacer) una acción.
• Guardar la configuración actual del estado del juego en un archivo de texto.
• Cargar la configuración de un estado del juego desde un archivo de texto.
• Guardar en un archivo de texto el historial de los sucesivos estados del juego y las acciones que se realizaron.

6. Recomendaciones

6.1 Para compilar
Cree una carpeta (o directorio) donde va a trabajar, descargue los archivos iguales.pas (que contiene la interfaz) y motor.pas (que solo contiene los encabezados de los subprogramas) y cópielos a dicha carpeta.

Compile el archivo iguales.pas desde la línea de comandos con:

Código:
fpc -Co -Cr -Mtp iguales.pas


o desde el IDE teniendo abierta la ventana con el archivo iguales.pas. El compilador se da cuenta automáticamente de 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, si bien no permite crear juegos nuevos ni realizar acciones, sí permite cargar archivos con juegos de prueba, como se explica a continuación. A medida que implemente los procedimientos y funciones, podrá realizar más acciones del juego.

6.2 Para probar usando la interfaz

Hasta que usted no implemente el procedimiento inicializarJuego(…), no va a poder generar sus propios tableros. Pero sí puede ir probando los otros procedimientos y funciones, por ejemplo cargar el juego desde uno de los archivo de ejemplo que le proporcionamos.
A continuación se proporcionan algunos archivos generados desde la interfaz, los cuales se pueden cargar sin necesidad de implementar los procedimientos y funciones del motor.

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 igulaes.pas y motor.pas.

• estadoJuego1.txt
• estadoJuego2.txt
• estadoJuego3.txt
• estadoJuego3-empezado.txt

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 estado inicial y la aplicación sucesiva de acciones eliminarBloque o eliminarBloqueMasGrande:

• historial1.txt
• historial2.txt
• historial3.txt

Además Ud. puede probar los procedimientos y funciones implementando su propia interfaz y/o pequeños programas para probar cada procedimiento por separado. Recuerde que lo que Ud. debe implementar son los procedimientos, la interfaz es simplemente una ayuda para probar y jugar con su implementación del motor.pas.

Descarga de los 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.

-------------------------------------------------------------------------------------

GUÍA PARA REALIZAR TEST DE ESTE PROGRAMA:

1. Introducción

Como parte de un proceso industrial, la fase de pruebas añade valor al producto generado. Todos los programas tienen defectos (somos humanos) y la fase de pruebas ayuda a descubrirlos. Ese es uno de los principales valores que añade.
Probar un programa es ejecutarlo con la peor intención con el fin de encontrarle defectos.
Para ésto se diseñan casos de prueba. Un caso de prueba consta de:

• entradas (parámetros de entrada al programa)
• resultados esperados

En esta hoja encontrarán casos de prueba de ejemplo (casos de prueba básicos) y puntos que deberían tener en cuenta a la hora de probar.
¡¡ 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.

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

La idea de cómo armar un puzzle e implementar y probar el juego iguales tiene muchas similitudes. El borde y algunas partes ya están prearmados y testeados (iguales.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:

1. Probar cada una de las partes armadas por ustedes por separado. O sea, cada subprograma o procedimiento por separado.
2. 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.

3. 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.”

4. Indicaciones y pautas a seguir para las pruebas

4.1 Probar por separado los subprogramas
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.

A modo de ejemplo se presentan los siguientes programas:

• PruebaInicializarJuego.pas
• PruebaObtenerBloque.pas

Estos archivos están en el RAR que deben descargar para este proyecto.

Sirven para probar en forma independiente los procedimientos incializarJuego y obtenerBloque. Recomendamos que armen programas similares para probar el resto de los subprogramas por separado.

4.2 Pautas para los casos de prueba

Recomendamos que piensen los casos de pruebas antes de empezar a probar y que anoten sus ideas. 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.

inicializarJuego
• 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)
• Verificar que el juego no está finalizado
• Verificar que el puntaje es cero
• Verificar que las fichas se distribuyen aleatoriamente sobre el tablero

obtenerBloque
• Diferentes ubicaciones de la posición: en el centro del tablero, en el borde derecho, en el borde izquierdo, en el borde superior, en el borde inferior
• Diferentes fichas en la celda de la posición: con ficha A, B, C, D, vacía
• Diferentes adyacentes a la celda de la posición: con adyacentes a la derecha, a la izquierda, arriba, y abajo
• Sin adyacentes

obtenerBloqueMasGrande
• Diferentes estados, situaciones, posiciones (como en el caso anterior)
• Probar con un tablero con solo bloques unitarios
• Probar con un tablero lleno de fichas del mismo color (el bloque es todo el tablero)
• Probar con un tablero con bloques del mismo tamaño

puntosAGenerar
Siendo n la cantidad de fichas en el bloque:
• Probar cuando el resultado es 0 puntos (n=0, n=1, o n=2)
• Probar para n>2
• Probar para un n grande

ordenarBloque
• Ordenar un bloque de tamaño>1
• Ordenar un bloque de tamaño 1
• Ordenar un bloque de tamaño cero
• Ordenar un bloque que abarque todo el tablero

eliminarBloque
• Eliminar un bloque del centro del tablero
• Eliminar un bloque que provoque uno o varios desplazamientos de columnas.
• Eliminar un bloque de tamaño 1 (esto no debería tener efecto)
• Eliminar un bloque que abarque todo el tablero

4.3 Integrar el motor.pas con iguales.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 la interfaz. En otras palabras deben verificar que están tomando correctamente los datos que les pasan por parámetro y devolviéndolos correctamente también.

4.4 En el juego, desde la interfaz
Esta es la última. Si hicieron bien las pruebas anteriores no deberían tener muchos errores en esta 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 defectos, entonces por varias partidas ponen el foco en buscar ciertos defectos, por ejemplo, eliminar bloques y verificar que las demás fichas se desplazan correctamente. Es importante que se guarden los historiales de cada partida(*), así cuando ocurre una falla, pueden reproducirla. Esto les servirá al momento de verificar que hayan arreglado el defecto. 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.

(*) Recuerde que la interfaz proporcionada por los docentes, le permite guardar y cargar desde un archivo de texto el estado de un juego (recién iniciado, o ya comenzado). También se puede guardar en un archivo de texto el historial de los estados por los que pasó el juego y las acciones que se realizaron.

5. 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:
• Revisar la formulación del caso de prueba. Puede que esté mal el caso y no sea el programa.
• 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 fallaron. 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 los errores.

6. 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í)
• Testing de Sistema o Caja Negra (probar que el puzzle armado es igual al de la imagen en la caja)


------------------------------------------------------------------------------------


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.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
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 2 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,