Unity Tutorial: Creating an Inventory System Framework

Creating an inventory system in Unity enhances gameplay by allowing players to manage and interact with items efficiently.

### Building an Inventory System in Unity for Minecraft-Like Gameplay
* 🎮 In this tutorial, we will create the framework for an inventory system in Unity, focusing on a **creative mode** without delving into player inventory or containers yet.
* 🛠 We will implement **drag-and-drop functionality** for items and create a **creative menu** to display all available blocks, allowing for **dynamic item management** in the toolbar.
* 🔧 The first step involves modifying the world script to include a boolean variable `inUI`, which helps determine if the player is **interacting with the UI**, ensuring player movement is **disabled while in the inventory**.
* 📜 We will create a new script called `ItemStack`, which will hold the **item ID and amount**, and another script named `UIItemSlot` to manage the **visual representation of each inventory slot**.
* 📊 The `ItemSlot` class will manage the item stacks, while the `UIItemSlot` class will handle the **UI updates**, linking visual elements to their corresponding **data**.
* 🧩 We will also set up a toolbar script that contains an **array of UI item slots**, enabling the player to **select and use items from their inventory dynamically**.
* 🔄 The tutorial will conclude with a demonstration of how to **manage item quantities within the slots**, preparing for future enhancements such as **drag-and-drop functionality** in the next part.
* ⏳ This video is part one of a two-part series, with the next installment focusing on **implementing drag-and-drop handling** for the inventory system.

[Music] you welcome to another unity tutorial on how to code again my minecraft in unity. Only enough this one is gonna be on making an inventory system. For now, it's just gonna be the framework of the inventory system. So basically for the creative mode, we're not gonna go into the things like containers and an actual player inventory yet because it's a bit pointless when we haven't got items we can drop and pick up and so on. Basically, we're just gonna go over drag and drop a ball items, a creative menu so you can pull up a window that will have all the blocks that we can have, and we'll get this toolbar working properly so it's not just preset at load time. You can actually put items in and out of it. So let's get into it. So the first thing we want to do is we want to go into our world script. I sorry world script, and we need to introduce a bull to distinguish between whether we are in or out of the UI. So nice and

simple just a public ball and we'll call it in UI that's going to equal false. Actually, we're gonna make this a private ball and we'll make it an underscore because what we're gonna do is we're gonna have a public bull which we will put somewhere near the bottom. That's not the way we'll go here, doesn't really matter. Public all and this one will be called in UI and this one's gonna be a get set ball. So for the get, we're just going to return in UI father set. However, first off, we will set in UI and UI equals value and then anything else we want to happen when we set and unset the in your eyeball, we will put in here. So for now, we haven't got anything to put in here but we will have eventually. So if we're going to our player script, we need to change this so that it doesn't do anything if we are in the UI. We don't want to be moving the player around and we don't want to be placing cursor.

blocks or anything like that if we're in the UI. So, that easily enough, we just do world dot in UI. Sorry, if not in UI, then we can execute all our player code. And then what we will also do is we will grab a reference in here. For now, we're just gonna use a simple I key. You can set this to whatever you want. You can set it as a button using the proper Unity input control menu, which you probably should do. This is more about learning how to do the inventory system, not how to properly set your keys in Unity. Maybe that's something I could do another video on, but for now, we're just gonna use the I key. So, if the input get key down key code die, and like I say, the eye is completely our chair. You can use whatever key you want. I know personally I prefer to use tab for inventory, but whatever it is, II prefer. So, if input get key down key code die, and then in here, all we're gonna do is world dot in UI equals not world dot in UI. So basically

whatever the world dying UI is currently set to. This will set it to the opposite. So if we go back in here, just do a quick test right now. I can move around and look around. You're gonna have to trust me on this sit there. It's working because you can't really see a visual cube. If I press I now, I could no longer move around. I'm pressing the keys there. And then if I press I again, we can move around again. Now there is a slight problem with this, with the way we've got our movements out there. If I press I while moving, we keep moving right now. We're technically in the inventory system, but the motion is still set. And the reason for that is because we have our actual movement code up here in fixedupdate. So we need to do the exact same thing up here. We'll just enclose all of this in if not world dot in UI. And then that should, if we run it now, should fix our problems. Yeah, as you can see, we stopped dead. So now to get into the actual meat

