{TAREAS PENDIENTES}
{
    * IMPORTANTE: La parte que se repite en la consola es porque el clrscr en geany solo borra lo que se ve, no lo de arriba.
      Para arreglar eso hay que hacer que se muestre la lista de a 10 jugadores.
    *
    *
    * Esperar a ver como llega la formacion de leo y editar el vector tacticas porque no son mas por fecha (lo hace pippo)
    * Hacer el retorno de los reportes a los menus (deberia hacerlo ronnie en mi opinion (pippo)
    * Resolver el tema de las listas de jugadores que se van de rango de pantalla
    * Resolver el tema de los titulares dobles
    * Correcciones Ortograficas o graficas (hay de a montones)
    * Eliminar los pasajes directos al tocar un numero en los menu, que haya que darle enter siempre.
    * }

    {* hay que poner dos 0 para salir del menu de clubes reales en la creacion de equipo
    * si se apreta enter en la pantalla principal de la configuracion de equipo, se borran los cambios actuales}

    {Data respecto a lo de LEO
    * DESPUES DE 3HS buscando di masomenos con el quid de la cuestion, el jugador se setea en 2 lados (Ver donde puse 'TESTEO')
      La pregunta es, cual se saca, o si se saca alguno, si se saca cualquiera NO se duplica mas nada, pero aparecen otros bugs.
      Si quieren mirenlo pero diria que lo dejemos asi y le preguntemos a LEO porque se asigna en 2 lados el Equipo[i].
    *
    * }
{bugs encontrados de lalo}
{
    1.- Al crear el administrador e ingresar mal la contraseña donde te pide para confirmarla, se buguea y termina pidiendo
    el nombre de nuevo.

    2.- Cuando no se elige el "Nombre" avisa de que el campo se ha dejado en blanco y se reinicia, pero si se pueden dejar
    en blanco los campos de "Apellido", "Club" y "Contraseña"... al reingresar la contraseña si se deja en blanco se dice que
    no es la misma y se reinicia.
}

{************Editando Ema*****************}


Program GranDT;

{Version Alpha 0.07}

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

Uses AyPDT, CRT;

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

Const
    JUGADORES = 623;
    EQUIPOS = 20;
    FECHAS_TORNEO = EQUIPOS-1;
    PRESUPUESTO = 60000000;
    MAX_USUARIOS = 10;
    JUGADORESXEQUIPO = 15;
    SEPARADORH = '--------------------------------------------------------------------------------'; {Una linea tiene 80 caracteres}
    LETRA_S = 83;
    TIEMPO_SALIDA = 1500;
    SIMBOLO_MONEDA = '$';
    TACTICAS = 5;
    MAX_TIPO_PREMIOS = 4;

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

Type
    tTactica = record
        ID: byte;
        Cantidad: byte;
        end;

    tTacticas = array[1..TACTICAS] of tTactica;
    tPuntajeJugador = array[1..JUGADORES, 1..FECHAS_TORNEO] of integer;

    tPuntajeTotalJugador = record
        ID: integer;
        puntajeTotal: integer;
        end;

    tPuntajeTotalJugadores = array[1..JUGADORES] of tPuntajeTotalJugador;

    tElegidoJugador = record
        ID: integer;
        valor: byte;
        end;

    tElegidoJugadores = array[1..JUGADORES] of tElegidoJugador;
    tListaApuestas = array[1..4] of integer;

    tPuntajeEquipo = array[1..FECHAS_TORNEO] of integer;
    tTacticaEquipo = array[1..FECHAS_TORNEO] of byte;
    tPrecioEquipo = array[1..FECHAS_TORNEO] of real;

    tCondicion = (TITULAR, SUPLENTE);

    tJugadorEquipo = record
        ID: integer;
        Condicion: tCondicion;
        end;

    tListaJugadoresEquipo = array[1..JUGADORESXEQUIPO] of tJugadorEquipo;

    tEquipo = record
        Puntaje: tPuntajeEquipo;
        Tactica: tTacticaEquipo;
        Precio: tPrecioEquipo;
        CantFechasGanadas: byte;
        CantCambiosAcum: byte;
        CantCambiosUltimaFecha: byte;
        Jugador: tListaJugadoresEquipo;
        end;

    tUsuario = record
            ID: byte;
            Nombre: string[25];
            Apellido: string[25];
            Club: string[20];
            Usuario: string[20];
            Contrasena: string[10];
            TipoUsuario: byte;
            Equipo: tEquipo;
            CantidadApuesta: real;
            GananciaPorFechas: real;
            GananciaPorTorneo: real;
            end;

    tUsuarios = array[1..MAX_USUARIOS] of tUsuario;

    tVEquipo = array [1..JUGADORES] of tJugador;
    tVCondicion = array [1..JUGADORES] of tCondicion;
    tVClubs = array [1..(EQUIPOS+1)] of integer;
    tVJugadores = array [1..JUGADORESXEQUIPO]of integer;
    tVFormacion = array [1..FECHAS_TORNEO] of integer;
    tVCambios = array [1..FECHAS_TORNEO] of byte;

    tRegEQUIPO = record
            ID: tVJugadores;
            Condicion:tVCondicion;
            Formacion: tVFormacion;
            Cambios: tVCambios;
            TotalCambios: byte;
            end;

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

Procedure MenuAdministrador(var FechaActual: byte; var TipoUsuario: byte; var vUsuarios: tUsuarios; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador;
CantUsuarios: byte; vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; var vListaJugadores: tListaJugadores;
UsuarioActual: byte; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);forward;

Procedure MenuIniciarSesion(var vUsuarios: tUsuarios; var TipoUsuario: byte; var UsuarioActual: byte; FechaActual: byte; var vListaApuestas: tListaApuestas;
var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores;
var vListaJugadores: tListaJugadores; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);forward;

Procedure MenuUsuario(var TipoUsuario: byte; var vUsuarios: tUsuarios; var FechaActual: byte; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; var vListaJugadores: tListaJugadores; UsuarioActual: byte;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);forward;

Procedure CargaUsuarios(var vUsuarios: tUsuarios; var TipoUsuario: byte; var UsuarioActual: byte; FechaActual: byte; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; var vListaApuestas: tListaApuestas;
var vListaJugadores: tListaJugadores; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);forward;

Procedure MenuCorrerReportes(var vUsuarios: tUsuarios;var TipoUsuario: byte; FechaActual: byte; CantUsuarios: byte; var vPuntajeJugador: tPuntajeJugador; var vListaApuestas: tListaApuestas;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vElegidoJugadores: tElegidoJugadores; var vTacticas: tTacticas; var vListaJugadores: tListaJugadores; UsuarioActual: byte;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);forward;

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

Procedure tRegEQUIPO_a_UsuariosEquipo(var vUsuarios:tUsuarios; var RegEQUIPO:tRegEQUIPO; UsuarioActual:Byte; FechaActual:Byte);
    var
        i,j:Integer;
    begin
    for i:=1 to JUGADORESXEQUIPO do
        begin
        vUsuarios[UsuarioActual].Equipo.Jugador[i].ID := RegEQUIPO.ID[i];
        vUsuarios[UsuarioActual].Equipo.Jugador[i].Condicion := RegEQUIPO.Condicion[i];
        for j:=1 to FechaActual do
            vUsuarios[UsuarioActual].Equipo.Tactica[j] := RegEQUIPO.Formacion[j];
        end;
        {falta pasar ea ambos modulos precio y cambios}
    end;

Procedure UsuariosEquipo_a_tRegEQUIPO(var vUsuarios:tUsuarios; var RegEQUIPO:tRegEQUIPO; UsuarioActual:Byte; FechaActual:Byte);
    var
        i,j:Integer;
    begin
    for i:=1 to JUGADORESXEQUIPO do
        begin
        RegEQUIPO.ID[i] := vUsuarios[UsuarioActual].Equipo.Jugador[i].ID;
        RegEQUIPO.Condicion[i] := vUsuarios[UsuarioActual].Equipo.Jugador[i].Condicion;
        for j:=1 to FechaActual do
            RegEQUIPO.Formacion[j] := vUsuarios[UsuarioActual].Equipo.Tactica[j];
        end;
    end;

{Imprime titulo del Programa. Ronnie Del Pino}
Procedure ImprimirTitulo(FechaActual: byte);
begin
    clrscr;
    gotoxy(35,1);
    writeln('GranDT - Grupo 4');
    case FechaActual of
        0:
        begin
            gotoxy(28,2);
            writeln('El Torneo aun no ha comenzado');
        end;
        1..19:
        begin
            gotoxy(40,2);
            writeln('Fecha ', FechaActual);
        end;
        20:
        begin
            gotoxy(32,2);
            writeln('El Torneo ha finalizado');
        end;
    end;
    writeln;
end;

{**************************************************************************************************************}
{Ordena En forma Ascendente y descendente el vector. Ronnie Del Pino}
Procedure OrdenarVector(var vUsuarios: tUsuarios; Orden: string);
var
    Aux: tUsuario;
    i, j: byte;
    DesOrd: boolean;
begin
    i := 1;
    DesOrd := true;
    while (i < MAX_USUARIOS) and (DesOrd) do
        begin
        DesOrd := false;
        for j:=1 to MAX_USUARIOS-i do
            begin
            if (Orden = 'Asc') then
                begin
                if (vUsuarios[j].Usuario > vUsuarios[j+1].Usuario) then
                    begin
                    Aux := vUsuarios[j];
                    vUsuarios[j] := vUsuarios[j+1];
                    vUsuarios[j+1] := Aux;
                    DesOrd := true;
                    end;
                end
            else
                begin
                if (vUsuarios[j].Usuario < vUsuarios[j+1].Usuario) then
                    begin
                    Aux := vUsuarios[j];
                    vUsuarios[j] := vUsuarios[j+1];
                    vUsuarios[j+1] := Aux;
                    DesOrd := true;
                    end;
                end;
            end;
        inc(i);
        end;
end;

{**************************************************************************************************************}
{Copia la lista de jugadores de la unit a un vector. Juan Manuel Castro Pippo}
Procedure GenerarListaJugadores(var vListaJugadores: tListaJugadores);
var
    jugador: tJugador;
    i: integer;
begin
    for i:=1 to JUGADORES do
        begin
            ObtenerJugador(i, Jugador);
            vListaJugadores[i] := Jugador;
        end;
end;

{**************************************************************************************************************}
{Validar un Numero con Rango. Juan Manuel Castro Pippo}
Function ObtenerNumero(min:Longint; max:Longint):Longint;
    Var
        entrada : string;
        salida : Longint;
        Nro, Rango : Boolean;
        cod : Byte;

begin
    repeat
        Nro:=True;
        Rango:=True;
        readln(entrada);
        val(entrada,salida,cod);
        if cod<>0 then
            Begin
            Nro:=False;
            writeln('Numero Invalido.');
            write('Ingrese de nuevo: ');
            End
        else
            if (salida<min) or (max<salida) then
                Begin
                Rango:=False;
                writeln('Numero fuera de Rango.');
                write('Ingrese de nuevo: ');
                End;
        until (Nro=True) and (Rango=True);

    ObtenerNumero := salida;
end;

{**************************************************************************************************************}
{Inicializa Strings. Emanuel Kotzayan}
Procedure InicializarStrings(var Campo: string);
begin
    Campo := '';
end;

{**************************************************************************************************************}
{Inicializa Bytes. Emanuel Kotzayan}
Procedure InicializarBytes(var Numero: byte);
begin
    Numero := 0;
end;

{**************************************************************************************************************}
{Inicializa Integers. Emanuel Kotzayan}
Procedure InicializarIntegers(var Numero: integer);
begin
    Numero := 0;
end;

{**************************************************************************************************************}
{Inicializa Reals. Emanuel Kotzayan}
Procedure InicializarReals(var Numero: real);
begin
    Numero := 0;
end;

{**************************************************************************************************************}
{Inicializa todas las variables. Emanuel Kotzayan}
Procedure InicializarVariables (var vUsuarios: tUsuarios; var vListaJugadores: tListaJugadores; var vTacticas: tTacticas; var vPuntajeTotalJugadores: tPuntajeTotalJugadores;
var vElegidoJugadores: tElegidoJugadores; var vPuntajeJugador: tPuntajeJugador; var vListaApuestas: tListaApuestas; var CantUsuarios: byte; var TipoUsuario: byte; var UsuarioActual: byte;
var FechaActual: byte);

var
    i, j, k, m, n, o, p: integer;
begin
    GenerarListaJugadores (vListaJugadores);
    for i := 1 to MAX_USUARIOS do
    begin
        InicializarBytes(vUsuarios[i].ID);
        InicializarStrings(vUsuarios[i].Nombre);
        InicializarStrings(vUsuarios[i].Apellido);
        InicializarStrings(vUsuarios[i].Club);
        InicializarStrings(vUsuarios[i].Usuario);
        InicializarStrings(vUsuarios[i].Contrasena);
        InicializarBytes(vUsuarios[i].TipoUsuario);
        InicializarReals(vUsuarios[i].CantidadApuesta);
        InicializarReals(vUsuarios[i].GananciaPorFechas);
        InicializarReals(vUsuarios[i].GananciaPorTorneo);
        for j:=1 to FECHAS_TORNEO do
        begin
            InicializarIntegers(vUsuarios[i].Equipo.Puntaje[j]);
            InicializarBytes(vUsuarios[i].Equipo.Tactica[j]);
            InicializarReals(vUsuarios[i].Equipo.Precio[j]);
        end;
        InicializarBytes(vUsuarios[i].Equipo.CantFechasGanadas);
        InicializarBytes(vUsuarios[i].Equipo.CantCambiosAcum);
        InicializarBytes(vUsuarios[i].Equipo.CantCambiosUltimaFecha);
        for k := 1 to JUGADORESXEQUIPO do
        InicializarIntegers(vUsuarios[i].Equipo.Jugador[k].ID);
    end;
    for m:=1 to TACTICAS do
    begin
        InicializarBytes(vTacticas[m].ID);
        InicializarBytes(vTacticas[m].Cantidad);
    end;
    for n := 1 to JUGADORES do
    begin
        InicializarIntegers(vPuntajeTotalJugadores[n].ID);
        InicializarIntegers(vPuntajeTotalJugadores[n].puntajeTotal);
        InicializarIntegers(vElegidoJugadores[n].ID);
        InicializarBytes(vElegidoJugadores[n].valor);
        for o := 1 to FECHAS_TORNEO do
        begin
            InicializarIntegers(vPuntajeJugador[n,o]);
        end;
    end;
    for p:=1 to 4 do
    InicializarIntegers(vListaApuestas[p]);
    InicializarBytes(CantUsuarios);
    InicializarBytes(TipoUsuario);
    InicializarBytes(UsuarioActual);
    InicializarBytes(FechaActual);
end;

{**************************************************************************************************************}
{Devuelve la cantidad de usuarios registrados. Ronnie Del Pino}
Function CantidadParticipantes(var vUsuarios: tUsuarios):integer;
var
    i: integer;
begin
    i := 0;
    OrdenarVector(vUsuarios, 'Des');
    repeat
        inc(i);
    until (vUsuarios[i].Usuario = '') or (i > MAX_USUARIOS);
    CantidadParticipantes := i-1;
end;

{**************************************************************************************************************}
{Obtiene la posicion libre mas cercana. Ronnie Del Pino}
Function Posicion(var UnRecord: tUsuarios):integer;
var
    i: integer;
begin
    OrdenarVector(UnRecord, 'Des');
    i := 0;
    repeat
        inc(i);
    until (UnRecord[i].Usuario = '') or (i > MAX_USUARIOS);
    Posicion := i;
end;

{**************************************************************************************************************}
{Valida y devuelve numeros de 0 a 9. Ronnie Del Pino}
Function ValidarOpciones(): integer;
var
    valor: string;
    Letra, Numero: byte;
    Ancho: string;
begin
    Ancho:='';
    repeat
    Letra := ord(readkey);
        if (Letra <> 8) then {Tecla Backspace}
            Begin
            if (Letra > 47) and (Letra < 58) then {Teclas Numericas}
                begin
                Valor := chr(Letra);
                Write(Valor);
                Ancho := Ancho + Valor;
                Val(Ancho, Numero);
                if (Length(Ancho) > 3) then
                    begin
                        Letra := 13;
                        Numero := 99;
                    end;
                end;
            end
        else
            begin
                Numero := 99;
                Letra := 13;
            end;
    until (Letra = 13);
    ValidarOpciones := Numero;
end;
{**************************************************************************************************************}
{Valida y devuelve la cantidad de cifras y el valor respectivameente. Ronnie Del Pino}
Function ValidarNumerosCifras(Cant: byte): integer;
var
    Letra, Acum: byte;
    Total: string;
    Valor: integer;
begin
    InicializarStrings(Total);
    Acum := 1;
    repeat
        Letra := ord(readkey);
        if (Letra > 47) and (Letra < 58) then
            begin
            write(chr(letra));
            inc(Acum);
            Total := Total + chr(letra);
            end;
    until (Letra = 13) or (Acum > Cant);
    val(Total,Valor);
    ValidarNumerosCifras := Valor;
end;

{**************************************************************************************************************}
{Verifica que no se dupliquen los usuarios. Ronnie Del Pino}
Function UsuarioDuplicado(User: string; var vUsuarios: tUsuarios): boolean;
var
    Inicio, Fin: integer;
    Medio: integer;
    Encontrado: boolean;
begin
    Inicio := 1;
    Fin := MAX_USUARIOS;
    Encontrado := False;
    OrdenarVector(vUsuarios, 'Des');
    repeat
        if (Inicio >= Fin) then
        begin
            if (vUsuarios[Inicio].Usuario = User) then
            begin
                UsuarioDuplicado := true;
                Encontrado := true;
            end
            else
            begin
                UsuarioDuplicado := false;
                Encontrado := true;
            end;
        end;
        Medio := (Inicio + Fin) div 2;
        if (vUsuarios[Medio].Usuario = User) then
            begin
            UsuarioDuplicado := true;
            Encontrado := true;
            end
        else
            if (vUsuarios[Medio].Usuario > User) then
                Inicio := Medio+1
            else
            Fin := Medio-1;
    until (Encontrado)
end;

{**************************************************************************************************************}
{Verifica que el usuarios y la contrasena existan en los registros. Ronnie Del Pino}
Function BuscarUsuario(User: string; Password: string; var vUsuarios: tUsuarios): boolean;
var
    Inicio, Fin: integer;
    Medio: integer;
    Encontrado: boolean;
begin
    Inicio := 1;
    Fin := MAX_USUARIOS;
    Encontrado := false;
    OrdenarVector(vUsuarios, 'Des');
    repeat
        if (Inicio >= Fin) then
            begin
            if (vUsuarios[Inicio].Usuario = User) and (vUsuarios[Inicio].Contrasena = Password) then
                begin
                    BuscarUsuario := true;
                    Encontrado := true;
                end
            else
                begin
                    BuscarUsuario := false;
                    Encontrado := true;
                end;
            end;
        Medio := (Inicio + Fin) div 2;
        if (vUsuarios[Medio].Usuario = User) then
            if (vUsuarios[Medio].Contrasena = Password) then
                begin
                    BuscarUsuario := true;
                    Encontrado := true;
                end
            else
                begin
                    BuscarUsuario := false;
                    Encontrado := true;
                end
        else
            if (vUsuarios[Medio].Usuario > User) then
                Inicio := Medio+1
            else
                Fin := Medio-1;
    until (Encontrado)
end;


{**************************************************************************************************************}
{Obtiene id de un usuario. Devuelve 0 sino existe. Ronnie Del Pino}
Function ObtenerID(User: string; var vUsuarios: tUsuarios): byte;
var
    Inicio, Fin: byte;
    Medio: integer;
    Encontrado: boolean;
begin
    Inicio := 1;
    Fin := MAX_USUARIOS;
    Encontrado := false;
    OrdenarVector(vUsuarios, 'Des');
    repeat
        if (Inicio >= Fin) then
            begin
            if (vUsuarios[Inicio].Usuario = User) then
                begin
                    ObtenerID := Inicio;
                    Encontrado := true;
                end
            else
                begin
                    ObtenerID := 0;
                    Encontrado := true;
                end;
            end;
        Medio := (Inicio + Fin) div 2;
        if (vUsuarios[Medio].Usuario = User) then
                    begin
                    ObtenerID := Medio;
                    Encontrado := true;
                    end
        else
            if (vUsuarios[Medio].Usuario > User) then
                Inicio := Medio+1
            else
                Fin := Medio-1;
    until (Encontrado)
end;


{**************************************************************************************************************}
{Verifica si el usuario es administrador o user. Ronnie Del Pino}
Function EsAdmin(var vUsuarios: tUsuarios; Usuario: string): boolean;
var
   i: byte;
begin
    InicializarBytes(i);
    OrdenarVector(vUsuarios, 'Des');
    repeat
        inc(i);
    until (vUsuarios[i].TipoUsuario = 0) or (i > MAX_USUARIOS);
    if (vUsuarios[i].Usuario = Usuario) then
        EsAdmin := true
    else
        EsAdmin := false;
end;

{**************************************************************************************************************}
{Oculta y devuelva las teclas ingresadas por el usuario. Ronnie Del Pino}
Function OcultarContrasena(): string;
var
   Contrasena: string;
   Tecla: byte;
   Contador: byte;
begin
    InicializarStrings(Contrasena);
    InicializarBytes(Contador);
    InicializarBytes(Tecla);
    while (Tecla <> 13) do
       begin
       Tecla := ord(readkey);
       if (Tecla > 47) and (Tecla < 123) and (Contador < 10) then
          begin
          write('*');
          Contrasena := Contrasena + chr(Tecla);
          Contador := Contador+1;
          end;
       end;
    OcultarContrasena := Contrasena;
end;

{**************************************************************************************************************}
{Convierte la tPosicion de un jugador a formato string. Juan Manuel Castro Pippo}
Function tPosicionAString(Posicion: tPosicion):string;
var
    TextPos:string[15];
begin
    case (Posicion) of
        ARQUERO: TextPos := 'Arquero';
        DEFENSOR: TextPos := 'Defensor';
        MEDIOCAMPISTA: TextPos := 'Mediocampista';
        DELANTERO: TextPos := 'Delantero'
        else TextPos := 'Desconocido';
    end;
    tPosicionAString := TextPos;
end;

{**************************************************************************************************************}
{Convierte la tCondicion de un jugador a formato string. Juan Manuel Castro Pippo}
Function tCondicionAString(Condicion: tCondicion): string;
var
    TextPos: string[15];
begin
    case (Condicion) of
        TITULAR: TextPos := 'Titular';
        SUPLENTE: TextPos := 'Suplente';
        else TextPos := 'Desconocido';
    end;
    tCondicionAString := TextPos;
end;

{**************************************************************************************************************}
{Imprime una Lista de los Mejores Jugadores por Puesto. Juan Manuel Castro Pippo}
Procedure ImprimirMejoresJugadoresxPuesto(var vPuntajeTotalJugadores: tPuntajeTotalJugadores; Posicion: tPosicion; var vListaJugadores: tListaJugadores);
var
    i,j,k: integer;
    AuxID: integer;
    Jugador: tJugador;
    Top, ElementosxPagina, Tecla: byte;
begin
    InicializarBytes(Tecla);
    i := 1;
    k := 1;
    Top := 10;
    ElementosxPagina := 15;
    while (Tecla <> LETRA_S) do
    begin
        clrscr();
        writeln('10 MEJORES JUGADORES EN LA POSICION ', upcase(tPosicionAstring(posicion)), ' EN LO QUE VA DEL TORNEO');
        writeln('');
        writeln('POS':4,'APELLIDO Y NOMBRE':29,'POSICION':16,'EQUIPO':15,'ACUMULADO':15);
        writeln(SEPARADORH);
        j := 1;
        if (i > JUGADORES) then
            i := 1;
        if (k > Top) then
        begin
            k := 1;
            i := 1;
        end;
        while (j <= ElementosxPagina) and (k <= Top) do
        begin
            AuxID := vPuntajeTotalJugadores[i].ID;
            Jugador := vListaJugadores[AuxID];
            if (vListaJugadores[AuxID].Posicion = Posicion) then
            begin
                writeln(k:4,Jugador.Nombre:29,tPosicionAString(Jugador.Posicion):16,Jugador.Equipo_Real:15,vPuntajeTotalJugadores[i].PuntajeTotal:15);
                inc(k);
                inc(j);
            end;
            inc(i);
        end;
        writeln(SEPARADORH);
        write('Volver al menu anterior?: ');
        tecla := ord(upcase(readkey));
    end;
end;

{**************************************************************************************************************}
{Muestra menu Resultados por posicion de jugador. Ronnie Del Pino}
Procedure ReportesMenuResultadosPorPuesto(var vUsuarios: tUsuarios; var TipoUsuario: byte; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vListaJugadores: tListaJugadores;
FechaActual: byte; CantUsuarios: byte; var vPuntajeJugador: tPuntajeJugador; var vListaApuestas: tListaApuestas; var vElegidoJugadores: tElegidoJugadores;
var vTacticas: tTacticas; UsuarioActual: byte; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    Opcion: byte;
begin
    ImprimirTitulo(FechaActual);
              writeln('1 - Arquero');
              writeln('2 - Defensor');
              writeln('3 - Mediocampista');
              writeln('4 - Delantero');
              writeln('5 - Volver');
              write('Opcion: ');
    Opcion := ValidarOpciones();
    case Opcion of
            1: ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores,ARQUERO, vListaJugadores);
            2: ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores,DEFENSOR, vListaJugadores);
            3: ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores,MEDIOCAMPISTA, vListaJugadores);
            4: ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores,DELANTERO, vListaJugadores);
            5: MenuCorrerReportes(vUsuarios, TipoUsuario, FechaActual, CantUsuarios, vPuntajeJugador, vListaApuestas, vPuntajeTotalJugadores, vElegidoJugadores, vTacticas, vListaJugadores,
               UsuarioActual, Equipo, Condicion, RegEquipo);
            else
            ReportesMenuResultadosPorPuesto(vUsuarios, TipoUsuario, vPuntajeTotalJugadores, vListaJugadores, FechaActual, CantUsuarios, vPuntajeJugador, vListaApuestas, vElegidoJugadores,
            vTacticas, UsuarioActual, Equipo, Condicion, RegEquipo);
            end;
