parcial-2008-12-04.pas

program aeropuerto;

uses crt;

const
  OPCIONES = ['A','D','P','F'];

type
  RegEvento = record
    nroVuelo:integer;
    hhmm:word;
    demora:byte;
  end;
  RegHistorial = record
    nroPista:byte;
    Evento:RegEvento;
  end;
  ArchivoHistorial = file of RegHistorial;
  
  tInfo = RegEvento;
  tpNodo = ^tNodo;
  tNodo = record
    Info:tInfo;
    sgte:tpNodo;
  end;  
  tCola = record
    P,
    F:tpNodo;
  end;
  tLista:tpNodo;
  
  RegPista = record
    habilitada:boolean;
    Despegues,
    Aterrizajes:tCola;
  end;
  
  VectorPista = array[1..9] of RegPista;

procedure Encolar(var Cola:tCola; Info:tInfo);
var
  pNuevo:tpNodo;
begin
  new(pNuevo);
  pNuevo^.Info := Info;
  if Cola.P = nil then
    Cola.P := pNuevo
  else
    Cola.F^.sgte = pNuevo
  end;
  Cola.F := pNuevo
end;

procedure Desencolar(var Cola:tCola; var Info:tInfo);
var
  pLibre:tpNodo;
begin
  Info = Cola.P^.info;
  pLibre = Cola.P;
  Cola.P = Cola.P^.sgte;
  dispose(pLibre);
  if Cola.P = nil
    Cola.F := nil
end;

procedure InsertarFrente(var Lista:tLista; Info:tInfo);
var 
  pNuevo:tpNodo;
begin
  new(pNuevo);
  pNuevo^.Info := Info;
  pNuevo^.sgte := Lista;
  Lista := pNuevo;
end;

procedure InsertarEnMedio(var Lista:tLista; Info:tInfo);
var
  pNuevo,
  pAct:tpNodo;
begin
  new(pNuevo);
  pNuevo^.Info := Info;
  pNuevo^.sgte := nil;
  pAct := Lista;
  while (pAct^.sgte <> nil) and (Abs(pNuevo^.Info.nroVuelo) < Abs(pAct^.sgte^.Info.nroVuelo)) do
    pAct := pAct^.sgte;
  pNuevo^.sgte := pAct^.sgte;
  pAct^.sgte := pNuevo
end;

procedure InsertarEnHistorial(var Historial:tLista; Info:tInfo);
begin
  Info.nroVuelo := Abs(Info.nroVuelo);
  if (Historial = nil) or (Abs(Info.nroVuelo) > Abs(Historial^.Info.nroVuelo)) then
    InsertarFrente(Historial, Info)
  else
    InsertarEnMedio(Historial, Info)
end;

procedure LeerHistorial(var Historial:tLista, var Info:tInfo);
var
  pLibre:tpNodo;
begin
  pLibre := Historial;
  Info := pLibre^.Info;
  Historial := Historial^.sgte;
  dispose(pLibre);
end;

procedure AbrirArchivos(var ArchDes, ArchAtt:ArchivoHistorial); begin {}
  assign(ArchDes, 'despegues.dat');
  assign(ArchAtt, 'aterrizajes.dat');
  fileMode := 1;
  reset(ArchDes);
  reset(ArchAtt)
end;

procedure CerrarArchivos(var ArchDes, ArchAtt:ArchivoHistorial); begin {}
  close(ArchDes);
  close(ArchAtt);
end;

procedure MostrarEncabezado;
var
  aaaa,mm,dd,ds:integer;
begin
  GetDate(aaaa,mm,dd,ds);
  writeln('Aeropuertos XII - Torre de Control');
  writeln
  writeln(' ':20, 'ATTERIZAJES Y DESPEGUES DEL DÍA ', dd, '/', mm, '/', aaaa);
  writeln('NUMERO DE VUELO    HORA DE SOLICITUD    NUMERO DE PISTA    ACCIÓN');
end;

function ObtenerOpcion:char;
var
  opcion:char;
begin
  repeat
    readln(opcion);
    opcion := UPCASE(opcion);
  until opcion in OPCIONES;
  ObtenerOpcion := opcion;
end;

function PistaLibre(var vPistas:VectorPista):byte;
var
  i:byte;
  pista:byte;
begin
  pista := 0;
  i := 0;
  repeat
    inc(i);
    if vPistas[i].habilitada
      pista := i
  until (pista <> 0) or (i = 9)
  PistaLibre := pista;
end;

procedure ObtenerDatosEvento(var nroVuelo:integer; var hora:word);
var
  hh,mm,ss,cs:word;
  vuelo:string;
