unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Grids, Spin;
type
  TGeldInformationen=packed record
    typ_i:cardinal;
    muenze_b:boolean;
  end;
  TWechselgeldInfo=packed record
    typ_i:byte;
    muenze:boolean;
    mindestAnzahl,mindestBehalten:byte;
  end;
  TWechselgeldOrdnung=packed array[1..200] of TWechselgeldInfo;
  TGeldArray=packed array[1..100] of cardinal;
  EFahrkartenAutomatError=class(Exception);
    EMuenzError=class(EFahrkartenAutomatError)
      MuenzenTyp_i:integer;
      constructor createTyp(const text1_s:string;const typ_i:integer;const text2_s:string);
    end;
      EUnbekannterMuenzenTypError=class(EMuenzError);
      EZuwenigMuenzenVorhandenError=class(EMuenzError);
      ESpeicherkapazitaetVomMuenzenTypVollError=class(EMuenzError);

      EScheinError=class(EFahrkartenAutomatError)
        ScheinTyp_i:integer;
        constructor createTyp(const text1_s:string;const typ_i:integer;const text2_s:string);
      end;
      EUnbekannterScheinTypError=class(EScheinError);
      EZuwenigScheineVorhandenError=class(EScheinError);
      ESpeicherkapazitaetVomScheinenTypVollError=class(EScheinError);

      EFahrkartenError=class(EFahrkartenAutomatError);

 // TArrayOfCardinal=packed array of cardinal;
 TFahrkartenAutomat=class
  private
    FEingeworfenerPreis_i:integer;
    FBestellteKarte_i:integer;
    FEingeworfenesGeld_xagi:packed array[1..100] of TGeldInformationen;
    FEingeworfenesGeldIndex_i:integer;
    FMuenzen_xac:TGeldArray;
    FScheine_xac:TGeldArray;
    FAktiveReihenfolge_xaw:TWechselgeldOrdnung;
    FVirtuellerModus_b:boolean;
    FBackupMuenzen_xac:TGeldArray;
    FBackupScheine_xac:TGeldArray;

    procedure AddGeldInDenStack(const GeldMenge_i:cardinal;const InMuenzen_b:boolean);

    procedure MuenzeVomTypAuswerfen(const typ_i:integer);
    procedure ScheinVomTypAuswerfen(const typ_i:integer);

    procedure WechselgeldAusgeben;
    procedure AktivereVirtuellenModus;
    procedure ReaktivereVirtuellenModus;
    procedure DeaktivereVirtuellenModus;

    function getAnzahlMuenzenVom_c(typ_i:integer):cardinal;
    function getAnzahlScheineVom_c(typ_i:integer):cardinal;
    function getGesamtKapazitaetVom_c(typ_i:integer):cardinal;

    function getAnzahlMuenzen_c:cardinal;
    function getAnzahlScheine_c:cardinal;

    function GibtEsWechselgeld_b:boolean;
  public
    constructor create;
    destructor destroy;override;

    //1
    procedure MuenzeVomTypEinwerfen(const typ_i:integer);
    procedure ScheinVomTypEinwerfen(const typ_i:integer);

    procedure FahrkarteVomTypBestellen(const typ_i:integer);
    procedure FahrkartenBestellungStornieren;

    procedure SetWechselgeldOrdnung(ordnung_xaw:TWechselgeldOrdnung);
    procedure SetStandardWechselgeldOrdnung;

    property MuenzenImSpeicher_c[typ_i:integer]:cardinal read getAnzahlMuenzenVom_c;
    property ScheineImSpeicher_c[typ_i:integer]:cardinal read getAnzahlScheineVom_c;
    property GeldImSpeicher_c[typ_i:integer]:cardinal read getGesamtKapazitaetVom_c;
    property AnzahlMuenzen_c:cardinal read getAnzahlMuenzen_c;
    property AnzahlScheine_c:cardinal read getAnzahlScheine_c;
    property WechselGeldVerfuegbar_b:boolean read GibtEsWechselgeld_b;
    //2