end;

{**************************************************************************************************************}
{Pide ingreso de usuario y contrasena. Ronnie Del Pino}
Procedure IniciarSesion(var vUsuarios: tUsuarios; var TipoUsuario: byte; var UsuarioActual: byte; FechaActual: byte; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador;
CantUsuarios: byte; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores:tElegidoJugadores; var vListaJugadores: tListaJugadores;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    Usuario, Contrasena: string;
begin
    ImprimirTitulo(FechaActual);
    write('Usuario: ');
    readln(Usuario);
    write('Contrasena: ');
    Contrasena := OcultarContrasena();
    UsuarioActual:=ObtenerID(Usuario,vUsuarios); {Devuelve 0 sino existe usuario}
    if (BuscarUsuario(Usuario, Contrasena, vUsuarios)) and (Contrasena <> '') then
        begin
        if EsAdmin(vUsuarios, Usuario) then
            begin
            TipoUsuario := 0;
            //Modificar y enviar usuario Actual:
            MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
            UsuarioActual, Equipo, Condicion, RegEquipo)
            end
        else
            begin
            TipoUsuario := 1;
            //Modificar y enviar usuario Actual:
            MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
            UsuarioActual, Equipo, Condicion, RegEquipo);
            end;
        end
    else
        begin
        writeln;
        writeln('Usuario y/o contrasena incorrectos!');
        delay(TIEMPO_SALIDA);
        MenuIniciarSesion(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
        vListaJugadores, Equipo, Condicion, RegEquipo);
        end;
end;

{**************************************************************************************************************}
{Muestra el Menu Crear o logear Usuario. Ronnie Del Pino}
Procedure MenuIniciarSesion(var vUsuarios: tUsuarios; var TipoUsuario: byte; var UsuarioActual: byte; FechaActual: byte; var vListaApuestas: tListaApuestas;
var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores:tElegidoJugadores;
var vListaJugadores: tListaJugadores; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEquipo);

var
    Opcion: byte;
    Respuesta: byte;
