Discussion :

[Bocator]

Bonjour,

Je travaille actuellement sur un projet qui consiste à développer un programme de simulation de chemin de fer, dans lequel je dois présenter une carte avec un ensemble de lignes de chemin de fer et de trains y circulant etc.., et j'en suis donc à coder les bases nécessaires à son bon fonctionnement et malgré des heures d'acharnement je n'ai pas réussi à coder la fonction "parfaite" pour le déplacement d'un train d'un point à un autre.

Ce que je veux dire par là, c'est que lorsque je déplace le point représentant mon train sur une ligne qui est oblique, le point peut prendre un chemin bizarre, une vidéo pour visualiser :

Le train (point rouge) arrive toujours à destination (points blancs) mais prend des directions que je ne comprends pas... Voici le code de la 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
65
66
67
68
69
70
71
72
        Private Sub avancerTrain()
        Dim posActuelle = t.getTete()
        Dim posArrivee = t.getArrivee()
 
        Dim v = vitesse
 
        If (posActuelle = posArrivee) Then
            'Si on est arrivés à destination
            posActuelle = posArrivee
            nextDestination(posArrivee)
 
        ElseIf (posActuelle.x = posArrivee.x) Then
            'Si le chemin à parcourir restant est horizontal
            If (posActuelle.y > posArrivee.y) Then
                'S'il faut descendre
                posActuelle.y = posActuelle.y - v
                If (posActuelle.y < posArrivee.y) Then
                    'Si on a dépassé le point d'arrivée
                    posActuelle = posArrivee
                End If
            Else
                'S'il faut monter
                posActuelle.y = posActuelle.y + v
                If (posActuelle.y > posArrivee.y) Then
                    'Si on a dépassé le point d'arrivée
                    posActuelle = posArrivee
                End If
            End If
 
        ElseIf (posActuelle.y = posArrivee.y) Then
            'Si le chemin à parcourir restant est vertical
            If (posActuelle.x > posArrivee.x) Then
                'S'il faut aller vers la gauche
                posActuelle.x = posActuelle.x - v
                If (posActuelle.x < posArrivee.x) Then
                    'Si on a dépassé le point d'arrivée
                    posActuelle = posArrivee
                End If
            Else
                'S'il faut aller vers la droite
                posActuelle.x = posActuelle.x + v
                If (posActuelle.x > posArrivee.x) Then
                    'Si on a dépassé le point d'arrivée
                    posActuelle = posArrivee
                End If
            End If
 
        Else
            'Si le chemin à parcourir est oblique
            Dim x1 = min(posActuelle.X, posArrivee.X)
            Dim x2 = max(posActuelle.X, posArrivee.X)
            Dim y1 = min(posActuelle.Y, posArrivee.Y)
            Dim y2 = max(posActuelle.Y, posArrivee.Y)
 
            Dim coeff = (x2 - x1) / (y2 - y1)
 
            v = vitesse / coeff
 
            posActuelle.X = posActuelle.x + coeff * v
 
            If (posActuelle.y > posArrivee.y) Then
                posActuelle.y = posActuelle.y - v
            Else
                posActuelle.y = posActuelle.y + v
            End If
        End If
 
        t.setTete(posActuelle)
 
        pnlBoard.Refresh()
 
    End Sub

La fonction est lancée à chaque fois que mon timer tick, elle calcule le mouvement à faire en fonction de la position actuelle, de la destination et de la vitesse prédéfinie, les mouvements horizontales/verticales marchent très bien, et ceux obliquent arrivent à destination mais font des détours inexplicables.

Je ne l'ai pas montré sur la vidéo, mais lorsque j'augmente suffisamment la vitesse du train (à partir du moment où elle est à x5) le chemin qu'il prend est tout à fait normal (j'ai testé au pas à pas), sur la vidéo elle est à x1 et j'ai le même problème en vitesse x2.
Je pourrais bien augmenter la vitesse de base mais ce serait un peu tricher...

Je sais plus vraiment quoi faire à partir de là, c'est la première fois que je me retrouve à coder des déplacements obliques et mes recherches sur le net ne m'ont pas plus aidé que ça, si quelqu'un pouvait m'apporter un indice ce serait sympa, merci d'avance.

[Rainui]

Bonjour,
Quels composants avez vous utilisé pour créer le circuit à parcourir?

Dans le calcul de la position du "train", la vitesse ne devrait pas intervenir. Ne devrait elle pas influencer uniquement la fréquence de Timer.Tick ?

Si vous utilisez un ShapeContainer, vous avez accès à la collection de LineShape.

