GodotBuddy is an advanced plugin for the Godot 4 Engine designed to assist you in coding and game design. It leverages AI to provide intelligent code suggestions, documentation, and more, all within the Godot Editor. ## Features - **AI-Powered Code Assistance**: Get real-time code suggestions and improvements. - **File Content Replacement**: Automatically replace file references with their contents. - **Chat History**: Maintain a history of your interactions with the AI. - **API Key Management**: Securely store and manage your API key. ## Usage 1. **Open the GodotBuddy Dock**: Once enabled, you will see the GodotBuddy dock on the right side of the editor. 2. **Enter Your API Key**: Input your API key in the provided field. The key will be saved. a. Acquire free or paid keys from [Groq.com Keys Dashboard](https://console.groq.com/keys) 3. **Interact with the AI**: Type your queries or code in the text editor and press the submit button. The AI will respond with suggestions or code snippets. You can use `@filename.gd` to reference a file in the editor, regardless of subdirectory. (finds first match, use a full path if you have multiple files with the same name)

Gdods is a small GDScript for reading ODS files: the OpenDocument format for spreadsheets used in for example LibreOffice, and OpenOffice. You can use this script to add support for ODS files to the game you're building in the Godot game engine. It does not support all features that ODS files have, but sticks mainly to reading text and images from columns, and providing you with some functions to iterate over spreadsheets. Gdods uses gdunzip( https://github.com/jellehermsen/gdunzip ) under the hood, for extracting the contents of the ODS file (since ODS files are actualy a bunch of xml's and other assets wrapped in a zip). Example code ---------------------- # Create a gdods instance var gdods = load('res://addons/gdods/gdods.gd').new() # Load an ODS file var loaded = gdods.load('res://test/test.ods') if !loaded: print('Could not load ODS file :-(') else: # Get cell in sheet 0, row 2, column 1 # NB: numbering starts from 0 var cell = gdods.get_cell(0, 2, 1) # Verify that the cell is a TextCell if cell.type == gdods.TEXT_CELL: print('We have a text cell with this value: ' + cell.value) # Get another cell by using the named position var cell2 = gdods.get_cell_by_name('A42') # Verify that this cell is an ImageCell if cell2.type == gdods.IMAGE_CELL: print('We have got us an image cell') # Grab the actual image from the ODS file var image = cell2.load_image() if !image: print('Failed loading the image from the image cell') else: print('Image width is: ' + str(image.get_width()) # Turn the second sheet with a header row into a array of dicts var dictarray = gdods.to_dictarray(1, 0) # Print the first row's value for the 'my_beautiful_key' column print(dictarray[0]['my_beautiful_key']) Class documentation --------------------------------- The gdods class inherits "reference", and upon initialization it loads gdunzip.gd from the same directory gdods.gd resides. CONSTANTS: - EMPTY_CELL = 0 - TEXT_CELL = 1 - IMAGE_CELL = 2 FUNCTIONS: - bool load(String path) Tries to load an ODS file with a given path. Returns false if it failed loading the ods, or true if it was successfull. - "Cell" get_cell(int sheet_nr, int row_nr, int column_nr) Given a sheet number, row number and column number this method will return this cell's value, this can either be a EmptyCell, TextCell or ImageCell instance. If the cell can't be found it will return an EmptyCell NB: numbering starts at 0 - "Cell" get_cell_by_name(int sheet_nr, int pos) Return a cell by giving its name (i.e A1, D100). Returns an empty cell if the cell can't be found, or if the input is incorrect. - Array to_dictarray(int sheet_nr, int header_row) If your sheet has a header row, you can use this function to transform all the rows beneath the header row into a array of dicts. The header row will be used as dictionary keys. This function returns false if the sheet denoted by sheet_nr or the header_row can't be found. INNER CLASSES Gdods has 3 inner classes that are used for cell types: TextCell, ImageCell, EmptyCell. Each of those has a to_string() function, and you can check the type of the class by comparing the "type" attribute to one of the gdods' constants (EMPTY_CELL / TEXT_CELL / IMAGE_CELL). You can get the image path from ImageCell by using the image_path attribute, and you can load the image by calling the "load_image" function with no arguments. This will return either false or an Image instance.

