Godot Engine

https://docs.godotengine.org/en/stable/
Admin
Godot Engine is a free, open-source game engine that supports 2D and 3D game development with...
Tokens:6,149,321
Snippets:115,579
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install dependencies on NetBSD

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use pkgin to install the necessary build tools.

```bash
pkg_add pkgin
pkgin -y install \
  pkg-config \
  py313-scons \
  wayland \
  pulseaudio
```

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

### Template File Examples

Source: https://docs.godotengine.org/en/stable/tutorials/scripting/creating_script_templates.html

Examples of file paths for custom script templates.

```text
script_templates/Node/smooth_camera.gd
script_templates/CharacterBody3D/platformer_movement.gd
```

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

### Install dependencies on Solus

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use eopkg to install the system development components and required libraries.

```bash
eopkg install -y \
  -c system.devel \
  scons \
  libxcursor-devel \
  libxinerama-devel \
  libxi-devel \
  libxrandr-devel \
  wayland-devel \
  mesalib-devel \
  libglu \
  alsa-lib-devel \
  pulseaudio-devel
```

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

### start

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

Starts playback of a specific node.

```APIDOC
## void start(node: StringName, reset: bool = true)

### Description
Starts playback of the specified node.

### Parameters
- **node** (StringName) - The name of the node to start.
- **reset** (bool) - Whether to reset the animation.
```

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

### Install dependencies on openSUSE

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use zypper to install the required development libraries and tools.

```bash
sudo zypper install -y \
  scons \
  pkgconfig \
  libX11-devel \
  libXcursor-devel \
  libXrandr-devel \
  libXinerama-devel \
  libXi-devel \
  wayland-devel \
  Mesa-libGL-devel \
  alsa-devel \
  libpulse-devel \
  libudev-devel \
  gcc-c++ \
  libGLU1
```

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

### start

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

Starts the IK processing.

```APIDOC
## void start(one_time: bool = false)

### Description
Starts applying IK effects on each frame to the Skeleton3D bones. If one_time is true, the effect takes place immediately and resets on the next frame.
```

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

### Install dependencies on Gentoo

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use emerge to sync the repository and install the required packages.

```bash
emerge --sync
emerge -an \
  dev-build/scons \
  x11-libs/libX11 \
  x11-libs/libXcursor \
  x11-libs/libXinerama \
  x11-libs/libXi \
  dev-util/wayland-scanner \
  media-libs/mesa \
  media-libs/glu \
  media-libs/alsa-lib \
  media-sound/pulseaudio
```

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

### start

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

Starts playing the given animation.

```APIDOC
void start(node: StringName, reset: bool = true)
```

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

### Engine.prototype.startGame(override)

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

Starts the game instance.

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

### Description
Start the game instance using the given configuration override. Expects executable and mainPack properties to be set.

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

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

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

### WebSocket Client Output Example

Source: https://docs.godotengine.org/en/stable/tutorials/networking/websocket.html

Expected console output after running the minimal client example.

```text
Connecting to wss://echo.websocket.org...
< Got text data from server: Request served by 7811941c69e658
> Sending test packet.
< Got text data from server: Test packet
```

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

### Install dependencies on FreeBSD

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use pkg to install the necessary build dependencies.

```bash
pkg install -y \
  devel/scons \
  pkgconf \
  xorg-libraries \
  libXcursor \
  libXrandr \
  libXi \
  xorgproto \
  libGLU \
  alsa-lib \
  pulseaudio \
  wayland
```

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

### Engine.prototype.start(override)

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

Starts the engine instance.

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

### Description
Start the engine instance using the given override configuration. Fails if a canvas cannot be found.

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

### Returns
- **Promise** - Resolves once the engine started.
```

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

### Complete script documentation example

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

A comprehensive example demonstrating documentation for classes, signals, enums, constants, variables, and inner classes.

```GDScript
class_name MyClass
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

```

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

### Install dependencies on Debian/Ubuntu

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use apt-get to install the build-essential package and required development libraries.

```bash
sudo apt-get update
sudo apt-get install -y \
  build-essential \
  scons \
  pkg-config \
  libx11-dev \
  libxcursor-dev \
  libxinerama-dev \
  libgl1-mesa-dev \
  libglu1-mesa-dev \
  libasound2-dev \
  libpulse-dev \
  libudev-dev \
  libxi-dev \
  libxrandr-dev \
  libwayland-dev
```

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

### Install dependencies on Arch Linux

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use pacman to install the necessary build environment components.

```bash
pacman -Sy --noconfirm --needed \
  scons \
  pkgconf \
  gcc \
  libxcursor \
  libxinerama \
  libxi \
  libxrandr \
  wayland-utils \
  mesa \
  glu \
  libglvnd \
  alsa-lib \
  pulseaudio
