program GranDT;

{Version Alpha 0.03}

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

uses AyPDT, CRT;

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

const
    JUGADORES = 623;
    EQUIPOS = 20;
    FECHAS_TORNEO = EQUIPOS-1;
    PRESUPUESTO = 60000000;
    MAX_USUARIOS = 10;
    JUGADORESXEQUIPO = 15;
    SEPARADORH = '--------------------------------------------------------------------------------';
    VOLVER = 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;
    tCambios = array[1..FECHAS_TORNEO] of byte;

    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;
        Cambios : tCambios;
        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;

    {De Leo}
    tvecEquipo = array [1..JUGADORES] of tJugador;
    tvecCondicion = array [1..JUGADORES] of tCondicion;
    tvecClubs = array [1..(EQUIPOS+1)] of integer;
    tPremios = array[1..MAX_TIPO_PREMIOS] of integer;

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

var
    vListaJugadores : tListaJugadores;
    vUsuarios : tUsuarios;  {Vector de usuarios participantes}
    vTacticas : tTacticas;      {Vector Tactica x fecha Mas Usada}
    vPuntajeJugador : tPuntajeJugador;  {Matriz Puntaje x 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: x fecha, 1ro, 2do, 3ro}
    CantUsuarios : byte;
    Premios : tPremios;
    TipoUsuario : byte;
    UsuarioActual : string;
    FechaActual : byte;
    Apuesta : integer;

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

procedure MenuAdministrador(var FechaActual:byte;var TipoUsuario:byte);forward;
procedure MenuIniciarSesion(var Usuarios:tUsuarios;var TipoUsuario:byte);forward;
procedure MenuUsuario(var TipoUsuario:byte);forward;
procedure CargaUsuarios(var Usuarios:tUsuarios; var TipoUsuario:byte; var UsuarioActual:string);forward;
procedure MenuCorrerReportes( var Usuarios:tUsuarios;var TipoUsuario:byte);forward;

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

{Imprime titulo del Programa}
procedure ImprimirTitulo();
begin
clrscr;
gotoxy(35,1);
writeln('GranDT - Grupo 4');
writeln;
end;

{**************************************************************************************************************}
{Ordena En forma Ascendente y descendente el vector}
Procedure OrdenarVector(var Usuarios: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 Usuarios[j].Usuario > Usuarios[j+1].Usuario then
                begin
                Aux:=Usuarios[j];
                Usuarios[j]:=Usuarios[j+1];
                Usuarios[j+1]:=Aux;
                DesOrd:=true;
                end;
            end
        else
            begin
            if Usuarios[j].Usuario < Usuarios[j+1].Usuario then
                begin
                Aux:=Usuarios[j];
                Usuarios[j]:=Usuarios[j+1];
                Usuarios[j+1]:=Aux;
                DesOrd:=true;
                end;
            end;
        end;
    inc(i);
    end;
end;

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

{**************************************************************************************************************}
{Obtiene la posicion libre mas cercana.}
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}
Function ValidarOpciones():integer;
var
    valor:string;
    Letra:byte;
 begin
repeat
    letra:=ord(readkey);

if (Letra>47) and (Letra<58) then
        begin
        Valor:=chr(letra);
        end;
until (length(Valor) < 2);
Val(Valor,Letra);
ValidarOpciones:=Letra;
end;

{**************************************************************************************************************}
{Valida y devuelve la cantidad de cifras y el valor respectivameente}
Function ValidarNumerosCifras(Cant:byte):integer;
var letra, Acum:byte;
    Total:string;
    Valor:integer;
begin
Total:='0';
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}
function UsuarioDuplicado(User:string; var Usuarios:tUsuarios):boolean;
var
    Inicio, Fin: integer;
    Medio:integer;
    Encontrado:boolean;
begin
Inicio:=1;
Fin:=MAX_USUARIOS;
Encontrado:=False;
OrdenarVector(Usuarios, 'Des');
repeat
if (Inicio>=Fin) then
    begin
    if (Usuarios[Inicio].Usuario=User) then
        begin
        UsuarioDuplicado:=true;
        Encontrado:=true;
        end
    else
        begin
        UsuarioDuplicado:=false;
        Encontrado:=true;
        end;
    end;
