Crafting Ingredients: Modular Gameplay Systems in UEFN’s Scene Graph | Unreal Fest Chicago 2026

[00:00:01]I hope everybody's having a good time. I know you're probably very tired. Um it's been a pretty crazy 2 days, but hopefully you're still awake enough to follow along with me and not fall asleep. And if you do, I'm sorry.

[00:00:14]So, a little bit about me. I'm a senior game developer at Fode. Recently worked on Droid Tycoon.

[00:00:20]Pretty cool game.

[00:00:21]Uh we built that with Scene Graph, and so I kind of like Scene Graph now.

[00:00:27]Uh so, today we're going to talk about a little quick little Scene Graph 101. You know, what is Scene Graph? What does it mean to Scene Graph?

[00:00:34]Um and then we're going to talk about what it means to craft ingredients.

[00:00:37]That's the title of this talk. I forgot to say that. Uh and then we're going to talk about custom items, and then a few other game mechanics. Then we're going to wrap it up with a quick recap, and then if we have time, a Q&A.

[00:00:50]So, just a quick vibe check. Who has shipped a game in UEFN?

[00:00:55]That didn't help. I can't see.

[00:00:58]Some of you. Who has built something with Scene Graph in UEFN?

[00:01:03]Less of you.

[00:01:04]Interesting.

[00:01:07]Let's talk about Scene Graph.

[00:01:10]Entities.

[00:01:11]Scene Graph has one big thing you got to know about, it's entities. They're the backbone of Scene Graph, and they're really not that complicated. They're just little lightweight containers that contain other things, other entities, or components.

[00:01:24]Components define what entities actually do in the scene.

[00:01:28]And everything in your game resides under one simulation entity. Uh if you were just next door a little bit ago at that other Scene Graph talk, they probably went a lot more into it than I'm going to.

[00:01:37]But, if you're from not UEFN, you should also know that an entity is kind of like an actor, but simpler.

[00:01:45]To really drive that home, here's the documentation page for entities. It's pretty long.

[00:01:50]Uh but, actors is I could not fit it on the slide.

[00:01:57]Components. The >> other most important thing in Scene Graph. Without them, entities don't do anything and you want your entities to do stuff.

[00:02:05]So, components that add logic can be written in Verse and assets are also components.

[00:02:10]So, anything like Niagara systems, static meshes, widgets turn into components.

[00:02:19]Um the entity life cycle. So, a key thing to know if you're writing logic for entities and components or even if you're just using them at all in your project, if you're not a developer, that's okay.

[00:02:31]You should still understand the life cycle stages they go through.

[00:02:34]So, these are where you where your programmers add their logic and entities in the scene are considered simulating.

[00:02:41]So, I'm not going to get too deep into what it means to be simulating. Are we in a simulation? I don't know.

[00:02:47]The entities are though, that's all you need to know.

[00:02:49]When they exit the scene, they're no longer in the simulation.

[00:02:53]This is like a quick little flow of what happens when you add it to the scene.

[00:02:56]These are like the stages, so it goes through on added to scene, on begin simulation, and that's like the setup phase, like it's ready to go.

[00:03:03]Uh and then on simulate, which is it's happening, we're doing stuff.

[00:03:07]And if you're if you know Verse at all, it's important to know that that is a suspended context, which means something to some of you.

[00:03:15]Then, when it's removed from the scene, so after it's lived its beautiful life, had some children, bought a farm, now it's leaving your scene.

[00:03:23]So, on simulate gets canceled, which again might mean something to you.

[00:03:28]Uh and then it calls on end simulation, where it stops simulating.

[00:03:32]And then finally, on removing from scene, it's out of the scene.

[00:03:37]Prefabs.

[00:03:38]They're just entities, but you can make copies of them basically. So, they're reusable entity hierarchies.

[00:03:45]Uh and they're kind of the magic of Scene Graph. I'm going to talk about them a lot cuz they're really cool.

[00:03:49]Um they can be instance at runtime or in the editor, and updating one prefab updates all the instances.

