TRIPLETRIAL Por: Bernabé Kantar, Joaquín. Tripletrial aparece en ...

TRIPLETRIAL
Por: Bernabé Kantar, Joaquín.
Tripletrial aparece en el clásico Final Fantasy VIII como un minijuego de cartas, en el cual el
objetivo es ganar las cartas del rival.
Para ello cada jugador escoge 5 cartas procedentes de su colección
(previamente conseguidas en el juego a través de misiones o encontradas en
los escenarios), cada carta dispone de 4 atributos o fuerzas
situadas cada una en uno de sus laterales.
El sistema de juego es simple,
por turnos los jugadores juegan una única carta de su
mano sobre un tablero con capacidad para 9 cartas en
un sistema de 3x3 (imagen de la izquierda).
Cuando se juega una carta, se ha de comprobar si
alguno de sus laterales está en contacto con alguna
carta rival, en caso de estarlo se comparan las fuerzas
situadas en los laterales en contacto y si la carta jugada
tiene un mayor valor de fuerza que la que ya estaba,
esta última pasa a ser del bando del contrario.
Este procedimiento se ha de realizar para todas las cartas rivales que estén en contacto con la recién
llegada.
Los jugadores alternan turnos en los cuales es obligatorio jugar una y sólo una carta, hasta que las
9 posiciones del tablero estén ocupadas. En este momento se dará por vencedor al jugador con más
cartas en su bando, siendo posible un empate.

¿CÓMO SE JUEGA?
Una vez iniciada la partida, los dos jugadores (en adelante Azul y Rojo) alternarán turnos tras jugar
sus cartas.
La secuencia del turno es la siguiente:
-Escoger una carta en mano.
-Elegir una posición libre del tablero.
-Jugar la carta.
-Comprobar las interacciones con las cartas rivales.
-Resolver las posibles interacciones.
-Fin del turno.
Por lo tanto durante el turno del jugador, este debe escoger una y sólo una de sus cartas
desplazándose con las flechas de dirección sobre las cartas de su mano y cuando esté sobre la que
desee pulsando “enter”. Ahora podrá desplazarse por el tablero y colocarla en una posición del
tablero que no estuviese previamente ocupada, en caso de arrepentirse de la carta que escogió
simplemente debe pulsar espacio para volver a su mano.
Una vez seleccionada la posición, la carta será llevada de la mano a la posición del tablero,
momento en el cual se comprobará si hay o no cartas rivales en contacto con la misma. De ser así
comparando sus valores de fuerzas en contacto podremos saber si las derrotaremos o no. Para
derrotar una carta rival y que ésta se una a nuestro bando, nuestra fuerza a comparar debe tener un
valor superior. En caso de derrotarla pasará a nuestro bando.
Ahora es el turno del rival.
Repitiendo este proceso hasta que las 9 posiciones estén ocupadas, entonces se cuenta las cartas de
cada bando, ¡el jugador que posea más cartas será el vencedor!
OBJETIVOS
El juego una vez desarrollado debe permitirnos jugar una partida para dos jugadores a partir de unas
manos generadas aleatoriamente como en otros juegos de cartas coleccionables.
En este caso quizás el formato Abierto sea el más interesante, en el cual ambos jugadores se ven las
manos, unido a que las cartas nos son desconocidas hasta el inicio de la misma la complejidad del
juego es mayor pues requerirá pensar por los dos, usar estrategias para engañar al oponente y
sacrificar alguna de nuestras cartas para hacer una jugada mejor.
A su vez en el trascurso de la partida, el programa debe impedir jugadas ilegales tales como no
jugar carta o jugar una carta en una posición ocupada.
En cuanto a gráficos, mediante ncurses usaremos las funciones de imprimir en pantalla con colores
para mostrar los bandos de las cartas, usando una paleta reducida (blanco, negro, amarillo, rojo y
azul) con la que el usuario fácilmente diferenciará y sabrá con exactitud lo que ocurre, tanto fase del
juego como las interacciones entre cartas.

