Discussion :

[Bigfoot71]

Bonjour/Bonsoir tout le monde, j'ai un petit problème avec les déplacements et le delta time, c'est très étrange et je n'arrive pas à me l'expliquer alors peut être que je m'y prends mal...

Voici comment je le calcul au début de la boucle principale :

Code :

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

1
2
3
 
delta_time = (SDL_GetTicks() - ticks_count) / 1000.0f;
ticks_count = SDL_GetTicks();

Le calcul est bon selon moi et je m'en sert même pour un timer qui fonctionne nickel.
Et voici à peu près à quoi ressemble ma fonction de déplacement :

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
 
    if (keyState[SDL_SCANCODE_UP])
    {
        if (!keyState[SDL_SCANCODE_LEFT] || !keyState[SDL_SCANCODE_RIGHT])
             rect.y -= 200 * delta_time;
        else rect.y -= 100 * delta_time;
    }
    else if (keyState[SDL_SCANCODE_DOWN])
    {
        if (!keyState[SDL_SCANCODE_LEFT] || !keyState[SDL_SCANCODE_RIGHT])
             rect.y += 200 * delta_time;
        else rect.y += 100 * delta_time;
    }
 
    if (keyState[SDL_SCANCODE_LEFT])
    {
        if (!keyState[SDL_SCANCODE_UP] || !keyState[SDL_SCANCODE_DOWN])
             rect.x -= 200 * delta_time;
        else rect.x -= 100 * delta_time;
    }
    else if (keyState[SDL_SCANCODE_RIGHT])
    {
        if (!keyState[SDL_SCANCODE_UP] || !keyState[SDL_SCANCODE_DOWN])
             rect.x += 200 * delta_time;
        else rect.x += 100 * delta_time;
    }
 
}

Mais voilà, j'ai remarqué que la vers la droite et vers le bas vont moins vite que vers le haut et vers la gauche (donc les += vont moins vite que les -=).
Alors j'ai fais pas mal de tests, dont par exemple mettre le "200 * dt" dans une varaible et faire le boulot ensuite mais c'etait exactement pareil.

Puis j'ai aussi remarqué qu'en reduisant la vitesse (par exemple de 200 à 50) ça se déplaçait aux "-=" mais plus dutout aux "+=" et là je ne comprends plus dutout pourquoi.
J'ai eu pas mal d'hypothèse mais qui se sont révélées fausses ou juste deviennent absurdes, c'est pour cela que je m'en retourne à vous, voilà tout...

Je vous remercie d'avance si vous avez des avis ou solutions !

EDIT: Petit exemple en C que je viens de faire pour que vous puissiez essayé et c'est bien flagrant, en tout cas chez moi... (encore plus que mon jeu en C++ alors que je n'ai pas changer les valeurs, bizarre...)

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
 
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <SDL2/SDL.h>
 
#define WIN_W 640
#define WIN_H 480
 
int main (int argc, char** argv)
{
    (void) argc; (void) argv;
 
    /* Initialisation de SDL */
 
    if (SDL_Init (SDL_INIT_VIDEO) < 0) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; };
 
    SDL_Window* win = SDL_CreateWindow ("Test mouvement avec delta time", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIN_W, WIN_H, 0);
    if (!win) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; }
 
    SDL_Renderer* ren = SDL_CreateRenderer (win, -1, SDL_RENDERER_ACCELERATED);
 
    SDL_Event event;
 
    /* Valeurs du programme */
 
    SDL_Rect rect = {(WIN_W-64)/2, (WIN_H-64)/2, 64, 64};
 
    uint32_t ticks_count = SDL_GetTicks();
    float delta_time;
 
    const uint8_t* keyState = SDL_GetKeyboardState(NULL);
    SDL_bool running = SDL_TRUE;
 
    /* Execution du programme */
 
    while (running)
    {
 
        /* Calcul du delta time */
 
        delta_time = (SDL_GetTicks() - ticks_count) / 1000.0f;
        ticks_count = SDL_GetTicks();
 
        /* Evenements SDL */
 
        while (SDL_PollEvent(&event))
            running = event.type != SDL_QUIT;
 
        SDL_PumpEvents();
 
        /* Déplacement du rectangle */
 
        if (keyState[SDL_SCANCODE_UP])
        {
            if (!keyState[SDL_SCANCODE_LEFT] || !keyState[SDL_SCANCODE_RIGHT])
                 rect.y -= 200 * delta_time;
            else rect.y -= 100 * delta_time;
        }
        else if (keyState[SDL_SCANCODE_DOWN])
        {
            if (!keyState[SDL_SCANCODE_LEFT] || !keyState[SDL_SCANCODE_RIGHT])
                 rect.y += 200 * delta_time;
            else rect.y += 100 * delta_time;
        }
 
        if (keyState[SDL_SCANCODE_LEFT])
        {
            if (!keyState[SDL_SCANCODE_UP] || !keyState[SDL_SCANCODE_DOWN])
                 rect.x -= 200 * delta_time;
            else rect.x -= 100 * delta_time;
        }
        else if (keyState[SDL_SCANCODE_RIGHT])
        {
            if (!keyState[SDL_SCANCODE_UP] || !keyState[SDL_SCANCODE_DOWN])
                 rect.x += 200 * delta_time;
            else rect.x += 100 * delta_time;
        }
 
        /* Rendu du programme */
 
        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
        SDL_RenderClear(ren);
 
        SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
        SDL_RenderFillRect(ren, &rect);
 
        SDL_RenderPresent(ren);
 
    }
 
    /* Closing the program */
 
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
 
    return 0;
}