[00:03:57]So, there's lots of lots of cool stuff in there. I'm not going to get too deep into it, but prefabs are an entity that you can spawn whenever you want, and you configure it in the editor at build time.

[00:04:10]Modularity. So, we kind of understand scene graph, hopefully. If you don't, I'm sorry. You'll kind of get it after the rest of the presentation, I hope. Um what does it mean for code to be modular?

[00:04:21]So, to me, a modular component enables a developer to add new gameplay by reusing existing components and systems, while keeping things kind of isolated. So, they're composable. You can make new features by combining your other features. They're reusable, which means functionality that's like generic should probably be generic, and so you can use it to compose new stuff.

[00:04:44]Uh and extendable, which means you can change a component without having to go inside and tear it apart and make a big mess.

[00:04:51]Uh and then the final thing is easy to change. So, if you do need to change it, which hopefully you don't if you listen to the last point, um it's still easy to do that, and you're not going to break your whole game by changing one thing.

[00:05:03]Uh biggest takeaway from this is do not put all your gameplay into one component. If you made games in UEFN before, you might be used to a device, and you have one game manager with literally everything in it. Don't do that anymore. We're past that.

[00:05:19]So, why would you do that? Well, designers can experiment, which is cool if you have a game designer who's maybe somebody who's not as technical as you.

[00:05:27]Um code can be reused in other projects, so, you know, you can build one thing and then take and build another thing later. We actually have done a little bit of that with scene graph already, and it's been fantastic. Um and it helps you break apart large problems into smaller, more manageable ones. For me, I don't like big problems, but the cool thing about a big problem is that it's actually many smaller problems in a trench coat.

[00:05:51]Um Standardizing functionality across your project. This kind of plays back into like making things portable. You can reuse stuff if you're following the same standards all the time in like Fortnite itself in UEFN if you're familiar does that. So Yeah, and then avoid duplicating logic which if you're a programmer you know that's like the big thing everybody's talking about is not repeating yourself, not writing too much code cuz writing code is boring. Um So the less you have to do that the better.

[00:06:19]So >> [clears throat] >> when you want to make something modular where do you start? You know, you want to make a game, how do you find those atomic little pieces?

[00:06:28]Well, how are other components going to interact with that component in your game?

[00:06:32]How will designers interact with that component when they're designing? What values can they configure? Stuff like that.

[00:06:38]Uh how players will interact with component. Obviously you're making a game, you want people to play it. How will they play it?

[00:06:45]And then just a general warning, I'm going to show like maybe a little bit of code. Don't be scared. It's okay.

[00:06:50]Uh I kind of boiled it all down to just comments and text so you don't have to know how to read verse. You can just imagine that there's verse there and that you know how to read it.

[00:06:59]Um wow, I just covered this slide already. But not a programmer, that's okay. It's valuable to know what options are available to your programmer. So if you need to ask them for something or you know, use their components you can kind of understand what's going on.

[00:07:16]So don't make everything modular. Don't be that guy that goes in and turns, you know, one tiny thing into 50 million different parts.

[00:07:24]Um identify just what's important and we'll get into how to do that later, but making that part of your present that part of your game modular will help you. So a few examples of that is like if you're making a first-person shooter you probably care about the weapons and those should be pretty modular.

[00:07:40]Um if you're building a roguelike game, your upgrades and abilities and items, those should be modular.

[00:07:46]If you're building a tycoon game, the unlocks and builds and tycoon stuff should probably be modular. Um, and then items and crafting in a survival crafting game, which conveniently segues into what I'm about to talk about, which is a survival crafting game.

[00:08:03]Items.

[00:08:06]So, kind of conveniently actually, custom items are already thing in UEFN as a very cool new feature set they've been working very hard to build.

[00:08:14]Um, and they work great right now. So, we're going to mostly just use those because they already exist and I'm lazy.

[00:08:21]An item is an entity that has an item component. And that's Pay attention to that. It's not an item because it's an item, it's an item because it's an entity with an item component.