```

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

### Common Property Hint Examples

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

Practical examples for configuring various data types and constraints within collection hints.

```GDScript
hint_string = "%d:" % [TYPE_INT] # Array of integers.
hint_string = "%d/%d:1,10,1" % [TYPE_INT, PROPERTY_HINT_RANGE] # Array of integers (in range from 1 to 10).
hint_string = "%d/%d:Zero,One,Two" % [TYPE_INT, PROPERTY_HINT_ENUM] # Array of integers (an enum).
hint_string = "%d/%d:Zero,One,Three:3,Six:6" % [TYPE_INT, PROPERTY_HINT_ENUM] # Array of integers (an enum).
hint_string = "%d/%d:*.png" % [TYPE_STRING, PROPERTY_HINT_FILE] # Array of strings (file paths).
hint_string = "%d/%d:Texture2D" % [TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Array of textures.

hint_string = "%d:%d:" % [TYPE_ARRAY, TYPE_FLOAT] # Two-dimensional array of floats.
hint_string = "%d:%d/%d:" % [TYPE_ARRAY, TYPE_STRING, PROPERTY_HINT_MULTILINE_TEXT] # Two-dimensional array of multiline strings.
hint_string = "%d:%d/%d:-1,1,0.1" % [TYPE_ARRAY, TYPE_FLOAT, PROPERTY_HINT_RANGE] # Two-dimensional array of floats (in range from -1 to 1).
hint_string = "%d:%d/%d:Texture2D" % [TYPE_ARRAY, TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Two-dimensional array of textures.
```

```C#
hintString = $"{Variant.Type.Int:D}/{PropertyHint.Range:D}:1,10,1"; // Array of integers (in range from 1 to 10).
hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Two"; // Array of integers (an enum).
hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Three:3,Six:6"; // Array of integers (an enum).
hintString = $"{Variant.Type.String:D}/{PropertyHint.File:D}:*.png"; // Array of strings (file paths).
hintString = $"{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Array of textures.

hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}:"; // Two-dimensional array of floats.
hintString = $"{Variant.Type.Array:D}:{Variant.Type.String:D}/{PropertyHint.MultilineText:D}:"; // Two-dimensional array of multiline strings.
hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}/{PropertyHint.Range:D}:-1,1,0.1"; // Two-dimensional array of floats (in range from -1 to 1).
hintString = $"{Variant.Type.Array:D}:{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Two-dimensional array of textures.
```

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

### Multimesh example

Source: https://docs.godotengine.org/en/stable/tutorials/3d/using_multi_mesh_instance.html

Example demonstrating how to set up a MultiMeshInstance3D to render multiple instances of a mesh efficiently.

```gdscript
var multimesh = MultiMesh.new()
multimesh.mesh = preload("res://my_mesh.res")
multimesh.instance_count = 1000
for i in range(1000):
    var transform = Transform3D(Basis(), Vector3(i * 2, 0, 0))
    multimesh.set_instance_transform(i, transform)

var multimesh_instance = MultiMeshInstance3D.new()
multimesh_instance.multimesh = multimesh
add_child(multimesh_instance)
```

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

### Install Perfetto SDK

Source: https://docs.godotengine.org/en/stable/engine_details/development/profiling/perfetto.html

Run this script from the Godot root directory to install the latest Perfetto SDK into the thirdparty folder.

```bash
python misc/scripts/install_perfetto.py
```

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

### Absolute NodePath examples

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

Examples of absolute paths starting from the SceneTree root.

```GDScript
^"/root"            # Points to the SceneTree's root Window.
^"/root/Title"      # May point to the main scene's root node named "Title".
^"/root/Global"     # May point to an autoloaded node or scene named "Global".
```

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

### start

Source: https://docs.godotengine.org/en/stable/classes/class_godotinstance.html

Completes the startup sequence for the Godot instance.

```APIDOC
## bool start()

### Description
Finishes this instance's startup sequence. Returns true on success.
```

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

### visibility_range_begin

Source: https://docs.godotengine.org/en/stable/classes/class_geometryinstance3d.html

Methods to get and set the starting distance for visibility range.

```APIDOC
## void set_visibility_range_begin(float value)

### Description
Sets the starting distance from which the GeometryInstance3D will be visible.

## float get_visibility_range_begin()

### Description
Returns the starting distance from which the GeometryInstance3D will be visible.
```

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

### setup

Source: https://docs.godotengine.org/en/stable/classes/class_openxrinteractionprofileeditorbase.html

Initializes the editor with the specified action map and interaction profile.

```APIDOC
### void setup(action_map: OpenXRActionMap, interaction_profile: OpenXRInteractionProfile)

#### Description
Sets up the editor for the provided `action_map` and `interaction_profile`.

#### Parameters
- **action_map** (OpenXRActionMap) - The action map to be associated with the editor.
- **interaction_profile** (OpenXRInteractionProfile) - The interaction profile to be edited.
```

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

### Install Godot via Package Managers

Source: https://docs.godotengine.org/en/stable/tutorials/editor/command_line_tutorial.html

Commands to install the standard or C# version of Godot using Scoop on Windows or Homebrew on macOS.

```bash
# Add "Extras" bucket
scoop bucket add extras