begin
    ImprimirTitulo(FechaActual);
    InicializarBytes(Respuesta);
    writeln('1 - Crear usuario');
    writeln('2 - Iniciar sesion');
    writeln('0 - Salir');
    write('Opcion: ');
    Opcion := ValidarOpciones();
          case Opcion of
                1:
                begin
                    TipoUsuario := 1;
                    CargaUsuarios(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas,
                    vListaJugadores, Equipo, Condicion, RegEquipo);
                    end;
                2:IniciarSesion(vUsuarios,TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
                  vListaJugadores, Equipo, Condicion, RegEquipo);
                0:begin
                    writeln('0');
                    write('Si sale se perderan todos los datos. Pulse S para salir: ');
                    Respuesta := ord(upcase(readkey));
                    if (Respuesta = LETRA_S) then
                        begin
                        writeln;
                        writeln('Fin del programa...');
                        delay(TIEMPO_SALIDA);
                        end
                    else
                        MenuIniciarSesion(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas,
                        vElegidoJugadores, vListaJugadores, Equipo, Condicion, RegEquipo);
                    end
                else
                    MenuIniciarSesion(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
                    vListaJugadores, Equipo, Condicion, RegEquipo);
         end;
end;

{**************************************************************************************************************}
{Verifica que un equipo este completo en el sector de armado de equipos. Emanuel Kotzayan}
{Function ChequearEquipoCompleto (var Equipo: tVEquipo): boolean;
var
    i: integer;
    EquipoCompleto: boolean;
begin
    i := 1;
    EquipoCompleto := true;
    while (i <= JUGADORESXEQUIPO) and (EquipoCompleto) do
        begin
            if Equipo[i].ID = 0 then
            EquipoCompleto := false;
            inc(i);
        end;
    ChequearEquipoCompleto := EquipoCompleto;
end;}

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

{CUIDADO CODIGO DE LEO}

{**************************************************************************************************************}
{Valida que el usuario halla ingresado un numero correcto. Leo Ojeda}

Procedure ValidarMenu(var Menu: integer; Max: byte);
var
    Salir: boolean;
begin
    Salir := false;
    repeat
        read(Menu);
        if (Menu < 0) or (Menu > Max) then
            writeln('Numero incorrecto, intente nuevamente')
        else
            Salir := true;
    until Salir;
end;

{**************************************************************************************************************}
{Muestra el dinero del usuario. Leo Ojeda}
Procedure MostrarDinero(var Equipo: tVEquipo);
var
    Dinero: real;
    Contador: byte;
begin
    Contador := 1;
    Dinero := 0;
    while (Equipo[Contador].ID <> 0) do
    begin
        Dinero := Equipo[Contador].Precio + Dinero;
        Inc(Contador);
    end;
    writeln('Usted dispone de ',(PRESUPUESTO-dinero)/1000000:2:1,' Millones de $ para realizar su compra.');
end;

{**************************************************************************************************************}
{Inicializa tVEquipo. Leo Ojeda}
Procedure InicializartVEquipo(var Equipo: tVEquipo);
var
    i: integer;
begin
    for i:=1 to JUGADORESXEQUIPO do
        InicializarIntegers(Equipo[i].ID);
end;

{**************************************************************************************************************}
{Verifica que el equipo este completo. Leo Ojeda}
Procedure ValidarAgregar(var Equipo: tVEquipo; var Valido: boolean);
var
    i, Contador: integer;
begin
    valido := true;
    Contador := 1;
    for i:=1 to JUGADORESXEQUIPO do
        if (Equipo[i].ID <> 0) then
            inc(Contador);
    if (Contador > JUGADORESXEQUIPO)  then
        Valido := false;
end;



{**************************************************************************************************************}
{Imprime una Lista de Jugadores. Juan Manuel Castro Pippo}
procedure ImprimirListaJugadores(var JugadorElegido:integer ;var vListaJugadores:tListaJugadores; var Equipo:tVEquipo);
    var
        i,j,k : integer;
        Jugador : tJugador;
        ElementosxPagina: byte;
        Top : Integer;
        Precio, Entrada : string;

    begin
        Entrada:='';
        i:=1;
        Top:=JUGADORES;
        ElementosxPagina:=15;

        while Entrada<>'C' do
            begin
            clrscr();
            writeln('LISTA DE JUGADORES PARA COMPRAR');
            writeln('');

            writeln('ID':4,'APELLIDO Y NOMBRE':29,'PRECIO':12,'POSICION':18,'EQUIPO':15);
            writeln(SEPARADORH);
            j:=1;
            k:=i;
            while (j<=ElementosxPagina) do
                begin
                if k<=Top then
                    begin
                    Jugador:=vListaJugadores[k];
                    Str(Jugador.precio/1000000:2:1,Precio);
                    Precio:=Precio+' M';
                    writeln(Jugador.id:4,Jugador.nombre:29,Precio:12,tPosicionAString(Jugador.posicion):18,Jugador.equipo_real:15);
                    inc(k);
                    end;
                inc(j);
                end;
            writeln(SEPARADORH);
            MostrarDinero(Equipo);
            writeln('Presione (C) para Comprar un Jugador (recuerde la ID).');
            write('Presione (A) y (S) para cambiar de pagina.');
            Entrada:=upcase(readkey);
            if (Entrada='A') and (i-ElementosxPagina>=1) then
                dec(i,ElementosxPagina);
            if (Entrada='S') and (i+ElementosxPagina<=Top) then
                inc(i,ElementosxPagina);
            end;

        clrscr();
    end;

{**************************************************************************************************************}
{Busqueda de jugadores para agregar al equipo. Leo Ojeda}
Procedure BuscarJugador (var JugadorElegido: integer; Equipo: tVEquipo; var vListaJugadores:tListaJugadores);
begin
    ImprimirListaJugadores(JugadorElegido, vListaJugadores, Equipo);
    writeln('Ingrese 0 si no desea comprar ningun jugador.');
    write('Ingrese la ID del Jugador que desea Comprar: ');
    JugadorElegido := ObtenerNumero(0,JUGADORES);
end;

{**************************************************************************************************************}
{Valida el jugador que desea agregar el usuario al equipo. Leo Ojeda.}
Procedure ValidarAgregarJugador(Equipo: tvEquipo; JugadorElegido: integer; var Condicion: tvCondicion; var Valido: boolean);
var
    i, ContadorClub: byte;
    AuxJugador: tJugador;
    ContadorPlata: real;
    Formacion, FormacionTit, FormacionSup: integer;
begin
    Valido := true;
    InicializarBytes(ContadorClub);
    InicializarIntegers(Formacion);
    InicializarIntegers(FormacionSup);
    InicializarIntegers(FormacionTit);
    ObtenerJugador(JugadorElegido, AuxJugador);
    ContadorPlata := AuxJugador.Precio;
    i:=1;
    while equipo[i].id<>0 do
        begin
            if equipo[i].id = jugadorElegido then
            begin
                writeln('Usted ya agrego a este jugador');
                valido:=false;
            end;
            inc(i);
        end;
    if valido then
    begin
        i:=1;
        while equipo[i].id <>0 do
        begin
            contadorplata:=contadorplata + equipo[i].precio;
            if equipo[i].equipo_real=auxjugador.equipo_real then
                inc(contadorclub);
            case equipo[i].posicion of
                ARQUERO:        inc(Formacion,1000);
                DEFENSOR:       inc(Formacion,100);
                MEDIOCAMPISTA:  inc(Formacion,10);
                DELANTERO:      inc(Formacion,1);
            end;
            if condicion[i]=SUPLENTE then
            case equipo[i].posicion of
                ARQUERO:        inc(FormacionSup,1000);
                DEFENSOR:       inc(FormacionSup,100);
                MEDIOCAMPISTA:  inc(FormacionSup,10);
                DELANTERO:      inc(FormacionSup,1);
            end;
            if condicion[i]=TITULAR then
            case equipo[i].posicion of
                ARQUERO:        inc(FormacionTit,1000);
                DEFENSOR:       inc(FormacionTit,100);
                MEDIOCAMPISTA:  inc(FormacionTit,10);
                DELANTERO:      inc(FormacionTit,1);
            end;
            inc(i);
        end;
        equipo[i]:=auxjugador;
        if contadorplata> PRESUPUESTO then
        begin
            writeln('Dinero insuficiente');
            valido:=false;
        end
        else
        begin
            if contadorclub = 3 then
            begin
                writeln('Solo puede tener 3 jugadores del mismo club');
                valido:=false;
            end
            else
            begin
                case equipo[i].posicion of
                    ARQUERO:
                    begin
                        formacion:= formacion div 1000;
                        if formacion = 2 then
                        begin
                            writeln('Solo puede tener 2 arqueros en el equipo');
                            valido:=false;
                        end;
                    end;
                    DEFENSOR:
                    begin
                        formacion:= (formacion div 100)mod 10;
                        if formacion = 5 then
                        begin
                            writeln('Solo puede tener 5 defensores en el equipo');
                            valido:=false;
                        end
                        else
                        begin
                            formacionsup:= (formacionsup div 100)mod 10;
                            formaciontit:=(formaciontit div 100)mod 10+(formaciontit div 10)mod 10+formaciontit mod 10;
                            if (formacionsup = 1) and( formaciontit=10) then
                            begin
                                writeln('Solo puede tener 1 suplente de cada posicion');
                                valido:=false;
                            end;
                        end;
                    end;
                    MEDIOCAMPISTA:
                    begin
                        formacion:= (formacion div 10)mod 10;
                        if formacion= 6 then
                        begin
                            writeln('Solo puede tener 6 mediocampistas en el equipo');
                            valido:=false;
                        end
                        else
                        begin
                            formacionsup:=(formacionsup div 10)mod 10;
                            formaciontit:=(formaciontit div 100)mod 10+(formaciontit div 10)mod 10+formaciontit mod 10;
                            if (formacionsup = 1) and( formaciontit=10)  then
                            begin
                                writeln('Solo puede tener 1 suplente de cada posicion');
                                valido:=false;
                            end;
                        end;
                    end;
                    DELANTERO:
                    begin
                        formacion:= formacion mod 10;
                        if formacion = 4 then
                        begin
                            writeln('Solo puede tener 4 delanteros en el equipo');
                            valido:=false;
                        end
                        else
                        begin
                            formacionsup:=formacion mod 10;
                            formaciontit:=(formaciontit div 100)mod 10+(formaciontit div 10)mod 10+formaciontit mod 10;
                            if (formacionsup = 1) and( formaciontit=10)  then
                            begin
                                writeln('Solo puede tener 1 suplente de cada posicion');
                                valido:=false;
                            end;
                        end;
                    end;
                end;
            end;
        end;
    end;
end;

{**************************************************************************************************************}
{Asigna jugador al vector de registros Equipo y en la misma posicion en el vector condicion que es paralelo al mismo pone si es titular o suplente. Leo Ojeda}
Procedure AsignarJugador(var Equipo: tVEquipo; var Condicion: tVCondicion; JugadorElegido: integer);
var
    i: byte;
    AuxJugador: tJugador;
    Formacion, Formacion2: integer;
begin
    InicializarIntegers(Formacion);
    InicializarIntegers(Formacion2);
    i:=1;
    while (Equipo[i].ID <> 0) do
    begin
        case Equipo[i].Posicion of
            ARQUERO:        inc(Formacion,1000);
            DEFENSOR:       inc(Formacion,100);
            MEDIOCAMPISTA:  inc(Formacion,10);
            DELANTERO:      inc(Formacion,1);
        end;
        if (Condicion[i] = TITULAR) then
        case Equipo[i].Posicion of
            ARQUERO:        inc(Formacion2,1000);
            DEFENSOR:       inc(Formacion2,100);
            MEDIOCAMPISTA:  inc(Formacion2,10);
            DELANTERO:      inc(Formacion2,1);
        end;
        inc(i);
    end;
    ObtenerJugador(JugadorElegido, AuxJugador);

    Equipo[i] := AuxJugador; {<= Estaba de antes,TESTEO}
    case Equipo[i].Posicion of
        ARQUERO:
        begin
            Formacion2 := Formacion div 1000;
            if Formacion2 = 1 then
                Condicion[i] := SUPLENTE;
        end;
        DEFENSOR:
        begin
            Formacion := (Formacion div 100) mod 10;
            if (Formacion = 4) then
                Condicion[i] := SUPLENTE
            else
            begin
                Formacion2 := (Formacion2 div 100) mod 10 + (Formacion2 div 10) mod 10 + Formacion2 mod 10;
                if (Formacion2 = 10) then
                    Condicion[i] := SUPLENTE;
            end;
        end;
        MEDIOCAMPISTA:
        begin
            Formacion := (Formacion div 10) mod 10;
            if Formacion = 5 then
                Condicion [i] := SUPLENTE
            else
            begin
                Formacion2 := (Formacion2 div 100) mod 10 + (Formacion2 div 10) mod 10 + Formacion2 mod 10;
                if (Formacion2 = 10) then
                    Condicion[i] := SUPLENTE;
            end;
        end;
        DELANTERO:
        begin
            Formacion := Formacion mod 10;
            if (Formacion = 3) then
                Condicion [i] := SUPLENTE
            else
            begin
                Formacion2 := (Formacion2 div 100) mod 10 + (Formacion2 div 10) mod 10 + Formacion2 mod 10;
                if (Formacion2 = 10) then
                    Condicion[i] := SUPLENTE;
            end;
        end
    end;
end;

{**************************************************************************************************************}
{Ordena la estructura Equipo teniendo en cuenta si son titulares o suplentes en primer criterio y en segundo que posicion tiene. Leo Ojeda}
Procedure OrdenarEstructura(var Equipo:tVEquipo; var Condicion:tVCondicion);
var
    Desordenado: boolean;
    AuxJugador: tJugador;
    AuxCondicion: tCondicion;
    Contador: byte;
    i: byte;

begin
    Contador := 1;
    while (Equipo[Contador].ID <> 0) do
        inc(Contador);
    Contador := Contador-1;
    if (Contador > 1) then
    begin
        Desordenado := true;
        while Desordenado do
        begin
            Desordenado := False;
            for i:=1 to Contador-1 do
            begin
                if (Equipo[i].Posicion > Equipo[i+1].Posicion) then
                begin
                    AuxJugador := Equipo[i];
                    AuxCondicion := Condicion[i];
                    Equipo[i] := Equipo[i+1];
                    Condicion[i] := Condicion[i+1];
                    Equipo[i+1] := AuxJugador;
                    Condicion[i+1] := AuxCondicion;
                    Desordenado := true;
                end;
            end;
        end;
        Desordenado := True;
        while Desordenado do
        begin
            Desordenado := false;
            for i:=1 to Contador-1 do
            begin
                if (Condicion[i] > Condicion[i+1]) then
                begin
                    AuxJugador := Equipo[i];
                    AuxCondicion := Condicion[i];
                    Equipo[i] := Equipo[i+1];
                    Condicion[i] := Condicion[i+1];
                    Equipo[i+1] := AuxJugador;
                    Condicion[i+1] := AuxCondicion;
                    Desordenado := true;
                end;
            end;
        end;
    end;
