Godot Scenes vs. OOP Classes

From Inheritance to Composition: A Paradigm Shift

In your work with Java, you've undoubtedly encountered and built deep inheritance hierarchies. A classic example is the Java Swing UI library, where a JButton inherits a vast amount of functionality from its ancestors.

This model works well for many applications, but it can become rigid and cumbersome in game development, where entities often share disparate sets of functionalities. For instance, what if you have a Player, an Enemy, and a destructible Tree?

• The Player and Enemy might share Health and Attack capabilities.
• The Player needs to respond to user Input.
• The Tree also has Health but doesn't attack or move.

If you create a base Entity class with all this functionality, the Tree inherits methods it doesn't need. If you create a more complex hierarchy, you can quickly end up with a tangled web of classes that is difficult to manage.

Godot encourages a different approach: composition over inheritance. Instead of an object being something, it has things. A Player isn't a single monolithic class; it's an object composed of smaller, independent parts: a part for health, a part for visuals, a part for input handling, and so on.

To see this principle in action, watch the first three minutes of the following video. It provides an excellent explanation of why composition is often preferable in game development.

In Godot, these "components" are called nodes, and a collection of nodes organized into a tree is called a scene.

Building Your First Scene: The "Goblin"

Let's make this concrete by building a simple "creature" for our card game. We'll create a visual representation for a Goblin. This is your first practical step in building a game element.

1. Create a New Scene:

   • In the Scene dock (top-left), click the + icon ("Add New Scene").
   • Godot will prompt you to create a root node. The root node is the top-level node of your scene's tree.
   • Select Node2D and click "Create". Node2D is a basic 2D node that provides position, rotation, and scale—a great starting point for any 2D game object.
   • Immediately rename the Node2D to Goblin by double-clicking it in the Scene dock.
   • Save the scene by pressing Ctrl+S (Cmd+S on Mac). Save it inside your scenes folder as goblin.tscn. The .tscn extension denotes a Godot scene file.

2. Give it a Visual (Composition in Action):

   • Our Goblin node has a position, but it's invisible. To give it a visual, we will add a child node.
   • Right-click the Goblin node in the Scene dock and select "Add Child Node".
   • Search for Sprite2D and click "Create".
   • Notice the Sprite2D node appears nested under Goblin. Our Goblin scene is now composed of a Node2D and a Sprite2D. The Sprite2D's sole job is to display a texture.
   • With the Sprite2D selected, look at the Inspector on the right. Find the Texture property. For now, drag the icon.svg file from the FileSystem dock into this slot. You should see the Godot icon appear in the viewport.

3. Give it a Name:

   • Let's add another component for its name. Right-click the Goblin node again and add a Label child node.
   • Select the Label node. In the Inspector, find the Text property and type "Goblin".
   • Use the move tool (or set the Position property in the Inspector) to place the label below the sprite.

Your scene tree should now look like this:

• Goblin (Node2D)
  • Sprite2D
  • Label

You have just built a game object using composition! Instead of creating a Goblin class that inherits from some RenderableGameObject class, you've assembled a Goblin from distinct, single-purpose nodes.

The Scene as a Blueprint

This goblin.tscn file is now a reusable blueprint. You can drag it into other scenes to create instances of your goblin, just like you would instantiate a class in Java. If you modify the goblin.tscn blueprint (e.g., change the sprite), all instances of it in your game will update automatically.

As scenes become more complex, you can use plain Node objects as "folders" to organize your components, much like you might use packages in Java.

The Godot documentation has an excellent page on scene organization. Given your background, you'll find the connections it draws to OOP principles like loose coupling and dependency injection particularly relevant.

The key takeaway is that child nodes should ideally know nothing about their parent. The parent node is responsible for connecting to its children's signals or calling their methods, creating a loosely coupled and highly reusable system.

Advanced Composition: Component Scenes

The real power of this model shines when you create your own reusable components as scenes. Imagine you need many different game objects to have health. Instead of adding a health variable to every script, you could create a HealthComponent.tscn. This scene might just contain a single Node with an attached script that manages health and emits a died signal when health reaches zero.

You could then instance this HealthComponent.tscn as a child of your Goblin, Player, or even a destructible Wall. The main script for each of those objects would simply connect to the died signal to handle the consequences.

The following video demonstrates this advanced pattern. It uses C#, but the architectural concepts are identical in GDScript and are very powerful.

We will be using this powerful pattern extensively as we build your card game, creating reusable components for things like card effects, mana costs, and creature abilities.

Conclusion

In this lesson, we've taken a deep dive into Godot's core architecture. You've moved beyond just knowing the editor layout to understanding the philosophy behind it.

Here are the key takeaways:

• Composition over Inheritance: Godot favors building objects by combining independent nodes rather than using rigid class hierarchies. An object is defined by what it has (its child nodes).
• Nodes are Building Blocks: Each node has a specific, focused purpose (e.g., Sprite2D displays an image, Label displays text).
• Scenes are Blueprints: A scene is a tree of nodes that can be saved, instantiated, and nested within other scenes, acting as a reusable template.
• Loose Coupling: The architecture naturally encourages a loosely coupled design, where components (nodes/scenes) can be reused in different contexts without modification.

You've successfully created your first scene by composing it from nodes, a fundamental skill for all Godot development.

Preview of the Next Lesson:
Now that you have a scene, the next step is to make it interactive. In the next lesson, you'll write your first lines of GDScript. We'll attach a script to our Goblin scene and explore GDScript's variables, functions, and control flow, directly contrasting its syntax and features with Java to get you coding comfortably as quickly as possible.