I guess you call it of this, so we're gonna create a new script, and we'll call this item stuck. And it's very simple. We'll get rid of all this. Item stack is not gonna be monobehaviour, and all it's gonna hold is a public byte ID, which is the idea of the blocky holes, and a public int amount, and that is for the amount in this item stack. Nice. All that's gonna hold nice and simple. Now we're gonna create another new script, and we're gonna call this one UI item slot, and this is where a lot of the work is gonna get done. So basically, the way we're gonna do the inventory system, forget the concept of containers and backpacks, where you want to call chests, anything like that. Just focus on the individual slots, the slot itself, the single item slots. Are they like these toolbar slots here? That's where all the magic will happen as far as containers go. The Container is just going to be a collection of these slots. The slots are gonna be what actually handles

everything. Let's get our UI item slot on the go first. Close all this. Get rid of all that. Sorry, we need a public bool called is linked, which will be false by default. All of this will become clear as we get on with it. We need a public item slot. Now, if you remember, we created item slot in the toolbar episode. We're going to be changing that class quite drastically, but we'll get to that. So, public item slot, which we'll just call item slot A. Public image. And to get hold of the image, we're going to need to bring in a Unity UI. And the public image, we're just gonna call slot image. And then another public image, which will be called slot icon. And then a public text. I know some of you have mentioned bringing in text mesh. It's really not that important. It makes text look slightly better. As I mentioned before, it's caused problems with this project when I upgraded from, I think, 2018 to 2019 or something. If you want to use text mesh, it's really not that big a

deal to just import it and switch out. You basically be using instead texts like I'm about to use here. You put text I think it's mesh Pro you GUI or something like that. And then you just use it exactly the same way that we're gonna use this text. So that's entirely up to you if you want to use that for the sake of simplicity. I'm not gonna do it in this. So this is gonna be a slot amount. Now we need a public pool which we're gonna call house item. And this is gonna be an entirely a get set. It'll just get actually it's read-only. So get and then we're gonna say if item slot is equal to null return false else. And for now we're just gonna return true. Now that's not the way this is gonna work. We do actually need to return something from the item slot. However we haven't done the item slot code yet. So we can't return that yet. So in fact you know what let's let's do the item slot code now.

because there's not much to the item slot code, or we do need to fix it if we go back to Unity. Was a toolbar to our toolbars is gonna essentially be completely scrapped by the time we finish this video. So, you know, let's just delete the toolbar entirely, and then I had some slot code. We're gonna put it down here now. Public class item slot. Now, this one is not gonna be a mana behavior, and we're gonna have a few things that we need in here. First one is going to be the item stack that we created, and then we also need a reference to a UI item slot, which is what we're creating up here. We'll just call out UI item slot equals null. Both of these will equal null by default, and then we'll have a constructor so we can create one of these of this item slot class. This one will take in UI item slot. I think that is all we need for this. We're just gonna create this one constructor for now. Custom, unlike most videos that I do, unlike all the videos.

that I've done. I haven't worked this video in advance, so I'm kind of winging it here. So, if we need more constructors as we go along, we'll create them as we go along. I'm not gonna try and anticipate everything we're gonna need, but I think this might be all for now. So, we can pass in a UI item slot stack will equal null. The UI item slots will equal UI item slot underscore UI height some slot. And then we will need something else in here, but we will add it in a second because we need to create the actual function. So, the function is going to be called link public void link UI slot UI item. It will take any UI item slot. We're just gonna call it UI slot. And all it will do is set UI item slot to that. And then we're gonna have the opposite of that, which is fun link. And then that one, as you may have already guessed, just sets this to null. We also need a like we do in the UI M slot class. We need a public Bull has

item again read-only, so we only need one get, no no set, and this is gonna be if if stack does not equal no, return true, else return false. So basically, the item stack, as you know, is just holding a particular item ID and item and amount of the item. This is holding a stack, so rather than each slot having a specific amount saying how many of whatever item is holding, is there. That is all stored by the stack, and then the item slot just stores the stack. So up here, we're just gonna put, sorry, up here instead of returning true. So this is if if item slot is null, then we definitely don't have anything in this item. However, if item slot is not long, we're going to return item slot dots has item. Now, I should probably just take a second to explain what's going on here. Item slot, this class here, is the behind-the-scenes holder of the particular slot. So whatever items are in this slot will remain in this slot, whether or not you are looking at your inventory or your tool belt or a container or whatever the

