This is a water shader with optional chromatic aberration, it has some options to tweak like tilling (To adjust waves scale), Murky ramp (To make it more or less "cloudy"), water tint colors (To make muddy water o caribean like), etc. It problably needs some optimization or has some bugs (since is one of my first incursions in shader coding) so please you are welcome to post issues or improvements. Only works on Godot 3.x, with GLES 3 backend for now.
This is a basic editor plugin for the Godot engine to simplify uploading projects to Itch using Butler
Kenney's UI audio pack, pre-packaged for use in Godot. 50 user interface sound effects including buttons, switches and generic clicks. Sounds were converted from Ogg Vorbis to WAV for lower CPU usage and better compatibility with Godot, at the cost of slightly larger file size. This is a lossless conversion which keeps the original sound quality. Support the original artist to create more free game assets: http://donate.kenney.nl/ 4.0 version of this asset: https://godotengine.org/asset-library/asset/796
A Counter Strike style customizable crosshair. Features: - Thickness - Size (length of the lines) - Gap (distance between the middle of the screen and the starts of the lines) - Color - Dot in the middle of the screen - Dynamic crosshair movement based on customizable inputs - Crosshair outline with thickness adjustment - T-style configuration (removes the top line) - Extra horizontal lines - Different crosshair line styles - Ability to convert crosshair configs into a string and vice versa Further instructions can be found on the Github repository.
Directly browse Poly Haven inside Godot editor and import assets as native Godot resources.
Godot Logging Util is a GDScript file that provides simple logging functionality. Features include: - Print detailed logs - Write to log files - Supports use of multiple log files
Kenney's UI audio pack, pre-packaged for use in Godot. 50 user interface sound effects including buttons, switches and generic clicks. Sounds were converted from Ogg Vorbis to WAV for lower CPU usage and better compatibility with Godot, at the cost of slightly larger file size. This is a lossless conversion which keeps the original sound quality. Support the original artist to create more free game assets: http://donate.kenney.nl/ 3.2 version of this asset: https://godotengine.org/asset-library/asset/795
A component-based architecture for Godot. Allows to extend the functionality of a node. Compatible with Godot 4.1 - 4.4+ Features - Create components that extend the functionality of a node. - Easy creation and management of components from the editor. - Work with components as with regular nodes. - Components can be created as scenes or scripts. - Supported nested scenes - Fully documented. Composition is a different approach to inheritance. It allows to extend the functionality of a node without modifying the node's code. Inheritance is a way to extend the functionality of a node by modifying the node's code. It is useful when you want to add new functionality to an existing node. Composition is a way to extend the functionality of a node by adding new nodes as children of the node. It is useful when you want to add new functionality to an existing node without modifying the node's code.
A simple virtual joystick for touchscreens with usefull options.
Go Godot simplifies common operations in Godot. It's like a swiss army knife of making Godot more intuitive! Here's the README for this asset package: A Godot add-on library to simplify common operations. Install instructions Within the project, open the setup.tscn file. This should load the library into the project settings. Reference function spawn_instance To spawn an instance of a scene at set location, type go.spawn_instance(, optional:, optional:, optional:) Examples: #spawn enemy at position 0, 0 as a child of the main scene root node go.spawn_instance("EnemyScene") #spawn enemy at position 200, 300 as a child of the main scene root node go.spawn_instance("EnemyScene", 200, 300) #spawn enemy at position 200, 300 as a child of the object calling the function go.spawn_instance("EnemyScene", 200, 300, self) function spawn_instance_grid Spawns a rectangular grid of instances of a provided scene. This is good for creating formations of enemies, or arcade puzzle elements. go.spawn_instance_grid(sceneName, numberOfColumns, numberOfRows, columnSpacing, rowSpacing, xPosition, yPosition, whereToAddChildren) Examples: #spawn a 4 by 5 grid of cards that are spread out with 100 pixels of space between them horizontally and vertically. go.spawn_instance_grid("CardScene", 4, 5, 100, 100) #the same as the above example, but the grid is placed at a position of 250, 150 from the root node. go.spawn_instance_grid("CardScene", 4, 5, 100, 100, 250, 150) #the same as the above example, but the grid is put as a child of the caller, rather than the scene's root node. go.spawn_instance_grid("CardScene", 4, 5, 100, 100, 250, 150, self) get the main scene root node #the following code gets a reference to the main scene root node: go.Main callback functions automatically connected to built-in signals NOTE: This is a breaking change. This replaces go_collision and go_body_collision Each node's built-in signals will automatically connect to a callback function whose name matches the signal name, within a script that is either on the node or its nearest ancestor node. To activate, just write a function definition whose name is the desired signal's name inside the node's script, or its parent (or grandparent, etc.). Examples: Extends Area2D #area_entered called when area overlaps another area func area_entered(otherArea): #do collision related things Note: normally, you would have to turn on contact monitor on the RigidBody2D and increase the number of contacts reporting from the default 0 value. Fortunately, if an ancestor node is found with the body_entered function, then GoGodot will automatically turn on contact monitor and increase contacts reporting so that it just works (without having to manually tweak those settings). function restart_game Example: #The following code reloads the current main scene go.restart_game() function get_all_nodes_by_class This function returns an array of all the nodes in the SceneTree that match a given class name. Example: var allLabels = go.get_all_nodes_by_class("Label") for label in allLabels: label.text = "all labels now show this text!" function destroy Example: #remove myObj go.remove(myObj) Destroy is simply an alias for queue_free(), but ensures that the object trying to be removed can actually queue_free. function random_integer Gets a random integer in range. Example: go.random_integer(2, 12) #get random integer, minimum of 2 and maximum of 12 If no arguments provided, then assume die roll 1 to 6. If only one argument provided, assume range of 1 to maximum of that argument provided. function array_shuffle Supply an array to shuffle, and the shuffled array is returned. Example: var shuffledFruitArray = go.array_shuffle(["apple", "banana", "orange"]) Go Modules Go Modules are nodes that can be found in the go_modules folder which give special powers to whatever node they are attached to. For example, adding the Platformer node to a Node2D will make that node behave like a platformer (moving and jumping, etc.). Platformer Adding the Platformer node to any Node that has a transform (e.g. Node2D, Sprite, etc.) will make that Node automatically possess typical Platformer behavior. Settings for the Platformer node can be tweaked in the Inspector with the following properties: Gravity - the strength of gravity Speed - the speed of the Platformer node Jump Strength - how "high" the Platformer node can "jump" Collision Bounds - the pixel dimensions of the collision area of the Platformer node. (Note: you may add your own custom collision shape if you like, but the Rectangle is the default option) Set Bounds To Sibling Sprite - when this is clicked, the first Sprite node that is a sibling to the Platformer node will be used to auto measure and determine the size of the collision area of the Platformer node. WASD - check this property to enable default WASD key controls. Arrow Keys - check this property to enable default arrow key controls. Spritesheet This node expands the typical Sprite node to make spritesheet animations easier to set up. The following properties of the Spritesheet node can be configured in the editor: Spritesheet - this is the Texture of the spritesheet, i.e., the spritesheet graphic itself. Note that the spritesheet's frames need to be evenly divided in a grid. Current Frame - this is the same as the Frame property, which states which frame of the animation is current. Framerate - set this to change how fast the animation plays in frames per second. Horz Frames - the same as HFrames, this tells Godot how many frames there are in each column. Vert Frames - the same as VFrames, this tells Godot how many frames there are in each row. First frame - if the desired animation does not begin on frame 0, you may choose which frame the animation starts on. Final frame - sometimes the grid ends before the final column, so this allows you to choose what the final frame actually is of the animation. Default assumes the final frame is the last frame in the grid calculated by the Horz Frames and Vert Frames. Loop - choose whether or not the animations should loop. Reverse - specify if the animation should be playing backwards. Note: this will play from the Final Frame to the First Frame. Is Playing - this allows you to preview the animation in the editor. Autostart - specify whether or not the spritesheet should start playing when it enters the scene at runtime. The following are functions that belong to the Spritesheet node that you can run on the Spritesheet object in the code: play() - starts the animation stop() - stops the animation and returns to the First Frame pause() - stops the animation, but stays on the Current Frame The following are callback functions that can be added to the nearest ancestor to the Spritesheet node that will automatically run under its respective conditions: func go_animation_end() - the nearest ancestor node to Spritesheet will run this function when the Spritesheet animation ends or loops. Linear Motion Adding this node to any node with a transform (e.g. Node2D, Sprite, etc.) will enable you to easily make the node "go" at a fixed speed. Unlike the linear_velocity property found on some nodes, the speed is controlled with an angle and speed rather than x and y velocity. The following properties can be modified in the editor in order to tweak the behavior of the Linear Motion module: Enabled - check this to enable the module to work. If it is unchecked (whether in the editor or in the code), the parent node will stop moving as a result of the Linear Motion node. Match Angle - check this to have the parent node move in the direction of its angle. Whatever angle the parent of Linear Motion is set to is the direction it will go. Otherwise, the node will go the direction of the Angle Of Motion property. Angle of Motion - if the Match Angle property is unchecked, the parent node will go the direction provided by the Angle of Motion property. This is good for when you don't want to rotate the parent node to have Linear Motion work. Speed - the speed of the Linear Motion in pixels per second. TopDownMovement Adding this node to any node with a transform (e.g. Node2D, Sprite, etc.) gives that node traditional top-down movement mechanics, as in classic top-down games, such as _The Legend of Zelda_ and _Metal Gear_. The following properties can be configured in the editor to customize how the top-down motion works. * Speed - pixels per second the node moves in the respective directions. Note that moving diagonally will move the given pixels per second _diagonally_, taking into account the correct vector magnitude. * CollisionBounds - set the size of the default rectangular collision boundaries of the character. * Set_Bounds_To_Sibling_Sprite - clicking this checkbox will have the module find the first Sprite sibling of the TopDownMovement node, and use its dimensions to automatically figure out the size of the rectangular collision shape. * LimitFourDirections - with this selected, the TopDownMotion can only go one direction at a time, instead of diagonally. * WASD - with this checked, the w, a, s, and d keys control the TopDownMotion in game. * ArrowKeys - with this checked, the arrow keys control the TopDownMotion in game. Note that WASD and ArrowKeys can both be checked, allowing either set of keys to work for the TopDownMotion.
A multidirectional, configurable and flexible joystick that allows you to adapt it to different games depending on the mechanics. Pides adjusts them to games of 2, 4, 8 and many more directions. supports n-upper directions. It is configurable and allows you to define a series of options, in addition to including a series of available textures; It is ideal for mobile games supports multiple taps in mobile games
The Dungeon Remastered Pack is a bundle of game assets that contains over 200 stylised 3D Dungeon assets and props! Features: - Walls, floors, stairs, doors, everything you can think of to make your ideal dungeon layout. - Props like chests, barrels, chairs, tables, crates, traps, banners, and more to satisfy your inner interior dungeon-decorator. - Textured using a single gradient atlas texture (1024x1024) that can be downsampled to 128x128 for further optimization - Free for personal and commercial use, no attribution required. (CC0 Licensed)
SuperSprite2D is a superset of animated sprite2d allowing you to call functions in animated sprite2d!
SEAL, or SEttings Abstraction Layer, is a versatile Godot plugin designed to simplify the management of user settings within applications. It supports a wide range of settings, from global performance parameters to cloud-based configurations and settings tailored for individual DLCs or game worlds. SEAL aims to streamline the process of adding, removing, and manipulating settings, ensuring that these operations can be performed with minimal code. # Key Features: - Supports all Godot 4.x versions - Ease of Use: SEAL allows developers to handle settings with just one line of code for adding, getting, or setting values. - Minimal Boilerplate: Saving, loading, and displaying settings require only a few lines of code, reducing overhead. - Extensible: The plugin is designed to be easily extendable, enabling the addition of new setting types and customization of storage methods. - Documentation and Examples: SEAL comes with comprehensive documentation and example code to help developers get started quickly. - Internationalization Support: It fully supports internationalization, making it adaptable for applications in different languages. # Installation SEAL requires the Log plugin, which is included with SEAL, ensuring seamless data printing to the console. Installation can be done through the asset store or by downloading from GitHub and copying the necessary folders into your project. Once installed, the plugins are enabled in the Project Settings, ensuring Log.gd is loaded before SEAL.gd. # Example Code SEAL includes a demo project to illustrate its capabilities, featuring a GlobalSettings class that can be easily integrated and modified. This demo demonstrates how to create, manage, and visualize settings, providing a practical foundation for developers to build upon. # License SEAL is released under the MIT license, promoting open-source usage and modification. This plugin aims to provide a robust and flexible solution for managing settings in Godot applications, enhancing both development efficiency and user experience.
A Scene Manager with easy to add and customize transition animations that allows for changing any scene in any place Features: * Background loading for the scene you want to change. * Easy tracking of the currently loading resource. * Easy to customize and add animations for transitioning in and out of the scenes. * Adding a scene nested inside a tree? Want to keep your hud in place? I got you covered with swap_scenes.
Adds a new animated grid container control node type that allow you to have a lot of control on it's children and their sorting over time in a grid like layout.
A UI control that can efficiently display a large amount of data in a scrollable table. It only loads data it shows, so it's useful for showing data from a database. It was originally made to show a SQLite table. Gif demos available on the github: https://github.com/karlak/godot-dataview
Switch to the previously active tab (last tab) by pressing Ctrl+Tab (macos: Option+Tab), including last doc, script and scene tabs.