[Kannagi]

Je vois rien d'anormal , mais le manque de delay me choque ,vu que bon tu vas prendre 100% de CPU pour rien ^^'

[Bigfoot71]

Je vois rien d'anormal , mais le manque de delay me choque ,vu que bon tu vas prendre 100% de CPU pour rien ^^'

Alors là, est-ce que ça pourrait venir du fait que je suis sur un petit netbook ? Mais si c'est ça je ne vois pas pourquoi ça ne le fait que pour "droite et bas" c'est vachement bizarre...

Je n'ai pas d'autre pc pour tester où je suis pour l'instant, je pourrais dire que dans quelques jours...

Et oui j'ai écrit l'exemple rapidement, il était tard je ne me suis pas pris la tête dutout, le problème est le même dans mon projet alors qui s'occupe de ça de toute façon... Merci quand même de la réponse !

[Mat.M]

salut le truc qui me chagrine c'est que vous testez SDL_SCANCODE_UP et SDL_SCANCODE_DOWN en même temps le premier événement annule l'autre donc forcément il y a des désynchronisations

Ensuite pour des questions de lisibilité ça serait mieux de faire une fonction OnKeyPressed() et utiliser un switch (touche_enfoncee) plutôt qu'une palanquée de if imbriqués les uns dans les autres

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
 
void OnKeyPressedDown()
{
const uint8_t* keyState = SDL_GetKeyboardState(NULL);
 
	switch(keyState)
	{
 
		case SDL_SCANCODE_LEFT:
		 rect.x -= 200 * delta_time;
		break;
 
		case SDL_SCANCODE_RIGHT:
		 rect.x += 200 * delta_time;
		break;
 
 
	}
}

MODIF PERSO de 20:15

ne pas tenir compte de ce code car on ne peut pas utiliser de switch

[Kannagi]

Mais si c'est ça je ne vois pas pourquoi ça ne le fait que pour "droite et bas" c'est vachement bizarre...

Parce que tu fait une condition pour peut être ?

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
 
if (keyState[SDL_SCANCODE_UP])
        {
            if (!keyState[SDL_SCANCODE_LEFT] || !keyState[SDL_SCANCODE_RIGHT])
                 rect.y -= 200 * delta_time;
            else rect.y -= 100 * delta_time;
        }
        else if (keyState[SDL_SCANCODE_DOWN])
        {
            if (!keyState[SDL_SCANCODE_LEFT] || !keyState[SDL_SCANCODE_RIGHT])
                 rect.y += 200 * delta_time;
            else rect.y += 100 * delta_time;
        }
 
        if (keyState[SDL_SCANCODE_LEFT])
        {
            if (!keyState[SDL_SCANCODE_UP] || !keyState[SDL_SCANCODE_DOWN])
                 rect.x -= 200 * delta_time;
            else rect.x -= 100 * delta_time;
        }
        else if (keyState[SDL_SCANCODE_RIGHT])
        {
            if (!keyState[SDL_SCANCODE_UP] || !keyState[SDL_SCANCODE_DOWN])
                 rect.x += 200 * delta_time;
            else rect.x += 100 * delta_time;
        }

Du coup la vitesse change selon quel direction on appuie.