[00:08:32]We'll talk about that more in a sec. Um, additional functionality is composed onto that item via the other components, like an icon component gives it an icon.

[00:08:41]The description component gives it a description. The pickup component I'm not going to keep going.

[00:08:47]Items are prefabs.

[00:08:50]We talked about prefabs and how they're magical. If you think about what an item is, it's like a thing, like, you know, am I an item?

[00:08:56]Maybe, I could be. I'm an entity.

[00:08:59]Um, and items are defined by just creating prefabs that have item component.

[00:09:04]And then they can be added to any inventory, which is just an entity with an inventory component.

[00:09:10]You might see a pattern.

[00:09:12]>> [snorts] >> Um, so I'm going to dive in. I'm going to show you a quick little video of me making an item.

[00:09:16]And we're going to just like talk through the components that are on there.

[00:09:20]Ignore the art in this, by the way. The artists were very busy, and so I they let I was allowed to make art, which is not usually a thing.

[00:09:28]So, we start by making a prefab.

[00:09:31]And then we're going to go and we're going to add our mesh. So, like I said, meshes are reflected as components, so we're going to find the log component cuz we're making a log.

[00:09:39]We're going to throw that on there.

[00:09:42]Good job, me.

[00:09:45]Next up, the description component and the icon component and the item component.

[00:09:52]Lots of components.

[00:09:54]The description component, like I said, gives it a description. This is cool because if you have anything else in your game that needs a description, you can just use this. And then you can get the description from something the same way for anything. And then the same thing as the icon component.

[00:10:10]I found a very beautiful log icon just in the Fortnite content. How cool is that?

[00:10:16]And then finally, we add the pickup component that makes it so you can pick it up. Um Fortnite and honestly, like you as a developer, if you're making something in Scene Graph, don't ever assume that everything needs everything, right?

[00:10:28]You don't always need an item to be able to be picked up. Maybe you only ever grant that item to the player directly.

[00:10:34]So, only add what you need. Generally, a good thing, good practice to follow.

[00:10:39]Um yeah. Cool log.

[00:10:43]So, composition.

[00:10:45]Kind of like you just saw, we put a bunch of things together to build that item.

[00:10:49]So, that's a really good example of how something can be modular by sort of focusing on making it composed of other things instead of just one big giant scary thing.

[00:10:57]Um so, you got to start by thinking about what an object has, not what it is. So, we thought about our log. Well, it looks like a log, so it's got to have a log mesh on it. Um it's going to have an icon, a description, and it's an item.

[00:11:11]So, you know, with that kind of thinking in mind, think about how easy it would be to create a backpack. That's just you know, it's just an item that also is an inventory. And Scene Graph really thrives when you give yourself to that thinking and always aim to do things compositionally.

[00:11:31]So, we got our items. We have a log, but how do you actually get the log in our game? Well, we're going to talk about gathering.

[00:11:39]Super cool, beautiful game. Wow, I broke a rock.

[00:11:43]Broke it a bunch of smaller rocks, and I cut down a tree.

[00:11:47]Pretend there's sound effects and it's not just me talking, please.

[00:11:53]Wow.

[00:11:55]All right, so how do you find those components? How do you know what those little atoms are that you build your game out of?

[00:12:02]Well, where do you like where do you start? How do you know what to add? Do we just do a pickaxe component when we want to make our pickaxe? That sounds kind of not very modular.

[00:12:12]Um, how do you make a pickaxe modular?

[00:12:14]It's just a pickaxe.

[00:12:15]So, what we're going to do is we're going to use a little magic power called abstraction, which if you're a programmer, you might know about.

[00:12:22]So, I took the description from Google here cuz it's pretty accurate. They know what they're talking about. Um, abstraction is the cognitive process of simplifying complex realities well by discarding specific details in favor of general ideas or patterns.

[00:12:38]To put it less like a nerd, simplify it until you find a sweet spot.

[00:12:43]So, what is a pickaxe? Well, it's a tool you use to harvest things. There's other ones of those. They're not all pickaxes, but they do all have things in common.

