Cpp/Juego de las 7 y Media/7yMedia.cpp

//Juego de las 7 y media
//Fernando M<>ndez

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

//Constantes:
const int PERSONA = 1; //Constante global, representa al JUGADOR.
const int MAQUINA = 2; //Constante global, representa a la MAQUINA.
const int limiteInf = 3; //Constante glogal. L<>mite inferior de cartas que se pueden sacar en los modos "A" y "B".
const int limiteSup = 5; //Constante glogal. L<>mite superior de cartas que se pueden sacar en los modos "A" y "B".
const int TIPOCARTAS = 8; //Constante glogal. Representa el tipo de cartas que hay en la baraja espa<70>ola (figuras y del 1 al 7).
const int MAXCARTAS = 40; //Constante global. Representa el n<>mero total de cartas que contiena la baraja espa<70>ola.
const int MAX_BARRAS = MAXCARTAS * 2 + 18; //IMPORTANTE: esta constante sirve s<>lo para decorar los resultados extra que se muestran al activar el modo depurar. No es necesaria, se puede eliminar y no afecta a la correcta ejecuci<63>n del juego.
const bool DEPURAR = false; //Constante global booleana. Si es "TRUE" el modo depuraci<63>n estar<61> activado (en este caso, toda la informaci<63>n extra, apararecer<65> entre guiones). Si es "FALSE", el modo depuraci<63>n estar<61> desactivado.

//Tipos:
typedef int tCartas;
typedef tCartas tCartasPorAparecer[TIPOCARTAS];

typedef int tBaraja[MAXCARTAS];
typedef struct {
	tBaraja mazo;
	int contador;
} tConjuntoCartas;

//Funciones:
void version1(char op); //Permite jugar a los modos de juego "A" y "B".
void version2(); //Permite jugar al modo de juego "C".
void version3(int& numPartidas); //Permite jugar al modo de juego "D".

double modoA(ifstream& mazo, int numCartas); //Permite a cualquiera de los dos jugadores realizar su turno en el modo de juego A.
double modoB(ifstream& mazo, int numCartas, int turno, double puntosContrario); //Permite jugar al jugador del turno (Persona o Maquina) en el modo B.
double modoC(ifstream& mazo, tCartasPorAparecer cartas, int turno, double puntosContrario); //Permite<74>jugar<61>al<61>jugador<6F>del<65>turno<6E>(Persona<6E>o<EFBFBD>Maquina)<29>en<65>el<65> modo<64>C.
double modoD(tConjuntoCartas& mazo, tCartasPorAparecer cartas, int turno, double puntosContrario, tConjuntoCartas& cartasJugador); //Permite jugar al jugador del<65>turno<6E>en<65>el<65>modo<64>D.

int determinaGanador(double puntosJugador, double puntosMaquina); //Recibe los<6F>puntos<6F>obtenidos<6F>por<6F>el<65>jugador<6F>humano<6E>y<EFBFBD>por<6F>la<6C>m<EFBFBD>quina,<2C>y<EFBFBD>devuelve<76>un<75>valor<6F>que<75>indica<63>qui<75>n<EFBFBD>gana<6E>(utiliza<7A>las<61>constantes<65>Hombre,<2C>Maquina).
int determinaGanador(double puntosJugador, double puntosMaquina, const tConjuntoCartas& cartasJugador, const tConjuntoCartas& cartasMaquina); //Recibe<62>los<6F>puntos<6F>obtenidos<6F>por<6F>el<65>jugador<6F>humano<6E>y<EFBFBD>por<6F>la<6C>m<EFBFBD>quina, as<61> como las cartas sacadas por ambos.<2E>Y<EFBFBD>devuelve<76>un<75>valor<6F>que<75>indica<63>qui<75>n<EFBFBD>gana<6E>(utiliza<7A>las<61>constantes<65>Hombre,<2C>Maquina).
bool abrirArchivo(ifstream & mazo); //Pide el nombre del archivo donde est<73> el mazo de cartas y si se puede abrir devuelve el mazo y true, y en otro caso false.
int menu(); //Muestra el men<65> del programa con las opciones posibles. Devuelve la opci<63>n elegida por el usuario.
void ejecutarMenu(); //Ejecuta la opci<63>n del men<65> que ha elegido el usuario en la funcion menu().
int generarAleatorio(); //Genera un n<>mero aleatorio entre un l<>mite inferior y un l<>mite superior.

