Library for extra math types in C#, including Vector4, double-precision, and integer types, all based on Godot's own C# math types. Please view the README for more details and instructions on how to use it.

Adds a 2D cinematic camera that can be used to create smooth transitions between cameras. The plugin contains two scripts: virtual_camera_2d.gd and cinematic_camera_2d.gd. Both can be added to your scenes as nodes through the "Create New Node" menu.

Utility class for registering and serializing light-weight RefCounted-based structs. It can be used as a replacement for Resources; it comes with its advantages and limitations. Register a type with: RefSerializer.register_type(&"ClassName", YourClass.new) Where ClassName is the name used to create and serialize the type and YourClass.new is a constructor Callable, which will be used to create instances of your class. YourClass can be any class, including custom internal classes. It needs to extend RefCounted. Create instances with: RefSerializer.create_object(&"ClassName") It returns an instance of your class created with the provided constructor method. Serialize with: RefSerializer.serialize_object(some_object) where some_object is an instance created with create_object() or deserialized using deserialize_object(). The methods returns a Dictionary that represents your object. Or use store methods: RefSerializer.save_as_text(some_object, "res://object.txt") RefSerializer.save_as_binary(some_object, "res://object.not_txt") Check the repository README for more details.

A high-performance YAML parser and serializer for Godot 4.3+ that speaks fluent Variant. Features include: - Editor integration with custom YAML file editor. - Comprehensive Variant support. Seamlessly parse and stringify most Godot Variant types. - Custom Class support. Register your Script classes for seamless serialization and deserialization. - Parsing YAML files with multiple documents. - Comprehensive style customization, with a style extraction feature during parsing. - Thread-safe parsing and stringifying. - Resource referencing that allows loading resources when parsing, with YAMLSecurity to help prevent loading dangerous resource types.

Provides functionality to control and sync coroutines with Promises similar to JavaScript. Is functional signals, functions, other Promises, and all other types. Compared to other Promise types on the Library, this type's [Modular Inner Classes] allow for easy to customize and extend Promise logic. Feel free to compactly and efferently create any functionality to handle multiple or a single coroutine(s).

Enables access to Google Play Store's in-app review functionality. Installation Steps: - click `Download` button - on the installation dialog... -> keep `Change Install Folder` setting pointing to your project's root directory -> keep `Ignore asset root` checkbox checked -> click `Install` button - enable the plugin via `Project->Project Settings...->Plugins` in the Godot Editor - for usage info, see https://github.com/cengiz-pz/godot-android-inapp-review-plugin/blob/main/README.md

Easy to use Coroutine functionality in Godot 4, such as resume() or join()

GDLinter is an addon for Godot Engine that runs gdlint on save to automatically lint your GDScript as you code. NOTE: This plugin only runs if "gdlint" is installed. Instructions available at https://github.com/Scony/godot-gdscript-toolkit

Introduces to Godot types inspired by the Rust programming language. - Option explicitly denotes that a value can be a null and must be handled - Result explicitly denotes that an operation can fail and must be handled - Custom Errors that carry with them details about the exception, including a cause and display message! It also acts as a place to have a centralized list of errors specific to your application, as GlobalScope.Error doesn't cover most cases. - TimedVars that keep track of when they were created, and can delete themselves after a set amount of time. - Enum structs (experimental): Enums that aren't just integers, but also carry user defined data with them! Good for state handling! Examples, documentation, and playground (see examples/misc) also included! PRs are welcome!!

A collection of high level multiplayer nodes that handshake between the authority and remote peers to prevent sending data to peers that are not yet ready to receive data.

Loggot is a Godot add-on that allow total control on logs.

Plugin to use external web JS audio libraries within Godot. It solves the Audio Stuttering problem some developers may have when exporting 3.2.x Godot builds in HTML5. https://github.com/godotengine/godot/issues/40891

A set of scripts to bridge the "signal gap" between scenes. Signals carry values, Cables carry Signals.

