godot-docs/classes/class_@gdscript.rst

.. Generated automatically by doc/tools/makerst.py in Godot's source tree.
.. DO NOT EDIT THIS FILE, but the @GDScript.xml source instead.
.. The source is found in doc/classes or modules/<name>/doc_classes.

.. _class_@GDScript:

@GDScript
=========

**Category:** Core

Brief Description
-----------------

Built-in GDScript functions.

Member Functions
----------------

+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_color>`                                  | :ref:`Color8<class_@GDScript_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_ColorN>` **(** :ref:`String<class_string>` name, :ref:`float<class_float>` alpha=1.0 **)**                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`abs<class_@GDScript_abs>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`acos<class_@GDScript_acos>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`asin<class_@GDScript_asin>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`assert<class_@GDScript_assert>` **(** :ref:`bool<class_bool>` condition **)**                                                                                                                                             |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`atan<class_@GDScript_atan>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`atan2<class_@GDScript_atan2>` **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**                                                                                                                        |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_variant>`                              | :ref:`bytes2var<class_@GDScript_bytes2var>` **(** :ref:`PoolByteArray<class_poolbytearray>` bytes **)**                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_vector2>`                              | :ref:`cartesian2polar<class_@GDScript_cartesian2polar>` **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**                                                                                                    |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`ceil<class_@GDScript_ceil>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_string>`                                | :ref:`char<class_@GDScript_char>` **(** :ref:`int<class_int>` ascii **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`clamp<class_@GDScript_clamp>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**                                                                                   |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_object>`                                | :ref:`convert<class_@GDScript_convert>` **(** :ref:`Variant<class_variant>` what, :ref:`int<class_int>` type **)**                                                                                                              |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`cos<class_@GDScript_cos>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`cosh<class_@GDScript_cosh>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`db2linear<class_@GDScript_db2linear>` **(** :ref:`float<class_float>` db **)**                                                                                                                                            |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`decimals<class_@GDScript_decimals>` **(** :ref:`float<class_float>` step **)**                                                                                                                                            |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`dectime<class_@GDScript_dectime>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` amount, :ref:`float<class_float>` step **)**                                                                           |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`deg2rad<class_@GDScript_deg2rad>` **(** :ref:`float<class_float>` deg **)**                                                                                                                                               |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_object>`                                | :ref:`dict2inst<class_@GDScript_dict2inst>` **(** :ref:`Dictionary<class_dictionary>` dict **)**                                                                                                                                |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`ease<class_@GDScript_ease>` **(** :ref:`float<class_float>` s, :ref:`float<class_float>` curve **)**                                                                                                                      |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`exp<class_@GDScript_exp>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`floor<class_@GDScript_floor>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                     |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`fmod<class_@GDScript_fmod>` **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**                                                                                                                          |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`fposmod<class_@GDScript_fposmod>` **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**                                                                                                                    |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_object>`                                | :ref:`funcref<class_@GDScript_funcref>` **(** :ref:`Object<class_object>` instance, :ref:`String<class_string>` funcname **)**                                                                                                  |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                                      | :ref:`hash<class_@GDScript_hash>` **(** :ref:`Variant<class_variant>` var **)**                                                                                                                                                 |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Dictionary<class_dictionary>`                        | :ref:`inst2dict<class_@GDScript_inst2dict>` **(** :ref:`Object<class_object>` inst **)**                                                                                                                                        |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_object>`                                | :ref:`instance_from_id<class_@GDScript_instance_from_id>` **(** :ref:`int<class_int>` instance_id **)**                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`inverse_lerp<class_@GDScript_inverse_lerp>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**                                                                    |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                                    | :ref:`is_inf<class_@GDScript_is_inf>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                   |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                                    | :ref:`is_nan<class_@GDScript_is_nan>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                   |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                                      | :ref:`len<class_@GDScript_len>` **(** :ref:`Variant<class_variant>` var **)**                                                                                                                                                   |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`lerp<class_@GDScript_lerp>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to, :ref:`float<class_float>` weight **)**                                                                                    |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`linear2db<class_@GDScript_linear2db>` **(** :ref:`float<class_float>` nrg **)**                                                                                                                                           |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_object>`                                | :ref:`load<class_@GDScript_load>` **(** :ref:`String<class_string>` path **)**                                                                                                                                                  |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`log<class_@GDScript_log>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`max<class_@GDScript_max>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**                                                                                                                            |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`min<class_@GDScript_min>` **(** :ref:`float<class_float>` a, :ref:`float<class_float>` b **)**                                                                                                                            |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                                      | :ref:`nearest_po2<class_@GDScript_nearest_po2>` **(** :ref:`int<class_int>` value **)**                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_variant>`                              | :ref:`parse_json<class_@GDScript_parse_json>` **(** :ref:`String<class_string>` json **)**                                                                                                                                      |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_vector2>`                              | :ref:`polar2cartesian<class_@GDScript_polar2cartesian>` **(** :ref:`float<class_float>` r, :ref:`float<class_float>` th **)**                                                                                                   |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`pow<class_@GDScript_pow>` **(** :ref:`float<class_float>` x, :ref:`float<class_float>` y **)**                                                                                                                            |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Resource<class_resource>`                            | :ref:`preload<class_@GDScript_preload>` **(** :ref:`String<class_string>` path **)**                                                                                                                                            |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`print<class_@GDScript_print>` **(** **)** vararg                                                                                                                                                                          |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`print_stack<class_@GDScript_print_stack>` **(** **)**                                                                                                                                                                     |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`printerr<class_@GDScript_printerr>` **(** **)** vararg                                                                                                                                                                    |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`printraw<class_@GDScript_printraw>` **(** **)** vararg                                                                                                                                                                    |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`prints<class_@GDScript_prints>` **(** **)** vararg                                                                                                                                                                        |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`printt<class_@GDScript_printt>` **(** **)** vararg                                                                                                                                                                        |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`rad2deg<class_@GDScript_rad2deg>` **(** :ref:`float<class_float>` rad **)**                                                                                                                                               |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`rand_range<class_@GDScript_rand_range>` **(** :ref:`float<class_float>` from, :ref:`float<class_float>` to **)**                                                                                                          |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_array>`                                  | :ref:`rand_seed<class_@GDScript_rand_seed>` **(** :ref:`int<class_int>` seed **)**                                                                                                                                              |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`randf<class_@GDScript_randf>` **(** **)**                                                                                                                                                                                 |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                                      | :ref:`randi<class_@GDScript_randi>` **(** **)**                                                                                                                                                                                 |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`randomize<class_@GDScript_randomize>` **(** **)**                                                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_array>`                                  | :ref:`range<class_@GDScript_range>` **(** **)** vararg                                                                                                                                                                          |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`range_lerp<class_@GDScript_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_round>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                     |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| void                                                       | :ref:`seed<class_@GDScript_seed>` **(** :ref:`int<class_int>` seed **)**                                                                                                                                                        |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`sign<class_@GDScript_sign>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`sin<class_@GDScript_sin>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`sinh<class_@GDScript_sinh>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`sqrt<class_@GDScript_sqrt>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`stepify<class_@GDScript_stepify>` **(** :ref:`float<class_float>` s, :ref:`float<class_float>` step **)**                                                                                                                 |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_string>`                                | :ref:`str<class_@GDScript_str>` **(** **)** vararg                                                                                                                                                                              |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_variant>`                              | :ref:`str2var<class_@GDScript_str2var>` **(** :ref:`String<class_string>` string **)**                                                                                                                                          |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`tan<class_@GDScript_tan>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                         |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`tanh<class_@GDScript_tanh>` **(** :ref:`float<class_float>` s **)**                                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_string>`                                | :ref:`to_json<class_@GDScript_to_json>` **(** :ref:`Variant<class_variant>` var **)**                                                                                                                                           |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                                    | :ref:`type_exists<class_@GDScript_type_exists>` **(** :ref:`String<class_string>` type **)**                                                                                                                                    |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                                      | :ref:`typeof<class_@GDScript_typeof>` **(** :ref:`Variant<class_variant>` what **)**                                                                                                                                            |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_string>`                                | :ref:`validate_json<class_@GDScript_validate_json>` **(** :ref:`String<class_string>` json **)**                                                                                                                                |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PoolByteArray<class_poolbytearray>`                  | :ref:`var2bytes<class_@GDScript_var2bytes>` **(** :ref:`Variant<class_variant>` var **)**                                                                                                                                       |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_string>`                                | :ref:`var2str<class_@GDScript_var2str>` **(** :ref:`Variant<class_variant>` var **)**                                                                                                                                           |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_object>`                                | :ref:`weakref<class_@GDScript_weakref>` **(** :ref:`Object<class_object>` obj **)**                                                                                                                                             |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>`                                  | :ref:`wrapf<class_@GDScript_wrapf>` **(** :ref:`float<class_float>` value, :ref:`float<class_float>` min, :ref:`float<class_float>` max **)**                                                                                   |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                                      | :ref:`wrapi<class_@GDScript_wrapi>` **(** :ref:`int<class_int>` value, :ref:`int<class_int>` min, :ref:`int<class_int>` max **)**                                                                                               |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`GDScriptFunctionState<class_gdscriptfunctionstate>`  | :ref:`yield<class_@GDScript_yield>` **(** :ref:`Object<class_object>` object=null, :ref:`String<class_string>` signal="" **)**                                                                                                  |
+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Numeric Constants
-----------------

- **PI** = **3.141593** --- Constant that represents how many times the diameter of a circle fits around its perimeter.
- **TAU** = **6.283185** --- The circle constant, the circumference of the unit circle.
- **INF** = **inf** --- A positive infinity. (For negative infinity, use -INF).
- **NAN** = **nan** --- Macro constant that expands to an expression of type float that represents a NaN.

The NaN values are used to identify undefined or non-representable values for floating-point elements, such as the square root of negative numbers or the result of 0/0.

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

This contains the list of built-in gdscript functions. Mostly math functions and other utilities. Everything else is expanded by objects.

Member Function Description
---------------------------

.. _class_@GDScript_Color8:

- :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 32 bit color with red, green, blue and alpha channels. Each channel has 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)

.. _class_@GDScript_ColorN:

- :ref:`Color<class_color>` **ColorN** **(** :ref:`String<class_string>` name, :ref:`float<class_float>` alpha=1.0 **)**

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

::

    red = ColorN("red", 1)

Supported color names:

"aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown", "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflower", "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod", "darkgray", "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen", "darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen", "darkslateblue", "darkslategray", "darkturquoise", "darkviolet", "deeppink", "deepskyblue", "dimgray", "dodgerblue", "firebrick", "floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold", "goldenrod", "gray", "webgray", "green", "webgreen", "greenyellow", "honeydew", "hotpink", "indianred", "indigo", "ivory", "khaki", "lavender", "lavenderblush", "lawngreen", "lemonchiffon", "lightblue", "lightcoral", "lightcyan", "lightgoldenrod", "lightgray", "lightgreen", "lightpink", "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray", "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta", "maroon", "webmaroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise", "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin", "navajowhite", "navyblue", "oldlace", "olive", "olivedrab", "orange", "orangered", "orchid", "palegoldenrod", "palegreen", "paleturquoise", "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple", "webpurple", "rebeccapurple", "red", "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver", "skyblue", "slateblue", "slategray", "snow", "springgreen", "steelblue", "tan", "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke", "yellow", "yellowgreen".

.. _class_@GDScript_abs:

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

Returns the absolute value of parameter ``s``  (i.e. unsigned value, works for integer and float).

::

    # a is 1
    a = abs(-1)

.. _class_@GDScript_acos:

- :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``.

::

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

.. _class_@GDScript_asin:

- :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 is 0.523599 or 30 degrees if converted with rad2deg(s)
    s = asin(0.5)

.. _class_@GDScript_assert:

- void **assert** **(** :ref:`bool<class_bool>` condition **)**

Assert that the ``condition`` is true. If the ``condition`` is false a fatal error is generated and the program is halted. Useful for debugging to make sure a value is always true.

::

    # Speed should always be between 0 and 20
    speed = -10
    assert(speed < 20) # Is true and program continues
    assert(speed >= 0) # Is false and program stops
    assert(speed >= 0 && speed < 20) # Or combined

.. _class_@GDScript_atan:

- :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_atan2>` if you always want an exact angle.