bool esProbablePasarse(double puntosMaquina, const tCartasPorAparecer cartas); //Determina<6E>si<73>la<6C>probabilidad<61>que<75>tiene<6E>la<6C>m<EFBFBD>quina<6E>de<64>pasarse si<73>robara<72>una<6E>carta<74>m<EFBFBD>s<EFBFBD>es<65>mayor<6F>que<75>0,5.
int sacarCarta(ifstream& mazo, double& puntos); //Extrae una carta del mazo.
void restarCarta(tCartasPorAparecer cartas, const int carta); //Elimina del array la carta que acaba de salir.
void inicializa(tCartasPorAparecer& cartas); //Inicializa el array con los n<>meros correspondientes a una baraja de cartas espa<70>ola.

void iniciar(tConjuntoCartas& cartas); //Inicializa<7A>cartas<61>a<EFBFBD>la<6C>lista<74>vac<61>a.
void sacar(tConjuntoCartas& cartas, int& carta); //Elimina<6E>la<6C><61>ltima<6D>carta<74>de la<6C>lista<74>cartas (pop_back) y<>la<6C>devuelve<76>en<65>carta.
void incluir(tConjuntoCartas& cartas, int carta); //A<>ade<64>una<6E>carta<74>al final<61>de<64>la<6C>lista<74>cartas<61>(push_back).
void crearMazo(tConjuntoCartas& mazo); //Rellena mazo con<6F>40<34>cartas<61>dispuestas<61>de<64>forma<6D>aleatoria.
void barajar(tConjuntoCartas& mazo); //Mezcla la baraja de forma aleatoria;
void sumarPuntos(double&puntos, int carta); //Suma los puntos correspondientes a la carta extraida.
bool cargarMazo(tConjuntoCartas& mazo); //Carga un mazo de cartas.
void guardarResultado(int& numPartidas, int ganador, double& puntosJugador, double& puntosMaquina, tConjuntoCartas& cartasJugador, tConjuntoCartas& cartasMaquina); //Guarda el resultado de la partida actual.
void depurar(tConjuntoCartas& mazo, const int turno, tConjuntoCartas& cartasJugador); //Muestra la baraja de cartas cargada desde un archivo de texto y las cartas extraidas por el jugador o por la m<>quina, en cada caso.


int main() {
	if (DEPURAR == false) { srand(time(nullptr)); }
	else { srand(1); }

	ejecutarMenu();

	return 0;
}

int menu() {
	//Par<61>metros: no tiene.
	//Devuelve: la opci<63>n del men<65> elegida por el usuario.

	int opc = 1;

	cout << "<--------------Menu-------------->" << endl;
	cout << " 1-Jugar MODO A." << endl;
	cout << " 2-JUGAR MODO B." << endl;
	cout << " 3-JUGAR MODO C." << endl;
	cout << " 4-JUGAR MODO D." << endl;
	cout << " 0-Salir" << endl;
	cout << "<-------------------------------->" << endl;
	cout << endl;

	cout << "Seleccione una opcion del menu: ";
	cin >> opc;
	while (opc < 0 || opc > 4) {
		cout << "Seleccione una opcion del menu (entre 0 y 4): ";
		cin >> opc;
	}

	return opc;
}

void ejecutarMenu() {
	//Par<61>metros: no tiene.

	int opcion = 1; //Entero que representa la opci<63>n escogida por el jugador.
	int numPartidas = 0; //Entero que representa el n<>mero de partidas jugadas al modo D, desde que se inicia el programa.

	system("cls");
	while (opcion != 0) {
		opcion = menu();
		switch (opcion) {
		case 1: version1(opcion); break;
		case 2: version1(opcion); break;
		case 3: version2(); break;
		case 4: version3(numPartidas); break;
		case 0: break;
		}
	}
}

