Juego de Cartas Chinchón en Haskell
Para este trabajo final decidimos desarrollar un juego de cartas llamado Chinchón en el lenguaje de programación Haskell. Para el desarrollo del juego, decidimos incluir una IA básica para que el usuario pueda jugar contra la computadora.
Nuestro Chinchón es un juego que usa la baraja de poker modificada (A = 1, 2, 3, 4, 5, 6, 7, 8, 9, J = 10, Q = 11, K = 12)(♠, ♥, ♦, ♣) de 48 cartas (sin comodines). Toman parte individualmente dos jugadores (un usuario y la computadora).
Cada partida se jugará hasta que alguno de los dos jugadores sobrepase los 100 puntos. El jugador que sobrepase estos puntos pierde el juego. Se juegan tantas manos como sean necesarias hasta que alguno pierda. El objetivo para cada jugador en cada una de las rondas es sumar el menor número de puntos posible. Para ello deberá combinar sus cartas antes que su rival.
Automaticamente se mezcla el mazo y se reparten 7 cartas a cada jugador, y se deja visible la siguiente carta del mazo en un montón nuevo. El resto del mazo no es visible para ninguno de los dos jugadores. El usuario empieza la partida.
El jugador tiene la posibilidad de levantar la carta visible o sacar la primera del mazo y esto dependerá de lo que quiera combinar. Una vez tomada una de estas cartas (tras lo cual tendrá 8 cartas en la mano) deberá inmediatamente decidir de cual de ellas deshacerse, agregandola encima del montón de cartas visibles. En los turnos sucesivos los jugadores deberán repetir este movimiento de tomar una de las cartas superiores, bien del mazo, o bien la carta superior del montón de cartas visibles. Si las cartas del mazo se agotan antes de finalizar la mano, se toman las cartas visibles (excepto la superior, que se mantiene), se las mezcla y se forma un nuevo mazo con ellas.
En cada mano, cada jugador tiene como objetivo intentar combinar sus cartas formando grupos de al menos tres cartas unidas por uno de los siguientes criterios:
- Cartas del mismo número.
- Cartas que forman una escalera (un grupo de cartas del mismo palo con nùmeros correlativos).
Un jugador en cualquiera de sus turnos, en el momento de deshacerse de una carta, puede cortar si tuviera todas las cartas combinadas (sea en dos grupos, de tres y cuatro cartas, o en un único grupo de 7 cartas) o si sólo le quedara una carta sin combinar.
El puntaje que obtendrá cada jugador cuando alguien corte se basa a las siguientes reglas:
- Si el jugador que cortó tiene una escalera de siete cartas (chinchón), ganará el juego directamente.
- Si el jugador tiene dos grupos de cartas (uno de tres y otro de cuatro):
- Si el jugador es el que cortó, este obtendrá -10 puntos.
- Sino, obtendrá 0 puntos.
- Si el jugador tiene combinaciones de 3 o 4 cartas, estas no se suman al puntaje de la ronda, que será la suma de las cartas que no se encuentarn combinadas.
El repositorio cuenta con un archivo Final.cabal que posee las configuraciones necesarias para compilar el programa.
username$ cd path/to/file
\path\to\file username$ cabal install -j
C:\username> cd path\to\file
C:\path\to\file> cabal install -j
\path\to\file username$ dist/build/Final/Final
C:\path\to\file> chcp 65001
C:\path\to\file> dist\build\Final\Final.exe
En windows, se agrega 'chcp 65001' para poder mostrar caracteres de ASCII-Extendido.
Ademas, en la siguiente carpeta: Final se encuentran los ejecutables para Windows, Linux y MacOs.
Una vez ejecutado, el programa te guiará para que comiences a jugar.
Nuestro objetivo para este proyecto era poder practicar y perfeccionar lo aprendido en clase con respecto al lenguaje de programación Haskell. Además, en el proceso tuvimos que pensar en cómo "pensaría" la computadora su estrategia, así teniendo que usar una AI básica para llevarlo a cabo. A lo largo del trabajo, practicamos el uso de guardas, patrones, modulos, estructuras de datos y tantos otros conceptos aprendidos en clases.
En un principio al elegir el "Chinchon", creímos que no representaría grandes problemas de programación, que con tan sólo encontrar escaleras y grupos del mismo número se resolvería. Un par de funciones sort y elem lo resolverían junto con las famosas map y filter, pero eso estaba lejos de ser verdad. Mientras la programación avanzaba, nos dimos cuenta cómo cada vez que había que decidir que carta levantar, toda la estrategia podía llegar a cambiar, y esto podía cambiar incluso ronda tras ronda. Esto genero un desafío no sólo del lenguaje sino también de AI, en el que tuvimos que pensar en todos los escenarios posibles con cada carta elegida.
Finalmente, logramos conseguir nuestro jugador "ideal" (la computadora), que pudiera pensar como un humano, analizando qué le conviene y qué no, y cuál sería su mejor estrategia para terminar el juego con el mejor puntaje posible.
Para mezclar el mazo de cartas en la función Shuffle' de Chinchon.hs usamos la función Shuffle' extraída de la siguiente referencia: https://wiki.haskell.org/Random_shuffle