[R] Labyrinthe

[sozary]

Je suis en train de créer un labyrinthe qui se génère tout seul!! Pouvez vous me dire où code bloque svp? ^^

► Afficher le texte

Code : Tout sélectionner

#include <Array.au3>



Func _CreerLaby($iHauteur = 5, $iLargeur = 5)

    Local $aLaby[$iHauteur][$iLargeur][2], $OpenList[0], $PrivateList[0]

    For $i = 0 To $iHauteur - 1
        For $j = 0 To $iLargeur - 1
            $aLaby[$i][$j][0] = "0"
            $aLaby[$i][$j][1] = "15"
        Next
    Next


    ;_ArrayDisplay($aLaby)
    _Cherche($aLaby, 0, 1, $OpenList, $PrivateList)
;~  _RpzIn2D($aLaby)
    $file=FileOpen("testou.txt",2)
    For $i=0 to UBound($aLaby)-1
        For $j=0 to UBound($aLaby,2)-1
            FileWrite($file,Binary(Number($aLaby[$i][$j][1])&" "))
        Next

        FileWrite($file,@CRLF)
    Next
    FileClose($file)
    _ArrayDisplay($aLaby)
    Return $aLaby
EndFunc   ;==>_CreerLaby

Func _Cherche(ByRef $aLaby, $X, $Y, $OpenList, $PrivateList)
    If _IsCompleted($aLaby) = True Then
        Return
    Else
        _ArrayAdd($PrivateList, _Verif($aLaby, $X + 1, $Y, 1))
        _ArrayAdd($PrivateList, _Verif($aLaby, $X - 1, $Y, 2))
        _ArrayAdd($PrivateList, _Verif($aLaby, $X, $Y + 1, 3))
        _ArrayAdd($PrivateList, _Verif($aLaby, $X, $Y - 1, 4))
        While _ArraySearch($PrivateList, -1) <> -1
            _ArrayDelete($PrivateList, _ArraySearch($PrivateList, -1))
        WEnd

                _ArrayDisplay($PrivateList,"privé")
                _ArrayDisplay($OpenList,"ouvert")

        If UBound($PrivateList) = 0 And UBound($OpenList)  > 0 Then
            $rand = Random(0, UBound($OpenList) - 1, 1)
            $X2 = StringSplit($OpenList[$rand], ",")[1]
            $Y2 = StringSplit($OpenList[$rand], ",")[2]
            _ArrayDelete($OpenList, $rand)
            ReDim $PrivateList[0]
            _Cherche($aLaby, $X2, $Y2, $OpenList, $PrivateList)
        ElseIf UBound($OpenList)=0 And  UBound($PrivateList) = 0 Then
            MsgBox(0,"","sort")
            Return

        EndIf

    ;~  _ArrayDisplay($OpenList)
        ;_ArrayDisplay($PrivateList)


        $rand = Random(0, UBound($PrivateList) - 1, 1)
        $X2 = StringSplit($PrivateList[$rand], ",")[1]
        $Y2 = StringSplit($PrivateList[$rand], ",")[2]

        Switch $X2
            Case $X + 1
                $aLaby[$X2][$Y2][1] = "7"
                $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], "13")
            Case $X - 1
                $aLaby[$X2][$Y2][1] = "13"
                $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], "7")
            Case $X
                Switch $Y2
                    Case $Y + 1
                        $aLaby[$X2][$Y2][1] = "11"
                        $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], "14")
                    Case $Y - 1
                        $aLaby[$X2][$Y2][1] = "14"
                        $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], "11")
                EndSwitch
        EndSwitch

        _ArrayDelete($PrivateList, $rand)
        For $i = 0 To UBound($PrivateList) - 1
            _ArrayAdd($OpenList, $PrivateList[$i])
        Next

        $aLaby[$X][$Y][0] = "1"
        _RpzIn2D($aLaby)
        ReDim $PrivateList[0]
        _Cherche($aLaby, $X2, $Y2, $OpenList, $PrivateList)
EndIf


EndFunc   ;==>_Cherche


