Godot Engine

https://docs.godotengine.org/en/4.4
Admin
Godot Engine is a free and open-source game engine providing a comprehensive set of tools for...
Tokens:5,365,440
Snippets:68,737
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### GDScript: Deferred navigation setup with call_deferred

Source: https://docs.godotengine.org/en/4.4/tutorials/navigation/navigation_using_navigationservers.html

Use this GDScript example to avoid empty or wrong path queries at game start. It defers a custom setup function so all scene tree nodes are ready, then creates a navigation map and region on the NavigationServer3D before the next physics frame.

```GDScript
extends Node3D

func _ready():
	# Use call deferred to make sure the entire scene tree nodes are setup
	# else await on 'physics_frame' in a _ready() might get stuck.
	custom_setup.call_deferred()

func custom_setup():

	# Create a new navigation map.
	var map: RID = NavigationServer3D.map_create()
	NavigationServer3D.map_set_up(map, Vector3.UP)
	NavigationServer3D.map_set_active(map, true)

	# Create a new navigation region and add it to the map.
	var region: RID = NavigationServer3D.region_create()
	NavigationServer3D.region_set_transform(region, Transform3D())
	NavigationServer3D.region_set_map(region, map)

```

--------------------------------

### Hello world in C#

Source: https://docs.godotengine.org/en/4.4/about/introduction.html

Basic C# example that prints 'Hello world!' to the output when the node is ready. Use this as a starting point for learning C# with Godot.

```csharp
public override void _Ready()
{
    GD.Print("Hello world!");
}

```

--------------------------------

### Hello world in GDScript

Source: https://docs.godotengine.org/en/4.4/about/introduction.html

Basic GDScript example that prints 'Hello world!' to the output when the node is ready. Use this as a starting point for learning GDScript syntax.

```gdscript
func _ready():
	print("Hello world!")

```

--------------------------------

### Complete GDScript class example following style guide

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdscript/gdscript_styleguide.html

A full class example that follows the style guide's conventions. It defines a hierarchical state machine for the player, initializes states, and delegates engine callbacks. Use it as a reference for structuring GDScript classes with signals, exports, properties, and lifecycle methods.

```gdscript
class_name StateMachine
extends Node
## Hierarchical State machine for the player.
##
## Initializes states and delegates engine callbacks ([method Node._physics_process],
## [method Node._unhandled_input]) to the state.

signal state_changed(previous, new)

@export var initial_state: Node
var is_active = true:
	set = set_is_active

@onready var _state = initial_state:
	set = set_state
@onready var _state_name = _state.name


func _init():
	add_to_group("state_machine")


func _enter_tree():
	print("this happens before ready")
```

--------------------------------

### File structure for GDExtension C example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdextension/gdextension_c_example.html

Shows the directory layout for the example project, with a demo folder for the game and a src folder for the extension source code.

```text
gdextension_c_example/
|
+--demo/                  # game example/demo to test the extension
|
+--src/                   # source code of the extension we are building

```

--------------------------------

### Complete script example with documentation comments

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdscript/gdscript_documentation_comments.html

A complete GDScript example showing how to document a class, signals, enums, constants, variables, functions, and inner classes. Includes tags like `@tutorial` and `@experimental`. Members starting with an underscore are treated as private unless documented.

```gdscript
extends Node2D
## A brief description of the class's role and functionality.
##
## The description of the script, what it can do,
## and any further detail.
##
## @tutorial:             https://example.com/tutorial_1
## @tutorial(Tutorial 2): https://example.com/tutorial_2
## @experimental

## The description of a signal.
signal my_signal

## This is a description of the below enum.
enum Direction {
	## Direction up.
	UP = 0,
	## Direction down.
	DOWN = 1,
	## Direction left.
	LEFT = 2,
	## Direction right.
	RIGHT = 3,
}

## The description of a constant.
const GRAVITY = 9.8

## The description of the variable v1.
var v1

## This is a multiline description of the variable v2.[br]
## The type information below will be extracted for the documentation.
var v2: int

## If the member has any annotation, the annotation should
## immediately precede it.
@export
var v3 := some_func()


## As the following function is documented, even though its name starts with
## an underscore, it will appear in the help window.
func _fn(p1: int, p2: String) -> int:
	return 0


# The below function isn't documented and its name starts with an underscore
# so it will treated as private and will not be shown in the help window.
func _internal() -> void:
	pass


## Documenting an inner class.
##
## The same rules apply here. The documentation must
## immediately precede the class definition.
##
## @tutorial: https://example.com/tutorial
## @experimental
class Inner:

	## Inner class variable v4.
	var v4


	## Inner class function fn.
	func fn(): pass

```

--------------------------------

### Methods and static functions example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdscript/gdscript_styleguide.html

Example showing the order for methods: _init, _ready, other virtual callbacks, then public and private methods. This order shows how the object is initialized and its main loop.

```gdscript
func _init():
	add_to_group("state_machine")


func _ready():
	state_changed.connect(_on_state_changed)
	_state.enter()


func _unhandled_input(event):
	_state.unhandled_input(event)


func transition_to(target_state_path, msg={}):
	if not has_node(target_state_path):
		return

	var target_state = get_node(target_state_path)
	assert(target_state.is_composite == false)

	_state.exit()
	self._state = target_state
	_state.enter(msg)
	Events.player_state_changed.emit(_state.name)


func _on_state_changed(previous, new):
	print("state changed")
	state_changed.emit()

```