De plus les conditions me semble assez fausse (comem dit c'est mieux de faire un switch ).

[Bigfoot71]

Cela marchait parfaitement sans le delta time donc je ne vois pas où mes conditions ne seraient pas correct, mais peut être.
Et comme j'avais besoin de 'SDL_GetKeyboardState()' pour mon programme (pour la "simplicté", peut être qu'il existe encore plus simple ?) c'est pour ça que je me suis retrouver "obligé" de faire pleins de conditions...

Je ne voyais pas vraiment comment utilisé un switch avec 'SDL_GetkeyboardState()' alors j'ai fait ceci, avec d'autres ajouts/modifications, je tatonne et c'est toujours pareil:

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
 
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <SDL2/SDL.h>
 
#define WIN_W 640
#define WIN_H 480
 
int onKeyPressed(const uint8_t* keyState)
{
    if (keyState[SDL_SCANCODE_UP])
        return 1;
 
    else if (keyState[SDL_SCANCODE_DOWN])
        return 2;
 
    else if (keyState[SDL_SCANCODE_LEFT])
        return 3;
 
    else if (keyState[SDL_SCANCODE_RIGHT])
        return 4;
 
    return 0;
}
 
int main (int argc, char** argv)
{
    (void) argc; (void) argv;
 
    /* Initialisation de SDL */
 
    if (SDL_Init (SDL_INIT_VIDEO) < 0) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; };
 
    SDL_Window* win = SDL_CreateWindow ("Test mouvement avec delta time", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIN_W, WIN_H, 0);
    if (!win) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; }
 
    SDL_Renderer* ren = SDL_CreateRenderer (win, -1, SDL_RENDERER_ACCELERATED);
 
    SDL_Event event;
 
    /* Valeurs du programme */
 
    SDL_Rect rect = {(WIN_W-64)/2, (WIN_H-64)/2, 64, 64};
 
    uint32_t actual_frame = SDL_GetTicks();
    uint32_t last_frame = 0;
    int      delta_time = 0;
    float    dt_move   = 0.f;
 
    const uint8_t* keyState = SDL_GetKeyboardState(NULL);
    SDL_bool running = SDL_TRUE;
 
    /* Execution du programme */
 
    while (running)
    {
        /* Calcul du delta time */
 
        last_frame = actual_frame;
        actual_frame = SDL_GetTicks();
        delta_time = actual_frame - last_frame;
        dt_move = delta_time / 1000.f;
 
        printf("DELTA TIME (ms): %d\n", delta_time); // Affichage du delta time
 
        /* Evenements SDL */
 
        while (SDL_PollEvent(&event))
            running = event.type != SDL_QUIT;
 
        SDL_PumpEvents();
 
        /* Déplacement du rectangle */
 
        switch (onKeyPressed(keyState))
        {
            case 1:
                rect.y -= 200 * dt_move; break;
 
            case 2:
                rect.y += 200 * dt_move; break;
 
            case 3:
                rect.x -= 200 * dt_move; break;
 
            case 4:
                rect.x += 200 * dt_move; break;
 
            default: break;
        }
 
        /* Rendu du programme */
 
        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
        SDL_RenderClear(ren);
 
        SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
        SDL_RenderFillRect(ren, &rect);
 
        SDL_RenderPresent(ren);
 
    }
 
    /* Closing the program */
 
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
 
    return 0;
}

Et chose que je comprends encore moins, j'ai refait le code depuis des exemples sur internet et quand je fais comme le code ci-dessous le delta time passe carrément de 0 à ~80 en une itteration et du coup le programme se bloque car ça fait un 'delay' avec une valeur negative...

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 <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <SDL2/SDL.h>
 
#define WIN_W 640
#define WIN_H 480
 
int onKeyPressed(const uint8_t* keyState)
{
    if (keyState[SDL_SCANCODE_UP])
        return 1;
 
    else if (keyState[SDL_SCANCODE_DOWN])
        return 2;
 
    else if (keyState[SDL_SCANCODE_LEFT])
        return 3;
 
    else if (keyState[SDL_SCANCODE_RIGHT])
        return 4;
 
    return 0;
}
 
