República Bolivariana de Venezuela

Universidad Católica Andrés Bello

Extensión Guayana
Escuela de Ingeniería Informática
Materia: Algoritmos y programación I.

Proyecto Final
II SEMESTRE

PROFESOR: INTEGRANTES:
Bello Castillo, Franklin Castro Gruber, Diego Andrés CI 27.922.745
Canga Guevara, Arturo Misael CI 25.696.222
Fernández Ocando, Luis Fernando CI 28.002.235
Muñoz Muñoz, Elony Valentina CI 27.656.703

Puerto Ordaz, 9 de junio del 2019

 Introducción.

Este Juego Técnico llamado “Juego de Tronos” trata de enfocar una manera simple y
metódica la aplicación de desarrollo de algoritmos y estructuras de datos, paso a paso, y su
materialización en programas de computador.

Desde luego, no fue fácil ya que sin lugar a dudas se está experimentando el desarrollo de
algoritmos y programas complejos y extensos en los cuales cada programador utilizó bases
técnicas personales, estrechamente vinculadas con el lenguaje Pascal de programación
aprendido en Aula.

En resumen, intentamos con el “Juego de Tronos” recoger ambos aspectos: por un

lado, viene a cubrir la necesidad de un enfoque metodológico en el aprendizaje y en el
ejercicio de la programación, pero también la necesidad de experimentar con programas
concretos, expresarlos en un lenguaje real y hacerlos funcionar con un traductor concreto y
correcto.
 Bases del Juego de Tronos.

Inicio de sesión del juego: el juego se inicio indicando tu usuario y clave correctamente
escrita (si te llega aflatar un campo por llenar se procederá a mandar un mensaje que diga
que debe llenar todos los campos para continuar); en caso de no poseer una cuenta se
presiona el botón registrar para crear su propio registro de jugador y luego de tener tú
cuenta se procederá a entrar al menú del juego.

Registro de jugador: En el registro de jugador se le pedirán una serie de datos personales

que usted deberá ingresar para poder crear tu cuenta en el juego. Entre esos datos están
Nombre, Apellido, Nombre de Usuario, Fecha de nacimiento, Correo, el País de
procedencia y la Clave (que luego esta al volverla a escribir en Confirmar se procederá a
ser encriptada para seguridad del usuario en una función que actuara de forma automática
luego de ingresar la clave deseada dentro del formulario). Luego de llenar todos los campos
se presiona el botón confirmar para poder guardar el nuevo usuario. Ahí mismo se aplicará
una serie de condiciones para verificar si se lleno todos los campos durante el proceso; si
no llena todos los mensajes se le enviará un mensaje que le indique al usuario que debe
llenar todos los campos para continuar.

Menú: Cuando se ingresa en el juego veras el menú donde tiene diferentes opciones que
puedas realizar. Entre las cuales cumplen las siguientes necesidades:

-Iniciar Juego: En este botón se ingresa los datos de juego de la partida que se estará
jugando, indicando cuales jugadores participaran, el tamaño de tablero, el nivel de dificultad
de juego, las casas con la que deseas participar y quien inicia primero el juego lanzando un
dado virtual buscando obtener el mayor número del 1 al 6 (En caso de ser empate se
tomará en cuenta el valor ASCII del nombre usuario de cada jugador). Todos estos datos de
juego se guardaron en un archivo para luego si se quiere verificar el historial de las partidas
que se jugaron.
-Opciones: en este botón se le podrá conceder al usuario de si quiere o no escuchar la
música de fondo de la temática de GAME OF THRONES o los efectos de sonido durante la
partida de juego.
-Calificaciones: Este botón permite chequear el reporte de los juegos jugados por el
usuario según su nombre de usuario y el rango de fecha ingresado. Se aplica una condición
en el botón buscar para saber si el usuario o la fecha ingresada existe en el reporte; si este
se llega a encontrar se mostrará el archivo de los usuarios con una serie de datos; sino, se
enviara un mensaje que indique que no se encontró ningún jugador con esos datos. Por
último tenemos el botón SALIR que al presionarlo se sale directamente del juego.

Todas las funciones y procedimientos están ubicadas en el anexo: Librería gotdnd.

Todos los códigos se encuentran en la sección Códigos.

-Inicialización de variables: Se definen 4 variables iníciales. jug1 y jug2 serán las

posiciones iníciales de los jugadores, flagturn que será una bandera que definirá el jugador
que está jugando, flagwin que será una bandera usada sólo si el jugador 1 gana y
numplayer que es una bandera que define el jugador que está jugando (usada por una
función de premio/penalización).
-Definición del ID del jugador: cada jugador tiene que introducir un nombre, para definir su
ID se suman los valores ordinales de cada uno de los caracteres que lo conforman. Esto se
hace con un ciclo Repita Para que va sumando un acumulador el carácter i del nombre del
jugador.