--------------------------------

### Initialize WebXR and start an immersive VR session

Source: https://docs.godotengine.org/en/4.4/classes/class_webxrinterface.html

Minimal GDScript example to initialize WebXR and start an immersive VR session. It connects to WebXR signals, checks session support, and configures session mode, reference space types, and features. Requires a Button child node for user consent.

```GDScript
extends Node3D

var webxr_interface
var vr_supported = false

func _ready():
	# We assume this node has a button as a child.
	# This button is for the user to consent to entering immersive VR mode.
	$Button.pressed.connect(self._on_button_pressed)

	webxr_interface = XRServer.find_interface("WebXR")
	if webxr_interface:
		# WebXR uses a lot of asynchronous callbacks, so we connect to various
		# signals in order to receive them.
		webxr_interface.session_supported.connect(self._webxr_session_supported)
		webxr_interface.session_started.connect(self._webxr_session_started)
		webxr_interface.session_ended.connect(self._webxr_session_ended)
		webxr_interface.session_failed.connect(self._webxr_session_failed)

		# This returns immediately - our _webxr_session_supported() method
		# (which we connected to the "session_supported" signal above) will
		# be called sometime later to let us know if it's supported or not.
		webxr_interface.is_session_supported("immersive-vr")

func _webxr_session_supported(session_mode, supported):
	if session_mode == 'immersive-vr':
		vr_supported = supported

func _on_button_pressed():
	if not vr_supported:
		OS.alert("Your browser doesn't support VR")
		return

	# We want an immersive VR session, as opposed to AR ('immersive-ar') or a
	# simple 3DoF viewer ('viewer').
	webxr_interface.session_mode = 'immersive-vr'
	# 'bounded-floor' is room scale, 'local-floor' is a standing or sitting
	# experience (it puts you 1.6m above the ground if you have 3DoF headset),
	# whereas as 'local' puts you down at the XROrigin.
	# This list means it'll first try to request 'bounded-floor', then
	# fallback on 'local-floor' and ultimately 'local', if nothing else is
	# supported.
	webxr_interface.requested_reference_space_types = 'bounded-floor, local-floor, local'
	# In order to use 'local-floor' or 'bounded-floor' we must also
	# mark the features as required or optional. By including 'hand-tracking'
	# as an optional feature, it will be enabled if supported.
	webxr_interface.required_features = 'local-floor'
	webxr_interface.optional_features = 'bounded-floor, hand-tracking'

	# This will return false if we're unable to even request the session,
	# however, it can still fail asynchronously later in the process, so we
	# only know if it's really succeeded or failed when our
	# _webxr_session_started() or _webxr_session_failed() methods are called.
	if not webxr_interface.initialize():
		OS.alert("Failed to initialize")
		return

func _webxr_session_started():
	$Button.visible = false
	# This tells Godot to start rendering to the headset.
	get_viewport().use_xr = true
	# This will be the reference space type you ultimately got, out of the
	# types that you requested above. This is useful if you want the game to
	# work a little differently in 'bounded-floor' versus 'local-floor'.
	print("Reference space type: ", webxr_interface.reference_space_type)
	# This will be the list of features that were successfully enabled
	# (except on browsers that don't support this property).
	print("Enabled features: ", webxr_interface.enabled_features)

func _webxr_session_ended():
	$Button.visible = true
	# If the user exits immersive mode, then we tell Godot to render to the web
	# page again.
	get_viewport().use_xr = false

func _webxr_session_failed(message):
	OS.alert("Failed to initialize: " + message)

```

--------------------------------

### Retrieve and travel to a state (C#)

Source: https://docs.godotengine.org/en/4.4/classes/class_animationnodestatemachineplayback.html

C# example showing how to get the playback object from an AnimationTree and travel to a state named "some_state".

```csharp
var stateMachine = GetNode<AnimationTree>("AnimationTree").Get("parameters/playback").As<AnimationNodeStateMachinePlayback>();
stateMachine.Travel("some_state");
```

--------------------------------

### Complete example: download a previously saved file

Source: https://docs.godotengine.org/en/4.4/tutorials/platform/web/javascript_bridge.html

Shows how to open a file with FileAccess, read its contents into a buffer, and download it via JavaScriptBridge.download_buffer(). The example creates a temporary ConfigFile, saves it to /tmp/test.cfg, and then downloads it.

```gdscript
extends Node

# Open a file for reading and download it via the JavaScript singleton.
func _download_file(path):
	var file = FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Failed to load file")
		return
	# Get the file name.
	var fname = path.get_file()
	# Read the whole file to memory.
	var buffer = file.get_buffer(file.get_len())
	# Prompt the user to download the file (will have the same name as the input file).
	JavaScriptBridge.download_buffer(buffer, fname)

func _ready():
	# Create a temporary file.
	var config = ConfigFile.new()
	config.set_value("option", "one", false)
	config.save("/tmp/test.cfg")

	# Download it
	_download_file("/tmp/test.cfg")

```

--------------------------------

### Comment Spacing: Good Example

Source: https://docs.godotengine.org/en/4.4/tutorials/shaders/shaders_style_guide.html

Regular comments start with a space, but commented-out code does not.

```glsl
// This is a comment.
//return;

```

--------------------------------

### C-style for loop examples

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdscript/gdscript_advanced.html

Three C-style for loops with different start, end, and step values.