L'idée est de déterminer la fonction de la droite en utilisant le calcul suivant :
Soit:
X1=LineShape.StartPoint.X
Y1=LineShape.StartPoint.Y
X2=LineShape.EndPoint.X
Y2=LineShape.EndPoint.Y

La fonction d'une droite est définie par F(x)=ax + b
Pour déterminer a :
a=(Y2-Y1)/(X2-X1)
Pour déterminer b :
b=Y1-(a*X1)

Une fois la fonction définie, il reste à incrémenter la valeur de X et quand on atteins le EndPoint de la LineShape, on passe à la suivante.

EDIT:
Bien qu'apparemment, vous travaillez en Windows Form, en WPF, il existe un contrôle PathListBox. Ce contrôle permet d'afficher des Items (ici votre cercle représentant le train) sur un élément Path. Il est également possible de lui appliquer une animation afin de reproduire la circulation de votre train.

[DonQuiche]

Bonjour, le résultat me semble tout à fait prévisible : un coup tu avances à l'horizontale, l'autre coup à la verticale, en alternance. C'est bien ce qu'on observe. Voici un algorithme beaucoup plus simple (pseudo-VB) qui n'aura pas ce problè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
Dim dx = posArrivée.x - posActuelle.x
Dim dy = posArrivée.y - posActuelle.y
Dim distance = Maths.Sqrt(dx * dx + dy * dy); 'Toujours différent de zéro grâce à la condition pointProche à la fin
 
positionActuelle.x += (v * dx) / distance
positionActuelle.y += (v * dy) / distance
 
Dim dx2 = posArrivée.x - posActuelle.x
Dim dy2 = posArrivée.y - posActuelle.y
 
'Dépasserait-on le point d'arrivée (changement de signe de dx et/ou dy) ou bien est-on très proche de celui-ci ?
Dim Epsilon = 1E-15
Dim pointDépassé = dx * dx2 < 0 Or dy * dy2 < 0
Dim pointProche = Math.Abs(dx2) < Epsilon And Math.Abs(dy2) < Epsilon
If (pointDépassé Or pointProche) Then
      posActuelle = posArrivee
      nextDestination(posArrivee)
End

PS : attention si tu utilises des entiers, tu pourrais avoir des cas particuliers pour les obliques quasiment horizontales ou verticales. Utilise donc des réels pour positionActuelle.

[Bocator]

Bonjour,
Quels composants avez vous utilisé pour créer le circuit à parcourir?

J'ai créé une classe Railroad.vb, qui possède une liste de points permettant de tracer un circuit en connectant chaque point i et i+1 plus le premier et dernier point, et elle possède également un attribut "owner" permettant de connaître son propriétaire/container afin de faciliter les positionnements des points.

Dans le calcul de la position du "train", la vitesse ne devrait pas intervenir. Ne devrait elle pas influencer uniquement la fréquence de Timer.Tick ?

C'est ce que j'ai eu l'occasion de faire lorsque j'ai programmé un Snake, l'intervalle du timer était divisé par la vitesse qui elle grandissait proportionnellement à la difficulté au cours du jeu.
Le problème ici est que en vitesse X1 mon l'intervalle de mon timer est déjà à 1ms, impossible donc de le descendre plus bas (je ne suis même pas sûr qu'il tick chaque ms). Le seul moyen était donc d'incrément de v (=vitesse) au lieu de 1 à chaque tick. Comme on peut le voir sur la vidéo la vitesse X1 est vraiment lente.

Si vous utilisez un ShapeContainer, vous avez accès à la collection de LineShape.

L'idée est de déterminer la fonction de la droite en utilisant le calcul suivant :
Soit:
X1=LineShape.StartPoint.X
Y1=LineShape.StartPoint.Y
X2=LineShape.EndPoint.X
Y2=LineShape.EndPoint.Y

La fonction d'une droite est définie par F(x)=ax + b
Pour déterminer a :
a=(Y2-Y1)/(X2-X1)
Pour déterminer b :
b=Y1-(a*X1)

Une fois la fonction définie, il reste à incrémenter la valeur de X et quand on atteins le EndPoint de la LineShape, on passe à la suivante.


EDIT:
Bien qu'apparemment, vous travaillez en Windows Form, en WPF, il existe un contrôle PathListBox. Ce contrôle permet d'afficher des Items (ici votre cercle représentant le train) sur un élément Path. Il est également possible de lui appliquer une animation afin de reproduire la circulation de votre train.

Donc si je comprends bien, mon code devrait plus ressembler à ça :

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
 