Func _Verif($aLaby, $X, $Y, $Case)
    If $X >= 0 And $Y >= 0 And $X <= UBound($aLaby) - 1 And $Y <= UBound($aLaby, 2) - 1 And $aLaby[$X][$Y][0] = "0" Then
        Switch $Case
            Case 1
                Return $X & "," & $Y & "," & $X - 1 & "," & $Y
            Case 2
                Return $X & "," & $Y & "," & $X + 1 & "," & $Y
            Case 3
                Return $X & "," & $Y & "," & $X & "," & $Y - 1
            Case 4
                Return $X & "," & $Y & "," & $X & "," & $Y + 1
        EndSwitch

    Else
        Return -1
    EndIf
EndFunc   ;==>_Verif

Func _IsCompleted($Array)
    For $i = 0 To UBound($Array) - 1
        For $j = 0 To UBound($Array, 2) - 1
            If $Array[$i][$j][0] <> "1" Then Return False
        Next
    Next
    MsgBox(0,"","complété")
    Return True
EndFunc   ;==>_IsCompleted

Func _RpzIn2D($Array)
    Local $temp[UBound($Array)][UBound($Array, 2)]
    For $i = 0 To UBound($Array) - 1
        For $j = 0 To UBound($Array, 2) - 1
            $temp[$i][$j] = $Array[$i][$j][0]
        Next
    Next

    _ArrayDisplay($temp)
EndFunc   ;==>_RpzIn2D


 

[jguinch]

On fait quoi avec ton script ?

[ZDS]

Bonjour,

Plusieurs points problématiques retiennent mon attention

• 1° Tout d'abord, les [] pour l'index dans un tableau s'appliquent à une variable uniquement, et non à un retour de fonction par exemple. Ainsi :

  Code : Tout sélectionner

  $X2 = StringSplit($OpenList[$rand], ",")[1]
  $Y2 = StringSplit($OpenList[$rand], ",")[2]

  est incorrect, par contre ceci l'est :

  Code : Tout sélectionner

  Local $split = StringSplit($OpenList[$rand], ",")
  $X2 = $split[1]
  $Y2 = $split[2]

• 2° Tu mélanges les torchons et les serviettes en appliquant des strings "0" ou "15" dans le tableau $aLaby, et autant faire des BitAnd sur des nombres est logique pour tester un bit en particulier (comme un masque), autant le faire sur une chaîne de caractères n'a pas de sens (surtout entre un seul caractère comme "7" et deux caractères comme "13")
• 3° Ton tableau final est à 3 dimensions, ce qui me semble totalement inutile puisque tu gères la dernière dimension pour un état marqué ou non : c'est aussi ce que tu fais dans le cadre des murs de ton labyrinthe 1 + 2 + 4 + 8, donc autant ajouter un 16 pour ce marquage, et s'abstraire de cette troisième dimension qui casse un peu les c**illes ^^
• 4° Ton algorithme est trop compliqué, quasiment illisible et non commenté. Merci de remédier à ça avant que qui que ce soit ne puisse t'apporter une aide plus importante sur ton code.

En bref, dans son état actuel ton code ne peut pas fonctionner, il faudra sans doute le reprendre en totalité (et commenté pour que d'autres puissent t'aider).
A bientôt !

PS: Deux fonctions qui pourraient t'être utile _get() et _set(), et un code exemple commenté qui pourra t'aider à comprendre comment les utiliser

► Afficher le texte_get / _set

Code : Tout sélectionner

#include <Array.au3>

; Les valeurs de chaque tableau sont sur 9 bits significatifs

; Premier tableau rempli de 0 à tous les bits significatifs
; Second tableau rempli de 1 à tous les bits significatifs
Local $array0[3][3], $val0 = 0 ; 0 = 0 0000 0000
Local $array1[3][3], $val1 = 2^9-1 ; 2^9 - 1 = 1 1111 1111
For $i = 0 To UBound($array0,1)-1
    For $j = 0 To UBound($array0,2)-1
        $array0[$i][$j] = $val0
        $array1[$i][$j] = $val1
    Next
Next

; Modification à chaque case du premier tableau en AJOUTANT un bit (incrémenté)
Local $index = 0
For $i = 0 To UBound($array0,1)-1
    For $j = 0 To UBound($array0,2)-1
        $index += 1
        _set($array0, $i, $j, True, $index)
        _ArrayDisplay($array0, "$array0 : "&$index&"/"&(UBound($array0,1)*UBound($array0,2)))
    Next