```cpp
for (int i = 0; i < 10; i++) {}

for (int i = 5; i < 10; i++) {}

for (int i = 5; i < 10; i += 2) {}

```

--------------------------------

### GDExtension [libraries] configuration example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdextension/gdextension_file.html

Example of a [libraries] section in a .gdextension file, mapping feature flag combinations (e.g., macos.debug, windows.release.x86_64) to compiled binary paths. Each line is evaluated from top to bottom, and the flags must match Godot's feature flags or custom export flags.

```ini
[libraries]

macos.debug = "res://bin/libgdexample.macos.template_debug.framework"
macos.release = "res://bin/libgdexample.macos.template_release.framework"
windows.debug.x86_32 = "res://bin/libgdexample.windows.template_debug.x86_32.dll"
windows.release.x86_32 = "res://bin/libgdexample.windows.template_release.x86_32.dll"
windows.debug.x86_64 = "res://bin/libgdexample.windows.template_debug.x86_64.dll"
windows.release.x86_64 = "res://bin/libgdexample.windows.template_release.x86_64.dll"
linux.debug.x86_64 = "res://bin/libgdexample.linux.template_debug.x86_64.so"
linux.release.x86_64 = "res://bin/libgdexample.linux.template_release.x86_64.so"
linux.debug.arm64 = "res://bin/libgdexample.linux.template_debug.arm64.so"
linux.release.arm64 = "res://bin/libgdexample.linux.template_release.arm64.so"
linux.debug.rv64 = "res://bin/libgdexample.linux.template_debug.rv64.so"
linux.release.rv64 = "res://bin/libgdexample.linux.template_release.rv64.so"

```

--------------------------------

### Initialize submodules after cloning example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdextension/gdextension_cpp_example.html

Commands to initialize submodules when you cloned the example from the introduction link. Required because submodules are not automatically initialized.

```bash
cd gdextension_cpp_example
git submodule update --init
```

--------------------------------

### Start game with engine.startGame

Source: https://docs.godotengine.org/en/4.4/tutorials/platform/web/customizing_html5_shell.html

Creates an `Engine` instance with the exported configuration and calls `engine.startGame` to automatically load, initialize, and start the game. The method is asynchronous and returns a `Promise`. Optional `EngineConfig` parameters can be overridden, such as `unloadAfterInit` and `canvasResizePolicy`.

```javascript
const engine = new Engine($GODOT_CONFIG);
engine.startGame({
    /* optional override configuration, eg. */
    // unloadAfterInit: false,
    // canvasResizePolicy: 0,
    // ...
});

```

--------------------------------

### Project structure for GDExtension C++ example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdextension/gdextension_docs_system.html

Assumed directory layout for the GDExtension C++ example, showing the demo, godot-cpp, and src directories.

```text
gdextension_cpp_example/  # GDExtension directory
|
+--demo/                  # game example/demo to test the extension
|   |
|   +--main.tscn
|   |
|   +--bin/
|       |
|       +--gdexample.gdextension
|
+--godot-cpp/             # C++ bindings
|
+--src/                   # source code of the extension we are building
|   |
|   +--register_types.cpp
|   +--register_types.h
|   +--gdexample.cpp
|   +--gdexample.h

```

--------------------------------

### Manual engine startup with engine.start

Source: https://docs.godotengine.org/en/4.4/tutorials/platform/web/customizing_html5_shell.html

Provides full control over the startup process by manually loading and initializing the engine with `engine.init`, preloading the pck file with `engine.preloadFile`, and then starting with `engine.start`. Note that `engine.start` does not automatically preload the pck file, so it must be preloaded manually.

```javascript
const myWasm = 'mygame.wasm';
const myPck = 'mygame.pck';
const engine = new Engine();
Promise.all([
    // Load and init the engine
    engine.init(myWasm),
    // And the pck concurrently
    engine.preloadFile(myPck),
]).then(() => {
    // Now start the engine.
    return engine.start({ args: ['--main-pack', myPck] });
}).then(() => {
    console.log('Engine has started!');
});

```

--------------------------------

### Example of a good comment with admonition

Source: https://docs.godotengine.org/en/4.4/contributing/development/code_style_guidelines.html

Shows a comment block that follows the style guide: starts with a space, uses sentence case, ends with a period, and includes a FIXME admonition. The comment explains the why, not the how.

```cpp
// Compute the first 10,000 decimals of Pi.
// FIXME: Don't crash when computing the 1,337th decimal due to `increment`
//        being negative.

```

--------------------------------

### Run HTTP client example (C#)

Source: https://docs.godotengine.org/en/4.4/tutorials/networking/http_client_class.html

Command to run the C# version of the HTTP client example from the command line.

```text
c:\godot> godot -s HTTPTest.cs

```

--------------------------------

### String.bigrams() example

Source: https://docs.godotengine.org/en/4.4/classes/class_string.html

Returns an array of bigrams (pairs of consecutive characters) from the string. The example prints the bigrams of "Get up!".

```gdscript
print("Get up!".bigrams()) # Prints ["Ge", "et", "t ", " u", "up", "p!"]

```

--------------------------------

### One Statement Per Line: Good Example

Source: https://docs.godotengine.org/en/4.4/tutorials/shaders/shaders_style_guide.html

Each statement is on its own line. This is the recommended style.

```glsl
void fragment() {
    ALBEDO = vec3(1.0);
    EMISSION = vec3(1.0);
}

```

--------------------------------