end;
type
  TForm1 = class(TForm)
    StringGrid1: TStringGrid; //Zeigt das im Automaten vorhandene Geld an
    Label1: TLabel;  //Statische Anzeige von: "Bestellte Karte:"
    Label3: TLabel;  //Statische Anzeige von: "Eingeworfener Preis:"
    Label2: TLabel;  //Wert der bestellten Karte
    Label4: TLabel;  //Wert des eingeworfenes Geld
    Label5: TLabel;  //Warnleuchte der dritten Teilaufgabe
    Button1: TButton; //Button um die Anzeigen zu aktualisieren, OnClick=Button1Click
    Button2: TButton; //Button um Münzen einzuwerfen, OnClick=Button2Click
    Button3: TButton; //Button um eine Karte zu bestellen, OnClick=Button3Click
    Button4: TButton; //Button um Scheine einzuwerfen, OnClick=Button4Click
    Button5: TButton; //Button um eine Karte zu stornieren, OnClick=Button5Click
    Button6: TButton; //Button um den Automaten aufzufüllen, OnClick=Button6Click
    SpinEdit1: TSpinEdit; //Wert, der bestellten Karte
    SpinEdit2: TSpinEdit; //Wert der einzuwerfenden Münze
    SpinEdit3: TSpinEdit; // "    "      "        Scheines                                    
    procedure FormCreate(Sender: TObject); //Erzeugen des Automaten
    procedure FormDestroy(Sender: TObject); //Freigeben des   "
    procedure Button1Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
    procedure Button5Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button6Click(Sender: TObject);
  private
    { Private-Deklarationen}
  public
    { Public-Deklarationen}
  end;

var
  Form1: TForm1;
  automat_xf:TFahrkartenAutomat;
implementation

{$R *.DFM}
constructor EMuenzError.createTyp(const text1_s:string;const typ_i:integer;const text2_s:string);
begin
  inherited;
  MuenzenTyp_i:=typ_i;
  Message:=text1_s+IntToStr(typ_i)+text2_s;
end;
constructor EScheinError.createTyp(const text1_s:string;const typ_i:integer;const text2_s:string);
begin
  inherited;
  ScheinTyp_i:=typ_i;
  Message:=text1_s+IntToStr(typ_i)+text2_s;
end;
constructor TFahrkartenAutomat.create;
begin
  inherited;
  FBestellteKarte_i:=0;
  FEingeworfenerPreis_i:=0;
  ZeroMemory(@FMuenzen_xac,sizeof(FMuenzen_xac));
  ZeroMemory(@FScheine_xac,sizeof(FMuenzen_xac));
  SetStandardWechselgeldOrdnung;
end;

destructor TFahrkartenAutomat.destroy;
begin
  inherited;
end;
procedure TFahrkartenAutomat.AddGeldInDenStack(const GeldMenge_i:cardinal;const InMuenzen_b:boolean);
begin
  inc(FEingeworfenesGeldIndex_i);
  FEingeworfenesGeld_xagi[FEingeworfenesGeldIndex_i].typ_i:=GeldMenge_i;
  FEingeworfenesGeld_xagi[FEingeworfenesGeldIndex_i].muenze_b:=InMuenzen_b;
end;
function TFahrkartenAutomat.getAnzahlMuenzenVom_c( typ_i:integer):cardinal;
begin
  if (typ_i<1)or(typ_i>100) then
    raise EUnbekannterMuenzenTypError.createTyp('Es gibt keine Münzen vom Typ ', typ_i,'');
  result:=FMuenzen_xac[typ_i];
end;
function TFahrkartenAutomat.getAnzahlScheineVom_c( typ_i:integer):cardinal;
begin
  if (typ_i<1)or(typ_i>100) then
    raise EUnbekannterScheinTypError.createTyp('Es gibt keine Scheine vom Typ ', typ_i,'');
  result:=FScheine_xac[typ_i];
end;
function TFahrkartenAutomat.getGesamtKapazitaetVom_c( typ_i:integer):cardinal;
begin
  result:=MuenzenImSpeicher_c[typ_i]+ScheineImSpeicher_c[typ_i];