bool abrirArchivo(ifstream& mazo) {
	bool carga = true; //Variable booleana que indica si el archivo ha cargado correctamente.
	string archivo; //Archivo a cargar. Se iguala al nombre del archivo, con extensi<73>n, introducido por el usuario.

	cout << "Introduzca el nombre del fichero: ";
	cin >> archivo;
	cout << endl;

	mazo.open(archivo);
	if (!mazo.is_open()) {
		cout << "No se ha encontrado el archivo." << endl;
		carga = false;
	}
	else {
		carga = true;
	}

	//mazo.close();

	return carga; //Devuelve true en caso de carga correcta del archivo, false en caso contrario.
}

void version1(char op) {
	ifstream mazo; //Archivo que carga el mazo.
	bool carga = abrirArchivo(mazo); //Variable booleana que se iguala a la funci<63>n arbrirArchivo(). Ser<65> true en caso de que el mazo se haya cargado, false en caso contrario.
	int numCartas = generarAleatorio(); //N<>mero de cartas que puede robar el jugador en esa ronda, se genera de forma aleatoria.
	int ganador = 0; //Variable entera que determina el ganador de la partida.

	double puntosJugador = 0; //Puntos del jugador.
	double puntosMaquina = 0; //Puntos de la m<>quina.
	int turno = 0; //Variable entera, determina si el turno es del JUGADOR o de la M<>QUINA. (MODO B).


	if (carga == true) {

		cout << "Numero de cartas: " << numCartas << endl;

		cout << "--------------" << endl;
		cout << "TURNO JUGADOR" << endl;
		cout << "--------------" << endl;

		if (op == 1) {
			puntosJugador = modoA(mazo, numCartas);
			cout << "Puntos Jugador: " << puntosJugador << endl << endl;
		}

		if (op == 2) {
			turno = PERSONA;
			puntosJugador = modoB(mazo, numCartas, turno, puntosJugador);
			cout << "Puntos Jugador: " << puntosJugador << endl << endl;
		}

		if (puntosJugador <= 7.5) {
			cout << "--------------" << endl;
			cout << "TURNO MAQUINA" << endl;
			cout << "--------------" << endl;

			if (op == 1) {
				puntosMaquina = modoA(mazo, numCartas);
			}
			if (op == 2) {
				turno = MAQUINA;
				puntosMaquina = modoB(mazo, numCartas, turno, puntosJugador);
			}

			cout << "Puntos Maquina: " << puntosMaquina << endl << endl;
		}

		ganador = determinaGanador(puntosJugador, puntosMaquina);
		if (ganador == 1) {
			cout << "GANA JUGADOR" << endl << endl;
		}
		else {
			cout << "GANA MAQUINA" << endl << endl;
		}
	}

	mazo.close();
	system("pause");
	system("cls");
}

void version2() {
	tCartasPorAparecer cartas;
	ifstream mazo; //Archivo que carga el mazo.
	bool carga = abrirArchivo(mazo); //Variable booleana que se iguala a la funci<63>n arbrirArchivo(). Ser<65> true en caso de que el mazo se haya cargado, false en caso contrario.

	double puntosJugador = 0; //Puntos del jugador.
	double puntosMaquina = 0; //Puntos de la m<>quina.
	int turno = 0; //Variable entera, determina si el turno es del JUGADOR o de la M<>QUINA.
	int ganador = 0; //Variable entera que determina el ganador de la partida.

	inicializa(cartas); //Inicializa las cartas que quedan por aparecer.

	if (carga == true) {

		cout << "--------------" << endl;
		cout << "TURNO JUGADOR" << endl;
		cout << "--------------" << endl;

		turno = PERSONA;
		puntosJugador = modoC(mazo, cartas, turno, puntosJugador);
		cout << "Puntos Jugador: " << puntosJugador << endl << endl;

		if (puntosJugador <= 7.5) {
			cout << "--------------" << endl;
			cout << "TURNO MAQUINA" << endl;
			cout << "--------------" << endl;

			turno = MAQUINA;
			puntosMaquina = modoC(mazo, cartas, turno, puntosJugador);
			cout << "Puntos Maquina: " << puntosMaquina << endl << endl;
		}

		ganador = determinaGanador(puntosJugador, puntosMaquina);
		if (ganador == 1) {
			cout << "GANA JUGADOR" << endl << endl;
		}
		else {
			cout << "GANA MAQUINA" << endl << endl;
		}
	}

	mazo.close();
	system("pause");
	system("cls");
}