### HTTPRequest Usage Examples

Source: https://docs.godotengine.org/en/4.4/classes/class_httprequest.html

Examples of using the HTTPRequest node to perform GET and POST requests, including handling responses and errors.

```APIDOC
## [GET] https://httpbin.org/get

### Description
Performs a GET request to the specified URL. The response is delivered via the `request_completed` signal.

### Method
GET

### Endpoint
https://httpbin.org/get

### Parameters
#### Query Parameters
- None documented.

### Request Example
No request body is sent for a GET request.

### Response
#### Success Response (200)
- **headers** (Dictionary) - Contains response headers, including the `User-Agent` string used by the HTTPRequest node.

#### Response Example
{
  "headers": {
    "User-Agent": "GodotEngine/4.4 (https://godotengine.org)"
  }
}

### Error Handling
- If the request fails, an error code is returned from the `request()` method. Check the return value against `OK`.

## [POST] https://httpbin.org/post

### Description
Performs a POST request to the specified URL with a JSON body. The response is delivered via the `request_completed` signal.

### Method
POST

### Endpoint
https://httpbin.org/post

### Parameters
#### Request Body
- **body** (String) - The request body, typically a JSON string. Required.

### Request Example
{
  "name": "Godette"
}

### Response
#### Success Response (200)
- **headers** (Dictionary) - Contains response headers, including the `User-Agent` string used by the HTTPRequest node.

#### Response Example
{
  "headers": {
    "User-Agent": "GodotEngine/4.4 (https://godotengine.org)"
  }
}

### Error Handling
- If the request fails, an error code is returned from the `request()` method. Check the return value against `OK`.

## [GET] https://placehold.co/512

### Description
Performs a GET request to download an image (PNG) from the specified URL. The response is delivered via the `request_completed` signal.

### Method
GET

### Endpoint
https://placehold.co/512

### Parameters
#### Query Parameters
- None documented.

### Request Example
No request body is sent for a GET request.

### Response
#### Success Response (200)
- **body** (PackedByteArray) - The raw image data (PNG) returned by the server.

#### Response Example
Binary image data (PNG) is returned in the `body` parameter.

### Error Handling
- If the request fails, the `result` parameter in the `request_completed` signal will not be `RESULT_SUCCESS`.
```

--------------------------------

### setup(server_options: TLSOptions)

Source: https://docs.godotengine.org/en/4.4/classes/class_dtlsserver.html

Sets up the DTLS server with the provided TLS options.

```APIDOC
## setup(server_options: TLSOptions) -> Error

### Description
Sets up the DTLS server to use the given `server_options`. See TLSOptions.server().

### Method
setup

### Parameters
- **server_options** (TLSOptions) - Required - The TLS options for the server.

### Returns
- **Error** - The result of the setup operation.
```

--------------------------------

### Install dependencies on OpenBSD

Source: https://docs.godotengine.org/en/4.4/contributing/development/compiling/compiling_for_linuxbsd.html

Install all required dependencies for compiling Godot on OpenBSD using pkg_add. Optionally install pulseaudio for audio support.

```shell
pkg_add \
  python \
  scons \
  llvm

```

--------------------------------

### Install Vulkan validation layers on Gentoo

Source: https://docs.godotengine.org/en/4.4/contributing/development/debugging/vulkan/vulkan_validation_layers.html

Install the media-libs/vulkan-layers package using emerge.

```bash
emerge -an media-libs/vulkan-layers

```

--------------------------------

### error_string() usage example

Source: https://docs.godotengine.org/en/4.4/classes/class_%40globalscope.html

Shows how to use `error_string()` to get a human-readable name for an Error code. The output for the given examples is shown in the comments.

```gdscript
print(OK)                              # Prints 0
print(error_string(OK))                # Prints "OK"
print(error_string(ERR_BUSY))          # Prints "Busy"
print(error_string(ERR_OUT_OF_MEMORY)) # Prints "Out of memory"
```

--------------------------------

### C#: Set transition request and get current state

Source: https://docs.godotengine.org/en/4.4/classes/class_animationnodetransition.html

C# equivalent of the GDScript example, showing how to set the transition_request and get the current state name and index using the Set and Get methods.

```csharp
// Play child animation connected to "state_2" port.
animationTree.Set("parameters/Transition/transition_request", "state_2");

// Get current state name (read-only).
animationTree.Get("parameters/Transition/current_state");

// Get current state index (read-only).
animationTree.Get("parameters/Transition/current_index");

```

--------------------------------

### C#: Initialize OpenXR in _Ready()

Source: https://docs.godotengine.org/en/4.4/tutorials/xr/setting_up_xr.html

C# equivalent of the GDScript example. It initializes OpenXR, disables v-sync, and enables XR output on the viewport. Prints an error if initialization fails.

```C#
using Godot;

public partial class MyNode3D : Node3D
{
    private XRInterface _xrInterface;

    public override void _Ready()
    {
        _xrInterface = XRServer.FindInterface("OpenXR");
        if(_xrInterface != null && _xrInterface.IsInitialized())
        {
            GD.Print("OpenXR initialized successfully");

            // Turn off v-sync!
            DisplayServer.WindowSetVsyncMode(DisplayServer.VSyncMode.Disabled);

            // Change our main viewport to output to the HMD
            GetViewport().UseXR = true;
        }
        else
        {
            GD.Print("OpenXR not initialized, please check if your headset is connected");
        }
    }
}

```

