godot-docs/classes/[email protected]

:github_url: hide

.. DO NOT EDIT THIS FILE!!!
.. Generated automatically from Godot engine sources.
.. Generator: https://github.com/godotengine/godot/tree/3.6/doc/tools/make_rst.py.
.. XML source: https://github.com/godotengine/godot/tree/3.6/modules/gdscript/doc_classes/@GDScript.xml.

.. _class_@GDScript:

@GDScript
=========

Built-in GDScript functions.

.. rst-class:: classref-introduction-group

Description
-----------

List of core built-in GDScript functions. Math functions and other utilities. Everything else is provided by objects. (Keywords: builtin, built in, global functions.)

.. rst-class:: classref-reftable-group

Methods
-------

.. table::
   :widths: auto

   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Color<class_Color>`                                 | :ref:`Color8<class_@GDScript_method_Color8>` **(** :ref:`int<class_int>` r8, :ref:`int<class_int>` g8, :ref:`int<class_int>` b8, :ref:`int<class_int>` a8=255 **)**                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Color<class_Color>`                                 | :ref:`ColorN<class_@GDScript_method_ColorN>` **(** :ref:`String<class_String>` name, :ref:`float<class_float>` alpha=1.0 **)**                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`abs<class_@GDScript_method_abs>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`acos<class_@GDScript_method_acos>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`asin<class_@GDScript_method_asin>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`assert<class_@GDScript_method_assert>` **(** :ref:`bool<class_bool>` condition, :ref:`String<class_String>` message="" **)**                                                                                                     |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`atan<class_@GDScript_method_atan>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`atan2<class_@GDScript_method_atan2>` **(** :ref:`float<class_float>` y, :ref:`float<class_float>` x **)**                                                                                                                        |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                             | :ref:`bytes2var<class_@GDScript_method_bytes2var>` **(** :ref:`PoolByteArray<class_PoolByteArray>` bytes, :ref:`bool<class_bool>` allow_objects=false **)**                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Vector2<class_Vector2>`                             | :ref:`cartesian2polar<class_@GDScript_method_cartesian2polar>` **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`ceil<class_@GDScript_method_ceil>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                               | :ref:`char<class_@GDScript_method_char>` **(** :ref:`int<class_int>` code **)**                                                                                                                                                        |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`clamp<class_@GDScript_method_clamp>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                             | :ref:`convert<class_@GDScript_method_convert>` **(** :ref:`Variant<class_Variant>` what, :ref:`int<class_int>` type **)**                                                                                                              |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`cos<class_@GDScript_method_cos>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`cosh<class_@GDScript_method_cosh>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`db2linear<class_@GDScript_method_db2linear>` **(** :ref:`float<class_float>` db **)**                                                                                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`decimals<class_@GDScript_method_decimals>` **(** :ref:`float<class_float>` step **)**                                                                                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`dectime<class_@GDScript_method_dectime>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` amount, :ref:`float<class_float>` step **)**                                                                           |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                                   | :ref:`deep_equal<class_@GDScript_method_deep_equal>` **(** :ref:`Variant<class_Variant>` a, :ref:`Variant<class_Variant>` b **)**                                                                                                      |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`deg2rad<class_@GDScript_method_deg2rad>` **(** :ref:`float<class_float>` deg **)**                                                                                                                                               |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Object<class_Object>`                               | :ref:`dict2inst<class_@GDScript_method_dict2inst>` **(** :ref:`Dictionary<class_Dictionary>` dict **)**                                                                                                                                |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`ease<class_@GDScript_method_ease>` **(** :ref:`float<class_float>` s, :ref:`float<class_float>` curve **)**                                                                                                                      |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`exp<class_@GDScript_method_exp>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`floor<class_@GDScript_method_floor>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                     |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`fmod<class_@GDScript_method_fmod>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**                                                                                                                          |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`fposmod<class_@GDScript_method_fposmod>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**                                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`FuncRef<class_FuncRef>`                             | :ref:`funcref<class_@GDScript_method_funcref>` **(** :ref:`Object<class_Object>` instance, :ref:`String<class_String>` funcname **)**                                                                                                  |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`                                 | :ref:`get_stack<class_@GDScript_method_get_stack>` **(** **)**                                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`hash<class_@GDScript_method_hash>` **(** :ref:`Variant<class_Variant>` var **)**                                                                                                                                                 |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Dictionary<class_Dictionary>`                       | :ref:`inst2dict<class_@GDScript_method_inst2dict>` **(** :ref:`Object<class_Object>` inst **)**                                                                                                                                        |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Object<class_Object>`                               | :ref:`instance_from_id<class_@GDScript_method_instance_from_id>` **(** :ref:`int<class_int>` instance_id **)**                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`inverse_lerp<class_@GDScript_method_inverse_lerp>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                                   | :ref:`is_equal_approx<class_@GDScript_method_is_equal_approx>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                                   | :ref:`is_inf<class_@GDScript_method_is_inf>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                                   | :ref:`is_instance_valid<class_@GDScript_method_is_instance_valid>` **(** :ref:`Object<class_Object>` instance **)**                                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                                   | :ref:`is_nan<class_@GDScript_method_is_nan>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                                   | :ref:`is_zero_approx<class_@GDScript_method_is_zero_approx>` **(** :ref:`float<class_float>` s **)**                                                                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`len<class_@GDScript_method_len>` **(** :ref:`Variant<class_Variant>` var **)**                                                                                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                             | :ref:`lerp<class_@GDScript_method_lerp>` **(** :ref:`Variant<class_Variant>` from, :ref:`Variant<class_Variant>` to, :ref:`float<class_float>` weight **)**                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`lerp_angle<class_@GDScript_method_lerp_angle>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**                                                                        |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`linear2db<class_@GDScript_method_linear2db>` **(** :ref:`float<class_float>` nrg **)**                                                                                                                                           |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Resource<class_Resource>`                           | :ref:`load<class_@GDScript_method_load>` **(** :ref:`String<class_String>` path **)**                                                                                                                                                  |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`log<class_@GDScript_method_log>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`max<class_@GDScript_method_max>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**                                                                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`min<class_@GDScript_method_min>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**                                                                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`move_toward<class_@GDScript_method_move_toward>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` delta **)**                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`nearest_po2<class_@GDScript_method_nearest_po2>` **(** :ref:`int<class_int>` value **)**                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`ord<class_@GDScript_method_ord>` **(** :ref:`String<class_String>` char **)**                                                                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                             | :ref:`parse_json<class_@GDScript_method_parse_json>` **(** :ref:`String<class_String>` json **)**                                                                                                                                      |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Vector2<class_Vector2>`                             | :ref:`polar2cartesian<class_@GDScript_method_polar2cartesian>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` th **)**                                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`posmod<class_@GDScript_method_posmod>` **(** :ref:`int<class_int>` a, :ref:`int<class_int>` b **)**                                                                                                                              |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`pow<class_@GDScript_method_pow>` **(** :ref:`float<class_float>` base, :ref:`float<class_float>` exp **)**                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Resource<class_Resource>`                           | :ref:`preload<class_@GDScript_method_preload>` **(** :ref:`String<class_String>` path **)**                                                                                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`print<class_@GDScript_method_print>` **(** ... **)** |vararg|                                                                                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`print_debug<class_@GDScript_method_print_debug>` **(** ... **)** |vararg|                                                                                                                                                        |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`print_stack<class_@GDScript_method_print_stack>` **(** **)**                                                                                                                                                                     |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`printerr<class_@GDScript_method_printerr>` **(** ... **)** |vararg|                                                                                                                                                              |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`printraw<class_@GDScript_method_printraw>` **(** ... **)** |vararg|                                                                                                                                                              |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`prints<class_@GDScript_method_prints>` **(** ... **)** |vararg|                                                                                                                                                                  |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`printt<class_@GDScript_method_printt>` **(** ... **)** |vararg|                                                                                                                                                                  |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`push_error<class_@GDScript_method_push_error>` **(** :ref:`String<class_String>` message **)**                                                                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`push_warning<class_@GDScript_method_push_warning>` **(** :ref:`String<class_String>` message **)**                                                                                                                               |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`rad2deg<class_@GDScript_method_rad2deg>` **(** :ref:`float<class_float>` rad **)**                                                                                                                                               |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`rand_range<class_@GDScript_method_rand_range>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to **)**                                                                                                          |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`                                 | :ref:`rand_seed<class_@GDScript_method_rand_seed>` **(** :ref:`int<class_int>` seed **)**                                                                                                                                              |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`randf<class_@GDScript_method_randf>` **(** **)**                                                                                                                                                                                 |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`randi<class_@GDScript_method_randi>` **(** **)**                                                                                                                                                                                 |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`randomize<class_@GDScript_method_randomize>` **(** **)**                                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`                                 | :ref:`range<class_@GDScript_method_range>` **(** ... **)** |vararg|                                                                                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`range_lerp<class_@GDScript_method_range_lerp>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` istart, :ref:`float<class_float>` istop, :ref:`float<class_float>` ostart, :ref:`float<class_float>` ostop **)** |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`round<class_@GDScript_method_round>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                     |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | void                                                      | :ref:`seed<class_@GDScript_method_seed>` **(** :ref:`int<class_int>` seed **)**                                                                                                                                                        |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`sign<class_@GDScript_method_sign>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`sin<class_@GDScript_method_sin>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`sinh<class_@GDScript_method_sinh>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`smoothstep<class_@GDScript_method_smoothstep>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` s **)**                                                                             |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`sqrt<class_@GDScript_method_sqrt>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`step_decimals<class_@GDScript_method_step_decimals>` **(** :ref:`float<class_float>` step **)**                                                                                                                                  |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`stepify<class_@GDScript_method_stepify>` **(** :ref:`float<class_float>` s, :ref:`float<class_float>` step **)**                                                                                                                 |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                               | :ref:`str<class_@GDScript_method_str>` **(** ... **)** |vararg|                                                                                                                                                                        |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                             | :ref:`str2var<class_@GDScript_method_str2var>` **(** :ref:`String<class_String>` string **)**                                                                                                                                          |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`tan<class_@GDScript_method_tan>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`tanh<class_@GDScript_method_tanh>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                               | :ref:`to_json<class_@GDScript_method_to_json>` **(** :ref:`Variant<class_Variant>` var **)**                                                                                                                                           |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                                   | :ref:`type_exists<class_@GDScript_method_type_exists>` **(** :ref:`String<class_String>` type **)**                                                                                                                                    |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`typeof<class_@GDScript_method_typeof>` **(** :ref:`Variant<class_Variant>` what **)**                                                                                                                                            |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                               | :ref:`validate_json<class_@GDScript_method_validate_json>` **(** :ref:`String<class_String>` json **)**                                                                                                                                |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PoolByteArray<class_PoolByteArray>`                 | :ref:`var2bytes<class_@GDScript_method_var2bytes>` **(** :ref:`Variant<class_Variant>` var, :ref:`bool<class_bool>` full_objects=false **)**                                                                                           |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                               | :ref:`var2str<class_@GDScript_method_var2str>` **(** :ref:`Variant<class_Variant>` var **)**                                                                                                                                           |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`WeakRef<class_WeakRef>`                             | :ref:`weakref<class_@GDScript_method_weakref>` **(** :ref:`Object<class_Object>` obj **)**                                                                                                                                             |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                                 | :ref:`wrapf<class_@GDScript_method_wrapf>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**                                                                                   |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                                     | :ref:`wrapi<class_@GDScript_method_wrapi>` **(** :ref:`int<class_int>` value, :ref:`int<class_int>` min, :ref:`int<class_int>` max **)**                                                                                               |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`GDScriptFunctionState<class_GDScriptFunctionState>` | :ref:`yield<class_@GDScript_method_yield>` **(** :ref:`Object<class_Object>` object=null, :ref:`String<class_String>` signal="" **)**                                                                                                  |
   +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Constants
