Godot Engine

https://docs.godotengine.org/en/latest/
Admin
Godot Engine is a free and open-source game engine that supports 2D and 3D game development with...
Tokens:11,309,910
Snippets:268,257
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### Basic TCPServer Setup and Connection Handling

Source: https://docs.godotengine.org/en/latest/classes/class_tcpserver.html

This example demonstrates how to initialize a TCPServer, listen on a specific port, and accept incoming connections. Replace the 'use_stream' function content with your specific logic for handling client data.

```GDScript
extends Node;

const DEFAULT_PORT: int = 19388;
var server: TCPServer;


func use_stream(stream: StreamPeerTCP):
    # Your Code Here
    pass;

func _ready():
    server = TCPServer.new();
    
    server.listen(DEFAULT_PORT);
func _process(_dt: float):
    while server.is_connection_available():
        var stream: StreamPeerTCP = server.take_connection();


        use_stream(stream);

```

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

### Local Signaling Example Setup

Source: https://docs.godotengine.org/en/latest/tutorials/networking/webrtc.html

Initializes a WebRTC peer connection for a p2p chat client using a local signaling server.

```gdscript
extends Node
# An example p2p chat client.

var peer = WebRTCPeerConnection.new()


```

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

### Initialization Example

Source: https://docs.godotengine.org/en/latest/classes/class_mobilevrinterface.html

Example of how to find and initialize the 'Native mobile' VR interface.

```APIDOC
## Initialization Example

### Description
This code snippet demonstrates how to find the 'Native mobile' VR interface provided by XRServer and initialize it. If initialization is successful, it enables VR usage for the viewport.

### Method
```gdscript
var interface = XRServer.find_interface("Native mobile")
if interface and interface.initialize():
	get_viewport().use_xr = true
```

### Notes
Ensure that the necessary input device sensors (accelerometer, gyroscope, etc.) are enabled in Project Settings for Android.
```

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

### C++ For Loop Examples

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

Provides examples of C-style for loops in C++ with different starting points, conditions, and increment steps.

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

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

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

```

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

### GDScript Hello World

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

A basic GDScript example to print 'Hello world!' to the console when the node is ready. This is typically used for initial setup and testing.

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

```

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

### Complete Script GDScript Example

Source: https://docs.godotengine.org/en/latest/tutorials/scripting/index.html

A complete GDScript example that combines node setup and basic movement. This script is attached to a Node2D and prints a message when ready.

```gdscript
extends Node2D

func _ready():
    print("Hello, world!")

func _process(delta):
    position.x += 100 * delta
```

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

### Connect to OpenXR Session Begun Signal

Source: https://docs.godotengine.org/en/latest/tutorials/xr/openxr_spatial_entities.html

Connects the `_set_up_persistence_context` function to the `session_begun` signal of the OpenXR interface. This ensures that the persistence context is set up when the OpenXR session starts. It also calls the setup function immediately in case the session is already running.

```GDScript
func _enter_tree():
	var openxr_interface : OpenXRInterface = XRServer.find_interface("OpenXR")
	if openxr_interface and openxr_interface.is_initialized():
		# Just in case our session hasn't started yet,
		# call our context creation on start beginning with our persistence scope.
		openxr_interface.session_begun.connect(_set_up_persistence_context)

		# And in case it is already up and running, call it already,
		# it will exit if we've called it too early.
		_set_up_persistence_context()

```

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

### C# Hello World

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

A basic C# example to print 'Hello world!' to the console when the node is ready. This is the equivalent of the GDScript example for C# users.

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

```

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

### Start Engine with Default Configuration

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

Automatically loads and initializes the engine before starting the game using the provided configuration. The `engine.startGame` method is asynchronous and returns a Promise.

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

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

### Minimal WebSocket Server Example

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

Set up a WebSocket server to listen for incoming connections and handle data exchange. This example requires a TCPServer instance.

```GDScript
extends Node

# The port we will listen to.
const PORT = 9080

# Our TCP Server instance.
var _tcp_server = TCPServer.new()

```

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

### Install Dependencies on NetBSD

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

Installs pkg-config and Python 3.13 SCons on NetBSD using pkgin.

```bash
pkgin install \
  pkg-config \
  py313-scons

```

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

### Template Naming Examples

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

Shows examples of how script templates are named within their respective node type directories.

```plaintext
script_templates/Node/smooth_camera.gd
```

```plaintext
script_templates/CharacterBody3D/platformer_movement.gd
```

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

### Install mold on Fedora

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

Installs the mold linker on Fedora systems. This is a prerequisite for using mold for faster compilation.

```bash
sudo dnf install -y mold

```

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

### Set/Get Start Position

Source: https://docs.godotengine.org/en/latest/classes/class_navigationpathqueryparameters2d.html

Allows setting and getting the pathfinding start position in global coordinates.

```APIDOC
## Set/Get Start Position

### Description
Manages the starting point for pathfinding queries in global 2D coordinates.