--------------------------------

### AABB.abs() example

Source: https://docs.godotengine.org/en/4.4/classes/class_aabb.html

Shows how to use AABB.abs() to get a bounding box with non-negative size. The example prints the resulting position and size for both GDScript and C#.

```GDScript
var box = AABB(Vector3(5, 0, 5), Vector3(-20, -10, -5))
var absolute = box.abs()
print(absolute.position) # Prints (-15.0, -10.0, 0.0)
print(absolute.size)     # Prints (20.0, 10.0, 5.0)

```

```C#
var box = new Aabb(new Vector3(5, 0, 5), new Vector3(-20, -10, -5));
var absolute = box.Abs();
GD.Print(absolute.Position); // Prints (-15, -10, 0)
GD.Print(absolute.Size);     // Prints (20, 10, 5)

```

--------------------------------

### C++ Mutex example - Implementation file

Source: https://docs.godotengine.org/en/4.4/tutorials/performance/using_multiple_threads.html

Implementation of the C++ Mutex demo, showing how to bind the thread function, handle notifications, and use mutex lock/unlock to protect the counter. The thread is started in NOTIFICATION_READY and joined in NOTIFICATION_EXIT_TREE.

```C++
#include "mutex_demo.h"

#include <godot_cpp/classes/engine.hpp>
#include <godot_cpp/classes/time.hpp>
#include <godot_cpp/core/class_db.hpp>
#include <godot_cpp/variant/utility_functions.hpp>

using namespace godot;

void MutexDemo::_bind_methods() {
	ClassDB::bind_method(D_METHOD("thread_function"), &MutexDemo::thread_function);
}

void MutexDemo::_notification(int p_what) {
	// Prevents this from running in the editor, only during game mode.
	if (Engine::get_singleton()->is_editor_hint()) {
		return;
	}

	switch (p_what) {
		case NOTIFICATION_READY: {
			UtilityFunctions::print("Mutex Demo Counter is starting at: ", counter);
			mutex.instantiate();
			thread.instantiate();
			thread->start(callable_mp(this, &MutexDemo::thread_function), Thread::PRIORITY_NORMAL);

			// Increase value, protect it with Mutex.
			mutex->lock();
			counter += 1;
			UtilityFunctions::print("Mutex Demo Counter is ", counter, " after adding with Mutex protection.");
			mutex->unlock();
		} break;
		case NOTIFICATION_EXIT_TREE: { // Thread must be disposed (or "joined"), for portability.
			// Wait until it exits.
			if (thread.is_valid()) {
				thread->wait_to_finish();
			}
			thread.unref();

			UtilityFunctions::print("Mutex Demo Counter is ", counter, " at EXIT_TREE."); // Should be 2.
		} break;
	}
}

MutexDemo::MutexDemo() {
	// Initialize any variables here.
}

MutexDemo::~MutexDemo() {
	// Add your cleanup here.
}

// Increment the value from the thread, too.
void MutexDemo::thread_function() {
	mutex->lock();
	counter += 1;
	mutex->unlock();
}

```

--------------------------------

### get_iv_state()

Source: https://docs.godotengine.org/en/4.4/classes/class_aescontext.html

Gets the current IV state for this context. The IV gets updated when calling update(). This function only makes sense when the context is started with MODE_CBC_ENCRYPT or MODE_CBC_DECRYPT.

```APIDOC
## [GET] get_iv_state()

### Description
Get the current IV state for this context (IV gets updated when calling update()). You normally don't need this function.

### Method
GET

### Endpoint
get_iv_state()

### Parameters
None

### Response
#### Success Response (200)
- **PackedByteArray** - The current IV state for this context.

#### Response Example
PackedByteArray
```

--------------------------------

### start(one_time: bool = false)

Source: https://docs.godotengine.org/en/4.4/classes/class_skeletonik3d.html

Starts the IK solver. If `one_time` is `true`, the IK is applied only once; otherwise, it runs continuously.

```APIDOC
## [METHOD] start(one_time: bool = false)

### Description
Starts the IK solver. If `one_time` is `true`, the IK is applied only once; otherwise, it runs continuously.

### Method
start(one_time: bool = false)

### Parameters
- **one_time** (bool) - Optional - If `true`, the IK is applied only once.

### Return Value
None
```

--------------------------------

### Signals and properties example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdscript/gdscript_styleguide.html

Example showing the order for signals, enums, constants, exported variables, regular variables, and @onready variables. @onready variables are evaluated right before _ready.

```gdscript
signal player_spawned(position)

enum Job {
	KNIGHT,
	WIZARD,
	ROGUE,
	HEALER,
	SHAMAN,
}

const MAX_LIVES = 3

@export var job: Job = Job.KNIGHT
@export var max_health = 50
@export var attack = 5

var health = max_health:
	set(new_health):
		health = new_health

var _speed = 300.0

@onready var sword = get_node("Sword")
@onready var gun = get_node("Gun")

```

--------------------------------

### GDScript: get_concatenated_subnames example

Source: https://docs.godotengine.org/en/4.4/classes/class_nodepath.html

Shows how to get all property subnames concatenated with a colon. The example uses a node path with a texture and resource_name subname and prints the concatenated subnames.

```GDScript
var node_path = ^"Sprite2D:texture:resource_name"
print(node_path.get_concatenated_subnames()) # Prints "texture:resource_name"
```

--------------------------------

### helloWorld()