-¿Cómo se define quién empieza?: En base a la documentación se le pide a los jugador

que introduzca un número del 5 al 10 para definir la dimensión de la matriz; si introduce un
valor que sea menor a 5 o mayor a 10 entonces mandará un mensaje que pedirá que se
ingrese un valor entre el 5 y el 10, una vez tomado el mayor se hará la suma de estos dos
valores y se verificará si es par o impar. Si es par empezará el jugador con mayor ID, en
caso de ser impar entonces empezará el jugador con menor ID; esto implica que el flagturn
y el numplayer cambiarán de valor a 1 y 2 respectivamente si el jugador 2 empieza. Así
mismo se arroja un mensaje dependiendo de quién empiece el juego.

-Solicitud de dificultad y definición de la cantidad de premios y penalizaciones: Se

define primero el total de casillas que podrán usarse, es decir, el cuadrado del valor N - 2
(se excluyen La Muralla y El Trono de Hierro). La dificultad vendrá definida en el menú del
juego y se representará con una letra: F, M o D; para fácil, medio o difícil. Dependiendo de
la dificultad se definirán unas variables “premios” y “pena” con un procedimiento Truncar. El
ciclo termina cuando la variable de dificultad sea igual a F, M o D. Estas variables van a ser
usadas con setlength para definir un arreglo de premios (arraypremios), uno de
penalizaciones (arraypena) y un arreglo auxiliar que será modif, de dimensión summodif
(premios + pena). Así mismo, los 6 premios y las 6 penalizaciones serán de la dimensión
correspondiente.

-Definición de casillas a nivel aleatorio: Primero se definen las casillas de premios, para
ello se realiza un ciclo Repita Para que empezará en 0 y terminará en la longitud del arreglo
de premios - 1 (debido a que es un arreglo dinámico). En ese ciclo se ejecuta un randomize
para generar un número aleatorio de una vez, un flag de premios se inicializa en 0 y se
generará un número aleatorio del 0 al total de las casillas utilizables + 2 (para excluir el 0 y
la primera casilla) con la función random. Si es el primer elemento que se genera, es decir,
i=0, entonces el primer número generado aleatoriamente se ubicará esta casilla tanto en
arraypremios como en modif, sino se recorrerá el arreglo modif con otro ciclo Repita Para
verificando que este número se encuentre (modif[j]=ubpremio), si se encuentra en el arreglo
modif el flag cambiará a 1; si el flag se hubiese mantenido en 0 entonces se almacenaría en
la ubicación i de arraypremios y modif. Todo este conjunto de operaciones dentro del para
más externo están a su vez dentro de un Repita Hasta, que finaliza si el flag es 0.

Para las penalizaciones se ejecuta de manera muy similar pero con ciertas diferencias
aparte de que se trabaje con el arreglo arraypena. Primero el ciclo Para externo empieza en
premios y termina en summodif -1 (con respecto a las ubicaciones de modif, ya que el ciclo
anterior terminó en premios-1, su consecuente es premios, así mismo terminará en
summodif-1 por ser un arreglo dinámico). Aparte, debido a un error que se encontraba, si se
copia el mismo código por alguna razón el primer elemento generado para penalizaciones
era igual que el último elemento generado por los premios; para evitar esto se hizo una
condición, de que si el último elemento de arraypremios es igual a la ubicación generada,
entonces el flag cambia a 1. De resto el bloque de código es casi exactamente igual, solo
con una línea más de código.

-Determinación de premios y penalizaciones específicas de manera aleatoria: Se

definen 6 contadores (c0 al c5) y se inicializan en 0, luego se define un ciclo Repita Para
que irá de 0 hasta los premios o penalizaciones - 1 (según sea el caso), en este ciclo se
generará un número aleatorio del 0 al 5 y dependiendo del resultado se le asignará el
elemento i del arreglo que se está usando (arraypena o arraypremios) y se ubicará en la
ubicación del contador N del arreglo de premio o penalización específica, además de que
este contador aumentaría en 1. Esto se aplica dos veces ya que se tiene que realizar con
los premios y las penalizaciones; una vez finalizado esto se redimensionan estos arreglos
específicos al tamaño de su contador. Debido a un problema de pascal donde 0
almacenado en una variable no era interpretado por la función setlength se dio la condición
de que si el contador era distinto de 0 se redimensionaba usando el contador, de lo
contrario se usa el valor 0 directamente.

-Generación de tropas y vida: Se le pedirá a cada jugador que pulse cualquier tecla, al
hacerlo se generará un número aleatorio del 1 al 6, el cual será el número de vidas, así
mismo se le generará el número de tropas como el valor de las vidas * 10000. Esto se
ejecutará 2 veces, uno para cada jugador.