# Standard editor:
scoop install godot

# Editor with C# support (will be available as `godot-mono` in `PATH`):
scoop install godot-mono
```

```bash
# Standard editor:
brew install godot

# Editor with C# support (will be available as `godot-mono` in `PATH`):
brew install godot-mono
```

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

### Get Response Headers as Dictionary

Source: https://docs.godotengine.org/en/stable/classes/class_httpclient.html

Example of the dictionary structure returned by get_response_headers_as_dictionary.

```json
{
	"content-length": 12,
	"Content-Type": "application/json; charset=UTF-8",
}
```

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

### List available build options

Source: https://docs.godotengine.org/en/stable/tutorials/scripting/cpp/build_system/cmake.html

Displays help strings and advanced options for the project.

```bash
cmake -S godot-cpp -LH
```

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

### Full ArrayMesh Implementation

Source: https://docs.godotengine.org/en/stable/tutorials/3d/procedural_geometry/arraymesh.html

Complete example showing the full setup of a MeshInstance3D with an ArrayMesh.

```GDScript
extends MeshInstance3D

func _ready():
	var surface_array = []
	surface_array.resize(Mesh.ARRAY_MAX)

	# PackedVector**Arrays for mesh construction.
	var verts = PackedVector3Array()
	var uvs = PackedVector2Array()
	var normals = PackedVector3Array()
	var indices = PackedInt32Array()

	#######################################
	## Insert code here to generate mesh ##
	#######################################

	# Assign arrays to surface array.
	surface_array[Mesh.ARRAY_VERTEX] = verts
	surface_array[Mesh.ARRAY_TEX_UV] = uvs
	surface_array[Mesh.ARRAY_NORMAL] = normals
	surface_array[Mesh.ARRAY_INDEX] = indices

	# Create mesh surface from mesh array.
	# No blendshapes, lods, or compression used.
	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, surface_array)
```

```C#
public partial class MyMeshInstance3D : MeshInstance3D
{
    public override void _Ready()
    {
        Godot.Collections.Array surfaceArray = [];
        surfaceArray.Resize((int)Mesh.ArrayType.Max);

        // C# arrays cannot be resized or expanded, so use Lists to create geometry.
        List<Vector3> verts = [];
        List<Vector2> uvs = [];
        List<Vector3> normals = [];
        List<int> indices = [];

        /***********************************
        * Insert code here to generate mesh.
        * *********************************/

        // Convert Lists to arrays and assign to surface array
        surfaceArray[(int)Mesh.ArrayType.Vertex] = verts.ToArray();
        surfaceArray[(int)Mesh.ArrayType.TexUV] = uvs.ToArray();
        surfaceArray[(int)Mesh.ArrayType.Normal] = normals.ToArray();
        surfaceArray[(int)Mesh.ArrayType.Index] = indices.ToArray();

        var arrMesh = Mesh as ArrayMesh;
        if (arrMesh != null)
        {
            // Create mesh surface from mesh array
            // No blendshapes, lods, or compression used.
            arrMesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, surfaceArray);
        }
    }
}
```

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

### Equivalent CMake configuration commands

Source: https://docs.godotengine.org/en/stable/tutorials/scripting/cpp/build_system/cmake.html

Demonstrates different ways to specify source and build directories.

```bash
# Current working directory is the godot-cpp source root.
cmake . -B build-dir

# Current working directory is an empty godot-cpp/build-dir.
cmake ../

# Current working directory is an existing build path.
cmake .
```

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

### Implement Library Initialization

Source: https://docs.godotengine.org/en/stable/engine_details/engine_api/gdextension/gdextension_c_example.html

Implements the entry point for the GDExtension, setting the initialization level and callback functions.

```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;
}
```

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

### Get Local Interfaces Dictionary Structure

Source: https://docs.godotengine.org/en/stable/classes/class_ip.html

Example of the dictionary structure returned by the get_local_interfaces method.

```gdscript
{
	"index": "1", # Interface index.
	"name": "eth0", # Interface name.
	"friendly": "Ethernet One", # A friendly name (might be empty).
	"addresses": ["192.168.1.101"], # An array of IP addresses associated to this interface.
}
```

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

### 2D Navigation Polygon Setup

Source: https://docs.godotengine.org/en/stable/tutorials/navigation/navigation_using_navigationmeshes.html

Example of creating a 2D navigation region and defining a convex polygon for navigation.

```GDScript
extends Node2D

var navigation_mesh: NavigationPolygon
var region_rid: RID