---------

.. _class_@GDScript_constant_PI:

.. rst-class:: classref-constant

**PI** = ``3.141593``

Constant that represents how many times the diameter of a circle fits around its perimeter. This is equivalent to ``TAU / 2``.

.. _class_@GDScript_constant_TAU:

.. rst-class:: classref-constant

**TAU** = ``6.283185``

The circle constant, the circumference of the unit circle in radians. This is equivalent to ``PI * 2``, or 360 degrees in rotations.

.. _class_@GDScript_constant_INF:

.. rst-class:: classref-constant

**INF** = ``inf``

Positive floating-point infinity. This is the result of floating-point division when the divisor is ``0.0``. For negative infinity, use ``-INF``. Dividing by ``-0.0`` will result in negative infinity if the numerator is positive, so dividing by ``0.0`` is not the same as dividing by ``-0.0`` (despite ``0.0 == -0.0`` returning ``true``).

\ **Note:** Numeric infinity is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer number by ``0`` will not result in :ref:`INF<class_@GDScript_constant_INF>` and will result in a run-time error instead.

.. _class_@GDScript_constant_NAN:

.. rst-class:: classref-constant

**NAN** = ``nan``

"Not a Number", an invalid floating-point value. :ref:`NAN<class_@GDScript_constant_NAN>` has special properties, including that it is not equal to itself (``NAN == NAN`` returns ``false``). It is output by some invalid operations, such as dividing floating-point ``0.0`` by ``0.0``.

\ **Note:** "Not a Number" is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer ``0`` by ``0`` will not result in :ref:`NAN<class_@GDScript_constant_NAN>` and will result in a run-time error instead.

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Method Descriptions
-------------------

.. _class_@GDScript_method_Color8:

.. rst-class:: classref-method

:ref:`Color<class_Color>` **Color8** **(** :ref:`int<class_int>` r8, :ref:`int<class_int>` g8, :ref:`int<class_int>` b8, :ref:`int<class_int>` a8=255 **)**

Returns a color constructed from integer red, green, blue, and alpha channels. Each channel should have 8 bits of information ranging from 0 to 255.

\ ``r8`` red channel

\ ``g8`` green channel

\ ``b8`` blue channel

\ ``a8`` alpha channel

::

    red = Color8(255, 0, 0)

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_ColorN:

.. rst-class:: classref-method

:ref:`Color<class_Color>` **ColorN** **(** :ref:`String<class_String>` name, :ref:`float<class_float>` alpha=1.0 **)**

Returns a color according to the standardized ``name`` with ``alpha`` ranging from 0 to 1.

::

    red = ColorN("red", 1)

