Top

Cargando cosas bonitas...

Recargar...

Programando el Juego de los Chinos en C++


code-machineHace unas cuantas semanas nos pusieron como práctica de la asignatura Fundamentos de la Programación crear un juego. Se trataba del famoso juego de los chinos. Es un buen ejercicio para alguien que recién acaba de empezar en el mundo de la programación ya que utiliza la mayor parte de las cosas fundamentales de la programación (condicionales, bucles while, do-while, for, lectura y escritura de un archivo, funciones, procedimientos, etc). La práctica estaba organizada en diferentes versiones que iban poco a poco aumentando las funcionalidades del programa. La última versión ya era capaz de jugar una partida automática entre dos máquinas teniendo una de ellas cierta inteligencia.

La forma más tradicional de jugar es que cada jugador dispone de tres monedas y en cada ronda puede sacar 0, 1, 2 o 3 en su mano derecha. Entonces cada jugador, por turno, dice una cifra –su apuesta- intentando adivinar cuántas monedas suman todas las manos, de manera que no se puede repetir una cifra ya dicha por otro. Las reglas de evolución de la partida pueden ser variadas: ‘a la caída’ (el que gana la ronda se retira y se continúan las rondas hasta que sólo queda un jugador), ‘a un marcador de 3 rondas ganadas’ (el que gana 3 rondas se retira y se continúa hasta que sólo queda un jugador), etc. Y una cosa importante… para no confundir a los demás jugadores ¡no se puede mentir! Es decir, un jugador no puede apostar por un número de monedas que sea inviable de acuerdo con las monedas que él ha sacado. Por ejemplo, suponiendo que haya dos jugadores, un jugador debe apostar por un número de monedas que sea mayor o igual que el número de monedas que él ha sacado y menor o igual que el número de monedas que él ha sacado más el número máximo de monedas de que dispone el rival.

cplusplus-logoUna vez iniciado el juego, en cada ronda los jugadores (máquina y humano) decidirán cuántas monedas sacan (disponen de 3) y dirán cuántas creen que hay en total (primero la máquina y después el humano). El programa impedirá que el humano mienta en su apuesta –obligándole a decir una cifra viable– así como que repita la cifra dicha por la máquina. El programa decidirá quién gana cada ronda, indicando entonces la elección hecha por la máquina. El programa deberá permitir jugar todas las rondas que sean necesarias hasta que haya un jugador que consiga 2 rondas ganadas, es decir, vamos a jugar en base a ‘marcador de 2 rondas ganadas’.

Una vez determinado el ganador de la partida el programa indicará quién es, así como el número de rondas ganadas por el perdedor.

Detalles de la implementación

La solución de la práctica debía incluir como mínimo los siguientes subprogramas, sin embargo como verás más adelante en el código yo he optado por usar algún subprograma más como uno que lee la configuración del juego:

  • int monedasHumano(): devuelve el número de monedas que saca el jugador humano, quién introduce el valor por teclado. Debe controlar la validez del dato (¡no se pueden sacar más de NUMMONEDAS monedas!) y permitir repetir la introducción del dato por teclado todas las veces que sea necesario hasta que no haya error.
  • int apuestaHumano(int eleccionM, int numMonedasH): devuelve el número de monedas elegidas por el humano en la apuesta, controlando que el humano no mienta y que no repita la elección de la máquina. Tiene como parámetros la apuesta de la máquina (eleccionM) y el nº de monedas sacadas por el humano (numMonedasH). Si el humano miente o repite la elección de la máquina el programa le reprenderá y el proceso de introducción de la apuesta se repetirá tantas veces como sea necesario hasta que el humano cumpla las reglas del juego.
  • int quienGana(int numMonedasM, int numMonedasH, int eleccionM, int eleccionH): devuelve un valor que indica quién gana la ronda (MAQUINA si gana la máquina; HUMANO si gana el humano) o que nadie ha acertado (NADIE). Tiene como parámetros las monedas sacadas por la máquina y por el humano (numMonedasM y numMonedasH, respectivamente) así como la apuesta de la máquina y la del humano (eleccionM y eleccionH, respectivamente).
  • int menu(): muestra el menú, pide la opción y la devuelve como resultado. Sólo devolverá una opción válida (esto es, en el intervalo [0,4]).
  • int pedirMarcador(): lee de teclado y devuelve un valor de marcador válido.
  • int pedirMonedas(): lee de teclado y devuelve un número de monedas válido.
  • bool mostrarReglas(): si el archivo reglas.txt no se encuentra devolverá false; en otro caso devuelve true. Si el archivo se encuentra, mostrará su contenido por pantalla.
  • void juego(int marcador, int numMONEDAS): conduce el juego de una partida. Tiene como argumentos el valor del marcador (marcador) y el nº de monedas de que dispone cada jugador (numMONEDAS).