Medio:=(Inicio+Fin) div 2;
if Usuarios[Medio].Usuario=User then
    begin
        UsuarioDuplicado:=true;
        Encontrado:=true;
    end
else
    if Usuarios[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}
function BuscarUsuario(User:string; password:string; var Usuarios:tUsuarios):boolean;
var
    Inicio, Fin: integer;
    Medio:integer;
    Encontrado:boolean;
begin
Inicio:=1;
Fin:=MAX_USUARIOS;
Encontrado:=False;
OrdenarVector(Usuarios, 'Des');
repeat
if (Inicio>=Fin) then
    begin
    if (Usuarios[Inicio].Usuario=User) and (Usuarios[Inicio].Contrasena=password) then
        begin
        BuscarUsuario:=true;
        Encontrado:=true;
        end
    else
        begin
        BuscarUsuario:=false;
        Encontrado:=true;
        end;
    end;
Medio:=(Inicio+Fin) div 2;
if Usuarios[Medio].Usuario=User then
    if Usuarios[Medio].Contrasena=password then
        begin
        BuscarUsuario:=true;
        Encontrado:=true;
        end
    else
        begin
        BuscarUsuario:=false;
        Encontrado:=true;
        end
else
    if Usuarios[Medio].Usuario>user then
        Inicio:=Medio+1
    Else
        Fin:=Medio-1;
until (Encontrado)
end;

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

{**************************************************************************************************************}
{Oculta y devuelva las teclas ingresadas por el usuario}
function OcultarContrasena():string;
var
   Contrasena:string;
   Tecla:byte;
   Contador:byte;
begin
contrasena:='';
contador:=0;
tecla:=0;
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;

{**************************************************************************************************************}
{Imprime una Lista de los Mejores Jugadores por Puesto. Juan Manuel Castro Pippo}
procedure ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores:tPuntajeTotalJugadores;posicion:tPosicion);
var
    i,j,k : integer;
    auxid : integer;
    Jugador : tJugador;
    Top, ElementosxPagina, tecla:byte;
begin
tecla:=0;
i:=1;   k:=1;
Top:=10;
ElementosxPagina:=15;
while tecla<>VOLVER 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}
procedure ReportesMenuResultadosPorPuesto(var Usuarios:tUsuarios; var TipoUsuario:byte);
var
    Opcion:byte;
begin
ImprimirTitulo();
          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);
        2: ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores,DEFENSOR);
        3: ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores,MEDIOCAMPISTA);
        4: ImprimirMejoresJugadoresxPuesto(vPuntajeTotalJugadores,DELANTERO);
        5: MenuCorrerReportes(Usuarios, TipoUsuario);
        else
        ReportesMenuResultadosPorPuesto(Usuarios, TipoUsuario);
        end;
end;

{**************************************************************************************************************}
{Pide ingreso de usuario y contrasena}
procedure IniciarSesion(var Usuarios:tUsuarios; var TipoUsuario:byte; var UsuarioActual:string);
var
    Usuario, Contrasena:string;
begin
ImprimirTitulo();
write('Usuario: ');
readln(Usuario);
write('Contrasena: ');
Contrasena:=OcultarContrasena();
if (BuscarUsuario(Usuario, Contrasena, Usuarios)) and (Contrasena <> '') then
    begin
    if EsAdmin(Usuarios, Usuario) then
        begin
        TipoUsuario:=0;
        //Modificar y enviar usuario Actual:
        MenuAdministrador(FechaActual, TipoUsuario)
        end
    else
        begin
        TipoUsuario:=1;
        //Modificar y enviar usuario Actual:
        MenuUsuario(TipoUsuario);
        end;
    end
else
    begin
    writeln;
    writeln('Usuario y/o contrasena incorrectos!');
    delay(TIEMPO_SALIDA);
    MenuIniciarSesion(Usuarios, TipoUsuario);
    end;
end;

{**************************************************************************************************************}
{Muestra el Menu Crear o logear Usuario}
procedure MenuIniciarSesion(var Usuarios:tUsuarios; var TipoUsuario:byte);
var
    Opcion:byte;
    Respuesta:byte;
