コード例 #1
0
        // recupere Id.
        public int GetId(Vector2 v)
        {
            float positionX = v.X - OriginX;
            float positionY = v.Y - OriginY;
            int   line      = (int)Math.Floor(positionY / TileHeight);
            int   column    = (int)Math.Floor(positionX / TileWidth);

            Noeud n = graph.getNoeud(new Vector2(column, line));

            if (n != null)
            {
                return(n.Indice);
            }
            else
            {
                return(-1);
            }
        }
コード例 #2
0
ファイル: AStar.cs プロジェクト: CorentinGaut/AStarDijkstra
    // Update is called once per frame
    void Update()
    {
        CheckKeys();
        Noeud player = new Noeud(posPlayer.x, posPlayer.y, 0, null, false);

        createMap();

        if (posPlayer.x == randomX && posPlayer.y == randomY)
        {
            nbPoints++;
            text.text = nbPoints + " : Points";
            generatePoint();
            NoeudArrive = new Noeud(randomX, randomY, 0, null, false);
        }
        Noeud arrive = AStarAlgorithme(player, NoeudArrive);

        DessinChemin(arrive);
    }
コード例 #3
0
ファイル: Maths.cs プロジェクト: vintaerj/FasterThanDust
        public static Noeud bestNoeud(List <Noeud> lstNoeuds)
        {
            Noeud noeudBest = null;

            if (lstNoeuds.Count() != 0)
            {
                noeudBest = lstNoeuds[0];
                foreach (var n in lstNoeuds)
                {
                    if (n.CoutF <= noeudBest.CoutF)
                    {
                        noeudBest = n;
                    }
                }
            }

            return(noeudBest);
        }
コード例 #4
0
 private void genererVoisins()
 {
     for (int i = 0, j = 1; i < grille.Count; i++, j++)
     {
         Noeud n = grille[i].GetComponent <Noeud>();
         if (j % colonne == 0)             // S'il n'y a pas de noeuds à droite
         {
             if (i + colonne < colonne * ligne)
             {
                 n.addVoisin(grille[i + colonne]);                                                // Noeud du haut
             }
             if (i - colonne >= 0)
             {
                 n.addVoisin(grille[i - colonne]); // Noeud du bas
             }
             n.addVoisin(grille[i - 1]);           // Noeud de gauche
         }
         else if (j % colonne == 1)                // S'il n'y a pas de noeuds à gauche
         {
             if (i + colonne < colonne * ligne)
             {
                 n.addVoisin(grille[i + colonne]);                                                // Noeud du haut
             }
             if (i - colonne >= 0)
             {
                 n.addVoisin(grille[i - colonne]);       // Noeud du bas
             }
             n.addVoisin(grille[i + 1]);                 // Noeud à droite
         }
         else
         {
             if (i + colonne < colonne * ligne)
             {
                 n.addVoisin(grille[i + colonne]);                                                // Noeud du haut
             }
             if (i - colonne >= 0)
             {
                 n.addVoisin(grille[i - colonne]);       // Noeud du bas
             }
             n.addVoisin(grille[i - 1]);                 // Noeud de gauche
             n.addVoisin(grille[i + 1]);                 // Noeud de droite
         }
     }
 }
コード例 #5
0
    /// <summary>
    /// Méthode qui va dessiner la grille avec les bonnes couleurs incluant le chemin s'il en existe un.
    /// </summary>
    void OnDrawGizmos()
    {
        //Gizmos.DrawWireCube(transform.position, new Vector3(dimensionMonde.x, dimensionMonde.y, 1));

        construireGrille(); //construction de la grille
                            //pour que ça marche, il faut que le script PathFinding soit rattaché au même GameObject que le script Grille
        PathFinding pathFinding = GetComponent <PathFinding>();

        GameObject depart  = GameObject.Find("Depart");  //trouve le joueur qui est le point de départ
        GameObject arrivee = GameObject.Find("Arrivee"); //trouve l'arrivée

        //on demande à la classe Pathfinding de trouver le chemin
        pathFinding.trouverCheminGizmos(depart.transform.position, arrivee.transform.position, this);

        if (grille != null) //si la grille a bel et bien été créé
        {
            Noeud noeudPlayer = noeudVsPoint(player.position);

            foreach (Noeud n in grille)   //pour tous les noeuds de la grille
            {
                if (n.walkable)           //si le noeud est marchable
                {
                    if (noeudPlayer == n) //si c'est le joueur
                    {
                        Gizmos.color = Color.cyan;
                    }
                    else if (chemin != null && chemin.Contains(n)) //si le noeud fait partie du chemin trouvé
                    {
                        Gizmos.color = Color.black;
                    }
                    else  //si ce n'est qu'une tuile marchable qui n'est pas dans le chemin trouvé
                    {
                        Gizmos.color = Color.clear;
                    }
                }
                else //si c'est un obstacle
                {
                    Gizmos.color = Color.red;
                }
                //on dessine un cube à la position de notre noeud et de la bonne dimension.
                Gizmos.DrawCube(n.position, Vector3.one * (diametreNoeud - .1f));
            }
        }
    }