location of this item slot is this will still hold the data. This UI item slot is only the visual representation on the actual screen, so this will only be doing anything if you're actually looking at the container or your tool belt or wherever the location of the slot is. So, the reason we have that separate is because otherwise we would have to store a UI element for every item that is stored in a slot in the game, which if you have played Minecraft, you understand there will be a lot of slots to get a decent-sized storeroom full of double-sized chests, and that's a ridiculous amount of slots. So, we store the information here, and then when we need it, this will be attached to a UI element, and it will load the information out of here into here, hopefully making sense. So, the good news is us, it's not all right a lot more to do with the actual item slot, but the UI is a slot. There is more to do, so we need another function which is going to be public void link item slot.

called item slot, and all that's gonna do is item slot equals underscore item slot, and we're gonna put is linked equals true, and then finally, we're gonna put item slot dot linked UI slot. It's going to link to this, and then in here, we need to do the converse. We need to actually link the UI item slot, so UI item slot dot link this, right? So, the next on the agenda is we need an unlink, so item slot dot okay for some reason. I've called that lock, obviously. Should be linked unlink UI slot, and then UI slots equals no. Now in both of these, we need to open, so that should be just item slot. Now in both of these, we need to update the actual UI elements, which we're going to do with a function we haven't created yet. We'll put the reference to it now, update slot. So, if we link on link, the first thing we want to do is update the UI elements to show what has happened. Either we've taken an item out of it, and there's now nothing in it, ah, we've added items to it, or so.

on and so forth. So when we update it, slot first. We need to make the actual function public void update slots. First thing we want to do is if item slot does not equal null and item slot dot has item, then we want to update all the elements. Else, we're gonna put we haven't written this function either yet, but we're gonna have a clear function to clear the elements. So slot icon dots write equals we haven't actually added. So before we can fill in these details, we do need a reference to world. So world world, and then I'd wait world equals game object find. And we'll look at maybe doing a more optimized way of doing this in the future, but it's not actually gonna be that many of these elements. And the ones that we're gonna have will all be loaded at the start, so it's only gonna slow down the initial loading of the game. And then down here, once we've got our reference to the world, we can set our slot icon dot sprite equals world adopts block types. We want item slot dot okay.

we need a stack at which I've met private, and I should have been public. dot stack ID, and then we want icon nice and simple, and then a slot amount dot text equals item slot stack dot amount dot just string, and then we want a slot icon dot enabled to equal true. The reason for this is because the icon will show up as a solid color if it doesn't have an image in it, so we're going to be disabling it whenever there isn't an item in the slot. Otherwise, we're gonna have like a solid square, and we don't want that. We can't turn the transparency down because then we wouldn't be able to see the icon when there is a knight on there. And then also, we want to do the same for slot amount dot enable the equals true. This we're just gonna turn off the amount, by the way, is gonna be the little number at the bottom of the inventory slot to show you how many items are currently in there. And then the public void clear, it's just gonna do

basically the opposite. So this is gonna equal no. This is gonna equal nothing. And then we're gonna disable both elements. And then just as a little buck, we shouldn't need this because we're going to be the ones writing all the code. But just in case we forget, we're gonna have a private void on destroyed. And then in here, if item slot does not equal null, item slot unlink. I am slot. And basically all eyes is if for some reason we destroy an item slot, the actual physical UI element, and it is currently linked, we will unlink it. So we don't have an item slot floating around thinking it's got UI elements when it hasn't. And we're just gonna add a few more little functions into item slot just to make life a little bit easier. So the first one is going to be public void empty slot, which is fairly straightforward. And in that, we're just gonna set stack equals null. And then if UI item slot does not equal null, UI item slot.update slot. So that just gives us a nice quick