void version3(int& numPartidas) {
	tCartasPorAparecer cartas;
	tConjuntoCartas mazo;
	tConjuntoCartas cartasJugador;
	tConjuntoCartas cartasMaquina;

	double puntosJugador = 0; //Puntos del jugador.
	double puntosMaquina = 0; //Puntos de la m<>quina.
	int turno = 0; //Variable entera, determina si el turno es del JUGADOR o de la M<>QUINA.
	int ganador = 0; //Variable entera que determina el ganador de la partida.
	bool carga = false; //Variable booleana que ser<65> "true" si el mazo ha cargado correctamente, false en caso contrario.


	inicializa(cartas); //Inicializa las cartas que quedan por aparecer.
	iniciar(mazo); iniciar(cartasJugador); iniciar(cartasMaquina); //Inicializa a "0" todos los arrays de cartas.

	if (DEPURAR == false) {
		crearMazo(mazo); //Crea un mazo de cartas de la baraja espa<70>ola.
		barajar(mazo);	//Mezcla de forma aleatoria el mazo anteriormente creado.
	}
	else {
		carga = cargarMazo(mazo); //Carga un mazo de cartas desde un archivo de texto.
		if (carga == true) {
			depurar(mazo, turno, cartasJugador); //Muestra la baraja de cartas cargada desde un archivo de texto.
		}
	}

	if (((!DEPURAR) && (!carga)) || ((DEPURAR) && (carga))) {
		cout << "--------------" << endl;
		cout << "TURNO JUGADOR" << endl;
		cout << "--------------" << endl;

		turno = PERSONA;
		puntosJugador = modoD(mazo, cartas, turno, puntosJugador, cartasJugador);
		cout << "Puntos Jugador: " << puntosJugador << endl << endl;

		if (puntosJugador <= 7.5) {
			cout << "--------------" << endl;
			cout << "TURNO MAQUINA" << endl;
			cout << "--------------" << endl;

			turno = MAQUINA;
			puntosMaquina = modoD(mazo, cartas, turno, puntosJugador, cartasMaquina);
			cout << "Puntos Maquina: " << puntosMaquina << endl << endl;
		}

		ganador = determinaGanador(puntosJugador, puntosMaquina, cartasJugador, cartasMaquina);
		if (ganador == 1) {
			cout << "GANA JUGADOR" << endl << endl;
		}
		else {
			cout << "GANA MAQUINA" << endl << endl;
		}
		numPartidas++;
		guardarResultado(numPartidas, ganador, puntosJugador, puntosMaquina, cartasJugador, cartasMaquina); //Guarda el resultado de la partida en un archivo de texto.
	}

	system("pause");
	system("cls");
}

double modoA(ifstream &mazo, int numCartas) {
	double puntos = 0; //Variable que representa los puntos que suman actualmente las cartas.
	int carta; //Variable entera que se igualar<61> a la siguiente carta del mazo.

	int i = 0;
	while (i < numCartas && puntos < 7.5) {
		mazo >> carta;

		if ((carta != 10) && (carta != 11) && (carta != 12)) {
			puntos += carta;
		}
		else {
			puntos += 0.5;
		}
		cout << "Carta: " << carta << setw(20) << setfill(char(0)) << "Puntos: " << puntos << endl;

		i++;
	}

	return puntos; //Devuelve los<6F>puntos<6F>obtenidos<6F>tras<61>robar<61>ese n<>mero<72>de<64>cartas,<2C>obtener<65>7,5<>o<EFBFBD>pasarse.<2E> 
}

