Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

AStar2D

Hérite de : RefCounted < Object

Une implémentation de A* pour trouver le chemin le plus court entre deux sommets d'un graphe connecté dans l'espace 2D.

Description

Une implémentation de l'algorithme A* pour trouver le chemin le plus court entre deux sommets d'un graphe connecté dans l'espace 2D.

Voir AStar3D pour une explication plus détaillée de comment utiliser cette classe. AStar2D est un wrapper pour AStar3D qui impose des coordonnées 2D.

Tutoriels

Démo de navigation sur une grille avec AStarGrid2D

Propriétés

bool

neighbor_filter_enabled

false

Méthodes

float	_compute_cost(from_id: int, to_id: int) virtual const
float	_estimate_cost(from_id: int, end_id: int) virtual const
bool	_filter_neighbor(from_id: int, neighbor_id: int) virtual const
void	add_point(id: int, position: Vector2, weight_scale: float = 1.0)
bool	are_points_connected(id: int, to_id: int, bidirectional: bool = true) const
void	clear()
void	connect_points(id: int, to_id: int, bidirectional: bool = true)
void	disconnect_points(id: int, to_id: int, bidirectional: bool = true)
int	get_available_point_id() const
int	get_closest_point(to_position: Vector2, include_disabled: bool = false) const
Vector2	get_closest_position_in_segment(to_position: Vector2) const
PackedInt64Array	get_id_path(from_id: int, to_id: int, allow_partial_path: bool = false)
int	get_point_capacity() const
PackedInt64Array	get_point_connections(id: int)
int	get_point_count() const
PackedInt64Array	get_point_ids()
PackedVector2Array	get_point_path(from_id: int, to_id: int, allow_partial_path: bool = false)
Vector2	get_point_position(id: int) const
float	get_point_weight_scale(id: int) const
bool	has_point(id: int) const
bool	is_point_disabled(id: int) const
void	remove_point(id: int)
void	reserve_space(num_nodes: int)
void	set_point_disabled(id: int, disabled: bool = true)
void	set_point_position(id: int, position: Vector2)
void	set_point_weight_scale(id: int, weight_scale: float)

Descriptions des propriétés

bool neighbor_filter_enabled = false 🔗

void set_neighbor_filter_enabled(value: bool)
bool is_neighbor_filter_enabled()

Si true, active le filtrage des voisins via _filter_neighbor().

Descriptions des méthodes

float _compute_cost(from_id: int, to_id: int) virtual const 🔗

Appelée lors du calcul du coût entre deux points connectés.

À noter que cette fonction est cachée dans la classe AStar2D par défaut.

float _estimate_cost(from_id: int, end_id: int) virtual const 🔗

Appelée lors du calcul du coût entre un point et le point final du chemin.

À noter que cette fonction est cachée dans la classe AStar2D par défaut.

bool _filter_neighbor(from_id: int, neighbor_id: int) virtual const 🔗

Appelée lorsque le voisin commence à être traité et si neighbor_filter_enabled vaut true. Si true est renvoyé, le point ne sera pas traité.

Notez que cette fonction est cachée dans la classe AStar2D par défaut.

void add_point(id: int, position: Vector2, weight_scale: float = 1.0) 🔗

Ajoute un nouveau point à la position spécifiée avec l'identifiant donné. L'identifiant id doit être supérieur ou égal à 0, et le facteur de poids weight_scale doit être supérieur ou égal à 0.0.

Le facteur de poids weight_scale est multiplié par le résultat de _compute_cost() pour déterminer le coût global d'une traversée d'un segment depuis un point voisin jusqu'à ce point. Ainsi, si la distance est la même, l'algorithme préfèrera les points avec le facteur de poids weight_scale le plus bas pour construire le chemin.

var astar = AStar2D.new()
astar.add_point(1, Vector2(1, 0), 4) # Ajoute le point (1, 0) avec le facteur de poids à 4 et l'identifiant 1

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(1, 0), 4); // Ajoute le point (1, 0) avec le facteur de poids à 4 et l'identifiant 1

Si un point existe déjà pour l'identifiant id donné, sa position et son facteur de poids seront mis à jour avec la valeur donnée.

