tutorials/best_practices/what_are_godot_classes

[giscus[bot]]

tutorials/best_practices/what_are_godot_classes

The engine offers two main ways to create reusable objects: scripts and scenes. Neither of these technically define classes under the hood. Still, many best practices using Godot involve applying o...

https://docs.godotengine.org/en/stable/tutorials/best_practices/what_are_godot_classes.html

[gratisnotas]

Why doesn't Godot use usual classes? What is the requirement to use ClassDB?

[apanascx]

C++ doesn't have support for reflection (or at least not as flexible as managed languages), so if you want to list fields of a class (e.g. to show them in the inspector) and allow you to modify their values (edit them in the inspector), you need a mechanism which, for any object that has a known parent class (like godot's Object class) gives you (in C++) all the details of that object's actual class (e.g. Node3D).

ClassDB is the structure that holds all that information in the engine's codebase. You can see ClassDB is also accessible from gdscript, and all methods take a class name. If you have any kind of object whose class inherits from Object you can call https://docs.godotengine.org/en/stable/classes/class_object.html#class-object-method-get-class to get it's class name.

This makes it possible to write code that interacts with instances of Object and still know what methods and properties the object's actual class is, to make tools like the editor inspector.

Just a side note: Godot still uses C++ classes, there's no way around that. But it also generates additional information about those classes that it stores in the ClassDB. This is how unreal does reflection for blueprints and garbage collection as well. It's also how the Qt framework does reflection.

[gratisnotas]

What is the difference between scenes, nodes, and classes, and are all scenes and nodes just class instances?

[HanifNaOH]

Nodes are instances of classes, scenes are collections of nodes, and yes, every node or scene is essentially a class instance in Godot architecture, same as irl taxonomy, human and monkey is essentially a mammal, simple as that

[tiagoskaterock]

Scenes are likes block we can put them together to build bigger things.

Nodes are smaller blocks we put them together to build scenes, the bigger blocks.

Once we put them all together, we can have a well organized game =)

[gass-git]

Well not quite - in this analogy, scenes would be blueprints (or classes) for instantiating blocks (nodes) with specific characteristics specified in the scene composition, e.g. a scene called blue_lego_block will be a blueprint for as many blue lego blocks you instantiate.

You could also have a yellow_lego_block scene, which would instantiate yellow lego block nodes.

When for example you run a Godot application which has a Main scene, this scene is instantiated and what comes out of this is a Main node instance that uses this Main scene as a blueprint for building all of its characteristics. So that is why even if two players in two different computers run the same Main scene can have a completely different experience - because each Main node instance will adjust its properties to the inputs made by the player. e.g. a player changes the background property of the Main node instance and the prop background set up in the Main scene gets mutated (changed) within the node instance which can be created or destroyed.

Nodes can have children nodes and these children nodes can have other children. So in this sense, there is no limit on levels for nesting nodes within nodes. These are known as tree nodes.

Don't mix the concepts of nodes and scenes - instances of scenes are nodes and at the same time scenes are also nodes. They can be anything: sprites, scripts, scenes, instances,... The node tree is how the game is organized and structured so that all the blocks as you mentioned can work together to deliver an specific experience for the user.

These are not easy concepts to grasp, I would suggest having a clear understanding of instances, nodes, classes/scenes and their differences so that the abstraction can become clearer - hope it makes a bit of sense.

[RedpingDev]

Hello! I'm a big fan of Godot, and I'm learning it with enthusiasm! I'm reaching out to make sure I understand things correctly and to get feedback on any misconceptions I might have. Here’s my question:

In the end, classes are created for reusability, but in Godot, we can achieve this with nodes and scenes. So, does that mean we don’t really need to create classes, and that we can implement object-oriented design by combining nodes and scenes effectively?

[Wiechciu]

In general, you can do almost everything with just Scenes and Nodes. However, there are advantages to using more lightweight constructs, including Classes, which is well described here
https://docs.godotengine.org/en/stable/tutorials/best_practices/node_alternatives.html

[uprun]

if someone will be searching on how to move a class into separate file, here is a good tutorial:
https://gdscript.com/tutorials/classes/
after moving class into separate file you can use it with preload

const Motorcycle = preload("res://Motorcycle.gd") # this goes to the top of your file
........
......
var moto = Motorcycle.new()

[kevyntime]

Maybe I'm misunderstanding you, but I think you don't need the const Motorcycle = preload("res://Motorcycle.gd") line. In the tutorial, motorcycle.gd starts with class_name Motorcycle which declares Motorcycle as a global class.

Because it's already global, you can call Motorcycle.new() in any script without preload. And if you re-declare Motorcycle anywhere, you'll get the SHADOWED_GLOBAL_IDENTIFIER warning.

# motorcycle.gd
class_name Motorcycle # this line makes it globally accessible by name
extends Node2D

# ... the rest of the Motorcycle

# any_other_script.gd
extends Node

var moto := Motorcycle.new()

[RostagRed]

Best way I can understand this is:

• Use 'Scenes' to create commonly used modules: AI, Combat, Audio etc.
• Create a main scene/script to build instances/clones
• You could create templates for each node needed for that particular entity. e.g: an enemy would need the character node, AI node, combat node, audio node etc.

[hubertgrzeskowiak]

When you instantiate a child scene, it shows the script of the child scene's root node. You can, however, detach the script from the instance. Is that intentional?