double modoB(ifstream & mazo, int numCartas, int turno, double puntosContrario) {
	double puntos = 0; //Variable que representa los puntos que suman actualmente las cartas.
	int carta; //Variable entera que se igualar<61> a la siguiente carta del mazo.
	char continuar = 'y'; //Variable de tipo car<61>cter. Si se iguala a "Y/y", el JUGADOR seguir<69> robando carta. Si se iguala a "N/n", no seguir<69> robando. (MODO B).
	int i = 0;

	while (((continuar == 'y') || (continuar == 'Y')) && (i < numCartas)) {
		if (((turno == MAQUINA) && (puntos <= puntosContrario)) || ((turno == PERSONA) && (puntos < 7.5))) {
			mazo >> carta;

			if ((carta != 10) && (carta != 11) && (carta != 12)) {
				puntos += carta;
			}
			else {
				puntos += 0.5;
			}

			cout << "Carta: " << carta << setw(20) << setfill(char(0)) << "Puntos: " << puntos << endl;

			if ((turno == PERSONA) && (i < numCartas - 1) && (puntos < 7.5)) {
				cout << "Quiere continuar robando (Y/N): ";
				cin >> continuar;
			}
		}
		i++;
	}

	return puntos; //Devuelve<76>los<6F>puntos<6F>obtenidos<6F>tras<61>robar<61>numCartas,<2C>obtener<65>7,5,<2C>pasarse<73>o<EFBFBD>plantarse.<2E> 
}

double modoC(ifstream& mazo, tCartasPorAparecer cartas, int turno, double puntosContrario) {
	double puntos = 0; //Variable que representa los puntos que suman actualmente las cartas.
	int carta = 0; //Variable entera que se igualar<61> a la siguiente carta del mazo.
	char continuar = 'y'; //Variable de tipo car<61>cter. Si se iguala a "Y/y", el JUGADOR seguir<69> robando carta. Si se iguala a "N/n", no seguir<69> robando.
	bool probabilidadPasarse = false; //Variable booleana que se iguala a la funci<63>n "esProbablePasarse()" para determinar si la m<>quina roba o no otra carta.


	do {
		if ((turno == PERSONA) || ((turno == MAQUINA) && (puntos <= puntosContrario))) {
			carta = sacarCarta(mazo, puntos); //Saca la siguiente carta del archivo que contiene el mazo.
			restarCarta(cartas, carta); //Resta la carta de la lista de cartas restantes.

			if ((turno == MAQUINA) && (puntos == puntosContrario)) {
				probabilidadPasarse = esProbablePasarse(puntos, cartas); //Calcula la probabilidad que tiene la MAQUINA de pasarse si contin<69>a sandao cartas (devuelve true si es mayor del 50%).
			}
			else {
				if ((turno == MAQUINA) && (puntos > puntosContrario)) {
					probabilidadPasarse = true;
				}
			}
		}

		cout << "Carta: " << carta << setw(20) << setfill(char(0)) << "Puntos: " << puntos << endl;

		if ((turno == PERSONA) && (puntos < 7.5)) {
			cout << "Quiere continuar robando (Y/N): ";
			cin >> continuar;
		}
	} while (((continuar == 'y') || (continuar == 'Y')) && ((puntos < 7.5) && (probabilidadPasarse != true)));

	return puntos; //Devuelve los<6F>puntos<6F>obtenidos<6F>y<EFBFBD>actualiza<7A>cartas<61>de<64>acuerdo<64>con<6F>las<61>cartas<61>que<75>haya<79>robado<64>el jugador.<2E>
}

