#include <iostream>
#include <stdio.h>
#include <math.h>
#include <conio.h>
#include <cstdlib>
#include <ctime>
#include<stdlib.h>
#include <string.h>
using namespace std;

struct jugador
{
	char nombre[20]; 
	char apellido [20]; 
	char cedula[12]; //Cada cédula es unica
	float monto; 
	int carton[5][5];//	Almacenamiento del cartón / Cada cartón es único
	int restan; // CONTADOR QUE SE ACTIVA UNA VEZ INICIADA UNA PARTIDA PARA AYUDAR AL JUGADOR EN SU CONTEO 
	int Record[2]; // SISTEMA DE RECORD DEL JUGADOR ALMACENA EL NUMERO DE VICTORIAS Y DERROTA DE CADA JUGADOR.
};

struct carton
{
	string letras[5];
	int numeros [5][5];
};

void inscripcion(struct jugador &j) //Procedimiento que permite el ingreso de los datos
{
	int aux;
	cout << "Introduzca su nombre: "<<endl;
	fflush(stdin);
	cin.getline(j.nombre, 20, '\n');
	
	cout << "Introduzca su apellido: "<<endl;
	fflush(stdin);
	cin.getline(j.apellido, 20, '\n');
	
	cout << "Introduzca su cedula: "<<endl;
	fflush(stdin);
	cin.getline(j.cedula, 12, '\n');
	cout << "Introduzca el monto que desea apostar: "<<endl;
	fflush(stdin);
	
	do{
		cin>>j.monto;
		if (j.monto<0)
		cout<<"Debe ingresar un numero positivo. "<<endl;
		else
		aux= 1;
		}
	while (aux== 0);
	j.Record[0] = 0;
	j.Record[1] = 0;
}

void verificar_cedula(struct jugador *j, int &num)// Procedimiento que verifica que el número de cédula no se repita
{
	for (int i = 0; i < num; i++) //Se recorre toda la estructura desde 0 hasta el número de participantes
	{
		if(!strcmp(j[num].cedula, j[i].cedula)) 
		{
			cout <<"Numero de cedula ya registrado. Intente de nuevo. "<<endl;
			num = num-1; // Se resta 1 al número de jugadores ya que ese jugador no pudo completar su registro
			break;
		}		
	}
	num = num+1; //Se suma para mantener el control 
}

/*void solicitar_cedula (struct jugador *j, char aux_cedula[], int num)
{

}
	 */

void llenar_carton (struct carton *arg_bingo, int &num)
{
srand((unsigned)time(0)); //Inicializar random
int numeroRandom, inicio, fin, rango;

	for(int i = 0; i < num; i++) // llena las letras de BINGO
	{
		arg_bingo[i].letras[0] = "B";
		arg_bingo[i].letras[1] = "I";
		arg_bingo[i].letras[2] = "N";
		arg_bingo[i].letras[3] = "G";
		arg_bingo[i].letras[4] = "O";
	}

	for(int i = 0; i < num; i++) // llena los números del BINGO
	{
	inicio = 1, fin=15;
	rango = (fin-inicio) + 1;
		for(int j=0;j<5;j++) // llena la columna B ([0] de los cartones del bingo) 
		{
			numeroRandom = inicio +
			int(rango * rand() / (RAND_MAX + 1.0));
			arg_bingo[i].numeros[0][j]=numeroRandom;
		}

	inicio = 16, fin=30;
	rango = (fin-inicio) + 1;
		for(int j = 0; j < 5; j++) // llena la columna I ([1] de los cartones del bingo)
		{
			numeroRandom = inicio +
			int(rango * rand() / (RAND_MAX + 1.0));
			arg_bingo[i].numeros[1][j]=numeroRandom;
		}

	inicio = 31, fin = 45;
	rango = (fin-inicio) + 1;
		for(int j = 0; j < 5; j++) // llena la columna N ([2] de los cartones del bingo)
		{
			numeroRandom = inicio +
			int(rango * rand() / (RAND_MAX + 1.0));
			arg_bingo[i].numeros[2][j]=numeroRandom;
		}

	inicio = 46, fin=60;
	rango = (fin-inicio) + 1;
		for(int j = 0; j < 5; j++) // llena la columna G ([3] de los cartones del bingo)
		{
			numeroRandom = inicio +
			int(rango * rand() / (RAND_MAX + 1.0));
			arg_bingo[i].numeros[3][j]=numeroRandom;
		}

	inicio = 61, fin=75;
	rango = (fin-inicio) + 1;
		for(int j=0;j<5;j++) // llena la columna O ([4] de los cartones del bingo)
		{
			numeroRandom = inicio +
			int(rango * rand() / (RAND_MAX + 1.0));
		arg_bingo[i].numeros[4][j]=numeroRandom;
		}
	}
}