[00:12:51]So, we're going to boil that down to the harvesting tool component because that's what a pickaxe is. It's a tool that you harvest with. And you know, we could reuse that later for like an axe, a shovel.

[00:13:02]I can't think of any other tools right now, but I could if I tried hard enough. So, how do we make our pickaxe harvest stuff? Well, when our pickaxe is in the player's inventory, it's simulated, which if you remember what that means, it means on simulate runs.

[00:13:19]So, while it's in the scene, we're going to wait for it to be equipped, listen for the player to click, and then we're going to send a little ray cast into the scene, and whatever we hit, we're going to send an event.

[00:13:30]What is an event?

[00:13:32]Scene events, you may have heard of them. You may not have heard of them.

[00:13:36]That's all right. They let you send messages through the entity hierarchy.

[00:13:40]So, entities can have children. Good for them.

[00:13:44]Um and you can send messages down to those children and communicate between stuff.

[00:13:51]Um this is powerful because it avoids creating a direct relationship between those things. Your pickaxe doesn't have to know about a tree. Your pickaxe just has to send its message to whatever it hits, and then the tree listens.

[00:14:05]Um that's done by implementing the on receive event, and just found out about this at Rodney's talk earlier if you were there, but there's going to be like way cooler ways to connect things with events later.

[00:14:16]Um and that'll be very similar to this.

[00:14:21]Scene events in action. So, like I said, our harvesting tool sends a line trace into the scene. Sends down a harvest scene event to anything it hits.

[00:14:30]Um and then with that event, we can create little components that listen to it.

[00:14:35]And other things in the scene never learn anything about that specific pickaxe, so we've achieved modularity.

[00:14:42]Let's wrap it up. Just kidding.

[00:14:46]Here's me uh creating a tree.

[00:14:51]Wow, I must have been tired.

[00:14:56]You can do it, buddy.

[00:14:58]Anyways, we're going to make the prefab, and then just like we did with our log, we're going to go and we're going to start composing functionality together from these little individual components.

[00:15:09]Actually, we're making the pickaxe first. I totally got ahead of myself.

[00:15:12]We're not making a tree yet.

[00:15:14]So, again, like the log, all those item components, the key difference here is that we're going to add our harvesting tool component, which makes this item into a harvesting tool.

[00:15:23]And we're also going to put a tag on it.

[00:15:26]So, tags are kind of neat. They allow you to just put a little piece of information on a thing, and then later you can look at that, compare it to other ones, and we'll we'll get into tags in a little bit.

[00:15:39]Very cool pickaxe mesh. You can tell what I didn't make.

[00:15:44]Keep moving forward.

[00:15:46]All right, we've got our pickaxe. We can harvest stuff.

[00:15:49]We don't have anything to harvest.

[00:15:51]We need a tree now. Um so, we've got we're going to have to figure out what that means. What does it mean to be a tree?

[00:15:58]I don't know, I'm not a tree. Um So, we need to make our component to listen to this scene event. But, we got to ask ourselves some questions first.

[00:16:06]So, we're not just making tree component.

[00:16:09]What other things might we want to harvest in our game?

[00:16:11]Probably quite a few.

[00:16:13]What's similar between them, and what's different? You saw in that video I had a tree and a rock, so let's compare a tree and a rock.

[00:16:21]So, a tree gives you a log, it falls over, you can harvest it with anything. Uh and it regrows after a little bit.

[00:16:30]A rock spawns little tiny baby rocks.

[00:16:33]Oh, uh it disappears when harvested, and it requires a strong tool to harvest.

[00:16:38]But, it does not respawn.

[00:16:42]Now, despite their differences, all literally all those points were different. Tree is a lot like rock.

[00:16:47]Um and we can refine those harvestable entity requirements down to the following.

[00:16:52]Some of them give items when you harvest them.

[00:16:55]Some of them spawn prefabs when you harvest them. That's what that dig pile of rocks was.