int main (int argc, char** argv)
{
    (void) argc; (void) argv;
 
    /* Initialisation de SDL */
 
    if (SDL_Init (SDL_INIT_VIDEO) < 0) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; };
 
    SDL_Window* win = SDL_CreateWindow ("Test mouvement avec delta time", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIN_W, WIN_H, 0);
    if (!win) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; }
 
    SDL_Renderer* ren = SDL_CreateRenderer (win, -1, SDL_RENDERER_ACCELERATED);
 
    SDL_Event event;
 
    /* Valeurs du programme */
 
    SDL_Rect rect = {(WIN_W-64)/2, (WIN_H-64)/2, 64, 64};
 
    uint32_t actual_frame = SDL_GetTicks();
    uint32_t last_frame = 0;
    int      delta_time = 0;
    float    dt_move   = 0.f;
 
    const uint8_t* keyState = SDL_GetKeyboardState(NULL);
    SDL_bool running = SDL_TRUE;
 
    /* Execution du programme */
 
    while (running)
    {
        /* Calcul du delta time */
 
        last_frame = actual_frame;
        actual_frame = SDL_GetTicks();
        delta_time = actual_frame - last_frame;
        dt_move = delta_time / 1000.f;
 
        printf("DELTA TIME (ms): %d\n", delta_time); // Affichage du delta time
 
        /* Evenements SDL */
 
        while (SDL_PollEvent(&event))
            running = event.type != SDL_QUIT;
 
        if (1000/60 > delta_time)
        {
            SDL_PumpEvents();
 
            /* Déplacement du rectangle */
 
            switch (onKeyPressed(keyState))
            {
                case 1:
                    rect.y -= 200 * dt_move; break;
 
                case 2:
                    rect.y += 200 * dt_move; break;
 
                case 3:
                    rect.x -= 200 * dt_move; break;
 
                case 4:
                    rect.x += 200 * dt_move; break;
 
                default: break;
            }
 
            /* Rendu du programme */
 
            SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
            SDL_RenderClear(ren);
 
            SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
            SDL_RenderFillRect(ren, &rect);
 
            SDL_RenderPresent(ren);
        }
        else
        {
            SDL_Delay((1000/60) - delta_time);
        }
 
 
    }
 
    /* Closing the program */
 
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
 
    return 0;
}

Alors que j'ai recuperer du code depuis une reponse du forum du site "libsdl" ... Je crois ne plus rien comprendre au principe ça me perd de tourner en rond...

Au passage, étant donner que j'affiche du texte dans la console l'execution se fait plus lente et le "bas/droite" qui deconne va legerement plus (surement car le delta time est plus grand)
Mais encore une fois pourquoi uniquement pour "bas/droite" alors que "haut/gauche" est normal ???

[Bigfoot71]

salut le truc qui me chagrine c'est que vous testez SDL_SCANCODE_UP et SDL_SCANCODE_DOWN en même temps le premier événement annule l'autre donc forcément il y a des désynchronisations

Ensuite pour des questions de lisibilité ça serait mieux de faire une fonction OnKeyPressed() et utiliser un switch (touche_enfoncee) plutôt qu'une palanquée de if imbriqués les uns dans les autres

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
 
void OnKeyPressedDown()
{
const uint8_t* keyState = SDL_GetKeyboardState(NULL);
 
	switch(keyState)
	{
 
		case SDL_SCANCODE_LEFT:
		 rect.x -= 200 * delta_time;
		break;
 
		case SDL_SCANCODE_RIGHT:
		 rect.x += 200 * delta_time;
		break;
 
 
	}
}

Je n'avais pas vu la modification, mais lorsque je fais ça j'obtiens:

Code :

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

1
2
main.c:57:17: error: switch quantity not an integer
   57 |         switch (keyState)

Et c'était voulu que si l'on appui sur "haut" ça ne prenne pas en compte "bas"

Le code avec votre fonction si jamais ça marche pour vous... Puis je crains que même si ça marche mon problème restera le même...

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
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <SDL2/SDL.h>
 
#define WIN_W 640
#define WIN_H 480
 
void onKeyPressedDown(SDL_Rect* rect, float delta_time)
{
    const uint8_t* keyState = SDL_GetKeyboardState(NULL);
 
	switch(keyState)
	{
 
		case SDL_SCANCODE_LEFT:
		 rect->x -= 200 * delta_time;
		break;
 
		case SDL_SCANCODE_RIGHT:
		 rect->x += 200 * delta_time;
		break;
 
 
	}
}
 
