1:
2:
3:
4:
5:
6:
7:
8:

with ComputerPlayedCard do
  for i := ComputerLImage1.Left to iAbgelegtePosX-65 do
  begin
    SetBounds(i, iTalonPosY, Width, Height);
    if Application.Terminated then exit;
    Sleep(iDelay);  //Ist zB. 1
    if Odd(i) then Form1.Refresh;
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

PROCEDURE TForm1.Button1Click(Sender: TObject);
VAR
  i, j: integer;
BEGIN

  Edit1.Text := '';
  application.ProcessMessages;
  FOR j := 0 TO 19 DO
    BEGIN
      FOR i := 1 TO 100 do
        sleep(10);
      Edit1.Text := Edit1.Text + 'X';
      application.ProcessMessages;
    END;
END;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

procedure Zeitschleife(msZeit: DWord);
var Dauer: double;
    Anfang, Ende, Frequenz : TLargeInteger;
begin
  QueryPerformanceFrequency(Frequenz);
  QueryPerformanceCounter(Anfang);
  repeat
    Application.ProcessMessages;  ///je nachdem, ob es gebraucht wird
    QueryPerformanceCounter(Ende);
    Dauer:=(Ende-Anfang)/Frequenz*1000.0;
    ///hier irgendetwas machen, zeichnen ....
  until Dauer>=msZeit;
end;                    

1:
2:
3:
4:
5:
6:
7:

MoveWidth := iAbgelegtePosX-65 - ComputerLImage1.Left; 
// Bewegungsweite

OriginalLeft := ComputerLImage1.Left;

// Und in der Schleife
ComputerLImage1.Left := OriginalLeft + VergangeneMillisekunden / DauerInMillisekunden * MoveWidth;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

var
  MoveWidth, OriginalLeft, VergangeneMillisekunden, DauerInMillisekunden: Integer;
//...
begin
  OriginalLeft := ComputerLImage1.Left;
  DauerInMillisekunden := 100;
  VergangeneMillisekunden := 0;

  while Left < iAbgelegtePosX do  //Left bezieht sich auf das TImage!
  begin
    Inc(VergangeneMillisekunden);  //Wie zähle ich VergangeneMillisekunden?

    //Hier kommt: "[DCC Fehler] CardsHandling.pas(884): E2010 Inkompatible Typen: 'Integer' und 'Extended'"
    {Left := OriginalLeft + VergangeneMillisekunden / DauerInMillisekunden * MoveWidth;}

    //Also mache ich es so:
    Left := OriginalLeft + VergangeneMillisekunden div DauerInMillisekunden * MoveWidth;

    Form1.Refresh;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

var
  StartPos, EndPos: Integer;
  Start, Current, Freq: Int64;
begin
  StartPos := 8;
  EndPos := FGui.DisplayWidth - 8 - FGui.ImageWidth;
  QueryPerformanceFrequency(Freq);
  while not Terminated do
  begin
    FGui.ImageLeft := StartPos;
    QueryPerformanceCounter(Start);
    repeat
      QueryPerformanceCounter(Current);
      FGui.ImageLeft := StartPos + Round((EndPos - StartPos) * (Current - Start) * 1000 / Freq / FAnimationDuration);
    until (Current - Start) * 1000 / Freq >= FAnimationDuration;
    FGui.ImageLeft := EndPos;
    Sleep(100);
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

var
  StartPos, EndPos: Integer;
  Start, Current, Freq: Int64;
begin
  StartPos := 8;
  EndPos := FGui.DisplayWidth - 8 - FGui.ImageWidth;

  //Der Name erklärt zwar, was das macht, aber zunächst dachte ich,
  //an Freq wird ja gar nichts zugewiesen. Das macht aber wohl QueryPerformanceFrequency!
  QueryPerformanceFrequency(Freq);
  while not Terminated do
  begin
    FGui.ImageLeft := StartPos;
 
   QueryPerformanceCounter(Start);  //Siehe obigen Kommentar!

    repeat
      QueryPerformanceCounter(Current);  //Auch das war/ist mir nicht so ganz klar, wie das arbeitet!

      //Auf diese Formel (auch auf die Anweisung im until) wäre ich von selbst nie gekommen!
      FGui.ImageLeft := StartPos + Round((EndPos - StartPos) * (Current - Start) * 1000 / Freq / FAnimationDuration);
    until (Current - Start) * 1000 / Freq >= FAnimationDuration;
    FGui.ImageLeft := EndPos;
    Sleep(100);
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

{**************************************************************************************************}
procedure SetSleepGranularity();
begin
  timeBeginPeriod(1);
end;
{**************************************************************************************************}
procedure ResetSleepGranularity();
begin
  timeEndPeriod(1);
end;
{**************************************************************************************************}