Discussion :

[Kliper]

Bonjour,

Je suis en proie au désespoir, j'essaye de faire un moteur de jeu (rts) et en se moment je bloque sur quelque chose de vraiment énervant. Je voudrais trouver un algo pour permettre a deux unitée (sprite) qui entre en collision de s'évitée (de glisser dans des direction différente). Je butte sur ce problème ridicule depuis au moins une ou deux semaine... je n'ai plus les idée claire je fait n’importe quoi, j'ai même essayer de faire la technique du labyrinthe (toujours a droite) mais sa ne donne pas un résultat génial.

Bref j'ai besoin d'aide parce que la je fatigue. Donc pour récapituler, je recherche un algo d’évitement (pas de A*) juste un truc pour éviter que deux unités mongolise et se bloque mutuellement (figure 3).

Dans un premier temps je voudrais que les unités s'évite une a une (figure 1) puis pour N unitée (figure 2).




Je dispose de la positions des unitée, du vecteur d'avancement de l'unitée source, je peu calculer l'angle entre les deux unitée... que dois-je faire?
Mon objectif est d'obtenir pour la source la prochaine destination pour éviter la cible.

Merci d'avance.

[Mat.M]

aachh là c'est l'aspect le plus pointu d'un jeu vidéo que tu essaies d'aborder.

Si les unités bougent toutes sur un clic souris comme ça se fait dans un RTS ce que j'ai fait dans mon jeu c'est que le premier part en avance et les suivants qui sont mémorisés dans une liste partent quelques secondes après.
C'est une solution à dix sous; l'unité est déplacée avec un algo de pathfinding et le point d'arrivée est légérement pondéré par un décalage aléatoire.
L'inconvénient c'est que les unités finissent quasiment en file indienne...
Sinon il y a des solutions plus complexes peut-être des quadtrees.
Moi aussi je me suis arraché les cheveux de la tête.

Sinon autre solution c'est de calculer pour toutes les unités les positions des unités précédentes et de décaler légérement la position finale des unités suivantes

[Kliper]

Bonjour,

Déjà merci d'avoir répondu si vite. Alors mon problème n'est pas exactement celui la, mais j'avais déjà réfléchi au problème dont tu me parle. Je note tes idée mais je vais résoudre les problème un par un sinon je n'y arriverai jamais

La solution que j'avais imaginer de mon cotée est la suivante: je calcule le centre (position) des unités sélectionnée et je rajoute une destination avant la destination finale qui sera espacée de la distance calculée.

Un petit schéma sera sans doute beaucoup plus explicite:



Mais revenons à mon problème: je voudrais un algorithme (ou un calcule) qui permette a une unitée qui collisionne N autres unitées de trouver une prochaine destination qui lui permettra de dévier sa trajectoire pour pas passer a travers son homologue.

Merci d'avance.

[nemo188]

bonjour a tous
voila un code simple une unité fait une fuite dans une direction aléatoire et l'autre recalcule le chemin, ça évite le bug de l'unité qui reste sur place coincé indéfiniment.j’espère que ça aidera .

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
if (unitcP.UType <> 1)  or (unitcP.UType <> 6) then
begin
 if unitcP.y < Unitp.y then
  UnitcP.y2 := UnitcP.y - 2*(UnitP.y - UnitcP.y)
 else
  UnitcP.y2 := UnitcP.y + 2*(UnitcP.y - UnitP.y);
 
 if unitcP.x < UnitP.x then
  UnitcP.x2 := UnitcP.x - 2*(UnitP.x - UnitcP.x)
 else
  UnitcP.x2 := UnitcP.x + 2*(UnitcP.x - UnitP.x);
 
 
 
  if UnitcP.x2 < 0 then UnitcP.x2 := 0; if UnitcP.y2 < 0 then UnitcP.y2 := 0;
  if UnitcP.x2 > MaxX then UnitcP.x2 := MaxX; if UnitcP.y2 > MaxX then UnitcP.y2 := MaxX;
  if UnitTypes[UnitcP.utype].flying then UnitcP.frame := 0;
 
 
  UnitcP.state := 2;
 
 end;
 
 
 
 
 
 Astar(UnitP);
 UnitP.state := 3;
 UnitP.wcounter := 0;
 Move(UnitP.x,UnitP.y,UnitP.direction);
 UpdateUnitTiles(UnitP);

on peut aussi comme moi même j'ai chercher,marqué la tile ou se trouve l'unité non passable et l'enlevé si le state de l'unité et en route.
le state c'est l'ordre en marche=3 ,immobile=1 ,en calcul du chemin=2.
voila !