double modoD(tConjuntoCartas& mazo, tCartasPorAparecer cartas, int turno, double puntosContrario, tConjuntoCartas& cartasJugador) {
	double puntos = 0; //Variable que representa los puntos que suman actualmente las cartas.
	int carta = 0; //Variable entera que se igualar<61> a la siguiente carta del mazo.
	char continuar = 'y'; //Variable de tipo car<61>cter. Si se iguala a "Y/y", el JUGADOR seguir<69> robando carta. Si se iguala a "N/n", no seguir<69> robando.
	bool probabilidadPasarse = false; //Variable booleana que se iguala a la funci<63>n "esProbablePasarse()" para determinar si la m<>quina roba o no otra carta.


	do {
		if ((turno == PERSONA) || ((turno == MAQUINA) && (puntos <= puntosContrario))) {
			sacar(mazo, carta); //Extrae la siguiente carta del mazo.
			sumarPuntos(puntos, carta); //Suma los puntos de la carta extraida.
			incluir(cartasJugador, carta); //Incluye la carta sacada en el array correspondiente.
			restarCarta(cartas, carta); //Resta la carta de la lista de cartas restantes.

			if ((turno == MAQUINA) && (puntos == puntosContrario)) {
				probabilidadPasarse = esProbablePasarse(puntos, cartas); //Calcula la probabilidad que tiene la MAQUINA de pasarse si contin<69>a sandao cartas (devuelve true si es mayor del 50%).
			}
			else {
				if ((turno == MAQUINA) && (puntos > puntosContrario)) {
					probabilidadPasarse = true;
				}
			}
		}

		cout << "Carta: " << carta << setw(20) << setfill(char(0)) << "Puntos: " << puntos << endl;

		if (DEPURAR == true) {
			depurar(mazo, turno, cartasJugador);
		}

		if ((turno == PERSONA) && (puntos < 7.5)) {
			cout << "Quiere continuar robando (Y/N): ";
			cin >> continuar;
		}

	} while (((continuar == 'y') || (continuar == 'Y')) && ((puntos < 7.5) && (probabilidadPasarse != true)));

	return puntos; //Devuelve los<6F>puntos<6F>obtenidos<6F>y<EFBFBD>actualiza<7A>cartas<61>de<64>acuerdo<64>con<6F>las<61>cartas<61>que<75>haya<79>robado<64>el jugador.
}

int determinaGanador(double puntosJugador, double puntosMaquina) {
	int ganador = 0; //Variable entera que tomar<61> el valor del ganador.

	if ((puntosJugador == puntosMaquina)) {
		ganador = PERSONA + rand() % (MAQUINA);
	}
	else {
		if ((puntosMaquina > puntosJugador) && (puntosMaquina <= 7.5)) {
			ganador = MAQUINA;
		}
		else {
			if (puntosJugador > 7.5) {
				ganador = MAQUINA;
			}
			else {
				ganador = PERSONA;
			}
		}
	}

	return ganador; //Devuelve 1 en caso de que gane el Jugador, 2 en caso de que gane la m<>quina.
}

int determinaGanador(double puntosJugador, double puntosMaquina, const tConjuntoCartas& cartasJugador, const tConjuntoCartas& cartasMaquina) {
	int ganador = 0; //Variable entera que tomar<61> el valor del ganador.

	if ((puntosJugador == puntosMaquina) && (cartasJugador.contador != cartasMaquina.contador)) {
		if (cartasJugador.contador > cartasMaquina.contador) {
			ganador = PERSONA;
		}
		if (cartasJugador.contador < cartasMaquina.contador) {
			ganador = MAQUINA;
		}
	}
	else {
		ganador = determinaGanador(puntosJugador, puntosMaquina);
	}

	return ganador; //Devuelve 1 en caso de que gane el Jugador, 2 en caso de que gane la m<>quina.
}

int generarAleatorio() {

	int aleatorio = limiteInf + rand() % (limiteSup - limiteInf);

	return aleatorio; //Devuelve un n<>mero aleatorio entre el rango [3-5].
}

