Plugins

This plugin imports *.blend files as native scenes. The *.blend file is exported as glTF 2.0 and then imported by Godot. The glTF file is cleaned afterwards.

Node Based Finite State Machine for Godot A plugin for easily creating a highly extensible Node Based Finite State Machine with Godot. Note: The plugin is still in alpha. Using it in commercial projects is not recommended. You can help by reporting any bugs to the Github repo.

Effortlessly manage multiple lobbies with one server in your Godot games. Features auto-replication, dynamic spawning, and easy C# & GDScript integration. Perfect for creating seamless multiplayer experiences.

An implementation of Charles "Chuck" Moore's Forth programming language as a virtual computer inside of Godot.

This plugin adds a new type of node that combines the features of the NinePatchRect, the Button, and the TextureButton, with the NinePatchRect being used as the base. We also added a customizable sound system, which allows you to assign sounds for some of its functions such as pressing it or hovering over it. If you have any feedback, be it a bug report, a suggestion, or a feature request, feel free to open an issue on GitHub. All we ask is that you try to label your issues suitably with the provided labels and that you try to prevent posting an issue about a topic that an issue already exists for. If an issue about a specific topic already exists, please do not create a new issue (although you may post a comment to an older issue about that topic if such an issue already exists). We will greatly appreciate any kind of constructive feedback you can give us. For more information on how to set up the plugin, what the NinePatchButton's many properties do, a changelog, why we made the plugin, and what our plans for the future of the plugin are, as well as download links for past and current (public) releases, feel free to check out the plugin's GitHub repository. Links: Talltale Studios GitHub page - https://github.com/Talltale-Studios

This scene transitioner implifies scene switching in your Godot project, adding polish and visual flair to your game's level changes.

DynamicDataTable is a GDScript plugin for Godot 4 that allows you to create and manage dynamic data tables easily and flexibly.

A Multiplayer Lobby

Yet another Tween for for Godot 3. - Easy as fluent syntax to use - No need adhoc logics - No need duration control - Kinematics based natural interpolation - Also has the same features as Tween [English] https://github.com/ydipeepo/godot-motion/blob/main/README.md [日本語] https://github.com/ydipeepo/godot-motion/blob/main/README_jp.md [简体中文] https://github.com/ydipeepo/godot-motion/blob/main/README_zh.md

This script provides a Dependency Injection (DI) system for the Godot Engine. It facilitates object creation, dependency management, and binding using various modes (singleton, instance, value, etc.). With this script, you can manage your dependencies more efficiently, especially for large-scale Godot projects. --- ## Features - **Dependency Injection**: Inject dependencies into nodes dynamically or throughout the scene tree. - **Binding System**: Bind classes, interfaces, variables, and scenes to be used as dependencies. - **Flexible Binding Modes**: - `INSTANCE`: Creates a new instance every time. - `SINGLETON`: A single shared instance for the class. - `SCENE_INSTANCE`: Creates an instance of a scene. - `SCENE_SINGLETON`: A single shared instance of a scene. - `VALUE`: Directly binds a value. - `ALL_MAPPED`: Retrieves all mapped dependencies for an interface. - **Scene Parent Management**: Automatically assigns default parent nodes for created scenes when no parent is specified. - **Recursive Tree Injection**: Injects dependencies recursively into the scene tree. - **Interface Mapping**: Supports mapping dependencies to enums for fine-grained control.

This console can be opened while the game is running. It lets you evaluate code and even choose which node from the scene tree should be "self" when you are running it.

