Algoritmo de Lanzamiento de Dado

El método lanzarDado() llama a la instancia de la clase Singleton Dados(), la cual cada vez que se llama actualiza sus valores. Al llamarse esta clase, se ejecuta primero un timer que en cada repetición sumaba en 1 al valor de i en cada iteración del for en el array. Este array esta compuesto de direcciones de las imágenes de los dados en el package, así cada vez que entra en el for pone una imagen diferente; esto para simular una animación de lanzamiento. Una vez complete esta animación se llama al siguiente timer, este cambia el valor de suma1 y suma2 por un numero obtenido de manera aleatoria entre 1 y 6. Posteriormente revisa el numero que le corresponde a suma1 y suma2 y pone la cara respectiva del dado que concuerde con el numero aleatoriamente obtenido, mientras está en "display" los numeros obtenidos esta clase llamará al método de mover al jugador movePlayer(int Sumadados), el cual recibe la suma de las dos variables anteriores y mueve al jugador esa cantidad . Este timer termina e inmediatamente llama al último timer, el cual pone, después de cierto tiempo, una imagen que pone "Dadoroll" para mostrar que ya el proceso ha termina.

Algoritmos para el movimiento de los jugadores

Timer Estrella:

Este algoritmo revisa que las rondas sean mayor a 1, puesto que la estrella no aparece hasta después del primer turno. Además revisa que la posición del jugador y la de la estrella sean la misma. Si cumple con esto, para el timer de movimiento y revisa si al jugador le alcanzan las monedas para comprarlo, si este es el caso le resta a las monedas el precio de la estrella y la invoca en otra posición. Al terminar reanuda el timer de movimiento.

Timer Movimiento:

Este algoritmo revisa todos los booleanos que le pertenecen al jugador y revisa cual está en true. Estos booleanos son actualizados cada vez que el jugador para de moverse. Este timer se puede ver como un controlador de movimiento, pues si se cumple un booleano específico, significa que el jugador se encuentra en una lista diferente y llamaría el método de movimiento respectivo para cada fase del tablero.

Timer Evento:

Este timer se llama cada vez que el jugador paró de moverse y revisa el método evento() de la casilla actual en la que está para ejecutarse.

MovePlayer(int moves):

Este algoritmo se ejecuta cada vez que se lanzan los dados, primero revisa que el booleano moviendose esté en false, si es así lo pone en true. Llama al método verifyPath(), para actualizar los booleanos y mandar la información al timer de movimiento para saber qué método de movimiento hacer. Después a los movimientos totales les suma el numero "moves" el cual entra en este método. Por último, llama al timer estrellas y al timer de movimiento.

MoverSigCasilla(String fase):

Este algoritmo revisa el string de la fase en la que está. Este método es llamado en cada método de movimiento. Primero revisa que esté en los finales de cada lista, si es el caso altera la posición de tal manera que entren en el caso de salida. La lógica de este método es cambiar la casilla actual del jugador por la que está en la misma fase pero en su posición actual + 1. Cambia sus valores de X y Y por los de esa nueva casilla y mueve el Label del jugador a esas coordenadas. Suma en 1 a la posición actual del jugador.

MoverAntCasilla():

Este algoritmo revisa el string de la fase en la que está. Este evento es llamado en los métodos de movimiento en reversa. Primero revisa que esté en las salidas (o en este caso entradas) de las listas. Este método cambia la casilla actual a la casilla de la fase en la que está en la posición - 1. Cambia los valores de X y de Y por los de la nueva casilla, mueve el JLabel del jugador respectivo y resta en 1 la posición actual del jugador.

MoveMainPath():

Este método es llamado si el jugador se encuentra en la lista principal. Revisa si ya terminó de moverse, si es el caso altera booleanos para el método de los turnos. Si la posición es mayor al máximo largo de la lista circular, resetea el valor de la posición y el de los movimientos totales. Si aun no ha parado de moverse y llega al final de la lista, simplemente se le cambia la casilla a la número 0 de la lista principal y resta en 45 (largo de la lista) los movimientos restantes. Si no cumple que ya paró de moverse y que llegó al máximo de la lista llama al método moverSigCasilla().

MoveA():

Revisa que la posición del jugador no exceda el largo de la lista, si lo hace, este cambia la posición del jugador a la casilla que sigue en la fase principal. De no ser así revisa si ya terminó de moverse, si lo hace para al timer de movimiento y llama a verifyList() para cambiar los booleanos del jugador. Si no se cumple nada de lo anterior simplemente llamará a moverSigCasilla() hasta que cumpla alguno.

MoveB():