Source: https://docs.godotengine.org/en/4.4/tutorials/platform/android/android_plugin.html

Prints a 'Hello World' message to the logcat using the plugin singleton.

```APIDOC
## helloWorld()

### Description
Prints a 'Hello World' message to the logcat using the plugin singleton.

### Method
helloWorld

### Parameters
None

### Return Value
None

### Example
```gdscript
var plugin = preload("res://plugin.gd").new()
plugin.helloWorld()
```

### Notes
- The plugin singleton must be initialized successfully before calling this method.
- If the singleton is not available, an error message is printed to the console.
```

--------------------------------

### hex_encode() example in GDScript

Source: https://docs.godotengine.org/en/4.4/classes/class_packedbytearray.html

Shows how to use hex_encode() to get a lowercase hexadecimal string from a PackedByteArray. The example prints "0b2eff" for the array [11, 46, 255].

```GDScript
var array = PackedByteArray([11, 46, 255])
print(array.hex_encode()) # Prints "0b2eff"
```

--------------------------------

### grow example in C#

Source: https://docs.godotengine.org/en/4.4/classes/class_aabb.html

C# equivalent of the grow example, using Grow() method. Outputs demonstrate position and size changes.

```C#
var a = new Aabb(new Vector3(4, 4, 4), new Vector3(8, 8, 8)).Grow(4);
GD.Print(a.Position); // Prints (0, 0, 0)
GD.Print(a.Size);     // Prints (16, 16, 16)

var b = new Aabb(new Vector3(0, 0, 0), new Vector3(8, 4, 2)).Grow(2);
GD.Print(b.Position); // Prints (-2, -2, -2)
GD.Print(b.Size);     // Prints (12, 8, 6)

```

--------------------------------

### Bot.cs - C# version of the CharacterBody3D resource example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/resources.html

C# implementation for the same resource example. Uses an [Export] Resource field and checks for the BotStats type in _Ready before printing Health.

```csharp
// Bot.cs
using Godot;

namespace ExampleProject
{
    public partial class Bot : CharacterBody3D
    {
        [Export]
        public Resource Stats;

        public override void _Ready()
        {
            if (Stats is BotStats botStats)
            {
                GD.Print(botStats.Health); // Prints '10'.
            }
        }
    }
}

```

--------------------------------

### Example scene tree for get_node()

Source: https://docs.godotengine.org/en/4.4/classes/class_node.html

Example scene tree used to illustrate get_node() path resolution. The Character node is the caller; paths are relative to it unless absolute (starting with /root).

```text
┖╴root
   ┠╴Character (you are here!)
   ┃  ┠╴Sword
   ┃  ┖╴Backpack
   ┃     ┖╴Dagger
   ┠╴MyGame
   ┖╴Swamp
      ┠╴Alligator
      ┠╴Mosquito
      ┖╴Goblin

```

--------------------------------

### Engine.prototype.startGame(override)

Source: https://docs.godotengine.org/en/4.4/tutorials/platform/web/html5_shell_classref.html

Starts the game instance using the given configuration override (if any). This will initialize the instance if it is not initialized. This will load the engine if it is not loaded, and preload the main pck. This method expects the initial config (or the override) to have both the executable and mainPack properties set (normally done by the editor during export).

```APIDOC
## Engine.prototype.startGame(override)

### Description
Starts the game instance using the given configuration override (if any). This will initialize the instance if it is not initialized. This will load the engine if it is not loaded, and preload the main pck. This method expects the initial config (or the override) to have both the executable and mainPack properties set (normally done by the editor during export).

### Method
Instance

### Parameters
- **override** (EngineConfig) - Optional - An optional configuration override.

### Returns
- **Promise** - Resolves once the game started.

```

--------------------------------

### hex_encode() example in C#

Source: https://docs.godotengine.org/en/4.4/classes/class_packedbytearray.html

Shows how to use HexEncode() in C# to get a lowercase hexadecimal string from a PackedByteArray. The example prints "0b2eff" for the array [11, 46, 255].

```C#
byte[] array = [11, 46, 255];
GD.Print(array.HexEncode()); // Prints "0b2eff"
```

--------------------------------

### Godot header file include order example (my_new_file.h)

Source: https://docs.godotengine.org/en/4.4/contributing/development/code_style_guidelines.html

Example header file showing the required copyright header, include guard, and include ordering for new Godot C++ files. The first include must be the class declaration header, followed by Godot headers in alphabetical order with quotes, then third-party headers with angle brackets, each block separated by an empty line.

```cpp
/**************************************************************************/
/*  my_new_file.h                                                         */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#ifndef MY_NEW_FILE_H
#define MY_NEW_FILE_H

#include "core/hash_map.h"
#include "core/list.h"
#include "scene/gui/control.h"

#include <png.h>

...

#endif // MY_NEW_FILE_H

```

--------------------------------

### Comment spacing - Good example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdscript/gdscript_styleguide.html