コード例 #6
0
 private Noeud recAdd(Noeud a, int x)
 {
     if (a == null)
     {
         Noeud t = new Noeud();
         t.value = x;
         t.fg    = t.fd = null;
         return(t);
     }
     if (x < a.value)
     {
         a.fg = recAdd(a.fg, x);
     }
     else
     {
         a.fd = recAdd(a.fd, x);
     }
     return(a);
 }
コード例 #7
0
    public override int Jouer(Position p)
    {
        racine = new Noeud(null, p);
        Stopwatch t0 = Stopwatch.StartNew();

        for (int i = 0; i < n; i++)
        {
            // Sélection
            Noeud no = racine;
            //no.cross = 0;
            do
            {
                no.CalculMeilleurFils(a);
                no = no.MeilleurFils();
            } while (no.fils.Length > 0 && no.cross > 0);
            // Simulation
            Resultat res = JeuHasard(no.p);
            int      re  = p.j1aletrait ? 0 : 1;
            if (res == Resultat.j1gagne)
            {
                re = 1;
            }
            if (res == Resultat.j0gagne)
            {
                re = 0;
            }
            // Rétropropagation
            while (no != null)
            {
                no.cross += 1;
                no.win   += re;
                no        = no.pere;
            }
            Temps = (int)t0.ElapsedMilliseconds;
            if (Temps > 1000)
            {
                break;
            }
        }
        racine.CalculMeilleurFils(a);
        Console.WriteLine(racine);
        return(racine.indiceMeilleurFils);;
    }
コード例 #8
0
    /// <summary>
    /// méthode qui va remonter la liste de parent pour déterminer le chemin
    /// </summary>
    /// <param name="depart">Depart.</param>
    /// <param name="arrivee">Arrivee.</param>
    private void tracerChemin(Noeud depart, Noeud arrivee)
    {
        List <Noeud> chemin       = new List <Noeud> ();
        Noeud        noeudCourant = arrivee; //on place notre noeud courant sur la tuile d'arrivée


        while (noeudCourant.parent != depart)         //on remonte la chaine de parent jusqu'à la tuile de départ
        {
            chemin.Add(noeudCourant);
            noeudCourant = noeudCourant.parent;
        }


        chemin.Add(noeudCourant);  //on oublie pas d'ajouter la tuile de départ dans notre chemin

        chemin.Reverse();          //on inverse pour que le chemin commence à la tuile de départ

        grille.chemin = chemin;    //on indique à l'objet grille quel est le chemin puisque c'est cet objet qui va dessiner la grille contenant le chemin
    }
コード例 #9
0
    /// <summary>
    /// TraitementVoisin
    /// Si il y a une voisin et que sont état est nonVisiter,
    /// change l'état du voisin pour enTraitement(marquer),
    /// calcule la distance entre le voisin et la case départ,
    /// ajout le noeud présentement analysé comme étant le père du voisin.
    /// </summary>
    /// <param name="voisin"> Noeud du voisin</param>
    /// <param name="head"> Noeud présentement analysé </param>
    private void TraitementVoisin(Noeud voisin, Noeud head)
    {
        if (voisin != null)
        {
            if (voisin.State == 1)
            {
                voisin.State = 4;
                ChangeState(voisin);

                if (head.Distance + 1 < voisin.Distance) // +1 parce que la distance des arrêtes entre les noeuds dans un labyrinth sont toujours égales.
                {
                    voisin.Distance = head.Distance + 1;
                }
                voisin.Pere = head;

                file.Enqueue(voisin);
            }
        }
    }
コード例 #10
0
        public void inverser()
        {
            Noeud nouvelleTete = new Noeud(tete.Val);
            Noeud parcour      = tete;

            //dernier = nouvelleTete;
            while ((parcour = parcour.succ) != null)
            {
                Noeud temp = new Noeud(nouvelleTete);
                nouvelleTete      = new Noeud(parcour.Val);
                nouvelleTete.succ = new Noeud(temp);
            }

            tete = new Noeud(nouvelleTete);
            for (Noeud i = tete; i != null; i = i.succ)
            {
                dernier = i;
            }
        }