-Generación del tablero: después de identificar el tamaño del tablero en pasos anteriores
(específicamente en el paso de cuando se define qué jugador empieza), se realiza un ciclo
repita para utilizando como índice ‘i’ para identificar las filas y ‘j’ para las columnas. Se
inicializan 2 variables una con el valor inicial de la matriz que será 0 y otro con la dimensión
de la matriz que será n-1 (a y b serán las variables respectivamente) y también se inicializa
un contador el cual irá colocando numero por numero en cada casilla que se le especifique
según dicen nuestros ciclos de repita para.
El índice ‘i’ se inicializa en 0 ya que es un arreglo dinámico el que se usa para crear la
matriz, el ciclo repita para donde se usará ‘i’ será el ciclo más externo y el que nos creara
toda la matriz en pantalla, después se aplican 4 ciclos de repita para usando como índice ‘j’
en todos los ciclos y se aplicará en cada ciclo las variables inicializadas en 0 y en el grado
de la matriz - 1.
Para crear el llenado de izquierda a derecha de la matriz se inicializa ‘j’ en el valor de ‘a’
hasta que llegue a el valor de b (recordemos que a=0 y b=grado de la matriz-1), y para su
llenado se inicia el contador que vaya sumando numero a numero y el número que tenga el
contador en ese momento se le asigna a la posición de la matriz que la expresaremos en
matriz[a,j], ya que ‘a’ será un valor fijo pq estamos llenando solo una fila y ‘j’ será el valor
que varíe debido a que se le asigna un nuevo valor cada vuelta del ciclo repita para.
Para el llenado de arriba a abajo de la matriz se aplica un ciclo repita para y se le asigna a ‘j’
el valor de ‘a+1’ hasta ‘b’ ya que empezaremos justo en la fila por debajo de la primera, se
le asigna el número del contador a la matriz expresada de manera matriz[j,b] ya que
recorreremos las filas se cambia de posición el índice de ‘j’ para que recorra solo las filas de
la matriz y se le asigna ‘b’ a la columna que estamos llenando.
El llenado de derecha a izquierda de la matriz se empieza con el ciclo repita para
inicializando ‘j’ con el valor de ‘b-1’ hasta el valor de ‘a’, pero esta vez el ciclo repita para
será un ‘downto’ debido a que tenemos que ir de mayor a menor en casillas por tanto
empezaremos en la columna justo a la izquierda de la última casilla en la que estamos
posicionados y se le asigna el número que tenga el contador a la casilla en la que estemos
situados, se representa la matriz de esta manera matriz[b.j] ya que nos estaremos
desplazando por las columnas y la fila será un valor fijo.
Y el cuarto y último ciclo de repetir para es otro downto, para llenar la matriz de abajo a
arriba, ya que se debe ir desde el mayor número de filas al menor; se le asigna a ‘j’ el valor
de b-1 y se le pide que recorra hasta el valor de a+1, ya que no podemos tomar la primera
casilla porque ya la llenamos anteriormente en el primer ciclo repita para, se le asigna el
valor del contador a la casilla en la que estemos recorriendo y se expresa en matriz[j,a] ya
que se recorre las filas nada más y la columna se mantiene como valor único ‘j’ varia y ‘a’ es
el valor constante en el ciclo repita para.
Al terminar el llenado externo, se aplican los 4 pasos anteriores repetidamente hasta el
llenado completo de la matriz, pero para lograr llenar la matriz cada vez mas internamente,
al terminar los 4 ciclos repetir para y antes de terminar el ciclo de ‘i’ se le suma 1 a la
variable ‘a’ y se le resta 1 a ‘b’ (es decir el nuevo a será a:=a+1 y el nuevo b sera b:=b-1).

-Sistema de turnos: Todo este sistema está en un ciclo Repita Hasta. Las operaciones de
los jugadores 1 y 2 son las mismas, la única diferencia es el flagturn (para el primer jugador,
el flag tiene que ser menor que 1, para el segundo jugador el flag tiene que ser mayor que
0) y numplayer que cambiará apenas se inicien los procedimientos del segundo jugador.

Primero que nada se le pide al jugador que pulse cualquier tecla para generar un número
aleatorio del 1 al 6, el cual será el dado; para ello se le coloca un randomize() luego del
readkey() y antes de la función random(). Una variable dice N (donde N es 1 o 2,
dependiendo del jugador) que es un string es usado para ir almacenando la secuencia de
dados de cada jugador, incrementará un carácter cada dado con la asignación
diceN:=diceN+inttostr(dado), donde dado es el número generado aleatoriamente y se usa la
función inttostr de la librería sysutils para convertir este valor a una cadena. Para el
recorrido se verifica que la condición jugador + dado-(n*n) sea menor o igual que 0. Si este
es el caso se hará un recorrido sencillo con un solo ciclo Repita Para que irá de 1 hasta el
dado, donde se irá sumando 1 al jugador por cada iteración y con un delay para dar tiempo
de mostrar el avance; de no ser así se harán dos ciclos Repita Para, uno que irá de 1 hasta
el máximo menos la casilla inicial del jugador, donde el jugador avanza (aumenta en 1) y
luego un ciclo que irá de 1 hasta jugador+dado-(n*n), donde el jugador retrocederá (decrece
en 1).