Generación de valores aleatorios

robotPara generar números aleatorios debes utilizar las funciones rand() y srand(semilla) de la biblioteca cstdlib. Una secuencia de números aleatorios comienza en un primer número entero que se denomina semilla.

Para establecer la semilla el programa deberá invocar a la función srand con el argumento deseado. Lo que hace que la secuencia se comporte de forma aleatoria es precisamente la semilla. Una semilla habitual es el valor de la hora del sistema que se obtiene con una invocación a time(NULL), de la biblioteca ctime, ya que así es siempre distinta para cada ejecución. Así pues, el programa deberá invocar una vez a srand(time(NULL)). Una vez establecida la semilla, la función rand() genera, de forma pseudoaleatoria, otro entero positivo a partir del anterior. Si quieres que los números aleatorios generados estén en un determinado intervalo, deberás utilizar el operador %. Por ejemplo, para obtener un entero aleatorio en el intervalo [0, limiteSuperior] hay que usar la expresión rand() % (limiteSuperior + 1); para obtener un entero aleatorio en el intervalo [1, limiteSuperior] debe usarse la expresión 1 + rand() % (limiteSuperior); y, en general, para obtener un entero aleatorio en el intervalo [limiteInferior, limiteSuperior] hay que usar la expresión limiteInferior + rand() % (limiteSuperior+1-limiteInferior).

Para que los posibles cambios realizados en el marcador y/o en el número de monedas no se pierdan entre ejecuciones del programa, hay que ampliar la versión anterior de manera que se puedan guardar ambos valores en un archivo (configP1.txt). Al inicio del programa debe realizarse la carga de los datos desde ese archivo y al final del programa guardar, para la próxima ejecución, los datos posiblemente modificados en el archivo. Si se da el caso de que no se encuentra el archivo al inicio del programa, se tomarán los valores por defecto (los de la versión 1) para el marcador y el número de monedas.

Parte opcional

Para finalizar, de manera opcional, se te ofrecía la posibilidad de extender la versión anterior con otra opción más en el menú que permita jugar una partida de forma automática, es decir, donde la máquina juegue contra sí misma.

También podías, de manera opcional, extender el programa de manera que el jugador humano pueda parar una partida no automática que se esté alargando mucho. Así, cuando se lleve un cierto nº de rondas MAXRONDAS, el programa preguntará al humano si quiere continuar con la partida o quiere abortarla. En caso de decidir abortarla, la ejecución del programa continuará con la visualización del menú de opciones. El valor de MAXRONDAS lo decides tú (por ejemplo, el doble del marcador, el marcador más diez, o lo que consideres oportuno). Si el humano permite que la partida se extienda más de MAXRONDAS rondas, el programa volverá a realizar la misma pregunta cuando hayan vuelto a pasar otras MAXRONDAS rondas (si es que antes no ha acabado la partida), y así sucesivamente.

El código de fuente ¡Al lío!

Aquí te dejo el código de fuente de la posible solución a este “ejercicio”. Sin embargo no te puedo prometer que no tenga errores o no sea la mejor posible. Pero ten en cuenta que llevo relativamente poco tiempo con la programación en C++. ¡Espero mejor en el futuro!

/*
	[VERSIÓN 4.0] JUEGO DE LOS CHINOS
	desarrollado por: DAVID ARROYO
	UNIVERSIDAD COMPLUTENSE DE MADRID
*/

#include <iostream>
using namespace std;
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <string>

const int nadie = 0;
const int maquina = 1;
const int humano = 2;

//PROTOTIPOS
void configuracion(int&, int&); // Carga el archivo de configuración <configP1.txt>
int menu(); // Muestra el menú de opciones
int pedirMarcador(); // Cambia el marcador que indica el ganador de la partida
int pedirMonedas(); // Cambia el número de monedas disponibles para cada jugador
bool mostrarReglas(); // Muestra el archivo reglas.txt por pantalla
void juego(int, int); // Carga el juego
void partidaAutomatica(int, int); // Carga el juego (partida automática)
int monedasHumano(int); // Obtención de lo que saca el humano
int apuestaHumano(int, int, int); // Obtención de la apuesta del humano
int quienGana(int, int, int, int); // Determinación del resultado de la ronda

