& pourquoi j’n’écrirais pas ça ?

unit uSnowflake;

interface

uses FMX.Objects, FMX.Types, System.Classes, Winapi.Windows, System.Math, FMX.Ani, FMX.Filter.Effects;

type
  TSnowflake = class(TImage)
    private
      FloatAnimationHorizontal: TFloatAnimation;
      FloatAnimationVertical  : TFloatAnimation;
      hue                     : THueAdjustEffect;
      FloatAnimationHue       : TFloatAnimation;
      procedure FloatAnimationVerticalFinish(Sender: TObject);
    public
      constructor GenerateSnowflake(AOwner: TComponent; parent: TFMXObject; sSprite: string);
  end;

implementation

{ TSnowflake }

uses uShared;

procedure TSnowflake.FloatAnimationVerticalFinish(Sender: TObject);
begin
  Self.Free;
end;

constructor TSnowflake.GenerateSnowflake(AOwner: TComponent; parent: TFMXObject; sSprite: string);
var
  rsSnowflake : TResourceStream;
  cParent     : TControl;
  dSize       : Double;
begin
  inherited Create(AOwner);
  Self.Parent  := parent;
  Self.HitTest := False;

  cParent := (parent as TControl);

  rsSnowflake := TResourceStream.Create(HInstance, sSprite, RT_RCDATA);
  try
    try
      rsSnowflake.Position := 0;
      Self.Bitmap.LoadFromStream(rsSnowflake);
      dSize := TConfig.Size;
      Self.Width  := Self.Bitmap.Width  * dSize;
      Self.Height := Self.Bitmap.Height * dSize;
      Self.Position.X := RandomRange(0, Round(cParent.Width));
      Self.Position.Y := -Self.Height;

      FloatAnimationHorizontal               := TFloatAnimation.Create(Self);
      FloatAnimationHorizontal.Parent        := Self;
      FloatAnimationHorizontal.StartValue    := Self.Position.X;
      FloatAnimationHorizontal.StopValue     := Self.Position.X + RandomRange(5, 100);
      FloatAnimationHorizontal.PropertyName  := 'Position.X';
      FloatAnimationHorizontal.AnimationType := TAnimationType.atInOut;
      FloatAnimationHorizontal.Interpolation := TInterpolationType.itElastic;
      FloatAnimationHorizontal.Loop          := True;
      FloatAnimationHorizontal.AutoReverse   := True;
      FloatAnimationHorizontal.Duration      := RandomRange(2, 10);

      FloatAnimationVertical              := TFloatAnimation.Create(Self);
      FloatAnimationVertical.Parent       := Self;
      FloatAnimationVertical.OnFinish     := FloatAnimationVerticalFinish;
      FloatAnimationVertical.StartValue   := Self.Position.Y;
      FloatAnimationVertical.StopValue    := cParent.Height;
      FloatAnimationVertical.PropertyName := 'Position.Y';
      FloatAnimationVertical.Duration     := RandomRange(10, 15);

      hue         := THueAdjustEffect.Create(Self);
      hue.Parent  := Self;
      hue.Hue     := 0.3;
      hue.Enabled := True;
      FloatAnimationHue              := TFloatAnimation.Create(Self);
      FloatAnimationHue.Parent       := Hue;
      FloatAnimationHue.StartValue   := -0.2;
      FloatAnimationHue.StopValue    :=  0.3;
      FloatAnimationHue.PropertyName := 'Hue';
      FloatAnimationHue.Duration     := RandomRange(5, 20);
      FloatAnimationHue.AutoReverse  := True;
      FloatAnimationHue.Loop         := True;

      FloatAnimationHorizontal.Start;
      FloatAnimationVertical.Start;
      FloatAnimationHue.Start;
    except
      begin
        Self.Free;
      end;
    end;
  finally
    rsSnowflake.Free;
  end;

//  Self.Free;
end;

end.

unit main;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants, System.Math,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Dialogs, Winapi.Windows, Winapi.MultiMon, FMX.Objects, FMX.Ani, FMX.Filter.Effects;

type
  TfrmMain = class(TForm)
    recBG: TRectangle;
    tmrSnowFlake: TTimer;
    procedure recBGMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Single);
    procedure recBGClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure tmrSnowFlakeTimer(Sender: TObject);
  private
    pMouse  : TPointF;
    function DesktopHeight: Integer;
    function DesktopLeft: Integer;
    function DesktopTop: Integer;
    function DesktopWidth: Integer;
    { Private declarations }
  public
    { Public declarations }
    procedure KeyDown(var Key: Word; var KeyChar: Char; Shift: TShiftState); override;
  end;

const
  DELTA_MOUSE = 5;

var
  frmMain: TfrmMain;

implementation

{$R *.fmx}

uses uShared, uSnowflake;

{ TfrmMain }

{$region 'Taille du bureau virtuel'}
function TfrmMain.DesktopLeft: Integer;
begin
  Result := GetSystemMetrics(SM_XVIRTUALSCREEN);
end;

function TfrmMain.DesktopWidth: Integer;
begin
  Result := GetSystemMetrics(SM_CXVIRTUALSCREEN);
end;

function TfrmMain.DesktopTop: Integer;
begin
  Result := GetSystemMetrics(SM_YVIRTUALSCREEN);
end;

function TfrmMain.DesktopHeight: Integer;
begin
  Result := GetSystemMetrics(SM_CYVIRTUALSCREEN);
end;
{$endregion}

procedure TfrmMain.KeyDown(var Key: Word; var KeyChar: Char; Shift: TShiftState);
begin
  inherited;

  // On ferme la fenêtre pour quitter l'application
  Self.Close;
end;

procedure TfrmMain.FormCreate(Sender: TObject);
begin
  Randomize;

  Self.Left    := DesktopLeft;
  Self.Width   := DesktopWidth;
  Self.Top     := DesktopTop;
  Self.Height  := DesktopHeight;

  pMouse.X := Pred(Self.Left);
  pMouse.Y := Pred(Self.Top);

  ShowCursor(False);

  tmrSnowFlake.Interval := TConfig.Frequency;
  tmrSnowFlake.Enabled  := True;
end;

procedure TfrmMain.recBGClick(Sender: TObject);
begin
  // On ferme la fenêtre pour quitter l'application
  Self.Close;
end;

procedure TfrmMain.recBGMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Single);
begin
  if ((pMouse.X <> Pred(Self.Left)) or (pMouse.Y <> Pred(Self.Top))) then // Valeur initiale
  begin
    if ((Abs(pMouse.X - X) > DELTA_MOUSE) or (Abs(pMouse.Y - Y) > DELTA_MOUSE)) then // Tolérance à un léger décalage...
    begin
      // La souris a bougé... on ferme la fenêtre pour quitter l'application
      Self.Close;
    end;
  end;

  // On met à jour les coordonnées
  pMouse.X := X;
  pMouse.Y := Y;
end;

procedure TfrmMain.tmrSnowFlakeTimer(Sender: TObject);
begin
  // Affichage d'un flocon
  TSnowflake.GenerateSnowflake(Self, recBG, 'sf' + IntToStr(RandomRange(1, 25))); // Affichage aléatoire d'un des 24 flocons
end;

end.