void imprimir_carton (struct carton *arg_bingo, int num) //Procedimiento que imprime los cartones de bingo
{
	for(int i = 0; i < num;i++) 
	{
		cout<<"CARTON DEL JUGADOR # "<<i+1<<endl;
		cout<<arg_bingo[i].letras[0]<<"\t";
		cout<<arg_bingo[i].letras[1]<<"\t";	
		cout<<arg_bingo[i].letras[2]<<"\t";
		cout<<arg_bingo[i].letras[3]<<"\t";
		cout<<arg_bingo[i].letras[4]<<"\t";
		cout<<endl;
		for(int k=0;k<5;k++) 
		{
			cout<<arg_bingo[i].numeros[0][k]<<"\t";
			cout<<arg_bingo[i].numeros[1][k]<<"\t";
			cout<<arg_bingo[i].numeros[2][k]<<"\t";
			cout<<arg_bingo[i].numeros[3][k]<<"\t";
			cout<<arg_bingo[i].numeros[4][k]<<"\t"<<endl;
		}
		cout<<endl;
		}
	cout<<endl<<endl;
}
int main()
{
	struct jugador j[3];
	struct carton bingo[3];
	char aux_cedula[12];
	int ind [2];
	int opcion;
	int num = 0;
	cout<<"********BINGO CASINO UNE********"<<endl;
	do
	{
		cout<<"********MENU PRINCIPAL********"<<endl;
		cout<<"1. Inscripcion. "<<endl;
		cout<<"2. Jugar. "<<endl;
		cout<< "3. Record. "<<endl;
		cout<< "4. Salir. "<<endl;
		cout<< "Introduzca opcion (1-4): ";
		cin>> opcion;
		
		//Inicio del anidamiento
		switch (opcion)
		{
			case 1: //Inscripcion de jugadores
			if (num < 3) 
			{
				inscripcion(j[num]);
				verificar_cedula(j,num);
				system ("pause");
				system("cls"); //Limpia la pantalla
			}
			else
			{
				cout<<"Limite de participantes ALCANZADO. "<<endl;	
			}
			break;
			
			case 2: //Juego
			if(num < 2)// Deben estar registrados al menos dos jugadores
				{
					if(num == 0)
						{
							cout << "No hay jugadores registrados.Para JUGAR necesita 2 jugadores minimo."<<endl;
							system ("pause");
							system ("cls");
						}
					else
						{
							cout <<"Para JUGAR necesita 2 jugadores minimo." << endl;
							system ("pause");
							system ("cls");
						}
				}
				
			else //Si esta la cantidad necesaria para poder jugar
				{
					solicitar_cedula (j, aux_cedula, num);
				//	llenar_carton (bingo, num);
				//	imprimir_carton (bingo, num);
				}
			}
		
	}
	while (opcion!=4); //No hay opcion 4 sino que el programa se cierra cuando el usuario coloca "4"
	return 0;
}

Estructura DatosJugador
        Nombre 
	Apellido 
	Cedula  //Cada cédula es unica. OK: pero un jugador puede comprar más de un cartón, verdad?... entonces esto no importa.
	Monto  //Esto es para pagar el cartón??????
	IndexCarton // Cada cartón es único
	BolasTachadas //Restan //  Le cambio el nombre, su propósito es confuso con ese nombre.
	//Record //  ¿es realmente necesario?. Si sí, añade el soporte para esto cuando lo demás, lo elemental para el juego funcione.
Fin Estructura

Array tipo DatosJugador Jugadores()   //este array contiene a todos los jugadores.

Array tipo Entero Cartones()  //este array contiene los cartones de todos los jugadores.
Array tipo Entero BolasPremio()  // este array contiene las bolas que van saliendo. consideramos las bolas desde 0 a 99.

// Estos valores cámbialos a tu gusto, los que pongo son de ejemplo.
Constante c_MaximoJugadores = 25  //si se alcanza los 25 jugadores, se rechaza añadir más jugadores a la partida.
constante c_MinJugadores = 2   // si hay menos jugadores, no hay ppartida posible.
Constante c_ValoresXCarton = 20    ' 4 filas por 5 columnas, Acertar una fila es = 
Entero NumJugadoresPartida //se pone al terminar una partida, y se va actualizando a medida que ingresan los jugadores.