bool esProbablePasarse(double puntosMaquina, const tCartasPorAparecer cartas) {
	double probabilidad = 0; //Variable que almacena la probabilidad de pasarse.
	double cartasRestantes = 0; //Variable que almacena el n<>mero de cartas restantes en el mazo.
	int cartasAptas = 7.5 - puntosMaquina + 1; //Variable que almacena hasta qu<71> valor de carta podr<64>a robar la m<>quina sin pasarse.
	double cartasMayores = 0; //Variable que almacena el n<>mero de cartas que quedan con valores que har<61>an que al robarlas, la m<>quina se pasara.

	for (int i = 0; i < TIPOCARTAS; i++) {
		cartasRestantes += cartas[i];
		if (i >= cartasAptas) {
			cartasMayores += cartas[i];
		}
	}

	probabilidad = cartasMayores / cartasRestantes;

	return (probabilidad > 0.5) ? true : false; //Devuelve true si la probabilidad de pasarse es mayor que 0.5, false en caso contrario.
}

int sacarCarta(ifstream& mazo, double& puntos) {
	int carta = 0; //Variable entera que representa el valor de una carta.

	mazo >> carta;

	if ((carta != 10) && (carta != 11) && (carta != 12)) {
		puntos += carta;
	}
	else {
		puntos += 0.5;
	}

	return carta; //Devuelve la carta obtenida del mazo.
}

void restarCarta(tCartasPorAparecer cartas, const int carta) {

	if ((carta > 9) && (cartas[0] != 0)) {
		cartas[0] -= 1;
	}
	else {
		if (cartas[carta] != 0) {
			cartas[carta] -= 1;
		}
	}

}

void inicializa(tCartasPorAparecer& cartas) {

	cartas[0] = 12;
	for (int i = 1; i < TIPOCARTAS; i++) {
		cartas[i] = 4;
	}

}

void iniciar(tConjuntoCartas& cartas) {

	for (int i = 0; i < MAXCARTAS; i++){
		cartas.mazo[i] = 0;
	}
	cartas.contador = MAXCARTAS-1;

}

void sacar(tConjuntoCartas& cartas, int& carta) {
	carta = cartas.mazo[cartas.contador];	//Saca la siguiente carta.
	cartas.contador--;
}

void incluir(tConjuntoCartas& cartas, int carta) {
	cartas.mazo[cartas.contador] = carta;
	cartas.contador--;
}

void crearMazo(tConjuntoCartas& mazo) {
	int n = 1; //Variable entera que va representando en n<>mero de la carta que se va a<>adiendo a cada posici<63>n del array.

	int i = 0;
	while (i < MAXCARTAS) {
		if (n == 8) { n = 10; }	//Se salta los 8<>s y 9<>s, porque no existen en la baraja espa<70>ola.
		mazo.mazo[i] = n;
		mazo.mazo[i + 1] = n;
		mazo.mazo[i + 2] = n;
		mazo.mazo[i + 3] = n;
		n++;
		i = i + 4;
	}
	mazo.contador = MAXCARTAS - 1;
}

void barajar(tConjuntoCartas& mazo) {
	int indice1 = 0, indice2 = 0; //Variable entera que determina una posici<63>n de la baraja.
	int auxiliar = 0; //Variable entera auxiliar que servir<69> para no perder el contenido de diferentes posiciones del array.

	for (int i = 0; i < MAXCARTAS; i++) {
		indice1 = (rand() % MAXCARTAS); //Genera una posici<63>n aleatoria de la baraja.
		indice2 = (rand() % MAXCARTAS); //Genera otra posici<63>n aleatoria de la baraja.
		auxiliar = mazo.mazo[indice1]; //Guarda el contenido de la primera posici<63>n aleatoria en un auxiliar;
		mazo.mazo[indice1] = mazo.mazo[indice2]; //Mueve el contenido de la segunda posici<63>n del mazo generada aleatoriamente, a la primera posici<63>n generada aleatoriamente.
		mazo.mazo[indice2] = auxiliar; //Guarda lo que hab<61>a en la primera posici<63>n (ahora guardado en la variable auxiliar), en la segunda posici<63>n del mazo aleatoria.
	}
}