end;

{**************************************************************************************************************}
{Agrega judagadores, le pide al usuario que elija un jugador y corrobora si se puede o no agregar el mismo. Leo Ojeda}
Procedure AgregarJugador(var Equipo: tVEquipo; var Condicion: tVCondicion; var vListaJugadores:tListaJugadores);
var
    JugadorElegido: integer;
    Valido: boolean;
    Valido2: boolean;
    Menu: integer;
    Salir: boolean;
begin
    Salir := false;
    ValidarAgregar(Equipo, Valido2);
    if (Valido2) then
    begin
        repeat
            clrscr();
            writeln ('AGREGAR JUGADOR');
            BuscarJugador (JugadorElegido, Equipo, vListaJugadores);
            if (JugadorElegido = 0) then
                Salir := true
            else
            begin
                ValidarAgregarJugador(Equipo, JugadorElegido, Condicion, Valido);
                if Valido then
                begin
                    AsignarJugador(Equipo, Condicion, JugadorElegido);
                    OrdenarEstructura(Equipo, Condicion);
                    writeln ('La asignacion fue exitosa ¿Desea agragar a otro jugador?');
                    writeln ('1: Si 0: No');
                    Menu:=ValidarOpciones();
                    if (Menu = 1) then
                    begin
                        ValidarAgregar(Equipo, Valido2);
                        if (not Valido2) then
                        begin
                            writeln ('No se puede agragar mas jugadores, debe realizar cambios');
                            readkey;
                            Salir := true;
                        end
                        else
                        Salir := false;
                    end
                    else
                        Salir := true;
                end
                else
                begin
                    writeln ('Cambio no valido ¿Desea  intentarlo nuevamente?');
                    writeln ('1: Si 0: No');
                    Menu:=ValidarOpciones();
                    if (Menu = 0) then
                        Salir := true
                    else
                        Salir := false;
                end;
            end;
        until Salir;
    end
    else
    writeln ('No se pueden agregar mas jugadores, debe realizar cambios');
end;


{**************************************************************************************************************}
{Muestra la Lista de Jugadores del Equipo Actual. Leo Ojeda}
Procedure MostrarLista(var Equipo: tVEquipo; var Condicion: tVCondicion; var Contador:integer);
begin
    Contador := 1;
    writeln('':3,'CONDICION':10,'APELLIDO Y NOMBRE':29,'PRECIO':9,'EQUIPO':15,'POSICION':14);
    writeln(SEPARADORH);
    while (equipo[Contador].ID <> 0) do
        begin
        writeln(Contador:2,':':1,tCondicionAString(condicion[Contador]):10,equipo[Contador].nombre:29,(equipo[Contador].precio/1000000):8:1,'M':1,equipo[Contador].equipo_real:15, tPosicionAString(equipo[Contador].posicion):14);
        inc(Contador);
        end;
    writeln('0: Volver');
    write('Opcion: ');
    Contador := Contador-1;
end;

{**************************************************************************************************************}
{Procedimiento para eliminar jugadores. Leo Ojeda}
Procedure EliminarJugador(var Equipo: tVEquipo; var Condicion: tVCondicion);
var
    Menu: integer;
    MaxMenu, i: integer;
    AuxJugador: tJugador;
    AuxCondicion: tCondicion;
begin
    repeat
        clrscr();
        writeln('MENU ELIMIAR');
        writeln(SEPARADORH);
        writeln('Seleccione un Jugador');
        MostrarLista(Equipo, Condicion, MaxMenu);
        ValidarMenu(Menu, MaxMenu);
        if (Menu <> 0) then
        begin
            InicializarIntegers(Equipo[Menu].ID);
            for i:=Menu to JUGADORESXEQUIPO do
            begin
                AuxJugador := Equipo[i];
                AuxCondicion := Condicion[i];
                Equipo[i] := Equipo[i+1];
                Condicion[i] := Condicion[i+1];
                Equipo[i+1] := AuxJugador;
                Condicion[i+1] := AuxCondicion;
            end;
        end;
    until (Menu = 0);
end;

{**************************************************************************************************************}
{Validar asignación de suplentes. Leo Ojeda}
Procedure ValidarAsignarSuplente(var Equipo: tVEquipo; var Condicion: tVCondicion; JugElegido: byte; var Valido: boolean);
var
    i: byte;
    FormacionSup: integer;
begin
    Valido := true;
    i := 1;
    FormacionSup:=0;
    if (Condicion[JugElegido] = TITULAR) then
    begin
        while (Equipo[i].ID <> 0) do
        begin
            if (Condicion[i] = SUPLENTE) then
                case Equipo[i].Posicion of
                    ARQUERO: inc(FormacionSup,1000);
                    DEFENSOR: inc(FormacionSup,1000);
                    MEDIOCAMPISTA: inc(FormacionSup,10);
                    DELANTERO: inc(FormacionSup,1);
                end;
            inc(i);
        end;
        case Equipo[JugElegido].Posicion of
            ARQUERO:
            begin
                FormacionSup := FormacionSup div 1000;
                if (FormacionSup = 1) then;
                begin
                    writeln('Ya hay un suplente en esa posicion');
                    Valido := false;
                end;
            end;
            DEFENSOR:
            begin
                FormacionSup := (FormacionSup div 100) mod 10;
                if (FormacionSup = 1) then;
                begin
                    writeln('Ya hay un suplente en esa posicion');
                    Valido := false;
                end;
            end;
            MEDIOCAMPISTA:
            begin
                FormacionSup := (FormacionSup div 10) mod 10;
                if (FormacionSup = 1) then;
                begin
                    writeln('Ya hay un suplente en esa posicion');
                    Valido := false;
                end;
            end;
            DELANTERO:
            begin
                FormacionSup := FormacionSup mod 10;
                if FormacionSup = 1 then;
                begin
                    writeln('Ya hay un suplente en esa posicion');
                    Valido := false;
                end;
            end;
        end;
    end
    else
    begin
        writeln('El jugador ya es suplente');
        Valido := false;
    end;
end;

{**************************************************************************************************************}
{Asignacion de suplentes. Leo Ojeda}
Procedure AsignarSuplente(var Equipo: tVEquipo; var Condicion: tVCondicion);
var
    Menu,MaxMenu: integer;
    Valido: boolean;
begin
    repeat
        clrscr();
        writeln('MENU ASIGNAR SUPLENTE');
        writeln(SEPARADORH);
        writeln('Seleccione un Jugador');
        MostrarLista(Equipo, Condicion, MaxMenu);
        ValidarMenu(Menu, MaxMenu);
        ValidarAsignarSuplente(Equipo, Condicion, Menu, Valido);
        if Valido then
        begin
            Condicion[Menu] := SUPLENTE;
            OrdenarEstructura(Equipo, Condicion);
        end;
    until (Menu = 0);
end;


{**************************************************************************************************************}
{Cambio de estructuras. Leo Ojeda}
Procedure CambioDeEstructuraIda(var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO; FechaActual: byte; Cambios: byte);
var
    i: byte;
    Formacion: integer;
begin
    InicializarIntegers(Formacion);
    for i:=1 to JUGADORESXEQUIPO do
    begin
        RegEquipo.Condicion[i] := Condicion[i];
        RegEquipo.ID[i]:= Equipo[i].ID;
        if Condicion[i] = TITULAR then
            case Equipo[i].Posicion of
                DEFENSOR: Formacion := Formacion +100;
                MEDIOCAMPISTA: Formacion := Formacion +10;
                DELANTERO: Formacion := Formacion +1;
            end;
        end;
        if (FechaActual <> 0) then
        begin
            RegEquipo.Formacion[FechaActual] := Formacion;
            RegEquipo.Cambios[FechaActual]:= Cambios;
            RegEquipo.TotalCambios := RegEquipo.TotalCambios + Cambios;
        end;
end;

{**************************************************************************************************************}
{Cambio de estructuras. Leo Ojeda}
Procedure CambiarEstructuraVuelta(var RegEquipo: TRegEQUIPO; var Equipo: tVEquipo; var Condicion: tVCondicion);
var
    i: byte;
    AuxJugador: tJugador;
begin
    for i:=1 to JUGADORESXEQUIPO do
    begin
        ObtenerJugador(RegEquipo.ID[i], AuxJugador);
        Equipo[i] := AuxJugador;
        Condicion[i] := RegEquipo.Condicion[i];
    end;
end;


{**************************************************************************************************************}
{Modulo de LISTA DE JUGADORES DEL EQUIPO. Leo Ojeda}
Procedure ListaJugadoresEquipo(var Equipo:tVEquipo; var Condicion: tVCondicion);
    var
        CantJugadoresEquipo:SmallInt;
    begin
        clrscr();
        writeln('LISTA DE JUGADORES DE SU EQUIPO');
        writeln();
        CantJugadoresEquipo:=1;
        while (equipo[CantJugadoresEquipo].ID <> 0) do
            inc(CantJugadoresEquipo);
        dec(CantJugadoresEquipo);
        writeln('Hay ',CantJugadoresEquipo,' jugadores en el equipo');
        writeln(SEPARADORH);
        MostrarLista(Equipo, Condicion, CantJugadoresEquipo);
        readkey;
    end;


{**************************************************************************************************************}
{Permite que el usuario arme el equipo. Leo Ojeda}
Procedure EditarEquipo (var FechaActual: byte; var TipoUsuario: byte; var vUsuarios: tUsuarios; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador;
CantUsuarios: byte; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores:tElegidoJugadores; var vListaJugadores: tListaJugadores;
UsuarioActual:byte; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);
var
    Menu: integer;
    Salir: boolean;
    MaxMenu, Contador, Cambios: byte; // NO SE USA CantidadJug: byte
    // NO SE USA Plata: real;
begin
        InicializartVEquipo(equipo);
        Salir := false;
        writeln(SEPARADORH);
        // NO SE USA Plata:=0;
    repeat
        clrscr();
        ImprimirTitulo(FechaActual);
        writeln('CONFIGURACION DEL EQUIPO');
        writeln(SEPARADORH);
        writeln('1 - Agregar jugardor');
        writeln('2 - Quitar jugador');
        writeln('3 - Asignar a un jugador como suplente');
        writeln('4 - Mostrar lista de jugadores');
        writeln('0 - Volver');
        write('Opcion: ');
        Menu := ValidarOpciones();
        case Menu of
        1: AgregarJugador(Equipo, Condicion, vListaJugadores);
        2: EliminarJugador(Equipo, Condicion);
        3: AsignarSuplente(Equipo, Condicion);
        4: ListaJugadoresEquipo(Equipo, Condicion);
        0: begin
            Contador := 1;
            while (EQUIPO[Contador].ID <> 0) do
                inc(Contador);
            if (Contador = 16) then
            begin
                Cambios := 0;
                CambioDeEstructuraIda(EQUIPO, CONDICION, RegEquipo, FechaActual, Cambios);
                salir:=true;
            end
            else
            begin
                writeln ('El equipo no esta terminado ¿desea salir y perder los cambios?');
                writeln ('0:no');
                writeln ('1:si');
                Salir := true;
                Maxmenu := 1;
                ValidarMenu(Menu, MaxMenu);
                if (Menu = 1) then
                Salir := true;
            end;
           end;
    end;
    until (Salir = true);
    If (TipoUsuario = 0) then
        MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
        UsuarioActual, Equipo, Condicion, RegEquipo)
    else
        MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
        UsuarioActual, Equipo, Condicion, RegEquipo);{//falta... los que falta es asignar el equipo a otra estructura que es la que vimos con pipo.obviamente hay que pasar esa estructura como parametro}
end;

{**************************************************************************************************************}
{Valida los cambios. Leo Ojeda}
Procedure ValidarCambio(var Equipo: tVEquipo; var Condicion: tVCondicion; JugadorEjegido: integer; Menu:byte; var Valido: boolean; var vListaJugadores:tListaJugadores);
var
JugadorElegido: integer;
begin
    Equipo[Menu].ID := 0;
    OrdenarEstructura(Equipo, Condicion);
    BuscarJugador (JugadorElegido, Equipo, vListaJugadores);
    ValidarAgregarJugador(Equipo, JugadorElegido, Condicion, Valido);
end;

{**************************************************************************************************************}
{Realiza los cambios. Leo Ojeda}
Procedure RealizarCambio(var Equipo: tVEquipo; var Condicion: tVCondicion; JugadorElegido: integer; Menu: byte);
begin
    Equipo[Menu].ID :=  0;
    OrdenarEstructura(Equipo, Condicion);
    AsignarJugador(Equipo, Condicion, JugadorElegido);
end;

{**************************************************************************************************************}
{Realiza los intercambios de jugadores. Leo Ojeda}
Procedure CambiarJugadorLista(var Equipo: tVEquipo; var Condicion: tVCondicion; var ContadorCambio: byte; var vListaJugadores:tListaJugadores);
var
    Menu, MaxMenu, JugadorElegido: integer;
    Valido: boolean;
begin
    repeat
        writeln('Elija el jugador que desea modificar');
        MostrarLista(Equipo, Condicion, MaxMenu);
        writeln('0: Salir');
        ValidarMenu(Menu, MaxMenu);
        if (Menu <> 0) then
        begin
            BuscarJugador (JugadorElegido, Equipo, vListaJugadores);
            if (JugadorElegido <> 0) then
            begin
                ValidarCambio(Equipo, Condicion, JugadorElegido, Menu, Valido, vListaJugadores);
                if (Valido) then
                begin
                    RealizarCambio(Equipo, Condicion, JugadorElegido, Menu);
                    inc(ContadorCambio);
                end
                else
                write ('El cambio no es correcto');
            end;
        end;
    until (menu = 0);
end;

{**************************************************************************************************************}
{Gestiona los cambios entre fechas. Leo Ojeda}
Procedure CambiosFecha (var RegEquipo: TRegEQUIPO; FechaActual: byte; var vListaJugadores:tListaJugadores);{********* FALTAN COSAS *********}
var
    Condicion: tVCondicion;
    Equipo: tVEquipo;
    MaxMenu, Cambios: byte;
    Menu, CantidadJug: integer;
    Salir: boolean;
    // NO SE USA plata: real;
begin
    CambiarEstructuraVuelta(RegEquipo, Equipo, Condicion);
    Salir := false;
    writeln('CONFIGURACION EQUIPO');
    writeln(SEPARADORH);
    InicializarBytes(Cambios);
    repeat
        writeln('ARMA TU EQUIPO');
        writeln('1:cambiar jugador suplente por titular');
        writeln('2:cambiar jugador de la lista general');
        writeln('4:mostrar lista de jugadores');
        writeln('0:salir');
        MaxMenu := 3;
        ValidarMenu(Menu, MaxMenu);
        case Menu of
            1:writeln('esto no esta terminado');{ cambiarsuplentextitular(EQUIPO,CONDICION);  }
            {pipo por favor fijate si podes hacer esto que vos la tenes mas clara esto cambia titular por suplente}
            {el usuario pude cambiar todos los suplentes y ponerlos a jugar, el unico limite que tenia de cambios era cuando cambiava jugadores en la lista general}
            {estos cambios pueden llegar a modificar la formacion pero igual no te preocupes por eso por que lo evaluo al final de este precedimiento}
            {lo importante es que no se cambie arquero por defensor, pero si puede haber cambio de delantero por mediocampista. etc,}
            2:begin
                if (FechaActual <> 1) then
                begin
                    if (Cambios + RegEquipo.Cambios[FechaActual-1] = 4) then
                        writeln ('No se pueden realizar mas cambios. Solo se permiten 4 cada dos fechas')
                    else
                    begin
                        if (Cambios = 4) then
                            writeln ('No se pueden realizar mas cambios. Solo se permiten 4 cada dos fechas')
                        else
                            CambiarJugadorLista(Equipo, Condicion, Cambios, vListaJugadores);
                    end;
                end;
            end;
            3:begin
                MostrarLista(Equipo, Condicion, CantidadJug);
                readkey;
            end;
            0:begin
                CambioDeEstructuraIda(Equipo, Condicion,RegEquipo, FechaActual, Cambios);
                Salir := true;
            end;
        end;
    until Salir;
end;

{CUIDADO
 FIN CODIGO DE LEO}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

{**************************************************************************************************************}
{Llama a la funcion crear equipo. Ronnie Del Pino}
Procedure CrearEquipo(var TipoUsuario: byte; FechaActual: byte; var vUsuarios: tUsuarios; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores:tElegidoJugadores; var vListaJugadores: tListaJugadores; var UsuarioActual: byte;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

begin
    if (FechaActual = 0) then
        begin
        {UsuariosEquipo_a_tRegEQUIPO(vUsuarios,RegEquipo,UsuarioActual,FechaActual);}{TESTEO}
        EditarEquipo(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
        UsuarioActual, Equipo, Condicion, RegEquipo);
        end
    else
        begin
        writeln;
        write('El Torneo ha empezado. No pueden crear equipos!');
        delay(TIEMPO_SALIDA);
        if (TipoUsuario = 0) then
            MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
            UsuarioActual, Equipo, Condicion, RegEquipo)
        else
            MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
            UsuarioActual, Equipo, Condicion, RegEquipo);
        end;