Pulsating light shader for round objects. This shader is based on the dot product between the face normal and the camera view vector, so it works best on smooth round surfaces with many triangles, ideally spheres. The shader has the following parameters: Albedo: base object color. Albedo's alpha channel works, but avoid using it for transparency. It is implemented to support alhpa in textures. For global transparency, use the Opacity parameter instead. Albedo Texture: texture for albedo. Alpha channel works. Saturation: higher values increase the flat color area in the center, with fast alpha slope on edges. Lower values cause blurred, softer gradients in the edges. Pulse Rate: how many times the light pulses per second. Pulse Intensity: how big the light becomes during pulses, relative to original object size. Pulses are created by moving the vertices along the triangles' normals during rendering. If applied to collideable objects, the collision shapes are unnafected. Opacity: alpha. Use this in animations to make objects fade in or out. May work with GLES2 but not tested.

With this tool you can automatically setup the animations of spritesheets exported from Aseprite.

Lightweight key-value storage system for Godot, inspired by UserDefaults in Swift.

Makes easy to find and use icons from popular icon-fonts in your Godot project. What problems it solves: You only needs this addon - as you don't have: to go online find font then find icon check icon licence - and maybe you need to search for another finally download it Better alterative to Godot's build emojis as to use them you need to find unicode online they don't work on some platforms for example Web they are outdated