This tool enables easy drag-and-drop functionality for 3D physical objects. 1. Add the `DragDropController.gd` as an `AutoLoad` (aka singleton) to your project. 2. Populate your 3D scene with physical objects 3. As a sibling to the Physics object (e.g. Area, KinematicBody, RigidBody, etc...), add a `Draggable` node 4. Register to the signals of the Draggable node as you see fit, especially the `drag_move` signal The DragDropController uses raycasting to detect where the mouse is hovering over (excuding the dragged object). Use this signal to update the position of your object as it is being dragged. It is done this way since you may want a snapping, animation, or something else, so it is for you to decide. The signal sends two variables, the draggable object and the raycast dictionary output (see https://docs.godotengine.org/en/3.2/classes/class_physicsdirectspacestate.html#class-physicsdirectspacestate-method-intersect-ray for more details) As an example, you may want to receive the signal as the following to simple slide over the collider object: func _on_Draggable_drag_move(node, cast): set_translation(cast['position']) Remember to use pivot points or references to properly position and avoid object overlaps. There is an example project provided where a draggable box slides above a plane.

A collection of the most commonly used animations for your UI

# Stairs Character A simple to use class that enables your CharacterBody3D to handle stairs properly. Mainly tested with the Jolt physics engine and cylinder colliders, not guaranteed to work well with anything else - but try it! ## Usage instructions: 1. Make your character controller extend `StairsCharacter` instead of `CharacterBody3D`. 2. Ensure your character's collider is named 'Collider'. 3. Every frame, set `desired_velocity` to the desired direction of movement. 4. Call `move_and_stair_step()` instead of calling `move_and_slide()`. 5. Done! ### Important: Ensure your character collider's margin value is set low - at most 0.01. Anything higher might cause snags. If you find that you're still snagging on ledges, lower it some more.

An easy, powerful and lightweight TCP client/server in C#. TCPMaid makes it easy to setup a robust client & server, send messages and requests, and provide your own SSL certificate. Features • Easy client & server setup • Supports SSL (TLS) encryption and certificates • Automatically serialises messages • Automatically fragments large messages • Supports requests and responses • Supports IPv4 and IPv6

Light-weight and easy-to-use interface for creating sound effects and music systems

Allows sharing of text and images with other apps on Android platform. Installation Steps: - click `Download` button - on the installation dialog... -> keep `Change Install Folder` setting pointing to your project's root directory -> keep `Ignore asset root` checkbox checked -> click `Install` button - enable the plugin via `Project->Project Settings...->Plugins` in the Godot Editor - for usage info, see https://github.com/cengiz-pz/godot-android-share-plugin/blob/main/README.md

This plugin provides the basic mechanism of DungeonCrawler: - map creation via titlemap node - player movement To run this script, simply play "World.tscn" Global.gd must be added to the autoloader. (Game/Global.gd) More detailed information can be found at: https://github.com/Rebelion-Board-game/DungonCrawler

Provide async functionality to have Promises similar to JavaScript with functions like Promise.all, Promise.race, Promise.any

Parse your midi files directly with native GDScript 4+ with no other dependencies. The example also include a demo of how you can create a sound player based on the parsed midi data. Usage var parser = MidiFileParser.load_file("res://yourmidi.mid") # parser.header contains midi header data # parser.tracks contains all midi tracks ## iterate over tracks and events for track in parser.tracks: for event in track.events: # do something with events here Playback Demo See midi_file_player_example.gd or load and play scene demo/midi_demo. It will contain all required parts (timing, _process loop) to play notes at correct times. The demo uses a very simple generic audio signal generator. Quality is not good but frequencies are correct. It will play "Beethoven - Fur Elise", which you will know for sure.

This plugin maintains game object state (property values) between scene changes as well as saves that state to a file. It handles the following scenarios for you: 1. Re-applying property values to game objects when a scene is reloaded. For example if an object is moved by the player, its position can be maintained so that it is in the new position when the scene is reloaded. 2. Re-instance a game object that was dynamically added to the scene. For example if an enemy drops an item and you want it to stay in the game even when the player leaves the scene, the plugin will re-instance this object when that scene is reloaded. Of course other properties can be persisted too, like the objects position. 3. Re-free a game object that was freed from the scene. For example, a quest item is added to a scene at design time in the Godot editor, and so is normally always present. However, the player can pick up the item which removes the item from the scene tree at runtime. This plugin will note the fact the item was freed and re-free it when the scene is reloaded. 4. Share values between scenes. This is done with a "global" section of the game state data. This allows something happening in one scene to affect something else in another. For example, a switch in once scene can set a global value to true which unlocks a door in another scene. The plugin takes care of all of the above, but if you have special state logic you need to add for a game object, you can hook into the state system by connecting to certain signals (see readme for details).

A character controller for Godot 4 with run, jump, climb, glide, optional stamina, and interactables.