A plugin for Godot that makes creating and maintaining translations much easier and intuitive in-editor. The goal of this plugin is to make it easy to create new translations and add them to existing or new .csv files. This will replace the old workflow of creating new .csv files and adding text before then adding them to editor without being able to see what you're adding. This method is also prone to mistakes where you could make a typo in the key for example. This workflow is also harder to follow through with, as you need to plan out all the text you need ahead of time, or go back and forth between the game and your .csv files constantly. This plugin makes the entire workflow doable from within the editor's inspector.

A unit testing library for Godot. * Define tests with test methods or programmatically with `define()` * Parameterized tests to conveniently define multiple tests * Mock classes dynamically, for simpler unit testing * Run benchmarks, to find the best performing implementations * Generate reports in TAP format, to integrate with other test harnesses * In-editor UI for convenient testing * Support for running in CI

# Rust Template for Godot This is a template project for using Rust in Godot, created based on the official [Godot-Rust](https://godot-rust.github.io/book/intro/hello-world.html) guide. It serves as a starting point for developers who want to integrate Rust into their Godot projects for better performance and type safety. ## Features - Template project to get started with Godot and Rust. - Configured to work with Godot Engine and the [Godot Rust bindings](https://github.com/godot-rust/gdext). - Provides a simple "Hello, World!" example to demonstrate how to integrate Rust code into Godot. - Setup is based on the [Hello World](https://godot-rust.github.io/book/intro/hello-world.html) tutorial from the official Godot-Rust book. ## Requirements - **Godot Engine** version 4.4 or later. - **Rust** installed. You can download it from the official website: https://www.rust-lang.org/ - **Cargo** – the Rust package manager, which is included when installing Rust. ## Installation 1. Clone this repository or download the ZIP. 2. Make sure you have Godot and Rust set up correctly. 3. Navigate to the `rust-template-godot` project folder and open the `rust-template` project with Godot. 4. Build the Rust code: - In the terminal, go to the project `rust` directory and run: ``` cargo build ``` 5. Run the project from Godot. ## Usage Once everything is set up, you can start adding your own Rust code into the project. The template includes a simple example that prints "Hello, World!" to the Godot console, and adds a `Player` class based on Sprite2D. This can be extended to your game logic. To modify the Rust code: 1. Open `src/lib.rs`. 2. Add your custom functionality or game logic written in Rust. 3. After making changes, rebuild your project using `cargo build` and test the integration in Godot. ### Visual Studio Code If you are working with VS Code, I recommend you to use the `rust-analyzer` extension and setting the `Check: Command` to `build`. This enables you library to be compiled each time you save your files, allowing for fast changes to be applied inside the Godot Editor without having to compile them in the terminal yourself each time. > This is only useful in Godot 4.2+ since it allows to import the changes without reloading the project. Since this template aims for 4.4+, this should not be a problem. Keep this in mind if you try a lesser version though. ## Project Structure - `rust`: The Rust directory for writing code. - `rust-template`: The Godot project directory, where scenes and assets are located. - `README.md`: This file. - `LICENSE` The MIT license ## Troubleshooting - If you encounter issues with Rust not building, ensure your environment is correctly configured by following the steps in the official [Godot-Rust Book](https://godot-rust.github.io/book/intro/hello-world.html). - For specific issues with the Godot-Rust bindings, refer to the official [GitHub repository](https://github.com/godot-rust/gdext) or consult the community forums. ## License This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details. The godot-rust Ferris icon was obtained from [their repository](https://github.com/godot-rust/assets) and its licence's details are explained [here](https://github.com/godot-rust/assets/blob/master/asset-licenses.md). ## Acknowledgments - [Godot Engine](https://godotengine.org/) - [Godot Rust](https://github.com/godot-rust/gdext) for their fantastic work on integrating Rust with Godot.