### Method
- `set_start_position(value: Vector2)`: Sets the pathfinding start position.
- `get_start_position()`: Returns the current pathfinding start position.

### Parameters
#### Path Parameters
- **start_position** (Vector2) - The pathfinding start position in global coordinates. Defaults to `Vector2(0, 0)`.
```

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

### Install mold on Debian/Ubuntu

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

Installs the mold linker on Debian-based systems. This is a prerequisite for using mold for faster compilation.

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

```

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

### Example Output of WebRTC Chat

Source: https://docs.godotengine.org/en/latest/tutorials/networking/webrtc.html

This is an example of the console output when two peers successfully exchange messages using the WebRTC setup.

```text
/root/main/@@3 received: Hi from /root/main/@@2
/root/main/@@2 received: Hi from /root/main/@@3
```

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

### Example Server Output

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

This output demonstrates a successful server startup and a client connection, including receiving and echoing a text packet.

```text
Server started.
+ Peer 2 connected.
< Got text data from peer 2: Test packet ... echoing


```

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

### Cut Video Segment with FFmpeg

Source: https://docs.godotengine.org/en/latest/tutorials/animation/creating_movies.html

Trim a video by specifying the start time and duration. This example keeps 5.2 seconds of video starting from 12.1 seconds.

```bash
ffmpeg -i input.avi -ss 00:00:12.10 -t 00:00:05.20 -crf 15 output.mp4

```

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

### Set up DTLS Server and Handle Connections (C#)

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

This C# example demonstrates how to set up a DTLS server using a private key and certificate, listen for UDP connections, and accept DTLS clients. It includes logic for polling peers and handling incoming/outgoing DTLS packets. Note that some initial connections may fail due to the cookie exchange process.

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

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

### Getting Physical Keycode String Representation

Source: https://docs.godotengine.org/en/latest/classes/class_inputeventkey.html

Example demonstrating how to get a human-readable string representation of a physical keycode using `OS.get_keycode_string()` in combination with `DisplayServer` functions.

```APIDOC
## Getting Physical Keycode String Representation

### Description
This example shows how to obtain the human-readable string for a physical keycode by converting it to a keycode and label using `DisplayServer` functions and then using `OS.get_keycode_string()`.

### GDScript Example
```gdscript
func _input(event):
	if event is InputEventKey:
		var keycode = DisplayServer.keyboard_get_keycode_from_physical(event.physical_keycode)
		var label = DisplayServer.keyboard_get_label_from_physical(event.physical_keycode)
		print(OS.get_keycode_string(keycode))
		print(OS.get_keycode_string(label))
```

### C# Example
```csharp
public override void _Input(InputEvent @event)
{
    if (@event is InputEventKey inputEventKey)
    {
        var keycode = DisplayServer.KeyboardGetKeycodeFromPhysical(inputEventKey.PhysicalKeycode);
        var label = DisplayServer.KeyboardGetLabelFromPhysical(inputEventKey.PhysicalKeycode);
        GD.Print(OS.GetKeycodeString(keycode));
        GD.Print(OS.GetKeycodeString(label));
    }
}
```
```

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

### Build Release Templates with Tracy Support (Windows Example)

Source: https://docs.godotengine.org/en/latest/engine_details/development/profiling/tracy.html

Build the release templates for your platform with Tracy profiler support. Ensure 'profiler_path' points to your cloned Tracy directory and 'debug_symbols=yes' is set for sampling features.

```bash
scons platform=windows target=template_release debug_symbols=yes profiler=tracy profiler_path=path/to/tracy

```

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

### Example File System Structure

Source: https://docs.godotengine.org/en/latest/tutorials/scripting/filesystem.html

Illustrates a typical project structure with Godot files and assets.

```plaintext
/project.godot
/enemy/enemy.tscn
/enemy/enemy.gd
/enemy/enemysprite.png
/player/player.gd

```

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

### C# "Hello, world!" Example

Source: https://docs.godotengine.org/en/latest/engine_details/editor/index.html

A basic C# example to print "Hello, world!" to the console. This demonstrates the syntax for outputting text in C# within Godot.

```csharp
using Godot;

public class HelloWorld : Node
{
    public override void _Ready()
    {
        GD.Print("Hello, world!");
    }
}
```

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

### get_delimiter_start_key

Source: https://docs.godotengine.org/en/latest/classes/class_codeedit.html

Gets the start key for a specified string or comment region index.

```APIDOC
## get_delimiter_start_key

### Description
Gets the start key for a string or comment region index.

### Method
String get_delimiter_start_key(int delimiter_index) const

### Parameters
#### Path Parameters
- **delimiter_index** (int) - Required - The index of the string or comment region.

### Returns
String: The start key of the specified delimiter.
```

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

### Get Collision Shape Node Example (GDScript)

Source: https://docs.godotengine.org/en/latest/classes/class_raycast3d.html

Retrieves the intersected shape node when a RayCast3D collides with a CollisionObject3D. This involves getting the collider, its shape ID, and then the owner of that shape.

