// 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);
}
}
// 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);
}
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);
}
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
}
}
}
/// <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));
}
}
}
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);
}
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);;
}
/// <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
}
/// <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);
}
}
}
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;
}
}
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("");
}
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);
}
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++);
}
}
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);
}
}
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);
}
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();
}
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);
}
// 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);
}
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);
}
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);
}
}
/// <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);
}
}
}
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);
}
}
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;
}
}
}
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;
}
}
}
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;
}
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();
}
// 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);
}
public Noeud(T val)
{
Val = val;
succ = null;
}
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();
}
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;
}
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;
}
/// <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);
}
}
}
}
}
}
public Liste()
{
tete = null;
dernier = null;
}
/**
* 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;
}
// 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);
*
*
* }
*
* }*/
}
/* 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>();
}
