Makes your coding 1000000x more ridiculous with screenshake, visual effects, and explosions and now an XP bar that tracks your coding progress with fireworks.

Template with a main menu, options menus, pause menu, credits, scene loader, extra tools, and an example game scene. This is identical to the Game Template, except for the opening has the GWJ logo and a space for the theme + wildcards to go. Created in collaboration with members of the Godot Wild Jam community. For usage information, visit the following: https://github.com/Maaack/Godot-Game-Template/blob/main/README.md#usage

Godot Gameplay Systems (formerly godot gameplay attributes) is a set of nodes and resources which speed up development of your gameplay mechanisms. Currently it provides: - An Attributes base system (complete with buff/debuff) - An Ability base system - A camera shake node - A slide show node for your game intro - Equipment base system - Inventory base system - Interactions system (base) - Loot and drop system - Point and click nodes (both 2d and 3d) - Turn based nodes - User interface controls (radial menu container)

Implements lag compensation and more to build multiplayer online games easier. Features: * Synchronized time * State interpolation * Lag compensation with CSP Check out the other addons and see more at: https://github.com/foxssake/netfox ## Upgrading ### v1.8.0 * Check your `RollbackSynchronizer` nodes and set `enable_input_broadcast` to false as applicable. ### v1.1.1 * Remove `Interpolators` from the project autoloads, it's a static class now

High-level, game-specific extras for netfox Features: * Networked weapons * Rollback-aware base class for input Check out the other addons and see more at: https://github.com/foxssake/netfox ## Upgrading ### v1.8.0 * Check your `RollbackSynchronizer` nodes and set `enable_input_broadcast` to false as applicable. ### v1.1.1 * Remove `Interpolators` from the project autoloads, it's a static class now

Integrate noray into your multiplayer games to bullet-proof your connectivity Features: * Establish connectivity using NAT punchthrough * Uses noray for orchestration * Implements a full UDP handshake * Use noray as a relay * Useful in cases where NAT punchthrough fails * If you can see this repo, you probably can connect through noray Check out the other addons and see more at: https://github.com/foxssake/netfox ## Upgrading ### v1.8.0 * Check your `RollbackSynchronizer` nodes and set `enable_input_broadcast` to false as applicable. ### v1.1.1 * Remove `Interpolators` from the project autoloads, it's a static class now

Modular inventory system for godot 4 with nodes, compatible with multiplayer, separate logic from the UI, Using items as separate resources. Demos: https://godotengine.org/asset-library/asset/1895

WFC (Wave Function Collapse) and generic constraint satisfaction problem solver implementation for Godot 4. Features: - Backtracking support. This addon implements backtracking, so it's possible to generate maps that are guaranteed to have no broken cells. - Multithreading. Generation of a 2d map using WFC algorithm can be split into few tasks. Some of the tasks can be executed concurrently. The algorithm is able to detect most of cases when it's impossible to split the task and fallback to single-threaded generation in such cases. - Learning from example. 2d WFC generator infers rules from an example of a valid map. - Supports different node types - TileMapLayer (including maps with hexagonal tilesets and scene tiles), GridMap, legacy TileMap nodes are still supported as well. Can be extended to support more node types. - Contains a generic implementation of a constraint satisfaction problem solver on top of which a WFC algorithm is built. This generic solver implementation can be reused for tasks different from WFC.

Modular Character Controller for Godot 4. Includes FPS version with headbob and camera movement. (Walk, Crouch, Sprint, Swim and Fly Mode).