'Si le chemin à parcourir est oblique
            Dim posDepart = t.getDepart()
            Dim x1 = posDepart.X
            Dim x2 = posArrivee.X
            Dim y1 = posDepart.Y
            Dim y2 = posArrivee.Y
 
            Dim a = (y2 - y1) / (x2 - x1)
            Dim b = y1 - (a * x1)
 
            If (posActuelle.X > posArrivee.X) Then
                posActuelle.X = posActuelle.X - v
            Else
                posActuelle.X = posActuelle.X + v
            End If
 
            posActuelle.Y = a * (posActuelle.X) + b

EDIT :

Ça marche très bien, un grand merci pour l'aide apportée. Cependant il y a un petit "soucis" avec la vitesse du "train", lorsqu'il se déplace en diagonal, j'ai l'impression que plus la valeur absolue du coefficient directeur est grande plus le point se déplace rapidement. Je ne vois pas trop comment je pourrais faire en sorte que la vitesse appliquée reste la même qu'en déplacement horizontal/vertical. Mais je suppose que ça a voir avec Pythagore, je vais essayer d'y réfléchir.

EDIT 2 :

Bonjour, le résultat me semble tout à fait prévisible : un coup tu avances à l'horizontale, l'autre coup à la verticale, en alternance. C'est bien ce qu'on observe. Voici un algorithme beaucoup plus simple (pseudo-VB) qui n'aura pas ce problè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
Dim dx = posArrivée.x - posActuelle.x
Dim dy = posArrivée.y - posActuelle.y
Dim distance = Maths.Sqrt(dx * dx + dy * dy); 'Toujours différent de zéro grâce à la condition pointProche à la fin
 
positionActuelle.x += (v * dx) / distance
positionActuelle.y += (v * dy) / distance
 
Dim dx2 = posArrivée.x - posActuelle.x
Dim dy2 = posArrivée.y - posActuelle.y
 
'Dépasserait-on le point d'arrivée (changement de signe de dx et/ou dy) ou bien est-on très proche de celui-ci ?
Dim Epsilon = 1E-15
Dim pointDépassé = dx * dx2 < 0 Or dy * dy2 < 0
Dim pointProche = Math.Abs(dx2) < Epsilon And Math.Abs(dy2) < Epsilon
If (pointDépassé Or pointProche) Then
      posActuelle = posArrivee
      nextDestination(posArrivee)
End

PS : attention si tu utilises des entiers, tu pourrais avoir des cas particuliers pour les obliques quasiment horizontales ou verticales. Utilise donc des réels pour positionActuelle.

Je viens tout juste de voir ton post, et ta solution me semble bien plus propre et optimisé que ce que j'ai fait, je vais donc l'essayer. Un grand merci à toi aussi.

EDIT 3 :

Après test, ta fonction me donne exactement ce que j'avais auparavant, les déplacements obliques déconnent, mais étant donné que ça fait la même chose en beaucoup de moins de lignes, je vais essayer de l'implémenter tout de même uniquement pour les déplacements horizontaux/verticaux

[Rainui]

Ça marche très bien, un grand merci pour l'aide apportée. Cependant il y a un petit "soucis" avec la vitesse du "train", lorsqu'il se déplace en diagonal, j'ai l'impression que plus la valeur absolue du coefficient directeur est grande plus le point se déplace rapidement. Je ne vois pas trop comment je pourrais faire en sorte que la vitesse appliquée reste la même qu'en déplacement horizontal/vertical. Mais je suppose que ça a voir avec Pythagore, je vais essayer d'y réfléchir.

Je dois avoir un problème au cerveau ... Il vous faut bien intégrer la vitesse comme vous l'avez fait.

Pour ce qui est du déplacement plus rapide en diagonales, oui, c'est du à l'angle. Pour corriger la vitesse de déplacement, il faut calculer le cosinus de l'angle.
Pour l'explication, c'est que l'on fait des déplacements de position à position, on ne lui demande pas de parcourir une distance suivant une direction en un temps donné.

[Bocator]

Je dois avoir un problème au cerveau ... Il vous faut bien intégrer la vitesse comme vous l'avez fait.

Pour ce qui est du déplacement plus rapide en diagonales, oui, c'est du à l'angle. Pour corriger la vitesse de déplacement, il faut calculer le cosinus de l'angle.
Pour l'explication, c'est que l'on fait des déplacements de position à position, on ne lui demande pas de parcourir une distance suivant une direction en un temps donné.

Pour corriger la vitesse j'ai pensé à ça :

J'ai une valeur globale vitesse qui détermine l'incrémentation à faire à chaque passage (1 par défaut), c'est à dire qu'il faut que je fasse en sorte que la distance parcourue à chaque tick en diagonale soit égale à "vitesse", soit d'après Pythagore :