```gdscript
var target = get_collider() # A CollisionObject3D.
var shape_id = get_collider_shape() # The shape index in the collider.
var owner_id = target.shape_find_owner(shape_id) # The owner ID in the collider.
var shape = target.shape_owner_get_owner(owner_id)
```

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

### GDScript "Hello, world!" Example

Source: https://docs.godotengine.org/en/latest/about/list_of_features.html

A basic GDScript example demonstrating the "Hello, world!" output. This is often the first script written when learning GDScript.

```gdscript
extends Node2D

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

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

### Absolute Node Paths

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

These examples demonstrate absolute paths that start from the SceneTree's root.

```gdscript
^"/root"            # Points to the SceneTree's root Window.
```

```gdscript
^"/root/Title"      # May point to the main scene's root node named "Title".
```

```gdscript
^"/root/Global"     # May point to an autoloaded node or scene named "Global".
```

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

### Manually Start Engine with Custom Files

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

Provides full control over the engine startup process by manually initializing and starting the engine. This method does not automatically preload the PCK file, so it should be preloaded manually using `engine.preloadFile`.

```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!');
});
```

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

### Start Server with --headless Argument (C#)

Source: https://docs.godotengine.org/en/latest/tutorials/export/exporting_for_dedicated_servers.html

This C# snippet allows you to start a dedicated server when the Godot binary is run with the `--headless` command-line argument. Place this in your main scene or an autoload's _ready() method.

```csharp
using System.Linq;

if (DisplayServer.GetName() == "headless")
{
    // Run your server startup code here...
    //
    // Using this check, you can start a dedicated server by running
    // a Godot binary (editor or export template) with the `--headless`
    // command-line argument.
}

```

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

### Get Subname - C#

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

Retrieves a property subname from the path by its index. Indices start from 0.

```csharp
var pathToName = new NodePath("Sprite2D:texture:resource_name");
GD.Print(pathToName.GetSubname(0)); // Prints "texture"
GD.Print(pathToName.GetSubname(1)); // Prints "resource_name"
```

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

### Get Subname - GDScript

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

Retrieves a property subname from the path by its index. Indices start from 0.

```gdscript
var path_to_name = NodePath("Sprite2D:texture:resource_name")
print(path_to_name.get_subname(0)) # Prints "texture"
print(path_to_name.get_subname(1)) # Prints "resource_name"
```

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

### C++ GDExtension "Hello, world!" Example

Source: https://docs.godotengine.org/en/latest/engine_details/editor/index.html

A basic C++ example using GDExtension to print "Hello, world!" to the Godot console. This shows the fundamental structure for C++ integration.

```cpp
#include <Godot.hpp>

namespace godot {

class HelloWorld : public Node {
private:

public:
  static void _register_methods() {
    register_method("_ready", &HelloWorld::_ready);
  }

  void _ready() {
    Godot::print("Hello, world!");
  }
};

} // namespace godot
```

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

### Get Name - C#

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

Retrieves a node name from the path by its index. Indices start from 0.

```csharp
var spritePath = new NodePath("../RigidBody2D/Sprite2D");
GD.Print(spritePath.GetName(0)); // Prints ".."
GD.Print(spritePath.GetName(1)); // Prints "PathFollow2D"
GD.Print(spritePath.GetName(2)); // Prints "Sprite"
```

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

### Set up DTLS Server and Handle Connections (GDScript)

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

This GDScript example demonstrates how to set up a DTLS server using a private key and certificate, listen for UDP connections, and accept DTLS clients. It includes logic for polling peers and handling incoming/outgoing DTLS packets. Note that some initial connections may fail due to the cookie exchange process.

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


```

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

### Get Name - GDScript

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

Retrieves a node name from the path by its index. Indices start from 0.

```gdscript
var sprite_path = NodePath("../RigidBody2D/Sprite2D")
print(sprite_path.get_name(0)) # Prints ".."
print(sprite_path.get_name(1)) # Prints "RigidBody2D"
print(sprite_path.get_name(2)) # Prints "Sprite"
```

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

### Initialize Git Submodules for Existing Project

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

If you cloned the example project, you need to initialize its Git submodules. Run this command within your project directory.

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

```

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

### Get Collision Shape Node Example (C#)

Source: https://docs.godotengine.org/en/latest/classes/class_raycast3d.html

Retrieves the intersected shape node when a RayCast3D collides with a CollisionObject3D using C#. This involves getting the collider, its shape ID, and then the owner of that shape.

```csharp
var target = (CollisionObject3D)GetCollider(); // A CollisionObject3D.
var shapeId = GetColliderShape(); // The shape index in the collider.
var ownerId = target.ShapeFindOwner(shapeId); // The owner ID in the collider.
var shape = target.ShapeOwnerGetOwner(ownerId);
```

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

### cutoff_hz Property

Source: https://docs.godotengine.org/en/latest/classes/class_audioeffectfilter.html

Sets or gets the frequency threshold for the filter in Hz. This value determines the point at which frequencies start to be attenuated or amplified.

```APIDOC
## Property Descriptions