end;

{**************************************************************************************************************}
{Lanzador del procedimiento de cambios en equipos. Ronnie Del Pino}
Procedure RealizarCambios(var TipoUsuario: byte; FechaActual: byte; var vUsuarios: tUsuarios; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores:tElegidoJugadores; var vListaJugadores: tListaJugadores; UsuarioActual: byte;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

begin
    if (FechaActual > 0) then
        begin
        //PROCEDIMIENTO CAMBIOS EN EQUIPOS
        end
    else
        begin
        writeln;
        write('El Torneo no ha empezado. No pueden realizar cambios!');
        delay(TIEMPO_SALIDA);
        if (TipoUsuario = 0) then
            MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
            UsuarioActual, Equipo, Condicion, RegEquipo)
        else
            MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
            UsuarioActual, Equipo, Condicion, RegEquipo);
        end;
end;

{**************************************************************************************************************}
{Ricardo Ariel Sosa Aquino}
Procedure SwapUsuario(var Usuario1: tUsuario; var Usuario2: tUsuario);
var
    AuxUsuario: tUsuario;
begin
    AuxUsuario := Usuario1;
    Usuario1 := Usuario2;
    Usuario2 := AuxUsuario;
end;

{**************************************************************************************************************}
{OrdernarUsuariosxPuntaje. Ricardo Ariel Sosa Aquino}
Procedure OrdernarUsuariosxPuntaje (var vUsuarios: tUsuarios; USUARIOS: byte; FECHAS: byte);
var
    i,j,k, PuntajeAcum1,PuntajeAcum2, CambiosAcum1, CambiosAcum2: integer;
    Ordenado: boolean;
    PrecioAcum1, PrecioAcum2: real;
begin
    i := 1;
    Ordenado := false;
    while (i<=USUARIOS) and (not(Ordenado)) do
    begin
        Ordenado := true;
        InicializarIntegers(PuntajeAcum1);
        InicializarReals(PrecioAcum1);
        CambiosAcum1 := PuntajeAcum1 + vUsuarios[i].Equipo.CantCambiosAcum;
        for j:=1 to USUARIOS-i do
        begin
            InicializarIntegers(PuntajeAcum2);
            InicializarReals(PrecioAcum2);
            CambiosAcum2 := PuntajeAcum2 + vUsuarios[j].Equipo.CantCambiosAcum;
            for k:=1 to FECHAS do
            begin
                if (j = 1) then
                begin
                    PuntajeAcum1 := PuntajeAcum1 + vUsuarios[i].Equipo.Puntaje[k];
                    PrecioAcum1 := PrecioAcum1 + vUsuarios[i].Equipo.Precio[k];
                end;
                PuntajeAcum2 := PuntajeAcum2 + vUsuarios[j].Equipo.Puntaje[k];
                PrecioAcum2 := PrecioAcum2 + vUsuarios[j].Equipo.Precio[k];
            end;
            if (PuntajeAcum2 > PuntajeAcum1) then
                Ordenado := false
            else
                if (PuntajeAcum2 = PuntajeAcum1) and (CambiosAcum2 < CambiosAcum1) then
                    Ordenado := false
                else
                    if (PuntajeAcum2 = PuntajeAcum1) and (CambiosAcum2 = CambiosAcum1) and (PrecioAcum2 > PrecioAcum1) then
                    Ordenado := false;
            if (not(Ordenado)) then
            begin
                PuntajeAcum1 := PuntajeAcum2;
                CambiosAcum1 := CambiosAcum2;
                PrecioAcum1 := PrecioAcum2;
                SwapUsuario(vUsuarios[i], vUsuarios[j]);
            end;
        end;
        inc(i);
    end;
end;

{**************************************************************************************************************}
{Muestra Tabla de Posiciones. Ricardo Ariel Sosa Aquino}
Procedure MostrarTablaDePosiciones (var vUsuarios: tUsuarios; USUARIOS: byte; FECHAS: byte);
var
    i,j: integer;
    PuntajeAcum, CambiosAcum: integer;
    PrecioAcum: real;
begin
    Writeln('Equipo':10,'Puntaje':12,'Fechas':12,'Ganadas':12,'N Cambios':12,'Presupuesto Promedio':22);
    for i:=1 to USUARIOS do
    begin
        InicializarIntegers(PuntajeAcum);
        InicializarIntegers(CambiosAcum);
        InicializarReals(PrecioAcum);
        for j:=1 to FECHAS do
        begin
            PuntajeAcum := PuntajeAcum + vUsuarios[i].Equipo.Puntaje[j];
            if (vUsuarios[i].Equipo.Tactica[j] <> vUsuarios[i].Equipo.Tactica[j+1]) and (not(j+1=FECHAS)) then
                inc(CambiosAcum);
            PrecioAcum := PrecioAcum + vUsuarios[i].Equipo.Precio[j];
        end;
        Write(vUsuarios[i].ID:8);
        Write(PuntajeAcum:10);
        Write(vUsuarios[i].Equipo.CantFechasGanadas:10);
        Write(CambiosAcum:12);
        Writeln((PrecioAcum/FECHAS):22:0);
    end;
end;

{**************************************************************************************************************}
{Muestra los Resultado de las Apuestas. Ricardo Ariel Sosa Aquino}
Procedure MostrasResultadosDeApuestas(var vListaApuestas: tListaApuestas; var vUsuarios: tUsuarios; USUARIOS: byte; FECHAS: byte);
var
    i,j,k, GanadoresxFecha, Campeones, Subcampeones, Puntaje1, Puntaje2: integer;
    Apuesta, GanadoxMedalla, GanadoxFecha, GastadoxFecha1, GastadoxFecha2: real;
    EsGanador, EsCampeon, EsSubcampeon, EsTercero: boolean;
begin
    Apuesta := (vListaApuestas[1] * FECHAS + vListaApuestas[2] + vListaApuestas[3] + vListaApuestas[4]) / USUARIOS;
    Writeln('Pozo por fecha: ', vListaApuestas[1]);
    Writeln('Medalla de Oro: ', vListaApuestas[2]);
    Writeln('Medalla de Plata: ', vListaApuestas[3]);
    Writeln('Medalla de Bronce: ', vListaApuestas[4]);
    Writeln('Nombre - Equipo - Apuesta - Ganancia por fecha - Ganancia por Torneo - Ganancia Total');
    for i:=1 to USUARIOS do
    begin
        Write(vUsuarios[i].Nombre);
        Write(' - Equipo ', vUsuarios[i].ID);
        Write(' - ', Apuesta);
        InicializarIntegers(Puntaje1);
        InicializarIntegers(Puntaje2);
        InicializarIntegers(Campeones);
        InicializarReals(GastadoxFecha1);
        InicializarReals(GanadoxMedalla);
        Subcampeones := 1;
        EsCampeon := true;
        EsSubcampeon := true;
        EsTercero := true;
        for j:=1 to USUARIOS do
        begin
            InicializarReals(GastadoxFecha2);
            for k:=1 to FECHAS do
            begin
                if (i = 1) then
                begin
                    Puntaje1 := Puntaje1 + vUsuarios[i].Equipo.Puntaje[k];
                    GastadoxFecha1 := GastadoxFecha1 + vUsuarios[i].Equipo.Precio[k];
                end;
                GastadoxFecha2 := GastadoxFecha2 + vUsuarios[j].Equipo.Precio[k];
                Puntaje2 := Puntaje2 + vUsuarios[j].Equipo.Puntaje[k];
            end;
            if (EsTercero) then
            begin
                if (Puntaje1 < Puntaje2) then
                begin
                    if (not(EsCampeon)) then
                        begin
                            if (not(EsSubcampeon)) then
                                EsTercero := false;
                            EsSubcampeon := false;
                        end;
                    EsCampeon := false;
                    inc(Campeones);
                end
                else
                if (Puntaje1 = Puntaje2) and (vUsuarios[i].Equipo.CantFechasGanadas < vUsuarios[j].Equipo.CantFechasGanadas) then
                begin
                    if (not(EsCampeon)) then
                        begin
                            if (not(EsSubcampeon)) then
                                EsTercero := false;
                            EsSubcampeon := false;
                        end;
                    EsCampeon := false;
                    inc(Campeones);
                end
                else
                if (Puntaje1 = Puntaje2) and (vUsuarios[i].Equipo.CantFechasGanadas = vUsuarios[j].Equipo.CantFechasGanadas) and (GastadoxFecha1 < GastadoxFecha2) then
                begin
                    if (not(EsCampeon)) then
                        begin
                            if (not(EsSubcampeon)) then
                                EsTercero := false;
                            EsSubcampeon := false;
                        end;
                    EsCampeon := false;
                    inc(Campeones);
                end
                else
                if (Puntaje1 = Puntaje2) and (vUsuarios[i].Equipo.CantFechasGanadas = vUsuarios[j].Equipo.CantFechasGanadas) and (GastadoxFecha1 = GastadoxFecha2) then
                begin
                    if (EsCampeon) then
                        inc(Campeones);
                    if (EsSubcampeon) then
                        inc(Subcampeones);
                end
            end;
        end;
        if (EsCampeon) then
            if (Campeones < 2) then
                GanadoxMedalla := vListaApuestas[2]
            else
            if (Campeones < 3) then
                GanadoxMedalla := (vListaApuestas[2] + vListaApuestas[3]) / Campeones
            else
            GanadoxMedalla := (vListaApuestas[2] + vListaApuestas[3] + vListaApuestas[4]) / Campeones
        else
        if (EsSubcampeon) and (Campeones < 3) then
            if (Campeones < 2) then
                if (Subcampeones > 1) then
                    GanadoxMedalla := (vListaApuestas[3] + vListaApuestas[4]) / Subcampeones
                else
                    write(vListaApuestas[3])
            else
            if (Campeones < 3) then
                GanadoxMedalla := vListaApuestas[4] / Subcampeones
        else
        if EsTercero and (Campeones + Subcampeones < 3)then
            GanadoxMedalla := vListaApuestas[4];
        write(' - ', GanadoxMedalla);
        if (vUsuarios[i].Equipo.CantFechasGanadas > 0) then
        begin
            InicializarReals(Ganadoxfecha);
            for j:=1 to FECHAS do
            begin
                GanadoresxFecha := 1;
                k := 1;
                EsGanador := true;
                while (k <= USUARIOS) and (EsGanador) do
                begin
                    if (vUsuarios[i].Equipo.Puntaje[j] < vUsuarios[k].Equipo.Puntaje[j]) then
                        EsGanador := false
                    else
                    if (vUsuarios[i].Equipo.Puntaje[j] = vUsuarios[k].Equipo.Puntaje[j]) and (vUsuarios[i].Equipo.Precio[k] < vUsuarios[k].Equipo.Precio[j]) then
                        esganador:=false
                    else
                    if (vUsuarios[i].Equipo.Puntaje[j] = vUsuarios[k].Equipo.Puntaje[j]) and (vUsuarios[i].Equipo.Precio[k] = vUsuarios[k].Equipo.Precio[j]) then
                        inc(GanadoresxFecha);
                    inc(k);
                end;
                if EsGanador then
                    GanadoxFecha := GanadoxFecha + vListaApuestas[1] / GanadoresxFecha;
            end;
            write(' - ', GanadoresxFecha);
        end
        else
            write(' - 0');
    end;
end;

{**************************************************************************************************************}
{Muestra los resultados de la ultima fecha. Ricardo Ariel Sosa Aquino}
Procedure ResultadosDeLaFecha (var PuntajeJugador: tPuntajeJugador; JUGADORES: integer; FECHA: integer);
var
    i: integer;
    Seguir: char;