::

    a = atan(0.5) # a is 0.463648

.. _class_@GDScript_atan2:

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

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.

::

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

.. _class_@GDScript_bytes2var:

- :ref:`Variant<class_variant>` **bytes2var** **(** :ref:`PoolByteArray<class_poolbytearray>` bytes **)**

Decodes a byte array back to a value.

.. _class_@GDScript_cartesian2polar:

- :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).

.. _class_@GDScript_ceil:

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

Rounds ``s`` upward, returning the smallest integral value that is not less than ``s``.

::

    i = ceil(1.45)  # i is 2
    i = ceil(1.001) # i is 2

.. _class_@GDScript_char:

- :ref:`String<class_string>` **char** **(** :ref:`int<class_int>` ascii **)**

Returns a character as a String of the given ASCII code.

::

    # a is 'A'
    a = char(65)
    # a is 'a'
    a = char(65+32)

.. _class_@GDScript_clamp:

- :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``.

::

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

.. _class_@GDScript_convert:

- :ref:`Object<class_object>` **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 enum TYPE\_\* in :ref:`@GlobalScope<class_@globalscope>`.

::

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

.. _class_@GDScript_cos:

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

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

::

    # prints 1 and -1
    print(cos(PI*2))
    print(cos(PI))

.. _class_@GDScript_cosh:

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

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