int main()
{
	const string parametro1 = "marcadorGanadas= "; // secuencia para añadir al <configP1.txt>
	const string parametro2 = "monedasXjugador= "; // secuencia para añadir al <configP1.txt>
	int marcador, numMonedas; // Valores del marcador y número monedas
	int opcionMenu; // Guarda la opción del menú elegida
	ofstream escribirConfig;
	
	cout << "----------------------------------------------------" << endl;
	cout << "BIENVENIDO AL JUEGO de los CHINOS [VERSION 4.0]" << endl;
	cout << "desarrollado por DAVID ARROYO" << endl;
	cout << "Facultad de Informatica - Universidad Complutense" << endl;
	
	configuracion(marcador, numMonedas); // Guarda en las variables la configuración del TXT
	
	do
	{
		opcionMenu = menu();
		
		switch (opcionMenu) {
			case 1: marcador = pedirMarcador(); break;
			case 2: numMonedas = pedirMonedas(); break;
			case 3: cout << endl; 
					if (!mostrarReglas()) cout << "ERROR! No se ha podido abrir el archivo <reglas.txt>";
					cout << endl;
					break;
			case 4: juego(marcador, numMonedas); break;
			case 5: partidaAutomatica(numMonedas, marcador); break;
			case 0: cout << endl << "Fin del programa" << endl; break;
		}
	} while (opcionMenu != 0);	
	
// El menú va a seguir apareciendo siempre y cuando el usuario introduzca un valor
// diferente al 0. Tal valor se guarda en la variable 'opcionMenu' que invoca al 
// subprograma 'menu()' y devuelve un valor de tipo entero. Tal valor es
// llevado al bloque de código condicional que deriva al caso elegido

	escribirConfig.open("configP1.txt"); 
	if (escribirConfig.is_open())
	{
		escribirConfig << parametro1 << marcador << endl << parametro2 << numMonedas; // Guarda configuración antes de acabar la ejecución
		escribirConfig.close();
	}
	else
	{
		cout << "[WARNING!] El archivo <configP1.txt> no se pudo abrir." << endl;
	}

	system("PAUSE");
	return 0;
}

void configuracion(int& marcadorInicial, int& monedasInicial)
// Parámetros: 
// 		marcadorInicial: variable de salida que extrae del TXT
//		monedasInicial: variable de salida que extrae del TXT
// Devuelve: no devuelve ningún valor
{
	string parametro;
	ifstream leerConfig;
	
	leerConfig.open("configP1.txt");
	if (leerConfig.is_open()) // El archivo se encuentra
	{
		leerConfig >> parametro >> marcadorInicial >> parametro >> monedasInicial; // Guarda los parámetros de conf.
				
		leerConfig.close();
	}
	else // El archivo no se encuentra
	{
		marcadorInicial = 2;
		monedasInicial = 3;
		cout << "----------------------------------------------------" << endl;
		cout << "ERROR!!! No se ha podido cargar el archivo de cofiguracion <configP1.txt>" << endl;
		cout << "Se estableceran los valores por defecto" << endl;
	}
}

int menu()
// Parámetros: no tiene
// Devuelve: la opción del menú elegida por el usuario
{
	int menuSeleccion;
	
	cout << "----------------------------------------------------" << endl;
	cout << "1 - Cambiar el marcador" << endl;
	cout << "2 - Cambiar el numero de monedas" << endl;
	cout << "3 - Acerca del juego de los chinos" << endl;
	cout << "4 - Jugar una partida" << endl;
	cout << "5 - Jugar una partida automatica" << endl;
	cout << "0 - Salir" << endl;
	cout << "----------------------------------------------------" << endl;
	
	do
	{
		cout << "Introduce una opcion, de 0 a 5... ";
		cin >> menuSeleccion;
		if (menuSeleccion < 0 || menuSeleccion > 5)
		{
			cout << "Debes escoger una opcion valida <0 a 5>" << endl;
		}
	} while (menuSeleccion < 0 || menuSeleccion > 5); // La introducción de datos sigue apareciendo hasta que el usuario introduce un valor válido
	
	return menuSeleccion;
}