コード例 #11
0
ファイル: labyrinthe.cs プロジェクト: dave26540/CodingGame
 public string dir(Noeud n1, Noeud n2)
 {
     if (n1.x > n2.x)
     {
         return("LEFT");
     }
     else if (n1.x < n2.x)
     {
         return("RIGHT");
     }
     else if (n1.y < n2.y)
     {
         return("DOWN");
     }
     else if (n1.y > n2.y)
     {
         return("UP");
     }
     return("");
 }
コード例 #12
0
ファイル: AStar.cs プロジェクト: CorentinGaut/AStarDijkstra
    Noeud AStarAlgorithme(Noeud noeudDepart, Noeud noeudArrive)
    {
        //--------------initialisation--------------
        List <Noeud> Testes       = new List <Noeud>();
        List <Noeud> noeudAtester = new List <Noeud>();

        noeudAtester.Add(noeudDepart);
        //--------------depart de l'algo--------------
        while (noeudAtester.Count > 0)
        {
            //--------------cout minimum de la list--------------
            Noeud s1 = choixDistancePlusPetite(noeudAtester);
            noeudAtester.Remove(s1);

            Testes.Add(s1);

            //--------------list des voisins de s1--------------
            List <Noeud> voisinsS1 = voisins(s1, Testes);

            //--------------test si neoud arrive--------------
            if (s1.x == noeudArrive.x && s1.y == noeudArrive.y)
            {
                return(s1);
            }

            //--------------mise a jour de la distance--------------
            foreach (Noeud s2 in voisinsS1)
            {
                if (!noeudAtester.Contains(s2) && !Testes.Contains(s2))
                {
                    int heuristique = Mathf.Max(Mathf.Abs(s2.x - noeudArrive.x), Mathf.Abs(s2.y - noeudArrive.y));
                    s2.distance    = s1.distance + 1;
                    s2.heuristique = heuristique;
                    map.SetTile(new Vector3Int(s2.x, s2.y, 0), visite);
                    noeudAtester.Add(s2);
                    graphe[s2.x, s2.y].parent = s1;
                }
            }
        }
        return(null);
    }
コード例 #13
0
ファイル: Menu3.cs プロジェクト: olga-czc/3A4_ArbreBin
        static partial void Menu3()
        {
            if (STEP <= 3000)
            {
                return;
            }

            MenuGénéral.MenuItems.AddRange(new[] {
                MenuItem.Spacer,
                new MenuItem("Stats 3"),
                new MenuItem("3 Sans benchmarks", () => MenuArbres.Show(false, 3), false),
                new MenuItem("3 Avec benchmarks", () => MenuArbres.Show(true, 3), false),
            });

            // Exemple de code pour le PPT
            if (Convert.ToBoolean(0))
            {
                var arbre = new Noeud(1);
                PréOrdre(arbre, n => n.Value++);
            }
        }
コード例 #14
0
 private void recAfficheAppartient(Noeud noeud, int a, int b)
 {
     if (noeud == null)
     {
         return;
     }
     if (noeud.value >= a && noeud.value <= b)
     {
         Console.WriteLine(noeud.value);
         recAfficheAppartient(noeud.fg, a, b);
         recAfficheAppartient(noeud.fd, a, b);
     }
     else if (noeud.value < a)
     {
         recAfficheAppartient(noeud.fd, a, b);
     }
     else
     {
         recAfficheAppartient(noeud.fg, a, b);
     }
 }
コード例 #15
0
ファイル: labyrinthe.cs プロジェクト: dave26540/CodingGame
    public override string ToString()
    {
        string s = "KX:" + this.KX + ", KY: " + this.KY + "\n";

        Noeud p = this.getNoeudSalleCommande();

        if (p != null)
        {
            s += "Position de la salle de controle : X" + p.x + ", Y: " + p.y + "\n";
        }
        for (int y = 0; y < nbRow; y++)
        {
            for (int x = 0; x < nbCol; x++)
            {
                //Console.Error.WriteLine(x + " " + y + "=" + data[y].Length + "="+ nbCol);
                s += getCell(x, y);
            }
            s += "\n";
        }
        return(s);
    }
コード例 #16
0
ファイル: PlayerInput.cs プロジェクト: hafewa/pathfinding
    public void btnObstacle()
    {
        if (noeud != null)
        {
            Renderer rend = noeud.GetComponent <Renderer>();
            rend.material.color = Color.black;
            Noeud n = noeud.GetComponent <Noeud>();
            n.setLibre(false);
            obstacles.Add(noeud);
            if (noeud == noeudDepart)
            {
                noeudDepart = null;
            }
            if (noeud == noeudArrivee)
            {
                noeudArrivee = null;
            }
            noeud = null;
        }
        UnitSelectionComponent selection = gameObject.GetComponent <UnitSelectionComponent>();
        List <Transform>       selected  = selection.getSelectedObjects();

        foreach (Transform nd in selected)
        {
            Renderer rend = nd.GetComponent <Renderer>();
            rend.material.color = Color.black;
            Noeud n = nd.GetComponent <Noeud>();
            n.setLibre(false);
            obstacles.Add(nd);
            if (nd == noeudDepart)
            {
                noeudDepart = null;
            }
            if (nd == noeudArrivee)
            {
                noeudArrivee = null;
            }
        }
        selection.clearSelections();
    }