Constante c_PrecioCarton = 25 // bingocoins. Lo que paga un jugador por cada cartón que compra.
Constante c_PremioXLinea = 200 //bingocoins. Lo que recibe un jugador si 'canta línea' .
Constante c_PremioXBingo = 1500 //bingocoins. lo que recibe un jugador si 'canta bingo'.

Evento IngresarJugador(Nombre, Apellido, Cedula, Monto, Mas)

Funcion CrearInstancia  // Equivale al New
    // Este array lo podemos redimensionar una vez al valor máximo alcanzable (sigue siendo un valor muy manejable). Evita redimensionarlo en cada partida con el número de jugadores en curso.
    Redimensionar Cartones(0 a (c_Maxjugadores * c_ValoresXCarton) -1 )
    Redimensionar BolasPremio(0 a 99) // el array del premio también basta con redimensionarlo una vez cuandos e crea la instancia.
fin Funcion

// NumJugadores, debiera ser por ejemplo el número de jugadores inscritos en una lista... (interesador en jugar una partida).
//Un jugador puede estar anotado más de una vez, (esto es quiere participar con más de 1 cartón si es en la misma partida). 
//El orden de acceso es riguroso... en el orden de anotados en la lista.
Buleano = Funcion NuevaPartida(NumJugadores)
    Si (NumJugadores < c_Minjugadores) luego
        Devolver FALSE
    Fin si
    Si (NumJugadores > c_Maxjugadores) luego
        NumJugadores  = c_Maxjugadores //se trunca al máximo, o se devuelve FALSE
    Fin si
   
    Redimensionar array Jugadores(0 a NumJugadores-1)
   
    Buleano Ingresado=FALSE, Mas=FALSE
    Bucle para k desde 0 a NumJugadores -1
        Hacer  // Añade un jugador en cada ciclo. Damos por hecho que es así, pero si 
            Ingresado = IngresarJ(k, Mas)
        Repetir Mientras (Ingresado = FALSE) y (Mas = TRUE)         
    Fin bucle     

    NumJugadoresPartida = (k -1)
    // Volvemos a comprobar que hay jugadores suficientes. Antes eran los interesados, ahora los que pudieron pagar su cartón.
    Si (NumJugadoresPartida < c_Minjugadores) luego
        Devolver FALSE
    Fin si     

    llamada a  Barajar  //barajamos los valores de los cartones y los premios que hayan de salir.
    Devolver TRUE
Fin Funcion

Buleano = Funcion IngresarJ(Entero K, Buleano Mas)
    // En cada disparo de evento, debiera añadirse un jugador, procedente quizás de una lista de interesados a la espera de una 'mesa y silla' (un hueco en la partida).
    DispararEvento IngresarJugador(Nombre, Apellidos, Cedula, Monto, Mas)
    //Mas, debe devolver si hay más jugadores en la lista apuntados aparte de éste que se ingresa. 
    //    esto es devolver TRUE, si no es el último en la lista, Y FALSE cuando sea el último.
    Si (Monto >= c_PrecioCarton) luego  // Si no puede pagar el cartón, no puede jugar???. El jugador no entra en esta partida.         
       //No verificamos que cédula no existe ya, porque esto imposibilita que un jugador pueda comprar más de un cartón
       Jugadores(k).Nombre = Nombre
       Jugadores(k).Apellidos = Apellidos
       Jugadores(k).Cedula = Cedula
       Jugadores(k).IndexCarton = (k * c_ValoresXCarton)   //los valores de su cartón van desde dicho valor hasta 19 más arriba, tenemos 20 valores por cartón.
       Jugadores(k).BolasTachadas = 0 
       Monto -= c_PrecioCarton //cobramos el cartón. Monto debe ser pasado por referencia, si no, 
          //el monto en origen no habrá cambiado. Solo se cobra si el jugador finalmente entra en la partida.
       Jugadores(k).Monto = Monto // ya hemos descontado el precio del cartón, previamente.
       Devolver TRUE
   Si no 
       Devolver FALSE
   Fin si
Fin funcion 

Funcion Barajar
     // Barajar cartones...
    llamada a BarajarCartones2
    // Barajar Premios
    BolasPremio = Barajar100 
fin funcion

función la solución óptima.
Funcion BarajarCartones1
     Bucle para k desde 0 hasta Cartones.LimiteMayor-1
         Cartones(k) = Aleatorio(entre 0 y 99)
     Fin bucle
Fin funcion