end;
function TFahrkartenAutomat.getAnzahlMuenzen_c:cardinal;
var i:integer;
begin
result:=0;
for i:=1 to 100 do
  result:=Result+MuenzenImSpeicher_c[i];
end;
function TFahrkartenAutomat.getAnzahlScheine_c:cardinal;
var i:integer;
begin
result:=0;
for i:=1 to 100 do
  result:=Result+ScheineImSpeicher_c[i];
end;
procedure TFahrkartenAutomat.MuenzeVomTypEinwerfen(const typ_i:integer);
begin
  if (typ_i<1)or(typ_i>100) then
    raise EUnbekannterMuenzenTypError.createTyp('Es gibt keine Münzen vom Typ ', typ_i,'');
  if (FMuenzen_xac[typ_i]>=high(FMuenzen_xac[typ_i])) then
    raise ESpeicherkapazitaetVomMuenzenTypVollError.createTyp('Der Speicher für Münzen vom Typ ',typ_i,' ist voll');
  if (FBestellteKarte_i=0) then
    raise EFahrkartenAutomatError.create('Um Geldeinzuwerfen, muss man erst eine Fahrkarte bestellen.');
  if (FEingeworfenesGeldIndex_i>=100) then
    raise EFahrkartenAutomatError.create('Speicher für eingeworfenes Geld ist voll (Lösung: Fahrkartenbestellung stornieren)');
  AddGeldInDenStack(typ_i,true);

  FMuenzen_xac[typ_i]:=FMuenzen_xac[typ_i]+1;
  FEingeworfenerPreis_i:=FEingeworfenerPreis_i+typ_i;
  if FEingeworfenerPreis_i=FBestellteKarte_i then begin
    FEingeworfenesGeldIndex_i:=0;
    FBestellteKarte_i:=0;
    //Karte ausgeben
  end else if FEingeworfenerPreis_i>FBestellteKarte_i then
    WechselgeldAusgeben;
end;
procedure TFahrkartenAutomat.ScheinVomTypEinwerfen(const typ_i:integer);
begin
  if (typ_i<1)or(typ_i>100) then
    raise EUnbekannterScheinTypError.createTyp('Es gibt keine Scheine vom Typ ', typ_i,'');
  if (FMuenzen_xac[typ_i]>=high(FMuenzen_xac[typ_i])) then
    raise ESpeicherkapazitaetVomScheinenTypVollError.createTyp('Der Speicher für Scheine vom Typ ',typ_i,' ist voll');
  if (FBestellteKarte_i=0) then
    raise EFahrkartenAutomatError.create('Um Geldeinzuwerfen, muss man erst eine Fahrkarte bestellen.');
  if (FEingeworfenesGeldIndex_i>=100) then
    raise EFahrkartenAutomatError.create('Speicher für eingeworfenes Geld ist voll (Lösung: Fahrkartenbestellung stornieren)');
  AddGeldInDenStack(typ_i,false);

  FScheine_xac[typ_i]:=FScheine_xac[typ_i]+1;
  FEingeworfenerPreis_i:=FEingeworfenerPreis_i+typ_i;
  if FEingeworfenerPreis_i=FBestellteKarte_i then begin
    FEingeworfenesGeldIndex_i:=0;
    FBestellteKarte_i:=0;
    //Karte ausgeben
  end else if FEingeworfenerPreis_i>FBestellteKarte_i then
    WechselgeldAusgeben;
end;
procedure TFahrkartenAutomat.MuenzeVomTypAuswerfen(const typ_i:integer);
begin
  if MuenzenImSpeicher_c[typ_i] <= 0 then
    raise EZuwenigMuenzenVorhandenError.createTyp('Es sind keine Münzen vom Typ ',typ_i,' vorhanden');

  FMuenzen_xac[typ_i]:=FMuenzen_xac[typ_i]-1;
  if not FVirtuellerModus_b then begin
    //Münzen Auswerfen
    ShowMessage('Münze ausgeworfen vom Typ: '+IntToStr(typ_i));
  end;