func _ready() -> void:
	navigation_mesh = NavigationPolygon.new()
	region_rid = NavigationServer2D.region_create()

	# Enable the region and set it to the default navigation map.
	NavigationServer2D.region_set_enabled(region_rid, true)
	NavigationServer2D.region_set_map(region_rid, get_world_2d().get_navigation_map())

	# Add vertices for a convex polygon.
	navigation_mesh.vertices = PackedVector2Array([
		Vector2(0.0, 0.0),
		Vector2(100.0, 0.0),
		Vector2(100.0, 100.0),
		Vector2(0.0, 100.0),
	])

	# Add indices for the polygon.
	navigation_mesh.add_polygon(
		PackedInt32Array([0, 1, 2, 3])
	)

	NavigationServer2D.region_set_navigation_polygon(region_rid, navigation_mesh)
```

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

### Implementing a UDP Server

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

Demonstrates how to initialize a server, listen on a port, and process incoming connections and packets.

```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 # Do something with the connected peers.
```

```csharp
// ServerNode.cs
using Godot;
using System.Collections.Generic;

public partial class ServerNode : Node
{
    private UdpServer _server = new UdpServer();
    private List<PacketPeerUdp> _peers  = new List<PacketPeerUdp>();

    public override void _Ready()
    {
        _server.Listen(4242);
    }

    public override void _Process(double delta)
    {
        _server.Poll(); // Important!
        if (_server.IsConnectionAvailable())
        {
            PacketPeerUdp peer = _server.TakeConnection();
            byte[] packet = peer.GetPacket();
            GD.Print($"Accepted Peer: {peer.GetPacketIP()}:{peer.GetPacketPort()}");
            GD.Print($"Received Data: {packet.GetStringFromUtf8()}");
            // Reply so it knows we received the message.
            peer.PutPacket(packet);
            // Keep a reference so we can keep contacting the remote peer.
            _peers.Add(peer);
        }
        foreach (var peer in _peers)
        {
            // Do something with the peers.
        }
    }
}
```

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

### Update HUD in new_game

Source: https://docs.godotengine.org/en/stable/getting_started/first_2d_game/06.heads_up_display.html

Updates the score display and shows the Get Ready message when starting a new game.

```GDScript
$HUD.update_score(score)
$HUD.show_message("Get Ready")
```

```C#
var hud = GetNode<HUD>("HUD");
hud.UpdateScore(_score);
hud.ShowMessage("Get Ready!");
```

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

### Create and save a ConfigFile

Source: https://docs.godotengine.org/en/stable/classes/class_configfile.html

Demonstrates initializing a ConfigFile, setting values, and persisting the data to the filesystem.

```gdscript
# Create new ConfigFile object.
var config = ConfigFile.new()

# Store some values.
config.set_value("Player1", "player_name", "Steve")
config.set_value("Player1", "best_score", 10)
config.set_value("Player2", "player_name", "V3geta")
config.set_value("Player2", "best_score", 9001)

# Save it to a file (overwrite if already exists).
config.save("user://scores.cfg")
```

```csharp
// Create new ConfigFile object.
var config = new ConfigFile();

// Store some values.
config.SetValue("Player1", "player_name", "Steve");
config.SetValue("Player1", "best_score", 10);
config.SetValue("Player2", "player_name", "V3geta");
config.SetValue("Player2", "best_score", 9001);

// Save it to a file (overwrite if already exists).
config.Save("user://scores.cfg");
```

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

### Begin a draw list with breadcrumb data

Source: https://docs.godotengine.org/en/stable/classes/class_renderingdevice.html

Example of starting a draw list with a custom breadcrumb value for GPU crash diagnostics.

```gdscript
rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)
```

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

### Create directories using instance and static methods

Source: https://docs.godotengine.org/en/stable/classes/class_diraccess.html

Demonstrates creating a directory using an instance of DirAccess versus the static make_dir_absolute method.

```GDScript
# Standard
var dir = DirAccess.open("user://levels")
dir.make_dir("world1")
# Static
DirAccess.make_dir_absolute("user://levels/world1")
```

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

### pck_start

Source: https://docs.godotengine.org/en/stable/classes/class_pckpacker.html

Initializes a new PCK file at the specified path.

```APIDOC
## pck_start(pck_path: String, alignment: int = 32, key: String = "...", encrypt_directory: bool = false)

### Description
Creates a new PCK file at the provided file path. The file extension is not added automatically.

### Parameters
- **pck_path** (String) - Required - The file path where the PCK will be created.
- **alignment** (int) - Optional - The alignment of the files within the package.
- **key** (String) - Optional - The encryption key for the package.
- **encrypt_directory** (bool) - Optional - Whether to encrypt the directory index.
```

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

### Implement a State Machine class

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

A comprehensive example demonstrating class structure, signals, exports, and lifecycle methods following the GDScript style guide.

```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 the ready method!")


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


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


func _physics_process(delta):
	_state.physics_process(delta)


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 set_is_active(value):
	is_active = value
	set_physics_process(value)
	set_process_unhandled_input(value)
	set_block_signals(not value)


func set_state(value):
	_state = value
	_state_name = _state.name


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


class State:
	var foo = 0

	func _init():
		print("Hello!")