Next
; Modification à chaque case du premier tableau en RETIRANT un bit (incrémenté)
Local $index = 0
For $i = 0 To UBound($array1,1)-1
    For $j = 0 To UBound($array1,2)-1
        $index += 1
        _set($array1, $i, $j, False, $index)
        _ArrayDisplay($array1, "$array1 : "&$index&"/"&(UBound($array1,1)*UBound($array1,2)))
    Next
Next

; Affichage des tableaux avec les bits
Local $index = 0
For $i = 0 To UBound($array0,1)-1
    For $j = 0 To UBound($array0,2)-1
        $array0[$i][$j] = bin($array0[$i][$j], UBound($array0,1)*UBound($array0,2))
        $array1[$i][$j] = bin($array1[$i][$j], UBound($array1,1)*UBound($array1,2))
    Next
Next
_ArrayDisplay($array0, "$array0 [Binaire]")
_ArrayDisplay($array1, "$array1 [Binaire]")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Transformation d'un nombre en chaine de caractères représantant le binaire
Func bin($val, $n=0)
    Local $result = "", $rest = $val
    Do
        $result = BitAND($rest, 1) & $result
        $rest = BitShift($rest, 1)
    Until $rest = 0 And StringLen($result) >= $n
    Return $result
EndFunc

; Consultation de la valeur du tableau
; - si $b = 0, retourne la valeur dans le tableau
; - sinon, retourne True si le bit en $b-ième position est vrai, False sinon
Func _get($tab, $x, $y, $b=0)
    If $b = 0 Then ; Si $b = 0, on retourne la valeur dans le tableau
        Return $tab[$x][$y]
    Else ; Sinon, on effectue un masque sur le bit demandé
        Return BitAND($tab[$x][$y], 2^($b-1)) <> 0
    EndIf
EndFunc

; Affectation d'un bit dans une valeur du tableau
; - si $b = 0, affecte directement la valeur $val dans le tableau
; - sinon, si $val = True, affectue uniquement le bit en $b-ième position de la valeur du tableau à 1, à 0 sinon
Func _set(ByRef $tab, $x, $y, $val, $b=0)
    If $b = 0 Then ; Si $b = 0, on set la valeur directement dans le tableau
        $tab[$x][$y] = $val
    Else ; Sinon, on agit en fonction de la valeur déjà en place
        Local $get = _get($tab, $x, $y, $b)
        If $get And Not $val Then ; Si le bit est déjà à 1, on le retire si $val = False
            $tab[$x][$y] -= 2^($b-1)
        ElseIf Not $get And $val Then ; Si le bit est déjà à 0, on l'ajoute si $val = True
            $tab[$x][$y] += 2^($b-1)
        EndIf ; Sinon, il est inutile de faire quoi que ce soit
    EndIf
EndFunc

[jguinch]

@ZDS : pour le point 1, cette écriture est possible depuis la v3.3.10 :
Added: Array access on expression: StringSplit("a,b", ",")[1].

Code : Tout sélectionner

MsgBox( 0, "", StringSplit("a,b", ",")[1] )

[ZDS]

Je suis en 3.3.10.2, j'ai seulement ajouté "Exit _CreerLaby()" en ligne 3 et pourtant j'ai droit à un :

Code : Tout sélectionner

"C:\Users\ZDS\Desktop\Nouveau AutoIt v3 Script.au3" (66) : ==> Subscript used on non-accessible variable.:
$X2 = StringSplit($PrivateList[$rand], ",")[1]
$X2 = StringSplit($PrivateList[$rand], ",")^ ERROR

Même si cela devrait être faisable comme tu dis puisque, bizarrement, ça, ça marche :

Code : Tout sélectionner

Func f()
    Local $result[10] = [10,11,12,13,14,15,16,17,18,19]
    Return $result
EndFunc
MsgBox(0, "", f()[5])

De toute manière d'un point de vue algo, répéter le split deux fois pour $X et $Y reste superflu voire absurde ^^

[sozary]

Re!! Désolé! Cet après midi je n'étais pas chez moi et est donc écrit ce post très trop rapidement!