begin
ImprimirTitulo();
Respuesta:=0;
writeln('1 - Crear usuario');
writeln('2 - Iniciar sesion');
writeln('0 - Salir');
write('Opcion: ');
Opcion:=ValidarOpciones();
      Case Opcion of
            1:
            begin
                TipoUsuario:=1;
                CargaUsuarios(Usuarios, TipoUsuario, UsuarioActual);
                end;
            2:IniciarSesion(Usuarios, TipoUsuario, UsuarioActual);
            0:begin
                writeln('0');
                write('Si sale se perderan todos los datos. Pulse S para salir: ');
                Respuesta:=ord(upcase(readkey));
                if Respuesta = VOLVER then
                    begin
                    writeln;
                    writeln('Fin del programa...');
                    delay(TIEMPO_SALIDA);
                    end
                else
                    MenuIniciarSesion(Usuarios, TipoUsuario);
                end
            else
                MenuIniciarSesion(Usuarios, TipoUsuario);
     end;
end;

{**************************************************************************************************************}
{LLama a la funcion crear equipo}
procedure CrearEquipo(var TipoUsuario:byte);
begin
if FechaActual=0 then
    begin
    // PROCEDIMIENTO CREAR EQUIPO
    end
else
    begin
    writeln;
    write('El Torneo ha empezado. No pueden crear equipos!');
    delay(TIEMPO_SALIDA);
    if TipoUsuario=0 then
        MenuAdministrador(FechaActual, TipoUsuario)
    else
        MenuUsuario(TipoUsuario);
    end;
end;

{**************************************************************************************************************}
procedure RealizarCambios(var TipoUsuario:byte);
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)
    else
        MenuUsuario(TipoUsuario);
    end;
end;

{**************************************************************************************************************}
procedure ReportesTablaDePosiciones(var TipoUsuario:byte);
begin

end;

procedure ReportesResultadosDeApuestas(var TipoUsuario:byte);
begin
end;

{**************************************************************************************************************}
procedure ReportesEquipoFavorito(var TipoUsuario:byte);
begin
end;

{**************************************************************************************************************}
Procedure swapUsuario(var Usuario1:tUsuario; var Usuario2:tUsuario);
var
    auxUsuario:tUsuario;
begin
    auxUsuario:=Usuario1;
    Usuario1:=Usuario2;
    Usuario2:=auxUsuario;
end;

{**************************************************************************************************************}
Procedure OrdernarUsuariosxPuntaje (var vUsuarios:tUsuarios; USUARIOS:byte; FECHAS:byte);
var i,j,k:integer;
    ordenado:boolean;
    puntajeacum1, cambiosacum1:integer;
    precioacum1:real;
    puntajeacum2, cambiosacum2:integer;
    precioacum2:real;
Begin
    i:=1;
    ordenado:=false;
    while (i<=USUARIOS) and not(ordenado) do
    begin
        ordenado:=true;
        puntajeacum1:=0;
        precioacum1:=0;
        cambiosacum1 := puntajeacum1 + vUsuarios[i].Equipo.CantCambiosAcum;
        for j:=1 to USUARIOS-i do
        begin
            puntajeacum2:=0;
            precioacum2:=0;
            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;

{**************************************************************************************************************}
Procedure MostrarTabladePosiciones (var vUsuarios:tUsuarios; USUARIOS:byte; FECHAS:byte);
var i,j:integer;
    puntajeacum, cambiosacum:integer;
    precioacum:real;

Begin
    Writeln('Equipo - Pts Acum - Fechas Ganadas - Cambios Acum - Presupuesto Promedio');
    for i:=1 to USUARIOS do
    begin
        Write('Equipo ', vUsuarios[i].ID);
        puntajeacum:=0;
        cambiosacum:=0;
        precioacum:=0;

        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(' - ' , puntajeacum);
        Write(' - ' , vUsuarios[i].Equipo.CantFechasGanadas);
        Write(' - ' , cambiosacum);
        Writeln(' - ' , precioacum/FECHAS);
    end;
End;

