@GDScript

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

PI = 3.141593 —- Constant that represents how many times the diameter of a circle fits around its perimeter. This is equivalent to .
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.
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 and will result in a run-time error instead.

NAN = nan —- “Not a Number”, an invalid floating-point value. 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 and will result in a run-time error instead.

Color8 ( int r8, g8, int b8, 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

Color ColorN ( name, 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 .

float abs ( s )

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

a = abs(-1) # a is 1

float acos ( s )

Returns the arc cosine of s in radians. Use to get the angle of cosine s. s must be between -1.0 and 1.0 (inclusive), otherwise, acos will return .

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

float asin ( s )

Returns the arc sine of s in radians. Use to get the angle of sine s. s must be between -1.0 and 1.0 (inclusive), otherwise, asin will return .

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

void assert ( bool condition, 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 push_error for reporting errors to project developers or add-on users.

Note: For performance reasons, the code inside is only executed in debug builds or when running the project from the editor. Don’t include code that has side effects in an 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

atan ( 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 if you have both y and x.

a = atan(0.5) # a is 0.463648

float atan2 ( y, 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

bytes2var ( PoolByteArray bytes, 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).

Vector2 cartesian2polar ( x, 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).

ceil ( 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 ceil, , stepify, and .

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

float fmod ( a, 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.

fposmod ( float a, 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

FuncRef funcref ( instance, 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 in a variable and call it later.

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

Array get_stack ( )

Returns an array of dictionaries representing the current call stack.

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

hash ( Variant var )

Returns the integer hash of the variable passed.

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

inst2dict ( Object inst )

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

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

Prints out:

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

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

inverse_lerp ( float from, to, 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).

See also which performs the reverse of this operation.

bool is_equal_approx ( a, 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.

is_inf ( float s )

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

is_instance_valid ( Object instance )

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

is_nan ( float s )

Returns whether s is a NaN (“Not a Number” or invalid) value.

is_zero_approx ( float s )

Returns true if s is zero or almost zero.

This method is faster than using with one value as zero.

int len ( 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

Variant lerp ( from, Variant to, 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.

If the from and to arguments are of type int or , the return value is a float.

If both are of the same vector type (, Vector3 or ), 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 inverse_lerp which performs the reverse of this operation. To perform eased interpolation with , combine it with ease or .

float lerp_angle ( from, float to, weight )

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

Similar to lerp, but interpolates correctly when the angles wrap around . To perform eased interpolation with lerp_angle, combine it with or 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.

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

load ( 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 .

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 ResourceLoader.load, which can be used for more advanced scenarios.

log ( 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 most calculators, which uses a base 10 logarithm.

log(10) # Returns 2.302585

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

max ( float a, b )

Returns the maximum of two values.

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

float min ( a, float b )

Returns the minimum of two values.

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

move_toward ( float from, to, 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

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

ord ( 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 .

Variant parse_json ( json )

Parse JSON text to a Variant. (Use 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 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 JSON for an alternative way to parse JSON text.

polar2cartesian ( float r, 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).

int posmod ( a, 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:

pow ( float base, exp )

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

pow(2, 5) # Returns 32.0

Resource preload ( path )

Returns a Resource from the filesystem located at path. The resource is loaded during script parsing, i.e. is loaded with the script and 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 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()

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 and push_warning to print error and warning messages instead of . This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed.

void print_debug ( … ) vararg

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

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'

void printerr ( … ) vararg

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

printerr("prints to stderr")

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 .

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

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

void push_error ( 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.

void push_warning ( 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

float rad2deg ( rad )

Converts an angle expressed in radians to degrees.

rad2deg(0.523599) # Returns 30.0

float rand_range ( from, 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.

rand_seed ( 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.

randf ( )

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

randf() # Returns e.g. 0.375671

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

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

Returns an array with the given 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 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.

range converts all arguments to 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 Array backwards, use:

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

Output:

9
6
3

range_lerp ( float value, istart, float istop, ostart, float ostop )

Maps a value from range [istart, istop] to [ostart, ostop].

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

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