Home/ Questions/Q 39428
In Process

askthedev.com Latest Questions

Asked: 2025-04-19T20:13:59+05:30

How can I implement runtime-defined classes in Godot with LSP features and check for Node inheritance in user code?

I’ve been diving deep into Godot, specifically with using the CodeEdit node for runtime scripting, and I’ve hit a bit of a roadblock that I hope someone can help me navigate through. I know the CodeEdit node is pretty nifty because it lets users write and execute code on the fly, but I’m aiming to do something a bit more complex.

Here’s what I’m trying to accomplish: I want to implement features in the CodeEdit to provide some decent LSP (Language Server Protocol) experiences for GDScript. This means things like syntax highlighting, autocompletion, and maybe even error checking while users are coding. So, the first step is to integrate those LSP features into the CodeEdit.

Next, I want to be able to interpret the code users are writing as valid GDScript. I suppose that would involve setting up a way for the CodeEdit to process and run the scripts correctly. I’m not sure how to set up the connection between the CodeEdit and the GDScript interpreter efficiently without making the experience lag or anything like that.

Now, here’s where it gets even trickier. I want to include functionality that checks whether a class was defined in the user’s code. It’s vital for my project since users might create different types of game elements on the fly. But alongside that, I also need to verify if the defined class inherits from the ‘Node’ class provided by Godot. This check is vital for ensuring that the custom classes can interact appropriately within the Godot scene tree.

If anyone has experienced implementing something similar or has insights into how I might go about tackling this, I would love to hear your thoughts! Specifically, I’m looking for advice or examples that deal with integrating LSP features, errors handling when interpreting GDScript, and doing those inheritance checks. Any guidance or resources would be greatly appreciated! Thanks!

Share

    Leave an answer

    You must login to add an answer.

    Need An Account,

    2 Answers

    1. For integrating robust LSP features—such as syntax highlighting, autocompletion, and error checking—into your CodeEdit node, your best route is likely utilizing existing language server community tools like the officially-supported GDScript language server available in recent Godot releases. You can connect your editor’s input to Godot’s built-in language server through an intermediary that supports the Language Server Protocol (LSP). Doing this will help you efficiently retrieve linting, completion suggestions, and diagnostics, maintaining an interactive, real-time editing experience without significant performance hits. Godot’s own editor backend provides widgets and methods you can leverage to parse scripts, interact with the language server, and stream results back into your CodeEdit node seamlessly.

      Regarding interpreting the user’s GDScript code and verifying class definitions/inheritance at runtime, the best solution is to invoke Godot’s built-in scripting API and reflection methods. One method is calling GDScript.new().parse() at runtime to quickly ascertain if the inputted code is valid and parses correctly. Once the script passes the initial parse check, you can load() or ResourceLoader.load() it dynamically, then inspect the returned script’s metadata or use Godot’s reflection tools like is_class() and is_subclass_of() to check inheritance against Node or its derived classes. This systematic approach ensures that scripts adhere strictly to Godot’s scene tree hierarchy, preventing runtime issues and maintaining reliable interaction within your environment.

    2. Hey there!

      It sounds like you’re diving into some pretty cool and complex stuff with Godot’s CodeEdit node! 🐢

      For adding LSP features like syntax highlighting and autocompletion, you might want to check out Godot’s built-in text editor features first. The CodeEdit node can be extended, but it may require some extra work to handle things like highlighting. You could look into parsing the GDScript syntax using regular expressions or libraries that might help with tokenizing code.

      As for autocompletion, you can try maintaining a list of keywords or classes to suggest while users are typing. Implementing a basic autocompletion might just involve checking what the user has typed so far and suggesting options from that list.

      Regarding interpreting the code, it’s essential to set up a method to execute the user scripts. You should look into using the built-in load() function, which can load scripts dynamically, but you’ll have to make sure the environment doesn’t clash with other running scripts. A possible way to minimize lag is to process code execution in a separate thread or process.

      About checking if a class is defined and whether it inherits from Node, you can use the type_of() function after your script is loaded, or try checking the type directly after executing the user’s script. You can also have custom error messaging that will inform the user if they’re not extending from Node.

      Overall, this could get pretty technical, but definitely do start small. Try building just one feature at a time, like the syntax highlighting, and see how that works out before diving into the stuff with inheritance checks.

      There are some great resources in the Godot community, and maybe even look through the Q&A sections to gather some insights. Good luck, and have fun coding!