Node2D

Eredita: CanvasItem < Node < Object

Ereditato da: AnimatedSprite2D, AudioListener2D, AudioStreamPlayer2D, BackBufferCopy, Bone2D, Camera2D, CanvasGroup, CanvasModulate, CollisionObject2D, CollisionPolygon2D, CollisionShape2D, CPUParticles2D, GPUParticles2D, Joint2D, Light2D, LightOccluder2D, Line2D, Marker2D, MeshInstance2D, MultiMeshInstance2D, NavigationLink2D, NavigationObstacle2D, NavigationRegion2D, Parallax2D, ParallaxLayer, Path2D, PathFollow2D, Polygon2D, RayCast2D, RemoteTransform2D, ShapeCast2D, Skeleton2D, Sprite2D, TileMap, TileMapLayer, TouchScreenButton, VisibleOnScreenNotifier2D

Un oggetto di gioco 2D, ereditato da tutti i nodi riguardanti il 2D. Ha una posizione, una rotazione, una scala e un'inclinazione.

Descrizione

Un oggetto di gioco 2D, con una trasformazione (posizione, rotazione e scala). Tutti i nodi 2D, inclusi gli oggetti di fisica e gli sprite, ereditano da Node2D. Utilizza Node2D come nodo genitore per spostare, scalare e ruotare i figli in un progetto 2D. Offre inoltre il controllo dell'ordine di rendering del nodo.

Nota: Poiché sia Node2D sia Control ereditano da CanvasItem, essi condividono diversi concetti della classe come le proprietà CanvasItem.z_index e CanvasItem.visible.

Tutorial

Proprietà

Vector2	global_position
float	global_rotation
float	global_rotation_degrees
Vector2	global_scale
float	global_skew
Transform2D	global_transform
Vector2	position	`Vector2(0, 0)`
float	rotation	`0.0`
float	rotation_degrees
Vector2	scale	`Vector2(1, 1)`
float	skew	`0.0`
Transform2D	transform

Metodi

void	apply_scale(ratio: Vector2)
float	get_angle_to(point: Vector2) const
Transform2D	get_relative_transform_to_parent(parent: Node) const
void	global_translate(offset: Vector2)
void	look_at(point: Vector2)
void	move_local_x(delta: float, scaled: bool = false)
void	move_local_y(delta: float, scaled: bool = false)
void	rotate(radians: float)
Vector2	to_global(local_point: Vector2) const
Vector2	to_local(global_point: Vector2) const
void	translate(offset: Vector2)

Descrizioni delle proprietà

Vector2 global_position 🔗

void set_global_position(value: Vector2)
Vector2 get_global_position()

La posizione globale. Vedi anche position.

float global_rotation 🔗

void set_global_rotation(value: float)
float get_global_rotation()

Rotazione globale in radianti. Vedi anche rotation.

float global_rotation_degrees 🔗

void set_global_rotation_degrees(value: float)
float get_global_rotation_degrees()

Proprietà di supporto per accedere a global_rotation in gradi anziché in radianti. Vedi anche rotation_degrees.

Vector2 global_scale 🔗

void set_global_scale(value: Vector2)
Vector2 get_global_scale()

Scala globale. Vedi anche scale.

float global_skew 🔗

void set_global_skew(value: float)
float get_global_skew()

Inclinazione globale in radianti. Vedi anche skew.

Transform2D global_transform 🔗

void set_global_transform(value: Transform2D)
Transform2D get_global_transform()

Transform2D globale. Vedi anche transform.

Vector2 position = Vector2(0, 0) 🔗

void set_position(value: Vector2)
Vector2 get_position()

Posizione, relativa al nodo genitore. Vedi anche global_position.

float rotation = 0.0 🔗

void set_rotation(value: float)
float get_rotation()

Rotazione in radianti, relativa al genitore del nodo. Vedi anche global_rotation.