begin
    i := 1;
    Seguir := 'S';
    writeln('Jugador - Puntaje');
    while (i < JUGADORES) and (upcase(Seguir)='s') do
    begin
        write('Jugador ', i , ' - ', PuntajeJugador[i, FECHA]);
        inc(i);
        readln(Seguir);
    end;
end;

{**************************************************************************************************************}
{Muestra la Tabla de Posiciones hasta la fecha actual. Ricardo Ariel Sosa Aquino}
Procedure ImprimirTablaDePosiciones (var vUsuarios: tUsuarios; USUARIOS: byte; FECHAS: byte);
begin
    OrdernarUsuariosxPuntaje (vUsuarios, USUARIOS, FECHAS);
    MostrarTabladePosiciones (vUsuarios, USUARIOS, FECHAS);
end;

{**************************************************************************************************************}
{Imprime una Lista de los Mejores Jugadores. Juan Manuel Castro Pippo}
Procedure ImprimirMejoresJugadores(var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vListaJugadores: tListaJugadores);
var
    i,j,k, AuxID: integer;
    Jugador: tJugador;
    Top, ElementosxPagina, Tecla: byte;
begin
    InicializarBytes(Tecla);
    i := 1;
    k := 1;
    Top := 25;
    ElementosxPagina := 15;
    while (Tecla <> LETRA_S) do
        begin
        clrscr();
        writeln('25 MEJORES JUGADORES EN LO QUE VA DEL TORNEO');
        writeln('');
        writeln('POS':5,'APELLIDO Y NOMBRE':29,'POSICION':16,'EQUIPO':15,'ACUMULADO':15);
        writeln(SEPARADORH);
        j := 1;
        if (i > JUGADORES) then
            i := 1;
        if (k > Top) then
        begin
            k := 1;
            i := 1;
        end;
        while (j <= ElementosxPagina) and (k <= Top) do
        begin
            AuxID := vPuntajeTotalJugadores[i].ID;
            Jugador := vListaJugadores[AuxID];
            writeln(k:5,Jugador.Nombre:29,tPosicionAString(Jugador.Posicion):16,Jugador.Equipo_Real:15,vPuntajeTotalJugadores[i].PuntajeTotal:15);
            inc(k);
            inc(j);
            inc(i);
        end;
        writeln(SEPARADORH);
        write('Volver al menu anterior?: ');
        Tecla := ord(upcase(readkey));
        end;
end;

{**************************************************************************************************************}
{Imprime Jugadores segun la posicion. Juan Manuel Castro Pippo}
Procedure JugadorFavoritoPosicion(var vListaJugadores: tListaJugadores; var vElegidoJugadores: tElegidoJugadores; CantUsuarios: byte; Posicion: tPosicion; Min: byte; Max: byte);
var
    i,j, Aux:integer;
begin
    i := 1;
    j := 1;
    while (j <= Max) do
    begin
        Aux := vElegidoJugadores[i].ID;
        if (vListaJugadores[Aux].Posicion = Posicion) then
        begin
            if (j <= Max) and (j >= Min) then
            writeln(vListaJugadores[Aux].Nombre:30,tPosicionAString(vListaJugadores[Aux].Posicion):25,vElegidoJugadores[i].Valor:25);
            inc(j);
        end;
        inc(i);
    end;
end;

{**************************************************************************************************************}
{Devuelve la ID de la Tactica Mas Usada. Juan Manuel Castro Pippo}
Function ObtenerTacticas(var vTacticas:tTacticas; CantUsuarios: byte): byte;
begin
    ObtenerTacticas := vTacticas[1].ID;
end;

{**************************************************************************************************************}
{Imprime el EquipoFavorito. Juan Manuel Castro Pippo}
Procedure EquipoFavorito(var vListaJugadores: tListaJugadores; var vElegidoJugadores: tElegidoJugadores; var vTacticas: tTacticas; CantUsuarios: byte);
var
    Arq, Def, Med, Del, Tecla: byte;
begin
    Tecla:=20;
    clrscr();
    writeln('EQUIPO FAVORITO');
    writeln();
    Arq := 1;
    case (ObtenerTacticas(vTacticas, CantUsuarios)) of
        1:
        begin
            Def := 3;
            Med := 4;
            Del := 3;
        end;
        2:
        begin
            Def := 3;
            Med := 5;
            Del := 2;
        end;
        3:
        begin
            Def := 4;
            Med := 3;
            Del := 3;
        end;
        4:
        begin
            Def := 4;
            Med := 4;
            Del := 2;
        end;
        5:
        begin
            Def := 4;
            Med := 5;
            Del := 1;
        end;
    end;
    writeln('JUGADORES DEL EQUIPO':30,'POSICION':25,'VECES ELEGIDO':25);
    writeln(SEPARADORH);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, ARQUERO, 1, Arq);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, DEFENSOR, 1, Def);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, MEDIOCAMPISTA, 1, Med);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, DELANTERO, 1, Del);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, ARQUERO, Arq+1, Arq+1);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, DEFENSOR, Def+1, Def+1);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, MEDIOCAMPISTA, Med+1, Med+1);
    JugadorFavoritoPosicion(vListaJugadores, vElegidoJugadores, CantUsuarios, DELANTERO, Del+1, Del+1);
    writeln(SEPARADORH);
    write('Volver al menu anterior?: ');
    while (Tecla<>LETRA_S) do
    Tecla := ord(upcase(readkey));
end;

{**************************************************************************************************************}
{Menu de Reportes. Ronnie del Pino}
Procedure MenuCorrerReportes(var vUsuarios: tUsuarios; var TipoUsuario: byte; FechaActual: byte; CantUsuarios: byte; var vPuntajeJugador: tPuntajeJugador;
var vListaApuestas: tListaApuestas; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vElegidoJugadores: tElegidoJugadores; var vTacticas: tTacticas;
var vListaJugadores: tListaJugadores; UsuarioActual: byte; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    Opcion:byte;
begin
    if (FechaActual <> 0) then
    begin
        ImprimirTitulo(FechaActual);
                  writeln('1 - Tabla de posiciones');
                  writeln('2 - Resultados por fecha');
                  writeln('3 - Resultado de apuestas');
                  writeln('4 - Mejores jugadores');
                  writeln('5 - Mejores jugadores por puesto');
                  writeln('6 - Equipo favorito');
                  writeln('0 - Volver');
                  write('Opcion: ');
                  Opcion := ValidarOpciones();
        case Opcion of
                1: ImprimirTablaDePosiciones (vUsuarios, CantUsuarios, FechaActual);
                2: ResultadosDeLaFecha (vPuntajeJugador, JUGADORES, FechaActual);
                3: MostrasResultadosDeApuestas(vListaApuestas, vUsuarios, CantUsuarios, FechaActual);
                4: ImprimirMejoresJugadores(vPuntajeTotalJugadores, vListaJugadores);
                5: ReportesMenuResultadosPorPuesto(vUsuarios, TipoUsuario, vPuntajeTotalJugadores, vListaJugadores, FechaActual, CantUsuarios, vPuntajeJugador, vListaApuestas, vElegidoJugadores,
                   vTacticas, UsuarioActual, Equipo, Condicion, RegEquipo);
                6: EquipoFavorito(vListaJugadores, vElegidoJugadores, vTacticas, CantUsuarios);
                0: begin
                    if (TipoUsuario = 0) then
                        MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                        UsuarioActual, Equipo, Condicion, RegEquipo)
                    else
                        MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                        UsuarioActual, Equipo, Condicion, RegEquipo);
                    end;
                 else
                    MenuCorrerReportes(vUsuarios, TipoUsuario, FechaActual, CantUsuarios, vPuntajeJugador, vListaApuestas, vPuntajeTotalJugadores, vElegidoJugadores, vTacticas, vListaJugadores,
                    UsuarioActual, Equipo, Condicion, RegEquipo);
        end;
    end
    else
    begin
        writeln;
        write('El Torneo no ha empezado. No puede ver reportes!');
        delay(TIEMPO_SALIDA);
        if (TipoUsuario = 0) then
            MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
            UsuarioActual, Equipo, Condicion, RegEquipo)
        else
            MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores, UsuarioActual,
            Equipo, Condicion, RegEquipo);
    end;
end;

{**************************************************************************************************************}
{Pide datos de premios para apuestas y los guarda. Ronnie Del Pino}
Procedure ConfigurarApuestas(var vUsuarios: tUsuarios; var vListaApuestas: tListaApuestas; FechaActual: byte; TipoUsuario: byte; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; UsuarioActual: byte; var vListaJugadores: tListaJugadores;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    j, Cant: byte;
begin
    if (FechaActual = 0) then
    begin
        Cant := 3;
        ImprimirTitulo(FechaActual);
        writeln('Premios(',SIMBOLO_MONEDA, '):');
        writeln;
        write('Fecha Ganada: ');
        vListaApuestas[1]:=ValidarNumerosCifras(Cant);writeln;
        write('Campeon del  Torneo: ');
        vListaApuestas[2]:=ValidarNumerosCifras(Cant);writeln;
        write('Subcampeon del Torneo: ');
        vListaApuestas[3]:=ValidarNumerosCifras(Cant);writeln;
        write('Tercer Puesto: ');
        vListaApuestas[4]:=ValidarNumerosCifras(Cant);writeln;
        writeln;
        writeln('La siguiente configuracion sera guardada:');
        writeln('Ganador de La fecha: ',SIMBOLO_MONEDA ,vListaApuestas[1]);
        writeln('Campeon: ', SIMBOLO_MONEDA,vListaApuestas[2]);
        writeln('SubCampeon: ',SIMBOLO_MONEDA ,vListaApuestas[3]);
        writeln('Tercer Puesto: ',SIMBOLO_MONEDA ,vListaApuestas[4]);
        writeln;
        writeln('Presione una tecla para continuar...');
        readkey;
        For j:=1 to MAX_USUARIOS do
                begin
                vUsuarios[j].CantidadApuesta:=((FECHAS_TORNEO*vListaApuestas[1]) + vListaApuestas[2] + vListaApuestas[3] + vListaApuestas[4]) / (CantidadParticipantes(vUsuarios));
                InicializarReals (vUsuarios[j].GananciaPorFechas);
                InicializarReals (vUsuarios[j].GananciaPorTorneo);
                end;
        MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
        UsuarioActual, Equipo, Condicion, RegEquipo)
    end
    else
    begin
        writeln;
        write('El Torneo ha empezado. No puede configurar apuestas!');
        delay(TIEMPO_SALIDA);
        MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
        UsuarioActual, Equipo, Condicion, RegEquipo)
    end;
end;

{**************************************************************************************************************}
{Verifica que todos los equipos esten completos. Emanuel Kotzayan}
Function ChequearEquiposCompletos(var vUsuarios: tUsuarios): boolean;
var
    i, j: integer;
    EquiposCompletos: boolean;
begin
    i := 1;
    EquiposCompletos := true;
    while (i <= CantidadParticipantes(vUsuarios)) and (EquiposCompletos) do
    begin
        j := 1;
        while (j <= JUGADORESXEQUIPO) and (EquiposCompletos) do
        begin
            if vUsuarios[i].Equipo.Jugador[j].ID = 0 then
                EquiposCompletos := false;
            inc(j);
        end;
        inc(i);
    end;
    ChequearEquiposCompletos := EquiposCompletos;
end;

{**************************************************************************************************************}
{Aumenta la fecha actual. Emanuel Kotzayan}
Procedure AumentarFecha (var FechaActual: byte);
begin
    inc(FechaActual);
end;

{**************************************************************************************************************}
{Calculo del puntaje de cada jugador en la fecha actual. Emanuel Kotzayan}
Procedure CalcularPuntajeJugador (var vPuntajeJugador: tPuntajeJugador; FechaActual: byte);
var
    i: integer;
begin
    for i:=1 to JUGADORES do
        begin
        if (jugoPartido(i) = true) then
            vPuntajeJugador[i, FechaActual] := ObtenerPuntajeJugador(i)
        else
            InicializarIntegers(vPuntajeJugador[i, FechaActual]);
        end;
end;

{**************************************************************************************************************}
{Calculo del puntaje total de cada jugador. Juan Manuel Castro Pippo}
Procedure CalcularPuntajeTotalJugador (var vPuntajeJugador: tPuntajeJugador; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; FechaActual: byte);
var
    i, j: integer;
begin
    for i:=1 to JUGADORES do
    begin
        j := 1;
        vPuntajeTotalJugadores[i].ID := i;
        InicializarIntegers(vPuntajeTotalJugadores[i].PuntajeTotal);
        while (j <= FechaActual) do
            inc(vPuntajeTotalJugadores[i].PuntajeTotal, vPuntajeJugador[i,j]);
        end;
end;

{**************************************************************************************************************}
{Calculo del puntaje de cada equipo en la fecha actual. Emanuel Kotzayan}
Procedure CalcularPuntajeEquipo (var vUsuarios: tUsuarios; var vPuntajeJugador: tPuntajeJugador; FechaActual: byte);
var
    i, j, Acumulador: integer;
begin
    for i:=1 to MAX_USUARIOS do
        begin
            InicializarIntegers(Acumulador);
            for j:=1 to JUGADORESXEQUIPO  do
                begin
                    if (vUsuarios[i].Equipo.Jugador[j].Condicion = TITULAR) then
                    Acumulador := Acumulador + vPuntajeJugador[vUsuarios[i].Equipo.Jugador[j].ID, FechaActual];
                end;
        vUsuarios[i].Equipo.Puntaje[FechaActual] := Acumulador;
        end;
end;

{**************************************************************************************************************}
{Ordena la Lista de vPuntajeTotalJugadores. Juan Manuel Castro Pippo}
Procedure OrdenarPuntajeTotalJugadores(var vPuntajeTotalJugadores: tPuntajeTotalJugadores);
var
    Aux: tPuntajeTotalJugador;
    i, j: integer;
begin
    for i:=1 to JUGADORES-1 do
        for j:=i+1 to JUGADORES do
            if (vPuntajeTotalJugadores[i].PuntajeTotal < vPuntajeTotalJugadores[j].PuntajeTotal) then
            begin
                Aux := vPuntajeTotalJugadores[i];
                vPuntajeTotalJugadores[i] := vPuntajeTotalJugadores[j];
                vPuntajeTotalJugadores[j] := Aux;
            end;
end;