The Composite Reverter is a memento-based undo/redo utility. A unique feature is its support of composition, allowing subsystems to handle their own saving and loading independently of each other while still operating in unison. This enhances decoupling and encapsulation in your code. Features: * Clean interface that runs like git with only basic functionality. * Easy to get up and running using plain dictionaries for mementos. * Extensible to optimize time and memory efficiency. * Equality can be defined between mementos to ignore insignificant changes. * Tags allow jumping through history like loading save-states. * Undo, redo, and revert methods. * Thoroughly documented. * Example included.

A simple implementation of a variation on a finite state machine that uses a 'pushdown' stack arrangement to handle states. Attach an instance of the finite_stack_machine.gd class to any entity in your Godot scene. Push new states to the top or bottom of your 'state stack' to control the flow of behavior. The demo shows of some of the features. I've only done limited testing on the on_start and on_end transitions of states, but so far everything seems to be working. Please make an issue if something isn't working! Still in an early version with some planned features missing: better input event handling, perhaps hierarchical states, etc.

Plugin for the godot engine, contains some easy to use widgets.

Godot-Stuff ECS 3.2 This is a Framework for adding a simple Entity Component System using Godot. The Framework puts less emphasis on performance, and instead tries to focus on improving Workflow and Code Reuse. Features * simple design * flexible * create using scene structure or code This version supports the Godot 3.2 releases. Read the documentation here: https://gs-ecs-docs.readthedocs.io/en/latest/index.html Get started with a very simple example here: https://gs-ecs-docs.readthedocs.io/en/latest/simple.html

There are two singletons, add them in Project > Project Settings... and in the AutoLoad tab. Pause: it captures the mouse at the start. It pauses the game when pressing escape and releases the mouse, you can use it to display a menu. Pressing escape a second time will quit the game and save the game (you can remove this feature), pressing left-click with resume it and capture the mouse. Save: it has a function to save the game and load it. By default there is a shortcut for a quick save by pressing F5 and quick load by pressing F6. You can use them while the game is paused. The game will display a message in the top left when the game is loaded or saved. You can call the save function from an Area node to make a checkpoint.

See README.MD in repo (click Show Files button) It doesn't need Discord SDK or anything like that to work. It requires just python 3.x and a bit of time to modify one file for Your needs Plugin made by: New Dev

Composable rig camera

Customizable script that unifies all 2D draw methods in one place, both for debugging and in game purposes. Contains functions that will draw circle outlines, lines, text and trajectories for rigid bodies depending on the force. NOTE: add Draftsman to auto loaded scripts. Go to: Project / Project settings / AutoLoad

Godot's High-level Multiplayer API can operate over WebRTC, however, it requires a signaling server to establish the WebRTC connections between all peers. Nakama is an Open Source, scalable game server that provides many features, including user accounts, authentication, matchmaking, chat, and much more. This Godot add-on provides some utility code to allow easily setting up those WebRTC connections using Nakama as the signaling server.

A simple node base finite state machine inspired by ShaggyDev's state machine.

C# conversion of original Hexgrid asset (https://godotengine.org/asset-library/asset/1032) 3 Classes that brings hex detection, 3D LOS, distance, influence, shortest path ... all you need to build a classical boardgame based on a single image hex map. A demo in the source tree.

This plugin deletes the contents of the project data folder with the click of a single button but does not delete the folder itself.

Allows you to programmatically tween an objects: float variables, vectors and colours. The gdTweener node uses flux-like syntax. https://github.com/rxi/flux

Google Maps plugin for Godot 4.x using Maps URLs

A simple logger that emits BBCode-formatted log entry signals.