bool are_points_connected(id: int, to_id: int, bidirectional: bool = true) const 🔗

Indique si les deux points donnés sont reliés par un segment ou une connexion. Si bidirectional vaut false, indique si le mouvement de l'identifiant id vers l'autre identifiant to_id est possible par ce segment.

void clear() 🔗

Retire tous les points et segments.

void connect_points(id: int, to_id: int, bidirectional: bool = true) 🔗

Crée un segment entre les points donnés. Si bidirectional vaut false, seul le mouvement de id vers to_id sera autorisé, et non le sens inverse.

var astar = AStar2D.new()
astar.add_point(1, Vector2(1, 1))
astar.add_point(2, Vector2(0, 5))
astar.connect_points(1, 2, false)

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(1, 1));
astar.AddPoint(2, new Vector2(0, 5));
astar.ConnectPoints(1, 2, false);

void disconnect_points(id: int, to_id: int, bidirectional: bool = true) 🔗

Supprime le segment entre les points donnés. Si bidirectional vaut false, seul le mouvement de l'identifiant id vers l'autre identifiant to_id est empêché, et un segment unidirectionnel peut rester.

int get_available_point_id() const 🔗

Renvoie l'identifiant du point disponible suivant avec aucun point lui étant associé.

int get_closest_point(to_position: Vector2, include_disabled: bool = false) const 🔗

Renvoie l'identifiant du point le plus proche de to_position, en prenant en compte les points désactivés en option. Renvoie -1 s'il n'y a pas de points dans l'ensemble de points.

Note : Si plusieurs points sont proches de to_position, celui avec le plus petit identifiant sera renvoyé, permettant d'obtenir un résultat déterministe.

Vector2 get_closest_position_in_segment(to_position: Vector2) const 🔗

Renvoie la position la plus proche de to_position qui est à l'intérieur du segment entre deux points connectés.

var astar = AStar2D.new()
astar.add_point(1, Vector2(0, 0))
astar.add_point(2, Vector2(0, 5))
astar.connect_points(1, 2)
var res = astar.get_closest_position_in_segment(Vector2(3, 3)) # Renvoie (0, 3)

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(0, 0));
astar.AddPoint(2, new Vector2(0, 5));
astar.ConnectPoints(1, 2);
Vector2 res = astar.GetClosestPositionInSegment(new Vector2(3, 3)); // Renvoie (0, 3)

Le résultat est dans le segment qui va de y = 0 à y = 5. C'est la position la plus proche sur le segment du point donné.

PackedInt64Array get_id_path(from_id: int, to_id: int, allow_partial_path: bool = false) 🔗

Renvoie un tableau avec les identifiants des points qui forment le chemin trouvé par AStar2D entre les points donnés. Le tableau est dans l'ordre du point de départ vers celui de l'arrivée.

Si le point from_id est désactivé, renvoie un tableau vide (même si from_id == to_id).

Si le point from_id n'est pas désactivé, et qu'il n'y a pas de chemin valide vers la cible, et allow_partial_path vauttrue, renvoie le point le proche de la cible qui peut être atteint.

Note : Lorsque allow_partial_path vaut true et to_id est désactivé, la recherche peut prendre un temps inhabituel à se terminer.

var astar = AStar2D.new()
astar.add_point(1, Vector2(0, 0))
astar.add_point(2, Vector2(0, 1), 1) # Le poids par défaut est 1
astar.add_point(3, Vector2(1, 1))
astar.add_point(4, Vector2(2, 0))

astar.connect_points(1, 2, false)
astar.connect_points(2, 3, false)
astar.connect_points(4, 3, false)
astar.connect_points(1, 4, false)

var res = astar.get_id_path(1, 3) # Renvoie [1, 2, 3]

var astar = new AStar2D() ;
astar.AddPoint(1, new Vector2(0, 0)) ;
astar.AddPoint(2, new Vector2(0, 1), 1) ; // Le poids par défaut est 1
astar.AddPoint(3, new Vector2(1, 1)) ;
astar.AddPoint(4, new Vector2(2, 0)) ;