float **cutoff_hz** = `2000.0`
  * void **set_cutoff**(value: float)
  * float **get_cutoff**()

Frequency threshold for the filter, in Hz. Value can range from 1 to 20500.
```

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

### Hello, world! GDScript Example

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

A basic GDScript example to print "Hello, world!" to the console. This is often the first script written when learning a new language.

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

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

### X509Certificate Tutorials

Source: https://docs.godotengine.org/en/latest/classes/class_xrvrs.html

Links to tutorials that demonstrate the usage of the X509Certificate class.

```APIDOC
## X509Certificate Tutorials

### Description
Learn how to use X509Certificate with these tutorials.

### Tutorials

- **Tutorial Name**: A brief description of the tutorial content.
```

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

### ConfirmationDialog Usage Example

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

Demonstrates how to create, configure, and display a ConfirmationDialog, including connecting signals for user actions.

```APIDOC
## ConfirmationDialog Usage Example

### Description
This example shows how to instantiate a ConfirmationDialog, set its title and text, connect to its `canceled` and `confirmed` signals, and display it.

### GDScript Example
```gdscript
func show_remove_confirmation_dialog():
    # Create dialog
    var dialog = ConfirmationDialog.new()
    dialog.title = "Remove Level"
    dialog.dialog_text = "This operation cannot be undone, are you sure to remove level?"

    # connect signals
    dialog.canceled.connect (dialog_canceled)
    dialog.confirmed.connect (dialog_confirmed)

    # show dialog
    add_child(dialog)
    dialog.popup_centered() # center on screen
    dialog.show()

func dialog_canceled():
    print("User clicked Cancel")

func dialog_confirmed():
    print("User clicked OK")
```

### C# Example
```csharp
public void ShowRemoveConfirmationDialog() {
    // Create dialog
    ConfirmationDialog dialog = new ConfirmationDialog();
    dialog.Title = "Remove Level";
    dialog.DialogText = "This operation cannot be undone, are you sure to remove level?";

    // connect signals
    dialog.Canceled += DialogCanceled;
    dialog.Confirmed += DialogConfirmed;

    // show dialog
    AddChild(dialog);
    dialog.PopupCentered(); // center on screen
    dialog.Show();
}

public void DialogCanceled() {
    GD.Print("User clicked Cancel");
}

public void DialogConfirmed() {
    GD.Print("User clicked OK");
}
```

### Notes
- The `canceled` and `confirmed` signals are emitted when the respective buttons are pressed.
- `popup_centered()` is a method inherited from `Window` to display the dialog centered on the screen.
```

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

### Comment Spacing: Good Example

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

Shows correct comment formatting, starting regular comments with a space and commented-out code without a leading space.

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


```

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

### Start Server with Custom --server Argument (C#)

Source: https://docs.godotengine.org/en/latest/tutorials/export/exporting_for_dedicated_servers.html

This C# snippet enables starting a dedicated server using a custom command-line argument, such as `--server`. Add this to your main scene or an autoload's _ready() method.

```csharp
using System.Linq;

if (OS.GetCmdlineUserArgs().Contains("--server"))
{
    // Run your server startup code here...
    //
    // Using this check, you can start a dedicated server by running
    // a Godot binary (editor or export template) with the `--server`
    // command-line argument.
}

```

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

### Set Custom Initial Value with PropertyTweener

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

Use from() to specify a custom starting value for the interpolation. This example moves a node from (100, 100) to (200, 100).

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

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

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

### Main Game Node Setup

Source: https://docs.godotengine.org/en/latest/tutorials/io/saving_games.html

Initializes the main game scene, preloads a saveable node, connects signals, and adds it to the scene tree.

```gdscript
#main.gd
extends Node2D

signal increase_score
@onready var saveNode := preload("res://instantiated_save_load_node.tscn")


# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	var pleaseSave = saveNode.instantiate()
	pleaseSave.creator_id = self
	pleaseSave.update_scores.connect(update_score_label)
	add_child(pleaseSave)
	print(pleaseSave)
	pass # Replace with function body.


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	pass

func call_to_save():
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		save()
	save_game()
	
func update_score_label(score,highscore):
	print(score," ",highscore)
	$LabelScore.text = str(score)
	$LabelHighScore.text = str(highscore)
	pass
	
func _on_button_increase_score_pressed() -> void:
	increase_score.emit()
	print("increase_score_signal_emitted_from_main")
	pass # Replace with function body.
	
func _on_button_save_game_pressed() -> void:
	call_to_save()
	pass # Replace with function body.

	
func _on_button_load_game_pressed() -> void:
	load_game()
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		doOnLoadSave()
	#need a way to tell the "newly" re-made saveScoreNode to resend the updateLabels update_scores.emit(score,highscore)
	pass # Replace with function body.
	
#again sense im calling from this node i must have a "dummy" function,
#have this function in every node that has Persist monaker, and is presumably saving info
#do this when you load :).....biatch! only 1 week now...roughly 40 hours over 6 days
func doOnLoadSave():
	#do a thing on loadSaveGame...
	#iterate through all nodes in Persist group and do the thing, if nothing to do just have pass here
	#update_scores.emit(score,highscore)
	pass


# Note: This can be called from anywhere inside the tree. This function is
# path independent.
# Go through everything in the persist category and ask them to return a
# dict of relevant variables.
func save_game():
	var save_file = FileAccess.open("user://savegame.save", FileAccess.WRITE)
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		# Check the node is an instanced scene so it can be instanced again during load.
		if node.scene_file_path.is_empty():
			print("persistent node '%s' is not an instanced scene, skipped" % node.name)
			continue

		# Check the node has a save function.
		if !node.has_method("save"):
			print("persistent node '%s' is missing a save() function, skipped" % node.name)
			continue

		# Call the node's save function.
		var node_data = node.call("save")

		# JSON provides a static method to serialized JSON string.
		var json_string = JSON.stringify(node_data)

		# Store the save dictionary as a new line in the save file.
		save_file.store_line(json_string)
		
```

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