Supported color names are the same as the constants defined in :ref:`Color<class_Color>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_abs:

.. rst-class:: classref-method

:ref:`float<class_float>` **abs** **(** :ref:`float<class_float>` s **)**

Returns the absolute value of parameter ``s`` (i.e. positive value).

::

    a = abs(-1) # a is 1

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_acos:

.. rst-class:: classref-method

:ref:`float<class_float>` **acos** **(** :ref:`float<class_float>` s **)**

Returns the arc cosine of ``s`` in radians. Use to get the angle of cosine ``s``. ``s`` will be clamped between ``-1.0`` and ``1.0`` (inclusive), in order to prevent :ref:`acos<class_@GDScript_method_acos>` from returning :ref:`NAN<class_@GDScript_constant_NAN>`.

::

    # c is 0.523599 or 30 degrees if converted with rad2deg(s)
    c = acos(0.866025)

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_asin:

.. rst-class:: classref-method

:ref:`float<class_float>` **asin** **(** :ref:`float<class_float>` s **)**

Returns the arc sine of ``s`` in radians. Use to get the angle of sine ``s``. ``s`` will be clamped between ``-1.0`` and ``1.0`` (inclusive), in order to prevent :ref:`asin<class_@GDScript_method_asin>` from returning :ref:`NAN<class_@GDScript_constant_NAN>`.

::

    # s is 0.523599 or 30 degrees if converted with rad2deg(s)
    s = asin(0.5)

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_assert:

.. rst-class:: classref-method

void **assert** **(** :ref:`bool<class_bool>` condition, :ref:`String<class_String>` message="" **)**

Asserts that the ``condition`` is ``true``. If the ``condition`` is ``false``, an error is generated. When running from the editor, the running project will also be paused until you resume it. This can be used as a stronger form of :ref:`push_error<class_@GDScript_method_push_error>` for reporting errors to project developers or add-on users.

\ **Note:** For performance reasons, the code inside :ref:`assert<class_@GDScript_method_assert>` is only executed in debug builds or when running the project from the editor. Don't include code that has side effects in an :ref:`assert<class_@GDScript_method_assert>` call. Otherwise, the project will behave differently when exported in release mode.

The optional ``message`` argument, if given, is shown in addition to the generic "Assertion failed" message. You can use this to provide additional details about why the assertion failed.

::

    # Imagine we always want speed to be between 0 and 20.
    var speed = -10
    assert(speed < 20) # True, the program will continue
    assert(speed >= 0) # False, the program will stop
    assert(speed >= 0 and speed < 20) # You can also combine the two conditional statements in one check
    assert(speed < 20, "speed = %f, but the speed limit is 20" % speed) # Show a message with clarifying details

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_atan:

.. rst-class:: classref-method

:ref:`float<class_float>` **atan** **(** :ref:`float<class_float>` s **)**

Returns the arc tangent of ``s`` in radians. Use it to get the angle from an angle's tangent in trigonometry: ``atan(tan(angle)) == angle``.

The method cannot know in which quadrant the angle should fall. See :ref:`atan2<class_@GDScript_method_atan2>` if you have both ``y`` and ``x``.

::

    a = atan(0.5) # a is 0.463648

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_atan2:

.. rst-class:: classref-method

:ref:`float<class_float>` **atan2** **(** :ref:`float<class_float>` y, :ref:`float<class_float>` x **)**

Returns the arc tangent of ``y/x`` in radians. Use to get the angle of tangent ``y/x``. To compute the value, the method takes into account the sign of both arguments in order to determine the quadrant.

Important note: The Y coordinate comes first, by convention.

::

    a = atan2(0, -1) # a is 3.141593

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_bytes2var:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **bytes2var** **(** :ref:`PoolByteArray<class_PoolByteArray>` bytes, :ref:`bool<class_bool>` allow_objects=false **)**

Decodes a byte array back to a value. When ``allow_objects`` is ``true`` decoding objects is allowed.

\ **WARNING:** Deserialized object can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats (remote code execution).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_cartesian2polar:

.. rst-class:: classref-method

:ref:`Vector2<class_Vector2>` **cartesian2polar** **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**

Converts a 2D point expressed in the cartesian coordinate system (X and Y axis) to the polar coordinate system (a distance from the origin and an angle).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_ceil:

.. rst-class:: classref-method

:ref:`float<class_float>` **ceil** **(** :ref:`float<class_float>` s **)**

Rounds ``s`` upward (towards positive infinity), returning the smallest whole number that is not less than ``s``.

::

    a = ceil(1.45)  # a is 2.0
    a = ceil(1.001) # a is 2.0

See also :ref:`floor<class_@GDScript_method_floor>`, :ref:`round<class_@GDScript_method_round>`, :ref:`stepify<class_@GDScript_method_stepify>`, and :ref:`int<class_int>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_char:

.. rst-class:: classref-method

:ref:`String<class_String>` **char** **(** :ref:`int<class_int>` code **)**

Returns a character as a String of the given Unicode code point (which is compatible with ASCII code).

::

    a = char(65)      # a is "A"
    a = char(65 + 32) # a is "a"
    a = char(8364)    # a is "€"

This is the inverse of :ref:`ord<class_@GDScript_method_ord>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_clamp:

.. rst-class:: classref-method

:ref:`float<class_float>` **clamp** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**

Clamps ``value`` and returns a value not less than ``min`` and not more than ``max``.

::

    a = clamp(1000, 1, 20) # a is 20
    a = clamp(-10, 1, 20)  # a is 1
    a = clamp(15, 1, 20)   # a is 15

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_convert:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **convert** **(** :ref:`Variant<class_Variant>` what, :ref:`int<class_int>` type **)**

Converts from a type to another in the best way possible. The ``type`` parameter uses the :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` values.

::

    a = Vector2(1, 0)
    # Prints 1
    print(a.length())
    a = convert(a, TYPE_STRING)
    # Prints 6 as "(1, 0)" is 6 characters
    print(a.length())

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_cos:

.. rst-class:: classref-method

:ref:`float<class_float>` **cos** **(** :ref:`float<class_float>` s **)**

Returns the cosine of angle ``s`` in radians.

::

    a = cos(TAU) # a is 1.0
    a = cos(PI)  # a is -1.0

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_cosh:

.. rst-class:: classref-method

:ref:`float<class_float>` **cosh** **(** :ref:`float<class_float>` s **)**

Returns the hyperbolic cosine of ``s`` in radians.

::

    print(cosh(1)) # Prints 1.543081

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_db2linear:

.. rst-class:: classref-method

:ref:`float<class_float>` **db2linear** **(** :ref:`float<class_float>` db **)**

Converts from decibels to linear energy (audio).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_decimals:

.. rst-class:: classref-method

:ref:`int<class_int>` **decimals** **(** :ref:`float<class_float>` step **)**

Deprecated alias for :ref:`step_decimals<class_@GDScript_method_step_decimals>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_dectime:

.. rst-class:: classref-method

:ref:`float<class_float>` **dectime** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` amount, :ref:`float<class_float>` step **)**

**Note:** ``dectime`` has been deprecated and will be removed in Godot 4.0, please use :ref:`move_toward<class_@GDScript_method_move_toward>` instead.

Returns the result of ``value`` decreased by ``step`` \* ``amount``.

::

    a = dectime(60, 10, 0.1)) # a is 59.0

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_deep_equal:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **deep_equal** **(** :ref:`Variant<class_Variant>` a, :ref:`Variant<class_Variant>` b **)**

Compares two values by checking their actual contents, recursing into any :ref:`Array<class_Array>` or :ref:`Dictionary<class_Dictionary>` up to its deepest level.

This compares to ``==`` in a number of ways:

- For ``null``, ``int``, ``float``, ``String``, ``Object`` and ``RID`` both ``deep_equal`` and ``==`` work the same.

- For ``Dictionary``, ``==`` considers equality if, and only if, both variables point to the very same ``Dictionary``, with no recursion or awareness of the contents at all.

- For ``Array``, ``==`` considers equality if, and only if, each item in the first ``Array`` is equal to its counterpart in the second ``Array``, as told by ``==`` itself. That implies that ``==`` recurses into ``Array``, but not into ``Dictionary``.

In short, whenever a ``Dictionary`` is potentially involved, if you want a true content-aware comparison, you have to use ``deep_equal``.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_deg2rad:

.. rst-class:: classref-method

:ref:`float<class_float>` **deg2rad** **(** :ref:`float<class_float>` deg **)**

Converts an angle expressed in degrees to radians.

::

    r = deg2rad(180) # r is 3.141593

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_dict2inst:

.. rst-class:: classref-method

:ref:`Object<class_Object>` **dict2inst** **(** :ref:`Dictionary<class_Dictionary>` dict **)**

Converts a dictionary (previously created with :ref:`inst2dict<class_@GDScript_method_inst2dict>`) back to an instance. Useful for deserializing.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_ease:

.. rst-class:: classref-method

:ref:`float<class_float>` **ease** **(** :ref:`float<class_float>` s, :ref:`float<class_float>` curve **)**

Returns an "eased" value of ``x`` based on an easing function defined with ``curve``. This easing function is based on an exponent. The ``curve`` can be any floating-point number, with specific values leading to the following behaviors:

::

    - Lower than -1.0 (exclusive): Ease in-out
    - 1.0: Linear
    - Between -1.0 and 0.0 (exclusive): Ease out-in
    - 0.0: Constant
    - Between 0.0 to 1.0 (exclusive): Ease out
    - 1.0: Linear
    - Greater than 1.0 (exclusive): Ease in

\ `ease() curve values cheatsheet <https://raw.githubusercontent.com/godotengine/godot-docs/3.6/img/ease_cheatsheet.png>`__\ 

See also :ref:`smoothstep<class_@GDScript_method_smoothstep>`. If you need to perform more advanced transitions, use :ref:`Tween<class_Tween>` or :ref:`AnimationPlayer<class_AnimationPlayer>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_exp:

.. rst-class:: classref-method

:ref:`float<class_float>` **exp** **(** :ref:`float<class_float>` s **)**

The natural exponential function. It raises the mathematical constant **e** to the power of ``s`` and returns it.

\ **e** has an approximate value of 2.71828, and can be obtained with ``exp(1)``.

For exponents to other bases use the method :ref:`pow<class_@GDScript_method_pow>`.

::

    a = exp(2) # Approximately 7.39

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_floor:

.. rst-class:: classref-method

:ref:`float<class_float>` **floor** **(** :ref:`float<class_float>` s **)**

Rounds ``s`` downward (towards negative infinity), returning the largest whole number that is not more than ``s``.

::

    a = floor(2.45)  # a is 2.0
    a = floor(2.99)  # a is 2.0
    a = floor(-2.99) # a is -3.0

See also :ref:`ceil<class_@GDScript_method_ceil>`, :ref:`round<class_@GDScript_method_round>`, :ref:`stepify<class_@GDScript_method_stepify>`, and :ref:`int<class_int>`.

\ **Note:** This method returns a float. If you need an integer and ``s`` is a non-negative number, you can use ``int(s)`` directly.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_fmod:

.. rst-class:: classref-method

:ref:`float<class_float>` **fmod** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**

Returns the floating-point remainder of ``a/b``, keeping the sign of ``a``.

::

    r = fmod(7, 5.5) # r is 1.5

For the integer remainder operation, use the % operator.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_fposmod:

.. rst-class:: classref-method

:ref:`float<class_float>` **fposmod** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**

Returns the floating-point modulus of ``a/b`` that wraps equally in positive and negative.

::

    for i in 7:
        var x = 0.5 * i - 1.5
        print("%4.1f %4.1f %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])

Produces:

::

    -1.5 -0.0  0.0
    -1.0 -1.0  0.5
    -0.5 -0.5  1.0
     0.0  0.0  0.0
     0.5  0.5  0.5
     1.0  1.0  1.0
     1.5  0.0  0.0

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_funcref:

.. rst-class:: classref-method

:ref:`FuncRef<class_FuncRef>` **funcref** **(** :ref:`Object<class_Object>` instance, :ref:`String<class_String>` funcname **)**

Returns a reference to the specified function ``funcname`` in the ``instance`` node. As functions aren't first-class objects in GDscript, use ``funcref`` to store a :ref:`FuncRef<class_FuncRef>` in a variable and call it later.

::

    func foo():
        return("bar")
    
    a = funcref(self, "foo")
    print(a.call_func()) # Prints bar

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_get_stack:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **get_stack** **(** **)**

Returns an array of dictionaries representing the current call stack. See also :ref:`print_stack<class_@GDScript_method_print_stack>`.

::

    func _ready():
        foo()
    
    func foo():
        bar()
    
    func bar():
        print(get_stack())

would print

::

    [{function:bar, line:12, source:res://script.gd}, {function:foo, line:9, source:res://script.gd}, {function:_ready, line:6, source:res://script.gd}]

\ **Note:** :ref:`get_stack<class_@GDScript_method_get_stack>` only works if the running instance is connected to a debugging server (i.e. an editor instance). :ref:`get_stack<class_@GDScript_method_get_stack>` will not work in projects exported in release mode, or in projects exported in debug mode if not connected to a debugging server.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_hash:

.. rst-class:: classref-method

:ref:`int<class_int>` **hash** **(** :ref:`Variant<class_Variant>` var **)**

Returns the integer hash of the variable passed.

::

    print(hash("a")) # Prints 177670

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_inst2dict:

.. rst-class:: classref-method

:ref:`Dictionary<class_Dictionary>` **inst2dict** **(** :ref:`Object<class_Object>` inst **)**

Returns the passed instance converted to a dictionary (useful for serializing).

::

    var foo = "bar"
    func _ready():
        var d = inst2dict(self)
        print(d.keys())
        print(d.values())

Prints out:

::

    [@subpath, @path, foo]
    [, res://test.gd, bar]

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_instance_from_id:

.. rst-class:: classref-method

:ref:`Object<class_Object>` **instance_from_id** **(** :ref:`int<class_int>` instance_id **)**

Returns the Object that corresponds to ``instance_id``. All Objects have a unique instance ID.

::

    var foo = "bar"
    func _ready():
        var id = get_instance_id()
        var inst = instance_from_id(id)
        print(inst.foo) # Prints bar

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_inverse_lerp:

.. rst-class:: classref-method

:ref:`float<class_float>` **inverse_lerp** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**

Returns an interpolation or extrapolation factor considering the range specified in ``from`` and ``to``, and the interpolated value specified in ``weight``. The returned value will be between ``0.0`` and ``1.0`` if ``weight`` is between ``from`` and ``to`` (inclusive). If ``weight`` is located outside this range, then an extrapolation factor will be returned (return value lower than ``0.0`` or greater than ``1.0``). Use :ref:`clamp<class_@GDScript_method_clamp>` on the result of :ref:`inverse_lerp<class_@GDScript_method_inverse_lerp>` if this is not desired.

::

    # The interpolation ratio in the `lerp()` call below is 0.75.
    var middle = lerp(20, 30, 0.75)
    # `middle` is now 27.5.
    # Now, we pretend to have forgotten the original ratio and want to get it back.
    var ratio = inverse_lerp(20, 30, 27.5)
    # `ratio` is now 0.75.

See also :ref:`lerp<class_@GDScript_method_lerp>` which performs the reverse of this operation, and :ref:`range_lerp<class_@GDScript_method_range_lerp>` to map a continuous series of values to another.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_is_equal_approx:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_equal_approx** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**

Returns ``true`` if ``a`` and ``b`` are approximately equal to each other.

Here, approximately equal means that ``a`` and ``b`` are within a small internal epsilon of each other, which scales with the magnitude of the numbers.

Infinity values of the same sign are considered equal.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_is_inf:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_inf** **(** :ref:`float<class_float>` s **)**

Returns whether ``s`` is an infinity value (either positive infinity or negative infinity).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_is_instance_valid:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_instance_valid** **(** :ref:`Object<class_Object>` instance **)**

Returns whether ``instance`` is a valid object (e.g. has not been deleted from memory).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_is_nan:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_nan** **(** :ref:`float<class_float>` s **)**

Returns whether ``s`` is a NaN ("Not a Number" or invalid) value.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_is_zero_approx:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_zero_approx** **(** :ref:`float<class_float>` s **)**

Returns ``true`` if ``s`` is zero or almost zero.

This method is faster than using :ref:`is_equal_approx<class_@GDScript_method_is_equal_approx>` with one value as zero.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_len:

.. rst-class:: classref-method

:ref:`int<class_int>` **len** **(** :ref:`Variant<class_Variant>` var **)**

Returns length of Variant ``var``. Length is the character count of String, element count of Array, size of Dictionary, etc.

\ **Note:** Generates a fatal error if Variant can not provide a length.

::

    a = [1, 2, 3, 4]
    len(a) # Returns 4

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_lerp:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **lerp** **(** :ref:`Variant<class_Variant>` from, :ref:`Variant<class_Variant>` to, :ref:`float<class_float>` weight **)**

Linearly interpolates between two values by the factor defined in ``weight``. To perform interpolation, ``weight`` should be between ``0.0`` and ``1.0`` (inclusive). However, values outside this range are allowed and can be used to perform *extrapolation*. Use :ref:`clamp<class_@GDScript_method_clamp>` on the result of :ref:`lerp<class_@GDScript_method_lerp>` if this is not desired.

If the ``from`` and ``to`` arguments are of type :ref:`int<class_int>` or :ref:`float<class_float>`, the return value is a :ref:`float<class_float>`.

If both are of the same vector type (:ref:`Vector2<class_Vector2>`, :ref:`Vector3<class_Vector3>` or :ref:`Color<class_Color>`), the return value will be of the same type (``lerp`` then calls the vector type's ``linear_interpolate`` method).

::

    lerp(0, 4, 0.75) # Returns 3.0
    lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)

See also :ref:`inverse_lerp<class_@GDScript_method_inverse_lerp>` which performs the reverse of this operation. To perform eased interpolation with :ref:`lerp<class_@GDScript_method_lerp>`, combine it with :ref:`ease<class_@GDScript_method_ease>` or :ref:`smoothstep<class_@GDScript_method_smoothstep>`. See also :ref:`range_lerp<class_@GDScript_method_range_lerp>` to map a continuous series of values to another.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_lerp_angle:

.. rst-class:: classref-method

:ref:`float<class_float>` **lerp_angle** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**

Linearly interpolates between two angles (in radians) by a normalized value.

Similar to :ref:`lerp<class_@GDScript_method_lerp>`, but interpolates correctly when the angles wrap around :ref:`TAU<class_@GDScript_constant_TAU>`. To perform eased interpolation with :ref:`lerp_angle<class_@GDScript_method_lerp_angle>`, combine it with :ref:`ease<class_@GDScript_method_ease>` or :ref:`smoothstep<class_@GDScript_method_smoothstep>`.

::

    extends Sprite
    var elapsed = 0.0
    func _process(delta):
        var min_angle = deg2rad(0.0)
        var max_angle = deg2rad(90.0)
        rotation = lerp_angle(min_angle, max_angle, elapsed)
        elapsed += delta

\ **Note:** This method lerps through the shortest path between ``from`` and ``to``. However, when these two angles are approximately ``PI + k * TAU`` apart for any integer ``k``, it's not obvious which way they lerp due to floating-point precision errors. For example, ``lerp_angle(0, PI, weight)`` lerps counter-clockwise, while ``lerp_angle(0, PI + 5 * TAU, weight)`` lerps clockwise.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_linear2db:

.. rst-class:: classref-method

:ref:`float<class_float>` **linear2db** **(** :ref:`float<class_float>` nrg **)**

Converts from linear energy to decibels (audio). This can be used to implement volume sliders that behave as expected (since volume isn't linear). Example:

::

    # "Slider" refers to a node that inherits Range such as HSlider or VSlider.
    # Its range must be configured to go from 0 to 1.
    # Change the bus name if you'd like to change the volume of a specific bus only.
    AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear2db($Slider.value))

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_load:

.. rst-class:: classref-method

:ref:`Resource<class_Resource>` **load** **(** :ref:`String<class_String>` path **)**

Loads a resource from the filesystem located at ``path``. The resource is loaded on the method call (unless it's referenced already elsewhere, e.g. in another script or in the scene), which might cause slight delay, especially when loading scenes. To avoid unnecessary delays when loading something multiple times, either store the resource in a variable or use :ref:`preload<class_@GDScript_method_preload>`.

\ **Note:** Resource paths can be obtained by right-clicking on a resource in the FileSystem dock and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.

::

    # Load a scene called main located in the root of the project directory and cache it in a variable.
    var main = load("res://main.tscn") # main will contain a PackedScene resource.

\ **Important:** The path must be absolute, a local path will just return ``null``.

This method is a simplified version of :ref:`ResourceLoader.load<class_ResourceLoader_method_load>`, which can be used for more advanced scenarios.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_log:

.. rst-class:: classref-method

:ref:`float<class_float>` **log** **(** :ref:`float<class_float>` s **)**

Returns the `natural logarithm <https://en.wikipedia.org/wiki/Natural_logarithm>`__ of ``s`` (base `[i]e[/i] <https://en.wikipedia.org/wiki/E_(mathematical_constant)>`__, with *e* being approximately 2.71828). This is the amount of time needed to reach a certain level of continuous growth.