The LanguageProcessor class is a comprehensive solution for handling language-specific settings in the Godot Engine. It manages language selection and font variations for UI elements based on the current language setting. This class is especially useful for multilingual applications and games, providing easy integration and dynamic language switching capabilities. If you want to translate the whole Scene. Your nodes have to get the name like the key in the csv file. Label or Richtext Node: menu_start The script search for a key like the node name and translate it. ## Features - **Language Support**: Supports a variety of languages, including those with Latin, Greek, Cyrillic, East Asian (Chinese, Korean, Japanese), and other. - **Font Management**: Handles different font styles (regular, bold, italic/light) for each supported language. - **Automatic Language Detection**: Defaults to the system language or falls back to English if the system language is not supported. Version: 4.X Tested: 4.2

This is a demo showing how one can generate and play audio samples from GDScript. It plays a simple 440 Hz sine wave at 22050 Hz. How it works: It uses the `push_frame()` method on an AudioStreamGeneratorPlayback object, which is inside of an AudioStreamPlayer node, to generate audio frame-by-frame based on `pulse_hz`. Language: GDScript Renderer: Compatibility

Demonstrates how to override GUI colors and styleboxes at runtime. Language: GDScript Renderer: GLES 2

This is a demo showing text-to-speech support. How it works: It uses `tts_*()` methods of the DisplayServer singleton to enumerate voice information, send utterances to the OS TTS API, and receive callback signals. Language: GDScript Renderer: Compatibility

This demo project gives an example of how to use compute shaders in Godot. A compute shader is a piece of code that runs on the GPU and is written in GLSL (as opposed to the Godot shader language). A compute shader can be used to take advantage of the GPU's ability to perform massively parallel operations faster than a CPU. This demo can generate the heightmap of an island from a noise texture, both on the CPU and the GPU. You can try both options to compare the time it takes to generate the heightmap on the CPU and GPU respectively. For smaller noise textures, the CPU will often be faster, but the larger the gains are by using the GPU. On a PC with a NVIDIA GeForce RTX 3060 and 11th-generation Intel Core i7 processor, the compute shader was tested to be faster for textures 1024×1024 and larger. The dimensions of the image can be set on the exported "Dimensions" property on the main scene. By default, it's set to 2048, which creates a 2048×2048 heightmap. NOTE: The shader code has been structured to be followed step-by-step by the user, and may not necessarily represent best practices. The CPU code is also less optimized than it could be. This is to reflect the GPU code as much as possible. Besides the use of the GPU, no multithreading is used. Languages: GDScript, GLSL Renderer: Mobile

A plugin for creating accessible rich internet applications with godot.

A demo for my scrolling backgrounds tool.

Automatically formats and lints GDScript files on save using gdformat and gdlint.

A demo for my scrolling backgrounds tool.

Navigation mesh demo for 3D scenes, with a character able to pathfind around a complex 3D environment. The navigation path is drawn using a line. Code is provided for polyline following in 3D. Language: GDScript Renderer: GLES 3

music player with spectrum viewer, with this template you can implement it for your own projects characteristics: Spectrum viewer .mp3 file scanner

It's just fxxking same as Unity Coroutine.

An example showing how to take screenshots of the screen. Language: GDScript Renderer: GLES 2

This project demonstrates how to set up a project to handle screens of multiple resolutions and aspect ratios. This demo allows you to adjust the window's base resolution, stretch mode, stretch aspect, and scale factor (internally known as "stretch shrink"). This lets you see what happens when adjusting those properties. Make sure to resize the project window in any direction to see the difference with the various stretch mode and stretch aspect settings. The GUI can be made to fit the window or constrained to a specific aspect ratio from a list of common aspect ratios. On ultrawide aspect ratios, this can be used to prevent HUD elements from being too spread apart, which can harm the gameplay experience. For non-essential HUD elements, specific controls can be made to ignore this aspect ratio constraint when it makes sense (e.g. a list of players on the side of the screen). Additionally, a GUI margin setting is provided to better handle TVs with an overscan area to prevent GUI elements from being cut off. This can also improve the gameplay experience on large monitors by bringing HUD elements closer to the center of the screen. A DynamicFont is also used to ensure font rendering remains crisp at high resolutions, thanks to Godot's built-in support for font oversampling. In other words, the engine will automatically re-rasterize fonts at different resolutions than the base window size when the window is resized (or when the window scale factor is changed). Language: GDScript Renderer: GLES 2

