Discussion :

[e.Saad]

Bonjour à tous !

Voilà voilà, je suis en train de créer un jeu vidéo, ce serait de l'infiltration en vue du dessus...



Et le problème est le suivant: J'ai bien vu l'algorithme A*, et parviens à le comprendre plus ou moins, mais n'ait aucune fichtre idée de la manière dont je pourrais éventuellement m'en servir.

Le gros problème étant sa conversion vers l'interface de Tkinter...

En fait, il y a plusieurs "petits" problèmes qui viennent s'ajouter un à un:
1 - J'ai une map sous format .txt, et je voudrais utiliser cette map comme base pour les cases.
Or, je n'ai aucune idée de la manière dont je pourrais vérifier la position du garde et du joueur par rapport aux cases données sur le .txt, en gros, savoir sur quelles cases ils sont.

2 - Il y a toujours quelques soucis de compréhension de l'algorithme, surtout dans son déroulé. J'ai peut-être été bercé trop près du mur, mais certaines choses me semblent floues, notamment au niveau des deux listes et de leur utilité, et de la manière dont le programme pourrait déterminer le chemin le plus court à prendre, voir modifier le trajet prévu à la base.

Ce sont les deux problèmes majeurs qui me bloquent dans ma recherche, et les régler m'aiderait déjà considérablement.

Pour créer la map, j'utilise ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def decor():
    global xroot
    global yroot
    for ligne in mapfile :
        for i in range(0,len (ligne)) :
            case = ligne[i]
            if case=='H':
                maison=drawzone.create_image(xroot,yroot, image=housetile, anchor="nw")
            if case=='P'   :
                rue=drawzone.create_image(xroot, yroot, image=pavestile, anchor="nw")
            xroot= xroot+50
        xroot=0
        yroot=yroot+50

Pour le moment, mon algorithme ressemble à ça:


Initiatliser la map via le document .txt.

Listes:
Pour lignes dans map:
Pour i dans (0, longueur des lignes):
case=ligne[i]
casesdispos[i]= i, ligne



Casesétudiées[]={vide}

Direction[]={vide}



On trouve la case de départ ! (comment faire pour la déterminer ?) !
Casedépart = Case[i], ligne[i]


On trouve la case de destination
Casedest = Case[f], ligne[f]





Discrimination:
case1= case[i-1], ligne[i] (donc la case à gauche de la case parente, ici la case initiale)
Si case dans la liste casedispos:
Si case: "B" (bloqué):
Supprimer de casesdispos
Sinon:
Valeur1: vitesse + ( (distanceencases[f-i]) (distanceenlignes[f-i]) )
Supprimer de cases dispos

Sinon:
#Apparemment il faut revérifier la valeur de la case si elle est dans la liste des cases étudiées... Je n'ai pas compris non plus#

case2= case[i+1], ligne[i] (donc la case à droite de la case parente, ici la case initiale)
Si case dans la liste casedispos:
Si case: "B" (bloqué):
Supprimer de casesdispos
Sinon:
Valeur2: vitesse + ( (distanceencases[f-i]) (distanceenlignes[f-i]) )
Supprimer de cases dispos

case3= case[i], ligne[i+1] (donc la case en dessous de la case parente, ici la case initiale)
Si case dans la liste casedispos:
Si case: "B" (bloqué):
Supprimer de casesdispos
Sinon:
Valeur3: vitesse + ( (distanceencases[f-i]) (distanceenlignes[f-i]) )
Supprimer de cases dispos

case4= case[i], ligne[i-1] (donc la case en dessous de la case parente, ici la case initiale)
Si case dans la liste casedispos:
Si case: "B" (bloqué):
Supprimer de casesdispos
Sinon:
Valeur4: vitesse + ( (distanceencases[f-i]) (distanceenlignes[f-i]) )
Supprimer de cases dispos


Si valeur1 < valeur2 < valeur3 < valeur4:
caseétudiée[1]= case[i-1], line[i]
Direction[1]= 1


If dernière case de case étudiée= Casedest, on arrête la boucle.


Ensuite, en fonction de la liste "direction", le PNJ va se déplacer sur la longueur d'une case dans la direction indiquée:
1 = Gauche
2 = Droite
3 = Haut
4 = Bas

Jusqu'à ce que la dernière valeur de la liste soit utilisée.




Merci pour votre attention, et à la prochaine !

Saad