Steam Sockets Multiplayer Peer for Godot 4 via GDExtension - No dependency with lobbies - Use steam networking low level (Sockets) - No compatible with channels (Will be added in the future) - No compatible with mesh peers This code was built on top of small experiments by Zennyth [https://github.com/Zennyth] , greenfox1505 [https://github.com/greenfox1505] and MichaelMacha [https://github.com/MichaelMacha]

Neuro-sama Game SDK for Godot.

The uuid class is a GDScript 'static' class that provides a unique identifier generation for Godot Engine.

Discord Game RPC Plugin for GDScript in Godot 4.1 or newer. It has Linux, Windows and partialy MacOS support. The GDScript code patterns are much easier then in other addons Make a complete rich presence with timestamps images info, Invites and much more.

This addon adds an extended scroll container node with smooth scroll settings. How to use: Activate the addon in the project settings' addon tab, Click the "+" button to add a new node and select "SmoothScrollContainer" instead "ScrollContainer". To add smooth scrollling to existing ScrollContainers, rightclick the node and select change type. Then select "SmoothScrollContainer". For smoother scrolling: In your project settings set gui/common/snap_controls_to_pixels to false Mouse scroll icon by Greg Fiske from the Noun Project

Lightweight ecs framework written with gdscript. - Lightweight and high-performance. - One step serialization and deserialization the game world. - Independent event system. - Hot-swappable system design. - Data-driven and event-driven. - Easy to use.

G.U.I.D.E is an extension for the Godot Engine that allows you to easily use input from multiple sources, such as keyboard, mouse, gamepad and touch in a unified way. Gone are the days, where mouse input was handled differently from joysticks and touch was a totally different beast. No matter where the input comes from - your game code works the same way. - Unified input detection and handling from multiple sources (keyboard, mouse, gamepad, touch, etc.). All inputs are used in the same way in your game code. - Inputs can be modified before being fed into your game code (e.g. for joystick dead-zones, sensitivity, inversion, conversion to 2D/3D coordinates, etc.). - Inputs can be assigned to actions and these actions trigger on various conditions (e.g. tap, hold, press, release, combos etc.). - Multiple input contexts can be defined, which can be enabled/disabled at runtime. This allows you to easily switch between different input schemes (e.g. in-game, menu, driving, flying, walking, etc.). - Overlapping input is automatically prioritized, such that input like _LT+A_ will have precedence over just _A_. - Supports both event-based and polling-based input handling, like Godot's built-in input system. - Full support for input rebinding at runtime including collision handling. - Built-in support for displaying input prompts in your game. These prompts support complex input combinations (e.g. _LT+A_ or combos like _A > B > A > X > Y_). Prompts can be displayed both as text and as icons. Icons will automatically reflect the actual input device being used (e.g. XBox controller, Playstation controller, keyboard, joystick, etc.). - Works nicely alongside Godot's built-in input system, so you can use both in parallel if needed. Can also inject action events into Godot's input system.

Two feature packed nodes: - `RicherTextLabel`: Reduce effort needed to display state data and stylize it. - `RichTextAnimation`: For dialogue and cinematics, animates text in and out. Updated to 1.14. Too many features to list. Check the README.

A collection of control nodes usable in a variety of games and GUI applications. Containers: - Interpolated Box/Flow/Free: Containers that smoothly animate children when they enter or change order. Drag-and-drop reordering and drag-and-drop to move between containers in both variants. Vertical layout and compacting children to fit are features supported in the Box variant. - Radial Container: script-based "Pie menu", supports texturing, tweening, different item sizes (via size_flags_stretch_ratio), and multiple position-to-index functions. - ScaleContainer: When resized, scales children instead of resizing them. With the integer scale setting, can be used for pixel-perfect viewports. - Child Transform Container: transform a Control's children while preserving minimum size. - ScrollZoomView: node that can have one child and allows to scroll and zoom using the mouse. Allows smooth zoom. - MaxSizeContainer: Limits child size to a max size. - View Switcher: Keeps only one child, and optionally a background, visible. Utility: - Draggable: node that can be dragged and resized with the mouse pointer, with grid snapping, parent-clipping, and a visible resize margin. - MultiSelection: allows dragging a box-selection over children of any specified node. Can detect [CollisionObject2D] and [Control] nodes. Can move all selected [Draggable] and [InterpolatedContainer] nodes together. - Connection Line: connection arrow between two Control nodes, even across different parents. Can be dragged to be reconnected to another node with the same parent, with optional creation of waypoints to path through. - Container Quantity Keeper: Keeps count of duplicates added as a child to a node, and merges them into one node. Best with **Interpolated Box/Flow**. - Remote Transform Rect: transform a Control remotely similar to RemoteTransform2D/3D - Data Dropper: passes Godot's built-in drag-and-drop callbacks via signal - Flipped Split: SplitContainer anchored to the other side for when the parent is resized Input: - Theme Icon Button: I use it in my other plugins all the time! Grabs icon from theme by name. - Properties Box: Form to input values like you'd use the inspector. Strings, bools, numbers (sliders supported) and enums. Allows foldable groups. - Unfolded Option Button: list of options, pick one or use as bit flags

Moves the file dock to the bottom of the editor. Includes hotkey to show/hide. Edit Shortcut tres file to desired buttons, default is CTRL + Space.

Traits made easy in Godot 4 Version 2.0.1 is live ! Compatible with Godot 4.4. For older Godot versions, please use 0.x versions, downloadable on Github (https://github.com/Earewien/godot-traits/releases) Godot Traits is an addon designed to bring traits into GDScript. A trait embodies a collection of behaviors (variables, functions, signals, etc.) that can be utilized to extend the functionalities of a class. Given that Godot Engine lacks an official interface system, many developers resort to composition for combining various behaviors in a single class. However, implementing composition correctly can become complex and inconsistent. This addon's goal is to offer a streamlined and accessible approach for adding and removing behaviors from objects in Godot. This is achieved by defining trait classes and attaching them to objects, and using auto-generated utilities to use them. Features: - Trait declaration using annotation - Auto-generated trait helper class to manipulate traits - Scenes and nodes as traits, - Strongly-typed traits and autocompletion - Strong trait usage runtime checks - Dynamic addition and removal of traits - Automatic trait dependencies injection - Traits inheritance

Yet another inventory system, made primarily for Action RPGs. Now for Godot 4! Setup: - Drag stuff from addons/wyvernbox_prefabs into your scene. Should just work. - Enabling the plugin optional, but highly recommended. - If enabled, access the Documentation as you would in Godot - via the F1 key, then search. - Items are defined through ItemType resources. - For loot tables, make ItemInstantiators (each item, chance optional) and/or ItemGenerators (one from list, can be generated by script). For "or" logic or script-driven checks, make ItemPatterns. Supports: - 4 inventory types, including those for multi-slot items, equipment, and theoretically-infinite (or count-limited) currencies - all types are compatible with GUI containers - 2D and 3D ground items - gestures: quick-transfer (Shift-Click), gather/transfer all items of type (Double-Click), split one/half (Right-Click) - crafting with substitutes and random outcomes, merchants with randomized and limitable wares - localizable equipment affixes (for your Incredible Club of Casual Murder) - item search/filters, autosave - custom inspector tables to map items to values in YOUR classes (like in ShopManager, ItemGenerator, ItemPattern objects). Include an Item Browser popup to easily drag-drop item types, generators and patterns from the project. - hook up the GrabbedItemStack node's signals to a node to make input events do custom actions with grabbed items. Try the example: - Copy the example/ and addons/ folders into you project. DON'T unpack the entire repo zip, just these two. - Enabling the plugin optional, but highly recommended. - Launch test_2d.tscn

Advanced loader for text data files (JSON, CFG). It can load your files and perform a complex data validation. If you like keeping your data in text files, this will be useful as it ensures that your data is correct, i.e. without typos. Data collections in TextDatabase are arrays of dictionaries. You can e.g. store items, enemy data, or level metadata etc. in a JSON or CFG files, where each item/enemy/level/etc is a Dictionary with some properties. You can define fields for your data, which can be either mandatory, or just allowed, and the loader will ensure that your fields are correct. Example usage: var database = TextDatabase.new() database.add_mandatory_property("price") database.add_valid_property("attack") database.load_from_path("res://items.json) var data = database.get_array() Example valid file: [ { "name": "Sword", "price": 100, "attack": 5 } ] Example invalid file: [ { "name": "Shield", "defense": 1 } ] It's missing "price" and "defense" is not a defined property, so the file won't load. You can catch errors like this, so you can avoid unexpected behaviors due to data typos. btw, ConfigFiles (CFG) are much better than JSON. Here's the Sword example as CFG: [Sword] price = 100 attack = 5 You can store multiple items in one file and load multiple files into database. Just use load() multiple times on one database and then get_array() will return data from all files. Or you can use get_dictionary() instead and access the entries by name. Explaining all functionality would be very long, so just read the README, which you can find in the asset's repository (: You can also find an example project in there.

Note: To use this plugin, simply download it. You don't have to enable it in the plugins menu The aim of this project is to integrate Python scripting into the Godot Engine, allowing developers to write scripts in Python instead of, or alongside, GDScript. This plugin enables the selection of Python as the scripting language when creating new scripts within Godot, providing an alternative for developers who are more comfortable with Python. Platform Compatibility: Please note that this plugin is currently only compatible with Windows 64-bit, Linux 64-bit and MacOS ARM64 systems. Ensure that you are working on one of these platforms to take full advantage of the Python scripting capabilities. Similarity to GDScript: The Python API is designed to be similar to GDScript, making it easier for developers familiar with GDScript to transition to or integrate Python into their projects. Getting Started: To start using Python in Godot: Install the Plugin: Download the plugin and install it in the addons folder Create Python Scripts: When creating a new script, select Python as the language. Refer to the Documentation: Look at the Github page for a short example of the api

Extension for the Tween system. It adds: TweenNode - a Node wrapper for Tween. It allows for configuring the Tween from the inspector and provides a reusable Tween object. You can either use it with TweenAnimation or via code, by implementing the virtual initialize_animation(tween) method. If TweenAnimation is used, you need to set a root node, similar to AnimationPlayer root. TweenAnimation - a Resource that defines an animation for a Tween. You can use it with a regular Tween by calling apply_to_tween(tween, root) or by assigning it to TweenNode. The root is the base Node for animation paths. TweenAnimation editor - a complete editor for creating TweenAnimation resources. You can add animation steps and add Tweeners to steps to create animation. The editor supports simple animation playback to preview what you are editing. TweenNode and TweenAnimation come with a documentation. For more information and images see the GitHub repo.