int pedirMarcador()
// Parámetros: no tiene
// Devuelve: el marcador que indica cuando acaba la partida
{
	int marcador;
	
	cout << "Introduce un valor para el marcador: "; 
	do
	{
		cin >> marcador;
		if (marcador <= 0)
		{
			cout << "Valor incorrecto para el marcador. Prueba otra vez... ";
		}
	} while (marcador <= 0);
	cout << "[OK. Marcador de " << marcador << " rondas ganadas]" << endl;
	
	return marcador;
}

int pedirMonedas()
// Parámetros: no tiene
// Devuelve: el número de monedas disponibles que tiene cada jugador
{
	int numMonedas;
	
	cout << "Introduce el numero de monedas disponibles para cada jugador: "; 
	do
	{
		cin >> numMonedas;
		if (numMonedas <= 0)
		{
			cout << "Valor incorrecto para el numero de monedas. Prueba otra vez... ";
		}
	} while (numMonedas <= 0);
	cout << "[OK. Cada jugador tendra " << numMonedas << " monedas disponibles]" << endl;
	
	return numMonedas;	
}

bool mostrarReglas()
// Parámetros: no tiene
// Devuelve: devuelve un valor booleano 'true' o 'false'
{
	string reglas; // Guarda las cadenas de carácteres del archivo
	string centinela = "XXX";
	ifstream leerArchivo;
	
	leerArchivo.open("reglas.txt");
	if (leerArchivo.is_open()) // El archivo se encuentra
	{
		getline(leerArchivo, reglas);
		while (reglas != centinela)
		{
			cout << reglas << endl;
			getline(leerArchivo, reglas);
		}
		leerArchivo.close();
		return true;
	}
	else
	{
		return false; // El archivo no se encuentra
	}
}

void juego(int marcador, int numMonedas) // Empieza la ejecución del juego, saca del exterior el valor del marcador y el número de monedas
// Parámetros: 
//		marcador: indica cuando acaba la partida
//		numMonedas: número de monedas disponibles que tiene cada jugador
// Devuelve: no devuelve ningún valor
{
	int numMonedasM, numMonedasH; // Monedas sacadas en cada ronda
	int eleccionM, eleccionH; // Apuestas en cada ronda
	int marcadorM = 0, marcadorH = 0; // Contadores de rondas ganadas (inicializadas en 0)
	int ganadorRonda; // Resultado de la ronda (NADIE = nadie gana; MAQUINA = gana la maquina; HUMANO = gana el humano)
	int contadorRonda = 0; // Nº de rondas echadas (comienza en 0)
	char pregunta = 'S'; // Respuesta de querer continuar al llegar a MAXRONDAS (inicializada en 'S' para evitar problemas con el bucle)
	const int MAXRONDAS = 2 * marcador; // Nº de rondas en el que se pregunta si se quiere continuar jugando
	
	do
	{	
		numMonedasH = monedasHumano(numMonedas); // pide las monedas al humano
		
		/* Empieza la parte donde la máquina genera su elección de monedas y apuesta (aleatoria) */
		
		srand(time(NULL)); // Iniciar con la hora actual el generador de números aleatorios
		numMonedasM = rand() % (numMonedas + 1); // Genera un valor aleatorio entre 0 y numMonedas

		eleccionM = numMonedasM + rand() % ((numMonedasM + numMonedas) + 1 - numMonedasM); /* La máquina hace su apuesta siguiendo las normas del juego,
																								no puede hacer una apuesta de menos monedas que las que sacó y
																								tampoco puede superar la suma de las monedas que sacó mas el 
																								número de monedas máximo del rival */
		
		cout << "MAQUINA: Creo que entre los dos tenemos un total de " << eleccionM << " monedas" << endl << endl;
		cout << "Ahora es momento de que introduzcas tu apuesta..." << endl; 
		
		eleccionH = apuestaHumano(eleccionM, numMonedasH, numMonedas); // Guarda en la variable el valor de la apuesta del humano
		
		cout << "La MAQUINA saco " << numMonedasM << " monedas" << endl;
		cout << "El HUMANO saco " << numMonedasH << " monedas" << endl << endl;
		
		ganadorRonda = quienGana(numMonedasM, numMonedasH, eleccionM, eleccionH); // Guarda en la variable 'ganadorRonda' el resultado de la ronda jugada
		if (ganadorRonda == maquina)
		{
			cout << "Gana la MAQUINA" << endl;
			cout << "-------------------------" << endl;
			marcadorM = marcadorM + 1; // Suma al marcador de la máquina una partida ganada
		}
		else if (ganadorRonda == humano)
		{
			cout << "Gana el HUMANO" << endl;
			cout << "-------------------------" << endl;
			marcadorH = marcadorH + 1;
		}
		else
		{
			cout << "No ha ganado nadie" << endl;
			cout << "-------------------------" << endl;
		}
		
		contadorRonda = contadorRonda + 1; // se añade una ronda al contador
		
		if (marcadorM == marcador)
		{
			cout << "El GANADOR de la partida ha sido la MAQUINA!!!" << endl;
			cout << "El HUMANO gano " << marcadorH << " partida(s)" << endl << endl;
		}
		else if (marcadorH == marcador)
		{
			cout << "El GANADOR de la partida ha sido el HUMANO!!!" << endl;
			cout << "La MAQUINA gano " << marcadorM << " partida(s)" << endl << endl;
		}
		else if (contadorRonda == MAXRONDAS) // cuando se alcanza al máximo de rondas
			{
				do{
					cout << "Se esta alargando la partida... Quieres continuar? <S/N>: ";
					cin >> pregunta;
					cout << "----------------------------------------------------------" << endl;
					if (pregunta == 'S' || pregunta == 's')
					{
						contadorRonda = 0; // si el jugador quiere continuar se reinicia el contador
					}
				} while ((pregunta != 's') && (pregunta != 'S') && (pregunta != 'n') && (pregunta != 'N')); // Control de teclado
			}
	
	} while (((marcadorM < marcador) && (marcadorH < marcador)) && (pregunta != 'n' && pregunta != 'N')); 
	/* Mientras ninguno de los marcadores haya alcanzado el límite y el humano no haya
	introducido <n> o <N> al haberle formulado la pregunta el juego se repite */
}