[00:17:00]And some of them play an animation when you harvest them.

[00:17:03]And some disappear instantly when you harvest them. Lots of things happen when you harvest things.

[00:17:08]So, instead of being limited to just a tree component and a rock component, let's make it modular and composable by using scene events again. Uh yeah.

[00:17:19]So, the harvestable component our core functionality is implemented directly on this thing. So, the stuff that's in common between tree and rock, we can take and we can put into the harvestable.

[00:17:30]Um and then additional stuff we compose onto there later.

[00:17:35]So, this is this is what that looks like. You can see the editables. Those are things that designers can configure.

[00:17:39]So, for example, what tools can harvest this? And that's using tags.

[00:17:44]Um what items are granted when you harvest it?

[00:17:48]Does it respawn and how long it takes to respawn?

[00:17:51]That's general enough. Like we're not overly committing to trees and rocks right now. We're keeping keeping things open.

[00:18:00]So, let's compose. Let's make some more components.

[00:18:03]So, one little thing here is the play animation on harvest. That's for our tree. It needs to fall over. But we could reuse it for other things, right?

[00:18:10]Like maybe we want to juice up our game and the rock like gets bigger or something. I don't know.

[00:18:15]Um and if it All we have to do in this component is super tiny. I reduced the verse code, but this is literally only two lines of code even if I actually showed you the code. Um it listens for that harvested event and then it plays that animation.

[00:18:31]The other one we have is the spawn prefab on harvest and we use that for our rock. It spawns that pile of much smaller rocks. Um again I think it's three lines of code even if I didn't get rid of the code.

[00:18:43]And all it does is it just spawns a prefab that somebody's configured on the component.

[00:18:50]Let's build a tree now for real.

[00:19:04]So, we start with the tree mesh, which again is a component.

[00:19:08]Uh we add our harvestable component.

[00:19:11]And then we start composing on top of that.

[00:19:14]Uh first we actually got to configure this. So we set it to give the log item we made before. So it's prefabs referencing prefabs referencing prefabs.

[00:19:22]You can build a lot of game by just combining prefabs together, composing things with components.

[00:19:40]So here we're throwing the other components on there like the play animation on harvest.

[00:19:46]And that's going to let us do our beautiful little tree falling over.

[00:19:49]Uh here's me grappling with the idea of a tree falling over I guess.

[00:19:55]I wish I could fast forward the video but technology is just not there yet.

[00:20:04]Beautiful animation.

[00:20:07]It's like the tree is really here with us.

[00:20:09]Um I don't want to run out of time just playing the videos. So pretend that I also showed you how we made the rock.

[00:20:23]The only difference there again is that we swapped out one of the components.

[00:20:26]But you see here I'm placing some trees.

[00:20:27]That's good.

[00:20:29]So the cool thing about prefabs is you just drag them from the content browser into your scene and now you have another tree.

[00:20:35]So you can really just keep building your game, keep reusing the same stuff and uh build cool game.

[00:20:42]So maybe we don't want to place our trees by hand because it's boring and I don't like placing trees by hand. And maybe we want to switch things up so the game plays differently every time.

[00:20:51]Logical entities is an that a logical entity is an entity that has no visual components.

[00:20:57]So not everything in a game is like visible all the time. There's invisible things happening all around us.

[00:21:05]Um so you can use that.

[00:21:07]So this is our little entity spawn manager component, and all it does is it takes a tag and then it looks for any entity that has that tag that we can scatter throughout the scene, and then we can spawn some trees on them.

[00:21:20]So, after we place that guy and we tag some entities and scatter them around, you can see now we have trees that I didn't have to place by hand, which is cool. And every time you, you know, every time that tree spawn manager simulates, it's going to be a little different.

[00:21:35]Cool.

[00:21:36]Gathering. Let's talk about crafting.

[00:21:39]Pretty key part of a survival crafting game, and we have some resources, so now we got to craft with them.

[00:21:45]This is what crafting looks like in our game. Kind of experimental avant-garde stuff.