### Modify Runtime Settings Directly (C#)

Source: https://docs.godotengine.org/en/latest/tutorials/editor/project_settings.html

Access and modify runtime properties or methods directly for settings that are read only once at game start. Examples include `Engine.MaxFps` and `DisplayServer.WindowSetMode()`.

```csharp
Engine.MaxFps = 60;
DisplayServer.WindowSetMode(DisplayServer.WindowMode.Windowed);
```

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

### Get Effective Arguments Example

Source: https://docs.godotengine.org/en/latest/classes/class_callable.html

Calculates the effective arguments for a callable by combining call arguments with bound arguments, excluding unbound arguments from the initial call arguments.

```gdscript
func get_effective_arguments(callable, call_args):
	assert(call_args.size() - callable.get_unbound_arguments_count() >= 0)
	var result = call_args.slice(0, call_args.size() - callable.get_unbound_arguments_count())
	result.append_array(callable.get_bound_arguments())
	return result

```

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

### GDExtension Initialization

Source: https://docs.godotengine.org/en/latest/tutorials/plugins/editor/making_plugins.html

Demonstrates the basic structure for initializing a GDExtension in C++. This includes setting up the initialization function and library pointer.

```csharp
void initialize_my_extension(GDExtensionInterfaceGetProcAddress p_get_proc_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
    // ... initialization code ...
}
```

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

### C# Example: Interacting with JavaScript Objects

Source: https://docs.godotengine.org/en/latest/classes/class_javascriptobject.html

This C# example demonstrates how to create JavaScript callbacks, access JavaScript interfaces like 'console', create JavaScript objects such as ArrayBuffer and Uint8Array, set and get indexed properties, and call JavaScript functions from C#. It's intended for Godot 3.6 and web exports.

```csharp
using Godot;

public class BasicExample : Node
{
    JavaScriptObject _my_js_callback;
    JavaScriptObject console;

    public override void _Ready()
    {
        _my_js_callback = JavaScript.CreateCallback(this, nameof(MyCallback)); // This reference must exist when it is called, or else it won't be called
        console = JavaScript.GetInterface("console");

        JavaScriptObject buf = JavaScript.CreateObject("ArrayBuffer", 10) as JavaScriptObject; // new ArrayBuffer(10)
        GD.Print(buf); // Prints [JavaScriptObject:OBJECT_ID]
        JavaScriptObject uint8arr = JavaScript.CreateObject("Uint8Array", buf) as JavaScriptObject; // new Uint8Array(buf)
        uint8arr.Set("1", 255);

        GD.PrintS(uint8arr.Get("1"), uint8arr.Get("length")); // Prints "255 10"

        // Prints "Uint8Array(10) [ 0, 255, 0, 0, 0, 0, 0, 0, 0, 0 ]" in the browser's console.
        console.Call("log", uint8arr);

        // Equivalent of JavaScriptBridge: Array.from(uint8arr).forEach(myCallback)
        (JavaScript.GetInterface("Array").Call("from", uint8arr) as JavaScriptObject).Call("forEach", _my_js_callback);
    }

    public void MyCallback(params object[] args)
    {
        // Will be called with the parameters passed to the "forEach" callback
        // [0, 0, [JavaScriptObject:1173]]
        // [255, 1, [JavaScriptObject:1173]]
        // ...
        // [0, 9, [JavaScriptObject:1180]]
        GD.PrintS(args);
    }
}
```

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

### Start UDPServer and Handle Connections (C#)

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

This C# snippet shows how to set up a UDPServer, listen on a port, and manage incoming connections and data. Ensure poll() is called frequently.

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

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

### Example .gitattributes for Git LFS

Source: https://docs.godotengine.org/en/latest/tutorials/best_practices/version_control_systems.html

A sample `.gitattributes` file to start with for Git LFS. It normalizes line endings for text files and specifies common binary asset types to be tracked by LFS.