{**************************************************************************************************************}
{Suma las tacticas de cada equipo. Juan Manuel Castro Pippo}
Procedure CargarTacticas (var vUsuarios: tUsuarios; var vTacticas: tTacticas; CantUsuarios: byte; FechaActual: byte);
var
    i: byte;
begin
    for i:=1 to CantUsuarios do
        inc(vTacticas[vUsuarios[i].Equipo.Tactica[FechaActual]].Cantidad);
    for i:=1 to TACTICAS do
        writeln('ID ',vTacticas[i].ID,' ',vTacticas[i].Cantidad);
end;

{**************************************************************************************************************}
{Ordena la Lista de Tacticas. Juan Manuel Castro Pippo}
Procedure OrdenarTacticas(var vTacticas: tTacticas; var CantUsuarios: byte);
var
    Aux: tTactica;
    i,j: integer;
begin
    for i:=1 to CantUsuarios-1 do
        for j:=i+1 to CantUsuarios do
            if (vTacticas[i].Cantidad < vTacticas[j].Cantidad) then
            begin
                Aux := vTacticas[i];
                vTacticas[i] := vTacticas[j];
                vTacticas[j] := Aux;
            end;
end;

{**************************************************************************************************************}
{Obtiene la cantidad de veces que fueron elegidos los jugadores. Emanuel Kotzayan}
Procedure ObtenerJugadoresElegidos(var vElegidoJugadores: tElegidoJugadores; var vUsuarios: tUsuarios);
var
    i,j,k: integer;
begin
    for i := 1 to JUGADORES do
        begin
            vElegidoJugadores[i].ID := i;
            InicializarBytes(vElegidoJugadores[i].Valor);
        end;
    for j := 1 to MAX_USUARIOS do
        begin
            for k := 1 to JUGADORESXEQUIPO do
            inc(vElegidoJugadores[vUsuarios[j].Equipo.Jugador[k].ID].Valor);
        end;
end;

{**************************************************************************************************************}
{Ordena la Lista de JugadoresElegidos. Juan Manuel Castro Pippo}
Procedure OrdenarJugadoresElegidos(var vElegidoJugadores: tElegidoJugadores; CantUsuarios: byte);
var
    Aux: tElegidoJugador;
    i,j: integer;
begin
    for i:=1 to JUGADORES-1 do
        for j:=i+1 to JUGADORES do
            if (vElegidoJugadores[i].Valor < vElegidoJugadores[j].Valor) then
            begin
                Aux := vElegidoJugadores[i];
                vElegidoJugadores[i] := vElegidoJugadores[j];
                vElegidoJugadores[j] := Aux;
            end;
end;

{**************************************************************************************************************}
{Corre los procedimientos que ocurren entre las fechas. Emanuel Kotzayan}
Procedure PasarFecha (var vUsuarios: tUsuarios; var vPuntajeJugador: tPuntajeJugador; FechaActual: byte; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas;
CantUsuarios: byte; var vElegidoJugadores: tElegidoJugadores; var vListaJugadores: tListaJugadores; UsuarioActual: byte; var Equipo: tVEquipo; var Condicion: tVCondicion;
TipoUsuario: byte; var vListaApuestas: tListaApuestas; var RegEquipo: TRegEQUIPO);

begin
    AumentarFecha (FechaActual);
    CalcularPuntajeJugador (vPuntajeJugador, FechaActual);
    CalcularPuntajeEquipo (vUsuarios, vPuntajeJugador, FechaActual);
    CalcularPuntajeTotalJugador (vPuntajeJugador, vPuntajeTotalJugadores, FechaActual);
    OrdenarPuntajeTotalJugadores(vPuntajeTotalJugadores);
    CargarTacticas(vUsuarios, vTacticas, CantUsuarios, FechaActual);
    OrdenarTacticas(vTacticas,CantUsuarios);
    ObtenerJugadoresElegidos(vElegidoJugadores, vUsuarios);
    OrdenarJugadoresElegidos(vElegidoJugadores, CantUsuarios);
    MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
    UsuarioActual, Equipo, Condicion, RegEquipo);
end;

{**************************************************************************************************************}
{Inicia el Torneo. Ronnie del Pino}
Procedure IniciarTorneo(var TipoUsuario: byte; var FechaActual: byte; var vUsuarios: tUsuarios; var vPuntajeJugador: tPuntajeJugador; var CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; var vListaApuestas: tListaApuestas; var UsuarioActual: byte;
var vListaJugadores: tListaJugadores; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

begin
    if (FechaActual = 0) and (ChequearEquiposCompletos(vUsuarios)) then
        begin
            PasarFecha (vUsuarios, vPuntajeJugador, FechaActual, vPuntajeTotalJugadores, vTacticas, CantUsuarios, vElegidoJugadores, vListaJugadores, UsuarioActual, Equipo, Condicion,
            TipoUsuario, vListaApuestas, RegEquipo);
            CantUsuarios := CantidadParticipantes(vUsuarios);
        end
    else
        begin
            if (FechaActual <> 0) then
                begin
                    writeln();
                    write('Torneo en curso!');
                    delay(TIEMPO_SALIDA);
                    MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                    UsuarioActual, Equipo, Condicion, RegEquipo);
                end
            else
                begin
                    writeln();
                    write('Los usuarios no completearon sus equipos');
                    delay(TIEMPO_SALIDA);
                    MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                    UsuarioActual, Equipo, Condicion, RegEquipo);
                end;
        end;
end;

{**************************************************************************************************************}
{Carga calificaciones. Ronnie del Pino}
Procedure CargarCalificaciones(var TipoUsuario: byte; var FechaActual: byte; var vUsuarios: tUsuarios; var vPuntajeJugador: tPuntajeJugador;
var CantUsuarios: byte; var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; var vListaApuestas: tListaApuestas;
UsuarioActual: byte; var vListaJugadores: tListaJugadores; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);
begin
    if (FechaActual > 0) then
        PasarFecha (vUsuarios, vPuntajeJugador, FechaActual, vPuntajeTotalJugadores, vTacticas, CantUsuarios, vElegidoJugadores, vListaJugadores, UsuarioActual, Equipo, Condicion,
        TipoUsuario, vListaApuestas, RegEquipo)
    else
        begin
        writeln;
        write('Torneo no iniciado. No puede cargar calificaciones!');
        delay(TIEMPO_SALIDA);
        MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
        UsuarioActual, Equipo, Condicion, RegEquipo);
        end;
end;

{**************************************************************************************************************}
{Muestra Listado de Opciones pasa usuarios comunes. Ronnie Del Pino}
Procedure MenuUsuario(var TipoUsuario: byte; var vUsuarios: tUsuarios; var FechaActual: byte; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores:tElegidoJugadores; var vListaJugadores: tListaJugadores; UsuarioActual: byte;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    Opcion:byte;
begin
    TipoUsuario := 1;
    ImprimirTitulo(FechaActual);
    writeln('BIENVENIDO ', upcase(vUsuarios[UsuarioActual].Nombre));
    writeln(SEPARADORH);
    writeln('1 - Crear equipo');
    writeln('2 - Realizar cambios');
    writeln('3 - Correr reportes');
    writeln('0 - Cerrar sesion');
    write('Opcion: ');
    Opcion := ValidarOpciones();
          case Opcion of
                1: CrearEquipo(TipoUsuario, FechaActual, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                   UsuarioActual, Equipo, Condicion, RegEquipo);
                2: RealizarCambios(TipoUsuario, FechaActual, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                   UsuarioActual, Equipo, Condicion, RegEquipo);
                3: begin
                    TipoUsuario := 1;
                    MenuCorrerReportes(vUsuarios, TipoUsuario, FechaActual, CantUsuarios, vPuntajeJugador, vListaApuestas, vPuntajeTotalJugadores, vElegidoJugadores, vTacticas,
                    vListaJugadores, UsuarioActual, Equipo, Condicion, RegEquipo);
                   end;
                0: MenuIniciarSesion(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
                   vListaJugadores, Equipo, Condicion, RegEquipo);
           else
                   MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                   UsuarioActual, Equipo, Condicion, RegEquipo);
           end
end;

{**************************************************************************************************************}
{Muestra Menu de Opciones para el Administrador. Ronnie Del Pino}
Procedure MenuAdministrador(var FechaActual: byte; var TipoUsuario: byte; var vUsuarios: tUsuarios; var vListaApuestas: tListaApuestas; var vPuntajeJugador: tPuntajeJugador;
CantUsuarios: byte; vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores:tElegidoJugadores; var vListaJugadores: tListaJugadores;
UsuarioActual:byte; var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    Opcion:byte;
begin
    TipoUsuario := 0;
    ImprimirTitulo(FechaActual);
    writeln('BIENVENIDO ', upcase(vUsuarios[UsuarioActual].Nombre));
    writeln(SEPARADORH);
    writeln('1 - Crear equipo');
    writeln('2 - Realizar cambios');
    writeln('3 - Correr reportes');
    writeln('4 - Configurar apuestas');
    writeln('5 - Iniciar torneo');
    writeln('6 - Cargar Calificaciones');
    writeln('0 - Cerrar sesion');
    write('Opcion: ');
    Opcion := ValidarOpciones();
    case Opcion of
        1: CrearEquipo(TipoUsuario, FechaActual, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores, UsuarioActual,
           Equipo, Condicion, RegEquipo);
        2: RealizarCambios(TipoUsuario, FechaActual, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
           UsuarioActual, Equipo, Condicion, RegEquipo);
        3: MenuCorrerReportes(vUsuarios, TipoUsuario, FechaActual, CantUsuarios, vPuntajeJugador, vListaApuestas, vPuntajeTotalJugadores, vElegidoJugadores, vTacticas, vListaJugadores,
           UsuarioActual, Equipo, Condicion, RegEquipo);
        4: ConfigurarApuestas(vUsuarios, vListaApuestas, FechaActual, TipoUsuario, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, UsuarioActual,
           vListaJugadores, Equipo, Condicion, RegEquipo);
        5: IniciarTorneo(TipoUsuario, FechaActual, vUsuarios, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas, UsuarioActual,
           vListaJugadores, Equipo, Condicion, RegEquipo);
        6: CargarCalificaciones(TipoUsuario, FechaActual, vUsuarios, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas, UsuarioActual,
           vListaJugadores, Equipo, Condicion, RegEquipo);
        0: MenuIniciarSesion(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
           vListaJugadores, Equipo, Condicion, RegEquipo)
    else
        MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
        UsuarioActual, Equipo, Condicion, RegEquipo);
    end;
end;