Oui donc j'ai terminé l'algorithme, seulement je n'ai pas beaucoup pris en compte tes conseils ZDS, du fait que je suis surbouqué en ce moment et que j'ai pas le temps de réécrire tout l'algo!

Je ferais donc cela un peu plus tard en prenant compte de tes remarques!

En revanche, voici sont fonctionnement: j'ai les 4 murs principaux d'une cellule d'un tableau 2D du labyrinthe, elle a donc l'état non visité (0) et la valeur 15. En effet, les murs Nord, Ouest,Sud et est sont bloqués, j'ai donc N=1, O=1, etc, on a donc 1111, ce qui en binaire donne 15.

Ensuite j'ai deux listes, une privé contenant tous les voisins potentiels de la cellule étudiée. L'algo, si il y a un voisin potentiel au minimum, en choisi un aléatoirement dans la liste privée, puis je coupe le chemin allant de la cellule voisine à celle actuelle, puis par une opération AND, je fais en sorte que la cellule actuelle soit ouverte sur la cellule voisine, en conservant ses liaisons d'avant (si ce fût le cas). Le reste des voisins potentiels est ajouté à la fin de l'open list.

Si la liste privée est vide, on prend un élément aléatoirement dans l open list, et on réitère sur les nouvelles coordonnées.


Pour ceux qui n'ont pas encore trop saisi, cette méthode est bien expliquée ici!

P-S: Merci pour ta patience ZDS, et je te comprends jguinch !
Voici le code provisoire: (il marche)

► Afficher le texte

Code : Tout sélectionner

#include <Array.au3>


Global $try = False

Func _CreerLaby($iHauteur = 5, $iLargeur = 5)
    Local $aLaby[$iHauteur][$iLargeur][2], $OpenList[0], $PrivateList[0]

    For $i = 0 To $iHauteur - 1     ;initialise le tableau 3D
        For $j = 0 To $iLargeur - 1
            $aLaby[$i][$j][0] = 0
            $aLaby[$i][$j][1] = 15
        Next
    Next


    _Cherche($aLaby, 0, 1, $OpenList, $PrivateList)


    _RpzIn2D($aLaby,"Laby") ;Montre uniquement les valeurs des cases et non leur état (0|1)
    $file = FileOpen("testou.txt", 2)
    For $i = 0 To UBound($aLaby) - 1
        For $j = 0 To UBound($aLaby, 2) - 1
            FileWrite($file, Binary(Number($aLaby[$i][$j][1]) & " "))
        Next

        FileWrite($file, @CRLF)
    Next
    FileClose($file);juste pour voir à quoi cela ressemble

    Return $aLaby
EndFunc   ;==>_CreerLaby