```gitattributes
# Normalize EOL for all files that Git considers text files.
* text=auto eol=lf

# Git LFS Tracking (Assets)


```

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

### Initialize and Connect HTTP Client (C#)

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

Creates an HTTPClient instance, connects to a host and port, and polls until connected. Uses Debug.Assert for error checking.

```csharp
public override async void _Initialize()
{
	Error err;
	HTTPClient http = new HTTPClient(); // Create the client.

	err = http.ConnectToHost("www.php.net", 80); // Connect to host/port.
	Debug.Assert(err == Error.Ok); // Make sure the connection is OK.

	// Wait until resolved and connected.
	while (http.GetStatus() == HTTPClient.Status.Connecting || http.GetStatus() == HTTPClient.Status.Resolving)
	{
		http.Poll();
		GD.Print("Connecting...");
		OS.DelayMsec(500);
	}

	Debug.Assert(http.GetStatus() == HTTPClient.Status.Connected); // Check if the connection was made successfully.
```

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

### Custom Logger Implementation

Source: https://docs.godotengine.org/en/latest/tutorials/scripting/logging.html

Implement a custom logger by extending the Logger class and defining _log_message and _log_error methods. This example shows a minimal setup for custom logging, intended to be added as an autoload.

```gdscript
extends Node

class CustomLogger extends Logger:
	# Note that this method is not called for messages that use
	# `push_error()` and `push_warning()`, even though these are printed to stderr.
	func _log_message(message: String, error: bool) -> void:
		# Do something with `message`.
		# `error` is `true` for messages printed to the standard error stream (stderr) with `print_error()`.
		# Note that this method will be called from threads other than the main thread, possibly at the same
		# time, so you will need to have some kind of thread-safety as part of it, like a Mutex.
		pass

	func _log_error(
			function: String,
			file: String,
			line: int,
			code: String,
			rationale: String,
			editor_notify: bool,
			error_type: int,
			script_backtraces: Array[ScriptBacktrace]
	) -> void:
		# Do something with the error. The error text is in `rationale`.
		# See the Logger class reference for details on other parameters.
		# Note that this method will be called from threads other than the main thread, possibly at the same
		# time, so you will need to have some kind of thread-safety as part of it, like a Mutex.
		pass

# Use `_init()` to initialize the logger as early as possible, which ensures that messages
# printed early are taken into account. However, even when using `_init()`, the engine's own
# initialization messages are not accessible.
func _init() -> void:
	OS.add_logger(CustomLogger.new())

```

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

### Adding and Managing a Custom Dock

Source: https://docs.godotengine.org/en/latest/classes/class_editordock.html

This example demonstrates how to create a custom dock, set its properties, add content, and integrate it into the editor using an EditorPlugin.

```APIDOC
## _enter_tree()

### Description
Plugin initialization function. Creates and adds a custom dock to the editor.

### Method
func _enter_tree():

### Code
```gdscript
@tool
extends EditorPlugin

# Dock reference.
var dock

# Plugin initialization.
func _enter_tree():
	dock = EditorDock.new()
	dock.title = "My Dock"
	ddock.dock_icon = preload("./dock_icon.png")
	ddock.default_slot = EditorDock.DOCK_SLOT_RIGHT_UL
	var dock_content = preload("./dock_content.tscn").instantiate()
	dock.add_child(dock_content)
	add_dock(dock)
```
```

```APIDOC
## _exit_tree()

### Description
Plugin clean-up function. Removes and frees the custom dock when the plugin is removed or the editor closes.

### Method
func _exit_tree():

### Code
```gdscript
@tool
extends EditorPlugin

# Dock reference.
var dock

# Plugin clean-up.
func _exit_tree():
	remove_dock(dock)
	dock.queue_free()
	dock = null
```
```

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

### GDScript: Hello, world!

Source: https://docs.godotengine.org/en/latest/classes/index.html

A basic GDScript example to print 'Hello, world!' to the console. This is often the first script written when learning GDScript.

```gdscript
print("Hello, world!")
```

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

### Node Script for Saving/Loading

Source: https://docs.godotengine.org/en/latest/tutorials/io/saving_games.html

An example script for a node that can be saved and loaded. It includes score variables, signals, and uses `@onready` to get a reference to its parent. This script demonstrates how to integrate with the save/load system by defining saveable properties and signals.

```gdscript
#instantiated_save_load_node.gd
extends Node2D

#dont forget to type-reference( := ),( : type =) for sanity sake when dynamic programming assumes wrong, sometimes!
var score : int = 0
var highscore : int = 0
signal update_scores(arg1,arg2)
#could just use parent, untill we have to do alot of re-referncing when we load_game()
@onready var mainId := get_parent()

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	print("saveNode-mainId: ",mainId)
	mainId.increase_score.connect(scoreUp)
	mainId.update_signal_connections(self)
	pass # Replace with function body.


```

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

### DTLSServer.setup

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

Sets up the DTLS server with the provided server options. This method initializes the server to use specific TLS configurations.

