Freiner un objet

Version imprimable

28/12/2019, 02h13
Silvano_Dimitrio

Freiner un objet

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 ?
28/12/2019, 11h33
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.
28/12/2019, 21h19
Silvano_Dimitrio

C'est un float, si je le change en double ca donne la même...
29/12/2019, 01h34
Bousk

:cristal:
29/12/2019, 01h45
dalfab

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

Voici body.cpp

Code:

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;
}

30/12/2019, 02h00
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.
30/12/2019, 09h29
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.

Ok voici body.h

Code:

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:

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;
}

30/12/2019, 20h42
dalfab

Les coordonnées sont donc entières donc :

Citation:

Envoyé par dalfab

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.
31/12/2019, 12h31
Guesset

Cumul

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