void sumarPuntos(double& puntos, int carta) {
	if ((carta != 10) && (carta != 11) && (carta != 12)) {
		puntos += carta;
	}
	else {
		puntos += 0.5;
	}
}

bool cargarMazo(tConjuntoCartas& mazo) {
	ifstream baraja; //Archivo que carga el mazo.
	bool carga = true; //Variable booleana que indica si el archivo ha cargado correctamente.
	string archivo; //Archivo a cargar. Se iguala al nombre del archivo, con extensi<73>n, introducido por el usuario.
	int auxiliar = 0; //Variable auxiliar que almacena temporalmente la carta que se va a incluir en la posici<63>n "i" del mazo.

	cout << "Introduzca el nombre del fichero: ";
	cin >> archivo;

	baraja.open(archivo);
	if (!baraja.is_open()) {
		cout << "No se ha encontrado el archivo." << endl;
		carga = false;
	}
	else {
		carga = true;
		for (int i = 0; i < MAXCARTAS; i++) {
			baraja >> mazo.mazo[i];
		}
		mazo.contador = MAXCARTAS - 1;
	}
	baraja.close();

	return carga; //Devuelve true en caso de carga correcta del archivo, false en caso contrario.
}

void guardarResultado(int& numPartidas, int ganador, double& puntosJugador, double& puntosMaquina, tConjuntoCartas& cartasJugador, tConjuntoCartas& cartasMaquina) {
	ofstream archivo; //Archivo que guarda el resultado.
	string nombreArchivo = "partida" + to_string(numPartidas) + ".txt"; //Nombre del archivo compuesto por "partida" + el n<>mero de la partida.
	string winner;	//Cadena de caracteres que representa al ganador de la partida.
	int auxiliar = 0; //Variable entera auxiliar.
	int i = MAXCARTAS - 1;

	archivo.open(nombreArchivo);
	if (!archivo.is_open()) {
		cout << "Error al guardar resultados." << endl;
	}
	else {
		archivo << "Numero de partida: " << numPartidas << endl;
		if (ganador == 1) {
			winner = "HUMANO";
		}
		else {
			winner = "MAQUINA";
		}
		archivo << "GANADOR: " << winner << endl;
		archivo << "Humano. Puntuaci<63>n: " << puntosJugador << endl;
		archivo << "Cartas: ";
		do {
			auxiliar = cartasJugador.mazo[i];
			archivo << auxiliar << ", ";
			i--;
		} while (i > cartasJugador.contador);
		archivo  << endl << "Maquina. Puntuaci<63>n: " << puntosMaquina << endl;
		archivo << "Cartas: ";
		i = MAXCARTAS - 1;
		do {
			auxiliar = cartasMaquina.mazo[i];
			archivo << auxiliar << ", ";
			i--;
		} while (i > cartasMaquina.contador);
	}

	archivo.close();
}

void depurar(tConjuntoCartas& mazo, const int turno, tConjuntoCartas& cartasJugador) {
	string turn; //Variable. Cadena de caracteres que representa en turno.

	switch(turno){
		case 1: turn = "JUGADOR"; break;
		case 2: turn = "MAQUINA"; break;
		default: turn = ""; break;
	}

	cout << "\n" << setw(MAX_BARRAS) << setfill(char(205)) << "\n" << "Mazo: ";
	for (int i = 0; i <= mazo.contador; i++) {
		cout << mazo.mazo[i] << char(0);
	}
	if (turno != 0) {
		cout << endl << "Cartas extraidas " << turn << ": ";
		for (int i = cartasJugador.contador + 1; i < MAXCARTAS; i++) {
			cout << cartasJugador.mazo[i] << char(0);
		}
	}
	cout << "\n" << setw(MAX_BARRAS) << setfill(char(205)) << "\n";

}