begin
  readln(vuelo);
  Val(vuelo, nroVuelo);
  GetTime(hh,mm,ss,cs);
  hora := hh * 100 + mm
end;

procedure EfectuarAterrizaje(var Info:tInfo);
var
  altitud,
  distancia:single;
begin
  altitud := 0; distancia := 0;
  repeat
    Radar(altitud,distancia);
    if not ConfirmaTrayectoDescenso(altitud,distancia) then
      writeln('DEBE CORREGIR LA TRAYECTORIA')
  until distancia = 0
end;

procedure ListarEvento(Info:tInfo; pista:byte);
var
  accion:string;
begin
  if Info.nroVuelo < 0 then
    accion := 'DESPEGUE'
  else
    accion := 'ATERRIZAJE';
  writeln(Info.nroVuelo:15, ' ':4,
          Info.hhmm:17, ' ':4,
          pista:15, ' ':4,
          accion:12)
end;

procedure Pista(var vPista:VectorPista; var cEspera:tCola);
var
  pista:byte;
  Info:tInfo;
begin
  repeat
    readln(pista);
  until pista in [1..9];
  if cEspera = nil then
    vPista[pista].habilitada := true;
  else begin
    if vPista[pista].habilitada then begin
      Desencolar(cEspera, Info)  
      vPista[pista].habilitada := false
      ListarEvento(Info, pista);
      if Info.nroVuelo < 0 then
        InsertarEnHistorial(vPista[i].Despegues, Info)
      else begin
        EfectuarAterrizaje(Info);
        InsertarEnHistorial(vPista[i].Aterrizajes, Info)
      end;
      vPista[pista].habilitada := true
    end
  end
end;

procedure Despegar(var vPista:VectorPista; var cEspera:tCola);
var
  pista:byte;
  Info:tInfo;
begin
  ObtenerDatosEvento(Info.nroVuelo, Info.hora);
  Info.nroVuelo := 0 - Abs(Info.nroVuelo);
  Info.demora := 0;
  pista := PistaLibre;
  if pista = 0 then begin
    writeln('Debe ir a la cola de espera.');
    Encolar(cEspera, Info)
  end
  else begin
    vPista[i].habilitada := false;
    ListarEvento(Info, i);
    InsertarEnHistorial(vPista[i].Despegues, Info);
    vPista[i].habilitada := true
  end
end;

procedure Aterrizar(var vPista:VectorPista; var cEspera:tCola);
var
  pista:byte;
  Info:tInfo;
begin
  ObtenerDatosEvento(Info.nroVuelo, Info.hora);
  Info.nroVuelo := Abs(Info.nroVuelo);
  Info.demora := 0;
  pista := PistaLibre;
  if pista = 0 then begin
    writeln('Debe ir a la cola de espera.');
    Encolar(cEspera, Info)
  end
  else begin
    vPista[i].habilitada := false;
    EfectuarAterrizaje(Info);
    ListarEvento(Info, i);
    InsertarEnHistorial(vPista[i].Aterrizajes, Info);
    vPista[i].habilitada := true
  end
end;

procedure Procesar(var vPista:VectorPista; var cEspera:tCola); {}
var
  opcion:char;
  nroVuelo:integer;
  hhmm:word;
begin
  MostrarEncabezado;
  repeat
    opcion := ObtenerOpcion;
    case opcion of
     'A':Aterrizar(vPista, cEspera);
     'D':Despegar(vPista, cEspera);
     'P':Pista(vPista, cEspera);
    end
  until (opcion = 'F') and (cEspera = nil);
end;

procedure GuardarArchivos(var ArchDes, ArchAtt:ArchivoEvento;var vPistas:VectorPistas);
var
  info:tInfo;
  registro:RegHistorial;
  i:byte;
begin
  for i := 9 downto 1 do begin
    while vPistas[i].Despegues <> nil do begin
      LeerHistorial(vPistas[i].Despegues, info);
      registro.Evento := info;
      registro.nroPista := i;
      write(ArchDes, registro)
    end;
    while vPistas[i].Aterrizajes <> nil do begin
      LeerHistorial(vPistas[i].Despegues, info);
      registro.Evento := info;
      registro.nroPista := i;
      write(ArchAtt, registro)
    end
  end
end;

{-----------------------------------------------------------------------------------}
var
  ArchDes,
  ArchAtt:ArchivoHistorial;
  vPista:VectorPista;
  cEspera:tCola;
  
begin
  AbrirArchivos(ArchDes,ArchAtt);
  Procesar(vPista, cEspera);
  GuardarArchivos(ArchDes, ArchAtt, vPista);
  CerrarArchivos(ArchDes,ArchAtt);
end.