```APIDOC
## DTLSServer.setup

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

### Method Signature
Error setup(server_options: TLSOptions)
```

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

### Query Paths with Specific Agent Sizes

Source: https://docs.godotengine.org/en/latest/tutorials/navigation/navigation_different_actor_types.html

Define start and end positions, along with a flag to use corridor funneling, to query navigation paths. This example shows how to retrieve paths for different agent sizes by using their respective navigation maps.

```csharp
// Create start and end position for the navigation path query.
Vector3 startPos = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 endPos = new Vector3(2.0f, 0.0f, 0.0f);
bool useCorridorFunnel = true;

// Query paths for each agent size.
var pathStandardAgent = NavigationServer3D.MapGetPath(navigationMapStandard, startPos, endPos, useCorridorFunnel);
var pathSmallAgent = NavigationServer3D.MapGetPath(navigationMapSmall, startPos, endPos, useCorridorFunnel);
var pathHugeAgent = NavigationServer3D.MapGetPath(navigationMapHuge, startPos, endPos, useCorridorFunnel);
```

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

### Brace Placement: Good Example

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

Follows the 1TBS style by placing the opening brace on the same line as the control statement. Always use braces for statements.

```glsl
void fragment() {
    if (true) {
        // ...
    }
}


```

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

### Get Build Dependencies for Resource

Source: https://docs.godotengine.org/en/latest/classes/class_resourceimporter.html

Override this method to specify build dependencies required by an imported resource. This is useful when a resource relies on specific engine modules or configurations. The example shows how to check a resource property and add a corresponding build dependency string.

```GDScript
func _get_build_dependencies(path):
	var resource = load(path)
	var dependencies = PackedStringArray()

	if resource.multichannel_signed_distance_field:
		dependencies.push_back("module_msdfgen_enabled")

	return dependencies

```

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

### start_simulation

Source: https://docs.godotengine.org/en/latest/classes/class_skeletonmodification2dphysicalbones.html

Tells the PhysicalBone2D nodes to start simulating and interacting with the physics world.

```APIDOC
## start_simulation(bones: Array[StringName] = [])

### Description
Tell the PhysicalBone2D nodes to start simulating and interacting with the physics world. Optionally, an array of bone names can be passed to this function, and that will cause only PhysicalBone2D nodes with those names to start simulating.

### Method
void

### Parameters
- **bones** (Array[StringName], optional) - An array of bone names to start simulating. If empty, all bones will simulate.

### Returns
None
```

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

### Install SCons using MacPorts

Source: https://docs.godotengine.org/en/latest/engine_details/development/compiling/compiling_for_ios.html

Use this command to install SCons if you have MacPorts installed.

```bash
sudo port install scons
```

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

### GDExtension Initialization

Source: https://docs.godotengine.org/en/latest/tutorials/scripting/cpp/gdextension_docs_system.html

Initializes the GDExtension by registering classes and setting up the extension API. This is the entry point for your GDExtension.

```c
#include <godot_cpp/core/class_db.hpp>
#include <godot_cpp/core/defs.hpp>
#include <godot_cpp/godot.hpp>

#include "my_class.h"

using namespace godot;

extern "C" {
// Called by Godot to begin the extension.
void GD_EXPORT initialize_extension(ModuleInitializationLevel p_level) {
	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
		return;
	}

	ClassDB::register_class<MyClass>();
}

// Called by Godot when the extension is unloaded.
void GD_EXPORT deinitialize_extension(ModuleInitializationLevel p_level) {
	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
		return;
	}
}

// Called by Godot to get the version of the GDExtension.
int GD_EXPORT get_extension_version() {
	return 1;
}
}

```

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

### Install SCons via Homebrew

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

Use this command to install the SCons build system if you have Homebrew installed.

```bash
brew install scons

```

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

### Install Dependencies on Ubuntu/Debian with Pip for SCons

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

Installs compilation dependencies on Ubuntu or Debian using apt and pip. This command installs build tools, development libraries, and then installs 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

```

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

### Install SCons using Homebrew

Source: https://docs.godotengine.org/en/latest/engine_details/development/compiling/compiling_for_ios.html

Use this command to install SCons if you have Homebrew installed. This also fetches Xcode Command Line Tools.

```bash
brew install scons
```

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

### Set up a MultiMesh in C#

Source: https://docs.godotengine.org/en/latest/tutorials/performance/using_multimesh.html

Initializes a MultiMesh with a specified instance count and transform format. Use this to prepare a MultiMesh for drawing many instances.

```C#
using Godot;

public partial class MyMultiMeshInstance3D : MultiMeshInstance3D
{
    public override void _Ready()
    {
        // Create the multimesh.
        Multimesh = new MultiMesh();
        // Set the format first.
        Multimesh.TransformFormat = MultiMesh.TransformFormatEnum.Transform3D;
        // Then resize (otherwise, changing the format is not allowed)
        Multimesh.InstanceCount = 1000;
        // Maybe not all of them should be visible at first.
        Multimesh.VisibleInstanceCount = 1000;

        // Set the transform of the instances.
        for (int i = 0; i < Multimesh.VisibleInstanceCount; i++)
        {
            Multimesh.SetInstanceTransform(i, new Transform3D(Basis.Identity, new Vector3(i * 20, 0, 0)));
        }
    }
}

