:github_url: hide .. _class_AnimationPlayer: AnimationPlayer =============== **Eredita:** :ref:`AnimationMixer` **<** :ref:`Node` **<** :ref:`Object` Un nodo utilizzato per la riproduzione di animazioni. .. rst-class:: classref-introduction-group Descrizione ---------------------- Un riproduttore di animazioni è utilizzato per la riproduzione generale di animazioni. Contiene un dizionario di risorse :ref:`AnimationLibrary` e tempi di fusione personalizzati tra le transizioni delle animazioni. Alcuni metodi e proprietà usano una singola chiave per fare riferimento direttamente a un'animazione. Queste chiavi sono formattate come la chiave per la libreria, seguita da una barra obliqua, e poi la chiave per l'animazione all'interno della libreria, per esempio ``"movement/run"``. Se la chiave della libreria è una stringa vuota (nota come la libreria predefinita), la barra obliqua è omessa, essendo la stessa chiave utilizzata dalla libreria. \ **AnimationPlayer** è più adatto di :ref:`Tween` per animazioni più complesse, per esempio quelle con tempi non banali. Può anche essere utilizzato invece di :ref:`Tween` se l'editor di tracce di animazione è più conveniente di scriverlo in codice. L'aggiornamento delle proprietà di destinazione delle animazioni avviene al frame di processo. .. rst-class:: classref-introduction-group Tutorial ---------------- - :doc:`Animazione di sprite 2D <../tutorials/2d/2d_sprite_animation>` - :doc:`Indice di documentazione di animazione <../tutorials/animation/index>` - `Demo di sparatutto in terza persona (TPS) `__ .. rst-class:: classref-reftable-group Proprietà ------------------ .. table:: :widths: auto +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`StringName` | :ref:`assigned_animation` | | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`StringName` | :ref:`autoplay` | ``&""`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`StringName` | :ref:`current_animation` | ``&""`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`float` | :ref:`current_animation_length` | | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`float` | :ref:`current_animation_position` | | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`bool` | :ref:`movie_quit_on_finish` | ``false`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`bool` | :ref:`playback_auto_capture` | ``true`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`float` | :ref:`playback_auto_capture_duration` | ``-1.0`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`EaseType` | :ref:`playback_auto_capture_ease_type` | ``0`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`TransitionType` | :ref:`playback_auto_capture_transition_type` | ``0`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`float` | :ref:`playback_default_blend_time` | ``0.0`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ | :ref:`float` | :ref:`speed_scale` | ``1.0`` | +--------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------+ .. rst-class:: classref-reftable-group Metodi ------------ .. table:: :widths: auto +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`StringName` | :ref:`animation_get_next`\ (\ animation_from\: :ref:`StringName`\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`animation_set_next`\ (\ animation_from\: :ref:`StringName`, animation_to\: :ref:`StringName`\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`clear_queue`\ (\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_blend_time`\ (\ animation_from\: :ref:`StringName`, animation_to\: :ref:`StringName`\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`AnimationMethodCallMode` | :ref:`get_method_call_mode`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_playing_speed`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`AnimationProcessCallback` | :ref:`get_process_callback`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array`\[:ref:`StringName`\] | :ref:`get_queue`\ (\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`NodePath` | :ref:`get_root`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_section_end_time`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_section_start_time`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has_section`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_animation_active`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_playing`\ (\ ) |const| | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`pause`\ (\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play`\ (\ name\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play_backwards`\ (\ name\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play_section`\ (\ name\: :ref:`StringName` = &"", start_time\: :ref:`float` = -1, end_time\: :ref:`float` = -1, custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play_section_backwards`\ (\ name\: :ref:`StringName` = &"", start_time\: :ref:`float` = -1, end_time\: :ref:`float` = -1, custom_blend\: :ref:`float` = -1\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play_section_with_markers`\ (\ name\: :ref:`StringName` = &"", start_marker\: :ref:`StringName` = &"", end_marker\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play_section_with_markers_backwards`\ (\ name\: :ref:`StringName` = &"", start_marker\: :ref:`StringName` = &"", end_marker\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play_with_capture`\ (\ name\: :ref:`StringName` = &"", duration\: :ref:`float` = -1.0, custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false, trans_type\: :ref:`TransitionType` = 0, ease_type\: :ref:`EaseType` = 0\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`queue`\ (\ name\: :ref:`StringName`\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reset_section`\ (\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`seek`\ (\ seconds\: :ref:`float`, update\: :ref:`bool` = false, update_only\: :ref:`bool` = false\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_blend_time`\ (\ animation_from\: :ref:`StringName`, animation_to\: :ref:`StringName`, sec\: :ref:`float`\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_method_call_mode`\ (\ mode\: :ref:`AnimationMethodCallMode`\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_process_callback`\ (\ mode\: :ref:`AnimationProcessCallback`\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_root`\ (\ path\: :ref:`NodePath`\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_section`\ (\ start_time\: :ref:`float` = -1, end_time\: :ref:`float` = -1\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_section_with_markers`\ (\ start_marker\: :ref:`StringName` = &"", end_marker\: :ref:`StringName` = &""\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`stop`\ (\ keep_state\: :ref:`bool` = false\ ) | +--------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Segnali -------------- .. _class_AnimationPlayer_signal_animation_changed: .. rst-class:: classref-signal **animation_changed**\ (\ old_name\: :ref:`StringName`, new_name\: :ref:`StringName`\ ) :ref:`🔗` Emesso quando un'animazione in coda d'attesa viene riprodotta dopo che la animazione precedente ha terminato. Vedi anche :ref:`queue()`. \ **Nota:** Il segnale non è emesso quando l'animazione è cambiata via :ref:`play()` o da un :ref:`AnimationTree`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_signal_current_animation_changed: .. rst-class:: classref-signal **current_animation_changed**\ (\ name\: :ref:`StringName`\ ) :ref:`🔗` Emesso quando :ref:`current_animation` cambia. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Enumerazioni ------------------------ .. _enum_AnimationPlayer_AnimationProcessCallback: .. rst-class:: classref-enumeration enum **AnimationProcessCallback**: :ref:`🔗` .. _class_AnimationPlayer_constant_ANIMATION_PROCESS_PHYSICS: .. rst-class:: classref-enumeration-constant :ref:`AnimationProcessCallback` **ANIMATION_PROCESS_PHYSICS** = ``0`` **Deprecato:** See :ref:`AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS`. .. _class_AnimationPlayer_constant_ANIMATION_PROCESS_IDLE: .. rst-class:: classref-enumeration-constant :ref:`AnimationProcessCallback` **ANIMATION_PROCESS_IDLE** = ``1`` **Deprecato:** See :ref:`AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_IDLE`. .. _class_AnimationPlayer_constant_ANIMATION_PROCESS_MANUAL: .. rst-class:: classref-enumeration-constant :ref:`AnimationProcessCallback` **ANIMATION_PROCESS_MANUAL** = ``2`` **Deprecato:** See :ref:`AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_MANUAL`. .. rst-class:: classref-item-separator ---- .. _enum_AnimationPlayer_AnimationMethodCallMode: .. rst-class:: classref-enumeration enum **AnimationMethodCallMode**: :ref:`🔗` .. _class_AnimationPlayer_constant_ANIMATION_METHOD_CALL_DEFERRED: .. rst-class:: classref-enumeration-constant :ref:`AnimationMethodCallMode` **ANIMATION_METHOD_CALL_DEFERRED** = ``0`` **Deprecato:** See :ref:`AnimationMixer.ANIMATION_CALLBACK_MODE_METHOD_DEFERRED`. .. _class_AnimationPlayer_constant_ANIMATION_METHOD_CALL_IMMEDIATE: .. rst-class:: classref-enumeration-constant :ref:`AnimationMethodCallMode` **ANIMATION_METHOD_CALL_IMMEDIATE** = ``1`` **Deprecato:** See :ref:`AnimationMixer.ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE`. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni delle proprietà ------------------------------------------------------ .. _class_AnimationPlayer_property_assigned_animation: .. rst-class:: classref-property :ref:`StringName` **assigned_animation** :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_assigned_animation**\ (\ value\: :ref:`StringName`\ ) - :ref:`StringName` **get_assigned_animation**\ (\ ) Se in riproduzione, la chiave dell'animazione attuale, altrimenti, l'ultima animazione riprodotta. Quando impostato, questo cambia l'animazione, ma non la riprodurrà a meno che è già in riproduzione. Vedi anche :ref:`current_animation`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_autoplay: .. rst-class:: classref-property :ref:`StringName` **autoplay** = ``&""`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_autoplay**\ (\ value\: :ref:`StringName`\ ) - :ref:`StringName` **get_autoplay**\ (\ ) La chiave dell'animazione da riprodurre quando la scena è caricata. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_current_animation: .. rst-class:: classref-property :ref:`StringName` **current_animation** = ``&""`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_current_animation**\ (\ value\: :ref:`StringName`\ ) - :ref:`StringName` **get_current_animation**\ (\ ) La chiave dell'animazione attualmente in gioco. Se nessuna animazione si sta riproducendo, il valore della proprietà è una stringa vuota. Cambiare questo valore non riavvia l'animazione. Vedi :ref:`play()`\ Per ulteriori informazioni sulla riproduzione delle animazioni. \ **Nota:** Nonostante questa proprietà appaia nell'Ispettore, non è pensata per essere modificata, e non è salvata nella scena. Questa proprietà è utilizzata principalmente per ottenere l'animazione attualmente in riproduzione, e internamente per le tracce di riproduzione di animazione. Per ulteriori informazioni, vedi :ref:`Animation`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_current_animation_length: .. rst-class:: classref-property :ref:`float` **current_animation_length** :ref:`🔗` .. rst-class:: classref-property-setget - :ref:`float` **get_current_animation_length**\ (\ ) La durata (in secondi) dell'animazione attualmente in riproduzione. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_current_animation_position: .. rst-class:: classref-property :ref:`float` **current_animation_position** :ref:`🔗` .. rst-class:: classref-property-setget - :ref:`float` **get_current_animation_position**\ (\ ) La posizione (in secondi) dell'animazione attualmente in riproduzione. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_movie_quit_on_finish: .. rst-class:: classref-property :ref:`bool` **movie_quit_on_finish** = ``false`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_movie_quit_on_finish_enabled**\ (\ value\: :ref:`bool`\ ) - :ref:`bool` **is_movie_quit_on_finish_enabled**\ (\ ) Se ``true`` e il motore è in esecuzione in modalità Movie Maker (vedi :ref:`MovieWriter`), il motore si chiude con :ref:`SceneTree.quit()` non appena un'animazione ha terminato la riproduzione in questo **AnimationPlayer**. Un messaggio è stampato quando il motore si chiude per questo motivo. \ **Nota:** Questo obbedisce alla stessa logica del segnale :ref:`AnimationMixer.animation_finished`, perciò non chiuderà il motore se l'animazione è impostata a ripetersi. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_playback_auto_capture: .. rst-class:: classref-property :ref:`bool` **playback_auto_capture** = ``true`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_auto_capture**\ (\ value\: :ref:`bool`\ ) - :ref:`bool` **is_auto_capture**\ (\ ) Se ``true``, esegue :ref:`AnimationMixer.capture()` automaticamente prima della riproduzione. Questo significa che solo :ref:`play_with_capture()` è eseguito con gli argomenti predefiniti invece di :ref:`play()`. \ **Nota:** L'interpolazione della cattura è solo eseguita se l'animazione contiene una traccia di cattura. Vedi anche :ref:`Animation.UPDATE_CAPTURE`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_playback_auto_capture_duration: .. rst-class:: classref-property :ref:`float` **playback_auto_capture_duration** = ``-1.0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_auto_capture_duration**\ (\ value\: :ref:`float`\ ) - :ref:`float` **get_auto_capture_duration**\ (\ ) Vedi anche :ref:`play_with_capture()` e :ref:`AnimationMixer.capture()`. Se :ref:`playback_auto_capture_duration` è un valore negativo, la durata è impostata all'intervallo tra la posizione attuale e la prima chiave. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_playback_auto_capture_ease_type: .. rst-class:: classref-property :ref:`EaseType` **playback_auto_capture_ease_type** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_auto_capture_ease_type**\ (\ value\: :ref:`EaseType`\ ) - :ref:`EaseType` **get_auto_capture_ease_type**\ (\ ) The ease type of the capture interpolation. See also :ref:`EaseType`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_playback_auto_capture_transition_type: .. rst-class:: classref-property :ref:`TransitionType` **playback_auto_capture_transition_type** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_auto_capture_transition_type**\ (\ value\: :ref:`TransitionType`\ ) - :ref:`TransitionType` **get_auto_capture_transition_type**\ (\ ) Il tipo di transizione dell'interpolazione di cattura. Vedi anche :ref:`TransitionType`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_playback_default_blend_time: .. rst-class:: classref-property :ref:`float` **playback_default_blend_time** = ``0.0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_default_blend_time**\ (\ value\: :ref:`float`\ ) - :ref:`float` **get_default_blend_time**\ (\ ) Il tempo predefinito in cui mischiare animazioni. L'intervallo va da 0 a 4096 avente una precisione di 0,01. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_property_speed_scale: .. rst-class:: classref-property :ref:`float` **speed_scale** = ``1.0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_speed_scale**\ (\ value\: :ref:`float`\ ) - :ref:`float` **get_speed_scale**\ (\ ) Il rapporto di scala della velocità. Ad esempio, se questo valore è ``1``, l'animazione è riprodotta alla velocità normale. Se è ``0.5``, allora è riprodotta alla velocità dimezzata. Se è ``2``, allora è riprodotta alla velocità doppia. Se impostato a un valore negativo, l'animazione è riprodotta al rovescio. Se impostato su ``0``, l'animazione non avanza. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei metodi -------------------------------------------- .. _class_AnimationPlayer_method_animation_get_next: .. rst-class:: classref-method :ref:`StringName` **animation_get_next**\ (\ animation_from\: :ref:`StringName`\ ) |const| :ref:`🔗` Restituisce la chiave dell'animazione che è in coda per essere riprodotta dopo l'animazione ``animation_from``. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_animation_set_next: .. rst-class:: classref-method |void| **animation_set_next**\ (\ animation_from\: :ref:`StringName`, animation_to\: :ref:`StringName`\ ) :ref:`🔗` Attiva l'animazione ``animation_to`` quando l'animazione ``animation_from`` conclude. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_clear_queue: .. rst-class:: classref-method |void| **clear_queue**\ (\ ) :ref:`🔗` Pulisce tutte le animazioni in coda d'attesa e non riprodotte. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_blend_time: .. rst-class:: classref-method :ref:`float` **get_blend_time**\ (\ animation_from\: :ref:`StringName`, animation_to\: :ref:`StringName`\ ) |const| :ref:`🔗` Restituisce il tempo di fusione (in secondi) tra due animazioni, riferite dalle loro chiavi. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_method_call_mode: .. rst-class:: classref-method :ref:`AnimationMethodCallMode` **get_method_call_mode**\ (\ ) |const| :ref:`🔗` **Deprecato:** Use :ref:`AnimationMixer.callback_mode_method` instead. Restituisce la modalità di chiamata utilizzata per le tracce "Chiama metodo". .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_playing_speed: .. rst-class:: classref-method :ref:`float` **get_playing_speed**\ (\ ) |const| :ref:`🔗` Restituisce la velocità di riproduzione effettiva dell'animazione attuale o ``0`` se non è riprodotta. Questa velocità è la proprietà :ref:`speed_scale` moltiplicata per l'argomento ``custom_speed`` specificato quando si chiama il metodo :ref:`play()`. Restituisce un valore negativo se l'animazione corrente si sta riproducendo all'indietro. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_process_callback: .. rst-class:: classref-method :ref:`AnimationProcessCallback` **get_process_callback**\ (\ ) |const| :ref:`🔗` **Deprecato:** Use :ref:`AnimationMixer.callback_mode_process` instead. Restituisce la notifica di processo in cui aggiornare le animazioni. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_queue: .. rst-class:: classref-method :ref:`Array`\[:ref:`StringName`\] **get_queue**\ (\ ) :ref:`🔗` Restituisce un elenco di chiavi di animazione che sono attualmente in coda per essere riprodotte. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_root: .. rst-class:: classref-method :ref:`NodePath` **get_root**\ (\ ) |const| :ref:`🔗` **Deprecato:** Use :ref:`AnimationMixer.root_node` instead. Restituisce il nodo da cui i riferimenti di percorso del nodo partono. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_section_end_time: .. rst-class:: classref-method :ref:`float` **get_section_end_time**\ (\ ) |const| :ref:`🔗` Restituisce il tempo di fine della sezione attualmente riprodotta. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_get_section_start_time: .. rst-class:: classref-method :ref:`float` **get_section_start_time**\ (\ ) |const| :ref:`🔗` Restituisce il tempo di inizio della sezione attualmente riprodotta. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_has_section: .. rst-class:: classref-method :ref:`bool` **has_section**\ (\ ) |const| :ref:`🔗` Restituisce ``true`` se un'animazione è attualmente in riproduzione con una sezione. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_is_animation_active: .. rst-class:: classref-method :ref:`bool` **is_animation_active**\ (\ ) |const| :ref:`🔗` Returns ``true`` if the an animation is currently active. An animation is active if it was played by calling :ref:`play()` and was not finished yet, or was stopped by calling :ref:`stop()`. This can be used to check whether an animation is currently paused or stopped. :: var is_paused = not is_playing() and is_animation_active() var is_stopped = not is_playing() and not is_animation_active() .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_is_playing: .. rst-class:: classref-method :ref:`bool` **is_playing**\ (\ ) |const| :ref:`🔗` Restituisce ``true`` se un'impostazione è attualmente in riproduzione (anche se :ref:`speed_scale` e/o ``custom_speed`` sono ``0``). .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_pause: .. rst-class:: classref-method |void| **pause**\ (\ ) :ref:`🔗` Pausa l'animazione attualmente in riproduzione. Il :ref:`current_animation_position` sarà mantenuto e chiamando :ref:`play()` o :ref:`play_backwards()` senza argomenti o con lo stesso nome dell'animazione :ref:`assigned_animation` riprenderà l'animazione dalla posizione di riproduzione corrente. Vedi anche :ref:`stop()`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_play: .. rst-class:: classref-method |void| **play**\ (\ name\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false\ ) :ref:`🔗` Riproduce l'animazione con la chiave ``name``. È possibile impostare tempi e velocità di fusione personalizzati. L'opzione ``from_end`` ha effetto solo quando si passa a una nuova traccia di animazione o se è la stessa traccia ma all'inizio o alla fine. Non ha effetto quando si riprende la riproduzione messa in pausa nel mezzo di un'animazione. Se ``custom_speed`` è negativo e ``from_end`` è ``true``, l'animazione sarà riprodotta all'indietro (il che equivale a chiamare :ref:`play_backwards()`). \ **AnimationPlayer** tiene traccia della sua animazione attuale o dell'ultima riprodotta con :ref:`assigned_animation`. Se questo metodo viene chiamato con la stessa animazione con ``name`` o senza il parametro ``name``, l'animazione assegnata riprenderà la riproduzione se era stata messa in pausa. \ **Nota:** L'animazione verrà aggiornata la prossima volta che l'**AnimationPlayer** verrà elaborato. Se altre variabili vengono aggiornate allo stesso tempo che questo metodo viene chiamato, potrebbero essere aggiornate troppo presto. Per eseguire l'aggiornamento immediatamente, chiama ``advance(0)``. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_play_backwards: .. rst-class:: classref-method |void| **play_backwards**\ (\ name\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1\ ) :ref:`🔗` Riproduce l'animazione con la chiave ``name`` al rovescio. Questo metodo è una abbreviazione per :ref:`play()` con ``custom_speed = -1.0`` e ``from_end = true``, quindi vedi la sua descrizione per ulteriori informazioni. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_play_section: .. rst-class:: classref-method |void| **play_section**\ (\ name\: :ref:`StringName` = &"", start_time\: :ref:`float` = -1, end_time\: :ref:`float` = -1, custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false\ ) :ref:`🔗` Riproduce l'animazione con la chiave ``name`` e la sezione a partire da ``start_time`` e che termina a ``end_time``. Vedi anche :ref:`play()`. Impostando ``start_time`` su un valore al di fuori dell'intervallo dell'animazione, verrà utilizzato l'inizio dell'animazione, mentre impostando ``end_time`` su un valore al di fuori dell'intervallo dell'animazione, verrà utilizzata la fine dell'animazione. ``start_time`` non può essere uguale a ``end_time``. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_play_section_backwards: .. rst-class:: classref-method |void| **play_section_backwards**\ (\ name\: :ref:`StringName` = &"", start_time\: :ref:`float` = -1, end_time\: :ref:`float` = -1, custom_blend\: :ref:`float` = -1\ ) :ref:`🔗` Riproduce l'animazione con la chiave ``name`` e la sezione a partire da ``start_time`` e che termina a ``end_time`` al rovescio. Questo metodo è una abbreviazione per :ref:`play_section()` con ``custom_speed = -1.0`` e ``from_end = true``, quindi vedi la sua descrizione per ulteriori informazioni. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_play_section_with_markers: .. rst-class:: classref-method |void| **play_section_with_markers**\ (\ name\: :ref:`StringName` = &"", start_marker\: :ref:`StringName` = &"", end_marker\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false\ ) :ref:`🔗` Riproduce l'animazione con la chiave ``name`` e la sezione che inizia da ``start_marker`` e termina su ``end_marker``. Se il marcatore di inizio è vuoto, la sezione inizia dall'inizio dell'animazione. Se il marcatore di fine è vuoto, la sezione termina alla fine dell'animazione. Vedi anche :ref:`play()`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_play_section_with_markers_backwards: .. rst-class:: classref-method |void| **play_section_with_markers_backwards**\ (\ name\: :ref:`StringName` = &"", start_marker\: :ref:`StringName` = &"", end_marker\: :ref:`StringName` = &"", custom_blend\: :ref:`float` = -1\ ) :ref:`🔗` Riproduce l'animazione con la chiave ``name`` e la sezione a partire da ``start_marker`` e che termina a ``end_marker`` al rovescio. Questo metodo è una abbreviazione per :ref:`play_section_with_markers()` con ``custom_speed = -1.0`` e ``from_end = true``, quindi vedi la sua descrizione per ulteriori informazioni. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_play_with_capture: .. rst-class:: classref-method |void| **play_with_capture**\ (\ name\: :ref:`StringName` = &"", duration\: :ref:`float` = -1.0, custom_blend\: :ref:`float` = -1, custom_speed\: :ref:`float` = 1.0, from_end\: :ref:`bool` = false, trans_type\: :ref:`TransitionType` = 0, ease_type\: :ref:`EaseType` = 0\ ) :ref:`🔗` Vedi anche :ref:`AnimationMixer.capture()`. È possibile utilizzare questo metodo per fornire opzioni di acquisizione più dettagliate rispetto a quelle eseguite da :ref:`playback_auto_capture`. Quando :ref:`playback_auto_capture` è ``false``, questo metodo è quasi uguale al seguente: :: capture(name, duration, trans_type, ease_type) play(name, custom_blend, custom_speed, from_end) Se ``name`` è vuoto, specifica :ref:`assigned_animation`. Se ``duration`` è un valore negativo, la durata è impostata sull'intervallo tra la posizione attuale e la prima chiave, quando ``from_end`` è ``true``, utilizza invece l'intervallo tra la posizione attuale e l'ultima chiave. \ **Nota:** ``duration`` tiene conto di :ref:`speed_scale`, ma non di ``custom_speed``, perché la cache di acquisizione viene interpolata con il risultato della fusione e il risultato potrebbe contenere più animazioni. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_queue: .. rst-class:: classref-method |void| **queue**\ (\ name\: :ref:`StringName`\ ) :ref:`🔗` Mette in coda un'animazione per la riproduzione una volta completata l'animazione attuale e tutte le animazioni precedentemente messe in coda. \ **Nota:** Se è in corso la riproduzione di un'animazione in ripetizione, l'animazione in coda non verrà mai riprodotta a meno che l'animazione in ripetizione non venga interrotta in qualche modo. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_reset_section: .. rst-class:: classref-method |void| **reset_section**\ (\ ) :ref:`🔗` Ripristina la sezione attuale. Non fa nulla se non è stata impostata una sezione. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_seek: .. rst-class:: classref-method |void| **seek**\ (\ seconds\: :ref:`float`, update\: :ref:`bool` = false, update_only\: :ref:`bool` = false\ ) :ref:`🔗` Cerca l'animazione fino al punto ``seconds`` nel tempo (in secondi). Se ``update`` è ``true``, anche l'animazione viene aggiornata, altrimenti viene aggiornata in fase di processo. Gli eventi compresi tra il frame attuale e ``seconds`` vengono saltati. Se ``update_only`` è ``true``, le tracce di riproduzione di metodo/audio/animazione non verranno elaborate. \ **Nota:** Cercare fino alla fine dell'animazione non emette :ref:`AnimationMixer.animation_finished`. Se si desidera saltare l'animazione ed emettere il segnale, usa :ref:`AnimationMixer.advance()`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_set_blend_time: .. rst-class:: classref-method |void| **set_blend_time**\ (\ animation_from\: :ref:`StringName`, animation_to\: :ref:`StringName`, sec\: :ref:`float`\ ) :ref:`🔗` Restituisce il tempo di fusione (in secondi) tra due animazioni, riferite dalle loro chiavi. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_set_method_call_mode: .. rst-class:: classref-method |void| **set_method_call_mode**\ (\ mode\: :ref:`AnimationMethodCallMode`\ ) :ref:`🔗` **Deprecato:** Use :ref:`AnimationMixer.callback_mode_method` instead. Imposta la modalità di chiamata utilizzata per le tracce "Chiama metodo". .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_set_process_callback: .. rst-class:: classref-method |void| **set_process_callback**\ (\ mode\: :ref:`AnimationProcessCallback`\ ) :ref:`🔗` **Deprecato:** Use :ref:`AnimationMixer.callback_mode_process` instead. Imposta la notifica di processo in cui aggiornare le animazioni. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_set_root: .. rst-class:: classref-method |void| **set_root**\ (\ path\: :ref:`NodePath`\ ) :ref:`🔗` **Deprecato:** Use :ref:`AnimationMixer.root_node` instead. Imposta il nodo da cui i riferimenti di percorso del nodo partono. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_set_section: .. rst-class:: classref-method |void| **set_section**\ (\ start_time\: :ref:`float` = -1, end_time\: :ref:`float` = -1\ ) :ref:`🔗` Modifica i tempi di inizio e fine della sezione riprodotta. La posizione di riproduzione attuale verrà limitata all'interno della nuova sezione. Vedi anche :ref:`play_section()`. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_set_section_with_markers: .. rst-class:: classref-method |void| **set_section_with_markers**\ (\ start_marker\: :ref:`StringName` = &"", end_marker\: :ref:`StringName` = &""\ ) :ref:`🔗` Modifica i marcatori di inizio e fine della sezione riprodotta. La posizione di riproduzione attuale verrà limitata all'interno della nuova sezione. Vedi anche :ref:`play_section_with_markers()`. Se l'argomento è vuoto, la sezione utilizza l'inizio o la fine dell'animazione. Se entrambi sono vuoti, significa che la sezione non è impostata. .. rst-class:: classref-item-separator ---- .. _class_AnimationPlayer_method_stop: .. rst-class:: classref-method |void| **stop**\ (\ keep_state\: :ref:`bool` = false\ ) :ref:`🔗` Interrompe l'animazione attualmente in riproduzione. La posizione di animazione è ripristinata a ``0`` e ``custom_speed`` è ripristinato a ``1.0``. Vedi anche :ref:`pause()`. Se ``keep_state`` è ``true``, lo stato di animazione non è aggiornato visivamente. \ **Nota:** Le tracce di riproduzione metodo / audio / animazione non saranno elaborate da questo metodo. .. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)` .. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)` .. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)` .. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)` .. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)` .. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)` .. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)` .. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)` .. |void| replace:: :abbr:`void (Nessun valore restituito.)`