{**************************************************************************************************************}
{Muestra los Resultado de las Apuestas. Requiere la lista de apuestas, la lista de usuarios, la variable de usuarios creados hasta el momento y la variable de la fecha actual. Ricardo Ariel Sosa Aquino}
Procedure MostrasResultadosdeApuestas(var vListaApuestas:tListaApuestas; var vUsuarios:tUsuarios; USUARIOS:byte; FECHAS:byte);
var i,j,k:integer;
    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]);
    {OrdernarUsuariosxPuntaje (vUsuarios, USUARIOS, FECHAS);}
    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);
        puntaje1:=0;
        puntaje2:=0;
        gastadoxfecha1:=0;
        ganadoxmedalla:=0;
        campeones:=0;
        subcampeones:=1;
        escampeon:=true;
        essubcampeon:=true;
        estercero:=true;
        for j:=1 to USUARIOS do
        begin
            gastadoxfecha2:=0;
            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
            Ganadoxfecha := 0;
            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. Requiere la lista de puntaje de jugadores, la variable de de cant de jugadores (623) y la variable de la fecha actual. 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. Requiere la lista de usuarios, la variable de usuarios creados hasta el momento y la variable de 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(vPuntajeTotalJugadores:tPuntajeTotalJugadores);
var
    i,j,k : integer;
    auxid : integer;
    Jugador : tJugador;
    Top, ElementosxPagina, tecla:byte;
begin
tecla:=0;
i:=1;
k:=1;
Top:=25;
ElementosxPagina:=15;
while tecla<>VOLVER do
begin
    clrscr();
    writeln('25 MEJORES JUGADORES 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];
        writeln(k:4,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:Integer;
    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:24);
        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:Byte;
    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':24);
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<>VOLVER do
tecla:=ord(upcase(readkey));
end;

{**************************************************************************************************************}
{Menu de Reportes. Ronnie del Pino}
procedure MenuCorrerReportes(var Usuarios:tUsuarios;var TipoUsuario:byte);
var
    Opcion:byte;
    i:byte;
begin
if FechaActual <> 0 then
begin
    ImprimirTitulo();
              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);
            5: ReportesMenuResultadosPorPuesto(Usuarios, TipoUsuario);
            6: EquipoFavorito(vListaJugadores, vElegidoJugadores, vTacticas, CantUsuarios);
            0:begin
                If TipoUsuario=0 then
                    MenuAdministrador(FechaActual, TipoUsuario)
                else
                    MenuUsuario(TipoUsuario);
                end;
             else
                MenuCorrerReportes(Usuarios, TipoUsuario);
    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)
    else
        MenuUsuario(TipoUsuario);
    end;
end;

{**************************************************************************************************************}
{Pide datos de premios para apuestas y los guarda}
procedure ConfigurarApuestas(var Usuarios:tUsuarios; var Premios:tPremios);
var
    j, Cant:byte;
begin
if FechaActual=0 then
begin
Cant:=3;
ImprimirTitulo();
writeln('Premios(',SIMBOLO_MONEDA, '):');
writeln;
write('Fecha Ganada: ');
Premios[1]:=ValidarNumerosCifras(Cant);writeln;
write('Campeon del  Torneo: ');
Premios[2]:=ValidarNumerosCifras(Cant);writeln;
write('Subcampeon del Torneo: ');
Premios[3]:=ValidarNumerosCifras(Cant);writeln;
write('Tercer Puesto: ');
Premios[4]:=ValidarNumerosCifras(Cant);writeln;
writeln;
writeln('La siguiente configuracion sera guardada:');
writeln('Ganador de La fecha: ',SIMBOLO_MONEDA ,Premios[1]);
writeln('Campeon: ', SIMBOLO_MONEDA,Premios[2]);
writeln('SubCampeon: ',SIMBOLO_MONEDA ,Premios[3]);
writeln('Tercer Puesto: ',SIMBOLO_MONEDA ,Premios[4]);
writeln;
writeln('Presione una tecla para continuar...');
readkey;
For j:=1 to MAX_USUARIOS do
        begin
        Usuarios[j].CantidadApuesta:=((FECHAS_TORNEO*Premios[1])+Premios[2]+Premios[3]+Premios[4])/(CantidadParticipantes(Usuarios));
        Usuarios[j].GananciaPorFechas:=0;
        Usuarios[j].GananciaPorTorneo:=0;

        end;
    MenuAdministrador(FechaActual, TipoUsuario);
end
else
    begin
    writeln;
    write('El Torneo ha empezado.No puede configurar apuestas!');
    delay(TIEMPO_SALIDA);
    MenuAdministrador(FechaActual, TipoUsuario);
    end;
end;

{**************************************************************************************************************}
procedure IniciarTorneo(var TipoUsuario:byte);
begin
if FechaActual=0 then
    begin
    //PROCEDIMIENTO INICIAR TORNEO
    end