Godot-Stuff Logger 3.5 A GDScript based logging utility, it provides a very low level way to debug your Games. There are different Appenders and Layouts available that let you control how the logger output is delivered. This latest release is now installed like a proper plugin. Activate the Logger by going into your Project settings and activating it. Note: Cyclical errors have been correct and a restart of Godot should no longer be required when adding this asset. Features * low overhead * simple to include in your projects * eight different logging levels * output to console or filesystem * html output available (experimental) This version supports the Godot Version 3.5 releases. For more information follow this link https://gitlab.com/godot-stuff/gs-logger/-/blob/3.5/README.md

Simple custom resource that allows you to modify the exported variables of a packed scene without modifying the referenced scene.

This plugin runs `gdformat` on save to automatically format your GD script as you code. NOTE: This plugin only runs if "gdformat" is installed. Instructions available at https://github.com/Scony/godot-gdscript-toolkit

Is a versatile and customizable module designed to streamline 2D Nodes movement in Godot Engine now in C#. Whether top-down, platformer or grid-based, this component offers the functionality you need without having to rewrite it yourself for each project. The movement can be made flexible with the exposed parameters and contains an internal API that facilitates the most common actions that can occur in a 2D game.

A GDScript implementation of the finite state machine pattern. Adds node types for finite state machines and states.

Imagine placing this component in any scene representing a projectile in your video game, and it is ready for action. It provides common functionalities for standard projectiles now in C#.

Gdunzip is a zip file browser/decompressor written entirely in a single GDScript file. You can use this in games you're building with the Godot game engine. This script is meant for modest zip decompressing purposes, since the inflate algorithm it contains isn't super fast and gdunzip doesn't do CRC checks of the uncompressed files. However, gdunzip works fine if you only need to decompress small files, or when your zip files contain precompressed files like png's. In order to create gdunzip, I have made a GDScript port of Jørgen Ibsen's excellent tiny inflate library: tinf (https://bitbucket.org/jibsen/tinf) for decompressing the deflate streams. Since the original was written in C and used some nifty pointer arithmetic, I had to make some minor changes here and there to be able to translate it. However, I tried to stay as close to the original code as possible. The zip file format parsing is all written from scratch and performs pretty well. Using gdunzip ---------------------- # Instance the gdunzip script var gdunzip = load('res://addons/gdunzip/gdunzip.gd').new() # Load a zip file var loaded = gdunzip.load('res://test.zip') # Uncompress a file, getting a PoolByteArray in return # (or false if it failed uncompressing) if loaded: var uncompressed = gdunzip.uncompress('lorem.txt') if !uncompressed: print('Failed uncompressing lorem.txt') else: print(uncompressed.get_string_from_utf8()) else: print('Failed loading zip file') - When gdunzip has loaded a zip file, you can iterate over all the files inside, by looping through the "files" attribute: for f in gdunzip.files: print('File name: ' + f['file_name']) # "compression_method" will be either -1 for uncompressed data, or # File.COMPRESSION_DEFLATE for deflate streams print('Compression method: ' + str(f['compression_method'])) print('Compressed size: ' + str(f['compressed_size'])) print('Uncompressed size: ' + str(f['uncompressed_size'])) Class documentation --------------------------------- MEMBER FUNCTIONS: - bool load(String path) Tries to load a zip file with a given path. Returns false if it failed loading the zip, or true if it was successfull. - PoolByteArray uncompress(String file_name) Try to uncompress the given file in the loaded zip. The file_name can include directories. This function returns *false* if the file can't be found, or if there's an error during uncompression. - PoolByteArray get_compressed(String file_name) Returns the compressed data for a given file name (or false if the file can't be found). Depending on the file compression it can be either uncompressed or a raw deflate stream. This function returns *false* if the file can't be found. FILES ATTRIBUTE: After you have loaded a file, the gdunzip instance will have a pre-filled "files" attribute. This is simply an dictionary containing the meta data for the files that reside in the zip. The dictionary is a mapping from file name (including directory) to another dictionary with the following keys: - file_name: the file name - compression_method: -1 if uncompressed or File.COMPRESSION_DEFLATE - file_header_offset: the exact byte location of this file's compressed data inside the zip file - compressed_size: the compressed file size in bytes - uncompressed_size: the uncompressed file size in bytes