\ **Note:** This is not the same as the "log" function on most calculators, which uses a base 10 logarithm. To use base 10 logarithm, use ``log(x) / log(10)``.

::

    log(10) # Returns 2.302585

\ **Note:** The logarithm of ``0`` returns ``-inf``, while negative values return ``-nan``.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_max:

.. rst-class:: classref-method

:ref:`float<class_float>` **max** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**

Returns the maximum of two values.

::

    max(1, 2) # Returns 2
    max(-3.99, -4) # Returns -3.99

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_min:

.. rst-class:: classref-method

:ref:`float<class_float>` **min** **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**

Returns the minimum of two values.

::

    min(1, 2) # Returns 1
    min(-3.99, -4) # Returns -4

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_move_toward:

.. rst-class:: classref-method

:ref:`float<class_float>` **move_toward** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` delta **)**

Moves ``from`` toward ``to`` by the ``delta`` value.

Use a negative ``delta`` value to move away.

::

    move_toward(5, 10, 4) # Returns 9
    move_toward(10, 5, 4) # Returns 6
    move_toward(10, 5, -1.5) # Returns 11.5

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_nearest_po2:

.. rst-class:: classref-method

:ref:`int<class_int>` **nearest_po2** **(** :ref:`int<class_int>` value **)**

Returns the nearest equal or larger power of 2 for integer ``value``.

In other words, returns the smallest value ``a`` where ``a = pow(2, n)`` such that ``value <= a`` for some non-negative integer ``n``.

::

    nearest_po2(3) # Returns 4
    nearest_po2(4) # Returns 4
    nearest_po2(5) # Returns 8
    
    nearest_po2(0) # Returns 0 (this may not be what you expect)
    nearest_po2(-1) # Returns 0 (this may not be what you expect)

\ **WARNING:** Due to the way it is implemented, this function returns ``0`` rather than ``1`` for non-positive values of ``value`` (in reality, 1 is the smallest integer power of 2).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_ord:

.. rst-class:: classref-method

:ref:`int<class_int>` **ord** **(** :ref:`String<class_String>` char **)**

Returns an integer representing the Unicode code point of the given Unicode character ``char``.

::

    a = ord("A") # a is 65
    a = ord("a") # a is 97
    a = ord("€") # a is 8364

This is the inverse of :ref:`char<class_@GDScript_method_char>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_parse_json:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **parse_json** **(** :ref:`String<class_String>` json **)**