astar.ConnectPoints(1, 2, false) ;
astar.ConnectPoints(2, 3, false) ;
astar.ConnectPoints(4, 3, false) ;
astar.ConnectPoints(1, 4, false) ;
long[] res = astar.GetIdPath(1, 3) ; // Renvoie[1, 2, 3]

Si vous changez le poids du deuxième point à 3, alors le résultat sera [1, 4, 3] à la place, parce que même si la distance est plus grande, c'est plus "facile" d'aller en passant par le point 4 que le point 2.

int get_point_capacity() const 🔗

Renvoie la capacité de la structure qui garde les points en cache, utile avec reserve_space().

PackedInt64Array get_point_connections(id: int) 🔗

Renvoie un tableau avec les identifiants des points qui forment une connexion avec le point donné.

var astar = AStar2D.new()
astar.add_point(1, Vector2(0, 0))
astar.add_point(2, Vector2(0, 1))
astar.add_point(3, Vector2(1, 1))
astar.add_point(4, Vector2(2, 0))

astar.connect_points(1, 2, true)
astar.connect_points(1, 3, true)

var voisins = astar.get_point_connections(1) # Renvoie [2, 3]

var astar = new AStar2D();
astar.AddPoint(1, new Vector2(0, 0));
astar.AddPoint(2, new Vector2(0, 1));
astar.AddPoint(3, new Vector2(1, 1));
astar.AddPoint(4, new Vector2(2, 0));

astar.ConnectPoints(1, 2, true);
astar.ConnectPoints(1, 3, true);

long[] voisins = astar.GetPointConnections(1); // Renvoie [2, 3]

int get_point_count() const 🔗

Renvoie le nombre de points actuellement dans le pool de points.

PackedInt64Array get_point_ids() 🔗

Renvoie un tableau de tous les identifiants des points.

PackedVector2Array get_point_path(from_id: int, to_id: int, allow_partial_path: bool = false) 🔗

Renvoie un tableau avec les points qui sont dans le chemin trouvé par AStar2D entre les points donnés. Le tableau est trié du point de départ au point final du chemin.

Si from_id point est désactivé, retourne un tableau vide (même si from_id == to_id).

Si from_id point n'est pas désactivé, qu''il n'y a pas de chemin valide vers la cible, et allow_partial_path vaut true, renvoie un chemin vers le point le plus proche de la cible qui peut être atteinte.

Note : Cette méthode n'est pas thread-safe, elle ne peut être appelée que depuis un seul Thread à un instant donné. Envisagez d'utiliser des Mutex pour vous assurer de l'accès exclusif à un thread pour éviter des accès concurrents.

De plus, lorsque allow_partial_path vaut true et to_id est désactivé, la recherche peut prendre un temps inhabituellement long pour se terminer.

Vector2 get_point_position(id: int) const 🔗

Renvoie la position du point associé à l'identifiant id donné.

float get_point_weight_scale(id: int) const 🔗

Renvoie le facteur de poids du point associé à l'identifiant id donné.

bool has_point(id: int) const 🔗

Renvoie si un point associé à l'identifiant id donné existe.

bool is_point_disabled(id: int) const 🔗

Renvoie si un point est désactivé ou non pour le calcul du chemin. Par défaut, tous les points sont activés.

void remove_point(id: int) 🔗

Retire le point associé à l'id donné du pool des points.

void reserve_space(num_nodes: int) 🔗

Réserve l'espace interne pour num_nodes points. Utile si vous voulez ajouter un grand nombre de points à la fois, pour une grille par exemple.

void set_point_disabled(id: int, disabled: bool = true) 🔗

Désactive ou active le point spécifié pour le pathfinding. Utile pour faire des obstacles temporaires.

void set_point_position(id: int, position: Vector2) 🔗

Définit la position du point avec l'identifiant id donné.

void set_point_weight_scale(id: int, weight_scale: float) 🔗

Définit le facteur de poids weight_scale pour le point avec l'identifiant id donné. Le facteur de poids weight_scale est multiplié par le résultat de _compute_cost() pour déterminer le coût global de voyage le long d'un segment d'un point voisin à ce point.