void partidaAutomatica(int numMonedas, int marcador)
// Parámetros: 
//		numMonedas: número de monedas disponibles que tiene cada jugador
//		marcador: indica cuando acaba la partida
// Devuelve: no devuelve ningún valor
{
	int maquina1, maquina2;
	int apuestaM1, apuestaM2;
	int marcadorM1 = 0, marcadorM2 = 0;
	
	do
	{
		srand(time(NULL)); // Iniciar con la hora actual el generador de números aleatorios
		maquina1 = rand() % (numMonedas + 1);
		maquina2 = rand() % (numMonedas + 1);
		apuestaM1 = maquina1 + rand() % ((maquina1 + numMonedas) + 1 - maquina1);
		
		/* Aquí la máquina 2 hace su apuesta con cierta inteligencia, es decir,
		intenta aproximar al máximo el intervalo en el que se encuentra el resultado
		ganador. Toma como referencia la apuesta hecha por la máquina 1 anteriormente */
		
		if (apuestaM1 < numMonedas)
		{
			apuestaM2 = maquina2 + rand() % ((apuestaM1 + maquina2) + 1 - maquina2);
		}
		else if (apuestaM1 >= numMonedas)
		{
			apuestaM2 = (apuestaM1 - numMonedas + maquina2) + rand() % ((maquina2 + numMonedas) + 1 - (apuestaM1 - numMonedas + maquina2));
		}
		
		cout << "MAQUINA 1: Yo saco " << maquina1 << " monedas" << endl;
		cout << "MAQUINA 2: Yo saco " << maquina2 << " monedas" << endl << endl;
		cout << "HABLA LA MAQUINA 1..." << endl << endl;
		cout << "Creo que entre los dos tenemos un total de " << apuestaM1 << " monedas" << endl << endl;
		if (apuestaM1 == (maquina1 + maquina2)) 
		{
			cout << "Gana la maquina 1" << endl;
			cout << "-------------------------" << endl;
			marcadorM1 = marcadorM1 + 1;
		}
		else // Si gana la máquina 1 no imprimimos la apuesta de la máquina 2
		{
			cout << "Ahora es turno de la maquina 2..." << endl;
			cout << "HABLA LA MAQUINA 2..." << endl << endl;
			cout << "Creo que entre los dos tenemos un total de " << apuestaM2 << " monedas" << endl << endl;
			if (apuestaM2 == (maquina1 + maquina2))
			{
				cout << "Gana la maquina 2" << endl;
				cout << "-------------------------" << endl;
				marcadorM2 = marcadorM2 + 1;
			}
			else
			{
				cout << "No ha ganado nadie" << endl;
				cout << "-------------------------" << endl;
			}
		}
		
		system("PAUSE");
	} while ((marcadorM1 < marcador) && (marcadorM2 < marcador)); /* Mientras ninguno de los marcadores haya alcanzado 
																	el límite de partidas ganadas el juego se repite */	
	if (marcadorM1 == marcador)
	{
		cout << "El GANADOR de la partida ha sido la MAQUINA 1!!!" << endl;
		cout << "La MAQUINA 2 gano " << marcadorM2 << " partida(s)" << endl << endl;
	}
	else // No definimos condición porque necesariamente tiene que haber un ganador (si no es uno es otro) ya que las rondas se repiten hasta que lo haya
	{
		cout << "El GANADOR de la partida ha sido la MAQUINA 2!!!" << endl;
		cout << "La MAQUINA 1 gano " << marcadorM1 << " partida(s)" << endl << endl;
	}
}