Regular comments (#) and documentation comments (##) should start with a space, but not code that you comment out. Code region comments (#region/#endregion) must follow that precise syntax, so they should not start with a space.

```GDScript
# This is a comment.
#print("This is disabled code")

```

--------------------------------

### init.c - GDExtension initialization implementation

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/gdextension/gdextension_c_example.html

Implements the initialization functions and the library entry point. Sets the initialization level to GDEXTENSION_INITIALIZATION_SCENE.

```c
#include "init.h"

void initialize_gdexample_module(void *p_userdata, GDExtensionInitializationLevel p_level)
{
}

void deinitialize_gdexample_module(void *p_userdata, GDExtensionInitializationLevel p_level)
{
}

GDExtensionBool GDE_EXPORT gdexample_library_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization)
{
    r_initialization->initialize = initialize_gdexample_module;
    r_initialization->deinitialize = deinitialize_gdexample_module;
    r_initialization->userdata = NULL;
    r_initialization->minimum_initialization_level = GDEXTENSION_INITIALIZATION_SCENE;

    return true;
}

```

--------------------------------

### Install custom RichTextEffect

Source: https://docs.godotengine.org/en/4.4/classes/class_richtextlabel.html

Two-part example: first defines a custom RichTextEffect with a bbcode identifier, then installs it on a RichTextLabel using install_effect(). The second part also shows an alternative using preload() when not using class_name.

```gdscript
# effect.gd
class_name MyCustomEffect
extends RichTextEffect

var bbcode = "my_custom_effect"

# ...
```

```gdscript
# rich_text_label.gd
extends RichTextLabel

func _ready():
	install_effect(MyCustomEffect.new())

	# Alternatively, if not using `class_name` in the script that extends RichTextEffect:
	install_effect(preload("res://effect.gd").new())
```

--------------------------------

### _initialize(project_path: String) -> bool

Source: https://docs.godotengine.org/en/4.4/classes/class_editorvcsinterface.html

Initializes the VCS plugin.

```APIDOC
## _initialize(project_path: String) -> bool

### Description
Initializes the VCS plugin when called from the editor. Returns whether or not the plugin was successfully initialized. A VCS project is initialized at `project_path`.

### Method
`_initialize`

### Parameters
- **project_path** (String) - Required - The path to the project.

### Returns
- **bool** - Whether initialization was successful.
```

--------------------------------

### Accessing external library and custom function from Godot (GDScript)

Source: https://docs.godotengine.org/en/4.4/tutorials/platform/web/javascript_bridge.html

GDScript example showing how to get the `window` object and the `axios` library using `JavaScriptBridge.get_interface`, call the custom `myFunc` function, and make a GET request with a callback.

```GDScript
extends Node

# Here create a reference to the `_on_get` function (below).
# This reference will be kept until the node is freed.
var _callback = JavaScriptBridge.create_callback(_on_get)

func _ready():
	# Get the `window` object, where globally defined functions are.
	var window = JavaScriptBridge.get_interface("window")
	# Call the JavaScript `myFunc` function defined in the custom HTML head.
	window.myFunc()
	# Get the `axios` library (loaded from a CDN in the custom HTML head).
	var axios = JavaScriptBridge.get_interface("axios")
	# Make a GET request to the current location, and receive the callback when done.
	axios.get(window.location.toString()).then(_callback)

func _on_get(args):
	OS.alert("On Get")
```

--------------------------------

### Search for a pattern and get the match

Source: https://docs.godotengine.org/en/4.4/classes/class_regex.html

Searches for a pattern with search() and retrieves the matched string with get_string(). The example prints 'n-0123'.

```gdscript
var regex = RegEx.new()
regex.compile("\\w-(\\d+)")
var result = regex.search("abc n-0123")
if result:
	print(result.get_string()) # Would print n-0123

```

--------------------------------

### Build with .NET on Windows

Source: https://docs.godotengine.org/en/4.4/contributing/development/compiling/compiling_with_dotnet.html

Builds the editor binary and export templates for Windows with Mono/.NET support enabled, then generates glue sources and builds the .NET assemblies. Use this on a Windows host with the Godot source checked out.

```bash
# Build editor binary
scons platform=windows target=editor module_mono_enabled=yes
# Build export templates
scons platform=windows target=template_debug module_mono_enabled=yes
scons platform=windows target=template_release module_mono_enabled=yes

# Generate glue sources
bin/godot.windows.editor.x86_64.mono --headless --generate-mono-glue modules/mono/glue
# Build .NET assemblies
./modules/mono/build_scripts/build_assemblies.py --godot-output-dir=./bin --godot-platform=windows

```

--------------------------------

### listen(port: int, bind_address: String = "*")

Source: https://docs.godotengine.org/en/4.4/classes/class_udpserver.html

Starts the UDP server listening on a given port.

```APIDOC
## listen(port: int, bind_address: String = "*")

### Description
Starts the server by opening a UDP socket listening on the given `port`. You can optionally specify a `bind_address` to only listen for packets sent to that address.

### Method
listen(port: int, bind_address: String = "*")

### Parameters
- **port** (int) - Required - The port to listen on.
- **bind_address** (String) - Optional - The address to bind to. Defaults to "*" (all interfaces).

### Returns
- **Error** - Returns an error code if the operation fails.

```

--------------------------------

### GDScript UDP server example

Source: https://docs.godotengine.org/en/4.4/classes/class_udpserver.html

Example of using UDPServer in GDScript. Start the server with listen(4242), then call poll() each frame (e.g. in _process) to accept new connections and receive packets; keep a reference to each peer to continue communication.

```GDScript
# server_node.gd
class_name ServerNode
extends Node

var server = UDPServer.new()
var peers = []

func _ready():
	server.listen(4242)

func _process(delta):
	server.poll() # Important!
	if server.is_connection_available():
		var peer = server.take_connection()
		var packet = peer.get_packet()
		print("Accepted peer: %s:%s" % [peer.get_packet_ip(), peer.get_packet_port()])
		print("Received data: %s" % [packet.get_string_from_utf8()])
		# Reply so it knows we received the message.
		peer.put_packet(packet)
		# Keep a reference so we can keep contacting the remote peer.
		peers.append(peer)

	for i in range(0, peers.size()):
		pass

```

--------------------------------

### Basic TTS usage with DisplayServer (GDScript/C#)

Source: https://docs.godotengine.org/en/4.4/tutorials/audio/text_to_speech.html

One-time setup: enable TTS in Project Settings, then query voices and speak. Picks the first English voice and speaks a short phrase, then a longer sentence; the method is asynchronous, so execution continues before the voice finishes.

```gdscript
# One-time steps.
# Pick a voice. Here, we arbitrarily pick the first English voice.
var voices = DisplayServer.tts_get_voices_for_language("en")
var voice_id = voices[0]

# Say "Hello, world!".
DisplayServer.tts_speak("Hello, world!", voice_id)

# Say a longer sentence, and then interrupt it.
# Note that this method is asynchronous: execution proceeds to the next line immediately,
# before the voice finishes speaking.
var long_message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
```

--------------------------------

### Get collision point with move_and_collide (C#)

Source: https://docs.godotengine.org/en/4.4/tutorials/physics/physics_introduction.html

C# equivalent of the GDScript example, using MoveAndCollide() and GetPosition() to retrieve the collision point.

```C#
using Godot;

public partial class Body : PhysicsBody2D
{
    private Vector2 _velocity = new Vector2(250, 250);

    public override void _PhysicsProcess(double delta)
    {
        var collisionInfo = MoveAndCollide(_velocity * (float)delta);
        if (collisionInfo != null)
        {
            var collisionPoint = collisionInfo.GetPosition();
        }
    }
}

```

--------------------------------

### Example calculation with x_prev=10 and x_curr=30

Source: https://docs.godotengine.org/en/4.4/tutorials/physics/interpolation/physics_interpolation_introduction.html

Substitutes the example values into the interpolation equation, showing the step-by-step calculation resulting in an interpolated X of 14.

```plaintext
x_interpolated = 10 + ((30 - 10) * 0.2)
x_interpolated = 10 + 4
x_interpolated = 14
```

--------------------------------

### Connect cancel button pressed signal (GDScript and C#)

Source: https://docs.godotengine.org/en/4.4/classes/class_confirmationdialog.html

Connect the cancel button's pressed signal to a handler. The GDScript example uses the connect method, while the C# example uses the += operator. This is shown in the ConfirmationDialog documentation to get the cancel action.

```GDScript
get_cancel_button().pressed.connect(_on_canceled)

```

```C#
GetCancelButton().Pressed += OnCanceled;

```

--------------------------------

### Install system libraries on Debian/Ubuntu

Source: https://docs.godotengine.org/en/4.4/contributing/development/compiling/compiling_for_linuxbsd.html

Install the required system libraries for Debian/Ubuntu using apt-get. Run these commands on top of the distro-specific one-liners. The package list includes libembree-dev, libenet-dev, libfreetype-dev, libpng-dev, zlib1g-dev, libgraphite2-dev, libharfbuzz-dev, libogg-dev, libtheora-dev, libvorbis-dev, libwebp-dev, libmbedtls-dev, libminiupnpc-dev, libpcre2-dev, libzstd-dev, libsquish-dev, and libicu-dev.

```bash
sudo apt-get update
sudo apt-get install -y \
  libembree-dev \
  libenet-dev \
  libfreetype-dev \
  libpng-dev \
  zlib1g-dev \
  libgraphite2-dev \
  libharfbuzz-dev \
  libogg-dev \
  libtheora-dev \
  libvorbis-dev \
  libwebp-dev \
  libmbedtls-dev \
  libminiupnpc-dev \
  libpcre2-dev \
  libzstd-dev \
  libsquish-dev \
  libicu-dev

```

--------------------------------

### Descriptive naming example

Source: https://docs.godotengine.org/en/4.4/tutorials/scripting/c_sharp/c_sharp_style_guide.html

Shows preferred descriptive method names over shortened ones.

```csharp
FindNearbyEnemy()?.Damage(weaponDamage);
```

```csharp
FindNode()?.Change(wpnDmg);
```

--------------------------------

### show_game_center usage examples

Source: https://docs.godotengine.org/en/4.4/tutorials/platform/ios/plugins_for_ios.html

Two examples of calling show_game_center with different view parameters. The first shows leaderboards with a specific leaderboard name, the second shows achievements.

```gdscript
var result = show_game_center({ "view": "leaderboards", "leaderboard_name": "best_time_leaderboard" })
var result = show_game_center({ "view": "achievements" })
```

--------------------------------

### @warning_ignore_start and @warning_ignore_restore example

Source: https://docs.godotengine.org/en/4.4/classes/class_%40gdscript.html

Starts ignoring 'unused_variable' warnings until the matching @warning_ignore_restore. Variables b and c produce no warning, while a and d do if enabled in Project Settings.

```GDScript
func test():
	var a = 1 # Warning (if enabled in the Project Settings).
	@warning_ignore_start("unused_variable")
	var b = 2 # No warning.
	var c = 3 # No warning.
	@warning_ignore_restore("unused_variable")
	var d = 4 # Warning (if enabled in the Project Settings).

```
Tokens:
Raw