コード例 #17
0
ファイル: labyrinthe.cs プロジェクト: dave26540/CodingGame
    public Noeud getNoeudLePlusProcheNonDiscoveredAndAccessible(Boolean esquive = false)
    {
        var n = getNoeudPlayer();

        List <Noeud> notDiscovered = new List <Noeud>();

        for (int y = 0; y < nbRow; y++)
        {
            for (int x = 0; x < nbCol; x++)
            {
                if (getCell(x, y) == '.' && !getNoeud(x, y).isVisited)
                {
                    notDiscovered.Add(getNoeud(x, y));
                }
            }
        }
        notDiscovered = notDiscovered.OrderBy(x => heuristic(n, x)).ToList();
        //  Console.WriteLine(notDiscovered.Count());
        //On peut les atteindre ???

        Noeud dest = null;

        foreach (Noeud n1 in notDiscovered)
        {
            Console.Error.WriteLine("Player : x:" + n.x + " y:" + n.y);
            Console.Error.WriteLine("N1 :" + n1.x + ", " + n1.y);
            List <Noeud> nfind = Maze.cheminLePlusCourt(this, n, n1, esquive);
            if (nfind != null)
            {
                //      Console.WriteLine("Player : x:" + n.x + " y:" + n.y);
                //     Console.WriteLine("Dest : X : " + n1.x + ",Y:" + n1.y);
                //    Console.WriteLine("Find[0]: " + nfind[0].x + " " + nfind[0].y);
                //   Console.WriteLine("Find[1]: " +nfind[1].x +" " + nfind[1].y );
                dest = nfind[1];
                break;
            }
        }
        return(dest);
    }
コード例 #18
0
ファイル: Dijstra.cs プロジェクト: CorentinGaut/AStarDijkstra
    // Update is called once per frame
    void Update()
    {
        Noeud noeudPoints = new Noeud(NoeudArrive.x, NoeudArrive.y, int.MaxValue, null, false);

        createMap();
        CheckKeys();

        Noeud player = new Noeud(posPlayer.x, posPlayer.y, 0, null, false);

        NoeudDepart = player;

        if (posPlayer.x == noeudPoints.x && posPlayer.y == noeudPoints.y)
        {
            nbPoints++;
            text.text   = nbPoints + " : Points";
            noeudPoints = generatePoint();
            NoeudArrive = noeudPoints;
        }
        Noeud arrive = Dijkstra(player, noeudPoints);

        DessinChemin(arrive);
    }
コード例 #19
0
ファイル: labyrinthe.cs プロジェクト: dave26540/CodingGame
    public List <Noeud> voisins(Noeud n)
    {
        List <Noeud> retour = new List <Noeud>();

        if (CanGoRight(n))
        {
            retour.Add(getNoeudRight(n));
        }
        if (CanGoLeft(n))
        {
            retour.Add(getNoeudLeft(n));
        }
        if (CanGoBottom(n))
        {
            retour.Add(getNoeudBottom(n));
        }
        if (CanGoUp(n))
        {
            retour.Add(getNoeudUp(n));
        }
        return(retour);
    }
コード例 #20
0
    private static bool GenerateSecretNodeNextToLastKey()
    {
        //Get Last Obstacle
        int i = criticalpathLength - 1;

        while (i > 0 && nodes[i].type != Noeud.TYPE_DE_NOEUD.OBSTACLE)
        {
            i--;
        }

        if (i > 0)
        {
            i = nodes[i].liens.First(lien => lien.Key != i + 1 && lien.Key != i - 1).Key;
            while (nodes[i].liens.ContainsKey(i + 1))
            {
                i++;
            }

            Vector2Int secretRoomDirection = NewDirection(nodes[i].position, nodes[i].position - nodes[i - 1].position);
            if (secretRoomDirection != Vector2Int.zero)
            {
                Noeud secretNode = new Noeud(nodes[i].position + secretRoomDirection, Noeud.TYPE_DE_NOEUD.SECRET);
                nodes[i].liens.Add(nodes.Count, Noeud.TYPE_DE_LIEN.SECRET);
                secretNode.liens.Add(i, Noeud.TYPE_DE_LIEN.SECRET);
                nodes.Add(secretNode);
                return(true);
            }
            else
            {
                return(false);
            }
        }
        else
        {
            Debug.LogError("Obstacle not found on critical path by secretroom");
            return(false);
        }
    }