int monedasHumano(int numMonedas)
// Parámetros:
//		numMonedas: el número de monedas disponibles que tiene cada jugador
// Devuelve: número de monedas que saca el humano
{
	int numMonedasH;
	do
	{
		cout << "Decide el numero de monedas que quieres sacar <0 a " << numMonedas << " monedas>: " << endl;
		cin >> numMonedasH;
		if (numMonedasH > numMonedas || numMonedasH < 0)
		{
			cout << "El valor introducido no es valido. Debes introducir un valor entre <0 y " << numMonedas << " monedas>" << endl;
		}
	} while (numMonedasH > numMonedas || numMonedasH < 0); // Repite la introducción de datos hasta que sea valida
	return numMonedasH;
}

int apuestaHumano(int eleccionM, int numMonedasH, int numMonedas)
// Parámetros:
//		eleccionM: la apuesta de la máquina
//		numMonedasH: el número de monedas que ha sacado el humano
//		numMonedas: el número de monedas disponibles que tiene cada jugador
// Devuelve: la apuesta que realiza el humano
{
	int eleccionH;
	
	do{
		cout << "Introduce tu apuesta <valor comprendido entre 0 y " << numMonedas * 2 << ">: " << endl;
		cin >> eleccionH;
		if (eleccionH == eleccionM) // Casos que no siguen las normas
		{
			cout << "No puedes repetir la apuesta de la MAQUINA. Prueba de nuevo..." << endl;
		}
		else if (eleccionH < numMonedasH || eleccionH > (numMonedasH + numMonedas)) // Casos que no siguen las normas
		{
			cout << "Debes seguir las normas, no mientas. Prueba de nuevo..." << endl;
		}
	} while (eleccionH < numMonedasH || eleccionH > (numMonedasH + numMonedas) || eleccionH == eleccionM); /* Repite la introducción de datos hasta 
																												que sea valida */
	return eleccionH;
}

int quienGana (int numMonedasM, int numMonedasH, int eleccionM, int eleccionH)
// Parámetros:
//		numMonedasM: monedas sacadas por la máquina
//		numMonedasH: monedas sacadas por el humano
// 		eleccionM: apuesta de la máquina
// 		eleccionH: apuesta del humano
// Devuelve: MAQUINA si gana la máquina; HUMANO si gana el humano; NADIE si nadie ha acertado. 	
{
	if (eleccionM == (numMonedasM + numMonedasH))
		return maquina;
	else if (eleccionH == (numMonedasH + numMonedasM))
		return humano;
	else 
		return nadie;
}
marcadorGanadas= 2
monedasXjugador= 3
ACERCA DEL JUEGO DE LOS CHINOS

Los chinos o chinchimonito es un juego de azar que consiste en intentar adivinar el numero total de monedas que varios jugadores (al menos dos) guardan en su mano cerrada.
Se utilizan tres monedas por jugador y se pueden sacar 0, 1, 2 o 3 monedas.
El juego se usa tipicamente como formula de echar a suertes para decidir quien paga la consumicion en un bar o cosas por el estilo.
XXX

(lo que hay aqui el programa no lo lee
el centinela es XXX)

Para probar el juego solo te faltaría compilarlo. Yo por ejemplo te recomiendo que utilices MinGW. También te recomiendo que te leas el manual de C++ que tengo publicado en el apartado de apuntes. Son los mismos que utilizamos nosotros para seguir la asignatura y seguro que te vienen muy bien para iniciarte en el mundo de la programación.

Aquí te dejo algunas capturas de como se vería la ejecución del juego:


Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.