Godot Version
4.5 stable
Question
I’m just wondering if this is a valid, not-overdesigned approach in general, or maybe at least for my game specifically.
In a nutshell: Data for specific enemies stored in .tres file Resources. A handful of scenes for each type of enemy that don’t have data in them, but read from said Resources to create themselves when spawned.
Explanation
I’m making a simple platformer that procedurally generates stages and randomly places enemies from a list of possible enemies. But enemies can be easily categorized into a few types, and there are going to be quite a lot of them, so it seems like a better approach to just have one base scene for each type, then have all the enemy-specific data in Resources. It’s also nice to have all the data for each enemy in a Resource, so I can even have stuff in there like its description and name, which would only be used for UI things.
So here’s what I have so far. I’ve got a basic enemy scene called an IdlerEnemy:
And this root node extends the script for an Enemy, which is literally just this:
class_name Enemy
extends BaseCharacter
@export var data: EnemyData
Now, EnemyData is not finished yet, but this is what it has so far:
class_name EnemyData
extends CharacterData
enum spawn_locations {
GROUND,
AIR,
WATER
}
@export var base_scene: PackedScene
@export var spawn_location: spawn_locations
@export var level: int
@export var att_setup: CharacterAttributesSetup
@export var item_drops: Dictionary[float, Resource] #change later
@export var sprite_frames: SpriteFrames
@export var collision_shape: RectangleShape2D
(CharacterData just has a variable for the name, and extends Resource)
So whenever I make a new enemy, I just create a new .tres file from this EnemyData, and I choose the base scene for the base_scene variable.
Now, my character spawning class that actually spawns the characters in can have a nice, safely-typed array of EnemyData, rather than an array of PackedScenes, and it can read the enemy data like the spawn location without actually instantiating the scene first.
So it does something like this (not precisely what I have but the same idea):
var spawn_amount: int = stage.spawn_amount
while spawn_amount > 0:
var enemy_data: EnemyData = possible_enemies.pick_random()
#I randomly generate my stages, so
#I need to check if there is water before placing any water enemies:
if enemy_data.spawn_location == enemy_data.spawn_locations.WATER and water_exists == false:
possible_enemies.erase(enemy_data)
continue
var enemy_instance = enemy_data.base_scene.instantiate()
enemy_instance.data = enemy_data
add_child(enemy_instance)
spawn_amount -= 1
When the enemy is added to the scene, it just uses the data to set itself up, like this:
So! I was thinking lately (from a discussion I had in another post I made) that just making a whole separate scene for each enemy might be easier. But I changed a few things since then so that the data-driven approach feels like it works just as fine and might actually be better for my game specifically. Here are my thoughts:
Whole new scene for every single enemy
Pros:
- Simpler to actually create, everything is done in the editor and left in the editor
- If I decide to change a specific enemy a little bit later, easier to make tiny changes to it
Cons:
- PackedScenes. With my random generation approach, I would have to first instantiate the scene, then check if it could even be spawned, and then if not, remove it from the array and queue_free() it. PackedScenes are also not safely typed as Enemies, and less readable in the editor. I also know that I’ll want things like a library where players can read about all the enemies, and I don’t want to instantiate them all just to get their data there, either.
- Lots of redundant scenes. If you have a Cat, an OrangeCat, and a GrayCat, and all that’s different is their color and stats, seems wasteful to have a scene for each.
Data-driven
Pros:
- Much easier to keep track of the actual in-game functionality of all the enemies, since you only have a handful of scenes. If I want to change the way all my Cats work later, I can just make one change to the base scene and be done.
- Much easier to read from the data for things like the UI and random spawning. Safely typed Resources that only have what you need in them before you instantiate anything.
- Very easy to make new enemies. Just create a new .tres file from the Resource and fill in the blanks, easy-peasy.
- More readable in the editor and better for the editor, too. If I want to create my list of possible enemies for a stage in the editor, I am safely required to drag in EnemyData (rather than any PackedScene), and I don’t get weird pictures that PackedScenes give you.
- Just feels way more organized to me overall.
Cons:
- Maybe overly complex?? It feels pretty readable and simple to me, but I’m not sure now after a recent discussion.
- Maybe I’m doing it in a weird way and there’s a better way to handle data vs. scenes?
That’s all, what do you think? Am I doing anything stupid? I really want to have my data for my enemies separated somewhere for this game, so I feel like the data-driven approach makes more sense now. I just want to ask before I go jumping in the deep end and making a bunch more.
(If you’re one of the people that helped me on my other post: I DID decide to use specific scenes for my PLAYER characters, thanks to that discussion. The player characters are all different enough to make unique scenes. The enemies are way more bare-bones and simple, though.)