Discussion :

[Mahus]

Bonjour je suis en train de coder un snake et je me confronte au problème suivant lorsque je change rapidement de direction ( voir l'image).



Pourtant j'utilise une fonction qui ,pour déplacer chaque parties du corps, récupère les positions de la parties précédentes. Voici la dite fonction :

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
for(int unsigned i = 1; i < coordonneePosition.size(); i++)
    {
        switch(direction)
        {
        case 0:
            if(coordonneePosition[i].y > coordonneePosition[i-1].y)
            {
                coordonneePosition[i].y--;
            }
            if(coordonneePosition[i].y < coordonneePosition[i-1].y)
            {
                coordonneePosition[i].y++;
            }
             if(coordonneePosition[i].y == coordonneePosition[i-1].y)
             {
                  coordonneePosition[i].x = coordonneePosition[i-1].x + 25;
             }
 
            break;
        case 1:
             if(coordonneePosition[i].y > coordonneePosition[i-1].y)
            {
                coordonneePosition[i].y--;
            }
            if(coordonneePosition[i].y < coordonneePosition[i-1].y)
            {
                coordonneePosition[i].y++;
            }
             if(coordonneePosition[i].y == coordonneePosition[i-1].y)
             {
                  coordonneePosition[i].x = coordonneePosition[i-1].x - 25;
             }
            break;
        case 2:
              if(coordonneePosition[i].x > coordonneePosition[i-1].x)
            {
                coordonneePosition[i].x--;
            }
            if(coordonneePosition[i].x < coordonneePosition[i-1].x)
            {
                coordonneePosition[i].x++;
            }
             if(coordonneePosition[i].x == coordonneePosition[i-1].x)
             {
                  coordonneePosition[i].y = coordonneePosition[i-1].y + 25;
             }
            break;
        case 3:
             if(coordonneePosition[i].x > coordonneePosition[i-1].x)
            {
                coordonneePosition[i].x--;
            }
            if(coordonneePosition[i].x < coordonneePosition[i-1].x)
            {
                coordonneePosition[i].x++;
            }
             if(coordonneePosition[i].x == coordonneePosition[i-1].x)
             {
                  coordonneePosition[i].y = coordonneePosition[i-1].y - 25;
             }
            break;
 
        }
    }

Pouvez vous m'indiquez l'erreur de mon idée ??

D'avance merci.

[Bousk]

Salut,

tu devrais plutot chercher l'erreur dans le changement de direction que le suivi des objets. Ils se suivent correctement, ton screenshot le montre bien.

[Mahus]

Il n'y as pas de soucis avec la direction c'est juste le fait que comme la tete est en mouvement permanent le corps ne suit pas le chemin que la tête a décris, il cherche la trajectoire la plus courte !

[skeud]

Pour ton switch, je suppose que tu utilise la direction de la tête, ça ne serait pas plutôt la direction de la partie précédente que tu devrais utiliser?
sinon une solution plus élégante serait de faire une liste chainée de tes maillon, ça serait plus simple pour toi....

[Mahus]

D'accord merci, je vais tout d'abord essayer de travailler avec la direction de chaque parties et si je bloque encore je me mettrais aux listes chaînées !

[ternel]

L'avantage de la liste, c'est que le "déplacement" consiste à rajouter un maillon en tête, et retirer le dernier.

Tu as surement constaté que visuellement, les maillons intermédiaires ne se déplacent pas.

D'ailleurs, en déplacement normal, tu n'auras pas forcément d'allocation mémoire, il suffit de procéder ainsi:

1. défaire le lien entre l'avant dernier maillon et le dernier.
2. modifier les coordonnées de "dernier" pour le mettre à la nouvelle position de la tête
3. lier le premier maillon comme suivant du "dernier".
4. considérer que la tête de la liste est "dernier".

Et l'augmentation de taille sera encore plus simple:

1. créer un nouveau maillon à la nouvelle position de la tête
2. lier le premier maillon comme suivant du "nouveau".
3. considérer que la tête de la liste est "nouveau".
4. ne pas déplacer le vers ce tour-ci, c'est déjà fait.

Ceci n'est pas vrai si les maillons ont chacun une texture unique, et stockée dedans.
Mais ce serait une erreur, il vaut mieux avoir une liste de texture autonome, que tu parcours en parallèle pendant le dessin.
En effet, les données d'affichage doivent être détachée de la logique du jeu.

[Mahus]

Ton idée semble très intéressante pour quelqu'un qui s'intéresse au code de façon très approfondie. Cependant je ne suis qu'un codeur "casu" et ma méthode est mille fois plus simple :

- pour chaque item "mangé", je créer une nouvelle surface et son SDL_Rec dans deux vector
- je calcul les déplacements
- je blit mes deux vectors.

Je n'ai pas cette logique que vous avez tous à vouloir utiliser tel ou tel moyen de coder. Et lorsque j'essaye de m'y mettre cela devient plus que catastrophique. C'est pourquoi j'essaye de résoudre mon soucis en suivant ma logique sans dénaturer le code qui m'est venu naturellement. Je ne rejette pas votre aide je vous fais juste comprendre qu'il ne sert à rien de me dire que j'aurais dû utiliser ceci, ou cela etc.. Mais je cherche plutôt à trouver comment avancer sur le chemin que j'ai déjà emprunté

[ternel]

Tu déplaces tous les rectangles, alors pour un faible intérêt pratique.
C'est dommage, tu va perdre en performance graphique.

On ne te conseille pas "notre" façon de faire, mais une façon meilleure que la tienne.

Ce n'est pas forcément la seule façon, c'est certain. Mais compare un peu:
Avec un vers de 20 segments, il te faut 20 switch et 40 affectations par déplacement, quand il n'en faut que 1+5 avec la liste.
Avec 50 segments, c'est encore pire.

Atteindre un fps suffisant pour la jouabilité signifie réduire drastiquement le temps de calcul.
A toi de voire ce qui te plait, en effet.
Personnellement, je pense que c'est dommage de perdre en rapidité quand le vers s'allonge, c'est à dire quand la partie avance.
Cela diminue la difficulté en augmentant le temps accordé à l'utilisateur.
Je reconnais que tant que tu es en dessous du seuil fps, c'est invisible.


Le propre du bon développeur est de savoir écouter l'avis des autres, pour apprendre les bonnes solutions.
En l'occurence, j'ai eu un professeur qui disait "la plus rapide façon d'obtenir une valeur, c'est encore de ne pas la calculer du tout".

Autrement dit, une bonne manière de résoudre un soucis, c'est aussi de supprimer la situation délicate.

[ternel]

Désolé, je double poste:

Cependant je ne suis qu'un codeur "casu" et ma méthode est mille fois plus simple :
- pour chaque item "mangé", je créer une nouvelle surface et son SDL_Rec dans deux vector
- je calcul les déplacements
- je blit mes deux vectors.

ta solution:

à chaque itération de la boucle de temps de jeu:
    si je mange, //ajouter un rectangle au bout.
        trouver le bout
        calculer les coordonnées de son suivant
        créer le rectangle
        l'ajouter au vecteur
    pour tout rectangle du vecteur
        //déplacer le rectangle en fonction de la position du précédent
        trouver le suivant
        calculer son déplacement
        modifier current
    pour tout rectangle du vecteur
        blitter le rectangle

ma solution:

à chaque itération de la boucle de temps de jeu:
    soit r = si je mange ? un nouveau rectangle : liste.pop_back()
    calculer les nouvelles coordonnées de la tete
    y placer r
    ajouter r en début de liste
    pour tout rectangle de la liste
        blitter le rectangle

Quel code est le plus simple?

Ma solution marcherait avec un vector, mais les performances seront pourries.
Ça marcherait aussi avec un deque, mais le mieux pourrait être la liste. (à vérifier cependant)

[skeud]

Je n'ai pas cette logique que vous avez tous à vouloir utiliser tel ou tel moyen de coder. Et lorsque j'essaye de m'y mettre cela devient plus que catastrophique. C'est pourquoi j'essaye de résoudre mon soucis en suivant ma logique sans dénaturer le code qui m'est venu naturellement. Je ne rejette pas votre aide je vous fais juste comprendre qu'il ne sert à rien de me dire que j'aurais dû utiliser ceci, ou cela etc.. Mais je cherche plutôt à trouver comment avancer sur le chemin que j'ai déjà emprunté

En général quand on poste un problème sur un forum on écoute les avis, si on te donne un avis pour faire autrement c'est parce que justement on a testé cette solution avant et elle n'est pas viable.

comme tu le dis, tu es un codeur "casu", donc justement tu devrais faire en sorte de t'améliorer afin de réaliser des soft meilleur. En l’occurrence on te parle de concept de base de programmation, donc une guideline à suivre lorsque l'on apprends a coder (on est tous passer par là).

Si on voulait te planter, on t'aurais dis d'utiliser des smart ptr et autres choses de ce genre qui dépende vraiment de la philosophie du codeur. Ce qui n'est pas le cas, c'est justement pour que tu puisse comprendre certaine logique qui, en jeu vidéo ne sont pas les même que dans le reste de la programmation .

Les conseils apportés sont souvent là pour réduire la complexité de ton code (c'est d’ailleurs le but d'un développeur, à savoir, simplifier des problème en langage machine).
Après si tu veux absolument continué dans la voie que tu as choisis, c'est ton choix, mais si tu te heurte à des problèmes lié à ta manière de faire, l'aide que tu recevra sera beaucoup moins enthousiaste. Tu essayes de faire un snake surement pour apprendre les bases des jeux vidéo dans le but d'en faire un plus complexe après, donc le but n'est pas de faire le snake mais d'apprendre à le faire correctement, d'où l'utilité des conseils des personnes plus douées que toi dans ce domaine .