int main (int argc, char** argv)
{
    (void) argc; (void) argv;
 
    /* Initialisation de SDL */
 
    if (SDL_Init (SDL_INIT_VIDEO) < 0) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; };
 
    SDL_Window* win = SDL_CreateWindow ("Test mouvement avec delta time", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIN_W, WIN_H, 0);
    if (!win) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; }
 
    SDL_Renderer* ren = SDL_CreateRenderer (win, -1, SDL_RENDERER_ACCELERATED);
 
    SDL_Event event;
 
    /* Valeurs du programme */
 
    SDL_Rect rect = {(WIN_W-64)/2, (WIN_H-64)/2, 64, 64};
 
    uint32_t actual_frame = SDL_GetTicks();
    uint32_t last_frame = 0;
    float    delta_time = 0;
 
    SDL_bool running = SDL_TRUE;
 
    /* Execution du programme */
 
    while (running)
    {
        /* Calcul du delta time */
 
        last_frame = actual_frame;
        actual_frame = SDL_GetTicks();
        delta_time = (actual_frame - last_frame) / 1000.f;
 
        /* Evenements SDL */
 
        while (SDL_PollEvent(&event))
            running = event.type != SDL_QUIT;
 
        /* Déplacement du rectangle */
 
        onKeyPressedDown(&rect, delta_time);
 
        /* Rendu du programme */
 
        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
        SDL_RenderClear(ren);
 
        SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
        SDL_RenderFillRect(ren, &rect);
 
        SDL_RenderPresent(ren);
 
    }
 
    /* Closing the program */
 
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
 
    return 0;
}

[Bousk]

keystate est un tableau, tu ne peux absolument pas faire un switch sur un tableau
un switch se fait sur une valeur...

quant au code, tu prétends qu'il est bon, mais en voyant juste la première condition ça fait pas rêver
if (!keyState[SDL_SCANCODE_LEFT] || !keyState[SDL_SCANCODE_RIGHT]) donc si je n'appuie pas sur gauche ou n'appuie pas sur droite, donc c'est faux uniquement si j'appuie gauche et droite en même temps, ce qui est au mieux bizarre.

Et avec ces conditions wtf, le comportement est normal.
Si j'appuye juste sur haut, je monte à 200.
Si j'appuye sur haut et gauche, je monte à 200 et vais à gauche à 200.
Et oui le second cas est beaucoup plus rapide que le premier.
Et si tu ne voyais pas la différence avant c'est juste parce que ton programme est tellement simple et rapide que c'était probablement pas flagrant.

[Bigfoot71]

Je le savais qu'on ne pouvais pas faire de switch avec mais bon, j'ai quand même essayer ce qu'on m'a proposé...

Donc j'ai simplifier au maximum les conditions comme elles sont mauvaises mais toujours le même problème pour moi... "bas/droite" ne fonctionnent pas donc je sais que ce n'est pas mes conditions le problème même si elles sont douteuses...

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
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <SDL2/SDL.h>
 
#define WIN_W 640
#define WIN_H 480
 
int main (int argc, char** argv)
{
    (void) argc; (void) argv;
 
    /* Initialisation de SDL */
 
    if (SDL_Init (SDL_INIT_VIDEO) < 0) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; };
 
    SDL_Window* win = SDL_CreateWindow ("Test mouvement avec delta time", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIN_W, WIN_H, 0);
    if (!win) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; }
 
    SDL_Renderer* ren = SDL_CreateRenderer (win, -1, SDL_RENDERER_ACCELERATED);
 
    SDL_Event event;
 
    /* Valeurs du programme */
 
    SDL_Rect rect = {(WIN_W-64)/2, (WIN_H-64)/2, 64, 64};
 
    uint32_t ticks_count = SDL_GetTicks();
    float delta_time;
 
    const uint8_t* keyState = SDL_GetKeyboardState(NULL);
    SDL_bool running = SDL_TRUE;
 
    /* Execution du programme */
 
    while (running)
    {
 
        /* Calcul du delta time */
 
        delta_time = (SDL_GetTicks() - ticks_count) / 1000.0f;
        ticks_count = SDL_GetTicks();
 
        /* Evenements SDL */
 
        while (SDL_PollEvent(&event))
            running = event.type != SDL_QUIT;
 
        SDL_PumpEvents();
 
        /* Déplacement du rectangle */
 
        if (keyState[SDL_SCANCODE_UP])
            rect.y -= 200 * delta_time;
 
        else if (keyState[SDL_SCANCODE_DOWN])
            rect.y += 200 * delta_time;
 
        if (keyState[SDL_SCANCODE_LEFT])
            rect.x -= 200 * delta_time;
 
        else if (keyState[SDL_SCANCODE_RIGHT])
            rect.x += 200 * delta_time;
 
        /* Rendu du programme */
 
        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
        SDL_RenderClear(ren);
 
        SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
        SDL_RenderFillRect(ren, &rect);
 
        SDL_RenderPresent(ren);
 
    }
 
    /* Closing the program */
 
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
 
    return 0;
}