else
    begin
    write('Torneo en curso!');
    delay(TIEMPO_SALIDA);
    MenuAdministrador(FechaActual, TipoUsuario);
    end;
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);
var
    I: integer;
begin
   for I:=1 to JUGADORES do
    begin
        if (jugoPartido(I) = true) then
            vPuntajeJugador[I,FechaActual] := obtenerPuntajeJugador(I)
        else
            vPuntajeJugador[I,FechaActual] := 0;
    end;
end;

{**************************************************************************************************************}
{Calculo del puntaje de cada equipo en la fecha actual. Emanuel Kotzayan}
procedure CalcularPuntajeEquipo (VAR vUsuarios: tUsuarios; VAR vPuntajeJugador: tPuntajeJugador);
var
    I,J, Acumulador: integer;
begin
for I:=1 to MAX_USUARIOS do
    begin
        Acumulador := 0;
        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);
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
    I,J,K: Integer;
begin
for I := 1 to JUGADORES do
    begin
        vElegidoJugadores[I].ID := I;
        vElegidoJugadores[I].Valor := 0;
    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; VAR FechaActual: byte);
begin
AumentarFecha (FechaActual);
CalcularPuntajeJugador (vPuntajeJugador);
CalcularPuntajeEquipo (vUsuarios, vPuntajeJugador);
OrdenarPuntajeTotalJugadores(vPuntajeTotalJugadores);
CargarTacticas(vUsuarios, vTacticas, CantUsuarios);
OrdenarTacticas(vTacticas,CantUsuarios);
ObtenerJugadoresElegidos(vElegidoJugadores);
OrdenarJugadoresElegidos(vElegidoJugadores, CantUsuarios);
end;

{**************************************************************************************************************}
procedure CargarCalificaciones(var TipoUsuario:byte);
begin
if FechaActual>0 then
    PasarFecha (vUsuarios, vPuntajeJugador, FechaActual)
else
    begin
    writeln;
    write('Torneo no iniciado. No puede cargar calificaciones!');
    delay(TIEMPO_SALIDA);
    MenuAdministrador(FechaActual, TipoUsuario);
    end;
end;

{**************************************************************************************************************}
{Muestra Listado de Opciones pasa usuarios comunes}
procedure MenuUsuario(var TipoUsuario:byte);
var
    Opcion:byte;
begin
TipoUsuario:=1;                      {PANTALLA MENU USER}
ImprimirTitulo();
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);
            2:RealizarCambios(TipoUsuario);
            3:begin
                TipoUsuario:=1;
                MenuCorrerReportes(vUsuarios, TipoUsuario);
                end;
            0:MenuIniciarSesion(vUsuarios, TipoUsuario);
       else
               MenuUsuario(TipoUsuario);
         end
end;

{**************************************************************************************************************}
{Muestra Menu de Opciones para el Administrador}
procedure MenuAdministrador(var FechaActual:byte; var TipoUsuario:byte);
var
    Opcion:byte;
begin
TipoUsuario:=0;
ImprimirTitulo();
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);
    2:RealizarCambios(TipoUsuario);
    3:MenuCorrerReportes(vUsuarios, TipoUsuario);
    4:ConfigurarApuestas(vUsuarios, Premios);
    5:IniciarTorneo(TipoUsuario);
    6:CargarCalificaciones(TipoUsuario);
    0:MenuIniciarSesion(vUsuarios, TipoUsuario)

else
    MenuAdministrador(FechaActual, TipoUsuario);
end;
end;

{**************************************************************************************************************}
{Pide y guarda datos de usuarios el el registro}
procedure CargaUsuarios(var Usuarios:tUsuarios; var TipoUsuario:byte; var UsuarioActual:string);
var
    Nombre, Apellido, Club, Usuario, Contrasena, pwConfirmacion:string;
    i:byte;
begin
if (FechaActual=0) and (CantidadParticipantes(Usuarios)<MAX_USUARIOS) then
begin
Contrasena:='';
Usuario:='';
i:=Posicion(Usuarios);
ImprimirTitulo();
OrdenarVector(Usuarios, 'Des');
write('Nombre: ');
readln(Nombre);
if Nombre='' then
    begin
    writeln('Campo Obligatorio. Reingrese.');
    delay(TIEMPO_SALIDA);
    CargaUsuarios(Usuarios, TipoUsuario, UsuarioActual);
    end
