https://www.gamedatacrunch.com/steam/list/all/reviews_total/...
I spent three months working in Godot a few years ago and it was clear even then that there were significant bugs in major systems. If you want to ship on Godot you had better be prepared to roll up your sleeves and dive right down deep into the engine.
This is one of the few bugs I logged before finally giving up on the engine.
https://github.com/godotengine/godot/issues/32383#issuecomme...
The object pooling system reuses references so that your script can't tell when a reference to an object it is holding, changes. They doubled down on the bug by making the behavior in Debug different to a Release build. It's marked closed, but users still report it happening.
The real problem is that you are not properly managing the lifetime of your objects so you have dangling references. Obviously Godot could provide better tooling to help you identify and troubleshoot it, but dangling references like that will cause breakage in basically any runtime environment that makes it possible to have them.
IDs of that sort can be reused in many environments. For example, if you use Unity, .NET GCHandle IDs can be reused in the exact same way.
I can guarantee this is not an issue in Unity where a object that has been removed from the scene is null.
Except - and this is called out in the github thread - the reference is not null and does exist. The check is working correctly.
The problem lies in the fact that what you want to check for is "is the object I originally pointed to still around?", but instead of doing that, you're checking "is the thing I'm pointing to currently a valid object?".
I'm making a complex Godot game.
'is_instance_valid' does what you are describing.
https://github.com/godotengine/godot-proposals/issues/1589 https://github.com/godotengine/godot/issues/41179
Reduz doesn't want the fix in release builds because the will be slower!
On Oct 2 @RandomShaper said "is_instance_valid() was made thread-safe, but it's still not something you can trust. An object allocated at the same address as a freed one will report a false positive. That's, of course, considering that what you want to check is that your variable is still pointing to the object you assigned, and not to just some object, which I think is the case.
@reduz respoinded with "Ah that may be still the case of 3.2, but in 4.0 this function is 100% trustworthy"
There probably is such a method, but you'd have to invoke it on the object, not on some other unrelated object.
When I reported the issue to the bugtracker, I was asked by devs literally "I still don't understand the issue you're experiencing. Aside from saving resources, why is it important that Rigidbodys are asleep?"... I was (and still is) speechless from that attitude, because, c`mon guys, the sole reason for that flag is to save some resources! But they didn't really cared about that, just reworded the docs a little and happily closed the issue.
Moreover, I got an email from one of the Devs stating that I'm violating their Code of Conduct for the phrase "I'm struggling to not interpret your comment as a joke.".
That was the last time I tried to take part in Godot improvement...
With that said, I’m still happy to have contributed a little bit of code to gdnative. Nothing exciting, just some quality of life stuff I wanted at the time (a few variadic template wrapper functions around the C api to avoid having to manually construct godot list objects of parameters). Last I checked it was still in use, although moved to a different file.
I can imagine that this was done here, Godot isn't really ready for a game like this IMO - it would have taken a huge amount of work.
Not to mention that the actual gameplay is incredibly fun. With varied gear options, replayable missions with new gear and lots of secrets to find.