コード例 #21
0
ファイル: Grille.cs プロジェクト: boumi21/Pixel-Shooter-Team
    /// <summary>
    /// Cette méthode va construire notre grille de noeud
    /// </summary>
    private void construireGrille()
    {
        diametreNoeud    = rayonNoeud * 2;
        dimensionGrilleX = Mathf.RoundToInt(generation.longueur / diametreNoeud);
        dimensionGrilleY = Mathf.RoundToInt(generation.hauteur / diametreNoeud);

        grille = new Noeud[dimensionGrilleX, dimensionGrilleY];

        Vector3 noeudBasGauche = transform.position - Vector3.right * dimensionMonde.x / 2 - Vector3.up * dimensionMonde.y / 2;

        for (int x = 0; x < dimensionGrilleX; x++)
        {
            for (int y = 0; y < dimensionGrilleY; y++)
            {
                Vector3 point = noeudBasGauche + Vector3.right * (x * diametreNoeud + rayonNoeud) + Vector3.up * (y * diametreNoeud + rayonNoeud);
                //la prochaine ligne vérifie si la tuile évaluée entre en collision avec un des cubes.  Si c'est le cas, la tuile ne sera pas marchable
                bool marchable = !(Physics.CheckSphere(point, rayonNoeud, impossibleMarcherMasque));
                //on créer un noeud que l'on place dans notre monde
                //notre noeud sait s'il est marchable, connait sa position à l'aide d'un vector3 et sait sa position par rapport à la grille
                grille [x, y] = new Noeud(marchable, point, x, y);
            }
        }
    }
コード例 #22
0
 private Noeud findrec(Noeud racine, int x)
 {
     if (racine == null)
     {
         return(null);
     }
     if (racine.value > x)
     {
         return(findrec(racine.fg, x));
     }
     else if (racine.value < x)
     {
         return(findrec(racine.fd, x));
     }
     else if (racine.value == x)
     {
         return(racine);
     }
     else
     {
         return(null);
     }
 }
コード例 #23
0
ファイル: PlayerInput.cs プロジェクト: hafewa/pathfinding
 public void btnNoeudDepart()
 {
     if (noeud != null)
     {
         Noeud n = noeud.GetComponent <Noeud>();
         if (n.isLibre())
         {
             if (noeudDepart == null)
             {
                 Renderer rend = noeud.GetComponent <Renderer>();
                 rend.material.color = Color.red;
             }
             else
             {
                 Renderer rend = noeudDepart.GetComponent <Renderer>();
                 rend.material.color = Color.white;
                 rend = noeud.GetComponent <Renderer>();
                 rend.material.color = Color.red;
             }
             noeudDepart = noeud;
             noeud       = null;
         }
     }
 }
コード例 #24
0
ファイル: PlayerInput.cs プロジェクト: hafewa/pathfinding
 public void btnNoeudArrivee()
 {
     if (noeud != null)
     {
         Noeud n = noeud.GetComponent <Noeud>();
         if (n.isLibre())
         {
             if (noeudArrivee == null)
             {
                 Renderer rend = noeud.GetComponent <Renderer>();
                 rend.material.color = Color.yellow;
             }
             else
             {
                 Renderer rend = noeudArrivee.GetComponent <Renderer>();
                 rend.material.color = Color.white;
                 rend = noeud.GetComponent <Renderer>();
                 rend.material.color = Color.yellow;
             }
             noeudArrivee = noeud;
             noeud        = null;
         }
     }
 }
コード例 #25
0
 public Vector2 getNearest(GameObject origine, GameObject cible)
 {/*
   * List<Noeud> resultat = new List<Noeud>();
   * target = cible.transform.position;
   */
     target               = cible.transform.position;
     colliderSize         = origine.GetComponent <CircleCollider2D>().radius;
     arbre                = new Noeud();
     arbre.position       = origine.transform.position;
     arbre.distanceSource = 0;
     arbre.distanceTarget = Vector2.Distance(origine.transform.position, cible.transform.position);
     if (!calculerNoeud(arbre))
     {
         if (state)//arbre.left.distanceSource+ arbre.left.distanceTarget < arbre.right.distanceSource+ arbre.right.distanceTarget)
         {
             return(arbre.left.position);
         }
         else
         {
             return(arbre.right.position);
         }
     }
     return(cible.transform.position);// arbre[next].position;
 }