IMPLEMENTACIÓN
Para convertir la teoría en una realidad se han implementado tres clases:
-CMano, en la cual creamos y gestionamos la mano del jugador, tendremos dos .
-CTablero, la cual recibirá las cartas jugadas y en la que podremos ver el resultado del juego así
como la interacción entre las cartas jugadas.
-CCursor, el cursor es el intermediario entre los deseos del usuario y la realización de su jugada, nos
asiste señalizando la carta que deseemos jugar desde la mano del usuario y una vez seleccionada
nos permitirá colocarla en la posición escogida del tablero.
Cuando iniciamos el juego se nos presenta en pantalla el tablero y las manos de ambos jugadores
con sus cartas iniciales y sus colores respectivos. El cursor (amarillo) nos mostrará sobre qué carta
estamos posicionados y nos permitirá seleccionar únicamente las cartas de nuestra mano y
colocarlas en las posiciones vacías del tablero.
Durante la sucesión de los turnos veremos como al derrotar las cartas rivales, éstas pasan a nuestro
color y viceversa.
ESTRUCTURA
Como ya se ha mencionada previamente, todas las gestiones relativas a la selección de carta o
posición para la misma se realiza a través de la clase CCursor que recibirá en su construcción una
referencia al tablero para poder posteriormente enviar la carta seleccionada hasta el tablero.
Igualmente cada turno recibe la referencia del jugador que es poseedor del mismo. Lo cual le
permite interactuar con el usuario que con las flechas de dirección podrá posicionar el cursor sobre
la carta de su mano que desee jugar. Una vez el usuario selecciona la carta, ésta es guardada en una
variable temporal hasta que el jugador (mediante el cursor) seleccione la posición del tablero en la
que quiere ponerla.
Si esta posición es válida, la carta seleccionada es pasada como parámetro al tablero junto con las
coordenadas de la posición en la que debe ser colocada. La carta original es borrada de la mano.
Una vez en el tablero, es el propio tablero el que comprueba las posibles interacciones con las cartas
que ya estaban él.
Por tanto vemos como claramente es la class CCursor la que interactúa con los usuarios, la cual se
asegura de que tanto las class CMano y CTablero le confirmen si una jugada o un desplazamiento es
válido.
Siendo CCursor el que da las órdenes a las demás y es la que recibe las órdenes directamente del
usuario.
A continuación procederemos a dar una breve descripción de cada método público de las clases
implementadas.

CMANO, sus métodos públicos:
CMano(CTablero *tablero, TColor color); Constructor al cual le pasamos la referencia al tablero y
el color que desde el principal le hemos asignado al jugador (Rojo/Azul).
~CMano(); Destructor.
TCarta DevuelveCarta(int p); Devolverá una copia de la carta en la posición p.
void BorraCarta(int p); Elimina la carta en la posición p.
int EnMano(); Devuelve el número de cartas que quedan en la mano.
void Pintate(); Imprime en pantalla la mano del jugador.
TColor ColorJugador(); Devuelve el color que asignamos al jugador en el constructor.
CTABLERO, sus métodos públicos:
CTablero(); Constructor, iniciamos todas las posiciones del tablero como vacías, iniciamos ncurses
y habilitamos la opción de movernos mediante el uso de los cursores.
~CTablero(); Destructor, cerramos ncurses y la ventana.
void RecibeManos(CMano *JugadorAzul, CMano *JugadorRojo); Una vez creados los
jugadores, le pasamos al tablero las direcciones de los mismos.
void JuegaCarta(TCarta carta, int x, int y); Recibe una carta y la posición del tablero donde debe
ponerla, una vez colocada gestiona las posibles capturas y en caso de ser necesario actualiza el
propietario de las cartas que están en el tablero.
TCarta DevuelveCarta(int x, int y); Devuelve una copia de la carta en la posición escogida.
void PintaEstado(); Imprime en pantalla las manos de los jugadores que le pasamos en
RecibeManos utilizando el método CMano::Pintate(), además de pintar el tablero con el estado
actual.
TColor Ganador(); Una vez finalizada la partida, calcula el resultado y devuelve el color vencedor.
CCURSOR, sus métodos públicos:
CCursor(CTablero *mesa); Constructor al que le pasamos la dirección del tablero.
~CCursor(); Destructor.
void DesplazateEnMano(CMano *jugador); Cada turno le pasamos la dirección del jugador cuyo
turno se va a desarrollar, nos desplazamos por la mano para seleccionar la carta que jugaremos y se
la pasamos al la función privada bool DesplazateEnTablero(TCarta, int, int) la cual nos permite
desplazarnos por el tablero y nos devolverá false si nos arrepentimos de la carta que cogimos y true
cuando juguemos la carta en una de las posiciones válidas del tablero, llamando entonces a
Ctablero::JuegaCarta(TCarta, int, int) con la carta elegida y su nueva posición como
parámetros.

principal.cpp
Alternación de turnos entre jugador
Rojo y Azul.
class CCursor
Métodos públicos llamados:
void DesplazateEnMano(CMano *jugador);
class CTablero
Métodos públicos llamados:
class CMano
Métodos públicos llamados:
TCarta DevuelveCarta(int p);
void BorraCarta(int p);
void JuegaCarta(TCarta carta, int x, int y);
void PintaEstado();
Estado actual del tablero tras jugar la carta
Leyenda:
Llamadas
Fin del proceso, vuelta al inicio