{**************************************************************************************************************}
{Pide y guarda datos de usuarios el el registro. Ronnie Del Pino}
Procedure CargaUsuarios(var vUsuarios: tUsuarios; var TipoUsuario: byte; var UsuarioActual: byte; FechaActual: byte; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; var vListaApuestas: tListaApuestas; var vListaJugadores: tListaJugadores;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    Nombre, Apellido, Club, Usuario, Contrasena, pwConfirmacion: string;
    i: byte;
begin
    if (FechaActual = 0) and (CantidadParticipantes(vUsuarios) < MAX_USUARIOS) then
        begin
        InicializarStrings(Contrasena);
        InicializarStrings(Usuario);
        i := Posicion(vUsuarios);
        OrdenarVector(vUsuarios, 'Des');
        ImprimirTitulo(FechaActual);
        writeln('INGRESE SUS DATOS');
        writeln(SEPARADORH);
        write('Nombre: ');
        readln(Nombre);
        if (Nombre = '') then
            begin
                writeln('Campo Obligatorio. Reingrese.');
                delay(TIEMPO_SALIDA);
                CargaUsuarios(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas,
                vListaJugadores, Equipo, Condicion, RegEquipo);
            end
        else
            begin
            write('Apellido: ');
            readln(Apellido);
            write('Club: ');
            readln(club);
            write('Usuario: ');
            readln(Usuario);
            if (UsuarioDuplicado(Usuario, vUsuarios)) then
            begin
                writeln('Campo Obligatorio o usuario existente!');
                delay(TIEMPO_SALIDA);
                CargaUsuarios(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas,
                vListaJugadores, Equipo, Condicion, RegEquipo);
            end
            else
            begin
                write('Contrasena: ');
                Contrasena := OcultarContrasena();
                writeln;
                write('Reingrese contrasena: ');
                pwConfirmacion := OcultarContrasena();
                if (Contrasena <> pwConfirmacion) or (Contrasena = '') then
                    begin
                    writeln;
                    writeln('Contrasena incorrecta. Reingrese.');
                    delay(TIEMPO_SALIDA);
                    CargaUsuarios(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
                    vListaApuestas, vListaJugadores, Equipo, Condicion, RegEquipo);
                    end
                else
                    begin
                    vUsuarios[i].Nombre := Nombre;
                    vUsuarios[i].Apellido := Apellido;
                    vUsuarios[i].Club := Club;
                    vUsuarios[i].Usuario := Usuario;
                    vUsuarios[i].Contrasena := Contrasena;
                    vUsuarios[i].ID := i;
                    vUsuarios[i].TipoUsuario := TipoUsuario;
                    UsuarioActual:=ObtenerID(Usuario,vUsuarios); {Devuelve 0 sino existe usuario}
                    if (TipoUsuario = 0) then
                        MenuAdministrador(FechaActual, TipoUsuario, vUsuarios, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
                        vListaJugadores, UsuarioActual, Equipo, Condicion, RegEquipo)
                    else
                        MenuUsuario(TipoUsuario, vUsuarios, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores,
                        UsuarioActual, Equipo, Condicion, RegEquipo);
                    end;
                end;
            end;
        end
    else
        begin
        writeln;
        writeln('No puede crear usuarios:');
        writeln('- Se a alcanzado el maximo (',MAX_USUARIOS,') de usuarios registrados!');
        write('- El Torneo a Iniciado!');
        delay(TIEMPO_SALIDA);
        MenuIniciarSesion(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores,
        vListaJugadores, Equipo, Condicion, RegEquipo);
        end;
end;

{**************************************************************************************************************}
Procedure PedidoAndres(var vUsuarios: tUsuarios; TipoUsuario: byte);
begin
    {Usuario 1}
    vUsuarios[1].TipoUsuario := 0;
    vUsuarios[1].ID := Posicion(vUsuarios);
    vUsuarios[1].Nombre := 'Admin';
    vUsuarios[1].Apellido := 'Admin';
    vUsuarios[1].Club := 'Boca Juniors';
    vUsuarios[1].Usuario := 'admin';
    vUsuarios[1].Contrasena := 'admin';
    {ARQUEROS}
    vUsuarios[1].Equipo.Jugador[1].ID:= 1;
    vUsuarios[1].Equipo.Jugador[1].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[2].ID:= 32;
    vUsuarios[1].Equipo.Jugador[2].Condicion:= SUPLENTE;
    {DEFENSORES}
    vUsuarios[1].Equipo.Jugador[3].ID:= 4;
    vUsuarios[1].Equipo.Jugador[3].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[4].ID:= 37;
    vUsuarios[1].Equipo.Jugador[4].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[5].ID:= 36;
    vUsuarios[1].Equipo.Jugador[5].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[6].ID:= 70;
    vUsuarios[1].Equipo.Jugador[6].Condicion:= SUPLENTE;
    {MEDIOCAMPISTAS}
    vUsuarios[1].Equipo.Jugador[7].ID:= 87;
    vUsuarios[1].Equipo.Jugador[7].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[8].ID:= 116;
    vUsuarios[1].Equipo.Jugador[8].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[9].ID:= 114;
    vUsuarios[1].Equipo.Jugador[9].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[10].ID:= 144;
    vUsuarios[1].Equipo.Jugador[10].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[11].ID:= 143;
    vUsuarios[1].Equipo.Jugador[11].Condicion:= SUPLENTE;
    {DELANTEROS}
    vUsuarios[1].Equipo.Jugador[12].ID:= 250;
    vUsuarios[1].Equipo.Jugador[12].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[13].ID:= 351;
    vUsuarios[1].Equipo.Jugador[13].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[14].ID:= 379;
    vUsuarios[1].Equipo.Jugador[14].Condicion:= TITULAR;
    vUsuarios[1].Equipo.Jugador[15].ID:= 380;
    vUsuarios[1].Equipo.Jugador[15].Condicion:= SUPLENTE;


    {Usuario 2}
    vUsuarios[2].TipoUsuario := 1;
    vUsuarios[2].ID := Posicion(vUsuarios);
    vUsuarios[2].Nombre := 'Carlos';
    vUsuarios[2].Apellido := 'Totti';
    vUsuarios[2].Club := 'Boca Juniors';
    vUsuarios[2].Usuario := 'carlos';
    vUsuarios[2].Contrasena := 'carlos';
    {ARQUEROS}
    vUsuarios[2].Equipo.Jugador[1].ID:= 1;
    vUsuarios[2].Equipo.Jugador[1].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[2].ID:= 32;
    vUsuarios[2].Equipo.Jugador[2].Condicion:= SUPLENTE;
    {DEFENSORES}
    vUsuarios[2].Equipo.Jugador[3].ID:= 4;
    vUsuarios[2].Equipo.Jugador[3].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[4].ID:= 37;
    vUsuarios[2].Equipo.Jugador[4].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[5].ID:= 36;
    vUsuarios[2].Equipo.Jugador[5].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[6].ID:= 70;
    vUsuarios[2].Equipo.Jugador[6].Condicion:= SUPLENTE;
    {MEDIOCAMPISTAS}
    vUsuarios[2].Equipo.Jugador[7].ID:= 87;
    vUsuarios[2].Equipo.Jugador[7].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[8].ID:= 116;
    vUsuarios[2].Equipo.Jugador[8].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[9].ID:= 114;
    vUsuarios[2].Equipo.Jugador[9].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[10].ID:= 144;
    vUsuarios[2].Equipo.Jugador[10].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[11].ID:= 143;
    vUsuarios[2].Equipo.Jugador[11].Condicion:= SUPLENTE;
    {DELANTEROS}
    vUsuarios[2].Equipo.Jugador[12].ID:= 250;
    vUsuarios[2].Equipo.Jugador[12].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[13].ID:= 351;
    vUsuarios[2].Equipo.Jugador[13].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[14].ID:= 379;
    vUsuarios[2].Equipo.Jugador[14].Condicion:= TITULAR;
    vUsuarios[2].Equipo.Jugador[15].ID:= 380;
    vUsuarios[2].Equipo.Jugador[15].Condicion:= SUPLENTE;

    {Usuario 3}
    vUsuarios[3].TipoUsuario := 1;
    vUsuarios[3].ID := Posicion(vUsuarios);
    vUsuarios[3].Nombre := 'Anibal';
    vUsuarios[3].Apellido := 'Ibarra';
    vUsuarios[3].Club := 'Racing Club';
    vUsuarios[3].Usuario := 'anibal';
    vUsuarios[3].Contrasena := 'anibal';
    {ARQUEROS}
    vUsuarios[3].Equipo.Jugador[1].ID:= 1;
    vUsuarios[3].Equipo.Jugador[1].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[2].ID:= 32;
    vUsuarios[3].Equipo.Jugador[2].Condicion:= SUPLENTE;
    {DEFENSORES}
    vUsuarios[3].Equipo.Jugador[3].ID:= 4;
    vUsuarios[3].Equipo.Jugador[3].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[4].ID:= 37;
    vUsuarios[3].Equipo.Jugador[4].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[5].ID:= 36;
    vUsuarios[3].Equipo.Jugador[5].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[6].ID:= 70;
    vUsuarios[3].Equipo.Jugador[6].Condicion:= SUPLENTE;
    {MEDIOCAMPISTAS}
    vUsuarios[3].Equipo.Jugador[7].ID:= 87;
    vUsuarios[3].Equipo.Jugador[7].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[8].ID:= 116;
    vUsuarios[3].Equipo.Jugador[8].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[9].ID:= 114;
    vUsuarios[3].Equipo.Jugador[9].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[10].ID:= 144;
    vUsuarios[3].Equipo.Jugador[10].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[11].ID:= 143;
    vUsuarios[3].Equipo.Jugador[11].Condicion:= SUPLENTE;
    {DELANTEROS}
    vUsuarios[3].Equipo.Jugador[12].ID:= 250;
    vUsuarios[3].Equipo.Jugador[12].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[13].ID:= 351;
    vUsuarios[3].Equipo.Jugador[13].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[14].ID:= 379;
    vUsuarios[3].Equipo.Jugador[14].Condicion:= TITULAR;
    vUsuarios[3].Equipo.Jugador[15].ID:= 380;
    vUsuarios[3].Equipo.Jugador[15].Condicion:= SUPLENTE;

    {Usuario 4}
    vUsuarios[4].TipoUsuario := 1;
    vUsuarios[4].ID := Posicion(vUsuarios);
    vUsuarios[4].Nombre := 'Francisco';
    vUsuarios[4].Apellido := 'Pasman';
    vUsuarios[4].Club := 'Sacachispas';
    vUsuarios[4].Usuario := 'francisco';
    vUsuarios[4].Contrasena := 'francisco';
    {ARQUEROS}
    vUsuarios[4].Equipo.Jugador[1].ID:= 1;
    vUsuarios[4].Equipo.Jugador[1].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[2].ID:= 32;
    vUsuarios[4].Equipo.Jugador[2].Condicion:= SUPLENTE;
    {DEFENSORES}
    vUsuarios[4].Equipo.Jugador[3].ID:= 4;
    vUsuarios[4].Equipo.Jugador[3].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[4].ID:= 37;
    vUsuarios[4].Equipo.Jugador[4].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[5].ID:= 36;
    vUsuarios[4].Equipo.Jugador[5].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[6].ID:= 70;
    vUsuarios[4].Equipo.Jugador[6].Condicion:= SUPLENTE;
    {MEDIOCAMPISTAS}
    vUsuarios[4].Equipo.Jugador[7].ID:= 87;
    vUsuarios[4].Equipo.Jugador[7].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[8].ID:= 116;
    vUsuarios[4].Equipo.Jugador[8].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[9].ID:= 114;
    vUsuarios[4].Equipo.Jugador[9].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[10].ID:= 144;
    vUsuarios[4].Equipo.Jugador[10].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[11].ID:= 143;
    vUsuarios[4].Equipo.Jugador[11].Condicion:= SUPLENTE;
    {DELANTEROS}
    vUsuarios[4].Equipo.Jugador[12].ID:= 250;
    vUsuarios[4].Equipo.Jugador[12].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[13].ID:= 351;
    vUsuarios[4].Equipo.Jugador[13].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[14].ID:= 379;
    vUsuarios[4].Equipo.Jugador[14].Condicion:= TITULAR;
    vUsuarios[4].Equipo.Jugador[15].ID:= 380;
    vUsuarios[4].Equipo.Jugador[15].Condicion:= SUPLENTE;

    {Usuario 5}
    vUsuarios[5].TipoUsuario := 1;
    vUsuarios[5].ID := Posicion(vUsuarios);
    vUsuarios[5].Nombre := 'Raul';
    vUsuarios[5].Apellido := 'Garcia';
    vUsuarios[5].Club := 'River Plate';
    vUsuarios[5].Usuario := 'raul';
    vUsuarios[5].Contrasena := 'raul';
    {ARQUEROS}
    vUsuarios[5].Equipo.Jugador[1].ID:= 1;
    vUsuarios[5].Equipo.Jugador[1].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[2].ID:= 32;
    vUsuarios[5].Equipo.Jugador[2].Condicion:= SUPLENTE;
    {DEFENSORES}
    vUsuarios[5].Equipo.Jugador[3].ID:= 4;
    vUsuarios[5].Equipo.Jugador[3].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[4].ID:= 37;
    vUsuarios[5].Equipo.Jugador[4].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[5].ID:= 36;
    vUsuarios[5].Equipo.Jugador[5].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[6].ID:= 70;
    vUsuarios[5].Equipo.Jugador[6].Condicion:= SUPLENTE;
    {MEDIOCAMPISTAS}
    vUsuarios[5].Equipo.Jugador[7].ID:= 87;
    vUsuarios[5].Equipo.Jugador[7].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[8].ID:= 116;
    vUsuarios[5].Equipo.Jugador[8].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[9].ID:= 114;
    vUsuarios[5].Equipo.Jugador[9].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[10].ID:= 144;
    vUsuarios[5].Equipo.Jugador[10].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[11].ID:= 143;
    vUsuarios[5].Equipo.Jugador[11].Condicion:= SUPLENTE;
    {DELANTEROS}
    vUsuarios[5].Equipo.Jugador[12].ID:= 250;
    vUsuarios[5].Equipo.Jugador[12].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[13].ID:= 351;
    vUsuarios[5].Equipo.Jugador[13].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[14].ID:= 379;
    vUsuarios[5].Equipo.Jugador[14].Condicion:= TITULAR;
    vUsuarios[5].Equipo.Jugador[15].ID:= 380;
    vUsuarios[5].Equipo.Jugador[15].Condicion:= SUPLENTE;
end;

{**************************************************************************************************************}
{Muestra las Primeras 2 Opciones y Inicializa valor de ser necesario. Ronnie Del Pino}
Procedure MenuPantallaInicial(var TipoUsuario: byte; var vUsuarios: tUsuarios; UsuarioActual: byte; FechaActual: byte; var vPuntajeJugador: tPuntajeJugador; CantUsuarios: byte;
var vPuntajeTotalJugadores: tPuntajeTotalJugadores; var vTacticas: tTacticas; var vElegidoJugadores: tElegidoJugadores; var vListaApuestas: tListaApuestas; var vListaJugadores: tListaJugadores;
var Equipo: tVEquipo; var Condicion: tVCondicion; var RegEquipo: TRegEQUIPO);

var
    Opcion, i: byte;
begin
    TipoUsuario := 0;
    //PedidoAndres(vUsuarios, TipoUsuario); {TESTEO}
    For i:=1 to MAX_USUARIOS do
        vUsuarios[i].TipoUsuario := 1;
    ImprimirTitulo(FechaActual);
    writeln('LOG IN');
    writeln(SEPARADORH);
    writeln('1 - Crear Administrador');
    writeln('0 - Salir del Programa');
    write('Opcion: ');
    Opcion := ValidarOpciones();
    case Opcion of
        1: CargaUsuarios(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas, vListaJugadores,
           Equipo, Condicion, RegEquipo);
        0: begin
              writeln;
              writeln('Fin del programa...');
           end
        else
            MenuPantallaInicial(TipoUsuario, vUsuarios, UsuarioActual, FechaActual, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas,
            vListaJugadores, Equipo, Condicion, RegEquipo);
    end;
end;

{**************************************************************************************************************}
{Intercambia 2 Jugadores de lugar de la ListaJugadores. Juan Manuel Castro Pippo}
Procedure IntercambiarJugadores(var vListaJugadores: tListaJugadores; k: integer; l: integer);
var
    Aux : tJugador;
begin
    Aux := vListaJugadores[k];
    vListaJugadores[k] := vListaJugadores[l];
    vListaJugadores[l] := Aux;
end;

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}

Var
    vListaJugadores: tListaJugadores;
    vUsuarios: tUsuarios;   {Vector de usuarios participantes}
    vTacticas: tTacticas;       {Vector Tactica por fecha Mas Usada}
    vPuntajeJugador: tPuntajeJugador;   {Matriz Puntaje por fecha de Jugadores}
    vPuntajeTotalJugadores: tPuntajeTotalJugadores; {Vector de Jugadores con sus puntajes Totales}
    vElegidoJugadores: tElegidoJugadores;   {Vector Nro de Veces Elegido Mejor Jugador}
    vListaApuestas: tListaApuestas; {Apuestas en orden: por fecha, 1ro, 2do, 3ro}
    Equipo: tVEquipo;
    Condicion: tVCondicion;
    CantUsuarios: byte;
    TipoUsuario: byte;
    UsuarioActual: byte;
    FechaActual: byte;
    RegEquipo: TRegEQUIPO;


BEGIN
    InicializarVariables (vUsuarios, vListaJugadores, vTacticas, vPuntajeTotalJugadores, vElegidoJugadores, vPuntajeJugador, vListaApuestas, CantUsuarios, TipoUsuario, UsuarioActual, FechaActual);
    PedidoAndres(vUsuarios, TipoUsuario);
    MenuIniciarSesion(vUsuarios, TipoUsuario, UsuarioActual, FechaActual, vListaApuestas, vPuntajeJugador, CantUsuarios,
     vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaJugadores, Equipo, Condicion, RegEquipo); {TESTEO}

    {MenuPantallaInicial(TipoUsuario, vUsuarios, UsuarioActual, FechaActual, vPuntajeJugador, CantUsuarios, vPuntajeTotalJugadores, vTacticas, vElegidoJugadores, vListaApuestas,
    vListaJugadores, Equipo, Condicion, RegEquipo);}
END.

{**************************************************************************************************************}
{**************************************************************************************************************}
{**************************************************************************************************************}