Discussion :

[mazertys17]

Bonjour,

Je réalise un petit jeux 2D, et je constate que la vitesse de certains éléments n'est pas parfaitement constante....J'en conclu qu'il sagit sans doute de la vitesse de calcul qui évolu. J'aimerais donc pouvoir calculer ce temps de calcul pour l'utiliser en tant que facteur pour la vitesse.

Mon code donne ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
        while (running)
        {
                startTime = System.currentTimeMillis();
                synchronized (view.getHolder()){view.update();}
                Canvas c = null;
                try
                {
                    c = view.getHolder().lockCanvas();
                    synchronized (view.getHolder()){view.doDraw(c);}
                }
                finally
                {
                    if(c != null){view.getHolder().unlockCanvasAndPost(c);}
                }
                sleepTime = SKIP_TICKS-(System.currentTimeMillis()-startTime);
                try
                {
                    if (sleepTime >= 0)
                    {
                        sleep(sleepTime);
                    }
                }
                    catch (Exception e){}
            }

Merci si vous pouvez m'aider.

[mazertys17]

Re bonjour,

J'ai ajouté une valeur pour calculer le temps, mais le résultat me paraît trop aproximatif : lorsque je lance mon programme sur l'émulateur, les éléments avancent a une vitesse raisonable, mais quand je le test sur mon smartphone, ils fusent a toute allure.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
public class GameLoop extends Thread {
 
    private final static int FRAMES_PER_SECOND = 30 ;
    private final static int SKIP_TICKS = 1000 / FRAMES_PER_SECOND;
    private final GameContent view;
    private boolean running = false;
    private double timer = 0 ;
 
    public GameLoop(GameContent view)
    {
        this.view = view;
    }
 
    public void setRunning(boolean run)
    {
        running = run;
    }
 
    @Override
    public void run(){
        long startTime;
        long sleepTime;
 
        while (running)
        {
            startTime = System.currentTimeMillis();
 
            Canvas c = null;
            try
            {
                c = view.getHolder().lockCanvas();
 
                double time = System.currentTimeMillis() - timer ;
                synchronized (view.getHolder()){view.draw( c , time );}
                timer = System.currentTimeMillis();
            }
            finally
            {
                if(c != null){view.getHolder().unlockCanvasAndPost(c);}
            }
            sleepTime = SKIP_TICKS-(System.currentTimeMillis()-startTime);
            try
            {
                if (sleepTime >= 0)
                {
                    sleep(sleepTime);
                }
            }
            catch (Exception e){}
        }
    }
}

S.V.P, savez vous comment faire pour gérer une vitesse stable des élements ?

Merci si vous pouvez m'aider.

[nicroman]

Le sleep est à éviter à tout prix dans un programme... il y a beaucoup d'autres moyen de synchroniser à une heure donnée une action.

D'autre part, Android n'étant pas un OS temps réel (ils sont rares ces OS, et chers ), rien ne dit que la boucle fera le temps donné.


En général on fait l'inverse dans un moteur de jeu... à chaque fois qu'on entre dans la boucle, on regarde le temps qui s'est écoulé depuis la dernière fois.
Ce temps permet de calculer le déplacement des objets en fonction de leur vitesse....

Si on compte la vitesse en "pixel / seconde", on aura un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
long currentTime = System.nanoTime(); // <= bien plus précis que currentTimeMillis
float seconds = (currentTime - this.lastTime) / 1000000000.0; // <= converting to seconds.
this.lastTime = currentTime; // <= il est posssible de faire aussi une "moyenne" sur les deux ou trois derniers frames pour éviter le stuttering
 
/// ici on a un object qui se déplace avec une vitesse dans "PointF  celerity;" et une position précédente (en pixels) de "PointF lastPos;"
// d'abord faire la gestion des collisions (l'objet se déplacant risque-t-il de collider avec un autre objet se déplacant) pendant ce temps. En profiter pour mettre à jour les accelerations
// puis effectuer le mouvement des objets (la "physique")... genre:
lastPost.x += celerity.x * seconds;
lastPost.y += celerity.y * seconds;
celerity.x += acceleration.x * seconds;
celerity.y += acceleration.y * seconds;
// enfin effectuer l'affichage de tout.

Normalement, que la boucle prenne un demi seconde ou 1/100eme de seconde, peu importe.....

[mazertys17]

Merci beaucoup, Nicroman !

J'a adopté cette méthode, c'est effectivement plus logique et ça semble bien fonctionner.

En revanche j'ai tout de même besoin de pouvoir calculer le temps pour des compteurs, ce d'un façon précise.
Connaissez vous la meilleur façon de faire ?