easy way to update that. Now we're gonna need more functions in here, but we will add them as we're actually gonna use them. And I'm sure you're anxious to see something else besides the actual code that I'm writing currently, so let's save this item step. That's pretty much it for I am stuck. We don't really didn't to do anything else with that. We've got all this locked off, so let's go back into Unity. Let's just see which codes, which error codes we've got from deleting. Oh good, none. If you remember though, now that we've deleted that, our toolbar no longer works. And that's because we have deleted all the code associated with it. But don't worry, we are going to fix that. So first thing we'll do, go into our canvas, we'll just remove the reference to toolbar because it's not there anymore. And we're going to delete all of these. I'm gonna keep this one. This one is going to be our prefab. So if we go in here and we dig

out our UI item slot and drag that onto here. And then in here, we already have an icon image, so we can drag the icon into slot icon. This image slot image is this one, the background of the actual slide itself. Thinking about it is completely useless for this tutorial, so a slot amount we don't actually have yet, so let's create that. Yeah, we're going here UI and on text. We will use just the Minecraft text that we've been using for everything. For now, we're just gonna say to $9.99. The color we're gonna set to white, and we're gonna put it. We'll just switch to 2D so I can see what I've done with the actual text. There we go, right. So it doesn't want to be any wider than the actual slot, which I think I said to 50x50. Apparently, I said to 24x24 because our mods really wider than that. 24x24 was set to because we're locking it to. Oh, let's just lock it to the middle, so position that and then just turn this.

highlight off for a second so we can see what's going on, and then we want it to be at the bottom. So, if we go to our text and we just set it to the bottom, and we'll give it a little bit of a margin. Yeah, I think I should just about do it. And let's just zoom in here so we can see what's going on. While we're here, we'll just increase the quality of this. So, if we're going to find our Minecraft font, go to font size, make that 150, and switch this to Unicode. That gives us a much crisper, nicer-looking font. And then we go back to our text thing. That is just a little bit too far off to this, so we're aligned to the right outlet. Yeah, so right there, right? So, set that to 0. By default, both of these are going to be disabled, so let's disable those. And then we can drug that into there, and that's our UI item slot set. So, let's go into our prefabs folder, and let's update that now. I probably

shouldn't have deleted the toolbar script because we are also going to need a toolbar script of sorts. But for now, let's recreate it but using the new system. So now our toolbar script is going to have an array of UI item slots, what you're gonna just call, will just call slots. And this wants to be public. We're gonna going to set these in the inspector to one and item slot. There we go now. So I tell a lie. We do actually have a little bit more to up to. I am stuck. So we're just gonna stick a constructor in there, which is gonna take in a byte for the ID and an empty for the amount. And all that's gonna do is set those values. So let's go back to our tool bar and do a little test. Create a new item stack. We will give it whatever block three is and fourteen of those. So this creates an item stack of whatever I've got a block tree. I really can't remember what his block ID three, but whatever that block is and it's 14 of them. And then now I

we've come to the first. As I mentioned, we'd add more to these as we go along if we needed them. We've come across the first one that we do need one, so we're gonna need another constructor in here: public item slot. And this one will take in a UI item slot again, but it will also take in an item stack. So, we're just gonna copy all of this, but instead of saying mr. null, it's going to set it to stack. And then, if we go back to our toolbar, the guy, our stack here, we're going to create a new item slot. It's going to take in slots, which is gonna be 0 because we've only got one, and it's gonna take in a stack. And that should take care of everything. So, let's run that and see what happens. Grass blocks. Grass blocks are number three. So now you can see it's added our number, and it's added our icon, which is exactly what we wanted. Buddha thought would work first time on this channel of all channels. So, let's

add a few more item slots, and now I've added these slots back. Let's stick them in our toolbar array, and now we'll just go into our toolbar, and we'll swap this. We'll do a little for loop, so we'll go for each UI item slot and pass in slots. So, for each one of these, just gonna do a quick index. Int index equals 1. Remember, we don't want this to be the index of the blocker. Sorry, that wants to be a byte, actually. This is the index of the block ID that we're going to use. We don't want to be 0. 0 is air blocks, and we can't use air blocks as blocks. Blocks we've won an air block. We destroy a block. We don't create an air block. We destroy a physical block. So, we start at 1, and then we're gonna loop through each item slot, and then we're just going to do the same thing, only this is going to equal index minus 1, because that will just want to start at 0. This is just