else
    begin
    write('Apellido: ');readln(Apellido);
    write('Club: ');readln(club);
    write('Usuario: ');readln(Usuario);
    if (UsuarioDuplicado(Usuario, Usuarios)) then
        begin
        writeln('Campo Obligatorio o usuario existente!');
        delay(TIEMPO_SALIDA);
        CargaUsuarios(Usuarios, TipoUsuario, UsuarioActual);
        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(Usuarios, TipoUsuario, UsuarioActual);
            end
        else
            begin
            if TipoUsuario=0 then
                begin
                //Modificar y enviar usuario Actual:
                Usuarios[i].Nombre:=Nombre;
                Usuarios[i].Apellido:=Apellido;
                Usuarios[i].Club:=Club;
                Usuarios[i].Usuario:=Usuario;
                Usuarios[i].Contrasena:=Contrasena;
                Usuarios[i].ID:=i;
                Usuarios[i].TipoUsuario:=TipoUsuario;
                TipoUsuario:=1;
                MenuAdministrador(FechaActual, TipoUsuario);
                end
            else
                begin
                //Modificar y enviar usuario Actual:
                Usuarios[i].Nombre:=Nombre;
                Usuarios[i].Apellido:=Apellido;
                Usuarios[i].Club:=Club;
                Usuarios[i].Usuario:=Usuario;
                Usuarios[i].Contrasena:=Contrasena;
                Usuarios[i].ID:=i;
                Usuarios[i].TipoUsuario:=TipoUsuario;
                MenuUsuario(TipoUsuario);
                end;
            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(Usuarios, TipoUsuario);
    end;
end;

{**************************************************************************************************************}
Procedure PedidoAndres(var Usuarios:tUsuarios; TipoUsuario:byte);
begin
Usuarios[1].TipoUsuario:=1;
Usuarios[1].ID:=Posicion(Usuarios);
Usuarios[1].Nombre:='Raul';
Usuarios[1].Apellido:='Garcia';
Usuarios[1].Club:='River Plate';
Usuarios[1].Usuario:='raul';
Usuarios[1].Contrasena:='raul';

Usuarios[2].TipoUsuario:=1;
Usuarios[2].ID:=Posicion(Usuarios);
Usuarios[2].Nombre:='Carlos';
Usuarios[2].Apellido:='Totti';
Usuarios[2].Club:='Boca Juniors';
Usuarios[2].Usuario:='carlos';
Usuarios[2].Contrasena:='carlos';

Usuarios[3].TipoUsuario:=1;
Usuarios[3].ID:=Posicion(Usuarios);
Usuarios[3].Nombre:='Anibal';
Usuarios[3].Apellido:='Ibarra';
Usuarios[3].Club:='Racing Club';
Usuarios[3].Usuario:='anibal';
Usuarios[3].Contrasena:='anibal';

Usuarios[4].TipoUsuario:=1;
Usuarios[4].ID:=Posicion(Usuarios);
Usuarios[4].Nombre:='Francisco';
Usuarios[4].Apellido:='Pasman';
Usuarios[4].Club:='Sacachispas';
Usuarios[4].Usuario:='francisco';
Usuarios[4].Contrasena:='francisco';
end;

{**************************************************************************************************************}
{Muestra las Primeras 2 Opciones y Inicializa valor de ser necesario.}
procedure MenuPantallaInicial(var TipoUsuario:byte);
var
   Opcion,i:byte;
begin
TipoUsuario:=0;
PedidoAndres(vUsuarios, TipoUsuario);
For i:=1 to MAX_USUARIOS do
    vUsuarios[i].TipoUsuario:=1;
ImprimirTitulo();
writeln('1 - Crear Administrador');
writeln('0 - Salir del Programa');
write('Opcion: ');
Opcion:=ValidarOpciones();
Case Opcion of
    1:CargaUsuarios(vUsuarios, TipoUsuario, UsuarioActual);
    0:begin
      writeln;
      writeln('Fin del programa...');
      end
else
    MenuPantallaInicial(TipoUsuario);
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;

{**************************************************************************************************************}
{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;

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

begin
FechaActual := 0;
GenerarListaJugadores (vListaJugadores);
MenuPantallaInicial(TipoUsuario);
end.

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