::

    # prints 1.543081
    print(cosh(1))

.. _class_@GDScript_db2linear:

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

Converts from decibels to linear energy (audio).

.. _class_@GDScript_decimals:

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

Returns the position of the first non-zero digit, after the decimal point.

::

    # n is 2
    n = decimals(0.035)

.. _class_@GDScript_dectime:

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

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

::

    # a = 59
    a = dectime(60, 10, 0.1))

.. _class_@GDScript_deg2rad:

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

Returns degrees converted to radians.

::

    # r is 3.141593
    r = deg2rad(180)

.. _class_@GDScript_dict2inst:

- :ref:`Object<class_object>` **dict2inst** **(** :ref:`Dictionary<class_dictionary>` dict **)**

Converts a previously converted instance to a dictionary, back into an instance. Useful for deserializing.

.. _class_@GDScript_ease:

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

Easing function, based on exponent. 0 is constant, 1 is linear, 0 to 1 is ease-in, 1+ is ease out. Negative values are in-out/out in.

.. _class_@GDScript_exp:

- :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.

::

    a = exp(2) # approximately 7.39

.. _class_@GDScript_floor:

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

Rounds ``s`` to the closest smaller integer and returns it.

::

    # a is 2
    a = floor(2.99)
    # a is -3
    a = floor(-2.99)