vitesse² = (incrémentationX)² + (incrémentationY)²

pour le coup "vitesse" est pas très intuitif je trouve dans ce calcul, donc :

distanceParcourable² = (incrémentationX)² + (incrémentationY)²
<=> distanceParcourable = sqrt((incrémentationX)² + (incrémentationY)²)
<=> incrémentationX = sqrt((distanceParcourable)² - (incrémentationY)²)
<=> incrémentationY = sqrt((distanceParcourable)² - (incrémentationX)²)

Sauf erreur de ma part, ça devrait les différentes égalités possibles.
Je connais donc distanceParcourable qui m'ait donné par la vitesse, et je me retrouve avec deux inconnues et une seule équation... ce qui ne facilite pas vraiment la tâche.
La seule idée qui me vienne serait de "piffer", c'est-à-dire faire un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
double distanceParcourable = v;
double incrémentationX = 0;
double incrémentationY = 0;
bool trouve = false;
 
while (!trouve) {
    incrémentationX++;
    incrémentationY = a * incrémentionX + b;
    trouve = (distanceParcourable = sqrt((incrémentationX)² + (incrémentationY)²));
}

Si j'dois en arriver là ça risque d'être assez lourd, sachant que plus tard j'aurais besoin de bouger plusieurs trains à la fois, même si je peux améliorer la recherche du X en en utilisant la dichotomie.

EDIT :

Si tu observes toujours ce problème avec mon code alors le problème vient d'ailleurs. Ou alors tu utilises des entiers.

Je convertis mes coordonnées en entiers uniquement lors du dessin pour ne pas provoquer d'erreur, autrement je ne fais jamais de conversions, mais il est vrai que pendant l'éxécution lorsque je fais des arrêts et que je regarde les valeurs de mes points, elles sont toujours en int, je ne saurais pas vraiment dire pourquoi.

[Rainui]

Je parlais de l'angle de la droite justement pour que l'on connaisse la deuxième inconnue.

Quant vous faites un déplacement horizontal ou vertical, vous lui ajoutez un nombre de pixel à la valeur X pour les déplacements horizontaux et Y pour le déplacements verticaux.

En déplacement oblique, vous voulez en fait que le point se déplace également du même nombre de pixel mais en ligne oblique. On a pas la possibilité de faire ça.

Pour palier à ça, on a une solution mathématique qui est :

Pythagore : C²=A²+B²
La trigonométrie : Sinus, Cosinus, Tangente

L'angle d'une droite est calculable avec la formule suivante :
a=Tan(Angle) ou a est le coefficient directeur de la droite (F(x)=ax + b)

On sait déjà que la tangente de notre triangle doit être égale au nombre de pixel que l'ont veut déplacer notre train. Avec la trigo, reste plus qu'à calculer Delta(X) et Delta(Y).

[Iradrille]

Pour corriger la vitesse j'ai pensé à ça :

J'ai une valeur globale vitesse qui détermine l'incrémentation à faire à chaque passage (1 par défaut), c'est à dire qu'il faut que je fasse en sorte que la distance parcourue à chaque tick en diagonale soit égale à "vitesse", soit d'après Pythagore :

vitesse² = (incrémentationX)² + (incrémentationY)²

Ou avec la trigo :
distance = vitesse * temps_écoulé
distance_x = distance * cos(angle)
distance_y = distance * sin(angle)

angle étant l'inclinaison du segment que suit ton train.

[DonQuiche]

Je convertis mes coordonnées en entiers uniquement lors du dessin pour ne pas provoquer d'erreur, autrement je ne fais jamais de conversions, mais il est vrai que pendant l'éxécution lorsque je fais des arrêts et que je regarde les valeurs de mes points, elles sont toujours en int, je ne saurais pas vraiment dire pourquoi.

Et quel est le type de x et y dans ta classe vecteur/point ? Et celui de "vitesse" ?
Crois-moi, l'algo que j'ai proposé doit fonctionner.

De toute façon tu utilises forcément des entiers à un moment avant l'affichage sinon ton code initial n'aurait jamais fonctionné (les deux positions n'auraient jamais été parfaitement égales), d'où l'avertissement que j'avais mis.

[DonQuiche]

Après test, ta fonction me donne exactement ce que j'avais auparavant, les déplacements obliques déconnent, mais étant donné que ça fait la même chose en beaucoup de moins de lignes, je vais essayer de l'implémenter tout de même uniquement pour les déplacements horizontaux/verticaux

Si tu observes toujours ce problème avec mon code alors le problème vient d'ailleurs. Ou alors tu utilises des entiers.