end;
procedure TFahrkartenAutomat.ScheinVomTypAuswerfen(const typ_i:integer);
begin
  if ScheineImSpeicher_c[typ_i] <= 0 then
    raise EZuwenigScheineVorhandenError.createTyp('Es sind keine Scheine vom Typ ',typ_i,' vorhanden');
  FScheine_xac[typ_i]:=FScheine_xac[typ_i]-1;

  if not FVirtuellerModus_b then begin
    //Scheine Auswerfen:
    ShowMessage('Schein ausgeworfen vom Typ: '+IntToStr(typ_i));
  end;
end;
procedure TFahrkartenAutomat.FahrkarteVomTypBestellen(const typ_i:integer);
begin
  if FBestellteKarte_i<>0 then
    raise EFahrkartenError.create('Es wurde bereits eine Fahrkarte bestellt. Diese Bestellung muss, um eine neue aufzugeben, zuerst storniert werden');
  FBestellteKarte_i:=typ_i;
  FEingeworfenerPreis_i:=0;
  FEingeworfenesGeldIndex_i:=0;
end;
procedure TFahrkartenAutomat.FahrkartenBestellungStornieren;
var i:integer;
begin
  FBestellteKarte_i:=0;
  FEingeworfenerPreis_i:=0;
  for i:=FEingeworfenesGeldIndex_i downto 1 do
    if FEingeworfenesGeld_xagi[i].muenze_b then
      MuenzeVomTypAuswerfen(FEingeworfenesGeld_xagi[i].typ_i)
     else
      ScheinVomTypAuswerfen(FEingeworfenesGeld_xagi[i].typ_i);
  FEingeworfenesGeldIndex_i:=0;
end;
procedure TFahrkartenAutomat.WechselgeldAusgeben();
var i,j_i,Schuld_i,firstIndex_i:integer;
    ReihenFolge_xaw:TWechselgeldOrdnung;
begin
  if FEingeworfenerPreis_i<=FBestellteKarte_i then
    raise EFahrkartenAutomatError.create('Es muss gar kein Wechselgeld ausgegeben werden');

  for i:=FEingeworfenesGeldIndex_i downto 0 do
    if FEingeworfenerPreis_i-FEingeworfenesGeld_xagi[i].typ_i>FBestellteKarte_i then begin
      FEingeworfenerPreis_i:=FEingeworfenerPreis_i-FEingeworfenesGeld_xagi[i].typ_i;
      if FEingeworfenesGeld_xagi[i].muenze_b then
        MuenzeVomTypAuswerfen(FEingeworfenesGeld_xagi[i].typ_i)
       else
        ScheinVomTypAuswerfen(FEingeworfenesGeld_xagi[i].typ_i);
      FEingeworfenesGeld_xagi[i]:=FEingeworfenesGeld_xagi[FEingeworfenesGeldIndex_i];
      FEingeworfenesGeldIndex_i:=FEingeworfenesGeldIndex_i-1;
    end;
  if FEingeworfenerPreis_i<=FBestellteKarte_i then
    exit;
  ReihenFolge_xaw:=FAktiveReihenfolge_xaw;
  AktivereVirtuellenModus;
  repeat
    Schuld_i:=FEingeworfenerPreis_i-FBestellteKarte_i;
    firstIndex_i:=-1;
    for i:=1 to 200 do begin