[00:21:51]Wow, it's the pickaxe from before.

[00:21:57]So, crafting. We want to abstract it so we can make those components, and we need to boil it down to its core meaning to do that.

[00:22:04]So, crafting is making something new from specific ingredients by following a recipe.

[00:22:09]And that's kind of always true no matter what you're crafting. Like that applies to cooking, brewing a potion, really anything that makes stuff from other stuff.

[00:22:19]We're crafting right now.

[00:22:21]So, prefabs, not only are they good for things that are visual and repeated throughout your scene, they're great for kind of like data only stuff, like a crafting recipe. Um, historically people might do all this in like a configuration file or a data asset if you're from Unreal Engine, but you can just build it out in the prefab.

[00:22:39]Um, and do it that way, so you don't have to do things in two different ways.

[00:22:44]So, we use that to set up the ingredients that are needed, the slots, and then also lay them out in that visual representation.

[00:22:51]Um, on the topic of prefabs, they are much more useful when they're self-contained.

[00:22:57]Nothing in this little example like depends on anything else to exist. Like you can have a tree by just placing a tree.

[00:23:04]Prefabs are way more useful when you do that.

[00:23:07]Make them self-contained where possible and avoid creating ones that depend on other things in the scene and you will thank yourself later because you can just throw stuff down and spawn it and really do whatever you want.

[00:23:20]So, how do we actually make that system where you can craft using those ingredients and use prefabs? Well, we're going to utilize the entity hierarchy, which is the fact that entities have parents, they have children.

[00:23:30]They go to college, they grow up.

[00:23:32]Um and we can query for specific components in the hierarchy. Scene graph has these really cool methods that let you look up or down throughout that scene graph, well, to find different pieces and parts.

[00:23:48]So, a crafting recipe, all it does is it looks for um it listens for events that are sent up from the crafting ingredient component, which we'll get to. Um and then it will check if all of its dis- all of its children, which are crafting ingredients, its beautiful children, if they are filled with the ingredient they need and if they are, then it's going to grant its ingredient.

[00:24:13]So, how does it actually check its children? How does it find them? Um we use something called the find descendant component. So, this is kind of what that looks like. If you have your root entity, which is our recipe, and you have the ingredients, which are the ingredients, and you need to find them, you do find descendant ingredient slot components and they there they are.

[00:24:33]So, it's very useful. It's cool that you can reuse the hierarchy and kind of everything's standardized around that.

[00:24:41]Tags. I told you I'd talk about them.

[00:24:44]They're verse classes that extend the base tag class.

[00:24:48]They can be added to entities in the editor or at runtime. You can also add them to prefabs, not just entities.

[00:24:53]Um and the tag query methods allow you to check if it's matching.

[00:25:01]So, we're going to use our We're going to use those for a crafting ingredient slot. You know, in your game, you might have many different kinds of stick.

[00:25:07]Maybe you don't just have oak trees, you have birch trees, you have aspen trees.

[00:25:13]I don't know any other trees.

[00:25:15]But, they all have different types of wood. And that's, you know, you don't want to have to configure every single kind of tree you go to add a new tree to your game cuz you think of a new one.

[00:25:23]And then, it doesn't work. You have to update everything else. So, you can just use tags to do that. And they help you achieve that kind of scalable content that can you can keep growing without having to go back and change your existing content.

[00:25:36]So, our crafting ingredient slot component, that's a crazy name, crafting recipe ingredient slot component.

[00:25:42]Um it just requires specific tags on the entity. It doesn't require like a specific item at all.

[00:25:50]So, yeah.

[00:25:54]One thing that you can do is you can try to keep the door open. Somebody just came in. The door was open.

[00:25:59]Identify opportunities that can make a component more useful by avoiding hard-coded behavior.

[00:26:04]Uh and that's a lot of words to say just don't make assumptions, right? Just try to keep things configurable when they can be. And you will open up more doors for yourself in the future.

[00:26:15]So, our recipes don't even assume that you're crafting an item. Because what if you're crafting a structure or something else you can craft.

