Unity 튜토리얼: 인벤토리 시스템 프레임워크 제작

### 마인크래프트와 같은 게임플레이를 위해 Unity로 인벤토리 시스템 구축하기
* 🎮 이 튜토리얼에서는 아직 플레이어 인벤토리나 컨테이너에 대해서는 자세히 다루지 않고 **크리에이티브 모드에 초점을 맞춰 Unity에서 인벤토리 시스템의 프레임워크**를 만들겠습니다.
* 🛠 항목에 드래그 앤 드롭 기능을 구현하고 사용 가능한 모든 블록을 표시하는 **창의적인 메뉴**를 만들어 툴바에서 **동적으로 항목을 관리**할 수 있도록 할 것입니다.
* 🔧 첫 번째 단계는 월드 스크립트를 수정하여 플레이어가 UI와 상호작용하는지 여부를 결정하는 데 도움이 되는 부울 변수 **'inUI'**를 포함하도록 하여 인벤토리에 있는 동안 플레이어의 이동이 비활성화되도록 하는 것입니다.
* 📜 아이템 ID와 수량을 저장할 **'ItemStack'이라는 새 스크립트**와 각 인벤토리 슬롯의 시각적 표현을 관리할 **'UIItemSlot'이라는 스크립트**를 생성합니다.
* 📊 **ItemSlot` 클래스는 아이템 스택을 관리**하고 **`UIItemSlot` 클래스는 시각적 요소를 해당 데이터에 연결**하여 UI 업데이트를 처리합니다.
* 또한 플레이어가 인벤토리에서 아이템을 동적으로 선택하고 사용할 수 있도록 **UI 아이템 슬롯 배열이 포함된 툴바 스크립트**를 설정할 예정입니다.
* 🔄 이 튜토리얼은 슬롯 내에서 아이템 수량을 관리하는 방법을 시연하는 것으로 마무리하며, **다음 파트에서 드래그 앤 드롭 기능**과 같은 향후 개선 사항에 대비합니다.
* ⏳ 이 동영상은 2부로 구성된 시리즈 중 1부이며, 다음 편에서는 **인벤토리 시스템의 드래그 앤 드롭 처리를 구현하는 데 중점**을 둡니다.

Unity에서 인벤토리 시스템을 생성하면 플레이어가 아이템을 효율적으로 관리하고 상호작용할 수 있어 게임플레이가 향상됩니다.

[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

Unity에서 인벤토리 시스템 생성하기

이 튜토리얼에서는 Unity를 사용하여 Minecraft와 유사한 게임에서 인벤토리 시스템의 프레임워크를 설정하는 데 중점을 둡니다.

UI 안과 밖을 구분하기 위해 공용 부울 변수를 도입하고, UI에 있는 동안 이동하지 못하도록 플레이어 스크립트를 수정합니다.

이 튜토리얼에서는 키를 눌러 UI 상태를 토글하여 인벤토리와 게임플레이 간의 원활한 전환을 보장하는 방법도 시연합니다.

인벤토리 시스템 생성하기: 아이템 스택 및 UI 아이템 슬롯

ItemStack 클래스는 공개 바이트 ID와 공개 정숫값을 보유합니다.

UIItemSlot 클래스는 링크용 공용 부울, 슬롯 및 아이콘용 공용 이미지, 슬롯 금액용 공용 텍스트로 개별 아이템 슬롯을 관리합니다.

ItemSlot 클래스는 ItemStack 및 UIItemSlot에 대한 참조를 보유하며, 생성자를 통해 ItemSlot 클래스의 인스턴스를 생성합니다.

이 비디오에서는 게임의 UI 아이템 슬롯을 생성하고 연결하는 프로세스에 대해 설명합니다.

아이템 슬롯 클래스가 아이템의 데이터를 보관하는 역할을 하는 반면, UI 아이템 슬롯 클래스는 화면에 시각적으로 표시하는 역할을 한다고 설명합니다.

또한 튜토리얼에서는 UI 아이템 슬롯을 아이템 슬롯과 연결 및 연결 해제하는 방법을 다루고, 아이템 슬롯의 변경 사항을 반영하기 위해 UI 요소를 업데이트하는 것의 중요성을 강조합니다.

Unity에서 아이템 슬롯 업데이트

업데이트 슬롯 함수는 아이템 슬롯이 널이 아니고 아이템이 있는지 확인한 다음 요소를 업데이트하고, 그렇지 않으면 요소를 지웁니다.

슬롯 아이콘의 스프라이트와 스택 ID를 설정하려면 월드에 대한 참조가 필요합니다.

이 함수는 아이템 유무에 따라 슬롯 아이콘과 금액 텍스트를 활성화 또는 비활성화하며, 아이템 슬롯의 UI 요소를 관리하는 클리어 기능과 소멸 기능도 포함하고 있습니다.

Unity에서 UI 아이템 슬롯 생성하기

이 튜토리얼에서는 아이콘 이미지와 텍스트를 드래그하고 배치하여 UI 항목 슬롯을 설정하는 방법을 설명합니다.

텍스트는 가격을 표시하도록 설정되고 글꼴은 더 선명하게 보이도록 조정됩니다.

아이템 슬롯을 관리하기 위한 툴바 스크립트가 생성되고 아이템 스택이 생성되어 슬롯을 아이콘과 숫자로 채웁니다.

도구 모음에서 항목 슬롯 구현하기

아이템 슬롯이 추가되어 현재 툴바 배열에 통합되고 있습니다.

에어 블록을 피하기 위해 1부터 시작하여 각 아이템 슬롯에 블록 ID와 무작위 수량을 할당하는 데 for 루프가 사용됩니다.

툴바의 아이템 선택 코드가 새로운 아이템 슬롯 관리를 반영하도록 업데이트되어 올바른 블록을 가져오는 기능이 복원되었습니다.

아이템 슬롯에는 아이템 스택을 직접 편집하는 대신 아이템 스택을 처리하는 함수가 있습니다.

"가져가기" 함수는 스택에서 지정된 양을 제거하려고 시도하여 "실제 가져온 양"을 반환하고 필요한 경우 슬롯을 비웁니다.

플레이어 클래스는 아이템 슬롯에 액세스할 때 툴바 참조를 사용하도록 업데이트됩니다.

계속 진행하기 전에 아이템 슬롯에 아이템이 있는지 확인하도록 코드를 조정 중입니다.

아이템의 값이 증가되고 플레이어의 툴바가 스크립트에서 직접 업데이트되고 있습니다.

이제 아이템이 사용됨에 따라 슬롯의 양이 줄어들고 사라지고 있으며, 비디오는 2부에서 드래그 앤 드롭 처리를 계속할 것입니다.