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...
Tween
Eredita: RefCounted < Object
Oggetto leggero utilizzato per animazioni generiche tramite script, utilizzando i Tweener.
Descrizione
I tween sono utili soprattutto per le animazioni che richiedono che una proprietà numerica sia interpolata su un intervallo di valori. Il nome tween deriva da in-betweening, una tecnica di animazione in cui si specificano i fotogrammi chiave e il computer interpola i fotogrammi che compaiono tra di essi. L'animazione di qualcosa con un Tween è chiamata tweening.
Tween è più adatto di AnimationPlayer per le animazioni in cui non si conoscono in anticipo i valori finali. Ad esempio, l'interpolazione del valore di zoom di una telecamera scelta dinamicamente è meglio eseguita con un Tween; sarebbe difficile fare la stessa cosa con un nodo AnimationPlayer. I tween sono anche più leggeri di AnimationPlayer, quindi sono molto adatti per animazioni semplici o attività generali che non richiedono modifiche visive fornite dall'editor. Possono essere utilizzati in modalità "usa e getta" per una logica che normalmente sarebbe eseguita dal codice. Ad esempio, puoi far in modo che qualcosa spari periodicamente tramite un CallbackTweener in ripetizione con un ritardo.
Un Tween può essere creato usando SceneTree.create_tween() o Node.create_tween(). I Tween creati manualmente (ad esempio usando Tween.new()) non sono validi e non possono essere usati per interpolare i valori.
Un'animazione tween si crea aggiungendo i Tweener all'oggetto Tween, tramite tween_property(), tween_interval(), tween_callback(), tween_method(), tween_subtween(), o tween_await():
var tween = get_tree().create_tween()
tween.tween_property($Sprite, "modulate", Color.RED, 1.0)
tween.tween_property($Sprite, "scale", Vector2(), 1.0)
tween.tween_callback($Sprite.queue_free)
Tween tween = GetTree().CreateTween();
tween.TweenProperty(GetNode("Sprite"), "modulate", Colors.Red, 1.0f);
tween.TweenProperty(GetNode("Sprite"), "scale", Vector2.Zero, 1.0f);
tween.TweenCallback(Callable.From(GetNode("Sprite").QueueFree));
Questa sequenza farà diventare rosso il nodo $Sprite, poi lo restringerà, prima di chiamare infine Node.queue_free() per liberare lo sprite. I Tweener sono eseguiti uno dopo l'altro come comportamento predefinito. Ciò può essere modificato tramite parallel() e set_parallel().
Quando un Tweener viene creato con uno dei metodi tween_*, è possibile utilizzare una chiamata di metodo concatenata per modificare le proprietà di questo Tweener. Ad esempio, se si desidera impostare un tipo di transizione diverso nell'esempio precedente, è possibile usare set_trans():
var tween = get_tree().create_tween()
tween.tween_property($Sprite, "modulate", Color.RED, 1.0).set_trans(Tween.TRANS_SINE)
tween.tween_property($Sprite, "scale", Vector2(), 1.0).set_trans(Tween.TRANS_BOUNCE)
tween.tween_callback($Sprite.queue_free)
Tween tween = GetTree().CreateTween();
tween.TweenProperty(GetNode("Sprite"), "modulate", Colors.Red, 1.0f).SetTrans(Tween.TransitionType.Sine);
tween.TweenProperty(GetNode("Sprite"), "scale", Vector2.Zero, 1.0f).SetTrans(Tween.TransitionType.Bounce);
tween.TweenCallback(Callable.From(GetNode("Sprite").QueueFree));
Anche la maggior parte dei metodi di Tween possono essere concatenati in questo modo. Nell'esempio seguente, il Tween è associato al nodo dello script in esecuzione ed è impostata una transizione predefinita per i suoi Tweener:
var tween = get_tree().create_tween().bind_node(self).set_trans(Tween.TRANS_ELASTIC)
tween.tween_property($Sprite, "modulate", Color.RED, 1.0)
tween.tween_property($Sprite, "scale", Vector2(), 1.0)
tween.tween_callback($Sprite.queue_free)
var tween = GetTree().CreateTween().BindNode(this).SetTrans(Tween.TransitionType.Elastic);
tween.TweenProperty(GetNode("Sprite"), "modulate", Colors.Red, 1.0f);
tween.TweenProperty(GetNode("Sprite"), "scale", Vector2.Zero, 1.0f);
tween.TweenCallback(Callable.From(GetNode("Sprite").QueueFree));
Un altro uso interessante per i Tween è l'animazione di insiemi arbitrari di oggetti:
var tween = create_tween()
for sprite in get_children():
tween.tween_property(sprite, "position", Vector2(0, 0), 1.0)
Tween tween = CreateTween();
foreach (Node sprite in GetChildren())
tween.TweenProperty(sprite, "position", Vector2.Zero, 1.0f);
Nell'esempio precedente, tutti i figli di un nodo sono spostati uno dopo l'altro nella posizione (0, 0).
Dovresti evitare di usare più di un Tween per proprietà di un oggetto. Se due o più tween animano una proprietà allo stesso tempo, l'ultimo creato avrà la priorità e assegnerà il valore finale. Se vuoi interrompere e riavviare un'animazione, considera di assegnare il Tween a una variabile:
var tween
func animate():
if tween:
tween.kill() # Interrompe l'animazione precedente.
tween = create_tween()
private Tween _tween;
public void Animate()
{
if (_tween != null)
_tween.Kill(); // Interrompe l'animazione precedente.
_tween = CreateTween();
}
Alcuni Tweener usano transizioni e allentamenti. La prima accetta una costante TransitionType e si riferisce al modo in cui viene gestita la tempistica dell'animazione (vedi easings.net per alcuni esempi). La seconda accetta una costante EaseType e controlla dove trans_type viene applicato all'interpolazione (all'inizio, alla fine o in entrambi). Se non sai quale transizione e allentamento scegliere, puoi provare le diverse costanti TransitionType con EASE_IN_OUT e usare quella che sembri la migliore.
Foglio riassuntivo sui tipi di transizione e di allentamento dei Tween
Nota: I Tween non sono progettati per essere riutilizzati e tentare di farlo risulta in comportamento indefinito. Crea un nuovo Tween per ogni animazione e ogni volta che riproduci un'animazione dall'inizio. Tieni presente che i Tween si avviano immediatamente, quindi crea un Tween solo quando vuoi iniziare l'animazione.
Nota: Il Tween è elaborato dopo tutti i nodi nel frame attuale, ovvero il metodo Node._process() del nodo sarebbe chiamato prima del Tween (o Node._physics_process() a seconda del valore passato a set_process_mode()).
Metodi
chain() |
|
custom_step(delta: float) |
|
get_loops_left() const |
|
get_total_elapsed_time() const |
|
has_tweeners() const |
|
interpolate_value(initial_value: Variant, delta_value: Variant, elapsed_time: float, duration: float, trans_type: TransitionType, ease_type: EaseType) static |
|
is_valid() |
|
void |
kill() |
parallel() |
|
void |
pause() |
void |
play() |
set_ignore_time_scale(ignore: bool = true) |
|
set_parallel(parallel: bool = true) |
|
set_pause_mode(mode: TweenPauseMode) |
|
set_process_mode(mode: TweenProcessMode) |
|
set_speed_scale(speed: float) |
|
set_trans(trans: TransitionType) |
|
void |
stop() |
tween_await(signal: Signal) |
|
tween_callback(callback: Callable) |
|
tween_interval(time: float) |
|
tween_method(method: Callable, from: Variant, to: Variant, duration: float) |
|
tween_property(object: Object, property: NodePath, final_val: Variant, duration: float) |
|
tween_subtween(subtween: Tween) |
Segnali
finished() 🔗
Emesso quando il Tween ha terminato tutto il tweening. Non emesso mai quando il Tween è impostato su ciclo infinito (vedi set_loops()).
loop_finished(loop_count: int) 🔗
Emesso quando un ciclo intero è completato (vedi set_loops()), fornendo l'indice del ciclo. Questo segnale non viene emesso dopo il ciclo finale, usa invece finished per questo caso.
Emesso quando un passaggio del Tween è completato, fornendo l'indice del passaggio. Un passaggio è un singolo Tweener o un gruppo di Tweener in esecuzione in parallelo.
Enumerazioni
enum TweenProcessMode: 🔗
TweenProcessMode TWEEN_PROCESS_PHYSICS = 0
Il Tween si aggiorna dopo ogni frame di fisica (vedi Node._physics_process()).
TweenProcessMode TWEEN_PROCESS_IDLE = 1
Il Tween si aggiorna dopo ogni frame di processo (vedi Node._process()).
enum TweenPauseMode: 🔗
TweenPauseMode TWEEN_PAUSE_BOUND = 0
Se il Tween ha un nodo associato, sarà elaborato quando quel nodo può elaborare (vedi Node.process_mode). Altrimenti è lo stesso di TWEEN_PAUSE_STOP.
TweenPauseMode TWEEN_PAUSE_STOP = 1
Se lo SceneTree è in pausa, anche il Tween sarà messo in pausa.
TweenPauseMode TWEEN_PAUSE_PROCESS = 2
Il Tween sarà elaborato a prescindere dal fatto che SceneTree sia in pausa o meno.
enum TransitionType: 🔗
TransitionType TRANS_LINEAR = 0
L'animazione è interpolata linearmente.
TransitionType TRANS_SINE = 1
L'animazione è interpolata tramite una funzione sinusoidale.
TransitionType TRANS_QUINT = 2
L'animazione è interpolata con una funzione quintica (alla potenza di 5).
TransitionType TRANS_QUART = 3
L'animazione è interpolata con una funzione quartica (alla potenza di 4).
TransitionType TRANS_QUAD = 4
L'animazione è interpolata con una funzione quadratica (alla potenza di 2).
TransitionType TRANS_EXPO = 5
L'animazione è interpolata con una funzione esponenziale (alla potenza di x).
TransitionType TRANS_ELASTIC = 6
L'animazione è interpolata con elasticità, oscillando lungo le estremità.
TransitionType TRANS_CUBIC = 7
L'animazione è interpolata con una funzione cubica (alla potenza di 3).
TransitionType TRANS_CIRC = 8
L'animazione è interpolata con una funzione radice quadrata.
TransitionType TRANS_BOUNCE = 9
L'animazione è interpolata rimbalzando alla fine.
TransitionType TRANS_BACK = 10
L'animazione è interpolata tornando indietro alle estremità.
TransitionType TRANS_SPRING = 11
L'animazione è interpolata come una molla verso la fine.
enum EaseType: 🔗
EaseType EASE_IN = 0
L'interpolazione inizia lentamente e accelera verso la fine.
EaseType EASE_OUT = 1
L'interpolazione inizia rapidamente e rallenta verso la fine.
EaseType EASE_IN_OUT = 2
Una combinazione di EASE_IN e EASE_OUT. L'interpolazione è più lenta a entrambe le estremità.
EaseType EASE_OUT_IN = 3
Una combinazione di EASE_IN e EASE_OUT. L'interpolazione è più rapida a entrambe le estremità.
Descrizioni dei metodi
Associa questo Tween al nodo node. I Tween sono elaborati direttamente dal SceneTree, quindi sono eseguiti indipendentemente dai nodi animati. Quando colleghi un Node al Tween, il Tween interromperà l'animazione quando l'oggetto non si trova all'interno dell'albero e il Tween sarà automaticamente interrotto quando l'oggetto associato verrà liberato. Inoltre, TWEEN_PAUSE_BOUND renderà il comportamento di pausa dipendente dal nodo associato.
Per un modo più breve per creare e associare un Tween, puoi usare Node.create_tween().
Utilizzato per concatenare due Tweener dopo che set_parallel() è stato chiamato con true.
var tween = create_tween().set_parallel(true)
tween.tween_property(...)
tween.tween_property(...) # Sarà eseguito parallelamente a quanto sopra.
tween.chain().tween_property(...) # Sarà eseguito dopo che i due sopra sono terminati.
Tween tween = CreateTween().SetParallel(true);
tween.TweenProperty(...);
tween.TweenProperty(...); // Sarà eseguito parallelamente a quanto sopra.
tween.Chain().TweenProperty(...); // Sarà eseguito dopo che i due sopra sono terminati.
bool custom_step(delta: float) 🔗
Elabora il Tween in base al valore delta specificato, in secondi. Questo è utile soprattutto per un controllo manuale quando il Tween è in pausa. Può anche essere utilizzato per terminare immediatamente l'animazione del Tween, impostando delta più lungo dell'intera durata dell'animazione del Tween.
Restituisce true se il Tween ha ancora dei Tweener che non sono terminati.
Restituisce il numero di cicli rimanenti per questo Tween (vedi set_loops()). Un valore restituito pari a -1 indica un Tween in ciclo infinito, mentre un valore restituito pari a 0 indica che il Tween ha già terminato.
float get_total_elapsed_time() const 🔗
Restituisce il tempo totale in secondi in cui il Tween è stato in animazione (ad esempio il tempo trascorso dall'inizio, senza contare le pause, ecc.). Il tempo è influenzato da set_speed_scale() e stop() lo reimposterà su 0.
Nota: Poiché risulta dall'accumulo di delta di frame, il tempo restituito dopo che il Tween ha terminato l'animazione sarà leggermente maggiore della durata effettiva del Tween.
Restituisce true se è stato aggiunto un Tweener al Tween e il Tween è valido. Utile quando i tweener vengono aggiunti dinamicamente e il tween può risultare vuoto. Interrompere un tween vuoto prima che inizi evita errori.
Variant interpolate_value(initial_value: Variant, delta_value: Variant, elapsed_time: float, duration: float, trans_type: TransitionType, ease_type: EaseType) static 🔗
Questo metodo può essere utilizzato per l'interpolazione manuale di un valore, quando non vuoi che il Tween esegua l'animazione per te. È simile a @GlobalScope.lerp(), ma con supporto per transizione e allentamento personalizzate.
initial_value è il valore iniziale dell'interpolazione.
delta_value è la modifica del valore nell'interpolazione, ovvero è uguale a final_value - initial_value.
elapsed_time è il tempo in secondi trascorso dopo l'inizio dell'interpolazione ed è utilizzato per controllare la posizione dell'interpolazione. Ad esempio, quando è uguale alla metà di duration, il valore interpolato sarà a metà tra i valori iniziale e finale. Questo valore può anche essere maggiore di duration o minore di 0, il che estrapolerà il valore.
duration è il tempo totale dell'interpolazione.
Nota: Se duration è uguale a 0, il metodo restituirà sempre il valore finale, a prescindere dal elapsed_time fornito.
Restituisce un valore che indica se il Tween è attualmente in esecuzione, ovvero se non è stato messo in pausa e non ha terminato.
Restituisce un valore che indica se il Tween è valido. Un Tween valido è un Tween contenuto nell'albero di scene (ad esempio, l'array da SceneTree.get_processed_tweens() conterrà questo Tween). Un Tween potrebbe diventare non valido quando ha terminato il tweening, è interrotto o quando è creato con Tween.new(). I Tween non validi non possono avere Tweener aggiunti.
void kill() 🔗
Interrompe tutte le operazioni di tweening e invalida il Tween.
Fa in modo che il Tweener successivo sia eseguito in parallelo al precedente.
var tween = create_tween()
tween.tween_property(...)
tween.parallel().tween_property(...)
tween.parallel().tween_property(...)
Tween tween = CreateTween();
tween.TweenProperty(...);
tween.Parallel().TweenProperty(...);
tween.Parallel().TweenProperty(...);
Tutti i Tweener nell'esempio saranno eseguiti allo stesso tempo.
Puoi rendere il Tween parallelo come predefinito attraverso set_parallel().
void pause() 🔗
Mette in pausa il tweening. L'animazione può essere ripresa usando play().
Nota: Se un Tween è in pausa e non è associato a nessun nodo, esisterà indefinitamente finché non sarà avviato manualmente o invalidato. Se perdi un riferimento a tale Tween, puoi recuperarlo usando SceneTree.get_processed_tweens().
void play() 🔗
Riprende un Tween in pausa o interrotto.
Tween set_ease(ease: EaseType) 🔗
Imposta il tipo di allentamento predefinito per i PropertyTweener e i MethodTweener accodati dopo questo metodo.
Prima che questo metodo venga chiamato, il tipo di allentamento predefinito è EASE_IN_OUT.
var tween = create_tween()
tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Usa EASE_IN_OUT.
tween.set_ease(Tween.EASE_IN)
tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Usa EASE_IN.
Tween tween = CreateTween();
tween.TweenProperty(this, "position", new Vector2(300, 0), 0.5); // Usa EaseType.InOut.
tween.SetEase(Tween.EaseType.In);
tween.TweenProperty(this, "rotation_degrees", 45.0, 0.5); // Usa EaseType.In.
Tween set_ignore_time_scale(ignore: bool = true) 🔗
Se ignore è true, il tween ignorerà Engine.time_scale e si aggiornerà con il tempo reale trascorso. Ciò influenza tutti i Tweener e i loro ritardi. Il valore predefinito è false.
Tween set_loops(loops: int = 0) 🔗
Imposta il numero di volte in cui la sequenza di tweening sarà ripetuta, ad esempio set_loops(2) eseguirà l'animazione due volte.
La chiamata a questo metodo senza argomenti farà in modo che Tween sia eseguito all'infinito, finché non è interrotto con kill(), il nodo associato al Tween viene liberato o tutti gli oggetti animati sono stati liberati (il che rende impossibile un'ulteriore animazione).
Attenzione: Assicurati di aggiungere sempre una certa durata/ritardo quando utilizzi cicli infiniti. Per evitare che il gioco si blocchi, le animazioni in ciclo di durata 0 (ad esempio un singolo CallbackTweener senza ritardo) vengono interrotte dopo un piccolo numero di cicli, il che potrebbe produrre risultati imprevisti. Se la durata di un Tween dipende da un nodo, usa sempre bind_node().
Tween set_parallel(parallel: bool = true) 🔗
Se parallel è true, i Tweener aggiunti dopo questo metodo saranno eseguiti simultaneamente per impostazione predefinita, anziché in sequenza.
Nota: Proprio come con parallel(), anche il tweener aggiunto prima di questo metodo farà parte del passaggio parallelo.
tween.tween_property(self, "position", Vector2(300, 0), 0.5)
tween.set_parallel()
tween.tween_property(self, "modulate", Color.GREEN, 0.5) # È eseguito insieme al tweener di position.
Tween set_pause_mode(mode: TweenPauseMode) 🔗
Determina il comportamento del Tween quando lo SceneTree è in pausa.
Il valore predefinito è TWEEN_PAUSE_BOUND.
Tween set_process_mode(mode: TweenProcessMode) 🔗
Determina se il Tween deve essere eseguito dopo i frame di processo (vedi Node._process()) o i frame di fisica (vedi Node._physics_process()).
Il valore predefinito è TWEEN_PROCESS_IDLE.
Tween set_speed_scale(speed: float) 🔗
Scala la velocità di tweening. Questo influisce su tutti i Tweener e i loro ritardi.
Tween set_trans(trans: TransitionType) 🔗
Imposta il tipo di transizione predefinito per i PropertyTweener e MethodTweener accodati dopo questo metodo.
Prima che questo metodo venga chiamato, il tipo di transizione predefinito è TRANS_LINEAR.
var tween = create_tween()
tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Usa TRANS_LINEAR.
tween.set_trans(Tween.TRANS_SINE)
tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Usa TRANS_SINE.
void stop() 🔗
Arresta il tweening e ripristina lo stato iniziale del Tween. Questo non rimuoverà alcun Tweener accodato.
Nota: Ciò non ripristina gli obiettivi dei PropertyTweener ai loro valori di quando il Tween è stato avviato per la prima volta.
var tween = create_tween()
# Si sposterà da 0 a 500 in 1 secondo.
position.x = 0.0
tween.tween_property(self, "position:x", 500, 1.0)
# Sarà a (circa) 250 quando il timer termina.
await get_tree().create_timer(0.5).timeout
# Ora si sposterà da (circa) 250 a 500 in 1 secondo,
# quindi a metà della velocità di prima.
tween.stop()
tween.play()
Nota: Se un Tween viene arrestato e non è associato a nessun nodo, esisterà indefinitamente finché non verrà avviato manualmente o invalidato. Se si perde un riferimento a tale Tween, è possibile recuperarlo usando SceneTree.get_processed_tweens().
AwaitTweener tween_await(signal: Signal) 🔗
Crea e aggiunge un AwaitTweener. Questo metodo può servire per attendere l'emissione di un segnale e creare animazioni o cutscene asincrone.
L'animazione non proseguirà finché il segnale atteso non viene emesso o la connessione non diventa invalida (ad esempio, dopo aver liberato l'oggetto di destinazione). Se si prevede che l'emissione potrebbe non avvenire, usare AwaitTweener.set_timeout().
Nota: Il segnale atteso si dovrebbe emettere durante il passaggio in cui l'AwaitTweener è attivo.
Esempio: Un oggetto si lancia ed esplode in caso di collisione o dopo 4 secondi.
var tween = create_tween()
tween.tween_callback(lancia)
tween.tween_await(scontrato).set_timeout(4.0)
tween.tween_callback(esplodi)
Esempio: Un personaggio cammina fino a un punto specifico, dice qualcosa e torna indietro quando il giocatore chiude la finestra di dialogo.
var tween = create_tween()
tween.tween_callback(cammina_verso.bind(600.0))
tween.tween_await(destinazione_raggiunta)
tween.tween_callback(say_dialogue.bind("Buongiorno, signore!"))
tween.tween_await(dialogo_chiuso)
tween.tween_callback(cammina_verso.bind(0.0))
Nota: Se si attende un segnale da un callback nello stesso Tween, assicurarsi che il segnale venga emesso dopo l'inizio dell'attesa. Se non è possibile garantirlo ragionevolmente, è possibile attendere ed emettere nello stesso passaggio:
var tween = create_tween()
tween.tween_await(signal)
tween.parallel().tween_callback(metodo_che_emette_il_segnale)
CallbackTweener tween_callback(callback: Callable) 🔗
Crea e aggiunge un CallbackTweener. Questo metodo può essere usato per chiamare un metodo arbitrario in qualsiasi oggetto. Usa Callable.bind() per associare argomenti aggiuntivi per la chiamata.
Esempio: Oggetto che continua a sparare ogni 1 secondo:
var tween = get_tree().create_tween().set_loops()
tween.tween_callback(shoot).set_delay(1.0)
Tween tween = GetTree().CreateTween().SetLoops();
tween.TweenCallback(Callable.From(Shoot)).SetDelay(1.0f);
Esempio: Convertire uno sprite in rosso e poi in blu, con un ritardo di 2 secondi:
var tween = get_tree().create_tween()
tween.tween_callback($Sprite.set_modulate.bind(Color.RED)).set_delay(2)
tween.tween_callback($Sprite.set_modulate.bind(Color.BLUE)).set_delay(2)
Tween tween = GetTree().CreateTween();
Sprite2D sprite = GetNode<Sprite2D>("Sprite");
tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Red)).SetDelay(2.0f);
tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Blue)).SetDelay(2.0f);
IntervalTweener tween_interval(time: float) 🔗
Crea e aggiunge un IntervalTweener. Questo metodo può essere usato per creare ritardi nell'animazione tween, come alternativa all'utilizzo del ritardo in altri Tweener, o quando non c'è animazione (nel qual caso il Tween funge da timer). time è la durata dell'intervallo, in secondi.
Esempio: Creazione di un intervallo nell'esecuzione del codice:
# ... un po' di codice
await create_tween().tween_interval(2).finished
# ... altro codice
// ... un po' di codice
await ToSignal(CreateTween().TweenInterval(2.0f), Tween.SignalName.Finished);
// ... altro codice
Esempio: Creazione di un oggetto che si muove avanti e indietro e salta ogni pochi secondi:
var tween = create_tween().set_loops()
tween.tween_property($Sprite, "position:x", 200.0, 1.0).as_relative()
tween.tween_callback(jump)
tween.tween_interval(2)
tween.tween_property($Sprite, "position:x", -200.0, 1.0).as_relative()
tween.tween_callback(jump)
tween.tween_interval(2)
Tween tween = CreateTween().SetLoops();
tween.TweenProperty(GetNode("Sprite"), "position:x", 200.0f, 1.0f).AsRelative();
tween.TweenCallback(Callable.From(Jump));
tween.TweenInterval(2.0f);
tween.TweenProperty(GetNode("Sprite"), "position:x", -200.0f, 1.0f).AsRelative();
tween.TweenCallback(Callable.From(Jump));
tween.TweenInterval(2.0f);
MethodTweener tween_method(method: Callable, from: Variant, to: Variant, duration: float) 🔗
Crea e aggiunge un MethodTweener. Questo metodo è simile a una combinazione di tween_callback() e tween_property(). Chiama un metodo nel tempo con un valore interpolato fornito come argomento. Il valore è interpolato tra from e to nel tempo specificato da duration, in secondi. Usa Callable.bind() per associare ulteriori argomenti per la chiamata. Puoi usare MethodTweener.set_ease() e MethodTweener.set_trans() per modificare l'allentamento e la transizione del valore o MethodTweener.set_delay() per ritardare l'interpolazione.
Esempio: Fare in modo che un oggetto 3D guardi da un punto a un altro punto:
var tween = create_tween()
tween.tween_method(look_at.bind(Vector3.UP), Vector3(-1, 0, -1), Vector3(1, 0, -1), 1) # Il metodo look_at() accetta il vettore UP come secondo argomento.
Tween tween = CreateTween();
tween.TweenMethod(Callable.From((Vector3 target) => LookAt(target, Vector3.Up)), new Vector3(-1.0f, 0.0f, -1.0f), new Vector3(1.0f, 0.0f, -1.0f), 1.0f); // Usa le lambda per associare ulteriori argomenti per la chiamata.
Esempio: Impostazione del testo di una Label, attraverso un metodo intermedio e dopo un ritardo:
func _ready():
var tween = create_tween()
tween.tween_method(set_label_text, 0, 10, 1).set_delay(1.0)
func set_label_text(value: int):
$Label.text = "Counting " + str(value)
public override void _Ready()
{
base._Ready();
Tween tween = CreateTween();
tween.TweenMethod(Callable.From<int>(SetLabelText), 0.0f, 10.0f, 1.0f).SetDelay(1.0f);
}
private void SetLabelText(int value)
{
GetNode<Label>("Label").Text = $"Counting {value}";
}
PropertyTweener tween_property(object: Object, property: NodePath, final_val: Variant, duration: float) 🔗
Crea e aggiunge un PropertyTweener. Questo metodo interpola una proprietà con nome property di un object tra un valore iniziale e final_val in un intervallo di tempo pari a duration, in secondi. Il valore iniziale predefinito è il valore della proprietà al momento in cui inizia l'interpolazione del PropertyTweener.
var tween = create_tween()
tween.tween_property($Sprite, "position", Vector2(100, 200), 1.0)
tween.tween_property($Sprite, "position", Vector2(200, 300), 1.0)
Tween tween = CreateTween();
tween.TweenProperty(GetNode("Sprite"), "position", new Vector2(100.0f, 200.0f), 1.0f);
tween.TweenProperty(GetNode("Sprite"), "position", new Vector2(200.0f, 300.0f), 1.0f);
sposterà lo sprite in posizione (100, 200) e poi in (200, 300). Se usi PropertyTweener.from() o PropertyTweener.from_current(), la posizione di partenza sarà invece sovrascritta dal valore specificato. Consulta gli altri metodi in PropertyTweener per vedere come il tweening può essere ulteriormente modificato.
Nota: Puoi trovare il nome corretto della proprietà passando il mouse sulla proprietà nell'Ispettore. Puoi anche fornire i componenti di una proprietà direttamente usando "property:component" (ad esempio position:x), dove si applicherebbe solo a quel particolare componente.
Esempio: Spostare un oggetto due volte dalla stessa posizione, con diversi tipi di transizione:
var tween = create_tween()
tween.tween_property($Sprite, "position", Vector2.RIGHT * 300, 1.0).as_relative().set_trans(Tween.TRANS_SINE)
tween.tween_property($Sprite, "position", Vector2.RIGHT * 300, 1.0).as_relative().from_current().set_trans(Tween.TRANS_EXPO)
Tween tween = CreateTween();
tween.TweenProperty(GetNode("Sprite"), "position", Vector2.Right * 300.0f, 1.0f).AsRelative().SetTrans(Tween.TransitionType.Sine);
tween.TweenProperty(GetNode("Sprite"), "position", Vector2.Right * 300.0f, 1.0f).AsRelative().FromCurrent().SetTrans(Tween.TransitionType.Expo);
SubtweenTweener tween_subtween(subtween: Tween) 🔗
Crea e accoda un SubtweenTweener. Questo metodo può essere utilizzato per annidare subtween all'interno di questo Tween, consentendo la creazione di sequenze più complesse e componibili.
# Il subtween ruoterà l'oggetto.
var subtween = create_tween()
subtween.tween_property(self, "rotation_degrees", 45.0, 1.0)
subtween.tween_property(self, "rotation_degrees", 0.0, 1.0)
# Il tween padre eseguirà il subtween come uno dei suoi passaggi.
var tween = create_tween()
tween.tween_property(self, "position:x", 500, 3.0)
tween.tween_subtween(subtween)
tween.tween_property(self, "position:x", 300, 2.0)
Nota: I metodi pause(), stop() e set_loops() possono causare il blocco del Tween padre nel passaggio del subtween; vedi la documentazione per tali metodi per maggiori informazioni.
Nota: Le modalità di pausa e di elaborazione impostate da set_pause_mode() e set_process_mode() su subtween verranno sovrascritte dalle impostazioni del Tween padre.