```

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

### Install dependencies via Scoop

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_windows.html

Use this command to install Python and MinGW if you have the Scoop package manager installed.

```bash
scoop install python mingw
```

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

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

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

Starts the server by opening a UDP socket listening on the specified 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.

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

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

### Install SCons via MacPorts

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_macos.html

Use this command to install the SCons build system if MacPorts is installed on your system.

```bash
sudo port install scons
```

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

### Install SCons via Homebrew

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_macos.html

Use this command to install the SCons build system if Homebrew is installed on your system.

```bash
brew install scons
```

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

### setup

Source: https://docs.godotengine.org/en/stable/classes/class_polygonpathfinder.html

Initializes the PolygonPathFinder with vertices and edge connections.

```APIDOC
## void setup(points: PackedVector2Array, connections: PackedInt32Array)

### Description
Sets up the PolygonPathFinder with an array of points that define the vertices of the polygon, and an array of indices that determine the edges of the polygon. The length of connections must be even.

### Parameters
- **points** (PackedVector2Array) - The vertices of the polygon.
- **connections** (PackedInt32Array) - The indices defining the edges of the polygon.
```

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

### Engine Setup Initialization Order

Source: https://docs.godotengine.org/en/stable/engine_details/engine_api/custom_modules_in_cpp.html

A list of the sequence of type registration methods called during engine startup.

```cpp
preregister_module_types();
preregister_server_types();
register_core_singletons();
register_server_types();
register_scene_types();
EditorNode::register_editor_types();
register_platform_apis();
register_module_types();
initialize_physics();
initialize_navigation_server();
register_server_singletons();
register_driver_types();
ScriptServer::init_languages();
```

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

### Property NodePath examples

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

Examples of paths pointing to object properties.

```GDScript
^":position"           # Points to this object's position.
^":position:x"         # Points to this object's position in the x axis.
^"Camera3D:rotation:y" # Points to the child Camera3D and its y rotation.
^"/root:size:x"        # Points to the root Window and its width.
```

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

### Relative NodePath examples

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

Examples of paths relative to the current node.

```GDScript
^"A"     # Points to the direct child A.
^"A/B"   # Points to A's child B.
^"."     # Points to the current node.
^".."    # Points to the parent node.
^"../C"  # Points to the sibling node C.
^"../.." # Points to the grandparent node.
```

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

### Implement server registration

Source: https://docs.godotengine.org/en/stable/engine_details/engine_api/custom_godot_servers.html

Initialize the server instance and register a dummy singleton class to expose functionality to GDScript.

```cpp
#include "register_types.h"

#include "core/object/class_db.h"
#include "core/config/engine.h"

#include "hilbert_hotel.h"

static HilbertHotel *hilbert_hotel = NULL;
static _HilbertHotel *_hilbert_hotel = NULL;

void register_hilbert_hotel_types() {
	hilbert_hotel = memnew(HilbertHotel);
	hilbert_hotel->init();
	_hilbert_hotel = memnew(_HilbertHotel);
	ClassDB::register_class<_HilbertHotel>();
	Engine::get_singleton()->add_singleton(Engine::Singleton("HilbertHotel", _HilbertHotel::get_singleton()));
}

void unregister_hilbert_hotel_types() {
	if (hilbert_hotel) {
		hilbert_hotel->finish();
		memdelete(hilbert_hotel);
	}

	if (_hilbert_hotel) {
		memdelete(_hilbert_hotel);
	}
}
```

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

### setup(server_options: TLSOptions)

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

Configures the DTLS server using the provided TLSOptions.

```APIDOC
## setup(server_options: TLSOptions)

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

### Parameters
- **server_options** (TLSOptions) - Required - The configuration options for the DTLS server.
```

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

### Install dependencies on OpenBSD

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use pkg_add to install the required build dependencies.

```bash
pkg_add -I \
  scons \
  wayland \
  pulseaudio
```

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

### Instantiate and use a custom module

Source: https://docs.godotengine.org/en/stable/engine_details/engine_api/binding_to_external_libraries.html

Demonstrates creating an instance of a custom module and calling its methods from a script.

```gdscript
var t = TTS.new()
var script = "Hello world. This is a test!"
var is_spoken = t.say_text(script)
print('is_spoken: ', is_spoken)
```

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

### Install dependencies on Mageia

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use urpmi to install the required development packages.

```bash
sudo urpmi --auto \
  scons \
  task-c++-devel \
  wayland-devel \
  "pkgconfig(alsa)" \
  "pkgconfig(glu)" \
  "pkgconfig(libpulse)" \
  "pkgconfig(udev)" \
  "pkgconfig(x11)" \
  "pkgconfig(xcursor)" \
  "pkgconfig(xinerama)" \
  "pkgconfig(xi)" \
  "pkgconfig(xrandr)"