コード例 #26
0
ファイル: PlayerInput.cs プロジェクト: hafewa/pathfinding
    public void btnEnleveObstacle()
    {
        if (noeud != null)
        {
            Renderer rend = noeud.GetComponent <Renderer>();
            rend.material.color = Color.white;
            Noeud n = noeud.GetComponent <Noeud>();
            n.setLibre(true);
            obstacles.Remove(noeud);
            noeud = null;
        }
        UnitSelectionComponent selection = gameObject.GetComponent <UnitSelectionComponent>();
        List <Transform>       selected  = selection.getSelectedObjects();

        foreach (Transform nd in selected)
        {
            Renderer rend = nd.GetComponent <Renderer>();
            rend.material.color = Color.white;
            Noeud n = nd.GetComponent <Noeud>();
            n.setLibre(true);
            obstacles.Remove(nd);
        }
        selection.clearSelections();
    }
コード例 #27
0
    // distance a vol d oiseau
    static float heuristic_cost_estimate(Noeud thestart, Noeud thegoal)
    {
        // Troncature ??
        /*int calc1 = thestart / 3;
        int calc2 = thestart % 3;
        int calc3 = thegoal / 3;
        int calc4 = thegoal % 3;

        return sqrt((calc3 - calc1)*(calc3 - calc1) + (calc4 - calc2)*(calc4 - calc2));*/
        return Vector3.Distance(thestart.position, thegoal.position);
    }
コード例 #28
0
 public Noeud(T val)
 {
     Val  = val;
     succ = null;
 }
コード例 #29
0
        void Xblood_Finished(object sender, EventArgs e)
        {
            timer1.Stop();
            lblLeaf.Text = X.leafs.ToString();
            lblBranches.Text = X.branches.ToString();
            lblResult.Text = "Charge l'arborescence...";

            Thread.Sleep(10);
            n = (Noeud)sender;

            //try
            //{
            //    muteur.WaitOne();
            //}
            //catch (AbandonedMutexException)
            //{
            //    muteur.ReleaseMutex();
            //    muteur.WaitOne();
            //}
            this.Invoke(KickTreeView);
            //muteur.ReleaseMutex();
        }
コード例 #30
0
 TreeNode Sousnoeuds(Noeud nodePK)
 {
     TreeNode Tnode = new TreeNode(nodePK.Nom);
     foreach (Noeud n in nodePK.ChildNodes)
     {
         TreeNode nodeTV = new TreeNode(n.Nom);
         if (n.ChildNodes.Count > 0)
         {
             TreeNode sousnoeud = Sousnoeuds(n);
             Tnode.Nodes.Add(sousnoeud);
         }
         else
             Tnode.Nodes.Add(nodeTV);
     }
     return Tnode;
 }
コード例 #31
0
 void LoadTV(Noeud n)
 {
     TVr閟ultat.Nodes.Clear();
     if (n != null)
     {
         TreeNode root = Sousnoeuds(n);
         TVr閟ultat.Nodes.Add(root);
     }
     lblResult.Text = "Fini!";
     lbrecordmin.Text = "Mini: " + X.recordmin.ToString();
     lbrecordmax.Text = "Maxi: " + X.recordmax.ToString();
     btChercher.Enabled = true;
     btStop.Enabled = false;
 }
コード例 #32
0
    /// <summary>
    /// C'est dans cette méthode qu'est implanté notre algorithme A*
    /// </summary>
    /// <param name="startPos">la position de notre tuile de départ</param>
    /// <param name="targetPos">la position de notre tuile d'arrivée</param>
    public void trouverChemin(Vector3 startPos, Vector3 targetPos)
    {    //on trouve les noeuds associés à nos positions
        Noeud noeudDepart  = grille.noeudVsPoint(startPos);
        Noeud noeudArrivee = grille.noeudVsPoint(targetPos);

        print("Je passe");

        List <Noeud> openList   = new List <Noeud> ();
        List <Noeud> closedList = new List <Noeud> ();

        openList.Add(noeudDepart);

        while (openList.Count > 0)                   //tant qu'il nous reste des noeuds à évaluer
        {
            Noeud noeudCourant = openList [0];       // on prend le premier noeud de la liste

            for (int i = 1; i < openList.Count; i++) //s'il y a plus d'un noeud dans la liste, on détermine celui au coût le plus bas
            {
                int fCost = openList [i].fCost();
                int hCost = openList [i].hCost;

                if (fCost < noeudCourant.fCost() || (fCost == noeudCourant.fCost() && hCost < noeudCourant.hCost))
                {
                    noeudCourant = openList[i];
                }
            }

            openList.Remove(noeudCourant);    //retire le noeud de la liste a évaluer
            closedList.Add(noeudCourant);     //on le rajoute dans la liste de ceux déjà évalué

            if (noeudCourant == noeudArrivee) //si nous avons trouvé la tuile d'arrivée
            {
                return;                       //on termine la fonction
            }
            else
            {
                List <Noeud> voisins = grille.retourneVoisins(noeudCourant);                //on trouve les voisins de notre noeud

                foreach (Noeud voisin in voisins)
                {
                    if (!voisin.walkable || closedList.Contains(voisin))                     //s'il n'est pas marchable ou s'il est déjà dans la closed list
                    {
                        continue;
                    }
                    //recalculer le coût de ce noeud
                    int nouveauGCost = noeudCourant.gCost + getDistance(noeudCourant, voisin);
                    //si notre nouveau calcul arrive à un coût plus bas, ou si c'est la première que l'on calcul son coût
                    if (nouveauGCost < voisin.gCost || !openList.Contains(voisin))
                    {                    //attribuer les coût à notre voisin
                        voisin.gCost = nouveauGCost;
                        voisin.hCost = getDistance(voisin, noeudArrivee);
                        //conserver en mémoire qui est son parent
                        voisin.parent = noeudCourant;

                        if (!openList.Contains(voisin))                         //l'ajouter au besoin dans la open list
                        {
                            openList.Add(voisin);
                        }
                    }
                }
            }
        }
    }
