:github_url: hide .. _class_Tween: Tween ===== **Наследует:** :ref:`RefCounted` **<** :ref:`Object` Легкий объект, используемый для универсальной анимации через скрипт с использованием :ref:`Tweener`. .. rst-class:: classref-introduction-group Описание ---------------- Tween, в основном, полезны для анимаций, требующих интерполяции числового свойства по диапазону значений. Название *tween* происходит от *in-betweening*, техники анимации, при которой вы указываете *ключевые кадры*, а компьютер интерполирует кадры, которые появляются между ними. Анимация чего-либо с помощью **Tween** называется созданием промежуточных кадров. \ **Tween** больше подходит, чем :ref:`AnimationPlayer`, для анимаций, где заранее неизвестны конечные значения. Например, интерполяцию динамически выбранного значения масштабирования камеры лучше всего осуществлять с помощью **Tween**; сделать то же самое с помощью узла :ref:`AnimationPlayer` будет сложно. Анимированные анимации также более легковесны, чем :ref:`AnimationPlayer`, поэтому они отлично подходят для простых анимаций или общих задач, не требующих визуальной настройки, предоставляемой редактором. Их можно использовать по принципу «запустил и забыл» для некоторой логики, которая обычно выполняется с помощью кода. Например, можно заставить что-то периодически стрелять, используя циклический :ref:`CallbackTweener` с задержкой. \ **Tween** можно создать с помощью :ref:`SceneTree.create_tween()` или :ref:`Node.create_tween()`. **Tween**-ы, созданные вручную (т. е. с помощью ``Tween.new()``), недействительны и не могут использоваться для значений tween. Анимация перехода между кадрами создается путем добавления :ref:`Tweener` к объекту **Tween** с помощью :ref:`tween_property()`, :ref:`tween_interval()`, :ref:`tween_callback()` или :ref:`tween_method()`: .. tabs:: .. code-tab:: gdscript 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) .. code-tab:: csharp 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)); Эта последовательность заставит узел ``$Sprite`` стать красным, затем уменьшиться, прежде чем наконец вызвать :ref:`Node.queue_free()` для освобождения спрайта. По умолчанию :ref:`Tweener`-ы выполняются один за другим. Это поведение можно изменить с помощью :ref:`parallel()` и :ref:`set_parallel()`. Когда :ref:`Tweener` создается с помощью одного из методов ``tween_*``, можно использовать цепочку вызовов методов для настройки свойств этого :ref:`Tweener`. Например, если вы хотите установить другой тип перехода в приведенном выше примере, вы можете использовать :ref:`set_trans()`: .. tabs:: .. code-tab:: gdscript 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) .. code-tab:: csharp 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)); Большинство методов **Tween** также можно объединить в цепочку подобным образом. В следующем примере **Tween** привязан к узлу работающего скрипта, а для его :ref:`Tweener`-ы установлены в переход по умолчанию: .. tabs:: .. code-tab:: gdscript 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) .. code-tab:: csharp 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)); Еще одно интересное применение **Tween**-ов — анимация произвольных наборов объектов: .. tabs:: .. code-tab:: gdscript var tween = create_tween() for sprite in get_children(): tween.tween_property(sprite, "position", Vector2(0, 0), 1.0) .. code-tab:: csharp Tween tween = CreateTween(); foreach (Node sprite in GetChildren()) tween.TweenProperty(sprite, "position", Vector2.Zero, 1.0f); В приведенном выше примере все дочерние элементы узла перемещаются один за другим в позицию ``(0, 0)``. Следует избегать использования более одного **Tween** на одно свойство объекта. Если два или более tweens одновременно анимируют одно свойство, то последний созданный tween будет иметь приоритет и назначит окончательное значение. Если вы хотите прервать и возобновить анимацию, рассмотрите возможность назначения **Tween** переменной: .. tabs:: .. code-tab:: gdscript var tween func animate(): if tween: tween.kill() # Отменить предыдущую анимацию. tween = create_tween() .. code-tab:: csharp private Tween _tween; public void Animate() { if (_tween != null) _tween.Kill(); // Отменить предыдущую анимацию. _tween = CreateTween(); } Некоторые :ref:`Tweener`-ы используют переходы и замедления. Первый принимает константу :ref:`TransitionType` и определяет способ обработки времени анимации (см. `easings.net `__ для некоторых примеров). Второй принимает константу :ref:`EaseType` и управляет тем, где ``trans_type`` применяется к интерполяции (в начале, в конце или в обоих случаях). Если вы не знаете, какой переход и замедление выбрать, вы можете попробовать разные константы :ref:`TransitionType` с :ref:`EASE_IN_OUT` и использовать ту, которая выглядит лучше всего. \ `Шпаргалка по типам анимации и переходов `__\ \ **Примечание:** Tween-ы не предназначены для повторного использования, и попытка сделать это приводит к непредсказуемому поведению. Создавайте новый Tween для каждой анимации и каждый раз, когда вы воспроизводите анимацию с самого начала. Помните, что Tween-ы запускаются немедленно, поэтому создавайте Tween только тогда, когда хотите начать анимацию. \ **Примечание:** Анимация обрабатывается после всех узлов в текущем кадре, т.е. метод узла :ref:`Node._process()` будет вызван до анимации (или :ref:`Node._physics_process()` в зависимости от значения, переданного в :ref:`set_process_mode()`). .. rst-class:: classref-reftable-group Методы ------------ .. table:: :widths: auto +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`bind_node`\ (\ node\: :ref:`Node`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`chain`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`custom_step`\ (\ delta\: :ref:`float`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_loops_left`\ (\ ) |const| | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_total_elapsed_time`\ (\ ) |const| | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`interpolate_value`\ (\ initial_value\: :ref:`Variant`, delta_value\: :ref:`Variant`, elapsed_time\: :ref:`float`, duration\: :ref:`float`, trans_type\: :ref:`TransitionType`, ease_type\: :ref:`EaseType`\ ) |static| | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_running`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`kill`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`parallel`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`pause`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`play`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_ease`\ (\ ease\: :ref:`EaseType`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_ignore_time_scale`\ (\ ignore\: :ref:`bool` = true\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_loops`\ (\ loops\: :ref:`int` = 0\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_parallel`\ (\ parallel\: :ref:`bool` = true\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_pause_mode`\ (\ mode\: :ref:`TweenPauseMode`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_process_mode`\ (\ mode\: :ref:`TweenProcessMode`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_speed_scale`\ (\ speed\: :ref:`float`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Tween` | :ref:`set_trans`\ (\ trans\: :ref:`TransitionType`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`stop`\ (\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`CallbackTweener` | :ref:`tween_callback`\ (\ callback\: :ref:`Callable`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`IntervalTweener` | :ref:`tween_interval`\ (\ time\: :ref:`float`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`MethodTweener` | :ref:`tween_method`\ (\ method\: :ref:`Callable`, from\: :ref:`Variant`, to\: :ref:`Variant`, duration\: :ref:`float`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PropertyTweener` | :ref:`tween_property`\ (\ object\: :ref:`Object`, property\: :ref:`NodePath`, final_val\: :ref:`Variant`, duration\: :ref:`float`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`SubtweenTweener` | :ref:`tween_subtween`\ (\ subtween\: :ref:`Tween`\ ) | +-----------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Сигналы -------------- .. _class_Tween_signal_finished: .. rst-class:: classref-signal **finished**\ (\ ) :ref:`🔗` Срабатывает, когда **Tween** завершил все промежуточные кадры. Никогда не срабатывает, когда **Tween** установлен на бесконечный цикл (см. :ref:`set_loops()`). .. rst-class:: classref-item-separator ---- .. _class_Tween_signal_loop_finished: .. rst-class:: classref-signal **loop_finished**\ (\ loop_count\: :ref:`int`\ ) :ref:`🔗` Срабатывает при завершении полного цикла (см. :ref:`set_loops()`), предоставляя индекс цикла. Этот сигнал не срабатывает после последнего цикла, вместо этого используйте :ref:`finished` для этого случая. .. rst-class:: classref-item-separator ---- .. _class_Tween_signal_step_finished: .. rst-class:: classref-signal **step_finished**\ (\ idx\: :ref:`int`\ ) :ref:`🔗` Срабатывает, когда один шаг **Tween** завершен, предоставляя индекс шага. Один шаг — это либо один :ref:`Tweener`, либо группа :ref:`Tweener`, работающих параллельно. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Перечисления ------------------------ .. _enum_Tween_TweenProcessMode: .. rst-class:: classref-enumeration enum **TweenProcessMode**: :ref:`🔗` .. _class_Tween_constant_TWEEN_PROCESS_PHYSICS: .. rst-class:: classref-enumeration-constant :ref:`TweenProcessMode` **TWEEN_PROCESS_PHYSICS** = ``0`` **Tween** обновляется после каждого физического кадра (см. :ref:`Node._physics_process()`). .. _class_Tween_constant_TWEEN_PROCESS_IDLE: .. rst-class:: classref-enumeration-constant :ref:`TweenProcessMode` **TWEEN_PROCESS_IDLE** = ``1`` **Tween** обновляется после каждого кадра процесса (см. :ref:`Node._process()`). .. rst-class:: classref-item-separator ---- .. _enum_Tween_TweenPauseMode: .. rst-class:: classref-enumeration enum **TweenPauseMode**: :ref:`🔗` .. _class_Tween_constant_TWEEN_PAUSE_BOUND: .. rst-class:: classref-enumeration-constant :ref:`TweenPauseMode` **TWEEN_PAUSE_BOUND** = ``0`` Если **Tween** имеет связанный узел, то он будет обрабатываться, когда этот узел тоже может обрабатываться (см. :ref:`Node.process_mode`). В противном случае это то же самое, что и :ref:`TWEEN_PAUSE_STOP`. .. _class_Tween_constant_TWEEN_PAUSE_STOP: .. rst-class:: classref-enumeration-constant :ref:`TweenPauseMode` **TWEEN_PAUSE_STOP** = ``1`` Если :ref:`SceneTree` приостановлен, **Tween** также будет приостановлен. .. _class_Tween_constant_TWEEN_PAUSE_PROCESS: .. rst-class:: classref-enumeration-constant :ref:`TweenPauseMode` **TWEEN_PAUSE_PROCESS** = ``2`` **Tween** будет обрабатываться независимо от того, приостановлено ли :ref:`SceneTree`. .. rst-class:: classref-item-separator ---- .. _enum_Tween_TransitionType: .. rst-class:: classref-enumeration enum **TransitionType**: :ref:`🔗` .. _class_Tween_constant_TRANS_LINEAR: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_LINEAR** = ``0`` Анимация интерполируется линейно. .. _class_Tween_constant_TRANS_SINE: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_SINE** = ``1`` Анимация интерполируется с использованием синусоидальной функции. .. _class_Tween_constant_TRANS_QUINT: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_QUINT** = ``2`` Анимация интерполируется с помощью функции пятой степени. .. _class_Tween_constant_TRANS_QUART: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_QUART** = ``3`` Анимация интерполируется с помощью функции четвертой степени. .. _class_Tween_constant_TRANS_QUAD: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_QUAD** = ``4`` Анимация интерполируется с помощью квадратичной (в степени 2) функции. .. _class_Tween_constant_TRANS_EXPO: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_EXPO** = ``5`` Анимация интерполируется с помощью экспоненциальной (в степени x) функции. .. _class_Tween_constant_TRANS_ELASTIC: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_ELASTIC** = ``6`` Анимация интерполирована с эластичностью, покачиваясь по краям. .. _class_Tween_constant_TRANS_CUBIC: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_CUBIC** = ``7`` Анимация интерполируется с помощью кубической (в степени 3) функции. .. _class_Tween_constant_TRANS_CIRC: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_CIRC** = ``8`` Анимация интерполируется с помощью функции, использующей квадратные корни. .. _class_Tween_constant_TRANS_BOUNCE: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_BOUNCE** = ``9`` Анимация интерполируется путем подпрыгивания в конце. .. _class_Tween_constant_TRANS_BACK: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_BACK** = ``10`` Анимация интерполируется с отходом назад на концах. .. _class_Tween_constant_TRANS_SPRING: .. rst-class:: classref-enumeration-constant :ref:`TransitionType` **TRANS_SPRING** = ``11`` Анимация к концу интерполируется подобно пружине. .. rst-class:: classref-item-separator ---- .. _enum_Tween_EaseType: .. rst-class:: classref-enumeration enum **EaseType**: :ref:`🔗` .. _class_Tween_constant_EASE_IN: .. rst-class:: classref-enumeration-constant :ref:`EaseType` **EASE_IN** = ``0`` Интерполяция начинается медленно и ускоряется к концу. .. _class_Tween_constant_EASE_OUT: .. rst-class:: classref-enumeration-constant :ref:`EaseType` **EASE_OUT** = ``1`` Интерполяция начинается быстро и замедляется к концу. .. _class_Tween_constant_EASE_IN_OUT: .. rst-class:: classref-enumeration-constant :ref:`EaseType` **EASE_IN_OUT** = ``2`` Комбинация :ref:`EASE_IN` и :ref:`EASE_OUT`. Интерполяция самая медленная на обоих концах. .. _class_Tween_constant_EASE_OUT_IN: .. rst-class:: classref-enumeration-constant :ref:`EaseType` **EASE_OUT_IN** = ``3`` Комбинация :ref:`EASE_IN` и :ref:`EASE_OUT`. Интерполяция выполняется быстрее всего на обоих концах. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описания метода ------------------------------ .. _class_Tween_method_bind_node: .. rst-class:: classref-method :ref:`Tween` **bind_node**\ (\ node\: :ref:`Node`\ ) :ref:`🔗` Связывает этот **Tween** с заданным ``node``. **Tween** обрабатываются непосредственно :ref:`SceneTree`, поэтому они запускаются независимо от анимированных узлов. Когда вы связываете :ref:`Node` с **Tween**, **Tween** остановит анимацию, когда объект не находится внутри дерева, и **Tween** будет автоматически завершен, когда связанный объект будет освобожден. Также :ref:`TWEEN_PAUSE_BOUND` сделает поведение паузы зависимым от связанного узла. Для более короткого способа создания и привязки **Tween** вы можете использовать :ref:`Node.create_tween()`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_chain: .. rst-class:: classref-method :ref:`Tween` **chain**\ (\ ) :ref:`🔗` Используется для связывания двух :ref:`Tweener` после вызова :ref:`set_parallel()` с ``true``. .. tabs:: .. code-tab:: gdscript var tween = create_tween().set_parallel(true) tween.tween_property(...) tween.tween_property(...) # Будет работать параллельно с предыдущим. tween.chain().tween_property(...) # Будет запущен после завершения двух вышеуказанных действий. .. code-tab:: csharp Tween tween = CreateTween().SetParallel(true); tween.TweenProperty(...); tween.TweenProperty(...); // Будет работать параллельно с предыдущим. tween.Chain().TweenProperty(...); // Будет запущен после завершения двух вышеуказанных действий. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_custom_step: .. rst-class:: classref-method :ref:`bool` **custom_step**\ (\ delta\: :ref:`float`\ ) :ref:`🔗` Обрабатывает **Tween** по заданному значению ``delta`` в секундах. Это в основном полезно для ручного управления, когда **Tween** приостановлен. Его также можно использовать для немедленного завершения анимации **Tween**, установив ``delta`` больше, чем вся продолжительность анимации **Tween**. Возвращает ``true``, если **Tween** все еще имеет :ref:`Tweener`, которые не были завершены. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_get_loops_left: .. rst-class:: classref-method :ref:`int` **get_loops_left**\ (\ ) |const| :ref:`🔗` Возвращает количество оставшихся циклов для этого **Tween** (см. :ref:`set_loops()`). Возвращаемое значение ``-1`` указывает на бесконечно зацикленный **Tween**, а возвращаемое значение ``0`` указывает на то, что **Tween** уже завершен. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_get_total_elapsed_time: .. rst-class:: classref-method :ref:`float` **get_total_elapsed_time**\ (\ ) |const| :ref:`🔗` Возвращает общее время в секундах, в течение которого **Tween** анимировался (т. е. время с момента начала, не считая пауз и т. д.). На время влияет :ref:`set_speed_scale()`, а :ref:`stop()` сбросит его до ``0``. \ **Примечание:** Поскольку это происходит из-за накопления кадровых дельт, время, возвращаемое после того, как **Tween** завершил анимацию, будет немного больше фактической длительности **Tween**. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_interpolate_value: .. rst-class:: classref-method :ref:`Variant` **interpolate_value**\ (\ initial_value\: :ref:`Variant`, delta_value\: :ref:`Variant`, elapsed_time\: :ref:`float`, duration\: :ref:`float`, trans_type\: :ref:`TransitionType`, ease_type\: :ref:`EaseType`\ ) |static| :ref:`🔗` Этот метод можно использовать для ручной интерполяции значения, когда вы не хотите, чтобы **Tween** выполнял анимацию за вас. Он похож на :ref:`@GlobalScope.lerp()`, но с поддержкой настраиваемого перехода и смягчения. \ ``initial_value`` — начальное значение интерполяции. \ ``delta_value`` — изменение значения при интерполяции, т. е. оно равно ``final_value - initial_value``. \ ``elapsed_time`` — время в секундах, прошедшее после начала интерполяции, и оно используется для управления положением интерполяции. Например, когда оно равно половине ``duration``, интерполированное значение будет находиться посередине между начальным и конечным значениями. Это значение также может быть больше ``duration`` или меньше 0, что приведет к экстраполяции значения. \ ``duration`` — общее время интерполяции. \ **Примечание:** Если ``duration`` равен ``0``, метод всегда будет возвращать конечное значение, независимо от предоставленного ``elapsed_time``. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_is_running: .. rst-class:: classref-method :ref:`bool` **is_running**\ (\ ) :ref:`🔗` Возвращает, выполняется ли в данный момент **Tween**, т.е. не приостановлен ли он и не завершен ли. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_is_valid: .. rst-class:: classref-method :ref:`bool` **is_valid**\ (\ ) :ref:`🔗` Возвращает, является ли **Tween** допустимым. Допустимый **Tween** — это **Tween**, содержащийся в дереве сцены (т. е. массив из :ref:`SceneTree.get_processed_tweens()` будет содержать этот **Tween**). **Tween** может стать недопустимым после завершения tween, уничтожения или при создании с помощью ``Tween.new()``. Недопустимые **Tween** не могут иметь добавленных :ref:`Tweener`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_kill: .. rst-class:: classref-method |void| **kill**\ (\ ) :ref:`🔗` Прерывает все операции по созданию промежуточных кадров и делает **Tween** недействительным. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_parallel: .. rst-class:: classref-method :ref:`Tween` **parallel**\ (\ ) :ref:`🔗` Заставляет следующий :ref:`Tweener` работать параллельно предыдущему. .. tabs:: .. code-tab:: gdscript var tween = create_tween() tween.tween_property(...) tween.parallel().tween_property(...) tween.parallel().tween_property(...) .. code-tab:: csharp Tween tween = CreateTween(); tween.TweenProperty(...); tween.Parallel().TweenProperty(...); tween.Parallel().TweenProperty(...); Все **Tween**-ы в примере будут запущены одновременно. Вы можете сделать **Tween** параллельным по умолчанию, используя :ref:`set_parallel()`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_pause: .. rst-class:: classref-method |void| **pause**\ (\ ) :ref:`🔗` Приостанавливает tween. Анимацию можно возобновить с помощью :ref:`play()`. \ **Примечание:** Если Tween приостановлен и не привязан ни к одному узлу, он будет существовать бесконечно, пока не будет запущен вручную или не станет недействительным. Если вы потеряете ссылку на такой Tween, вы можете восстановить его с помощью :ref:`SceneTree.get_processed_tweens()`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_play: .. rst-class:: classref-method |void| **play**\ (\ ) :ref:`🔗` Возобновляет приостановленный или остановленный **Tween**. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_ease: .. rst-class:: classref-method :ref:`Tween` **set_ease**\ (\ ease\: :ref:`EaseType`\ ) :ref:`🔗` Устанавливает тип плавности по умолчанию для :ref:`PropertyTweener` и :ref:`MethodTweener`, добавленных после этого метода. Перед вызовом этого метода тип плавности по умолчанию — :ref:`EASE_IN_OUT`. :: var tween = create_tween() tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Использует EASE_IN_OUT. tween.set_ease(Tween.EASE_IN) tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Использует EASE_IN. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_ignore_time_scale: .. rst-class:: classref-method :ref:`Tween` **set_ignore_time_scale**\ (\ ignore\: :ref:`bool` = true\ ) :ref:`🔗` Если ``ignore`` равен ``true``, твин будет игнорировать :ref:`Engine.time_scale` и обновляться с реальным, прошедшим временем. Это влияет на все :ref:`Tweener` и их задержки. Значение по умолчанию — ``false``. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_loops: .. rst-class:: classref-method :ref:`Tween` **set_loops**\ (\ loops\: :ref:`int` = 0\ ) :ref:`🔗` Устанавливает количество повторений последовательности tween, т. е. ``set_loops(2)`` запустит анимацию дважды. Вызов этого метода без аргументов заставит **Tween** работать бесконечно, пока он не будет убит с помощью :ref:`kill()`, связанный узел **Tween** не будет освобожден или все анимированные объекты не будут освобождены (что делает дальнейшую анимацию невозможной). \ **Предупреждение:** Обязательно всегда добавляйте некоторую длительность/задержку при использовании бесконечных циклов. Чтобы предотвратить зависание игры, циклические анимации с нулевой длительностью (например, один :ref:`CallbackTweener` без задержки) останавливаются после небольшого количества циклов, что может привести к неожиданным результатам. Если время жизни **Tween** зависит от какого-либо узла, всегда используйте :ref:`bind_node()`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_parallel: .. rst-class:: classref-method :ref:`Tween` **set_parallel**\ (\ parallel\: :ref:`bool` = true\ ) :ref:`🔗` Если ``parallel`` равен ``true``, то :ref:`Tweener`, добавленный после этого метода, по умолчанию будет выполняться одновременно, а не последовательно. \ **Примечание:** Как и в случае с :ref:`parallel()`, tweener, добавленный непосредственно перед этим методом, также будет частью параллельного шага. :: tween.tween_property(self, "position", Vector2(300, 0), 0.5) tween.set_parallel() tween.tween_property(self, "modulate", Color.GREEN, 0.5) # Работает вместе с позиционным твином. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_pause_mode: .. rst-class:: classref-method :ref:`Tween` **set_pause_mode**\ (\ mode\: :ref:`TweenPauseMode`\ ) :ref:`🔗` Определяет поведение **Tween**, когда :ref:`SceneTree` приостановлен. Значение по умолчанию — :ref:`TWEEN_PAUSE_BOUND`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_process_mode: .. rst-class:: classref-method :ref:`Tween` **set_process_mode**\ (\ mode\: :ref:`TweenProcessMode`\ ) :ref:`🔗` Определяет, должен ли **Tween** запускаться после кадров процесса (см. :ref:`Node._process()`) или кадров физики (см. :ref:`Node._physics_process()`). Значение по умолчанию — :ref:`TWEEN_PROCESS_IDLE`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_speed_scale: .. rst-class:: classref-method :ref:`Tween` **set_speed_scale**\ (\ speed\: :ref:`float`\ ) :ref:`🔗` Масштабирует скорость tweening. Это влияет на все :ref:`Tweener` и их задержки. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_set_trans: .. rst-class:: classref-method :ref:`Tween` **set_trans**\ (\ trans\: :ref:`TransitionType`\ ) :ref:`🔗` Устанавливает тип перехода по умолчанию для :ref:`PropertyTweener` и :ref:`MethodTweener`, добавленных после этого метода. Перед вызовом этого метода тип перехода по умолчанию — :ref:`TRANS_LINEAR`. :: var tween = create_tween() tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Использует TRANS_LINEAR. tween.set_trans(Tween.TRANS_SINE) tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Использует TRANS_SINE. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_stop: .. rst-class:: classref-method |void| **stop**\ (\ ) :ref:`🔗` Останавливает tweening и сбрасывает **Tween** в его начальное состояние. Это не удалит никакие добавленные :ref:`Tweener`. \ **Примечание:** Это *не* сбрасывает цели :ref:`PropertyTweener` к их значениям, когда **Tween** был запущен впервые. :: var tween = create_tween() # Будет изменяться от 0 до 500 за 1 секунду. position.x = 0.0 tween.tween_property(self, "position:x", 500, 1.0) # Когда таймер закончит отсчет, будет (примерно) 250. await get_tree().create_timer(0.5).timeout # Теперь будет двигаться от (примерно) 250 до 500 за 1 секунду, # таким образом, с половинной скоростью, чем раньше. tween.stop() tween.play() \ **Примечание:** Если Tween остановлен и не привязан ни к одному узлу, он будет существовать бесконечно, пока не будет запущен вручную или не станет недействительным. Если вы потеряете ссылку на такой Tween, вы можете восстановить его с помощью :ref:`SceneTree.get_processed_tweens()`. .. rst-class:: classref-item-separator ---- .. _class_Tween_method_tween_callback: .. rst-class:: classref-method :ref:`CallbackTweener` **tween_callback**\ (\ callback\: :ref:`Callable`\ ) :ref:`🔗` Создает и добавляет :ref:`CallbackTweener`. Этот метод можно использовать для вызова произвольного метода в любом объекте. Используйте :ref:`Callable.bind()` для привязки дополнительных аргументов для вызова. \ **Пример:** Объект, который продолжает стрелять каждую секунду: .. tabs:: .. code-tab:: gdscript var tween = get_tree().create_tween().set_loops() tween.tween_callback(shoot).set_delay(1.0) .. code-tab:: csharp Tween tween = GetTree().CreateTween().SetLoops(); tween.TweenCallback(Callable.From(Shoot)).SetDelay(1.0f); \ **Пример:** Окрашиваем спрайт в красный, а затем в синий цвет с задержкой в 2 секунды: .. tabs:: .. code-tab:: gdscript 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) .. code-tab:: csharp Tween tween = GetTree().CreateTween(); Sprite2D sprite = GetNode("Sprite"); tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Red)).SetDelay(2.0f); tween.TweenCallback(Callable.From(() => sprite.Modulate = Colors.Blue)).SetDelay(2.0f); .. rst-class:: classref-item-separator ---- .. _class_Tween_method_tween_interval: .. rst-class:: classref-method :ref:`IntervalTweener` **tween_interval**\ (\ time\: :ref:`float`\ ) :ref:`🔗` Создает и добавляет :ref:`IntervalTweener`. Этот метод можно использовать для создания задержек в анимации tween, как альтернативу использованию задержки в других **Tween** или когда нет анимации (в этом случае **Tween** действует как таймер). ``time`` — это длина интервала в секундах. \ **Пример:** Создание интервала при выполнении кода: .. tabs:: .. code-tab:: gdscript # ... какой-то код await create_tween().tween_interval(2).finished # ... больше кода .. code-tab:: csharp // ... какой-то код await ToSignal(CreateTween().TweenInterval(2.0f), Tween.SignalName.Finished); // ... больше кода \ **Пример:** Создание объекта, который движется вперед и назад и прыгает каждые несколько секунд: .. tabs:: .. code-tab:: gdscript 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) .. code-tab:: csharp 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); .. rst-class:: classref-item-separator ---- .. _class_Tween_method_tween_method: .. rst-class:: classref-method :ref:`MethodTweener` **tween_method**\ (\ method\: :ref:`Callable`, from\: :ref:`Variant`, to\: :ref:`Variant`, duration\: :ref:`float`\ ) :ref:`🔗` Создает и добавляет :ref:`MethodTweener`. Этот метод похож на комбинацию :ref:`tween_callback()` и :ref:`tween_property()`. Он вызывает метод с течением времени с tween-значением, предоставленным в качестве аргумента. Значение tween-значение между ``from`` и ``to`` в течение времени, указанного ``duration`` в секундах. Используйте :ref:`Callable.bind()`, чтобы привязать дополнительные аргументы для вызова. Вы можете использовать :ref:`MethodTweener.set_ease()` и :ref:`MethodTweener.set_trans()`, чтобы настроить смягчение и переход значения или :ref:`MethodTweener.set_delay()`, чтобы задержать tween-значение. \ **Пример:** Заставить 3D-объект смотреть из одной точки в другую: .. tabs:: .. code-tab:: gdscript var tween = create_tween() tween.tween_method(look_at.bind(Vector3.UP), Vector3(-1, 0, -1), Vector3(1, 0, -1), 1.0) # Метод look_at() принимает вектор в качестве второго аргумента. .. code-tab:: csharp 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); // Используйте лямбда-выражения для привязки дополнительных аргументов к вызову. \ **Пример:** Установка текста :ref:`Label` с использованием промежуточного метода и после задержки: .. tabs:: .. code-tab:: gdscript func _ready(): var tween = create_tween() tween.tween_method(set_label_text, 0, 10, 1.0).set_delay(1.0) func set_label_text(value: int): $Label.text = "Counting " + str(value) .. code-tab:: csharp public override void _Ready() { base._Ready(); Tween tween = CreateTween(); tween.TweenMethod(Callable.From(SetLabelText), 0.0f, 10.0f, 1.0f).SetDelay(1.0f); } private void SetLabelText(int value) { GetNode