```

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

### Navigate to Help Topics

Source: https://docs.godotengine.org/en/stable/classes/class_scripteditor.html

Examples of topic strings used with goto_help to focus on specific classes, methods, constants, signals, annotations, properties, or theme items.

```text
# Shows help for the Node class.
class_name:Node
# Shows help for the global min function.
# Global objects are accessible in the `@GlobalScope` namespace, shown here.
class_method:@GlobalScope:min
# Shows help for get_viewport in the Node class.
class_method:Node:get_viewport
# Shows help for the Input constant MOUSE_BUTTON_MIDDLE.
class_constant:Input:MOUSE_BUTTON_MIDDLE
# Shows help for the BaseButton signal pressed.
class_signal:BaseButton:pressed
# Shows help for the CanvasItem property visible.
class_property:CanvasItem:visible
# Shows help for the GDScript annotation export.
# Annotations should be prefixed with the `@` symbol in the descriptor, as shown here.
class_annotation:@GDScript:@export
# Shows help for the GraphNode theme item named panel_selected.
class_theme_item:GraphNode:panel_selected
```

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

### start(type: HashType)

Source: https://docs.godotengine.org/en/stable/classes/class_hashingcontext.html

Starts a new hash computation of the specified type.

```APIDOC
## Error start(type: HashType)

### Description
Starts a new hash computation of the given type (e.g., HASH_SHA256 to start computation of an SHA-256 hash).

### Parameters
- **type** (HashType) - Required - The hashing algorithm to use (HASH_MD5, HASH_SHA1, or HASH_SHA256).
```

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

### Initialize submodules for existing project

Source: https://docs.godotengine.org/en/stable/tutorials/scripting/cpp/gdextension_cpp_example.html

Run this command if you have cloned an existing project and need to initialize the submodules.

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

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

### Example key format

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_with_script_encryption_key.html

The expected format of the generated key file.

```text
# NOTE: Do not use the key below! Generate your own key instead.
aeb1bc56aaf580cc31784e9c41551e9ed976ecba10d315db591e749f3f64890f
```

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

### C-style Iteration Examples

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

Examples of C-style for loops and STL iteration patterns.

```cpp
const char** strings = new const char*[50];

[..]

for (int i = 0; i < 50; i++) {
	printf("Value: %c Index: %d\n", strings[i], i);
}

// Even in STL:
std::list<std::string> strings;

[..]

for (std::string::const_iterator it = strings.begin(); it != strings.end(); it++) {
	std::cout << *it << std::endl;
}
```

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

### Define Project Settings with Feature Tags

Source: https://docs.godotengine.org/en/stable/tutorials/export/feature_tags.html

Example configuration showing a base setting and a debug-specific override.

```ini
[section]

subsection/example = "Release"
subsection/example.debug = "Debug"
```

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

### Create a new Godot project

Source: https://docs.godotengine.org/en/stable/tutorials/editor/command_line_tutorial.html

Initializes a new project directory and creates the required project.godot file.

```bash
mkdir newgame
cd newgame
touch project.godot
```

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

### Install mold Linker

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Commands to install the mold linker on various Linux distributions.

```bash
sudo apt-get update
sudo apt-get install -y mold
```

```bash
sudo dnf install -y mold
```

```bash
pacman -Sy --noconfirm --needed mold
```

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

### Creating an ENet Client

Source: https://docs.godotengine.org/en/stable/classes/class_enetmultiplayerpeer.html

Example of initializing a client connection using ENetMultiplayerPeer.

```gdscript
var peer = ENetMultiplayerPeer.new();
var error = peer.create_client('google.com', 69);
if error:
    print(error);
    return;
get_tree().get_multiplayer().multiplayer_peer = peer;
print('success');
```

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

### remove_joy_mapping(guid: String)

Source: https://docs.godotengine.org/en/stable/classes/class_input.html

Removes all mappings from the internal database that match the given GUID.

```APIDOC
## void remove_joy_mapping(guid: String)

### Description
Removes all mappings from the internal database that match the given GUID. All currently connected joypads that use this GUID will become unmapped.

### Parameters
- **guid** (String) - Required - The GUID of the joypad mapping to remove.
```

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

### Initialize GDExtension project with submodules

Source: https://docs.godotengine.org/en/stable/tutorials/scripting/cpp/gdextension_cpp_example.html

Use this sequence to create a new project directory and add the godot-cpp repository as a Git submodule.

```bash
mkdir gdextension_cpp_example
cd gdextension_cpp_example
git init
git submodule add -b 4.x https://github.com/godotengine/godot-cpp
cd godot-cpp
git submodule update --init
```

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

### Install gettext on macOS

Source: https://docs.godotengine.org/en/stable/tutorials/i18n/localization_using_gettext.html

Commands for installing gettext using common macOS package managers.

```bash
brew install gettext
```

```bash
sudo port install gettext
```

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

### Implement a DTLS Server

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

Demonstrates setting up a DTLS server and handling incoming connections.

```gdscript
# server_node.gd
extends Node

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

func _ready():
	server.listen(4242)
	var key = load("key.key") # Your private key.
	var cert = load("cert.crt") # Your X509 certificate.
	dtls.setup(TlsOptions.server(key, cert))

