program LetsBingo;

uses crt;
const
JUGADORES = 10;
CASILLEROS = 100;
type
puntaje = 0..3;
acerte = 1..15;

jugador = record
nombre: string;
puntos: puntaje;
end;

vectorJugadores = array[1..10] of jugador;

BolilleroCarton = array [1..100] of boolean;

jugada = record

carton: BolilleroCarton;
salio: boolean;
aciertos: integer;

end;

VectorPartida = array[1..10] of jugada;

procedure leerJugador(var j: jugador);

begin
Write ('Ingrese el nombre del Jugador: ');
readln(j.nombre);
j.puntos:= 0;
end;

procedure CargarJugadores(var vj: VectorJugadores);

var
i: integer;
begin
for i:= 1 to JUGADORES do begin
leerJugador(vj[i]);
end;
end;

procedure inicializarCartones(var b: BolilleroCarton);

var
i: integer;
begin
for i:=1 to CASILLEROS do {Los cartones comienzan "en blanco"}
b[i]:= FALSE;
end;

procedure NumerosSinRepetir(var b: BolilleroCarton);

var
num, cant: integer;
begin
 cant:= 0;
num:= Random (100) + 1;
while(cant <> 15) do begin {La condicion del while se debe a que quiero cargar
solo 15 numeros en el carton}
if((b[num] = FALSE))then begin {Si no sale el cero y el carton esta vacio en
esa posicion, asigna numeros al carton}
cant:= cant + 1;
b[num]:= TRUE;
end;
num:= Random (100) + 1;
end;
end;

procedure CargarCartones(var vp: VectorPartida);

var
i: integer;
begin

for i:= 1 to JUGADORES do begin

inicializarCartones(vp[i].carton);
vp[i].salio:= false;
vp[i].aciertos:= 0;
{Genero 1 carton}
//AsignarCartones(vp[i]);
NumerosSinRepetir(vp[i].carton);
{Inicializo acierto en 0}

end;
end;

procedure CargarCartonesAleatorios(var vp: VectorPartida);

var
num, i: integer;
ok: boolean;
begin
i:= 0;
While (i< 10) do begin
inicializarCartones(vp[i].carton);
vp[i].salio:= false;
vp[i].aciertos:= 0;
{Genero 1 carton}
ok:= false;
num:= Random(10)+1; {defino aleatoriamente a qui?n le voy a asignar el cart?
n}
while (not(ok)) do begin
if ((vp[num].salio = false))then begin {si el n?mero no es 0 y el jugador
no sali? previamente}
NumerosSinRepetir(vp[i].carton); {asigna el cart?n al jugador en la
posici?n del n?mero r?ndom}
vp[num].salio:= true; {cambio el valor del campo en el vector para
saber que ya tiene un cart?n asignado}
ok:= true;
i:= i + 1;
end
else
num:= Random(10)+1; {si el n?mero random fue 0 o repetido saco otro y
vuelvo a evaluarlo}
end;
end;
end;

function numerossinrepetir2 (b:BolilleroCarton): integer;

var
num: integer;
begin
num := Random(100)+1; // genero un n?mero entre 0 y 99
while (b[num] = true) do {si es true ya salio el numero y necesito generar
otro}
num := Random(100)+1;

numerossinrepetir2 := num; {devuelve un n?mero no repetido}

end;

procedure verificarCartonPorJugador (var j:jugada; num:integer);

begin
if (j.carton[num] = true) then
j.aciertos:= j.aciertos +1;
end;

procedure verificarCartonesJugadores(num: integer; var vp: vectorPartida);

var
i:integer;
begin
for i:=1 to 10 do begin {ver por cada jugador si tiene el n?mero en el
cart?n}
if (vp[i].aciertos <> -1) then {s?lo verifico cart?n de jugador que
no gan?}
verificarCartonPorJugador (vp[i],num); {Si est? en true suma
aciertos+1}
end;
end;

procedure verificarGanadores(var vp:VectorPartida; var vj: vectorJugadores;

var jugadoresGanadores: integer;
var puntosQueVanAGanar: integer);
var
i: integer;
ganoAlguienEstaRonda: boolean;
begin
ganoAlguienEstaRonda := false;
for i:= 1 to 10 do begin
if vp[i].aciertos = 15 then begin {Bingo!}
ganoAlguienEstaRonda := true; {pone en true si alguien gan? esta
ronda}
vp[i].aciertos := -1; {ya gan?, no necesito volver a verificar su
cart?n}
vj[i].puntos := puntosQueVanAGanar; {marca los puntos que gan?
el jugador}
jugadoresGanadores:=jugadoresGanadores+1;
end;
end;
if (ganoAlguienEstaRonda) then
puntosQueVanAGanar := puntosQueVanAGanar -1; {resta 1 si alguien gan?
esta ronda}
end;
procedure jugarUnaPartida (var vp:vectorPartida; var vj: vectorJugadores);
var
b: BolilleroCarton;
numQueSalio, jugadoresGanadores, puntosQueVanAGanar,
bolillasSorteadas: integer;

Begin

inicializarCartones(b);

puntosQueVanAGanar:= 3; // etapas, el primero gana 3 puntos

jugadoresGanadores:= 0;

bolillasSorteadas := 0;

while (puntosQueVanAGanar<>0) and (jugadoresGanadores<10) do begin

numQueSalio := numerossinrepetir2(b); //sacar un numero del bolillero

b[numQueSalio]:=true; // marca que ya sali? el numero

verificarCartonesJugadores (numQueSalio,vp);

bolillasSorteadas := bolillasSorteadas +1;

If (bolillasSorteadas >= 15) then {al menos 15 bolillas antes de ver si

hay ganador}

verificarGanadores(vp, vj, jugadoresGanadores, puntosQueVanAGanar);

end;

end;

procedure Ordenar (var vj: vectorJugadores);

var
i,j,p:integer;
aux: jugador;
begin
for i:=1 to JUGADORES-1 do begin {busca el maximo puntaje v[p], entre
v[1], ..., v[9] }
p := i;
for j := i+1 to JUGADORES do begin
if (vj[j].puntos > vj[p].puntos)then
p:=j;
end;
{intercambia v[i] y v[p] }
aux := vj[p];
vj[p] := vj[i];
vj[i] := aux;

end;
end;

procedure ImprimirPuntos(vj: vectorJugadores);

var
i:integer;
begin
 Ordenar(vj);
for i:= 1 to JUGADORES do begin
case vj[i].puntos of
3: writeln('El ganador o ganadores es: ', vj[i].nombre);
0..2: writeln('El jugador ', vj[i].nombre,' quedo en la posicion ', i);
end;
end;
end;

Var

vj: vectorJugadores;

vp: vectorPartida;
i: integer;

{Se supone que tiene que andar, sumando todos los m?dulos}

Begin
Randomize;

cargarJugadores (vj); {Falta el nombre del proceso arriba, no?}

cargarCartones (vp);

jugarUnaPartida(vp, vj);

for i:= 1 to JUGADORES do

writeln(vj[i].nombre, ' puntos: ', vj[i].puntos);

ImprimirPuntos(vj);

readkey;

end.