gonna equal index and then the amount. We're just gonna do random dot range, and we'll go from two completely random numbers to or 6065 integers, exclude the top number. So it will go from 2 to 64. So the top number when you do a random range of integers, the top number is exclusive, which means it will never be 65. It only goes up to 64. I think when you do floats, it's inclusive. So, um, little quirk of the system there. Absolutely. This doesn't want to be slot, sorry. It wants to be s. So now if we run it, we should get the first line blocks that we've got and some random amounts. And instead, we've got entirely bedrock. And the reason for that is because I didn't increment our index. So let's just try that again. There we go. So we've got our mounts, and we have icons, and we have proper item management behind the scenes. So let's just quickly get our toolbar working again. So I'm not gonna go over this selection code again.

because we did this in the toolbar menu. So, if you like me deleted the toolbar script when you really didn't need to because I told you to, so I'm sorry about that. Just go back to the toolbar script and delete the script. Whatever, basically it's just the just a bit for selecting which item slot we're currently looking at in the toolbar. I'm just gonna record that, but I'm gonna show you that because we've done it already. So, see you in a second. Okay, so I've put the code, but for the selection is mainly these two here. We need the rect transform for our highlight rectangle thing, and we need a slot index. And then down here, this is the code we have in our update. As you can see, there's a few errors, so I've left them there so that I can fix them for like you can see what we have to do to change that. So, if you remember item slots previously referred to the just go back in a unit, previously referred to these, the actual physics re, not these, these, the actual position in the

array that's no longer what item slot means. So, if we just change this to slots, that fixes that problem. We also need a reference to our player. Sorry, I forgot about that. And now in here, we need to change this because we're no longer working with the same class behind the scenes. So, instead of slaughtering the X icon, we need... What do we need? Slot icon is what we've called it. So, if we go back to toolbar, that wants to be slot icon. And then the item item slot staff died ID. I understand that's quite a lengthy procedure to get there. So, if we go back into Unity now, we want to rename our highlight thing, and we want to drag it into here. And then also, we will need our player in there, and that should get our scrolling working again. So, I scrolling is working again, and as you can see, it is pulling the... It's pulling the correct block once more. So, we're basically... We were back to where we started at the start of the tutorial. So, let's go ahead and work on some

more if we go back into a UI item slot, and we go down to item slot. We're gonna add a few functions in here. So, we're not going to edit item stack directly. The way we're going to handle the snack is we're gonna have some functions that will do it for us. And then what that allows us to do is ensure that things are handled properly. The first thing we're going to do is a public void. No, let's do public int. And we're just gonna call this take. And it's gonna take in an int. We're just gonna call up um. So, what this is gonna do is we're gonna try and take an amount from this. The reason we're not just gonna edit the integer value and the reason we're not just passing in an amount been taking that amount of ways because we don't know if we're gonna have enough. So, what this does is it allows us to say if M is greater than stack dot amount. So, if we're asking for more than this than

this item slot is currently holding. Then we're going to return stuck dot amount. And then we're going to empty slot because there's nothing in it. Sorry, the way we need to do this is we need to create a new int because we can't enter this a lot before we return the amount. And we can't return the amount and then empty the slot. So we create a new int. We're just gonna call, we'll just call it underscore amount equals stack dot.amount. Then we empty the slot, which gets rid of this stack. So that's why we need to do it this way because we can, once we've entered the start, the slot, we can no longer access this stack 'cause it will be null. And then we return amount. Else if amount is less than stack dot.amount. Stack dot.amount minus equals amount. Return amount. And then the final condition when I look at is we've got if amount is more than reguar amount is less than. The only condition left is if amount is equal to. So if it's equal to.

once again we're gonna empty the slot, and then we're gonna return the amount. So, we're returning the amount that was asked for, and we are emptying the slot because the amount that was asked for is the amount that was in the slot. So, now if we go back to our toolbar, no sorry, we go back to our player, dope world, and we go down to our place block, we're just gonna make a few changes in here. No, just remember where I put the code for this. Here we go, place block. The way we're gonna handle this is we're gonna do away with a selected block index, and we're gonna have a pub little. First off, we're gonna have toolbar reference, and we're gonna use that to access what we need. So, in our toolbar, this is public, and this will, we're gonna have to make this public as well. So, if we go back to our where we want to be using that, but there down here, what we're gonna do is we're gonna say tool bar dot slots toolbar.