Func _Cherche(ByRef $aLaby, $X, $Y, $OpenList, $PrivateList)
    If _IsCompleted($aLaby) = True Then; si toutes les cases on été visitées, on sort
        Return
    Else
        _ArrayAdd($PrivateList, _Verif($aLaby, $X + 1, $Y, 1))
        _ArrayAdd($PrivateList, _Verif($aLaby, $X - 1, $Y, 2))
        _ArrayAdd($PrivateList, _Verif($aLaby, $X, $Y + 1, 3))
        _ArrayAdd($PrivateList, _Verif($aLaby, $X, $Y - 1, 4))
        While _ArraySearch($PrivateList, -1) <> -1
            _ArrayDelete($PrivateList, _ArraySearch($PrivateList, -1))
        WEnd


        If UBound($PrivateList) = 0 And UBound($OpenList) > 0 Then
            $rand = Random(0, UBound($OpenList) - 1, 1)
            $X2 = StringSplit($OpenList[$rand], ",")[1]
            $Y2 = StringSplit($OpenList[$rand], ",")[2]
            _ArrayDelete($OpenList, $rand)
            ReDim $PrivateList[0]
            Switch $X2
                Case $X + 1
                    $aLaby[$X2][$Y2][1] = 7
                    $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 13)
                Case $X - 1
                    $aLaby[$X2][$Y2][1] = 13
                    $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 7)
                Case $X
                    Switch $Y2
                        Case $Y + 1
                            $aLaby[$X2][$Y2][1] = 11
                            $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 14)
                        Case $Y - 1
                            $aLaby[$X2][$Y2][1] = 14
                            $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 11)
                    EndSwitch
            EndSwitch

            $aLaby[$X][$Y][0] = 1

            _Cherche($aLaby, $X2, $Y2, $OpenList, $PrivateList)
        ElseIf UBound($OpenList) = 0 And UBound($PrivateList) = 0 Then

            Return

        EndIf

        If $try Then Return

        $rand = Random(0, UBound($PrivateList) - 1, 1)
        $X2 = StringSplit($PrivateList[$rand], ",")[1]
        $Y2 = StringSplit($PrivateList[$rand], ",")[2]

        Switch $X2
            Case $X + 1
                $aLaby[$X2][$Y2][1] = 7
                $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 13)
            Case $X - 1
                $aLaby[$X2][$Y2][1] = 13
                $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 7)
            Case $X
                Switch $Y2
                    Case $Y + 1
                        $aLaby[$X2][$Y2][1] = 11
                        $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 14)
                    Case $Y - 1
                        $aLaby[$X2][$Y2][1] = 14
                        $aLaby[$X][$Y][1] = BitAND($aLaby[$X][$Y][1], 11)
                EndSwitch
        EndSwitch

        _ArrayDelete($PrivateList, $rand)
        For $i = 0 To UBound($PrivateList) - 1
            _ArrayAdd($OpenList, $PrivateList[$i])
        Next

        $aLaby[$X][$Y][0] = 1
        ReDim $PrivateList[0]
        _Cherche($aLaby, $X2, $Y2, $OpenList, $PrivateList)
    EndIf


EndFunc   ;==>_Cherche


Func _Verif($aLaby, $X, $Y, $Case)
    If $X >= 0 And $Y >= 0 And $X <= UBound($aLaby) - 1 And $Y <= UBound($aLaby, 2) - 1 And $aLaby[$X][$Y][0] = "0" Then
        Switch $Case
            Case 1
                Return $X & "," & $Y & "," & $X - 1 & "," & $Y
            Case 2
                Return $X & "," & $Y & "," & $X + 1 & "," & $Y
            Case 3
                Return $X & "," & $Y & "," & $X & "," & $Y - 1
            Case 4
                Return $X & "," & $Y & "," & $X & "," & $Y + 1
        EndSwitch

    Else
        Return -1
    EndIf
EndFunc   ;==>_Verif

Func _IsCompleted($Array)
    For $i = 0 To UBound($Array) - 1
        For $j = 0 To UBound($Array, 2) - 1
            If $Array[$i][$j][0] <> 1 Then Return False
        Next
    Next
    $try = True
    Return True
EndFunc   ;==>_IsCompleted

Func _RpzIn2D($Array, $title = "")
    Local $temp[UBound($Array)][UBound($Array, 2)]
    For $i = 0 To UBound($Array) - 1
        For $j = 0 To UBound($Array, 2) - 1
            $temp[$i][$j] = $Array[$i][$j][1]
        Next
    Next

    _ArrayDisplay($temp, $title)
EndFunc   ;==>_RpzIn2D


 

[sozary]

Rebonjour!

Alors voilà, j'ai apporté des amélioration au code, enlevé la 3D inutile, et est enlevé la récursivité!
On à donc quelque chose de plus simple, j'aimerais néanmoins savoir si vous trouvez des erreurs dans le code.
Il est également moins long que le précédant, et plus facile à comprendre aussi!

► Afficher le texte

Code : Tout sélectionner

#include <Array.au3>


Global $try = False