Parse JSON text to a Variant. (Use :ref:`typeof<class_@GDScript_method_typeof>` to check if the Variant's type is what you expect.)

\ **Note:** The JSON specification does not define integer or float types, but only a *number* type. Therefore, parsing a JSON text will convert all numerical values to :ref:`float<class_float>` types.

\ **Note:** JSON objects do not preserve key order like Godot dictionaries, thus, you should not rely on keys being in a certain order if a dictionary is constructed from JSON. In contrast, JSON arrays retain the order of their elements:

::

    var p = JSON.parse('["hello", "world", "!"]')
    if typeof(p.result) == TYPE_ARRAY:
        print(p.result[0]) # Prints "hello"
    else:
        push_error("Unexpected results.")

See also :ref:`JSON<class_JSON>` for an alternative way to parse JSON text.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_polar2cartesian:

.. rst-class:: classref-method

:ref:`Vector2<class_Vector2>` **polar2cartesian** **(** :ref:`float<class_float>` r, :ref:`float<class_float>` th **)**

Converts a 2D point expressed in the polar coordinate system (a distance from the origin ``r`` and an angle ``th``) to the cartesian coordinate system (X and Y axis).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_posmod:

.. rst-class:: classref-method

:ref:`int<class_int>` **posmod** **(** :ref:`int<class_int>` a, :ref:`int<class_int>` b **)**

Returns the integer modulus of ``a/b`` that wraps equally in positive and negative.

::

    for i in range(-3, 4):
        print("%2d %2d %2d" % [i, i % 3, posmod(i, 3)])

Produces:

::

    -3  0  0
    -2 -2  1
    -1 -1  2
     0  0  0
     1  1  1
     2  2  2
     3  0  0

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_pow:

.. rst-class:: classref-method

:ref:`float<class_float>` **pow** **(** :ref:`float<class_float>` base, :ref:`float<class_float>` exp **)**

Returns the result of ``base`` raised to the power of ``exp``.

::

    pow(2, 5) # Returns 32.0

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_preload:

.. rst-class:: classref-method

:ref:`Resource<class_Resource>` **preload** **(** :ref:`String<class_String>` path **)**

Returns a :ref:`Resource<class_Resource>` from the filesystem located at ``path``. The resource is loaded during script parsing, i.e. is loaded with the script and :ref:`preload<class_@GDScript_method_preload>` effectively acts as a reference to that resource. Note that the method requires a constant path. If you want to load a resource from a dynamic/variable path, use :ref:`load<class_@GDScript_method_load>`.

\ **Note:** Resource paths can be obtained by right clicking on a resource in the Assets Panel and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.

::

    # Instance a scene.
    var diamond = preload("res://diamond.tscn").instance()

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_print:

.. rst-class:: classref-method

void **print** **(** ... **)** |vararg|

Converts one or more arguments of any type to string in the best way possible and prints them to the console.

::

    a = [1, 2, 3]
    print("a", "=", a) # Prints a=[1, 2, 3]

\ **Note:** Consider using :ref:`push_error<class_@GDScript_method_push_error>` and :ref:`push_warning<class_@GDScript_method_push_warning>` to print error and warning messages instead of :ref:`print<class_@GDScript_method_print>`. This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_print_debug:

.. rst-class:: classref-method

void **print_debug** **(** ... **)** |vararg|

Like :ref:`print<class_@GDScript_method_print>`, but includes the current stack frame when running with the debugger turned on.

Output in the console would look something like this:

::

    Test print
       At: res://test.gd:15:_process()

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_print_stack:

.. rst-class:: classref-method

void **print_stack** **(** **)**

Prints a stack trace at the current code location. See also :ref:`get_stack<class_@GDScript_method_get_stack>`.

Output in the console would look something like this:

::

    Frame 0 - res://test.gd:16 in function '_process'

\ **Note:** :ref:`print_stack<class_@GDScript_method_print_stack>` only works if the running instance is connected to a debugging server (i.e. an editor instance). :ref:`print_stack<class_@GDScript_method_print_stack>` will not work in projects exported in release mode, or in projects exported in debug mode if not connected to a debugging server.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_printerr:

.. rst-class:: classref-method

void **printerr** **(** ... **)** |vararg|

Prints one or more arguments to strings in the best way possible to standard error line.

::

    printerr("prints to stderr")

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_printraw:

.. rst-class:: classref-method

void **printraw** **(** ... **)** |vararg|

Prints one or more arguments to strings in the best way possible to console. No newline is added at the end.

::

    printraw("A")
    printraw("B")
    # Prints AB

\ **Note:** Due to limitations with Godot's built-in console, this only prints to the terminal. If you need to print in the editor, use another method, such as :ref:`print<class_@GDScript_method_print>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_prints:

.. rst-class:: classref-method

void **prints** **(** ... **)** |vararg|

Prints one or more arguments to the console with a space between each argument.

::

    prints("A", "B", "C") # Prints A B C

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_printt:

.. rst-class:: classref-method

void **printt** **(** ... **)** |vararg|

Prints one or more arguments to the console with a tab between each argument.

::

    printt("A", "B", "C") # Prints A       B       C

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_push_error:

.. rst-class:: classref-method

void **push_error** **(** :ref:`String<class_String>` message **)**

Pushes an error message to Godot's built-in debugger and to the OS terminal.

::

    push_error("test error") # Prints "test error" to debugger and terminal as error call

\ **Note:** Errors printed this way will not pause project execution. To print an error message and pause project execution in debug builds, use ``assert(false, "test error")`` instead.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_push_warning:

.. rst-class:: classref-method

void **push_warning** **(** :ref:`String<class_String>` message **)**

Pushes a warning message to Godot's built-in debugger and to the OS terminal.

::

    push_warning("test warning") # Prints "test warning" to debugger and terminal as warning call

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_rad2deg:

.. rst-class:: classref-method

:ref:`float<class_float>` **rad2deg** **(** :ref:`float<class_float>` rad **)**

Converts an angle expressed in radians to degrees.

::

    rad2deg(0.523599) # Returns 30.0

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_rand_range:

.. rst-class:: classref-method

:ref:`float<class_float>` **rand_range** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to **)**

Returns a random floating point value between ``from`` and ``to`` (both endpoints inclusive).

::

    prints(rand_range(0, 1), rand_range(0, 1)) # Prints e.g. 0.135591 0.405263

\ **Note:** This is equivalent to ``randf() * (to - from) + from``.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_rand_seed:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **rand_seed** **(** :ref:`int<class_int>` seed **)**

Random from seed: pass a ``seed``, and an array with both number and new seed is returned. "Seed" here refers to the internal state of the pseudo random number generator. The internal state of the current implementation is 64 bits.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_randf:

.. rst-class:: classref-method

:ref:`float<class_float>` **randf** **(** **)**

Returns a random floating point value on the interval ``[0, 1]``.

::

    randf() # Returns e.g. 0.375671

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_randi:

.. rst-class:: classref-method

:ref:`int<class_int>` **randi** **(** **)**

Returns a random unsigned 32-bit integer. Use remainder to obtain a random value in the interval ``[0, N - 1]`` (where N is smaller than 2^32).