.. _class_@GDScript_fmod:

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

Returns the floating-point remainder of ``x/y``.

::

    # remainder is 1.5
    var remainder = fmod(7, 5.5)

.. _class_@GDScript_fposmod:

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

Returns the floating-point remainder of ``x/y`` that wraps equally in positive and negative.

::

    var i = -10;
    while i < 0:
        prints(i, fposmod(i, 10))
        i += 1

Produces:

::

    -10 10
    -9 1
    -8 2
    -7 3
    -6 4
    -5 5
    -4 6
    -3 7
    -2 8
    -1 9

.. _class_@GDScript_funcref:

- :ref:`Object<class_object>` **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

.. _class_@GDScript_hash:

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

Returns the integer hash of the variable passed.

::

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

.. _class_@GDScript_inst2dict:

- :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]

.. _class_@GDScript_instance_from_id:

- :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

.. _class_@GDScript_inverse_lerp:

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

Returns a normalized value considering the given range.

::

    inverse_lerp(3, 5, 4) # returns 0.5

.. _class_@GDScript_is_inf:

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

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

.. _class_@GDScript_is_nan:

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

Returns True/False whether ``s`` is a NaN (Not-A-Number) value.

.. _class_@GDScript_len:

- :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

.. _class_@GDScript_lerp:

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