doubts slot index for the index dot item slot stuck dot ID. So, once again, this gets us back to sort of where we were before we started messing with the code a second ago. But what we're gonna do this time is we're gonna check first that the slot that we are looking at actually has anything in it: close those in brackets. And we're gonna do another check. We'll just copy this. So, if toolbar dot has item, so we're only gonna be doing this if there is an item in there. So, if it has an item, we do that. And then we want to make sure we increment our values. So, item slots dot take one. Oh yeah, we no longer need this line of code because we are getting our selected block directly from the script. And if we go back in here, we just want to set toolbar in our player reference. And if we run that, should have. So, it is actually working in terms of maintaining the value, but we're not updating our amount for some reason. So, let's just check why.

that is and why that is is because we're only actually updating the slot when we empty it, and obviously, we're not always gonna be emptying it. So, I'm sorry, UI item slot dot updates slot. And now, if you look, you can see the amount is going down and is vanishing when we use them all up. And now that slide's empty, we're not actually putting anything down, so that part's working. Now, this video has run very long, so I mean objection, I'm trying to keep these things palatable. So, this is now gonna be a two-part video. I'm gonna stop this part here, and in the next video, we'll do drag and drop handling. If you're a bit impatient and you can't wait for that video, I did do a video on drag and drop handling that shouldn't be too difficult to apply to this. So, we're gonna stop this one here. I would possibly maybe get the part to up before next week, off to say our time pans out. I won't keep you waiting too.

long for part two. I'm gonna end this one here, and we will carry on in the next video. Bye-bye for now.

Make Minecraft in Unity 3D Tutorial - 13- Inventory Part 1

Game related content!!!!11one

On this channel you will find mostly beginner-to-intermediate level tutorials for working with Unity 3D, typically using C#, with something different (but always video game or game-dev related) occasionally sneaking in. This channel is family friendly in language and themes, however the occasional low-poly bunny rabbit may get squashed in the pursuit of game dev shenanigans.

You have been warned.

b3agz

The tutorial focuses on setting up the framework for an inventory system in a Minecraft-like game using Unity.

It introduces a public boolean variable to distinguish between being in and out of the UI, and modifies the player script to prevent movement while in the UI.

The tutorial also demonstrates how to toggle the UI state using a key press, ensuring smooth transitions between the inventory and gameplay.

Creating an Inventory System: Item Stack and UI Item Slot

The ItemStack class will hold a public byte ID and a public int amount.

The UIItemSlot class will manage individual item slots, with a public bool for linking, public images for the slot and icon, and a public text for the slot amount.

The ItemSlot class will hold a reference to the ItemStack and UIItemSlot, with a constructor to create instances of the ItemSlot class.

The video discusses the process of creating and linking UI item slots for a game.

It explains the role of the item slot class in holding the data for items, while the UI item slot class provides the visual representation on the screen.

The tutorial also covers linking and unlinking the UI item slots with the item slots, and emphasizes the importance of updating the UI elements to reflect any changes in the item slots.

The update slots function checks if the item slot is not null and has an item, then updates the elements; otherwise, it clears them.

A reference to the world is needed to set the slot icon's sprite and stack ID.

The function also enables or disables the slot icon and amount text based on the presence of an item, and includes a clear function and an on destroy function to manage the item slot's UI elements.

The tutorial involves setting up a UI item slot by dragging and positioning an icon image and text.

The text is set to display a price, and the font is adjusted for better clarity.

A toolbar script is created to manage the item slots, and an item stack is generated to populate the slot with an icon and number.

Additional item slots have been added and are now being integrated into the toolbar array.

A for loop is used to assign block IDs and random amounts to each item slot, starting from 1 to avoid air blocks.

The toolbar's item selection code is updated to reflect the new item slot management, restoring the functionality to pull the correct block.

The item slot will have functions to handle the item stack instead of directly editing it.

The "take" function will attempt to remove a specified amount from the stack, returning the "actual amount taken" and emptying the slot if necessary.

The player class will be updated to use the toolbar reference for accessing item slots.

The code is being adjusted to check if the item slot has any items before proceeding.

The item's value is being incremented and the player's toolbar is being updated directly from the script.

The slot's amount is now decreasing and vanishing as items are used, and the video will continue with drag and drop handling in part two.