::

    randi()           # Returns random integer between 0 and 2^32 - 1
    randi() % 20      # Returns random integer between 0 and 19
    randi() % 100     # Returns random integer between 0 and 99
    randi() % 100 + 1 # Returns random integer between 1 and 100

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_randomize:

.. rst-class:: classref-method

void **randomize** **(** **)**

Randomizes the seed (or the internal state) of the random number generator. Current implementation reseeds using a number based on time.

::

    func _ready():
        randomize()

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_range:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **range** **(** ... **)** |vararg|

Returns an array with the given range. :ref:`range<class_@GDScript_method_range>` can be called in three ways:

\ ``range(n: int)``: Starts from 0, increases by steps of 1, and stops *before* ``n``. The argument ``n`` is **exclusive**.

\ ``range(b: int, n: int)``: Starts from ``b``, increases by steps of 1, and stops *before* ``n``. The arguments ``b`` and ``n`` are **inclusive** and **exclusive**, respectively.

\ ``range(b: int, n: int, s: int)``: Starts from ``b``, increases/decreases by steps of ``s``, and stops *before* ``n``. The arguments ``b`` and ``n`` are **inclusive** and **exclusive**, respectively. The argument ``s`` **can** be negative, but not ``0``. If ``s`` is ``0``, an error message is printed.

\ :ref:`range<class_@GDScript_method_range>` converts all arguments to :ref:`int<class_int>` before processing.

\ **Note:** Returns an empty array if no value meets the value constraint (e.g. ``range(2, 5, -1)`` or ``range(5, 5, 1)``).

Examples:

::

    print(range(4))        # Prints [0, 1, 2, 3]
    print(range(2, 5))     # Prints [2, 3, 4]
    print(range(0, 6, 2))  # Prints [0, 2, 4]
    print(range(4, 1, -1)) # Prints [4, 3, 2]

To iterate over an :ref:`Array<class_Array>` backwards, use:

::

    var array = [3, 6, 9]
    for i in range(array.size(), 0, -1):
        print(array[i - 1])

Output:

::

    9
    6
    3

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_range_lerp:

.. rst-class:: classref-method

:ref:`float<class_float>` **range_lerp** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` istart, :ref:`float<class_float>` istop, :ref:`float<class_float>` ostart, :ref:`float<class_float>` ostop **)**

Maps a ``value`` from range ``[istart, istop]`` to ``[ostart, ostop]``. See also :ref:`lerp<class_@GDScript_method_lerp>` and :ref:`inverse_lerp<class_@GDScript_method_inverse_lerp>`. If ``value`` is outside ``[istart, istop]``, then the resulting value will also be outside ``[ostart, ostop]``. Use :ref:`clamp<class_@GDScript_method_clamp>` on the result of :ref:`range_lerp<class_@GDScript_method_range_lerp>` if this is not desired.

::

    range_lerp(75, 0, 100, -1, 1) # Returns 0.5

For complex use cases where you need multiple ranges, consider using :ref:`Curve<class_Curve>` or :ref:`Gradient<class_Gradient>` instead.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_round:

.. rst-class:: classref-method

:ref:`float<class_float>` **round** **(** :ref:`float<class_float>` s **)**

Rounds ``s`` to the nearest whole number, with halfway cases rounded away from zero.

::

    a = round(2.49) # a is 2.0
    a = round(2.5)  # a is 3.0
    a = round(2.51) # a is 3.0

See also :ref:`floor<class_@GDScript_method_floor>`, :ref:`ceil<class_@GDScript_method_ceil>`, :ref:`stepify<class_@GDScript_method_stepify>`, and :ref:`int<class_int>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_seed:

.. rst-class:: classref-method

void **seed** **(** :ref:`int<class_int>` seed **)**

Sets seed for the random number generator.

::

    my_seed = "Godot Rocks"
    seed(my_seed.hash())

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_sign:

.. rst-class:: classref-method

:ref:`float<class_float>` **sign** **(** :ref:`float<class_float>` s **)**

Returns the sign of ``s``: -1 or 1. Returns 0 if ``s`` is 0.

::

    sign(-6) # Returns -1
    sign(0)  # Returns 0
    sign(6)  # Returns 1

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_sin:

.. rst-class:: classref-method

:ref:`float<class_float>` **sin** **(** :ref:`float<class_float>` s **)**

Returns the sine of angle ``s`` in radians.

::

    sin(0.523599) # Returns 0.5

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_sinh:

.. rst-class:: classref-method

:ref:`float<class_float>` **sinh** **(** :ref:`float<class_float>` s **)**

Returns the hyperbolic sine of ``s``.

::

    a = log(2.0) # Returns 0.693147
    sinh(a) # Returns 0.75

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_smoothstep:

.. rst-class:: classref-method

:ref:`float<class_float>` **smoothstep** **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` s **)**

Returns the result of smoothly interpolating the value of ``s`` between ``0`` and ``1``, based on the where ``s`` lies with respect to the edges ``from`` and ``to``.

The return value is ``0`` if ``s <= from``, and ``1`` if ``s >= to``. If ``s`` lies between ``from`` and ``to``, the returned value follows an S-shaped curve that maps ``s`` between ``0`` and ``1``.

This S-shaped curve is the cubic Hermite interpolator, given by ``f(y) = 3*y^2 - 2*y^3`` where ``y = (x-from) / (to-from)``.

::

    smoothstep(0, 2, -5.0) # Returns 0.0
    smoothstep(0, 2, 0.5) # Returns 0.15625
    smoothstep(0, 2, 1.0) # Returns 0.5
    smoothstep(0, 2, 2.0) # Returns 1.0

Compared to :ref:`ease<class_@GDScript_method_ease>` with a curve value of ``-1.6521``, :ref:`smoothstep<class_@GDScript_method_smoothstep>` returns the smoothest possible curve with no sudden changes in the derivative. If you need to perform more advanced transitions, use :ref:`Tween<class_Tween>` or :ref:`AnimationPlayer<class_AnimationPlayer>`.

\ `Comparison between smoothstep() and ease(x, -1.6521) return values <https://raw.githubusercontent.com/godotengine/godot-docs/3.6/img/smoothstep_ease_comparison.png>`__

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_sqrt:

.. rst-class:: classref-method

:ref:`float<class_float>` **sqrt** **(** :ref:`float<class_float>` s **)**

Returns the square root of ``s``, where ``s`` is a non-negative number.

::

    sqrt(9) # Returns 3

\ **Note:** Negative values of ``s`` return NaN. If you need negative inputs, use ``System.Numerics.Complex`` in C#.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_step_decimals:

.. rst-class:: classref-method

:ref:`int<class_int>` **step_decimals** **(** :ref:`float<class_float>` step **)**

Returns the position of the first non-zero digit, after the decimal point. Note that the maximum return value is 10, which is a design decision in the implementation.

::

    n = step_decimals(5)           # n is 0
    n = step_decimals(1.0005)      # n is 4
    n = step_decimals(0.000000005) # n is 9

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_stepify:

.. rst-class:: classref-method

:ref:`float<class_float>` **stepify** **(** :ref:`float<class_float>` s, :ref:`float<class_float>` step **)**

Snaps float value ``s`` to a given ``step``. This can also be used to round a floating point number to an arbitrary number of decimals.

::

    stepify(100, 32) # Returns 96.0
    stepify(3.14159, 0.01) # Returns 3.14

See also :ref:`ceil<class_@GDScript_method_ceil>`, :ref:`floor<class_@GDScript_method_floor>`, :ref:`round<class_@GDScript_method_round>`, and :ref:`int<class_int>`.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_str:

.. rst-class:: classref-method