Linearly interpolates between two values by a normalized value.

::

    lerp(1, 3, 0.5) # returns 2

.. _class_@GDScript_linear2db:

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

Converts from linear energy to decibels (audio).

.. _class_@GDScript_load:

- :ref:`Object<class_object>` **load** **(** :ref:`String<class_string>` path **)**

Loads a resource from the filesystem located at ``path``. Note: resource paths can be obtained by right clicking on a resource in the Assets Panel and choosing "Copy Path".

::

    # load a scene called main located in the root of the project directory
    var main = load("res://main.tscn")

.. _class_@GDScript_log:

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

Natural logarithm. The amount of time needed to reach a certain level of continuous growth. Note: This is not the same as the log function on your calculator which is a base 10 logarithm.

::

    log(10) # returns 2.302585

.. _class_@GDScript_max:

- :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

.. _class_@GDScript_min:

- :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

.. _class_@GDScript_nearest_po2:

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

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

::

    nearest_po2(3) # returns 4
    nearest_po2(4) # returns 4
    nearest_po2(5) # returns 8

.. _class_@GDScript_parse_json:

- :ref:`Variant<class_variant>` **parse_json** **(** :ref:`String<class_string>` json **)**

Parse JSON text to a Variant (use :ref:`typeof<class_@GDScript_typeof>` to check if it is what you expect).

Be aware that 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 that 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:

::

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

.. _class_@GDScript_polar2cartesian:

- :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).

.. _class_@GDScript_pow:

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

Returns the result of ``x`` raised to the power of ``y``.

::

    pow(2,5) # returns 32

.. _class_@GDScript_preload:

- :ref:`Resource<class_resource>` **preload** **(** :ref:`String<class_string>` path **)**

Returns a resource from the filesystem that is loaded during script parsing. Note: resource paths can be obtained by right clicking on a resource in the Assets Panel and choosing "Copy Path".

::

    # load a scene called main located in the root of the project directory
    var main = preload("res://main.tscn")

.. _class_@GDScript_print:

- void **print** **(** **)** vararg

Converts one or more arguments to strings in the best way possible and prints them to the console.

::

    a = [1,2,3]
    print("a","b",a) # prints ab[1, 2, 3]

.. _class_@GDScript_print_stack:

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

Prints a stack track at code location, only works when running with debugger turned on.

Output in the console would look something like this:

::

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

.. _class_@GDScript_printerr:

- void **printerr** **(** **)** vararg

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

::

    printerr("prints to stderr")

.. _class_@GDScript_printraw:

- 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

.. _class_@GDScript_prints:

- 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

.. _class_@GDScript_printt:

- 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

.. _class_@GDScript_rad2deg:

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

Converts from radians to degrees.

::

    rad2deg(0.523599) # returns 30

.. _class_@GDScript_rand_range:

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

Random range, any floating point value between ``from`` and ``to``.

::

    prints(rand_range(0, 1), rand_range(0, 1)) # prints 0.135591 0.405263

.. _class_@GDScript_rand_seed:

- :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.

.. _class_@GDScript_randf:

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

Returns a random floating point value between 0 and 1.

::

    randf() # returns 0.375671

.. _class_@GDScript_randi:

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

Returns a random 32 bit integer. Use remainder to obtain a random value between 0 and N (where N is smaller than 2^32 -1).

::

    randi() % 20      # returns random number between 0 and 19
    randi() % 100     # returns random number between 0 and 99
    randi() % 100 + 1 # returns random number between 1 and 100

.. _class_@GDScript_randomize:

- 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()

.. _class_@GDScript_range:

- :ref:`Array<class_array>` **range** **(** **)** vararg

Returns an array with the given range. Range can be 1 argument N (0 to N-1), two arguments (initial, final-1) or three arguments (initial, final-1, increment).