コード例 #33
0
 public Liste()
 {
     tete    = null;
     dernier = null;
 }
コード例 #34
0
    /**
     * Return the path to follow in the right order
     */
    static List<Noeud> reconstruct_path(Dictionary<Noeud,Path> labyrinthe, Noeud current)
    {
        List<Noeud> theConvertedPath = new List<Noeud>();

        if (labyrinthe[current].comeFrom != null)
        {
           // Noeud test = labyrinthe[current.Value.comeFrom];
            theConvertedPath.AddRange(reconstruct_path(labyrinthe,labyrinthe[current].comeFrom));

            theConvertedPath.Add(current);
        }

        //Debug.Log (theConvertedPath.Count);
        return theConvertedPath;
    }
コード例 #35
0
    // Update is called once per frame
    void Update()
    {
        if (aggresser)/************************************************************************/
        {
            /*if(premiereFois)
             * {
             *  noeudAvantAttaque = grille.noeudVsPoint(transform.position);
             *  posAvantAttaque = transform.position;
             *  premiereFois = false;
             * }*/


            positionCible = GameObject.Find("Hero").transform.position;

            if (transform.position != positionCible)
            {
                noeudDepart  = grille.noeudVsPoint(transform.position);
                noeudArriver = grille.noeudVsPoint(positionCible);
                if (noeudArriver.walkable && noeudDepart != noeudArriver)
                {
                    pathfinder.trouverChemin(noeudDepart, noeudArriver);
                    pointActuel = 0;
                }
            }
            if (pointActuel != grille.chemin.Count)
            {
                Vector3 target    = grille.chemin[pointActuel].position;
                Vector3 direction = target - transform.position;
                if (direction.magnitude < .1)
                {
                    pointActuel++;
                }
                else
                {
                    transform.position = Vector3.MoveTowards(transform.position, target, vitesse * Time.deltaTime);
                }
            }

            /********************************************************/
        }

        /*if (!aggresser && !enChemin && retourAttaque) /***************************************************************************
         * {
         *  positionCible = posAvantAttaque;
         *  if (transform.position != positionCible)
         *  {
         *      noeudDepart = grille.noeudVsPoint(transform.position);
         *      noeudArriver = grille.noeudVsPoint(positionCible);
         *      if (noeudArriver.walkable && noeudDepart != noeudArriver)
         *      {
         *
         *          pathfinder.trouverChemin(noeudDepart, noeudArriver);
         *          pointActuel = 0;
         *      }
         *  }
         *  if (pointActuel != grille.chemin.Count)
         *  {
         *      Vector3 target = grille.chemin[pointActuel].position;
         *      Vector3 direction = target - transform.position;
         *      if (direction.magnitude < .1)
         *          pointActuel++;
         *      else
         *          transform.position = Vector3.MoveTowards(transform.position, target, vitesse * Time.deltaTime);
         *
         *
         *  }
         * }*/



        /*if (enChemin && !aggresser && !retourAttaque)/***************************************************************************
         * {
         *  positionCible = manager.positionsTabs[numeroAdversaire - 1];
         *  if (transform.position != positionCible)
         *  {
         *      noeudDepart = grille.noeudVsPoint(transform.position);
         *      noeudArriver = grille.noeudVsPoint(manager.positionsTabs[numeroAdversaire -1 ]);
         *      if (noeudArriver.walkable && noeudDepart != noeudArriver)
         *      {
         *
         *          pathfinder.trouverChemin(noeudDepart, noeudArriver);
         *          pointActuel = 0;
         *      }
         *  }
         *  if (pointActuel != grille.chemin.Count)
         *  {
         *      Vector3 target = grille.chemin[pointActuel].position;
         *      Vector3 direction = target - transform.position;
         *      if (direction.magnitude < .1)
         *          pointActuel++;
         *      else
         *          transform.position = Vector3.MoveTowards(transform.position, target, vitesse * Time.deltaTime);
         *
         *
         *  }
         *
         * }*/
    }