Revisa que la posición del jugador no exceda el largo de la lista, si lo hace, este cambia la posición del jugador a la casilla que sigue en la fase principal. De no ser así revisa si ya terminó de moverse, si lo hace para al timer de movimiento y llama a verifyList() para cambiar los booleanos del jugador. Si no se cumple nada de lo anterior simplemente llamará a moverSigCasilla() hasta que cumpla alguno.

MoveC():

Revisa que la posición del jugador no exceda el largo de la lista, si lo hace, este cambia la posición del jugador a la casilla que sigue en la fase principal. De no ser así revisa si ya terminó de moverse, si lo hace para al timer de movimiento y llama a verifyList() para cambiar los booleanos del jugador. Si no se cumple nada de lo anterior simplemente llamará a moverSigCasilla() hasta que cumpla alguno.

MoveD():

Tiene las mismas tres opciones. Si se le acabaron los movimientos que simplemente revise donde quedó; si se pasó del largo de la lista que resetee los valores de posición y los movimientos (por ser circular) y por último, si no cumplió esos que se siga moviendo con moverSigCasilla.

MoveBackwardsC():

Cumple la misma funcionalidad que los otros métodos de moverse. Sin embargo, tiene un cambio en su algoritmo pues al ir para atrás no se puede llegar a que la posición del jugador sea igual a movimientos totales, por lo hubo que buscar una manera de igualarlas, para esto se estudió el movimiento del jugador dentro de la lista y se llegó a que para hacer una ecuación equivalente a (pos = movimientos) se encontró el siguiente pos = movimientos - 2 * (movimientos - 1).

MoveBackwardsD():

Este algoritmo revisa que esté en la ultima posición de la lista, si es el caso cambia la posición a 10 nuevamente y cambia el valor de su casilla actual. Si no es el caso va a llegar a dos opciones: se va a mover constantemente hasta que entre a la otra opción, que la posición sea igual a los movimientos, pero al ser en reversa no se logrará nunca. Por lo que se encontró que su equivalente en nuestro caso sería: pos = movimientos - 2 * (movimientos - 6 ) + (10*n); siendo n un numero que suma en 1 cada vez que el jugador le da una vuelta a la lista D en reversa.

verifyPath():

Verifica si las coordenadas en las que se encuentra pertenecen a una intersección entre listas, si es el caso cambia el booleano para que así cambie de un método de movimiento a otro. En el caso de que el jugador esté en las coordenadas de la casilla morada, teletransportará al jugador de una casilla morada a otra, pues es la manera en la que el jugador puede llegar a la casilla D de manera que no sea por el teleport de eventos.

verifyTeleport():

Revisa las coordenadas de la casilla en la que apareció después de tele transportarse, de esta manera cambiará los booleanos, para posteriormente saber qué método de movimiento deberá usar.

verifyList():

Este método revisa el booleano del jugador, este booleano hace saber en qué lista se encuentra. El método toma ese booleano y actualiza la casilla actual del jugador a una nueva utilizando getCasilla(int pos, String fase), pues tomará la posición del jugador y el string de la fase en la que está (información que brinda el booleano) y se le pondrá como su nueva casilla. También tiene la lógica para revisar si en en la posición del jugador que esté jugando está otro jugador, si es el caso lo mete en una lista simple y llama al evento duelo con los jugadores que estén en esa lista (siendo uno de estos el jugador que estaba jugando su turno).

Algoritmo para escoger ganador:

Revisará las estrellas de todos los jugadores que se encuentren en la lista de jugadores. Si no hay empates llamará la ventana del ganador. De haber empate meterá los jugadores que tengan la misma cantidad de estrellas en una lista y llamará un método para sacar el que tenga la mayor cantidad de monedas entre los que estén en esa lista, el que resulte mayor será el ganador y se llamará la ventana de ganador correspondiente.

Algoritmo getCasilla(int pos, String lista):

Este método consiste en un switch-case. Va a recibir el string de la lista que sea, y revisará caso por caso la vocal de entrada. Dependiendo de la vocal retornará la casilla en la fase de la vocal de entrada y en la posición de entrada.

Algoritmo getFase(String fase):

Este método consiste en otro switch-case, le entrará la misma vocal y dependiendo del caso retornará la fase (lista) en el mapa.

Algoritmo getRandomTile():

Este algoritmo crea dos numeros aleatorios. Primero crea un numero rand el cual es un numero entre 1 y 106 (Cantidad de casillas totales del tablero) Dependiendo del numero cambiará el valor de la variable lista a una fase específica utilizando el getFase(String fase). Posteriormente crea otro numero random entre 0 y largo de la nueva lista (Para así evitar null pointers), el cual va a ser la nueva posición. Este método retornará la casilla en la nueva lista y en la posición anteriormente sacadas.