Run away from Evil Godots forever. Full Godot C# project for procedural infinite terrain generation, with random items or obstacles spreading throughout the map, with physics enabled.

This lightweight GDExtension adds static functions for loading Ogg Vorbis files into an immediately usable AudioStreamOggVorbis at runtime, without requiring the files to be imported using Godot Editor first. You may load files by path, or directly from a PackedByteArray buffer in memory, which could for example be used with ZIPReader to play music out of a zip package. Binaries for Windows, Mac, and Linux are provided. Please see README.md for usage details.

Reverse any animation in your project (Creating a new reversed animation)

Due to various restrictive laws or sanctions, financial exchanges are not available in a free and equal way for everyone in the world. Still, cryptocurrencies do not have any geographical limitations, and they are not limited to anyone. App stores usually follow those rules and sanctions, and for that reason, some developers cannot sell their products. However, those app stores also deduct a significant percentage of the sales as commissions and taxes from the income of developers! However, making in-app purchases using cryptocurrencies is possible to prevent that. In fact, with this method, the need for banks and app stores is eliminated, and as a result, no one will be under legal restrictions or sanctions, and the entire income will directly go to the developers, and they will not need to pay fees and taxes. How the program works: The programmer puts the price of the program based on dollars in his program, and then the program shows the user the price of the program according to the price of the selected digital currency every time it is executed. It is possible to determine the price by using one of the cryptocurrency price announcement sites by raw source code. Then, the user must deposit the desired price in that cryptocurrency to the specified account address within the time limit. Each money deposit through cryptocurrencies has a payment ID(Transaction Hash ID); The user must provide that payment ID to the app to validate it; if it is validated, the purchase will be accepted. Various cryptocurrency transaction tracking sites can be used to confirm the payment. Cryptocurrencies are free for everyone to use them. Websites announcing the price of cryptocurrencies are also free for everyone to access. Websites tracking transactions are also accessible freely. As a result, programmers don't need middlemen paying them for these financial affairs and selling their products. There is no law or sanction against this method of earning money; only accessing the Internet is enough. For those cases where the price announcement site is down, a default price list has been placed on this GitHub site to be used. These default prices are in their folder (default prices) on this site. Key information is updated through a special file (key_data.txt) on this GitHub site so that possible problems can be solved quickly in the future and there is no need to produce a new program and download it by the customer.

Use D-Bus for IPC on Linux with Godot. This GDExtension adds simple nodes to use D-Bus. The DBusServerNode allows the definition of a DBusServer just through the property panel without having to write a single line of code. In your code you can then attach callbacks to the specified methods which will automatically be called if a client sends a message to the server. The DBusClientNode lets you specify one specific interface to interact with and make simple requests to. Both nodes abstract D-Bus specifiers away and let you just pass the basic Godot Variant Types. Open the demo for a full example.

This project showcases optional support for double-precision rendering and physics in action. When using a *single-precision* build, precision errors can be noticeable as soon as you're more than a few thousand units away from the world origin. When using a *double-precision* build, meshes will remain stable even when very far away from the world origin (billions of units away or more). See the Large world coordinates documentation for more information: https://docs.godotengine.org/en/latest/tutorials/physics/large_world_coordinates.html WARNING: Official Godot builds do *not* have double-precision support enabled for performance reasons. You need to compile a custom engine build to use double precision support. Languages: GDScript Renderer: Mobile

This is a demo showing how the audio output device can be changed from Godot. How it works: It uses the `set_device()` method in the AudioServer singleton to change the audio device. The list of devices is populated using `get_device_list()`. Language: GDScript Renderer: Compatibility