コード例 #36
0
    /* Prend trop de temps !
    public static void resetNoeud(Noeud noeud, List<Noeud> noeudFais)
    {
        noeud.comeFrom = null;
        noeud.f_score = float.MaxValue;
        noeud.g_score = float.MaxValue;
        noeudFais.Add(noeud);
        foreach(Noeud n in noeud.neighbours)
        {
            if (!noeudFais.Contains(n))
            {
                resetNoeud (n,noeudFais);
            }
        }
    }*/
    public static List<Noeud> aStar(Noeud startNoeud, Noeud goalNoeud)
    {
        if (startNoeud == null || goalNoeud == null)
        {
            Debug.Log(startNoeud + " et " + goalNoeud);
            return null;
        }

        //Noeud theStart = new Noeud(noeudStart);
           // Noeud theGoal = new Noeud(noeudGoal);

        // INITIALISATION
        //resetNoeud (theStart,new List<Noeud>());
        Dictionary<Noeud,Path>  closedset = new Dictionary<Noeud,Path> ();
        Dictionary<Noeud,Path>  openset = new Dictionary<Noeud,Path> ();

           // Noeud startPath = new Noeud(noeudStart);
        Path startPath = new Path();
        startPath.g_score = 0;
        startPath.f_score = startPath.g_score + heuristic_cost_estimate(startNoeud, goalNoeud);
        openset.Add(startNoeud,startPath);

        // START
        while (openset.Count > 0)
        {
            // the node in openset having the lowest f_score[] value, the first because it is sorted !
            Path currentPath = openset.First().Value;
            Noeud currentNoeud = openset.First().Key;

            if (currentNoeud == goalNoeud)
            {
                closedset.Add(currentNoeud, currentPath);
                return reconstruct_path(closedset,currentNoeud); // reconstruct_path(came_from, goal);
            }
           // Debug.Log(currentNoeud.position);
            foreach (Noeud n in currentNoeud.neighbours)
            {
               // Debug.Log(currentPath.place.position + " a pour voisin " + c.position);
                if (!closedset.ContainsKey(n))
                {
                    float tentative_g_score = currentPath.g_score + n.myCost;
                    float tentative_f_score = tentative_g_score + heuristic_cost_estimate(n, goalNoeud);

                    if (openset.ContainsKey(n))
                    {
                        if (tentative_f_score < openset[n].f_score)
                        {
                            openset[n].f_score = tentative_f_score;
                            openset[n].g_score = tentative_g_score;
                            openset[n].comeFrom = currentNoeud;
                        }
                    }
                    else
                    {
                        Path newPath = new Path();
                        newPath.f_score = tentative_f_score;
                        newPath.g_score = tentative_g_score;
                        newPath.comeFrom = currentNoeud;

                        openset.Add(n, newPath);
                    }
                }
            }
            /*
            int gch;
            int dr;
            int bas;
            int haut;
            CalculVoisinCase(current, gch, dr, bas, haut);
            eachNeighbor(gch);
            eachNeighbor(dr);
            eachNeighbor(bas);
            eachNeighbor(haut);
            */

            closedset.Add(openset.First().Key, openset.First().Value);
            openset.Remove(openset.First().Key);

            // TODO Optimisation sort
            List<KeyValuePair<Noeud, Path>> myList = openset.ToList();
            myList.Sort(
                delegate(KeyValuePair<Noeud, Path> A,
                KeyValuePair<Noeud, Path> B)
                {
                    if (A.Value.f_score == B.Value.f_score)
                    {
                        return 0;
                    }
                    else if (A.Value.f_score > B.Value.f_score)
                    {
                        return 1;
                    }
                    else
                    {
                        return -1;
                    }
                }
            );
            openset.Clear();
            foreach (var person in myList)
            {
                openset.Add(person.Key, person.Value);
            }
            //openset.OrderBy(Path.sort);

        }

        //reconstruct_path();

        Debug.Log("AStar no path");
        return new List<Noeud>();
    }