[00:26:24]By not assuming the crafted prefab is an item, we're going to open up some cool doors later. It's It's pretty sick.

[00:26:29]You'll see it.

[00:26:33]This is what it looks like to build out a recipe.

[00:26:37]We're going to make a recipe for a fence.

[00:26:51]So, we start out by adding those entities. Like I said, we're using the hierarchy here. So, we've added the first child to the prefab.

[00:26:57]Congratulations.

[00:26:58]Um and we're going to give it just the ingredient slot component and then we're going to configure that to look for our log tag.

[00:27:06]So, that, you know, like I said, going forward, anytime we add a log to our game, it's going to work in this recipe.

[00:27:15]We're also going to add a mesh component of that log because, like I said, and like you saw, the crafting in our game is kind of visual.

[00:27:21]So, we just throw that same log component same log mesh on there. We make it look a little bit more like a crafting ingredient slot.

[00:27:28]Uh and then we just dupe that out.

[00:27:30]We don't have to configure anything on the crafting recipe itself after we dupe these out. Like we don't have to explicitly tell it about all the ingredients it needs because it's just looking under itself in the entity hierarchy.

[00:27:41]It just works.

[00:27:43]Um and then we throw the recipe onto that, say that it gives a fence, and that's all that's a recipe.

[00:27:53]So, we just crafted a fence. Our game doesn't have fences yet. We need them now.

[00:27:58]Um So, these are Whoa. How did I do that?

[00:28:03]I'll tell you. Um This is our little building system. It's very simple. Um but as you can see, you place the fence, it plays a cute little animation where it expands. You can see a preview of what you're placing.

[00:28:15]Uh and that's all just one component and some prefabs.

[00:28:20]So, we don't want to build a big giant colossal building system because we we don't do that anymore. We do components now. So, we're going to build one single component and that's the buildable item component.

[00:28:33]Much like the harvesting tool, we put it on an item, which is just an entity with an item component, and then it's buildable.

[00:28:40]The structures that you place, like that fence, are just a prefab and they can do anything a prefab can do.

[00:28:45]And that preview is also a different prefab. And that's you can make things different, you know, not everything needs to show the entire mesh. Like if you're replacing a house, for example, it might be kind of intense to see the entire house. Uh and you might just want to show like a little square on the ground where the house is going to go.

[00:29:04]So, this is our buildable component.

[00:29:05]It's just These are the only options it has, and that's kind of all we need because everything else is configured inside those prefabs.

[00:29:12]So, we have the ghost prefab, the place prefab, uh and then just a few other game designy values.

[00:29:19]While that buildable component is simulating, so while it's in the scene in somebody's inventory, we're going to spawn that ghost prefab, put it where they're looking, uh check for any collisions.

[00:29:29]Then when they click, we're going to spawn that prefab or that the other prefab, lots of prefabs, at that location.

[00:29:38]Scene graph has a lot of useful helper methods for these entities for checking for collisions. So, this is one of my favorites, find overlap hits.

[00:29:46]Um you use it and it will tell you if something is overlapping anything on a prefab, which is cool if you don't necessarily know what a prefab is like that you're using, what that prefab is, and how many mesh components it has, and anything else on it with collision. You can just check the entity itself.

[00:30:05]So, this is what our our buildable item looks like. You're not going to have to watch me build it one component at a time now.

[00:30:10]Um and it's got the item component just like our other items. It's got the icon description, but it's also got our new buildable component.

[00:30:22]So, you saw our fence kind of like expanded when we placed it, but I didn't actually do anything on the item for that because we don't want to be presumptuous, right? We want to keep things modular and not make too many assumptions.

[00:30:34]So, we're going to build tiny little helper components, kind of like um uh little molecules, and you can reuse those wherever you want. Your designers can throw them on stuff to add polish, juice things up. Um and you can kind of give yourself ammo with those, right? Like So, here's one that we use to make that fence expand when it spawned. This is animate on spawn.

[00:31:01]It does what it says. It animates when it spawns.