Func _CreerLaby($iHauteur = 5, $iLargeur = 5)
    $iHauteur += 1
    $iLargeur += 1
    Local $aLaby[$iHauteur][$iLargeur], $OpenList[0], $Fin = False, $PrivateList[0], $X = 0, $Y = 0

    For $i = 0 To $iHauteur - 1 ;initialise le tableau 2D
        For $j = 0 To $iLargeur - 1
            $aLaby[$i][$j] = 15
        Next
    Next



    Do
        $Fin = False
        While Not $Fin ;TANT que l on a des voisins, donc que nous sommes pas dans une impasse
            _ArrayAdd($PrivateList, _Verif($aLaby, $X + 1, $Y));on ajoute nos voisins
            _ArrayAdd($PrivateList, _Verif($aLaby, $X - 1, $Y))
            _ArrayAdd($PrivateList, _Verif($aLaby, $X, $Y + 1))
            _ArrayAdd($PrivateList, _Verif($aLaby, $X, $Y - 1))
            While _ArraySearch($PrivateList, -1) <> -1; on eleve ceux n'etant pas accessibles
                _ArrayDelete($PrivateList, _ArraySearch($PrivateList, -1))
            WEnd
            If UBound($PrivateList) = 0 Then
                $Fin = True ;si il n y a pas de voisins, alors on est dans une impasse, on sort donc de la boucle while
            Else
                $rand = Random(0, UBound($PrivateList) - 1, 1);sinon on pioche au hasard parmis nos voisins
                $X2 = StringSplit($PrivateList[$rand], ",")[1]
                $Y2 = StringSplit($PrivateList[$rand], ",")[2]

                Switch $X2; on casse les murs joignant les deux cellules
                    Case $X + 1
                        $aLaby[$X2][$Y2] = 7
                        $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 13)
                    Case $X - 1
                        $aLaby[$X2][$Y2] = 13
                        $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 7)
                    Case $X
                        Switch $Y2
                            Case $Y + 1
                                $aLaby[$X2][$Y2] = 11
                                $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 14)
                            Case $Y - 1
                                $aLaby[$X2][$Y2] = 14
                                $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 11)
                        EndSwitch
                EndSwitch
                ;_ArrayDisplay($PrivateList)
                _ArrayDelete($PrivateList, $rand); on enleve le voisin que l on vient de visiter
                For $i = 0 To UBound($PrivateList) - 1; on ajoute ensuite à notre liste principale tous les autre voisins qu'on avait dans notre liste de voisins
                    _ArrayAdd($OpenList, $PrivateList[$i])
                Next
                $X = $X2 ;on utilise la cellule que l'on vient de visiter comme cellule courante
                $Y = $Y2
                ReDim $PrivateList[0];on vide la liste des voisins
                ;_ArrayDisplay($OpenList)
            EndIf
        WEnd;SI il n y a pas de voisin potentiel, alors on regarde dans la liste ouverte, contenant tous les voisins dont on ne c'est pas occupé

        $rand = Random(0, UBound($OpenList) - 1, 1); on en prend un au hasard
        $X2 = StringSplit($OpenList[$rand], ",")[1]
        $Y2 = StringSplit($OpenList[$rand], ",")[2]

        Switch $X2; on casse les murs joignant les deux cellules
            Case $X + 1
                $aLaby[$X2][$Y2] = 7
                $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 13)
            Case $X - 1
                $aLaby[$X2][$Y2] = 13
                $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 7)
            Case $X
                Switch $Y2
                    Case $Y + 1
                        $aLaby[$X2][$Y2] = 11
                        $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 14)
                    Case $Y - 1
                        $aLaby[$X2][$Y2] = 14
                        $aLaby[$X][$Y] = BitAND($aLaby[$X][$Y], 11)
                EndSwitch
        EndSwitch

        _ArrayDelete($OpenList, $rand); on eleve ce voisins que l on vient de visiter
        ;_ArrayDisplay($aLaby)
        $X = $X2;on utilise la cellule que l'on vient de visiter comme cellule courante
        $Y = $Y2
        $Fin = False; on remet le boolean a false pour pouvoir recommencer l opération et voir si notre cellule courante a des voisins. Si c'est une impasse, elle reviendra par ici

    Until UBound($OpenList) = 0; tout ça tant que notre liste de tous les voisins n est pas vide
    _ArrayDisplay($aLaby)

    Return $aLaby
EndFunc   ;==>_CreerLaby



Func _Verif($aLaby, $X, $Y)
    If $X >= 0 And $Y >= 0 And $X <= UBound($aLaby) - 1 And $Y <= UBound($aLaby, 2) - 1 And $aLaby[$X][$Y] = 15 Then
        Return $X & "," & $Y
    Else
        Return -1
    EndIf
EndFunc   ;==>_Verif

 

Merci d'avance!