Para chequear si cayó en un premio o penalización se inicializa un flag goodbad en 1 si es

premio, ó 2 si es penalización, se recorren los arreglos específicos con una función
checkmodifier para cada arreglo, si el valor que arroja es 1 se aplicará la función
dependiendo de cual sea el caso (explicados en el anexo Librería gotdnd). Luego se verifica
si pasó el límite y se realiza la reasignación dependiendo de cuantas casillas pasó con n*n-
jugador.

La siguiente condición es si tienen la misma casilla. Si el jugador 1 cae en la misma casilla

que el jugador 2, el segundo tiene que ser enviado al inicio, para ello se verifica si están en
la misma casilla, de ser así el jugador opuesto al que está jugando será reasignado de
manera inmediata a la primera casilla y se le restará una vida. Si la cantidad de vidas del
jugador opuesto es 0, se mostrará un mensaje diciendo que el jugador se ha quedado sin
vidas. Además se hace una condición de que si las vidas del jugador opuesto son mayores
que 0 se hará el cambio del flag necesario.

Además, para el jugador 1 se verifica al final de su sección si su casilla es la misma que el

máximo del tablero (n*n), de ser así flagwin cambiará a 1. Si este flag es 1 entonces no se
ejecutará el segundo jugador.

Recordando que todo el sistema de los turnos estaba en un Repita Hasta, la condición de
salida es que alguno de los dos jugadores llegue al máximo de la casilla o que las vidas de
ambos jugadores sea 0.

-Mensajes finales del juego y generación de strings para los archivos: Dependiendo
del jugador que haya llegado al trono de hierro se mandará una felicitación en pantalla hasta
que se pulse una tecla, si ambos jugadores se quedaron sin vidas entonces se mandará un
mensaje indicando eso y que el juego ha finalizado. Al final de cada partida se enviara un
mensaje que sea referido al cuidado del ambiente.

Luego se generarán unas cadenas para la creación de los archivos finales de informe de la
partida con la función stringwriter, ubicada en gotdnd.

Se creó una matriz temporal de imágenes en la cual se van a cargar las imágenes
normales, unas matriz del tamaño del tablero en la cual se van a cargar cada una de las
imágenes dadas. Luego se hará un recorrido por los arreglos de penalizaciones para buscar
cuales son las posiciones de la matriz principal ósea del tablero, en el cual van las
penalizaciones, Ósea que recorro ARRAY_PENAS y busco el valor asociado a cada una de
las penalizaciones en la matriz principal (Matriz). Cuando lo encuentra inmediatamente
agarra y carga la imagen de las penalizaciones en la casilla i, j en la cual se quedó, lo
mismo ocurre en la ARRAY_PREMIOS que es básicamente recorrer el arreglo de los
premios que cada uno tiene contenida la posición donde va cada uno de los premios, luego
lo recorro uno por uno y lo busco en la matriz principal que donde lo consiga ahí mismo en
el valor de i, j lo hago en la matriz temporal.

-Creacion de informes finales del juego: para la creación de los informes finales se deben
guardar los datos específicos de cada juego como por ejemplo, el código del juego, los
nombres de usuario de los jugadores, su dificultad, la secuencia de dados y las tropas
iniciales y finales. Para guardar la secuencia de dados de cada jugador se transforma el
numero del dado al ser tirado en un string o cadena y este se le concatena a una cadena
auxiliar declarada anteriormente y se va a aumentando cada vez que un jugador tire el dado
(obviamente son secuencias de dados diferentes para cada jugador), las tropas y vidas
finales e iniciales se guardan en unas variables al crearlas para tener el inicio y la tropa y la
vida que se usa en el juego constantemente en el final del mismo serán las finales
Al terminar de jugar se abren dos informes con los datos específicos y se guardan en una
carpeta con el código del juego para diferenciar cada informe con su juego.

NOTA: Profesor Franklin bello nosotros somos el grupo de la situación complicada y el

código logra correr hasta cierto punto, logramos encontrar los procedures pero hay un error
en los mismos ya que es una versión algo antigua, ya que, nuestro compañero es el único
que tiene la versión mas reciente, se acomodo pero sigue habiendo algún error de
compilación. De todos modos si usted prefiere, podemos volver a mandárselo mañana
cuando encontremos cual es el error. Pero si solo va a evaluar el código este es lo que
tenemos.

Att: Luis Fernandez C.I: 28002235