[00:31:06]Uh and this is replace after duration, which is another one. We don't use that on the fence, but what we do use it on is something I'll show you later.

[00:31:15]So, how do we make our fence destructible? Because usually when you build a fence, you kind of want to reserve the right to get rid of that fence later. You don't want to commit to having a fence there. That'd be a very weird game.

[00:31:27]Um well, the good news is we already figured out how to do that. That's just harvesting, but you get your fence back.

[00:31:33]So, we don't have to change anything about our harvesting system or our building system. We just throw that harvestable component on to our fence prefab.

[00:31:41]Uh and we just combine them.

[00:31:44]So, now here's what that fence prefab looks like.

[00:31:47]It's pretty simple. It's got our mesh. It's got the animate on spawn. It's got the harvestable. And it plays an animation when you harvest it.

[00:31:56]So, it does it kind of shrinks back down. Pretty cool.

[00:32:01]So, here's a sapling.

[00:32:03]Usually, you don't want to just deforest the planet and then never again be able to harvest a tree. So, I made our trees give us little baby trees.

[00:32:12]And it'll grow eventually.

[00:32:16]Any second now.

[00:32:19]There it is.

[00:32:21]So, that was not a lot of work to make that sapling. I only used what we already had.

[00:32:27]It's just a structure like the fence, but we use that replace after duration component to replace it with a tree after a few seconds. You kind of see like, "Wow, you can make games that are just little pieces."

[00:32:37]Uh here's another one of those and this one's my favorite actually.

[00:32:42]So this is a campfire.

[00:32:44]You know, it's a structure replacing it.

[00:32:48]This campfire has a crafting recipe inside of it. That's crazy. That's like the two things we just talked about. Uh so we put the logs down in there and then it's going to spawn a new prefab, our beautiful campfire.

[00:33:01]So here's what that looks like.

[00:33:03]Um [snorts] not a lot really. It's just a little campfire mesh and then our crafting recipe and that points to another prefab that has the different version of the campfire that doesn't have the the recipe in it instead has fire.

[00:33:20]So we just made some cool stuff, but like how do we do it?

[00:33:24]Well, we use the great features of scene graphs such as prefabs, which are great for defining and configuring gameplay.

[00:33:30]Scene events, which are great for communicating without coupling.

[00:33:34]Tags, which are great for finding things or attaching things or or for attaching comparable and searchable data to your entities and prefabs.

[00:33:44]We did modularity.

[00:33:46]We standardized and we reused.

[00:33:49]We abstracted to find our components.

[00:33:51]We made tiny little helpers to build new stuff out of old stuff.

[00:33:55]And we experimented with our components to make new gameplay. We made that campfire all without adding anything new.

[00:34:02]But do not give in to the allure of modularizing everything.

[00:34:07]How do you know when to modularize?

[00:34:10]Sometimes you want to avoid it. It can make a lot of extra work. It can confuse you and make debugging difficult. It can introduce new types of bugs you've never heard of.

[00:34:19]Um and it can rack up a lot of options if you aren't careful.

[00:34:23]Be challenging to on the onboard your new developers too. Like imagine joining a project and you open the prefab and there's like 800 components in in and you're like, well, I I have to study everything in this project now.

[00:34:36]But when is it worth it? When should you do it?

[00:34:39]Well, could you have fun with the new component? I actually didn't want to stop adding new features to the game.

[00:34:44]Like I could have probably kept going for about like 3 hours of content just with those components I already made.

[00:34:50]Um modularize when it's a part of your core gameplay. Like I said, if it's something your game's going to have a lot of and you need to build a lot of content that's similar, think about how to get more out of your prefabs and your components.

[00:35:03]Uh and do you have time for it right now? Cuz realistically, at the end of the day, you just want to ship a game.

[00:35:09]So, don't overthink it.

[00:35:11]Uh and that's kind of the last piece of advice I'm going to leave you with.

[00:35:14]Thank you.

[00:35:16]>> [applause] [applause]