:ref:`String<class_String>` **str** **(** ... **)** |vararg|

Converts one or more arguments of any type to string in the best way possible.

::

    var a = [10, 20, 30]
    var b = str(a);
    len(a) # Returns 3
    len(b) # Returns 12

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_str2var:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **str2var** **(** :ref:`String<class_String>` string **)**

Converts a formatted string that was returned by :ref:`var2str<class_@GDScript_method_var2str>` to the original value.

::

    a = '{ "a": 1, "b": 2 }'
    b = str2var(a)
    print(b["a"]) # Prints 1

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_tan:

.. rst-class:: classref-method

:ref:`float<class_float>` **tan** **(** :ref:`float<class_float>` s **)**

Returns the tangent of angle ``s`` in radians.

::

    tan(deg2rad(45)) # Returns 1

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_tanh:

.. rst-class:: classref-method

:ref:`float<class_float>` **tanh** **(** :ref:`float<class_float>` s **)**

Returns the hyperbolic tangent of ``s``.

::

    a = log(2.0) # a is 0.693147
    b = tanh(a)  # b is 0.6

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_to_json:

.. rst-class:: classref-method

:ref:`String<class_String>` **to_json** **(** :ref:`Variant<class_Variant>` var **)**

Converts a :ref:`Variant<class_Variant>` ``var`` to JSON text and return the result. Useful for serializing data to store or send over the network.

::

    # Both numbers below are integers.
    a = { "a": 1, "b": 2 }
    b = to_json(a)
    print(b) # {"a":1, "b":2}
    # Both numbers above are floats, even if they display without any decimal places.

\ **Note:** The JSON specification does not define integer or float types, but only a *number* type. Therefore, converting a :ref:`Variant<class_Variant>` to JSON text will convert all numerical values to :ref:`float<class_float>` types.

See also :ref:`JSON<class_JSON>` for an alternative way to convert a :ref:`Variant<class_Variant>` to JSON text.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_type_exists:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **type_exists** **(** :ref:`String<class_String>` type **)**

Returns whether the given class exists in :ref:`ClassDB<class_ClassDB>`.

::

    type_exists("Sprite") # Returns true
    type_exists("Variant") # Returns false

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_typeof:

.. rst-class:: classref-method

:ref:`int<class_int>` **typeof** **(** :ref:`Variant<class_Variant>` what **)**

Returns the internal type of the given Variant object, using the :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` values.

::

    p = parse_json('["a", "b", "c"]')
    if typeof(p) == TYPE_ARRAY:
        print(p[0]) # Prints a
    else:
        print("unexpected results")

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_validate_json:

.. rst-class:: classref-method

:ref:`String<class_String>` **validate_json** **(** :ref:`String<class_String>` json **)**

Checks that ``json`` is valid JSON data. Returns an empty string if valid, or an error message otherwise.

::

    j = to_json([1, 2, 3])
    v = validate_json(j)
    if not v:
        print("Valid JSON.")
    else:
        push_error("Invalid JSON: " + v)

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_var2bytes:

.. rst-class:: classref-method

:ref:`PoolByteArray<class_PoolByteArray>` **var2bytes** **(** :ref:`Variant<class_Variant>` var, :ref:`bool<class_bool>` full_objects=false **)**

Encodes a variable value to a byte array. When ``full_objects`` is ``true`` encoding objects is allowed (and can potentially include code).

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_var2str:

.. rst-class:: classref-method

:ref:`String<class_String>` **var2str** **(** :ref:`Variant<class_Variant>` var **)**

Converts a Variant ``var`` to a formatted string that can later be parsed using :ref:`str2var<class_@GDScript_method_str2var>`.

::

    a = { "a": 1, "b": 2 }
    print(var2str(a))

prints

::

    {
    "a": 1,
    "b": 2
    }

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_weakref:

.. rst-class:: classref-method

:ref:`WeakRef<class_WeakRef>` **weakref** **(** :ref:`Object<class_Object>` obj **)**

Returns a weak reference to an object.

A weak reference to an object is not enough to keep the object alive: when the only remaining references to a referent are weak references, garbage collection is free to destroy the referent and reuse its memory for something else. However, until the object is actually destroyed the weak reference may return the object even if there are no strong references to it.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_wrapf:

.. rst-class:: classref-method

:ref:`float<class_float>` **wrapf** **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**

Wraps float ``value`` between ``min`` and ``max``.

Usable for creating loop-alike behavior or infinite surfaces.

::

    # Infinite loop between 5.0 and 9.9
    value = wrapf(value + 0.1, 5.0, 10.0)

::

    # Infinite rotation (in radians)
    angle = wrapf(angle + 0.1, 0.0, TAU)

::

    # Infinite rotation (in radians)
    angle = wrapf(angle + 0.1, -PI, PI)

\ **Note:** If ``min`` is ``0``, this is equivalent to :ref:`fposmod<class_@GDScript_method_fposmod>`, so prefer using that instead.

\ ``wrapf`` is more flexible than using the :ref:`fposmod<class_@GDScript_method_fposmod>` approach by giving the user control over the minimum value.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_wrapi:

.. rst-class:: classref-method

:ref:`int<class_int>` **wrapi** **(** :ref:`int<class_int>` value, :ref:`int<class_int>` min, :ref:`int<class_int>` max **)**

Wraps integer ``value`` between ``min`` and ``max``.

Usable for creating loop-alike behavior or infinite surfaces.

::

    # Infinite loop between 5 and 9
    frame = wrapi(frame + 1, 5, 10)

::

    # result is -2
    var result = wrapi(-6, -5, -1)

\ **Note:** If ``min`` is ``0``, this is equivalent to :ref:`posmod<class_@GDScript_method_posmod>`, so prefer using that instead.

\ ``wrapi`` is more flexible than using the :ref:`posmod<class_@GDScript_method_posmod>` approach by giving the user control over the minimum value.

.. rst-class:: classref-item-separator

----

.. _class_@GDScript_method_yield:

.. rst-class:: classref-method

:ref:`GDScriptFunctionState<class_GDScriptFunctionState>` **yield** **(** :ref:`Object<class_Object>` object=null, :ref:`String<class_String>` signal="" **)**

Stops the function execution and returns the current suspended state to the calling function.

From the caller, call :ref:`GDScriptFunctionState.resume<class_GDScriptFunctionState_method_resume>` on the state to resume execution. This invalidates the state. Within the resumed function, ``yield()`` returns whatever was passed to the ``resume()`` function call.

If passed an object and a signal, the execution is resumed when the object emits the given signal. In this case, ``yield()`` returns the argument passed to ``emit_signal()`` if the signal takes only one argument, or an array containing all the arguments passed to ``emit_signal()`` if the signal takes multiple arguments.

You can also use ``yield`` to wait for a function to finish:

::

    func _ready():
        yield(countdown(), "completed") # waiting for the countdown() function to complete
        print('Ready')
    
    func countdown():
        yield(get_tree(), "idle_frame") # returns a GDScriptFunctionState object to _ready()
        print(3)
        yield(get_tree().create_timer(1.0), "timeout")
        print(2)
        yield(get_tree().create_timer(1.0), "timeout")
        print(1)
        yield(get_tree().create_timer(1.0), "timeout")
    
    # prints:
    # 3
    # 2
    # 1
    # Ready

When yielding on a function, the ``completed`` signal will be emitted automatically when the function returns. It can, therefore, be used as the ``signal`` parameter of the ``yield`` method to resume.

In order to yield on a function, the resulting function should also return a ``GDScriptFunctionState``. Notice ``yield(get_tree(), "idle_frame")`` from the above example.

.. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
.. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
.. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
.. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)`