func _process(delta):
	while server.is_connection_available():
		var peer = server.take_connection()
		var dtls_peer = dtls.take_connection(peer)
		if dtls_peer.get_status() != PacketPeerDTLS.STATUS_HANDSHAKING:
			continue # It is normal that 50% of the connections fails due to cookie exchange.
		print("Peer connected!")
		peers.append(dtls_peer)

	for p in peers:
		p.poll() # Must poll to update the state.
		if p.get_status() == PacketPeerDTLS.STATUS_CONNECTED:
			while p.get_available_packet_count() > 0:
				print("Received message from client: %s" % p.get_packet().get_string_from_utf8())
				p.put_packet("Hello DTLS client".to_utf8_buffer())
```

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

public partial class ServerNode : Node
{
    private DtlsServer _dtls = new DtlsServer();
    private UdpServer _server = new UdpServer();
    private Godot.Collections.Array<PacketPeerDtls> _peers = [];

    public override void _Ready()
    {
        _server.Listen(4242);
        var key = GD.Load<CryptoKey>("key.key"); // Your private key.
        var cert = GD.Load<X509Certificate>("cert.crt"); // Your X509 certificate.
        _dtls.Setup(TlsOptions.Server(key, cert));
    }

    public override void _Process(double delta)
    {
        while (_server.IsConnectionAvailable())
        {
            PacketPeerUdp peer = _server.TakeConnection();
            PacketPeerDtls dtlsPeer = _dtls.TakeConnection(peer);
            if (dtlsPeer.GetStatus() != PacketPeerDtls.Status.Handshaking)
            {
                continue; // It is normal that 50% of the connections fails due to cookie exchange.
            }
            GD.Print("Peer connected!");
            _peers.Add(dtlsPeer);
        }

        foreach (var p in _peers)
        {
            p.Poll(); // Must poll to update the state.
            if (p.GetStatus() == PacketPeerDtls.Status.Connected)
            {
                while (p.GetAvailablePacketCount() > 0)
                {
                    GD.Print($"Received Message From Client: {p.GetPacket().GetStringFromUtf8()}");
                    p.PutPacket("Hello DTLS Client".ToUtf8Buffer());
                }
            }
        }
    }
}
```

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

### Install External Library Dependencies

Source: https://docs.godotengine.org/en/stable/engine_details/engine_api/binding_to_external_libraries.html

Commands to install the Festival library and voice packages on Linux.

```bash
sudo apt-get install festival festival-dev  # Installs festival and speech_tools libraries
apt-cache search festvox-*  # Displays list of voice packages
sudo apt-get install festvox-don festvox-rablpc16k festvox-kallpc16k festvox-kdlpc16k  # Installs voices
```

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

### Configure GPU execution with prime-run

Source: https://docs.godotengine.org/en/stable/classes/class_projectsettings.html

Use the %command% placeholder to prepend custom command-line arguments when running the project.

```text
prime-run %command%
```

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

### Install dependencies on Fedora

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use dnf to install the required build tools and development headers.

```bash
sudo dnf install -y \
  scons \
  pkgconfig \
  gcc-c++ \
  libstdc++-static \
  wayland-devel
```

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

### setup

Source: https://docs.godotengine.org/en/stable/classes/class_openxrbindingmodifiereditor.html

Configures the editor with the specified action map and binding modifier.

```APIDOC
### Method
void setup(action_map: OpenXRActionMap, binding_modifier: OpenXRBindingModifier)

### Description
Setup this editor for the provided action_map and binding_modifier.

### Parameters
- **action_map** (OpenXRActionMap) - The action map to associate with the editor.
- **binding_modifier** (OpenXRBindingModifier) - The specific binding modifier to be edited.
```

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

### Creating and managing a native menu

Source: https://docs.godotengine.org/en/stable/classes/class_nativemenu.html

Demonstrates creating a menu, adding items with callbacks, displaying it as a popup, and freeing the menu resource.

```gdscript
var menu

func _menu_callback(item_id):
	if item_id == "ITEM_CUT":
		cut()
	elif item_id == "ITEM_COPY":
		copy()
	elif item_id == "ITEM_PASTE":
		paste()

func _enter_tree():
	# Create new menu and add items:
	menu = NativeMenu.create_menu()
	NativeMenu.add_item(menu, "Cut", _menu_callback, Callable(), "ITEM_CUT")
	NativeMenu.add_item(menu, "Copy", _menu_callback, Callable(), "ITEM_COPY")
	NativeMenu.add_separator(menu)
	NativeMenu.add_item(menu, "Paste", _menu_callback, Callable(), "ITEM_PASTE")

func _on_button_pressed():
	# Show popup menu at mouse position:
	NativeMenu.popup(menu, DisplayServer.mouse_get_position())

func _exit_tree():
	# Remove menu when it's no longer needed:
	NativeMenu.free_menu(menu)
```

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