//    if Reihenfolge_xaw[i].mindestAnzahl<niedrigsteMindestAnzahl then Reihenfolge_xaw[i].
      j_i:=1;
      if ReihenFolge_xaw[i].muenze then begin
        if  MuenzenImSpeicher_c[ReihenFolge_xaw[i].typ_i]-ReihenFolge_xaw[i].mindestBehalten<ReihenFolge_xaw[i].mindestAnzahl then
          ReihenFolge_xaw[i].mindestAnzahl:=MuenzenImSpeicher_c[ReihenFolge_xaw[i].typ_i]-ReihenFolge_xaw[i].mindestBehalten;
        while (j_i<=ReihenFolge_xaw[i].mindestAnzahl)and(Schuld_i>=Reihenfolge_xaw[i].typ_i) do begin
          if firstIndex_i=-1 then firstIndex_i:=i;
          MuenzeVomTypAuswerfen(Reihenfolge_xaw[i].typ_i);
          inc(j_i);
        end;
      end else begin
        if  ScheineImSpeicher_c[ReihenFolge_xaw[i].typ_i]-Reihenfolge_xaw[i].mindestBehalten<Reihenfolge_xaw[i].mindestAnzahl then
          Reihenfolge_xaw[i].mindestAnzahl:=ScheineImSpeicher_c[reihenfolge_xaw[i].typ_i]-Reihenfolge_xaw[i].mindestBehalten;
        while (j_i<=Reihenfolge_xaw[i].mindestAnzahl)and(Schuld_i>=Reihenfolge_xaw[i].typ_i) do begin
          if firstIndex_i=-1 then firstIndex_i:=i;
          ScheinVomTypAuswerfen(Reihenfolge_xaw[i].typ_i);
          inc(j_i);
        end;
      end;
    end;
    for i:=1 to 200 do begin
      if Reihenfolge_xaw[i].muenze then begin
        while (Schuld_i>=Reihenfolge_xaw[i].typ_i)and(MuenzenImSpeicher_c[Reihenfolge_xaw[i].typ_i]>ReihenFolge_xaw[i].mindestBehalten) do begin
          if firstIndex_i=-1 then firstIndex_i:=i;
          MuenzeVomTypAuswerfen(Reihenfolge_xaw[i].typ_i);
          Schuld_i:=Schuld_i-Reihenfolge_xaw[i].typ_i;
        end;
      end else begin
        while (Schuld_i>=Reihenfolge_xaw[i].typ_i)and(ScheineImSpeicher_c[Reihenfolge_xaw[i].typ_i]>ReihenFolge_xaw[i].mindestBehalten) do begin
          if firstIndex_i=-1 then firstIndex_i:=i;
          ScheinVomTypAuswerfen(Reihenfolge_xaw[i].typ_i);
          Schuld_i:=Schuld_i-Reihenfolge_xaw[i].typ_i;
        end;
      end;
    end;

    if (Schuld_i>0)and(FVirtuellerModus_b) then begin
      if firstIndex_i<>-1 then begin
        ReaktivereVirtuellenModus;
        ReihenFolge_xaw[firstIndex_i].mindestBehalten:=ReihenFolge_xaw[firstIndex_i].mindestBehalten+1;
      end else begin
        DeaktivereVirtuellenModus;
        FahrkartenBestellungStornieren;
        raise EFahrkartenAutomatError.create('Es gibt kein passendes Wechselgeld');
      end;
    end else if FVirtuellerModus_b then begin
      Schuld_i:=100;
      DeaktivereVirtuellenModus;
    end;
  until Schuld_i<=0;
  if FVirtuellerModus_b then
    DeaktivereVirtuellenModus;
  FBestellteKarte_i:=0;
  FEingeworfenerPreis_i:=0;
end;

procedure TFahrkartenAutomat.AktivereVirtuellenModus;
begin
  if FVirtuellerModus_b then
    raise EFahrkartenAutomatError.create('Es ist nicht möglich im virtuellen Modus denselben zu aktivieren');
  FVirtuellerModus_b:=true;
  FBackupMuenzen_xac:=fMuenzen_xac;
  FBackupScheine_xac:=FScheine_xac;
end;
procedure TFahrkartenAutomat.ReaktivereVirtuellenModus;
begin
  if FVirtuellerModus_b=false then
    raise EFahrkartenAutomatError.create('Es ist nicht möglich eine deaktivierten virtuellen Modus zu reaktivieren');
  FMuenzen_xac:=FBackupMuenzen_xac;
  FScheine_xac:=FBackupScheine_xac;
end;
procedure TFahrkartenAutomat.DeaktivereVirtuellenModus;
begin
  if FVirtuellerModus_b=false then
    raise EFahrkartenAutomatError.create('Es ist nicht möglich den virtuellen Modus zu deaktivieren, wenn er es schon ist');
  FVirtuellerModus_b:=false;
  FMuenzen_xac:=FBackupMuenzen_xac;
  FScheine_xac:=FBackupScheine_xac;