Clientside Predictor Character synchronization using clientside prediction for Godot 3D network games. This asset allows you to implement clientside prediction with just a few lines of code per entity. Do youn need an 3D artist or a gamedev? In that case, please send a mail to [email protected] ================================= Usage: -Replace the Script ServerScriptForConnectionHandlingEtc.gd with something that has to be called from your server, spawning the player avatars. playerId has to be the string representation of the unique network id. var target:Vector3=Vector3(100.0,0.0,100.0) var lockRotation:Vector3=Vector3(0.0,1.0,1.0) get_parent().find_node("DummySpawner",true,false).remote_spawn_dummy(0.4,str(playerId),Vector3(0,0,0),Quat(0.0,0.0,0.0,0.0),"","DummyCollection",lockRotation) get_parent().get_root().get_node("ClientsidePredictionSpawner").initBegin("Player","DummyCollection", 30.0,target,"Camera",5.0,false,false) get_parent().find_node("ClientsidePrediction",true,false).initBegin("Player","DummyCollection", 30.0,target,"Camera",5.0,false,false) Each entity (for example each player entity, each bullet entity etc - not their instances!) has to have its own ClientsidePrediction node (you will have to rename it in order to use more than one entity.) To modify the avatar the user sees, the corresponding node should be attached to the node called "Dummy" that has to be a unique subnode of the node "DummyCollection" ("DummyCollection" can be renamed, just don't forget to specify the correct name in the spawnig function), and that has got to have the script "ClientsidePredictionDummy" attached to it. (DummyCollection=>Dummy(ClientsidePredictionDummy.gd)=>Avatar The "Dummy" node should be positioned outside the walkable terrain, as it could cause unwanted collissions. -Replace the Player node in ExampleClient.tscn with a real first person player controller, which has been derived from KinematicBody =================================== Dummy states to implement into state machine: (!!! Untested !!! Please write GitHub issue in case of failure) These have to be called from the client. Only states of nodes with client's ID can be changed, and the states will be replicated over the network. var dummyNode:ClientsidePredictionDummy=get_tree().find_node("DummyCollection").get_node(nodeID) Play sound: dummyNode.play_sound("res://sound.ogg", nodeID, "DummyCollection", "<SoundNodeName>") Play animation: dummyNode.playAnimation(nodeID, "<AnimationPlayerName>","SomeCoolAnimation", animationNodeId,true): Set mesh: dummyNode.set_mesh(var "res://mesh",nodeID, "DummyCollection", "<MeshNodeName>"): Set speed_ dummyNode.set_speed(0.4, nodeID, "DummyCollection"): ================================= Node Structure: ===Client=== -root --"Player" (type: KinematicBody) - has to have the player controller script attached (name can be changed for more entities) --"ClientsidePrediction" (type: Spatial) ClientsidePrediction.gd (name can be changed for more entities) ----"DummyFunctions" (type: Spatial) (feature not yet implemented) ----""DummyCollection" (type: Spatial) ------"Dummy" (type: KinematicBody) ClientsidePredictionDummy.gd --------"MeshInstance" (type: MeshInstance) --------"CollissionShape" (type: CollissionShape) ===Server=== -root --"Player" (type: KinematicBody) (name can be changed for more entities) --"DummySpawner" (type: Spatial) DummySpawner.gd --"ClientsidePredictionSpawner" (Type: Spatial) ClientsidePredictionSpawner.gd --"ClientsidePrediction" (type: Spatial) ClientsidePrediction.gd (name can be changed for more entities) ----"DummyFunctions" (type: Spatial) (feature not yet implemented) ----"DummyCollection" (type: Spatial) (name can be changed for more entities) ------"Dummy" (type: KinematicBody) ClientsidePredictionDummy.gd --------"MeshInstance" (type: MeshInstance) --------"CollissionShape" (type: CollissionShape) ================================= Update: v0.2: -Seperated client scene from server scene. The server scene now has got to have a DummySpawner.gd node attached. -Added demo scenes. (You will have to add an own connection handling part, which calls the DummySpawner, though. The player controller for the "Player" node also has to be implemented, it is not included.) v0.2.1 -added some sanity checks v0.2.2 -parametrized ClientsidePrediction.tscn name in DummySpawner v0.3 -moved spawning of ClientsidePrediction.gd to server, making it being called by ClientsidePredictionSpawner v0.5 -addes states v0.5 -added more sanity checks v0.6 -added demo scenes v0.6.1 -removed buffer overflow in animations v0.6.2 -added missing player controller to demo scene v0.6.3 -repaired scenes v0.6.4 -repaired scenes even more ================================= #==== DummySpawner.gd==== # Note: This script should be attached to a seperate node on the server only. #----func remote_spawn_dummy(var idNode:String, var pos:Vector3, var rota:Quat,var _AnimationTreeName, var _collectionName):---- # idNode: Unique ID of the character instance per player # pos: Start position # rota: Start rotation # _AnimationTreeName: Name of the AnimationTree (can be "" when not using Animation Trees # _collectionName: Name of the node with the ClientsidePrediction.tscn #==== ClientsidePrediction.gd==== (Attached to the main node of the clientside prediction, most likely labled ClientsidePrediction) # Note: This script should be attached to the _collectionNode. # # The dummy node has got to have the script ClientsidePredictionDummy.gd attached, # and it has to be a child node of the _collectionNode. # To spawn an instance of a character, call the dummy node's spawn_dummy function from the server # The rotational node should be the node from which to get the rotation, for example the Camera node # #----func initBegin(var _speed:float, var _characterNode, var _collectionNode, var _tickrate, _targetPosition, var _rotator, var _clamping,_useKeyFrames,_useTarget): # _speed: speed of interpolation # _characterNode: node that should be interpolated # _collectionNode:node to that holds the character list # _tickrate: rate at that the position is being updated (milliseconds) # _target: target position when using direct position instead of character sync # _rotation: target rotation when using direct position instead of character sync # _clamping: distance from extrapolated position to current position at which to snap # _useKeyFrames: should root motion be applied when animating? # _useTarget: use fixed target instead of character synchronization

Godot Plugin to integrate Google Play Billing Library.

Godot 4 volumetric fog replaced Godot 3 depth fog. But depth fog feels more retro and is suitable for PSX / N64 style graphics. This impliments the camera setup required to create a Post Processing with depth-sampling fragment shader in Godot 4 ala this guide: https://docs.godotengine.org/en/4.0/tutorials/shaders/advanced_postprocessing.html It contains a scene with a 3D Camera Setup for with a Quad mesh stretched in front and uses a fragment shader to create a Distance/Depth based fog effect. The Fog also has a 2 color noise effect. The shader has input paramters to set the distance, colors and timescale of the noise. The second effect is a 2D Canvas shader that fades in from black, controlled by a script tweeen.