Funcion BarajarCartones2
    Array Bolas(0 a 99)
     
    j = 0
    Bucle para k desde 0 hasta NumJugadoresPartida -1
        Bolas = Barajar100
        n = 0
        Bucle para i desde j hasta (j + c_ValoresXCarton - 1) // tomamos las primeras 20 bolas (que ya fueron barajadas. También podría elegirse al azar entre bolas, pero estando ya barajadas es superfluo.
            Cartones(j) = Bolas(n)
            n +=1    //n irá desde 0 a 19...
        Fin Bucle
        j = i   // es equivalente a: j += c_ValoresXCarton, ó también: j += n
    Fin bucle
Fin funcion

Array = Funcion Barajar100
    Array Bolas(0 a 99)

    //Bucle necesario, porque todos los valores han de tener la misma posibilidad de salir,
    //    luego todos los valores han de constar el mismo número de veces (al caso 1)
    Bucle para k desde 0 hasta 99
        Bolas(k) = k
    Fin bucle

    //Ahora se barajan cambiando el orden que ocupan. ...Pero todos siguen constando 1 sola vez, 
    //     luego si se toman x bolas (sean las que sean), todas serán distintas (ninguna aparece repetida).
    Bucle para k desde 99 hasta 1 retrocediendo de 1 en 1
        tmp = Aleatorio(entre k y 1) 
        Bolas(tmp) = Bolas(k)
        Bolas(k) = Bolas(tmp)
    Fin bucle

    Devolver Bolas  //entrega el array barajado. 
Fin Funcion

Funcion IniciarPartida  //Esta función debe invocarse solo tras la función NuevaPartida y solo si aquella devuelve TRUE
    Entero Bolas = 0          //cantidad de valores que se han sacado ya del bingo.
    Entero Bola                  //valor actual que se acaba de sacar del bingo.
    Buleano Bingo = False  //alguien cantó bingo?
    Buleano Linea = False  //alguien cantó Linea?    
    Entero Lineas              //para verificar las diferentes líneas en busca de 'línea'
    Entero Index              //Indice donde localizar en el cartón

    Hacer
        //Sacar la siguiente bola del bingo.
        Bola = BolasPremio(Bolas)  // ya están barajadas.

        Bucle para j desde 0 a NumJugadoresPartida -1
            //Indice apunta al cartón del jugador (índice en el array donde comienza) para el jugador que se va a verificar su cartón.
            Indice = (j * c_ValoresXCarton)  

            Si (Linea = FALSE) luego  //No puede cantarse 'Bingo' sin antes cantarse 'Linea'
                Lineas = 0
                Hacer  // Este bucle verifica las 4 líneas (de un cartón), para al encontrar una, la primera... se 'cante' línea...
                    Linea = VarificarLinea(Indice , Bola, j)
                    Si (Linea = TRUE) luego  //pagar al jugador que obtuvo la línea.
                        Jugadores(j).Monto += c_PremioXLinea
                    Fin si
                    Lineas += 1 
                    Indice += 5
                Repetir Mientras (Lineas < 3) y (Linea = FALSE)
            Si no
                Bingo = VerificarBingo(Indice, Bola,j)                
                Si (Bingo = TRUE) luego  // pagar al jugador que obtuvo el bingo, y será fin de la partida...
                    Jugadores(j).Monto += c_PremioXBingo
                Fin si
            Fin si
        Siguiente en bucle
        Bolas += 1
   Repetir Mientras (Bolas < 100) y (Bingo = FALSE)
Fin funcion

Buleano  = Funcion VerificarLinea(Entero Index, Entero Bola, Entero Jugador)
    Entero n

    Bucle para k desde Index a (Index + 4)   // por ejemplo 0,1,2,3,4 ó: 5,6,7,8,9
        Si (Cartones(k) = -1) luego 
            n += 1  //contamos las tachadas en esta línea
        Si no
            Si (Cartones(k) = Bola) luego 
                Cartones(k ) = -1 // Tachada para la próxima vez
                Jugadores(Jugador).BolasTachadas  +=1
                n += 1
            Fin si 
        Fin si
    Fin bucle

    // Si están tachadas todas en la línea devuelve TRUE, obtuvo Linea.
    Devolver (n = 5)
Fin funcion

Buleano  = Funcion VerificarBingo(Entero Index, Entero Bola, Entero Jugador)
    Bucle para k desde Index a Index + c_ValoresXCarton-1           
           Si (Cartones(k) = Bola) luego 
               Cartones(k ) = -1 // Tachada para la próxima vez
               Jugadores(Jugador).BolasTachadas  +=1
           Fin si 
    Fin bucle

    //Si las tachadas = todas las que tiene el cartón devulve TRUE, obtuvo Bingo.
    Devolver (Jugadores(Jugador).BolasTachadas  = c_ValoresXCarton) 
Fin funcion