end;
function TFahrkartenAutomat.GibtEsWechselgeld_b:boolean;
var
  gesamtGeld_xac:tGeldArray;
  neuesGeld_xac:TGeldArray;
  MindestBehalten_xac:TGeldArray;
  i,j,Wechselgeld_i,index_i:integer;
begin
  result:=true;
  for i:=1 to 99 do begin
    gesamtGeld_xac[i]:=GeldImSpeicher_c[i];
    if (gesamtGeld_xac[i]=0) then begin
      result:=false;
      for j:=1 to i-1 do
        if (gesamtGeld_xac[j]*j>=i)and(i mod j=0) then begin
          result:=true;
          break;
        end;
      if not result then begin
        ZeroMemory(@mindestBehalten_xac,length(mindestBehalten_xac)*sizeof(mindestBehalten_xac[1]));
        repeat
          Wechselgeld_i:=i;
          neuesGeld_xac:=gesamtGeld_xac;
          index_i:=-1;
          for j:=i-1 downto 1 do begin
            while (Wechselgeld_i>=j) and (neuesGeld_xac[j]>MindestBehalten_xac[j]) do begin
              if index_i=-1 then index_i:=j;
              Wechselgeld_i:=Wechselgeld_i-j;
              neuesGeld_xac[j]:=neuesGeld_xac[j]-1;
            end;
          end;
          if Wechselgeld_i>0 then begin
            if index_i<>-1 then MindestBehalten_xac[index_i]:=mindestBehalten_xac[index_i]+1
            else wechselgeld_i:=0;
          end else result:=true;
        until Wechselgeld_i=0;
        if not Result then exit;
      end;
    end;
  end;
end;

procedure TFahrkartenAutomat.SetWechselgeldOrdnung(ordnung_xaw:TWechselgeldOrdnung);
begin
  FAktiveReihenfolge_xaw:=ordnung_xaw;
