@GDScript

Category: Core

Brief Description

Built-in GDScript functions.

Methods

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

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

Method Descriptions

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

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

• float abs ( float s )

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

# a is 1
a = abs(-1)

• float acos ( 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)

• float asin ( 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)

• void assert ( bool condition )

Asserts that the condition is true . If the condition is false, an error is generated and the program is halted until you resume it. Only executes in debug builds, or when running the game from the editor. Use it for debugging purposes, to make sure a statement is true during development.

# Imagine we always want speed to be between 0 and 20
speed = -10
assert(speed < 20) # True, the program will continue
assert(speed >= 0) # False, the program will stop
assert(speed >= 0 && speed < 20) # You can also combine the two conditional statements in one check

• float 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 atan2 if you always want an exact angle.

a = atan(0.5) # a is 0.463648

• float atan2 ( float 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.

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

• Variant bytes2var ( PoolByteArray bytes, bool allow_objects=false )

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

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

• Vector2 cartesian2polar ( float 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).

• float ceil ( 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

• String char ( 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)

• float clamp ( float value, float min, 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)

• Variant convert ( Variant what, int type )

Converts from a type to another in the best way possible. The type parameter uses the enum TYPE_* in @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())

• float cos ( float s )

Returns the cosine of angle s in radians.

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

• float cosh ( float s )

Returns the hyperbolic cosine of s in radians.

# prints 1.543081
print(cosh(1))

• float db2linear ( float db )

Converts from decibels to linear energy (audio).

• float decimals ( float step )

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

# n is 2
n = decimals(0.035)

• float dectime ( float value, float amount, float step )

Returns the result of value decreased by step * amount.

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

• float deg2rad ( float deg )

Returns degrees converted to radians.

# r is 3.141593
r = deg2rad(180)

• Object dict2inst ( Dictionary dict )

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

• float ease ( float s, 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.

• float exp ( 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.

For exponents to other bases use the method pow.

a = exp(2) # approximately 7.39

• float floor ( 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)

• float fmod ( float x, float y )

Returns the floating-point remainder of x/y.

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

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

• FuncRef funcref ( Object 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 FuncRef 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())

would print

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

• int hash ( Variant var )

Returns the integer hash of the variable passed.

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

• Dictionary 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.keys())
    print(d.values())

Prints out:

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

• Object 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

• float inverse_lerp ( float from, float to, float weight )

Returns a normalized value considering the given range.

inverse_lerp(3, 5, 4) # returns 0.5

• bool is_inf ( float s )

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

• bool is_instance_valid ( Object instance )

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

• bool is_nan ( float s )

Returns whether s is a NaN (Not-A-Number) value.

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

• Variant lerp ( Variant from, Variant to, float weight )

Linearly interpolates between two values by a normalized value.

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

If both are of the same vector type (Vector2, Vector3 or Color), the return value will be of the same type (lerp then calls the vector type’s linear_interpolate method).

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

• float linear2db ( float nrg )

Converts from linear energy to decibels (audio).

• Resource load ( 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")

• float 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 your calculator which is a base 10 logarithm.

log(10) # returns 2.302585

• float max ( float a, float b )

Returns the maximum of two values.

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

• float min ( float a, float b )

Returns the minimum of two values.

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

• int nearest_po2 ( 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

• Variant parse_json ( String json )

Parse JSON text to a Variant (use 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 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")

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

• float pow ( float x, float y )

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

pow(2, 5) # returns 32

• Resource preload ( 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")

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

• void print_debug ( … ) vararg

Like print, but prints only when used in debug mode.

• 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

• 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

• void push_warning ( String message )

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

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

• float rad2deg ( float rad )

Converts from radians to degrees.

rad2deg(0.523599) # returns 30

• float rand_range ( float from, float to )

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

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

• Array 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.

• float 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] (where N is smaller than 2^32 -1).

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

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

• 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

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

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

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

• float round ( float s )

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

round(2.6) # returns 3

• void seed ( int seed )

Sets seed for the random number generator.

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

• float sign ( 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

• float sin ( float s )

Returns the sine of angle s in radians.

sin(0.523599) # returns 0.5

• float sinh ( float s )

Returns the hyperbolic sine of s.

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

• float smoothstep ( float from, float to, float weight )

Returns a number smoothly interpolated between the from and to, based on the weight. Similar to lerp, but interpolates faster at the beginning and slower at the end.

smoothstep(0, 2, 0.5) # returns 0.15
smoothstep(0, 2, 1.0) # returns 0.5
smoothstep(0, 2, 2.0) # returns 1.0

• float sqrt ( float s )

Returns the square root of s.

sqrt(9) # returns 3

• float stepify ( float s, float step )

Snaps float value s to a given step.

• 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

• Variant str2var ( String string )

Converts a formatted string that was returned by var2str to the original value.

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

• float tan ( float s )

Returns the tangent of angle s in radians.

tan(deg2rad(45)) # returns 1

• float tanh ( float s )

Returns the hyperbolic tangent of s.

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

• String to_json ( 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}

• bool type_exists ( String type )

Returns whether the given class exists in ClassDB.

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

• int typeof ( Variant what )

Returns the internal type of the given Variant object, using the TYPE_* enum in @GlobalScope.

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

• String validate_json ( 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)

• PoolByteArray var2bytes ( Variant var, bool full_objects=false )

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

• String var2str ( Variant var )

Converts a Variant var to a formatted string that can later be parsed using str2var.

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

prints

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

• WeakRef weakref ( 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.

• float wrapf ( float value, float min, 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)

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

Note: If you just want to wrap between 0.0 and n (where n is a positive float value) then it’s better for performance to use fmod method like fmod(number, n).

The usage of wrapf is more flexible than using the fmod approach by giving the user a simple control over the minimum value. It also fully supports negative numbers, e.g.

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

• int wrapi ( int value, int min, 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)

Note: If you just want to wrap between 0 and n (where n is a positive integer value) then it’s better for performance to use modulo operator like number % n.

The usage of wrapi is more flexible than using the modulo approach by giving the user a simple control over the minimum value. It also fully supports negative numbers, e.g.

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

• GDScriptFunctionState yield ( Object object=null, String signal=”” )

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

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

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