Deutsche English	Limitateur de fréquence (aussi appelé Delta-time) et Calculateur d'images par secondes (FPS)	Show Index

Ce morceau de code effectue deux fonctions à la fois.

Premièrement il calcule le nombre d'images par seconde rendues par votre programme lorsqu'il tourne (en faisant l'approximation du temps mis pour rendre les 5 dernières images).

Deuxièmement il vous aide à maintenir la vitesse de votre jeu constante sur n'importe quelle machine en fournissant 2 variables (SpeedFactor# ou TimeElapsed#) que vous pouvez utiliser pour multiplier toutes les fonctions de votre jeu qui dépendent du temps (comme le mouvement du joueur).  Cela vous permet de conserver fluidité et douceur lors de l'exécution de vos jeux (particulierement pour les jeux avec scrolling).

Pour l'utiliser commencez par placer le code suivant au début de votre programme:

Global Debug = True

Type FrameRate
  Field TargetFPS#
  Field SpeedFactor#
  Field TimeElapsed#
  Field FPS#
  Field FPS2#
  Field FPS3#
  Field FPS4#
  Field FPS5#
  Field CurrentTicks
  Field FrameDelay
End Type

Global FL.FrameRate = New FrameRate

;initialize frame limiter
FL\TargetFPS# = 60	;set this to whatever FPS your code is based on
FL\FrameDelay = MilliSecs()

Ensuite placez le code suivant dans votre boucle principale: (là ou s'effectuent les calculs)

;Set Speed Factor
FL\CurrentTicks = MilliSecs()
FL\SpeedFactor# = (FL\CurrentTicks - FL\FrameDelay) / (1000.0 / FL\TargetFPS#)
If FL\SpeedFactor# <= 0 Then FL\SpeedFactor# = 0.00000000001
FL\TimeElapsed# = (FL\CurrentTicks - FL\FrameDelay) / 1000.0
If Debug
  FL\FPS# = (FL\FPS2# + FL\FPS3# + FL\FPS4# + FL\FPS5# + FL\TargetFPS# / FL\SpeedFactor#) / 5
  FL\FPS5# = FL\FPS4# : FL\FPS4# = FL\FPS3# : FL\FPS3# = FL\FPS2# : FL\FPS2# = FL\FPS#
EndIf
FL\FrameDelay = FL\CurrentTicks

Pour finir, utilisez les méthodes suivantes pour vous servir du code vu précédemment.

Pour afficher un compteur d'images par seconde

Ajoutez simplement un code similaire là ou vous le souhaitez dans votre boucle principale:

;example FPS display
If Debug
 Text 0, 0, "FPS: " + Int(FL\FPS#)
EndIf

Pour faire bouger les objets de votre jeu de manière équivalente sur toutes les machines

Pour utiliser la fonction de limitation de fréquence, vous devez vous servir soit de la variable SpeedFactor# soit de la variable TimeElapsed.  Cela dépend du type de jeu que vous écrivez.  SpeedFactor contient un pourcentage de la dernière image.   TimeElapsed contient un pourcentage de la dernière seconde.

Si vous avez dans votre jeu des objets qui se déplacent sur une certaine distance à chaque RENDU (chaque IMAGE) alors utilisez la variable SpeedFactor#.

Si vous avez dans votre jeu des objets qui se déplacent sur une certaine distance chaque SECONDE alors utilisez la variable TimeElapsed#.

Utilisation de la variable SpeedFactor#:

Disons que vous écrivez un jeu de platforme avec scrolling.  Quand le joueur appuye sur la touche de flèche droite, le sprite du personnage se déplace de 4 pixels à chaque image.  D'habitude vous pouriez programmer cela de la manière suivante:

If KeyDown(205)
 PlayerX = PlayerX + 4
EndIf

Pour effectuer un scrolling fluide sur n'importe quelle machine, vous devez modifier le code comme ce qui suit:

If KeyDown(205)
 PlayerX = PlayerX + 4.0 * FL\SpeedFactor#
EndIf

Le résultat donne un déplacement de 4 pixels du sprite +/- une différence determinée par la variable SpeedFactor#.
Si, par exemple, la dernière image prend plus de temps que la normale (determiné par la variable TargetFPS#) alors SpeedFactor# sera égale à un nombre plus grand que 1.0 (disons 1.25 par exemple).  4*1.25 = 5 alors le sprite se déplacera de 5 pixels cette image au lieu de 4 pour compenser le temps suplémentaire de la dernière image.

Cliquez ici pour voir un exemple de l'avantage d'utiliser le Delta-timing par rapport à un Timer.

(Essayez le code suivant pour constater la différence entre l'utilisation d'un simple timer contre la technique du delta-timing. Vous noterez que le mouvement de la croix rouge sur l'écran est plus fluide en utilisant le delta-timing.)

Utilisation de la variable TimeElapsed#:

Disons que vous écrivez une simulation de voiture de course.  Vous voulez que la voiture se déplace comme dans le temps réel, utilisez la variable TimeElapsed#.

Dans votre jeu, pour calculer la nouvelle vélocité de la voiture chaque image, vous utilisez la formule:

nouvellevelocité = anciennevelocité + (temps*acceleration)

la vélocité est en metres par secondes (m/s)
le temps est mesuré en secondes (s)
l'accélération est en metres par secondes par secondes (m/s^2)

Tout simplement, tout ce que vous devez faire consiste à substituer la variable TimeElapsed# à la place du temps (comme TimeElapsed# égal la durée (en secondes) écoulée depuis la dernière image)

newvel# = oldvel# + (FL\TimeElapsed# * accel#)

Maintenant la voiture changera de velocité en fonction du temps ACTUEL écoulé depuis la dernière image.