Discussion :

[Silvano_Dimitrio]

Bonjour,

j'ai un petit jeu 2D ou en appuyant sur la touche droite je donne la vitesse x à un objet et la touche gauche -x. La vitesse est multiplié par 0.9 à chaque tour de boucle ce qui freine l'objet. Mais il y a un gros problème. A l'écran l'objet bouge plus longtemps si j'appuie sur gauche que sur droite. Comment ça se fait ?

[dalfab]

Bonjour,

Si ta vitesse est un nombre entier, cela peut être dû à l'arrondi des entiers.
Par exemple : -15 * 0.9 => -13.5 arrondi entier en -14, alors que +15 * 0.9 => 13.5 arrondi entier en 13 donc la vitesse diminuerait moins vite pour les nombres négatifs.

[Silvano_Dimitrio]

C'est un float, si je le change en double ca donne la même...

[Bousk]

[dalfab]

Et ma boule de cristal a mal fonctionné, peut-être qu'avec le code on y verrait plus clair.

[Silvano_Dimitrio]

Voici body.cpp

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include "body.h"
 
body::body() : m_vx(0), m_vy(0), m_leg(0), m_kick(0)
{
    m_rectangle.x = 500;
    m_rectangle.y = 0;
    m_rectangle.w = 88;
    m_rectangle.h = 304;
}
 
body::~body()
{
    //dtor
}
 
void body::load(SDL_Renderer *renderer)
{
    m_surface3 = SDL_LoadBMP(kick);
    m_texture3 = SDL_CreateTextureFromSurface(renderer, m_surface3);
    m_surface2 = SDL_LoadBMP(jambe);
    m_texture2 = SDL_CreateTextureFromSurface(renderer, m_surface2);
    m_surface1 = SDL_LoadBMP(defaut);
    m_texture1 = SDL_CreateTextureFromSurface(renderer, m_surface1);
}
 
void body::affiche(SDL_Renderer *renderer)
{
    if(m_leg)
    {
        m_rectangle.w = 169;
        SDL_RenderCopy(renderer, m_texture2, NULL, &m_rectangle);
    }
 
    else if(m_kick)
    {
        m_rectangle.w = 185;
        SDL_RenderCopy(renderer, m_texture3, NULL, &m_rectangle);
    }
 
 
    else
    {
        m_rectangle.w = 88;
        SDL_RenderCopy(renderer, m_texture1, NULL, &m_rectangle);
    }
 
 
 
}
 
void body::action(input touch)
{
    if(touch.getTouchDown(SDL_SCANCODE_UP) && m_rectangle.y >= 420)
        m_vy += -20;
 
    if(touch.getTouchDown(SDL_SCANCODE_DOWN))
    {
 
    }
 
    if(touch.getTouchDown(SDL_SCANCODE_RIGHT))
        m_vx = 4;
 
    if(touch.getTouchDown(SDL_SCANCODE_LEFT))
        m_vx = -4;
 
    if(touch.getTouchDown(SDL_SCANCODE_C))
    {
        if(m_kick)
            m_kick = 0;
 
        else
            m_kick = 1;
    }
 
    if(touch.getTouchUp(SDL_SCANCODE_C))
        m_kick = 0;
 
    if(touch.getTouchUp(SDL_SCANCODE_RIGHT))
    {
 
    }
 
 
    if(touch.getTouchUp(SDL_SCANCODE_LEFT))
    {
 
    }
}
 
void body::dynamic()
{
    m_rectangle.x += m_vx;
    m_rectangle.y += m_vy;
 
    if(m_rectangle.y >= 420)
    {
        m_vy = 0;
        m_rectangle.y = 420;
        m_leg = 0;
    }
 
    else
    {
        m_vy += 1;
 
        if(!m_kick)
            m_leg = 1;
 
        else
            m_leg = 0;
    }
 
    m_vx *= 0.99;
}
 
float body::location()
{
    return m_location;
}

[dalfab]

Sans les types des données et sans savoir qui appelle la fonction body::dynamic() difficile d'en dire plus.
Si les x sont entiers avec une vitesse flottante on a le même décalage dû aux erreurs d'arrondi mais le temps de parcours est quasi-identique dans les 2 sens c'est alors la distance parcourue qui est bien plus importante vers la gauche.

[LittleWhite]

Bonjour,

Avez-vous besoin d'inertie ? (un mouvement qui continue même après l'arrêt de l'appui sur la touche, du style de Asteroids)
Si vous n'en avez pas besoin, vous devriez juste donner une vitesse si une touche est appuyée. Si aucune touche n'est appuyée, la vitesse est 0.
Ensuite, vous pouvez utiliser les formules classiques de l'accélération (kinématic). Après, les formules ne sont pas nécessairement aussi compliquée, notamment dans les jeux vidéo.

[Silvano_Dimitrio]

Ok voici body.h

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
#ifndef BODY_H
#define BODY_H
 
#include "SDL.h"
#include "input.h"
#include <iostream>
 
const char defaut[] = "laura3.bmp", jambe[] = "laura2legup.bmp", kick[] = "laura2kick.bmp";
 
class body
{
    public:
        body();
        ~body();
 
        void load(SDL_Renderer*);
        void affiche(SDL_Renderer*);
        void action(input);
        void dynamic();
 
        float location();
 
    private:
        SDL_Rect m_rectangle;
        SDL_Texture *m_texture1, *m_texture2, *m_texture3;
        SDL_Surface *m_surface1, *m_surface2, *m_surface3;
 
        float m_location;
        float m_vx, m_vy;
        bool m_leg, m_kick;
};
 
#endif // BODY_H

et moteur.cpp

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
#include "moteur.h"
 
moteur::moteur() : m_largeur(1280), m_hauteur(720)
{
    SDL_CreateWindowAndRenderer(m_largeur, m_hauteur, SDL_WINDOW_RESIZABLE, &m_window, &m_renderer);
    SDL_SetWindowTitle(m_window, "Jeu 2D");
    m_laura2.load(m_renderer);
}
 
moteur::~moteur()
{
    //dtor
}
 
int moteur::start()
{
    while(m_input.start())
    {
        m_input.getEvent();
 
        SDL_SetRenderDrawColor(m_renderer, 0, 50, 100, 255);
        SDL_RenderClear(m_renderer);
 
        m_world.bouge(m_laura2.location());
 
        m_laura2.affiche(m_renderer);
        m_laura2.action(m_input);
        m_laura2.dynamic();
 
        SDL_RenderPresent(m_renderer);
        SDL_Delay(10);
    }
 
    return 0;
}

[dalfab]

Les coordonnées sont donc entières donc :

Si les x sont entiers avec une vitesse flottante on a le même décalage dû aux erreurs d'arrondi mais le temps de parcours est quasi-identique dans les 2 sens c'est alors la distance parcourue qui est bien plus importante vers la gauche.

[Guesset]

Bonjour,

A chaque incrément de type int_X += float_vX, il y a une erreur d'arrondi qui se cumule. Comme déjà expliqué, L'erreur n'est pas nécessairement la même en positif et négatif (delta potentiel de 1).

Conseil : travailler avec avec float_X += float_vX. La conversion en int ne se fera qu'à l'affichage et les erreurs ne seront alors pas cumulatives.

Il est vraisemblable qu'actuellemnt, le freinage ne fonctionne pas non plus très bien (ralentissements par a-coups lorsque l'on passe d'un arrondi à un autre).

Salutations