[Bigfoot71]

RESOLU ! C'est tout bête et je me le suis dit au départ mais comme ça fonctionnait à moitié je n'y croyais pas !

C'est juste que les valeurs de SDL_Rect sont de type entières et donc chez moi (avec mon pc pourri) la multiplication avec le delta time tombait proche de 0 et donc (comme type entiers) donnaient 0, mais pourquoi uniquement sur les "+=" ? Perso je ne sais pas. (si... voir fin, si besoin)

Voici correction si ça arrive à quelqu'un d'autre, il faut utilisé SDL_FRect et non SDL_Rect (qui prend des valeurs float au lieu d'int) et SDL_RenderFillRectF() pour l'afficher. Exemple d'un code qui fait ce que j'attendais, même avec mon pc pourri (et avec gestion des diagonales):

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
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <SDL2/SDL.h>
 
#define WIN_W 640
#define WIN_H 480
 
int main (int argc, char** argv)
{
    (void) argc; (void) argv;
 
    /* Initialisation de SDL */
 
    if (SDL_Init (SDL_INIT_VIDEO) < 0) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; };
 
    SDL_Window* win = SDL_CreateWindow ("Test mouvement avec delta time", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIN_W, WIN_H, 0);
    if (!win) { fprintf(stderr, "ERROR: %s", SDL_GetError()); return 1; }
 
    SDL_Renderer* ren = SDL_CreateRenderer (win, -1, SDL_RENDERER_ACCELERATED);
 
    SDL_Event event;
 
    /* Valeurs du programme */
 
    SDL_FRect rect = {(WIN_W-64)/2.f, (WIN_H-64)/2.f, 64.f, 64.f};
 
    uint32_t ticks_count = SDL_GetTicks();
    float delta_time;
 
    const uint8_t* keyState = SDL_GetKeyboardState(NULL);
    SDL_bool running = SDL_TRUE;
 
    /* Execution du programme */
 
    while (running)
    {
 
        /* Calcul du delta time */
 
        delta_time = (SDL_GetTicks() - ticks_count) / 1000.0f;
        ticks_count = SDL_GetTicks();
 
        /* Evenements SDL */
 
        while (SDL_PollEvent(&event))
            running = event.type != SDL_QUIT;
 
        SDL_PumpEvents();
 
        /* Déplacement du rectangle en prenant compte des diagonales */
 
        float vx = 0.f, vy = 0.f; // Valeurs de direction
 
        if (keyState[SDL_SCANCODE_UP])    vy -= 1.0f;
        if (keyState[SDL_SCANCODE_DOWN])  vy += 1.0f;
        if (keyState[SDL_SCANCODE_LEFT])  vx -= 1.0f;
        if (keyState[SDL_SCANCODE_RIGHT]) vx += 1.0f;
 
        float length = sqrt(vx * vx + vy * vy);
 
        if (length > 0.0f)
        {
            vx /= length;
            vy /= length;
        }
 
        rect.x += (vx*200) * delta_time;
        rect.y += (vy*200) * delta_time;
 
        /* Rendu du programme */
 
        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
        SDL_RenderClear(ren);
 
        SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
        SDL_RenderFillRectF(ren, &rect);
 
        SDL_RenderPresent(ren);
 
    }
 
    /* Closing the program */
 
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();
 
    return 0;
}

Merci quand même pour l'attention portée ! Dailleurs si quelqu'un a des suggestions sur le pourquoi uniquement les "+=" ça serait le bienvenu ! ^^

Edit: la raison était ultra évidente, je vais me reposé Je vous laisse faire vos conclusions si jamais ça peu en aider, merci en tout cas

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
 
int main(void)
{
    int n1 = 1, n2 = 1;
    n1 += .4f; n2 -= .4f;
 
    printf("%d\n", n1);
    printf("%d\n", n2);
 
    return 0;
}

Code :

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

1
2
1
0

[Mat.M]

Autant pour moi oui il y a une erreur dans mon code et la fonction SDL_GetKeyboardState retourne bien un tableau.
Mea Culpa et à la modération de modifier les messages inappropriés