### List available modules

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/optimizing_for_size.html

Use this command to view all available modules and build options for the engine.

```bash
scons --help
```

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

### Install a custom RichTextEffect

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

Demonstrates how to define a custom effect class and install it into a RichTextLabel instance.

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

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

### Use from() to set a custom start value

Source: https://docs.godotengine.org/en/stable/classes/class_propertytweener.html

Defines a specific starting point for the property interpolation.

```GDScript
var tween = get_tree().create_tween()
tween.tween_property(self, "position", Vector2(200, 100), 1).from(Vector2(100, 100))
```

```C#
Tween tween = GetTree().CreateTween();
tween.TweenProperty(this, "position", new Vector2(200.0f, 100.0f), 1.0f).From(new Vector2(100.0f, 100.0f));
```

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

### submit()

Source: https://docs.godotengine.org/en/stable/classes/class_renderingdevice.html

Pushes frame setup and draw command buffers.

```APIDOC
## submit()

### Description
Pushes the frame setup and draw command buffers then marks the local device as currently processing. Only available in local RenderingDevices.
```

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

### surface_begin(primitive: PrimitiveType, material: Material = null)

Source: https://docs.godotengine.org/en/stable/classes/class_immediatemesh.html

Begins the definition of a new surface.

```APIDOC
## void surface_begin(primitive: PrimitiveType, material: Material = null)

### Description
Begin a new surface.
```

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

### Example Project Directory Structure

Source: https://docs.godotengine.org/en/stable/tutorials/best_practices/project_organization.html

A recommended layout showing how to group assets and scenes within a Godot project.

```text
/project.godot
/docs/.gdignore  # See "Ignoring specific folders" below
/docs/learning.html
/models/town/house/house.dae
/models/town/house/window.png
/models/town/house/door.png
/characters/player/cubio.dae
/characters/player/cubio.png
/characters/enemies/goblin/goblin.dae
/characters/enemies/goblin/goblin.png
/characters/npcs/suzanne/suzanne.dae
/characters/npcs/suzanne/suzanne.png
/levels/riverdale/riverdale.scn
```

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

### Install MinGW-w64 on Linux and macOS

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_windows.html

Commands to install the required MinGW-w64 toolchain on various operating systems.

```bash
pacman -S mingw-w64
```

```bash
apt install mingw-w64
```

```bash
dnf install mingw64-gcc-c++ mingw64-winpthreads-static \
            mingw32-gcc-c++ mingw32-winpthreads-static
```

```bash
brew install mingw-w64
```

```bash
urpmi mingw64-gcc-c++ mingw64-winpthreads-static \
      mingw32-gcc-c++ mingw32-winpthreads-static
```

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

### start(time_sec: float = -1)

Source: https://docs.godotengine.org/en/stable/classes/class_timer.html

Starts or resets the timer. Fails if the timer is not inside the scene tree.

```APIDOC
## void start(time_sec: float = -1)

### Description
Starts the timer, or resets the timer if it was started already. Fails if the timer is not inside the scene tree. If time_sec is greater than 0, this value is used for the wait_time.

### Parameters
- **time_sec** (float) - Optional - The duration to set for the timer if greater than 0.
```

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

### initialize

Source: https://docs.godotengine.org/en/stable/classes/class_webrtcpeerconnection.html

Initializes the peer connection with the provided configuration.

```APIDOC
Error initialize(configuration: Dictionary = {})
```

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

### Install system dependencies for Fedora

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Install the required development packages for Godot's third-party dependencies on Fedora.

```bash
sudo dnf install -y \
  embree-devel \
  enet-devel \
  glslang-devel \
  graphite2-devel \
  harfbuzz-devel \
  libicu-devel \
  libsquish-devel \
  libtheora-devel \
  libvorbis-devel \
  libwebp-devel \
  libzstd-devel \
  mbedtls-devel \
  miniupnpc-devel \
  SDL3-devel
```

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

### Install and name export templates

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Paths and naming conventions for custom export templates.

```text
$HOME/.local/share/godot/export_templates/<version>/
```

```text
linux_debug.arm32
linux_debug.arm64
linux_debug.x86_32
linux_debug.x86_64
linux_release.arm32
linux_release.arm64
linux_release.x86_32
linux_release.x86_64
```

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

### Install dependencies on openKylin

Source: https://docs.godotengine.org/en/stable/engine_details/development/compiling/compiling_for_linuxbsd.html

Use apt to install build tools and libraries, including SCons via pip.

```bash
sudo apt update
sudo apt install -y \
  python3-pip \
  build-essential \
  pkg-config \
  libx11-dev \
  libxcursor-dev \
  libxinerama-dev \
  libgl1-mesa-dev \
  libglu1-mesa-dev \
  libasound2-dev \
  libpulse-dev \
  libudev-dev \
  libxi-dev \
  libxrandr-dev \
  libwayland-dev
sudo pip install scons
```
Tokens:
Raw