end;
procedure TFahrkartenAutomat.SetStandardWechselgeldOrdnung;
var i:integer;
begin
  zeromemory(@FAktiveReihenfolge_xaw,sizeof(FAktiveReihenfolge_xaw));
  FAktiveReihenfolge_xaw[1].typ_i:=100;

  FAktiveReihenfolge_xaw[3].typ_i:=75;

  FAktiveReihenfolge_xaw[5].typ_i:=50;

  FAktiveReihenfolge_xaw[7].typ_i:=25;

  FAktiveReihenfolge_xaw[9].typ_i:=20;

  FAktiveReihenfolge_xaw[11].typ_i:=10;

  FAktiveReihenfolge_xaw[13].typ_i:=90;

  FAktiveReihenfolge_xaw[15].typ_i:=80;

  FAktiveReihenfolge_xaw[17].typ_i:=70;

  FAktiveReihenfolge_xaw[19].typ_i:=60;

  FAktiveReihenfolge_xaw[21].typ_i:=40;

  FAktiveReihenfolge_xaw[23].typ_i:=30;

  FAktiveReihenfolge_xaw[25].typ_i:=95;

  FAktiveReihenfolge_xaw[27].typ_i:=85;

  FAktiveReihenfolge_xaw[29].typ_i:=65;

  FAktiveReihenfolge_xaw[31].typ_i:=55;

  FAktiveReihenfolge_xaw[33].typ_i:=45;

  FAktiveReihenfolge_xaw[35].typ_i:=35;

  FAktiveReihenfolge_xaw[37].typ_i:=15;

  FAktiveReihenfolge_xaw[39].typ_i:=5;

  FAktiveReihenfolge_xaw[41].typ_i:=98;

  FAktiveReihenfolge_xaw[43].typ_i:=96;

  FAktiveReihenfolge_xaw[45].typ_i:=94;

  FAktiveReihenfolge_xaw[47].typ_i:=92;

  FAktiveReihenfolge_xaw[49].typ_i:=88;

  FAktiveReihenfolge_xaw[51].typ_i:=86;

  FAktiveReihenfolge_xaw[53].typ_i:=84;

  FAktiveReihenfolge_xaw[55].typ_i:=82;

  FAktiveReihenfolge_xaw[57].typ_i:=78;

  FAktiveReihenfolge_xaw[59].typ_i:=76;

  FAktiveReihenfolge_xaw[61].typ_i:=74;

  FAktiveReihenfolge_xaw[63].typ_i:=72;

  FAktiveReihenfolge_xaw[65].typ_i:=68;

  FAktiveReihenfolge_xaw[67].typ_i:=66;

  FAktiveReihenfolge_xaw[69].typ_i:=64;

  FAktiveReihenfolge_xaw[71].typ_i:=62;

  FAktiveReihenfolge_xaw[73].typ_i:=58;

  FAktiveReihenfolge_xaw[75].typ_i:=56;

  FAktiveReihenfolge_xaw[77].typ_i:=54;

  FAktiveReihenfolge_xaw[79].typ_i:=52;

  FAktiveReihenfolge_xaw[81].typ_i:=48;

  FAktiveReihenfolge_xaw[83].typ_i:=46;

  FAktiveReihenfolge_xaw[85].typ_i:=44;

  FAktiveReihenfolge_xaw[87].typ_i:=42;

  FAktiveReihenfolge_xaw[89].typ_i:=38;

  FAktiveReihenfolge_xaw[91].typ_i:=36;

  FAktiveReihenfolge_xaw[93].typ_i:=34;

  FAktiveReihenfolge_xaw[95].typ_i:=32;

  FAktiveReihenfolge_xaw[97].typ_i:=28;

  FAktiveReihenfolge_xaw[99].typ_i:=26;

  FAktiveReihenfolge_xaw[101].typ_i:=24;

  FAktiveReihenfolge_xaw[103].typ_i:=22;

  FAktiveReihenfolge_xaw[105].typ_i:=18;

  FAktiveReihenfolge_xaw[107].typ_i:=16;

  FAktiveReihenfolge_xaw[109].typ_i:=14;

  FAktiveReihenfolge_xaw[111].typ_i:=12;

  FAktiveReihenfolge_xaw[113].typ_i:=8;

  FAktiveReihenfolge_xaw[115].typ_i:=6;

  FAktiveReihenfolge_xaw[117].typ_i:=4;

  FAktiveReihenfolge_xaw[119].typ_i:=2;

  FAktiveReihenfolge_xaw[121].typ_i:=99;

  FAktiveReihenfolge_xaw[123].typ_i:=97;

  FAktiveReihenfolge_xaw[125].typ_i:=93;

  FAktiveReihenfolge_xaw[127].typ_i:=91;

  FAktiveReihenfolge_xaw[129].typ_i:=89;

  FAktiveReihenfolge_xaw[131].typ_i:=87;

  FAktiveReihenfolge_xaw[133].typ_i:=83;

  FAktiveReihenfolge_xaw[135].typ_i:=81;

  FAktiveReihenfolge_xaw[137].typ_i:=79;

  FAktiveReihenfolge_xaw[139].typ_i:=77;

  FAktiveReihenfolge_xaw[141].typ_i:=73;

  FAktiveReihenfolge_xaw[143].typ_i:=71;

  FAktiveReihenfolge_xaw[145].typ_i:=69;

  FAktiveReihenfolge_xaw[147].typ_i:=67;

  FAktiveReihenfolge_xaw[149].typ_i:=63;

  FAktiveReihenfolge_xaw[151].typ_i:=61;

  FAktiveReihenfolge_xaw[153].typ_i:=59;

  FAktiveReihenfolge_xaw[155].typ_i:=57;

  FAktiveReihenfolge_xaw[157].typ_i:=53;

  FAktiveReihenfolge_xaw[159].typ_i:=51;

  FAktiveReihenfolge_xaw[161].typ_i:=49;

  FAktiveReihenfolge_xaw[163].typ_i:=47;

  FAktiveReihenfolge_xaw[165].typ_i:=43;

  FAktiveReihenfolge_xaw[167].typ_i:=41;

  FAktiveReihenfolge_xaw[169].typ_i:=39;

  FAktiveReihenfolge_xaw[171].typ_i:=37;

  FAktiveReihenfolge_xaw[173].typ_i:=33;

  FAktiveReihenfolge_xaw[175].typ_i:=31;

  FAktiveReihenfolge_xaw[177].typ_i:=29;

  FAktiveReihenfolge_xaw[179].typ_i:=27;

  FAktiveReihenfolge_xaw[181].typ_i:=23;

  FAktiveReihenfolge_xaw[183].typ_i:=21;

  FAktiveReihenfolge_xaw[185].typ_i:=19;

  FAktiveReihenfolge_xaw[187].typ_i:=17;

  FAktiveReihenfolge_xaw[189].typ_i:=13;

  FAktiveReihenfolge_xaw[191].typ_i:=11;

  FAktiveReihenfolge_xaw[193].typ_i:=9;

  FAktiveReihenfolge_xaw[195].typ_i:=7;

  FAktiveReihenfolge_xaw[197].typ_i:=3;

  FAktiveReihenfolge_xaw[199].typ_i:=1;

  for i:=1 to 100 do begin
    FAktiveReihenfolge_xaw[i*2].typ_i:=FAktiveReihenfolge_xaw[i*2-1].typ_i;
    if FAktiveReihenfolge_xaw[i*2-1].typ_i>50 then begin
      FAktiveReihenfolge_xaw[i*2].muenze:=true;
      FAktiveReihenfolge_xaw[i*2-1].muenze:=false;
    end else begin
      FAktiveReihenfolge_xaw[i*2-1].muenze:=true;
      FAktiveReihenfolge_xaw[i*2].muenze:=false;
    end;
  end;