Nota: Questa proprietà è modificata nell'ispettore in gradi. Se vuoi usare i gradi in uno script, usa rotation_degrees.

float rotation_degrees 🔗

void set_rotation_degrees(value: float)
float get_rotation_degrees()

Proprietà ausiliare per accedere a rotation in gradi anziché in radianti. Vedi anche global_rotation_degrees.

Vector2 scale = Vector2(1, 1) 🔗

void set_scale(value: Vector2)
Vector2 get_scale()

La scala del nodo, relativa al genitore del nodo. Valore non scalato: (1, 1). Vedi anche global_scale.

Nota: Le scale X negative in 2D non sono scomponibili dalla matrice di trasformazione. A causa del modo in cui la scala è rappresentata con le matrici di trasformazione in Godot, le scale negative sull'asse X saranno modificate in scale negative sull'asse Y e una rotazione di 180 gradi quando scomposte.

float skew = 0.0 🔗

void set_skew(value: float)
float get_skew()

Se impostato su un valore diverso da zero, inclina il nodo in una direzione o nell'altra. Può essere utilizzato per effetti pseudo-3D. Vedi anche global_skew.

Nota: L'inclinazione viene eseguita solo sull'asse X e tra la rotazione e il ridimensionamento.

Nota: Questa proprietà viene modificata nell'ispettore in gradi. Se è necessario utilizzare i gradi in uno script, usa skew = deg_to_rad(valore_in_gradi).

Transform2D transform 🔗

void set_transform(value: Transform2D)
Transform2D get_transform()

il Transform2D del nodo, relativo al nodo genitore di questo nodo. Vedi anche global_transform.

Descrizioni dei metodi

void apply_scale(ratio: Vector2) 🔗

Moltiplica la scala attuale per il vettore ratio.

float get_angle_to(point: Vector2) const 🔗

Restituisce l'angolo tra il nodo e il punto point in radianti.

Illustrazione dell'angolo restituito.

Transform2D get_relative_transform_to_parent(parent: Node) const 🔗

Restituisce il Transform2D relativo al nodo padre di questo nodo.

void global_translate(offset: Vector2) 🔗

Aggiunge il vettore offset alla posizione globale del nodo.

void look_at(point: Vector2) 🔗

Ruota il nodo in modo che il suo asse +X locale punti verso il punto point, che dovrebbe utilizzare coordinate globali.

point non dovrebbe essere uguale alla posizione del nodo, altrimenti il nodo guarda sempre a destra.

void move_local_x(delta: float, scaled: bool = false) 🔗

Applica una traslazione locale sull'asse X del nodo in base al delta di Node._process(). Se scaled è false, normalizza il movimento.

void move_local_y(delta: float, scaled: bool = false) 🔗

Applica una traslazione locale sull'asse Y del nodo in base al delta di Node._process(). Se scaled è false, normalizza il movimento.

void rotate(radians: float) 🔗

Applica una rotazione al nodo, in radianti, a partire dalla sua rotazione attuale.

Vector2 to_global(local_point: Vector2) const 🔗

Trasforma la posizione locale fornita in una posizione nello spazio di coordinate globali. L'input dovrebbe essere locale rispetto al Node2D su cui viene chiamato. Ad esempio, applicando questo metodo alle posizioni dei nodi figli, le loro posizioni saranno trasformate correttamente nello spazio di coordinate globali, ma applicandolo alla posizione del nodo stesso si otterrà un risultato non corretto, poiché incorporerà la trasformazione del nodo stesso nella sua posizione globale.

Vector2 to_local(global_point: Vector2) const 🔗

Trasforma la posizione globale fornita in una posizione nello spazio delle coordinate locali. L'output sarà locale rispetto al Node2D su cui viene chiamato. Ad esempio, è appropriato per determinare le posizioni dei nodi figli, ma non è appropriato per determinare la propria posizione rispetto al proprio genitore.

void translate(offset: Vector2) 🔗

Trasla il nodo in base a offset specificato in coordinate locali.