::

    for i in range(4):
        print(i)
    for i in range(2, 5):
        print(i)
    for i in range(0, 6, 2):
        print(i)

Output:

::

    0
    1
    2
    3
    
    2
    3
    4
    
    0
    2
    4

.. _class_@GDScript_range_lerp:

- :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]``.

::

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

.. _class_@GDScript_round:

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

Returns the integral value that is nearest to ``s``, with halfway cases rounded away from zero.

::

    round(2.6) # returns 3

.. _class_@GDScript_seed:

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

Sets seed for the random number generator.

::

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

.. _class_@GDScript_sign:

- :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

.. _class_@GDScript_sin:

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

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

::

    sin(0.523599) # returns 0.5

.. _class_@GDScript_sinh:

- :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

.. _class_@GDScript_sqrt:

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

Returns the square root of ``s``.

::

    sqrt(9) # returns 3

.. _class_@GDScript_stepify:

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

Snaps float value ``s`` to a given ``step``.

.. _class_@GDScript_str:

- :ref:`String<class_string>` **str** **(** **)** vararg

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

::

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

.. _class_@GDScript_str2var:

- :ref:`Variant<class_variant>` **str2var** **(** :ref:`String<class_string>` string **)**

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

::

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

.. _class_@GDScript_tan:

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

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

::

    tan( deg2rad(45) ) # returns 1

.. _class_@GDScript_tanh:

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

Returns the hyperbolic tangent of ``s``.

::

    a = log(2.0) # returns 0.693147
    tanh(a)      # returns 0.6

.. _class_@GDScript_to_json:

- :ref:`String<class_string>` **to_json** **(** :ref:`Variant<class_variant>` var **)**

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

::

    a = { 'a': 1, 'b': 2 }
    b = to_json(a)
    print(b) # {"a":1, "b":2}

.. _class_@GDScript_type_exists:

- :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

.. _class_@GDScript_typeof:

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

Returns the internal type of the given Variant object, using the TYPE\_\* enum in :ref:`@GlobalScope<class_@globalscope>`.

::

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

.. _class_@GDScript_validate_json:

- :ref:`String<class_string>` **validate_json** **(** :ref:`String<class_string>` json **)**

Checks that ``json`` is valid JSON data. Returns empty string if valid. Returns error message if not valid.

::

    j = to_json([1, 2, 3])
    v = validate_json(j)
    if not v:
        print("valid")
    else:
        prints("invalid", v)

.. _class_@GDScript_var2bytes:

- :ref:`PoolByteArray<class_poolbytearray>` **var2bytes** **(** :ref:`Variant<class_variant>` var **)**

Encodes a variable value to a byte array.

.. _class_@GDScript_var2str:

- :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_str2var>`.

::

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

prints

::

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

.. _class_@GDScript_weakref:

- :ref:`Object<class_object>` **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.

.. _class_@GDScript_wrapf:

- :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.

::

    # a is 0.5
    a = wrapf(10.5, 0.0, 10.0)

::

    # a is 9.5
    a = wrapf(-0.5, 0.0, 10.0)

::

    # infinite loop between 0.0 and 0.99
    f = wrapf(f + 0.1, 0.0, 1.0)

.. _class_@GDScript_wrapi:

- :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.

::

    # a is 0
    a = wrapi(10, 0, 10)

::

    # a is 9
    a = wrapi(-1, 0, 10)

::

    # infinite loop between 0 and 9
    frame = wrapi(frame + 1, 0, 10)

.. _class_@GDScript_yield:

- :ref:`GDScriptFunctionState<class_gdscriptfunctionstate>` **yield** **(** :ref:`Object<class_object>` object=null, :ref:`String<class_string>` signal="" **)**

Stops the function execution and returns the current state. Call :ref:`GDScriptFunctionState.resume<class_GDScriptFunctionState_resume>` on the state to resume execution. This invalidates the state.

Returns anything that was passed to the resume function call. If passed an object and a signal, the execution is resumed when the object's signal is emitted.