end;
procedure TForm1.FormCreate(Sender: TObject);
var i:integer;
begin
  StringGrid1.Cells[1,0]:='Münzen';
  StringGrid1.Cells[2,0]:='Scheine';
  StringGrid1.Cells[3,0]:='Insgesamt';
  for i:=1 to 100 do begin
    StringGrid1.Cells[0,i]:=IntToStr(i);
  end;
  automat_xf:=TFahrkartenAutomat.create;
end;

procedure TForm1.Button1Click(Sender: TObject);
var i:integer;
begin
  for i:=1 to 100 do begin
    StringGrid1.Cells[1,i]:=IntToStr(automat_xf.getAnzahlMuenzenVom_c(i));;
    StringGrid1.Cells[2,i]:=IntToStr(automat_xf.getAnzahlScheineVom_c(i));;
    StringGrid1.Cells[3,i]:=IntToStr(automat_xf.getGesamtKapazitaetVom_c(i));;
  end;
  label2.Caption:=IntToStr(automat_xf.FBestellteKarte_i);
  label4.Caption:=IntToStr(automat_xf.FEingeworfenerPreis_i);
  Label5.Visible:=not automat_xf.GibtEsWechselgeld_b;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  automat_xf.free;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  automat_xf.FahrkarteVomTypBestellen(SpinEdit3.Value);
  Button1.Click;
end;


procedure TForm1.Button5Click(Sender: TObject);
begin
  automat_xf.FahrkartenBestellungStornieren;
  Button1.Click;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  automat_xf.MuenzeVomTypEinwerfen(SpinEdit1.Value);
  Button1.Click;
end;
procedure TForm1.Button4Click(Sender: TObject);
begin
  automat_xf.ScheinVomTypEinwerfen(SpinEdit2.value);
  Button1.Click;
end;

procedure TForm1.Button6Click(Sender: TObject);
var i:integer;
begin
for i:=1 to 100 do begin
  automat_xf.FahrkarteVomTypBestellen(i);
  automat_xf.MuenzeVomTypEinwerfen(i);
  automat_xf.FahrkarteVomTypBestellen(i);
  automat_xf.ScheinVomTypEinwerfen(i);
end;
Button1.Click;
end;

end.

