If you're developing a bullet-hell shooter or any game that involves a high number of 2D bullets, BlastBullets2D provides a powerful and easy-to-use solution that delivers outstanding performance inside Godot Engine.

The main advantages to using this custom built plugin:

• Production Ready, Free, Open Source And Yours Forever Without Any Hidden Fees Or Weird Licenses - If you like what I do and you find the plugin useful consider supporting further development of such tools on KoFi and Patreon. Expect tutorials on My Youtube Channel.
• Superior Performance And Simple To Use API That Does NOT Require Any Math Knowledge.
• Homing Bullets - Targets Node2D enemies, GlobalPositions and even the Mouse. You have support for shared homing targets and per-bullet homing targets with a double ended queue implementation. You can control the smoothness of the rotation, the update time interval for tracking the targets, register a callback function when the required distance away from the target has been reached and much much more!
• Orbiting Bullets - Each bullet can begin orbiting a homing target at a custom radius while also moving in a circle around it. Imagine a swarm of bullets orbiting your mouse as you move it, while the radius increases or decreases then some of them go and orbit another target, this is the type of behavior you can implement on the go.
• Path2D Movement Patterns - Draw a Path2D in your scene and suddenly the bullets possess that movement behavior relative to their direction (allows zig zag patterns and any other creative pattern you can think about). Example: A bullet gets spawned with a zig zag pattern (that might or might not repeat), then you can swap it with another pattern during runtime or even have homing bullets with custom movement patterns - very powerful.
• BulletCurvesData2D - You can use curves inside the Inspector to control the speed, rotation and direction. Choose between using unit curves (normalized time) or absolute values (at exactly X time have Y speed) - super easy and creative way of having bulllets that speed up/slow down at specific times without the need of writing any extra code.
• Control Speed And Rotation The Normal Way - If bullet curves are not needed, you can still use normal speed and speed acceleration values for both movement and rotation using BulletSpeedData2D and BulletRotationData2D.
• Animated Textures - Support for animation that switches between an array of textures and texture times (how long the texture should be on screen before moving to the next). Set a default texture or have full blown animated bullets, no problem!
• Custom Collision Shape Sizes - Support for rectangle collision shapes with a custom Vector2 size.
• Support For Custom Bullet Max Collisions Amount - A bullet can collide multiple times before being disabled. Very useful for Bullet Hell games.
• Custom Bullets Debugger - Debug collision shapes easily to see what is going on in your game and find problems.
• Attach Timer Logic - The ability to attach function callbacks that execute at a particular time on the entire multimesh with the option to be repeated over and over (safely executes code during runtime while preventing crashes that might occur with the normal timers if you don't use call_deferred()). This is the preferred way of manipulating bullet related data, don't use the normal Godot timers!
• Edit Properties And Call Methods During Runtime - Every single feature has helper methods that you can use during runtime to adjust the behavior of the bullets (change homing targets, orbiting radius, switch movement pattern, disable a bulllet and so on..). Combine this with the attach timer logic and you have the most flexible bullet system ever created. If you are not using the attach timer logic, make sure to use call_deferred() to avoid issues like game crashes or inconsistent behavior.
• Teleport And Offset Support - Instantly shift bullets with a Vector2 offset value or teleport them in global space to a new position.
• Set Inherited Velocity Offset - This is the velocity that gets added to the bullets when they are spawned. Useful for creating effects like a machine gun that inherits the velocity of the player character, so that the bullets shoot out with more speed if the player is moving forward, and with less speed if the player is moving backward or standing still.
• Instance Shader Parameters - Support for shaders with instance uniform variables.
• Custom Physics Interpolation logic - Bullets will always look smooth no matter the refresh rate of the monitor/device that you are targeting. No more weird jitter and buggy choppy feel on screens above 60Hz.
• Bullet Attachments - Seamlessly attach GPUParticles2D, CPUParticles2D or custom sprites that follow the bullet's transform with optional offsets. The use of modern GDExtension features like virtual methods allow you to override what happens when attachments are spawned/disabled/pooled. These custom methods get called inside C++ to set up your bullet attachment as necessary. Example - Spawn attachments with visible particles but when they collide you have to disable the emitting and even disable visibility of extra nodes you might've attached. Super flexible and easy to use.
• Automatic Object Pooling - MultiMesh instances and attachments are automatically pooled and reused. You can manually populate or free pools, or disable the system to use your own custom logic. You can choose the easy way of using the plugin without any care (because performance is handled for you already) OR you can delve deeper. Example: disable auto pooling, which will allow you to save your bullet instances into an array of multimeshes without fear of problems. Reuse them whenever you want with runtime functions such as enable_bullet()/disable_bullet().
• Dynamic Sparse Set - The plugin uses custom made data structure that is used internally for precise tracking and looping over ONLY ACTIVE MultiMeshInstances and ONLY THE ACTIVE bullets inside them. This reduces branching and improves performance (a pattern used in ECS engines that could be further improved in future versions of BlastBullets2D).
• Bullets Custom Data - Attach a custom resource that the multimesh of bullets carries - used for storing damage, armor damage or anything else custom that should be available during collision.
• Familiar Signals - Collisions are tracked with area_entered and body_entered signals inside the BulletFactory2D node. Combine this with the bullet custom data and you can easily differentiate between types of bullets. You can even detach/attach new bullet attachments or make explosion effects while editing runtime properties inside the function callbacks.
• Extensive Documentation - Full in-editor documentation for every function and property, accessible directly within the Godot Inspector and Script Editor.
• Even Faster Release Builds - Compiled with Link Time Optimization (LTO) for maximum runtime performance in your exported projects. Debug builds contain the in-engine docs, while release builds are automatically detected and used by Godot for the final release of your game.
• ....AND SO MUCH MORE - Download the plugin and experiment with it right away! There is also a test_project.zip available where you can check out some of the features and benchmark against a normal Godot Area2D bullet implementation.

⚠️ When Not To Use BlastBullets2D

While BlastBullets2D is highly optimized and feature-rich for top-down 2D games, there are a few limitations you should be aware of:

• ❌ Y-sorting is not supported
  If your game relies heavily on Y-based depth sorting (common in platformers or isometric games), this plugin may not be a good fit.
• ❌ Only RectangleShape2D is supported for collisions
  Currently, other collision shapes like CircleShape2D or ConvexPolygonShape2D are not supported.
• ❌ Only Area2D like behavior
  All bullets act as Area2D - they are not RigidBody2D and don't support bouncing off of other bullets and so on. Basically you can NOT apply impulse forces. Just view them as Area2D bullets.
• ❌ No Save/Load System
  Version 2.0 of BlastBullets2D had a saving/loading system based on custom resources that got removed in version 3.0. This is due to the enormous amount of features and changes that got added and the difficulty of keeping everything supported for every type of game and every mix of features, which proved very hard in practice. The recommended way is for the user to implement this logic depending on the game he's working on - you can fork the repository and begin experimenting. There are currently no plans of this getting implemented again, since people that donated or contacted me privately wanted the advanced features mostly and found the saving/loading unnecessary.

In conclusion, BlastBullets2D is ideal for top-down shooters and arcade-style games, but may not be suitable for other 2D genres if those specific features are essential to your project.

For more information check out the official GitHub repository: https://github.com/nikoladevelops/godot-blast-bullets-2d