```

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

### Install Dependencies on OpenBSD

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

Installs Python, SCons, and LLVM on OpenBSD using pkg_add. Note that audio support may optionally require installing pulseaudio.

```bash
pkg_add \
  python \
  scons \
  llvm

```

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

### _profiling_start

Source: https://docs.godotengine.org/en/latest/classes/class_scriptlanguageextension.html

Starts script profiling.

```APIDOC
## _profiling_start

### Description
Starts script profiling.

### Method
virtual required
```

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

### Moving Forward GDScript Example

Source: https://docs.godotengine.org/en/latest/getting_started/introduction/index.html

Extends the movement example by showing how to move a character forward. This script snippet is part of a larger example for character control.

```gdscript
var speed = 200
var direction = Vector2.ZERO

func _process(delta):
    direction.x = Input.get_action_strength("move_right") - Input.get_action_strength("move_left")
    if direction.x != 0:
        $Sprite.flip_h = direction.x < 0
        position.x += direction.x * speed * delta
    else:
        pass
```

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

### Start Server with --headless Argument (GDScript)

Source: https://docs.godotengine.org/en/latest/tutorials/export/exporting_for_dedicated_servers.html

This GDScript snippet allows you to start a dedicated server when the Godot binary is run with the `--headless` command-line argument. Place this in your main scene or an autoload's _ready() method.

```gdscript
if DisplayServer.get_name() == "headless":
	# Run your server startup code here...
	#
	# Using this check, you can start a dedicated server by running
	# a Godot binary (editor or export template) with the `--headless`
	# command-line argument.
	pass

```

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

### GDExtension Wrapper API Example

Source: https://docs.godotengine.org/en/latest/tutorials/plugins/editor/making_plugins.html

Illustrates creating a wrapper API for a GDExtension in C++. This allows for more structured interaction with the extension's classes and methods.

```csharp
class MyCustomClassWrapper {
    // ... wrapper methods ...
};

void bind_my_custom_class_methods(GDExtensionInterfaceGetProcAddress p_get_proc_address, const GDExtensionClassLibraryPtr p_library) {
    // ... binding code ...
}
```

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

### start

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

Starts a new hash computation of the given type.

```APIDOC
## start

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

### Method
Error

### Parameters
#### Path Parameters
- **type** (HashType) - Required - The hashing algorithm to use.

### Response
- **Error**: Returns OK on success, or an error code if the type is not supported.
```

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

### Install Dependencies on Gentoo

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

Installs compilation dependencies on Gentoo using emerge. This command synchronizes the repository and installs SCons, various X11 libraries, Mesa, ALSA, and PulseAudio.

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

```

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

### Minimal WebRTC Connection Example

Source: https://docs.godotengine.org/en/latest/tutorials/networking/webrtc.html

Sets up a basic WebRTC connection between two peers within the same application for demonstration purposes. Connects session descriptions and ICE candidates, creates offer, sends messages, and polls for incoming data.

```gdscript
extends Node

# Create the two peers
var p1 = WebRTCPeerConnection.new()
var p2 = WebRTCPeerConnection.new()
# And a negotiated channel for each each peer
var ch1 = p1.create_data_channel("chat", {"id": 1, "negotiated": true})
var ch2 = p2.create_data_channel("chat", {"id": 1, "negotiated": true})

func _ready():
	# Connect P1 session created to itself to set local description.
	p1.session_description_created.connect(p1.set_local_description)
	# Connect P1 session and ICE created to p2 set remote description and candidates.
	p1.session_description_created.connect(p2.set_remote_description)
	p1.ice_candidate_created.connect(p2.add_ice_candidate)

	# Same for P2
	p2.session_description_created.connect(p2.set_local_description)
	p2.session_description_created.connect(p1.set_remote_description)
	p2.ice_candidate_created.connect(p1.add_ice_candidate)

	# Let P1 create the offer
	p1.create_offer()

	# Wait a second and send message from P1.
	await get_tree().create_timer(1).timeout
	ch1.put_packet("Hi from P1".to_utf8_buffer())

	# Wait a second and send message from P2.
	await get_tree().create_timer(1).timeout
	ch2.put_packet("Hi from P2".to_utf8_buffer())

func _process(_delta):
	# Poll connections
	p1.poll()
	p2.poll()

	# Check for messages
	if ch1.get_ready_state() == ch1.STATE_OPEN and ch1.get_available_packet_count() > 0:
		print("P1 received: ", ch1.get_packet().get_string_from_utf8())
	if ch2.get_ready_state() == ch2.STATE_OPEN and ch2.get_available_packet_count() > 0:
		print("P2 received: ", ch2.get_packet().get_string_from_utf8())

```
Tokens:
Raw